Gestion de la synchronisation du processus avec Laravel Cache Locks

La gestion des opérations simultanées dans les applications nécessite une synchronisation minutieuse pour éviter les conflits. Le mécanisme de verrouillage du cache de Laravel offre une solution robuste pour cela, gérant efficacement des scénarios comme les téléchargements de fichiers, le traitement Webhook et les tâches d'arrière-plan. Ce système crée des verrous distribués, fonctionnant de manière transparente sur plusieurs serveurs, processus et travailleurs de file d'attente, empêchant ainsi les conditions de course dans des environnements distribués.

Voici comment implémenter un verrouillage de cache:

use Illuminate\Support\Facades\Cache;

$lock = Cache::lock('process-payment', 120); // Creates a lock named 'process-payment' lasting 120 seconds

if ($lock->get()) {
    // Payment processing logic here.  The lock is automatically released after 120 seconds.
}

illustrons avec un exemple pratique de la manipulation de webhook:

<?php namespace App\Http\Controllers;

use Illuminate\Support\Facades\Cache;
use App\Jobs\ProcessWebhook;
use Illuminate\Http\Request;
use Log;
use Exception;

class WebhookController extends Controller
{
    public function handle(Request $request)
    {
        $webhookId = $request->input('webhook_id');
        $lockName = "webhook-{$webhookId}";

        $lock = Cache::lock($lockName, 60);

        try {
            if (!$lock->get()) {
                Log::info("Webhook {$webhookId} is already being processed");
                return response()->json(['message' => 'Webhook is being processed'], 409);
            }

            $this->validateWebhook($request); // Validation step

            ProcessWebhook::dispatch($request->all(), $lock->owner())->onQueue('webhooks');

            return response()->json(['message' => 'Webhook accepted', 'processing_id' => $lock->owner()]);

        } catch (Exception $e) {
            $lock?->release();
            throw $e;
        }
    }
}

class ProcessWebhook implements ShouldQueue
{
    public function __construct(private array $payload, private string $lockOwner) {}

    public function handle()
    {
        $lock = Cache::restoreLock("webhook-{$this->payload['webhook_id']}", $this->lockOwner);

        try {
            $this->processWebhookPayload(); // Webhook processing logic

        } finally {
            $lock->release(); // Ensure lock release even on errors
        }
    }
}

Cet exemple montre comment acquérir un verrou, traiter le webhook dans un bloc protégé et libérer de manière fiable le verrou, assurer l'intégrité des données même sous les demandes simultanées. Les verrous à cache de Laravel fournissent un mécanisme fiable pour gérer les processus simultanés et maintenir la stabilité de l'application.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!