Share
Sebbene sia generalmente consigliabile utilizzare una sorta di framework o CMS, a volte un progetto è abbastanza piccolo in modo tale che tali opzioni possano appesantire lo sviluppo. Tuttavia, anche nei progetti più piccoli, la separazione degli elementi di presentazione dalle query di back-end non dovrebbe essere ignorata. Questo tutorial ti guiderà attraverso la creazione di un motore di query di base basato su classi per PHP e MySQL.
La prima cosa che vorremmo fare è creare alcuni file e directory specifici. Ecco come mi piace impostare i miei progetti. Ovviamente puoi sentirti libero di cambiare i nomi e la struttura a tuo piacimento. Assicurati solo di aver cambiato la richiesta più tardi.
Avremo bisogno di una nuova directory per contenere tutto. In questo caso, l'ho chiamato tut. All'interno di questo, ho inserito i miei file di configurazione in una directory chiamata conf. Quindi, farò un inc directory (abbreviazione di include) e inserire una directory "class" all'interno di quella.
Quindi, dentro / conf, noi faremo config.php. Dentro / Inc / classe noi faremo DAL.php. Infine, nella directory radice, faremo index.php.
DAL sta per "Data Access Layer" o "Data Access Link".
Nell'architettura a più livelli, viene essenzialmente utilizzato per tradurre i risultati delle query del database in oggetti e viceversa.
Abbiamo bisogno di creare un database e popolarlo con alcuni dati. Ai fini di questo tutorial, sarà solo un database di due tabelle con una singola relazione uno-a-molti. Questo è solo per mostrare il nostro motore di query che comprende almeno una relazione.
Quindi, in un database chiamato "tut", facciamo una tabella chiamata fa e un tavolo chiamato Modelli. Il fa tabella avrà i campi "id" e "nome" e il Modelli la tabella avrà i campi "id", "make" e "name".
Ora possiamo aggiungere alcune marche (come Ford, Chevy, ecc.) Come dati nella tabella marche e alcuni modelli di cui questi produttori sono responsabili.
Questo tutorial presuppone che tu abbia una conoscenza pratica di database e SQL, quindi non entrerò nei dettagli sulla relazione / configurazione della chiave esterna.
Di solito, non mi piace lavorare con le costanti grezze in PHP. Definirò tipicamente un sacco di cose quindi creerò alcune funzioni per agganciare quelle costanti. Per questo esempio, manteniamo le cose semplici e usiamo le costanti.
Nel nostro /conf/config.php file, impostiamo le nostre variabili di connessione al database. Mentre ci siamo, gettiamo un include al nostro script DAL.php.
Questa configurazione presuppone che tu stia eseguendo MySQL sulla sua porta predefinita.
Ora, dentro /inc/class/DAL.php, faremo una funzione che useremo per connetterci al nostro database.
La connessione, così come tutte le query future, vivranno all'interno di una classe chiamata DAL. L'impacchettamento di tutto il coinvolgimento del database all'interno di una singola classe ci consente di manipolare le nostre query in un secondo momento senza dover toccare script di livello aziendale o di presentazione. Inoltre, fornisce un certo grado di finto spazio dei nomi.
Nel caso di questa classe, aggiungeremo un costruttore anche se non ha bisogno di fare nulla.
Accentsconagua
Impossibile connettersi al server MySQL "); mysql_select_db (DB_DB, $ conn) o die ("
Impossibile selezionare il database indicato "); return $ conn;?> Si noti che lo scopo del Collega database il metodo è privato. Questo perché non dovremmo aver bisogno di connetterci al database al di fuori del nostro DAL. Invece, avremo metodi di interrogazione pubblica che chiameranno dbconnect dall'interno del DAL. Un po 'di confusione? Nessun problema, continua a leggere.
Per astrarre le nostre domande in modo da poter riutilizzare brevi parti di codice, avremo bisogno di due cose. Innanzitutto, avremo bisogno di una sorta di classe "risultato di una query generica". Secondo, avremo bisogno di un metodo di interrogazione generico all'interno del nostro DAL.
Lo scopo di tutto questo è quello di essere in grado di convertire query SQL in oggetti e minimizzare l'uso del brutto while ($ row = mysql_fetch_array ($ result)) ciclo continuo. Gli oggetti sono molto più facili da lavorare e ci permettono di usare proprietà invece di chiavi di array.
In breve, vogliamo creare una classe che crei i nomi delle proprietà al volo e memorizzi i dati associati a tali proprietà.
Metteremo questa classe dentro la nostra /inc/class/DAL.php script. Dal momento che è una nuova classe, sarà al di fuori della classe DAL.
class DALQueryResult private $ _results = array (); funzione pubblica __construct () funzione pubblica __set ($ var, $ val) $ this -> _ results [$ var] = $ val; public function __get ($ var) if (isset ($ this -> _ results [$ var])) return $ this -> _ results [$ var]; else return null;
Ora, dentro il nostro DAL classe, abbiamo bisogno di fare un metodo di query generico che girerà SELEZIONARE domande in DALQueryResult oggetti.
Fondamentalmente, vogliamo trasformare ogni nome di campo restituito in una proprietà di DALQueryResult oggetto.
query di funzione privata ($ 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; $ results [] = $ result; restituire $ risultati;
Ecco una funzione privata che accetta una query SQL. Si collega al database ed esegue la query. Quindi, controlla se ci sono dei risultati. Se non ci sono risultati, restituisce null su a SELEZIONARE query, false su altre query. Se la query ha avuto esito positivo e la query non è stata a SELEZIONARE query, restituirà true. Se fosse un SELEZIONARE, quindi converte i risultati in una matrice di oggetti DALQueryResult. Questo imita i risultati che si otterrebbero normalmente da una mysql_query.
Ora siamo pronti per scrivere effettivamente una query SQL. Le query DAL dovrebbero essere molto specifiche sia per nome che per scopo. Facciamo uno che trovi tutti i modelli di una data marca.
Questo sarà il nostro primo metodo pubblico.
funzione pubblica get_models_by_make_name ($ name) $ sql = "SELEZIONA models.id come id, model.name come nome, make.name come make FROM models INNER JOIN fa ON models.make = makes.id WHERE makes.name = '$ nome'"; restituire $ this-> query ($ sql);
Qui stiamo solo scrivendo la query e restituendo il risultato sotto forma di oggetti DALQueryResult. Il nostro generico domanda il metodo si occupa delle itterazioni e del processo decisionale.
A questo punto, il nostro DAL.php lo script è finito. Dovrebbe apparire come il seguente.
_risultati [$ var] = $ val; public function __get ($ var) if (isset ($ this -> _ results [$ var])) return $ this -> _ results [$ var]; else return null; classe DAL funzione pubblica __construct () funzione pubblica get_models_by_make_name ($ name) $ sql = "SELECT models.id come id, models.name as name, makes.name as make FROM models INNER JOIN rende ON i modelli .make = makes.id WHERE makes.name = '$ name' "; restituire $ this-> query ($ sql); funzione privata dbconnect () $ conn = mysql_connect (DB_HOST, DB_USER, DB_PASSWORD) o die ("
Impossibile connettersi al server MySQL "); mysql_select_db (DB_DB, $ conn) o die ("
Impossibile selezionare il database indicato "); restituire $ conn; query di funzione privata ($ 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 come $ k => $ v) $ result -> $ k = $ v; $ risultati [] = $ risultato; restituisce $ risultati;?> Ora, andiamo finalmente al nostro /index.php script e visualizzare i nostri risultati utilizzando il DAL. Tutto ciò che dobbiamo fare è includere il nostro /conf/config.php file, creare un'istanza del DAL e fare qualcosa con i dati. Ecco un esempio.
get_models_by_make_name ($ make); eco "Modelli di $ make
"; // controlla se ci sono risultati se ($ risultati) echo"
Siamo spiacenti, non abbiamo informazioni su quel produttore.
";?>Come puoi vedere, ora abbiamo risultati che possiamo chiamare i nomi dei campi come proprietà di un oggetto PHP.
Spesso, sarà utile convertire il generico DALQueryResult in un oggetto più specifico. In questo caso, puoi scrivere oggetti business che accettano un DALQueryResult come parametro costruttore Quindi, lo usi semplicemente per costruire il nuovo oggetto.
Ecco un esempio
_id = $ result-> id; $ this -> _ make = $ result-> make; $ questo -> _ nome = $ risultato-> nome; public function __get ($ var) switch ($ var) case 'id': restituisce $ this -> _ id; rompere; case 'make': restituisce $ this -> _ make; rompere; case 'name': restituisce $ this -> _ name; rompere; default: return null; rompere; public function __toString () return $ this -> _ name; ?>
Quindi, scrivi una query per restituire una matrice di questi oggetti invece di una serie di generici DALQueryResult oggetti.
Ricorda, chiama sempre le tue domande in modo molto specifico.
funzione pubblica get_models_by_make_name_as_CarModel ($ name) // Riutilizzare la query esistente $ results = $ this-> get_models_by_make_name ($ sql); // controlla i risultati se (! $ risultati) restituisce $ risultati; else // array per contenere oggetti CarModel $ object_results = array (); // scorrere e convertire in oggetti CarModel foreach ($ risultati come $ result) object_results [] = nuovo CarModel ($ result); // return array di oggetti CarModel restituisce object_results;
Costruire oggetti specifici può diventare molto utile quando i calcoli sono necessari per estrarre dati significativi dai campi.
Spero vi sia piaciuto tutto il tutorial! In bocca al lupo.
