控制权倒置是项目责任转移的一个指标。

当依赖项被授予直接作用于调用者空间的能力时，每次都会发生控制反转。

最小的IoC是通过引用传递变量，让我们先看看非IoC代码：

function isVarHello($var) {
    return ($var === "Hello");
}

// Responsibility is within the caller
$word = "Hello";
if (isVarHello($word)) {
    $word = "World";
}

现在，让我们通过将结果的责任从调用者转移到依赖项来反转控制：

function changeHelloToWorld(&$var) {
    // Responsibility has been shifted to the dependency
    if ($var === "Hello") {
        $var = "World";
    }
}

$word = "Hello";
changeHelloToWorld($word);

下面是另一个使用OOP的示例：

<?php

class Human {
    private $hp = 0.5;

    function consume(Eatable $chunk) {
        // $this->chew($chunk);
        $chunk->unfoldEffectOn($this);
    }

    function incrementHealth() {
        $this->hp++;
    }
    function isHealthy() {}
    function getHungry() {}
    // ...
}

interface Eatable {
    public function unfoldEffectOn($body);
}

class Medicine implements Eatable {
    function unfoldEffectOn($human) {
        // The dependency is now in charge of the human.
        $human->incrementHealth();
        $this->depleted = true;
    }
}

$human = new Human();
$medicine = new Medicine();
if (!$human->isHealthy()) {
    $human->consume($medicine);   
}

var_dump($medicine);
var_dump($human);

*)免责声明：现实世界中的人类使用消息队列。

在使用“控制反转”之前，你应该充分了解它的优点和缺点，如果你这样做，你应该知道为什么要使用它。

赞成的意见：

您的代码被解耦，因此您可以轻松地将接口的实现与其他实现交换它是针对接口而非实现进行编码的强大动力为代码编写单元测试是非常容易的，因为它只依赖于它在构造函数/setter中接受的对象，并且可以很容易地用正确的对象单独初始化它们。

欺骗：

IoC不仅会反转程序中的控制流，还会使其变得相当模糊。这意味着你不能再只读取代码并从一个地方跳到另一个地方，因为代码中通常存在的连接不再存在。相反，它在XML配置文件或注释中以及IoC容器的代码中解释这些元数据。出现了一类新的错误，即您的XML配置或注释错误，您可以花费大量时间来找出IoC容器在特定条件下向其中一个对象注入空引用的原因。

就我个人而言，我看到了IoC的优点，我非常喜欢它们，但我倾向于尽可能避免使用IoC，因为它将您的软件变成一个类的集合，这些类不再构成“真正的”程序，而只是需要通过XML配置或注释元数据组合在一起的东西，如果没有IoC，它就会崩溃。

这是怎么一回事？反转（耦合）控制，更改方法签名的耦合方向。对于反向控制，方法签名的定义由方法实现（而不是方法的调用方）决定。此处完整解释

它解决了哪个问题？方法上的自顶向下耦合。这随后消除了重构的需要。

什么时候使用合适，什么时候不合适？对于定义良好的小型应用程序，如果没有太大的变化，可能会产生开销。然而，对于将要发展的定义较少的应用程序，它减少了方法签名的固有耦合。这使开发人员可以更自由地开发应用程序，避免了对代码进行昂贵的重构。基本上，允许应用程序在很少返工的情况下发展。

为了理解这个概念，控制反转（IoC）或依赖反转原理（DIP）涉及两个活动：抽象和反转。依赖注入（DI）只是为数不多的反转方法之一。

要了解更多信息，您可以在此处阅读我的博客

这是怎么一回事？

这是一种让实际行为来自边界之外的实践（面向对象编程中的类）。边界实体只知道它的抽象（例如面向对象编程中的接口、抽象类、委托）。

它解决了什么问题？

在编程方面，IoC试图通过使单片代码模块化、解耦其各个部分并使其可单元测试来解决单片代码。

什么时候合适，什么时候不合适？

这在大多数情况下都是合适的，除非您有只需要单片代码的情况（例如非常简单的程序）

为了理解IoC，我们应该讨论依赖反转。

依赖反转：依赖于抽象，而不是具体。

控制反转：主与抽象，以及主如何成为系统的粘合剂。

我写了一些很好的例子，你可以在这里查看：

https://coderstower.com/2019/03/26/dependency-inversion-why-you-shouldnt-avoid-it/

https://coderstower.com/2019/04/02/main-and-abstraction-the-decoupled-peers/

https://coderstower.com/2019/04/09/inversion-of-control-putting-all-together/

控制反转是一个通用原则，而依赖注入将这一原则实现为对象图构造的设计模式（即配置控制对象如何相互引用，而不是对象本身控制如何获取对另一个对象的引用）。

将控制反转视为一种设计模式，我们需要看看我们正在反转什么。依赖注入反转了对构建对象图的控制。如果用外行的术语来说，控制反转意味着程序中控制流的改变。例如，在传统的独立应用程序中，我们有一个主要的方法，从那里控制权被传递给其他第三方库（在这种情况下，我们使用了第三方的库的功能），但通过控制反转，控制权从第三方程序库代码转移到我们的代码，因为我们正在使用第三方代码库的服务。但在程序中还有其他方面需要反转，例如调用方法和线程来执行代码。

对于那些对控制反转感兴趣的人来说，已经发表了一篇论文，概述了控制反转作为一种设计模式的更完整的图景（OfficeFloor:使用办公模式来改进软件设计http://doi.acm.org/10.1145/2739011.2739013免费下载http://www.officefloor.net/about.html).

确定的关系如下：

控制反转（用于方法）=依赖（状态）注入+连续注入+线程注入

可用控制反转的上述关系汇总http://dzone.com/articles/inversion-of-coupling-control