依赖注入框架dagger2学习笔记

基本介绍

dagger2 是一款基于Java注解来实现的完全在编译阶段完成依赖注入的开源库，主要用于模块间解耦、提高代码的健壮性和可维护性。

1.1 在android中如何使用

使用Gradle 引用dagger2依赖库就可以

// Add Dagger dependenciesdependencies 
{
 compile 'com.google.dagger:dagger:2.x' 
annotationProcessor 'com.google.dagger:dagger-compiler:2.x'
}

2. 学习中的几个疑惑

2.1 dagger2中的Inject,Component,Module,Provides等等都是什么东东，有什么作用?

Dagger2 通过注解来生成代码，定义不同的角色，主要的注解如下：
@Module: Module类里面的方法专门提供依赖，所以我们定义一个类，用@Module注解，这样Dagger在构造类的实例的时候，就知道从哪里去找到需要的依赖。
**@Provides: **在Module中，我们定义的方法是用这个注解，以此来告诉Dagger我们想要构造对象并提供这些依赖。
**@Inject: **通常在需要依赖的地方使用这个注解。换句话说，你用它告诉Dagger这个类或者字段需要依赖注入。这样，Dagger就会构造一个这个类的实例并满足他们的依赖。
**@Component: **Component从根本上来说就是一个注入器，也可以说是@Inject和@Module的桥梁，它的主要作用就是连接这两个部分。将Module中产生的依赖对象自动注入到需要依赖实例的Container中。
@Scope: Dagger2可以通过自定义注解限定注解作用域，来管理每个对象实例的生命周期。
**@Qualifier: **当类的类型不足以鉴别一个依赖的时候，我们就可以使用这个注解标示。例如：在Android中，我们会需要不同类型的context，所以我们就可以定义 qualifier注解“@perApp”和“@perActivity”，这样当注入一个context的时候，我们就可以告诉 Dagger我们想要哪种类型的context。

2.2 dagger2到底能带来哪些好处？

最大的好处就是模块间解耦

下面举个简单的例子：
如果在 Class A 中，有 Class B 的实例，则称 Class A 对 Class B 有一个依赖。如果不用Dagger2的情况下我们应该这么写：

 public class A {
  ... 
 B b;
  ... 
 public A() {
    b = new B(); 
 }
}

上面例子面临着一个问题，一旦某一天B的创建方式（如构造参数）发生改变，那么你不但需要修改A中创建B的代码，还要修改其他所有地方创建B的代码。
有了dagger2 后，代码风格变成这样了

public class A{
    @InjectB b;
}

2.3 怎样把dagger2应用到具体项目中？

3. dagger2 demo代码

3.1 初始化User对象

这个很简单，就是创建一个普通的class

public class User {
    private String name;
    private int age;
    public User(String name ,int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "user:" + name + ",age:" + age;
    }
}

3.2 生成UserModule 对象

/**
 *
 * module类就是给user初始化并且提供外部调用的类，这里类中我们需要给user初始，并且返回给dagger一个可调用的对象
 * @Module  真正提供依赖的类，以表明该类是Module类,这样Dagger2才能识别 ,Dagger在构造类的实例的时候，就知道从哪里去找到需要的依赖。
 * @Provides 就是写在Module中某些方法上，表示这个方法提供依赖
 *
 */
@Module
public class UserModule {
    @Provides
    User providerUser(){
        return new User("卡卡",20);
    }
}

3.3 生成Component对象

/**
 * 有了提供依赖的组件（module），我们还需要将依赖注入到需要的对象中。连接提供依赖和消费依赖对象的组件被称为Injector。Dagger2中我们将这个对象其称为component。
 *
 * @Component  也可以说是@Inject和@Module的桥梁，它的主要作用就是连接这两个部分 , 将Module中产生的依赖对象自动注入到需要依赖实例的Container中。
 */
@Component(modules = UserModule.class)
public interface UserComponent {
    /**
     * 这里必须是真正消耗依赖的类型MainActivity，而不可以写成其父类，比如Activity。
     *
     * 因为Dagger2在编译时生成依赖注入的代码，会到inject方法的参数类型中寻找可以注入的对象
     * @param activity
     */
    void inject(MainActivity activity);

}

3.4 完成依赖注入

public class MainActivity extends AppCompatActivity {

    /**
     * 使用@Inject标志被注入的对象User （注意User 不能为private）
     *
     * 换句话说，你用它告诉Dagger这个类或者字段需要依赖注入 ,这样，Dagger就会构造一个这个类的实例并满足他们的依赖
     */
    @Inject
    User user;// 不能是private

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        TextView tv = (TextView) findViewById(R.id.user);

        UserComponent component = DaggerUserComponent.builder().userModule(new UserModule()).build();
        component.inject(this);

        tv.setText(user.toString());
    }
}

注意：
这里的DaggerUserComponent不是我们自己创建的，是dagger自动在build时（可手动make project）创建的，后边的userModule也是更具你在Component设置的module对象生成的方法-如果不成功需先clean工程，再make project 一遍

4、小结

这两天在网上看了不少有关dagger2的文章，现在虽然对它有了初步的认识，但是还有很多疑惑。
一个是还没有领悟到这个框架的独到之处，虽然它能起到一定解耦的效果，但是现在是感觉有点繁琐。
还有一点就是，在实际项目中怎么用？现在还是一头雾水、无从下手。

参考文档

1、官方文档
2、dagger2 — 基础篇
3、daager2 — 初认识一
4、dagger2详解 — 从代码分析其原理
5、github 地址