Get best of the week

So fügen Sie Laravel mithilfe von Pusher Echtzeitbenachrichtigungen hinzu

Eine Übersetzung des Artikels wurde speziell für Studenten des Kurses „Framework Laravel“ erstellt .



Ein moderner Webbenutzer erwartet, über alles informiert zu werden, was in der Anwendung geschieht. Sie möchten nicht die Website sein, die nicht einmal eine Dropdown-Liste mit Benachrichtigungen enthält, die jetzt nicht nur auf allen Websites sozialer Netzwerke, sondern heutzutage im Allgemeinen überall zu finden ist.

Glücklicherweise ist die Implementierung dieser Funktionalität mit Laravel und Pusher recht einfach.

Echtzeitbenachrichtigungen


Um eine positive Benutzererfahrung zu erzielen, sollten Benachrichtigungen in Echtzeit angezeigt werden. Ein Ansatz besteht darin, regelmäßig eine AJAX-Anfrage an den Server zu senden und gegebenenfalls die neuesten Benachrichtigungen zu erhalten.

Der beste Ansatz besteht darin, die Funktionen von WebSockets zu nutzen und Benachrichtigungen zu erhalten, wenn diese gesendet werden. Genau das werden wir in diesem Artikel implementieren.

Pusher


Pusher ist ein Webdienst zur Integration bidirektionaler Echtzeitfunktionen über WebSockets in Web- und mobile Anwendungen.

Es hat eine sehr einfache API, aber wir werden es mit Laravel Broadcasting und Laravel Echo noch einfacher machen.

In diesem Artikel werden wir einem vorhandenen Blog Echtzeitbenachrichtigungen hinzufügen.

Projekt


Initialisierung


Zuerst klonen wir einen einfachen Laravel-Blog:

git clone   https://github.com/marslan-ali/laravel-blog

Anschließend erstellen wir die MySQL-Datenbank und richten die Umgebungsvariablen ein, um der Anwendung Zugriff auf die Datenbank zu gewähren.

Lassen Sie uns Kopie env.examplein .envund aktualisieren Sie die Variablen mit der Datenbank verbunden.

cp .env.example .envDB_HOST=localhost
DB_DATABASE=homestead
DB_USERNAME=homestead
DB_PASSWORD=secret

Lassen Sie uns nun die Projektabhängigkeiten mit installieren

composer install

Führen Sie den Befehl Migration und Auffüllen aus, um die Datenbank mit einigen Daten zu füllen:

php artisan migrate --seed

Wenn Sie die Anwendung ausführen und zu gehen, /postswird eine Liste der generierten Beiträge angezeigt.

Überprüfen Sie die Anwendung, registrieren Sie den Benutzer und erstellen Sie einige Nachrichten. Dies ist eine sehr einfache Anwendung, die sich jedoch hervorragend zur Demonstration eignet.

Benutzer abonnieren


Wir möchten den Benutzern die Möglichkeit geben, sich gegenseitig zu abonnieren. Daher müssen wir eine Viele-zu-Viele-Beziehung zwischen Benutzern herstellen, um dies zu realisieren.

Erstellen wir eine Pivot-Tabelle, die Benutzer mit Benutzern verknüpft. Lassen Sie uns eine neue Migration durchführen followers:

php artisan make:migration create_followers_table --create=followers

Wir müssen dieser Migration mehrere Felder hinzufügen: user_idum den abonnierten Benutzer darzustellen, und ein Feld follows_id, um den Benutzer darzustellen, den sie abonniert haben.

Aktualisieren Sie die Migration wie folgt:

public function up()
{
    Schema::create('followers', function (Blueprint $table) {
        $table->increments('id');
        $table->integer('user_id')->index();
        $table->integer('follows_id')->index();
        $table->timestamps();
    });
}

Fahren wir nun mit der Erstellung der Tabelle fort:

php artisan migrate

Fügen wir dem Modell Beziehungsmethoden hinzu User.

// ...

class extends Authenticatable
{
    // ...

    public function followers() 
    {
        return $this->belongsToMany(self::class, 'followers', 'follows_id', 'user_id')
                    ->withTimestamps();
    }

    public function follows() 
    {
        return $this->belongsToMany(self::class, 'followers', 'user_id', 'follows_id')
                    ->withTimestamps();
    }
}

Nachdem das Modell Userüber die erforderlichen Beziehungen verfügt, gibt es followersalle Abonnenten des Benutzers und followsalle Abonnenten des Benutzers zurück.

Wir benötigen einige Zusatzfunktionen, mit denen der Benutzer andere Benutzer abonnieren followund prüfen kann, ob der Benutzer einen bestimmten Benutzer abonniert hat isFollowing.

// ...

class extends Authenticatable
{
    // ...

    public function follow($userId) 
    {
        $this->follows()->attach($userId);
        return $this;
    }

    public function unfollow($userId)
    {
        $this->follows()->detach($userId);
        return $this;
    }

    public function isFollowing($userId) 
    {
        return (boolean) $this->follows()->where('follows_id', $userId)->first(['id']);
    }

}

Fein. Nach der Vorbereitung des Modells müssen Sie eine Liste der Benutzer erstellen.

eine Liste der Benutzer


Beginnen wir mit der Identifizierung der erforderlichen Routen.

/...
Route::group(['middleware' => 'auth'], function () {
    Route::get('users', 'UsersController@index')->name('users');
    Route::post('users/{user}/follow', 'UsersController@follow')->name('follow');
    Route::delete('users/{user}/unfollow', 'UsersController@unfollow')->name('unfollow');
});

Dann ist es Zeit, einen neuen Controller für Benutzer zu erstellen:

php artisan make:controller UsersController

Wir werden eine Methode hinzufügen index:

// ...
use App\User;
class UsersController extends Controller
{
    //..
    public function index()
    {
        $users = User::where('id', '!=', auth()->user()->id)->get();
        return view('users.index', compact('users'));
    }
}

Die Methode muss eingeführt werden. Erstellen wir eine Ansicht users.indexund fügen das folgende Markup hinzu:

@extends('layouts.app')

@section('content')
    <div class="container">
        <div class="col-sm-offset-2 col-sm-8">

            <!-- Following -->
            <div class="panel panel-default">
                <div class="panel-heading">
                    All Users
                </div>

                <div class="panel-body">
                    <table class="table table-striped task-table">
                        <thead>
                        <th>User</th>
                        <th> </th>
                        </thead>
                        <tbody>
                        @foreach ($users as $user)
                            <tr>
                                <td clphpass="table-text"><div>{{ $user->name }}</div></td>
                                @if (auth()->user()->isFollowing($user->id))
                                    <td>
                                        <form action="{{route('unfollow', ['id' => $user->id])}}" method="POST">
                                            {{ csrf_field() }}
                                            {{ method_field('DELETE') }}

                                            <button type="submit" id="delete-follow-{{ $user->id }}" class="btn btn-danger">
                                                <i class="fa fa-btn fa-trash"></i>Unfollow
                                            </button>
                                        </form>
                                    </td>
                                @else
                                    <td>
                                        <form action="{{route('follow', ['id' => $user->id])}}" method="POST">
                                            {{ csrf_field() }}

                                            <button type="submit" id="follow-user-{{ $user->id }}" class="btn btn-success">
                                                <i class="fa fa-btn fa-user"></i>Follow
                                            </button>
                                        </form>
                                    </td>
                                @endif
                            </tr>
                        @endforeach
                        </tbody>
                    </table>
                </div>
            </div>
        </div>
    </div>
@endsection

Jetzt können Sie die Seite besuchen /users, um die Liste der Benutzer anzuzeigen.

Folgen und nicht mehr folgen


In UsersControllerfehlenden Methoden followund unfollow. Lassen Sie uns sie implementieren, um diesen Teil zu vervollständigen.

//...
class UsersController extends Controller
{
    //...

    public function follow(User $user)
    {
        $follower = auth()->user();
        if ($follower->id == $user->id) {
            return back()->withError("You can't follow yourself");
        }
        if(!$follower->isFollowing($user->id)) {
            $follower->follow($user->id);

            //  
            $user->notify(new UserFollowed($follower));

            return back()->withSuccess("You are now friends with {$user->name}");
        }
        return back()->withError("You are already following {$user->name}");
    }

    public function unfollow(User $user)
    {
        $follower = auth()->user();
        if($follower->isFollowing($user->id)) {
            $follower->unfollow($user->id);
            return back()->withSuccess("You are no longer friends with {$user->name}");
        }
        return back()->withError("You are not following {$user->name}");
    }
}

Wir sind mit dieser Funktionalität fertig. Jetzt können wir Benutzer abonnieren und sie auf der Seite abbestellen /users.

Benachrichtigungen


Laravel bietet eine API zum Senden von Benachrichtigungen über mehrere Kanäle. E-Mail, SMS, Webbenachrichtigungen und andere Arten von Benachrichtigungen können mithilfe der Benachrichtigungsklasse gesendet werden .

Wir werden zwei Arten von Benachrichtigungen haben:

  • Abonnementbenachrichtigung: Wird an den Benutzer gesendet, wenn ein anderer Benutzer ihn abonniert
  • Post-Benachrichtigung: Wird an Abonnenten dieses Benutzers gesendet, wenn ein neuer Post veröffentlicht wird.

Abonnementbenachrichtigung


Mit handwerklichen Befehlen können wir eine Migration für Benachrichtigungen generieren:

php artisan notifications:table

Lassen Sie uns die Migration durchführen und diese Tabelle erstellen.

php artisan migrate

Wir beginnen mit Abonnementbenachrichtigungen. Führen Sie diesen Befehl aus, um eine Benachrichtigungsklasse zu erstellen:

php artisan make:notification UserFollowed

Dann ändern wir die gerade erstellte Benachrichtigungsklassendatei:

class UserFollowed extends Notification implements ShouldQueue
{
    use Queueable;

    protected $follower;

    public function __construct(User $follower)
    {
        $this->follower = $follower;
    }

    public function via($notifiable)
    {
        return ['database'];
    }

    public function toDatabase($notifiable)
    {
        return [
            'follower_id' => $this->follower->id,
            'follower_name' => $this->follower->name,
        ];
    }
}

Mit diesen wenigen Codezeilen können wir bereits viel erreichen. Zunächst muss die Instanz $followerimplementiert werden, wenn diese Benachrichtigung generiert wird.

Mit dieser Methode viaweisen wir Laravel an, diese Benachrichtigung über den Kanal zu senden database. Wenn Laravel darauf stößt, wird ein neuer Eintrag in der Benachrichtigungstabelle erstellt.

user_idund typeBenachrichtigungen werden automatisch festgelegt, und wir können die Benachrichtigung um zusätzliche Daten erweitern. Dafür ist es da toDatabase. Das zurückgegebene Array wird dem dataBenachrichtigungsfeld hinzugefügt .

Und schließlich dank der ImplementierungShouldQueueLaravel stellt diese Benachrichtigung automatisch in eine Warteschlange, die im Hintergrund ausgeführt wird, wodurch die Antwort beschleunigt wird. Dies ist sinnvoll, da wir HTTP-Aufrufe hinzufügen, wenn wir Pusher später verwenden.

Lassen Sie uns eine Benutzerabonnementbenachrichtigung implementieren.

// ...
use App\Notifications\UserFollowed;
class UsersController extends Controller
{
    // ...
    public function follow(User $user)
    {
        $follower = auth()->user();
        if ( ! $follower->isFollowing($user->id)) {
            $follower->follow($user->id);

            //  ,   
            $user->notify(new UserFollowed($follower));

            return back()->withSuccess("You are now friends with {$user->name}");
        }

        return back()->withSuccess("You are already following {$user->name}");
    }

    //...
}

Wir können die Benachrichtigungsmethode für das Benutzermodell aufrufen, da sie bereits das Merkmal Benachrichtigbar verwendet.

Jedes Modell, das Sie benachrichtigen möchten, sollte es verwenden, um Zugriff auf die Benachrichtigungsmethode zu erhalten.

Wir markieren die Benachrichtigung als gelesen.

Benachrichtigungen enthalten einige Informationen und einen Link zur Ressource. Beispiel: Wenn der Benutzer eine Benachrichtigung über eine neue Nachricht erhält, sollte die Benachrichtigung informativen Text enthalten, den Benutzer beim Drücken auf die Nachricht umleiten und als gelesen markiert werden.

Wir werden eine Ebene erstellen, die prüft, ob die Anforderung vorhanden ist, ?read=notification_idund sie als gelesen markiert.

Lassen Sie uns diese Ebene mit dem folgenden Befehl erstellen:

php artisan make:middleware MarkNotificationAsRead

Dann fügen wir diesen Code in die handleInterlayer- Methode ein :

class MarkNotificationAsRead
{
    public function handle($request, Closure $next)
    {
        if($request->has('read')) {
            $notification = $request->user()->notifications()->where('id', $request->read)->first();
            if($notification) {
                $notification->markAsRead();
            }
        }
        return $next($request);
    }
}

Damit unsere Ebene für jede Anforderung ausgeführt werden kann, fügen wir sie hinzu $middlewareGroups.

//...
class Kernel extends HttpKernel
{
    //...
    protected $middlewareGroups = [
        'web' => [
            //...
            \App\Http\Middleware\MarkNotificationAsRead::class,
        ],
        // ...
    ];
    //...
}

Danach werden die Benachrichtigungen angezeigt.

Benachrichtigungen anzeigen


Wir müssen die Benachrichtigungsliste mit AJAX anzeigen und sie dann mit Pusher in Echtzeit aktualisieren. Fügen wir notificationszunächst dem Controller eine Methode hinzu :

// ...
class UsersController extends Controller
{
    // ...
    public function notifications()
    {
        return auth()->user()->unreadNotifications()->limit(5)->get()->toArray();
    }
}

Dieser Code gibt die letzten 5 ungelesenen Benachrichtigungen zurück. Wir müssen nur eine Route hinzufügen, um sie zugänglich zu machen.

//...
Route::group([ 'middleware' => 'auth' ], function () {
    // ...
    Route::get('/notifications', 'UsersController@notifications');
});

Fügen Sie nun eine Dropdown-Liste für Benachrichtigungen in die Kopfzeile ein.

<head>
    <!-- // ... // -->
    <!-- Scripts -->
    <script>
        window.Laravel = <?php echo json_encode([
            'csrfToken' => csrf_token(),
        ]); ?>
    </script>
    <!--   id     JavaScript -->
    @if(!auth()->guest())
        <script>
            window.Laravel.userId = <?php echo auth()->user()->id; ?>
        </script>
    @endif
</head>
<body>
    <!-- // ... // -->
    @if (Auth::guest())
        <li><a href="{{ url('/login') }}">Login</a></li>
        <li><a href="{{ url('/register') }}">Register</a></li>
    @else
        <!-- // add this dropdown // -->
        <li class="dropdown">
            <a class="dropdown-toggle" id="notifications" data-toggle="dropdown" aria-haspopup="true" aria-expanded="true">
                <span class="glyphicon glyphicon-user"></span>
            </a>
            <ul class="dropdown-menu" aria-labelledby="notificationsMenu" id="notificationsMenu">
                <li class="dropdown-header">No notifications</li>
            </ul>
        </li>
<!-- // ... // -->

Wir haben window.Laravel.userIddem Skript auch eine globale Variable hinzugefügt , um die aktuelle Benutzer-ID abzurufen.

JavaScript und SASS


Wir werden Laravel Mix verwenden, um JavaScript und SASS zu kompilieren. Zuerst müssen wir npm-Pakete installieren.

npm install

Fügen wir diesen Code nun hinzu zu app.js:

window._ = require('lodash');
window.$ = window.jQuery = require('jquery');
require('bootstrap-sass');
var notifications = [];
const NOTIFICATION_TYPES = {
    follow: 'App\\Notifications\\UserFollowed'
};

Dies ist nur eine Initialisierung. Wir werden Benachrichtigungen verwenden, um alle Benachrichtigungsobjekte zu speichern, unabhängig davon, ob sie über AJAX oder Pusher abgerufen werden.

Wie Sie wahrscheinlich bereits vermutet haben, NOTIFICATION_TYPESenthält es Benachrichtigungstypen.

Lassen Sie uns jetzt Benachrichtigungen über AJAX erhalten ("GET").

//...
$(document).ready(function() {
    // ,      
    if(Laravel.userId) {
        $.get('/notifications', function (data) {
            addNotifications(data, "#notifications");
        });
    }
});
function addNotifications(newNotifications, target) {
    notifications = _.concat(notifications, newNotifications);
    //    5 
    notifications.slice(0, 5);
    showNotifications(notifications, target);
}

Dank dieses Codes erhalten wir die neuesten Benachrichtigungen von unserer API und fügen sie in eine Dropdown-Liste ein.

Im Inneren addNotificationskombinieren wir vorhandene Benachrichtigungen mit neuen mithilfe von Lodash und nehmen nur die letzten 5, die angezeigt werden.

Wir brauchen noch ein paar Funktionen, um den Job zu beenden.

//...
function showNotifications(notifications, target) {
    if(notifications.length) {
        var htmlElements = notifications.map(function (notification) {
            return makeNotification(notification);
        });
        $(target + 'Menu').html(htmlElements.join(''));
        $(target).addClass('has-notifications')
    } else {
        $(target + 'Menu').html('<li class="dropdown-header">No notifications</li>');
        $(target).removeClass('has-notifications');
    }
}

Diese Funktion erstellt eine Zeile aller Benachrichtigungen und platziert sie in der Dropdown-Liste.
Wenn keine Benachrichtigungen eingegangen sind, wird einfach "Keine Benachrichtigungen" angezeigt.

Außerdem wird der Dropdown-Schaltfläche eine Klasse hinzugefügt, die bei Benachrichtigungen einfach die Farbe ändert. Ein bisschen wie Github-Benachrichtigungen.

Schließlich einige Hilfsfunktionen zum Erstellen von Benachrichtigungszeichenfolgen.

//...
//   
function makeNotification(notification) {
    var to = routeNotification(notification);
    var notificationText = makeNotificationText(notification);
    return '<li><a href="' + to + '">' + notificationText + '</a></li>';
}
//        
function routeNotification(notification) {
    var to = '?read=' + notification.id;
    if(notification.type === NOTIFICATION_TYPES.follow) {
        to = 'users' + to;
    }
    return '/' + to;
}
//        
function makeNotificationText(notification) {
    var text = '';
    if(notification.type === NOTIFICATION_TYPES.follow) {
        const name = notification.data.follower_name;
        text += '<strong>' + name + '</strong> followed you';
    }
    return text;
}

Jetzt fügen wir dies einfach unserer Datei hinzu app.scss:

//... 
#notifications.has-notifications {
  color: #bf5329
}

Lassen Sie uns die Assets zusammenstellen:

npm run dev

Wenn Sie nun versuchen, einen Benutzer zu abonnieren, erhält er eine Benachrichtigung. Wenn er darauf klickt, wird er zu weitergeleitet /usersund die Benachrichtigung selbst verschwindet.

Neue Post-Benachrichtigung


Wir werden Abonnenten benachrichtigen, wenn ein Benutzer einen neuen Beitrag veröffentlicht.

Beginnen wir mit der Erstellung einer Benachrichtigungsklasse.

php artisan make:notification NewPost

Ändern wir die generierte Klasse wie folgt:

// ..
use App\Post;
use App\User;
class NewArticle extends Notification implements ShouldQueue
{
    // ..
    protected $following;
    protected $post;
    public function __construct(User $following, Post $post)
    {
        $this->following = $following;
        $this->post = $post;
    }
    public function via($notifiable)
    {
        return ['database'];
    }
    public function toDatabase($notifiable)
    {
        return [
            'following_id' => $this->following->id,
            'following_name' => $this->following->name,
            'post_id' => $this->post->id,
        ];
    }
}

Als nächstes müssen wir eine Benachrichtigung senden. Es gibt verschiedene Möglichkeiten, dies zu tun.

Ich benutze gerne eloquente Beobachter.

Lassen Sie uns einen Beobachter für die Post erstellen und ihre Ereignisse anhören. Wir werden eine neue Klasse erstellen:app/Observers/PostObserver.php

namespace App\Observers;
use App\Notifications\NewPost;
use App\Post;
class PostObserver
{
    public function created(Post $post)
    {
        $user = $post->user;
        foreach ($user->followers as $follower) {
            $follower->notify(new NewPost($user, $post));
        }
    }
}

Dann registrieren Sie den Beobachter in AppServiceProvider:

//...
use App\Observers\PostObserver;
use App\Post;
class AppServiceProvider extends ServiceProvider
{
    //...
    public function boot()
    {
        Post::observe(PostObserver::class);
    }
    //...
}

Jetzt müssen wir nur noch die Nachricht für die Anzeige in JS formatieren:

// ...
const NOTIFICATION_TYPES = {
    follow: 'App\\Notifications\\UserFollowed',
    newPost: 'App\\Notifications\\NewPost'
};
//...
function routeNotification(notification) {
    var to = `?read=${notification.id}`;
    if(notification.type === NOTIFICATION_TYPES.follow) {
        to = 'users' + to;
    } else if(notification.type === NOTIFICATION_TYPES.newPost) {
        const postId = notification.data.post_id;
        to = `posts/${postId}` + to;
    }
    return '/' + to;
}
function makeNotificationText(notification) {
    var text = '';
    if(notification.type === NOTIFICATION_TYPES.follow) {
        const name = notification.data.follower_name;
        text += `<strong>${name}</strong> followed you`;
    } else if(notification.type === NOTIFICATION_TYPES.newPost) {
        const name = notification.data.following_name;
        text += `<strong>${name}</strong> published a post`;
    }
    return text;
}

Und voila! Benutzer werden über Abonnements und neue Beiträge informiert! Versuch es selber!

Beenden Sie in Echtzeit mit Pusher


Es ist Zeit, Pusher zu verwenden, um Echtzeitbenachrichtigungen über Web-Sockets zu erhalten.

Registrieren Sie sich für ein kostenloses Pusher-Konto bei pusher.com und erstellen Sie eine neue App.

...
BROADCAST_DRIVER=pusher
PUSHER_KEY=
PUSHER_SECRET=
PUSHER_APP_ID=

Legen Sie die Parameter für Ihr Konto in der Konfigurationsdatei fest broadcasting:

//...
    'connections' => [
            'pusher' => [
                //...
                'options' => [
                    'cluster' => 'eu',
                    'encrypted' => true
                ],
            ],
    //...

Dann werden wir uns App\Providers\BroadcastServiceProviderim Array registrieren providers.

// ...
'providers' => [
    // ...
    App\Providers\BroadcastServiceProvider
    //...
],
//...

Jetzt müssen wir das PHP SDK und Laravel Echo von Pusher installieren:

composer require pusher/pusher-php-server
npm install --save laravel-echo pusher-js

Wir müssen Benachrichtigungsdaten für die Übertragung einrichten. Lassen Sie uns die Benachrichtigung ändern UserFollowed:

//...
class UserFollowed extends Notification implements ShouldQueue
{
    // ..
    public function via($notifiable)
    {
        return ['database', 'broadcast'];
    }
    //...
    public function toArray($notifiable)
    {
        return [
            'id' => $this->id,
            'read_at' => null,
            'data' => [
                'follower_id' => $this->follower->id,
                'follower_name' => $this->follower->name,
            ],
        ];
    }
}

Und NewPost:

//...
class NewPost extends Notification implements ShouldQueue
{
    //...
    public function via($notifiable)
    {
        return ['database', 'broadcast'];
    }
    //...
    public function toArray($notifiable)
    {
        return [
            'id' => $this->id,
            'read_at' => null,
            'data' => [
                'following_id' => $this->following->id,
                'following_name' => $this->following->name,
                'post_id' => $this->post->id,
            ],
        ];
    }
}

Das Letzte, was wir tun müssen, ist unser JS zu aktualisieren. Öffnen app.jsSie den folgenden Code und fügen Sie ihn hinzu

// ...
window.Pusher = require('pusher-js');
import Echo from "laravel-echo";
window.Echo = new Echo({
    broadcaster: 'pusher',
    key: 'your-pusher-key',
    cluster: 'eu',
    encrypted: true
});
var notifications = [];
//...
$(document).ready(function() {
    if(Laravel.userId) {
        //...
        window.Echo.private(`App.User.${Laravel.userId}`)
            .notification((notification) => {
                addNotifications([notification], '#notifications');
            });
    }
});

Und das ist alles. Benachrichtigungen werden in Echtzeit hinzugefügt. Jetzt können Sie mit der Anwendung spielen und sehen, wie Benachrichtigungen aktualisiert werden.

Fazit


Pusher verfügt über eine sehr benutzerfreundliche API, die die Implementierung von Ereignissen in Echtzeit unglaublich einfach macht. In Kombination mit Laravel-Benachrichtigungen können wir Benachrichtigungen über mehrere Kanäle (E-Mail, SMS, Slack usw.) von einem Ort aus senden. In diesem Handbuch haben wir Funktionen zum Verfolgen der Benutzeraktivität in einem einfachen Blog hinzugefügt und diese mithilfe der oben genannten Tools verbessert, um reibungslose Echtzeitfunktionen zu erhalten.

Pusher und Laravel haben viel mehr Benachrichtigungen: Mit Tandem-Diensten können Sie Pub- / Sub-Nachrichten in Echtzeit an Browser, Mobiltelefone und IOT-Geräte senden. Es gibt auch eine API zum Abrufen des Online- / Offline-Benutzerstatus.

Bitte beachten Sie deren Dokumentation ( Pusher-Dokumente, Pusher-Tutorials , Laravel-Dokumente ), um mehr über ihre Verwendung und ihr wahres Potenzial zu erfahren.

Wenn Sie Kommentare, Fragen oder Empfehlungen haben, können Sie diese gerne in den Kommentaren unten teilen!


Erfahren Sie mehr über den Kurs.

More articles:


All Articles