Laravel's routing model binding can automatically inject model instances into the route or controller method without manually querying the database; 2. Implicit binding requires that the routing parameter name is consistent with the type prompt variable name of the controller method, Laravel will automatically load the model according to the ID and return 404 if not found; 3. By rewriting the getRouteKeyName method in the model, you can customize the query field, such as using slug instead of id; 4. Explicit binding is registered in the RouteServiceProvider through Route::bind, which is suitable for scenarios where custom logic is required, such as finding users based on username; 5. The soft deletion model is excluded by default. If you need to include soft deleted records, you can use the withTrashed() method in explicit binding; Summary: The routing model binding reduces duplicate code, supports two methods: implicit and explicit, and is suitable for web and API routing, improving development efficiency and the default behavior is safe and reliable.

Route model binding in Laravel is a convenient way to inject model instances directly into your routes or controller methods. Instead of manually fetching a model from the database using an ID, Laravel automatically resolves the model based on the route parameter. Here's how to use it effectively.

1. Understanding Implicit Route Model Binding

This is the most common and easiest way. Laravel automatically injects the model instance when the route parameter name matches the variable name in the controller method.

Example:

Suppose you have a Post model and want to show a specific post.

Route (in routes/web.php or routes/api.php ):

 use App\Http\Controllers\PostController;

Route::get('/posts/{post}', [PostController::class, 'show']);

Controller:

 use App\Models\Post;

public function show(Post $post)
{
    // $post is automatically loaded from the database
    // where the {post} in the route matches the $post parameter
    return view('posts.show', compact('post'));
}

? How it works: Laravel sees that you're type-hinting Post $post and looks for a route parameter named {post} . It then fetches the Post model with the ID matching that parameter.

If no record is found, Laravel automatically returns a 404 response.

2. Customizing the Route Key (Using a Different Column)

By default, Laravel uses the id column for binding. But you can customize this by overriding the getRouteKeyName() method in your model.

Example: Using slug instead of id

 // In your Post model (app/Models/Post.php)
public function getRouteKeyName()
{
    return 'slug'; // Now routes will look up posts by slug
}

Now this route:

 Route::get('/posts/{post}', [PostController::class, 'show']);

Will automatically find the Post where slug = $post , not id .

So visiting /posts/why-laravel-is-great will work if there's a post with that slug.

3. Explicit Route Model Binding (Advanced Control)

Use this when you need more control — for example, binding in RouteServiceProvider or using custom logic.

Register in RouteServiceProvider.php :

In the boot() method:

 use App\Models\Post;
use Illuminate\Support\Facades\Route;

public function boot()
{
    parent::boot();

    Route::bind('post', function ($value) {
        return Post::where('slug', $value)->firstOrFail();
        // Or add more complex logic here
    });

    // You can also bind multiple models
    Route::bind('user', function ($value) {
        return User::active()->where('username', $value)->firstOrFail();
    });
}

Now {post} in any route will use this custom resolution logic.

4. Using Custom Keys in Implicit Binding

You don't always need explicit binding. You can still use implicit binding with a custom key by setting getRouteKeyName() in the model:

 // App\Models\Post.php
public function getRouteKeyName()
{
    return 'slug';
}

Then keep your route and controller simple:

 Route::get('/posts/{post}', [PostController::class, 'show']); // uses slug

 public function show(Post $post)
{
    // automatically resolved by slug
}

This is cleaner than explicit binding for most use cases.

5. Handling Soft Deletes (Optional)

If you're using SoftDeletes , and you want trashed models to return 404, Laravel handles that automatically with route model binding — firstOrFail() skips trashed models by default.

If you do want to include trashed models, you'd need explicit binding:

 Route::bind('post', function ($value) {
    return Post::withTrashed()->findOrFail($value);
});

Summary of Key Points

• ? Implicit binding works out of the box when parameter name matches model type-hint.
• ? Use getRouteKeyName() to change lookup field (eg, slug , username ).
• ?? Use explicit binding in RouteServiceProvider for advanced logic.
• ? Missing models automatically return 404 — no need to check manually.
• ? Works in both web and API routes.

Basically, route model binding saves you from writing repetitive Post::findOrFail($id) code. Just type-hint the model, and Laravel does the rest. Not magic — just smart defaults.

The above is the detailed content of How to use route model binding in Laravel?. For more information, please follow other related articles on the PHP Chinese website!