Um das Versenden mehrerer E-Mail-Benachrichtigungen nach verschiedenen Ereignissen (z. B. Benutzererstellung, Passwortzurücksetzung usw.) zu vereinfachen, können Sie ein paar Schritte unternehmen, um Ihre Benachrichtigungen und Auftragsabwicklung zu zentralisieren. Dieser Ansatz macht Ihre Arbeit einfacher und skalierbarer, ohne dass für jedes Ereignis ein separater Job oder eine separate Benachrichtigung erstellt werden muss.

Strategien zur Vereinfachung der Bearbeitung von E-Mail-Benachrichtigungen:

1. Verwenden Sie einen allgemeinen E-Mail-Benachrichtigungsjob.
2. Event-Listener-Architektur nutzen.
3. Ähnliche Benachrichtigungen gruppieren.

1. Erstellen Sie einen allgemeinen E-Mail-Benachrichtigungsauftrag:

Anstatt für jede Benachrichtigung separate Jobs zu erstellen, können Sie einen einzelnen wiederverwendbaren Job erstellen, der die Benachrichtigung und den Benutzer als Parameter verwendet. Auf diese Weise kann derselbe Job zur Bearbeitung unterschiedlicher Benachrichtigungen verwendet werden.

Generalisierter SendEmailNotificationJob:

namespace App\Jobs;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Notifications\Notification;
use App\Models\User;

class SendEmailNotificationJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public $user;
    public $notification;

    /**
     * Create a new job instance.
     *
     * @param  User $user
     * @param  Notification $notification
     * @return void
     */
    public function __construct(User $user, Notification $notification)
    {
        $this->user = $user;
        $this->notification = $notification;
    }

    /**
     * Execute the job.
     *
     * @return void
     */
    public function handle()
    {
        // Send the notification
        $this->user->notify($this->notification);
    }
}

Mit diesem allgemeinen Job können Sie verschiedene Arten von E-Mail-Benachrichtigungen mit demselben Job versenden:

Beispielverwendung:

use App\Jobs\SendEmailNotificationJob;
use App\Notifications\UserWelcomeNotification;
use App\Models\User;

$user = User::find(1); // Example user

// Dispatch a welcome email notification
SendEmailNotificationJob::dispatch($user, new UserWelcomeNotification());

// Dispatch a password reset notification
SendEmailNotificationJob::dispatch($user, new PasswordResetNotification());

2. Event-Listener-Architektur nutzen:

Anstatt Jobs nach jedem Ereignis manuell zu versenden, können Sie mit der Event-Listener-Architektur von Laravel automatisch Benachrichtigungen und Jobs basierend auf bestimmten Ereignissen (z. B. Benutzererstellung) auslösen.

Schritt 1: Ereignisse definieren:

Sie können ein Ereignis wie UserCreated definieren:

php artisan make:event UserCreated

Beispiel für ein vom Benutzer erstelltes Ereignis:

namespace App\Events;

use App\Models\User;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;

class UserCreated
{
    use Dispatchable, SerializesModels;

    public $user;

    public function __construct(User $user)
    {
        $this->user = $user;
    }
}

Schritt 2: Listener erstellen:

Sie können einen Listener erstellen, der eine Benachrichtigung sendet, wenn das Ereignis ausgelöst wird:

php artisan make:listener SendUserWelcomeNotification --event=UserCreated

Beispiel-Listener:

namespace App\Listeners;

use App\Events\UserCreated;
use App\Jobs\SendEmailNotificationJob;
use App\Notifications\UserWelcomeNotification;

class SendUserWelcomeNotification
{
    public function handle(UserCreated $event)
    {
        // Dispatch the email notification job
        SendEmailNotificationJob::dispatch($event->user, new UserWelcomeNotification());
    }
}

Schritt 3: Ereignis bei Benutzererstellung auslösen:

Immer wenn ein Benutzer erstellt wird, können Sie das Ereignis auslösen und Laravel erledigt den Rest automatisch:

use App\Events\UserCreated;

$user = User::create($data);
event(new UserCreated($user));

Mit diesem Ansatz können Sie die Logik der Benachrichtigungsverarbeitung von Ihrer Geschäftslogik entkoppeln und so das System skalierbarer machen.

3. Ähnliche Benachrichtigungen gruppieren:

Wenn Sie viele ähnliche Benachrichtigungen haben (z. B. benutzerbezogene Benachrichtigungen wie Willkommens-E-Mails, Passwort-Resets usw.), können Sie einen Benachrichtigungsdienst erstellen, der alle Benutzerbenachrichtigungen zentral verarbeitet.

Beispiel NotificationService:

namespace App\Services;

use App\Models\User;
use App\Jobs\SendEmailNotificationJob;
use App\Notifications\UserWelcomeNotification;
use App\Notifications\PasswordResetNotification;

class NotificationService
{
    public function sendUserWelcomeEmail(User $user)
    {
        SendEmailNotificationJob::dispatch($user, new UserWelcomeNotification());
    }

    public function sendPasswordResetEmail(User $user)
    {
        SendEmailNotificationJob::dispatch($user, new PasswordResetNotification());
    }

    // You can add more methods for different types of notifications
}

Beispielverwendung:

In Ihren Controllern oder Event-Listenern können Sie jetzt einfach den Dienst aufrufen:

$notificationService = new NotificationService();
$notificationService->sendUserWelcomeEmail($user);

Abschluss:

• Einzelner Job: Sie können einen generalisierten Job (SendEmailNotificationJob) verwenden, um verschiedene Arten von Benachrichtigungen zu verarbeiten.
• Event-Listener-Architektur: Nutzen Sie das Event-Listener-System von Laravel, um automatisch Benachrichtigungen basierend auf Systemereignissen auszulösen.
• Zentraler Benachrichtigungsdienst: Gruppieren Sie ähnliche Benachrichtigungen in einem Dienst für eine bessere Verwaltung und Wiederverwendbarkeit.

Dieser Ansatz trägt dazu bei, dass Ihr Code trocken bleibt (Don't Repeat Yourself) und erleichtert die Wartung, wenn Sie mehrere E-Mail-Benachrichtigungen senden müssen.