Använda belysa databas med eloquent i din PHP App utan Laravel

Illuminate är Laravels databasmotor minus Laravel. Den levereras med Eloquent ORM i Laravel. Om du vill bygga dina PHP-appar med ORM och föredrar att inte använda Laravel, är denna handledning för dig.

I denna handledning kommer vi att bygga baksidan för en Q & A-app med PHP, upplysningsdatabasen och Eloquent ORM.

Projektberoende 

1. PHP: 5.5+
2. MYSQL
3. Kompositör

Appfunktioner

Vår app kommer att utföra tio uppgifter:

• Lägg till en användare.
• Lägg till en fråga.
• Lägg till ett svar på en fråga. 
• Upvote ett svar.
• Få en fråga med svar.
• Få alla frågor och användare som frågade dem.
• Få särskilda frågor, svar och uppskattningar.
• Räkna frågor av en viss användare.
• Uppdatera svar av användaren.
• Ta bort en fråga.

Först skapar vi vår projektkatalog och struktur.

I huvudprojektkatalogen skapar vi en app mappen och sedan i den här appmappen skapar vi två mappar:modeller och controllers. I den här bilden heter vår huvudprojektmapp vältalande. Du ska ersätta det med vilket namn du föredrar.

Därefter skapar vi en index.php filen i huvudprojektmappen, på samma nivå som app mapp.

Vi använder git, så vi skapar en .gitignore-fil. Observera att detta steg är valfritt.

Därefter installerar vi de beroenden som behövs för att projektet ska fungera. I huvudprojektmappen skapar vi en komponent.json-fil. Klistra sedan in det här i filen composer.json.

"Name": "illuminate-example / eloquent", "description": "Implementering av databasfrågor med upplyst och talang", "typ": "project", "require": 

För att installera Illuminate-databasen lägger vi till den här på vår composer.json:
"Belysa / databas": "5.1.8",.

Därefter lägger vi till psr-4 autoloading för våra Modeller och controllers:

"Autoload": "psr-4": "Controllers \\": "app / controllers /", "Modeller \\": "app / models /"

Nu ska vår komponent.json-fil se ut så här:

"Namn": "belysa-exempel / vältaligt", "beskrivning": "Implementering av databasfrågor med upplyst och talang", "typ": "projekt", "behov": "belysa / databas": "5.1. 8 "," autoload ": " psr-4 ": " Controllers \\ ":" app / controllers / "," Modeller \\ ":" app / models / " 

Vi kommer nu att köra dessa två kompositörskommandon på samma plats som vår composer.json-fil:

kompositör installera kompositör dump-autoload -o

Detta kommer att generera en leverantörsmapp som vi kan lägga till i gitignore (det här är också ett valfritt steg).

Låt oss lägga till en config-fil för våra databasuppgifter.

I huvudprojektkatalogen skapar vi en fil med namnet config.php och definierar DB-detaljer i Config.php-filen. Observera att värdena ska ersättas med dina egna anslutningsuppgifter.

Därefter skapar vi schemat för vår app.
En sak att notera innan vi skapar schemat för tabellerna i vår databas är att vi kan lägga till tidsstämplar till vårt schema.
Eloquent ORM förväntar sig två tidsstämpelspaltar om vi vill aktivera tidsstämpeloperation på en viss tabell / modell. De är skapad vid och updated_at kolumner. Om vi ​​aktiverar tidsstämplar för en modell uppdaterar Eloquent dessa fält automatiskt när vi skapar eller uppdaterar en post.
Det kallas en tredje kolumn deleted_at. De deleted_at tidstämpel fungerar dock annorlunda. Eloquent har en mjuk raderingskapacitet som använder deleted_at kolumn för att bestämma om en post har raderats. Om du raderar en post med den vältaliga "radera" -funktionen och du aktiverar Soft Delete, uppdateras kolumnen med borttagningstiden. Dessa borttagna objekt kan sedan hämtas när som helst.
I den här appen kommer vi att utnyttja tidstämplarna, så vi använder alla tre i vår Schema-skapelse.
Skapa tabeller med följande kommandon i MySQL:
frågor
CREATE TABLE 'questions' ('id' int (11) unsigned INTE NULL AUTO_INCREMENT, 'question' tinytext, 'user_id' int (11) DEFAULT NULL, 'created_at' tidsstämpel NULL DEFAULT NULL, 'updated_at' tidsstämpel NULL DEFAULT NULL, ' deleted_at 'timestamp NULL DEFAULT NULL, PRIMÄR KEY (' id ')) MOTOR = InnoDB DEFAULT CHARSET = utf8;
svar
CREATE TABLE 'svar' ('id' int (11) unsigned INTE NULL AUTO_INCREMENT, 'answer' tinytext, 'user_id' int (11) DEFAULT NULL, 'question_id' int (11) DEFAULT NULL, 'created_at' tidsstämpel NULL DEFAULT NULL , 'updated_at' tidsstämpel NULL DEFAULT NULL, 'deleted_at' tidsstämpel NULL DEFAULT NULL, PRIMARY KEY ('id')) MOTOR = InnoDB DEFAULT CHARSET = utf8;
upvotes
CREATE TABLE 'upvotes' ('id' int (11) unsigned INTE NULL AUTO_INCREMENT, 'answer_id' int (11) DEFAULT NULL, 'user_id' int (11) DEFAULT NULL, 'created_at' tidsstämpel NULL DEFAULT NULL, 'updated_at' tidstämpel NULL DEFAULT NULL, 'deleted_at' tidsstämpel NULL DEFAULT NULL, PRIMARY KEY ('id')) MOTOR = InnoDB DEFAULT CHARSET = utf8;
användare
CREATE TABLE "users" ("id" int (11) unsigned INTE NULL AUTO_INCREMENT, "användarnamn" varchar (100) DEFAULT NULL, "email" varchar (200) DEFAULT NULL, "lösenord" varchar (200) DEFAULT NULL, 'created_at 'tidsstämpel NULL DEFAULT NULL,' updated_at 'tidsstämpel NULL DEFAULT NULL,' deleted_at 'tidsstämpel NULL DEFAULT NULL, PRIMARY KEY (' id ')) MOTOR = InnoDB DEFAULT CHARSET = utf8;
Vi fortsätter genom att skapa filer för modeller och controllers för våra bord på följande platser:
 
project_folder / app / modeller / question.php
 
project_folder / app / modeller / answer.php
 
project_folder / app / modeller / upvote.php
 
project_folder / app / modeller / user.php
 
project_folder / app / modeller / 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
 
Öppna modeller / database.php med en redaktör.
Först skapar vi kapseln:
addConnection (['drivrutin' => DBDRIVER, 'värd' => DBHOST, 'databas' => DBNAME, 'användarnamn' => DBUSER, 'lösenord' => DBPASS, 'charset' => 'utf8' => 'utf8_unicode_ci', 'prefix' => ",]) // Inställning Eloquent ORM ... $ kapsel-> bootEloquent ();
I filen ovan initierar och ställer vi in ​​kapseln med de konstanter som definieras i config.php, och sedan startar vi vältaliga.
Nästa steg är att skapa ett startskript. Det här är en fil där allt som måste köras innan våra apparbeten körs.
Vi skapar en startfil på platsen project_folder / start.php, och sedan i filen, kräver Composer autoload-filen:
kräver "säljare / autoload.php";
Efter det behöver vi config.php för att få de angivna referenserna: kräver 'config.php';
Sedan initierar vi databasklassen.
Din start.php ska se så här ut:
Inkludera start.php i ditt index.php eftersom det här blir vår huvudfil.
Vår index.php-fil ser nu ut så här:
 
Därefter kan vi börja arbeta med våra styrenheter och modeller. I project_folder/app/modeller / question.php, vi lägger till detta:
Sedan i project_folder/app/controllers/questions.php:
I project_folder/app/controllers/answers.php, vi gör detsamma:
Uppgift 1: Lägg till en användare
I användarmodellen (project_folder/app/models/user.php), vi lägger till följande kod för att definiera vårt namnrymd, förlänga Eloquent-modellen och definiera tabellnamnet (skyddad $ bord) och vilka fält i tabellerna kan fyllas med massuppbyggnad (skyddad $ fyllbar).
I användarens kontroller (project_folder/app/controllers/user.php), definierar vi vårt namnutrymme och klass som vanligt:
Då för att skapa en användare, importerar vi användarnamnens namnrymd i användarens kontroller, Använd Modeller \ Användare;, och lägg sedan till en funktion för att skapa användaren.
$ Username 'e' => $ e-post, 'lösenord' => lösenord $]); returnera $ användaren; 
Vår användarkontroller ser nu ut så här.
$ Username 'e' => $ e-post, 'lösenord' => lösenord $]); returnera $ användaren; ?>
Sedan lägger vi till dessa rader i index.php och kör appen för att skapa en ny användare.
Uppgift 2: Lägg till en fråga
För att lägga till en fråga importerar vi namneskalan för frågemodell i frågestyraren och skriver en create_question fungera:
Använd Modeller \ Fråga;
Sedan:
$ Fråga, 'user_id' => $ user_id]); returnera $ fråga;  
Vi har använt Eloquent Mass Creation-modeller för att infoga denna post, men innan det fungerar måste vi tillåta att dessa fält fylls, eftersom Eloquent-modeller som standard skyddar mot massuppbyggnad.
Så vi går till fråga modell och lägg till skyddad $ fyllbar egendom till klassen.
skyddad $ fillable = ['question', 'user_id'];
För att köra detta, importera frågestyraren i index.php och ringa create_question funktion statiskt:
använd Controllers \ Question;
Skapa sedan en fråga med en fråga och användar-ID som parametrar:
$ question = Questions :: create_question ("Har du någonsin träffat din doppelganger?", 1);
Detta returnerar ett modellobjekt om det lyckas.
Vi kör nu index.php-skriptet med olika poster för att lägga till fler frågor till databasen.
Uppgift 3: Lägg till ett svar på en fråga 
I svarmodellen upprepar vi de steg som tagits för fråga och användarmodeller genom att lägga till koden nedan:
Därefter skriver vi följande linjer i svarkontrollen:
$ answer, 'question_id' => $ question_id, 'user_id' => $ user_id]); returnera $ answer; ?>
Därefter i index.php kan vi skapa ett svar på frågan med id 1 som vi lagt till tidigare med användar-ID 2. Glöm inte att importera svarkontrollen till index.php först.
För att förhindra flera poster, kommentera alla andra samtal i index.php innan du kör en ny.
Uppgift 4: Upprepa ett svar
Det är ungefär samma steg som vi är vana vid.
Så vi kopierar detta till Upvote-modellen på project_folder/app/modeller / upvote.php.
Därefter importerar vi namnet på Upvote Model i svarkontrollerna.
Använd Modeller \ Upvote;
Då skapar vi en upvote_answer fungera.
$ Answer_id, 'user_id' => $ user_id]); returnera $ upvote; 
I index.php kan vi ringa funktionen med ett dummy-användar-ID för att uppväga svaret med id 1.
$ upvote = Svar :: upvote_answer (1,14); 
Uppgift 5: Få en fråga med svar
För uppgifter som detta kan vi använda Eloquent-relationer.
Typer av relationer inkluderar en till en, en till många, många till många osv.
När man använder dessa relationer antar Eloquent en främmande nyckel i formuläret modellnamnDet finns på modellerna. För denna uppgift är förhållandet ett till många förhållande eftersom en enskild fråga kan äga någon mängd svar.
Först definierar vi detta förhållande genom att lägga till den här funktionen i vår frågeformulär.
hasMany ( '\ modeller \ Answer'); 
Sedan i frågestyraren skriver vi en funktion för att få frågor med svar.
får () -> toArray (); returnera $ questions; 
Detta hämtar frågorna med motsvarande svar.
I index.php kommenterar vi alla andra samtal och kör:
$ all = Frågor :: get_questions_with_answers ();
Vi kan var_dump eller print_r de $ alla variabel för att se resultaten.
Uppgift 6: Få alla frågor och användare som frågade dem
Detta är ett till ett förhållande eftersom en fråga har en användare, så lägger vi till det på frågeformuläret.
Tillhör ( '\ modeller \ User'); 
Då skapar vi en funktion i frågestyraren och använder med funktion på frågeformuläret.
får () -> toArray (); returnera $ questions; 
I index.php, kommentera alla andra och köra det här:
$ all_with_users = Frågor :: get_questions_with_users ();
Uppgift 7: Få en fråga med svar och uppsteg
Först definierar vi ett förhållande mellan svar och uppsteg. Ett svar har många uppeningar, så förhållandet är en till många.
Så vi lägger till följande funktion i vår svarmodell:
hasMany ( '\ modeller \ upvote'); 
Sedan i frågestyraren skapar vi funktionen för att få det här:
svar () -> med ( 'upvotes') -> get () -> toArray (); returnera $ questions; 
Som i tidigare steg kommenterar vi alla andra samtal till index.php och kör det här:
$ one_question = Frågor :: get_question_answers_upvotes (1);
Vi kan skriva ut $ one_question variabel för att se resultaten.
Uppgift 8: Räkna alla frågor av en viss användare
Först importerar vi frågeformuläret i användarnas kontroller:
Använd Modeller \ Fråga;
Då skriver vi den här funktionen:
räkna(); returnera $ count; 
I index.php kommenterar vi andra samtal och lägger till den här raden:
$ user_question_count = Användare :: question_count (1);
Detta returnerar ett heltal som är antalet frågor som har lagts till av en användare med id 1. 
Vi kan skriva ut $ user_question_count variabel och kör index.php för att se resultaten.
Uppgift 9: Uppdatera svar av användaren
Begreppet uppdatering med Eloquent ORM är ganska enkelt. Först hittar vi en post, och då muterar vi och sparar.
Nu, i svarkontrollerna lägger vi till den här funktionen:
svara = $ new_answer; $ updated = $ answer-> save (); returnera $ uppdaterad; 
I index.php kan vi kommentera alla andra samtal och uppdatera svar med ID 1 så här:
$ update_answer = Svar :: update_answer (1, "Detta är ett uppdaterat svar");
Detta returnerar ett booleskt värde-true-om uppdateringen är framgångsrik.
Uppgift 10: Ta bort en fråga (Soft Delete)
I den här sista uppgiften kommer vi att implementera Eloquent SoftDelete.
Först berättar vi frågeformuläret att använda SoftDeletes genom att importera SoftDeletes namespace och sedan använda SoftDeletes egenskap i vår klass.
använd Belysa \ Databas \ Eloquent \ SoftDeletes;
Sedan lägger vi till den här raden efter klassdeklarationsraden:
använd SoftDeletes;
Sedan lägger vi till deleted_at till skyddade $ datum egendom för modellen. Dessa är de nödvändiga stegen. 
skyddad $ dates = ['deleted_at'];
Vår modell ser nu ut så här:
hasMany ( '\ modeller \ Answer');  public function user () return $ this-> belongsTo ('\ Modeller \ User'); ?>
Då skapar vi delete_question funktionen i frågestyraren.
radera(); returnera $ deleted;  
Kör i index.php:
$ delete = Frågor :: delete_question (1);
grattis! Du har bara byggt en fullt fungerande bakre ände med belysa och lösa. Och vi behövde inte skriva så mycket kod för att uppnå allt detta.
Koden för denna handledning finns på GitHub. 
Slutsats
Illuminate kommer också med Query Builder som du kan använda för ännu mer komplexa databasfrågor och är definitivt något du vill experimentera med och använda i din app.
Det enda som saknas i den fristående upplysningsdatabasen är databasmigrationer, som är en härlig egenskap hos Laravel och Lumen, Larros mikroframställning. Du bör överväga att använda båda i dina appar för att dra fördel av de användbara funktionerna som de kommer med.
Du kan läsa mer om Eloquent på den officiella Eloquent Documentation Page.
referenser
 
Upplys databasen på GitHub
 
Eloquent ORM-dokument
 



		
			
	   
	




Koda