Dagger2使用详解

Dagger2 是一个Android依赖注入框架，由谷歌开发，最早的版本Dagger1 由Square公司开发。依赖注入框架主要用于模块间解耦，提高代码的健壮性和可维护性。

Dragger2 通过注解来生成代码，定义不同的角色，主要的注解有：@Inject、@Module、@Component、@Provides、@Scope、@SubComponent等。

• @Inject：通常在需要依赖的地方使用这个注解。换句话说，你用它告诉Dragger这个类或者字段需要依赖注入。这样，Dragger就会构造一个这个类的实例并满足他们的依赖。
• @Module: Modules类里面的方法专门提供依赖，所以我们定义一个类，用@Module注解，这样Dragger在构造类的实例的时候，就知道从哪里去找到需要的依赖。modules一个重要特性是他们设计为分区并组合在一起（比如说，在我们的app中可以有多个组成在一起的modules）
• @Provides：在modules中，我们定义的方法使用这个注入器，以此来告诉Dragger我们想要构造对象并提供这些依赖。
• @Component： Components从根本上来说就是一个注入器，也可以说是@Inject和@Module的桥梁，它的主要作用就是连接这两部分。Commponents可以提供所有定义了的类型的实例。比如：我们必须用@Commponent注解一个接口然后列出所有的@Modules组成该组件，如果缺失了任何一块都会在编译的时候报错。所有组件都可以通过它的modules知道以来的范围。
• @Scope：Dragger2可以通过自定义注解限定注解作用域。一般说来每一个Component都有一个自己的作用域
• @Qualifier: 当类的类型不足以鉴别一个依赖的时候，我们就可以使用这个注解标示。例如：在Android中，我们会需要不同类型的context，所以我们就可以定义qulifier注解”@perApp”和”@perActivity:，这样当注入一个context的时候，我们就可以告诉Dagger我们想要那哪种类型的context。

结构

Dagger2要实现一个完整的依赖注入，必不可少的元素有三种:Module，Component和Container。

为了便于理解，其实可以把component想象成针管，module是注射瓶，里面的依赖对象是注入的药水，build方法是插进患者（Container），inject方法的调用是推动活塞。

一个简单的例子

实现module

@Module // 注明本类是Module
public class MyModule{
    @Provides  // 注明该方法是用来提供依赖对象的方法
    public B provideB(){
        return new B();
    }
}

实现Component

@Component(modules={ MyModule.class}) // 指明Component查找Module的位置
public interface MyComponent{    // 必须定义为接口，Dagger2框架将自动生成Component的实现类，对应的类名是Dagger×××××，这里对应的实现类是DaggerMyComponent 
    void inject(A a);   // 注入到A(Container)的方法，方法名一般使用inject
 }

实现Container

A就是可以被注入依赖关系的容器

public A{
     @Inject   //标记b将被注入
     B b;   // 成员变量要求是包级可见，也就是说@Inject不可以标记为private类型。 
     public void init(){
         DaggerMyComponent.create().inject(this); // 将实现类注入
     }
 }

当调用A的init()方法时，b类自动被赋予实现类的对象。

更多用法

方法参数
上面的例子@Provdes标注的方法是没有输入参数的，Module中@Provides标注的方法是可以带输入参数的，其参数值是可以由Module中其它被@Provides标注的方法提供。

@Module
public class MyModule{
    @Provides
    public B provideB(C c){         
        return new B(c);
    }
    @Provides
    pulic C provideC(){
        return new C();
    }
}

如果找不到到@Provides注释的方法提供对应参数对象的话，将自动调用被@Inject注释的构造方法生成相应对象。

@Module
public class MyModule{
    @Provides
    public B provideB(C c){
        return new B(c);
    }
}
public class C{
    @Inject
    Public C(){
    }
}

添加多个Module

一个Commponent可以添加多个Module，这样Component获取依赖的时候会自动从多个Module中查找获取。添加多个Module有两种方法，一种就是在Component的注解@Component(modules={××××，×××})中添加多个modules

@Component(modules={ModuleA.class,ModuleB.class,ModuleC.class}) 
public interface MyComponent{
    ...
}

另外一种添加多个Module的方法可以使用@Module的 includes的方法（includes={××××，×××}）

@Module(includes={ModuleA.class,ModuleB.class,ModuleC.class})
public class MyModule{
    ...
}
@Component(modules={MyModule.class}) 
public interface MyComponent{
    ...
}

创建Module实例

上面简单例子中，当调用DaggerMyComponent.create()实际上等价于调用了DaggerMYComponent.builder().build().可以看出DaggerMyComponent使用了Builder构造者模式。在构建的过程中，默认使用Module无参构造器产生实例。如果需要传入特点的Module实例。可以使用

DaggerMyComponent.builder()
.moduleA(new ModuleA()) 
.moduleB(new ModuleB())
.build()

区分@Provides方法

这里以Android Context为例。当有Context需要注入时，Dagger2就会在Module中查找返回类型为Context的方法。但是，当Container需要依赖两种不同的Context的时候，你就需要写两个@Provides方法，并且这两个@Provides方法都是返回Context类型，靠跑别返回值得做法就行不通了。这就可以使用@Named注解来区分

//定义Module
@Module
public class ActivityModule{
private Context mContext    ;
private Context mAppContext = App.getAppContext();
    public ActivityModule(Context context) {
        mContext = context;
    }
    @Named("Activity")
    @Provides
    public Context provideContext(){  
        return mContext;
    }
    @Named("Application")
    @Provides
    public Context provideApplicationContext (){
        return mAppContext;
    }
}

//定义Component
@Component(modules={ActivityModule.class}) 
interface ActivityComponent{   
    void inject(Container container);   
}

//定义Container
class Container extends Fragment{
    @Named("Activity") 
    @Inject
    Context mContext; 

    @Named("Application") 
    @Inject
    Context mAppContext; 
    ...
    public void init(){
         DaggerActivityComponent.
     .activityModule(new ActivityModule(getActivity()))
     .inject(this);
     }

}

这样，只有相同的@Named的@Inject成员变量与@Provides方法才可以被对应起来。

**更常用的方法是使用@Qualifier来自定义注解

@Qualifier   
@Documented   //起到文档提示作用
@Retention(RetentionPolicy.RUNTIME)  //注意注解范围是Runtime级别
public @interface ContextLife {
    String value() default "Application";  // 默认值是"Application"
} 

//定义Module
@Module
public class ActivityModule{
private Context mContext    ;
private Context mAppContext = App.getAppContext();
    public ActivityModule(Context context) {
        mContext = context;
    }
    @ContextLife("Activity")
    @Provides
    public Context provideContext(){  
        return mContext;
    }
    @ ContextLife ("Application")
    @Provides
    public Context provideApplicationContext (){
        return mAppContext;
    }
}

//定义Component
@Component(modules={ActivityModule.class}) 
interface ActivityComponent{   
    void inject(Container container);   
}

//定义Container
class Container extends Fragment{
    @ContextLife ("Activity") 
    @Inject
    Context mContext; 

    @ContextLife ("Application") 
    @Inject
    Context mAppContext; 
    ...
    public void init(){
         DaggerActivityComponent.
     .activityModule(new ActivityModule(getActivity()))
     .inject(this);

     }

}

组件依赖

假设ActivityComponent依赖ApplicationComponent。当使用ActivityComponent注入Container的时候，如果找不到对应的依赖，就会到ApplicationCoponent中去查找。但是ApplicationComponent必须显式把ActivityComponent找不到的依赖提供给ActivityComponent。

//定义ApplicationModule
@Module
public class ApplicationModule {
    private App mApplication;

    public ApplicationModule(App application) {
        mApplication = application;
    }

    @Provides
    @ContextLife("Application")
    public Context provideApplicationContext() {
        return mApplication.getApplicationContext();
    }

}

//定义ApplicationComponent
@Component(modules={ApplicationModule.class})
interface ApplicationComponent{
    @ContextLife("Application")
    Context getApplication();  // 对外提供ContextLife类型为"Application"的Context
}

//定义ActivityComponent
@Component(dependencies=ApplicationComponent.class, modules=ActivityModule.class)
 interface ActivityComponent{
    ...
}

进阶用法

单利用法

创建某些对象有时候是耗时、浪费资源的或者需要确保其唯一性，这时就需要使用@Singleton注解标注为单利。

@Module
class MyModule{
    @Singleton   // 标明该方法只产生一个实例
    @Provides
    B provideB(){
        return new B();
    }
}
@Singleton  // 标明该Component中有Module使用了@Singleton
@Component(modules=MyModule.class)
class MyComponent{
    void inject(Container container)
}

※注意：Java中，单例通常保存在一个静态域中，这样的单例往往要等到虚拟机关闭时候，该单例所占用的资源才释放。但是，Dagger通过注解创建出来的单例并不保持在静态域上，而是保留在Component实例中。所以说不同的Component实例提供的对象是不同的。

自定义Scope

@Singleton就是一种Scope注解，也是Dagger2唯一自带的Scope注解,下面是@Singleton的源码

@Scope
@Documented
@Retention(RUNTIME)
public @interface Singleton{}

可以看到定义一个Scope注解，必须添加以下三部分：
@Scope ：注明是Scope
@Documented ：标记文档提示
@Retention(RUNTIME) ：运行时级别

对于Android，我们通常会定义一个针对整个App全生命周期的@PerApp的Scope注解和针对一个Activity生命周期的@PerActivity注解，如下：

@Scope
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface PerApp {
}

@Scope
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface PerActivity {
}

@PerApp的使用例：
@Module
public class ApplicationModule {
    private App mApplication;

    public ApplicationModule(App application) {
        mApplication = application;
    }

    @Provides
    @PerApp
    @ContextLife("Application")
    public Context provideApplicationContext() {
        return mApplication.getApplicationContext();
    }

}

@PerApp
@Component(modules = ApplicationModule.class)
public interface ApplicationComponent {
    @ContextLife("Application")
    Context getApplication();

}

// 单例的有效范围是整个Application
public class App extends Application {
private static  ApplicationComponent mApplicationComponent;
    public void onCreate() {
        mApplicationComponent = DaggerApplicationComponent.builder()
                .applicationModule(new ApplicationModule(this))
                .build();
    }

    // 对外提供ApplicationComponent
    public static ApplicationComponent getApplicationComponent() {
        return mApplicationComponent;
    }
}

@PerActivity的使用例子：

public abstract class BaseActivity extends AppCompatActivity {
    protected ActivityComponent mActivityComponent;
    // 对外提供ActivityComponent
    public ActivityComponent getActivityComponent() {
        return mActivityComponent;
    }

    public void onCreate() {
        mActivityComponent = DaggerActivityComponent.builder()
                .applicationComponent(App.getApplicationComponent())
                .activityModule(new ActivityModule(this))
                .build();
    }
}

通过上面的例子可以发现，使用自定义Scope可以很容易区分单例的有效范围。

子组件

可以使用@Subcomponent注解拓展原有component。Subcomponent其功能效果优点类似component的dependencies。但是使用@Subcomponent不需要在父component中显式添加子component需要用到的对象，只需要添加返回子Component的方法即可，子Component能自动在父Component中查找缺失的依赖

//父Component：
@Component(modules=××××)
public AppComponent{    
    SubComponent subComponent ();  // 这里返回子Component
}
//子Component：
@Subcomponent(modules=××××)   
public SubComponent{
    void inject(SomeActivity activity); 
}

// 使用子Component
public class SomeActivity extends Activity{
    public void onCreate(Bundle savedInstanceState){
        App.getComponent().subCpmponent().inject(this); // 这里调用子Component
    }    
}

懒加载

可以使用Lazy来包装Container中需要被注入的类型为延迟加载

public class Container{
    @Inject Lazy b; 
    public void init(){
        DaggerComponent.create().inject(this);
        B b=b.get();  //调用get时才创建b
    }
}

另外可以使用Provider实现强制加载，每次调用get都会调用Module的Provides方法一次，和懒加载模式正好相反。