Cet article a été revu par des pairs par Rafie Younes et Wern Ancheta. Merci à tous les pairs examinateurs de SitePoint pour avoir fait du contenu SitePoint le meilleur possible!
L'utilisateur Web moderne prévoit d'être informé de tout ce qui se passe dans l'application. Vous ne voulez pas être ce site Web qui n'a même pas la liste déroulante des notifications non seulement dans tous les sites Web de médias sociaux, mais partout ailleurs ces jours-ci aussi.
Heureusement, avec Laravel et Pusher, la mise en œuvre de cette fonctionnalité est un jeu d'enfant. Le code que nous écrivons dans ce tutoriel peut être trouvé ici.
Image via pusher.com
Afin de fournir aux utilisateurs une bonne expérience, les notifications doivent être affichées en temps réel. Une approche consiste à envoyer régulièrement une demande Ajax à l'arrière et à récupérer les dernières notifications si elles existent.
Une meilleure approche consiste à tirer parti de la puissance de WebSockets et à recevoir des notifications au moment où ils sont envoyés. C'est ce que nous allons utiliser dans ce tutoriel.
Pusher est un service Web pour
… Intégration des fonctionnalités bidirectionnelles en temps réel via les lignes Websockets aux applications Web et mobiles.
Il a une API très simple, mais nous allons le rendre encore plus simple avec Laravel Broadcasting et Laravel Echo.
Dans ce tutoriel, nous allons ajouter des notifications en temps réel à un blog existant. La fonctionnalité de base est similaire aux notifications de Laravel en temps réel avec le flux. Nous allons commencer par ce dépôt fabriqué par Christopher Vundi (je l'ai changé un peu) qui est un simple blog où les utilisateurs qui peuvent effectuer Crud sur les articles.
Nous allons d'abord cloner le simple blog Laravel:
<span>git clone https://github.com/vickris/simple-blog </span>
Ensuite, nous allons créer une base de données MySQL et configurer des variables d'environnement pour donner à l'application l'accès à la base de données.
Copiez Env.example à .env et mettons à jour les variables liées à la base de données.
<span>cp .env.example .env </span>
DB_HOST=localhost DB_DATABASE=homestead DB_USERNAME=homestead DB_PASSWORD=secret
.env
Installons maintenant les dépendances du projet avec
<span>composer install </span>
et exécutez la commande de migration et de semis pour remplir la base de données avec certaines données:
php artisan migrate <span>--seed </span>
Si vous exécutez l'application et visitez / articles, vous pourrez voir une liste des messages générés. Vérifiez l'application, enregistrez un utilisateur et créez des messages. C'est une application très basique, mais sert parfaitement notre démo.
Nous voulons donner aux utilisateurs la possibilité de suivre d'autres utilisateurs et d'être suivis par les utilisateurs, nous devons donc créer de nombreuses relations entre les utilisateurs pour y arriver.
Faisons une table de pivot qui relie les utilisateurs aux utilisateurs. Faire une nouvelle migration de followers:
php artisan make:migration create_followers_table <span>--create=followers </span>
Nous devons ajouter des champs à cette migration: un user_id pour représenter l'utilisateur qui suit, et un champ suit_id pour représenter l'utilisateur qui est suivi.
Mettez à jour la migration comme suit:
<span>public function up()
</span><span>{
</span> <span>Schema<span>::</span>create('followers', function (Blueprint $table) {
</span> <span>$table->increments('id');
</span> <span>$table->integer('user_id')->index();
</span> <span>$table->integer('follows_id')->index();
</span> <span>$table->timestamps();
</span> <span>});
</span><span>}
</span>Migré maintenant pour créer le tableau:
php artisan migrate
Si vous avez suivi l'article d'approche du flux, vous constaterez que les choses sont presque identiques jusqu'à présent. Dans la partie qui suit, nous allons réaliser les mêmes fonctionnalités de suivi avec une approche différente.
Ajoutons des méthodes de relations au modèle utilisateur.
<span>// ...
</span>
<span>class extends Authenticatable
</span><span>{
</span> <span>// ...
</span>
<span>public function followers()
</span> <span>{
</span> <span>return $this->belongsToMany(<span>self::</span>class, 'followers', 'follows_id', 'user_id')
</span> <span>->withTimestamps();
</span> <span>}
</span>
<span>public function follows()
</span> <span>{
</span> <span>return $this->belongsToMany(<span>self::</span>class, 'followers', 'user_id', 'follows_id')
</span> <span>->withTimestamps();
</span> <span>}
</span><span>}
</span>app / user.php
Maintenant que le modèle d'utilisateur a les relations nécessaires, les abonnés renvoie tous les abonnés d'un utilisateur et suit tout le monde que l'utilisateur suit.
Nous aurons besoin de certaines fonctions d'assistance pour permettre à l'utilisateur de suivre un autre utilisateur et de vérifier si un utilisateur a suivi un utilisateur spécifique.
<span>// ...
</span>
<span>class extends Authenticatable
</span><span>{
</span> <span>// ...
</span>
<span>public function follow($userId)
</span> <span>{
</span> <span>$this->follows()->attach($userId);
</span> <span>return $this;
</span> <span>}
</span>
<span>public function unfollow($userId)
</span> <span>{
</span> <span>$this->follows()->detach($userId);
</span> <span>return $this;
</span> <span>}
</span>
<span>public function isFollowing($userId)
</span> <span>{
</span> <span>return (boolean) $this->follows()->where('follows_id', $userId)->first(['id']);
</span> <span>}
</span>
<span>}
</span>app / user.php
parfait. Avec l'ensemble de modèles, il est temps de répertorier les utilisateurs.
Commençons par définir les routes nécessaires
<span>//...
</span><span>Route<span>::</span>group(['middleware' => 'auth'], function () {
</span> <span>Route<span>::</span>get('users', 'UsersController@index')->name('users');
</span> <span>Route<span>::</span>post('users/{user}/follow', 'UsersController@follow')->name('follow');
</span> <span>Route<span>::</span>delete('users/{user}/unfollow', 'UsersController@unfollow')->name('unfollow');
</span><span>});
</span>routes / web.php
Ensuite, il est temps de créer un nouveau contrôleur pour les utilisateurs:
php artisan make:controller UsersController
Nous allons y ajouter une méthode d'index:
<span>// ...
</span><span>use App<span>\User</span>;
</span><span>class UsersController extends Controller
</span><span>{
</span> <span>//..
</span> <span>public function index()
</span> <span>{
</span> <span>$users = User<span>::</span>where('id', '!=', auth()->user()->id)->get();
</span> <span>return view('users.index', compact('users'));
</span> <span>}
</span><span>}
</span>app / http / contrôlers / userstoller.php
La méthode a besoin d'une vue. Créons la vue utilisateurs.index et mettons ce balisage:
@<span>extends('layouts.app')
</span>
@<span>section('content')
</span> <span><div class="container">
</span> <span><div class="col-sm-offset-2 col-sm-8">
</span>
<span><!-- Following -->
</span> <span><div class="panel panel-default">
</span> <span><div class="panel-heading">
</span> All Users
<span></div>
</span>
<span><div class="panel-body">
</span> <span><table class="table table-striped task-table">
</span> <span><thead>
</span> <span><th>User</th>
</span> <span><th> </th>
</span> <span></thead>
</span> <span><tbody>
</span> @<span>foreach ($users as $user)
</span> <span><tr>
</span> <span><td clphpass="table-text"><div>{{ $user->name }}</div></td>
</span> @<span>if (auth()->user()->isFollowing($user->id))
</span> <span><td>
</span> <span><form action="{{route('unfollow', ['id' => <span><span>$user->id</span>])}}"</span> method="POST">
</span> <span>{{ csrf_field() }}
</span> <span>{{ method_field('DELETE') }}
</span>
<span><button type="submit" id="delete-follow-{{ <span><span>$user->id</span> }}"</span> class="btn btn-danger">
</span> <span><i class="fa fa-btn fa-trash"></i>Unfollow
</span> <span></button>
</span> <span></form>
</span> <span></td>
</span> @<span>else
</span> <span><td>
</span> <span><form action="{{route('follow', ['id' => <span><span>$user->id</span>])}}"</span> method="POST">
</span> <span>{{ csrf_field() }}
</span>
<span><button type="submit" id="follow-user-{{ <span><span>$user->id</span> }}"</span> class="btn btn-success">
</span> <span><i class="fa fa-btn fa-user"></i>Follow
</span> <span></button>
</span> <span></form>
</span> <span></td>
</span> @<span>endif
</span> <span></tr>
</span> @<span>endforeach
</span> <span></tbody>
</span> <span></table>
</span> <span></div>
</span> <span></div>
</span> <span></div>
</span> <span></div>
</span>@endsection
Ressources / vues / utilisateurs / index.blade.php
Vous pouvez maintenant visiter la page / utilisateurs pour voir une liste des utilisateurs.
Le contrôle des utilisateurs manque de méthodes suivant et désabonnez les méthodes. Faisons-les pour conclure cette partie.
<span>//...
</span><span>class UsersController extends Controller
</span><span>{
</span> <span>//...
</span> <span>public function follow(User $user)
</span> <span>{
</span> <span>$follower = auth()->user();
</span> <span>if ($follower->id == $user->id) {
</span> <span>return back()->withError("You can't follow yourself");
</span> <span>}
</span> <span>if(!$follower->isFollowing($user->id)) {
</span> <span>$follower->follow($user->id);
</span>
<span>// sending a notification
</span> <span>$user->notify(new UserFollowed($follower));
</span>
<span>return back()->withSuccess("You are now friends with <span><span>{$user->name}</span>"</span>);
</span> <span>}
</span> <span>return back()->withError("You are already following <span><span>{$user->name}</span>"</span>);
</span> <span>}
</span>
<span>public function unfollow(User $user)
</span> <span>{
</span> <span>$follower = auth()->user();
</span> <span>if($follower->isFollowing($user->id)) {
</span> <span>$follower->unfollow($user->id);
</span> <span>return back()->withSuccess("You are no longer friends with <span><span>{$user->name}</span>"</span>);
</span> <span>}
</span> <span>return back()->withError("You are not following <span><span>{$user->name}</span>"</span>);
</span> <span>}
</span><span>}
</span>app / http / contrôlers / userstoller.php
Nous avons terminé avec la fonctionnalité de suivi. Nous pouvons maintenant suivre et désabonner les utilisateurs de la page / utilisateurs.
Laravel fournit une API pour envoyer des notifications via plusieurs canaux. Les e-mails, les SMS, les notifications Web et tout autre type de notifications peuvent tous être envoyés en utilisant la classe de notification.
Nous allons avoir deux types de notifications:
En utilisant des commandes d'artisan, nous pouvons générer une migration pour les notifications:
<span>git clone https://github.com/vickris/simple-blog </span>
Migré et créons ce nouveau tableau.
<span>cp .env.example .env </span>
Nous commençons par des notifications suivantes. Exécutons cette commande pour générer une classe de notification:
DB_HOST=localhost DB_DATABASE=homestead DB_USERNAME=homestead DB_PASSWORD=secret
Ensuite, nous mettrons à jour le fichier de classe de notification que nous venons de créer:
<span>composer install </span>
App / Notifications / Userfolded.php
Avec ces quelques lignes de code, nous pouvons réaliser beaucoup. Nous exigeons d'abord qu'une instance du suiveur $ soit injectée lorsque cette notification est créée.
En utilisant la méthode via, nous disons à Laravel d'envoyer cette notification via le canal de la base de données. Lorsque Laravel rencontre cela, il créera un nouvel enregistrement dans le tableau des notifications.
le type user_id et la notification sont automatiquement définis, plus nous pouvons étendre la notification avec plus de données. C’est à cela que sert la todatabase. Le tableau renvoyé sera ajouté au champ de données de la notification.
Enfin, en mettant en œuvre Sourqueue, Laravel mettra automatiquement cette notification dans une file d'attente à exécuter en arrière-plan, ce qui accélérera la réponse. Cela a du sens car nous ajouterons des appels HTTP lorsque nous utiliserons Pusher plus tard.
lançons la notification lorsque l'utilisateur est suivi.
php artisan migrate <span>--seed </span>
app / http / contrôlers / userstoller.php
Nous pourrions appeler la méthode de notification sur un modèle utilisateur car il utilise déjà le trait notifiable. Tout modèle que vous souhaitez aviser doit l'utiliser pour accéder à la méthode de notification.
Les notifications contiendront des informations et un lien vers une ressource. Par exemple: lorsqu'un utilisateur reçoit une notification sur un nouveau message, la notification doit afficher un texte informatif, rediriger l'utilisateur vers le message lorsqu'il est cliqué et être signalé comme lu.
Nous allons créer un middleware qui vérifie si une demande a une entrée? Read = notification_id et l'indicateur comme lu.
Faisons un middleware avec la commande suivante:
php artisan make:migration create_followers_table <span>--create=followers </span>
Ensuite, mettons ce code à l'intérieur de la méthode de poignée du middleware:
<span>public function up()
</span><span>{
</span> <span>Schema<span>::</span>create('followers', function (Blueprint $table) {
</span> <span>$table->increments('id');
</span> <span>$table->integer('user_id')->index();
</span> <span>$table->integer('follows_id')->index();
</span> <span>$table->timestamps();
</span> <span>});
</span><span>}
</span>app / http / middleware / marknotificationAasread.php
Afin de faire en sorte que notre middleware soit exécuté pour chaque demande, nous l'ajouterons aux middlewaregroups.
<span>git clone https://github.com/vickris/simple-blog </span>
app / http / kernel.php
avec cela fait, montrons quelques notifications.
Nous devons afficher une liste des notifications à l'aide d'Ajax, puis la mettre à jour en temps réel avec Pusher. Tout d'abord, ajoutons une méthode de notifications au contrôleur:
<span>cp .env.example .env </span>
app / http / contrôlers / userstoller.php
Cela renverra les 5 dernières notifications non lues. Il nous suffit d'ajouter un itinéraire pour le rendre accessible.
DB_HOST=localhost DB_DATABASE=homestead DB_USERNAME=homestead DB_PASSWORD=secret
routes / web.php
Ajoutez maintenant une liste déroulante pour les notifications dans l'en-tête.
<span>composer install </span>
Ressources / vues / disposition / app.blade.php
Nous avons également ajouté une variable Global Window.Laravel.Userrid dans un script pour obtenir l'ID de l'utilisateur actuel.
Nous allons utiliser Laravel Mix pour compiler JavaScript et Sass. Tout d'abord, nous devons installer des packages NPM.
php artisan migrate <span>--seed </span>
Ajoutons maintenant ce code dans app.js:
php artisan make:migration create_followers_table <span>--create=followers </span>
App / Resources / Assets / JS / App.js
Ce n'est qu'une initialisation. Nous allons utiliser des notifications pour stocker tous les objets de notification, qu'ils soient récupérés via Ajax ou Pusher.
Vous l'avez probablement deviné, Notification_types contient des types de notifications.
Ensuite, «Obtenons» les notifications via Ajax.
<span>public function up()
</span><span>{
</span> <span>Schema<span>::</span>create('followers', function (Blueprint $table) {
</span> <span>$table->increments('id');
</span> <span>$table->integer('user_id')->index();
</span> <span>$table->integer('follows_id')->index();
</span> <span>$table->timestamps();
</span> <span>});
</span><span>}
</span>App / Resources / Assets / JS / App.js
Avec cela, nous obtenons les dernières notifications de notre API et les mettons à l'intérieur de la liste déroulante.
À l'intérieur des addnotifications, nous concatenons les notifications actuelles avec les nouvelles utilisant Lodash, et prenons uniquement les 5 derniers à montrer.
Nous avons besoin de quelques fonctions supplémentaires pour terminer le travail.php artisan migrate
App / Resources / Assets / JS / App.js
Cette fonction construit une chaîne de toutes les notifications et la place à l'intérieur de la liste déroulante. Si aucune notification n'a été reçue, elle montre simplement «aucune notification».
Il ajoute également une classe au bouton déroulant, qui changera simplement sa couleur lorsqu'il existe des notifications. C'est un peu comme les notifications de Github.
Enfin, certaines fonctions d'assistance pour faire des chaînes de notification.
<span>// ...
</span>
<span>class extends Authenticatable
</span><span>{
</span> <span>// ...
</span>
<span>public function followers()
</span> <span>{
</span> <span>return $this->belongsToMany(<span>self::</span>class, 'followers', 'follows_id', 'user_id')
</span> <span>->withTimestamps();
</span> <span>}
</span>
<span>public function follows()
</span> <span>{
</span> <span>return $this->belongsToMany(<span>self::</span>class, 'followers', 'user_id', 'follows_id')
</span> <span>->withTimestamps();
</span> <span>}
</span><span>}
</span>App / Resources / Assets / JS / App.js
Maintenant, nous allons simplement l'ajouter à notre fichier app.scss:
<span>// ...
</span>
<span>class extends Authenticatable
</span><span>{
</span> <span>// ...
</span>
<span>public function follow($userId)
</span> <span>{
</span> <span>$this->follows()->attach($userId);
</span> <span>return $this;
</span> <span>}
</span>
<span>public function unfollow($userId)
</span> <span>{
</span> <span>$this->follows()->detach($userId);
</span> <span>return $this;
</span> <span>}
</span>
<span>public function isFollowing($userId)
</span> <span>{
</span> <span>return (boolean) $this->follows()->where('follows_id', $userId)->first(['id']);
</span> <span>}
</span>
<span>}
</span>App / Resources / Assets / Sass / App.scss
compilons les actifs:
<span>//...
</span><span>Route<span>::</span>group(['middleware' => 'auth'], function () {
</span> <span>Route<span>::</span>get('users', 'UsersController@index')->name('users');
</span> <span>Route<span>::</span>post('users/{user}/follow', 'UsersController@follow')->name('follow');
</span> <span>Route<span>::</span>delete('users/{user}/unfollow', 'UsersController@unfollow')->name('unfollow');
</span><span>});
</span>Si vous essayez de suivre un utilisateur maintenant, il recevra une notification. Lorsqu'ils le cliquent, ils seront redirigées vers / utilisateurs, et la notification disparaîtra.
Nous allons informer les abonnés lorsqu'un utilisateur crée un nouveau message.
Commençons par générer la classe de notification.
<span>git clone https://github.com/vickris/simple-blog </span>
mettons à jour la classe générée comme suit:
<span>cp .env.example .env </span>
App / Notifications / NewArticle.php
Ensuite, nous devons envoyer la notification. Il y a plusieurs façons de le faire. J'aime utiliser des observateurs éloquents.
Faisons un observateur pour Post et écoutons ses événements. Nous allons créer une nouvelle classe: app / observateurs / postobserver.php
DB_HOST=localhost DB_DATABASE=homestead DB_USERNAME=homestead DB_PASSWORD=secret
Ensuite, enregistrez l'observateur dans AppServiceProvider:
<span>composer install </span>
App / Providers / AppServiceProvider.php
Maintenant, nous avons juste besoin de formater le message à afficher dans JS:
php artisan migrate <span>--seed </span>
App / Resources / Assets / JS / App.js
et voilà! Les utilisateurs reçoivent des notifications sur les suites et les nouveaux articles! Allez-y et essayez-le!
Il est temps d'utiliser Pusher pour obtenir des notifications en temps réel via WebSockets.
Inscrivez-vous à un compte Pusher GRATUIT sur Pusher.com et créez une nouvelle application.
php artisan make:migration create_followers_table <span>--create=followers </span>
Définissez les options de votre compte dans le fichier de configuration de la diffusion:
<span>public function up()
</span><span>{
</span> <span>Schema<span>::</span>create('followers', function (Blueprint $table) {
</span> <span>$table->increments('id');
</span> <span>$table->integer('user_id')->index();
</span> <span>$table->integer('follows_id')->index();
</span> <span>$table->timestamps();
</span> <span>});
</span><span>}
</span>config / rawlasting.php
Ensuite, nous enregistrerons AppProvidersBroadcastServiceProvider dans le tableau des fournisseurs.
php artisan migrate
config / app.php
Nous devons installer le SDK PHP de Pusher et Laravel Echo maintenant:
<span>// ...
</span>
<span>class extends Authenticatable
</span><span>{
</span> <span>// ...
</span>
<span>public function followers()
</span> <span>{
</span> <span>return $this->belongsToMany(<span>self::</span>class, 'followers', 'follows_id', 'user_id')
</span> <span>->withTimestamps();
</span> <span>}
</span>
<span>public function follows()
</span> <span>{
</span> <span>return $this->belongsToMany(<span>self::</span>class, 'followers', 'user_id', 'follows_id')
</span> <span>->withTimestamps();
</span> <span>}
</span><span>}
</span><span>// ...
</span>
<span>class extends Authenticatable
</span><span>{
</span> <span>// ...
</span>
<span>public function follow($userId)
</span> <span>{
</span> <span>$this->follows()->attach($userId);
</span> <span>return $this;
</span> <span>}
</span>
<span>public function unfollow($userId)
</span> <span>{
</span> <span>$this->follows()->detach($userId);
</span> <span>return $this;
</span> <span>}
</span>
<span>public function isFollowing($userId)
</span> <span>{
</span> <span>return (boolean) $this->follows()->where('follows_id', $userId)->first(['id']);
</span> <span>}
</span>
<span>}
</span>Nous devons définir les données de notification à diffuser. Mise à jour la notification suivante par l'utilisateur:
<span>//...
</span><span>Route<span>::</span>group(['middleware' => 'auth'], function () {
</span> <span>Route<span>::</span>get('users', 'UsersController@index')->name('users');
</span> <span>Route<span>::</span>post('users/{user}/follow', 'UsersController@follow')->name('follow');
</span> <span>Route<span>::</span>delete('users/{user}/unfollow', 'UsersController@unfollow')->name('unfollow');
</span><span>});
</span>App / Notifications / Userfolded.php
et newpost:
php artisan make:controller UsersController
App / Notifications / newpost.php
La dernière chose que nous devons faire est de mettre à jour notre JS. Ouvrir app.js et ajouter le code suivant
<span>// ...
</span><span>use App<span>\User</span>;
</span><span>class UsersController extends Controller
</span><span>{
</span> <span>//..
</span> <span>public function index()
</span> <span>{
</span> <span>$users = User<span>::</span>where('id', '!=', auth()->user()->id)->get();
</span> <span>return view('users.index', compact('users'));
</span> <span>}
</span><span>}
</span>App / Resources / Assets / JS / App.js
Et nous avons terminé ici. Des notifications sont ajoutées en temps réel. Vous pouvez maintenant jouer avec l'application et voir comment les notifications sont mises à jour.
Pusher a une API très simple qui facilite la réception des événements en temps réel. Couplé aux notifications de Laravel, nous pourrions envoyer une notification via plusieurs canaux (e-mail, SMS, Slack, etc.) à partir d'un seul endroit. Dans ce tutoriel, nous avons ajouté des fonctionnalités de suivi des utilisateurs à un blog simple et l'ont améliorée avec les outils susmentionnés pour obtenir des fonctionnalités en temps réel fluide.
Il y a beaucoup plus à Pusher et aux notifications Laravel: en tandem, les services vous permettent d'envoyer des messages Pub / sous en temps réel aux navigateurs, mobiles et appareils IoT. Il existe également une API de présence pour obtenir le statut en ligne / hors ligne des utilisateurs.
Veuillez vérifier leurs documentations respectives (Pusher Docs, Pusher Tutorials, Laravel Docs) pour les explorer plus en profondeur et utiliser leur véritable potentiel.
Laissez-moi entendre ce que vous avez construit avec ces technologies dans les commentaires.
Les problèmes de dépannage avec l'intégration Laravel et Pusher peuvent être un peu délicats, surtout si vous êtes nouveau sur la plate-forme. La première chose que vous devez faire est de vérifier votre fichier .env pour vous assurer que les informations d'identification de l'application Pusher sont correctement saisies. Si les informations d'identification sont correctes, vous pouvez utiliser la console de débogage du poussoir pour vérifier les erreurs. Si vous rencontrez toujours des problèmes, vous pouvez utiliser la fonction de journalisation intégrée de Laravel pour enregistrer toutes les erreurs qui se produisent pendant le processus de diffusion. Cela peut vous aider à déterminer exactement où le problème se produit.
Oui, vous pouvez utiliser Laravel et Pusher pour les notifications mobiles. Pusher fournit une API REST que vous pouvez utiliser pour envoyer des notifications aux appareils mobiles. Vous pouvez utiliser la fonction de diffusion des événements de Laravel pour déclencher ces notifications. Lorsqu'un événement est diffusé, vous pouvez l'attraper dans votre application mobile et afficher la notification.
La personnalisation de l'apparence de vos notifications est effectuée sur côté client, pas sur le côté du serveur. Cela signifie que vous devrez utiliser JavaScript, CSS ou toute autre technologie côté client pour personnaliser vos notifications. Pusher fournit une bibliothèque JavaScript que vous pouvez utiliser pour écouter les événements et afficher les notifications. Vous pouvez utiliser cette bibliothèque en combinaison avec votre propre CSS pour personnaliser l'apparence de vos notifications.
Le test de votre intégration Laravel et Pusher peut être effectuée en utilisant les fonctionnalités de test intégrées de Laravel. Vous pouvez rédiger un test qui déclenche un événement, puis utiliser la console de débogage Pusher pour vérifier si l'événement a été diffusé. Vous pouvez également rédiger des tests pour vérifier si vos auditeurs d'événements fonctionnent correctement.
La sécurisation de votre intégration Laravel et Pusher est cruciale pour empêcher un accès non autorisé à vos données. Vous pouvez sécuriser votre intégration en utilisant des canaux privés. Les canaux privés nécessitent une authentification, ce qui signifie que seuls les utilisateurs autorisés peuvent s'abonner à eux. Vous pouvez implémenter l'authentification à l'aide des fonctionnalités d'authentification intégrées de Laravel.
Oui, vous pouvez utiliser Laravel et Pusher pour le chat en temps réel applications. Pusher fournit des fonctionnalités en temps réel que vous pouvez utiliser pour envoyer et recevoir des messages instantanément. Vous pouvez utiliser la fonction de diffusion des événements de Laravel pour déclencher ces messages.
Les erreurs de traitement dans votre intégration Laravel et Pusher peuvent être effectuées en utilisant les fonctionnalités de gestion des erreurs intégrées de Laravel. Vous pouvez faire des exceptions qui se produisent pendant le processus de diffusion et les gérer en conséquence. Vous pouvez également utiliser la console Pusher Debug pour vérifier les erreurs.
Optimisation de votre intégration Laravel et Pusher peut être effectuée en réduisant le nombre de événements que vous diffusez. La diffusion trop d'événements peut ralentir votre application et consommer beaucoup de ressources. Vous pouvez également optimiser votre intégration en utilisant le système de files d'attente de Laravel pour gérer les événements en arrière-plan.
Oui, vous pouvez utiliser Laravel et Pusher pour applications de streaming en direct. Pusher fournit des fonctionnalités en temps réel que vous pouvez utiliser pour diffuser des flux vidéo en direct. Vous pouvez utiliser la fonction de diffusion d'événements de Laravel pour déclencher ces flux.
La surveillance de votre intégration Laravel et Pusher peut être effectuée à l'aide des fonctionnalités d'analyse de Pusher. Vous pouvez utiliser ces fonctionnalités pour suivre le nombre de messages que vous envoyez, le nombre de connexions dont vous disposez et d'autres mesures importantes. Vous pouvez également utiliser la fonction de journalisation intégrée de Laravel pour enregistrer toutes les erreurs qui se produisent pendant le processus de radiodiffusion.
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!
Comment ouvrir un fichier zip
Quelle interface est audio ?
Introduction aux raisons pour lesquelles le bureau à distance ne peut pas se connecter
Pendant combien d'années faut-il payer une assurance maladie pour bénéficier d'une assurance médicale à vie ?
Qu'est-ce que Spring MVC
odm
Où est la lampe de poche du téléphone OnePlus ?
Utilisation de la commande source sous Linux
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
