php的控制反转和依赖注入

1.判断代码的好处就是高内聚低耦合
高内聚就是软件模块是由相关性很强的代码组成，只负责一项任务，也就是常说的单一责任原则。
低耦合就是每个模块之间耦合度要低，如果要修改，修改一点点就可以而不是修改一大部分。
而在代码中体现出来的设计模式就是依赖注入和控制反转
2.依赖注入：
就是A类所依赖的B类C类等以属性或者构造函数等方式注入A类而不是直接在A类中实例化。
例如：

class A
{
    public $b;
    public $c;
    public function __construct()
    {
        //TODO
    }
    public function method()
    {
        $this->b=new B();
        $this->c=new C();
         
        $this->b->method();
        $this->c->method();
         
        //TODO
    }
}
 
class B
{
    public function __construct()
    {
        //TODO
    }
    public function method()
    {
        //TODO
        echo 'b';
    }
}
 
class C
{
    public function __construct()
    {
        //TODO
    }
    public function method()
    {
        //TODO
        echo 'c';
    }
}
 
$a=new A();
$a->method();

上面中A类中依赖了B和C类，如果后期开发中涉及函数改名，就会牵动到a类的整个都需要修改。有没有方法真的修改了B和C类，尽量也不要去改动A呢？这里要用到控制反转，就是现在是b和c控制着a,我们要反转过来，a这边可以主动控制，不管b和c改成什么。控制反转(IOC)是一种思想，依赖注入(ID)是实施这种思想的方法。
第一种方法：构造器注入(不推荐使用，但比不用好)

class A{
     public $b;
     public $c;
     public function __construct($b,$c){
          $this->b=$b;
          $this-<c=$c;
     }
     public function method(){
         $this->b->method();
         $this->c->method();
     }
}
这样调用
$a = new A(new B(),new C());
$a->method();

第二种方法：工厂模式注入

class Factory
{
    public function Factory()
    {
        //TODO
    }
    public function create($s)
    {
        switch($s)
        {
            case 'B':
            {
                return new B();
                break;
            }
            case 'C':
            {
                return new C();
                break;
            }
            default:
            {
                return null;
                break;
            }
        }
    }
}

然后把A类改成这样

class A
{
    public $b;
    public $c;
    public function __construct()
    {
        //TODO
    }
    public function method()
    {
        $f=new Factory();
        $this->b=$f->create('B');
        $this->c=$f->create('C');
         
        $this->b->method();
        $this->c->method();
         
        //TODO
    }
}

这样至少如果B和C类的构造函数发生变化，比如修改参数时，只需要修改Factory类就可以了。
把B类和C类的方法再抽象出来，做一个接口.
这样，A类中的b变量和c变量就不再是一个具体的变量了，而是一个抽象类型的变量，不到运行那一刻，不知道他们的Method方式是怎么实现的。

interface IMethod
{
    public function method();
}

class B implements IMethod
{
    public function __construct()
    {
        //TODO
    }
    public function method()
    {
        //TODO
        echo 'b';
    }
}
 
class C implements IMethod
{
    public function __construct()
    {
        //TODO
    }
    public function method()
    {
        //TODO
        echo 'c';
    }
}

总结：
1.我们把A类中的B类对象和C类对象的创建移至A类外
2.原本A类依赖B类和C类，现在变成了A依赖Factory，Factory依赖B和C。