Laravel依赖注入（DI）和Ioc容器

Posted 2020-08-18

原文地址：http://lixiangfeng.com/blog/article/content/7908531

 

Laravel这个框架，用起来方便，理解起来不简单。

为什么不简单？因为包含了一大堆所谓“先进”的概念，其中依赖注入（DI）和Ioc容器是比较核心的内容之一。

我百度了一下，讲php DI和Ioc的内容很少，更别说详解Laravel ioc的了。

在这里，我综合了几篇写得比较典型的文章，以一个产品经理的身份，从用户体验的角度尝试让初学者也能比较容易理解这个2个概念。

 

DI和Ioc就是一种设计模式，这个概念已经存在10几年了，请先对面向对象编程和设计模式（DesignPatterns）有初步的理解：

预先了解一下这三种模式：1. 工厂模式 2. 单例模式 3. 注册器模式

也请了解一下 interface 的用法和作用；

 

如果上述内容你都不是很熟悉，没关系，很简单的，请接着看：

 

1. 首先来看 依赖注入（DI）：

故事是这样的：

我们知道写一个类的时候，类本身是有个目的的，类里面有很多方法，每个方法搞定一些事情；

class Hookup {
 
public function getPhone(){
     //此处省略
}

public function inviteHer(){
     //此处省略
}

public function giveGifts(){
     //此处省略
}
public function kissHer(){
     //此处省略
}
}

比方说

这个类是什么意思？Hookup就是泡妞的意思，里面有4个步骤，第一步打电话，第二部邀请她共进晚餐，第三步送礼物，第四步打波儿，第五步.....我只能帮你到这里了...

 

别看只有4步，其实每一步都不简单，第一步打电话，你得先要到人家电话吧，第二步邀请吃饭，你得提前订好饭店吧，第三步送礼物，你得先买礼物吧~第四步Kiss，你总得抓住一个合适的机会吧；

 

当你在专心处理Hookup的时候，我太了解你了，你只关心结果，也就是抱得美人归，问电话号码，订餐，买礼物，找机会这种小事，就交给其他“类”处理吧。

 

如下：

 require ‘BuyGifts.php‘;


class Hookup {
 
public function getPhone(){
     //此处省略
}

public function inviteHer(){
     //此处省略
}

public function giveGifts(){
$gift = new BuyGifts();
$gift->select();
$gift->pay();
}
public function kissHer(){
     //此处省略
}
}

$paoniu = new hookup();
$paoniu->giveGifts();

这里面送礼物这个环节(比较懒，其他的不写了)，就引入了BuyGifts这个类，买礼物这种小事，就交给BuyGifts这个秘书去处理吧。

 

所以，一切问题的出发点，就是在一个类中调用其他类，我们要解决的，就是在这过程中会发生的问题。

 

Hookup这个可以称之为主类，BuyGifts称之为次类，为了实现主类的目标，要依赖很多次类来配合。

 

好，现在你已经知道什么是依赖了。

 

问题来了。现在讲正经的。

 

比方说你很忙，你不仅要泡妞，还要开公司，做生意，没事打打高尔夫球什么的。这每一件事都是一个“主类”，BuyGifts 这种“次类” ，除了泡妞，也可以放在 做生意这个类里面调用，做生意也要送礼的嘛，当然还可以应用在别的主类。 

 

如果BuyGifts被调用很多次，哪一天需要把名字改了，那你就必须在众多主类中逐一修改。

还有就是，每一次调用都要new实例化一次。

这样做不科学，你也知道。

 

怎么办： 工厂模式

工厂模式很简单，就是来帮助你批量实例化“次类”的。也就是说，用了工厂模式，你的主类中将不会再出现new这样的关键字。

 

看实例，有3个类 哦：

-----   Factory.php    ----------

include ‘BuyGifts.php‘

class Factory {

static function getPhone(){
 
return new getPhone;
}


static function BuyGifts(){
 
return new BuyGifts;
}

//……下面还有很多，此处省略

}

-----   BuyGifts.php    ----------

class  BuyGifts{
 
public function select(){
//此处省略 }

public function pay(){
//此处省略 }

}

-----   Hookup.php    ----------

require ‘BuyGifts.php‘;
require ‘Factory.php ‘;

class Hookup {

private $gift;
 
public function getPhone(){
     //此处省略
}

public function inviteHer(){
     //此处省略
}

public function giveGifts(){
$this->gift = Factory::BuyGifts();
$gift->select();
$gift->pay();
}
public function kissHer(){
     //此处省略
}
}

$paoniu = new hookup();
$paoniu->giveGifts();

 

你看，现在主类Hookup 要调用次类BuyGifts，就得先去找Factory类，Factory就变成中介了。

Factory这个中介的主要服务就是帮 你实例化次类，另外管理很多次类（工厂嘛），这样你就不用直接与次类发生关系。

 

这个过程就叫做 解耦，不管次类怎么变，你找工厂就可以了。

 

可是这样做问题依旧存在，，当我们在很多主类里调用了工厂及其方法，可是有一天发现工厂类要改名，，或者工厂里面的方法要改名呢？那我们还不是得逐一改主类？虽然这种情况不多，但是这种不讲信誉的“黑中介”也是偶尔会出现的。

 

怎么办呢？我们对这个Factory 中介 也得 防 一手。

-----   Hookup.php    ----------

require ‘BuyGifts.php‘;
require ‘Factory.php ‘;

class Hookup {

private $gift;
 
public function getPhone(){
     //此处省略
}

public function inviteHer(){
     //此处省略
}

public function giveGifts(){
$gift->select();
$gift->pay();
}

public function kissHer(){
     //此处省略
}

public function setGift($instance){
$this->gift = $instance；
}
}

$paoniu = new hookup();
$paoniu->setGift(Factory::BuyGifts()); // 看到 Factory已经滚粗 
我们的主类了
$paoniu->giveGifts();

 

 

现在Hookup类就像一个公司，作为老板的你只关心怎么泡妞，脏活累活交给别人干，于是你设立了一个setGift采购部门，这个部门专门负责和Factory中介打交道，这样Factory中介就完全滚粗你的视野了。

 

Factory这个被依赖的对象 是通过参数 从外部 注入到 类内容的 静态 属性 实现实例化的，这个就是依赖注入。

 

可以聪明的你马上发现，我擦，setGift 你这个部门就负责采购gift啊？我要打电话，发预约邀请难道还要setPhone，setInvitation吗？

 

这样主类里面要写很多set方法，外面要调用很多次set方法，你会发现，更不科学了。

里面：

public function setGift($instance){
$this->gift = $instance；
}
public 
function setPhone($instance){
$this->phone = $instance；
}

public function setInvitation($instance){
$this->Invitation = $instance；
}

….

 

外面：

$paoniu->setGift(Factory::BuyGifts());
$paoniu->setPhone(Factory::GetPhone());
$paoniu->setInvitation(Factory::SendInvitation());

….

 

这个时候，你已经把Factory 赶出 Hookup公司了，所以，公司内部的事情，只能你自己搞定了。

公司外部的业务，这时Factory中介 又屁颠屁颠的跑过来找你，提出一个方案：

 

我们来搞个“总代”怎么样？

class TopFactory {

public static function all_Agents_in_one（）{
 
$paoniu_agent = new 
hookup();
         
 $paoniu_agent->setGift(Factory::BuyGifts()); 
$paoniu_agent->setPhone(Factory::GetPhone());
        
 $paoniu_agent->setInvitation(Factory::SendInvitation());
 
return $paoniu_agent;
}

}

 

黑中介Factory对你说：“你看我搞了个总代公司（TopFactory），你在外面也不要new啊，set什么的了，我全包了。

 

于是现在你在外面要做的变简单了：

$paoniu = TopFactory::all_Agents_in_one();
$paoniu->giveGifts();//giveGifts里面就可以调用Buygifts了；
$paoniu->getPhone();
….

 

到现在为止，你已经有一套完整的 依赖注入方案了，这个方案组建的时候虽然有点复杂（层层转包），但是一旦建好，维护起来比较方便。

可是，别忘了公司内部的事情还没解决哪，另外要提醒你，你是程序员，不是老板，所以Factory那一部分也是你的活~~~

 

需要一种更高级的方案，让程序员的生活变得Easier一些。

这个方案就是IoC容器，IoC容器首先是一种类注册器，其次它是一种更高级的依赖注入方式。

 

它和工厂Factory其实性质一样，都是中介代理，但实现机制不一样。

 

工厂Factory 把 次类 一一对应 注册到 类中的 实例化静态方法中；

IoC容器是把 次类 实例化对象 依次 注册到 类中一个静态数组；

 

IoC容器的设计模式叫做 注册器模式；

 

看实例：

———Di.php——-
class Di {
 
protected static $objects;

static function 
set($key, $object){

self::$objects[$key]=$object;

}

static function get ($key){

return 
self::$objects[$key];

}

static function unset 
($key){

unset(self::$objects[$key]);

}


}


-----   Hookup.php    ----------

require ‘BuyGifts.php‘;
require ‘Factory.php ‘;
require ‘Di.php ‘;

class Hookup {

private $di;

function 
__construct(Di &$di){
       $this->_di = $di;
    }
 
public function getPhone(){
     //此处省略
}

public function inviteHer(){
     //此处省略
}

public function giveGifts(){
$this->di->get(‘BuyGifts’)->select();
$this->di->get(‘BuyGifts’)->pay();
}

public function kissHer(){
     //此处省略
}

public function setGift($instance){
$this->gift = $instance；
}
}

$di = new Di();
$di->set(‘BuyGift’, function(){
return Factory::BuyGift();
}


$paoniu=new Hookup($di);
$paoniu->giveGifts();

 

 

可以看到，IoC模式才是真正的总代，它连公司内部的事情也管了。和设立set部门相比，set只能处理一个个单独的业务，比如setGift，setPhone，setInvitation，之类的，，而ioc容器把这些实例全部放在一个数组里统一处理，并且还可以重新命名（键名），实现了完全的解耦。

 

请注意的是，我们在注册Ioc容器的时候，是这样写的：

$di->set(‘BuyGift’, function(){
return Factory::BuyGift();
}

而没有这样写：
$di->set(‘BuyGift’, Factory::BuyGift());

 

第一个参数是数组的键名，第二个参数是数组的值；

 

第一种写法用了回调函数，它只有在读取数组的值的时候才会被执行；

第二种方法直接实例化成一个对象，保存到数组的值中。第二种方法会比较占资源。

另外我们发现

$di = new Di();
$di->set(‘BuyGift’, function(){
return Factory::BuyGift();
}


$paoniu=new 
Hookup($di);
$paoniu->giveGifts();


这里面怎么还有new呢，我们用静态方法和Factory写得优雅一些：
Di::set(‘BuyGift’, function(){
return Factory::BuyGift();
} //注册到容器
$paoniu=factory::Hookup(factory::DI()); // 
将容器注入主类
$paoniu->giveGifts(); //这里就可以调用BuyGift()这个次类（依赖类）；

 

好了，我们来看看Laravel Ioc容器 是怎么用的：

 

绑定类到容器

App::bind(‘foo‘, function()
{
    return newFooBar;
});

 

App 就是Ioc容器，bind就是set方法，’foo’ 就是数组中 实例的 键名；

 

 

至此，我们已经对Ioc容器有了一个比较清楚的认识，我们已经了解了工厂模式，注册模式，依赖注入等知识，其实依赖注入有3种方式，，一种就是set注入（单类注入），一种是容器注入（Ioc），还有一种是接口注入（Interface）；前两种我们已经学习过了，后一种放在本文的第二部分来讲。

 

在本文的第二部分，我们将详细讲解LaravelIoC的用法，为什么说Laravel理解起来比较难，因为它的设计不是入门级别的，而是专业级别的，比前面讲的要复杂许多，但是看官方文档，寥寥数语，真有种想砸电脑的冲动。