所谓依赖，即写一个类的时候，里面需要使用到其他的类；
分为主动依赖 和 被动依赖，这里通过操作用户数据来理解一下。
一、先看看写法的区别
用户模型主动依赖的写法 ↓↓↓
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，这个主要是用来做标准化的，就是大家都会写自己的类，那如何标方便调用呢？
