w3resource

Laravel (5.7) Contracts

Introduction

Laravel's Contracts are a set of interfaces that define the core services provided by the framework. For example, an Illuminate/Contracts/Queue/Queue contract defines the methods needed for queueing jobs, while the Illuminate/Contracts/mail/Mailer contract defines the methods needed for sending the e-mail.

All contract has a corresponding implementation provided by the framework. Like, Laravel provides a queue implementation with a variety of drivers, and a mailer implementation that is powered by SwiftMailer.

Laravel Contracts live in their own GitHub repository. This provides a quick reference point for all available contracts, as well as a single, decoupled package that may be utilized by package developers.

Contracts Vs. Facades

Laravel's facades and helper functions provide a way of utilizing Laravel's services without needing to type-hint and resolve contracts out of the service container. In most cases, each facade has an equivalent contract.

Most application will be fine regardless of whether you prefer facades or contracts. However, if you are building a package, you should strongly consider using contracts since they will be easier to test in a package context.

When to Use Contracts

Contracts or facades will come down to personal taste and the tastes of your development team. Both contracts and facades can be used to create robust, well-tested Laravel applications. As long as you are keeping your class' responsibilities focused, you will notice very few practical differences between using contracts and facades.

Loose Coupling

First, let's review some code that is tightly coupled to a cache implementation. Consider the following.

Let's look at a simple example.

<?php
namespace App\Orders;

class Repository
{    
    protected $cache;   
    public function __construct(\SomePackage\Cache\Memcached $cache)
    {
        $this->cache = $cache;
    }   
    public function find($id)
    {
        if ($this->cache->has($id))    {
            //
        }
    }
}

In this class, the code is tightly coupled to a given cache implementation. It is tightly coupled because we are depending on a concrete Cache class from a package vendor. If the API of that package changes our code must change as well.

Instead of this approach, we can improve our code by depending on a simple, vendor agnostic interface.

Let's look at a simple example.

<?php
namespace App\Orders;

use Illuminate\Contracts\Cache\Repository as Cache;

class Repository
{
    
    protected $cache;
    public function __construct(Cache $cache)
    {
        $this->cache = $cache;
    }
}

Now the code is not coupled to any specific vendor, or even Laravel. Since the contracts package contains no implementation and no dependencies, you may easily write an alternative implementation of any given contract, allowing you to replace your cache implementation without modifying any of your cache consuming code.

How to Use Contracts

Many types of classes in Laravel are resolved through the service container, including controller, event listeners, middleware, queued jobs and even route Closures. So, to get an implementation of a contract, you can just type-hint the interface in the constructor of the class being resolved.

Let's look at a simple example.

<?php

namespace App\Listeners;

use App\User;
use App\Events\OrderWasPlaced;
use Illuminate\Contracts\Redis\Database;

class CacheOrderInformation
{
   
    protected $redis;
    public function __construct(Database $redis)
    {
        $this->redis = $redis;
    }
    public function handle(OrderWasPlaced $event)
    {
        //
    }
}

Previous: Laravel (5.7) Facades
Next: Laravel (5.7) Routing



Share this Tutorial / Exercise on : Facebook and Twitter