In real-time web applications, event broadcasting is one of the most important functions. The Laravel framework provides out-of-the-box event broadcasting functionality, and event broadcasting and monitoring can be easily implemented through Laravel Broadcasting. This article will introduce how to use Laravel Broadcasting to implement event broadcasting.

1. Understanding Event Broadcasting

In web applications, when an event occurs, such as successful user registration, article publication, etc., we hope that other users can receive relevant information in time. At this time, if you use the traditional page refresh or Ajax polling method, it will consume a lot of bandwidth and server resources, and cannot meet the real-time demand. Event broadcasting can solve this problem.

Event broadcasting is to emit an event to a specific channel or broadcast group, and then users monitoring the specific channel or broadcast group can receive relevant information immediately. Through event broadcasting, the number of communications between the server and the client can be significantly reduced, network latency and bandwidth consumption can be reduced, and the performance and user experience of web applications can be improved.

2. Install Laravel Broadcasting

Before using Laravel Broadcasting, you need to install Laravel Echo and related broadcast drivers. Laravel Echo is the Socket.io client library that comes with the Laravel framework, used for real-time communication with broadcast services. The broadcast driver provides APIs for interacting with different broadcast services, such as Redis and Pusher. In this article, we will use Pusher as a broadcast service.

1. Install Laravel Echo and Pusher SDK

Install Laravel Echo and Pusher SDK through npm:

npm install --save laravel-echo pusher-js

2. Modify the configuration file

Open the config/app.php file and uncomment the following code:

AppProvidersBroadcastServiceProvider::class,

Then, add Pusher related configuration in the .env file:

BROADCAST_DRIVER=pusher

PUSHER_APP_ID=your-app-id
PUSHER_APP_KEY=your-app-key
PUSHER_APP_SECRET=your-app-secret

Among them, your- app-id, your-app-key and your-app-secret need to be modified according to the actual situation.

3. Create events and channels

In Laravel, events are implemented through the Event class. We can create a corresponding Event class for each event that needs to be broadcast. In this article, we take successful user registration as an example to create a UserRegistered event. First, execute the following command in the terminal to create the UserRegistered event class:

php artisan make:event UserRegistered

Next, open the app/Events/UserRegistered.php file and modify the code to:

namespace AppEvents;

use AppUser;
use IlluminateQueueSerializesModels;
use IlluminateFoundationEventsDispatchable;

class UserRegistered
{
    use Dispatchable, SerializesModels;

    public $user;

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

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

In the above code, We created a UserRegistered event class and injected the User model in the constructor. Then, in the broadcastOn() method, we define the channel to which the event needs to be broadcast, where a private channel is specified in the form of 'user.{user_id}'.

Next, we need to create a UserChannel channel for monitoring users of the 'user.{user_id}' channel. There are two ways to create a UserChannel channel: manual registration and automatic discovery.

Manual registration method:

Register the UserChannel channel in the app/Providers/BroadcastServiceProvider.php file:

use IlluminateSupportFacadesBroadcast;
use AppBroadcastingUserChannel;

Broadcast::channel('user.{userId}', UserChannel::class);

Automatic discovery method:

In app/ Create a UserChannel.php file in the Broadcasting directory and modify the code to:

namespace AppBroadcasting;

use AppUser;

class UserChannel
{
    /**
     * Create a new channel instance.
     *
     * @param  AppUser  $user
     * @return void
     */
    public function __construct(User $user)
    {
        $this->user = $user;
    }

    /**
     * Authenticate the user's access to the channel.
     *
     * @return array|bool
     */
    public function join(User $user, $userId)
    {
        return $user->id === (int) $userId;
    }
}

In the above code, we created a UserChannel channel class and injected the User model in the construction method. Then, verify that the user has access to the channel via the join() method.

4. Broadcast events

After creating events and channels, we can use the broadcast() function to broadcast events to the specified channel. In this article, we will implement the UserRegistered event broadcast in the UserController class after successful user registration:

namespace AppHttpControllers;

use AppUser;
use AppEventsUserRegistered;
use IlluminateHttpRequest;

class UserController extends Controller
{
    /**
     * Register a new user.
     *
     * @param  IlluminateHttpRequest  $request
     * @return IlluminateHttpResponse
     */
    public function register(Request $request)
    {
        $user = new User([
            'name' => $request->input('name'),
            'email' => $request->input('email'),
            'password' => bcrypt($request->input('password')),
        ]);
        $user->save();

        event(new UserRegistered($user));

        return response()->json([
            'message' => 'User registered successfully!',
            'user' => $user,
        ]);
    }
}

In the above code, we first create a user and perform a save operation. Then, use the event() function to broadcast the UserRegistered event to notify other users that a new user has successfully registered.

5. Monitoring events

After creating events and channels, other users can receive events by monitoring the corresponding channels. Next, we will listen for the UserRegistered event through Laravel Echo.

1. Modify the configuration file

First, add the following code in the resources/assets/js/bootstrap.js file:

import Echo from 'laravel-echo';

window.Pusher = require('pusher-js');

window.Echo = new Echo({
    broadcaster: 'pusher',
    key: process.env.MIX_PUSHER_APP_KEY,
    cluster: process.env.MIX_PUSHER_APP_CLUSTER,
    encrypted: true
});

In the above code , we use Laravel Echo and Pusher SDK to connect to Pusher broadcast service. PUSHER_APP_KEY and PUSHER_APP_CLUSTER can be set in the .env file.

2. Create a listener

Open the resources/assets/js/app.js file and add the following code in it:

import Echo from 'laravel-echo';

window.Pusher = require('pusher-js');

window.Echo = new Echo({
    broadcaster: 'pusher',
    key: process.env.MIX_PUSHER_APP_KEY,
    cluster: process.env.MIX_PUSHER_APP_CLUSTER,
    encrypted: true
});

window.Echo.channel('user.' + userId)
    .listen('UserRegistered', (e) => {
        console.log(e);
    });

In the above code , we listen to the 'user.{user_id}' channel through the window.Echo.channel() method, and specify the event type as 'UserRegistered'. This code will be executed after the user logs in to ensure that each user is only listening to their own channel.

6. Test

Register a new user in the application, and then check whether a new user registration event is received in the console.

Through the above steps, we have completed the process of using Laravel Broadcasting to implement event broadcasting. Event broadcasting is one of the important functions of real-time web applications, which can greatly improve the performance and user experience of web applications.

The above is the detailed content of Laravel development: How to use Laravel Broadcasting to implement event broadcasting?. For more information, please follow other related articles on the PHP Chinese website!