Android开发之Dagger2的基本使用（一）

前言

新入职的公司的项目里是MVVM+Retrofit+Dagger2的架构，所以想把Dagger2研究一下，以前也研究过，但是不怎么具体，现在想花点时间好好研究下。如今的Android开发，RxJava+Retrofit+MVP+Dagger2已经成了主流框架，现在我这里直说Dagger2.。

依赖注入

说到Dagger2，首先应该说依赖注入。
在软件领域，依赖注入是用于控制反转的常见的实现方式，主要是用于降低依赖和被依赖之间的耦合，当需要修改被依赖的实现时，不需要修改被依赖的实例。

依赖注入的实现

依赖注入主要有以下几种方式实现

• 1 通过构造方法

public class Student {

    private Student mStudent;

    public Student(Student student){
        this.mStudent=student;
    }

}

• 2 通过setter方法

public class HighSchool {

    private Student mStudent;

    public void setStudent(Student student){
        this.mStudent=student;
    }
}

• 3 通过接口

public interface School {
    void setStudent(Student student);
}

public class MiddleSchool implements School{

    private Student mStudent;

    @Override
    public void setStudent(Student student) {
        mStudent=student;
    }
}

• 4 通过Java注解

public class Human {
    ...
    @Inject Father father;
    ...
    public Human() {
    }
}

Dagger2就是通过这种方式。

Dagger

Dagger1最初由square公司推出 Dagger1传送门，后来Goole公司接手，并推出了Dagger2Dagger2的传送门。

现在我们看看Dagger2是怎么样实现依赖注入的。

源码传送门

Dagger2的使用

引入

添加Android Gradle，我写这篇文章的时候，最新的版本是2.15版本。

dependencies {
  compile 'com.google.dagger:dagger:2.15'
  annotationProcessor 'com.google.dagger:dagger-compiler:2.15'
}

这里要说明一下，如果你的Android Studio版本小于2.2，或者你想通过apt插件方式引入Dagger2，可以这样做
首先在项目的总的build.gradle下添加

dependencies {
        classpath 'com.android.tools.build:gradle:2.3.1'
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8' //apt方式
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }

然后再app的build.gradle下，添加如下代码：

apply plugin: 'com.android.application'
apply plugin: 'com.neenbedankt.android-apt'

dependencies {
 apt 'com.squareup.dagger:dagger-compiler:2.15'
 compile 'com.squareup.dagger:dagger:2.15'
}

提醒一下，用这种方式，Android Studio可能会报warn哦

开始使用

前面我们说了，Dagger2最好配合MVP方式使用，现在不急，我们先做一点测试。看一下到底怎么使用。
我们使用Dagger2的方式来注入一个类的实例到Activity中，并在Activity中使用注入的实例。

1首先创建一个简单的Student类

创建一个简单的Student类，和普通的类的区别是，我们在类的构造方法上用 @Inject注解

public class Student {

    private String mess="Student的实例是注解方式注入的";

   @Inject
    public Student(){

    }

    public String showMessage(){
        return mess;
    }

}

2 在Activity中注入Student的实例,并使用

public class Daggertest1Activity extends AppCompatActivity {

    @Inject
    Student mStudent;  // 注入Studnet的实例

    private TextView tv_mess;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_daggertest1);
        tv_mess =  findViewById(R.id.text);
        tv_mess.setText(mStudent.showMessage());
    }
}

我们编译运行程序，可以看到报错如下

很明显Student的实例为空，Student的实例没有注入成功，所以还需要额外的代码，完成注入工作。

3. 创建Module类

我们创建一个Module类，MainModule，里面暂时什么也不做，但是注意的是必须用@Module注解，表明这个类是Module类。

@Module
public class MainModule {

}

4. 创建Component接口

创建一个MainComponent接口，接口用@Component(modules = MainModule.class)注解，在此方法里inject相应的Activity。

@Singleton
@Component(modules = MainModule.class)
public interface MainComponent {
    void inject(Daggertest1Activity daggertest1Activity);
}

5. 在Activity里完成注入

重新编译一下代码，在Activity里添加如下代码

 DaggerMainComponent.builder()
                .mainModule(new MainModule())
                .build()
                .inject(this);

可以看到，编译生成的要导入的模块是Dagger+Component名字的形式。
运行代码我们看到Student的实例注入成功，并调用Student实例的方法成功。

以上是完成了Dagger2注入的基本使用，我们最终完成了Student对象的注入，也许你要说，我们直接在Activity里new一个Student的对象不就可以了吗，为什么要花这么大力气来研究一个Dagger2呢，这就是我们为什么需要依赖注入。

为什么要使用依赖心注入

我们知道依赖注入主要是用来降低耦合，怎么来降低耦合呢？以上我们是用了一个Student类的例子，这个Studnet的实例我们也就使用了一次，如果你的项目里有个类使用了上百次，那么你就new了上百次Student的对象，现在突然来了个需求更改，要在Student的构造方法里传一个参数，这样的话，你就必须去每一个new的地方去修改，wtf，想想都觉得很给力，我的心情就只能用下面的图片形容了。

后续问题

虽然注入成功了，但是我们还有好多问题没有解决。

• 我们添加inject后，通过编译生成的DaggerMainComponent类来导入，说明编译以后生成了一些类，那到底生成了什么类呢。
• Module和Component又是什么，该怎么里理解
  这些问题我们在下一篇文章再讨论。
  源码传送门