Laravel

Performance Optimization Comparison

Vanilla PHP caching approach:

// Vanilla PHP - Manual caching implementation
function getUserData($userId) {
    $cacheFile = 'cache/user_' . $userId . '.cache';
    
    if (file_exists($cacheFile) && (time() - filemtime($cacheFile) < 3600)) {
        return unserialize(file_get_contents($cacheFile));
    }
    
    // Database query
    $db = new PDO('mysql:host=localhost;dbname=app', 'user', 'password');
    $stmt = $db->prepare('SELECT * FROM users WHERE id = ?');
    $stmt->execute([$userId]);
    $data = $stmt->fetch(PDO::FETCH_ASSOC);
    
    // Store in cache
    file_put_contents($cacheFile, serialize($data));
    
    return $data;
}
        

Laravel caching approach:

// Laravel - Using the Cache facade
use Illuminate\Support\Facades\Cache;

function getUserData($userId) {
    return Cache::remember('user:' . $userId, 3600, function () use ($userId) {
        return User::find($userId);
    });
}
        

Architectural Flow in Laravel Directory Structure:

// 1. Request enters via public/index.php front controller
require __DIR__.'/../bootstrap/autoload.php';
$app = require_once __DIR__.'/../bootstrap/app.php';

// 2. Routes defined in routes/web.php
Route::get('/users', [UserController::class, 'index']);

// 3. Controller in app/Http/Controllers/UserController.php
public function index()
{
    $users = User::all(); // Model interaction
    return view('users.index', compact('users')); // View rendering
}

// 4. Model in app/Models/User.php
class User extends Authenticatable
{
    // Relationships, attributes, query scopes
}

// 5. View in resources/views/users/index.blade.php
@foreach($users as $user)
    {{ $user->name }}
@endforeach
        

Route Definition Anatomy:

Route::get('profile/{id}', [ProfileController::class, 'show'])
    ->middleware('auth')
    ->name('profile.show')
    ->where('id', '[0-9]+');
        

Route Dispatching Internals:

// Simplified internals of route matching
$request = Request::capture();
$router = app(Router::class);

// Find route that matches the request
$route = $router->getRoutes()->match($request);

// Execute middleware stack
$response = $router->prepareResponse(
    $request, 
    $route->run($request)
);
        

Parameter Constraints and Validation:

// Using the where method for inline constraints
Route::get('users/{id}', [UserController::class, 'show'])
    ->where('id', '[0-9]+');

// Global pattern constraints in RouteServiceProvider
public function boot()
{
    Route::pattern('id', '[0-9]+');
    // ...
}

// Custom parameter binding with explicit model resolution
Route::bind('user', function ($value) {
    return User::where('username', $value)
        ->firstOrFail();
});

// Implicit model binding with custom resolution logic
Route::get('users/{user:username}', function (User $user) {
    // $user is resolved by username instead of ID
});
        

Advanced Named Route Techniques:

// Generating URLs with query parameters
$url = route('users.index', [
    'search' => 'John',
    'filter' => 'active',
]);

// Accessing the current route name
if (Route::currentRouteName() === 'users.show') {
    // Logic for the users.show route
}

// Checking if a route exists
if (Route::has('api.users.show')) {
    // The route exists
}

// URL generation for signed routes (tamper-proof URLs)
$url = URL::signedRoute('unsubscribe', ['user' => 1]);

// Temporary signed routes with expiration
$url = URL::temporarySignedRoute(
    'confirm-registration',
    now()->addMinutes(30),
    ['user' => 1]
);
        

Advanced Route Grouping Techniques:

// Domain routing for multi-tenant applications
Route::domain('tenant.{account}.example.com')->group(function () {
    Route::get('/', function ($account) {
        // $account will be the subdomain segment
    });
});

// Route group with rate limiting
Route::middleware([
    'auth:api',
    'throttle:60,1' // 60 requests per minute
])->prefix('api/v1')->group(function () {
    // API routes
});

// Controller groups with namespace (Laravel < 8)
Route::namespace('Admin')->prefix('admin')->group(function () {
    // Controllers in App\Http\Controllers\Admin namespace
});

// Conditional route registration
Route::middleware('auth')->group(function () {
    if (config('features.notifications')) {
        Route::get('notifications', [NotificationController::class, 'index']);
    }
});
        

// In a ModuleServiceProvider
public function boot()
{
    $this->loadRoutesFrom(__DIR__ . '/../routes/module.php');
}
        

Advanced Controller Implementation with Multiple Concerns:

namespace App\Http\Controllers;

use App\Http\Requests\StoreUserRequest;
use App\Models\User;
use App\Services\UserService;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;

class UserController extends Controller
{
    protected $userService;
    
    // Constructor injection
    public function __construct(UserService $userService)
    {
        $this->userService = $userService;
        // Apply middleware only to specific methods
        $this->middleware('auth')->only(['store', 'update', 'destroy']);
        $this->middleware('role:admin')->except(['index', 'show']);
    }
    
    // Type-hinted dependency injection in method
    public function store(StoreUserRequest $request): JsonResponse
    {
        try {
            // Request is automatically validated due to form request type
            $user = $this->userService->createUser($request->validated());
            return response()->json(['user' => $user, 'message' => 'User created'], 201);
        } catch (\Exception $e) {
            Log::error('User creation failed: ' . $e->getMessage());
            return response()->json(['error' => 'Failed to create user'], 500);
        }
    }
    
    // Route model binding via type-hint
    public function show(User $user)
    {
        // $user is automatically fetched by ID from the route parameter
        return view('users.show', compact('user'));
    }
}
    

Resource Controller with Model Binding and API Resources:

namespace App\Http\Controllers;

use App\Http\Resources\ProductResource;
use App\Http\Resources\ProductCollection;
use App\Models\Product;
use App\Http\Requests\ProductStoreRequest;
use App\Http\Requests\ProductUpdateRequest;

class ProductController extends Controller
{
    public function index()
    {
        $products = Product::paginate(15);
        return new ProductCollection($products);
    }

    public function store(ProductStoreRequest $request)
    {
        $product = Product::create($request->validated());
        return new ProductResource($product);
    }

    public function show(Product $product) // Implicit route model binding
    {
        return new ProductResource($product);
    }

    public function update(ProductUpdateRequest $request, Product $product)
    {
        $product->update($request->validated());
        return new ProductResource($product);
    }

    public function destroy(Product $product)
    {
        $product->delete();
        return response()->noContent();
    }
}
    

HTTP Request
  ↓
Route Matching
  ↓
Global Middleware (app/Http/Kernel.php)
  ↓
Route Group Middleware
  ↓
Controller Middleware
  ↓
Controller Method
  ↓
Response
  ↓
Middleware (in reverse order)
  ↓
HTTP Response
    

View Service Provider Registration:

// The ViewServiceProvider bootstraps the entire view system
namespace Illuminate\View\Providers;

class ViewServiceProvider extends ServiceProvider
{
    public function register()
    {
        $this->registerFactory();
        $this->registerViewFinder();
        $this->registerEngineResolver();
    }
}
        

Blade Compilation Internals:

// From Illuminate\View\Compilers\BladeCompiler
protected function compileStatements($content)
{
    // Pattern matching for all registered directives
    return preg_replace_callback(
        '/\B@(\w+)([ \t]*)(\( ( (?>[^()]+) | (?3) )* \))?/x',
        function ($match) {
            return $this->compileStatement($match);
        },
        $content
    );
}
        

Custom Blade Directive Registration:

// In a service provider
public function boot()
{
    Blade::directive('datetime', function ($expression) {
        return "format('m/d/Y H:i'); ?>";
    });
}

// Usage in Blade template
@datetime($user->created_at)
        

Directive Registration Mechanism:

// From BladeServiceProvider
public function boot()
{
    $blade = $this->app['view']->getEngineResolver()->resolve('blade')->getCompiler();
    
    // Core directive registration
    $blade->directive('if', function ($expression) {
        return "";
    });
    
    // Custom directive example
    $blade->directive('datetime', function ($expression) {
        return "format('Y-m-d H:i:s'); ?>";
    });
}
        

Multi-level Inheritance:

// Master layout (resources/views/layouts/master.blade.php)
<html>
<head>
    <title>@yield('site-title') - @yield('page-title', 'Default')</title>
    @yield('meta')
    @stack('styles')
</head>
<body>
    @include('partials.header')
    
    <div class="container">
        @yield('content')
    </div>
    
    @include('partials.footer')
    @stack('scripts')
</body>
</html>

// Intermediate layout (resources/views/layouts/admin.blade.php)
@extends('layouts.master')

@section('site-title', 'Admin Panel')

@section('meta')
    <meta name="robots" content="noindex">
    @parent
@endsection

@section('content')
    <div class="admin-container">
        <div class="sidebar">
            @include('admin.sidebar')
        </div>
        <div class="main">
            @yield('admin-content')
        </div>
    </div>
@endsection

@push('scripts')
    <script src="{{ asset('js/admin.js') }}"></script>
@endpush

// Page view (resources/views/admin/dashboard.blade.php)
@extends('layouts.admin')

@section('page-title', 'Dashboard')

@section('admin-content')
    <h1>Admin Dashboard</h1>
    <div class="dashboard-widgets">
        @each('admin.widgets.card', $widgets, 'widget', 'admin.widgets.empty')
    </div>
@endsection

@prepend('scripts')
    <script src="{{ asset('js/dashboard.js') }}"></script>
@endprepend
        

Class-based Component:

// App\View\Components\Alert.php
namespace App\View\Components;

use Illuminate\View\Component;

class Alert extends Component
{
    public $type;
    public $message;
    
    public function __construct($type, $message)
    {
        $this->type = $type;
        $this->message = $message;
    }
    
    public function render()
    {
        return view('components.alert');
    }
    
    // Computed property
    public function alertClasses()
    {
        return 'alert alert-' . $this->type;
    }
}

// resources/views/components/alert.blade.php
<div class="{{ $alertClasses }}">
    <div class="alert-title">{{ $title ?? 'Notice' }}</div>
    <div class="alert-body">{{ $message }}</div>
    {{ $slot }}
</div>

// Usage
<x-alert type="error" message="System error occurred">
    <p>Please contact support.</p>
</x-alert>
        

Customizing Model Configuration:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    // Custom table name
    protected $table = 'inventory_items';
    
    // Custom primary key
    protected $primaryKey = 'product_id';
    
    // Disable auto-timestamps
    public $timestamps = false;
    
    // Custom connection
    protected $connection = 'inventory_db';
    
    // Mass assignment protection
    protected $fillable = ['name', 'price', 'description'];
    protected $guarded = ['product_id', 'admin_notes'];
    
    // Default attribute values
    protected $attributes = [
        'is_active' => true,
        'stock' => 0
    ];
}
        

Advanced Eloquent Query Techniques:

// Subqueries in Eloquent
$users = User::addSelect([
    'last_order_date' => Order::select('created_at')
        ->whereColumn('user_id', 'users.id')
        ->latest()
        ->limit(1)
])->get();

// Complex joins with constraints
$posts = Post::with(['comments' => function($query) {
    $query->where('is_approved', true);
}])
->whereHas('comments', function($query) {
    $query->where('rating', '>', 4);
}, '>=', 3)
->get();

// Querying JSON columns
$users = User::where('preferences->theme', 'dark')
             ->whereJsonContains('roles', 'admin')
             ->get();
        

Creation Methods and Their Internals:

// Standard creation pattern
$post = new Post;
$post->title = 'Advanced Eloquent';
$post->content = 'Content here...';
$post->save(); // Triggers created/saved events, performs insert query

// Mass assignment with protection
$post = Post::create([
    'title' => 'Advanced Eloquent',
    'content' => 'Content here...'
]); // Checks $fillable/$guarded, triggers events, returns instance

// createOrFirst with unique constraints
$post = Post::firstOrCreate(
    ['slug' => 'advanced-eloquent'], // Unique constraint fields
    ['title' => 'Advanced Eloquent', 'content' => 'Content'] // Additional fields
); // Performs SELECT first, INSERT only if needed

// Inserting multiple records efficiently
Post::insert([
    ['title' => 'Post 1', 'content' => 'Content 1'],
    ['title' => 'Post 2', 'content' => 'Content 2'],
]); // Bulk insert without creating model instances or firing events

// Create with relationships
$post = User::find(1)->posts()->create([
    'title' => 'My New Post',
    'content' => 'Content here...'
]); // Automatically sets the foreign key
        

// Query building with advanced conditions
$posts = Post::where(function($query) {
    $query->where('status', 'published')
          ->orWhere(function($query) {
              $query->where('status', 'draft')
                    ->where('user_id', auth()->id());
          });
})
->whereHas('comments', function($query) {
    $query->where('is_approved', true);
}, '>', 5) // Posts with more than 5 approved comments
->withCount([
    'comments', 
    'comments as approved_comments_count' => function($query) {
        $query->where('is_approved', true);
    }
])
->with(['user' => function($query) {
    $query->select('id', 'name');
}])
->latest()
->paginate(15);

// Raw expressions
$posts = Post::selectRaw('COUNT(*) as post_count, DATE(created_at) as date')
             ->whereRaw('YEAR(created_at) = ?', [date('Y')])
             ->groupBy('date')
             ->orderByDesc('date')
             ->get();

// Chunk processing for large datasets
Post::where('needs_processing', true)
    ->chunkById(100, function($posts) {
        foreach ($posts as $post) {
            // Process each post
            $post->update(['processed' => true]);
        }
    });
        

// Efficient increment/decrement
Post::where('id', 1)->increment('views', 1, ['last_viewed_at' => now()]);

// Conditional updates
$post = Post::find(1);
$post->title = 'New Title';
// Only save if the model has changed
if ($post->isDirty()) {
    // Get which attributes changed
    $changes = $post->getDirty();
    $post->save();
}

// Using updateOrCreate for upserts
$post = Post::updateOrCreate(
    ['slug' => 'unique-slug'], // Fields to match
    ['title' => 'Updated Title', 'content' => 'Updated content'] // Fields to update/create
);

// Touching timestamps on relationships
$user = User::find(1);
// Update user's updated_at and all related posts' updated_at
$user->touch();
$user->posts()->touch();

// Mass update with JSON columns
Post::where('id', 1)->update([
    'title' => 'New Title',
    'metadata->views' => DB::raw('metadata->views + 1'),
    'tags' => DB::raw('JSON_ARRAY_APPEND(tags, '$', "new-tag")')
]);
        

// Soft deletes
// First ensure your model uses SoftDeletes trait and migration includes deleted_at
use Illuminate\Database\Eloquent\SoftDeletes;

class Post extends Model
{
    use SoftDeletes;
    // ...
}

// Working with soft deletes
$post = Post::find(1);
$post->delete(); // Soft delete - sets deleted_at column
Post::withTrashed()->get(); // Get all posts including soft deleted
Post::onlyTrashed()->get(); // Get only soft deleted posts
$post->restore(); // Restore a soft deleted post
$post->forceDelete(); // Permanently delete

// Cascading deletes through relationships
// In your User model:
public function posts()
{
    return $this->hasMany(Post::class);
}

// Option 1: Using deleting event
public static function boot()
{
    parent::boot();
    
    static::deleting(function($user) {
        $user->posts()->delete();
    });
}

// Option 2: Using onDelete cascade in migration
Schema::create('posts', function (Blueprint $table) {
    // ...
    $table->foreignId('user_id')
          ->constrained()
          ->onDelete('cascade');
});
        

// Basic transaction
DB::transaction(function () {
    $post = Post::create(['title' => 'New Post']);
    Comment::create([
        'post_id' => $post->id,
        'content' => 'First comment!'
    ]);
    // If any exception occurs, the transaction will be rolled back
});

// Manual transaction control
try {
    DB::beginTransaction();
    
    $post = Post::create(['title' => 'New Post']);
    
    if (someCondition()) {
        Comment::create([
            'post_id' => $post->id,
            'content' => 'First comment!'
        ]);
    }
    
    DB::commit();
} catch (\Exception $e) {
    DB::rollBack();
    throw $e;
}

// Transaction with deadlock retry
DB::transaction(function () {
    // Operations that might cause deadlocks
}, 5); // Will retry up to 5 times on deadlock
        

SQL Raw Statements:

DB::statement('CREATE FULLTEXT INDEX fulltext_index ON articles(title, body)');
        

Complex Alterations with Foreign Key Constraints:

Schema::table('posts', function (Blueprint $table) {
    $table->unsignedBigInteger('user_id');
    
    $table->foreign('user_id')
          ->references('id')
          ->on('users')
          ->onDelete('cascade');
});
        

Custom Migration Repository:

// In a service provider
$this->app->singleton('migration.repository', function ($app) {
    return new CustomMigrationRepository(
        $app['db'], 'migrations'
    );
});
        

// Multiple seeders with specific ordering and conditionals
public function run()
{
    if (app()->environment('local', 'testing')) {
        $this->call([
            PermissionsSeeder::class,
            RolesSeeder::class,
            UsersSeeder::class,
            // Dependencies must be seeded first
            PostsSeeder::class,
            CommentsSeeder::class,
        ]);
    } else {
        $this->call(ProductionMinimalSeeder::class);
    }
}
        

// Advanced factory with states and relationships
class UserFactory extends Factory
{
    protected $model = User::class;
    
    public function definition()
    {
        return [
            'name' => $this->faker->name(),
            'email' => $this->faker->unique()->safeEmail(),
            'email_verified_at' => now(),
            'password' => Hash::make('password'),
            'remember_token' => Str::random(10),
        ];
    }
    
    // State definitions for variations
    public function admin()
    {
        return $this->state(function (array $attributes) {
            return [
                'role' => 'admin',
                'permissions' => json_encode(['manage_users', 'manage_content'])
            ];
        });
    }
    
    // After-creation hooks for relationships or additional processing
    public function configure()
    {
        return $this->afterCreating(function (User $user) {
            $user->profile()->create([
                'bio' => $this->faker->paragraph(),
                'avatar' => 'default.jpg'
            ]);
        });
    }
}
        

// Complex factory usage with relationships
User::factory()
    ->admin()
    ->has(Post::factory()->count(3)->has(
        Comment::factory()->count(5)
    ))
    ->count(10)
    ->create();

// Sequence-based attribute generation
User::factory()
    ->count(5)
    ->sequence(
        ['department' => 'Engineering'],
        ['department' => 'Marketing'],
        ['department' => 'Sales']
    )
    ->create();
        

// Dynamic test data in feature tests
public function test_user_can_view_posts()
{
    $user = User::factory()->create();
    $posts = Post::factory()
        ->count(3)
        ->for($user)
        ->create();
        
    $response = $this->actingAs($user)
                     ->get('dashboard');
                     
    $response->assertOk();
    $posts->each(function ($post) use ($response) {
        $response->assertSee($post->title);
    });
}
        

Idempotent Seeder Pattern for Production:

public function run()
{
    // Avoid duplicates in reference data
    $countries = [
        ['code' => 'US', 'name' => 'United States'],
        ['code' => 'CA', 'name' => 'Canada'],
        // More countries...
    ];
    
    foreach ($countries as $country) {
        Country::updateOrCreate(
            ['code' => $country['code']], // Identify by code
            $country // Full data to insert/update
        );
    }
}
        

// Optimized bulk seeding
public function run()
{
    Model::unguard();
    DB::disableQueryLog();
    
    $totalRecords = 100000;
    $chunkSize = 1000;
    
    DB::transaction(function () use ($totalRecords, $chunkSize) {
        for ($i = 0; $i < $totalRecords; $i += $chunkSize) {
            $users = User::factory()
                ->count($chunkSize)
                ->make()
                ->toArray();
                
            User::withoutEvents(function () use ($users) {
                User::insert($users);
            });
            
            // Free memory
            unset($users);
        }
    });
    
    Model::reguard();
}
        

Relationship Internals Example:

// In Illuminate\Database\Eloquent\Relations\HasMany:

protected function getRelationExistenceQuery(Builder $query, Builder $parentQuery, $columns = ['*'])
{
    return $query->select($columns)->whereColumn(
        $parentQuery->getModel()->qualifyColumn($this->localKey),
        '=',
        $this->getQualifiedForeignKeyName()
    );
}
        

Configuration in auth.php:

return [
    'defaults' => [
        'guard' => 'web',
        'passwords' => 'users',
    ],

    'guards' => [
        'web' => [
            'driver' => 'session',
            'provider' => 'users',
        ],
        'api' => [
            'driver' => 'sanctum',
            'provider' => 'users',
        ],
    ],

    'providers' => [
        'users' => [
            'driver' => 'eloquent',
            'model' => App\Models\User::class,
        ],
    ],
];
        

Manual Authentication Implementation:

public function authenticate(Request $request)
{
    $credentials = $request->validate([
        'email' => ['required', 'email'],
        'password' => ['required'],
    ]);
 
    // Attempt to authenticate with remember cookie
    if (Auth::attempt($credentials, $request->boolean('remember'))) {
        $request->session()->regenerate();
 
        // Access control logic
        return $this->handleUserRedirect(Auth::user());
    }
 
    // Authentication failed
    return back()->withErrors([
        'email' => 'The provided credentials do not match our records.',
    ])->onlyInput('email');
}
        

1. Authentication Guards Customization:

// config/auth.php
'guards' => [
    'web' => [
        'driver' => 'session',
        'provider' => 'users',
    ],
    
    // Custom guard example
    'admin' => [
        'driver' => 'session',
        'provider' => 'admins',
    ],
    
    // Token guard example
    'api' => [
        'driver' => 'sanctum',
        'provider' => 'users',
    ],
],

// Custom provider
'providers' => [
    'users' => [
        'driver' => 'eloquent',
        'model' => App\Models\User::class,
    ],
    
    'admins' => [
        'driver' => 'eloquent',
        'model' => App\Models\Admin::class,
    ],
],
        

2. Custom User Provider Implementation:

namespace App\Extensions;

use Illuminate\Contracts\Auth\UserProvider;
use Illuminate\Contracts\Auth\Authenticatable;

class CustomUserProvider implements UserProvider
{
    public function retrieveById($identifier) {
        // Custom logic to retrieve user by ID
    }
    
    public function retrieveByToken($identifier, $token) {
        // Custom logic for remember me token
    }
    
    public function updateRememberToken(Authenticatable $user, $token) {
        // Update token logic
    }
    
    public function retrieveByCredentials(array $credentials) {
        // Retrieve user by credentials
    }
    
    public function validateCredentials(Authenticatable $user, array $credentials) {
        // Validate credentials
    }
}

// Register in a service provider
Auth::provider('custom-provider', function ($app, array $config) {
    return new CustomUserProvider($config);
});
        

3. Custom Auth Guard Implementation:

namespace App\Extensions;

use Illuminate\Contracts\Auth\Guard;
use Illuminate\Contracts\Auth\UserProvider;
use Illuminate\Contracts\Auth\Authenticatable;

class CustomGuard implements Guard
{
    protected $provider;
    protected $user;

    public function __construct(UserProvider $provider)
    {
        $this->provider = $provider;
    }
    
    public function check() {
        return ! is_null($this->user());
    }
    
    public function guest() {
        return ! $this->check();
    }
    
    public function user() {
        if (! is_null($this->user)) {
            return $this->user;
        }
        
        // Custom logic to retrieve authenticated user
    }
    
    public function id() {
        if ($user = $this->user()) {
            return $user->getAuthIdentifier();
        }
    }
    
    public function validate(array $credentials = []) {
        // Custom validation logic
    }
    
    public function setUser(Authenticatable $user) {
        $this->user = $user;
        return $this;
    }
}

// Register in a service provider
Auth::extend('custom-guard', function ($app, $name, array $config) {
    return new CustomGuard($app->make('auth')->createUserProvider($config['provider']));
});
        

4. Customizing Authentication Middleware:

namespace App\Http\Middleware;

use Closure;
use Illuminate\Auth\Middleware\Authenticate as Middleware;

class CustomAuthenticate extends Middleware
{
    protected function redirectTo($request)
    {
        if ($request->expectsJson()) {
            return response()->json(['message' => 'Unauthorized'], 401);
        }
        
        if ($request->is('admin/*')) {
            return route('admin.login');
        }
        
        return route('login');
    }
    
    public function handle($request, Closure $next, ...$guards)
    {
        // Custom pre-authentication logic
        
        $result = parent::handle($request, $next, ...$guards);
        
        // Custom post-authentication logic
        
        return $result;
    }
}
        

Middleware Structure:

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class ExampleMiddleware
{
    public function handle(Request $request, Closure $next): Response
    {
        // Pre-processing logic

        $response = $next($request);

        // Post-processing logic
        
        return $response;
    }
}
        

Pipeline Implementation (simplified):

// Simplified version of how Laravel creates the middleware pipeline
$pipeline = new Pipeline($container);

return $pipeline
    ->send($request)
    ->through($middleware)
    ->then(function ($request) use ($route) {
        return $route->run($request);
    });
        

Implementation Details:

Global middleware is registered in the $middleware property of the app/Http/Kernel.php class:

protected $middleware = [
    // These run in the order listed for every request
    \App\Http\Middleware\TrustProxies::class,
    \Fruitcake\Cors\HandleCors::class,
    \App\Http\Middleware\PreventRequestsDuringMaintenance::class,
    \Illuminate\Foundation\Http\Middleware\ValidatePostSize::class,
    \App\Http\Middleware\TrimStrings::class,
    \Illuminate\Foundation\Http\Middleware\ConvertEmptyStringsToNull::class,
];
        

Behind the scenes, Laravel's HttpKernel sends requests through the global middleware stack using the Pipeline pattern:

// Simplified code from Illuminate\Foundation\Http\Kernel
protected function sendRequestThroughRouter($request)
{
    $this->app->instance('request', $request);
    
    Facade::clearResolvedInstance('request');
    
    $this->bootstrap();
    
    return (new Pipeline($this->app))
                ->send($request)
                ->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)
                ->then($this->dispatchToRouter());
}
        

Registration and Application:

Route middleware is registered in the $routeMiddleware property of the HTTP Kernel:

protected $routeMiddleware = [
    'auth' => \App\Http\Middleware\Authenticate::class,
    'auth.basic' => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
    'cache.headers' => \Illuminate\Http\Middleware\SetCacheHeaders::class,
    'can' => \Illuminate\Auth\Middleware\Authorize::class,
    'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
    'password.confirm' => \Illuminate\Auth\Middleware\RequirePassword::class,
    'signed' => \Illuminate\Routing\Middleware\ValidateSignature::class,
    'throttle' => \Illuminate\Routing\Middleware\ThrottleRequests::class,
    'verified' => \Illuminate\Auth\Middleware\EnsureEmailIsVerified::class,
];
        

Application to routes can be done through several methods:

// Single middleware
Route::get('profile', function () {
    // ...
})->middleware('auth');

// Multiple middleware
Route::get('admin/dashboard', function () {
    // ...
})->middleware(['auth', 'role:admin']);

// Middleware with parameters
Route::get('api/resource', function () {
    // ...
})->middleware('throttle:60,1');

// Controller middleware
class UserController extends Controller
{
    public function __construct()
    {
        $this->middleware('auth');
        $this->middleware('log')->only('index');
        $this->middleware('subscribed')->except('store');
    }
}
        

Structure and Configuration:

Middleware groups are defined in the $middlewareGroups property of the HTTP Kernel:

protected $middlewareGroups = [
    'web' => [
        \App\Http\Middleware\EncryptCookies::class,
        \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
        \Illuminate\Session\Middleware\StartSession::class,
        \Illuminate\View\Middleware\ShareErrorsFromSession::class,
        \App\Http\Middleware\VerifyCsrfToken::class,
        \Illuminate\Routing\Middleware\SubstituteBindings::class,
    ],

    'api' => [
        'throttle:api',
        \Illuminate\Routing\Middleware\SubstituteBindings::class,
    ],

    // Custom middleware groups can be defined here
    'admin' => [
        'auth',
        'role:admin',
        'log.admin.actions',
    ],
];
        

Application to routes:

// Apply middleware group
Route::middleware('admin')->group(function () {
    Route::get('admin/settings', 'AdminController@settings');
    Route::get('admin/reports', 'AdminController@reports');
});

// Laravel automatically applies middleware groups in RouteServiceProvider
// Inside the boot() method of RouteServiceProvider
Route::middleware('web')
    ->namespace($this->namespace)
    ->group(base_path('routes/web.php'));
        

Middleware Parameters:

Laravel supports parameterized middleware using colon syntax:

// In Kernel.php
protected $routeMiddleware = [
    'role' => \App\Http\Middleware\CheckRole::class,
];

// In middleware
public function handle($request, Closure $next, $role)
{
    if (!$request->user()->hasRole($role)) {
        return redirect('home');
    }
    
    return $next($request);
}

// In route definition
Route::get('admin', function () {
    // ...
})->middleware('role:administrator');

// Multiple parameters
Route::get('admin', function () {
    // ...
})->middleware('role:editor,author');
        

// Different ways to access form data
$name = $request->input('name');
$name = $request->name;
$name = $request->get('name');
$all = $request->all();
$only = $request->only(['name', 'email']);
$except = $request->except(['password']);

// File uploads
$file = $request->file('document');
$hasFile = $request->hasFile('document');
$isValid = $request->file('document')->isValid();
        

Manual Validator Creation:

$validator = Validator::make($request->all(), [
    'email' => 'required|email|unique:users,email,'.$user->id,
    'name' => 'required|string|max:255',
]);

if ($validator->fails()) {
    // Access the validator's MessageBag
    $errors = $validator->errors();
    
    // Manually redirect with errors
    return redirect()->back()
                     ->withErrors($errors)
                     ->withInput();
}
        

// app/Http/Requests/StoreUserRequest.php
class StoreUserRequest extends FormRequest
{
    public function authorize()
    {
        return $this->user()->can('create-users');
    }

    public function rules()
    {
        return [
            'name' => ['required', 'string', 'max:255'],
            'email' => [
                'required', 
                'email', 
                Rule::unique('users')->ignore($this->user)
            ],
            'role_id' => [
                'required', 
                Rule::exists('roles', 'id')->where(function ($query) {
                    $query->where('active', true);
                })
            ],
        ];
    }
    
    public function messages()
    {
        return [
            'email.unique' => 'This email is already registered in our system.'
        ];
    }

    public function attributes()
    {
        return [
            'email' => 'email address',
        ];
    }
    
    // Custom validation preprocessing
    protected function prepareForValidation()
    {
        $this->merge([
            'name' => ucwords(strtolower($this->name)),
        ]);
    }
    
    // After validation hooks
    public function withValidator($validator)
    {
        $validator->after(function ($validator) {
            if ($this->somethingElseIsInvalid()) {
                $validator->errors()->add('field', 'Something is wrong with this field!');
            }
        });
    }
}

// Usage in controller
public function store(StoreUserRequest $request)
{
    // Validation already occurred
    $validated = $request->validated();
    // or
    $safe = $request->safe()->only(['name', 'email']);
    
    User::create($validated);
    
    return redirect()->route('users.index');
}
        

// Using validation rule objects
$rules = [
    'payment_method' => 'required',
    'card_number' => [
        Rule::requiredIf(fn() => $request->payment_method === 'credit_card'),
        'nullable',
        'string',
        new CreditCardRule
    ]
];

// Using the 'sometimes' rule
$validator = Validator::make($request->all(), [
    'address' => 'sometimes|required|string|max:255',
]);

// Conditionally adding rules
$validator = Validator::make($request->all(), $rules);

if ($request->has('subscription')) {
    $validator->sometimes('plan_id', 'required|exists:plans,id', function ($input) {
        return $input->subscription === true;
    });
}
        

Custom Error Formatting:

// Customize error format for API responses
use Illuminate\Contracts\Validation\Validator;
use Illuminate\Http\Exceptions\HttpResponseException;

protected function failedValidation(Validator $validator)
{
    throw new HttpResponseException(response()->json([
        'success' => false,
        'errors' => $validator->errors(),
        'message' => 'Validation errors'
    ], 422));
}
        

Rule Declaration Patterns:

// Multiple approaches to defining rules
$rules = [
    // String-based rules
    'email' => 'required|email|unique:users,email,'.auth()->id(),
    
    // Array-based rules
    'password' => [
        'required',
        'string',
        'min:8',
        'confirmed',
        Rule::notIn($commonPasswords)
    ],
    
    // Conditional rules using Rule class
    'profile_image' => [
        Rule::requiredIf(fn() => $request->has('is_public_profile')),
        'image',
        'max:2048'
    ],
    
    // Using when() method
    'company_name' => Rule::when($request->type === 'business', [
        'required',
        'string',
        'max:100',
    ], ['nullable']),
    
    // Complex validation with dependencies between fields
    'expiration_date' => [
        Rule::requiredIf(fn() => $request->payment_type === 'credit_card'),
        'date',
        'after:today'
    ],
    
    // Array validation
    'products' => 'required|array|min:1',
    'products.*.name' => 'required|string|max:255',
    'products.*.price' => 'required|numeric|min:0.01',
    
    // Regular expression validation
    'slug' => [
        'required',
        'alpha_dash',
        'regex:/^[a-z0-9-]+$/'
    ]
];
        

1. Custom Rule Objects:

// app/Rules/ValidRecaptcha.php
class ValidRecaptcha implements Rule
{
    protected $ip;
    
    public function __construct()
    {
        $this->ip = request()->ip();
    }
    
    public function passes($attribute, $value)
    {
        $response = Http::asForm()->post('https://www.google.com/recaptcha/api/siteverify', [
            'secret' => config('services.recaptcha.secret'),
            'response' => $value,
            'remoteip' => $this->ip
        ]);
        
        return $response->json('success') === true &&
               $response->json('score') >= 0.5;
    }
    
    public function message()
    {
        return 'The :attribute verification failed. Please try again.';
    }
}

// Usage
$rules = [
    'g-recaptcha-response' => ['required', new ValidRecaptcha],
];
        

2. Validator Extension (Global):

// In a service provider's boot method
Validator::extend('unique_translation', function ($attribute, $value, $parameters, $validator) {
    [$table, $column, $ignoreId, $locale] = array_pad($parameters, 4, null);
    
    $query = DB::table($table)->where($column->{$locale}, $value);
    
    if ($ignoreId) {
        $query->where('id', '!=', $ignoreId);
    }
    
    return $query->count() === 0;
});

// Custom message in validation.php language file
'unique_translation' => 'The :attribute already exists for this language.',

// Usage
$rules = [
    'title.en' => 'unique_translation:posts,title,'.optional($post)->id.',en',
];
        

3. Implicit Validator Extension:

// In a service provider's boot method
Validator::extendImplicit('required_translation', function ($attribute, $value, $parameters, $validator) {
    // Get the main attribute name (e.g., "title" from "title.en")
    $mainAttribute = explode('.', $attribute)[0];
    $data = $validator->getData();
    
    // Check if at least one translation is provided
    foreach ($data[$mainAttribute] ?? [] as $translationValue) {
        if (!empty($translationValue)) {
            return true;
        }
    }
    
    return false;
});

// Usage
$rules = [
    'title' => 'required_translation',
];
        

1. Form Request with Custom Response:

// app/Http/Requests/UpdateProfileRequest.php
class UpdateProfileRequest extends FormRequest
{
    public function rules()
    {
        return [
            'name' => 'required|string|max:255',
            'email' => 'required|email|unique:users,email,'.auth()->id(),
        ];
    }
    
    // Custom error formatting for API responses
    protected function failedValidation(Validator $validator)
    {
        if (request()->expectsJson()) {
            throw new HttpResponseException(
                response()->json([
                    'success' => false,
                    'errors' => $this->transformErrors($validator),
                    'message' => 'The given data was invalid.'
                ], 422)
            );
        }
        
        parent::failedValidation($validator);
    }
    
    // Transform error format for frontend consumption
    private function transformErrors(Validator $validator)
    {
        $errors = [];
        
        foreach ($validator->errors()->messages() as $key => $value) {
            // Transform dot notation to nested arrays for JavaScript
            $keyParts = explode('.', $key);
            $this->arraySet($errors, $keyParts, $value[0]);
        }
        
        return $errors;
    }
    
    private function arraySet(&$array, $path, $value)
    {
        $key = array_shift($path);
        
        if (empty($path)) {
            $array[$key] = $value;
        } else {
            if (!isset($array[$key]) || !is_array($array[$key])) {
                $array[$key] = [];
            }
            
            $this->arraySet($array[$key], $path, $value);
        }
    }
}
        

2. Contextual Validation Messages:

// app/Http/Requests/RegisterUserRequest.php
class RegisterUserRequest extends FormRequest
{
    public function rules()
    {
        return [
            'email' => 'required|email|unique:users',
            'password' => [
                'required',
                'min:8',
                'regex:/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/',
            ]
        ];
    }
    
    public function messages()
    {
        return [
            'password.regex' => $this->getPasswordStrengthMessage(),
        ];
    }
    
    private function getPasswordStrengthMessage()
    {
        // Check which specific password criterion is failing
        $password = $this->input('password');
        
        if (strlen($password) < 8) {
            return 'Password must be at least 8 characters.';
        }
        
        if (!preg_match('/[a-z]/', $password)) {
            return 'Password must include at least one lowercase letter.';
        }
        
        if (!preg_match('/[A-Z]/', $password)) {
            return 'Password must include at least one uppercase letter.';
        }
        
        if (!preg_match('/\d/', $password)) {
            return 'Password must include at least one number.';
        }
        
        if (!preg_match('/[@$!%*?&]/', $password)) {
            return 'Password must include at least one special character (@$!%*?&).';
        }
        
        return 'Password must be at least 8 characters and include uppercase, lowercase, number and special character.';
    }
}
        

1. After Validation Hooks:

$validator = Validator::make($request->all(), [
    'items' => 'required|array',
    'items.*.id' => 'required|exists:products,id',
    'items.*.quantity' => 'required|integer|min:1',
]);

$validator->after(function ($validator) use ($request) {
    // Business logic validation beyond field rules
    $totalQuantity = collect($request->items)->sum('quantity');
    
    if ($totalQuantity > 100) {
        $validator->errors()->add(
            'items', 
            'You cannot order more than 100 items at once.'
        );
    }
    
    // Check inventory availability
    foreach ($request->items as $index => $item) {
        $product = Product::find($item['id']);
        
        if ($product->stock < $item['quantity']) {
            $validator->errors()->add(
                "items.{$index}.quantity", 
                "Not enough inventory for {$product->name}. Only {$product->stock} available."
            );
        }
    }
});

if ($validator->fails()) {
    return redirect()->back()
                     ->withErrors($validator)
                     ->withInput();
}
        

2. Dependent Validation Using Custom Rules:

// app/Rules/RequiredBasedOnStatus.php
class RequiredBasedOnStatus implements Rule
{
    protected $statusField;
    protected $requiredStatuses;
    
    public function __construct($statusField, $requiredStatuses)
    {
        $this->statusField = $statusField;
        $this->requiredStatuses = is_array($requiredStatuses) 
            ? $requiredStatuses 
            : [$requiredStatuses];
    }
    
    public function passes($attribute, $value, $parameters = [])
    {
        $data = request()->all();
        $status = Arr::get($data, $this->statusField);
        
        // If status requires this field, it must not be empty
        if (in_array($status, $this->requiredStatuses)) {
            return !empty($value);
        }
        
        // Otherwise, field is optional
        return true;
    }
    
    public function message()
    {
        $statuses = implode(', ', $this->requiredStatuses);
        return "The :attribute field is required when status is {$statuses}.";
    }
}

// Usage
$rules = [
    'status' => 'required|in:pending,approved,rejected',
    'rejection_reason' => [
        new RequiredBasedOnStatus('status', 'rejected'),
        'nullable',
        'string',
        'max:500'
    ],
    'approval_date' => [
        new RequiredBasedOnStatus('status', 'approved'),
        'nullable',
        'date'
    ]
];
        

Exporting Validation Rules to JavaScript:

// routes/web.php
Route::get('validation-rules/users', function () {
    // Export Laravel validation rules to be used by JS libraries
    $rules = [
        'name' => 'required|string|max:255',
        'email' => 'required|email',
        'password' => 'required|min:8|confirmed',
    ];
    
    // Map Laravel rules to a format your JS validator can use
    $jsRules = collect($rules)->map(function ($ruleset, $field) {
        $parsedRules = [];
        $ruleArray = is_string($ruleset) ? explode('|', $ruleset) : $ruleset;
        
        foreach ($ruleArray as $rule) {
            if (is_string($rule)) {
                $parsedRule = explode(':', $rule);
                $ruleName = $parsedRule[0];
                $params = isset($parsedRule[1]) ? explode('','', $parsedRule[1]) : [];
                
                $parsedRules[$ruleName] = count($params) ? $params : true;
            }
        }
        
        return $parsedRules;
    })->toArray();
    
    return response()->json($jsRules);
});
        

Customizing Exception Handler:

// app/Exceptions/Handler.php
public function render($request, Throwable $exception)
{
    // API specific validation error handling
    if ($exception instanceof ValidationException && $request->expectsJson()) {
        return response()->json([
            'message' => 'The given data was invalid.',
            'errors' => $this->transformValidationErrors($exception),
            'status_code' => 422
        ], 422);
    }
    
    return parent::render($request, $exception);
}

protected function transformValidationErrors(ValidationException $exception)
{
    $errors = $exception->validator->errors()->toArray();
    
    // Transform errors to a more frontend-friendly format
    return collect($errors)->map(function ($messages, $field) {
        return [
            'field' => $field,
            'message' => $messages[0], // First error message
            'all_messages' => $messages // All error messages
        ];
    })->values()->toArray();
}