> ## 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 zur neuen App-Struktur ab Laravel 11

> Häufige Fragen und Antworten rund um die Slim Application Skeleton, die mit Laravel 11 eingeführt wurde. Für alle, die in Projekten mit alter Struktur eingestiegen sind oder mit älteren Büchern und Tutorials gelernt haben.

Mit Laravel 11 wurde die Anwendungsstruktur als „Slim Application Skeleton" grundlegend überarbeitet. Wer in einem Projekt mit alter Struktur eingestiegen ist oder mit Laravel 10 und älteren Büchern gelernt hat, stolpert an denselben Stellen. Wir sammeln hier die Fragen, die in Laracasts-Foren und auf Stack Overflow rund um das Release von Laravel 11 besonders häufig gestellt wurden.

<Info>
  Dieses FAQ richtet sich an **neue Projekte** (Laravel 11 oder höher). Die Migration eines bestehenden Projekts wird im [Migrationsleitfaden](/de/advanced/app-structure-migration) beschrieben.
</Info>

<AccordionGroup>
  <Accordion title="Es gibt weniger config-Dateien">
    In der neuen Struktur werden selten geänderte Config-Dateien aus dem Projekt entfernt. Verwendet werden dann die Dateien im Framework-eigenen `config/`.

    Projekt- und Framework-`config/` werden gemergt, wobei **die Projekt-Seite Vorrang** hat. Sobald Anpassungen nötig sind, legen Sie die Datei einfach an — sie wird berücksichtigt.

    ```bash theme={null}
    # Config-Datei im Framework anschauen
    cat vendor/laravel/framework/config/cors.php

    # In das Projekt kopieren und anpassen
    php artisan config:publish cors
    ```
  </Accordion>

  <Accordion title="$this->validate() oder $this->authorize() geht im Controller nicht mehr">
    In der neuen Struktur von Laravel 11 ist `App\Http\Controllers\Controller` eine leere Klasse. Sie erbt nicht mehr von `Illuminate\Routing\Controller` und verwendet weder `ValidatesRequests` noch `AuthorizesRequests`.

    | Laravel 10                               | Laravel 11   |
    | ---------------------------------------- | ------------ |
    | Erbt von `Illuminate\Routing\Controller` | Leere Klasse |
    | Nutzt Trait `ValidatesRequests`          | Nein         |
    | Nutzt Trait `AuthorizesRequests`         | Nein         |

    Referenz: [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)

    **Alternativen:**

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

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

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

    Wenn Sie diese Methoden häufig brauchen, können Sie `App\Http\Controllers\Controller` wie in Laravel 10 wiederherstellen.

    ```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="Es gibt kein app/Http/Middleware bzw. kein app/Http/Kernel.php mehr">
    In der neuen Struktur entfällt `app/Http/Kernel.php`. Middleware konfigurieren Sie über `withMiddleware()` in `bootstrap/app.php`.

    ```php theme={null}
    // bootstrap/app.php
    ->withMiddleware(function (Middleware $middleware) {
        // Einstellungen der TrustProxies-Middleware und andere gehen alle über Methoden der Middleware-Klasse
        $middleware->trustProxies(at: '*');

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

        // Alias für Route-Gruppen
        $middleware->alias([
            'my-middleware' => \App\Http\Middleware\MyMiddleware::class,
        ]);

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

    Die Middleware-Dateien selbst legen Sie weiterhin in `app/Http/Middleware/` an.
  </Accordion>

  <Accordion title="Im Controller funktioniert $this->middleware() nicht mehr">
    `$this->middleware()` gehört zu `Illuminate\Routing\Controller` und ist im leeren Basiscontroller der neuen Struktur nicht verfügbar.

    Verwenden Sie stattdessen das Interface `HasMiddleware` und definieren Sie die Methode `middleware()`.

    ```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']),
            ];
        }
    }
    ```

    Ab Laravel 13 gibt es zusätzlich das Attribut `#[Middleware]`.

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

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

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

  <Accordion title="$this->authorizeResource() fehlt">
    `authorizeResource()` gehört zum Trait `AuthorizesRequests` und ist im leeren Basiscontroller der neuen Struktur nicht verfügbar.

    **Es gibt mehrere Optionen.**

    **1. Basiscontroller wie in Laravel 10 wiederherstellen (am einfachsten)**

    ```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;
    }
    ```

    Damit steht `$this->authorizeResource()` wieder zur Verfügung.

    **2. Das Laravel-13-Attribut `#[Authorize]` an jeder Methode einsetzen**

    ```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="Es gibt kein app/Console/Kernel.php mehr, wie richte ich den Scheduler ein?">
    In der neuen Struktur entfällt `app/Console/Kernel.php`; der Scheduler wird an anderer Stelle konfiguriert.

    **In `routes/console.php` (empfohlen):**

    ```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`:**

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

  <Accordion title="Wie registriere ich Events und Listener?">
    In der neuen Struktur entfällt der `EventServiceProvider` — Events und Listener müssen nicht mehr manuell registriert werden.

    **Automatische Registrierung:** Deklarieren Sie in der `handle()`-Methode des Listeners die Event-Klasse per Type-Hint — sie wird automatisch registriert.

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

    use App\Events\OrderShipped;

    class SendShipmentNotification
    {
        // Ein Type-Hint der Event-Klasse in handle() reicht für die automatische Registrierung
        public function handle(OrderShipped $event): void
        {
            // ...
        }
    }
    ```

    Manuelle Registrierung erfolgt in `AppServiceProvider::boot()`.

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

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

  <Accordion title="Wie füge ich Service Provider in config/app.php hinzu?">
    In der neuen Struktur wird die Provider-Liste nicht mehr in `config/app.php`, sondern in `bootstrap/providers.php` gepflegt.

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

    Ein per `artisan make:provider` erzeugter Provider wird automatisch dort eingetragen.
  </Accordion>

  <Accordion title="Es gibt kein app/Exceptions/Handler.php mehr">
    In der neuen Struktur entfällt `app/Exceptions/Handler.php`. Ausnahmebehandlung konfigurieren Sie über `withExceptions()` in `bootstrap/app.php`.

    ```php theme={null}
    // bootstrap/app.php
    ->withExceptions(function (Exceptions $exceptions) {
        // Bestimmte Exceptions nicht melden
        $exceptions->dontReport(InvalidOrderException::class);

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

        // Weiterleitung bei nicht authentifizierten Nutzern anpassen
        $exceptions->shouldRenderJsonWhen(function (Request $request, Throwable $e) {
            return $request->is('api/*');
        });
    })
    ```
  </Accordion>

  <Accordion title="Ich möchte Routing anpassen">
    Routing passen Sie über `withRouting()` in `bootstrap/app.php` an.

    **Zusätzliche Route-Datei einbinden:**

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

    **Vollständige Kontrolle (wie beim `RouteServiceProvider` in Laravel 10):**

    Mit `using` deaktivieren Sie die Standard-Registrierung von Laravel vollständig und übernehmen alles selbst.

    ```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="Ich möchte den Standard-ServiceProvider von Laravel ersetzen">
    Fügen Sie in `config/app.php` den Schlüssel `providers` ein — die Einstellung wird mit der Framework-Konfiguration gemergt.

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

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

    Mit `replace()` tauschen Sie Standard-Provider durch eigene Implementierungen aus.
  </Accordion>

  <Accordion title="Es gibt keine routes/api.php">
    Ab Laravel 11 sind API-Funktionen standardmäßig nicht enthalten und werden bei Bedarf einzeln installiert.

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

    Der Befehl legt bzw. konfiguriert:

    * `routes/api.php`
    * Einstellungen für [Laravel Sanctum](https://laravel.com/docs/sanctum) als API-Authentifizierung
    * Registrierung der API-Routen in `bootstrap/app.php`
  </Accordion>

  <Accordion title="Es gibt keine routes/channels.php">
    Auch Broadcasting ist ab Laravel 11 standardmäßig nicht enthalten und wird bei Bedarf einzeln installiert.

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

    Der Befehl legt bzw. konfiguriert:

    * `routes/channels.php`
    * Setup von [Laravel Reverb](https://laravel.com/docs/reverb)
    * Broadcasting-Konfigurationsdateien
  </Accordion>

  <Accordion title="Wie erkenne ich, ob ein Projekt neu oder alt strukturiert ist?">
    Schauen Sie in `bootstrap/app.php`.

    **Neue Struktur ab Laravel 11 (oder bereits migriert):**

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

    **Ein Projekt in alter Struktur, das nur auf die neue Version gehoben wurde:**

    ```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
    );
    // ...
    ```

    Beginnt die Datei mit `return Application::configure(...)`, ist es die neue Struktur — andernfalls ein Upgrade in alter Struktur. Die Migration zur neuen Struktur beschreibt der [Migrationsleitfaden](/de/advanced/app-structure-migration).
  </Accordion>
</AccordionGroup>

## Verwandte Seiten

<Card title="Anwendungsstruktur ab Laravel 11" icon="sitemap" href="/de/advanced/app-structure">
  Vollständige Erläuterung der neuen App-Struktur und der internen Implementierung des `ApplicationBuilder`.
</Card>

<Card title="Migrationsleitfaden von alter zu neuer Struktur" icon="arrow-right" href="/de/advanced/app-structure-migration">
  Schritt-für-Schritt-Anleitung zum Umstieg von Laravel 10 auf die neue Struktur ab Laravel 11.
</Card>


## Related topics

- [Migrationsleitfaden von der alten zur neuen Struktur](/de/advanced/app-structure-migration.md)
- [Anwendungsstruktur ab Laravel 11](/de/advanced/app-structure.md)
- [Übersicht der neuen Features in Laravel 13](/de/blog/laravel-13-new-features.md)
- [Labeler](/de/packages/laravel-bluesky/labeler.md)
- [Upgrade von Laravel 10 auf 11](/de/blog/upgrade-10-to-11.md)