• Index

• Moteur personnalisé

Laravel Scout

• Introduction
• Installation
  • File d'attente
  • Configuration
Configurer l'index du modèle
• Configurer les données consultables
  Configurer l'ID du modèle
  • Index
Importation par lots
• Ajouter des enregistrements
  Mettre à jour les enregistrements
  Supprimer les enregistrements
  Suspendre l'indexation
  Instances de modèle consultables conditionnellement
  • "Recherche" Moteur personnalisé
  • Macro générateur
• • IntroductionLaravel Scout fournit une solution simple basée sur un pilote pour la recherche en texte intégral des modèles Eloquent. En utilisant des observateurs de modèles, Scout synchronise automatiquement l'index de recherche des enregistrements Eloquent.
  • Actuellement, Scout est livré avec un chauffeur Algolia. Cependant, écrire un pilote personnalisé est également simple et vous pouvez facilement étendre Scout avec votre propre implémentation de recherche.
  • Installation
  Tout d'abord, installez Scout via le gestionnaire de packages Composer :

composer require laravel/scout

• Scout Une fois l'installation terminée, utilisez la commande vendor:publish Artisan pour générer la configuration Scout. déposer. Cette commande générera un fichier de configuration scout.php dans votre répertoire config.

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

  Enfin, ajoutez le trait LaravelScoutSearchable au modèle sur lequel vous souhaitez effectuer une recherche. Ce trait enregistrera un observateur de modèle pour garder le modèle et tous les pilotes synchronisés :

<?php
    namespace App;
    use Laravel\Scout\Searchable;
    use Illuminate\Database\Eloquent\Model;
    class Post extends Model{
        use Searchable;
      }

queue

Une fois que vous avez configuré le pilote de file d'attente, la valeur de l'option queue dans votre fichier de configuration config/scout.php doit être définie sur true :

'queue' => true,

Conditions nécessaires au pilote

Algolia

Lors de l'utilisation du pilote Algolia, vous devez configurer votre id et votre secret< d'Algolia dans le config/scout.php fichier de configuration /code> Informations d'identification. Après avoir configuré les informations d'identification, vous devez également utiliser le gestionnaire de packages Composer pour installer le SDK PHP Algolia : config/scout.php 配置文件配置你的 Algolia id 和 secret 凭证。配置好凭证之后，还需要使用 Composer 包管理器安装 Algolia PHP SDK：

composer require algolia/algoliasearch-client-php:^2.2

配置

配置模型索引

每个 Eloquent 模型都是通过给定的 「索引」 进行同步，该 「索引」 包含所有可搜索的模型记录。换句话说，你可以把每一个 「索引」 设想为一张 MySQL 数据表。默认情况下，每个模型都会被持久化到与模型的 「表」 名（通常是模型名称的复数形式）相匹配的索引。你也可以通过重写模型上的 searchableAs 方法来自定义模型的索引：

<?php
    namespace App;
    use Laravel\Scout\Searchable;
    use Illuminate\Database\Eloquent\Model;
    class Post extends Model{
        use Searchable;    
      /**
     * 获取索引名称
     *
     * @return string
     */   
     public function searchableAs()  
       {   
            return 'posts_index';  
       }
    }

配置可搜索数据

默认情况下，模型以完整的 toArray 格式持久化到搜索索引。如果要自定义同步到搜索索引的数据，可以覆盖模型上的 toSearchableArray 方法：

<?php
    namespace App;
    use Laravel\Scout\Searchable;
    use Illuminate\Database\Eloquent\Model;
    class Post extends Model{ 
       use Searchable;    
     /**
     * 获取模型的可搜索数据
     *
     * @return array
     */ 
      public function toSearchableArray() 
        {      
          $array = $this->toArray();       
           // Customize array...       
           return $array;    
          }
       }

配置模型 ID

默认情况下，Scout 将使用模型的主键作为搜索索引中存储的唯一 ID 。 可以通过模型上的 getScoutKey 方法自定义：

<?php
    namespace App;
    use Laravel\Scout\Searchable;
    use Illuminate\Database\Eloquent\Model;
    class User extends Model{
        use Searchable;    
     /**
     *  获取模型主键
     *
     * @return mixed
     */   
     public function getScoutKey()  
       {    
           return $this->email;  
         }
     }

索引

批量导入

如果你想安装 Scout 到已存在的项目中，你可能已经有了想要导入搜索驱动的数据库记录。Scout 提供了 Artisan 命令 import 用来导入所有已存在的记录到搜索索引：

php artisan scout:import "App\Post"

flush 命令可用于从搜索索引中删除所有模型的记录：

php artisan scout:flush "App\Post"

添加记录

当你将 LaravelScoutSearchable trait 添加到模型中，你需要做的就是 save

$order = new App\Order;// ...$order->save();

Configuration

🎜🎜

🎜🎜Configuration des index de modèle🎜🎜Chaque modèle Eloquent est donné en synchronisant "l'index" qui contient tous les enregistrements de modèle consultables. En d’autres termes, vous pouvez considérer chaque « index » comme une table de données MySQL. Par défaut, chaque modèle est conservé dans un index qui correspond au nom de « table » du modèle (généralement la forme plurielle du nom du modèle). Vous pouvez également personnaliser l'index du modèle en remplaçant la méthode searchableAs sur le modèle : 🎜

// 通过 Eloquent 查询构造器增加..
App\Order::where('price', '>', 100)->searchable();
// 你也可以通过模型关系增加记录...
$user->orders()->searchable();
// 你也可以通过集合增加记录...
$orders->searchable();

🎜🎜🎜

🎜🎜Configuration des données consultables🎜🎜Par défaut, les modèles sont conservés dans l'index de recherche au format toArray complet. Si vous souhaitez personnaliser les données synchronisées avec l'index de recherche, vous pouvez remplacer la méthode toSearchableArray sur le modèle : 🎜

$order = App\Order::find(1);
// 更新订单...
$order->save();

🎜🎜🎜< div name=" 8c2464" data-unique="8c2464">🎜🎜Configuration de l'ID du modèle🎜🎜Par défaut, Scout utilisera la clé primaire du modèle comme identifiant unique stocké dans l'index de recherche. Peut être personnalisé via la méthode getScoutKey sur le modèle : 🎜

// 通过 Eloquent 查询更新...
App\Order::where('price', '>', 100)->searchable();
// 你也可以通过数据间的关联进行更新...
$user->orders()->searchable();
// 你也可以通过数据集合进行更新...
$orders->searchable();

🎜🎜🎜

🎜

index

🎜🎜🎜

🎜🎜Batch import🎜🎜Si vous souhaitez installer Scout dans un projet existant, Vous disposez peut-être déjà d'enregistrements de base de données que vous souhaitez importer dans le pilote de recherche. Scout fournit la commande Artisan import pour importer tous les enregistrements existants dans l'index de recherche : 🎜

$order = App\Order::find(1);
$order->delete();

🎜 La commande flush peut être utilisée pour supprimer tous les enregistrements de modèle de l'index de recherche : 🎜

// 通过 Eloquent 查询删除...
App\Order::where('price', '>', 100)->unsearchable();
//  你可以通过数据间的关系进行删除...
$user->orders()->unsearchable();
// 你可以通过数据集合进行删除...
$orders->unsearchable();

🎜🎜🎜

🎜🎜Ajout d'enregistrements🎜🎜Lorsque vous ajoutez le trait LaravelScoutSearchable à votre model , tout ce que vous avez à faire est de enregistrer une instance de modèle et elle sera automatiquement ajoutée à l'index de recherche. Si vous avez configuré Scout pour 🎜utiliser une file d'attente🎜, alors cette opération sera effectuée en arrière-plan par votre processus de travail de file d'attente : 🎜

App\Order::withoutSyncingToSearch(function () { 
   // 执行模型操作...
  });

🎜🎜

Ajout via une requête

Si vous souhaitez ajouter une collection de modèles à l'index de recherche via le générateur de requêtes Eloquent, vous pouvez également chaîner la méthode searchable sur le générateur de requêtes Eloquent. searchable décomposera les résultats de la requête du constructeur et ajoutera les enregistrements à votre index de recherche. De même, si vous avez configuré Scout pour utiliser une file d'attente, tous les blocs de données seront ajoutés par votre processus de travail de file d'attente en arrière-plan : la méthode searchable 方法。searchable 会把构造器的查询 结果分块 并且将记录添加到你的搜索索引里。同样的，如果你已经配置 Scout 为使用队列，则所有的数据块将在后台由你的队列工作进程添加：

public function shouldBeSearchable(){
    return $this->isPublished();
   }

searchable 方法可以被看做是「更新插入」的操作。换句话说，如果模型记录已经在你的索引里了，它就会被更新。如果搜索索引中不存在，则将其添加到索引中。

更新记录

要更新可搜索的模型，只需要更新模型实例的属性并将模型 save 到数据库。Scout 会自动将更新同步到你的搜索索引中：

// 此处将遵循 "shouldBeSearchable" 结果...
App\Order::where('price', '>', 100)->searchable();
$user->orders()->searchable();$order->save();
// 此处将覆盖 "shouldBeSearchable" 结果...
$orders->searchable();
$order->searchable();

你也可以在 Eloquent 查询语句上使用 searchable 方法来更新一个模型的集合。如果这个模型不存在你检索的索引里，就会被创建：

$orders = App\Order::search('Star Trek')->get();

删除记录

使用 delete 从数据库中删除该模型就可以移除索引里的记录。这种删除形式甚至与 软删除 的模型兼容:

use Illuminate\Http\Request;
Route::get('/search', function (Request $request) {
    return App\Order::search($request->search)->get();
   });

如果你不希望记录在删除之前被检索到，可以在 Eloquent 查询实例或集合上使用 unsearchable 方法：

$orders = App\Order::search('Star Trek')->raw();

暂停索引

你可能需要在执行一批 Eloquent 操作的时候，不同步模型数据到搜索索引。此时你可以使用 withoutSyncingToSearch 方法来执行此操作。这个方法接受一个立即执行的回调。该回调中所有的操作都不会同步到模型的索引：

$orders = App\Order::search('Star Trek') 
   ->within('tv_shows_popularity_desc')    
   ->get();

有条件的搜索模型实例

有时候你可能需要在某些条件下模型是可搜索的。例如，假设你有 AppPost 模型可能两种状态之一：「草稿」和「发布」。你可能只允许搜索 「发布」过的帖子。为了实现这一点，你需要在模型中定义一个 shouldBeSearchable 方法：

$orders = App\Order::search('Star Trek')->where('user_id', 1)->get();

只有在通过 save 方法、查询或关联模型操作时，才应使用 shouldBeSearchable 方法。直接使用 searchable 方法将使模型或集合的可搜索结果覆盖 shouldBeSearchable

$orders = App\Order::search('Star Trek')->paginate();

searchable peut être considérée comme une opération "d'insertion de mise à jour". En d'autres termes, si l'enregistrement du modèle est déjà dans votre index, il sera mis à jour. S'il n'existe pas dans l'index de recherche, il est ajouté à l'index.

Mise à jour des enregistrements

Pour mettre à jour un modèle consultable, mettez simplement à jour les propriétés de l'instance de modèle et enregistrer le modèle dans la base de données. Scout synchronisera automatiquement les mises à jour de votre index de recherche : 🎜

$orders = App\Order::search('Star Trek')->paginate(15);

🎜 Vous pouvez également utiliser la méthode searchable sur une requête Eloquent pour mettre à jour une collection de modèles. Si le modèle n'existe pas dans l'index que vous recherchez, il sera créé : 🎜

<div class="container">
    @foreach ($orders as $order) 
           {{ $order->price }}
    @endforeach
    </div>
  {{ $orders->links() }}

🎜🎜🎜

🎜

Supprimer les enregistrements

🎜Utilisez delete pour supprimer le modèle de la base de données afin de supprimer les enregistrements de l'index. Cette forme de suppression est même compatible avec le modèle de suppression logicielle : 🎜

'soft_delete' => true,

🎜 Si vous ne souhaitez pas que l'enregistrement soit récupéré avant la suppression, vous pouvez utiliser la méthode unsearchable sur l'instance ou la collection de requête Eloquent : 🎜

// 搜索结果包括已删除的记录...
$orders = App\Order::withTrashed()->search('Star Trek')->get();
// 搜索结果只含已删除的记录...
$orders = App\Order::onlyTrashed()->search('Star Trek')->get();

🎜< a name="pausing-indexing">🎜🎜

🎜

Suspendre l'indexation

🎜Vous devrez peut-être effectuer un lot de Opérations éloquentes sans synchroniser les données du modèle avec l'index de recherche. À ce stade, vous pouvez utiliser la méthode withoutSyncingToSearch pour ce faire. Cette méthode accepte un rappel qui est exécuté immédiatement. Toutes les opérations de ce rappel ne seront pas synchronisées avec l'index du modèle : 🎜

use Algolia\AlgoliaSearch\SearchIndex;
App\Order::search('Star Trek', function (SearchIndex $algolia, string $query, array $options) {
    $options['body']['query']['bool']['filter']['geo_distance'] = [
            'distance' => '1000km',        
            'location' => ['lat' => 36, 'lon' => 111],  
          ];    
     return $algolia->search($query, $options);
  })->get();

🎜🎜🎜

🎜 < h3>Instance de modèle de recherche conditionnelle🎜Parfois, vous aurez peut-être besoin qu'un modèle puisse être recherché sous certaines conditions. Par exemple, supposons que vous disposiez d'un modèle AppPost qui peut être dans l'un des deux états suivants : « Brouillon » ou « Publié ». Vous ne pouvez autoriser que les recherches de publications « publiées ». Pour y parvenir, vous devez définir une méthode shouldBeSearchable dans votre modèle : 🎜

use Laravel\Scout\Builder;
abstract public function update($models);
abstract public function delete($models);
abstract public function search(Builder $builder);
abstract public function paginate(Builder $builder, $perPage, $page);
abstract public function mapIds($results);
abstract public function map($results, $model);
abstract public function getTotalCount($results);
abstract public function flush($model);

🎜save, la requête ou le modèle associé. >shouldBeSearchable méthode. L'utilisation directe de la méthode searchable entraînera le remplacement des résultats de recherche du modèle ou de la collection par les résultats de la méthode shouldBeSearchable : 🎜

use Laravel\Scout\EngineManager;
/**
 * 启动任何的服务
 *
 * @return void
 */
 public function boot(){ 
    resolve(EngineManager::class)->extend('mysql', function () {
            return new MySqlSearchEngine;   
         });
      }

🎜🎜🎜🎜🎜🎜

Recherche

Vous pouvez utiliser la méthode recherche pour rechercher des modèles. La méthode de recherche accepte une chaîne pour rechercher le modèle. Vous devez également enchaîner la méthode get sur la requête de recherche pour rechercher la correspondance des modèles Eloquent avec une instruction de recherche donnée : search 方法来搜索模型。search 方法接受一个用于搜索模型的字符串。你还需要在搜索查询上链式调用 get 方法，才能用给定的搜索语句查询与之匹配的 Eloquent 模型：

'driver' => 'mysql',

Scout 搜索返回 Eloquent 模型的集合，因此你可以直接从路由或控制器返回结果，它们会被自动转换成 JSON 格式：

<?php
    namespace App\Providers;
    use Laravel\Scout\Builder;
    use Illuminate\Support\ServiceProvider;
    use Illuminate\Support\Facades\Response;
    class ScoutMacroServiceProvider extends ServiceProvider{  
      /**
     * 注册应用的Scout 宏命令.
     *
     * @return void
     */  
       public function boot()  
         {     
            Builder::macro('count', function () {
                 return $this->engine->getTotalCount(           
                      $this->engine()->search($this)    
                           );     
                     });   
           }
        }

如果你想在它们返回 Eloquent 模型前得到原结果，你应该使用 raw 方法：

App\Order::search('Star Trek')->count();

搜索查询通常会在模型的 searchableAs 方法指定的索引上执行。当然，你也可以使用 within 方法指定应该搜索的自定义索引：

rrreee

Where 语句

允许你在搜索查询中增加简单的 "where" 语句。目前，这些语句只支持基本的数值等式检查，并且主要是用于根据租户 ID 进行的范围搜索查询。由于搜索索引不是关系型数据库，因此当前不支持更高级的 "where" 语句：

rrreee

分页

除了检索模型的集合，你也可以使用 paginate 方法对搜索结果进行分页。这个方法会返回一个就像 传统的 Eloquent 查询分页 一样的 Paginator 实例：

rrreee

你可以通过将数量作为第一个参数传递给 paginate 方法来指定每页检索多少个模型：

rrreee

获取到检索结果后，就可以使用 Blade 来渲染分页链接和显示检索结果，就像传统的 Eloquent 查询分页一样：

rrreee

软删除

如果你的索引模型是 软删除 ，并且你需要搜索软删除的模型，设置 config/scout.php 配置文件的 soft_delete 选项的值为 true：

rrreee

当这个配置选项是 true 的时候， Scout 不会从搜索索引中移除软删除模型。相反，它会在索引记录中设置一个隐藏 __soft_deleted 属性。 然后，在搜索的时候，你可以使用 withTrashed 或 onlyTrashed 方法检索软删除记录：

rrreee

{提示} 要永久删除模型可以使用 forceDeleterrreee

La recherche Scout renvoie une collection de modèles Eloquent, vous pouvez donc directement lorsque les résultats sont renvoyés par une route ou un contrôleur, ils sont automatiquement convertis au format JSON :

rrreee

Si vous souhaitez obtenir les résultats originaux avant qu'ils ne soient renvoyés au modèle Eloquent, vous devez utiliser la méthode raw : rrreeeLes requêtes de recherche sont généralement exécutées sur l'index spécifié par la méthode searchableAs

du modèle. Bien sûr, vous pouvez également utiliser la méthode within pour spécifier un index personnalisé dans lequel rechercher :

rrreee

🎜🎜

🎜

Instruction Where

🎜 vous permet d'ajouter de simples instructions "where" aux requêtes de recherche. Actuellement, ces instructions ne prennent en charge que les contrôles d'égalité numérique de base et sont principalement destinées aux requêtes de recherche de plage basées sur l'ID de locataire. L'index de recherche n'étant pas une base de données relationnelle, les instructions "where" plus avancées ne sont actuellement pas prises en charge : 🎜rrreee🎜🎜🎜

🎜< h3>Paginate🎜En plus de récupérer une collection de modèles, vous pouvez également utiliser la méthode paginate pour paginer les résultats de recherche. Cette méthode renvoie une instance Paginator tout comme la pagination traditionnelle des requêtes Eloquent : 🎜rrreee🎜Vous pouvez spécifier la quantité en la passant comme premier argument à la méthode paginate Combien de modèles à récupérer par page : 🎜rrreee🎜Après avoir obtenu les résultats de la recherche, vous pouvez utiliser Blade pour restituer les liens de pagination et afficher les résultats de la recherche, tout comme la pagination de requête Eloquent traditionnelle : 🎜rrreee🎜🎜🎜

🎜

Suppression logicielle

🎜Si votre modèle d'index est supprimé de manière logicielle et que vous devez rechercher des modèles supprimés de manière logicielle, définissez config/scout.php La valeur de l'option soft_delete dans le fichier de configuration est true : 🎜rrreee🎜Lorsque cette option de configuration est true Scout ne le fait pas supprimer les modèles supprimés de l’index de recherche. Au lieu de cela, il définit un attribut __soft_deleted caché sur l'enregistrement d'index. Ensuite, lors de la recherche, vous pouvez utiliser la méthode withTrashed ou onlyTrashed pour récupérer les enregistrements supprimés de manière logicielle : 🎜rrreee

🎜{Astuce} Pour supprimer définitivement le modèle, utilisez < code >forceDelete pour supprimer, Scout supprimera automatiquement le modèle de l'index de recherche. 🎜🎜🎜🎜🎜🎜🎜🎜

Moteur de recherche personnalisé

Si vous devez personnaliser le comportement de recherche du moteur, vous pouvez transmettre le rappel comme deuxième paramètre à la méthode search. Par exemple, vous pouvez utiliser ce rappel pour ajouter des données de géolocalisation à la requête de recherche avant de les transmettre à Algolia : search 方法。例如，在将搜索查询传递给 Algolia 之前，可以使用这个回调将地理位置数据添加到搜索请求中：

rrreee

自定义引擎

写引擎

如果内置的 Scout 搜索引擎不能满足你的需求，你可以编写自定义的引擎并且将它注册到 Scout。你的引擎需要继承 LaravelScoutEnginesEngine 抽象类，这个抽象类包含了你自定义的引擎必须要实现的七个方法：

rrreee

在 LaravelScoutEnginesAlgoliaEngine 类里查看这些方法的实现会对你有较大的帮助。这个类会为你在学习如何在自定义引擎中实现这些方法提供一个好的起点。

注册引擎

一旦你写好了自定义引擎，你可以用 Scout 引擎管理的 extend 方法将它注册到 Scout。你只需要从 AppServiceProvider 下的 boot 方法或者应用中使用的任何一个服务提供器中调用 extend 方法。举个例子，如果你写好了一个 MySqlSearchEngine，你可以像这样去注册它：

rrreee

引擎注册后，你可以在 config/scout.php 配置文件中指定它为默认的 Scout driver：

rrreee

生成宏命令

如果你想要自定义生成器方法，你可以使用   LaravelScoutBuilder  类下的 macro  方法。通常，定义 "macros" 时， 需要实现 service provider's  boot 方法:

rrreee

macro  函数接受一个名字作为第一个参数，第二个参数为一个闭包函数。当
调用 LaravelScoutBuilderrrreee

Moteur personnalisé

Moteur d'écriture

Si le moteur de recherche Scout intégré ne peut pas satisfaire En fonction de selon vos besoins, vous pouvez écrire un moteur personnalisé et l'enregistrer auprès de Scout. Votre moteur doit hériter de la classe abstraite LaravelScoutEnginesEngine. Cette classe abstraite contient sept méthodes que votre moteur personnalisé doit implémenter : 🎜rrreee🎜Affichez-les dans la classe LaravelScoutEnginesAlgoliaEngine. la méthode vous sera d’une grande aide. Ce cours vous fournira un bon point de départ pour apprendre à implémenter ces méthodes dans un moteur personnalisé. 🎜

🎜

Enregistrer le moteur

🎜Une fois que vous avez écrit votre moteur personnalisé, vous pouvez utiliser le moteur Scout pour gérer étendre méthode pour l'enregistrer auprès de Scout. Il vous suffit d'appeler la méthode extend à partir de la méthode boot sous AppServiceProvider ou tout fournisseur de services utilisé dans l'application. Par exemple, si vous avez écrit un MySqlSearchEngine, vous pouvez l'enregistrer comme ceci : 🎜rrreee🎜Une fois le moteur enregistré, vous pouvez le configurer dans config/scout.php Spécifiez-le comme pilote Scout par défaut dans le fichier : 🎜rrreee🎜🎜🎜

🎜< h2 >Générer une commande de macro🎜Si vous souhaitez personnaliser la méthode du générateur, vous pouvez utiliser la méthode macro sous la classe LaravelScoutBuilder. Habituellement, lors de la définition de "macros", vous devez implémenter la méthode boot du fournisseur de services : 🎜rrreee🎜macro La fonction accepte un nom comme premier paramètre et comme deuxième paramètre est une fonction de package de fermeture. Cette fonction est appelée lors de
l'appel de la macro-commande LaravelScoutBuilder.🎜rrreee🎜Cet article a été publié pour la première fois sur le site Web 🎜LearnKu.com🎜. 🎜🎜

← Authentification du passeport OAuth

Connexion sociale socialite →

soumettre

Site Web PHP chinois

MaisonCoursArticleQuestions et réponsesDictionnaireManuelTéléchargerrecherche APPTélécharger