Share
Quando creiamo un'applicazione a singola pagina dovremmo usare un qualche tipo di framework per fare un po 'di lavoro per noi, così possiamo concentrarci sulle funzionalità effettive. AngularJS si adatta perfettamente alla perfezione, perché funzionalità come l'iniezione di dipendenza dinamica e l'associazione bidirezionale dei dati sono semplicemente grandi. A volte richiediamo anche un qualche tipo di server. Se hai scelto PHP, Laravel potrebbe essere la tua migliore opzione, poiché è facile da usare e piuttosto potente.
In questo tutorial creerai un semplice sistema di gestione delle transazioni / dei clienti con la possibilità di aggiungere e rimuovere sia le transazioni che i clienti. Questo probabilmente non è il tipo di cose che fai molto spesso, ma mostra come usare le caratteristiche di entrambi i framework.
Prima di iniziare dovresti impostare un database MySQL che useremo (Laravel ne supporta molti di più, ma questo è ancora il più popolare). Non hai bisogno di alcun server web poiché utilizzeremo quello integrato di PHP (ma tieni presente che questa soluzione è solo per lo sviluppo e non dovrebbe mai essere utilizzata in produzione - manca di molte funzionalità necessarie per il corretto funzionamento dell'app in pubblico). Per questo, avremo bisogno almeno della versione 5.4.0 di PHP.
La prima cosa che dobbiamo fare è installare Laravel. Il processo completo è descritto sul sito Web di Laravel. Dopodiché, dovresti avere la tua directory di progetto creata con tutti i file di Laravel. Passare a tale directory nella riga di comando ed eseguire questo comando lì:
servire php artigianale
Se tutto va bene, si dovrebbe vedere che il server di sviluppo locale è stato avviato locahost: 8000. Apri il tuo browser e naviga lì, dovresti vedere la pagina di benvenuto di Laravel:
Ora possiamo procedere all'applicazione effettiva.
I modelli in Laravel sono come in qualsiasi altro framework MVC. Sta usando l'Eloquent ORM per facilitare il lavoro per voi - probabilmente non avrete mai più bisogno di scrivere una query SQL (a meno che non desideriate qualcosa che Eloquent non supporta). Utilizzando le migrazioni è possibile modificare la struttura del database con la possibilità di eseguire il rollback delle modifiche in caso di problemi. Puoi leggere ulteriori informazioni sulle migrazioni nella documentazione.
Nella nostra app utilizzeremo due modelli:
Accentsconagua
Cliente - terrà i dati del clienteTransazione - terranno le informazioni su una transazioneIniziamo creando delle migrazioni per loro. Se non lo hai già fatto, spegni il server che abbiamo avviato in precedenza (Ctrl + C).
Innanzitutto, invoca questo comando:
php artisan migrate: crea create_customers_table
Questo creerà un file di migrazione con una struttura di base per te. Ora vai a app / database / migrazioni. Dovrebbe esserci un file con il suo nome che inizia con un timestamp e termina con "create_customers_tableLaravel ha creato automaticamente questa struttura di base per te su() il metodo viene chiamato quando viene applicata la migrazione e giù() quando viene tirato indietro.
Prima chiama il Schema :: create () metodo. Richiede due argomenti: il nome dello schema e una funzione di callback:
Schema :: create ('customers', function ($ table) Il callback viene eseguito quando viene creata la tabella. L'oggetto tabella è passato come il $ tavolo variabile e manipoliamo la struttura della tabella utilizzandola. Aggiungiamo un auto-incremento id campo:
$ Tavola-> incrementi ( 'id');
Successivamente ci saranno tre campi stringa per il nome, il cognome e l'indirizzo email del cliente:
$ Tavola-> string ( 'first_name'); $ Tavola-> string ( 'cognome'); $ Tavola-> string ( 'e-mail') -> unico ();
Facciamo il e-mail campo unico chiamando il unico() metodo su di esso.
L'ultimo metodo è per i timestamp:
$ Tavola-> timestamp (); );
Questo creerà due campi data nello schema: created_at e updated_at. Questi verranno utilizzati da Eloquent per memorizzare l'ora in cui l'elemento è stato creato e aggiornato.
Infine, il codice dovrebbe assomigliare a questo:
public function up () Schema :: create ('customers', function ($ table) $ table-> increments ('id'); $ table-> string ('first_name'); $ table-> string (' last_name '); $ table-> string (' email ') -> unique (); $ table-> timestamps ();); Il giù() il metodo è molto più semplice - cancella semplicemente lo schema:
public function down () Schema :: drop ('clienti'); Il codice qui sarà simile a quello dei clienti. Innanzitutto richiamare questo comando:
php artisan migrate: crea create_transactions_table
Ora individuare il file appropriato in app / database / migrazioni e aprilo. Come in precedenza, inizia creando lo schema:
Schema :: create ('transazioni', funzione ($ tabella) Ora aggiungi i campi per l'id, il nome della transazione, il suo costo e l'id del cliente a cui appartiene:
$ Tavola-> incrementi ( 'id'); $ Tavola-> string ( 'name'); $ Tavola-> float ( 'importo'); $ Tavola-> intero ( 'CUSTOMER_ID');
E naturalmente i timestamp:
$ Tavola-> timestamp (); );
Il codice finale dovrebbe assomigliare a questo:
public function up () Schema :: create ('transaction', function ($ table) $ table-> increments ('id'); $ table-> string ('name'); $ table-> float (' importo '); $ table-> intero (' customer_id '); $ table-> timestamp ();); E ora il giù() metodo:
public function down () Schema :: drop ('transazioni'); Ora prima di applicare le migrazioni dovrai configurare la connessione al tuo database. Apri il app / config / database.php file e vai alla riga 55. Ecco i dati di configurazione per MySQL (ce ne sono pochi altri, ad esempio è possibile utilizzare SQLite o Postgres):
'mysql' => array ('driver' => 'mysql', // driver del database, non toccare 'host' => 'localhost', // host del database, di solito localhost a meno che tu non abbia il tuo db su alcuni server 'database' => 'database', // nome del database che si sta utilizzando, deve essere creato in precedenza 'username' => 'root', // nome utente che lo script userà per connettersi, consiglio vivamente contro usando l'utente root per questa 'password' => ", // password per l'utente sopra, è meglio non usare uno vuoto 'charset' => 'utf8', // codifica del db 'collation' => 'utf8_unicode_ci ', // db's collation setting' prefix '=> ", // prefisso delle tabelle del database, utile se si hanno più script che utilizzano lo stesso database), Dopo averlo riempito, sei a posto. Assicurati di aver salvato il file e di invocare questo comando dalla directory principale della tua app (quella con il file artigiano file in esso):
php artisan migrate
E questo è tutto. Se non ci fossero errori, ciò significa che le tabelle sono state create con successo. Puoi connetterti al tuo db usando, per esempio, phpMyAdmin per controllare manualmente se vuoi.
In Laravel, la creazione di un modello dopo aver configurato il database utilizzando le migrazioni è molto veloce. Navigare verso app / modelli ed elimina l'esempio user.php file che è lì. Ora crea due file di nome Customer.php e Transaction.php.
Iniziamo con Customer.php. Ogni modello in Laravel deve estendere il Eloquente classe:
classe cliente estende Eloquent
Ora definiremo una relazione tra il cliente e le sue transazioni. Questo viene fatto definendo un metodo pubblico nel modello con il nome della proprietà che vorremmo avere in esso (in questo caso transazioni):
transazioni di funzioni pubbliche ()
Ora nel corpo della funzione ci sarà solo una riga:
restituire $ this-> hasMany ('Transaction'); Questo dice a Eloquent che dovrebbe fornire tutte le transazioni identificativo del cliente del cliente sotto una proprietà denominata transazioni.
Ora faremo praticamente lo stesso per le transazioni, ma invertiremo la relazione per rendere accessibile il proprietario della transazione tramite cliente proprietà:
class Transaction estende Eloquent public function customer () return $ this-> belongsTo ('Customer'); Questo è fatto usando il $ This-> belongsTo () metodo del modello.
Ora per utilizzare effettivamente i modelli dobbiamo creare controller per loro. Vai al app / controller directory, eliminare il HomeController.php solo - BaseController.php è importante in quanto i nostri controllori lo estenderanno. Ora crea due file: CustomerController.php e TransactionController.php.
Questo controller gestirà tutto ciò che riguarda i clienti - aggiungendo, rimuovendo e mostrando un elenco di essi. Inizia definendo la classe:
class CustomerController estende BaseController
Useremo la funzionalità di Laravel denominata controller RESTful. Rende la creazione di percorsi più semplice perché dobbiamo solo definire l'URI di base e Laravel gestirà tutto per noi. Ciò richiede di avviare i nomi delle funzioni con il verbo HTTP appropriato e quindi continuare con il nome di sottotitoli (utilizzando camelCase). Ad esempio, se avessimo un metodo chiamato getNames e l'URI di base sarebbe /clienti, allora il metodo sarà accessibile a / clienti / nomi.
Il getIndex (), postIndex (), deleteIndex () ecc. i metodi verranno mappati sulla rotta predefinita (in questo caso /clienti).
Ora definiamo il nostro primo percorso: ottenere il cliente dal suo id:
funzione pubblica getIndex ()
Prendiamo l'id dai parametri di query (Laravel fornisce una bella Ingresso classe per affrontarlo, quindi non devi usarlo $ _GET, $ _POST e $ _FILES):
$ id = Input :: get ('id'); E cerca l'utente nel database usando quell'id:
return Customer :: find ($ id);
Ogni metodo del controller deve restituire un valore che è una stringa o ha un __accordare() metodo. In questo caso il Cliente il modello restituito verrà convertito in JSON prima dell'invio.
Ora restituiamo un elenco di tutti gli utenti (questo sarà accessibile sotto / Clienti / all):
funzione pubblica getAll () return Customer :: all ();
Come puoi vedere, possiamo ottenere che tutti i clienti utilizzino il modello tutti() metodo.
Ora la parte più lunga, aggiungendo un nuovo cliente:
funzione pubblica postIndex ()
Per prima cosa controlliamo se sono state fornite tutte le informazioni necessarie. Possiamo farlo usando il Ingresso :: ha () metodo:
if (Input :: has ('first_name', 'last_name', 'email')) Mettiamo tutti i campi di input nel $ input variabile per evitare di chiamare Ingresso :: get () ancora ed ancora. Questo può essere fatto usando Ingresso :: tutti ():
$ input = Input :: all ();
Quindi controlleremo se uno degli input è vuoto. In tal caso, restituiremo un errore di richiesta non valida HTTP 400 con un messaggio più dettagliato:
if ($ input ['first_name'] == "|| $ input ['last_name'] ==" || $ input ['email'] == ") return Response :: make ('Devi riempire tutto dei campi di input ', 400); Dato che volevamo restituire un codice di stato diverso da 200 invece di restituire il messaggio come stringa, abbiamo usato Risposta :: fare (), che prende i dati da inviare come primo parametro e il codice di stato come secondo. Dai un'occhiata ai documenti se vuoi saperne di più sulle risposte.
Ora finalmente creiamo un nuovo Cliente modella e alimentalo con i dati forniti:
$ cliente = nuovo cliente; $ cliente-> first_name = $ input ['first_name']; $ customer-> last_name = $ input ['last_name']; $ cliente-> email = $ input ['email'];
Dopo di ciò possiamo salvare il modello appena creato e rispondere alla richiesta con esso:
$ Customer> save (); restituire $ cliente;
Qui gestiamo il caso se non sono stati forniti tutti gli input:
else return Response :: make ('È necessario compilare tutti i campi di input', 400); Infine, abbiamo anche bisogno della possibilità di rimuovere i clienti. Questo è veramente breve:
funzione pubblica deleteIndex ()
Iniziamo ottenendo l'id del cliente da eliminare:
$ id = Input :: get ('id'); Successivamente, cerchiamo ed eliminiamo il cliente:
$ cliente = Cliente :: trova ($ id); $ Customer> delete ();
Successivamente, rispondiamo alla richiesta con l'ID fornito:
return $ id;
Ora prima che le rotte siano accessibili, dobbiamo agganciarle. Apri il app / routes.php file, elimina tutto tranne il commento e aggiungi questa riga alla fine del file:
Route :: controller ('/ customers', 'CustomerController'); Questo dirà a Laravel di indirizzare tutte le richieste a /clienti a noi CustomerController. Ora puoi usare CURL per giocare con esso. Per prima cosa avviare il server con servire php artigianale e quindi puoi, ad esempio, creare un cliente:
curl -X POST -d "[email protected]" http: // localhost: 8000 / customers
Quindi puoi ottenere l'elenco di tutti i clienti:
curl http: // localhost: 8000 / customers / all
Questo, come il modello è molto simile al CustomerController. Per prima cosa crea la classe:
class TransactionController estende BaseController
Quindi definiamo il metodo per ottenere tutte le transazioni per un utente:
funzione pubblica getIndex () $ id = Input :: get ('id'); return User :: find ($ id) -> transazioni; Come puoi vedere, stiamo usando la relazione definita in precedenza per ottenere le transazioni (ora richiama la query che hai dovuto scrivere per ottenere la stessa cosa usando semplicemente PHP e SQL).
La prossima cosa sarà la creazione di transazioni:
funzione pubblica postIndex ()
Come in precedenza, stiamo verificando se sono fornite tutte le informazioni richieste:
if (Input :: has ('name', 'amount')) In tal caso, assegnarlo a un $ input variabile:
$ input = Input :: all ();
Verifica se uno dei valori forniti è vuoto e in tal caso restituisci un errore:
if ($ input ['name'] == "|| $ input ['amount'] ==") return Response :: make ('Devi riempire tutti i campi di input', 400); Ora crea la transazione e forniscila con tutte le informazioni fornite:
$ transaction = new Transaction; $ transaction-> name = $ input ['name']; $ transaction-> amount = $ input ['amount'];
Ora dobbiamo aggiungerlo al cliente appropriato. Scoprili tramite l'ID fornito e aggiungi il $ transazione alla loro lista di transazioni:
$ id = $ input ['customer_id']; User :: trovare ($ id) -> transactions-> salvare ($ transazione);
Questo è fatto usando il transactions-> save () metodo fornito da Laravel. Ora possiamo rispondere con la transazione creata:
restituire $ transazione;
E gestisci il caso in cui non sono stati forniti tutti o non tutti i dati:
else return Response :: make ('È necessario compilare tutti i campi di input', 400); Successivamente, esiste anche un metodo per eliminare la transazione nello stesso modo in cui abbiamo eliminato il cliente:
public function deleteIndex () $ id = Input :: get ('id'); $ transaction = Transaction :: find ($ id); $ Transaction-> delete (); return $ id; Ora basta aggiungere il percorso e puoi testare il controller usando CURL:
Route :: controller ('/ transactions', 'TransactionController'); Bene, questa è la fine della prima parte - nella seconda parte di questo tutorial, creeremo il front-end usando AngularJS. Sentiti libero di aggiungere ulteriori funzionalità alla tua app (come la modifica dei clienti o l'ordinamento), nel caso in cui non hai trovato le informazioni che stavi cercando, dai un'occhiata alla documentazione di Laravel.
