En PHP 4, les variables sont généralement déclarées à l'aide de var, tandis qu'en PHP 5, vous pouvez utiliser les fonctionnalités de programmation orientée objet (POO) pour personnaliser la visibilité des données - c'est-à-dire que l'accessibilité est ici très similaire à la portée des variables. , mais offre un meilleur mécanisme de contrôle, il existe trois types de modificateurs de visibilité :
Public (par défaut) - Les variables sont accessibles ou modifiées dans la portée globale.
Protégé : les variables ne sont accessibles ou modifiées qu'au sein de la classe elle-même et des classes directement dérivées (à l'aide de l'instruction extends).
Privé : les variables ne sont accessibles ou modifiables qu'au sein de la classe.
Comme pour les implémentations d'interfaces, la violation de ces règles dans un programme entraînera de graves erreurs et, comme les interfaces, elles existent uniquement pour la commodité des programmeurs. Mais cela ne signifie pas qu'ils peuvent être ignorés. Spécifier la visibilité d'une certaine variable membre de classe peut protéger les données contenues dans l'objet contre toute influence extérieure.
Supposons qu'il existe une classe MySqlDB et qu'une variable $link y soit déclarée privée, ce qui signifie que cette variable n'est accessible que depuis l'intérieur de l'objet en utilisant la variable $this. Cela empêche l'écrasement accidentel par d'autres objets ou fonctions en dehors de la classe. , nous utiliserons l'attribut de visibilité pour nous aider à créer un objet de requête.
Vous pouvez considérer une requête comme une entité distincte qui peut être exécutée et renvoyer des résultats. Certains systèmes de base de données ont également des procédures stockées. Les procédures stockées sont très similaires aux fonctions. Elles stockent les instructions de requête et acceptent les paramètres correspondants lorsqu'elles sont appelées. Cependant, MySQL ne fournissait pas de fonctions similaires avant la version 5.1, et certains autres types de systèmes de gestion de bases de données ne le faisaient pas non plus.
Dans cet article, les deux fonctionnalités ci-dessus seront combinées dans l'objet de requête de l'exemple. L'exemple simulera une procédure stockée de base et enregistrera le pointeur de résultat en interne. Pour l'instant, l'accent est mis sur l'exécution de la requête à partir de l'objet, où vous pouvez appeler la fonction query() de l'objet MySqlDB.
Les fonctions publiques suivantes peuvent être définies dans l'objet de requête :
__construct() - Le constructeur accepte un paramètre qui contient une référence d'instance à l'objet qui implémente l'interface DB.
préparer()--La fonction préparer() initialise la procédure stockée de requête. Il peut contenir un ou plusieurs espaces réservés limités, qui seront passés en paramètres à la fonction exécuter(). Un espace réservé est défini comme deux points liés au nombre de paramètres suivis d'un nombre entier et d'une lettre liée au type de paramètre.
Une requête simple contenant des espaces réservés ressemble à ce qui suit :
SELECT col1,col2 FROM table_name WHERE col1=:1Iexecute
()--La fonction execute() exécutera la requête. S'il est initialisé prématurément en tant que procédure stockée par la fonction prepare(), tous les paramètres transmis seront utilisés comme paramètres d'exécution de la procédure stockée. Sinon, le premier paramètre ne sera utilisé que comme texte de requête. La fonction execute() renverra les résultats après l'exécution de la requête.
compile()--La fonction compile() est similaire à la fonction perform(). En fait, la requête n'est pas exécutée, mais remplace tous les espaces réservés dans la chaîne de requête, accepte les paramètres de la procédure stockée et renvoie la version compilée. de la requête.
Membres protégés
Comme mentionné ci-dessus, le concept de visibilité peut être utilisé pour masquer le fonctionnement interne d'un objet, protégeant ainsi l'intégrité des données requise pour le fonctionnement interne. Comme expliqué précédemment, le pointeur de résultat renvoyé par la requête sera enregistré en tant qu'attribut protégé. Le membre protégé est utilisé ici car un objet de requête de base de données spécifique dérivé de l'objet de requête peut surcharger certaines fonctions principales.
Assez
parlé de la théorie du code
, commençons maintenant à écrire du code. Tout d'abord, créez un modèle comme indiqué dans l'exemple 1 :Exemple 1 : une
classe de modèle DBQuery
de la classe de requête de base de données.
{
/**
*Enregistrez une référence à un objet qui implémente l'interface DB.
*/
protégé $db;
/**
*S'il s'agit d'une procédure stockée, définissez-la sur true.
*/
protégé $stored_procedure = faux
/**
*Enregistrez une requête avec toutes les chaînes supprimées.
*/
requête $ privée ;
/**
* est utilisé pour faire correspondre les guillemets en SQL.
*/
privé statique $QUOTE_MATCH = "/(".*(?db = $db;
}
fonction publique préparer ($ requête)
{
$this->stored_procedure = true ;
}
compilation de fonction publique ($args)
{}
fonction publique exécuter($query)
{}
}
La fonction préparer
est le modèle de l'exemple 1. La première chose que vous devez faire est de construire la fonction préparer(). Pour garantir que les caractères sans guillemets sont accidentellement analysés comme des espaces réservés, la fonction doit supprimer tous les caractères de la requête et. stockez-les temporairement dans un tableau. La chaîne elle-même sera également remplacée par des espaces réservés, qui sont généralement reconnus comme des séquences de chaînes qui ne doivent pas apparaître dans l'instruction SQL. Lors de la compilation de la requête, l'espace réservé de la procédure est d'abord remplacé, puis la chaîne est remise dans la requête. Cela se fait via la fonction preg_replace() et une autre fonction de rappel d'assistance utilisée comme fonction preg_replace().
Exemple 2 : fonction préparer()
/**
* Préparez la requête en tant que procédure stockée.
* @param string $query Texte de requête préparé
* @retour nul
*/
fonction publique préparer ($ requête)
{
$this->stored_procedure = true ;
$this->quote_store = array(); //Effacer les guillemets $this->query = preg_replace(self::$QUOTE_MATCH, '$this->sql_quote_replace("1"?"1":'2')', $ requête);
}
fonction privée sql_quote_replace ($ match)
{
$number = count($this->query_strings);
$this->query_strings[] = $match;
renvoyer "$||$$numéro" ;
}
Notez ici l'utilisation de l'attribut statique QUOTE_MATCH private, ainsi que l'attribut quote_store et la fonction sql_quote_replace(). Par rapport à protected, le définir comme privé ici garantit que toute sous-classe qui remplace la méthode prepare() de la classe de requête utilise son propre mécanisme pour supprimer les guillemets.
Fonction compileL'étape
suivante consiste à construire les fonctions compile() etexecute().
La fonction compile(), comme le montre l'exemple 3, a les fonctions suivantes :
·Le nombre de paramètres acceptés est variable (c'est-à-dire des paramètres variables), qui correspondront aux espaces réservés dans la requête.
· Vérifiez que l'espace réservé est du type de données correct et remplacez-le par la valeur du paramètre.
·Renvoyer la requête sous forme de chaîne mais ne l'exécutez pas.
· Si l'objet de requête n'est pas initialisé en tant que procédure stockée à l'aide de la fonction prepare(), une exception sera levée.
Exemple 3 : fonction compile()
/**
* Renvoie la requête compilée, mais ne l'exécute pas.
* @param mixte $args,... Paramètres de requête
* @return chaîne Requête compilée
*/
compilation de fonction publique ($params)
{
si (! $this->stored_procedure) {
throw new Exception("La procédure stockée n'a pas été initialisée !");
}
/* Paramètres de substitution*/
$params = func_get_args(); // Récupère les paramètres de la fonction $query = preg_replace("/(?query);
return $this->add_strings($query); // Remet la chaîne dans la requête
}
/**
* Réinsérez la chaîne supprimée par la fonction prepare().
*/
fonction privée add_strings($string)
{
$numbers = array_keys($this->query_strings);
$count = count($nombres);
$recherches = tableau();
pour($x = 0; $x < $count; $x++) {
$searches[$x] = "$||${$numbers[$x]}";
}
return str_replace($searches, $this->query_strings, $string);
}
/**
* Chaque fois qu'elle est exécutée, un espace réservé dans la procédure stockée est remplacé.
*/
fonction protégée compile_callback($params, $index, $type)
{
--$index;
/* Lance une exception */
si (! isset($params[$index])) {
throw new Exception("La procédure stockée n'a pas reçu le nombre requis de paramètres !");
}
/* Vous pouvez ajouter d'autres types ici, tels que la date et l'heure. */
commutateur ($type) {
cas 'S' :
return '"' . $this->db->escape_string($params[$index]) . '"';
casser;
cas 'je' :
return (int) $params[$index];
casser;
cas 'N' :
return (float) $params[$index];
défaut:
throw new Exception("Le type de données '$type' spécifié dans la procédure stockée n'est pas reconnu.");
}
}
Deux fonctions supplémentaires sont utilisées dans la fonction compile(). La fonction compile_callback() est utilisée comme fonction de rappel dans l'appel de fonction preg_replace(). Chaque fois qu'un espace réservé est trouvé dans la requête, il est remplacé par la valeur passée à. Lors de la compilation de la valeur d'une fonction, celle-ci sera exécutée.
Fonction exécuter
Enfin, vous devez construire la fonction exécuter(). La fonction exécuter() compile la requête et l'exécute à l'aide de l'objet DB, qui est utilisé ici pour initialiser l'objet DBQuery. Veuillez noter dans l'exemple 4 comment la fonction call_user_func_array() est utilisée pour obtenir la requête compilée. La raison en est que la fonction execute() ne peut pas déterminer le nombre d'arguments qui lui sont transmis avant l'exécution.
Exemple 4 : fonction exécuter()
/**
*
* Exécutez la requête actuelle et remplacez les espaces réservés par les paramètres fournis.
*
* @param mixte $queryParams,... Paramètre de requête
* @return resource Une référence à la ressource représentant la requête exécutée.
*/
fonction publique exécuter ($queryParams = '')
{
//Par exemple : SELECT * FROM table WHERE nom=:1S AND type=:2I AND level=:3N
$args = func_get_args();
if ($this->stored_procedure) {
/* Appeler la fonction compile pour obtenir la requête */
$query = call_user_func_array(array($this, 'compile'), $args);
} autre {
/* Si la procédure stockée n'a pas été initialisée, exécutez-la comme une requête standard. */
$ requête = $ requêteParams ;
}
$this->result = $this->db->query($query);
return $this->result;
}
Rassemblez le tout.
Pour montrer comment utiliser l'objet de requête, un petit exemple est construit ci-dessous, qui utilisera l'objet DBQuery comme procédure stockée et vérifiera si le nom d'utilisateur et le mot de passe corrects sont saisis. Veuillez consulter l'exemple 5 :
exemple. 5 :
nécessite ' mysql_db.php5' ;
require_once 'query2.php5';
$db = nouveau MySqlDb ;
$db->connect('hôte', 'nom d'utilisateur', 'pass');
$db->query('use content_management_system');
$query = new DBQuery($db);
$query->prepare('SELECT fname,sname FROM users WHERE username=:1S AND pword=:2S AND expire_time<:3I ');
if ($result = $query->execute("visualad", "apron", time())) {
si ($db->num_rows($result) == 1) {
echo('Les informations d'identification sont correctes.');
} autre {
echo('Les informations d'identification sont incorrectes et la session a expiré.');
}
} autre {
echo('Une erreur s'est produite lors de l'exécution de la requête :' . $db->error());
}
Dans cet article, vous avez vu comment protéger les données et limiter la visibilité des objets de données en utilisant les modificateurs d'accès private, protected et public lors de la déclaration des variables de classe. En même temps, dans PHP 5, ces concepts peuvent également être utilisés dans. autre classe de données pour protéger ses données internes importantes.