Laravel contracts are interfaces that define core services, enabling decoupled and testable code by depending on abstractions rather than implementations; 1. Understand that contracts like Illuminate\Contracts\Cache\Repository serve as blueprints for features; 2. Use them in type-hinting constructors or methods, allowing Laravel’s service container to inject the correct implementation; 3. Apply contracts in service providers or custom classes to ensure reusability and testability, such as injecting the Queue contract in a service; 4. Leverage dependency injection for easier mocking in tests, improving test reliability; 5. Replace facades like Cache::get() with their contract equivalents to enhance design and maintainability; 6. Optionally bind custom implementations to contracts in service providers for tailored behavior; ultimately, using contracts promotes better coding practices in complex applications.

In Laravel, "contracts" refer to a set of interfaces that define the core services provided by the framework. They live in the illuminate/contracts package and act as a blueprint for Laravel's features — like caching, queues, mail, events, etc. Using contracts helps you write more decoupled and testable code by depending on abstractions (interfaces), not concrete implementations.

Here’s how to use contracts in Laravel effectively:

? 1. Understand What Contracts Are

Laravel contracts are interfaces. For example:

• Illuminate\Contracts\Cache\Repository
• Illuminate\Contracts\Queue\Queue
• Illuminate\Contracts\Mail\Mailer

These define what a service can do, without specifying how it does it. The actual implementation (like Redis for cache, or SMTP for mail) is injected at runtime via Laravel’s service container.

? Key idea: Instead of type-hinting a concrete class (which ties you to an implementation), you type-hint the interface (contract), letting Laravel inject the right implementation.

? 2. Use Contracts in Type-Hinting (Controllers, Jobs, etc.)

Laravel automatically resolves contract interfaces when you type-hint them in constructors or method parameters.

Example: Using Cache Contract in a Controller

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Contracts\Cache\Repository as Cache;

class UserController extends Controller
{
    protected $cache;

    // Type-hint the contract
    public function __construct(Cache $cache)
    {
        $this->cache = $cache;
    }

    public function index()
    {
        // The $cache is automatically resolved to the configured cache driver
        $users = $this->cache->remember('users', 3600, function () {
            return User::all();
        });

        return view('users.index', compact('users'));
    }
}

Laravel’s container knows how to inject a class that implements Illuminate\Contracts\Cache\Repository based on your config (config/cache.php).

? 3. Use Contracts in Service Providers and Custom Classes

When building reusable services or packages, depend on contracts to stay framework-agnostic and testable.

Example: A Service Using the Queue Contract

<?php

namespace App\Services;

use Illuminate\Contracts\Queue\Queue;

class ExportService
{
    protected $queue;

    public function __construct(Queue $queue)
    {
        $this->queue = $queue;
    }

    public function dispatchExport($job)
    {
        $this->queue->push($job);
    }
}

Then register and use it:

// In a controller
public function export(ExportService $service)
{
    $service->dispatchExport(new ExportUsersJob());
    return response()->json(['status' => 'queued']);
}

? 4. Benefit from Dependency Injection & Testing

Because you’re using interfaces, you can easily mock them in tests.

Example: Testing with Mocked Cache

/** @test */
public function it_uses_cache_contract()
{
    // Mock the contract
    $this->instance(\Illuminate\Contracts\Cache\Repository::class, $mock = Mockery::mock(\Illuminate\Contracts\Cache\Repository::class));

    $mock->shouldReceive('get')->with('key')->andReturn('value');

    $response = $this->get('/cached-route');

    $response->assertSee('value');
}

This is cleaner than mocking a specific cache driver.

? 5. Commonly Used Contracts and Facades Alternative

You might be used to using facades like Cache::get() or Mail::send(). Contracts are an alternative that promote better design.

? You can switch from facades to contracts to make your code more testable and less static.

? 6. Register Custom Implementations (Optional)

You can bind your own implementation of a contract in a service provider:

$this->app->bind(
    \Illuminate\Contracts\Mail\Mailer::class,
    \App\Services\CustomMailer::class
);

Now every time the contract is type-hinted, your custom mailer is injected.

Summary: Best Practices

• ? Use contracts when writing classes that depend on Laravel services.
• ? Type-hint them in constructors or method arguments — Laravel handles the rest.
• ? Avoid tight coupling to specific implementations (e.g., Redis, database queue).
• ? Use them in packages or large apps where testability and flexibility matter.
• ? Prefer contracts over facades in complex services (though facades are fine for simple cases).

Using contracts isn’t mandatory in Laravel — facades are totally valid — but they’re a powerful tool for writing clean, testable, and maintainable code, especially as your app grows.

Basically, if you want to write code that’s easier to test and less tied to Laravel’s internals, contracts are the way to go.

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