Share
Bien qu’il soit généralement conseillé d’utiliser une sorte de cadre ou de système de gestion de contenu, un projet est parfois suffisamment petit pour que ces options ralentissent le développement. Cependant, même dans des projets plus petits, la séparation des éléments de présentation de la requête principale ne doit pas être ignorée. Ce tutoriel vous guidera dans la création d'un moteur de requête de base basé sur les classes pour PHP et MySQL.
La première chose que nous allons vouloir faire est de créer des fichiers et des répertoires spécifiques. Voici comment j'aime configurer mes projets. Vous pouvez bien sûr vous sentir libre de changer les noms et la structure à votre guise. Assurez-vous simplement de changer le besoin plus tard.
Nous aurons besoin d'un nouveau répertoire pour tout contenir. Dans ce cas, je l'ai appelé tut. À l'intérieur de cela, je mets mes fichiers de configuration dans un répertoire appelé conf. Ensuite, je vais faire un inc répertoire (raccourci pour inclure) et mettre un répertoire "class" à l'intérieur de celui-ci.
Puis à l'intérieur / conf, nous ferons config.php. À l'intérieur / inc / classe nous ferons DAL.php. Enfin, dans le répertoire racine, nous ferons index.php.
DAL signifie "Data Access Layer" ou "Data Access Link".
Dans une architecture à plusieurs niveaux, il est essentiellement utilisé pour traduire les résultats d'une requête de base de données en objets, et inversement..
Nous devons créer une base de données et la renseigner avec certaines données. Pour les besoins de ce didacticiel, il s'agira simplement d'une base de données à deux tables avec une seule relation un-à-plusieurs. C’est pour que nous puissions afficher notre moteur de recherche couvrant au moins une relation..
Donc, dans une base de données nommée "tut", créons une table appelée fait du et une table appelée des modèles. le fait du table aura les champs "id" et "nom" et le des modèles la table aura les champs "id", "make" et "name".
Nous pouvons maintenant ajouter quelques marques (comme Ford, Chevy, etc.) sous forme de données dans le tableau des marques et de certains modèles pour lesquels ces fabricants sont responsables..
Ce tutoriel suppose que vous maîtrisiez bien les bases de données et le langage SQL. Par conséquent, je ne vais pas entrer dans les détails concernant la configuration de la relation / clé étrangère..
D'habitude, je n'aime pas travailler avec des constantes brutes en PHP. Je vais généralement définir un tas de choses, puis créer quelques fonctions à intégrer dans ces constantes. Pour cet exemple, gardons les choses simples et utilisons les constantes.
Dans notre /conf/config.php fichier, configurons nos variables de connexion à la base de données. Pendant que nous y sommes, ajoutons un inclus à notre script DAL.php.
Cette configuration suppose que vous utilisez MySQL sur son port par défaut..
Maintenant, à l'intérieur /inc/class/DAL.php, nous allons faire une fonction que nous allons utiliser pour nous connecter à notre base de données.
La connexion, ainsi que toutes les requêtes à venir, vivront dans une classe nommée DAL. En englobant toutes les bases de données impliquées dans une même classe, nous pouvons manipuler nos requêtes plus tard sans avoir à toucher aux scripts de couche métier ou de couche de présentation. En outre, il fournit un certain degré d’espace de noms fictif.
Dans le cas de cette classe, nous allons ajouter un constructeur même s'il n'a rien à faire..
Accentsconagua
Impossible de se connecter au serveur MySQL "); mysql_select_db (DB_DB, $ conn) ou die ("
Impossible de sélectionner la base de données indiquée "); return $ conn;?> Notez que la portée de la dbconnect la méthode est privée. En effet, nous ne devrions pas avoir besoin de nous connecter à la base de données depuis l'extérieur de notre DAL. Au lieu de cela, nous aurons des méthodes de requête publiques qui appelleront dbconnect à partir du DAL. Un peu déroutant? Pas de soucis, lisez la suite.
Pour résumer nos requêtes afin de pouvoir réutiliser de courts morceaux de code, nous aurons besoin de deux choses. Premièrement, nous aurons besoin d’une sorte de classe "résultat de requête générique". Deuxièmement, nous aurons besoin d’une méthode d’interrogation générique dans notre DAL.
Le but de tout cela est de pouvoir convertir les requêtes SQL en objets et de minimiser l’utilisation de la while ($ row = mysql_fetch_array ($ result)) boucle. Les objets sont beaucoup plus faciles à utiliser et nous permettent d'utiliser des propriétés au lieu de clés de tableau.
En bref, nous voulons créer une classe qui créera des noms de propriétés à la volée et stockera les données associées à ces propriétés..
Nous allons mettre cette classe dans notre /inc/class/DAL.php scénario. Puisqu'il s'agit d'une nouvelle classe, ce sera en dehors de la classe DAL.
class DALQueryResult private $ _results = array (); fonction publique __construct () fonction publique __set ($ var, $ val) $ ceci -> _ résultats [$ var] = $ val; fonction publique __get ($ var) if (isset ($ this -> _ résultats [$ var])) return $ this -> _ résultats [$ var]; else return null;
Maintenant, à l'intérieur de notre DAL classe, nous devons faire une méthode de requête générique qui va tourner SÉLECTIONNER requêtes dans DALQueryResult objets.
Fondamentalement, nous voulons transformer chaque nom de champ retourné en une propriété du DALQueryResult objet.
requête de fonction privée ($ sql) $ this-> dbconnect (); $ res = mysql_query ($ sql); if ($ res) if (strpos ($ sql, 'SELECT') === false) return true; else if (strpos ($ sql, 'SELECT') === false) return false; else return null; $ results = array (); while ($ row = mysql_fetch_array ($ res)) $ result = new DALQueryResult (); foreach ($ row as $ k => $ v) $ result -> $ k = $ v; $ résultats [] = $ résultat; retourne $ résultats;
Voici une fonction privée qui accepte une requête SQL. Il se connecte à la base de données et exécute la requête. Ensuite, il vérifie s'il y a des résultats. S'il n'y a aucun résultat, il retourne null sur un SÉLECTIONNER query, false sur les autres requêtes. Si la requête aboutissait et que la requête n'était pas un SÉLECTIONNER requête, elle retournera true. Si c'était un SÉLECTIONNER, il convertit ensuite les résultats en un tableau d'objets DALQueryResult. Cela imite les résultats que l’on obtiendrait normalement d’un mysql_query.
Nous sommes maintenant prêts à écrire une requête SQL. Les requêtes DAL doivent être très spécifiques en nom et en finalité. Faisons-en un qui trouve tous les modèles d'une marque donnée.
Ce sera notre première méthode publique.
fonction publique get_models_by_make_name ($ name) $ sql = "SELECT id_modèles, id_models, nom.modèle.nom, marques.nom en tant que, à partir de modèles INNER JOIN fait ON modèles.make = make.id prénom'"; return $ this-> query ($ sql);
Ici, nous écrivons simplement la requête et renvoyons le résultat sous la forme d'objets DALQueryResult. Notre générique question méthode prend en charge les itérations et la prise de décision.
À ce stade, notre DAL.php le script est terminé. Cela devrait ressembler à ceci.
_résultats [$ var] = $ val; fonction publique __get ($ var) if (isset ($ this -> _ résultats [$ var])) return $ this -> _ résultats [$ var]; else return null; class DAL fonction publique __construct () fonction publique get_models_by_make_name ($ name) $ sql = "SELECT modèles.id en tant qu'id, modèles.name en tant que nom, marques.nom en tant que modèles FROM INNER JOIN marques en modèles .make = marques.id WHERE marques.nom = '$ nom' "; return $ this-> query ($ sql); fonction privée dbconnect () $ conn = mysql_connect (DB_HOST, DB_USER, DB_PASSWORD) ou die ("
Impossible de se connecter au serveur MySQL "); mysql_select_db (DB_DB, $ conn) ou die ("
Impossible de sélectionner la base de données indiquée "); return $ conn; requête de fonction privée ($ sql) $ this-> dbconnect (); $ res = mysql_query ($ sql); if ($ res) if (strpos ($ sql, 'SELECT') === false) return true; else if (strpos ($ sql, 'SELECT') === false) return false; else retour null; $ results = array (); while ($ row = mysql_fetch_array ($ res)) $ result = new DALQueryResult (); foreach ($ row as $ k => $ v) $ result -> $ k = $ v; $ résultats [] = $ result; return $ results;?> Maintenant, passons enfin à notre /index.php script et afficher nos résultats en utilisant le DAL. Tout ce que nous devons faire, c'est inclure notre /conf/config.php fichier, instancier le DAL et faire quelque chose avec les données. Voici un exemple.
get_models_by_make_name ($ make); écho "Modèles par $ make
"; // vérifie s'il y a des résultats si ($ results) echo"
Désolé, nous n'avons aucune information concernant ce fabricant..
";?>Comme vous pouvez le constater, nous avons maintenant des résultats qui permettent d'appeler les noms de champs en tant que propriétés d'un objet PHP..
Souvent, il sera utile de convertir le générique DALQueryResult dans un objet plus spécifique. Dans ce cas, vous pouvez écrire des objets métier acceptant une DALQueryResult en tant que paramètre constructeur. Ensuite, vous utilisez simplement cela pour construire le nouvel objet.
Voici un exemple
_id = $ resultat-> id; $ this -> _ make = $ result-> make; $ this -> _ name = $ result-> name; fonction publique __get ($ var) switch ($ var) case 'id': return $ this -> _ id; Pause; case 'make': retourne $ this -> _ make; Pause; case 'nom': retourne $ ceci -> _ nom; Pause; défaut: return null; Pause; public function __toString () return $ this -> _ name; ?>
Ensuite, il suffit d'écrire une requête pour renvoyer un tableau de ces objets au lieu d'un tableau de générique DALQueryResult objets.
N'oubliez pas de toujours nommer vos requêtes très précisément.
fonction publique get_models_by_make_name_as_CarModel ($ name) // réutiliser la requête existante $ results = $ this-> get_models_by_make_name ($ sql); // vérifie les résultats si (! $ results) return $ results; else // tableau contenant les objets CarModel $ object_results = array (); // parcourt et convertit les objets CarModel pour chaque fonction ($ résultats sous forme de $ résultat) object_results [] = new CarModel ($ result); // return tableau d'objets CarModel return object_results;
La création d'objets spécifiques peut devenir très utile lorsque des calculs sont nécessaires pour extraire des données significatives des champs.
J'espère que vous avez tous apprécié le tutoriel! Bonne chance.
