PHP程序员如何理解依赖注入容器(dependency injection container)

Coding01 发布于2019-06-27 10:58 / 496人阅读

摘要：代码这就是控制反转模式。是变量有默认值则设置默认值是一个类，递归解析有默认值则返回默认值从容器中取得以上代码的原理参考官方文档反射，具有完整的反射，添加了对类接口函数方法和扩展进行反向工程的能力。

PHP程序员如何理解依赖注入容器(dependency injection container) 背景知识

传统的思路是应用程序用到一个Foo类，就会创建Foo类并调用Foo类的方法，假如这个方法内需要一个Bar类，就会创建Bar类并调用Bar类的方法，而这个方法内需要一个Bim类，就会创建Bim类，接着做些其它工作。

    // 代码【1】
    class Bim
    {
        public function doSomething()
        {
            echo __METHOD__, "|";
        }
    }
    
    class Bar
    {
        public function doSomething()
        {
            $bim = new Bim();
            $bim->doSomething();
            echo __METHOD__, "|";
        }
    }
    
    class Foo
    {
        public function doSomething()
        {
            $bar = new Bar();
            $bar->doSomething();
            echo __METHOD__;
        }
    }
    
    $foo = new Foo();
    $foo->doSomething(); //Bim::doSomething|Bar::doSomething|Foo::doSomething

使用依赖注入的思路是应用程序用到Foo类，Foo类需要Bar类，Bar类需要Bim类，那么先创建Bim类，再创建Bar类并把Bim注入，再创建Foo类，并把Bar类注入，再调用Foo方法，Foo调用Bar方法，接着做些其它工作。

    // 代码【2】
    class Bim
    {
        public function doSomething()
        {
            echo __METHOD__, "|";
        }
    }
    
    class Bar
    {
        private $bim;
    
        public function __construct(Bim $bim)
        {
            $this->bim = $bim;
        }
    
        public function doSomething()
        {
            $this->bim->doSomething();
            echo __METHOD__, "|";
        }
    }
    
    class Foo
    {
        private $bar;
    
        public function __construct(Bar $bar)
        {
            $this->bar = $bar;
        }
    
        public function doSomething()
        {
            $this->bar->doSomething();
            echo __METHOD__;
        }
    }
    
    $foo = new Foo(new Bar(new Bim()));
    $foo->doSomething(); // Bim::doSomething|Bar::doSomething|Foo::doSomething

这就是控制反转模式。依赖关系的控制反转到调用链的起点。这样你可以完全控制依赖关系，通过调整不同的注入对象，来控制程序的行为。例如Foo类用到了memcache，可以在不修改Foo类代码的情况下，改用redis。

使用依赖注入容器后的思路是应用程序需要到Foo类，就从容器内取得Foo类，容器创建Bim类，再创建Bar类并把Bim注入，再创建Foo类，并把Bar注入，应用程序调用Foo方法，Foo调用Bar方法，接着做些其它工作.

总之容器负责实例化，注入依赖，处理依赖关系等工作。

代码演示依赖注入容器 (dependency injection container)

通过一个最简单的容器类来解释一下，这段代码来自 Twittee

    class Container
    {
        private $s = array();
    
        function __set($k, $c)
        {
            $this->s[$k] = $c;
        }
    
        function __get($k)
        {
            return $this->s[$k]($this);
        }
    }

这段代码使用了魔术方法，在给不可访问属性赋值时，__set() 会被调用。读取不可访问属性的值时，__get() 会被调用。

    $c = new Container();
    
    $c->bim = function () {
        return new Bim();
    };
    $c->bar = function ($c) {
        return new Bar($c->bim);
    };
    $c->foo = function ($c) {
        return new Foo($c->bar);
    };
    
    // 从容器中取得Foo
    $foo = $c->foo;
    $foo->doSomething(); // Bim::doSomething|Bar::doSomething|Foo::doSomething

这段代码使用了匿名函数

再来一段简单的代码演示一下，容器代码来自simple di container

    class IoC
    {
        protected static $registry = [];
    
        public static function bind($name, Callable $resolver)
        {
            static::$registry[$name] = $resolver;
        }
    
        public static function make($name)
        {
            if (isset(static::$registry[$name])) {
                $resolver = static::$registry[$name];
                return $resolver();
            }
            throw new Exception("Alias does not exist in the IoC registry.");
        }
    }
    
    IoC::bind("bim", function () {
        return new Bim();
    });
    IoC::bind("bar", function () {
        return new Bar(IoC::make("bim"));
    });
    IoC::bind("foo", function () {
        return new Foo(IoC::make("bar"));
    });
    
    
    // 从容器中取得Foo
    $foo = IoC::make("foo");
    $foo->doSomething(); // Bim::doSomething|Bar::doSomething|Foo::doSomething

这段代码使用了后期静态绑定

依赖注入容器 (dependency injection container) 高级功能

真实的dependency injection container会提供更多的特性，如

自动绑定（Autowiring）或自动解析（Automatic Resolution）

注释解析器（Annotations）

延迟注入（Lazy injection）

下面的代码在Twittee的基础上，实现了Autowiring。

    class Bim
    {
        public function doSomething()
        {
            echo __METHOD__, "|";
        }
    }
    
    class Bar
    {
        private $bim;
    
        public function __construct(Bim $bim)
        {
            $this->bim = $bim;
        }
    
        public function doSomething()
        {
            $this->bim->doSomething();
            echo __METHOD__, "|";
        }
    }
    
    class Foo
    {
        private $bar;
    
        public function __construct(Bar $bar)
        {
            $this->bar = $bar;
        }
    
        public function doSomething()
        {
            $this->bar->doSomething();
            echo __METHOD__;
        }
    }
    
    class Container
    {
        private $s = array();
    
        public function __set($k, $c)
        {
            $this->s[$k] = $c;
        }
    
        public function __get($k)
        {
            // return $this->s[$k]($this);
            return $this->build($this->s[$k]);
        }
    
        /**
         * 自动绑定（Autowiring）自动解析（Automatic Resolution）
         *
         * @param string $className
         * @return object
         * @throws Exception
         */
        public function build($className)
        {
            // 如果是匿名函数（Anonymous functions），也叫闭包函数（closures）
            if ($className instanceof Closure) {
                // 执行闭包函数，并将结果
                return $className($this);
            }
    
            /** @var ReflectionClass $reflector */
            $reflector = new ReflectionClass($className);
    
            // 检查类是否可实例化, 排除抽象类abstract和对象接口interface
            if (!$reflector->isInstantiable()) {
                throw new Exception("Can"t instantiate this.");
            }
    
            /** @var ReflectionMethod $constructor 获取类的构造函数 */
            $constructor = $reflector->getConstructor();
    
            // 若无构造函数，直接实例化并返回
            if (is_null($constructor)) {
                return new $className;
            }
    
            // 取构造函数参数,通过 ReflectionParameter 数组返回参数列表
            $parameters = $constructor->getParameters();
    
            // 递归解析构造函数的参数
            $dependencies = $this->getDependencies($parameters);
    
            // 创建一个类的新实例，给出的参数将传递到类的构造函数。
            return $reflector->newInstanceArgs($dependencies);
        }
    
        /**
         * @param array $parameters
         * @return array
         * @throws Exception
         */
        public function getDependencies($parameters)
        {
            $dependencies = [];
    
            /** @var ReflectionParameter $parameter */
            foreach ($parameters as $parameter) {
                /** @var ReflectionClass $dependency */
                $dependency = $parameter->getClass();
    
                if (is_null($dependency)) {
                    // 是变量,有默认值则设置默认值
                    $dependencies[] = $this->resolveNonClass($parameter);
                } else {
                    // 是一个类，递归解析
                    $dependencies[] = $this->build($dependency->name);
                }
            }
    
            return $dependencies;
        }
    
        /**
         * @param ReflectionParameter $parameter
         * @return mixed
         * @throws Exception
         */
        public function resolveNonClass($parameter)
        {
            // 有默认值则返回默认值
            if ($parameter->isDefaultValueAvailable()) {
                return $parameter->getDefaultValue();
            }
    
            throw new Exception("I have no idea what to do here.");
        }
    }
    
    // ----
    $c = new Container();
    $c->bar = "Bar";
    $c->foo = function ($c) {
        return new Foo($c->bar);
    };
    // 从容器中取得Foo
    $foo = $c->foo;
    $foo->doSomething(); // Bim::doSomething|Bar::doSomething|Foo::doSomething
    
    // ----
    $di = new Container();
    
    $di->foo = "Foo";
    
    /** @var Foo $foo */
    $foo = $di->foo;
    
    var_dump($foo);
    /*
    Foo#10 (1) {
      private $bar =>
      class Bar#14 (1) {
        private $bim =>
        class Bim#16 (0) {
        }
      }
    }
    */
    
    $foo->doSomething(); // Bim::doSomething|Bar::doSomething|Foo::doSomething

以上代码的原理参考PHP官方文档：反射，PHP 5 具有完整的反射 API，添加了对类、接口、函数、方法和扩展进行反向工程的能力。此外，反射 API 提供了方法来取出函数、类和方法中的文档注释。

若想进一步提供一个数组访问接口，如$di->foo可以写成$di["foo"]，则需用到ArrayAccess（数组式访问）接口。

一些复杂的容器会有许多特性，下面列出一些相关的github项目，欢迎补充。

参考代码

Twittee

simple di container

Pimple

PHP-DI

Ding

推荐阅读

PHP程序员如何理解IoC/DI

PHP之道

PHP最佳实践

云服务器超融合服务器依赖注入依赖注入方式 js依赖注入构造函数依赖注入

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/20882.html

PHP程序员如何理解IoC/DI

摘要：依赖注入容器管理应用程序中的全局对象包括实例化处理依赖关系。为了解决这样的问题，我们再次回到全局注册表创建组件。参考文章程序员如何理解依赖注入容器补充很多代码背后，都是某种哲学思想的体现。思想思想是解决问题的根本思想必须转换成习惯构建一套完整的思想体系是开发能力成熟的标志——《简单之美》（前言） . 成功的软件项目就是那些提交产物达到或超出客户的预期的项目，而且开发过程符合时间和费...

DataPipeline 2019-06-27 10:59 评论0 收藏0
Laravel Dependency Injection (依赖注入) 概念详解

摘要：依赖注入并不限于构造函数作为经验，注入最适合必须的依赖关系，比如示例中的情况注入最适合可选依赖关系，比如缓存一个对象实例。本文翻译自 Symfony 作者 Fabien Potencier 的《Dependency Injection in general and the implementation of a Dependency Injection Container in P...

Fundebug 2019-06-28 13:55 评论0 收藏0
Yii2中的依赖注入

摘要：构造器注入实现特定参数的构造函数，在新建对象时传入所依赖类型的对象。基本概念 1.依赖倒置（反转）原则（DIP）：一种软件架构设计的原则（抽象概念，是一种思想）在面向对象编程领域中，依赖反转原则（Dependency inversion principle，DIP）是指一种特定的解耦（传统的依赖关系创建在高层次上，而具体的策略设置则应用在低层次的模块上）形式，使得高层次的模块不依赖于...

harriszh 2019-06-28 13:31 评论0 收藏0
Laravel Container (容器) 概念详解 (上)

摘要：上文书，创建对象需要先创建对象。创建对象的杂活是嵌入在中的。对象使用来管理依赖关系非常好，但不是必须的。很容易实现，但手工维护各种乱七八糟的对象还是很麻烦。所有文章均已收录至项目。本文翻译自 Symfony 作者 Fabien Potencier 的《Dependency Injection in general and the implementation of a Depend...

FullStackDeveloper 2019-06-28 13:54 评论0 收藏0
深入剖析 Laravel 服务容器

摘要：划下重点，服务容器是用于管理类的依赖和执行依赖注入的工具。类的实例化及其依赖的注入，完全由服务容器自动的去完成。本文首发于深入剖析 Laravel 服务容器，转载请注明出处。喜欢的朋友不要吝啬你们的赞同，谢谢。之前在深度挖掘 Laravel 生命周期一文中，我们有去探究 Laravel 究竟是如何接收 HTTP 请求，又是如何生成响应并最终呈现给用户的工作原理。本章将带领大...

abson 2019-07-01 10:00 评论0 收藏0