1. 控制反转
 
 
 
手册地址：https://www.cnblogs.com/xdp-gacl/p/4249939.html
 
 
1.1. Ioc(容器)是什么
 
 
 
Ioc - Inversion of Control 即 “控制反转” ，它不是什么技术，而是一种设计思想。Ioc意味着将你设计好额对象放再一个叫容器控制里面（也就是你所封装好的对象方法常用的放在一个容器里面，容器里面可以做好关联，以便后面方便使用）而不是传统的在你的对象内部直接使用控制，如果理解好Ioc呢，理解好Ioc的关键是要明确 “谁控制谁，控制什么，为何是反转(有反转就有正转）”，哪些方面反转，那么我们来深入了解以下。
 
 
谁控制谁，控制什么
 
 
 
传统程序设计模式，我们是直接在对象内部通过 new 进行创建对象，是程序主动去创建依赖对象（也就是传统在操作对象的时候，逻辑里面需要用到什么，就去new什么，如果一个对象里面还需要用到其他对象，而要在当前对象里面在new其他对象来调用），而Ioc是由专门一个容器来创建这些对象，即由容器来控制对象创建。谁控制谁，当然是Ioc控制了对象，控制什么?拿就是主要控制了外部资源获取。
 
 
 
 
为何是反转，哪些反面反转了，有反转就是有正转，产痛应用程序时由我们自己在对象中主动控制去直接获取依赖对象，也就是正转：而反转则时由容器来帮忙创建及注入依赖对象，为何是反转？因为容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转
 
 
Ioc能做什么？
 
 
 
IOc不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出耦合、更优良的程序，传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试，有了Ioc容器后，把创建和查找依赖对象的控制权交给了容器（举个栗子：有个订单操作类，在订单操作类里面需要用到订单通知类、订单日志类等，而在订单操作类里面还需要引入通知以及日志两个类，这样很难后期维护，有了容器，可以将订单的通知类以及订单的日志类全部放在一个容器里面把他们关联起来，需要用到的时候自己从容器里面拿出来即可）,由容器进行注入组合对象，所以对象与对象之间是松散耦合，这样方便测试，利于功能服用，更重要的是是的程序的整个体系结构变的非常灵活
 
 
依赖注入：
 
 
 
DI - Dependency Injection 即 “依赖注入”：组件之间依赖关系，由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中（上面的订单日志类以及订单的通知类，如果订单通知类里面需要用到订单的日志类，我们可以把通知类注入到订单日志类里面也就是关联一起），依赖注入的目的并非为软件系统带来更多的功能，而是为了替身组件重要的频率，作为系统搭建一个灵活、可扩张性的平台，通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就指定目标需要的资源，完成自身的业务逻辑，而不是关心具体的资源来自何处，由谁实现
 
 
 
 
理解DI的关键是“谁依赖谁，为什么需要注入，注入了什么”，那我们来深入分析一下
 
 
 
 
谁依赖谁：当时是应用程序依赖于Ioc容器（也就是说，每次需要用到的操作，必须依赖从容器里面拿出来）
为什么需要依赖：应用程序需要Ioc容器来提供对象需要的外部资源
谁注入谁：很明显是Ioc容器注入了应用程序的某个对象，应用程序依赖的对象
 注入了什么：就是注入某个对象所需要的外部资源：
 
 
“依赖注入”：明确描述了“被注入对象依赖ioc容器配置依赖对象”
 “依赖注入”：其实就是把相关的操作类，设计到的逻辑，全部注入到一起，注入到一个容器里面方便使用
 
传统模式，控制正转，栗子：
 
<?php

// 传统模式，控制正转
class A1
{
    // 用来存储对象
    protected $b1;

    public function __construct()
    {
        $this->b1 = new B1();
    }

    public function getB()
    {
        return $this->b1;
    }
}

class B1
{
    public function __construct()
    {

    }

    public function method()
    {
        echo '我是B类方法';
    }
}

$a =  (new A1())->getB()->method();
var_dump($a);
 
 
 
上面的代码：很容易理解为就是，A依赖了B
 也就是说，如果今后开发中，要对B类修改，一旦方法名或则函数参数都变动了，甚至整个类发生了变化，我们也要对A类相应的修改，否则A类就会对B类丧失了功能。也就是“牵一发动全身”。、
 解决这个问题：需要用到控制反转
 
 
控制反转例子：
 
例子如下：
 
<?php

class A
{
    // 接受容器的对象
    protected $ioc;

    public function __construct(Ioc $ioc)
    {
        // 将容器存储起来，方便使用容器里面的其他方法
        $this->ioc = $ioc;
    }

    // 例如需要在A类里面使用到B类的方法
    // 这一步就是注入相关的B类
    public function getB()
    {
        return $this->ioc->make('B');
    }

}

class Ioc
{
    // 存储注入的对象
    protected $instance = [];

    public function __construct()
    {
        // 将B类注入到Ioc容器中并存储到注入对象数组中
        // 传入$this 是方便与A类里面可以使用到B类里面的方法逻辑，依赖注入关系
        // 其实这一步的类名不应该是写死的，需要另外一中工厂模式来动态修改
        $this->instance['B'] = new B($this);
        $this->instance['A'] = new A($this);
    }

    // 要使用的时候，必须先创建，创建你想用到的对象
    // 这里面其实还需要检测是否需要依赖注入关系
    public function make($class_name)
    {
        return $this->instance[$class_name];
    }


}


class B
{
    protected $ioc;
    public function __construct(Ioc $ioc)
    {
        // 将Ioc容器存储起来，方便可以使用到容器里面的其他方法
        $this->ioc = $ioc;
    }

    // 在B类里面使用到A类的方法
    public function getA()
    {
        return $this->ioc->make('A');
    }
}

// 第一步：先创建容器
// 容器里面已经注入了两个类，一个是B类一个是A类
$obj = new Ioc();
// 想用A类
$a = $obj->make('A');

// 使用A类里面调用B类的方法
// 例如需求上在A类需要用到B类的操作逻辑，所以在A类里面也注入了B类对象,这样就方便使用
var_dump($a->getB());

首先从概念上来说，依赖注入是控制反转的一种具体实现。
 
而从PHP面向对象的角度来说，控制反转是想解决，A类依赖于B类，而在一般情况下A 类想要使用B类的方法，需要先New 一个B类。所以对于B类的控制权在于A类手中。
 
但是这样的坏处就是，假如B 类又依赖于C 类，这样下去，就会很麻烦，因为互相依赖太多。
 
而控制反转就可以  使用一个    另外的类，假如说是IOC类，这个类专门用来生成各种对象，然后将这些生成的对象以参数传递的方式放入所需要的类。
 
 
 
而IOC 类的具体实现 在laravel中使用的是 PHP 反射机制，就可以拿到PHP的构造方法或者什么方法 传递过来的所需要的类。
 
把这些类在进行实例化，如果这个类还依赖于其他类，那么递归调用。
 
 
 
总结一下：
 
1.依赖注入是控制反转的一种具体实现。
 
2.laravel中的依赖注入 是利用 PHP的反射机制， 加上递归进行处理的。
 
先简单记录下。。。供参考。

1、控制反转(IoC): 不需要自己内容修改，改成由外部传递。从依赖内部改为依赖外部。
2、依赖注入(DI)：不是由自己内部new对象或者实例，而是通过构造函数或方法传入调用其他类的都属于依赖注入 。
 
 
 
 
 
                   原始代码
 
 
 
 
           
 
                      控制反转和依赖注入
 
左边的问题：假设现在想用数据库记录日志的话，我们就得修改User类，这份代码没达到解耦合，也不符合编程开放封闭原则。
 解决：右边的控制反转和依赖注入。其中，$user = new User(new DatabaseLog());是Contracts契约(面向接口编程) 
 
控制反转(IOC)、依赖注入(DI)、依赖反转(DIP)的三者的区别联系？
 
1、控制反转(IOC)：Inversion Of Control，'控制'是对程序执行流程的控制，'反转'是没使用框架前，程序员自己控制整个程序执行，使用框架后，控制权从程序员反转到了框架。
 
2、依赖注入(DI)：Dependency Injection，与IOC相反，一种具体的编码技巧，可简记为：
不通过new()方式在类内部创建依赖类对象，而是将依赖类对象在外部创建好，通过构造函数或函数参数等注入给类使用。即：一个组件内部依赖一个对象，但他不自己造，等别人送上来。
 ---依赖注入框架：通过依赖注入框架提供的扩展点，简单配置下所有需要的类及类与类之间依赖关系，就可实现由框架来自动创建对象，管理对象的生命周期、依赖注入等原本需要程序员来做的事情。
 
3、依赖反转(DIP)原则：Dependency Inversion，高层模块不要依赖低层模块(调用者属于高层，被调用者属于低层)，之间应该通过抽象来相互依赖。抽象不该依赖实现细节，实现细节依赖抽象。
 
综合：控制反转是编程思想，把控制权交给第三方；依赖注入是实现控制反转最典型的方法，底层实现要符合“里氏替换”原则，子类的可替换，使得父类模块依赖于抽象的高层模块，实现程序的可扩展性。
 依赖注入采用“基于接口而非实现编程”，即：一个组件内部依赖一个对象，但他不自己造，等别人送上来。
 
基于接口而非实现编程 与 依赖注入 的联系与区别？
 
联系：都是从外部传入依赖对象，而不是在内部new一个出来
 区别：前者强调接口，强调依赖的对象是接口，而不是具体的实现类；后者是类和接口都可以，只要是从外部传入，而不是内部new出来的。
 
 
 
 
 

3、反射:
 
$reflector = new reflectionClass(User::class);//获取User的reflectionClass对象
$constructor = $reflector->getConstructor();//拿到User的构造函数
$dependencies = $constructor->getParameters();//拿到User的构造函数的所有依赖参数
$user = $reflector->newInstance();//创建user对象
$user = $reflector->newInstanceArgs($dependencies = []);//创建user对象，需要传递参数的
 
反射的使用：类的实例化由make来创建
 

4、容器：把各种类的创建放在一个闭包中，闭包的好处是使用时再创建(懒加载的思想)。包含两部分：bind + make
 使用容器的好处：假如我们项目里有很多功能用到了这个login功能，我们则在这几个页面反复写。突然我们有一天换需求了，觉得数据库记录日志不太好，想要改成文件的，那我们不是每个页面用到login功能的都去替换成new FileLog()呢？，那如何修改呢？
 

相关文档详见：控制反转+依赖注入+反射   容器+服务提供者
 相关源码详见：反射   容器
 
5、服务提供者(ServiceProvider)：服务提供者是食物，容器是篮子，服务提供者注册到容器，相当于把各种食物放进篮子里。
 使用场景：可以借助一个容器，提前把 log,user 都绑定到 Ioc 容器中。User 的创建交给这个容器去做。比如下面这样的，你再任何地方使用 login。都不需要关心是用什么记录日志了，哪怕后期需要修改只需要在 ioc 容器修改绑定其他记录方式日志就行了。
 
 
         入口处的服务提供者(Http\Kernel)
 
 
 
 
 
                             其它服务提供者(Http\Kernel)
 
 
 
6、外观模式/门面(Facades)：Facade核心实现原理就是在 UserFacade 提前注入 Ioc 容器。
 使用场景：需要$ioc->make('user')才能拿到User的实例，再去使用$user->login();那能不能更方便点，用这种方式：UserFacade::login(); 
 步骤：
（1）定义一个服务提供者的外观类，在该类定义一个类的变量，跟 ioc 容器绑定的 key 一样；
 （2）通过静态魔术方法__callStatic 可以得到当前想要调用的 login；
 （3）使用 static::$ioc->make('user');
 

从代码看，使用Facade更加麻烦了，还需要注入ioc容器，还得需要用魔术方法。其实laravel在框架运行的时候这些步骤都帮我们自动加好了，我们只需要使用UserFacade::login ();就可以了。使用 Facades 其实最主要的就是它提供了(1)简单，易记的语法，从而无需手动注入或配置长长的类名。此外，由于他们对PHP静态方法的独特调用，使得(2)测试起来非常容易。
 
 

Ioc （Inversion of Control） 控制反转模式 又称 （Depe-ndency Injection）依赖注入模式
 
控制反转是将组件的依赖关系从程序内部提到程序外部来管理，而依赖注入是指组件的依赖通过外部以参数或其它形式注入
 
下面我将以一个简单的例子来演示什么是 Ioc 控制反转
 
<?php

interface Visit
{
    public function go();
}

class Leg implements Visit       //行走接口
{
    public function go()
    {
        // TODO: Implement go() method.
        echo "walt to Tibet!!!";
    }
}

class Car implements Visit         //汽车接口
{
    public function go()
    {
        // TODO: Implement go() method.
        echo "drive car to Tibet!!!";
    }

}

class Train implements Visit        //火车接口
{
    public function go()
    {
        // TODO: Implement go() method.
        echo "go to Tibet by train";
    }
}


class Traveller                  // 旅行者类
{
    protected $trafficTool;

    public function __construct(Visit $trafficTool)
    {
        $this->trafficTool = $trafficTool;
    }

    public function visitTibet()
    {
        $this->trafficTool->go();
    }
}


$tra = new Traveller(new Car());

$tra->visitTibet();
 
Traveller 类的构造函数依赖了一个外部的具有visit接口的实例，而实例化Traveller时，我们传递了一个 $trafficTool 实例， 即通过依赖注入的方法解决依赖