Laravel中无需Laravel Scout，通过服务提供者/Traits整合Algolia PHP客户端

Great question! Since you don't want to rely on Laravel Scout, integrating Algolia directly via Laravel's service container (using a service provider) or a reusable trait are both excellent ways to avoid repetitive initialization code. Let's break down both approaches:

This is the most "Laravel-native" approach, leveraging the framework's dependency injection container to manage Algolia instances. It's clean, testable, and decoupled.

步骤1：添加Algolia配置 #

First, add your Algolia credentials to config/services.php so you don't hardcode them in your code:

return [
    // ... 其他服务配置
    'algolia' => [
        'id' => env('ALGOLIA_APP_ID'),
        'secret' => env('ALGOLIA_SECRET'),
        'default_index' => env('ALGOLIA_DEFAULT_INDEX'),
    ],
];

Then update your .env file with your actual credentials:

ALGOLIA_APP_ID=your_algolia_app_id
ALGOLIA_SECRET=your_algolia_admin_api_key
ALGOLIA_DEFAULT_INDEX=your_default_index_name

步骤2：创建Algolia服务提供者 #

Generate a new service provider using Artisan:

php artisan make:provider AlgoliaServiceProvider

Open the generated file (app/Providers/AlgoliaServiceProvider.php) and update the register method to bind the Algolia client and index to the container:

<?php

namespace App\Providers;

use AlgoliaSearch\Client;
use AlgoliaSearch\Index;
use Illuminate\Support\ServiceProvider;

class AlgoliaServiceProvider extends ServiceProvider
{
    /**
     * Register services.
     */
    public function register(): void
    {
        // Bind the Algolia client as a singleton (only one instance is created)
        $this->app->singleton(Client::class, function ($app) {
            return new Client(
                $app['config']['services.algolia.id'],
                $app['config']['services.algolia.secret']
            );
        });

        // Bind the default Algolia index (optional but convenient)
        $this->app->bind(Index::class, function ($app) {
            return $app->make(Client::class)
                ->initIndex($app['config']['services.algolia.default_index']);
        });
    }

    /**
     * Bootstrap services.
     */
    public function boot(): void
    {
        // No bootstrap logic needed here unless you want to add macros or other setup
    }
}

步骤3：注册服务提供者 #

Add your new provider to the providers array in config/app.php:

'providers' => [
    // ... 其他服务提供者
    App\Providers\AlgoliaServiceProvider::class,
],

步骤4：在控制器中使用 #

Now you can inject the Algolia client or index directly into your controllers via constructor or method injection:

注入默认索引 #

<?php

namespace App\Http\Controllers;

use AlgoliaSearch\Index;
use Illuminate\Http\Request;

class ProductController extends Controller
{
    protected $algoliaIndex;

    // Inject the default index via constructor
    public function __construct(Index $algoliaIndex)
    {
        $this->algoliaIndex = $algoliaIndex;
    }

    public function search(Request $request)
    {
        $results = $this->algoliaIndex->search($request->query('q'));
        
        // Use any Algolia Index method here
        // $this->algoliaIndex->saveObjects(...);
        // $this->algoliaIndex->deleteObject(...);

        return view('products.search', compact('results'));
    }
}

注入客户端（用于自定义索引） #

If you need to work with multiple indexes, inject the client instead:

<?php

namespace App\Http\Controllers;

use AlgoliaSearch\Client;
use Illuminate\Http\Request;

class MultiIndexController extends Controller
{
    protected $algoliaClient;

    public function __construct(Client $algoliaClient)
    {
        $this->algoliaClient = $algoliaClient;
    }

    public function searchUsers(Request $request)
    {
        $userIndex = $this->algoliaClient->initIndex('users');
        $results = $userIndex->search($request->query('q'));
        
        return view('users.search', compact('results'));
    }

    public function searchProducts(Request $request)
    {
        $productIndex = $this->algoliaClient->initIndex('products');
        $results = $productIndex->search($request->query('q'));
        
        return view('products.search', compact('results'));
    }
}

If you prefer a more lightweight approach without dependency injection, a trait lets you add Algolia functionality to any controller with minimal code.

步骤1：创建Trait #

Create a new trait file at app/Traits/UsesAlgolia.php:

<?php

namespace App\Traits;

use AlgoliaSearch\Client;
use AlgoliaSearch\Index;

trait UsesAlgolia
{
    protected ?Client $algoliaClient = null;
    protected ?Index $algoliaIndex = null;

    /**
     * Initialize Algolia client and default index
     */
    protected function initAlgolia(): void
    {
        if (!$this->algoliaClient) {
            $this->algoliaClient = new Client(
                config('services.algolia.id'),
                config('services.algolia.secret')
            );
        }

        if (!$this->algoliaIndex) {
            $this->algoliaIndex = $this->algoliaClient->initIndex(
                config('services.algolia.default_index')
            );
        }
    }

    /**
     * Convenience method for search (optional)
     */
    protected function algoliaSearch(string $query, array $options = []): array
    {
        $this->initAlgolia();
        return $this->algoliaIndex->search($query, $options);
    }
}

步骤2：在控制器中使用Trait #

Simply use the trait in any controller and call the methods:

<?php

namespace App\Http\Controllers;

use App\Traits\UsesAlgolia;
use Illuminate\Http\Request;

class BlogController extends Controller
{
    use UsesAlgolia;

    public function search(Request $request)
    {
        // Use the convenience method
        $results = $this->algoliaSearch($request->query('q'));

        // Or use the raw index instance
        // $this->initAlgolia();
        // $results = $this->algoliaIndex->search($request->query('q'));

        return view('blog.search', compact('results'));
    }
}

• Service Provider: Recommended for most projects. It follows Laravel's best practices, supports dependency injection (great for testing), and keeps your code decoupled.
• Trait: Good for small projects or when you want a quick, low-boilerplate way to add Algolia access across controllers. It's less flexible for testing but faster to implement.

内容的提问来源于stack exchange，提问作者Kiow