Android Dagger2

Dagger2
概述：
官方地址：https://github.com/google/dagger
它是解决Android或java中依赖注入的一个类库。

Dagger2是Dagger1的分支，由谷歌公司接手开发，目前的版本是2.8。Dagger2是受到AutoValue项目的启发。 刚开始，Dagger2解决问题的基本思想是：利用生成和写的代码混合达到看似所有的产生和提供依赖的代码都是手写的样子。

基本注解：
@Inject
@Module
@Provide
@Component（注入器）
@Scope
@Singleton
@Qualifier（限定符）

基本用法：
@Inject + @Component

public class UserInfo {
    @Inject
​
    public UserInfo() {

    }
​
    public String getName() {
        return "Future";
    }
​
}

public class MainActivity extends AppCompatActivity {
   @Inject
    public UserInfo userInfo;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
​
        super.onCreate(savedInstanceState);
​
        setContentView(R.layout.activity_main);
​
        DaggerUserComponent.builder().build().inject(this);
​
           ((TextView)findViewById(R.id.name)).setText(userInfo.getName());
​
    }
​
}

@Component
public interface UserComponent {
    void inject(MainActivity mainActivity);
}

@Inject + @Component+ @Module + @Provides （Demo2）

@Component(modules = UserModule.class)
public interface UserComponent2 {
    void inject(MainActivity mainActivity);
}

@Module
public class UserModule {
​    @Provides
​    public ThirdUserInfo getUserInfo() {
        return new ThirdUserInfo();
    }
}

public class ThirdUserInfo {
    public String getName() {
        return "Future";
    }
}

public class SecondActivity extends Activity{​
    @Inject
    ThirdUserInfo thirdUserInfo;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        DaggerUserComponent2.builder().build().inject(this);
        Log.d("lc", "name="+thirdUserInfo.getName());
​
    }
​
}

@Qualifier(限定符 TAG)当我们对于同一个类型，返回不同的对象时，Dagger会无法区分你到底要用哪个方法来提供依赖对象，这时就需要@Qualifier出现了。

@Module
public class UserModule {
    @Provides
    public ThirdUserInfo getUserInfo() {
        return new ThirdUserInfo().setName("tom");
    }
​
    @Provides
    public ThirdUserInfo getUserInfo2() {
        return new ThirdUserInfo().setName("lc");
    }
​
    @Provides
    public LoginInfo getLoginInfo() {
        return new LoginInfo();
    }
}

自定义注解Type 需要加@Qualifier注解来标识。

@Qualifier
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface Type {
    String value() default "";
}

用自己定义的Type的注解来区分不同的依赖。

@Module
public class UserModule {
    @Provides
    @Type(value = "tom")
    public ThirdUserInfo getUserInfo() {
        return new ThirdUserInfo().setName("tom");
    }
​
​
​
    @Provides
    @Type(value = "lc")
    public ThirdUserInfo getUserInfo2() {
        return new ThirdUserInfo().setName("lc");
    }
​
    @Provides
    public LoginInfo getLoginInfo() {
        return new LoginInfo();
    }
}

然后再Activity中标识对应的注解。

public class SecondActivity extends AppCompatActivity{
    @Type("tom")
    @Inject
    ThirdUserInfo thirdUserInfo;
    @Type("lc")
    @Inject
    ThirdUserInfo thirdUserInfo2;
    @Inject
    LoginInfo loginInfo;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
​
        super.onCreate(savedInstanceState);
​
        DaggerUserComponent2.builder().build().inject(this);
​
        Log.d("lc", "name="+thirdUserInfo.getName());
​
        Log.d("lc", "name2="+thirdUserInfo2.getName());
​
    }
​
}

@Scope(作用域) & @Singleton(单例)
首先说下@Singleton(作用域-单例)
没有使用@Singleton的代码

public class UserInfo {
    @Inject
    public UserInfo() {
    }
}

@Component
public interface UserComponent3 {
    void inject(ThirdActivity thirdActivity);
}

public class ThirdActivity extends AppCompatActivity{
    @Inject
    UserInfo userInfo;
    @Inject
    UserInfo userInfo2;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
​
        super.onCreate(savedInstanceState);
​
        DaggerUserComponent3.builder().build().inject(this);
​
        Log.d("lc", "userInfo=" + userInfo.toString());
​
        Log.d("lc", "userInfo2=" + userInfo2.toString());
​
    }
​
}

打印结果：
D/lc (30180):userInfo=com.example.luchao.testdagger.demo3.UserInfo@43131e98
D/lc (30180): userInfo2=com.example.luchao.testdagger.demo3.UserInfo@43131ea8
这里可以看出是两个不同的对象
然后使用@ Singleton注解

@Singleton
public class UserInfo {
    @Inject
​
    public UserInfo() {
    }
​
}

@Singleton
@Component
public interface UserComponent3 {
    void inject(ThirdActivity thirdActivity);
}

打印结果：
D/lc ( 2834):userInfo=com.example.luchao.testdagger.demo3.UserInfo@43132bf0
D/lc ( 2834):userInfo2=com.example.luchao.testdagger.demo3.UserInfo@43132bf0

现在我们知道@Singleton注解实际上实现的是一个全局单例模式，在实际开发中我们可能还需要一种局部单例的控件，我们可以通过自定义@Scope来实现局部单例。
注意标红的这段话，是从网络上一篇博客看到的，因为这句话，我也被误导了好久。其实@Singleton并没有全局单例的功能。
当我从ThirdActivity跳转到ThirdActivity2中的时候。

public class ThirdActivity2 extends AppCompatActivity{
    @Inject
    UserInfo userInfo;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
//        ((MyApplication) //getApplication()).getApplicationCompenent().inject(this);
​
        DaggerUserComponent3.builder().build().inject(this);
​
        Log.d("lc", "userInfo3="+userInfo);
​
    }
​
}

发现UserInfo打印的完全不一样了。从此就产生了疑问了。后来阅读了一篇博客后恍然大悟。
地址：http://www.jianshu.com/p/1d42d2e6f4a5
其实@Singleton的作用并不是创建全局单例功能。仔细发现@Singleton的代码

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

其实也用到了@Scope注解。
在Dagger2中唯一创建全局单例模式的方式：
首先Module
提供了创建实例的方法，接着AppComponent
中对Module
进行管理，最后AppComponent****在自定义Applicaiton中被实例化了一次。
最关键的就是被实例化一次，然后通过scope注解，通过代理实现单例。
如下：
自定义注解，用来表明Component与Module之间的关系。

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

module:

@Module
public class ApplicationModule {
    @ApplicationScope
    @Provides
    public UserInfo getUserInfo() {
        return new UserInfo();
    }
}

component:

@Component(modules = ApplicationModule.class)
@ApplicationScope
public interface ApplicationCompenent {
​
    void inject(ThirdActivity thirdActivity);
​
    void inject(ThirdActivity2 thirdActivity);
​
}

application:

public class MyApplication extends Application{
    private ApplicationCompenent applicationCompenent;
    @Override
    public void onCreate() {
        super.onCreate();
        applicationCompenent = DaggerApplicationCompenent.builder().build();
​
    }
​
    public ApplicationCompenent getApplicationCompenent() {
        return applicationCompenent;
    }
​
}

activity:

public class ThirdActivity extends AppCompatActivity{
    @Inject
    UserInfo userInfo;
    @Inject
    UserInfo userInfo2;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
​
        super.onCreate(savedInstanceState);
​
        setContentView(R.layout.activity_four);
​
        findViewById(R.id.next).setOnClickListener(new View.OnClickListener() {
​
            @Override
​
            public void onClick(View v) {
​
                Intent intent = new Intent(ThirdActivity.this, ThirdActivity2.class);
​
                startActivity(intent);
​
            }
​
        });
​
        ((MyApplication) getApplication()).getApplicationCompenent().inject(this);
​
//        DaggerUserComponent3.builder().build().inject(this);
​
        Log.d("lc", "userInfo=" + userInfo.toString());
​
        Log.d("lc", "userInfo2=" + userInfo2.toString());
​
    }
​
}

按照上面的情况来说，是不是@Singleton就是多此一举？其实也不是！
其实@
Singleton还有有一些作用的，首先一方面能让你直面的了解到这是一个单例，其次这个@
Singleton能够更好的管理Modlue
和Component
之间的关系。
Dagger2注入的基本实现原理：拿Demo2作为例子。
编译时会根据注解，生成实现类。路径：generated-source-apt-debug
生成类的对应关系: DaggerUserComponent2
UserComponent2 -> DaggerUserComponent2
SecondActivity -> SecondActivity_MembersInjector
UserModule:
getUserInfo -> UserModule_GetUserInfoFactory
getuserInfo2 -> UserModule_GetUserInfo2Factory
getLoginInfo -> UserModule_getLoginfoFactory
大概注入思路：Builder->Factory
见代码：
DaggerUserComponent2.builder().build().inject(this);注入的代码。

public static final class Builder {
  private UserModule userModule;
  private Builder() {}
  public UserComponent2 build() {
    if (userModule == null) {
      this.userModule = new UserModule();
    }
    return new DaggerUserComponent2(this);
  }
​
​
​
  public Builder userModule(UserModule userModule) {
​
    this.userModule = Preconditions.checkNotNull(userModule);
​
    return this;
​
  }
​
}

初始化 initialize：

private void initialize(final Builder builder) {
  this.getUserInfoProvider = UserModule_GetUserInfoFactory.create(builder.userModule);
​
  this.getUserInfo2Provider = UserModule_GetUserInfo2Factory.create(builder.userModule);
​
  this.getLoginInfoProvider = UserModule_GetLoginInfoFactory.create(builder.userModule);
​
  this.secondActivityMembersInjector =
​
      SecondActivity_MembersInjector.create(
​
          getUserInfoProvider, getUserInfo2Provider, getLoginInfoProvider);
​
}

为SecondActivity_MembersInjector类中的Provider 对象赋值。

public static MembersInjector create(

​
    Provider thirdUserInfoProvider,
​
    Provider thirdUserInfo2Provider,
​
    Provider loginInfoProvider) {
​
  return new SecondActivity_MembersInjector(
​
      thirdUserInfoProvider, thirdUserInfo2Provider, loginInfoProvider);
​
}

public SecondActivity_MembersInjector(

​
    Provider thirdUserInfoProvider,
​
    Provider thirdUserInfo2Provider,
​
    Provider loginInfoProvider) {
​
  assert thirdUserInfoProvider != null;
​
  this.thirdUserInfoProvider = thirdUserInfoProvider;
​
  assert thirdUserInfo2Provider != null;
​
  this.thirdUserInfo2Provider = thirdUserInfo2Provider;
​
  assert loginInfoProvider != null;
​
  this.loginInfoProvider = loginInfoProvider;
​
}

此时对象的注入准备工作已经完成准备inject开始注入

@Override

​
public void inject(SecondActivity secondActivity) {
​
  secondActivityMembersInjector.injectMembers(secondActivity);
​
}

这时传进来要注入对象的类，我们这里是SecondActivity，这时猜想后面我们应该会对SecondActivity里面的
thirdUserInfo, thirdUserInfo2,loginInfo做初始化操作，往下看。
secondActivityMembersInjector是接口，哪里实现这个接口的呢？见初始化的initialize方法，里面SecondActivity_MembersInjector实现了secondActivityMembersInjector接口。
之后看SecondActivity_MembersInjector：

@Override

​
public void injectMembers(SecondActivity instance) {
​
  if (instance == null) {
​
    throw new NullPointerException("Cannot inject members into a null reference");
​
  }
​
  instance.thirdUserInfo = thirdUserInfoProvider.get();
​
  instance.thirdUserInfo2 = thirdUserInfo2Provider.get();
​
  instance.loginInfo = loginInfoProvider.get();
​
}

这里对SecondActivity中的对象完成了赋值，此时完成了注入的操作。
经过上述过程，完成了对SecondActivity依赖对象的注入。

简介：APT(AnnotationProcessing Tool)
现在很多主流库都使用了APT,比如Dagger2,ButterKnife,EventBus3等
代码样例参考：http://www.tuicool.com/articles/aIfaum6

dagger2****到底有哪些好****处****？(因地制宜)

---

增加开发效率、省去重复的简单体力劳动首先new一个实例的过程是一个重复的简单体力劳动，dagger2完全可以把new一个实例的工作做了，因此我们把主要精力集中在关键业务上、同时也能增加开发效率上。省去写单例的方法，并且也不需要担心自己写的单例方法是否线程安全，自己写的单例是懒汉模式还是饿汉模式。因为dagger2都可以把这些工作做了。

更好的管理类实例每个app中的ApplicationComponent管理整个app的全局类实例，所有的全局类实例都统一交给ApplicationComponent管理，并且它们的生命周期与app的生命周期一样。每个页面对应自己的Component，页面Component管理着自己页面所依赖的所有类实例。因为Component，Module，整个app的类实例结构变的很清晰。

解耦假如不用dagger2的话，一个类的new代码是非常可能充斥在app的多个类中的，假如该类的构造函数发生变化，那这些涉及到的类都得进行修改。设计模式中提倡把容易变化的部分封装起来。假如是通过用Inject注解标注的构造函数创建类实例，则即使构造函数变的天花乱坠，我们基本上都不需要修改任何代码。