Share
Även om det vanligtvis är lämpligt att använda någon form av ram eller CMS, är det ibland ett projekt tillräckligt liten så att dessa alternativ skulle väga ner utvecklingen. Men även i mindre projekt bör separering av presentationselement från backend-fråga inte ignoreras. Denna handledning går dig genom att skapa en grundläggande klassbaserad sökmotor för PHP och MySQL.
Det första vi ska vilja göra är att göra vissa specifika filer och kataloger. Så här gillar jag att installera mina projekt. Du kan självklart gärna ändra namn och struktur efter eget tycke. Bara se till att du ändrar kravet senare också.
Vi behöver en ny katalog för att hålla allt. I det här fallet ringde jag det tut. Inuti det lägger jag mina konfigurationsfiler i en katalog som heter conf. Då ska jag göra en inc katalog (kort för att inkludera) och sätta en "klass" -katalog inuti den.
Sedan inuti / conf, vi ska göra config.php. Inuti / Inc / klass vi ska göra DAL.php. Slutligen kommer vi att göra i rotkatalogen index.php.
DAL står för "Data Access Layer" eller "Data Access Link".
I flervärdesarkitektur används det huvudsakligen för att översätta databasfrågor i objekt och vice versa.
Vi måste göra en databas och fylla den med vissa data. För syftet med denna handledning kommer det bara att vara en databas med två tabeller med ett enda förhållande. Det här är bara så att vi kan visa vår frågande motor som spänner över minst ett förhållande.
Så, i en databas med namnet "tut", låt oss ringa ett bord gör och ett bord som heter modeller. De gör bordet kommer att ha fält "id" och "namn" och modeller tabellen kommer att ha fält "id", "make" och "name".
Nu kan vi bara lägga till några märken (som Ford, Chevy, etc.) som data i tillverkatabellen och några modeller som dessa tillverkare är ansvariga för.
Denna handledning förutsätter att du har lite kunskap om databaser och SQL, så jag kommer inte att gå in på detaljer om inställningen relativ / utländsk nyckel.
Vanligtvis gillar jag inte att arbeta med råa konstanter i PHP. Jag definierar typiskt en massa saker och gör några funktioner att haka i de konstanterna. För det här exemplet, låt oss bara hålla sakerna enkla och använda konstanterna.
I vår /conf/config.php fil, låt oss konfigurera våra databasförbindelsesvariabler. Medan vi är på det, låt oss kasta ett innehåll till vårt DAL.php-skript.
Den här inställningen förutsätter att du kör MySQL på standardporten.
Nu inuti /inc/class/DAL.php, Vi kommer att göra en funktion som vi kommer att använda för att ansluta till vår databas.
Anslutningen, liksom alla kommande frågor, kommer att leva inom en klass som heter DAL. Omslutning av all databasbeteende i en enda klass gör det möjligt för oss att manipulera våra frågor senare utan att behöva röra skript för företag eller presentationslager. Det ger också en viss mock namnspace.
När det gäller den här klassen lägger vi till en konstruktör trots att den inte behöver göra någonting.
Accentsconagua
Kunde inte ansluta till MySQL-servern "); mysql_select_db (DB_DB, $ conn) eller dö ("
Kunde inte välja den angivna databasen "); returnera $ conn;?> Observera att omfattningen av dbconnect Metoden är privat. Detta beror på att vi inte behöver ansluta till databasen från vår DAL. I stället kommer vi att ha offentliga sökmetoder som kommer att ringa dbconnect inuti DAL. Lite förvirrande? Inga bekymmer, läs vidare.
Att abstrahera våra frågor så att vi kan återanvända korta bitar av kod, vi behöver två saker. För det första behöver vi någon form av "generisk sökresultat" -klass. För det andra behöver vi en generisk frågemetod inom vår DAL.
Syftet med allt detta är att kunna konvertera SQL-frågor till objekt och minimera användningen av den fula medan ($ row = mysql_fetch_array ($ resultat)) slinga. Objekt är mycket enklare att arbeta med och tillåter oss att använda egenskaper i stället för matrisnycklar.
Kort sagt, vi vill göra en klass som kommer att skapa fastighetsnamn på flyg och lagra data i samband med dessa egenskaper.
Vi ska sätta den här klassen inuti vårt /inc/class/DAL.php manus. Eftersom det är en ny klass kommer den att ligga utanför DAL-klassen.
klass DALQueryResult privat $ _results = array (); offentlig funktion __construct () allmän funktion __set ($ var, $ val) $ this -> _ results [$ var] = $ val; allmän funktion __get ($ var) if (isset ($ this -> _ results [$ var])) returnera $ this -> _ results [$ var]; annars return null;
Nu, inne i vår DAL klass måste vi göra en generisk frågemetod som kommer att vända VÄLJ frågor till DALQueryResult objekt.
I grund och botten vill vi vända varje returfältnamn till en egenskap av DALQueryResult objekt.
privat funktionsfråga ($ sql) $ this-> dbconnect (); $ res = mysql_query ($ sql); om ($ res) om (strpos ($ sql, 'SELECT') === false) return true; annat om (strpos ($ sql, 'SELECT') === false) return false; annars return null; $ results = array (); medan ($ row = mysql_fetch_array ($ res)) $ result = new DALQueryResult (); foreach ($ rad som $ k => $ v) $ resultat -> $ k = $ v; $ resultat [] = $ resultat; returnera $ resultat;
Här är en privat funktion som accepterar en SQL-fråga. Den kopplas till databasen och kör sökningen. Då kontrollerar den att se om det finns några resultat. Om det inte finns några resultat returnerar det null på en VÄLJ fråga, fel på andra frågor. Om frågan var framgångsrik och frågan inte var en VÄLJ fråga kommer det att returneras sant. Om det var a VÄLJ, då omvandlas resultaten till en rad DALQueryResult-objekt. Detta härmar efter de resultat som man normalt skulle få från en mysql_query.
Nu är vi redo att faktiskt skriva en SQL-fråga. DAL-frågor bör vara mycket specifika både i namn och syfte. Låt oss göra en som hittar alla modeller av ett givet märke.
Detta kommer att bli vår första offentliga metod.
offentlig funktion get_models_by_make_name ($ name) $ sql = "SELECT models.id som id, models.name som namn, makes.name som make FROM modeller INNER JOIN gör ON models.make = make.id WHERE makes.name = '$ namn'"; returnera $ this-> query ($ sql);
Här skriver vi bara frågan och returnerar resultatet i form av DALQueryResult-objekt. Vårt generiska fråga Metoden tar hand om itterations och beslutsfattande.
Vid denna tidpunkt, vår DAL.php Skriptet är klart. Det ska se ut som följande.
_results [$ var] = $ val; allmän funktion __get ($ var) if (isset ($ this -> _ results [$ var])) returnera $ this -> _ results [$ var]; annars return null; klass DAL offentlig funktion __construct () offentlig funktion get_models_by_make_name ($ name) $ sql = "SELECT models.id som id, models.name som namn, makes.name som make FROM modeller INNER JOIN gör ON-modeller .make = make.id WHERE makes.name = '$ name' "; returnera $ this-> query ($ sql); privat funktion dbconnect () $ conn = mysql_connect (DB_HOST, DB_USER, DB_PASSWORD) eller dö ("
Kunde inte ansluta till MySQL-servern "); mysql_select_db (DB_DB, $ conn) eller dö ("
Kunde inte välja den angivna databasen "); returnera $ conn; privatfunktionsfråga $ this-> dbconnect (); $ res = mysql_query ($ sql); om ($ res) if (strpos SQL = "false") = returnera false array (); medan ($ row = mysql_fetch_array ($ res)) $ result = ny DALQueryResult (); foreach ($ rad som $ k => $ v) $ resultat -> $ k = $ v; resultat [] = $ result; returnera $ resultat;?> Låt oss äntligen gå över till vårt /index.php skript och visa våra resultat med hjälp av DAL. Allt vi behöver göra är att inkludera vår /conf/config.php fil, installa DAL, och gör något med data. Här är ett exempel.
get_models_by_make_name ($ make); eko "Modeller av $ make
"; // kontrollera om det fanns några resultat om ($ resultat) echo"
Tyvärr, vi har ingen information om den tillverkaren.
";?>Som ni kan se har vi nu resultat som vi kan kalla fältnamnen som egenskaper för ett PHP-objekt.
Ofta kommer det att vara användbart att konvertera generiska DALQueryResult in i ett mer specifikt objekt. I det här fallet kan du skriva affärsobjekt som accepterar en DALQueryResult som en konstruktorparameter. Sedan använder du bara det för att bygga det nya objektet.
Här är ett exempel
_id = $ result-> id; $ this -> _ make = $ result-> make; $ this -> _ name = $ result-> name; offentlig funktion __get ($ var) switch ($ var) case 'id': returnera $ this -> _ id; ha sönder; fall "make": returnera $ this -> _ make; ha sönder; fall "namn": returnera $ this -> _ name; ha sönder; standard: return null; ha sönder; allmän funktion __toString () returnera $ this -> _ name; ?>
Skriv sedan en fråga för att returnera en matris av dessa objekt istället för en grupp av generiska DALQueryResult objekt.
Kom ihåg att namnge dina frågor alltid specifikt.
allmän funktion get_models_by_make_name_as_CarModel ($ name) // Återanvänd befintlig sökning $ results = $ this-> get_models_by_make_name ($ sql); // kolla efter resultat om (! $ resultat) return $ results; annat // array för att hålla CarModel-objekt $ object_results = array (); // cykla igenom och konvertera till CarModel-objekt förutseende ($ resultat som $ resultat) object_results [] = new CarModel ($ result); // Returuppsättning med CarModel-objekt returnerar object_results;
Att bygga specifika objekt kan bli mycket användbart när beräkningar behövs för att extrahera meningsfulla data från fält.
Hoppas att alla njöt av handledningen! Lycka till.
