Alle Beiträge von Peter Homburg

Laravel CRUD

CRUD steht für: create, read, update und delete.

Laravel implementiert die REST Architektur (Representational State Transfer). Vereinfach gesagt bedeutet dies, dass die Anforderungen an eine Ressource über die Route bzw. den URL abgebildet werden.

Wir wollen unsere BeispielApp ein wenig „aufbohren“, damit wir nicht nur Artikel anzeigen können (read), sondern sie auch erzeugen (create), aktualisieren (update) und löschen können (delete).

Wir löschen nun den BlogController in unserem Projekt und speichern uns vorher den Code aus der index Action weg. Wir erzeugen ihn noch mal, diesmal aber mit dem Schalter: -r

php artisan make:controller BlogController -r

Wenn wir uns nun den Controller anschauen, stellen wir fest, dass die CRUD Methoden bzw. Actions schon generiert wurden.

  • Action: index – liefert eine Liste der Ressource
  • Action: create – liefert eine View bzw. Form zur Erfassung einer neuen Ressource
  • Action: store – speichert die Ressource
  • Action: show – liefert eine bestimmte Ressource
  • Action: edit – liefert eine View bzw. Form zur Bearbeitung einer Ressource
  • Action: update – speichert eine bearbeitete Ressource
  • Action: delete – löscht eine bestimmte Ressource

Wir fügen nun wieder den Code aus der index Action ein.

Wir möchten nun als nächstes, dass wir einen bestimmten Artikel in einer View angezeigt bekommen.

Für die Verarbeitung verantwortlich ist die Action show des Blog Controllers.

Zunächst definieren wir die Route:

Die Route in der routes/web.php:

Route::get('/blogs/{id}', [BlogController::class, 'show']);

Wir tragen temporär diesen Code in die show Action ein:

die('BlogController - showAction'); exit;

Die Route funktioniert also. Die geschweiften Klammern in der Route definieren also Parameter. Wir übergeben in diesem Fall die id des Artikel der Blog Tabelle.

Die Methode show des Blog Controllers:

Wir legen eine neue View an: blog.blade.php und fügen folgenden Code ein:

Der Aufruf im Browser:

Der Aufruf: /blogs/1 ruft also die Action show des Block Controllers auf. So ist es ja auch in der Route definiert.

Die Methode: show empfängt den Parameter id beim Aufruf.

Über das Blog Modell setzen wir eine sql-ähnliche Abfrage ab und erhalten so ein Blog Model, dass wir der View übergeben können.

Wir kümmern uns nun um das Anlegen eines neuene Blog Eintrags. Zunächst die Route in routes/web.php:

Route::get('/create', [BlogController::class, 'create']);

Die create Action des Blog Controllers:

Die Action: create gibt eine View: create zurück. Diese erstellen wir jetzt und fügen ein Formular ein:

Nun setzen wir die Route in der routes/web.php. Da wir Formulardaten an den Server senden wollen, benutzen wir diesmal die Methode: POST anstatt GET

Die Route ist identisch mit der für die index.blade.php. Nur eben diesmal als POST Request

Die zuständige Action ist: store.

Wenn wir nun /create aufrufen und einen neuen Artikel eintragen:

Wenn wir nun absenden, bekommen wir folgende Seite zu sehen:

Laravel erwartet einen Key oder Hash, der auf dem Server verglichen wird. Diese sogenannte Token wurde nämlich beim create Request erzeugt und ins HTML eingebettet.

Damit verhindert oder erschwert Laravel sogenannte CSRF Attacken.

Wir fügen nun folgendes ein in die create.blade.php:

Wir wollen nun erst einmal pürfen, ob das Problem dadurch gelöst wurde und damit der Request im Blog Controller bzw. der Store Action ankommt. Wir fügen diesen Code in die Store Action ein:

die('store action'); exit;

Wenn das Formular abgeschickt wurde, sollte der Browser so aussehen:

Nur der Vollständigkeit halber: Durch den Zusatz: @csrf im Formular wird ein Token erzeugt, dass dann beim POST mitgesendet und von Laravel auf Gleichheit überprüft wird.

Die Ausgabe in den Dev-Tools des Browsers:

Mit anderen Worten: Nur, wenn das Token, welches bei create mitgesendet wurde, identisch ist mit dem, welches beim Speicher POST mitgesendet wird, akzeptiert Laravel den Request.

Schlussendlich wollen wir natürlich den neuen Blog Eintrag auch in der Datenbank speichern. Wir programmieren in der Store Action:

Laravel übergibt ein Request Objekt. Wir lesen den Wert von blog aus, speichern ihn und erzeugen ein neues Blog Objekt. Dann setzen wir den Wert bzw. content und speichern das Model.

Am Schluss programmieren wir noch einen Redirekt auf die Übersichtsseite.

Der neue Blog Eintrag ist nun im Browser zu sehen:

Wir wollen nun einen bestimmten Blog Eintrag auch editieren und die Änderungen speichern. Wie gehabt, wir definieren die dafür zuständige Route in der routes/web.php und programmieren eine Controller Action.

Route::get('/blogs/{id}/edit', [BlogController::class, 'edit']);

Die Edit Action:

Kurze Erläuterung zu dem auskommentierten Code: Blog::find($id) funktioniert zwar, aber anders als bei der Where Abfrage, wird, falls die ID in der Datenbank nicht gefunden wird, keine 404 Page generiert. Es würde null zurückgegeben und so an die View übergeben. Der Zugriff in der View würde dann erst eine Exception auslösen.

Fehlt noch die View: edit.blade.php

Das war’s mit unserem Laravel-Tutorial. Wenn Sie noch Fragen haben oder Hilfe benötigen, können Sie sich sehr gerne mit uns in Verbindung setzen.

Hier geht es zum vorherigen Teil: Laravel Layout

Besuchen Sie auch gerne unsere Webseite: admin-code.de

Laravel Layout

Bisher haben wir nur eine View blogs.blade.php

Wahrscheinlich wird es aber mehrere Webseiten geben, die zur Website gehören. Jedes Template beinhaltet den kompletten HTML Code.

Oft ist nun aber so, dass beispielsweise der Header und/oder Footer immer derselbe ist. Trotzdem wird in jedem Template der Code wiederholt. Dies ist nicht nur redundanter Code, sondern es ist auch mühselig, alle Templates anzupassen, wenn sich mal etwas ändert, z.B. am Header oder Footer.

Erfreulicherweise bieter uns Laravel hier eine Lösung an, Layout Files

Die Idee ist, sich wiederholende Teile der HTML Seite in das Layout File zu schreiben. Die einzelnen Seiten fügen dann nur noch ihren speziellen Content ein.

Damit das Sinn macht, fügen wir als erstes ein zweites Template hinzu: about.blade.php

Wir könnten nun einen AboutController hinzufügen. Wir entscheiden uns aber dafür, einen InfoController anzulegen, der über verschiedene Actions solche Seiten wie about, impressum, contact usw. abwickelt.

Wir setzen die Route:

Die Route /about definiert also den InfoController und die Action showAbout.

Der Aufruf im Browser sollte zu diesem Ergebnis führen:

Wir möchten nun eine horizontale Navigation auf all unseren Seiten haben. Anstatt nun den Code auf jeder Seite einzufügen, legen wir ein Layout File an:

Wie man sieht, stellt das Layout-Template das Html Grundgerüst zur Verfügung und die Navigation.

Genau das brauchen wir auf jeder Seite. Den speziellen Seiten-Content stellen dann die einzelnen Seiten zur Verfügung.

Wir beginnen mit der index.blade.php. Wir löschen den Inhalt und fügen diesen Code ein:

Mittels @extends(‚layout‘) erbt unser Template den Code vom layout.blade.php Template.

Man kann nun verschiedene sogenannte sections definieren, deren Inhalt dann layout.blade.php ergänzt. In diesem Fall eben das H1 Tag.

Wenn wir nun die Startseite aufrufen, sehen wir erst einmal nur das layout Grundgerüst. Wir müssen im Layout Template noch die Sections rendern:

Wenn irgendeine Seite von Layout erbt, bedeutet dies auch, dass Layout Zugriff auf die Sections hat.

Im Layout File wird dann an beliebiger Stelle, also dort, wo der Inhalt der Section erscheinen soll, mittels @yield(‚NameDerSection‘) ebendieser Inhalt der jeweiligen Section hineingerendert.

Dementsprechend sieht dann die Ausgabe im Browser aus:

Nun bearbeiten wir die about.blade.php

Die Ausgabe dann entsprechend. Durch den Mechanismus der Vererbung sparen wir also Code und gestalten den Aufbau unserer Seiten modular.

Wir müssen noch die blog.blade.php bearbeiten. Sie sollte danach so aussehen:

Wir fügen nun in die layout.blade.php noch den Artikel Link ein, der auf die Route/blogs zeigt und passen das CSS ein wenig an, damit die Formatierung nur zieht bei unserer Navigation:

Der Aufruf im Browser:

Hier geht es zum vorherigen Teil: Laravel Datenbank

Hier geht es zum letzten Teil: Laravel CRUD

Besuchen Sie auch gerne unsere Webseite: admin-code.de

Laravel Datenbank

Wir verwenden in unserem Tutorial eine MySQL Datenbank.

Wir loggen uns als root auf dem Datenbank-Server ein.

mysql -u root -p

root hat in unserem Fall kein Passwort, also die Passwortabfrage einfach mit Enter quittieren.

Im Mysql Prompt folgendes eingeben.

CREATE USER 'laravel'@'localhost' IDENTIFIED BY 'admin';

Wir geben dem User laravel Berechtigungen für die Databank laravel. 

GRANT ALL PRIVILEGES ON laravel.* TO 'laravel'@'localhost';

Dann noch.

FLUSH PRIVILEGES;

Wir loggen uns als root aus.

quit;

 Wir melden uns als User laravel an.

mysql -u laravel -p

Wir sind nun als der User laravel eingeloggt und erzeugen die Datenbank laravel.

create database laravel;

Wir loggen uns wieder aus.  

quit;

Wir haben damit die Vorbereitungen abgeschlossen.

Im Document Root liegt eine verstecktes File .env

Wir konfigurieren den MySQL Zugang.

Die Konfigurationsdatei .env wird übrigens vom File config/database verarbeitet.

Mittels des CLI Tools artisan erzeugen wir ein Model (Wir befinden uns im Document Root). 

php artisan make:model Blog

Das Model Blog wurde nun im Verzeichnis app/Models erzeugt. Generierte Einträge entfernen wir erst einmal.

Wiederum mittels artisan erzeugen wir eine sogenannte Migration. Dies generiert uns eine Art SQL Script.

php artisan make:migration create_blog_table

Wie man sieht, wird unter database/migrations ein entsprechendes Script bzw. Klasse angelegt.

In der up() Methode werden schon 2 Felder definiert: id und timestamp. Wird das Script ausgeführt, wird die Tabelle Blog erzeugt.

Außerdem werden die Felder in der up() Methode in der Datenbank angelegt.

Die übrigen Scripte legt Laravel übrigens bei der Generierung des Projekts an. Wen sie nicht stören, lässt sie einfach drin. Somit wäre beispielsweise schon mal die Programmierung eines Logins bzw. einer User-Verwaltung schneller möglich.

Wir ersetzen noch Felder in der Datenbank bzw. modifizieren sie. Wir brauchen erst einmal nur ein Feld: content

Die Ausführung des Scripts bzw. die Migration wird angestoßen. 

php artisan migrate

Falls das folgenden Fehler erzeugt:

Eine Codezeile unter Providers/AppServiceProvider in der Methode boot() löst das Problem

Die Datenbank sollte nun so aussehen:

Wir wollen nun mitels des Tools: artisan tinker (im Terminal – im Document Root) 2 Datensätze in der Datenbank anlegen.

php artisan tinker

$blog = new App\Models\Blog

$blog->content = 'Mein erster Blogeintrag'

$blog->save()

Das dürfte zu folgendem Fehler führen:

Wir müssen dem Model noch mitteilen, zu welcher Tabelle es gehört:

Mit ctrl + c oder durch Eingabe des Befehls exit loggt man sich aus tinker aus.

Danach noch mal ausführen: in tinker einloggen, Model erzeugen, Eigenschaft setzen und speichern.

Unser Eintrag taucht dann auch erwartungsgemäß in der Datenbank auf:

Wir legen noch einen zweiten Datensatz an mit dem Content: Mein zweiter Blogeintrag.

Nun, wir möchten, dass die Route bzw. Adresse: http:/meineDomain/blogs uns die Einträge auf einer Webseite ausgibt.

Ein Controller soll für diese Route zuständig sein. 

php artisan make:controller BlogController

Wir fügen eine Action bzw. Methode index() ein.

Wir setzen die Route:

Wie gesagt, das Model ist sowohl für die Business Logik zuständig, als auch für den Datenbankzugriff

Dementsprechend besorgen wir uns im Controller die gewünschten Daten über das Blog Model:

Nicht vergessen: use App\Models\Blog; einfügen, sonst weiß Laravel nichts anzufangen.

Blog::all();

Wir brauchen noch die View. Diese legen wir an unter bzw. als resources/blogs.blade.php

Nun übergeben wir im Controller der View die Variable $blogs, also den Result aus der Datenbank:

Da unsere Abfrage alle Datensätze besorgt, ist die Rückgabe eine Collection. Wir müssen also in der View diese durchschleifen.

Die Template Engine Blade stellt uns dafür die Syntax bereit. Variablen werden immer in doppelte geschweifte Klammern gesetzt. Wir brauchen zusätzlich aber auch noch die Schleifen-Syntax:

Das Template bzw. Blade kann also durch diese Syntax auf die vorher im Controller übergebene Variable zugreifen und sie ausgeben bzw. verarbeiten.

Das Ergbnis im Browser sollte nun so aussehen:

Hier geht es weiter: Laravel Layout

Hier geht es zum vorherigen Teil: Laravel Beispielapp

Besuchen Sie auch gerne unsere Webseite: admin-code.de

Laravel Beispielapp

Wir programmieren eine Blog App.

Wir erzeugen mittels des CLI-Tools Artisan einen IndexController.

php artisan make:controller IndexController

Wir programmieren eine Methode, eine sogenannte Action, in den Controller

Nun passen wir die Definition der Route an.

Wir geben also als 2. Parameter den Controller und die Action an.

Die Syntax ::class löst übrigens den voll qualifizierten Namen auf – inkl. Namespace

Nun sollte das Ergebnis im Browser so aussehen.

Soweit klappt das also schon mal. Nun die View.

Laravel verwendet standardmäßig die Template-Engine Blade.
Der Konvention entsprechend erzeugen wir also unter resources/views ein File index.blade.php

Wir ändern die Index Action im Controller und lassen die View zurückgeben.

Nun sollte das Ergebnis im Browser so aussehen.

Wir haben nun also die Route gesetzt, verwenden einen Controller und geben eine neu erzeugte View zurück.

Hier geht es weiter: Laravel Datenbank

Hier geht es zum vorherigen Teil: Laravel Routing

Besuchen Sie auch gerne unsere Webseite: admin-code.de

Laravel Routing

Eine Route ist die angeforderte Ressource bzw. der URL.

Die Routen werden definiert in dem File routes/web.php.

Wie man sieht, wird hier eine Get-Route definiert.

  • Dabei bedeutet: „/“, dass die Domain angesteuert wird bzw. die index.html oder index.php.
  • Eine anonyme Funktion gibt dann die View zurück. Der Name der View, in diesem Fall: welcome, wird als Parameter mitgegeben.
  • Die View wird dann anhand des Namens unter resources/views gefunden

Dass die Route direkt die View zurückgibt, ist zwar technisch möglich, aber eher unüblich.

In der Beispielanwendung verwenden wir dann auch Routen, die mit Controllern zusammenarbeiten.

Hier geht es weiter: Laravel Beispielapp

Hier geht es zum vorherigen Teil: Laravel MVC

Besuchen Sie auch gerne unsere Webseite: admin-code.de

Laravel MVC

Laravel implementiert das MVC Pattern, also Model, View, Controller.

  • Das Model implementiert die Business Logik und den Datenbankzugriff.
  • Die View repräsentiert die sichtbare Ausgabe bzw. das ausgelieferte HTML.
  • Der Controller nimmt den Request entgegen und tauscht Daten aus mit dem Model. Gegebenenfalls übergibt der Controller Daten an die View. Außerdem sendet er den Response.

In einem Laravel Projekt liegen die Models unter app/Models.

Die Views liegen unter resources/views.

Die Controller liegen unter app/Http/Controllers.

Hier geht es weiter: Laravel Routing

Hier geht es zum vorherigen Teil: Hier geht es weiter: Laravel Projekt erzeugen

Besuchen Sie auch gerne unsere Webseite: admin-code.de

Laravel installieren

Die Beispiele werden ausgeführt auf einem Ubuntu 18.04 mit PHP 7.3.

Installierte Komponenten: Apache, MariaDB, PHP 7.3, Composer und alle für Webanwendungen benötigten Libraries.

composer global require laravel/installer

Anschließend Composer als Umgebungsvariable hinzufügen. Auf einem Mac ist dies folgendes.

$HOME/.composer/vendor/bin

Hier geht es weiter: Laravel Projekt erzeugen

Besuchen Sie auch gerne unsere Webseite: admin-code.de