在我们工作中传统的思路是应用程序用到一个A类，就会创建A类并调用A类的方法，假如这个方法内需要一个B类，就会创建B类并调用B类的方法，而这个方法内需要一个C类，就会创建C类，接着做些其它工作。
<?php
class C
{
public function doSomething()
{
echo __METHOD__, '我是C类|';
}
}
class B
{
public function doSomething()
{
$bim = new C();
$bim->doSomething();
echo __METHOD__, '我是B类|';
}
}
class A
{
public function doSomething()
{
$bar = new B();
$bar->doSomething();
echo __METHOD__, '我是A类|';;
}
}
$class = new A();
$class->doSomething(); //C::doSomething我是C类|B::doSomething我是B类|A::doSomething我是A类|
使用依赖注入的思路是应用程序用到A类，A类需要B类，B类需要C类，那么先创建C类，再创建B类并把C注入，再创建A类，并把B类注入，再调用A方法，A调用B方法，接着做些其它工作。
<?php
class C
{
public function doSomething()
{
echo __METHOD__, '我是C类|';
}
}
class B
{
private $c;
public function __construct(C $c)
{
$this->c = $c;
}
public function doSomething()
{
$this->c->doSomething();
echo __METHOD__, '我是B类|';
}
}
class A
{
private $b;
public function __construct(B $b)
{
$this->b = $b;
}
public function doSomething()
{
$this->b->doSomething();
echo __METHOD__, '我是A类|';;
}
}
$class = new A(new B(new C()));
$class->doSomething(); // C::doSomething我是C类|B::doSomething我是B类|A::doSomething我是A类|
增加容器
<?php
class C
{
public function doSomething()
{
echo __METHOD__, '我是C类|';
}
}
class B
{
private $c;
public function __construct(C $c)
{
$this->c = $c;
}
public function doSomething()
{
$this->c->doSomething();
echo __METHOD__, '我是B类|';
}
}
class A
{
private $b;
public function __construct(B $b)
{
$this->b = $b;
}
public function doSomething()
{
$this->b->doSomething();
echo __METHOD__, '我是A类|';;
}
}
//这段代码使用了魔术方法，在给不可访问属性赋值时，__set() 会被调用。读取不可访问属性的值时，__get() 会被调用。
class Container
{
private $s = array();
function __set($k, $c)
{
$this->s[$k] = $c;
}
function __get($k)
{
return $this->s[$k]($this);
}
}
$class = new Container();
$class->c = function () {
return new C();
};
$class->b = function ($class) {
return new B($class->c);
};
$class->a = function ($class) {
return new A($class->b);
};
// 从容器中取得A
$model = $class->a;
$model->doSomething(); // C::doSomething我是C类|B::doSomething我是B类|A::doSomething我是A类|
优化
<?php
class C
{
public function doSomething()
{
echo __METHOD__, '我是C类|';
}
}
class B
{
private $c;
public function __construct(C $c)
{
$this->c = $c;
}
public function doSomething()
{
$this->c->doSomething();
echo __METHOD__, '我是B类|';
}
}
class A
{
private $b;
public function __construct(B $b)
{
$this->b = $b;
}
public function doSomething()
{
$this->b->doSomething();
echo __METHOD__, '我是A类|';;
}
}
class IoC
{
protected static $registry = [];
public static function bind($name, Callable $resolver)
{
static::$registry[$name] = $resolver;
}
public static function make($name)
{
if (isset(static::$registry[$name])) {
$resolver = static::$registry[$name];
return $resolver();
}
throw new Exception('Alias does not exist in the IoC registry.');
}
}
IoC::bind('c', function () {
return new C();
});
IoC::bind('b', function () {
return new B(IoC::make('c'));
});
IoC::bind('a', function () {
return new A(IoC::make('b'));
});
// 从容器中取得A
$foo = IoC::make('a');
$foo->doSomething(); // C::doSomething我是C类|B::doSomething我是B类|A::doSomething我是A类|
依赖注入容器的高级功能
真实的dependency injection container会提供更多的特性，如
-
自动绑定（Autowiring）或 自动解析（Automatic Resolution）
-
注释解析器（Annotations）
-
延迟注入（Lazy injection）
下面的代码在Twittee的基础上，实现了Autowiring。
<?php
class C
{
public function doSomething()
{
echo __METHOD__, '我是周伯通C|';
}
}
class B
{
private $c;
public function __construct(C $c)
{
$this->c = $c;
}
public function doSomething()
{
$this->c->doSomething();
echo __METHOD__, '我是周伯通B|';
}
}
class A
{
private $b;
public function __construct(B $b)
{
$this->b = $b;
}
public function doSomething()
{
$this->b->doSomething();
echo __METHOD__, '我是周伯通A|';;
}
}
class Container
{
private $s = array();
public function __set($k, $c)
{
$this->s[$k] = $c;
}
public function __get($k)
{
// return $this->s[$k]($this);
return $this->build($this->s[$k]);
}
/**
* 自动绑定（Autowiring）自动解析（Automatic Resolution）
*
* @param string $className
* @return object
* @throws Exception
*/
public function build($className)
{
// 如果是匿名函数（Anonymous functions），也叫闭包函数（closures）
if ($className instanceof Closure) {
// 执行闭包函数，并将结果
return $className($this);
}
/** @var ReflectionClass $reflector */
$reflector = new ReflectionClass($className);
// 检查类是否可实例化, 排除抽象类abstract和对象接口interface
if (!$reflector->isInstantiable()) {
throw new Exception("Can't instantiate this.");
}
/** @var ReflectionMethod $constructor 获取类的构造函数 */
$constructor = $reflector->getConstructor();
// 若无构造函数，直接实例化并返回
if (is_null($constructor)) {
return new $className;
}
// 取构造函数参数,通过 ReflectionParameter 数组返回参数列表
$parameters = $constructor->getParameters();
// 递归解析构造函数的参数
$dependencies = $this->getDependencies($parameters);
// 创建一个类的新实例，给出的参数将传递到类的构造函数。
return $reflector->newInstanceArgs($dependencies);
}
/**
* @param array $parameters
* @return array
* @throws Exception
*/
public function getDependencies($parameters)
{
$dependencies = [];
/** @var ReflectionParameter $parameter */
foreach ($parameters as $parameter) {
/** @var ReflectionClass $dependency */
$dependency = $parameter->getClass();
if (is_null($dependency)) {
// 是变量,有默认值则设置默认值
$dependencies[] = $this->resolveNonClass($parameter);
} else {
// 是一个类，递归解析
$dependencies[] = $this->build($dependency->name);
}
}
return $dependencies;
}
/**
* @param ReflectionParameter $parameter
* @return mixed
* @throws Exception
*/
public function resolveNonClass($parameter)
{
// 有默认值则返回默认值
if ($parameter->isDefaultValueAvailable()) {
return $parameter->getDefaultValue();
}
throw new Exception('I have no idea what to do here.');
}
}
// ----
$class = new Container();
$class->b = 'B';
$class->a = function ($class) {
return new A($class->b);
};
// 从容器中取得A
$model = $class->a;
$model->doSomething();
$di = new Container();
$di->php7 = 'A';
/** @var A $php7 */
$foo = $di->php7;
var_dump($foo);
$foo->doSomething(); //C::doSomething我是周伯通C|B::doSomething我是周伯通B|A::doSomething我是周伯通A|object(A)#10 (1) { ["b":"A":private]=> object(B)#14 (1) { ["c":"B":private]=> object(C)#16 (0) { } } } C::doSomething我是周伯通C|B::doSomething我是周伯通B|A::doSomething我是周伯通A|
?>
网友评论