Laravel Pipelines: Optimierung der Web-Entwicklung

Laravel Pipelines: Optimierung der Web-Entwicklung

Laravel Pipelines ist eine weniger bekannte, aber leistungsstarke Funktion von Laravel, die in der offiziellen Laravel-Dokumentation nicht beschrieben ist. Dennoch wird dieses Tool innerhalb des Frameworks weit verbreitet für die Durchführung sequenzieller Operationen verwendet. In diesem Artikel werden wir untersuchen, wie Laravel Pipelines in der CRM-Entwicklung von Vorteil sein kann und Beispiele für deren Verwendung geben, wobei die Prinzipien der sauberen Architektur und der Domain-Driven Design (DDD) eingehalten werden.

Wo Laravel Pipelines von Vorteil sein kann

Stellen Sie sich ein Szenario vor, in dem Sie einige Anfangsdaten haben, die eine Reihe von sequenziellen Aktionen durchlaufen müssen. Zum Beispiel das Hinzufügen eines neuen Kontakts zu einem CRM-System.

Beispiel 1: Hinzufügen eines neuen Kontakts

Wenn ein Benutzer einen neuen Kontakt hinzufügt, werden die Daten an den Controller gesendet. Der Kontakt durchläuft mehrere Schritte, bevor er in der Datenbank gespeichert wird:

1. Überprüfung auf das Vorhandensein aller erforderlichen Felder.
2. Datenvalidierung: Sicherstellen der Korrektheit der E-Mail, Telefonnummer usw.
3. Entfernen von überflüssigem Leerzeichen und Formatieren des Textes.
4. Überprüfung auf eindeutigen Kontakt.
5. Erzeugen einer eindeutigen Kennung für den Kontakt.
6. Speichern des Kontakts in der Datenbank.

Beispiel 2: Bearbeitung einer Supportanfrage

Wenn ein Benutzer eine Supportanfrage erstellt, durchlaufen die Anfragedaten ebenfalls mehrere Schritte:

1. Überprüfung auf das Vorhandensein aller erforderlichen Felder.
2. Datenvalidierung: Sicherstellen der Korrektheit der E-Mail, der Problembeschreibung usw.
3. Entfernen von überflüssigem Leerzeichen und Formatieren des Textes.
4. Erzeugen einer eindeutigen Kennung für die Anfrage.
5. Speichern der Anfrage in der Datenbank.
6. Senden einer Benachrichtigung an den Benutzer.
7. Zuweisung der Anfrage an einen Supportmitarbeiter.

Code-Evolution

Sehen wir uns an, wie sich der Code weiterentwickelt, wenn neue Schritte hinzugefügt werden, wobei die Prinzipien der sauberen Architektur und DDD eingehalten werden.

Anfangsstadium

Zunächst haben wir einen Controller und einen Service, der die Kernlogik bearbeitet. Zum Beispiel das Hinzufügen eines einfachen Kontakts:

// Controller
public function store(Request $request, ContactService $contactService)
{
    $contact = $contactService->create($request->all());
    return response()->json($contact, 201);
}

// Service
class ContactService
{
    protected $contactRepository;

    public function __construct(ContactRepository $contactRepository)
    {
        $this->contactRepository = $contactRepository;
    }

    public function create(array $data)
    {
        return $this->contactRepository->create($data);
    }
}

// Repository
class ContactRepository
{
    public function create(array $data)
    {
        return Contact::create($data);
    }
}

Hinzufügen neuer Schritte

Mit dem Hinzufügen neuer Schritte wird der Code komplexer. Wir verschieben die Logik in separate Klassen:

// Controller
public function store(Request $request, ContactService $contactService)
{
    $contact = $contactService->create($request->all());
    return response()->json($contact, 201);
}

// Service
class ContactService
{
    protected $contactRepository;

    public function __construct(ContactRepository $contactRepository)
    {
        $this->contactRepository = $contactRepository;
    }

    public function create(array $data)
    {
        $data = (new TrimWhitespace())->handle($data);
        $data = (new ValidateUniqueEmail())->handle($data);
        $data = (new GenerateUniqueId())->handle($data);

        return $this->contactRepository->create($data);
    }
}

Vereinheitlichung von Schnittstellen

Wir können die Schnittstellen vereinheitlichen und Laravel Pipelines für die sequenzielle Ausführung von Schritten verwenden:

// Controller
public function store(Request $request, ContactService $contactService)
{
    $contact = $contactService->create($request->all());
    return response()->json($contact, 201);
}

// Service
class ContactService
{
    protected $contactRepository;

    public function __construct(ContactRepository $contactRepository)
    {
        $this->contactRepository = $contactRepository;
    }

    public function create(array $data)
    {
        $pipes = [
            TrimWhitespace::class,
            ValidateUniqueEmail::class,
            GenerateUniqueId::class,
        ];

        $data = app(Pipeline::class)
            ->send($data)
            ->through($pipes)
            ->then(function ($data) {
                return $this->contactRepository->create($data);
            });

        return $data;
    }
}

Beispiel für die Verwendung von Laravel Pipelines

Pipe-Schnittstelle

Jeder Schritt (Pipe) sollte die Pipe-Schnittstelle implementieren:

namespace App\Pipes;

use Closure;

interface Pipe
{
    public function handle($data, Closure $next);
}

Pipe-Beispiel

namespace App\Pipes;

use Closure;

class TrimWhitespace implements Pipe
{
    public function handle($data, Closure $next)
    {
        $data['name'] = trim($data['name']);
        return $next($data);
    }
}

Begleitende Probleme

Manchmal müssen Sie die Ausführung an einem bestimmten Schritt unterbrechen oder die Datenbank von zuvor ausgeführten Schritten bereinigen. Hier ist ein Beispiel, wie solche Probleme behandelt werden können:

class ContactService
{
    protected $contactRepository;

    public function __construct(ContactRepository $contactRepository)
    {
        $this->contactRepository = $contactRepository;
    }

    public function create(array $data)
    {
        $pipes = [
            TrimWhitespace::class,
            ValidateUniqueEmail::class,
            GenerateUniqueId::class,
        ];

        try {
            DB::beginTransaction();
            $data = app(Pipeline::class)
                ->send($data)
                ->through($pipes)
                ->then(function ($data) {
                    return $this->contactRepository->create($data);
                });
            DB::commit();
            return $data;
        } catch (Exception $e) {
            DB::rollback();
            throw $e;
        }
    }
}

Hier wird eine Transaktion verwendet, um die Datenintegrität sicherzustellen. Im Falle eines Fehlers wird die Transaktion zurückgesetzt (DB::rollback()), und eine Fehlermeldung wird zurückgegeben.

Schlussfolgerung

Laravel Pipelines ist ein leistungsstarkes Tool zur Verwaltung sequenzieller Operationen. Es hilft, Spaghetti-Code zu vermeiden und den Code sauberer und wartbarer zu machen. In diesem Artikel haben wir Beispiele für die Verwendung von Laravel Pipelines zur Verwaltung von Kontakten und Supportanfragen in einem CRM-System untersucht, wobei die Prinzipien der sauberen Architektur und DDD eingehalten wurden. Wir hoffen, dass diese Informationen für Ihre Projektentwicklung nützlich sind.