php设计模式 依赖注入和控制反转

依赖注入和控制反转在现如今的主流框架中经常可以看到，主要是用于解决程序的松耦合，便于程序的协调开发和管理。

DI——Dependency Injection 依赖注入

IoC——Inversion of Control 控制反转

当一个类的实例需要另一个类的实例协助时，在传统的程序设计过程中，通常由调用者来创建被调用者的实例。而采用依赖注入的方式，创建被调用者的工作不再由调用者来完成，因此叫控制反转，创建被调用者的实例的工作由IOC容器来完成，然后注入调用者，因此也称为依赖注入。

控制反转（Inversion of Control）：当调用者需要被调用者的协助时，在传统的程序设计过程中，通常由调用者来创建被调用者的实例，但在这里，创建被调用者的工作不再由调用者来完成，而是将被调用者的创建移到调用者的外部，从而反转被调用者的创建，消除了调用者对被调用者创建的控制，因此称为控制反转。

依赖注入（Dependency Injection）：要实现控制反转，解决方案是将创建被调用者实例的工作交由IoC容器来完成，然后在调用者中注入被调用者（通过构造器/方法注入实现），这样我们就实现了调用者与被调用者的解耦，该过程被称为依赖注入。依赖注入是控制反转的一种实现方式。常见注入方式有三种：setter、constructor injection、property injection。

比如我们写一个file的缓存类，类user需要用到这个缓存类 传统的调用方式是在调用者中实例化被调用者

class fileCache{
    /**
     * 设置缓存
     * @param $name
     * @param $value
     */
    public function set($name ,$value){
        //TODO
    }

    /**
     * 删除缓存
     * @param $name
     */
    public function delete($name){
        //TODO
    }

    /**
     * 获取缓存数据
     * @param $name
     */
    public function get($name){
        //TODO
    }
}

class User {
    protected $cache;

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

    public function getUser(){
        return $this->cache->get("user");
    }


}


$user = new User();

$user->getUser();

一旦平台或者环境发生变化，我们不用file来做为缓存，而是用redis做缓存,那相应调用类User就需要做出修改。程序不应该依赖于具体的实现，而是要依赖抽像的接口

class fileCache implements Cache{

    public function set($name)
    {
        //TODO
    }

    public function get($name)
    {
        //TODO
    }

    public function delete($name)
    {
        //TODO
    }

}


class redisCache implements Cache{

    public function set($name)
    {
        //TODO
    }

    public function get($name)
    {
        //TODO
    }

    public function delete($name)
    {
        //TODO
    }

}

构造器注入

class User{

    protected $cache ;

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

    public function getUser()
    {
        return $this->cache->get('user');
    }


}

$redis = new redisCache();
$user = new User($redis);
$user->getUser();

$file = new fileCache();
$user = new User($file);
$user->getUser();

setter注入

class User{

    protected $cache ;

    public function  setCache( Cache $cache)
    {
        $this->cache = $cache;
    }

    public function getUser()
    {
        return $this->cache->get('user');
    }


}


$redis = new redisCache();
$user = new User();
$user->setCache($redis);
$user->getUser();

$file = new fileCache();
$user = new User();
$user->setCache($file);
$user->getUser();

但是这样的注入还会产生一个问题，当调用类依赖于多个外部类时，我们就需要不断的写set

$user = new User();

$user->setDb($db);//注入db连接

$user->setCache($file);//注入缓存处理类
#.....

如果引入的外部类很多时，就会变得十分繁琐。这就引入另一个概念容器又叫做IoC容器、DI容器。
这里我们引入一个约定：在User类的构造函数里传入一个名为Di $di的参数，如下：

class Di{
    protected $_objects = [];


    public function set($name, $object)
    {

        $this->_objects[$name] = $object;

    }
    public function get($name) {
        return $this->_objects[$name];
    }
}


class User {

    private $_di;

    function __construct(Di &$di)
    {

        $this->_di = $di;

    }

    //通过di容器获取db实例

    public function getUser()
    {
        return $this->_di->get('cache')->get('User');
    }

}

$di = new Di();

$cache  = new fileCache();

$di->set("cache",$cache);

$user = new User($di);

$user->getUser();