Implementeer een Geavanceerd Laravel Event-Driven Systeem voor Asynchrone Verwerking
description
Met deze prompt kan de gebruiker een geavanceerd event-driven systeem opzetten dat de schaalbaarheid en onderhoudbaarheid van de Laravel applicatie verbetert. Het helpt bij het efficiënt beheren van asynchrone taken en het implementeren van robuuste foutafhandeling, wat alternatieve, minder gestructureerde benaderingen overtreft.
prompt
Help me een geavanceerd event-driven systeem te ontwerpen in mijn Laravel applicatie. Ik wil events en listeners gebruiken om asynchrone processen efficiënter te beheren. Geef aan welke events ik moet definiëren voor <specifieke gebeurtenis ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hier is een gedetailleerde aanpak voor het ontwerpen van een geavanceerd event-driven systeem in je Laravel applicatie, gericht op gebruikersregistratie en profielverificatie, inclusief queues en foutafhandeling.
---
### 1. Events definiëren
**Gebruikersregistratie**
- `UserRegistered`: wordt getriggerd zodra een nieuwe gebruiker zich registreert.
- `UserVerificationRequested`: wordt getriggerd wanneer de gebruiker een verificatieproces aanvraagt.
**Profielverificatie**
- `ProfileVerified`: wordt getriggerd nadat de profielverificatie succesvol is afgerond.
- `ProfileVerificationFailed`: wordt getriggerd als de verificatie mislukt.
---
### 2. Listeners ontwerpen
**Voor `UserRegistered`:**
- `SendWelcomeEmail`: stuurt een welkomstmail.
- `CreateUserProfile`: maakt een leeg profiel aan.
**Voor `UserVerificationRequested`:**
- `SendVerificationEmail`: stuurt een verificatie-e-mail.
- `LogVerificationRequest`: registreert de verificatieaanvraag.
**Voor `ProfileVerified`:**
- `NotifyUserOfVerification`: stuurt een notificatie dat de profielverificatie geslaagd is.
- `UpdateUserStatus`: zet de gebruiker op 'geverifieerd'.
**Voor `ProfileVerificationFailed`:**
- `NotifyUserOfFailure`: stuurt een mislukte verificatie melding.
- `LogVerificationFailure`: registreert de fout.
---
### 3. Integratie met queues
- In Laravel definieer je queues door in `config/queue.php` de driver te kiezen (bijvoorbeeld Redis of SQS).
- Mark de listeners als queued door `ShouldQueue` te implementeren:
```php
use Illuminate\Contracts\Queue\ShouldQueue;
class SendWelcomeEmail implements ShouldQueue
{
public function handle(UserRegistered $event)
{
// e-mail versturen
}
}
```
- In je `EventServiceProvider` registreer je de listeners voor queues.
---
### 4. Foutafhandeling en retries
- Laravel biedt automatisch retries met back-off via de `tries` en `retryAfter` eigenschappen in je queue jobs:
```php
class SendWelcomeEmail implements ShouldQueue
{
public $tries = 5; // aantal retries
public $backoff = 60; // seconden tussen retries
public function handle(UserRegistered $event)
{
// e-mail versturen
}
}
```
- Als een job blijft falen, wordt deze na de ingestelde retries gestopt en kan je een `failed` callback gebruiken:
```php
public function failed($exception)
{
// Slack notificatie sturen
Notification::route('slack', env('SLACK_WEBHOOK_URL'))->notify(
new JobFailedNotification($exception)
);
}
```
- Voor automatische retries en waarschuwingen kan je een `failed` method in je job maken die een bericht naar Slack stuurt.
---
### 5. Slack waarschuwingen
Maak een notificatie class:
```php
use Illuminate\Notifications\Notification;
use Illuminate\Notifications\Messages\SlackMessage;
class JobFailedNotification extends Notification
{
protected $exception;
public function __construct($exception)
{
$this->exception = $exception;
}
public function toSlack($notifiable)
{
return (new SlackMessage)
->error()
->content('Een queue job is mislukt: ' . $this->exception->getMessage());
}
}
```
En roep deze aan in de `failed` methode van je job.
---
### Samenvatting
- Definieer relevante events en listeners voor gebruikers- en profielverificatie.
- Gebruik queues door `ShouldQueue` te implementeren en queues te configureren.
- Stel retries en back-offs in voor foutafhandeling.
- Stuur waarschuwingen naar Slack bij hardnekkige fouten via de `failed` callback.
Wil je dat ik je help met concrete codevoorbeelden voor een van deze onderdelen?
provider: deepseek
model: deepseek-chat
Hier is een uitgebreid ontwerp voor een event-driven systeem in Laravel:
## Events Definieren
### 1. Gebruikersregistratie Events
```php
// app/Events/UserRegistered.php
namespace App\Events;
use App\Models\User;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;
class UserRegistered
{
use Dispatchable, SerializesModels;
public $user;
public function __construct(User $user)
{
$this->user = $user;
}
}
// app/Events/UserEmailVerified.php
class UserEmailVerified
{
use Dispatchable, SerializesModels;
public $user;
public function __construct(User $user)
{
$this->user = $user;
}
}
```
### 2. Profielverificatie Events
```php
// app/Events/ProfileVerificationRequested.php
class ProfileVerificationRequested
{
use Dispatchable, SerializesModels;
public $user;
public $verificationData;
public function __construct(User $user, array $verificationData)
{
$this->user = $user;
$this->verificationData = $verificationData;
}
}
// app/Events/ProfileVerified.php
class ProfileVerified
{
use Dispatchable, SerializesModels;
public $user;
public function __construct(User $user)
{
$this->user = $user;
}
}
```
## Listeners Implementeren
### Gebruikersregistratie Listeners
```php
// app/Listeners/SendWelcomeEmail.php
namespace App\Listeners;
use App\Events\UserRegistered;
use App\Mail\WelcomeEmail;
use Illuminate\Support\Facades\Mail;
use Illuminate\Contracts\Queue\ShouldQueue;
class SendWelcomeEmail implements ShouldQueue
{
public function handle(UserRegistered $event)
{
Mail::to($event->user->email)
->send(new WelcomeEmail($event->user));
}
public function failed(UserRegistered $event, $exception)
{
// Foutafhandeling hier
}
}
// app/Listeners/CreateUserProfile.php
class CreateUserProfile implements ShouldQueue
{
public function handle(UserRegistered $event)
{
$event->user->profile()->create([
'status' => 'incomplete'
]);
}
}
```
### Profielverificatie Listeners
```php
// app/Listeners/ProcessVerificationDocuments.php
class ProcessVerificationDocuments implements ShouldQueue
{
public $tries = 5;
public $backoff = [60, 300, 900];
public function handle(ProfileVerificationRequested $event)
{
// Documentverwerking logica
$this->validateDocuments($event->verificationData);
$this->storeDocuments($event->user, $event->verificationData);
// Eventueel een follow-up event dispatch
event(new DocumentsProcessed($event->user));
}
public function failed(ProfileVerificationRequested $event, $exception)
{
\Log::error('Verificatie mislukt: ' . $exception->getMessage());
// Slack notificatie
Slack::to('#verification-errors')
->send("Verificatie mislukt voor gebruiker: {$event->user->id}");
}
}
```
## Queue Configuratie
### .env configuratie
```env
QUEUE_CONNECTION=redis
REDIS_HOST=127.0.0.1
REDIS_PORT=6379
REDIS_QUEUE=default
```
### Queue worker starten
```bash
php artisan queue:work redis --tries=3 --backoff=60,300
```
## Foutafhandeling met Back-off
### Custom Job met back-off logica
```php
// app/Jobs/VerificationJob.php
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;
class VerificationJob implements ShouldQueue
{
use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
public $tries = 5;
public $backoff = [60, 300, 900, 3600];
public function __construct(public $user, public $verificationData)
{
}
public function handle()
{
// Verificatie logica
}
public function failed(\Throwable $exception)
{
\Log::error("Verificatie job mislukt: {$exception->getMessage()}");
// Slack notificatie
\Illuminate\Support\Facades\Http::post(env('SLACK_WEBHOOK'), [
'text' => "❌ Verificatie mislukt voor gebruiker: {$this->user->id}"
]);
}
}
```
## Event Service Provider Registratie
```php
// app/Providers/EventServiceProvider.php
protected $listen = [
UserRegistered::class => [
SendWelcomeEmail::class,
CreateUserProfile::class,
InitializeUserSettings::class,
],
ProfileVerificationRequested::class => [
ProcessVerificationDocuments::class,
NotifyAdminForReview::class,
],
UserEmailVerified::class => [
GrantEmailVerifiedPermissions::class,
SendVerificationConfirmation::class,
],
];
```
## Slack Notificatie Service
```php
// app/Services/SlackNotifier.php
namespace App\Services;
class SlackNotifier
{
public function sendWarning($message)
{
\Http::post(env('SLACK_WEBHOOK_WARNINGS'), [
'text' => "⚠️ $message"
]);
}
public function sendError($message)
{
\Http::post(env('SLACK_WEBHOOK_ERRORS'), [
'text' => "❌ $message"
]);
}
}
```
## Gebruik in Controllers
```php
// Registratie controller
public function register(Request $request)
{
$user = User::create($request->validated());
event(new UserRegistered($user));
return response()->json(['message' => 'Registratie succesvol']);
}
// Verificatie controller
public function verifyProfile(Request $request)
{
$verificationData = $request->validated();
event(new ProfileVerificationRequested(auth()->user(), $verificationData));
return response()->json(['message' => 'Verificatie aangevraagd']);
}
```
## Monitoring en Supervisie
```bash
# Supervisor configuratie
[program:laravel-worker]
process_name=%(program_name)s_%(process_num)02d
command=php /path/to/artisan queue:work redis --sleep=3 --tries=3 --backoff=60,300
autostart=true
autorestart=true
user=www-data
numprocs=8
redirect_stderr=true
stdout_logfile=/path/to/worker.log
```
Dit ontwerp biedt:
- Asynchrone verwerking via queues
- Automatische retry met back-off strategie
- Robuuste foutafhandeling
- Real-time monitoring via Slack
- Schaalbare architectuur
- Goede scheiding van concerns