Simply understand DI dependency injection in PHP

This article brings you relevant knowledge about PHP, which mainly introduces related issues about dependency injection. Dependency injection DI actually refers to the dependence on classes through the constructor. Automatic injection, let’s take a look at it, I hope it will be helpful to everyone.

(Recommended tutorial: PHP video tutorial)

What is DI/Dependency Injection

Dependency Injection DI In fact, it essentially means that the dependency on the class is automatically injected through the constructor

In layman's terms, it means that you are currently operating a class, but some methods or functions of this class cannot be completed by this class alone. , but it can only be accomplished with the help of another class

The most direct sign is when the parameter data is passed as an object. Strictly speaking, if you want to operate one class in another class, there is an interdependence relationship between the two classes. The method of passing parameters is called injection

The reason for dependency injection

When dependency injection is not used, when PHP needs to use another class in one class, it often performs the following operations

For example, if I need to use the adapter class in the container class, I need to do it before using it. Instantiation

If a large number of external classes need to be used, this will cause the coupling degree to be too high, which can easily lead to later maintenance difficulties

In layman's terms, that is, the container cannot be separated. External classes go to work, which is called too high a coupling degree

<?php
class container
{
    private $adapter;

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

Simple dependency injection

The above code is too highly coupled, which leads to the emergence of dependency injection, mainly to understand the coupling

In the following case, we only need to pass in the class object that needs to be operated.

The parameters of the dependency injection operation are objects, not ordinary parameters. Do you have a better understanding?

But such a simple dependency injection will cause that if you depend on a lot of classes, it will take a long time to pass parameters and it will be easy to get confused

<?php
class container
{
    private $adapter;

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

High-level dependency injection

In order to solve the problem of parameter confusion above, dependency injection has been optimized at this time.

Through the magic method, __get sets the object

At this time, we can solve the problem of too many dependencies and confusing parameters. Problem

<?php
class container
{
    public $instance = [];

    public function __set($name, $value)
    {
        $this->instance[$name] = $value;
    }
}

$container = new container();

$container->adapter = new adapter();
$container->autofelix = new autofelix();

Application of Dependency Injection

We first define a container class, which is mainly used to inject the class you want to operate into the container

When using it, just You only need to pass the object of the container

<?php
class container
{
    public $instance = [];

    public function __set($name, $value)
    {
        $this->instance[$name] = $value;
    }
}

class adapter
{
    public $name = &#39;我是调度器&#39;;
}

$container = new container();
$container->adapter = new adapter();

class autofelix
{
    private $container;

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

    public function who($class)
    {
        return $this->container->instance[$class]->name;
    }
}

$autofelix = new autofelix($container);

$who = $autofelix->who(&#39;adapter&#39;);

var_dump($who); //我是调度器

High-order optimization of dependency injection

In the above application, we directly inject the instantiated object into the container

Like this This will cause all objects to be instantiated before they are used, resulting in resource loss

We can pass in closures so that the objects will not be instantiated and injected when you need to use them yourself When instantiating, you can reduce the loss of server resources

<?php
$container = new container();
$container->adapter = new adapter();

//高阶优化
$container = new container();
$container->adapter = function () {
    return new adapter();
};

(Recommended tutorial: PHP video tutorial)

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