1. Introdução
O PDF do documento está |AQUI|.
Os códigos do documento estão |AQUI|.
Este documento é um produto da IA Claude, da Anthropic. Ele dá seguimento ao documento “Introdução passo a passo ao framework web [Laravel]” (2026), que por sua vez deu seguimento aos documentos “Introdução passo a passo ao framework web [Flask],” "Introdução passo a passo ao framework web [Spring MVC]," "Introdução passo a passo ao framework web [ASP.NET Core MVC]" e "Introdução passo a passo ao framework web [NestJS]" (2026). Este documento permanece no universo [PHP], mas muda de framework:
- o framework [Laravel] é substituído pelo framework [Symfony] 8.1, ainda com a linguagem [PHP] (versão 8.4 ou posterior);
- as views [Blade] são substituídas por views [Twig], a engine de views do [Symfony];
- a validação por meio das regras do [Laravel] e das requisições de formulário ([FormRequest]) é substituída pelo componente Validator do [Symfony] (restrições, escritas como atributos [PHP]) e por seu componente Form, que descreve os formulários por meio de classes;
- os guards, os middlewares e os componentes [Gate] do [Laravel] são substituídos pelo componente Security do [Symfony]: firewalls, autenticadores, papéis, hash de senhas e um limitador de tentativas, complementado pela biblioteca [firebase/php-jwt] para tokens JWT;
- Os middlewares, no entanto, não existem no [Symfony]: event listeners são usados para intervir no processamento da requisição;
- o ORM [Eloquent] é substituído pelo [Doctrine], o ORM associado ao [Symfony], que por sua vez trabalha com o banco [MySQL].
O documento segue de perto a estrutura do curso de [Laravel]: primeiro, vários pequenos projetos, cada um centrado em um único conceito, seguidos de um estudo de caso completo — uma aplicação web de agendamento de consultas em um consultório médico — com todos os arquivos integralmente comentados. Os exemplos têm os mesmos números e abordam os mesmos temas que nos cursos de [Laravel], [Flask], [Spring MVC], e [ASP.NET Core MVC]: um leitor que conheça um desses cursos pode comparar os frameworks caso a caso. No entanto, isso não é necessário: este documento é autossuficiente e não pressupõe nenhum conhecimento prévio desses frameworks. Os únicos pré-requisitos são noções básicas de programação web (o protocolo HTTP, a linguagem HTML) e os fundamentos da linguagem [PHP] (variáveis, arrays, funções, classes). O curso “Introdução à linguagem PHP7 por meio de exemplos” (2019) apresenta a própria linguagem para quem precisa aprendê-la primeiro; os recursos novos do [PHP] 8 usados aqui (propriedades promovidas, classes [readonly], atributos, enumerações, argumentos nomeados, operador null-safe etc.) são explicados quando aparecem pela primeira vez.
1.1. O papel do Symfony em uma aplicação web
Uma aplicação web costuma ser construída em camadas, e cada camada se comunica apenas com as camadas vizinhas:

- a camada web recebe as requisições HTTP do navegador e devolve a ele páginas HTML. É a camada que o [Symfony] nos ajuda a escrever;
- a camada de negócio contém as regras de negócio da aplicação (por exemplo, “um paciente só pode ter uma consulta futura”). Ela não sabe nada sobre a web: poderia igualmente atender a uma aplicação de linha de comando;
- a camada de acesso a dados (camada DAO, de Data Access Object) lê e grava no banco de dados. Usaremos o [Doctrine], o ORM (Object Relational Mapper) associado ao [Symfony], que mapeia linhas de tabelas em objetos [PHP].
A própria camada web segue o padrão MVC (Model-View-Controller):
- o controller (C) é uma classe [PHP] cujos métodos, chamados de actions, tratam cada um um tipo específico de requisição (por exemplo, [GET /schedule]). Uma action lê os parâmetros da requisição, processa-a por meio da camada de negócio e, em seguida, escolhe a view a exibir;
- o modelo (M) é o conjunto de dados que a action passa à view;
- a view (V) é um arquivo [Twig] (extensão [.html.twig]): uma página HTML que contém expressões [{{ ... }}] e instruções [{% if %}], [{% for %}]... que o motor [Twig] substitui pelos dados do modelo.
Uma observação sobre a terminologia, para evitar confusão: no [Symfony], as classes que representam tabelas do banco de dados são chamadas de entidades (pasta [src/Entity]). Neste documento, o termo “modelo” sempre se referirá, portanto, ao modelo da view (os dados passados a uma view) ou, no Capítulo 2, ao modelo da action (os dados que ela recebe). O termo “template” designa a view comum da qual as outras páginas herdam (capítulo sobre views).
O processamento de uma requisição segue as etapas numeradas do diagrama:
- 1: O navegador envia uma requisição HTTP, como [GET /schedule?doctorId=1&day=2026-09-26];
- 2: O servidor web recebe a requisição e a repassa à aplicação [Symfony] por meio do arquivo [public/index.php]. Durante o desenvolvimento, esse servidor é o que acompanha o [PHP], iniciado pelo comando [php -S localhost:8000 -t public]; em produção, será um servidor como o [nginx] ou o [Apache], associado ao [PHP-FPM]. O arquivo [public/index.php] repassa a requisição ao núcleo (kernel) da aplicação, que a faz passar por uma série de eventos: participam classes do [Symfony] e da aplicação, bem como listeners (sessão, segurança, idioma etc.). Um deles compara o caminho solicitado com as rotas da aplicação e seleciona a action responsável por essa requisição: é o roteamento;
- 3: A action solicita à camada de negócio os dados de que precisa; se necessário, a camada de negócio recorre à camada DAO, que consulta o banco de dados [MySQL] em SQL;
- 4: A action constrói o modelo M da view e instrui o motor [Twig] a gerar a página (método [render]);
- 5: A página HTML gerada pela view é a resposta da action, que o [Symfony] devolve ao navegador.
O [Symfony] é, junto com o [Laravel], um dos dois grandes frameworks web do mundo [PHP]. Gratuito e de código aberto, criado em 2005 por Fabien Potencier (e pela empresa francesa SensioLabs), funciona em qualquer lugar em que funcione o [PHP] ([Windows], [Linux], [macOS]), e o [PHP] funciona em quase todas as hospedagens web. [Symfony] é antes de tudo uma coleção de cerca de cinquenta componentes — bibliotecas independentes (requisições e respostas HTTP, roteamento, console, formulários, validação, segurança etc.) — tão bem conceituados que outros projetos os utilizam: o [Laravel] próprio é construído sobre vários deles, e os leitores do curso anterior já os encontraram. O framework [Symfony] reúne esses componentes por meio de bundles (pacotes de integração) e de um contêiner de serviços que cria os objetos da aplicação. Em comparação com o [Laravel], o [Symfony] faz escolhas claras: nada de facades nem de funções globais, mas serviços obtidos por injeção de dependência; configuração explícita em arquivos YAML; atributos [PHP] ([#[Route]], [#[Assert\NotBlank]]...) para descrever o código; e um ORM, o [Doctrine], que separa os objetos de sua persistência. É um framework renomado por seu rigor, sua documentação e sua política de versionamento: uma versão menor a cada seis meses, uma versão de “suporte de longo prazo” a cada dois anos e a garantia de que uma aplicação sem avisos de obsolescência passará para a próxima versão principal sem modificações. [Symfony] pode criar servidores que devolvem JSON a um cliente [JavaScript] ([Angular], [React], [Vue.js], [Flutter]...), assim como aplicações web tradicionais, em que o servidor gera as páginas HTML e o navegador se limita a exibi-las. É esse segundo caso de uso que este documento examina.
Uma particularidade do [PHP] explica muito do [Symfony]: a aplicação é reconstruída a cada requisição e depois descartada (exemplo 01). [Symfony] compensa esse custo compilando sua configuração de uma vez por todas em código [PHP], que é armazenado em um cache (pasta [var/cache]). Voltaremos a isso com frequência.
1.2. Ferramentas utilizadas
Os exemplos foram escritos e testados com as seguintes ferramentas (sua instalação é descrita no apêndice):
- [PHP] 8.4 (qualquer versão 8.4 ou posterior serve), com as extensões [intl], [mbstring], [openssl], e [pdo_mysql];
- [Composer] 2, o gerenciador de bibliotecas do [PHP];
- o editor [Visual Studio Code], com as extensões [PHP Intelephense] (análise de código), [Twig Language 2] (views) e [YAML] (arquivos de configuração);
- um navegador moderno ([Chrome], [Firefox], [Edge]);
- a ferramenta de linha de comando [curl], que exibe as respostas HTTP brutas (ela acompanha o [Windows] 10 e 11);
- um SGBD, [MySQL] (ou [MariaDB]), por exemplo, o do [Laragon] no [Windows], a partir do capítulo sobre acesso a dados e para o estudo de caso. No [Windows], o [Laragon] instala o [PHP], o [Composer] e o [MySQL] de uma só vez.
O [Symfony] e as demais bibliotecas não fazem parte do [PHP]: [Composer] as baixa do repositório [Packagist] durante a instalação (portanto, é preciso estar conectado à Internet nesse dia) e as coloca em uma pasta [vendor]. Cada projeto descreve suas bibliotecas em um arquivo [composer.json]. A tabela a seguir lista as principais, com as versões utilizadas:
[symfony/framework-bundle] | o framework: núcleo, roteamento, controllers, contêiner de serviços, configuração, sessão, cache; ele instala os componentes de que precisa ([symfony/http-foundation], [symfony/http-kernel], [symfony/routing], [symfony/dependency-injection]...) | 8.1.7 |
[symfony/twig-bundle], [twig/twig] | as views [Twig] (capítulo sobre views) | 8.1.7, 3.30.0 |
[symfony/validator], [symfony/form] | Validação (a partir do Exemplo 08) e formulários (a partir do Exemplo 17) | 8.1.7 |
[symfony/security-bundle] | Autenticação e autorização (capítulo sobre segurança) | 8.1.7 |
[symfony/translation] | Traduções (exemplos 09 e 22) | 8.1.7 |
[doctrine/orm], [doctrine/dbal], [doctrine/doctrine-bundle] | acesso ao banco de dados (exemplo 28 e estudo de caso) | 3.7.2, 4.5.0, 3.3.2 |
[firebase/php-jwt] | tokens JWT (capítulo sobre autenticação) | 7.2.0 |
O [Symfony] normalmente é instalado criando-se um projeto completo com o comando:
ou com a ferramenta de linha de comando do [Symfony] (o programa [symfony]; veja os apêndices): [symfony new my-project --webapp]. [Composer] baixa então o esqueleto de uma aplicação [Symfony] e, em seguida, suas bibliotecas. O esqueleto também contém o [Symfony Flex], um plugin do [Composer] que, a cada vez que uma biblioteca ([composer require twig]) é instalada, escreve seus próprios arquivos de configuração a partir de templates publicados on-line. É assim que se inicia um projeto real. Para o aprendizado, esse método tem um inconveniente: os arquivos aparecem sozinhos, sem que se saiba para que servem. Os exemplos deste documento partem, portanto, da outra extremidade: o Exemplo 01 é a menor aplicação [Symfony] possível, e cada exemplo acrescenta apenas os arquivos de que precisa, escritos e comentados à mão. O estudo de caso final segue a estrutura de uma aplicação [Symfony] padrão.
1.3. Executar o estudo de caso
1.3.1. Instalação do Laragon
O estudo de caso requer um SGBD, o MySQL, um interpretador PHP e o instalador de pacotes PHP [composer]. O Laragon pode fornecer tudo isso e muito mais. Em setembro de 2026, o Laragon está disponível na URL [Download Laragon – Fast & Modern Dev Environment ]. O Laragon vem com ferramentas que permitem instalar um servidor PHP e o SGBD [MySQL]:

- em [1], um servidor web Apache;
- em [2], o SGBD [MySQL];
- em [3], uma ferramenta de mensagens que não usaremos;
- [4] inicia todos os serviços (Apache, [MySQL], MailPit);
- [5] exibe a página web da URL [http://localhost]. Por padrão, essa URL corresponde à pasta <laragon-install>\www, em que <laragon-install> é a pasta de instalação do Laragon;
- em [6], inicia a ferramenta HeidiSQL, que permite gerenciar bancos de dados MySQL. Usaremos essa ferramenta para criar o banco de dados do estudo de caso;
- em [7], abre um terminal; todos os binários necessários ao Laragon estão no PATH;
- em [8], abre uma janela do Windows Explorer na pasta associada à URL [http://localhost];
A pasta de instalação do Laragon contém os seguintes itens:
![]() |
- Em [1], a pasta [bin] contém numerosas aplicações:
![]() |
- em [1], o servidor web Apache;
- em [2], um terminal de linha de comando;
- em [3], um cliente [git] que permite gerenciar as diferentes versões de um projeto;
- em [4], um gerenciador de bancos de dados;
- em [5], um gerenciador de e-mails;
- em [6], o SGBD [MySQL];
- em [7], outro servidor web;
- em [8], o [node.js] para executar scripts JavaScript;
- em [9], um editor de texto;
- em [10], o interpretador PHP;
- em [11], o interpretador [Python];
- em [12], um servidor de cache;
O Laragon vem com um ambiente de desenvolvimento completo. Neste curso, usaremos:
- o SGBD [MySQL], [6], e a ferramenta [heidisql] para o gerenciamento gráfico;
- o interpretador PHP 8.5;
- o instalador de pacotes [composer];
O README do estudo de caso indica que é preciso digitar os seguintes comandos em um terminal:
para instalar os pacotes PHP necessários aos exemplos e ao estudo de caso.
para executar um dos exemplos ou o estudo de caso. Se você usar um terminal [PowerShell] dentro do VSCode, encontrará o seguinte problema: nem o [composer] nem o [php] estão no PATH da máquina Windows depois da instalação do Laragon. Por isso, esses comandos não serão reconhecidos em um terminal do VSCode.
Para incluir o [composer] e o [php] no PATH da máquina Windows, abra um terminal PowerShell no modo [administrator] e digite os seguintes comandos:
[Environment]::SetEnvironmentVariable("Path",[Environment]::GetEnvironmentVariable("Path", "Machine") + ";C:\laragon\bin\composer","Machine")
[Environment]::SetEnvironmentVariable("Path",[Environment]::GetEnvironmentVariable("Path", "Machine") + ";C:\laragon\bin\php\php-8.5.11-nts-Win32-vs17-x64","Machine")
Ajuste os dois caminhos destacados ao seu ambiente.
Será preciso reiniciar o VSCode para que essas alterações tenham efeito.
Para criar o banco de dados [MySQL] necessário ao estudo de caso, proceda da seguinte forma:
![]() |
- Em [1], todos os serviços devem estar iniciados;
- em [2], a opção [Database] permite gerenciar o banco de dados;
A opção [Database] inicia um utilitário chamado HeidiSQL:
![]() |
- Em [1], você pode selecionar diversos SGBD. O valor padrão proposto é o SGBD MySQL. Ele serve;
- em [2], você se conecta ao HeidiSQL;
![]() | ![]() |
- Em [1-2], execute o arquivo SQL e, em seguida, selecione o arquivo [dbrdvmedecins2.sql], que você encontrará na pasta [symfony-sept-2026/rdvmedecins2-symfony/database]:

A execução do arquivo [3] criará o banco de dados [dbrdvmedecins2] usado pelo estudo de caso. Para visualizá-lo, pressione F5 no HeidiSQL para atualizar a exibição:
Nota do editor: as capturas de tela a seguir mostram um banco de dados chamado [dbrdvmedecins], enquanto o banco de dados do estudo de caso se chama [dbrdvmedecins2]. Os dois bancos são praticamente idênticos, por isso julgamos desnecessário refazer as capturas.
Fim da nota

O banco de dados [dbrdvmedecins] foi criado. Eis o seu conteúdo:

- em [1-3], a tabela [clients];
- [id] é a chave primária da tabela;
- [version] é o número de versão da linha. Esse número é incrementado a cada modificação da linha;
- [titre, nom, prenom] identificam a pessoa;

- em [1-3], a tabela [medecins];
- [id] é a chave primária da tabela;
- [version] é o número de versão da linha;
- [titre, nom, prenom] identificam a pessoa;

- Em [1-3], a tabela dos horários de consulta dos médicos:
- [id]: chave primária;
- [version]: número de versão da linha;
- [id-medecin]: chave estrangeira que referencia a chave primária do médico;
- [hdebut, mdebut]: hora e minutos do início da consulta. Assim, [8,20] significa 8h20.
- [hfin, mfin]: hora e minutos do fim da consulta.

- Em [1-3], a tabela [rv] das consultas agendadas;
- [id]: chave primária;
- [version]: número de versão;
- [jour]: data da consulta;
- [id_creneau]: chave estrangeira que referencia a chave primária do horário de consulta. Como um horário está ligado a um médico, sabemos qual médico atenderá essa consulta;
- [id_client]: chave estrangeira para o número (chave primária) do paciente que comparece à consulta;

- em [1-3], a tabela [users] lista os usuários autorizados a usar a aplicação RdvMedecins;
- [id, version]: chave primária, número de versão;
- [login, password]: credenciais do usuário;
- [nom]: nome do usuário;
- [role]: o papel do usuário. [ADMIN] tem todos os direitos de acesso. [USER] tem acesso somente de leitura. Esse usuário pode consultar a agenda de um médico, mas não pode marcar nem cancelar uma consulta;
1.3.2. Executando o estudo de caso
Nota do revisor: aconselho o leitor a executar o estudo de caso imediatamente, como descrito a seguir. Depois de compreender bem a finalidade dessa aplicação de agendamento de consultas, peça à sua IA favorita que modifique a aplicação da seguinte forma: a partir de agora, cada médico poderá:
- definir seus próprios horários de consulta entre duas datas. Isso lhe permitirá ajustar a agenda conforme a necessidade;
- retirar certos horários da agenda em um determinado dia — por exemplo, se estiver indisponível por motivos pessoais;
A modificação não é trivial, pois envolve uma mudança na estrutura do banco de dados. Peça à IA que lhe forneça o novo código da aplicação e o script SQL para criar o novo banco de dados. Para isso, será preciso entregar a ela o arquivo ZIP com o projeto completo, bem como o script SQL do banco de dados antigo.
Além disso, não revisei o curso criado pelo Claude. Ele já havia produzido os cursos [NestJS], [ASP.NET Core MVC], [Spring MVC] e [Flask], todos perfeitos. Presumi que o mesmo valesse para este. Se você tiver dificuldade para entender algo, a solução é sempre a mesma: peça à sua IA favorita que explique o que você não entendeu. Claude, por exemplo, é muito bom nisso. Talvez seja preciso fazer o “upload” do exemplo que você não entende para ele.
Fim da nota.
O estudo de caso no final deste documento é uma aplicação completa. Os leitores provavelmente vão querer vê-la em funcionamento antes de mergulhar nos detalhes do framework: veja como executá-la. Ela está na pasta [rdvmedecins2-symfony], ao lado da pasta [examples]:
É preciso ter instalado o [PHP] (versão 8.4 ou posterior), o [Composer], o [Visual Studio Code] e o [MySQL] (veja os apêndices). Em seguida:
- Crie o banco de dados [dbrdvmedecins2] executando o script [rdvmedecins2-symfony/database/dbrdvmedecins2.sql]. Com o [Laragon], abra a ferramenta [HeidiSQL] (botão Database) e execute o script pelo menu File / Run SQL. Na linha de comando, a partir da pasta [rdvmedecins2-symfony]:
- Abra a pasta [rdvmedecins2-symfony] no [Visual Studio Code] (menu File / Open Folder) e, em seguida, abra um terminal (menu Terminal / New Terminal);
- Instale as bibliotecas da aplicação: o [Composer] lê o arquivo [composer.json], baixa o [Symfony] e as demais bibliotecas e as coloca na pasta [vendor] da aplicação (leva algumas dezenas de segundos):
- Verifique a conexão com o banco de dados. A aplicação se conecta ao [MySQL] em [127.0.0.1], porta 3306, com o usuário [root] sem senha (as configurações padrão do [Laragon]). Se a sua conta [root] tiver senha, informe-a no arquivo [.env] da aplicação, na linha [DATABASE_URL]: [mysql://root:myPassword@127.0.0.1:3306/dbrdvmedecins2...];
- Execute a aplicação:
- O [PHP] exibe:
O servidor de desenvolvimento escuta na porta 8081 da máquina ([localhost]). Cada requisição recebida será registrada no console, junto com as mensagens do [Symfony] (a rota selecionada, os comandos SQL enviados ao banco de dados);
- Abra o endereço [http://localhost:8081] em um navegador:

- Faça login com uma das contas de demonstração, cuja senha é igual ao nome de usuário: [admin] (administrador), [pelissier], [tatou], [dupont] (médicos), [martin], [durand], [bistrou], [german] (pacientes). Também é preciso digitar os caracteres da imagem, em maiúsculas ou minúsculas.
Uma aplicação [PHP] não lê o banco de dados na inicialização: um erro de conexão só aparece na primeira página que consulta o banco, ou seja, no momento da conexão. O [Symfony] exibe então sua página de erro detalhada e registra o erro no console do servidor. Se a mensagem for [SQLSTATE[HY000] [2002] Connection refused], significa que o [MySQL] não foi iniciado; com [[1045] Access denied for user 'root'@'localhost'], significa que a senha está incorreta; com [[1049] Unknown database 'dbrdvmedecins2'], significa que o script SQL não foi executado; com [could not find driver], que a extensão [pdo_mysql] do [PHP] não está habilitada. Se a página exibir [Failed opening required '.../vendor/autoload_runtime.php'], significa que o [composer install] não foi executado; se o comando [php -S] falhar com a mensagem [Failed to listen on localhost:8081 (reason: Address already in use)], significa que a porta 8081 já está em uso (por outra versão da aplicação, por exemplo). O arquivo [README.md] da aplicação descreve outros cenários. Pare a aplicação com [Ctrl-C] no terminal.
O estudo de caso no final do documento demonstra como usar a aplicação e, em seguida, explica cada um de seus arquivos.
1.4. Exemplos
Os exemplos ficam na pasta [examples], com uma subpasta por exemplo:
Cada exemplo é uma pequena aplicação ([Symfony]) que funciona sozinha. Todos os exemplos usam as mesmas bibliotecas, descritas no arquivo [examples/composer.json]:
- Linhas 6–29: o que os exemplos exigem: [PHP] 8.4 ou posterior, as extensões [intl] (formatação de números e datas conforme o idioma, Exemplo 16) e [pdo_mysql] (acesso ao [MySQL], exemplo 28), seguidas das bibliotecas, em ordem alfabética: [Doctrine] (exemplo 28), [firebase/php-jwt] (os tokens JWT, exemplo 25) e os componentes e bundles do [Symfony] que os exemplos utilizam. [^8.1] significa “versão 8.1, ou uma versão mais recente da versão principal 8”;
- linhas 30–34: as classes do namespace [Common] ficam na pasta [common] (a regra PSR-4, mostrada no Exemplo 01): é o controller compartilhado que serve o [Bootstrap] (Exemplo 15);
- as demais linhas configuram o comportamento do [Composer]: o carregador de classes é otimizado, as bibliotecas são ordenadas por nome e somente versões estáveis são aceitas.
Para executar os exemplos, instale primeiro suas bibliotecas — uma vez por todas — em uma janela de terminal aberta na pasta [examples]:
O [Composer] cria a pasta [examples/vendor], compartilhada por todos os 28 exemplos, e o arquivo [composer.lock], que registra as versões exatas instaladas (veja o estudo de caso). A pasta [common] contém o framework CSS [Bootstrap] ([common/bootstrap]) — compartilhado pelos exemplos que formatam suas páginas (a partir do Exemplo 15) — e o controller que o serve ([common/BootstrapController.php]; veja o Exemplo 15).
Quase todos os exemplos têm a mesma estrutura — a de uma aplicação [Symfony] padrão, reduzida ao essencial. Por exemplo, a do Exemplo 13:
- [public/index.php]: o ponto de entrada de todas as requisições; [src/Kernel.php]: o núcleo da aplicação; [bin/console]: a ferramenta de linha de comando do [Symfony] (Exemplo 01);
- [config]: a configuração: os bundles da aplicação ([bundles.php]), a configuração de cada um (pasta [packages]), as rotas ([routes.yaml], Exemplo 02) e os serviços ([services.yaml], Exemplo 06);
- [src]: as classes da aplicação: controllers ([src/Controller]), modelos, serviços etc.;
- [templates]: as views [Twig] (a partir do capítulo sobre views);
- [.env]: as configurações específicas do exemplo (Exemplo 01); [var]: os arquivos que o [Symfony] grava por conta própria (o cache, a sessão).
Para executar um exemplo, abra um terminal em sua pasta (no [Visual Studio Code]: clique com o botão direito na pasta do exemplo e selecione “Open in Integrated Terminal”) e digite:
Todos os exemplos escutam na porta 8000: só é possível executar um de cada vez (ou é preciso mudar a porta: [php -S localhost:8001 -t public]). Pare o servidor com [Ctrl-C] no terminal. Não é necessário reiniciar o servidor após modificar um arquivo [PHP], uma view ou a configuração: as alterações passam a valer na requisição seguinte (exemplo 01).
Quando você abre a pasta [examples] no [Visual Studio Code], a extensão [PHP Intelephense] analisa todos os arquivos, inclusive os do [Symfony] na pasta [vendor]: em cada arquivo, você aproveita o preenchimento automático de código, a navegação até a definição de uma classe ou método (tecla [F12]) e a indicação de erros. Como todos os exemplos têm suas classes no namespace [App], a extensão pode sinalizar classes “duplicadas”: isso não tem efeito na execução, pois cada exemplo é executado de forma independente. Para evitar esses avisos, basta abrir a própria pasta do exemplo.
1.5. Conteúdo do documento
O documento está organizado da seguinte forma:
Actions, roteamento, respostas | Da requisição à action: rotas, controllers, respostas, redirecionamentos, serviços compartilhados | 01 a 06 |
O modelo da action | Parâmetros da requisição: binding, conversão, validação, requisições POST | 07 a 12 |
A view e seu template | [Twig], template, macros, formulários [Symfony], validação, PRG, proteção anti-CSRF | 13 a 21 |
Internacionalização | Uma aplicação em francês e inglês | 22 |
Escopo dos dados | requisição, sessão, cache, cookies | 23 |
O ciclo de vida de uma requisição | Eventos do kernel, resolvedores de argumentos, tratamento de exceções | 24 |
Autenticação e autorização | Firewall, autenticador JWT em um cookie, papéis, CAPTCHA, limite de tentativas | 25–27 |
Arquitetura em camadas e acesso a dados | Web / negócio / DAO com [Doctrine] e [MySQL] | 28 |
Estudo de caso | A aplicação RdvMedecins, explicada arquivo por arquivo | - |
Cada exemplo introduz apenas alguns conceitos novos, e os capítulos se apoiam uns nos outros: o melhor é lê-los em ordem. O estudo de caso, por sua vez, mobiliza todos os conceitos dos capítulos anteriores: sempre que pertinente, seu comentário remete ao exemplo em que o conceito foi introduzido. Os apêndices descrevem como instalar as ferramentas: [PHP], [Composer], [Visual Studio Code] e suas extensões, [MySQL] junto com o [Laragon], o [curl] e a ferramenta [symfony].





