Symfony MongoDB Integration

Por que usar MongoDB em um aplicativo Symfony?

Ao usar o MongoDB como um armazenamento de dados em um aplicação web Symfony, você pode aproveitar o modelo de dados do documento para criar expressões de query ricas, permitindo que você interaja facilmente com os dados. Você também pode personalizar suas conexões para persistir e acessar dados de e para vários bancos de dados e collections.

Em seus aplicativos, você pode implementar o Doctrine MongoDB ODM, que é um mapeador de documentos de objetos (ODM) para MongoDB e PHP. Ele fornece uma maneira de trabalhar com o MongoDB no Symfony, usando os mesmos princípios do Doctrine ORM para bancos de dados relacionais.

O Doctrine ODM permite mapear objetos PHP para documentos do MongoDB e consultar o MongoDB usando uma API de construtor. Esse mapeamento permite que você use outros recursos do MongoDB , como design de esquema flexível e pesquisas avançadas. Para saber mais sobre esta biblioteca, consulte a seção Recursos .

Pré-requisitos

Para criar o aplicativo Quick Start, você precisa do seguinte software instalado em seu ambiente de desenvolvimento:

• PHP

• Composer

• Symfony CLI

• Um aplicativo de terminal e shell. Para usuários do MacOS, use o Terminal ou um aplicativo semelhante. Para usuários do Windows, use o PowerShell.

Criar um cluster MongoDB Atlas

Você deve criar um cluster MongoDB onde pode armazenar e gerenciar seus dados. Complete o guia Iniciar com Atlas para configurar uma nova conta Atlas e criar um agrupamento MongoDB de camada grátis . Este tutorial também demonstra como carregar conjuntos de dados de exemplo em seu cluster, incluindo os dados usados neste tutorial.

Você fornece instruções ao driver sobre onde e como se conectar ao cluster MongoDB fornecendo a ele uma string de conexão. Para recuperar a string de conexão, siga as instruções no tutorial Conectar ao Cluster na documentação do Atlas .

Instalar extensão MongoDB

Para saber mais sobre como instalar a extensão MongoDB, consulte o tutorial Introdução à biblioteca PHP.

Inicializar um projeto Symfony

Execute o seguinte comando para criar um projeto de estrutura do Symfony chamado restaurants:

composer create-project symfony/skeleton restaurants

Instale o Driver PHP e o Doctrine ODM

Insira o diretório do projeto e, em seguida, adicione o driver MongoDB PHP e o pacote Doctrine ODM ao seu aplicação. O pacote integra a biblioteca ODM ao Symfony para que você possa ler e escrever objetos no MongoDB. A instalação do pacote também adiciona automaticamente o driver ao seu projeto. Para saber mais, consulte a seção Recursos deste guia.

Execute os seguintes comandos para instalar o ODM:

composer require doctrine/mongodb-odm-bundle

Do you want to execute this recipe?

Para garantir que o Doctrine ODM esteja ativado em seu projeto, verifique se o arquivo config/bundles.php contém a entrada destacada no código a seguir:

return [
    // ...
    Doctrine\Bundle\MongoDBBundle\DoctrineMongoDBBundle::class => ['all' => true],
];

doctrine_mongodb:
  auto_generate_proxy_classes: true
  auto_generate_hydrator_classes: true
  connections:
    default:
      server: "%env(resolve:MONGODB_URL)%"
  default_database: "%env(resolve:MONGODB_DB)%"
  document_managers:
    default:
      auto_mapping: true
      mappings:
        App:
          dir: "%kernel.project_dir%/src/Document"
          mapping: true
          type: attribute
          prefix: 'App\Document'
          is_bundle: false
          alias: App

Instalar dependência frontend

Este projeto utiliza o twig, o mecanismo de modelo padrão para Symfony, para gerar modelos neste aplicação. Execute o seguinte comando para instalar o pacote twig :

composer require symfony/twig-bundle

Modificar arquivos do projeto

Esta seção demonstra como modificar os arquivos em seu projeto do restaurants para criar um aplicação web Symfony que exibe restaurantes que correspondem aos critérios especificados.

...
MONGODB_URL=<your Atlas connection string>
MONGODB_DB=sample_restaurants

<?php
declare(strict_types=1);
namespace App\Document;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ODM\MongoDB\Mapping\Annotations as ODM;
#[ODM\Document(collection: 'restaurants')]
class Restaurant
{
    #[ODM\Id]
    public ?string $id = null;
    #[ODM\Field]
    public string $name;
    #[ODM\Field]
    public string $borough;
    #[ODM\Field]
    public string $cuisine;
}

<?php
declare(strict_types=1);
namespace App\Controller;
use App\Document\Restaurant;
use Doctrine\ODM\MongoDB\DocumentManager;
use MongoDB\BSON\Regex;
use Psr\Log\LoggerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
class RestaurantController extends AbstractController
{
    private DocumentManager $dm;
    private LoggerInterface $logger;
    public function __construct(DocumentManager $dm, LoggerInterface $logger)
    {
        $this->dm = $dm;
        $this->logger = $logger;
    }
    #[Route('/', name: 'restaurant_index', methods: ['GET'])]
    public function index(Request $request): Response
    {   
        return $this->render('restaurant/index.html.twig');
    }
    #[Route('/restaurant/browse', name: 'restaurant_browse', methods: ['GET'])]
    public function browse(Request $request): Response
    {
        $restaurantRepository = $this->dm->getRepository(Restaurant::class);
        $queryBuilder = $restaurantRepository->createQueryBuilder();
        $restaurants = $queryBuilder
                ->field('borough')->equals('Queens')
                ->field('name')->equals(new Regex('Moon', 'i'))
                ->getQuery()
                ->execute();
        return $this->render('restaurant/browse.html.twig', ['restaurants' => $restaurants]);
    }
}

{# templates/restaurant/index.html.twig #}
{% extends 'base.html.twig' %}
{% block body %}
    <h1>Welcome to the Symfony MongoDB Quickstart!</h1>
{% endblock %}

{# templates/restaurant/browse.html.twig #}
   
{% extends 'base.html.twig' %}
{% block title %}
    Search Restaurants
{% endblock %}
{% block body %}
    <h1>Search Restaurants</h1>
        {% for restaurant in restaurants %}
            <p>
                <span style="color:deeppink;"><b>Name: </b>{{ restaurant.name }}</span><br>
                <b>Borough:</b> {{ restaurant.borough }}<br>
                <b>Cuisine:</b> {{ restaurant.cuisine }}<br>
            </p>
        {% endfor %}
{% endblock %}

Inicie seu aplicativo Symfony

Execute o seguinte comando a partir do diretório raiz do aplicativo para iniciar seu servidor da web integrado no PHP:

symfony server:start

Após o servidor iniciar, ele gera a seguinte mensagem:

[OK] Web server listening
     The Web server is using PHP FPM 8.3.4
     http://127.0.0.1:8000

Abra a URL http://127.0.0.1:8000/restaurant/browse em seu navegador. A página mostra uma lista de restaurantes e detalhes sobre cada um deles, conforme exibido na seguinte captura de tela:

Parabéns por concluir o tutorial de início rápido!

Depois de concluir essas etapas, você tem um aplicação web do Symfony que se conecta à implementação do MongoDB , executa uma query nos dados de amostra e renderiza um resultado recuperado.