行为的属性和方法注入原理

上面我们了解到了行为的用意在于将自身的属性和方法注入给所依附的类。 那么Yii中是如何将一个行为 yii\base\Behavior 的属性和方法， 注入到一个 yii\base\Component 中的呢？ 对于属性而言，是通过 __get() 和 __set() 魔术方法来实现的。 对于方法，是通过 __call() 方法。

属性的注入

以读取为例，如果访问 $Component->property1 ，Yii在幕后干了些什么呢？ 这个看看 yii\base\Component::__get()

1. public function __get($name) 
2.  
3. { 
4.  
5.   $getter = 'get' . $name; 
6.  
7.   if (method_exists($this, $getter)) { 
8.  
9.     return $this->$getter(); 
10.  
11.   } else { 
12.  
13.     // 注意这个 else 分支的内容，正是与 yii\base\Object::__get() 的 
14.  
15.     // 不同之处 
16.  
17.     $this->ensureBehaviors(); 
18.  
19.     foreach ($this->_behaviors as $behavior) { 
20.  
21.       if ($behavior->canGetProperty($name)) { 
22.  
23.  
24.  
25.         // 属性在行为中须为 public。否则不可能通过下面的形式访问呀。 
26.  
27.         return $behavior->$name; 
28.  
29.       } 
30.  
31.     } 
32.  
33.   } 
34.  
35.   if (method_exists($this, 'set' . $name)) { 
36.  
37.     throw new InvalidCallException('Getting write-only property: ' . 
38.  
39.       get_class($this) . '::' . $name); 
40.  
41.   } else { 
42.  
43.     throw new UnknownPropertyException('Getting unknown property: ' . 
44.  
45.       get_class($this) . '::' . $name); 
46.  
47.   } 
48.  
49. } 

重点来看 yii\base\Compoent::__get() 与 yii\base\Object::__get() 的不同之处。 就是在于对于未定义getter函数之后的处理， yii\base\Object 是直接抛出异常， 告诉你想要访问的属性不存在之类。 但是 yii\base\Component 则是在不存在getter之后，还要看看是不是注入的行为的属性：

首先，调用了 $this->ensureBehaviors() 。这个方法已经在前面讲过了，主要是确保行为已经绑定。

在确保行为已经绑定后，开始遍历 $this->_behaviors 。 Yii将类所有绑定的行为都保存在 yii\base\Compoent::$_behaviors[] 数组中。

最后，通过行为的 canGetProperty() 判断这个属性， 是否是所绑定行为的可读属性，如果是，就返回这个行为的这个属性 $behavior->name 。 完成属性的读取。 至于 canGetProperty() 已经在 :ref::property 部分已经简单讲过了， 后面还会有针对性地一个介绍。

对于setter，代码类似，这里就不占用篇幅了。

方法的注入

与属性的注入通过 __get() __set() 魔术方法类似， Yii通过 __call() 魔术方法实现对行为中方法的注入:

1. public function __call($name, $params) 
2.  
3. { 
4.  
5.   $this->ensureBehaviors(); 
6.  
7.   foreach ($this->_behaviors as $object) { 
8.  
9.     if ($object->hasMethod($name)) { 
10.  
11.       return call_user_func_array([$object, $name], $params); 
12.  
13.     } 
14.  
15.   } 
16.  
17.   throw new UnknownMethodException('Calling unknown method: ' . 
18.  
19.     get_class($this) . "::$name()"); 
20.  
21. } 

从上面的代码中可以看出，Yii还是先是调用了 $this->ensureBehaviors() 确保行为已经绑定。

然后，也是遍历 yii\base\Component::$_behaviros[] 数组。 通过 hasMethod() 方法判断方法是否存在。 如果所绑定的行为中要调用的方法存在，则使用PHP的 call_user_func_array() 调用之。 至于 hasMethod() 方法，我们后面再讲。

注入属性与方法的访问控制

在前面我们针对行为中public和private、protected的成员在所绑定的类中是否可访问举出了具体例子。 这里我们从代码层面解析原因。

在上面的内容，我们知道，一个属性可不可访问，主要看行为的 canGetProperty() 和 canSetProperty() 。 而一个方法可不可调用，主要看行为的 hasMethod() 。 由于 yii\base\Behavior 继承自我们的老朋友 yii\base\Object ，所以上面提到的三个判断方法， 事实上代码都在 Object 中。我们一个一个来看:

1. public function canGetProperty($name, $checkVars = true) 
2.  
3. { 
4.  
5.   return method_exists($this, 'get' . $name) || $checkVars && 
6.  
7.     property_exists($this, $name); 
8.  
9. } 
10.  
11. public function canSetProperty($name, $checkVars = true) 
12.  
13. { 
14.  
15.   return method_exists($this, 'set' . $name) || $checkVars && 
16. //phpfensi.com 
17.     property_exists($this, $name); 
18.  
19. } 
20.  
21. public function hasMethod($name) 
22.  
23. { 
24.  
25.   return method_exists($this, $name); 
26.  
27. } 

这三个方法真的谈不上复杂。对此，我们可以得出以下结论：

当向Component绑定的行为读取（写入）一个属性时，如果行为为该属性定义了一个getter (setter)，则可以访问。 或者，如果行为确实具有该成员变量即可通过上面的判断，此时，该成员变量可为 public, private, protected。 但最终只有 public 的成员变量才能正确访问。原因在上面讲注入的原理时已经交待了。

当调用Component绑定的行为的一个方法时，如果行为已经定义了该方法，即可通过上面的判断。 此时，这个方法可以为 public, private, protected。 但最终只有 public 的方法才能正确调用。如果你理解了上一款的原因，那么这里也就理解了。

依赖注入容器

依赖注入（Dependency Injection，DI）容器就是一个对象，它知道怎样初始化并配置对象及其依赖的所有对象。Martin 的文章 已经解释了 DI 容器为什么很有用。这里我们主要讲解 Yii 提供的 DI 容器的使用方法。

依赖注入

Yii 通过 yii\di\Container 类提供 DI 容器特性。它支持如下几种类型的依赖注入：

构造方法注入;

Setter 和属性注入;

PHP 回调注入.

构造方法注入

在参数类型提示的帮助下，DI 容器实现了构造方法注入。当容器被用于创建一个新对象时，类型提示会告诉它要依赖什么类或接口。容器会尝试获取它所依赖的类或接口的实例，然后通过构造器将其注入新的对象。例如：

1. class Foo 
2.  
3. { 
4.  
5.   public function __construct(Bar $bar) 
6.  
7.   { 
8.  
9.   } 
10.  
11. } 
12.  
13. $foo = $container->get('Foo'); 
14.  
15. // 上面的代码等价于： 
16.  
17. $bar = new Bar; 
18.  
19. $foo = new Foo($bar); 

Setter 和属性注入

Setter 和属性注入是通过配置提供支持的。当注册一个依赖或创建一个新对象时，你可以提供一个配置，该配置会提供给容器用于通过相应的 Setter 或属性注入依赖。例如：

1. use yii\base\Object; 
2.  
3. class Foo extends Object 
4.  
5. { 
6.  
7.   public $bar; 
8.  
9.   private $_qux; 
10.  
11.   public function getQux() 
12.  
13.   { 
14.  
15.     return $this->_qux; 
16.  
17.   } 
18.  
19.   public function setQux(Qux $qux) 
20.  
21.   { 
22.  
23.     $this->_qux = $qux; 
24.  
25.   } 
26.  
27. } 
28.  
29. $container->get('Foo', [], [ 
30.  
31.   'bar' => $container->get('Bar'), 
32.  
33.   'qux' => $container->get('Qux'), 
34.  
35. ]); 

PHP 回调注入

这种情况下，容器将使用一个注册过的 PHP 回调创建一个类的新实例。回调负责解决依赖并将其恰当地注入新创建的对象。例如：

1. $container->set('Foo', function () { 
2.  
3.   return new Foo(new Bar); 
4.  
5. }); 
6.  
7. $foo = $container->get('Foo'); 

注册依赖关系

可以用 yii\di\Container::set() 注册依赖关系。注册会用到一个依赖关系名称和一个依赖关系的定义。依赖关系名称可以是一个类名，一个接口名或一个别名。依赖关系的定义可以是一个类名，一个配置数组，或者一个 PHP 回调。

1. $container = new \yii\di\Container; 
2.  
3. // 注册一个同类名一样的依赖关系，这个可以省略。 
4.  
5. $container->set('yii\db\Connection'); 
6.  
7. // 注册一个接口 
8.  
9. // 当一个类依赖这个接口时，相应的类会被初始化作为依赖对象。 
10.  
11. $container->set('yii\mail\MailInterface', 'yii\swiftmailer\Mailer'); 
12.  
13. // 注册一个别名。 
14.  
15. // 你可以使用 $container->get('foo') 创建一个 Connection 实例 
16.  
17. $container->set('foo', 'yii\db\Connection'); 
18.  
19. // 通过配置注册一个类 
20.  
21. // 通过 get() 初始化时，配置将会被使用。 
22.  
23. $container->set('yii\db\Connection', [ 
24.  
25.   'dsn' => 'mysql:host=127.0.0.1;dbname=demo', 
26.  
27.   'username' => 'root', 
28.  
29.   'password' => '', 
30.  
31.   'charset' => 'utf8', 
32.  
33. ]); 
34.  
35. // 通过类的配置注册一个别名 
36.  
37. // 这种情况下，需要通过一个 “class” 元素指定这个类 
38.  
39. $container->set('db', [ 
40.  
41.   'class' => 'yii\db\Connection', 
42.  
43.   'dsn' => 'mysql:host=127.0.0.1;dbname=demo', 
44.  
45.   'username' => 'root', 
46.  
47.   'password' => '', 
48.  
49.   'charset' => 'utf8', 
50.  
51. ]); 
52.  
53. // 注册一个 PHP 回调 
54.  
55. // 每次调用 $container->get('db') 时，回调函数都会被执行。 
56.  
57. $container->set('db', function ($container, $params, $config) { 
58.  
59.   return new \yii\db\Connection($config); 
60.  
61. }); 
62.  
63. // 注册一个组件实例 
64.  
65. // $container->get('pageCache') 每次被调用时都会返回同一个实例。 
66.  
67. $container->set('pageCache', new FileCache); 

Tip: 如果依赖关系名称和依赖关系的定义相同，则不需要通过 DI 容器注册该依赖关系。

通过 set() 注册的依赖关系，在每次使用时都会产生一个新实例。可以使用 yii\di\Container::setSingleton() 注册一个单例的依赖关系：

1. $container->setSingleton('yii\db\Connection', [ 
2.  
3.   'dsn' => 'mysql:host=127.0.0.1;dbname=demo', 
4.  
5.   'username' => 'root', 
6.  
7.   'password' => '', 
8.  
9.   'charset' => 'utf8', 
10.  
11. ]); 

解决依赖关系

注册依赖关系后，就可以使用 DI 容器创建新对象了。容器会自动解决依赖关系，将依赖实例化并注入新创建的对象。依赖关系的解决是递归的，如果一个依赖关系中还有其他依赖关系，则这些依赖关系都会被自动解决。

可以使用 yii\di\Container::get() 创建新的对象。该方法接收一个依赖关系名称，它可以是一个类名，一个接口名或一个别名。依赖关系名或许是通过 set() 或 setSingleton() 注册的。你可以随意地提供一个类的构造器参数列表和一个configuration 用于配置新创建的对象。例如：

1. // "db" 是前面定义过的一个别名 
2.  
3. $db = $container->get('db'); 
4.  
5. // 等价于： $engine = new \app\components\SearchEngine($apiKey, ['type' => 1]); 
6.  
7. $engine = $container->get('app\components\SearchEngine', [$apiKey], ['type' => 1]); 

代码背后，DI 容器做了比创建对象多的多的工作。容器首先将检查类的构造方法，找出依赖的类或接口名，然后自动递归解决这些依赖关系。

如下代码展示了一个更复杂的示例。UserLister 类依赖一个实现了 UserFinderInterface 接口的对象；UserFinder 类实现了这个接口，并依赖于一个 Connection 对象。所有这些依赖关系都是通过类构造器参数的类型提示定义的。通过属性依赖关系的注册，DI 容器可以自动解决这些依赖关系并能通过一个简单的 get('userLister') 调用创建一个新的 UserLister 实例。

1. namespace app\models; 
2.  
3. use yii\base\Object; 
4.  
5. use yii\db\Connection; 
6.  
7. use yii\di\Container; 
8.  
9. interface UserFinderInterface 
10.  
11. { 
12.  
13.   function findUser(); 
14.  
15. } 
16.  
17. class UserFinder extends Object implements UserFinderInterface 
18.  
19. { 
20.  
21.   public $db; 
22.  
23.   public function __construct(Connection $db, $config = []) 
24.  
25.   { 
26.  
27.     $this->db = $db; 
28.  
29.     parent::__construct($config); 
30.  
31.   } 
32.  
33.   public function findUser() 
34.  
35.   { 
36.  
37.   } 
38.  
39. } 
40.  
41. class UserLister extends Object 
42.  
43. { 
44.  
45.   public $finder; 
46.  
47.   public function __construct(UserFinderInterface $finder, $config = []) 
48.  
49.   { 
50.  
51.     $this->finder = $finder; 
52.  
53.     parent::__construct($config); 
54.  
55.   } 
56.  
57. } 
58.  
59. $container = new Container; 
60.  
61. $container->set('yii\db\Connection', [ 
62.  
63.   'dsn' => '...', 
64.  
65. ]); 
66.  
67. $container->set('app\models\UserFinderInterface', [ 
68.  
69.   'class' => 'app\models\UserFinder', 
70.  
71. ]); 
72.  
73. $container->set('userLister', 'app\models\UserLister'); 
74.  
75. $lister = $container->get('userLister'); 
76.  
77. // 等价于: 
78.  
79. $db = new \yii\db\Connection(['dsn' => '...']); 
80.  
81. $finder = new UserFinder($db); 
82.  
83. $lister = new UserLister($finder); 

实践中的运用

当在应用程序的入口脚本中引入 Yii.php 文件时，Yii 就创建了一个 DI 容器。这个 DI 容器可以通过 Yii::$container 访问。当调用 Yii::createObject() 时，此方法实际上会调用这个容器的 yii\di\Container::get() 方法创建新对象。如上所述，DI 容器会自动解决依赖关系（如果有）并将其注入新创建的对象中。因为 Yii 在其多数核心代码中都使用了 Yii::createObject() 创建新对象，所以你可以通过 Yii::$container 全局性地自定义这些对象。

例如，你可以全局性自定义 yii\widgets\LinkPager 中分页按钮的默认数量:

\Yii::$container->set('yii\widgets\LinkPager', ['maxButtonCount' => 5]);

这样如果你通过如下代码在一个视图里使用这个挂件，它的 maxButtonCount 属性就会被初始化为 5 而不是类中定义的默认值 10。

echo \yii\widgets\LinkPager::widget();

然而你依然可以覆盖通过 DI 容器设置的值：

echo \yii\widgets\LinkPager::widget(['maxButtonCount' => 20]);

另一个例子是借用 DI 容器中自动构造方法注入带来的好处。假设你的控制器类依赖一些其他对象，例如一个旅馆预订服务。你可以通过一个构造器参数声明依赖关系，然后让 DI 容器帮你自动解决这个依赖关系。

1. namespace app\controllers; 
2.  
3. use yii\web\Controller; 
4.  
5. use app\components\BookingInterface; 
6.  
7. class HotelController extends Controller 
8.  
9. { 
10.  
11.   protected $bookingService; 
12.  
13.   public function __construct($id, $module, BookingInterface $bookingService, $config = []) 
14. //phpfensi.com 
15.   { 
16.  
17.     $this->bookingService = $bookingService; 
18.  
19.     parent::__construct($id, $module, $config); 
20.  
21.   } 
22.  
23. } 

如果你从浏览器中访问这个控制器，你将看到一个报错信息，提醒你 BookingInterface 无法被实例化。这是因为你需要告诉 DI 容器怎样处理这个依赖关系。

\Yii::$container->set('app\components\BookingInterface', 'app\components\BookingService');

现在如果你再次访问这个控制器，一个 app\components\BookingService 的实例就会被创建并被作为第三个参数注入到控制器的构造器中。

什么时候注册依赖关系

由于依赖关系在创建新对象时需要解决，因此它们的注册应该尽早完成。如下是推荐的实践：

如果你是一个应用程序的开发者，你可以在应用程序的入口脚本或者被入口脚本引入的脚本中注册依赖关系。

如果你是一个可再分发扩展的开发者，你可以将依赖关系注册到扩展的引导类中。

总结

依赖注入和服务定位器都是流行的设计模式，它们使你可以用充分解耦且更利于测试的风格构建软件。强烈推荐你阅读 Martin 的文章，对依赖注入和服务定位器有个更深入的理解。

Yii 在依赖住入（DI）容器之上实现了它的服务定位器。当一个服务定位器尝试创建一个新的对象实例时，它会把调用转发到 DI 容器。后者将会像前文所述那样自动解决依赖关系。

Tags: Yii框架

分享到：