Symfony 8 in 2026: nieuwe functies, PHP 8.4 lazy objects en sollicitatievragen

Symfony 8, uitgebracht in november 2025, verwijdert twee jaar aan deprecations en levert dezelfde functieset als Symfony 7.4, maar met een harde ondergrens van PHP 8.4. Die vereiste ontgrendelt native lazy objects, property hooks en de nieuwe HTML5-parser: drie toevoegingen op taalniveau waar het framework intern nu op steunt. Dit artikel ontleedt de functies die de dagelijkse ontwikkeling veranderen, de sollicitatievoorbereiding beïnvloeden en aandacht verdienen bij upgrades in productie.

Native lazy objects vervangen proxy-codegeneratie

PHP 8.4 introduceert lazy objects op engine-niveau via ReflectionClass::newLazyGhost() en ReflectionClass::newLazyProxy(). Symfony 8 maakt hier direct gebruik van: het DependencyInjection-component genereert geen proxyklassen meer voor lazy services. In plaats daarvan maakt het ghost-objecten die initialiseren bij de eerste eigenschapstoegang.

Het praktische gevolg is aanzienlijk. final en readonly klassen, voorheen onverenigbaar met Symfony's proxy-gebaseerde lazy loading, werken nu zonder workarounds. Doctrine profiteert evenzeer: entity proxies vereisen geen codegeneratie meer, wat een onderhoudslast wegneemt die meer dan tien jaar standhield.

namespace App\Service;

use Symfony\Component\DependencyInjection\Attribute\Lazy;

#[Lazy]
final readonly class HeavyReportGenerator
{
    public function __construct(
        private DatabaseConnection $db,
        private PdfEngine $pdf,
        private CacheInterface $cache,
    ) {
        // Constructor runs only when a method is actually called
    }

    public function generate(int $reportId): string
    {
        $data = $this->db->fetchReport($reportId);
        return $this->pdf->render($data);
    }
}

Het #[Lazy] attribuut markeert de service voor ghost-object instantiatie. De container injecteert een schil die identiek lijkt aan HeavyReportGenerator. De constructor en de drie geïnjecteerde afhankelijkheden worden pas uitgevoerd wanneer generate() wordt aangeroepen. Voor services die voorwaardelijk worden gebruikt (bijvoorbeeld een rapportgeneratie geactiveerd door een specifieke admin-actie), elimineert dit overbodige databaseverbindingen en geheugentoewijzing bij elke request.

De variant #[Autowire(lazy: true)] staat lazy injectie toe op de aanroeplocatie zonder de serviceklasse zelf te wijzigen:

namespace App\Controller;

use Symfony\Component\DependencyInjection\Attribute\Autowire;

class DashboardController
{
    public function __construct(
        #[Autowire(lazy: true)]
        private HeavyReportGenerator $reportGenerator,
    ) {}
}

In sollicitatiegesprekken zijn vragen over het verschil tussen ghost objects en virtual proxies te verwachten. Ghost objects initialiseren de oorspronkelijke instantie ter plekke. Virtual proxies delegeren naar een aparte, volledig geïnitialiseerde instantie. Symfony kiest standaard voor ghosts, tenzij een factory betrokken is: in dat geval schakelt het automatisch over op proxies.

Multi-step formulieren met AbstractFlowType

Vóór Symfony 8 vereisten multi-step formulieren bundles van derden zoals CraueFormFlowBundle. Het framework biedt nu AbstractFlowType: een native form-flow engine met validatie per stap, voorwaardelijke vertakking en ingebouwde navigatie.

namespace App\Form;

use Symfony\Component\Form\Flow\AbstractFlowType;
use Symfony\Component\Form\Flow\FormFlowBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class UserSignUpType extends AbstractFlowType
{
    public function buildFormFlow(FormFlowBuilderInterface $builder, array $options): void
    {
        $builder->addStep('personal', UserPersonalType::class);
        $builder->addStep('professional', UserProfessionalType::class);
        $builder->addStep('account', UserAccountType::class);

        $builder->add('navigator', NavigatorFlowType::class);
    }

    public function configureOptions(OptionsResolver $resolver): void
    {
        $resolver->setDefaults([
            'data_class' => UserSignUp::class,
            'step_property_path' => 'currentStep',
        ]);
    }
}

Elke stapnaam fungeert tegelijk als validatiegroep. De dataklasse UserSignUp gebruikt #[Valid] met groepsbeperkingen om alleen de actieve stap te valideren:

namespace App\DTO;

use Symfony\Component\Validator\Constraints as Assert;

class UserSignUp
{
    public function __construct(
        #[Assert\Valid(groups: ['personal'])]
        public Personal $personal = new Personal(),

        #[Assert\Valid(groups: ['professional'])]
        public Professional $professional = new Professional(),

        #[Assert\Valid(groups: ['account'])]
        public Account $account = new Account(),

        public string $currentStep = 'personal',
    ) {}
}

De controller spiegelt de standaard Symfony formulier-afhandeling. isFinished() retourneert alleen true nadat de laatste stap de validatie doorstaat:

#[Route('/signup')]
public function __invoke(Request $request): Response
{
    $flow = $this->createForm(UserSignUpType::class, new UserSignUp())
        ->handleRequest($request);

    if ($flow->isSubmitted() && $flow->isValid() && $flow->isFinished()) {
        $this->userService->register($flow->getData());
        return $this->redirectToRoute('app_signup_success');
    }

    return $this->render('signup/flow.html.twig', [
        'form' => $flow->getStepForm(),
    ]);
}

Navigatieknoppen (NextFlowType, PreviousFlowType, FinishFlowType, ResetFlowType) ondersteunen voorwaardelijk renderen via include_if, het overslaan van stappen met skip en directe navigatie met back_to. Daarmee zijn de meeste reële wizard-patronen gedekt zonder maatwerk JavaScript-statebeheer.

Invokable commands met input-attributen

Console commands hoeven niet meer de basisklasse Command uit te breiden of configure() te overschrijven. De methode __invoke() ontvangt argumenten en opties direct via PHP-attributen.

namespace App\Command;

use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Attribute\Argument;
use Symfony\Component\Console\Attribute\Option;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Style\SymfonyStyle;

#[AsCommand(
    name: 'app:create-user',
    description: 'Create a new user account',
)]
class CreateUserCommand
{
    public function __invoke(
        SymfonyStyle $io,
        #[Argument(description: 'The username for the new account')]
        string $username,
        #[Argument(description: 'The email address')]
        string $email,
        #[Option(shortcut: 'r', description: 'Role to assign')]
        string $role = 'ROLE_USER',
        #[Option(description: 'Activate immediately')]
        bool $activate = false,
    ): int {
        // User creation logic
        $io->success(sprintf('User "%s" created with role %s.', $username, $role));
        return Command::SUCCESS;
    }
}

Symfony 8 voegt ondersteuning toe voor backed enums in argumenten en opties. String-invoer wordt automatisch geconverteerd naar het overeenkomende enum-geval:

enum CloudRegion: string {
    case UsEast = 'us-east';
    case UsWest = 'us-west';
    case EuWest = 'eu-west';
}

// In the command
public function __invoke(
    SymfonyStyle $io,
    #[Argument] CloudRegion $region,
    #[Option] ?ServerSize $size = null,
): int {
    $io->info(sprintf('Deploying to %s', $region->value));
    return Command::SUCCESS;
}

Voor commands met veel parameters mapt #[MapInput] de invoer naar een DTO:

class DeployInput
{
    #[Argument]
    public CloudRegion $region;

    #[Option]
    public string $branch = 'main';

    #[Option(shortcut: 'f')]
    public bool $force = false;
}

// src/Command/DeployCommand.php
#[AsCommand(name: 'app:deploy')]
class DeployCommand
{
    public function __invoke(
        SymfonyStyle $io,
        #[MapInput] DeployInput $input,
    ): int {
        // Access $input->region, $input->branch, $input->force
        return Command::SUCCESS;
    }
}

Dit patroon elimineert de ceremonie van configure() plus execute() en maakt commands testbaar door het DTO direct te construeren.

JsonStreamer-, JsonPath- en ObjectMapper-componenten

Drie nieuwe standalone componenten worden meegeleverd met Symfony 8:

JsonStreamer verwerkt grote JSON-payloads zonder het hele document in het geheugen te laden. Voor API's die responses van megabyteformaat afhandelen (bulk data-exports, analytics-feeds, log-ingestion) omzeilt dit het geheugenplafond van json_decode().

JsonPath implementeert een subset van RFC 9535 voor het navigeren door geneste JSON-structuren. In plaats van een volledige response te decoderen en arrays handmatig te doorlopen, haalt een padexpressie de doelgegevens direct op.

ObjectMapper converteert tussen DTO's en arrays/JSON met PHP-attributen, ter vervanging van handgeschreven hydratielogica. Gecombineerd met het Serializer-component dekt het de volledige levenscyclus van API request/response-mapping.

Verbeteringen in security en DX die het vermelden waard zijn

CSRF-bescherming vereist niet langer server-side sessions. De nieuwe stateless CSRF-implementatie werkt met HTTP-caching, waardoor ze geschikt is voor API-first architecturen en CDN-gecachete pagina's.

Het Messenger-component ondersteunt message signing: cryptografische handtekeningen op payloads voorkomen manipulatie tussen producer en consumer. Voor systemen waar berichtintegriteit telt (betaalverwerking, audit trails) vervangt dit maatwerk signing-middleware.

Nieuwe validatiebeperkingen dekken charsets, MAC-adressen, ISO-weeknummers, woordtellingen, YAML-syntax, slugs, Twig-templates en videobestanden. Alleen al de #[Slug] constraint elimineert een veelvoorkomende custom validator.

Security voters verklaren nu hun beslissingen in de profiler. Het debuggen van autorisatielogica, voorheen een raadspel over welke voter toegang weigerde, wordt een directe opzoekactie in de Symfony profiler toolbar.

PHP 8.4 property hooks in Symfony-context

Property hooks (get en set rechtstreeks gedefinieerd op klasse-eigenschappen) integreren naadloos met het Symfony-ecosysteem. Doctrine entiteiten kunnen hooks gebruiken voor berekende eigenschappen. Form types kunnen hooks inzetten voor datatransformatie. Validatiebeperkingen werken zonder aanpassing op eigenschappen met hooks.

class Product
{
    public string $name {
        set(string $value) {
            $this->name = trim($value);
        }
    }

    public float $price {
        set(float $value) {
            if ($value < 0) {
                throw new \InvalidArgumentException('Price cannot be negative');
            }
            $this->price = $value;
        }
    }

    public float $priceWithTax {
        get => $this->price * 1.20;
    }
}

Property hooks verminderen de behoefte aan getter/setter-paren en verplaatsen de handhaving van invarianten naar de eigenschapsdefinitie. In Symfony forms betekent dit minder transformer-boilerplate. In Doctrine entiteiten blijven berekende waarden dicht bij de gegevens waarvan ze afhankelijk zijn.

Sollicitatievragen om je op voor te bereiden

Symfony 8 verlegt waar interviewers naar testen. De volgende onderwerpen komen regelmatig terug in Symfony sollicitatievoorbereidingen:

• Lazy objects: het verschil tussen ghost objects en virtual proxies uitleggen. Wanneer kiest Symfony de een boven de ander? Waarom maakt PHP 8.4 final readonly services lazy-loadable?
• Multi-step formulieren: hoe gaat AbstractFlowType om met validatie per stap? Wat is de rol van step_property_path? Hoe werken voorwaardelijke stappen?
• Invokable commands: wat vervangt configure() in invokable commands? Hoe werkt #[MapInput]? Welke regels gelden voor #[Option] defaults?
• Nieuwe componenten: wanneer verdient JsonStreamer de voorkeur boven json_decode()? Welk probleem lost ObjectMapper op dat de Serializer niet aanpakt?
• Upgradestrategie: waarom wordt het upgraden naar 7.4 vóór 8.0 aanbevolen? Wat impliceert het verwijderen van 13.202 regels deprecation-code voor achterwaartse compatibiliteit?

Oefenen met echte code. De module Symfony console commands en de module Doctrine gevorderd dekken de meest geteste gebieden.

Conclusie

• Symfony 8 vereist PHP 8.4 en omarmt volledig native lazy objects, waardoor proxy-codegeneratie zowel voor de DI-container als voor Doctrine ORM verdwijnt
• AbstractFlowType vervangt bundles van derden voor multi-step formulieren, met validatiegroepen per stap en ingebouwde navigatieknoppen
• Invokable commands met #[Argument], #[Option] en #[MapInput] schrappen boilerplate en ondersteunen backed enums en DTO's
• Drie nieuwe componenten (JsonStreamer, JsonPath, ObjectMapper) pakken JSON-verwerking en object-mapping aan zonder externe afhankelijkheden
• Stateless CSRF, message signing, security voter debugging en meer dan 20 nieuwe validatiebeperkingen versterken het security- en DX-oppervlak
• Property hooks uit PHP 8.4 integreren transparant met Doctrine entiteiten, Symfony forms en validatiebeperkingen
• Het upgradepad loopt via Symfony 7.4: alle deprecations daar oplossen voordat naar 8.0 wordt overgestapt