依赖注入的原理

比眉伴天荒 2022-07-21 01:25 245阅读 0赞

### **什么是依赖注入** ###

依赖注入是实现程序解耦的一种方式。如果通过百度搜索可以找到如下答案：

*  控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题.控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。依赖注入应用比较广泛。

看完之后发现更晕了~~~

**看到一个比较形象的比喻和解释：**

(1)原始社会里，几乎没有社会分工。需要斧子的人(调用者)只能自己去磨一把斧子(被调用者)。对应的情形为:Java程序里的调用者自己创建被调用者。

(2)进入工业社会，工厂出现。斧子不再由普通人完成，而在工厂里被生产出来，此时需要斧子的人(调用者)找到工厂，购买斧子，无须关心斧子的制造过程。对应Java程序的简单工厂的设计模式。

(3)进入“按需分配”社会，需要斧子的人不需要找到工厂，坐在家里发出一个简单指令:需要斧子。斧子就自然出现在他面前。对应Spring的依赖注入。

第一种情况下，Java实例的调用者创建被调用的Java实例，必然要求被调用的Java类出现在调用者的代码里。无法实现二者之间的松耦合。

第二种情况下，调用者无须关心被调用者具体实现过程，只需要找到符合某种标准(接口)的实例，即可使用。此时调用的代码面向接口编程，可以让调用者和被调用者解耦，这也是工厂模式大量使用的原因。但调用者需要自己定位工厂，调用者与特定工厂耦合在一起。

第三种情况下，调用者无须自己定位工厂，程序运行到需要被调用者时，系统自动提供被调用者实例。

**个人理解：**在程序中，一个对象中的方法需要依赖另一个对象，该对象中保存其所依赖对象的实例，生成依赖对象的方式不再该对象中通过`new`创建，而是调用者外部创建依赖对象，通过一定的方式进行传入。

### **举个栗子** ###

public class Classes { 
    
        // 依赖类
        private Boy boy;
    
        public Classes(){
            // 在当前对象中直接 new 出依赖类
            boy = new Boy();
        }
    
        public void run(){
            boy.run();
        }
    
    }

public class Boy { 
    
        String name;
    
        public Boy(){
    
        }
    
        public void run(){
    
        }
    }

有一个班级，班级中有一个boy。直接在班级中`new`出boy。班级中有一个`run()`方法，其内部实际调用的是boy的`run()`。

此时看着无大碍，那么如果boy发生了变化，其构造方法发生了变化，需要传入一个姓名。那么需要修改代码：

public class Boy { 
    
        String name;
    
        public Boy(String name ){
            // 修改了构造方法
            this.name = name;
        }
    
        public void run(){
    
        }
    }

public class Classes { 
    
        // 依赖类
        private Boy boy;
    
    
        public Classes(){
            // 因为Boy的构造方法发生变化，所以需要修改该处代码
            boy = new Boy("lilei");
        }
    
    
    
        public void run(){
            boy.run();
        }
    
    }

修改了Boy的构造方法之后，因为Classes依赖Boy，所以其内部也需要修改。

如果又发生了变化，Boy的姓名更改了，又要修改`Classes`中的代码。。。这样的话，一个还是不明显，当工程量很浩大时，呵呵了。

此时，我们可以将Boy该对象的实例化交给其调用者，通过某种方式传入进来。这种模式就是**依赖注入**。

### **依赖注入的三种实现方式** ###

依赖注入常见的有三种方式：  
\- 构造方法注入。  
\- Setter方式注入。  
\- 接口注入。

#### **构造方法注入** ####

该方式是通过构造方法将其所依赖的外部类对象传入进来，是我认为的最简单的方式。其实现方式如下，我们修改之前的代码：

public class Classes { 
    
        // 依赖类
        private Boy boy;
    
    
        /** * 构造方法注入，通过构造方法传入该对象 * @param boy */
        public Classes(Boy boy) {
            this.boy = boy;
        }
    
    
        public void run() {
            boy.run();
        }
    
    }

#### **Setter 注入** ####

public class Classes { 
        //....
    
        private Boy boy;
    
        public void setBoy(Boy boy){
            this.boy = boy;
        }
    
        //....
    
    }

通过手动方式调用`set`方法将`Boy`设置进来。

#### **接口方式** ####

接口方式是定义一个接口，该接口中声明一个注入的方法，而需要注入的类实现该接口，实现接口中定义的方法。

/** * * 定义接口，声明注入方法 * Created by MH on 2016/7/12. */
    public interface BoyInjection { 
    
        void inject(Boy boy);
    }

public class Classes implements BoyInjection { 
        //....
    
        private Boy boy;
    
    
        @Override
        public void inject(Boy boy) {
            //实现接口中的方法
            this.boy = boy;
        }
    
        //....
    
    }

### **依赖注入总结** ###

如上的方式只不过是比较简单的方式，真正的使用中，往往涉及到效率，性能等很多的影响。此时，往往使用一些框架实现依赖注入。

`Dagger2`便是一个很好的依赖注入框架。本篇博客也是对`Dagger2`学习的一个铺垫。

> 依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念。具体含义是:当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，在 传统的程序设计过程中，通常由调用者来创建被调用者的实例。创建被调用者的工作不再由调用者来完成，因此称为控制反转;创建被调用者 实例的工作通常由框架（Dagger2 等）来完成，然后注入调用者，因此也称为依赖注入。