Symfony 7 : API Platform et bonnes pratiques
Guide complet pour créer des APIs REST professionnelles avec Symfony 7 et API Platform 4. State Providers, Processors, validation et sérialisation expliqués.

API Platform 4 transforme la création d'APIs REST et GraphQL avec Symfony. La version 4.4, publiée en septembre 2026, apporte les filtres composables, la dépréciation des décorateurs #[ApiFilter] et le support natif d'OpenAPI 3.2. Combiné avec le conteneur de services et l'autowiring de Symfony, construire une API professionnelle devient simple.
La version 4.4 déprécie les décorateurs #[ApiFilter] historiques (suppression prévue pour la 6.0) au profit de filtres composables comme ComparisonFilter, OrFilter et ChainFilter. Scalar UI remplace Swagger UI par défaut depuis la 4.3, et OpenAPI 3.2 est désormais supporté. Consultez les notes de version officielles pour le guide de migration.
Installation et configuration initiale
API Platform s'installe en quelques commandes avec Symfony Flex. La configuration par défaut couvre la majorité des cas d'usage tout en restant entièrement personnalisable.
# 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 apiSymfony Flex configure automatiquement les routes, la documentation OpenAPI et l'interface Scalar UI accessible à /api. La documentation API Platform détaille toutes les options de configuration.
# 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: 100Cette configuration définit les formats de sérialisation, la pagination globale et les métadonnées de la documentation API.
Création d'une ressource API simple
L'attribut #[ApiResource] expose une entité Doctrine comme ressource REST. API Platform génère automatiquement les endpoints CRUD, la documentation OpenAPI et les validations de base.
<?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 \;
}
}Cette entité génère six endpoints : GET /api/books, POST /api/books, GET /api/books/{id}, PUT /api/books/{id}, PATCH /api/books/{id} et DELETE /api/books/{id}.
API Platform supporte nativement les UUID v7 comme identifiants. Cette approche améliore la sécurité (identifiants non prédictibles) et les performances (tri naturel par date de création).
Groupes de sérialisation pour contrôler les données exposées
Les groupes de sérialisation permettent de définir précisément quelles propriétés sont exposées en lecture (normalization) et en écriture (denormalization). Cette séparation est essentielle pour la sécurité et la flexibilité de l'API. Pour les scénarios de sérialisation complexes, le composant Serializer de Symfony offre des options de personnalisation supplémentaires.
<?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;
}
}Avec cette configuration, plainPassword n'est jamais exposé en réponse mais peut être envoyé lors de la création ou mise à jour.
Prêt à réussir tes entretiens Symfony ?
Entraîne-toi avec nos simulateurs interactifs, fiches express et tests techniques.
State Processors pour la logique métier
Les State Processors interceptent les opérations de persistance pour ajouter de la logique métier. API Platform simplifie leur création grâce à l'injection de dépendances via attributs.
<?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(\, \, \, \);
}
}Ce pattern de composition permet d'ajouter n'importe quelle logique (envoi d'emails, événements, logs) tout en conservant le comportement standard de persistance. Pour les architectures event-driven, les processors s'intègrent parfaitement avec Symfony Messenger.
Processor avec logique conditionnelle
Un processor peut adapter son comportement selon le type d'opération.
<?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 pour les sources de données personnalisées
Les State Providers permettent de récupérer des données depuis n'importe quelle source : API externe, cache, fichiers, ou logique métier complexe.
<?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);
});
}
}Ce provider s'utilise sur une opération dédiée.
<?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
{
// ...
}Validation avancée avec groupes dynamiques
API Platform intègre nativement le composant Validator de Symfony. Les groupes de validation peuvent varier selon l'opération ou le contexte.
<?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...
}Validation dynamique avec un service
Pour des règles de validation complexes, un générateur de groupes personnalisé offre une flexibilité totale.
<?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 \;
}
}Les validations complexes peuvent impacter les performances. Pour les imports en masse, envisagez de désactiver temporairement certaines validations ou d'utiliser des contraintes asynchrones.
Filtres pour des requêtes flexibles
API Platform 4.4 repense le système de filtres avec les filtres composables. Le décorateur #[ApiFilter] historique est déprécié (suppression prévue pour la 6.0), et un codemod est disponible pour la migration.
<?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...
}Ces filtres génèrent automatiquement la documentation OpenAPI et permettent des requêtes comme :
GET /api/products?name=phone&price[gte]=100&price[lte]=500&isActive=true&sort[price]=ascAPI Platform 4.4 introduit de nouveaux filtres : StartSearchFilter, EndSearchFilter, WordStartSearchFilter, et des wrappers composables comme ComparisonFilter, OrFilter et ChainFilter.
Relations et sous-ressources
API Platform gère élégamment les relations entre entités avec des options de sérialisation et des sous-ressources.
<?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...
}Sécurité et contrôle d'accès
API Platform s'intègre parfaitement avec le système de sécurité Symfony. Les voters et expressions de sécurité contrôlent l'accès aux ressources. Pour une vue complète des patterns de sécurité Symfony, consultez Symfony Security : Voters, Firewalls et questions d'entretien.
<?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;
}
}L'expression object.getCustomer() == user donne accès à l'entité courante et à l'utilisateur connecté pour des vérifications fines.
Tests automatisés de l'API
API Platform fournit des traits PHPUnit pour tester facilement les endpoints.
<?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';
}
}Sources
- Notes de version API Platform 4.4 - Filtres composables, dépréciation de #[ApiFilter], OpenAPI 3.2
- Documentation API Platform - Guides officiels d'installation et de configuration
- Composant Serializer Symfony - Groupes de sérialisation et normalisation
Checklist des bonnes pratiques API Platform Symfony
API Platform avec Symfony représente l'état de l'art pour créer des APIs REST professionnelles en PHP. La séparation claire entre State Providers (lecture) et State Processors (écriture), combinée aux groupes de sérialisation et au système de validation, permet de construire des APIs robustes et maintenables.
Checklist pour une API de qualité
- Utiliser des groupes de sérialisation distincts pour lecture et écriture
- Implémenter des State Processors pour la logique métier (hash de mot de passe, notifications)
- Configurer des filtres pour les recherches et le tri (migrer des décorateurs #[ApiFilter] dépréciés vers les filtres composables)
- Appliquer des validations par opération avec des groupes
- Sécuriser les endpoints avec des expressions de sécurité
- Écrire des tests fonctionnels pour chaque endpoint
- Documenter l'API via les métadonnées OpenAPI
Passe à la pratique !
Teste tes connaissances avec nos simulateurs d'entretien et tests techniques.
La philosophie d'API Platform encourage la composition plutôt que l'héritage, et la configuration plutôt que la convention. Le résultat : des APIs évolutives, testables et conformes aux standards REST/JSON-LD, prêtes pour la production dès le premier jour.
Tu saurais repérer le bug en Symfony ?
Un vrai bout de code, un bug caché, une tentative par jour. Sans compte pour essayer.

Écrit par
Anthony Fillion-MailletFondateur de SharpSkill
Développeur fullstack depuis plus de 10 ans. Il dirige SharpSkill et répond de tout ce qui y est publié.
Mis à jour le 12 octobre 2026
Tags
Partager
Articles similaires

Doctrine ORM : Maîtriser les relations en Symfony
Guide complet des relations Doctrine ORM dans Symfony. OneToMany, ManyToMany, stratégies de chargement et optimisation des performances avec exemples pratiques.

Questions d'entretien Symfony : Top 25 en 2026
Les 25 questions d'entretien Symfony les plus posées. Architecture, Doctrine ORM, services, sécurité, formulaires et tests avec réponses détaillées et exemples de code.

Injection de dépendances Symfony : conteneur de services, autowiring et tags en 2026
Plongée dans l'injection de dépendances Symfony : conteneur de services, autowiring, attribut #[Autowire], liaison d'interfaces, services taggés avec #[AutowireIterator], compiler passes et services paresseux dans Symfony 7.4 et 8.0.