Laravel Tutorial: 6 Schritt-Anfänger GUIDE in Deutsch [2024]

Möchtest Du Laravel kennenlernen?

Brauchst Du ein einfaches Einstiegs-Tutorial?

In 6 Schritten programmieren wir eine Laravel-API auf JSON-Basis.

Starten wir!

Einführung API mit Laravel

Dieses Tutorial setzt sich zum Ziel einen Backend für einen Online-Shop auf dem Austauschformat JSON zu entwickeln. Die Daten liegen in einer MySQL-Datenbank, während das Frontend das selbstgebaute REST-Interface abfragen kann.

Laravel-API-Shop mit Produkten

Die Schnittstelle /products/ soll alle Produkte mit dem Titel und dessen Beschreibung des Shops auflisten. Diese Schnittstelle könnten wir z. B. für eine App nutzen. Ein anderer Entwickler könnte als Affiliate auf Deine Angebote auf anderen Webseiten publizieren, sodass Du mehr Umsatz generieren kannst.

Technische Voraussetzungen: Computer für Laravel vorbereiten

Für Laravel brauchen wir auf Windows eine PHP-Entwicklungsumgebung (XMAPP) mit Composer als PHP-Bibliotheks-Verwaltungs-Tool.

1. XAMPP kannst Du hier downloaden und über einen GUI installieren. Wähle nicht alle Module aus:

• Composer kannst Du mit der XAMPP-Shell oder Windows PowerShell installieren. Nutze für die Installation das aktuelle 4-zeilige Skript auf der Download-Webseite von Composer.
  

• Im nächsten Schritt richten wir die Umgebungsvariablen für Composer und PHP in Windows ein.
  

Die Umgebungsvariablen lädt Dein Computer nur, wenn Du Dich ausloggst und wieder einloggst (nicht sperren!)

Öffne die Windows PowerShell im Administrator-Modus (Linksklick auf das Icon).

Um die Installation von Composer zu prüfen, gebe in die Shell folgendes ein
composer

Grundlagen für Laravel einfach erklärt

Eine kleine Übersicht über die wichtigsten Programme zu Laravel.

Was ist Laravel?

Das Framework Laravel erleichtert die Programmierung von Programmierschnittstellen (APIs) und Backends. Das Framework basiert auf PHP, die Paketverwaltung Composer und dem Artisan-Comand-Line-Interface (Konsole).

Der Programmierer kann ein Frontend-Framework wie Angular, Vue oder Blade in Laravel nutzen. Blade strukturiert HTML-Vorlagen, indem Blade den Bild- und Text-Inhalt in die Webseiten einfügt.

Funktionen, Vorteile + Umfang von Laravel

Wie in jedem Framework schreibst Du einen Framework-eigenen Code. PHP-Artisan-CLI bietet mehrere Funktionen, um Codesnippets, Migrationen, Stukturen, Datein und mehr zu erzeugen und darzustellen.

Laravel erstellt mit den Starter-Kits einen Login mit dessen Backend-Logik automatisch. Die Struktur und Aufbau eines sicheren Logins folgt immer dem gleichen Muster. Die Entwickler von Larvel verwenden Best Practises, damit Du Dir selbst über die Standard Arbeit keien Gedanken machen musst. Mit ein paar Anpassungen kannst Du den generierten Code in Dein Projekt einfügen.

Wir arbeiten für dieses Tutorial über die PHP-Artisan-CLI mit einer MariaDB-Integration. Über ein PHP-Skript kann Laravel Tabellen generieren.

Die Kommandzeile Composer dient als Paket-Manager für PHP-Dateien (wie Node.js für JavaScript-Bibliotheken). Die Pakete kannst Du unter Packagist anschauen.

Basics: MVC + CLI

Was bedeutet MVC?

Was ist eine CLI?

Hier ein paar Grundlagen

Model-View-Controller (MVC) in Laravel

Laravel basiert auf dem Model-View-Controller-Prinzip. Das MVC trennt das Datenmodell (Datenbank),  die Benutzeroberfläche (GUI) und die Anwendungslogik. Laravel arbeitet mit einer Vielzahl an (No)SQL-Datenbanken. In diesem Tutorial verwende ich MariaDB über PHPMyAdmin.

Der Model-View-Controller stellt ein typisches Architektur-Muster dar. Das MVC trennt die Komponenten, weil der View „Design-Moden“ durchläuft. Alle 3–5 Jahre kristallisiert sich eine andere Form von einem neuen „hippen“ Design heraus, welches sich schnell ändert. Bei einer starken Verflechtung der Komponenten müsste der Programmierer neben dem View den Controller neu entwickeln.

Der Controller dient dazu, die Eingaben des Views zu verifizieren und an das Backend weiterzuleiten. Neben der Überprüfung der Eingaben kann der Controller Texte übersetzen und geladene Text- und Bild-Inhalte formatieren.

Command Line Interface (CLI) – PHP-Artisan

Eine Kommandozeile (engl. Command Line Interface, CLI) steuert z. B. ein Programm über das Terminal / Bash / Shell. Der Nutzer gibt Anweisungen und Parameter per Text in die CLI ein. Ein Interpreter überprüft die Eingaben. Das Programm führt die Anweisungen mit den gegebenen Parametern aus.

Viele Entwicklungsprogramme wie Node.js, Android SDK und Composer stellen eine CLI zur Verfügung.

Der Programmierer muss die Befehle kennen oder nutzt den-help Flag. Die CLIs bieten (meistens) mehr Funktionalität und Fehlerbehebungsmöglichkeiten als die GUI. Diese bauen auf die Funktionen einer CLI auf. Eine CLI bietet neben der Funktion eine Textausgabe und Debugging-Möglichkeiten.

Schritt für Schritt – Erste Schnittstelle

Dieses Tutorial setzt sich zum Ziel einem Backend für einen Shop mit JSON zu entwickeln. Die Daten sollen in einer MariaDB-Datenbank liegen, die Du mit einem Laravel-Rest-Interface Abfragen kannst.

Die Schnittstelle /products/ soll alle Produkte mit dem Titel und dessen Beschreibung auflisten.

Diese Schnittstelle könnten wir z. B. für eine Web App nutzen.

Laravel installieren und starten

1. Wenn Composer läuft, installiere Laravel mit dem folgenden Kommando global auf Deinem Rechner.
   composer global require laravel/installer
2. Gehe mit der Windows PowerShell in einen Ordner, in dem Du das Projekt starten möchtest
   cd Desktop
3. Führe in dem Ordner das Start-Kommando aus, um das Projekt zu starten
   laravel news shop
4. Sobald der Prozess beendet ist, gehe in den Ordner
   cd shop
   und starte den Server mit
   php aritsan serve
5. Das erste Starten kann bis zu 10 Minuten (je nach Rechenleistung) dauern.
6. Öffne Deinen Browser und geben in die URL
   localhost:8000
7. Die weiße Laravel-Default-Webseite sollte laden

Laravel Model + Controller für Shop erstellen

4. php artisan make:migration create_products_table --create=products
5. Erstelle eine Tabelle in PhpMyAdmin, indem Du zu
   localhost/phpMyAdmin

    

gehst und dort eine Tabelle mit den Namen Laravel erstellt.

Im Projektordner findest Du eine
.env
Datei, in der die Credentials zu Deiner MySQL-Datenbank, damit sich Laravel in die Datenbank einloggen kann und Kommandos ausführen kann
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=root
DB_PASSWORD=

Mit Laravel kannst Du mit einem PHP-Script eine Tabelle hinzufügen. Bearbeite den folgenden Code in
database > migrations > XXXX_XX_XX_063911_create_products_table.php
zu

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateProductsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('products', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->string('name');
            $table->text('description');
            $table->decimal('price', 5, 2);
            $table->bigInteger('categoryID');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('products');
    }
}

Die CLI übernimmt die SQL-Arbeit für Dich und führt die automatisch erstellten SQL-Statements auf Deiner Datenbank aus. Jede Migration soll wohlüberlegt sein, weil diese im Produktiv-System einen Datenverlust bedeuten können.
php artisan migrate
ausführst

Füge den Controller hinzu
php artisan make:controller ProductController --resource --model=Product

Datenbank “sähen” mit Database Seeder / Factory. Mit dem Datenbank-Sähen erstellt Laravel für dich Probeeinträge, die Du nur zur  Demonstration erstellst.
php artisan make:factory ProductFactory --model=Product

Fake 1000 Produkte mit den folgenden Zeilen Code
factory(AppProduct::class, 1000)->create();

Erstelel einen API-Controller, indem Du die Routen erklärst erstellen mit
php artisan make:controller API/ProductController --api

Füge folgenden PHP-Code hinzu
app/Http/Controllers/API/ProductController.php

<?php

namespace App\Http\Controllers\API;

use App\Http\Controllers\Controller;
use App\Product;
use Illuminate\Http\Request;

class ProductController extends Controller
{
    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {
        return Product::all();
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request)
    {
        return Product::create($request->all());
    }

    /**
     * Display the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function show($id)
    {
        return Product::find($id);
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, $id)
    {
        $product  = Product::findOrFail($id);
        $product->delete();

        return $product;
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function destroy($id)
    {
        //
    }
}

Füge eine JSON-Ressource hinzu
php artisan make:resource Product
und dann
php artisan make:resource Product --collection

Ändere die Routen
routes/api.php

<?php

use Illuminate\Http\Request;

Route::get('/products', 'API\ProductController@index');
Route::get('/products/{id}', 'API\ProductController@show');
Route::put('/products/{id}', 'API\ProductController@update');

Route::middleware('auth:api')->get('/user', function (Request $request) {
    return $request->user();
});

Füge folgenden Code hinzu
app/Http/Resources/Product.php

<?php

namespace App\Http\Resources;

use Illuminate\Http\Resources\Json\JsonResource;

class Product extends JsonResource
{
    /**
     * Transform the resource into an array.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return array
     */
    public function toArray($request)
    {
        return [
            'type'          => 'products',
            'id'            => (string) $this->id,
            'attributes'    => [
                'title' => $this->title,
            ],
        ];
    }
}

Führe
php artisan serve
aus, um den Server zu starten.

Öffne den Browser unter, um die REST-API abzufragen. Dein Browser wirft Dir ein Haufen von Symbolen entgegen, wenn Du nicht der Browser für Dich JSON formatiert …
localhost:8000/api/products/
Dort sollten jetzt alle Artikel angezeigt werden.

Unter
localhost:8000/api/products/1
zeigt Dir der Browser nur 1 Produkt an

Fertig. Die API kannst Du mit Routen und Funktionen erweitern.

Erweiterungen: Laravel Schnittstellen

Mit etwas PHP Geschick geht noch mehr …

Füge nach gleichem Prinzip …

• Nutzer
• Shops
• Lieferanten

… hinzu.