जब हमारे वेब ऐप्स में जटिल डेटा से निपटने की बात आती है तो लारवेल का इवेंट सिस्टम अभूतपूर्व है क्योंकि यह डिकौपल्ड और बिल्कुल जटिल ऐप्स के निर्माण के लिए आधारशिला है। यह मार्गदर्शिका विशेष रूप से 2024 में इवेंट सुनने के कार्यान्वयन और उपयोग पर अत्यंत विस्तृत बिंदु बताती है, जो लारवेल 11 में सबसे विस्तृत सामग्री और विस्तृत कोड उदाहरण इवेंट श्रोताओं के साथ एक नया परिप्रेक्ष्य प्रदान करती है।

*(ए) घटनाओं और श्रोताओं के पीछे के मूल को समझना
*
तो, आइए उन्हें तोड़ दें, लारवेल में होने वाली घटनाएं एक ऐप के अंदर विशिष्ट घटनाओं का प्रतिनिधित्व करती हैं। श्रोता वे वर्ग हैं जो ऐसे सभी ऐप इवेंट पर प्रतिक्रिया देंगे। यह पैटर्न चिंताओं के पृथक्करण को बढ़ावा देता रहता है और अधिक मॉड्यूलर और परीक्षण योग्य कोड की अनुमति देता रहा है।

*(बी) एक इवेंट बनाना
*
आइए एक जटिल ईवेंट बनाकर शुरुआत करें, जिसे बेहतर ढंग से समझाने के लिए हम आर्टिसन कमांड का उपयोग करेंगे, हम अत्यधिक सुझाव देते हैं कि आप भी ऐसा करें

php कारीगर ने बनाया: इवेंट का ऑर्डर दिया गया

यह कमांड ऐप/इवेंट डायरेक्टरी में एक नया इवेंट क्लास जेनरेट करेगा। आइए अधिक विस्तृत घटना वर्ग की जाँच करें

`नेमस्पेस ऐप\इवेंट्स;

ऐप\मॉडल\ऑर्डर का उपयोग करें;
App\Models\User का उपयोग करें;
Illumate\Foundation\Events\Dispatchable का उपयोग करें;
Illumate\Queue\SerializesModels का उपयोग करें;
Illumate\Broadcasting\InteractsWithSockets का उपयोग करें;
इल्यूमिनेट\ब्रॉडकास्टिंग\प्राइवेटचैनल का उपयोग करें;
Illumate\Contracts\Broadcasting\ShouldBroadcast का उपयोग करें;

क्लास ऑर्डरप्लेस्ड उपकरण शोडब्रॉडकास्ट
{
डिस्पैचेबल, इंटरैक्ट्सविथसॉकेट, सीरियलाइज़मॉडल का उपयोग करें;

public $order;
public $user;

/**
 * Create a new event instance.
 *
 * @param  \App\Models\Order  $order
 * @param  \App\Models\User  $user
 * @return void
 */
public function __construct(Order $order, User $user)
{
    $this->order = $order;
    $this->user = $user;
}

/**
 * Get the channels the event should broadcast on.
 *
 * @return \Illuminate\Broadcasting\Channel|array
 */
public function broadcastOn()
{
    return new PrivateChannel('orders.'.$this->user->id);
}

/**
 * The event's broadcast name.
 *
 * @return string
 */
public function broadcastAs()
{
    return 'order.placed';
}

}`

इस विस्तारित उदाहरण में, हम ऑर्डर और उपयोगकर्ता मॉडल दोनों को शामिल कर रहे हैं। SerializesModels विशेषता यह सुनिश्चित कर रही है कि जब घटना पंक्तिबद्ध श्रोताओं को दी जाती है तो हमारे एलोक्वेंट मॉडल सही ढंग से क्रमबद्ध और डिसेरिएलाइज्ड होते हैं। हमने ShouldBroadcast इंटरफ़ेस को भी लागू किया है और broadcastOn और broadcastAs तरीकों को परिभाषित किया है, जिससे इस इवेंट को वास्तविक समय के अपडेट के लिए वेबसॉकेट पर प्रसारित किया जा सकता है।

*एकाधिक श्रोता बनाना
*
एक ही कार्यक्रम के लिए, हमें अनेक श्रोता चाहिए होंगे। आइए उदाहरण को और अधिक विस्तारित करने के लिए अपने OrderPlaced इवेंट के लिए दो श्रोता बनाएं। मैं बस यही चाहता हूं कि आप लोग यह सुनिश्चित करें कि आपको हर चीज का सार मिल जाए। तो, इसके लिए कृपया नीचे दिए गए कोड उदाहरण देखें

php कारीगर बनाते हैं: श्रोता भेजेंऑर्डर पुष्टिकरण --इवेंट=ऑर्डरप्लेस्ड
php कारीगर बनाओ: श्रोता अपडेट इन्वेंटरी --इवेंट=ऑर्डरप्लेस्ड

तो अब आप समझ गए होंगे कि यह कमांड लाइन हमें हमारे ऐप/लिसनर्स डायरेक्टरी में कुछ नए श्रोता वर्ग दिलाएगी। अब बात यह है कि, यहां नीचे, हम SendOrderConfirmation श्रोता की जांच करेंगे और देखेंगे कि यह कैसे आगे बढ़ता है

`नेमस्पेस ऐप\लिसनर;

App\Events\OrderPlaced का उपयोग करें;
App\Mail\OrderConfirmation का उपयोग करें;
Illumate\Contracts\Queue\ShouldQueue का उपयोग करें;
Illumate\Queue\InteractsWithQueue;
का उपयोग करें Illumate\Support\Facades\Mail का उपयोग करें;
Illumate\Support\Facades\Log का उपयोग करें;

क्लास सेंडऑर्डर कन्फर्मेशन, ShodQueue को लागू करता है
{
InteractsWithQueue का उपयोग करें;

/**
 * The number of times the job may be attempted.
 *
 * @var int
 */
public $tries = 3;

/**
 * Handle the event.
 *
 * @param  \App\Events\OrderPlaced  $event
 * @return void
 */
public function handle(OrderPlaced $event)
{
    $order = $event->order;
    $user = $event->user;

    try {
        Mail::to($user->email)->send(new OrderConfirmation($order));
        Log::info('Order confirmation email sent', ['order_id' => $order->id, 'user_id' => $user->id]);
    } catch (\Exception $e) {
        Log::error('Failed to send order confirmation email', ['order_id' => $order->id, 'user_id' => $user->id, 'error' => $e->getMessage()]);
        $this->fail($e);
    }
}

/**
 * Handle a job failure.
 *
 * @param  \App\Events\OrderPlaced  $event
 * @param  \Throwable  $exception
 * @return void
 */
public function failed(OrderPlaced $event, $exception)
{
    Log::error('Order confirmation listener failed', ['order_id' => $event->order->id, 'user_id' => $event->user->id, 'error' => $exception->getMessage()]);
}

}`

यह श्रोता ShouldQueue इंटरफ़ेस को कार्यान्वित कर रहा है, जो दर्शाता है कि इसे कतारबद्ध किया जाना चाहिए। हमने विफलताओं को संभालने के लिए त्रुटि प्रबंधन, लॉगिंग को जोड़ा है और एक असफल विधि को परिभाषित किया है। विफलता की स्थिति में एकाधिक प्रयासों की अनुमति देने के लिए $tries प्रॉपर्टी सेट की जाएगी।
अब, आइए अपडेटइन्वेंटरी श्रोता को देखें

`नेमस्पेस ऐप\लिसनर;

App\Events\OrderPlaced का उपयोग करें;
Illumate\Contracts\Queue\ShouldQueue का उपयोग करें;
Illumate\Queue\InteractsWithQueue;
का उपयोग करें Illumate\Support\Facades\DB;
का उपयोग करें Illumate\Support\Facades\Log का उपयोग करें;

क्लास अपडेटइन्वेंटरी, ShodQueue को लागू करता है
{
InteractsWithQueue का उपयोग करें;

/**
 * Handle the event.
 *
 * @param  \App\Events\OrderPlaced  $event
 * @return void
 */
public function handle(OrderPlaced $event)
{
    $order = $event->order;

    DB::transaction(function () use ($order) {
        foreach ($order->items as $item) {
            $product = $item->product;

            if ($product->stock quantity) {
                throw new \Exception("Insufficient stock for product: {$product->id}");
            }

            $product->decrement('stock', $item->quantity);
            Log::info("Inventory updated", ['product_id' => $product->id, 'quantity' => $item->quantity]);
        }
    });
}

/**
 * Handle a job failure.
 *
 * @param  \App\Events\OrderPlaced  $event
 * @param  \Throwable  $exception
 * @return void
 */
public function failed(OrderPlaced $event, $exception)
{
    Log::error('Failed to update inventory', ['order_id' => $event->order->id, 'error' => $exception->getMessage()]);
}

}`

अब, आप समझ गए होंगे कि, यह श्रोता ऑर्डर आइटम आदि के आधार पर इन्वेंट्री को अपग्रेड करने जैसे कारणों से वहां मौजूद है। हमने डेटा स्थिरता सुनिश्चित करने के लिए इन्वेंट्री अपडेट को डेटाबेस लेनदेन में लपेट दिया है। हमने नकारात्मक स्टॉक को रोकने के लिए त्रुटि जांच भी जोड़ी है और सफल अपडेट और विफलताओं के लिए लॉगिंग भी शामिल की है।

*घटनाओं और श्रोताओं का पंजीकरण
*
हम इन घटनाओं और श्रोताओं को इवेंटसर्विसप्रोवाइडर में पंजीकृत करेंगे

`App\Events\OrderPlaced का उपयोग करें;
App\Listeners\SendOrderConfirmation का उपयोग करें;
App\Lisners\UpdateInventory का उपयोग करें;

क्लास इवेंटसर्विसप्रोवाइडर सर्विसप्रोवाइडर का विस्तार करता है
{
/**
* एप्लिकेशन के लिए इवेंट श्रोता मैपिंग।
*
* @var सरणी
*/
संरक्षित $सुनो = [
ऑर्डरप्लेस्ड::क्लास => [
आदेश पुष्टिकरण भेजें::वर्ग,
अद्यतन सूची::वर्ग,
],
];

/**
 * Register any events for your application.
 *
 * @return void
 */
public function boot()
{
    parent::boot();

    //
}

}`

प्रेषण घटनाएँ:

हम नियंत्रक या सेवा वर्ग से ईवेंट भेज सकते हैं

`App\Events\OrderPlaced का उपयोग करें;
ऐप\मॉडल\ऑर्डर का उपयोग करें;
Illumate\Http\Request का उपयोग करें;
Illumate\Support\Facades\DB;

क्लास ऑर्डरकंट्रोलर नियंत्रक का विस्तार करता है
{
/**
* एक नया ऑर्डर दें।
*
* @परम \इलुमिनेट\Http\अनुरोध $अनुरोध
* @वापसी \इल्यूमिनेट\Http\JsonResponse
*/
सार्वजनिक समारोह स्थानआदेश(अनुरोध $अनुरोध)
{
$user = auth()->user();

    DB::transaction(function () use ($request, $user) {
        $order = Order::create($request->all());
        $order->user()->associate($user);
        $order->save();

        event(new OrderPlaced($order, $user));
    });

    return response()->json(['message' => 'Order placed successfully', 'order_id' => $order->id]);
}

}`

इस उदाहरण में, हमने यह सुनिश्चित करने के लिए ऑर्डर निर्माण और ईवेंट डिस्पैचिंग को डेटाबेस लेनदेन में लपेट दिया है कि दोनों सफलतापूर्वक होते हैं या बिल्कुल नहीं।