PHP Inversion of Control and Dependency Injection Examples

This article mainly shares with you PHP control inversion and dependency injection examples. The purpose of dependency injection is to achieve a loosely coupled software architecture for better testing, management and expansion of code.

Inversion of Control: When the caller needs the help of the callee, in the traditional programming process, the caller usually creates the callee. instance of the caller, but here the work of creating the callee is no longer done by the caller, but the creation of the callee is moved outside the caller, thus reversing the creation of the callee and eliminating the call The control created by the caller over the callee is therefore called inversion of control.

Dependency Injection: To achieve inversion of control, the usual solution is to leave the work of creating the callee instance to the IoC container, and then in the caller Injecting the callee (implemented through constructor/method injection), so that we achieve the decoupling of the caller and the callee, this process is called dependency injection. Dependency injection is an implementation of inversion of control. There are three common injection methods: setter, constructor injection, and property injection.

Container (Container): Manage the life cycle of object generation, resource acquisition, destruction, etc., establish dependencies between objects, and can delay loading of objects. The more famous ones are PHP-DI and Pimple.

Code demonstration IoC:

Assuming that the application has storage requirements, if the low-level module API is directly called in the high-level application, the application will Modules create dependencies.

<?php
/**
 * 高层
 */
class App
{
    private $writer;

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

    public function save()
    {
        $this->writer->saveToFloppy();
    }
}

/**
 * 低层，软盘存储
 */
class FloppyWriter
{
    public function saveToFloppy()
    {
        echo __METHOD__;
    }
}

$app = new App();
$app->save(); // FloppyWriter::saveToFloppy

Assuming that the program is to be ported to another platform, and that platform uses a USB disk as a storage medium, the program cannot be directly reused and must be modified. In this case, due to changes in the low-level, the high-level changes also follow, which is a bad design. Programs should not rely on concrete implementations, but on abstract interfaces. Please see the code demonstration:

<?php
/**
 * 接口
 */
interface IDeviceWriter
{
    public function saveToDevice();
}

/**
 * 高层
 */
class App
{
    /**
     * @var IDeviceWriter
     */
    private $writer;

    /**
     * @param IDeviceWriter $writer
     */
    public function setWriter($writer)
    {
        $this->writer = $writer;
    }

    public function save()
    {
        $this->writer->saveToDevice();
    }
}

/**
 * 低层，软盘存储
 */
class FloppyWriter implements IDeviceWriter
{

    public function saveToDevice()
    {
        echo __METHOD__;
    }
}

/**
 * 低层，USB盘存储
 */
class UsbDiskWriter implements IDeviceWriter
{

    public function saveToDevice()
    {
        echo __METHOD__;
    }
}

$app = new App();
$app->setWriter(new UsbDiskWriter());
$app->save(); // UsbDiskWriter::saveToDevice

$app->setWriter(new FloppyWriter());
$app->save(); // FloppyWriter::saveToDevice

The control is transferred from the actual FloppyWriter to the abstract IDeviceWriter interface, making the App dependent on the IDeviceWriter interface, and FloppyWriter and UsbDiskWriter also depend on the IDeviceWriter interface.
This is IoC. In the face of changes, the high-level does not need to modify a line of code, and no longer relies on the low-level, but relies on injection, which leads to DI.

If this component has many dependencies, we need to create multiple parameter setter methods to pass dependencies, which makes our code difficult to maintain.

<?php
//创建依赖实例
$request = new Request();
$filter = new Filter();

//把实例作为参数传递给构造函数
$some = new SomeComponent($request, $filter);

$some->setRequest($request);
$some->setFilter($filter);

The solution is to provide a container for the dependent instance. This container acts as a global registry, injected into the container rather than the specific instance.

<?php
class SomeComponent
{

    protected $_di;

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

    public function someRequest()
    {

        // 请求实例
        $connection = $this->_di->get(&#39;request&#39;);

    }

    public function someOtherRequest()
    {

        // 请求实例
        $connection = $this->_di->get(&#39;request&#39;);

        // 过滤器实例
        $filter = $this->_di->get(&#39;filter&#39;);

    }

}

$di = new DI();

//在容器中注册一个request服务
$di->set(&#39;request&#39;, function() {
    return new Request(array(
        "test" => "test"
    ));
});

//在容器中注册一个filter服务
$di->set(&#39;filter&#39;, function() {
    return new Filter();
});

//把传递服务的容器作为唯一参数传递给组件
$some = new SomeComponent($di);
$some->someRequest();

This component can now easily obtain the services it needs. The services use lazy loading and are only initialized when needed, which also saves server resources. This component is now highly decoupled.
Related recommendations:

Analysis of PHP Dependency Injection and Inversion of Control

PHP Dependency Injection (DI) and Inversion of Control (IoC) Example Tutorial

PHP Inversion of Control and Dependency Injection

The above is the detailed content of PHP Inversion of Control and Dependency Injection Examples. For more information, please follow other related articles on the PHP Chinese website!