2016
02-18

依赖注入和控制反转是什么?

年前,@绵阳飞在群里发起了一个讨论,依赖注入和控制反转到底是什么?
我之前对依赖注入和控制反转也不甚理解,直至在学习Phalcon框架的过程中,发现在Phalcon文档中有一个篇幅通过代码示例的方式专门描述了依赖注入的原理。本文打算通过此文档中的代码示例来讲解什么是依赖注入(DI)和控制反转(IoC)。通过示例代码,来更加深入的了解这些概念。

接下来的例子有些长,但解释了为什么我们要使用依赖注入。所以绝对都是干货,请耐心读完,必会有所收获。

依赖的产生

首先,假设我们正在开发一个组件,叫SomeComponent,它需要执行的内容现在还不重要。 但是我们的组件需要依赖数据库连接。

<?php

class SomeComponent
{
    /**
     * 数据库连接是被写死在组件的内部
     * 因此,我们很难从外部替换或者改变它的行为
     */
    public function someDbTask()
    {
        $connection = new Connection(
            array(
                "host"     => "localhost",
                "username" => "root",
                "password" => "secret",
                "dbname"   => "invo"
            )
        );

        // ...
    }
}

$some = new SomeComponent();
$some->someDbTask();

从上面这个例子中,可以看到数据库连接是在组件内部建立的。在我们日常开发中,类似这样的依赖关系在项目中非常常见。但是这种方法其实是不太实用的;我们不能改变创建数据库连接的参数或者选择不同的数据库系统,因为数据库连接是在组件被创建时建立的。


依赖注入

为了解决这样的情况,我们通过一个setter函数,在使用前注入独立外部依赖:

<?php

class SomeComponent
{
    protected $_connection;

    /**
     * 设置外部传入的数据库连接
     */
    public function setConnection($connection)
    {
        $this->_connection = $connection;
    }

    public function someDbTask()
    {
        $connection = $this->_connection;

        // ...
    }
}

$some = new SomeComponent();

// 建立数据库连接
$connection = new Connection(
    array(
        "host"     => "localhost",
        "username" => "root",
        "password" => "secret",
        "dbname"   => "invo"
    )
);

// 向组件注入数据库连接
$some->setConnection($connection);

$some->someDbTask();

目前来看,通过setter函数来注入独立的外部依赖的方式,已经解耦了数据库连接与应用程序的依赖。这里已经使用到了控制反转(IoC)的模式。具体概念稍后再解释,还是以代码示例的方式来增加理解。

我们想像一下,假设这个组件在应用内的好几个地方都需要用到,那在注入数据库连接时,我们还需要建立好几次数据库连接。 是否可以获取到数据库连接,而不用每次都创建新的连接呢?可以使用某种全局注册的方式来解决这样的问题:

<?php

class Registry
{
    /**
     * 返回数据库连接
     */
    public static function getConnection()
    {
        return new Connection(
            array(
                "host"     => "localhost",
                "username" => "root",
                "password" => "secret",
                "dbname"   => "invo"
            )
        );
    }
}

class SomeComponent
{
    protected $_connection;

    /**
     * 设置外部传入的数据库连接
     */
    public function setConnection($connection)
    {
        $this->_connection = $connection;
    }

    public function someDbTask()
    {
        $connection = $this->_connection;

        // ...
    }
}

$some = new SomeComponent();

// 把数据库连接传递给组件
$some->setConnection(Registry::getConnection());

$some->someDbTask();

通过上述方法,我们实现了共享数据库连接,而不用每次都创建新的数据库连接。
那么,让我们再扩展一下,我们可以实现2个方法,第一个方法总是创建新的数据库连接,第二方法总是使用一个共享的数据库连接:

<?php

class Registry
{
    protected static $_connection;

    /**
     * 建立一个新的数据库连接
     */
    protected static function _createConnection()
    {
        return new Connection(
            array(
                "host"     => "localhost",
                "username" => "root",
                "password" => "secret",
                "dbname"   => "invo"
            )
        );
    }

    /**
     * 只建立一个数据库连接,后面的请求共享该连接
     */
    public static function getSharedConnection()
    {
        if (self::$_connection===null) {
            $connection = self::_createConnection();
            self::$_connection = $connection;
        }

        return self::$_connection;
    }

    /**
     * 总是返回一个新的数据库连接
     */
    public static function getNewConnection()
    {
        return self::_createConnection();
    }
}

class SomeComponent
{
    protected $_connection;

    /**
     * 设置外部传入的数据库连接
     */
    public function setConnection($connection)
    {
        $this->_connection = $connection;
    }

    /**
     * 这个方法使用共享的数据库连接
     */
    public function someDbTask()
    {
        $connection = $this->_connection;

        // ...
    }

    /**
     * 这个方法总是使用新的数据库连接
     */
    public function someOtherDbTask($connection)
    {

    }
}

$some = new SomeComponent();

// 注入共享的数据库连接
$some->setConnection(Registry::getSharedConnection());

$some->someDbTask();

// 这里总是传递一个新的数据库连接
$some->someOtherDbTask(Registry::getNewConnection());

到目前为止,我们已经看到通过依赖注入怎么解决我们的问题了。把依赖作为参数来传递,而不是在内部建立它们,这使我们的应用更加容易维护和更加解耦。但是这种形式的依赖注入还有一些缺点。

例如,如果这个组件有很多依赖, 我们需要创建多个参数的setter方法来传递依赖关系,或者建立一个多个参数的构造函数来传递它们,另外在使用组件前还需要每次都创建依赖,这让我们的代码像这样不易维护:

<?php

// 创建依赖对象或从注册表中查找
$connection = new Connection();
$session    = new Session();
$fileSystem = new FileSystem();
$filter     = new Filter();
$selector   = new Selector();

// 把依赖对象作为参数传递给构造函数
$some = new SomeComponent($connection, $session, $fileSystem, $filter, $selector);

// ... 或者使用setter

$some->setConnection($connection);
$some->setSession($session);
$some->setFileSystem($fileSystem);
$some->setFilter($filter);
$some->setSelector($selector);

我们假设在应用内不同的地方使用和创建了这些对象。如果当我们永远不需要其中某个依赖对象时,那我们需要去删掉构造函数中的参数,或者去删掉注入的setter函数。为了解决这样的问题,我们再次回到全局注册的方式创建组件。在创建对象之前,给它增加了一个新的抽象层:

<?php

class SomeComponent
{
    // ...

    /**
     * 定义一个工厂方法来创建SomeComponent组件所需的依赖对象
     */
    public static function factory()
    {
        $connection = new Connection();
        $session    = new Session();
        $fileSystem = new FileSystem();
        $filter     = new Filter();
        $selector   = new Selector();

        return new self($connection, $session, $fileSystem, $filter, $selector);
    }
}

瞬间,我们又绕回到刚刚开始的问题了:我们再次在组件内部创建依赖的对象!一个实用又优雅的解决方法,是为依赖对象提供一个容器。


容器

所谓容器,从字面上来理解,就是可以装东西的东西。变量、对象属性等都可以算是容器。
我们可以通过这个容器获取依赖的各个对象,这样能够降低我们这个组件的复杂性,及对依赖对象的耦合性(即解耦):

<?php

//加载容器
use Phalcon\Di;

class SomeComponent
{
    protected $_di;

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

    public function someDbTask()
    {
        // 获取数据库连接
        // 总是返回一个新的连接
        $connection = $this->_di->get('db');
    }

    public function someOtherDbTask()
    {
        // 获取共享的数据库连接
        // 每次请求都返回相同的数据库连接
        $connection = $this->_di->getShared('db');

        // 这个方法也需要一个过滤的依赖服务
        $filter = $this->_di->get('filter');
    }
}

$di = new Di();

// 在容器中注册一个db服务
$di->set('db', function () {
    return new Connection(
        array(
            "host"     => "localhost",
            "username" => "root",
            "password" => "secret",
            "dbname"   => "invo"
        )
    );
});

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

// 在容器中注册一个session服务
$di->set('session', function () {
    return new Session();
});

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

$some->someDbTask();

上面这段代码并没有介绍DI容器的内部是如何运作的,下面我们自己来实现一个简单的容器:

class Container{

    protected $binds;

    /**
     * 注入服务
     * @param $name  服务名称
     * @param $callback  回调函数
     */
    public function set($name, $callback){
        $this -> binds[$name] = $callback;
    }

    /**
     * 加载服务
     * @param $name  服务名称
     * @param array $param  参数
     */
    public function make($name, $param=[]){
        if(isset($this -> binds[$name])){
            return call_user_func_array($this -> binds[$name], $param);
        }
    }
}

这时候,一个粗糙的容器就诞生了。我们来看看这个容器如何使用:

//创建一个容器
$container = new Container();

//注入db服务
$container -> set('db', function(){
    return new Connection(
        array(
            "host"     => "localhost",
            "username" => "root",
            "password" => "secret",
            "dbname"   => "invo"
        )
    );
});

//注入filter服务
$container -> set('filter', function(){
    return new Fileter();
});

如此,SomeComponent这个组件现在可以很简单的获取到它所需要的各个服务,服务采用延迟加载的方式,只有在需要使用的时候才初始化,这也节省了服务器资源。这个组件现在是高度解耦。例如,我们可以替换掉创建数据库连接的方式,它们的行为或它们的任何其他方面,也不会影响该组件。

通过上述代码示例,大家应该初步了解了依赖注入和控制反转其中的原理。这里总结一下概念。

依赖注入(DI)

依赖注入的英文全称为:Dependency Injection. 其基本原则是:应用组件不应该负责查找资源或者其他依赖的协作对象。配置对象的工作应该由容器负责,“查找资源”的逻辑应该从应用组件的代码中抽取出来,交给容器负责。不必自己在代码中维护对象的依赖。

控制反转(IoC)

控制反转的英文全称为:Inversion of Control. 从上述代码示例里可以看出,把传统上由程序代码直接操控的对象的调用权转交给容器,通过容器来实现对象组件的装配与管理。也就是对组件对象控制权的转移,从程序代码本身转移到了外部容器。这就是控制反转。主要就是依赖关系的转移。

容器

  • 管理对象的生成、资源获取、销毁等生命周期
  • 建立对象与对象之间的依赖关系
  • 启动容器后,所有对象直接取用,不用编写任何一行代码来产生对象,或是建立对象之间的依赖关系



参考资料:
https://segmentfault.com/a/1190000002424023
https://segmentfault.com/a/1190000002411255
https://github.com/laracasts/simple-di-container
http://laravelacademy.org/post/769.html
https://docs.phalconphp.com/zh/latest/reference/di.html

「真诚赞赏,手留余香」
您的支持将鼓励我继续创作 :)