Utilizzare Illuminate Database con Eloquent nella tua app PHP senza Laravel

Illuminate è il motore di database di Laravel meno Laravel. Viene fornito in bundle con l'ORM Eloquent in Laravel. Se vuoi costruire le tue app PHP con ORM e preferisci non usare Laravel, questo tutorial è per te.

In questo tutorial, costruiremo il back-end per un'applicazione di domande e risposte con PHP, Illuminate Database e l'Eloquent ORM.

Dipendenze del progetto 

1. PHP: 5.5+
2. MYSQL
3. Compositore

Funzionalità app

La nostra app eseguirà dieci attività:

• Aggiungi un utente.
• Aggiungi una domanda.
• Aggiungi una risposta a una domanda. 
• Risparmi una risposta.
• Ottenere una domanda con risposte.
• Ricevi tutte le domande e gli utenti che hanno chiesto loro.
• Ricevi domande particolari, risposte e voti positivi.
• Conta domande da un utente particolare.
• Aggiorna risposta per utente.
• Elimina una domanda.

In primo luogo, creiamo la nostra directory e struttura del progetto.

Nella directory principale del progetto, creeremo un App cartella, e quindi in questa cartella dell'app, creeremo due cartelle:Modelli e controllori. In questa immagine, la nostra cartella di progetto principale è chiamata eloquente. Dovresti sostituirlo con qualsiasi nome tu preferisca.

Successivamente, creiamo un index.php file nella cartella del progetto principale, allo stesso livello del file App cartella.

Useremo git, quindi creiamo un file .gitignore. Si noti che questo passaggio è facoltativo.

Successivamente, installiamo le dipendenze necessarie affinché questo progetto funzioni. Nella cartella del progetto principale, creeremo un file composer.json. Quindi incollalo nel nostro file compositore.json.

"Nome": "illumina-esempio / eloquente", "descrizione": "Implementazione di query di database con illumina ed eloquente", "tipo": "progetto", "richiede": 

Per installare il database Illuminate, lo aggiungiamo al nostro compositore.json:
"Illumina / database": "5.1.8",.

Successivamente, aggiungiamo il caricamento automatico di psr-4 per i nostri modelli e controller:

"Autoload": "psr-4": "Controller \\": "app / controller /", "Modelli \\": "app / modelli /"

Ora, il nostro file compositore.json dovrebbe assomigliare a questo:

"Nome": "illumina-esempio / eloquente", "descrizione": "Implementazione di query di database con illumina ed eloquente", "tipo": "progetto", "richiede": "illumina / database": "5.1. 8 "," autoload ": " psr-4 ": " Controller \\ ":" app / controller / "," Modelli \\ ":" app / modelli / " 

Ora eseguiremo questi due comandi compositore nella stessa posizione del nostro file composer.json:

compositore installa compositore dump-autoload -o

Questo genererà una cartella del venditore che possiamo aggiungere a gitignore (questo è anche un passaggio facoltativo).

Aggiungiamo un file di configurazione per le credenziali del nostro database.

Nella directory principale del progetto, creiamo un file chiamato config.php e definiamo i dettagli del DB nel file Config.php. Si noti che i valori devono essere sostituiti con i propri dettagli di connessione.

Successivamente, creiamo lo schema per la nostra app.
Una cosa da notare prima di creare lo schema per le tabelle nel nostro database è che possiamo aggiungere timestamp al nostro schema.
L'ORM Eloquent prevede due colonne timestamp se si desidera abilitare l'operazione timestamp su una tabella / modello particolare. Loro sono il created_at e updated_at colonne. Se abilitiamo i timestamp per un modello, Eloquent aggiorna automaticamente questi campi con il momento in cui creiamo o aggiorniamo un record.
C'è una terza colonna chiamata deleted_at. Il deleted_at il timestamp funziona diversamente, però. Eloquent ha una capacità di eliminazione morbida che utilizza il deleted_at colonna per determinare se un record è stato cancellato. Se elimini un record con la funzione eloquente "cancella" e abiliti Soft Delete, la colonna viene aggiornata con il tempo di cancellazione. Questi articoli eliminati possono quindi essere recuperati in qualsiasi momento.
In questa app, trarremo vantaggio dai timestamp, quindi useremo tutti e tre nella creazione dello schema.
Crea tabelle con i seguenti comandi in MySQL:
Domande
CREATE TABLE 'questions' ('id' int (11) non firmato NOT NULL AUTO_INCREMENT, 'question' tinytext, 'user_id' int (11) DEFAULT NULL, 'created_at' timestamp NULL DEFAULT NULL, 'updated_at' timestamp NULL DEFAULT NULL, ' deleted_at 'timestamp NULL DEFAULT NULL, PRIMARY KEY (' id ')) ENGINE = InnoDB DEFAULT CHARSET = utf8;
risposte
CREATE TABLE 'risposte' ('id' int (11) non firmato NOT NULL AUTO_INCREMENT, 'answer' tinytext, 'user_id' int (11) DEFAULT NULL, 'question_id' int (11) DEFAULT NULL, 'created_at' timestamp NULL DEFAULT NULL , 'updated_at' timestamp NULL DEFAULT NULL, 'deleted_at' timestamp NULL DEFAULT NULL, PRIMARY KEY ('id')) ENGINE = InnoDB DEFAULT CHARSET = utf8;
upvotes
CREATE TABLE 'upvotes' ('id' int (11) non firmato NOT NULL AUTO_INCREMENT, 'answer_id' int (11) DEFAULT NULL, 'user_id' int (11) DEFAULT NULL, 'created_at' timestamp NULL DEFAULT NULL, 'updated_at' timestamp NULL DEFAULT NULL, timestamp 'deleted_at' NULL DEFAULT NULL, PRIMARY KEY ('id')) ENGINE = InnoDB DEFAULT CHARSET = utf8;
utenti
CREATE TABLE 'users' ('id' int (11) non firmato NOT NULL AUTO_INCREMENT, 'username' varchar (100) DEFAULT NULL, 'email' varchar (200) DEFAULT NULL, 'password' varchar (200) DEFAULT NULL, 'created_at 'timestamp NULL DEFAULT NULL,' updated_at 'timestamp NULL DEFAULT NULL,' deleted_at 'timestamp NULL DEFAULT NULL, PRIMARY KEY (' id ')) ENGINE = InnoDB DEFAULT CHARSET = utf8;
Procederemo creando file per modelli e controller per le nostre tabelle nelle seguenti posizioni:
 
project_folder / app / modelli / question.php
 
project_folder / app / modelli / answer.php
 
project_folder / app / modelli / upvote.php
 
project_folder / app / modelli / user.php
 
project_folder / app / modelli / database.php
 
project_folder / app / controllers / questions.php
 
project_folder / app / controllers / answers.php
 
project_folder / app / controllers / upvotes.php
 
project_folder / app / controllers / users.php
 
Aperto modelli / database.php con un editore.
Per prima cosa creiamo la Capsule:
addConnection (['driver' => DBDRIVER, 'host' => DBHOST, 'database' => DBNAME, 'username' => DBUSER, 'password' => DBPASS, 'charset' => 'utf8', 'collation' => 'utf8_unicode_ci', 'prefix' => ",]); // Imposta l'Eloquent ORM ... $ capsule-> bootEloquent ();
Nel file sopra, inizializziamo e impostiamo la capsula con le costanti definite in config.php, e quindi iniziamo ad eseguire l'eloquenza.
Il prossimo passo è creare uno script iniziale. Questo sarà un file in cui viene eseguito tutto ciò che deve essere eseguito prima che la nostra app funzioni.
Creiamo un file di avvio nella posizione project_folder / start.php, e quindi nel file, richiede il file di caricamento automatico Composer:
richiedere "fornitore / autoload.php";
Dopo ciò, richiediamo config.php per ottenere le credenziali definite: richiede 'config.php';
Quindi inizializziamo la classe del database.
Il tuo start.php dovrebbe assomigliare a questo:
Includi start.php nel tuo index.php in quanto questo sarà il nostro file principale.
Il nostro file index.php ora appare così:
 
Successivamente, possiamo iniziare a lavorare sui nostri controller e modelli. Nel project_folder/ App /modelli / question.php, aggiungiamo questo:
Quindi in project_folder/app/controllers/questions.php:
Nel project_folder/app/controllers/answers.php, facciamo lo stesso:
Attività 1: aggiungere un utente
Nel modello utente (project_folder/app/models/user.php), aggiungiamo il seguente codice per definire il nostro spazio dei nomi, estendere il modello Eloquent e definire il nome della tabella (tabella $ protetta) e quali campi nelle tabelle possono essere riempiti mediante creazione di massa (protetto $ fillable).
Nel controller degli utenti (project_folder/app/controllers/user.php), definiamo il nostro spazio dei nomi e la classe come al solito:
Quindi per creare un utente, nel controller degli utenti, importiamo lo spazio dei nomi del modello utente, utilizzare Modelli \ Utente;, e quindi aggiungere una funzione per creare l'utente.
$ Username, 'e-mail' => $ email, 'password' => $ password]); restituire $ utente; 
Il nostro controller utente ora sembra così.
$ Username, 'e-mail' => $ email, 'password' => $ password]); restituire $ utente; ?>
Quindi in index.php aggiungiamo queste righe ed eseguiamo l'app per creare un nuovo utente.
Attività 2: aggiungere una domanda
Per aggiungere una domanda, importiamo lo spazio dei nomi del modello Domanda nel controller delle domande e scriviamo a create_question funzione:
utilizzare Modelli \ Domanda;
Poi:
$ Domanda, 'user_id' => $ user_id]); restituire $ domanda;  
Abbiamo usato i modelli di creazione di massa Eloquent per inserire questo record, ma prima che funzioni, dobbiamo permettere che quei campi siano compilabili, perché i modelli Eloquent proteggono dalla creazione di massa di default.
Quindi andiamo al domanda modella e aggiungi il protetto $ fillable proprietà alla classe.
protected $ fillable = ['question', 'user_id'];
Per eseguirlo, importa il controller delle domande in index.php e chiama il create_question funzione staticamente:
utilizzare Controller \ Domanda;
Quindi creare una domanda con una domanda e ID utente come parametri:
$ question = Questions :: create_question ("Hai mai incontrato il tuo doppelganger?", 1);
Questo restituisce un oggetto modello se ha successo.
Ora eseguiremo lo script index.php con diverse voci per aggiungere più domande al database.
Attività 3: aggiungere una risposta a una domanda 
Nel modello di risposta, ripetiamo i passaggi adottati per domande e modelli utente aggiungendo il seguente codice:
Quindi nel controller delle risposte, scriviamo queste righe:
$ answer, 'question_id' => $ question_id, 'user_id' => $ user_id]); restituisci $ answer; ?>
Quindi in index.php, possiamo creare una risposta per la domanda con l'id 1 che abbiamo aggiunto in precedenza, con l'id utente 2. Non dimenticare di importare prima il controller delle risposte su index.php.
Per prevenire più voci, commenta tutte le altre chiamate in index.php prima di eseguirne una nuova.
Attività 4: Rispondere a una risposta
Questo è praticamente lo stesso per cui siamo abituati.
Quindi lo copiamo nel modello di Upvote in project_folder/ App /modelli / upvote.php.
Quindi, nei controller delle risposte, importiamo lo spazio dei nomi di Upvote Model.
utilizzare Modelli \ Verso l'alto;
Quindi creiamo un upvote_answer funzione.
$ Answer_id, 'user_id' => $ user_id]); restituire $ upvote; 
In index.php, possiamo chiamare la funzione con un fittizio User ID per invogliare la risposta con id 1.
$ upvote = Answers :: upvote_answer (1,14); 
Attività 5: ottenere una risposta con le risposte
Per compiti come questo, possiamo usare relazioni eloquenti.
I tipi di relazioni includono uno a uno, uno a molti, molti a molti, ecc.
Quando si usano queste relazioni, Eloquent assume una chiave esterna nel modulo nome del modello_id esiste sui modelli. Per questo compito, la relazione è una relazione uno-a-molti perché una singola domanda può possedere qualsiasi quantità di risposte.
Per prima cosa definiamo questa relazione aggiungendo questa funzione al nostro modello di domanda.
hasMany ( '\ Modelli \ risposta'); 
Quindi nel controllore delle domande, scriviamo una funzione per ottenere domande con le risposte.
get () -> toArray (); restituire $ domande; 
Questo recupera le domande con le risposte corrispondenti.
In index.php, commentiamo tutte le altre chiamate ed eseguiamo:
$ tutti = Domande :: get_questions_with_answers ();
Noi possiamo var_dump o print_r il $ tutto variabile per vedere i risultati.
Compito 6: Ottieni tutte le domande e gli utenti che le hanno richieste
Questa è una relazione uno a uno perché una domanda ha un utente, quindi la aggiungiamo al modello di domanda.
belongsTo ( '\ modelli \ User'); 
Quindi creiamo una funzione nel controllore delle domande e usiamo il con funzione sul modello di domanda.
get () -> toArray (); restituire $ domande; 
In index.php, commenta tutti gli altri ed esegui questo:
$ all_with_users = Domande :: get_questions_with_users ();
Compito 7: Ottieni una domanda con risposte e Upvotes
Innanzitutto, definiamo una relazione tra risposte e upvotes. Una risposta ha molti ascendenti, quindi la relazione è uno a molti.
Quindi aggiungiamo la seguente funzione al nostro modello di risposta:
hasMany ( '\ models \ Upvote'); 
Quindi nel controller delle domande, creiamo la funzione per ottenere questo:
risposte () -> con ( 'upvotes') -> get () -> toArray (); restituire $ domande; 
Come nei passaggi precedenti, commentiamo tutte le altre chiamate a index.php ed eseguiamo questo:
$ one_question = Questions :: get_question_answers_upvotes (1);
Possiamo stampare il $ one_question variabile per vedere i risultati.
Attività 8: conta tutte le domande di un particolare utente
Per prima cosa importiamo il modello di domanda nei controller degli utenti:
utilizzare Modelli \ Domanda;
Quindi scriviamo questa funzione:
contare(); return $ count; 
In index.php, commentiamo altre chiamate e aggiungiamo questa riga:
$ user_question_count = Users :: question_count (1);
Questo restituisce un numero intero che è il numero di domande che sono state aggiunte da un utente con ID 1. 
Possiamo stampare il $ user_question_count variabile e lancia index.php per vedere i risultati.
Attività 9: Aggiornamento della risposta dell'utente
Il concetto di aggiornamento con l'ORM Eloquent è piuttosto semplice. Per prima cosa troviamo un record, quindi cambiamo e salviamo.
Ora, nei controller delle risposte, aggiungiamo questa funzione:
answer = $ new_answer; $ updated = $ answer-> save (); ritorno $ aggiornato; 
In index.php, possiamo commentare tutte le altre chiamate e aggiornare la risposta con id 1 in questo modo:
$ update_answer = Risposte :: update_answer (1, "Questa è una risposta aggiornata");
Restituisce un valore booleano-true-se l'aggiornamento ha esito positivo.
Operazione 10: eliminazione di una domanda (eliminazione graduale)
In questo compito finale, implementeremo Eloquent SoftDelete.
Per prima cosa diciamo al modello di domanda da usare SoftDeletes importando il SoftDeletes spazio dei nomi e quindi utilizzare il SoftDeletes tratto nella nostra classe.
usa Illuminate \ Database \ Eloquent \ SoftDeletes;
Quindi, dopo la riga di dichiarazione della classe, aggiungiamo questa riga:
usa SoftDeletes;
Quindi aggiungiamo deleted_at al date $ protette proprietà per il modello. Questi sono i passaggi richiesti. 
protected $ dates = ['deleted_at'];
Il nostro modello di domanda ora si presenta così:
hasMany ( '\ Modelli \ risposta');  public function user () return $ this-> belongsTo ('\ Models \ User'); ?>
Quindi creiamo il delete_question funzione nel controllore delle domande.
Elimina(); ritorno $ cancellato;  
Esegui in index.php:
$ delete = Questions :: delete_question (1);
Congratulazioni! Hai appena realizzato un back-end completamente funzionale con Illuminate ed Eloquent. E non abbiamo dovuto scrivere tanto codice per ottenere tutto questo.
Il codice per questo tutorial è disponibile su GitHub. 
Conclusione
Illuminate viene fornito con Query Builder che puoi utilizzare per query di database ancora più complesse ed è sicuramente qualcosa che desideri sperimentare e utilizzare nella tua app.
L'unica cosa che manca nel database Illuminate standalone sono le migrazioni di database, che sono una bella caratteristica di Laravel, e Lumen, la microframework di Laravel. Dovresti prendere in considerazione l'utilizzo di entrambi nelle tue app per trarre vantaggio dalle funzioni utili che vengono fornite.
Puoi trovare ulteriori informazioni su Eloquent sulla pagina ufficiale della documentazione eloquente.
Riferimenti
 
Illumina Database su GitHub
 
Documenti ORM eloquenti
 



		
			
	   
	




Codice