从 DI依赖注入 到 IoC容器

所谓依赖，即写一个类的时候，里面需要使用到其他的类；
分为主动依赖 和 被动依赖，这里通过操作用户数据来理解一下。

一、先看看写法的区别

用户模型主动依赖的写法 ↓↓↓

class UserModel {
    function __construct() {
        $this->db = new Database('db1');
    }
}

用户模型被动依赖的写法 ↓↓↓

class UserModel {
    function __construct(Database $db) {
        $this->db = $db;
    }
}

---

二、为什么需要被动依赖？

先看看主动依赖的情况

class Database {
    public function __construct($name) {
        echo "Linked {$name} Database.\n";
    }
}

class UserModel {
    public function __construct() {
        $this->db = new Database('db1');
    }
}

$user = new UserModel();
// 输出 "Linked db1 Database."

以上情况，如果你需要操作其他数据库呢？
就需要把 new Database('db1') 改为 new Database('db2')
那如果是两个库都要操作呢？
思考一下。

---

再看看被动依赖的情况

class UserModel {
    function __construct(Database $db) {
        $this->db = $db;
    }
}

$user1 = new UserModel(new Database('db1'));
// 输出 Linked db1 Database.
$user2 = new UserModel(new Database('db2'));
// 输出 Linked db2 Database.

不需要修改 Database 类，就可以访问其他数据库，或者同时访问；
降低耦合度
但问题是 UserModel 依旧需要传递一个 Database 对象来初始化，如果想改用 Redis 了呢？
思考一下。

---

三、彻底解除依赖关系 IoC容器

说容器之前，插播个函数
call_user_func_array
调用回调函数，并把一个数组参数作为回调函数的参数
官方例子：

function foobar($arg, $arg2) {
    echo __FUNCTION__, " got $arg and $arg2\n";
}

// Call the foobar() function with 2 arguments
call_user_func_array("foobar", array("one", "two"));

// output：foobar got one and two

接着说 IoC容器

// 定义一个标准接口
interface ModuleInterface {
    public function activate(array $target);
}

// 数据库实现标准接口
class Database implements ModuleInterface {

    public function __construct($name) {
        echo "Linked {$name} Database.\n";
    }

    public function activate(array $target) {
        echo "Database activate.\n";
    }
}

// 缓存实现标准接口
class Redis implements ModuleInterface {

    public function __construct($name) {
        echo "Linked {$name} Redis.\n";
    }

    public function activate(array $target) {
        echo "Redis activate.\n";
    }
}

// 用户模型依赖注入接口
class UserModel {
    protected $module;

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

    public function test($arr = []) {
        $this->module->activate($arr);
    }
}

// IoC容器的实现
class Container {
    protected $binds;
    protected $instances;

    // 实现绑定关系
    public function bind($abstract, $concrete) {
        if ($concrete instanceof Closure) {
            $this->binds[$abstract] = $concrete;
        } else {
            $this->instances[$abstract] = $concrete;
        }
    }

    // 生产类对象
    public function make($abstract, $parameters = []) {
        if (isset($this->instances[$abstract])) {
            return $this->instances[$abstract];
        }
        
        $arr = [$this, $parameters];

        return call_user_func_array($this->binds[$abstract], $arr);
    }
}

// 容器服务
$container = new Container;
// 注册UserModel
$container->bind('user', function($container, $params){
    return new UserModel($container->make($params[0], $params[1]));
});
// 注册Database
$container->bind('database', function($container, $name){
    return new Database($name);
});
// 注册Redis
$container->bind('redis', function($container, $name){
    return new Redis($name);
});

$user1 = $container->make('user', ['database', 'db_master']);
// 这里解释一下调用后具体发生了什么
// step1：调用容器的 make 方法，传入 $abstract, $parameters
// step2：$parameters 在 array_unshift 之后有两个值 [$this, 'database']
// step3：call_user_func_array 回调外面注册过的 UserModel 闭包，并将参数传入
// step4：注册的 UserModel 闭包接收参数，$container 继续调用容器 make 方法
// step5：此时 make 方法收到的参数是 'database'，继续回调函数
// step6：返回注册过的 Database 对象依赖注入到 UserModel 中
// step7：最终返回 UserModel 对象
$user1 = $container->make('user', ['database', 'db_master']);
$user1->test([1,2,3]);
$user2 = $container->make('user', ['database', 'db_slave']);
$user3 = $container->make('user', ['redis', '127.0.0.1']);
// output：Linked db_master Database.
// output：Database activate.
// output：Linked db_slave Database.
// output：Linked 127.0.0.1 Redis.

以上输出看出，通过 IoC容器 创建的对象，既可以用 Database 来初始化，也可以用 Redis 来初始化。

在容器中，所谓注册，其实就是把闭包(匿名函数)存储在一个字典中了，key值就是注册的第一个字符串参数
闭包(匿名函数)又返回了对应的类对象
然后再通过 callback 将依赖的对象注入到需要的对象中

真正的 IoC容器 要比这复杂得多，全面得多，这里仅仅是为了方便了解其运行机制。

至于代码中提到的 interface ModuleInterface，这个主要是用来做标准化的，就是大家都会写自己的类，那如何标方便调用呢？