Symfony 7: API Platform en Best Practices
Volledige gids voor het bouwen van professionele REST API's met Symfony 7 en API Platform 4. State Providers, Processors, validatie en serialisatie uitgelegd.

API Platform 4 transformeert de creatie van REST- en GraphQL-API's met Symfony. Versie 4.4, uitgebracht in september 2026, brengt componeerbare filters, verouderde #[ApiFilter]-decorators en native OpenAPI 3.2-ondersteuning. Gecombineerd met Symfony's service container en autowiring wordt het bouwen van een professionele API eenvoudig.
Versie 4.4 markeert legacy #[ApiFilter]-decorators als deprecated (verwijdering gepland voor 6.0) ten gunste van componeerbare filters zoals ComparisonFilter, OrFilter en ChainFilter. Scalar UI vervangt Swagger UI standaard sinds 4.3, en OpenAPI 3.2 wordt volledig ondersteund. Zie de officiele release notes voor migratierichtlijnen.
Installatie en Initiele Configuratie
API Platform installeert in enkele commando's met Symfony Flex. De standaardconfiguratie dekt de meeste gebruiksscenario's en blijft volledig aanpasbaar.
# 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 configureert automatisch routes, OpenAPI-documentatie en de Scalar UI-interface die toegankelijk is via /api. De API Platform-documentatie behandelt alle configuratieopties.
# 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: 100Deze configuratie definieert serialisatieformaten, globale paginering en API-documentatiemetadata.
Een Eenvoudige API Resource Aanmaken
Het #[ApiResource]-attribuut stelt een Doctrine-entiteit bloot als REST-resource. API Platform genereert automatisch CRUD-endpoints, OpenAPI-documentatie en basisvalidaties.
<?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 ;
}
}Deze entiteit genereert zes endpoints: GET /api/books, POST /api/books, GET /api/books/{id}, PUT /api/books/{id}, PATCH /api/books/{id} en DELETE /api/books/{id}.
API Platform ondersteunt UUID v7 als identifier van nature. Deze aanpak verbetert de beveiliging (niet-voorspelbare identifiers) en prestaties (natuurlijke sortering op aanmaakdatum).
Serialisatiegroepen voor Controle over Blootgestelde Data
Serialisatiegroepen definieren nauwkeurig welke eigenschappen worden blootgesteld voor lezen (normalisatie) en schrijven (denormalisatie). Deze scheiding is essentieel voor de beveiliging en flexibiliteit van de API. Voor complexe serialisatiescenario's biedt het Symfony Serializer-component aanvullende aanpassingsmogelijkheden.
<?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;
}
}Met deze configuratie wordt plainPassword nooit blootgesteld in antwoorden, maar kan het worden meegegeven bij aanmaak of updates.
Klaar om je Symfony gesprekken te halen?
Oefen met onze interactieve simulatoren, flashcards en technische tests.
State Processors voor Bedrijfslogica
State Processors onderscheppen persistentieoperaties om bedrijfslogica toe te voegen. API Platform vereenvoudigt hun creatie via dependency injection op basis van attributen.
<?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(, , , );
}
}Dit compositiepatroon maakt het mogelijk om willekeurige logica toe te voegen (verzenden van e-mails, events, logging) met behoud van het standaard persistentiegedrag. Voor event-driven architecturen werken processors naadloos samen met Symfony Messenger.
Processor met Conditionele Logica
Een processor kan zijn gedrag aanpassen op basis van het type operatie.
<?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 voor Aangepaste Databronnen
State Providers halen gegevens op uit elke bron: externe API's, cache, bestanden of complexe bedrijfslogica.
<?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);
});
}
}Deze provider wordt gebruikt op een toegewijde operatie.
<?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
{
// ...
}Geavanceerde Validatie met Dynamische Groepen
API Platform integreert van nature de Symfony Validator-component. Validatiegroepen kunnen varieren op basis van de operatie of context.
<?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...
}Dynamische Validatie met een Service
Voor complexe validatieregels biedt een aangepaste groepsgenerator maximale flexibiliteit.
<?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 ;
}
}Complexe validaties kunnen de prestaties beinvloeden. Voor bulkimports verdient het aanbeveling bepaalde validaties tijdelijk uit te schakelen of asynchrone constraints te gebruiken.
Filters voor Flexibele Queries
API Platform 4.4 herwerkt het filtersysteem met componeerbare filters. De legacy #[ApiFilter]-decorator is deprecated (verwijdering gepland voor 6.0), en een codemod is beschikbaar voor migratie.
<?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...
}Deze filters genereren automatisch OpenAPI-documentatie en maken queries mogelijk zoals:
GET /api/products?name=phone&price[gte]=100&price[lte]=500&isActive=true&sort[price]=ascAPI Platform 4.4 introduceert nieuwe filters: StartSearchFilter, EndSearchFilter, WordStartSearchFilter en componeerbare wrappers zoals ComparisonFilter, OrFilter en ChainFilter.
Relaties en Subresources
API Platform behandelt entiteitsrelaties elegant met serialisatieopties en subresources.
<?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...
}Beveiliging en Toegangscontrole
API Platform integreert naadloos met het beveiligingssysteem van Symfony. Voters en beveiligingsexpressies regelen de toegang tot resources. Voor een volledig overzicht van Symfony-beveiligingspatronen, zie Symfony Security: Voters, Firewalls en Sollicitatievragen.
<?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;
}
}De expressie object.getCustomer() == user geeft toegang tot de huidige entiteit en de aangemelde gebruiker voor fijnmazige controles.
Geautomatiseerde API Tests
API Platform levert PHPUnit-traits voor het eenvoudig testen van 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
- API Platform 4.4 Release Notes - Componeerbare filters, deprecated #[ApiFilter], OpenAPI 3.2
- API Platform Documentatie - Officiele installatie- en configuratiegidsen
- Symfony Serializer Component - Serialisatiegroepen en normalisatie
API Platform Symfony Best Practices Checklist
API Platform met Symfony vertegenwoordigt de stand van de techniek voor het maken van professionele REST API's in PHP. De duidelijke scheiding tussen State Providers (lezen) en State Processors (schrijven), gecombineerd met serialisatiegroepen en het validatiesysteem, maakt het mogelijk om robuuste en onderhoudbare API's te bouwen.
Checklist voor Kwaliteits-API's
- Gebruik afzonderlijke serialisatiegroepen voor lezen en schrijven
- Implementeer State Processors voor bedrijfslogica (wachtwoordhashing, notificaties)
- Configureer filters voor zoeken en sorteren (migreer van deprecated #[ApiFilter] naar componeerbare filters)
- Pas validaties per operatie toe met groepen
- Beveilig endpoints met beveiligingsexpressies
- Schrijf functionele tests voor elk endpoint
- Documenteer de API via OpenAPI-metadata
Begin met oefenen!
Test je kennis met onze gespreksimulatoren en technische tests.
De filosofie van API Platform moedigt compositie boven overerving aan, en configuratie boven conventie. Het resultaat: schaalbare, testbare API's die voldoen aan REST/JSON-LD-standaarden en vanaf dag een productieklaar zijn.
Zie jij de bug in Symfony?
Een echt codefragment, een verborgen bug, één poging per dag. Zonder account uit te proberen.

Geschreven door
Anthony Fillion-MailletOprichter van SharpSkill
Al meer dan 10 jaar fullstack-ontwikkelaar. Hij leidt SharpSkill en staat in voor alles wat hier verschijnt.
Bijgewerkt op 12 oktober 2026
Tags
Delen
Gerelateerde artikelen

API Platform Symfony REST: Complete Tutorial en Sollicitatievragen 2026
REST APIs bouwen met API Platform 4.3 en Symfony 7. State Providers, Processors, serialisatiegroepen en veelvoorkomende sollicitatievragen voor Symfony-ontwikkelaars.

Doctrine ORM: Relaties beheersen in Symfony
Volledige gids voor Doctrine ORM-relaties in Symfony. OneToMany, ManyToMany, laadstrategieën en performance-optimalisatie met praktische voorbeelden.

Symfony-sollicitatievragen: Top 25 in 2026
De 25 meest gestelde Symfony-sollicitatievragen. Architectuur, Doctrine ORM, services, beveiliging, formulieren en tests met gedetailleerde antwoorden en codevoorbeelden.