Symfony 7: API Platform e Boas Praticas
Guia completo para criar APIs REST profissionais com Symfony 7 e API Platform 4. State Providers, Processors, validacao e serializacao explicados.

O API Platform 4 transforma a criacao de APIs REST e GraphQL com Symfony. A versao 4.4, lancada em setembro de 2026, traz filtros composables, a depreciacao dos decoradores #[ApiFilter] e suporte nativo ao OpenAPI 3.2. Combinado com o container de servicos e autowiring do Symfony, construir uma API profissional se torna simples.
A versao 4.4 deprecia os decoradores #[ApiFilter] legados (remocao prevista para a 6.0) em favor de filtros composables como ComparisonFilter, OrFilter e ChainFilter. O Scalar UI substitui o Swagger UI por padrao desde a 4.3, e o OpenAPI 3.2 agora tem suporte completo. Consulte as notas de versao oficiais para o guia de migracao.
Instalacao e Configuracao Inicial
O API Platform e instalado em poucos comandos com o Symfony Flex. A configuracao padrao cobre a maioria dos casos de uso e permanece totalmente personalizavel.
# terminal
# Create a new Symfony project with API Platform
composer create-project symfony/skeleton my-api
cd my-api
# Install API Platform with Doctrine ORM
composer require api
# Verify installation
php bin/console debug:router | grep apiO Symfony Flex configura automaticamente as rotas, a documentacao OpenAPI e a interface Scalar UI acessivel em /api. A documentacao do API Platform detalha todas as opcoes de configuracao.
# config/packages/api_platform.yaml
api_platform:
title: 'My API'
version: '1.0.0'
# Supported response formats
formats:
jsonld: ['application/ld+json']
json: ['application/json']
# OpenAPI documentation
swagger:
versions: [3]
# Default pagination
defaults:
pagination_items_per_page: 30
pagination_maximum_items_per_page: 100Essa configuracao define os formatos de serializacao, a paginacao global e os metadados da documentacao da API.
Criacao de um Recurso API Simples
O atributo #[ApiResource] expoe uma entidade Doctrine como recurso REST. O API Platform gera automaticamente os endpoints CRUD, a documentacao OpenAPI e as validacoes basicas.
<?php
// src/Entity/Book.php
namespace App\Entity;
use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Post;
use ApiPlatform\Metadata\Put;
use ApiPlatform\Metadata\Patch;
use ApiPlatform\Metadata\Delete;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;
#[ORM\Entity]
#[ApiResource(
// Explicit definition of available operations
operations: [
new GetCollection(),
new Post(),
new Get(),
new Put(),
new Patch(),
new Delete(),
],
// Default ordering for collections
order: ['publishedAt' => 'DESC'],
// Pagination configuration for this resource
paginationItemsPerPage: 20
)]
class Book
{
#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column]
private ?int \ = null;
#[ORM\Column(length: 255)]
#[Assert\NotBlank(message: 'Title is required')]
#[Assert\Length(min: 2, max: 255)]
private ?string \ = null;
#[ORM\Column(type: 'text')]
#[Assert\NotBlank]
private ?string \ = null;
#[ORM\Column(length: 13, unique: true)]
#[Assert\Isbn]
private ?string \ = null;
#[ORM\Column]
private ?\DateTimeImmutable \ = null;
// Getters and setters...
public function getId(): ?int
{
return \->id;
}
public function getTitle(): ?string
{
return \->title;
}
public function setTitle(string \): static
{
\->title = \;
return \;
}
public function getDescription(): ?string
{
return \->description;
}
public function setDescription(string \): static
{
\->description = \;
return \;
}
public function getIsbn(): ?string
{
return \->isbn;
}
public function setIsbn(string \): static
{
\->isbn = \;
return \;
}
public function getPublishedAt(): ?\DateTimeImmutable
{
return \->publishedAt;
}
public function setPublishedAt(\DateTimeImmutable \): static
{
\->publishedAt = \;
return \;
}
}Essa entidade gera seis endpoints: GET /api/books, POST /api/books, GET /api/books/{id}, PUT /api/books/{id}, PATCH /api/books/{id} e DELETE /api/books/{id}.
O API Platform suporta nativamente o UUID v7 como identificador. Essa abordagem melhora a seguranca (identificadores nao previsiveis) e o desempenho (ordenacao natural por data de criacao).
Grupos de Serializacao para Controlar Dados Expostos
Os grupos de serializacao definem com precisao quais propriedades sao expostas para leitura (normalizacao) e escrita (desnormalizacao). Essa separacao e essencial para a seguranca e flexibilidade da API. Para cenarios de serializacao complexos, o componente Serializer do Symfony oferece opcoes adicionais de personalizacao.
<?php
// src/Entity/User.php
namespace App\Entity;
use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Post;
use ApiPlatform\Metadata\Put;
use ApiPlatform\Metadata\Patch;
use ApiPlatform\Metadata\Delete;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Serializer\Annotation\Groups;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
use App\State\UserPasswordHasher;
#[ORM\Entity]
#[ORM\Table(name: '`user`')]
#[UniqueEntity('email')]
#[ApiResource(
operations: [
new GetCollection(),
// Custom processor for password hashing
new Post(processor: UserPasswordHasher::class,
validationContext: ['groups' => ['Default', 'user:create']]),
new Get(),
new Put(processor: UserPasswordHasher::class),
new Patch(processor: UserPasswordHasher::class),
new Delete(),
],
// Properties exposed when reading
normalizationContext: ['groups' => ['user:read']],
// Properties accepted when writing
denormalizationContext: ['groups' => ['user:create', 'user:update']],
)]
class User implements UserInterface, PasswordAuthenticatedUserInterface
{
#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column]
#[Groups(['user:read'])]
private ?int \ = null;
#[ORM\Column(length: 180, unique: true)]
#[Assert\NotBlank]
#[Assert\Email]
#[Groups(['user:read', 'user:create', 'user:update'])]
private ?string \ = null;
#[ORM\Column]
private ?string \ = null;
// Never exposed when reading, only when writing
#[Assert\NotBlank(groups: ['user:create'])]
#[Groups(['user:create', 'user:update'])]
private ?string \ = null;
#[ORM\Column(length: 100)]
#[Groups(['user:read', 'user:create', 'user:update'])]
private ?string \ = null;
#[ORM\Column(type: 'json')]
#[Groups(['user:read'])]
private array \ = [];
#[ORM\Column]
#[Groups(['user:read'])]
private ?\DateTimeImmutable \ = null;
public function __construct()
{
\->createdAt = new \DateTimeImmutable();
}
// UserInterface implementation
public function getUserIdentifier(): string
{
return (string) \->email;
}
public function getRoles(): array
{
\ = \->roles;
\[] = 'ROLE_USER';
return array_unique(\);
}
public function getPassword(): string
{
return \->password;
}
public function eraseCredentials(): void
{
\->plainPassword = null;
}
// Getters and setters...
public function getId(): ?int
{
return \->id;
}
public function getEmail(): ?string
{
return \->email;
}
public function setEmail(string \): static
{
\->email = \;
return \;
}
public function setPassword(string \): static
{
\->password = \;
return \;
}
public function getPlainPassword(): ?string
{
return \->plainPassword;
}
public function setPlainPassword(?string \): static
{
\->plainPassword = \;
return \;
}
public function getFullName(): ?string
{
return \->fullName;
}
public function setFullName(string \): static
{
\->fullName = \;
return \;
}
public function setRoles(array \): static
{
\->roles = \;
return \;
}
public function getCreatedAt(): ?\DateTimeImmutable
{
return \->createdAt;
}
}Com essa configuracao, plainPassword nunca e exposto nas respostas, mas pode ser enviado durante a criacao ou atualizacoes.
Pronto para mandar bem nas entrevistas de Symfony?
Pratique com nossos simuladores interativos, flashcards e testes tecnicos.
State Processors para Logica de Negocio
Os State Processors interceptam as operacoes de persistencia para adicionar logica de negocio. O API Platform simplifica sua criacao por meio de injecao de dependencia baseada em atributos.
<?php
// src/State/UserPasswordHasher.php
namespace App\State;
use ApiPlatform\Metadata\Operation;
use ApiPlatform\State\ProcessorInterface;
use App\Entity\User;
use Symfony\Component\DependencyInjection\Attribute\Autowire;
use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
/**
* Processor that hashes password before persistence
* @implements ProcessorInterface<User, User>
*/
final class UserPasswordHasher implements ProcessorInterface
{
public function __construct(
// Injection of standard Doctrine processor
#[Autowire(service: 'api_platform.doctrine.orm.state.persist_processor')]
private ProcessorInterface \,
private UserPasswordHasherInterface \,
) {
}
public function process(mixed \, Operation \, array \ = [], array \ = []): User
{
// Hash password if provided
if (\->getPlainPassword()) {
\ = \->passwordHasher->hashPassword(
\,
\->getPlainPassword()
);
\->setPassword(\);
\->eraseCredentials();
}
// Delegate persistence to standard processor
return \->persistProcessor->process(\, \, \, \);
}
}Esse padrao de composicao permite adicionar qualquer logica (envio de e-mails, eventos, logs) preservando o comportamento padrao de persistencia. Para arquiteturas event-driven, os processors se integram perfeitamente com o Symfony Messenger.
Processor com Logica Condicional
Um processor pode adaptar seu comportamento com base no tipo de operacao.
<?php
// src/State/BookProcessor.php
namespace App\State;
use ApiPlatform\Metadata\DeleteOperationInterface;
use ApiPlatform\Metadata\Operation;
use ApiPlatform\Metadata\Post;
use ApiPlatform\State\ProcessorInterface;
use App\Entity\Book;
use App\Service\NotificationService;
use App\Service\SearchIndexer;
use Symfony\Component\DependencyInjection\Attribute\Autowire;
/**
* @implements ProcessorInterface<Book, Book|void>
*/
final class BookProcessor implements ProcessorInterface
{
public function __construct(
#[Autowire(service: 'api_platform.doctrine.orm.state.persist_processor')]
private ProcessorInterface \,
#[Autowire(service: 'api_platform.doctrine.orm.state.remove_processor')]
private ProcessorInterface \,
private NotificationService \,
private SearchIndexer \,
) {
}
public function process(mixed \, Operation \, array \ = [], array \ = []): mixed
{
// Deletion: use remove processor
if (\ instanceof DeleteOperationInterface) {
\->searchIndexer->remove(\);
return \->removeProcessor->process(\, \, \, \);
}
// Creation: set publication date
if (\ instanceof Post) {
\->setPublishedAt(new \DateTimeImmutable());
}
// Standard persistence
\ = \->persistProcessor->process(\, \, \, \);
// Post-processing: indexing and notification
\->searchIndexer->index(\);
if (\ instanceof Post) {
\->notifications->notifyNewBook(\);
}
return \;
}
}State Providers para Fontes de Dados Personalizadas
Os State Providers buscam dados de qualquer fonte: APIs externas, cache, arquivos ou logica de negocio complexa.
<?php
// src/State/PopularBooksProvider.php
namespace App\State;
use ApiPlatform\Metadata\Operation;
use ApiPlatform\State\ProviderInterface;
use App\Entity\Book;
use App\Repository\BookRepository;
use Symfony\Contracts\Cache\CacheInterface;
use Symfony\Contracts\Cache\ItemInterface;
/**
* Provider that returns popular books with caching
* @implements ProviderInterface<Book>
*/
final class PopularBooksProvider implements ProviderInterface
{
public function __construct(
private BookRepository \,
private CacheInterface \,
) {
}
public function provide(Operation \, array \ = [], array \ = []): array
{
// 5-minute cache for popular books
return \->cache->get('popular_books', function (ItemInterface \) {
\->expiresAfter(300);
return \->bookRepository->findPopular(limit: 10);
});
}
}Esse provider e utilizado em uma operacao dedicada.
<?php
// src/Entity/Book.php (excerpt)
use App\State\PopularBooksProvider;
#[ApiResource(
operations: [
// ... other operations
new GetCollection(
uriTemplate: '/books/popular',
provider: PopularBooksProvider::class,
paginationEnabled: false,
),
],
)]
class Book
{
// ...
}Validacao Avancada com Grupos Dinamicos
O API Platform integra nativamente o componente Validator do Symfony. Os grupos de validacao podem variar conforme a operacao ou o contexto.
<?php
// src/Entity/Article.php
namespace App\Entity;
use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Post;
use ApiPlatform\Metadata\Put;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;
#[ORM\Entity]
#[ApiResource(
operations: [
new GetCollection(),
new Get(),
// Strict validation on creation
new Post(validationContext: ['groups' => ['Default', 'article:create']]),
// More lenient validation for updates
new Put(validationContext: ['groups' => ['Default', 'article:update']]),
],
)]
class Article
{
#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column]
private ?int \ = null;
#[ORM\Column(length: 255)]
#[Assert\NotBlank]
#[Assert\Length(min: 10, max: 255)]
private ?string \ = null;
#[ORM\Column(type: 'text')]
#[Assert\NotBlank]
// Minimum 500 characters on creation
#[Assert\Length(min: 500, groups: ['article:create'])]
// Minimum 100 characters for updates
#[Assert\Length(min: 100, groups: ['article:update'])]
private ?string \ = null;
#[ORM\Column(length: 50)]
#[Assert\NotBlank(groups: ['article:create'])]
#[Assert\Choice(choices: ['draft', 'published', 'archived'])]
private ?string \ = 'draft';
#[ORM\Column(nullable: true)]
// Required only if status is "published"
#[Assert\NotBlank(groups: ['article:publish'])]
private ?\DateTimeImmutable \ = null;
// Getters and setters...
}Validacao Dinamica com um Servico
Para regras de validacao complexas, um gerador de grupos personalizado oferece flexibilidade total.
<?php
// src/Validator/ArticleGroupsGenerator.php
namespace App\Validator;
use ApiPlatform\Symfony\Validator\ValidationGroupsGeneratorInterface;
use App\Entity\Article;
use Symfony\Bundle\SecurityBundle\Security;
final class ArticleGroupsGenerator implements ValidationGroupsGeneratorInterface
{
public function __construct(
private Security \,
) {
}
public function __invoke(object \): array
{
assert(\ instanceof Article);
\ = ['Default'];
// Admins have fewer restrictions
if (\->security->isGranted('ROLE_ADMIN')) {
\[] = 'admin';
return \;
}
// Additional validation if publishing
if (\->getStatus() === 'published') {
\[] = 'article:publish';
}
return \;
}
}Validacoes complexas podem impactar o desempenho. Para importacoes em massa, considere desabilitar temporariamente certas validacoes ou utilizar constraints assincronas.
Filtros para Consultas Flexiveis
O API Platform 4.4 repensa o sistema de filtros com filtros composables. O decorador legado #[ApiFilter] esta depreciado (remocao prevista para a 6.0), e um codemod esta disponivel para migracao.
<?php
// src/Entity/Product.php
namespace App\Entity;
use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\ApiFilter;
use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
use ApiPlatform\Doctrine\Orm\Filter\RangeFilter;
use ApiPlatform\Doctrine\Orm\Filter\OrderFilter;
use ApiPlatform\Doctrine\Orm\Filter\BooleanFilter;
use ApiPlatform\Doctrine\Orm\Filter\DateFilter;
use Doctrine\ORM\Mapping as ORM;
#[ORM\Entity]
#[ApiResource]
// Text search on name and description
#[ApiFilter(SearchFilter::class, properties: [
'name' => 'partial', // LIKE %value%
'description' => 'partial',
'category.name' => 'exact', // Search on relation
'sku' => 'exact', // Exact match
])]
// Range filtering
#[ApiFilter(RangeFilter::class, properties: ['price', 'stock'])]
// Date filtering
#[ApiFilter(DateFilter::class, properties: ['createdAt', 'updatedAt'])]
// Boolean filtering
#[ApiFilter(BooleanFilter::class, properties: ['isActive', 'isFeatured'])]
// Customizable sorting
#[ApiFilter(OrderFilter::class, properties: [
'name',
'price',
'createdAt',
], arguments: ['orderParameterName' => 'sort'])]
class Product
{
#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column]
private ?int \ = null;
#[ORM\Column(length: 255)]
private ?string \ = null;
#[ORM\Column(type: 'text', nullable: true)]
private ?string \ = null;
#[ORM\Column(length: 50, unique: true)]
private ?string \ = null;
#[ORM\Column(type: 'decimal', precision: 10, scale: 2)]
private ?string \ = null;
#[ORM\Column]
private ?int \ = null;
#[ORM\Column]
private ?bool \ = true;
#[ORM\Column]
private ?bool \ = false;
#[ORM\ManyToOne(targetEntity: Category::class)]
private ?Category \ = null;
#[ORM\Column]
private ?\DateTimeImmutable \ = null;
#[ORM\Column(nullable: true)]
private ?\DateTimeImmutable \ = null;
// Getters and setters...
}Esses filtros geram automaticamente documentacao OpenAPI e habilitam consultas como:
GET /api/products?name=phone&price[gte]=100&price[lte]=500&isActive=true&sort[price]=ascO API Platform 4.4 introduz novos filtros: StartSearchFilter, EndSearchFilter, WordStartSearchFilter, e wrappers composables como ComparisonFilter, OrFilter e ChainFilter.
Relacoes e Subrecursos
O API Platform trata de forma elegante as relacoes entre entidades, com opcoes de serializacao e subrecursos.
<?php
// src/Entity/Author.php
namespace App\Entity;
use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Link;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Serializer\Annotation\Groups;
#[ORM\Entity]
#[ApiResource(
normalizationContext: ['groups' => ['author:read']],
)]
class Author
{
#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column]
#[Groups(['author:read', 'book:read'])]
private ?int \ = null;
#[ORM\Column(length: 255)]
#[Groups(['author:read', 'book:read'])]
private ?string \ = null;
#[ORM\Column(type: 'text', nullable: true)]
#[Groups(['author:read'])]
private ?string \ = null;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: Book::class)]
#[Groups(['author:read'])]
private Collection \;
public function __construct()
{
\->books = new ArrayCollection();
}
// Getters and setters...
}<?php
// src/Entity/Book.php (with relation)
namespace App\Entity;
use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Link;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Serializer\Annotation\Groups;
#[ORM\Entity]
#[ApiResource(
normalizationContext: ['groups' => ['book:read']],
)]
// Subresource: GET /api/authors/{authorId}/books
#[ApiResource(
uriTemplate: '/authors/{authorId}/books',
operations: [new GetCollection()],
uriVariables: [
'authorId' => new Link(
fromProperty: 'books',
fromClass: Author::class
),
],
normalizationContext: ['groups' => ['book:read']],
)]
class Book
{
#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column]
#[Groups(['book:read', 'author:read'])]
private ?int \ = null;
#[ORM\Column(length: 255)]
#[Groups(['book:read', 'author:read'])]
private ?string \ = null;
#[ORM\ManyToOne(targetEntity: Author::class, inversedBy: 'books')]
#[ORM\JoinColumn(nullable: false)]
#[Groups(['book:read'])]
private ?Author \ = null;
// Getters and setters...
}Seguranca e Controle de Acesso
O API Platform se integra perfeitamente ao sistema de seguranca do Symfony. Voters e expressoes de seguranca controlam o acesso aos recursos. Para uma visao completa dos padroes de seguranca do Symfony, consulte Symfony Security: Voters, Firewalls e perguntas de entrevista.
<?php
// src/Entity/Order.php
namespace App\Entity;
use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Post;
use ApiPlatform\Metadata\Patch;
use ApiPlatform\Metadata\Delete;
use Doctrine\ORM\Mapping as ORM;
#[ORM\Entity]
#[ApiResource(
operations: [
// List: authenticated users see their orders
new GetCollection(
security: "is_granted('ROLE_USER')",
// Automatic filter by connected user
provider: UserOrdersProvider::class,
),
// Creation: any authenticated user
new Post(
security: "is_granted('ROLE_USER')",
processor: CreateOrderProcessor::class,
),
// Read: owner or admin
new Get(
security: "is_granted('ROLE_ADMIN') or object.getCustomer() == user",
securityMessage: "Access denied to this order.",
),
// Modification: admin only
new Patch(
security: "is_granted('ROLE_ADMIN')",
),
// Deletion: admin only
new Delete(
security: "is_granted('ROLE_ADMIN')",
),
],
)]
class Order
{
#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column]
private ?int \ = null;
#[ORM\ManyToOne(targetEntity: User::class)]
#[ORM\JoinColumn(nullable: false)]
private ?User \ = null;
#[ORM\Column(length: 50)]
private ?string \ = 'pending';
#[ORM\Column(type: 'decimal', precision: 10, scale: 2)]
private ?string \ = null;
#[ORM\Column]
private ?\DateTimeImmutable \ = null;
// Getters...
public function getCustomer(): ?User
{
return \->customer;
}
}A expressao object.getCustomer() == user permite acessar a entidade atual e o usuario conectado para verificacoes granulares.
Testes Automatizados de API
O API Platform fornece traits do PHPUnit para testar endpoints de forma simples e eficaz.
<?php
// tests/Api/BookTest.php
namespace App\Tests\Api;
use ApiPlatform\Symfony\Bundle\Test\ApiTestCase;
use App\Entity\Book;
use App\Factory\BookFactory;
use App\Factory\UserFactory;
use Zenstruck\Foundry\Test\Factories;
use Zenstruck\Foundry\Test\ResetDatabase;
class BookTest extends ApiTestCase
{
use ResetDatabase;
use Factories;
public function testGetCollection(): void
{
// Create test data
BookFactory::createMany(30);
// GET request on collection
\ = static::createClient()->request('GET', '/api/books');
// Assertions
\->assertResponseIsSuccessful();
\->assertResponseHeaderSame('content-type', 'application/ld+json; charset=utf-8');
\->assertJsonContains([
'@context' => '/api/contexts/Book',
'@type' => 'Collection',
'totalItems' => 30,
]);
// Verify pagination (20 items per page)
\->assertCount(20, \->toArray()['member']);
}
public function testCreateBook(): void
{
\ = UserFactory::createOne(['roles' => ['ROLE_ADMIN']]);
static::createClient()->request('POST', '/api/books', [
'auth_bearer' => \->getToken(\),
'json' => [
'title' => 'Clean Code',
'description' => 'A Handbook of Agile Software Craftsmanship',
'isbn' => '9780132350884',
],
]);
\->assertResponseStatusCodeSame(201);
\->assertJsonContains([
'@type' => 'Book',
'title' => 'Clean Code',
]);
}
public function testCreateBookValidationFails(): void
{
\ = UserFactory::createOne(['roles' => ['ROLE_ADMIN']]);
static::createClient()->request('POST', '/api/books', [
'auth_bearer' => \->getToken(\),
'json' => [
'title' => '', // Empty title = error
'isbn' => 'invalid-isbn',
],
]);
\->assertResponseStatusCodeSame(422);
\->assertJsonContains([
'@type' => 'ConstraintViolationList',
'violations' => [
['propertyPath' => 'title', 'message' => 'Title is required'],
],
]);
}
private function getToken(object \): string
{
// Implementation depends on your authentication system
return 'test_token';
}
}Fontes
- Notas de versao do API Platform 4.4 - Filtros composables, depreciacao de #[ApiFilter], OpenAPI 3.2
- Documentacao do API Platform - Guias oficiais de instalacao e configuracao
- Componente Serializer do Symfony - Grupos de serializacao e normalizacao
Checklist de boas praticas API Platform Symfony
O API Platform com Symfony representa o estado da arte na criacao de APIs REST profissionais em PHP. A separacao clara entre State Providers (leitura) e State Processors (escrita), combinada com grupos de serializacao e o sistema de validacao, permite construir APIs robustas e de facil manutencao.
Checklist para APIs de qualidade
- Utilizar grupos de serializacao distintos para leitura e escrita
- Implementar State Processors para logica de negocio (hash de senha, notificacoes)
- Configurar filtros para pesquisa e ordenacao (migrar dos decoradores #[ApiFilter] depreciados para filtros composables)
- Aplicar validacoes por operacao com grupos
- Proteger endpoints com expressoes de seguranca
- Escrever testes funcionais para cada endpoint
- Documentar a API por meio de metadados OpenAPI
Comece a praticar!
Teste seus conhecimentos com nossos simuladores de entrevista e testes tecnicos.
A filosofia do API Platform privilegia a composicao em detrimento da heranca e a configuracao em vez da convencao. O resultado: APIs escalaveis, testaveis e conformes aos padroes REST/JSON-LD, prontas para producao desde o primeiro dia.
Você saberia encontrar o bug em Symfony?
Um trecho real, um bug escondido, uma tentativa por dia. Sem conta para testar.

Escrito por
Anthony Fillion-MailletFundador da SharpSkill
Desenvolvedor fullstack há mais de 10 anos. Dirige a SharpSkill e responde por tudo o que é publicado aqui.
Atualizado em 12 de outubro de 2026
Tags
Compartilhar
Artigos relacionados

Doctrine ORM: Dominando relacionamentos no Symfony
Guia completo dos relacionamentos Doctrine ORM no Symfony. OneToMany, ManyToMany, estratégias de carregamento e otimização de performance com exemplos práticos.

Perguntas de entrevista Symfony: Top 25 em 2026
As 25 perguntas de entrevista Symfony mais frequentes. Arquitetura, Doctrine ORM, serviços, segurança, formulários e testes com respostas detalhadas e exemplos de código.

Injeção de dependências do Symfony: contêiner de serviços, autowiring e tags em 2026
Mergulho na injeção de dependências do Symfony: contêiner de serviços, autowiring, atributo #[Autowire], ligação de interfaces, serviços com tags com #[AutowireIterator], compiler passes e serviços preguiçosos no Symfony 7.4 e 8.0.