<small id='Aq3Z'></small> <noframes id='l89R'>

  • <tfoot id='bnXBNxUyD'></tfoot>

      <legend id='hoHsV4tZy'><style id='kiZPzpc'><dir id='zVI0emkL'><q id='nIFWhY'></q></dir></style></legend>
      <i id='dnSFNgrV'><tr id='avYpAH'><dt id='ji5zCEYAF'><q id='JKPgB1tcZ'><span id='lyRjwfCaxo'><b id='N85hbZ1'><form id='T3vVtDihS'><ins id='GWDMU6mFi'></ins><ul id='oh1iP3WHC'></ul><sub id='dTQzaj6'></sub></form><legend id='c9BYh'></legend><bdo id='QbeB'><pre id='W6JC2kEQMa'><center id='Jw4Q'></center></pre></bdo></b><th id='deZpE7'></th></span></q></dt></tr></i><div id='SHcK8aQ3Y'><tfoot id='p0lUIsex'></tfoot><dl id='e83prlm'><fieldset id='ZpAK7'></fieldset></dl></div>

          <bdo id='Gd3S6'></bdo><ul id='StcjyT8D'></ul>

          1. <li id='UaS8Hq0c'></li>
            登陆

            1号娱乐彩票-了解 PHP 依靠注入 和 操控回转

            admin 2019-11-06 163人围观 ,发现0个评论

            要想了解 PHP 依靠注入操控回转 两个概念,就有必要搞清楚如下的两个问题:

            • DI —— Dependency Injection 依靠注入
            • IoC —— Inversion of Control 操控回转

            什么是依靠注入

            没有你我就活不下去,那么,你便是我的依靠。 说白了便是:

            不是我本身的,却是我需求的,都是我所依靠的。悉数需求外部供给的,都是需求进行依靠注入的。

            依靠注入举例

            class Boy {
            protected $girl;
            public function __construct(Girl $girl) {
            $this->girl = $girl;
            }
            }
            class Girl {
            ...
            }
            $boy = new Boy(); // Error; Boy must have girlfriend!
            // 所以,有必要要给他一个女朋友才行
            $girl = new Girl();
            $boy = new Boy($girl); // Right! So Happy!

            从上述代码咱们能够看到Boy强依靠Girl有必要在结构时注入Girl的实例才行。

            那么为什么要有依靠注入这个概念,依靠注入究竟处理了什么问题?

            咱们将上述代码批改一下咱们初学时都写过的代码:

            class Boy {
            protected $girl;
            public function __construct() {
            $this->girl = new Girl();
            }
            }

            这种办法与前面的办法有什么不同呢?

            咱们会发现Bo1号娱乐彩票-了解 PHP 依靠注入 和 操控回转y的女朋友被咱们硬编码到Boy的身体里去了。。。 每次Boy重生自己想换个类型的女朋友都要把自己扒光才行。

            某天Boy特别喜爱一个LoliGirl ,非常想让她做自己的女朋友。。。怎么办? 重生自己。。。扒开自己。。。把Girl扔了。。。把 LoliGirl塞进去。。。

            class LoliGirl {
            }
            class Boy {
            protected $girl;
            public function __construct() {
            // $this->girl = new Girl(); // sorry...
            $this->girl = new LoliGirl();
            }
            }

            某天 Boy沉迷上了御姐....Boy 好烦。。。

            是不是感觉不太好?每次遇到诚心相待的人却要这么的摧残自己。。。

            Boy说,我要变的强壮一点。我不想被改来改去的!

            好吧,咱们让Boy强壮一点:

            interface Girl {
            // Boy need knows that I have some abilities.
            }
            class LoliG1号娱乐彩票-了解 PHP 依靠注入 和 操控回转ril implement Girl {
            // I will implement Girl's abilities.
            }
            class Vixen implement Girl {
            // Vixen definitely is a girl, do not doubt it.
            }
            class Boy {
            protected $girl;
            public function __construct(Girl $girl) {
            $this->girl = $girl;
            }
            }
            $loliGirl = new LoliGirl();
            $vixen = new Vixen();
            $boy = new Boy($loliGirl);
            $boy = new Bo圣澜熙y($vixen);

            Boy 很快乐,总算能够不必扒开自己就能够体会不同的人生了。。。So Happy!

            依靠注入办法

            1、结构器 注入


            class Book {
            private $db_conn;
            public function __construct($db_conn) {
            $this->db_conn = $db_conn;
            }
            }

            2、setter 注入


            class Book {
            private $db;
            private $file;

            function setdb($db) {
            $this->db = $db;
            }

            function setfile($file) {
            $this->file = $file;
            }
            }

            class file {
            }

            class db {
            }

            // ...

            class test {
            $book = new Book();
            $book->setdb(new db());
            $book->setfile(new file());
            }

            小结:

            由于大多数应用程序都是由两个或许更多的类经过互相协作来完成事务逻辑,这使得每个目标都需求获取与其协作的目标(也便是它所依靠的目标)的引证。假如这个获取进程要靠本身完成,那么将导致代码高度耦合而且难以保护和调试。

            所以才有了依靠注入的概念,依靠注入处理了以下问题:

            • 依靠之间的解耦
            • 单元测试,便利Mock

            上面俩种办法代码很明晰,可是当咱们需求注入很多个依靠时,意味着又要增加很多行,会比较难以办理。

            比较好的处理办法是 树立一个class作为一切依靠联系的container,在这个class中能够寄存、创立、获取、查找需求的依靠联系。先来了解一下IOC的概念

            操控回转 (Inversion Of Control, IOC)

            操控回转 是面向目标编程中的一种规划准则,能够用来减低计算机代码之间的耦合度。其间最常见的办法叫做 依靠注入(Dependency Injection, DI), 还有一种叫"依靠查找"(Dependency Lookup)。经过操控回转,目标在被创立的时分,由一个调控体系内一切目标的外界实体,将其所依靠的目标的引证传递给它。也能够说,依靠被注入到目标中。




            class Ioc {
            protected $db_conn;

            public static function make_book() {
            $new_book = new Book();
            $new_book->set_db(self::$db_conn);
            //...
            //...
            //其他的依靠注入
            return $new_book;
            }
            }

            此刻,假如获取一个book实例,只需求履行$newone = Ioc::makebook();

            以上是container的一个详细实例,最好仍是不要把详细的某个依靠注入写成办法,选用registry注册,get获取比较好


            /**
            * 操控回转类
            */
            class Ioc {
            /**
            * @var array 注册的依靠数组
            */
            protected static $registry = array();

            /**
            * 增加一个 resolve (匿名函数)到 registry 数组中
            *
            * @param string $name 依靠标识
            * @param Closure $resolve 一个匿名函数,用来创立实例
            * @return void
            */
            public static function register($name, Closure $resolve) {
            static::$registry[$name] = $resolve;
            }

            /**
            * 回来一个实例
            *
            * @param string $name 依靠的标识
            * @return mixed
            * @throws \Exception
            */
            public static function resolve($name) {
            if (static::registered($na1号娱乐彩票-了解 PHP 依靠注入 和 操控回转me)) {
            $name = static::$registry[$name];
            return $name();
            }

            throw new \Exception("Nothing registered with that name");
            }

            /**
            * 查询某个依靠实例是否存在
            *
            * @param string $name
            * @return bool
            */
            public static function registered($name) {
            return array_key_exists($name, static::$registry);
            }
            }

            现在就能够经过如下办法来注册和注入一个

            Ioc::register("book", function () {
            $book = new Book()1号娱乐彩票-了解 PHP 依靠注入 和 操控回转;
            $book->setdb('db');
            $book->setfile('file');
            return $book;
            });
            // 注入依靠
            $book = Ioc::resolve('book');

            问题汇总

            1、参与者都有谁?

            答:一般有三方参与者,一个是某个目标;一个是IoC/DI的容器;另一个是某个目标的外部资源。又要名词解释一下,某个目标指的便是恣意的、一般的Java目标; IoC/DI的容器简单点说便是指用来完成IoC/DI功用的一个结构程序;目标的外部资源指的便是目标需求的,可是是从目标外部获取的,都总称资源,比方:目标需求的其它目标、或许是目标需求的文件资源等等。

            2、依靠:谁依靠于谁?为什么会有依靠?

            答:某个目标依靠于IoC/DI的容器。依靠是不可防止的,在一个项目中,各个类之间有各式各样的联系,不可能悉数彻底独立,这就构成了依靠。传统的开发是运用其他类时直接调用,这会构成强耦合,这是要防止的。依靠注入借用容器转移了被依靠目标完成解耦。

            3、注入:谁注入于谁?究竟注入什么?

            答:经过容器向目标注入其所需求的外部资源

            4、操控回转:谁操控谁?操控什么?为什么叫回转?

            答:IoC/DI的容器操控目标,主要是操控目标实例的创立。回转是相对于正向而言的,那么什么算是正向的呢?考虑一下惯例状况下的应用程序,假如要在A里边运用C,你会怎么做呢?当然是直接去创立C的目标,也便是说,是在A类中自动去获取所需求的外部资源C,这种状况被称为正向的。那么什么是反向呢?便是A类不再自动去获取C,而是被迫等候,等候IoC/DI的容器获取一个C的实例,然后反向的注入到A类中。

            5、依靠注入和操控回转1号娱乐彩票-了解 PHP 依靠注入 和 操控回转是同一概念吗?

            答:从上面能够看出:依1号娱乐彩票-了解 PHP 依靠注入 和 操控回转靠注入是从应用程序的视点在描绘,能够把依靠注入描绘完整点:应用程序依靠容器创立并注入它所需求的外部资源;而操控回转是从容器的视点在描绘,描绘完整点:容器操控应用程序,由容器反向的向应用程序注入应用程序所需求的外部资源

            请关注微信公众号
            微信二维码
            不容错过
            Powered By Z-BlogPHP