安卓开发 第一篇 关于依赖注入框架dagger2的使用和理解
（这篇博客真是磨难重重啊，写到一半电脑蓝屏了，还好markdown编辑器保持了部分类容）
最近开始重构项目，在重构项目中用到了依赖注入框架dagger2，发现它确实很方便，能大大加快我们编写代码的速度，同时也很方便我们对于功能模块的解耦。在这里就不过多介绍dagger2了，大家谷歌 百度一下就能得到很多关于dagger2的介绍。学习dagger2是需要一定的学习成本的，我自己开始学习的时候也差不多花了一周的时间才弄明白怎样使用dagger2，下面就说说自己对dagger2的理解和使用方法。
dagger2中最重要的就是module和component了，module是生产我们需要的对象的地方，component是联系module和module生产出的对象的使用场景的桥梁。（说白了，dagger2就像是设计模式中的工厂模式，为我们生产各种我们需要的对象）
不明白？上代码：（假如我们有一个类A，然后我们通过依赖注入方法要在MainActivity中使用）
×××××××××××××××××××××××不使用dagger2××××××××××××××××××××××××
//类A
public class A {
private int field;
... //其他属性
public A() {
}
public void doSomething(){
Log.i("美女","我爱你");
}
public void doOtherthing(){
Log.i("美女","我是真的爱你");
}
... //其他方法
}
//类MainActivity
public class MainActivity extends AppCompatActivity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
A a=new A();
a.doSomething();
a.doOtherthing();
}
}
×××××××××××××××××××××××使用dagger2××××××××××××××××××××××××
//类A
public class A {
private int field;
... //其他属性
public A() {
}
public void doSomething(){
Log.i("美女","我爱你");
}
public void doOtherthing(){
Log.i("美女","我是真的爱你");
}
... //其他方法
}
//我们先要构造一个Module,这个Module中生产A的对象
@Module
public class AMedule {
@Provides
A provideA(){
return new A();
}
}
//然后需要一个Component，用了连接Module和MainActivity
@Component(modules = AMedule.class)
public interface ActivityComponent {
A a();
}
//在MainActivity类中使用
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ActivityComponent component=DaggerActivityComponent.builder()
.aMedule(new AMedule())
.build();
A a=component.a();
a.doSomething();
a.doOtherthing();
}
}
一个简单的依赖注入就完成了。也许大家会觉得这样写很麻烦，其实不然，还有一种更加简单的方法来做这件事，我们把B注入到BComponent中，直接使用@Inject注解：
//类A
public class A {
private int field;
... //其他属性
public A() {
}
public void doSomething(){
Log.i("美女","我爱你");
}
public void doOtherthing(){
Log.i("美女","我是真的爱你");
}
... //其他方法
}
//我们先要构造一个Module
@Module
public class AMedule {
@Provides
A provideA(){
return new A();
}
}
//然后需要一个Component
@Component(modules = AMedule.class)
public interface ActivityComponent {
void inject(MainActivity mainActivity);
}
//在MainActivity类中使用
public class MainActivity extends AppCompatActivity {
@Inject
A a；
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerActivityComponent.builder()
.aMedule(new AMedule())
.build()
.inject(this);
a.doSomething();
a.doOtherthing();
}
}
怎么样，是不是简单，方便一些了。什么？还麻烦，那我们更进一步吧（由于这里的A类是我们自己定义的，可以更进一步）：
//类A
public class A {
private int field;
... //其他属性
@Inject
public A() {
}
public void doSomething(){
Log.i("美女","我爱你");
}
public void doOtherthing(){
Log.i("美女","我是真的爱你");
}
... //其他方法
}
//我们先要构造一个Module（其实这里Module已经用不到了，我们不需要通过Modu生产A了，不过为了与上面对比，还是留着吧）
@Module
public class AMedule {
// @Provides
// A provideA(){
// return new A();
// }
}
//然后需要一个Component
@Component(modules = AMedule.class)
public interface ActivityComponent {
void inject(MainActivity mainActivity);
}
//在MainActivity类中使用
public class MainActivity extends AppCompatActivity {
@Inject
A a；
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerActivityComponent.builder()
.aMedule(new AMedule())
.build()
.inject(this);
a.doSomething();
a.doOtherthing();
}
}
是不是看迷糊了，A没有在Module生产，那是怎么来的呢？不知道大家注意到没有，A的构造方法上面有个@Inject注解，没错，就是他，就是这个注解生产A对象的。
看到这里，我们就知道dagger2生产对象有两种方式，一种是在Module中通过@Provides注解加上providexxx 方法，另一种就是直接在要生产的对象的类的构造方法加上@inject注解。
那么什么时候用Module，什么时候用@Inject呢？
在这里悄悄告诉大家： 一般生成系统或者SDK或者第三方库提供的类的对象时用Module，而自定义的类的对象用@Inject，当然，你也可以用一个类继承系统或者SDK或者第三方库提供的类，然后在其构造方法加上@Inject注解。
2. 可能大家对Module和Component的还是似懂非懂，在这里在打一个形象一点的比喻吧。
例如到吃饭的时间了，我们要去做饭(吃外卖的绕道)，我们得去厨房吧(希望不是野外烧烤)，我们需要煤气灶（也可能是电磁炉），锅，刀，砧板，盆子….（发现需要的真多哈），这些都是一个个类吧，你厨房里的那些具体的比如美的电饭煲（美的是不是得给点广告费），苏泊尔不粘锅（刚买了一个）…..就是一个个具体的对象，我们有了这些具体的对象才能愉快的做饭，而Module就是让我们得到这一个个对象（一个大工厂，生产美的电饭煲，苏泊尔不粘锅….）,Component 就是我们的厨房，DaggerActivityComponent .builder().aMedule(new AMedule()).build() 就是让我们拥有了一个厨房（想想机器猫的口袋，我们可以从里面得到任何东西 ），我们可以从厨房里面拿炊具做饭（往外拿：A a=component.a()，这是把厨房里的东西拿到厨房外面，在外面做饭），而 DaggerActivityComponent.builder() .aMedule(new AMedule()) .build().inject(this)就是我们自己进入厨房，在厨房里面 做饭（我们当然很容易获得厨房里面的炊具了，用@Inject获得），好了，开始做饭。。。
3. 一个Component可以依赖多个Module，如
@Component(modules = {AModule.class,BModule.class,...})
同样，Component也可以依赖另一个Component，如
@Component(dependencies = BComponent.class,modules = {AModule.class,BModule.class,...})
甚至多个Component，如
@Component(dependencies = {BComponent.class,CComponent.class,...}
,modules = {AModule.class,BModule.class,.