dagger2学习笔记

1.导入Dagger2
project的build.gradle中

buildscript {

    ....

    dependencies {

        classpath 'com.android.tools.build:gradle:2.1.0'
        // 添加android-apt 插件
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
    }
}

app的build.gradle中

apply plugin: 'com.android.application'
// 应用插件
apply plugin: 'com.neenbedankt.android-apt'

android {
    compileSdkVersion 23
    buildToolsVersion "23.0.2"

    defaultConfig {
        applicationId "com.mahao.alex.architecture"
        minSdkVersion 15
        targetSdkVersion 23
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}


dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:23.3.0'

    // dagger 2 的配置
    compile 'com.google.dagger:dagger:2.4'
    apt 'com.google.dagger:dagger-compiler:2.4'
    compile 'org.glassfish:javax.annotation:10.0-b28'// 添加java 注解库
}

android-apt是Gradle编译器的插件,主要两个作用：

• 编译时使用该工具，最终打包时不会将该插件打入到apk中。
• 能够根据设置的源路径，在编译时期生成相应代码。

2.Dagger2 API

public @interface Component {
    Class<?>[] modules() default {};
    Class<?>[] dependencies() default {};
}

public @interface Subcomponent {
    Class<?>[] modules() default {};
}

public @interface Module {
    Class<?>[] includes() default {};
}

public @interface Provides {
}

public @interface MapKey {
    boolean unwrapValue() default true;
}

public interface Lazy<T> {
    T get();
}

用在dagger2中的 JSR-330(Java中的依赖注入标准)定义的注解

public @interface Inject {
}

public @interface Scope {
}

public @interface Qualifier {
}

3.dagger2 使用
3.1 @inject使用

http://blog.csdn.net/lisdye2/article/details/51942511
方式一：由module中@Provides 注解的providerXXX（）提供对象

public class Person {  
   person(){
  }
}

@Module   //依赖对象提供者
public class ActivityModule{
 private SplashActivity activity;

    public ActivityModule(SplashActivity activity) {
        this.activity = activity;
    }
    @Provides // 关键字，标记具体提供依赖对象的方法
    SplashActivity providerSplashActivity  (){
        return activity;
    }
    @Provides // 关键字，标记具体提供依赖对象的方法
    Person providerPerson(){
        return new Person();
    }
}

@Component(modules = ActivityModule.class)
public interface ActivityComponent {
    void inject(SplashActivity splashActivity );
}

到这重新build项目， AndroidStudio -> Build -> Make Project，生成
DaggerXXXComponent。

public class SplashActivity extends AppCompatActivity {

    @Inject
    Person person;

    @Override
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);
       //开始注入
      DaggerActivityComponent.builder()
    .ActivityModule(new ActivityModule())
    .build()
    .inject(this);
    }
}

方式二：@Inject注解类（Person ）的构造函数，直接初始化对象

public class Person {  
   @inject //@Inject注解构造函数
   person(){
  }
}
@Module   //依赖对象提供者
public class ActivityModule{
 private SplashActivity activity;

    public ActivityModule(SplashActivity activity) {
        this.activity = activity;
    }
    @Provides // 关键字，标记具体提供依赖对象的方法
    SplashActivity providerSplashActivity  (){
        return activity;
    }
}
//记得先rebuild 项目
public class SplashActivity extends AppCompatActivity {

    @Inject
    Person person;

    @Override
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);
       //开始注入
      DaggerActivityComponent.builder()
    .ActivityModule(new ActivityModule())
    .build()
    .inject(this);
    }
}

需要参数的实例化对象

public class Person {  
   String name;
   person(String name){
   this.name=name;
  }
}

ActivityModule:
@Module   //依赖对象提供者
public class ActivityModule{
 private SplashActivity activity;

    public ActivityModule(SplashActivity activity) {
        this.activity = activity;
    }
    @Provides // 关键字，标记具体提供依赖对象的方法
    SplashActivity providerSplashActivity  (){
        return activity;
    }
    @Provides // name由ActivityModule中providerString提供
    Person providerPerson(String name){
        return new Person(name);
    }
    @Provides // 关键字，标记具体提供依赖对象的方法
    String providerString(){
        return "李好";
    }
}

//记得先rebuild 项目
public class SplashActivity extends AppCompatActivity {

    @Inject
    Person person;

    @Override
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);
       //开始注入
      DaggerActivityComponent.builder()
    .ActivityModule(new ActivityModule())
    .build()
    .inject(this);
    }
}

注入流程
步骤1：查找Module中是否存在提供对象（@Inject标记的对象）的方法。
步骤2：若Module中存在提供该对象的方法（providerXXX），查看该方法是否有参数
步骤2.1：若有参数，则按从步骤1开始依次初始化每个参数（即从（Module的providerXXX）中获取参数值）。
步骤2.2：若没有参数，则直接调用初始化该类实例，一次依赖注入结束。
步骤3：若Module中没有提供该对象方法，则查找@Inject注解的构造函数，看构造函数是否有参数
步骤3.1：若有参数，则从步骤1开始依次初始化每个参数
步骤3.2：若没有参数，则直接初始化该类实例，一次依赖注入结束。

3.2 @Qualifier
使用场景：
当一个类有两个构造函数时，使用Dagger2时，如何获取指定构造函数new出来的对象 ？ 这就需要@Qualifier来解决。

public class Person {  
   String name;
   person(){
   }

   person(String name){
   this.name=name;
  }
}

首先
用@Qualifier 自定义一个限定符

@Qualifier//限定符
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface Type {
    String value() default "";//默认值为""
}

修改ActivityModule， 添加@Named；

@Module   //依赖对象提供者
public class ActivityModule{
 private SplashActivity activity;

    public ActivityModule(SplashActivity activity) {
        this.activity = activity;
    }
    @Provides // 关键字，标记具体提供依赖对象的方法
    SplashActivity providerSplashActivity  (){
        return activity;
    }
    @Named("normal")
    @Provides // 关键字，标记具体提供依赖对象的方法
    Person providerPerson(String name){
        return new Person(name);
    }
    @Named("default")
    @Provides // 关键字，标记具体提供依赖对象的方法
    Person providerPerson(){
        return new Person();
    }

 @Provides
    public String provideString(){
        return new String(“有参数”);
    }
}

修改SplashActivity ， 添加@Type；

public class SplashActivity extends AppCompatActivity {
    @Named("default")   
    @Inject
    Person person;

    @Named("normal")
    @Inject
    Person person2;
    @Override
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);
       //开始注入
      DaggerActivityComponent.builder()
    .ActivityModule(new ActivityModule())
    .build()
    .inject(this);
     Log.i("dagger","person.name = "+ person.name+"; person2.name = "+ person2.name);
    }
}

打印结果

person.name = null; person2.name=“有参数”

此时的person，person2是由不同的构造方法创建。
通过字符串标记一个对象，容易导致前后不匹配.做如下修改

@Qualifier  // 关键词
@Retention(RetentionPolicy.RUNTIME)  // 运行时仍可用
public @interface PersonForDefault {

}
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface PersonForName {
    // name 对象的注解
}
**********************ActivityModule**********************
    @PersonForDefault 
    @Provides // 关键字，标记具体提供依赖对象的方法
    Person providerPerson(String name){
        return new Person(name);
    }
    @PersonForName 
    @Provides // 关键字，标记具体提供依赖对象的方法
    Person providerPerson(){
        return new Person();
    }

 @Provides
    public String provideString(){
        return new String(“有参数”);
    }
********************SplashActivity*************************
    @PersonForDefault   
    @Inject
    Person person;

    @PersonForName 
    @Inject
    Person person2;

3.3 @Singleton
@Singleton注解实际上实现的是一个全局单例模式，通过@Singleton创建出来的全局单例并不保持在静态域上，而是保留在Component实例中。不同的Component实例对象通过@Singleton创建出来的全局单例不同。

• 不使用 @Singleton

public class SplashActivity extends AppCompatActivity{

    @Inject
    Person person;

    @Inject
    Person person2;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // 构造桥梁对象
 ActivityComponent splashcomponent=  DaggerActivityComponent.builder()
    .ActivityModule(new ActivityModule())
    .build()；

        //注入
        component.inject(this);

        // 打印两个对象的地址
        Log.i("dagger","person = "+ person.toString()+"; person2 = "+ person2.toString());
    }
}

打印结果

 person = com.nihao.dagger2.Person@430d1620；
 person2 = com.nihao.dagger2.Person@430d17c8；

person 和person2 地址不相等，不是同一个对象，即创建了2个对象。

• 使用 @Singleton

修改ActivityModule代码，在providerPerson（）上添加 @Singleton注解

@Module   //依赖对象提供者
public class ActivityModule{
 private SplashActivity activity;

    public ActivityModule(SplashActivity activity) {
        this.activity = activity;
    }
    @Provides // 关键字，标记具体提供依赖对象的方法
    SplashActivity providerSplashActivity (){
        return activity;
    }

    @Singleton
    @Provides // 关键字，标记具体提供依赖对象的方法
    Person providerPerson(){
        return new Person();
    }
}

ActivityComponent 也要添加@Singleton，否则无法编译

@Singleton
@Component(modules = ActivityModule.class)
public interface ActivityComponent {
    void inject(SplashActivity splashActivity );
}

重新运行

person = com.mahao.alex.architecture.dagger2.Person@4310f898；          person2= com.mahao.alex.architecture.dagger2.Person@4310f898;

person 和person2 地址相等，是由splashcomponent提供同一个对象。

• @Singleton创建出来的全局单例并不保持在静态域上，而是保留在Component实例中

**********************修改ActivityComponent **************
@Singleton
@Component(modules = ActivityModule.class)
public interface ActivityComponent {
    void inject(SplashActivity splashActivity );
    void inject(MainActivity mainActivity );
}
*******************ActivityModule添加***********************
MainActivity mainactivity；
    public ActivityModule(MainActivity mainactivity) {
        this.mainactivity= mainactivity;
    }
    @Provides // 关键字，标记具体提供依赖对象的方法
    MainActivity providerMainActivity  (){
        return mainactivity;
    }
*******************添加MainActivity ***********************  
public class MainActivity extends AppCompatActivity{

    @Inject
    Person person3;

    @Inject
    Person person4;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // 构造桥梁对象
 ActivityComponent maincomponent=  DaggerActivityComponent.builder()
    .ActivityModule(new ActivityModule())
    .build()；

        //注入
        maincomponent.inject(this);

        // 打印两个对象的地址
        Log.i("dagger","person3 = "+ person3.toString()+"; person4 = "+ person4.toString());
    }
}

此时person 和person2 是由splashcomponent提供同一个对象。
person3和person4是由maincomponent提供的同一对象，但是person
和person3，person4不是同一对象 ，这是因为maincomponent和splashcomponent不是同一个对象。

3.4@MapKey

这个注解用于定义依赖集合(映射和集)。
定义

 @MapKey(unwrapValue = true)
@interface TestKey {
    String value();
}

提供依赖

@Provides(type = Type.MAP)
@TestKey("foo")
String provideFooKey() {
    return "foo value";
}

@Provides(type = Type.MAP)
@TestKey("bar")
String provideBarKey() {
    return "bar value";
}

使用

@Inject
Map<String, String> map;

map.toString() // => „{foo=foo value, bar=bar value}”

3.5 Lazy

@Inject
Lazy<Person> lazyPerson; // 注入Lazy元素
@Inject
Provider<Person> providerPerson; // 注入Provider

 // 调用该方法时才会去创建Person,以后每次调用获取的是同一个对象
 Person person = lazyPerson.get();
 Person person1 = lazyPerson.get();
 person1,person指向同一对象 ;

// 调用该方法时才回去创建Person1，以后每次调用都会重新加载Module中的具体方法，根据Module中的实现，可能相同，可能不相同。
Person person2 = providerPerson.get();
Person person3 = providerPerson.get();
person2 和person3 可能相同，可能不相同。

3.6 Component依赖
Component之间的关系有： 依赖(dependencies),包含(SubComponent),继承方式(extends)

http://blog.csdn.net/soslinken/article/details/70231089

经验总结：

• @Inject成员不能是private的,否则会报:Error:(35, 29) 错误: Dagger does not support injection into private fields
• @Provides的优先级高于@Inject
• @Provides注解的方法以ProvidesXXX形式规范
• 通过Singleton创建出来的单例并不保持在静态域上，而是保留在Component实例中。
• @Component关联的@Module中的任何一个@Provides有@scope，则该整个@Component要加上这个scope。否则在暴露或者注入时（不暴露且不注入时，既不使用它构造对象时，不报错），会报错。
• 没有scope的组件不能依赖有scope的组件。否则会报错。
• @Component的dependencies与@Component自身的scope不能相同，即组件之间的scope不能相同,否则出现错误。
• @Singleton的组件不能依赖其他scope的组件，但是其他scope的组件可以依赖@Singleton组件。
• 一个组件不能同时有多个scope即一个 组件依赖多个Component(Subcomponent除外)时报错：Component
  depends on more than one scoped component