• 
    
  • <tbody id="a8qsl"><track id="a8qsl"></track></tbody>
    <tbody id="a8qsl"><pre id="a8qsl"></pre></tbody>

      <dd id="a8qsl"><noscript id="a8qsl"></noscript></dd>
      您的位置 >>> 星想互联 >>> 编程技术 >>> PHP高级编程
      依赖注入(DI)和Ioc容器
      点击数:1212  发布时间2020-06-06 20:55:26

      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理解起来比较难,因为它的设计不是入门级别的,而是专业级别的,比前面讲的要复杂许多,但是看官方文档,寥寥数语,真有种想砸电脑的冲动。

      来源:咸宁网站建设
      日本高清中文字幕在线观穿线视频-一本色综合网久久-剧情国产AV剧情-欧美首页