In die moderne web ekosisteem, · Dit gaan oor die en As 'n Senior Symfony Ontwikkelaar, weet jy dat LIKE %...% vrae 'n tegniese skuldval is. “search” is not just about finding text performance relevance user experience Hierdie artikel verduidelik hoe om 'n Elasticsearch-integrasie in Symfony 7.4. Ons is nie net 'n bundel te installeer nie; ons bou 'n veerkragtige, nul-downtime-soekarchitektuur met behulp van die en vir . production-grade PHP 8.4 features Attributes Symfony Messenger asynchronous indexing Die architektuur: prestasie en veerkragtigheid In 'n junior implementasie sal 'n entiteit-update 'n sinchrone HTTP-oproep na Elasticsearch veroorsaak. As Elastic af is, kan u gebruiker nie hul data red nie. Ons produksie strategie: 
 
 
 
 Zero-Downtime Indexing: Ons skryf nooit direk na die live-indeks nie. Ons skryf na 'n tydstempel indeks en gebruik 'n Alias om die app na die huidige live weergawe te wys. Async-indeksering: Databasis geskryf word ontkoppel van soek geskryf met behulp van Symfony Messenger. Strikte typing: Ons gebruik DTO's en sterk typed dienste, wat waar moontlik "magie-array's" vermy. Voorwaardes en installasie Ons gebruik die f (v7.0+). Dit bied die beste abstraksie oor die ruwe kliënt terwyl hy aan Symfony se konfigurasie standaarde voldoen. riendsofsymfony/elastica-bundle elasticsearch-php Milieue vereistes: 
 
 
 
 PHP 8.2+ (rekening van 8.4) Die Simfonie 7.4 Geskryf deur Elasticsearch 8.x Afhanklikheid installeer Voer die volgende in jou terminal: composer require friendsofsymfony/elastica-bundle "^7.0"
composer require symfony/messenger
composer require symfony/serializer
 omgewing konfigurasie Voeg jou Die jou In die produksie, maak seker dat dit in 'n geheime bestuurder (soos of die Elasticsearch DSN .env Symfony Secrets HashiCorp Vault # .env
ELASTICSEARCH_URL=http://localhost:9200/
 Die “Zero-Downtime” opstel Dit is waar die meeste tutorials misluk. Hulle stel 'n statiese indeksnaam in. Ons sal 'n aliasstrategie konfigurer om agtergrondreindeksing toe te laat sonder dat die webwerf afneem. Skep of actualiseer : config/packages/fos_elastica.yaml # config/packages/fos_elastica.yaml
fos_elastica:
    clients:
        default:
            url: '%env(ELASTICSEARCH_URL)%'
            # Production Tip: Increase timeout for bulk operations
            config:
                connect_timeout: 5
                timeout: 10

    indexes:
        app_products:
            # "use_alias: true" is critical for zero-downtime reindexing
            use_alias: true 
            
            # Define your distinct settings (analyzers, filters)
            settings:
                index:
                    analysis:
                        analyzer:
                            app_analyzer:
                                type: custom
                                tokenizer: standard
                                filter: [lowercase, asciifolding]

            # Your Persistence strategy (Doctrine integration)
            persistence:
                driver: orm
                model: App\Entity\Product
                provider: ~
                # CRITICAL: We disable the default listener to use Messenger instead
                listener: 
                    insert: false
                    update: false
                    delete: false
                finder: ~

            # Explicit Mapping (Always prefer explicit over dynamic for production)
            properties:
                id: { type: integer }
                name: 
                    type: text 
                    analyzer: app_analyzer
                    fields:
                        keyword: { type: keyword, ignore_above: 256 }
                description: { type: text, analyzer: app_analyzer }
                price: { type: float }
                stock: { type: integer }
                created_at: { type: date }
 Die Domain Layer Kom ons veronderstel 'n standaard produk entiteit. Ons gebruik standaard PHP 8 attribute. namespace App\Entity;

use App\Repository\ProductRepository;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity(repositoryClass: ProductRepository::class)]
#[ORM\Table(name: 'products')]
class Product
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(length: 255)]
    private ?string $name = null;

    #[ORM\Column(type: Types::TEXT)]
    private ?string $description = null;

    #[ORM\Column]
    private ?float $price = null;

    #[ORM\Column]
    private ?int $stock = 0;

    #[ORM\Column]
    private ?\DateTimeImmutable $createdAt = null;

    public function __construct()
    {
        $this->createdAt = new \DateTimeImmutable();
    }

    // ... Getters and Setters
    
    public function getId(): ?int
    {
        return $this->id;
    }
    
    // ...
}
 Async indeksering met Messenger (Die Senior Pattern) In plaas van die laat vertraag ons gebruikersverzoeke deur onmiddellik te indexeer, sal ons 'n boodskap na 'n ry stuur. fos_elastica Die boodskap Eenvoudig die identiteit van die entiteit wat verander het. DTO (Data Transfer Object) namespace App\Message;

final readonly class IndexProductMessage
{
    public function __construct(
        public int $productId,
        // 'index' or 'delete'
        public string $action = 'index'
    ) {}
}
 Die Lifecycle Event Abonneer Ons luister na Doctrine gebeure om ons boodskap outomaties te stuur. namespace App\EventListener;

use App\Entity\Product;
use App\Message\IndexProductMessage;
use Doctrine\Bundle\DoctrineBundle\Attribute\AsDoctrineListener;
use Doctrine\ORM\Event\PostPersistEventArgs;
use Doctrine\ORM\Event\PostRemoveEventArgs;
use Doctrine\ORM\Event\PostUpdateEventArgs;
use Doctrine\ORM\Events;
use Symfony\Component\Messenger\MessageBusInterface;

#[AsDoctrineListener(event: Events::postPersist, priority: 500, connection: 'default')]
#[AsDoctrineListener(event: Events::postUpdate, priority: 500, connection: 'default')]
#[AsDoctrineListener(event: Events::postRemove, priority: 500, connection: 'default')]
class ProductIndexerSubscriber
{
    public function __construct(
        private MessageBusInterface $bus
    ) {}

    public function postPersist(PostPersistEventArgs $args): void
    {
        $this->dispatch($args->getObject(), 'index');
    }

    public function postUpdate(PostUpdateEventArgs $args): void
    {
        $this->dispatch($args->getObject(), 'index');
    }

    public function postRemove(PostRemoveEventArgs $args): void
    {
        // When removing, we still need the ID, but the object is technically gone from DB.
        // Ensure you capture the ID before it's fully detached if needed, 
        // but postRemove usually still has access to the object instance.
        $this->dispatch($args->getObject(), 'delete');
    }

    private function dispatch(object $entity, string $action): void
    {
        if (!$entity instanceof Product) {
            return;
        }

        $this->bus->dispatch(new IndexProductMessage($entity->getId(), $action));
    }
}
 Die handelaar Dit is waar die werklike werk plaasvind in die agtergrondwerkers. namespace App\MessageHandler;

use App\Entity\Product;
use App\Message\IndexProductMessage;
use App\Repository\ProductRepository;
use FOS\ElasticaBundle\Persister\ObjectPersisterInterface;
use Symfony\Component\Messenger\Attribute\AsMessageHandler;

#[AsMessageHandler]
final class IndexProductHandler
{
    public function __construct(
        // Inject the specific persister for 'app_products' index
        // The service ID usually follows the pattern fos_elastica.object_persister.<index_name>.<type_name>
        // Or you can bind it via services.yaml if autowiring fails
        private ObjectPersisterInterface $productPersister,
        private ProductRepository $productRepository
    ) {}

    public function __invoke(IndexProductMessage $message): void
    {
        if ($message->action === 'delete') {
             // For deletion, we can't fetch the entity as it's gone. 
             // We pass the ID directly to the persister.
             // Note: In some setups, you might need a stub object or just the ID.
             // The ObjectPersisterInterface typically expects an object, 
             // but strictly speaking, Elastica needs an ID. 
             // A cleaner way for delete is often using the Elastica Client directly 
             // if the Persister insists on an Entity object.
             // For simplicity here, we assume the persister handles ID lookups or we use a custom service.
             
             // Production-grade approach: Use the Raw Index Service for deletes to avoid hydration issues
             // But for this example, let's focus on Indexing.
             return; 
        }

        $product = $this->productRepository->find($message->productId);

        if (!$product) {
            // Product might have been deleted before this worker ran
            return;
        }

        // This pushes the single object to Elasticsearch
        $this->productPersister->replaceOne($product);
    }
}
 Jy moet die persister uitdruklik in Twee motorfietse korrek, of gebruik 'n attribuut as jy verskeie indekse het. services.yaml ObjectPersisterInterface #[Target] # config/services.yaml
services:
    _defaults:
        bind:
            # Bind the specific persister to the argument name or type
            $productPersister: '@fos_elastica.object_persister.app_products'
 Soek: Die repository patroon Moenie Elastica logika in jou bestuurders plaas nie. Maak 'n toegewyde diens. namespace App\Service\Search;

use FOS\ElasticaBundle\Finder\TransformedFinder;

class ProductSearchService
{
    public function __construct(
        // The TransformedFinder returns Doctrine Entities. 
        // If you want raw speed and arrays, use the 'index' service directly.
        private TransformedFinder $productFinder
    ) {}

    /**
     * @return array<int, \App\Entity\Product>
     */
    public function search(string $query, int $limit = 20): array
    {
        // Elastica Query Builder
        $boolQuery = new \Elastica\Query\BoolQuery();
        
        // Match name or description
        $matchQuery = new \Elastica\Query\MultiMatch();
        $matchQuery->setQuery($query);
        $matchQuery->setFields(['name^3', 'description']); // Boost name by 3x
        $matchQuery->setFuzziness('AUTO'); // Handle typos
        
        $boolQuery->addMust($matchQuery);
        
        // Filter by stock (only in stock items)
        $stockFilter = new \Elastica\Query\Range('stock', ['gt' => 0]);
        $boolQuery->addFilter($stockFilter);

        $elasticaQuery = new \Elastica\Query($boolQuery);
        $elasticaQuery->setSize($limit);

        // Returns Hydrated Doctrine Objects
        return $this->productFinder->find($elasticaQuery);
    }
}
 Verifikasie & Invoering Maak die indeks Voordat jou app kan werk, moet jy die indeks initieel. php bin/console fos:elastica:create
 Bevolkingsdata (inisiële lading) As jy bestaande data in MySQL het, druk dit na Elastic. php bin/console fos:elastica:populate
 Hierdie opdrag gebruik die Zero-Downtime-logika: dit skep 'n nuwe indeks, vul dit in en skakel dan atomies die alias. Kyk na die CURL Kyk of jou kaarte korrek is direk in Elastic. curl -X GET "http://localhost:9200/app_products/_mapping?pretty"
 Konklusie Jy het nou 'n soektogarchitektuur wat: 
 
 
 
 Survives DB loading: Soektog tref Elastic, nie MySQL nie. Survives Elastic downtime: boodskappe waai op in Messenger (RabbitMQ/Redis) en herhaal later. Survives Reindexing: Jy kan jou analiseurs en kaarte verander, fos:elastica:populate hardloop en gebruikers sal nie iets sien nie. Dit is die standaard vir hoë-prestasie Symfony-toepassings. Kom ons bly in kontak met my op LinkedIn [ ] vir meer PHP & Symfony argitektuur insigte. https://www.linkedin.com/in/matthew-mochalkin/ https://www.linkedin.com/in/matthew-mochalkin/

Read My Stories

Hierdie oudio word in die oorspronklike taal van die storie vervaardig!

Symfony-soektog wat nie afgaan nie: Zero-Downtime Elasticsearch + Async-indeksering

About Author

KOMMENTAAR

HANG TAGS

HIERDIE ARTIKEL IS AANGEBIED IN

Related Stories

"What If ... I didn't Do It?"

The Opt Out Writing Contest: Final Round Results Announcement 🎉

The AI Writing Contest by Bright Data & HackerNoon: Results Announcement 🎉

Startups of The Year: Meet the Business Industry

"What If ... I didn't Do It?"

The Opt Out Writing Contest: Final Round Results Announcement 🎉

The AI Writing Contest by Bright Data & HackerNoon: Results Announcement 🎉

Startups of The Year: Meet the Business Industry

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps