Share
Hoewel het meestal raadzaam is om een soort van framework of CMS te gebruiken, is een project soms klein genoeg, zodat die opties de ontwikkeling in de weg zouden kunnen staan. Zelfs in kleinere projecten moet het scheiden van presentatie-elementen van backend-bevraging echter niet worden genegeerd. Deze tutorial begeleidt je bij het maken van een standaard op class gebaseerde query-engine voor PHP en MySQL.
Het eerste dat we willen gaan doen is een aantal specifieke bestanden en mappen maken. Dit is hoe ik het leuk vind om mijn projecten in te stellen. U kunt natuurlijk de naam en structuur naar eigen inzicht aanpassen. Zorg er wel voor dat u de vereisten later ook aanpast.
We hebben een nieuwe map nodig om alles vast te houden. In dit geval heb ik het gebeld tut. Daarin zet ik mijn configuratiebestanden in een map met de naam conf. Dan zal ik een maken inc map (afkorting voor opnemen) en zet daar een map "klasse" in.
Dan, binnen / conf, we zullen maken config.php. Binnen / Inc / klasse we zullen maken DAL.php. Eindelijk, in de root-directory, zullen we maken index.php.
DAL staat voor "Data Access Layer" of "Data Access Link".
In multi-tiered-architectuur wordt het in essentie gebruikt om databasequery-resultaten in objecten te vertalen en omgekeerd.
We moeten een database maken en die vullen met wat gegevens. Voor de doeleinden van deze zelfstudie zal het gewoon een database met twee tabellen zijn met een enkele one-to-many-relatie. Dit is precies zodat we onze query-engine kunnen laten zien die ten minste één relatie omvat.
Dus, in een database met de naam "tut", laten we een tabel maken met de naam merken en een tabel genaamd modellen. De merken tabel bevat velden "id" en "naam" en de modellen tabel bevat velden "id", "make" en "naam".
Nu kunnen we gewoon een aantal merken (zoals Ford, Chevy, enz.) Toevoegen als gegevens in de tabel Maken en sommige modellen waarvoor die fabrikanten verantwoordelijk zijn.
Deze tutorial gaat ervan uit dat je wat praktische kennis hebt van databases en SQL, dus ik zal niet ingaan op details over de relatie / instelling van de externe sleutel.
Meestal werk ik niet graag met onbewerkte constanten in PHP. Ik zal meestal een aantal dingen definiëren en vervolgens een aantal functies maken om in die constanten te haken. Laten we voor dit voorbeeld de dingen eenvoudig houden en de constanten gebruiken.
In onze /conf/config.php bestand, laten we onze databaseverbindingsvariabelen instellen. Terwijl we bezig zijn, gooien we een include naar ons DAL.php-script.
Bij deze opstelling wordt ervan uitgegaan dat u MySQL uitvoert op de standaardpoort.
Nu, binnen /inc/class/DAL.php, we zullen een functie maken die we gebruiken om verbinding te maken met onze database.
De verbinding, evenals alle aankomende zoekopdrachten, zullen in een klasse met de naam wonen DAL. Als alle databasebetrokkenheid in een enkele klasse wordt gewikkeld, kunnen we onze query's later manipuleren zonder bedrijfs- of presentatielaag-scripts aan te raken. Ook biedt het een zekere mate van nep-namespacing.
In het geval van deze klasse voegen we een constructor toe, hoewel deze niets hoeft te doen.
Accentsconagua
Kon geen verbinding maken met MySQL-server "); mysql_select_db (DB_DB, $ conn) of sterven ("
Kon de aangegeven database niet selecteren "); return $ conn;?> Merk op dat de reikwijdte van de dbconnect methode is privé. Dit komt omdat we geen verbinding moeten maken met de database van buiten onze DAL. In plaats daarvan zullen we openbare zoekmethoden hebben die de dbconnect vanuit de DAL oproepen. Een beetje verwarrend? Geen zorgen, lees verder.
Om onze vragen te abstraheren zodat we korte stukjes code kunnen hergebruiken, hebben we twee dingen nodig. Ten eerste hebben we een soort "generiek queryresultaat" -klasse nodig. Ten tweede hebben we een generieke zoekmethode nodig binnen onze DAL.
Het doel van dit alles is om SQL-query's in objecten te kunnen converteren en het gebruik van lelijk tot een minimum te beperken while ($ row = mysql_fetch_array ($ result)) lus. Objecten zijn veel gemakkelijker om mee te werken en stellen ons in staat om eigenschappen te gebruiken in plaats van array-toetsen.
Kortom, we willen een klasse maken die eigenschapsnamen direct maakt en gegevens opslaat die aan die eigenschappen zijn gekoppeld.
We zullen deze klasse in ons plaatsen /inc/class/DAL.php script. Omdat het een nieuwe klasse is, zal het buiten de DAL-klasse vallen.
class DALQueryResult private $ _results = array (); publieke functie __construct () openbare functie __set ($ var, $ val) $ this -> _ resultaten [$ var] = $ val; openbare functie __get ($ var) if (isset ($ this -> _ resultaten [$ var])) return $ this -> _ results [$ var]; else return null;
Nu, binnen onze DAL klasse, we moeten een generieke querymethode maken die zal worden omgezet SELECT bevraagt in DALQueryResult voorwerpen.
Kortom, we willen elke geretourneerde veldnaam veranderen in een eigenschap van de DALQueryResult voorwerp.
persoonlijke functiequery ($ sql) $ this-> dbconnect (); $ res = mysql_query ($ sql); if ($ res) if (strs ($ 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 ($ rij als $ k => $ v) $ resultaat -> $ k = $ v; $ resultaten [] = $ resultaat; return $ resultaten;
Hier is een privéfunctie die een SQL-query accepteert. Het maakt verbinding met de database en voert de query uit. Vervolgens wordt gecontroleerd of er resultaten zijn. Als er geen resultaten zijn, wordt null geretourneerd op a SELECT query, false bij andere vragen. Als de query is geslaagd en de query geen was SELECT query, het zal waar teruggeven. Als het een was SELECT, vervolgens converteert het de resultaten naar een array van DALQueryResult-objecten. Dit bootst de resultaten na die normaal gesproken uit een mysql_query zouden komen.
Nu zijn we klaar om daadwerkelijk een SQL-query te schrijven. DAL-zoekopdrachten moeten zeer specifiek zijn, zowel wat betreft naam als doel. Laten we er een maken die alle modellen van een bepaald merk vindt.
Dit wordt onze eerste openbare methode.
publieke functie get_models_by_make_name ($ name) $ sql = "SELECT models.id als id, models.name als naam, make.name als make FROM modellen INNER JOIN maakt op models.make = makes.id WHERE makes.name = '$ naam'"; return $ this-> query ($ sql);
Hier schrijven we alleen de query en retourneren we het resultaat in de vorm van DALQueryResult-objecten. Onze generieke vraag methode zorgt voor de itteraties en besluitvorming.
Op dit punt, onze DAL.php script is voltooid. Het moet er als volgt uitzien.
_resultaten [$ var] = $ val; openbare functie __get ($ var) if (isset ($ this -> _ resultaten [$ var])) return $ this -> _ results [$ var]; else return null; class DAL public function __construct () openbare functie get_models_by_make_name ($ name) $ sql = "SELECT models.id als id, models.name als naam, makes.name als make FROM modellen INNER JOIN maakt op modellen .make = makes.id WHERE makes.name = '$ name' "; return $ this-> query ($ sql); private function dbconnect () $ conn = mysql_connect (DB_HOST, DB_USER, DB_PASSWORD) of die ("
Kon geen verbinding maken met MySQL-server "); mysql_select_db (DB_DB, $ conn) of sterven ("
Kon de aangegeven database niet selecteren "); return $ conn; persoonlijke functiequery ($ 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 ($ rij als $ k => $ v) $ resultaat -> $ k = $ v; $ resultaten [] = $ resultaat; return $ results;?> Laten we nu eindelijk naar onze /index.php script en toon onze resultaten met behulp van de DAL. Het enige dat we moeten doen, is onze /conf/config.php bestand, de DAL instantiëren en iets met de gegevens doen. Hier is een voorbeeld.
get_models_by_make_name ($ make); echo "Modellen van $ make
"; // controleer of er resultaten waren als ($ resultaten) echo"
Sorry, we hebben geen informatie over die fabrikant.
";?>Zoals je ziet, hebben we nu resultaten die we de veldnamen kunnen noemen als eigenschappen van een PHP-object.
Vaak zal het nuttig zijn om de generieke om te zetten DALQueryResult in een meer specifiek object. In dit geval kunt u bedrijfsobjecten schrijven die a accepteren DALQueryResult als constructorparameter. Vervolgens gebruik je dat alleen om het nieuwe object te bouwen.
Hier is een voorbeeld
_id = $ resultaat-> id; $ this -> _ make = $ result-> make; $ this -> _ name = $ result-> name; openbare functie __get ($ var) switch ($ var) case 'id': retourneer $ this -> _ id; breken; case 'make': retourneer $ this -> _ make; breken; naam van het geval: retourneer $ this -> _ naam; breken; standaard: return null; breken; openbare functie __toString () return $ this -> _ naam; ?>
Schrijf vervolgens een query om een array van deze objecten terug te sturen in plaats van een array generieke DALQueryResult voorwerpen.
Vergeet niet dat u uw vragen altijd heel specifiek moet noemen.
openbare functie get_models_by_make_name_as_CarModel ($ name) // Hergebruik bestaande query $ results = $ this-> get_models_by_make_name ($ sql); // check voor resultaten als (! $ resultaten) return $ resultaten; else // array om CarModel-objecten te houden $ object_results = array (); // doorlopen en converteren naar CarModel-objecten voor elk ($ resultaten als resultaat $) objectresultaten [] = nieuw CarModel (resultaat $); // return array van CarModel-objecten retourneert object_resultaten;
Het bouwen van specifieke objecten kan erg handig zijn wanneer berekeningen nodig zijn om zinvolle gegevens uit velden te extraheren.
Ik hoop dat jullie allemaal genoten hebben van de tutorial! Succes.
