深入浅出，一篇文章让你学会Dagger2使用

本篇文章已授权微信公众号 guolin_blog （郭霖）独家发布

前言

最近在做项目中，用到了Dagger2，所以找了一些博客并参考了菜鸟窝Ivan的视频，算是知道如何使用了，但是对其理解还相差很远。所以这篇文章重点针对如何使用和使用中常见的一些问题。
本文由上下2篇文章整合在一起。可能有些长，但是读起来会很爽

---

Dagger2

根据官网来说他就是一个快速的依赖注入框架。如果对依赖注入不太了解，那么请看这篇文章依赖注入原理，在这里我就不过多介绍了。其实他的作用重点就是解耦和管理实例对象。那我们看看他具体有什么好处：

1. 依赖的注入和配置独立于组件之外，注入的对象在一个独立、不耦合的地方初始化，这样在改变注入对象时，我们只需要修改对象的实现方法，而不用大改代码库。

2. 依赖可以注入到一个组件中：我们可以注入这些依赖的模拟实现，这样使得测试更加简单。

3. app中的组件不需要知道有关实例创建和生命周期的任何事情，这些由我们的依赖注入框架管理的

这是网上的一切说法。对于文字我们不好理解，还是看看在具体应用中我们该如何去使用。不过在使用之前我们先简单的理解及概念。
@Inject:
通常在需要依赖的地方使用这个注解。换句话说，你用它告诉Dagger这个类或者字段需要依赖注入。这样，Dagger就会构造一个这个类的实例并满足他们的依赖。

@Module:
Modules类里面的方法专门提供依赖，所以我们定义一个类，用@Module注解，这样Dagger在构造类的实例
时候，就知道从哪里去找到需要的 依赖。modules的一个重要特征是它们设计为分区并组合在一起（比如说，
我们的app中可以有多个组成在一起的modules）

@Provide:
在modules中，我们定义的方法是用这个注解，以此来告诉Dagger我们想要构造对象并提供这些依赖。

@Component:
Components从根本上来说就是一个注入器，也可以说是@Inject和@Module的桥梁，它的主要作用就是连接这两个部分。
读不懂也没关系，我们接下来实战代码。在讲解后在结合概念我们就能很好的理解了

---

引入

引入方法有2种：
第一种：
在工程的build.gradle文件中添加android-apt插件（该插件后面介绍）

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中。

• 能够根据设置的源路径，在编译时期生成相应代码。

在导入类库时，

    compile 'com.google.dagger:dagger:2.4'
    apt 'com.google.dagger:dagger-compiler:2.4'

dagger是主要的工具类库。dagger-compiler为编译时期生成代码等相关的类库。

在android-apt的文档中，也推荐使用这种方式。因为，编译时期生成代码的类库在运行期并不需要，那么将其分为两个库，（运行类库dagger）和（编译器生成代码类库（dagger-compiler）），那么在打包时，就不需要将dagger-compiler打入其中（用不到），减小APK 的大小

---

第二种：
这种方法比较简单(Android Studio2.2以上)，直接引入依赖

 compile 'com.google.dagger:dagger:2.9'
 annotationProcessor 'com.google.dagger:dagger-compiler:2.9'

推荐第一种方式

---

实践(基本用法)

public class ApiService {

    public void register() {
        //注册的方法
         Log.i("TAG", "ApiService: ");
    }

}

public class UserStroe {

    public void login(){
        //登录的方法
    }
}

首先假设我们现在有两个方法，一个是注册，另一个是登录。如果我们现在MainActivity中调用register();我们一般会这么写：

ApiSeivie apiServce=new ApiService();
apiService.register();

如果们们使用Dagger2该如何使用呢？
- module
首先：我们先创建module(他是主要提供实例的类)，这里我们定义为UserModule：

@Module
public class UserModule {

    public UserModule() {
    }

    @Provides
    public ApiService provideApiService() {
        return new ApiService();
    }
}

@Module:
Modules类里面的方法专门提供依赖，所以我们定义一个类，用@Module注解，这样Dagger在构造类的实例
时候，就知道从哪里去找到需要的依赖。

@Provide:
在modules中，我们定义的方法是用这个注解，以此来告诉Dagger我们想要构造对象并提供这些依赖。

现在我们回头在看看概念是不就明白其中的含义了。

可以看到我们在MainActivity中需要ApiService，我们在module中创建他的实例。等他需要的时候我们就给他。现在module创建好了。我们还需要调用者(MainActivity)和被调用者(module)之间的桥梁，这就是Component。

注意，在module中，我们创建的方法必须是public不可以是privite。这个也很好理解。我们创建的方法本来就是给外界调用的，如果你用privite的话只能本类使用了。

Component：

@Component(modules = {UserModule.class})
public interface UserComponet {

    void inject(MainActivity activity);
}

注意：inject方法接收父类型参数，而调用时传入的是子类型对象则无法注入。比如你想作用BaseActivity，inject()就传入BaseActivity,但是只能作用BaseActivity不能作用子类MainActivity。反之亦然；

@Component：
我们定义UserComponet并加上@Component注解。表明他是一个桥梁。首先他必须是一个接口。其次我们必须依赖一个module(当然，从{}这个符号我们就可以看到，他可以同时依赖多个module)，它还有另一参数dependencies，这里我们先不说他，等后面讲到了再说他。这里我们看到他里面只有一个方法 void inject().这里我们传入MainActivity，因为我们想在这个类中使用我们实例ApiService。这样module和MainActivity通过Component就关联起来了。创建好这些类以后我们需要Rebuild Progect。

这是会生成一个DaggerUserComponet类，这个类命名是以Dagger开头接上我们UserComponet类名。这个类方法很少，主要就是将我们的MainActivity和Component关联起来，通过：

DaggerUserComponet.create().inject(this);

将我们的MainActivity传入Component的inject()方法中，这样这个桥梁就就通了，我们就可以使用了，如下：

public class MainActivity extends AppCompatActivity {


    @Inject
    ApiService mApiService;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        DaggerUserComponet.create().inject(this);
        mApiService.register();
        Log.d("TAG", "onCreate: " + mApiService);
    }
}

注意 这里我们 @Inject注解的对象不能用privite修饰。

在我们的想要的创建的对象加上@Inject注解并且调用DaggerUserComponet.create().inject(this);后我们就可以使用这个对象了。我们运行看看结果：

dagger2 D/TAG: ApiService: 
com.example.ggxiaozhi.dagger2 D/TAG: onCreate: com.example.ggxiaozhi.dagger2.ApiService@4a7c73b4

可以看到正常运行没有问题了。实例对象已经被我们创建出来了。为们用2张图总结一下：

这张图从概念出发，我们再从我们的例子中总结出来经验概括就是这样的：

---

明白了流程后那他是怎么解耦的呢？使用方法就这么简单就结束了吗？答案是肯定的。我们一定不止这么简单，关于解耦的话我就举一个简单的例子。之前我们创建了2个类注册和登录，现在我们再创建一个类去管理他们：

public class UserManager {

    UserStroe mUserStroe;
    ApiService mApiService;

    public UserManager() {
        mApiService = new ApiService();
        mUserStroe = new UserStroe();
    }

    public void register() {
        mApiService.register();
        mUserStroe.login();
    }
}

然后我们在MainActivity中去调用UserManager中的register方法。这么一个看好像是没什么问题，但是如果我们mApiService.register();需要一个Context参数怎么办？你可能会这么该：

public class UserManager {

    UserStroe mUserStroe;
    ApiService mApiService;

    public UserManager(Context context) {
        mApiService = new ApiService(context);
        mUserStroe = new UserStroe();
    }

    public void register() {
        mApiService.register();
        mUserStroe.login();
    }
}

调用处new UserManager(this);但是你注意看，我们只是需要一个context就要将UserManager和MainActivity中的代码都要改，要是在实际项目中，需要改更多的参数呢？所以我们来看下用Dagger2该如何解决。这里我把需求再复杂话一些。首先我们还是先从module来看：
这里我们将例子复杂一下假设ApiService需要一个context，userStroe需要一个url。我们就可以这样写

@Module
public class UserModule {

    Context context;

    public UserModule(Context context) {
        this.context = context;
    }

    @Provides
    public ApiService provideApiService() {
        return new ApiService(context);
    }
    @Provides
    public String providerUrl() {
        return "www.baidu.com";
    }

    @Provides
    public UserManager provideUserManager(ApiService apiService, UserStroe userStroe) {
        return new UserManager(userStroe, apiService);
    }
}

public class UserManager {
    UserStroe mUserStroe;
    ApiService mApiService;

    public UserManager(UserStroe mUserStroe, ApiService mApiService) {
        this.mUserStroe = mUserStroe;
        this.mApiService = mApiService;
    }

    public void register() {
        mApiService.register();
        mUserStroe.login();
    }
}

 public class UserStroe {

    @Inject
    public UserStroe(String url) {
        Log.d("TAG", "UserStroe: " + url);
    }

    public void login() {
        Log.d("TAG", "UserStroe: ");
    }
}  

public class MainActivity extends AppCompatActivity {


    @Inject
    UserManager mManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        DaggerUserComponet.builder().userModule(new UserModule(this)).build().inject(this);
        mManager.register();
        Log.d("TAG", "onCreate: " + mManager);
    }
}

这里我们创建DaggerUserComponet用了方法：

 DaggerUserComponet.builder().userModule(new UserModule(this)).build().inject(this);

这个方法与之前用的其实内部都是一样的，因为我们UserModule需要context参数，所以我们选择这种构建方法

可以看到在创建对象时我们可以在module中像之前一样提供一个创建的方法，第二种我们也可以通过在对象的构造函数上加上@Inject注解，这里我们需要一个url和context，我们只需要提供一个创建String的url方法即可，并通过UserModule的构造函数将conetxnt传入，最后提供一个创建UserManager的方法将两个参数穿进去，最后运行一下：

dagger2 D/TAG: UserStroe: www.baidu.com
com.example.ggxiaozhi.dagger2 D/TAG: ApiService: 
com.example.ggxiaozhi.dagger2 D/TAG: UserStroe: 
com.example.ggxiaozhi.dagger2 D/TAG: onCreate: com.example.ggxiaozhi.dagger2.UserManager@4a7c6f00

可以看到我们修改了这么多，又需要URL，又需要context但是我们创建UserManager和调用方法没变，因为我们只是需要UserManager中的方法，里面你需要什么，怎么实现的对MainActivity它并不关心。所以这样就大大做到了解耦的目的。其实使用Dagger2就说白了就是调用者需要什么实例我就在module中创建什么实例，如果这个实例需要参数，需要什么参数，我就在mudule给你创建你想要的参数。

---

实践(高级用法)

上面在学习了Dagger2的基本用法后下面我们来看下它的高级用法

---

注解

• @Qualifier: 要作用是用来区分不同对象实例
  @Named 其实是@Qualifier的一种实现
• Scope
• Subcomponent
• Lazy与Provider

@Qualifier

上面也提到了，作用是用来区分不同对象的实例的。平时我们可能会对一个类创建不同的构造方法以满足不同的需求，假设现在现在ApiSevice有2个构造方法，根据不同情况调用不同方法。这时就要用到@Named标签(@Named是@Qualifier的一种实现).

public class ApiService {

    public ApiService(Context context) {

    }

    public ApiService(String url) {
        Log.d("TAG", "ApiService: " + url);
    }

    public void register() {
        Log.d("TAG", "ApiService: ");
    }

}

可以看到ApiService有2个不同的构造方法，并且参数不同。下面我们就要在UserModule分别创建这两个对象的实例。

@Module
public class UserModule {

    Context context;

    public UserModule(Context context) {
        this.context = context;
    }

    @Provides
    @Named("dev")
    public ApiService provideApiServiceDev(String url) {
        ApiService apiService = new ApiService(url);
        Log.d("TAG", "provideApiServiceDev: " + apiService);
        return apiService;
    }

    @Provides
    @Named("release")
    public ApiService provideApiServiceRelease() {
        ApiService apiService = new ApiService(context);
        Log.d("TAG", "provideApiServiceRelease: " + apiService);

        return apiService;
    }

    @Provides
    public Context provideContext() {
        return context;
    }

    @Provides
    public String providerUrl() {
        return "www.baidu.com";
    }


    @Provides
    public UserManager provideUserManager(ApiService apiService, UserStroe userStroe) {
        return new UserManager(userStroe, apiService);
    }
}

可以看到我们为ApiService分别提供了2个构造方法但参数不同。然后分别用@Named(“dev”)和@Named(“release”)注解，表明这是2个不同的构造方法。

(提问：这里为什么我们可以直接引用参数参数中的context和url呢？因为我们提供了providerUrl()和provideContext()所以可以直接使用)

那么我们看下MainActivity中如何调用的：

    @Named("dev")
    @Inject
    ApiService mApiService;

    @Named("release")
    @Inject
    ApiService mApiService1;
    private boolean is_Dev = true;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        DaggerUserComponet.builder().userModule(new UserModule(this)).build().inject(this);
        Log.d("TAG", "mApiService= " + mApiService);
        Log.d("TAG", "mApiService1= " + mApiService1);
        if (is_Dev) {
            mApiService.register();
        } else {
            mApiService.register();
        }
    }
}

可以看到我们在modle中用@Named区分，在使用是只需在 @Inject时添加上@Named注解就会创建对应注解的实例，然后我们用一个is_Dev标签，表明不同情况使用不同的对象。我们来看下打印结果：

 D/TAG: ApiService: www.baidu.com
 D/TAG: provideApiServiceDev: .ApiService@4a7c44c8
 D/TAG: provideApiServiceRelease: .ApiService@4a7c477c
 D/TAG: mApiService= .ApiService@4a7c44c8
 D/TAG: mApiService= .ApiService@4a7c477c

注意：我们在Moudle用了@Named标签，在调用时也需要加上@Named标签，如果在调用处不使用@Named注解就需要在Moudle中创建对应没有用@Named注解的实例方法

通过字符串标记一个对象，容易导致前后不匹配，所以除了使用这种方法，我们还可以通过自定义注解的方式。
那么如何实现自定义注解@Qualifier呢？很简单，@Named就是@Qualifier的一种实现，我看他是怎么实现的，我们就照葫芦画瓢被：

@Qualifier
@Documented
@Retention(RUNTIME)
public @interface Named {

    /** The name. */
    String value() default "";
}

• @Qualifier ：注明是Qualifier(关键词)

• @Documented ：标记在文档

• @Retention(RUNTIME) ：运行时级别
  可以看到@Qualifier决定它关键性的作用是用来区分不同对象的。里面的String类型就是我们之前填写的(“dev”)和(“release”)用来区分的，那么我也照着写我们的自定义的标签：

@Qualifier
@Retention(RUNTIME)
public @interface Dev {

}

@Qualifier
@Retention(RUNTIME)
public @interface Release {

}

我们创建了2个自定义注解，当然你全赋值过来也是没有问题的，这里我去掉了不必要的部分。因为本身我们就不像用字符串区分了，所以我把字符串参数去掉了。

  @Provides
    @Release
    public ApiService provideApiServiceDev(String url) {
        ApiService apiService = new ApiService(url);
        Log.d("TAG", "provideApiServiceDev: " + apiService);
        return apiService;
    }

    @Provides
    @Dev
    public ApiService provideApiServiceRelease() {
        ApiService apiService = new ApiService(context);
        Log.d("TAG", "provideApiServiceRelease: " + apiService);
        return apiService;
    }  

    @Dev
    @Inject
    ApiService mApiService;

    @Release
    @Inject
    ApiService mApiService1;

用法和上面是结果是一样的。

---

@Singleton

我们先看下他的里面是什么样子的：

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

友情提示：我刚学习的时候就总搞不懂总以为@Scope，@Singleton，@Qualifier，@Named是4个不同作用的操作符，其实他就是两两一对的，@Named是@Qualifier具体实现，@Singleton是@Scope的具体实现；@Scope和@Qualifier类似不同作用注解的关键字

他就是用@Scope注解修饰的注解。这样我们就知道了。那么首先我们来看下，如果不用单例什么样的：

    @Inject
    ApiService mApiService1;

    @Inject
    ApiService mApiService2;
    private boolean is_Dev = true;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        DaggerUserComponet.builder().userModule(new UserModule(this)).build().inject(this);

        Log.d("TAG", "mApiService1= " + mApiService1);
        Log.d("TAG", "mApiService2= " + mApiService2);
    }
}

结果：

D/TAG: mApiService1= .ApiService@4a7c7904
D/TAG: mApiService2= .ApiService@4a7c7aa8

可以看到确实创建了2个实例，那么如何使用单例注解：
首先在Module中将创建实例的方法加上@Singleton

@Singleton
@Provides
public ApiService provideApiService() {
     ApiService apiService = new ApiService(context);
     Log.d("TAG", "provideApiService: " + apiService);
     return apiService;
    }    

然后在@Component中也加上@Singleton：

@Singleton
@Component(modules = {UserModule.class})
public interface UserComponet {

    void inject(MainActivity activity);
}

@Singleton在使用时调用处正常书写：

@Inject
ApiService mApiService1;

@Inject
ApiService mApiService2;

打印结果：

provideApiService: com.example.ggxiaozhi.dagger2.ApiService@4a7c5200   
mApiService1= com.example.ggxiaozhi.dagger2.ApiService@4a7c5200
mApiService2= com.example.ggxiaozhi.dagger2.ApiService@4a7c5200 

可以看到只调用了一次创建对象的方法。2个对象其实是一个实例。

注意：

• module 的 provide 方法使用了 scope ，那么 component 就必须使用同一个注解
• @Singleton 的生命周期依附于component，同一个module被不同的@Component依赖结果也不一样
  -@Singleton分为Activity级别单例生命周期和全局的生命周期单例
  这里第一点注意我们通过上面的事例比较容易理解，那么第二点是什么意思呢？这句话的意思在于@Singleton 的生命周期依附于component。那么实际测试下。我们在创建一个LoginAcyivity。并创建LogingConponent如下：

@Singleton
@Component(modules = UserModule.class)
public interface LoginComponent {
    void inject(LoginActivity activity);
}

LogingConponent也依赖UserModule.class。然后在LoginAcyivity中创建ApiService如下：

public class LoginActivity extends AppCompatActivity {

    @Inject
    ApiService mApiService;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);
        DaggerLoginComponent.builder().userModule(new UserModule(this)).build().inject(this);
        Log.d("TAG", "LoginActivity-->mApiService : "+mApiService);
    }
}

运行结果：

 D/TAG: provideApiService: com.example.ggxiaozhi.dagger2.ApiService@4a7c5994
 D/TAG: MainActivity-->mApiService1= com.example.ggxiaozhi.dagger2.ApiService@4a7c5994
 D/TAG: MainActivity-->mApiService2= com.example.ggxiaozhi.dagger2.ApiService@4a7c5994
 D/TAG: provideApiService: com.example.ggxiaozhi.dagger2.ApiService@4a7d54f8
 D/TAG: LoginActivity-->mApiService : com.example.ggxiaozhi.dagger2.ApiService@4a7d54f8

可以看你到LoginComponent和UserComponent都依赖UserMoudle，并且创建ApiService已经加了@Singleton注解但是在MainActivity中是单例但是在LoginActivity又创建了不同的ApiService的实例，这就是上面提到的因为LoginComponent和UserComponent为两个不同的@Component，@Singleton的生命周期依附于component，同一个module provide singleton ,不同component 也是不一样。所以会看到这样的结果。如果我们修改下代码呢？如下：

@Singleton
@Component(modules = {UserModule.class})
public interface UserComponet {

    void inject(MainActivity activity);
    void inject(LoginActivity activity);
}

然后在LoginActivity中也引用UserComponent而不去引用LogingComponent呢？

public class LoginActivity extends AppCompatActivity {

    @Inject
    ApiService mApiService;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);
        UserComponet userComponet = DaggerUserComponet.builder().userModule(new UserModule(this)).build();
        userComponet.inject(this);
        Log.d("TAG", "LoginActivity-->mApiService : "+mApiService);
        Log.d("TAG", "LoginActivity-->UserComponet : "+userComponet);
    }
}

这也也是不行的。为什么?看打印结果：

  D/TAG: provideApiService: com.example.ggxiaozhi.dagger2.ApiService@4a7c454c
 D/TAG: MainActivity-->mApiService1= com.example.ggxiaozhi.dagger2.ApiService@4a7c454c
 D/TAG: MainActivity-->mApiService2= com.example.ggxiaozhi.dagger2.ApiService@4a7c454c
 D/TAG: MainActivity-->UserComponet= com.example.ggxiaozhi.dagger2.DaggerUserComponet@4a7c382c
 D/TAG: provideApiService: com.example.ggxiaozhi.dagger2.ApiService@4a7d3ccc
 D/TAG: LoginActivity-->mApiService : com.example.ggxiaozhi.dagger2.ApiService@4a7d3ccc
 D/TAG: LoginActivity-->UserComponet : com.example.ggxiaozhi.dagger2.DaggerUserComponet@4a7d3c9c

可以看到，在UserComponet在LoginActivity和MainActivity中会创建2个不同的实例，当然会创建2个不同的mApiService了。如果像实现全局单例我就就要用到自定义@Scope注解。

---

自定义@Scope注解

上面是属于Activity生命周期单例。下面我们就创建全局生命周期单例。

1. 创建全局AppModule：

@Module
public class AppMoudle {
    private MyApplication context;

    public AppMoudle(MyApplication context) {
        this.context = context;
    }

    @Singleton
    @Provides
    public ApiService provideApiService() {
        ApiService apiService = new ApiService(context);
        Log.d("TAG", "provideApiService: " + apiService);
        return apiService;
    }
}

2. 创建全局AppComponent：

@Singleton
@Component(modules = AppMoudle.class)
public interface AppComponent {

    /**
     * 全局单例。所以不用Inject Activity
     *
     * @return 向下返回ApiService实例
     */
    ApiService getApiService();
}

3. 在MyApplication实例化AppComponent：

单例的依托于他所在的Component中，所以需要在Application中进行实例化。

public class MyApplication extends Application {

    private AppComponent mAppComponent;

    @Override
    public void onCreate() {
        super.onCreate();
        mAppComponent = DaggerAppComponent.builder().appMoudle(new AppMoudle(this)).build();
    }

    public AppComponent getAppComponent() {
        return mAppComponent;
    }
}

4.自定义@Scope：

@Scope
@Retention(RUNTIME)
public @interface PerActivity {
}

5. 让其他Component依赖：

@PerActivity
@Component(modules = {UserModule.class},dependencies = AppComponent.class)
public interface UserComponet {

    void inject(MainActivity activity);
}

@PerActivity
@Component(modules = UserModule.class,dependencies = AppComponent.class)
public interface LoginComponent {
    void inject(LoginActivity activity);
}

6. 调用

MainActivity：

DaggerUserComponet.builder().
                appComponent(((MyApplication)getApplicationContext()).getAppComponent()).
                build().inject(this);

LoginActivity：

DaggerLoginComponent.builder().
                 appComponent(((MyApplication)getApplicationContext()).getAppComponent()).
                 build().inject(this);

打印结果：

 D/TAG: provideApiService: com.example.ggxiaozhi.dagger2.ApiService@4a7c3e8c
 D/TAG: MainActivity-->mApiService1= com.example.ggxiaozhi.dagger2.ApiService@4a7c3e8c
 D/TAG: MainActivity-->mApiService2= com.example.ggxiaozhi.dagger2.ApiService@4a7c3e8c
 D/TAG: LoginActivity-->mApiService= com.example.ggxiaozhi.dagger2.ApiService@4a7c3e8c

可以看到这次全局都是用的一个单例了。

注意：

• 可以看到第4步我们自定义@Scope注解PerActivity，因为component的dependencies与component自身的scope不能相同，即组件之间的scope不同。所以我们自己定义。
• Singleton的组件不能依赖其他scope的组件，只能其他scope的组件依赖Singleton的组件 如下：
  AppComponent已经用@Singleton修饰就不能再去依赖（dependencies=XXX.class）别的Component。
  
• 但是其他scope的组件 可以依赖其他组件：
  

---

@Subcomponent

作用有些类似Component中的dependencies作用。特点：
1. Subcomponent同时具备两种不同生命周期的scope, SubComponent具备了父Component拥有的Scope，也具备了自己的Scope。
2. SubComponent的Scope范围小于父Component

我们用代码使用体会下：
FComponent

//第一步
@Module
public class FModule {

    @Singleton
    @Provides
    public User provideUser() {
        return new User();
    }
}
//第二步
@Singleton
@Component(modules = FModule.class)
public interface FComponent {
  //需要将SubComponent 追加到被依赖的Component中
    CComponent addCComponent();
}

//第三步
public class MyApplication extends Application {

    private AppComponent mAppComponent;

    private FComponent mFComponent;

    @Override
    public void onCreate() {
        super.onCreate();
        mAppComponent = DaggerAppComponent.builder().appMoudle(new AppMoudle(this)).build();
        mFComponent = DaggerFComponent.builder().build();
    }

    public AppComponent getAppComponent() {
        return mAppComponent;
    }

    public FComponent getFComponent() {
        return mFComponent;
    }
}

CComponent：

@Module
public class CModule {

    @PerActivity
    @Provides
    public UserStroe provideUser(User user) {
        return new UserStroe(user);
    }
}

@PerActivity
@Subcomponent(modules = CModule.class)
public interface CComponent {
    void Inject(Main2Activity activity);
}  

调用：

public class Main2Activity extends AppCompatActivity {
    private static final String TAG = "Main2Activity";
    @Inject
    UserStroe mUserStroe;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);
        ((MyApplication)getApplicationContext()).getFComponent().getCComponent().Inject(this);
        Log.d(TAG, "onCreate: "+mUserStroe);
    }
}

首先我们先创建FComponent，他属于App级别的。我们在MyApplication创建它。FComponent中调用者提供CComponent。然后有CComponent。这和我们之前使用有些不同。之前我们都是通过Avtivity级别创建，然后填入App级别的参数。这个使用正好相反。优势：

不需要在被依赖的Component显示提供依赖
不需要使用更多的DaggerXXXXComponent对象来创建依赖，仅需要在被依赖Component中增加 XXXComponent addXXComponent(XXXModule) 方法

这个如果不太理解也没有关系，会使用就行。

---

懒加载Lazy和强制重新加载Provider

这个比较简单，我就列举一个简单的例子。

public class Container{
    @Inject Lazy<User> lazyUser; //注入Lazy元素
    @Inject Provider<User> providerUser; //注入Provider元素
    public void init(){
        DaggerComponent.create().inject(this);
        User user1=lazyUser.get();  
//在这时才创建user1,以后每次调用get会得到同一个user1对象

        User user2=providerUser.get(); 
//在这时创建user2，以后每次调用get会再强制调用Module的Provides方法一次，
//根据Provides方法具体实现的不同，可能返回跟user2是同一个对象，也可能不是。
    }
}

注意事项（重要）分析

1. componet 的 inject 方法接收父类型参数，而调用时传入的是子类型对象则无法注入
2. component关联的modules中不能有重复的provide
3. module 的 provide 方法使用了 scope ，那么 component 就必须使用同一个注解
4. module 的 provide 方法没有使用 scope ，那么 component 和 module 是否加注解都无关紧要，可以通过编译
5. component的dependencies与component自身的scope不能相同，即组件之间的scope不同
6. Singleton的组件不能依赖其他scope的组件，只能其他scope的组件依赖Singleton的组件
7. 没有scope的component不能依赖有scope的component
8. 一个component不能同时有多个scope(Subcomponent除外)
9. @Singleton 的生命周期依附于component，同一个module provide singleton ,不同component 也是不一样
10. Component注入的Activity 在其他Component中不能再去注入
11. dagger2是跟着生命周期的绑定Activity（Fragment）onDestory 对象也会销毁
12. 创建实例的方法和引用实例都不能用private修饰

刚开始使用一定总会遇到很多错误，遇到错误不要着急。如果注意事项中的错误没有犯的话一定会减少很多错误。

---

结语

不知不觉写的有点多。对我这种菜鸟，看源码写博客。真的很费心，学过的技术忘的很快，很多东西理解不透彻，想把博客写好写深还是很有难度的。不过如果你看到了这篇文章，希望有错误很问题请留言一起探讨。Dagger2也是在我用MVP构建项目时候使用的，可能学习的不是很深入。不过相信把这两篇文章的代码敲一边。平常的使用一定没有问题的。最后希望大家一起加油！！！