API Platform với Symfony 2026: Kiến trúc Hiện đại và Câu hỏi Phỏng vấn

<?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\Delete;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;

#[ORM\Entity]
#[ApiResource(
    operations: [
        new GetCollection(),
        new Get(),
        new Post(security: "is_granted('ROLE_ADMIN')"),
        new Put(security: "is_granted('ROLE_ADMIN') or object.owner == user"),
        new Delete(security: "is_granted('ROLE_ADMIN')")
    ],
    paginationItemsPerPage: 20,
    paginationClientEnabled: true
)]
class Product
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(length: 255)]
    #[Assert\NotBlank]
    #[Assert\Length(min: 3, max: 255)]
    private string $name;

    #[ORM\Column(type: 'decimal', precision: 10, scale: 2)]
    #[Assert\Positive]
    private string $price;

    #[ORM\Column(type: 'text', nullable: true)]
    private ?string $description = null;

    #[ORM\ManyToOne(targetEntity: User::class)]
    public ?User $owner = null;

    // Getters and setters
    public function getId(): ?int
    {
        return $this->id;
    }

    public function getName(): string
    {
        return $this->name;
    }

    public function setName(string $name): self
    {
        $this->name = $name;
        return $this;
    }

    public function getPrice(): string
    {
        return $this->price;
    }

    public function setPrice(string $price): self
    {
        $this->price = $price;
        return $this;
    }

    public function getDescription(): ?string
    {
        return $this->description;
    }

    public function setDescription(?string $description): self
    {
        $this->description = $description;
        return $this;
    }
}

<?php

namespace App\Entity;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\SmartPlatform\Attributes\SmartCache;
use ApiPlatform\SmartPlatform\Attributes\QueryOptimization;

#[ApiResource]
#[SmartCache(
    predictiveEnabled: true,
    learningMode: 'adaptive',
    ttlStrategy: 'usage_based'
)]
#[QueryOptimization(
    autoJoin: true,
    selectOptimization: true,
    indexSuggestions: true
)]
class Order
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\ManyToOne(targetEntity: Customer::class)]
    #[ORM\JoinColumn(nullable: false)]
    private Customer $customer;

    #[ORM\OneToMany(mappedBy: 'order', targetEntity: OrderItem::class, cascade: ['persist'])]
    private Collection $items;

    #[ORM\Column(type: 'datetime_immutable')]
    private \DateTimeImmutable $createdAt;

    #[ORM\Column(length: 50)]
    private string $status = 'pending';
}

<?php

namespace App\State;

use ApiPlatform\Metadata\Operation;
use ApiPlatform\State\ProviderInterface;
use App\Repository\ProductRepository;
use App\Entity\Product;

class ProductStateProvider implements ProviderInterface
{
    public function __construct(
        private ProductRepository $repository,
        private CacheInterface $cache
    ) {}

    public function provide(Operation $operation, array $uriVariables = [], array $context = []): object|array|null
    {
        if ($operation instanceof GetCollection) {
            return $this->repository->findActiveProducts(
                $context['filters'] ?? []
            );
        }

        $id = $uriVariables['id'] ?? null;
        
        return $this->cache->get(
            "product_{$id}",
            fn() => $this->repository->find($id)
        );
    }
}

<?php

namespace App\State;

use ApiPlatform\Metadata\Operation;
use ApiPlatform\State\ProcessorInterface;
use App\Entity\Product;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\Messenger\MessageBusInterface;

class ProductStateProcessor implements ProcessorInterface
{
    public function __construct(
        private EntityManagerInterface $em,
        private MessageBusInterface $bus
    ) {}

    public function process(
        mixed $data,
        Operation $operation,
        array $uriVariables = [],
        array $context = []
    ): Product {
        if ($operation instanceof Post) {
            $data->setCreatedAt(new \DateTimeImmutable());
        }

        $this->em->persist($data);
        $this->em->flush();

        $this->bus->dispatch(new ProductUpdatedMessage($data->getId()));

        return $data;
    }
}

<?php

namespace App\Filter;

use ApiPlatform\Doctrine\Orm\Filter\AbstractFilter;
use ApiPlatform\Doctrine\Orm\Util\QueryNameGeneratorInterface;
use ApiPlatform\Metadata\Operation;
use Doctrine\ORM\QueryBuilder;

class ProductAvailabilityFilter extends AbstractFilter
{
    protected function filterProperty(
        string $property,
        mixed $value,
        QueryBuilder $queryBuilder,
        QueryNameGeneratorInterface $queryNameGenerator,
        string $resourceClass,
        Operation $operation = null,
        array $context = []
    ): void {
        if ($property !== 'availability') {
            return;
        }

        $alias = $queryBuilder->getRootAliases()[0];
        $paramName = $queryNameGenerator->generateParameterName($property);

        match ($value) {
            'in_stock' => $queryBuilder
                ->andWhere("$alias.stock > 0"),
            'out_of_stock' => $queryBuilder
                ->andWhere("$alias.stock = 0"),
            'low_stock' => $queryBuilder
                ->andWhere("$alias.stock > 0")
                ->andWhere("$alias.stock < :threshold")
                ->setParameter('threshold', 10),
            default => null
        };
    }

    public function getDescription(string $resourceClass): array
    {
        return [
            'availability' => [
                'property' => 'availability',
                'type' => 'string',
                'required' => false,
                'description' => 'Filter by stock availability',
                'openapi' => [
                    'enum' => ['in_stock', 'out_of_stock', 'low_stock']
                ]
            ]
        ];
    }
}

<?php

namespace App\Entity;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use Symfony\Component\Serializer\Annotation\Groups;

#[ApiResource(
    operations: [
        new GetCollection(normalizationContext: ['groups' => ['product:list']]),
        new Get(normalizationContext: ['groups' => ['product:read', 'product:details']])
    ]
)]
class Product
{
    #[Groups(['product:list', 'product:read'])]
    private ?int $id = null;

    #[Groups(['product:list', 'product:read'])]
    private string $name;

    #[Groups(['product:list', 'product:read'])]
    private string $price;

    #[Groups(['product:details'])]
    private ?string $description = null;

    #[Groups(['product:details'])]
    private Collection $reviews;
}

<?php

namespace App\Dto;

use Symfony\Component\Validator\Constraints as Assert;

class CreateOrderInput
{
    #[Assert\NotBlank]
    public int $customerId;

    #[Assert\NotBlank]
    #[Assert\Count(min: 1)]
    #[Assert\Valid]
    public array $items;

    #[Assert\NotBlank]
    public string $shippingAddress;

    public ?string $notes = null;
}

<?php

namespace App\Security;

use Symfony\Component\Security\Http\AccessToken\AccessTokenHandlerInterface;
use Symfony\Component\Security\Http\Authenticator\Passport\Badge\UserBadge;

class ApiTokenHandler implements AccessTokenHandlerInterface
{
    public function __construct(
        private UserRepository $userRepository,
        private TokenValidatorService $tokenValidator
    ) {}

    public function getUserBadgeFrom(string $accessToken): UserBadge
    {
        $tokenData = $this->tokenValidator->validate($accessToken);
        
        return new UserBadge(
            $tokenData->getUserIdentifier(),
            fn(string $id) => $this->userRepository->find($id)
        );
    }
}