Dagger 2 系列（二） -- 基础篇：@Inject、@Component

• 该系列博客的最终目标： 搭建 MVP + Dagger2 框架
• 该系列博客包含如下几篇内容：

1. Dagger 2 系列（一） -- 前奏篇：依赖注入的基本介绍
2. Dagger 2 系列（二） -- 基础篇：@Inject、@Component
3. Dagger 2 系列（三） -- 基础篇：@Module 和@Provides
4. Dagger 2 系列（四） -- 基础篇：@Named 和 @Qualifier
5. Dagger 2 系列（五） -- 进阶篇：@Scope 和 @Singleton

在这篇文章中你会看到什么：

1. @Inject 是什么
2. @Component 是什么
3. @Inject和 @Component 如何协同做战。

1. 前提

在介绍他们以前咱们来看一段咱们在项目中看到的相似的代码：

public class ClassA{
    ClassB classB = new ClassB();
    ClassC classC = new ClassC("xxx",xxx);
    .....
}
复制代码

如你所见，当咱们在目标类初始化其余类时，这些工做几乎都是重复性的操做，咱们可不能够用一种方案来替代这种操做，这时咱们所使用的 Dagger2 的成员 @Inject 和 @Component 就跳出来了，大声喊道：我能够~~~

2. @Inject 是什么？

@Inject为了实现以上功能，咱们须要完成如下步骤：

1. 须要用注解 @Inject (Annotation) 来标注目标类中依赖类的实例对象
2. 一样用注解 @Inject (Annotation) 来标注所依赖的其余类的 构造函数。

目标类 ClassA

public class ClassA{
	    
	        @Inject
	        ClassB classB;// 使用 @Inject 标注依赖类的实例对象
	        @Inject
	        ClassC classC;
       
	    }
复制代码

依赖类 ClassB

public class ClassB{
        @Inject // 使用 @Inject 标注依赖类的构造函数
        public ClassB(){}
        ....
    }
复制代码

依赖类 ClassC

public class ClassC{
        @Inject
        public ClassC(XXX xxx, XXX xxx){
            ...
        }
    }
复制代码

注意：在使用 @Inject 标注类的构造函数，只能标注一个构造函数，没法标注多个。

虽然 目标类 和 依赖类 都使用了@Inject 来标记，可是他们并无产生实在乎义上的联系，这时 @Component 就充当了媒婆的角色。

3. @Component 是什么

做用：将Module中产生的依赖对象自动注入到须要依赖实例的Container中

很明显 @Component 是一个注解，那么被 @Component 标记的类理所固然的被称为 注解类，而且该类必须是接口或抽象类。那么下面咱们看一下这个媒婆是怎么开展工做的：

1.@Component 标注类的实例必须存在目标类中 2.Component会查找目标类中用 @Inject 注解标注的属性 3. 查找到相应的属性后,会接着查找该属性对应的用 @Inject 标注的构造函数（这时候就发生联系了） 4. 剩下的工做就是初始化该属性的实例并把实例进行赋值 具体过程以下图：

4. 简单使用

• 依赖类 -- User ，使用 @Inject 标注构造函数

public class User {
    private String mName = "jack chen";
    private int mAge = 40;
    @Inject
    public User() { }

    public String getName() {
        return mName;
    }
    
    public void setName(String mName) {
        this.mName = mName;
    }

    public int getAge() {
        return mAge;
    }

    public void setAge(int mAge) {
        this.mAge = mAge;
    }
}
复制代码

• 媒介类 -- UserComponentm ( 接口), 使用 @Component 注解该类

@Component
public interface UserComponent {
    void inject(MainActivity mMainActivity);
}
复制代码

• 目标类 -- MainActivity，使用 @Inject 注解相关实例变量

public class MainActivity extends AppCompatActivity {

    @Inject
    User mUser;

    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        // 这一句代码是完成依赖注入的关键
        DaggerUserComponent.builder().build().inject(this); 
        
        Log.e(TAG,"name : " + mUser.getName() + " age :" + mUser.getAge());
        mUser.setAge(50);
        mUser.setName("blur");
        Log.e(TAG,"name2 : " + mUser.getName() + " age2 :" + mUser.getAge());

    }
}

复制代码

• 执行结果

name : jack chen age :40
 name2 : blur age2 :50
复制代码

5. 总结

到此为止，咱们已经实现了基本的基于 Dagger2 的依赖注入。下面咱们把过程再梳理一遍：

1. 用 @Inject 注解标注目标类中依赖类的实例对象
2. 用 @Inject 注解标注依赖类的构造函数
3. 若其余类还依赖于其余的类，则重复进行上面2个步骤
4. 调用 Component（注入器）的 injectXXX（Object）方法开始注入（injectXXX方法名字是官方推荐的名字,以inject开始）

Component 就像 目标类 和本身的 依赖类 的媒介，把目标类依赖的实例注入到目标类中，来初始化目标类中的依赖实例变量。

5.参考文章

---

Dagger 详解

这就是Dagger2

Dagger2 入门实践

Android：dagger2让你爱不释手-终结篇

最简单的Dagger2入门教程

Android：dagger2让你爱不释手-基础依赖注入框架篇