Mit Laravel Scout die Volltextsuche aktivieren

Das Laravel-Framework hat sich zu einer wichtigen Ressource für Entwickler entwickelt, die Webservices erstellen.

Als Open-Source-Tool bietet Laravel eine Vielzahl von Out-of-the-Box-Funktionen, mit denen Entwickler robuste und funktionale Anwendungen erstellen können.

Dazu gehört auch Laravel Scout, eine Bibliothek zur Verwaltung der Suchindizes für deine Anwendung. Dank ihrer Flexibilität können Entwickler die Konfigurationen fein abstimmen und zwischen Algolia-, Meilisearch-, MySQL- oder Postgres-Treibern für die Speicherung der Indizes wählen.

In diesem Artikel werden wir dieses Tool genauer unter die Lupe nehmen und dir zeigen, wie du eine Laravel-Anwendung mit Hilfe des Treibers um eine Volltextsuche erweitern kannst. Du wirst eine Demo-Laravel-Anwendung modellieren, um den Namen von Mockup-Zügen zu speichern und dann Laravel Scout verwenden, um der Anwendung eine Suche hinzuzufügen.

Voraussetzungen

Um mitzumachen, solltest du Folgendes mitbringen:

• Der PHP-Compiler sollte auf deinem Computer installiert sein. Dieses Tutorial verwendet die PHP-Version 8.1.
• Die Docker-Engine oder Docker Desktop auf deinem Computer installiert haben
• Ein Algolia-Cloud-Konto, das du kostenlos erstellen kannst

So installierst du Scout in einem Laravel-Projekt

Um Scout zu nutzen, musst du zunächst eine Laravel-Anwendung erstellen, in die du die Suchfunktion einbauen willst. Das Laravel-Scout Bash-Skript enthält die Befehle, um eine Laravel-Anwendung in einem Docker-Container zu erstellen. Die Verwendung von Docker bedeutet, dass du keine zusätzliche unterstützende Software wie eine MySQL-Datenbank installieren musst.

Das Laravel-Scout-Skript verwendet die Skriptsprache Bash, du musst es also in einer Linux-Umgebung ausführen. Wenn du mit Windows arbeitest, musst du das Windows Subsystem für Linux (WSL) konfigurieren.

Wenn du WSL verwendest, führe den folgenden Befehl in deinem Terminal aus, um deine bevorzugte Linux-Distribution einzustellen.

wsl -s ubuntu

Als Nächstes navigierst du zu dem Ort auf deinem Computer, an dem du das Projekt ablegen möchtest. Das Laravel-Scout-Skript wird hier ein Projektverzeichnis erstellen. Im folgenden Beispiel würde das Laravel-Scout-Skript ein Verzeichnis innerhalb des Desktop-Verzeichnisses erstellen.

cd /desktop

Führe den unten stehenden Befehl aus, um das Laravel-Scout-Skript auszuführen. Es wird eine Docker-Anwendung mit dem notwendigen Boilerplate-Code erstellen.

curl -s https://laravel.build/laravel-scout-app | bash

Nach der Ausführung wechselst du mit cd laravel-scout-app in dein Verzeichnis. Führe dann den Befehl sail-up im Projektordner aus, um die Docker-Container für deine Anwendung zu starten.

Hinweis: Bei vielen Linux-Distributionen musst du den unten stehenden Befehl möglicherweise mit dem Befehl sudo ausführen, um erweiterte Rechte zu erhalten.

./vendor/bin/sail up

Es kann sein, dass du eine Fehlermeldung erhältst:

Um dieses Problem zu beheben, verwende die Variable APP_PORT, um einen Port im Befehl sail up anzugeben:

APP_PORT=3001 ./vendor/bin/sail up

Als Nächstes führst du den folgenden Befehl aus, um die Anwendung über Artisan auf dem PHP-Server auszuführen.

php artisan serve

Navigiere mit deinem Webbrowser zu der laufenden Anwendung unter http://127.0.0.1:8000. Die Anwendung zeigt die Laravel-Begrüßungsseite über die Standardroute an.

So fügst du Laravel Scout zu deiner Anwendung hinzu

Gib in deinem Terminal den Befehl ein, um den Composer PHP-Paketmanager zu aktivieren und Laravel Scout zu deinem Projekt hinzuzufügen.

composer require laravel/scout

Als Nächstes veröffentlichst du die Scout-Konfigurationsdatei mit dem Befehl vendor:publish. Mit diesem Befehl wird die Konfigurationsdatei scout.php im config-Verzeichnis deiner Anwendung veröffentlicht.

 php artisan vendor:publish --provider="Laravel\Scout\ScoutServiceProvider"

Ändere nun die Boilerplate-Datei .env so, dass sie einen booleschen Wert SCOUT_QUEUE enthält.

Der Wert SCOUT_QUEUE ermöglicht es Scout, Operationen in eine Warteschlange zu stellen und damit die Reaktionszeiten zu verbessern. Ohne diesen Wert werden Scout-Treiber wie Meilisearch neue Datensätze nicht sofort anzeigen.

SCOUT_QUEUE=true

Ändere außerdem die Variable DB_HOST in der .env-Datei so, dass sie auf deinen Localhost zeigt, um die MySQL-Datenbank in den Docker-Containern zu verwenden.

DB_HOST=127.0.0.1

So markierst du ein Modell und konfigurierst den Index

Scout aktiviert standardmäßig keine durchsuchbaren Datenmodelle. Du musst ein Modell explizit als durchsuchbar markieren, indem du seine Laravel\Scout\Searchable Eigenschaft verwendest.

Du beginnst mit der Erstellung eines Datenmodells für eine Train Demo-Anwendung und markierst es als durchsuchbar.

So erstellst du ein Modell

Für die Anwendung Train möchtest du die Platzhalternamen der einzelnen verfügbaren Züge speichern.

Führe den folgenden Artisan-Befehl aus, um die Migration zu erstellen und nenne sie create_trains_table.

php artisan make:migration create_trains_table 

Die Migration wird in einer Datei erstellt, deren Name sich aus dem angegebenen Namen und dem aktuellen Zeitstempel zusammensetzt.

Öffne die Migrationsdatei, die sich im Verzeichnis database/migrations/ befindet.

Um eine Titelspalte hinzuzufügen, füge den folgenden Code nach der Spalte id() in Zeile 17 ein. Der Code fügt eine Titelspalte hinzu.

$table->string('title');

Um die Migration anzuwenden, führe den folgenden Befehl aus.

php artisan migrate

Nachdem du die Datenbankmigrationen ausgeführt hast, erstelle eine Datei namens Train.php im Verzeichnis app/Models/.

So fügst du die Eigenschaft Laravel\Scout\Searchable hinzu

Markiere das Modell Train für die Suche, indem du die Eigenschaft Laravel\Scout\Searchable zum Modell hinzufügst, wie unten gezeigt.

<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
use Laravel\Scout\Searchable;

class Train extends Model
{
    use Searchable;
    public $fillable = ['title'];

Außerdem musst du die Suchindizes konfigurieren, indem du die Methode searchableAs überschreibst. Das Standardverhalten von Scout würde das Modell so verändern, dass es mit dem Namen der Modelltabelle übereinstimmt.

Füge also den folgenden Code in die Datei Train.php unterhalb des Codes aus dem vorherigen Block ein.

/**
     * Retrieve the index name for the model.
     *
     * @return string
    */
    public function searchableAs()
    {
        return 'trains_index';
   }
}

Wie man Algolia mit Scout verwendet

Für die erste Volltextsuche mit Laravel Scout wirst du den Algolia-Treiber verwenden. Algolia ist eine Software-as-a-Service (SaaS)-Plattform für die Suche in großen Datenmengen. Sie bietet ein Web-Dashboard, mit dem Entwickler ihre Suchindizes verwalten können, und eine robuste API, auf die du über ein Software Development Kit (SDK) in deiner bevorzugten Programmiersprache zugreifen kannst.

Innerhalb der Laravel-Anwendung wirst du das Algolia-Client-Paket für PHP verwenden.

So richtest du Algolia ein

Zuerst musst du das Algolia PHP-Suchclient-Paket für deine Anwendung installieren.

Führe dazu den folgenden Befehl aus.

composer require algolia/algoliasearch-client-php

Als Nächstes musst du deine Anwendungs-ID und den geheimen API-Schlüssel von Algolia in der .env-Datei festlegen.

Navigiere mit deinem Webbrowser zu deinem Algolia Dashboard, um die Anwendungs-ID und den geheimen API-Schlüssel zu erhalten.

Klicke unten in der linken Seitenleiste auf „Einstellungen„, um zur Seite „Einstellungen“ zu gelangen.

Klicke auf der Einstellungsseite im Bereich Team und Zugang auf API-Schlüssel, um die Schlüssel für dein Algolia-Konto einzusehen.

Notiere dir auf der Seite mit den API-Schlüsseln die Werte für die Anwendungs-ID und den Admin-API-Schlüssel. Du wirst diese Anmeldedaten verwenden, um die Verbindung zwischen der Laravel-Anwendung und Algolia zu authentifizieren.

Füge den folgenden Code mit deinem Code-Editor zu deiner .env-Datei hinzu und ersetze die Platzhalter durch die entsprechenden Algolia-API-Geheimnisse.

ALGOLIA_APP_ID=APPLICATION_ID
ALGOLIA_SECRET=ADMIN_API_KEY

Ersetze außerdem die Variable SCOUT_DRIVER durch den unten stehenden Code, um den Wert von meilisearch in algolia zu ändern. Wenn du diesen Wert änderst, weist du Scout an, den Algolia-Treiber zu verwenden.

SCOUT_DRIVER=algolia

So erstellst du die Anwendungscontroller

Erstelle im Verzeichnis app/Http/Controllers/ eine Datei TrainSearchController.php, um einen Controller für die Anwendung zu speichern. Der Controller listet Daten auf und fügt sie dem Modell Train hinzu.

Füge den folgenden Codeblock in die Datei TrainSearchController.php ein, um den Controller zu erstellen.

<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use App\Http\Requests;
use App\Models\Train;

class TrainSearchController extends Controller
{
    /**
     * Compile the content for a trains list view.
     *
     * @return \Illuminate\Contracts\View\Factory|\Illuminate\Contracts\View\View
    */
    public function index(Request $request)
    {
        if($request->has('titlesearch')){
            $trains = Train::search($request->titlesearch)
                ->paginate(6);
        }else{
            $trains = Train::paginate(6);
        }
        return view('Train-search',compact('trains'));
    }

    /**
     * Create a new train entry.
     *
     * @return \Illuminate\Http\RedirectResponse
    */
    public function create(Request $request)
    {
        $this->validate($request,['title'=>'required']);

        $trains = Train::create($request->all());
        return back();
    }
}

So erstellst du die Anwendungsrouten

In diesem Schritt erstellst du die Routen für das Auflisten und Hinzufügen neuer Züge in der Datenbank.

Öffne deine Datei routes/web.php und ersetze den vorhandenen Code durch den folgenden Block.

<?php

use Illuminate\Support\Facades\Route;
use App\Http\Controllers\TrainSearchController;

Route::get('/', function () {
    return view('welcome');
});

Route::get('trains-lists', [TrainSearchController::class, 'index']) -> name ('trains-lists');

Route::post('create-item', [TrainSearchController::class, 'create']) -> name ('create-item');

Der obige Code definiert zwei Routen in der Anwendung. Die Anfrage GET für die Route /trains-lists listet alle gespeicherten Train-Daten auf. Die Anfrage POST für die Route /create-item erstellt neue Train-Daten.

So erstellst du die Anwendungsansichten

Erstelle eine Datei im Verzeichnis resources/views/ und nenne sie Train-search.blade.php. In dieser Datei wird die Benutzeroberfläche für die Suchfunktion angezeigt.

Füge den Inhalt des folgenden Codeblocks in die Datei Train-search.blade.php ein, um eine einzelne Seite für die Suchfunktion zu erstellen.

<!DOCTYPE html>
<html>
<head>
    <title>Laravel - Laravel Scout Algolia Search Example</title>
    <link rel="stylesheet" type="text/css" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css">
</head>
<body>
<div class="container">
    <h2 class="text-bold">Laravel Full-Text Search Using Scout </h2><br/>
    <form method="POST" action="{{ route('create-item') }}" autocomplete="off">
        @if(count($errors))
            <div class="alert alert-danger">
                <strong>Whoops!</strong> There is an error with your input.
                <br/>
                <ul>
                    @foreach($errors->all() as $error)
                    <li>{{ $error }}</li>
                    @endforeach
                </ul>
            </div>
        @endif

        <input type="hidden" name="_token" value="{{ csrf_token() }}">

        <div class="row">
            <div class="col-md-6">
                <div class="form-group {{ $errors->has('title') ? 'has-error' : '' }}">
                    <input type="text" id="title" name="title" class="form-control" placeholder="Enter Title" value="{{ old('title') }}">
                    <span class="text-danger">{{ $errors->first('title') }}</span>
                </div>
            </div>
            <div class="col-md-6">
                <div class="form-group">
                    <button class="btn btn-primary">Create New Train</button>
                </div>
            </div>
        </div>
    </form>

    <div class="panel panel-primary">
      <div class="panel-heading">Train Management</div>
      <div class="panel-body">
            <form method="GET" action="{{ route('trains-lists') }}">

                <div class="row">
                    <div class="col-md-6">
                        <div class="form-group">
                            <input type="text" name="titlesearch" class="form-control" placeholder="Enter Title For Search" value="{{ old('titlesearch') }}">
                        </div>
                    </div>
                    <div class="col-md-6">
                        <div class="form-group">
                            <button class="btn btn-primary">Search</button>
                        </div>
                    </div>
                </div>
            </form>

            <table class="table">
                <thead>
                    <th>Id</th>
                    <th>Train Title</th>
                    <th>Creation Date</th>
                    <th>Updated Date</th>
                </thead>
                <tbody>
                    @if($trains->count())
                        @foreach($trains as $key => $item)
                            <tr>
                                <td>{{ ++$key }}</td>
                                <td>{{ $item->title }}</td>
                                <td>{{ $item->created_at }}</td>
                                <td>{{ $item->updated_at }}</td>
                            </tr>
                        @endforeach
                    @else
                        <tr>
                            <td colspan="4">No train data available</td>
                        </tr>
                    @endif
                </tbody>
            </table>
            {{ $trains->links() }}
      </div>
    </div>
</div>
</body>
</html>

Der obige HTML-Code enthält ein Formularelement mit einem Eingabefeld und einer Schaltfläche, um den Titel eines Trains einzugeben, bevor du ihn in der Datenbank speicherst. Der Code enthält außerdem eine HTML-Tabelle, in der die ID, der Titel, das created_at und das updated_at eines Train-Eintrags in der Datenbank angezeigt werden.

So benutzt du die Algolia-Suche

Um die Seite aufzurufen, navigiere mit deinem Webbrowser zu http://127.0.0.1:8000/trains-lists.

Die Datenbank ist zurzeit leer, also musst du einen Titel für einen Demo-Train in das Eingabefeld eingeben und auf Neuen Train erstellen klicken, um ihn zu speichern.

Um die Suchfunktion zu nutzen, gibst du ein Stichwort aus einem der gespeicherten Train-Titel in das Eingabefeld Titel für Suche eingeben ein und klickst auf Suchen.

Wie in der Abbildung unten zu sehen ist, werden nur Sucheinträge angezeigt, die das Stichwort in ihrem Titel enthalten.

Meilisearch mit Laravel Scout

Meilisearch ist eine Open-Source-Suchmaschine, die sich auf Geschwindigkeit, Leistung und ein verbessertes Entwicklererlebnis konzentriert. Sie hat einige Funktionen mit Algolia gemeinsam und verwendet die gleichen Algorithmen, Datenstrukturen und Forschungsergebnisse – allerdings in einer anderen Programmiersprache.

Entwicklerinnen und Entwickler können eine Meilisearch-Instanz in ihrer On-Premises- oder Cloud-Infrastruktur erstellen und selbst hosten. Meilisearch hat auch ein Beta-Cloud-Angebot ähnlich wie Algolia für Entwickler, die das Produkt nutzen wollen, ohne die Infrastruktur zu verwalten.

In diesem Tutorial hast du bereits eine lokale Instanz von Meilisearch in deinen Docker-Containern laufen. Du wirst nun die Laravel Scout-Funktionalität erweitern, um die Meilisearch-Instanz zu nutzen.

Um Meilisearch zu deiner Laravel-Anwendung hinzuzufügen, führe den folgenden Befehl in deinem Projektterminal aus.

composer require meilisearch/meilisearch-php

Als Nächstes musst du die Meilisearch-Variablen in der .env-Datei ändern, um sie zu konfigurieren.

Ersetze die Variablen SCOUT_DRIVER, MEILISEARCH_HOST und MEILISEARCH_KEY in der .env-Datei durch die unten stehenden Variablen.

SCOUT_DRIVER=meilisearch
MEILISEARCH_HOST=http://127.0.0.1:7700
MEILISEARCH_KEY=LockKey

Der Schlüssel SCOUT_DRIVER gibt den Treiber an, den Scout verwenden soll, während MEILISEARCH_HOST für die Domäne steht, in der deine Meilisearch-Instanz läuft. Während der Entwicklung ist es nicht erforderlich, aber in der Produktion wird empfohlen, die MEILISEARCH_KEY hinzuzufügen.

Hinweis: Kommentiere die Algolia ID und Secret aus, wenn du Meilisearch als deinen bevorzugten Treiber verwendest.

Nachdem du die .env-Konfigurationen abgeschlossen hast, solltest du deine bereits vorhandenen Datensätze mit dem unten stehenden Artisan-Befehl indizieren.

php artisan scout:import "App\Models\Train"

Laravel Scout mit Datenbank-Engine

Die Datenbank-Engine von Scout eignet sich am besten für Anwendungen, die kleinere Datenbanken verwenden oder weniger intensive Workloads verwalten. Derzeit unterstützt die Datenbank-Engine PostgreSQL und MySQL.

Diese Engine verwendet „Where-like“-Klauseln und Volltextindizes für deine bestehende Datenbank, um die relevantesten Suchergebnisse zu finden. Wenn du die Datenbank-Engine verwendest, musst du deine Datensätze nicht indizieren.

Um die Datenbank-Engine zu nutzen, musst du deine SCOUT_DRIVER .env Variable auf die Datenbank setzen.

Öffne die .env-Datei innerhalb der Laravel-Anwendung und ändere den Wert der Variable SCOUT_DRIVER.

SCOUT_DRIVER = database

Nachdem du deinen Treiber auf die Datenbank geändert hast, schaltet Scout auf die Verwendung der Datenbank-Engine für die Volltextsuche um.

Collection Engine mit Laravel Scout

Zusätzlich zur Datenbank-Engine bietet Scout auch eine Collection-Engine. Diese Engine verwendet „Where“-Klauseln und Sammlungsfilter, um die relevantesten Suchergebnisse zu ermitteln.

Im Gegensatz zur Datenbank-Engine unterstützt die Sammel-Engine alle relationalen Datenbanken, die auch Laravel unterstützt.

Du kannst die Collection Engine nutzen, indem du die Umgebungsvariable SCOUT_DRIVER auf collection setzt oder den Collection Driver manuell in der Scout-Konfigurationsdatei angibst.

SCOUT_DRIVER = collection

Explorer mit Elasticsearch

Mit der Stärke von Elasticsearch-Abfragen ist der Explorer ein moderner Elasticsearch-Treiber für Laravel Scout. Er bietet einen kompatiblen Scout-Treiber und Vorteile wie das Speichern, Suchen und Analysieren riesiger Datenmengen in Echtzeit. Elasticsearch mit Laravel liefert Ergebnisse in Millisekunden.

Um den Elasticsearch Explorer-Treiber in deiner Laravel-Anwendung zu verwenden, musst du die Boilerplate-Datei docker-compose.yml konfigurieren, die das Laravel-Scout-Skript erstellt hat. Du fügst die zusätzlichen Konfigurationen für Elasticsearch hinzu und startest die Container neu.

Öffne deine Datei docker-compose.yml und ersetze ihren Inhalt durch den folgenden.

# For more information: https://laravel.com/docs/sail
version: '3'
services:
    laravel.test:
        build:
            context: ./vendor/laravel/sail/runtimes/8.1
            dockerfile: Dockerfile
            args:
                WWWGROUP: '${WWWGROUP}'
        image: sail-8.1/app
        extra_hosts:
            - 'host.docker.internal:host-gateway'
        ports:
            - '${APP_PORT:-80}:80'
            - '${VITE_PORT:-5173}:${VITE_PORT:-5173}'
        environment:
            WWWUSER: '${WWWUSER}'
            LARAVEL_SAIL: 1
            XDEBUG_MODE: '${SAIL_XDEBUG_MODE:-off}'
            XDEBUG_CONFIG: '${SAIL_XDEBUG_CONFIG:-client_host=host.docker.internal}'
        volumes:
            - '.:/var/www/html'
        networks:
            - sail
        depends_on:
            - mysql
            - redis
            - meilisearch
            - mailhog
            - selenium
            - pgsql
            - elasticsearch

    mysql:
        image: 'mysql/mysql-server:8.0'
        ports:
            - '${FORWARD_DB_PORT:-3306}:3306'
        environment:
            MYSQL_ROOT_PASSWORD: '${DB_PASSWORD}'
            MYSQL_ROOT_HOST: "%"
            MYSQL_DATABASE: '${DB_DATABASE}'
            MYSQL_USER: '${DB_USERNAME}'
            MYSQL_PASSWORD: '${DB_PASSWORD}'
            MYSQL_ALLOW_EMPTY_PASSWORD: 1
        volumes:
            - 'sail-mysql:/var/lib/mysql'
            - './vendor/laravel/sail/database/mysql/create-testing-database.sh:/docker-entrypoint-initdb.d/10-create-testing-database.sh'
        networks:
            - sail
        healthcheck:
            test: ["CMD", "mysqladmin", "ping", "-p${DB_PASSWORD}"]
            retries: 3
            timeout: 5s
            
    elasticsearch:
        image: 'elasticsearch:7.13.4'
        environment:
            - discovery.type=single-node
        ports:
            - '9200:9200'
            - '9300:9300'
        volumes:
            - 'sailelasticsearch:/usr/share/elasticsearch/data'
        networks:
            - sail
    kibana:
        image: 'kibana:7.13.4'
        environment:
            - elasticsearch.hosts=http://elasticsearch:9200
        ports:
            - '5601:5601'
        networks:
            - sail
        depends_on:
            - elasticsearch
    redis:
        image: 'redis:alpine'
        ports:
            - '${FORWARD_REDIS_PORT:-6379}:6379'
        volumes:
            - 'sail-redis:/data'
        networks:
            - sail
        healthcheck:
            test: ["CMD", "redis-cli", "ping"]
            retries: 3
            timeout: 5s
    pgsql:
        image: 'postgres:13'
        ports:
            - '${FORWARD_DB_PORT:-5432}:5432'
        environment:
            PGPASSWORD: '${DB_PASSWORD:-secret}'
            POSTGRES_DB: '${DB_DATABASE}'
            POSTGRES_USER: '${DB_USERNAME}'
            POSTGRES_PASSWORD: '${DB_PASSWORD:-secret}'
        volumes:
            - 'sailpgsql:/var/lib/postgresql/data'
        networks:
            - sail
        healthcheck:
            test: ["CMD", "pg_isready", "-q", "-d", "${DB_DATABASE}", "-U", "${DB_USERNAME}"]
            retries: 3
            timeout: 5s
    meilisearch:
        image: 'getmeili/meilisearch:latest'
        ports:
            - '${FORWARD_MEILISEARCH_PORT:-7700}:7700'
        volumes:
            - 'sail-meilisearch:/meili_data'
        networks:
            - sail
        healthcheck:
            test: ["CMD", "wget", "--no-verbose", "--spider",  "http://localhost:7700/health"]
            retries: 3
            timeout: 5s
    mailhog:
        image: 'mailhog/mailhog:latest'
        ports:
            - '${FORWARD_MAILHOG_PORT:-1025}:1025'
            - '${FORWARD_MAILHOG_DASHBOARD_PORT:-8025}:8025'
        networks:
            - sail
    selenium:
        image: 'selenium/standalone-chrome'
        extra_hosts:
            - 'host.docker.internal:host-gateway'
        volumes:
            - '/dev/shm:/dev/shm'
        networks:
            - sail
networks:
    sail:
        driver: bridge
volumes:
    sail-mysql:
        driver: local
    sail-redis:
        driver: local
    sail-meilisearch:
        driver: local
    sailpgsql:
        driver: local
    sailelasticsearch:
        driver: local 

Als Nächstes führst du den folgenden Befehl aus, um das neue Elasticsearch-Image zu laden, das du der Datei docker-compose.yml hinzugefügt hast.

docker-compose up

Führe dann den Composer-Befehl unten aus, um Explorer in das Projekt zu installieren.

composer require jeroen-g/explorer

Du musst auch eine Konfigurationsdatei für den Explorer-Treiber erstellen.

Führe den folgenden Artisan-Befehl aus, um eine explorer.config-Datei zum Speichern der Konfigurationen zu erstellen.

php artisan vendor:publish --tag=explorer.config

Die oben erstellte Konfigurationsdatei wird im Verzeichnis /config verfügbar sein.

In deiner Datei config/explorer.php kannst du dein Modell mit dem Schlüssel indexes referenzieren.

'indexes' => [
        AppModelsTrain::class
],

Ändere den Wert der Variable SCOUT_DRIVER in der .env-Datei in elastic, um Scout für die Verwendung des Explorer-Treibers zu konfigurieren.

SCOUT_DRIVER = elastic

An dieser Stelle verwendest du den Explorer innerhalb des Train Modells, indem du die Explorer-Schnittstelle implementierst und die Methode mappableAs() überschreibst.

Öffne die Datei Train.php im Verzeichnis App\Models und ersetze den vorhandenen Code durch den unten stehenden Code.

<?php
namespace App\Models;
 
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use JeroenG\Explorer\Application\Explored;
use Laravel\Scout\Searchable;
 
class Train extends Model implements Explored
{
    use HasFactory;
    use Searchable;
 
    protected $fillable = ['title'];
 
    public function mappableAs(): array
    {
        return [
        	'id'=>$this->Id,
        	'title' => $this->title,
        ];
    }
} 

Mit dem Code, den du oben hinzugefügt hast, kannst du jetzt den Explorer verwenden, um Text im Modell Train zu suchen.

Zusammenfassung

Für PHP-Entwickler ist es mit Laravel und Add-ons wie Scout ein Kinderspiel, eine schnelle und robuste Volltextsuche zu integrieren. Mit der Database Engine, der Collection Engine und den Möglichkeiten von Meilisearch und Elasticsearch kannst du mit der Datenbank deiner App interagieren und erweiterte Suchmechanismen in wenigen Millisekunden implementieren.

Die nahtlose Verwaltung und Aktualisierung deiner Datenbank bedeutet, dass deine Nutzer ein optimales Erlebnis haben, während dein Code sauber und effizient bleibt.

Mit unseren Lösungen für das Anwendungs- und Datenbank-Hosting ist Kinsta dein One-Stop-Shop für alle deine Anforderungen an eine moderne Laravel-Entwicklung. Die ersten 20 Dollar gehen auf uns.

Jeremy Holcombe Kinsta

Content & Marketing Editor at Kinsta, WordPress Web Developer, and Content Writer. Outside of all things WordPress, I enjoy the beach, golf, and movies. I also have tall people problems ;).

• Webseite
• LinkedIn