Dagger2-从入门到精通(下)

前言

继上篇文章，这篇我们来学习Dagger2的高级用法。如果没看上篇文章的话最好先看下上篇文章再来学习本章，因为本章是接续上篇文章来写的，直接来看的话可能效果不是很好，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 {
            mApiService1.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: mApiService1= .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，然后MainActivity创建对象后直接跳转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。
    clipboard.png

  • 但是其他scope的组件 可以依赖其他组件：


    clipboardd.png

@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构建项目时候使用的，可能学习的不是很深入。不过相信把这两篇文章的代码敲一边。平常的使用一定没有问题的。最后希望大家一起加油！！！

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 158,560评论 4赞 361
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 67,104评论 1赞 291
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 108,297评论 0赞 243
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 43,869评论 0赞 204
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,275评论 3赞 287
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,563评论 1赞 216
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,833评论 2赞 312
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,543评论 0赞 197
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,245评论 1赞 241
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,512评论 2赞 244
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,011评论 1赞 258
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,359评论 2赞 253
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,006评论 3赞 235
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,062评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,825评论 0赞 194
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,590评论 2赞 273
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,501评论 2赞 268

推荐阅读更多精彩内容