Detailed introduction to dependency injection and IoC in Laravel (with examples)

This article brings you a detailed introduction to dependency injection and IoC in Laravel (with examples). It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

As developers, we are always trying to find new ways to write well-designed and robust code by using design patterns and trying new robust frameworks. In this article, we'll explore the Dependency Injection design pattern with Laravel's IoC components and see how it can improve our designs.

Dependency Injection

The term dependency injection is a term proposed by Martin Fowler, which is the act of injecting components into an application. As Ward Cunningham said:

Dependency injection is a key element in agile architecture.

Let's look at an example:

class UserProvider{
    protected $connection;

    public function __construct(){
        $this->connection = new Connection;
    }

    public function retrieveByCredentials( array $credentials ){
        $user = $this->connection
                        ->where( 'email', $credentials['email'])
                        ->where( 'password', $credentials['password'])
                        ->first();

        return $user;
    }
}

If you want to test or maintain this class, you must access the instance of the database to perform some queries. To avoid having to do this, you can decouple this class from other classes, you have one of three options to inject the Connection class without using it directly.

When injecting components into a class, you can use one of the following three options:

Constructor method injection

class UserProvider{
    protected $connection;

    public function __construct( Connection $con ){
        $this->connection = $con;
    }
    ...

Setter method injection

Similarly, we also Dependencies can be injected using the Setter method:

class UserProvider{
    protected $connection;
    public function __construct(){
        ...
    }

    public function setConnection( Connection $con ){
        $this->connection = $con;
    }
    ...

Interface injection

interface ConnectionInjector{
    public function injectConnection( Connection $con );
}

class UserProvider implements ConnectionInjector{
    protected $connection;

    public function __construct(){
        ...
    }

    public function injectConnection( Connection $con ){
        $this->connection = $con;
    }
}

When a class implements our interface, we define the injectConnection method to resolve dependencies.

Advantages

Now when testing our classes we can mock dependent classes and pass them as parameters. Each class must focus on a specific task and should not be concerned with resolving their dependencies. This way, you'll have a more focused and maintainable application.

If you want to learn more about DI, Alejandro Gervassio has covered it extensively and expertly in this series of articles, so be sure to read them. So, what is IoC? IoC (Inversion of Control) does not require the use of dependency injection, but it can help you manage dependencies effectively.

Inversion of Control

Ioc is a simple component that makes it easier to resolve dependencies. You can describe the object as a container, and every time a class is resolved, dependencies are automatically injected.

Laravel Ioc

Laravel Ioc is a little special in the way it resolves dependencies when you request an object:

We use A simple example will improve it in this article. The
SimpleAuth class depends on FileSessionStorage, so our code might look like this:

class FileSessionStorage{
  public function __construct(){
    session_start();
  }

  public function get( $key ){
    return $_SESSION[$key];
  }

  public function set( $key, $value ){
    $_SESSION[$key] = $value;
  }
}

class SimpleAuth{
  protected $session;

  public function __construct(){
    $this->session = new FileSessionStorage;
  }
}

//创建一个 SimpleAuth
$auth = new SimpleAuth();

This is a classic approach, let's start with using the constructor Function injection begins.

class SimpleAuth{
  protected $session;

  public function __construct( FileSessionStorage $session ){
    $this->session = $session;
  }
}

Now we create an object:

$auth = new SimpleAuth( new FileSessionStorage() );

Now I want to use Laravel Ioc to manage all this.

Because the Application class inherits from the Container class, you can access the container through the App facade.

App::bind( 'FileSessionStorage', function(){
    return new FileSessionStorage;
});

bind The first parameter of the method is the unique ID to be bound to the container, and the second parameter is a callback function that is executed whenever the FileSessionStorage class is executed. , we can also pass a string representing the class name as shown below.

Note: If you look at the Laravel package, you will see that bindings are sometimes grouped, such as ( view, view.finder ...).

Assuming we convert the session store to Mysql storage, our class should look like:

class MysqlSessionStorage{

  public function __construct(){
    //...
  }

  public function get($key){
    // do something
  }

  public function set( $key, $value ){
    // do something
  }
}

Now that we have changed the dependencies, we also need to change the SimpleAuth construct function and bind the new object to the container!

High-level modules should not depend on low-level modules, both should depend on abstract objects.
Abstraction should not depend on details, details should depend on abstraction.

Robert C. Martin

Our SimpleAuth class should not care about how our storage is done, instead it should focus more on consuming the service.

Therefore, we can abstractly implement our storage:

interface SessionStorage{
  public function get( $key );
  public function set( $key, $value );
}

so that we can implement and request an instance of the SessionStorage interface:

class FileSessionStorage implements SessionStorage{

  public function __construct(){
    //...
  }

  public function get( $key ){
    //...
  }

  public function set( $key, $value ){
    //...
  }
}

class MysqlSessionStorage implements SessionStorage{

  public function __construct(){
    //...
  }

  public function get( $key ){
    //...
  }

  public function set( $key, $value ){
    //...
  }
}

class SimpleAuth{

  protected $session;

  public function __construct( SessionStorage $session ){
    $this->session = $session;
  }

}

If we Use App::make('SimpleAuth') to resolve the SimpleAuth
class through the container, the container will throw BindingResolutionException trying to resolve the class from the binding After that, go back to the reflection method and resolve all dependencies.

Uncaught exception 'Illuminate\Container\BindingResolutionException' with message 'Target [SessionStorage] is not instantiable.'

The container is trying to instantiate the interface. We can make a specific binding for this interface.

App:bind( 'SessionStorage', 'MysqlSessionStorage' );

Now every time we try to resolve this interface from the container, we will get a MysqlSessionStorage instance. If we want to switch our storage service, we just change this binding.

Note: If you want to check whether a class has been bound in the container, you can use App::bound('ClassName'), or you can use App::bindIf('ClassName') To register a binding that has not yet been registered.

Laravel Ioc also provides App::singleton('ClassName', 'resolver') to handle singleton binding.
You can also use App::instance('ClassName', 'instance') to create a singleton binding.
If the container cannot resolve the dependency, it will throw ReflectionException, but we can use the App::resolvingAny(Closure) method to resolve any specified type in the form of a callback function .

Note: If you have registered a resolving method for a certain type, the resolvingAny method will still be called, but it will return directly bind The return value of the method.

Tips

Where to write these bindings:

If it is just a small application, you can write it in a global start file global/start.php, but if the project becomes larger and larger, it will be necessary to use Service Provider.

Testing:

When you need quick and easy testing, you can consider using php artisan tinker. It is very powerful and can help you improve your Laravel testing process.

Reflection API:

PHP’s Reflection API is very powerful. If you want to go deep into Laravel Ioc, you need to be familiar with the Reflection API. You can first read this tutorial to get more information. [Related recommendations: PHP video tutorial]

The above is the detailed content of Detailed introduction to dependency injection and IoC in Laravel (with examples). For more information, please follow other related articles on the PHP Chinese website!