PHP依赖注入和控制反转（DI，IoC）
PHP依赖注入和控制反转（DI&&IoC）
User: Jeremy.Ke
Time: 2019/6/25 3:32
1 理论分析
- 1.1 概念
依赖注入和控制反转是对同一件事情的不同描述，从某个方面讲，就是它们描述的角度不同。
(1)依赖注入是从应用程序的角度在描述，可以把依赖注入，即：应用程序依赖容器创建并注入它所需要的外部资源；
(2)而控制反转是从容器的角度在描述，即：容器控制应用程序，由容器反向的向应用程序注入应用程序所需要的外部资源.
- 1.2 优势
使用依赖注入，最重要的一点好处就是有效的分离了对象和它所需要的外部资源，使得它们松散耦合，有利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。
- 1.3 自问自答
（1）整个过程中的参与者？
一般有三方参与者，一个是某个对象；一个是IoC/DI的容器；另一个是某个对象的外部资源。
其一：某个对象指的就是任意的、普通的PHP对象;
其二：IoC/DI的容器简单点说就是指用来实现IoC/DI功能的一个框架程序；
其三：对象的外部资源指的就是对象需要的，但是是从对象外部获取的，都统称资源，比如：对象需要的其它对象、或者是对象需要的文件资源等等。
（2）谁依赖于谁？为什么需要依赖？
某个对象依赖于IoC/DI的容器,对象需要IoC/DI的容器来提供对象需要的外部资源.
（3）谁注入于谁?注入什么?
IoC/DI的容器 注入(某些资源到)某个对象，注入的对象所需的资源。
（4）控制什么？为何叫反转？什么是正转？
主要是控制对象实例的创建。
A类的实例化需要资源B,直接在A类中去获取配置文件或者实例化B获取资源B，叫做正转；
A类不再主动去获取C，而是被动等待，等待IoC/DI的容器获取一个C的实例，然后反向的注入到A类中，叫做反转。
图解：
- 1.4 总结
其实IoC/DI对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，
要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC/DI容器来创建并注入它所需要的资源了。
2 代码演示
- 痛点：如果实例化A需要对象B，也就是A与B有强关联的关系，B的变化会影响A。
class B
{
public function bsay()
{
echo "b say";
}
}
class A
{
public function asay()
{
$b_obj = new B;
$b_obj->bsay();
}
}
$a_obj = new A;
$a_obj->asay();
- 通过构造函数来将B对象注入到A，使得A和B解耦，就是B的类名和内部属性方法改变不影响这个程序。
class B
{
public function bsay()
{
echo "b say";
}
}
class A
{
private $_bobj;
public function __construct($b_obj)
{
$this->_bobj = $b_obj;
}
public function asay()
{
$this->_bobj->bsay();
}
}
$b_obj = new B;
$a_obj = new A($b_obj);
$a_obj->asay();
?>
但是如果A需要的资源不只是B的对象，还有C，D…这个时候，你就需要在构造函数写很多变量来接收这个资源，显然，这是不合理的。这个
时候需要一个专门的容器来存储所要需要的资源。
- 申明一个DI来存储需要注入的资源，以便全局位置可以使用这些资源，并且可以存储C，D…等需要的所有依赖资源（对象，数组…）。
class DI
{
public $b;
public $c;
public $d;
public function __construct()
{
$this->c = new C();
$this->d = new D();
$this->b = new B();
}
}
class B
{
public function bsay()
{
echo "b say";
}
}
class C
{
public function csay()
{
echo "c say";
}
}
class D
{
public function dsay()
{
echo "d say";
}
}
class A
{
private $_bobj;
public function __construct($b_obj)
{
$this->_bobj = $b_obj;
}
public function asay()
{
$this->_bobj->bsay();
}
}
$di_obj = new DI();
$a_obj = new A($di_obj->b);
$a_obj->asay();
?>
以上基本能满足如何使用依赖注入解决我们的问题。不是在代码内部创建依赖关系，而是让其作为一个参数传递，这使得我们的程序更容易维
护，降低程序代码的耦合度，实现一种松耦合。但是从长远来看，这种形式的依赖注入也有一些缺点。例如，如果组件中有较多的依赖关系，
我们需要创建多个setter方法传递，或创建构造函数进行传递。另外，每次使用组件时，都需要创建依赖组件，使代码维护不太易。我们需要修改
一下DI这个容器类。
class Di
{
private $container = array();
public function set($key, $obj,$arg)
{
if(count($arg) == 1 && is_array($arg[0])){
$arg = $arg[0];
}
/*
* 注入的时候不做任何的类型检测与转换
* 由于编程人员为问题，该注入资源并不一定会被用到
*/
$this->container[$key] = array(
"obj"=>$obj,
"params"=>$arg,
);
}
function delete($key)
{
unset( $this->container[$key]);
}
function clear()
{
$this->container = array();
}
function get($key)
{
if(isset($this->container[$key])){
$result = $this->container[$key];
if(is_object($result['obj'])){
return $result['obj'];
}else if(is_callable($result['obj'])){
return $this->container[$key]['obj'];
}else if(is_string($result['obj']) && class_exists($result['obj'])){
$reflection = new \ReflectionClass ( $result['obj'] );
$ins = $reflection->newInstanceArgs ( $result['params'] );
$this->container[$key]['obj'] = $ins;
return $this->container[$key]['obj'];
}else{
return $result['obj'];
}
}else{
return null;
}
}
}
class B
{
public function bsay()
{
echo "b say";
}
}
class A
{
private $_bobj;
public function __construct($b_obj)
{
$this->_bobj = $b_obj;
}
public function asay()
{
$this->_bobj->bsay();
}
}
$di_obj = new DI();
$di_obj->set('b_obj','B');
$a_obj = new A($di_obj->get('b_obj'));
$a_obj->asay();
?>
现在，该Di类只有访问某种service的时候才需要它，如果它不需要，它甚至不初始化，以节约资源。该组件是高度解耦。他们的行为，或者说他们的任
何其他方面都不会影响到组件本身。
优点：
(1)我们可以更换一个依赖资源，从他们本身或者第三方轻松创建。
(2)我们可以充分的控制对象的初始化，并对对象进行各种设置。
(3)我们可以使用统一的方式从容器中，得到一个结构化的全局实例。
(4)DI类。除非开发人员在注入服务的时候直接实例化一个对象，然后存存储到容器中。在容器中，通过数组，字符串等方式存储的服务都将被延迟加载，即只有在请求对象的时候才被初始化。