> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# FAQ over de nieuwe appstructuur van Laravel 11+

> Veelgestelde vragen en antwoorden over de overstap naar het Slim Application Skeleton van Laravel 11 en later. Voor wie instapt in een project dat met de oude structuur is geüpgraded, of geleerd heeft uit oudere boeken en tutorials.

In Laravel 11 is de applicatiestructuur ingrijpend veranderd met het "Slim Application Skeleton". Deze pagina bundelt de punten waar je makkelijk over struikelt als je instapt in een project dat met de oude structuur is geüpgraded, of als je geleerd hebt met boeken en tutorials van Laravel 10 of eerder. Het zijn vragen die rond de release van Laravel 11 vaak gesteld werden op het Laracasts-forum en Stack Overflow.

<Info>
  Deze FAQ richt zich op **nieuwe projecten** (Laravel 11 en later). Voor het upgraden van bestaande projecten, zie de [migratiegids](/nl/advanced/app-structure-migration).
</Info>

<AccordionGroup>
  <Accordion title="Er zijn maar weinig configbestanden">
    In de nieuwe structuur zijn configbestanden die zelden worden aangepast uit het project verwijderd. Voor deze bestanden wordt de `config/` binnen het framework gebruikt.

    De `config/` aan de projectkant en de `config/` aan de frameworkkant worden samengevoegd, waarbij **de projectkant voorrang krijgt**. Zodra je iets wilt aanpassen, maak je het bestand aan en wordt het toegepast.

    ```bash theme={null}
    # Bekijk de config binnen het framework
    cat vendor/laravel/framework/config/cors.php

    # Kopieer naar de projectkant en pas aan
    php artisan config:publish cors
    ```
  </Accordion>

  <Accordion title="$this->validate() en $this->authorize() werken niet in controllers">
    In de nieuwe structuur van Laravel 11 is `App\Http\Controllers\Controller` een lege klasse geworden: hij erft niet van `Illuminate\Routing\Controller` en gebruikt de traits `ValidatesRequests` / `AuthorizesRequests` niet.

    | Laravel 10                               | Laravel 11    |
    | ---------------------------------------- | ------------- |
    | Erft van `Illuminate\Routing\Controller` | Lege klasse   |
    | Gebruikt de trait `ValidatesRequests`    | Niet aanwezig |
    | Gebruikt de trait `AuthorizesRequests`   | Niet aanwezig |

    Zie: [Controller in Laravel 10](https://github.com/laravel/laravel/blob/10.x/app/Http/Controllers/Controller.php) vs [Controller in Laravel 11](https://github.com/laravel/laravel/blob/11.x/app/Http/Controllers/Controller.php)

    **Alternatieven:**

    ```php theme={null}
    // Gebruik $request->validate()
    public function store(Request $request)
    {
        $validated = $request->validate([
            'title' => 'required|string|max:255',
        ]);
    }

    // Gebruik Gate::authorize()
    use Illuminate\Support\Facades\Gate;

    public function update(Request $request, Post $post)
    {
        Gate::authorize('update', $post);
    }
    ```

    Gebruik je dit vaak, dan kun je `App\Http\Controllers\Controller` ook terugbrengen naar de Laravel 10-variant.

    ```php theme={null}
    <?php

    namespace App\Http\Controllers;

    use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
    use Illuminate\Foundation\Validation\ValidatesRequests;
    use Illuminate\Routing\Controller as BaseController;

    abstract class Controller extends BaseController
    {
        use AuthorizesRequests, ValidatesRequests;
    }
    ```
  </Accordion>

  <Accordion title="app/Http/Middleware ontbreekt en ik kan middleware-instellingen niet wijzigen / app/Http/Kernel.php ontbreekt">
    In de nieuwe structuur is `app/Http/Kernel.php` vervallen; middleware configureer je nu via `withMiddleware()` in `bootstrap/app.php`.

    ```php theme={null}
    // bootstrap/app.php
    ->withMiddleware(function (Middleware $middleware) {
        // Alles wat je vroeger via bijvoorbeeld de TrustProxies-middleware instelde, kan nu via methodes van de Middleware-klasse
        $middleware->trustProxies(at: '*');

        // Globale middleware toevoegen
        $middleware->append(\App\Http\Middleware\MyMiddleware::class);

        // Een alias instellen voor routegroepen
        $middleware->alias([
            'my-middleware' => \App\Http\Middleware\MyMiddleware::class,
        ]);

        // Web- / API-middlewaregroepen aanpassen
        $middleware->web(append: [
            \App\Http\Middleware\HandleInertiaRequests::class,
        ]);
    })
    ```

    De bestanden van je eigen middleware maak je nog steeds aan in `app/Http/Middleware/`.
  </Accordion>

  <Accordion title="$this->middleware() werkt niet binnen een controller">
    `$this->middleware()` is functionaliteit van `Illuminate\Routing\Controller` en is dus niet beschikbaar in de lege basiscontroller van de nieuwe structuur.

    Implementeer in plaats daarvan de interface `HasMiddleware` en definieer een `middleware()`-methode.

    ```php theme={null}
    use Illuminate\Routing\Controllers\HasMiddleware;
    use Illuminate\Routing\Controllers\Middleware;

    class UserController extends Controller implements HasMiddleware
    {
        public static function middleware(): array
        {
            return [
                'auth',
                new Middleware('log', only: ['index']),
                new Middleware('subscribed', except: ['index']),
            ];
        }
    }
    ```

    Vanaf Laravel 13 kun je ook het `#[Middleware]`-attribute gebruiken.

    ```php theme={null}
    use Illuminate\Routing\Controllers\HasMiddleware;
    use App\Http\Middleware\EnsureTokenIsValid;

    #[Middleware(EnsureTokenIsValid::class)]
    class UserController extends Controller
    {
        // ...
    }
    ```

    Zie: [Controller middleware](https://laravel.com/docs/13.x/controllers#controller-middleware)
  </Accordion>

  <Accordion title="$this->authorizeResource() bestaat niet">
    `authorizeResource()` is afhankelijk van de trait `AuthorizesRequests` en werkt daarom niet in de lege basiscontroller van de nieuwe structuur.

    **Er zijn meerdere oplossingen.**

    **1. De basiscontroller terugbrengen naar de Laravel 10-opzet (het eenvoudigst)**

    ```php theme={null}
    // app/Http/Controllers/Controller.php
    use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
    use Illuminate\Routing\Controller as BaseController;

    abstract class Controller extends BaseController
    {
        use AuthorizesRequests;
    }
    ```

    Hiermee kun je `$this->authorizeResource()` weer gebruiken.

    **2. Het `#[Authorize]`-attribute van Laravel 13 op elke methode zetten**

    ```php theme={null}
    use Illuminate\Routing\Attributes\Controllers\Authorize;
    use App\Models\Post;

    class PostController extends Controller
    {
        #[Authorize('view', 'post')]
        public function show(Post $post) { /* ... */ }

        #[Authorize('update', 'post')]
        public function update(Request $request, Post $post) { /* ... */ }
    }
    ```
  </Accordion>

  <Accordion title="app/Console/Kernel.php ontbreekt en ik kan de Schedule niet instellen">
    In de nieuwe structuur is `app/Console/Kernel.php` vervallen en is de plek voor het instellen van de schedule veranderd.

    **In `routes/console.php` zetten (aanbevolen):**

    ```php theme={null}
    // routes/console.php
    use Illuminate\Support\Facades\Schedule;

    Schedule::command('emails:send')->daily();
    Schedule::job(new SendEmails)->everyFiveMinutes();
    ```

    **In `bootstrap/app.php` zetten:**

    ```php theme={null}
    ->withSchedule(function (Schedule $schedule) {
        $schedule->command('emails:send')->daily();
    })
    ```
  </Accordion>

  <Accordion title="Ik weet niet hoe ik events en listeners registreer">
    In de nieuwe structuur is de `EventServiceProvider` vervallen en is handmatig registreren van events en listeners niet meer nodig.

    **Hoe automatische registratie werkt:** zodra je in de `handle()`-methode van een listenerklasse de eventklasse als type declareert, wordt de listener automatisch geregistreerd.

    ```php theme={null}
    namespace App\Listeners;

    use App\Events\OrderShipped;

    class SendShipmentNotification
    {
        // Alleen al door de eventklasse als argument van handle() op te geven, wordt deze automatisch geregistreerd
        public function handle(OrderShipped $event): void
        {
            // ...
        }
    }
    ```

    Is handmatige registratie toch nodig, dan doe je dat in `AppServiceProvider::boot()`.

    ```php theme={null}
    use Illuminate\Support\Facades\Event;

    public function boot(): void
    {
        Event::listen(
            OrderShipped::class,
            SendShipmentNotification::class,
        );
    }
    ```
  </Accordion>

  <Accordion title="Ik weet niet hoe ik een service provider aan config/app.php toevoeg">
    In de nieuwe structuur is het beheer van de lijst met service providers verplaatst van `config/app.php` naar `bootstrap/providers.php`.

    ```php theme={null}
    // bootstrap/providers.php
    return [
        App\Providers\AppServiceProvider::class,
        App\Providers\MyCustomServiceProvider::class, // ← hier toevoegen
    ];
    ```

    Providers die je aanmaakt met `artisan make:provider` worden hier automatisch aan toegevoegd.
  </Accordion>

  <Accordion title="app/Exceptions/Handler.php ontbreekt">
    In de nieuwe structuur is `app/Exceptions/Handler.php` vervallen; de afhandeling van excepties configureer je via `withExceptions()` in `bootstrap/app.php`.

    ```php theme={null}
    // bootstrap/app.php
    ->withExceptions(function (Exceptions $exceptions) {
        // Bepaalde excepties niet rapporteren
        $exceptions->dontReport(InvalidOrderException::class);

        // Aangepaste rendering
        $exceptions->render(function (InvalidOrderException $e, Request $request) {
            return response()->view('errors.invalid-order', status: 500);
        });

        // Redirectdoel bij niet-geauthenticeerde requests wijzigen
        $exceptions->shouldRenderJsonWhen(function (Request $request, Throwable $e) {
            return $request->is('api/*');
        });
    })
    ```
  </Accordion>

  <Accordion title="Ik wil de routing aanpassen">
    Routes pas je aan via `withRouting()` in `bootstrap/app.php`.

    **Een routebestand toevoegen:**

    ```php theme={null}
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        then: function () {
            Route::middleware('web')
                ->prefix('admin')
                ->group(base_path('routes/admin.php'));
        },
    )
    ```

    **Volledige controle nemen (zoals de `RouteServiceProvider` in Laravel 10):**

    Geef je `using` op, dan wordt de standaard routeregistratie van Laravel volledig uitgeschakeld en beheer je alles zelf.

    ```php theme={null}
    ->withRouting(
        using: function () {
            Route::middleware('web')
                ->group(base_path('routes/web.php'));

            Route::middleware('api')
                ->prefix('api')
                ->group(base_path('routes/api.php'));
        },
    )
    ```
  </Accordion>

  <Accordion title="Ik wil een standaard ServiceProvider van Laravel vervangen">
    Voeg je een `providers`-sleutel toe aan `config/app.php`, dan wordt die samengevoegd met de `config/app.php` binnen het framework en toegepast.

    ```php theme={null}
    // config/app.php
    use Illuminate\Support\ServiceProvider;

    return [
        // ...
        'providers' => ServiceProvider::defaultProviders()->replace([
            Illuminate\Foo\FooServiceProvider::class => Bar\BarServiceProvider::class,
        ])->toArray(),
    ];
    ```

    Met de `replace()`-methode vervang je een standaardprovider door je eigen implementatie.
  </Accordion>

  <Accordion title="routes/api.php ontbreekt">
    Vanaf Laravel 11 is API-functionaliteit niet standaard aanwezig; je installeert die apart wanneer je die nodig hebt.

    ```bash theme={null}
    php artisan install:api
    ```

    Dit commando maakt en configureert het volgende:

    * `routes/api.php`
    * De configuratie van [Laravel Sanctum](https://laravel.com/docs/sanctum) voor API-authenticatie
    * Registratie van de API-routes in `bootstrap/app.php`
  </Accordion>

  <Accordion title="routes/channels.php ontbreekt">
    Vanaf Laravel 11 is ook broadcastingfunctionaliteit niet standaard aanwezig; je installeert die apart wanneer je die nodig hebt.

    ```bash theme={null}
    php artisan install:broadcasting
    ```

    Dit commando maakt en configureert het volgende:

    * `routes/channels.php`
    * De installatie en configuratie van [Laravel Reverb](https://laravel.com/docs/reverb)
    * Het configuratiebestand voor broadcasting
  </Accordion>

  <Accordion title="Ik wil weten of een project waar ik instap de oude of nieuwe structuur gebruikt">
    Bekijk de inhoud van `bootstrap/app.php`.

    **Nieuwe structuur van Laravel 11 en later (of al gemigreerd):**

    ```php theme={null}
    // bootstrap/app.php
    return Application::configure(basePath: dirname(__DIR__))
        ->withRouting(...)
        ->withMiddleware(...)
        ->withExceptions(...)
        ->create();
    ```

    **Project dat met de oude structuur van Laravel 10 of eerder is geüpgraded:**

    ```php theme={null}
    // bootstrap/app.php
    $app = new Illuminate\Foundation\Application(
        $_ENV['APP_BASE_PATH'] ?? dirname(__DIR__)
    );

    $app->singleton(
        Illuminate\Contracts\Http\Kernel::class,
        App\Http\Kernel::class
    );
    // ...
    ```

    Zie je de vorm `return Application::configure(...`, dan is het de nieuwe structuur; zo niet, dan is het een project dat met de oude structuur is geüpgraded. Voor het migreren van een project met de oude structuur naar de nieuwe structuur, zie de [migratiegids](/nl/advanced/app-structure-migration).
  </Accordion>
</AccordionGroup>

## Gerelateerde pagina's

<Card title="Applicatiestructuur van Laravel 11 en later" icon="sitemap" href="/nl/advanced/app-structure">
  Een compleet overzicht van de nieuwe applicatiestructuur en de interne implementatie van de `ApplicationBuilder`.
</Card>

<Card title="Migratiegids van oude naar nieuwe structuur" icon="arrow-right" href="/nl/advanced/app-structure-migration">
  Stap voor stap migreren van de oude appstructuur van Laravel 10 naar de nieuwe structuur van Laravel 11 en later.
</Card>


## Related topics

- [Applicatiestructuur van Laravel 11 en later](/nl/advanced/app-structure.md)
- [Migratiegids van oude naar nieuwe structuur](/nl/advanced/app-structure-migration.md)
- [Het nieuwe code-analyse-ecosysteem van Laravel — surveyor / ranger / roster](/nl/blog/laravel-ecosystem-analysis.md)
- [Upgradegids van Laravel 11 naar 12](/nl/blog/upgrade-11-to-12.md)
- [Laravel-updates van augustus 2026](/nl/blog/changelog/202608.md)