首页 / PHP / PHP依赖注入，从此不再考虑加载顺序，从此不再加载_PHP教程

PHP依赖注入，从此不再考虑加载顺序，从此不再加载_PHP教程

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了PHP依赖注入，从此不再考虑加载顺序，从此不再加载_PHP教程，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11365字，纯文字阅读大概需要17分钟。

内容图文

PHP 依赖注入，从此不再考虑加载顺序，从此不再加载

说这个话题之前先讲一个比较高端的思想--'依赖倒置原则'

"依赖倒置是一种软件设计思想，在传统软件中，上层代码依赖于下层代码，当下层代码有所改动时，上层代码也要相应进行改动，因此维护成本较高。而依赖倒置原则的思想是，上层不应该依赖下层，应依赖接口。意为上层代码定义接口，下层代码实现该接口，从而使得下层依赖于上层接口，降低耦合度，提高系统弹性"

上面的解释有点虚，下面我们以实际代码来解释这个理论

比如有这么条需求，用户注册完成后要发送一封邮件，然后你有如下代码：

先有邮件类'Email.class.php'

class Mail{
    public function send()
    {
        /*这里是如何发送邮件的代码*/
    }
}

然后又注册的类'Register.class.php'

class Register{
    private $_emailObj;

    public function doRegister()
    {
        /*这里是如何注册*/

        $this->_emailObj = new Mail();
        $this->_emailObj->send();//发送邮件
    }
}

然后开始注册

include 'Mail.class.php';
include 'Register.class.php';
$reg = new Register();
$reg->doRegister();

看起来事情很简单，你很快把这个功能上线了，看起来相安无事... xxx天过后，产品人员说发送邮件的不好，要使用发送短信的，然后你说这简单我把'Mail'类改下...

又过了几天，产品人员说发送短信费用太高，还是改用邮件的好... 此时心中一万个草泥马奔腾而过...

这种事情，常常在产品狗身上发生，无可奈何花落去...

以上场景的问题在于，你每次不得不对'Mail'类进行修改，代码复用性很低，高层过度依赖于底层。那么我们就考虑'依赖倒置原则'，让底层继承高层制定的接口，高层依赖于接口。

interface Mail
{
    public function send();
}

class Email implements Mail()
{
    public function send()
    {
        //发送Email
    }
}

class SmsMail implements Mail()
{
    public function send()
    {
        //发送短信
    }
}

class Register
{
    private $_mailObj;

    public function __construct(Mail $mailObj)
    {
        $this->_mailObj = $mailObj;
    }

    public function doRegister()
    {
        /*这里是如何注册*/
        $this->_mailObj->send();//发送信息
    }
}

下面开始发送信息

/* 此处省略若干行 */
$reg = new Register();
$emailObj = new Email();
$smsObj = new SmsMail();

$reg->doRegister($emailObj);//使用email发送
$reg->doRegister($smsObj);//使用短信发送
/* 你甚至可以发完邮件再发短信 */

上面的代码解决了'Register'对信息发送类的依赖，使用构造函数注入的方法，使得它只依赖于发送短信的接口，只要实现其接口中的'send'方法，不管你怎么发送都可以。上例就使用了"注入"这个思想，就像注射器一样将一个类的实例注入到另一个类的实例中去，需要用什么就注入什么。当然"依赖倒置原则"也始终贯彻在里面。"注入"不仅可以通过构造函数注入，也可以通过属性注入，上面你可以可以通过一个"setter"来动态为"mailObj"这个属性赋值。

上面看了很多，但是有心的读者可能会发现标题中"从此不再考虑加载顺序"这个字眼，你上面的不还是要考虑加载顺序吗? 不还是先得引入信息发送类，然后在引入注册类，然后再实例化吗？如果类一多，不照样晕！

确实如此，现实中有许多这样的案例，一开始类就那么多，慢慢的功能越来越多，人员越来越多，编写了很多类，要使用这个类必须先引入那个类，而且一定要确保顺序正确。有这么个例子, "a 依赖于b, b 依赖于c, c 依赖于 d, d 依赖于e", 要获取'a'的实例，你必须依次引入 'e,d,c,b'然后依次进行实例化，老的员工知道这个坑，跳过去了。某天来了个新人，他想实例化'a' 可是一直报错，他都不造咋回事，此时只能看看看'a'的业务逻辑，然后知道要先获取'b'的实例，然后在看'b'的业务逻辑，然后... 一天过去了，他还是没有获取到'a'的实例，然后领导来了...

那这个事情到底是新人的技术低下，还是当时架构人员的水平低下了？

现在切入话题，来实现如何不考虑加载顺序，在实现前就要明白要是不考虑加载顺序就意味着让程序自动进行加载自动进行实例化。类要实例化，只要保证完整的传递给'__construct'函数所必须的参数就OK了，在类中如果要引用其他类，也必须在构造函数中注入，否则调用时仍然会发生错误。那么我们需要一个类，来保存类实例化所需要的参数，依赖的其他类或者对象以及各个类实例化后的引用

该类命名为盒子 'Container.class.php', 其内容如下：

/**
*    依赖注入类
*/
class Container{
    /**
    *@var array 存储各个类的定义  以类的名称为键
    */
    private $_definitions = array();

    /**
    *@var array 存储各个类实例化需要的参数 以类的名称为键
    */
    private $_params = array();

    /**
    *@var array 存储各个类实例化的引用
    */
    private $_reflections = array();

    /**
    * @var array 各个类依赖的类
    */
    private $_dependencies = array();

    /**
    * 设置依赖
    * @param string $class 类、方法 名称
    * @param mixed $defination 类、方法的定义
    * @param array $params 类、方法初始化需要的参数
    */
    public function set($class, $defination = array(), $params = array())
    {
        $this->_params[$class] = $params;
        $this->_definitions[$class] = $this->initDefinition($class, $defination);
    }

    /**
    * 获取实例
    * @param string $class 类、方法 名称
    * @param array $params 实例化需要的参数
    * @param array $properties 为实例配置的属性
    * @return mixed
    */
    public function get($class, $params = array(), $properties = array())
    {
        if(!isset($this->_definitions[$class]))
        {//如果重来没有声明过 则直接创建
            return $this->bulid($class, $params, $properties);
        }

        $defination = $this->_definitions[$class];

        if(is_callable($defination, true))
        {//如果声明是函数
            $params = $this->parseDependencies($this->mergeParams($class, $params));
            $obj = call_user_func($defination, $this, $params, $properties);
        }
        elseif(is_array($defination))
        {
            $originalClass = $defination['class'];
            unset($definition['class']);

            //difinition中除了'class'元素外 其他的都当做实例的属性处理
            $properties = array_merge((array)$definition, $properties);

            //合并该类、函数声明时的参数
            $params = $this->mergeParams($class, $params);
            if($originalClass === $class)
            {//如果声明中的class的名称和关键字的名称相同 则直接生成对象
                $obj = $this->bulid($class, $params, $properties);
            }
            else
            {//如果不同则有可能为别名 则从容器中获取
                $obj = $this->get($originalClass, $params, $properties);
            }
        }
        elseif(is_object($defination))
        {//如果是个对象 直接返回
            return $defination;
        }
        else
        {
            throw new Exception($class . ' 声明错误!');
        }
        return $obj;
    }

    /**
    * 合并参数
    * @param string $class 类、函数 名称
    * @param array $params 参数
    * @return array
    */
    protected function mergeParams($class, $params = array())
    {
        if(empty($this->_params[$class]))
        {
            return $params;
        }
        if(empty($params))
        {
            return $this->_params;
        }

        $result = $this->_params[$class];
        foreach($params as $key => $value) 
        {
            $result[$key] = $value;
        }
        return $result;
    }

    /**
    * 初始化声明
    * @param string $class 类、函数 名称
    * @param array $defination 类、函数的定义
    * @return mixed
    */
    protected function initDefinition($class, $defination)
    {
        if(empty($defination))
        {
            return array('class' => $class);
        }
        if(is_string($defination))
        {
            return array('class' => $defination);
        }
        if(is_callable($defination) || is_object($defination))
        {
            return $defination;
        }
        if(is_array($defination))
        {
            if(!isset($defination['class']))
            {
                $definition['class'] = $class;
            }
            return $defination;
        }
        throw new Exception($class. ' 声明错误');
    }

    /**
    * 创建类实例、函数
    * @param string $class 类、函数 名称
    * @param array $params 初始化时的参数
    * @param array $properties 属性
    * @return mixed
    */
    protected function bulid($class, $params, $properties)
    {
        list($reflection, $dependencies) = $this->getDependencies($class);

        foreach ((array)$params as $index => $param) 
        {//依赖不仅有对象的依赖 还有普通参数的依赖
            $dependencies[$index] = $param;
        }

        $dependencies = $this->parseDependencies($dependencies, $reflection);

        $obj = $reflection->newInstanceArgs($dependencies);

        if(empty($properties))
        {
            return $obj;
        }

        foreach ((array)$properties as $name => $value) 
        {
            $obj->$name = $value;
        }

        return $obj;
    }

    /**
    * 获取依赖
    * @param string $class 类、函数 名称
    * @return array
    */
    protected function getDependencies($class)
    {
        if(isset($this->_reflections[$class]))
        {//如果已经实例化过 直接从缓存中获取
            return array($this->_reflections[$class], $this->_dependencies[$class]);
        }

        $dependencies = array();
        $ref = new ReflectionClass($class);//获取对象的实例
        $constructor = $ref->getConstructor();//获取对象的构造方法
        if($constructor !== null)
        {//如果构造方法有参数
            foreach($constructor->getParameters() as $param) 
            {//获取构造方法的参数
                if($param->isDefaultValueAvailable())
                {//如果是默认 直接取默认值
                    $dependencies[] = $param->getDefaultValue();
                }
                else
                {//将构造函数中的参数实例化
                    $temp = $param->getClass();
                    $temp = ($temp === null ? null : $temp->getName());
                    $temp = Instance::getInstance($temp);//这里使用Instance 类标示需要实例化 并且存储类的名字
                    $dependencies[] = $temp;
                }
            }
        }
        $this->_reflections[$class] = $ref;
        $this->_dependencies[$class] = $dependencies;
        return array($ref, $dependencies);
    }

    /**
    * 解析依赖
    * @param array $dependencies 依赖数组
    * @param array $reflection 实例
    * @return array $dependencies
    */
    protected function parseDependencies($dependencies, $reflection = null)
    {
        foreach ((array)$dependencies as $index => $dependency) 
        {
            if($dependency instanceof Instance)
            {
                if ($dependency->id !== null) 
                {
                    $dependencies[$index] = $this->get($dependency->id);
                } 
                elseif($reflection !== null) 
                {
                    $parameters = $reflection->getConstructor()->getParameters();
                    $name = $parameters[$index]->getName();
                    $class = $reflection->getName();
                    throw new Exception('实例化类 ' . $class . ' 时缺少必要参数:' . $name);
                }   
            }
        }
        return $dependencies;
    }
}

下面是'Instance'类的内容，该类主要用于记录类的名称，标示是否需要获取实例

class Instance{
    /**
     * @var 类唯一标示
     */
    public $id;

    /**
     * 构造函数
     * @param string $id 类唯一ID
     * @return void
     */
    public function __construct($id)
    {
        $this->id = $id;
    }

    /**
     * 获取类的实例
     * @param string $id 类唯一ID
     * @return Object Instance
     */
    public static function getInstance($id)
    {
        return new self($id);
    }
}

然后我们在'Container.class.php'中还是实现了为类的实例动态添加属性的功能，若要动态添加属性，需使用魔术方法'__set'来实现，因此所有使用依赖加载的类需要实现该方法，那么我们先定义一个基础类 'Base.class.php',内容如下

class Base{
    /**
    * 魔术方法
    * @param string $name
    * @param string $value
    * @return void
    */
    public function __set($name, $value)
    {
        $this->{$name} = $value;
    }
}

然后我们来实现'A,B,C'类，A类的实例依赖于 B类的实例，B类的实例依赖于C类的实例

'A.class.php'

class A extends Base{
    private $instanceB;

    public function __construct(B $instanceB)
    {
        $this->instanceB = $instanceB;
    }

    public function test()
    {
        $this->instanceB->test();
    }
}

'B.class.php'

class B  extends Base{
    private $instanceC;

    public function __construct(C $instanceC)
    {
        $this->instanceC = $instanceC;
    }

    public function test()
    {
        return $this->instanceC->test();
    }
}

'C.class.php'

class C  extends Base{
    public function test()
    {
        echo 'this is C!';
    }
}de

然后我们在'index.php'中获取'A'的实例，要实现自动加载，需要使用SPL类库的'spl_autoload_register'方法，代码如下

function autoload($className)
{
    include_once $className . '.class.php';
}
spl_autoload_register('autoload', true, true);
$container = new Container;

$a = $container->get('A');
$a->test();//

输出 'this is C!'

上面的例子看起来是不是很爽，根本都不需要考虑'B','C' (当然，这里B，C 除了要使用相应类的实例外，没有其他参数，如果有其他参数，必须显要调用'$container->set(xx)'方法进行注册，为其制定实例化必要的参数)。有细心同学可能会思考，比如我在先获取了'A'的实例，我在另外一个地方也要获取'A'的实例，但是这个地方'A'的实例需要其中某个属性不一样，我怎么做到？

你可以看到'Container' 类的 'get' 方法有其他两个参数，'$params' 和 '$properties' ，这个'$properties' 即可实现刚刚的需求，这都依赖'__set'魔术方法，当然这里你不仅可以注册类，也可以注册方法或者对象，只是注册方法时要使用回调函数，例如

$container->set('foo', function($container, $params, $config){
    print_r($params);
    print_r($config);
});

$container->get('foo', array('name' => 'foo'), array('key' => 'test'));

还可以注册一个对象的实例，例如

class Test
{
    public function mytest()
    {
        echo 'this is a test';
    }
}

$container->set('testObj', new Test());

$test = $container->get('testObj');
$test->mytest();

以上自动加载，依赖控制的大体思想就是将类所要引用的实例通过构造函数注入到其内部，在获取类的实例的时候通过PHP内建的反射解析构造函数的参数对所需要的类进行加载，然后进行实例化，并进行缓存以便在下次获取时直接从内存取得

以上代码仅仅用于学习和实验，未经严格测试，请不要用于生产环境，以免产生未知bug

鄙人才疏学浅，有不足之处，欢迎补足！

http://www.bkjia.com/PHPjc/1092697.htmlwww.bkjia.comtruehttp://www.bkjia.com/PHPjc/1092697.htmlTechArticlePHP 依赖注入，从此不再考虑加载顺序，从此不再加载说这个话题之前先讲一个比较高端的思想--' 依赖倒置原则 ' "依赖倒置是一种软件设计...

内容总结

以上是互联网集市为您收集整理的PHP依赖注入，从此不再考虑加载顺序，从此不再加载_PHP教程全部内容，希望文章能够帮你解决PHP依赖注入，从此不再考虑加载顺序，从此不再加载_PHP教程所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/189558.html

来源：【匿名】

【上一篇】PHP系列：PHPWeb开发基础，phpweb_PHP教程【下一篇】PHP 5 数据对象 (PDO) 抽象层与 Oracle

更多 ►

【PHP依赖注入，从此不再考虑加载顺序，从此不再加载_PHP教程】教程文章相关的互联网学习教程文章

[PHP] 理解依赖注入【代码】

两个类有依赖关系的时候使用者通过构造函数参数，方法或属性等方式将具体组件，传给自己$storage=new Storge(); //构造函数注入class User{publicfunction __construct($storage){$this->storage = $storage;}}//方法注入class User{publicfunction setSessionStorage($storage){$this->storage = $storage;}}//属性注入class User{public$sessionStorage;}$user->sessionStorage = $storage;通过构造函数注入适用于必要的依赖，如...

PHP 依赖注入(DI) 和控制反转(IoC)【代码】

要想理解 PHP 依赖注入和控制反转两个概念，就必须搞清楚如下的两个问题：DI —— Dependency Injection 依赖注入IoC —— Inversion of Control 控制反转什么是依赖注入没有你我就活不下去，那么，你就是我的依赖。说白了就是：不是我自身的，却是我需要的，都是我所依赖的。一切需要外部提供的，都是需要进行依赖注入的。依赖注入举例class Boy {protected $girl;public function __construct(Girl $girl) {$this->girl = $g...

谈谈php里的IOC控制反转，DI依赖注入（转）

转自：http://www.cnblogs.com/qq120848369/p/6129483.html发现问题在深入细节之前，需要确保我们理解"IOC控制反转"和"DI依赖注入"是什么，能够解决什么问题，这些在维基百科中有非常清晰的说明。控制反转（Inversion of Control，缩写为IoC）：是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。依赖注入（Dependency Injection，简称DI）：DI是IOC的一种实现，表现为：在类A的实例创建过程中即创建了依赖的B...

PHP依赖注入容器【pimple】【代码】

安装使用定义服务定义服务工厂定义变量保护变量修改已定义的服务扩展容器获取服务创建方法EasyWechat容器模式分析获取容器Factory做了什么？Application做了什么？ServiceContainer做了什么？Container的register做了什么？Provider到底做了什么？调用时才实例化服务类TOChttps://pimple.symfony.com/安装通过composer：$ ./composer.phar require pimple/pimple ~3.0或者通过PHP的C扩展：$ git clone https://github.com/silexphp...

PHP经典设计模式之依赖注入定义与用法详解

本文实例讲述了PHP经典设计模式之依赖注入定义与用法。分享给大家供大家参考，具体如下：依赖注入的实质就是把一个类不可能更换的部分和可更换的部分分离开来，通过注入的方式来使用，从而达到解耦的目的。一个数据库连接类： class Mysql{private $host;private $prot;private $username;private $password;private $db_name;// 构造方法public function __construct(){$this->host = 127.0.0.1;$this->port = 22;$this->userna...

php设计模式-依赖注入的使用详解

前言终于要讲到这个著名的设计原则，其实它比其他设计模式都简单。依赖注入的实质就是把一个类不可能更换的部分和可更换的部分分离开来，通过注入的方式来使用，从而达到解耦的目的。这里就举个数据库链接的栗子，希望大家理解一个数据库连接类class Mysql{private $host;private $port;private $username;private $password;private $db_name;public function construct(){$this->host = 127.0.0.1;$this->port = 22;$this-...

php – 你能使用依赖注入并仍然避免许多私有变量吗？【代码】

我一直在阅读/观看很多推荐的材料,最近一次是这个 – MVC for advanced PHP developers.有一件事是Singletons很糟糕,他们在类之间创建依赖关系,而依赖注入很好,因为它允许单元测试和解耦. 在我编写程序之前,这一切都很好.我们以电子商店的产品页面为例.首先我有我的页面：class Page {public $html;public function __construct() {} public function createPage() {// do something to generate the page} public function showP...

控制反转原则，它和依赖注入有什么联系【代码】

控制反转(IOC)首先，我们来看一个例子。class Person {private $name = ;private $age = 0;public function __construct(string $name, int $age){$this->name = $name;$this->age = $age;}public function eat (){echo 吃东西 . PHP_EOL;}public function drink (){echo 喝水 . PHP_EOL;}public function sleep (){echo 睡觉 . PHP_EOL;}public function wakeup (){echo 起床 . PHP_EOL;}public function drive (){echo 开车 . PH...

深入理解依赖注入是如何实现解耦【代码】【图】

第一章：小明和他的手机从前有个人叫小明小明有三大爱好，抽烟，喝酒…… 咳咳，不好意思，走错片场了。应该是逛知乎、玩王者农药和抢微信红包小明的三大爱好我们用一段简单的伪代码，来制造一个这样的小明class Ming extends Person {private $_name;private $_age;function read(){//逛知乎}function play(){//玩农药}function grab(){//抢红包} }但是，小明作为一个人类，没有办法仅靠自己就能实现以上的功能，他必须依赖一部...

通俗易懂理解PHP依赖注入容器【代码】【图】

依赖注入容器理解耦合一个好的代码结构设计一定是松耦合的，这也是很多通用设计模式的宗旨，就是把分散在各处的同一个功能的代码汇聚到一起，形成一个模块，然后在不同模块之间通过一些细小的、明确的渠道进行沟通。在实践中，不同功能和模块之间的互相依赖是不可避免的，而如何处理好这些依赖之间的关系则是代码结构能否变得美好的关键。<?php class User {public function register($user){// 注册操作...// 发送确认邮件$notify...

PHP中的服务容器与依赖注入的思想【代码】

依赖注入当A类需要依赖于B类，也就是说需要在A类中实例化B类的对象来使用时候，如果B类中的功能发生改变，也会导致A类中使用B类的地方也要跟着修改，导致A类与B类高耦合。这个时候解决方式是，A类应该去依赖B类的接口，把具体的类的实例化交给外部。就拿我们业务中常用的通知模块来说。<?php /*** 定义了一个消息类* Class Message */ class Message{public function seed(){return seed email;} } /** 订单产生的时候需要发送消...

关于PHP中依赖注入的详细介绍【代码】【图】

依赖注入原理：依赖注入是一种允许我们从硬编码的依赖中解耦出来，从而在运行时或者编译时能够修改的软件设计模式。简而言之就是可以让我们在类的方法中更加方便的调用与之关联的类。实例讲解：假设有一个这样的类：class Test {public function index(Demo $demo,Apple $apple){$demo->show();$apple->fun();} }如果想使用index方法我们需要这样做：$demo = new Demo(); $apple = new Apple(); $obj = new Test(); $obj->index($d...

首页 / PHP / PHP依赖注入，从此不再考虑加载顺序，从此不再加载_PHP教程

PHP依赖注入，从此不再考虑加载顺序，从此不再加载_PHP教程

内容导读

内容图文

PHP 依赖注入，从此不再考虑加载顺序，从此不再加载

内容总结

内容备注

内容手机端

【PHP依赖注入，从此不再考虑加载顺序，从此不再加载_PHP教程】教程文章相关的互联网学习教程文章

[PHP] 理解依赖注入【代码】

PHP 依赖注入(DI) 和控制反转(IoC)【代码】

谈谈php里的IOC控制反转，DI依赖注入（转）

PHP依赖注入容器【pimple】【代码】

PHP经典设计模式之依赖注入定义与用法详解

php设计模式-依赖注入的使用详解

php – 你能使用依赖注入并仍然避免许多私有变量吗？【代码】

控制反转原则，它和依赖注入有什么联系【代码】

深入理解依赖注入是如何实现解耦【代码】【图】

通俗易懂理解PHP依赖注入容器【代码】【图】

PHP中的服务容器与依赖注入的思想【代码】

关于PHP中依赖注入的详细介绍【代码】【图】

关于PHP中依赖注入的详细介绍【代码】【图】

PHP中的服务容器与依赖注入的思想【代码】

php依赖注入的原理【图】

PHP - 相关标签

加载 - 相关标签

PHP - 技术教程分类

PHP - 最新教程

PHP - 最热教程