溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要講解了“現代PHP框架里的IOC容器怎么實現”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“現代PHP框架里的IOC容器怎么實現”吧！
相信很多人聽說過依賴注入，依賴注入實現的基礎條件離不開容器，容器就是用來管理類依賴和注入的，負責服務的管理和解耦組件，最簡單的理解我們可以把容器理解成一個超級大、專門存對象的數組。
如圖所示調用者通過容器的標示獲取到對象實例，圖里可以看出來，可以通過 ::class 的方式來獲取也可以直接通過對象標示獲取實例對象。
大家可能都聽說過IOC容器，IOC的全稱是：(Inversion Of Control，反轉控制)。
我們來理解一下什么是反轉控制，在我們傳統編碼中我們在類與類之間的依賴通常是我們通過編碼的方式new出來對象再傳遞的，而使用控制反轉我們可以把對象的控制權交給容器或者框架去實現。目的是為了讓我們不需要硬編碼去創建對象，看圖1可以知道，容器里面存放著很多對象，當我們要使用的時候可以直接去用。而容器里面的對象不需要我們在代碼中編碼創建。在需要某個類對象的時候會去容器里面獲取對象，如果對象不存在則會自動創建。這就是省略了我們在代碼里面去創建對象的過程，由容器去幫我們實現這個創建的過程，這就叫反轉控制。一句話總結IOC：把創建對象的控制權轉移給容器實現類的實例化。
例如：沒有使用IOC的情況下，我們想要創建類
<?php
class Sunny{
}
$sunny = new Sunny();
我們需要手動去new一個類，這種情況就是硬編碼在代碼里面去實現的。
而使用IOC容器的代碼則可以這樣寫。
<?php
class Sunny{
}
$sunny = Container::getBean(Sunny::class);
在容器的內部去幫我們實現這個類，有同學看到這里可能會有疑問，我使用 new Sunny 不是代碼寫得更短更簡單嗎？我們看完依賴注入再看一個例子。
現在知道了IOC是什么，那么一個新的問題出來了，我們在創建類的時候有些類的構造方法會需要我們傳遞參數怎么辦？通過IOC的學習我們知道了IOC容器會幫我們解決這個對象實例創建的問題，那么在容器里面創建對象的時候發現類有其他依賴則會進行依賴查找，容器尋找需要對象的過程，稱為DL(Dependency Lookup, 依賴查找)。而把需要的依賴注入到代碼片段中這個稱為DI(Dependency Injection,依賴注入)。
例如IOC里面說到的 new Sunny 這個例子。如果在類與類之間有多重依賴。
<?php
class Computer{
public function run(){
echo "編程中....\n";
}
}
class Sunny{
private $computer;
public function __construct(Computer $computer){
$this->computer = $computer;
}
public function program(){
$this->computer->run();
}
}
$sunny = new Sunny(new Computer());
$sunny->program();
這里可以看到 Sunny 這個類想要編程依賴類 Computer 這個類，而如果使用IOC容器實現依賴注入的話，代碼就簡單了。
<?php
class Computer{
public function run(){
echo "編程中....\n";
}
}
class Sunny{
private $computer;
public function __construct(Computer $computer){
$this->computer = $computer;
}
public function program(){
$this->computer->run();
}
}
$sunny = Container::getBean(Sunny::class);
$sunny->program();
一句話總結：解決創建類實例當中對其他類的依賴，動態的向某個對象提供它所需要的其他對象。
依賴倒置解決的問題是松耦各個模塊之間的重度依賴，上層模塊不應該依賴底層模塊，它們都應該依賴于抽象。通常簡單的理解依賴倒置就是面向接口或者面向抽象來進行編程。我們通過下面的例子來看看面向接口編程。
class Cache{
public function set($key,$value){
$redis = new CFile();
$redis->set($key,$value);
}
}
class CFile{
public function set($key,$value){
echo "file:{$key}->{$value}\n";
}
}
$cache = new Cache();
$cache->set("name","sunny");
上面的這段代碼看似沒有什么大問題，但是如果有一天把文件緩存改成Redis緩存呢？
class Cache{
public function set($key,$value){
$redis = new CRedis();
$redis->set($key,$value);
}
}
class CRedis{
public function set($key,$value){
echo "redis:{$key}->{$value}\n";
}
}
$cache = new Cache();
$cache->set("name","sunny");
通過這段代碼可以看出來當一個緩存使用的驅動改變了的時候，Cache的代碼也必須作出相應的改變，因為代碼寫死在調用者身上了，耦合度變得高了。再對代碼進行改造一樣，讓程序員面向interface編程，讓代碼變得更通用，更規范。
interface ICache{
public function set($key,$value);
}
class CRedis implements ICache {
public function set($key,$value)
{
echo "redis:{$key}->{$value}\n";
}
}
class CFile implements ICache{
public function set($key,$value)
{
echo "file:{$key}->{$value}\n";
}
}
class Cache{
private $drive;
public function __construct(ICache $drive)
{
$this->drive = $drive;
}
public function set($key,$value){
$this->drive->set($key,$value);
}
}
$cache = new Cache(new CFile());
$cache->set("name","sunny");
很多人看到這段代碼的時候想著，那我在構造方法直接把要的對象傳進去不就好了嗎？為什么還要定義一個interface呢？其實定義interface是為了規范代碼，不管你使用哪個驅動，只要實現了我這個interface的都可以用，沒有interface開發者在開發驅動的時候就會不知道這個驅動里面該有什么方法。當我們使用interface之后大家只要面向接口編程，Cache完全不管類是怎么實現的，Cache只是根據interface的方法進行操作。
一句話總結：依賴倒置實現松耦合
<?php
class Container
{
// 當前容器對象
private static $instance;
// 存放在容器里面到實例
protected $instances = [];
private function __construct()
{
}
public static function getInstance()
{
if (!self::$instance) {
self::$instance = new static();
}
return self::$instance;
}
/**
* 獲取對象實例
* @param $key
* @return mixed
*/
public function get($key)
{
if (isset($this->instances[$key])) {
return $this->instances[$key];
}
}
/**
* 綁定對象、閉包、類到容器
* @param $key
* @param null $concrete
* @return Container
*/
public function bind($key, $concrete = null)
{
if ($concrete instanceof Closure) {
$this->instances[$key] = $concrete;
} elseif (is_object($concrete)) {
$this->instances[$key] = $concrete;
}
return $this;
}
}
class Sunny
{
public function getName()
{
echo time() . "\n";
}
}
$app = Container::getInstance();
$sunny = $app->bind(Sunny::class,new Sunny());
$sunny = $app->get(Sunny::class);
$sunny->getName();
Container.php
<?php
class Container
{
// 當前容器對象
private static $instance;
// 存放在容器里面到實例
protected $instances = [];
private function __construct()
{
}
public static function getInstance()
{
if (!self::$instance) {
self::$instance = new static();
}
return self::$instance;
}
/**
* 獲取對象實例
* @param $key
* @return mixed
* @throws ReflectionException
*/
public function get($key)
{
if (isset($this->instances[$key])) {
return $this->instances[$key];
}
return $this->make($key);
}
/**
* 綁定對象、閉包、類到容器
* @param $key
* @param null $concrete
* @return Container
* @throws ReflectionException
*/
public function bind($key, $concrete = null)
{
if ($concrete instanceof Closure) {
$this->instances[$key] = $concrete;
} elseif (is_object($concrete)) {
$this->instances[$key] = $concrete;
} else {
$this->make($key, $concrete);
}
return $this;
}
/**
* 創建類綁定到類實例
* @param $abstract
* @param null $atgs
* @return mixed
* @throws ReflectionException
*/
public function make($abstract, $atgs = null)
{
if (isset($this->instances[$abstract])) {
return $this->instances[$abstract];
}
$object = $this->invokeClass($abstract);
$this->instances[$abstract] = $object;
return $object;
}
/**
* 反射解析類
* @param $abstract
* @return object
* @throws ReflectionException
*/
public function invokeClass($abstract)
{
$reflectionClass = new \ReflectionClass($abstract);
// 獲取構造方法
$construct = $reflectionClass->getConstructor();
// 獲取參數得到實例
$params = $construct ? $this->parserParams($construct) : [];
$object = $reflectionClass->newInstanceArgs($params);
return $object;
}
/**
* 解析構造方法參數
* @param $reflect
* @return array
* @throws ReflectionException
*/
public function parserParams(ReflectionMethod $reflect)
{
$args = [];
$params = $reflect->getParameters();
if (!$params) {
return $args;
}
if (count($params) > 0) {
foreach ($params as $param) {
$class = $param->getClass();
if ($class) {
$args[] = $this->make($class->getName());
continue;
}
// 獲取變量的名稱
$name = $param->getName();
// 默認值
$def = null;
// 如果有默認值，從默認值獲取類型
if ($param->isOptional()) {
$def = $param->getDefaultValue();
}
$args[] = $_REQUEST[$name] ?? $def;
}
}
return $args;
}
}
Test.php
<?php
class Test
{
public $name;
private $test1;
public function __construct(Test1 $test1)
{
$this->test1 = $test1;
$this->name = $this->test1->getName();
}
}
Test1.php
<?php
class Test1
{
public function getName(){
return "test1返回的名字";
}
}
Sunny.php
<?php
require_once "./Container.php";
require_once "./Test.php";
require_once "./Test1.php";
class Sunny
{
private $test;
public function __construct(Test $test)
{
$this->test = $test;
}
public function getName()
{
echo "獲取test里面的name：{$this->test->name}\n";
}
}
$app = Container::getInstance();
$sunny = $app->get(Sunny::class);
$sunny->getName();
感謝各位的閱讀，以上就是“現代PHP框架里的IOC容器怎么實現”的內容了，經過本文的學習后，相信大家對現代PHP框架里的IOC容器怎么實現這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
