What is laravel dependency injection

The term laravel dependency injection is a term proposed by Martin Fowler. It is a behavior of injecting components into an application. Dependency injection is a key element in agile architecture. Examples of use are such as "class UserProvider{protected $connection...}".

The operating environment of this article: Windows 7 system, Laravel version 5.7, DELL G3 computer.

What is laravel dependency injection?

Detailed explanation of dependency injection and IoC in Laravel:

As developers, we 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. It 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 database instance 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;
  }

}

如果我们使用 App::make('SimpleAuth') 通过容器解析 SimpleAuth
类，容器将会抛出 BindingResolutionException ，尝试从绑定解析类之后，返回到反射方法并解析所有依赖项。

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

容器正试图将接口实例化。我们可以为该接口做一个具体的绑定。

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

现在每次我们尝试从容器解析该接口时，我们会得到一个 MysqlSessionStorage 实例。如果我们想要切换我们的存储服务，我们只要变更一下这个绑定。

Note: 如果你想要查看一个类是否已经在容器中被绑定，你可以使用 App::bound('ClassName') ，或者可以使用 App::bindIf('ClassName') 来注册一个还未被注册过的绑定。

Laravel Ioc 也提供 App::singleton('ClassName', 'resolver') 来处理单例的绑定。
你也可以使用 App::instance('ClassName', 'instance') 来创建单例的绑定。
如果容器不能解析依赖项就会抛出 ReflectionException ，但是我们可以使用 App::resolvingAny(Closure) 方法以回调函数的形式来解析任何指定的类型。

Note: 如果你为某个类型已经注册了一个解析方式 resolvingAny 方法仍然会被调用，但它会直接返回 bind 方法的返回值。

小贴士

• 这些绑定写在哪儿：
  如果只是一个小型应用你可以写在一个全局的起始文件 global/start.php 中，但如果项目变得越来越庞大就有必要使用 Service Provider 。

• 测试：
  当需要快速简易的测试可以考虑使用 php artisan tinker ，它十分强大，且能帮你提升你的 Laravel 测试流程。

• Reflection API：
  PHP 的 Reflection API 是非常强大的，如果你想要深入 Laravel Ioc 你需要熟悉 Reflection API ，可以先看下这个 教程 来获得更多的信息。

相关推荐：最新的五个Laravel视频教程

The above is the detailed content of What is laravel dependency injection. For more information, please follow other related articles on the PHP Chinese website!