行為的屬性和方法注入原理

上面我們了解到了行為的用意在于將自身的屬性和方法注入給所依附的類。 那么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. //Vevb.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. //Vevb.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 容器。后者將會像前文所述那樣自動解決依賴關系。