依赖注入和控制反转在现如今的主流框架中经常可以看到，主要是用于解决程序的松耦合，便于程序的协调开发和管理。
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();
网友评论