Dagger的简单使用

Dagger2的简单使用

一、简单介绍

Dagger是一个依赖注入框架，所谓依赖注入其实是一种编程模式，目的是为了降低程序耦合。

1、基本概念

Inject：用于在需要注入以来的地发那个进行朱姐

Module：用于提供依赖，告诉Dagger从哪里去寻找依赖，一个App通常是一个或多个Module组成

Provide：用这个方法表示注解

Component：注入器，是Inject和Module的桥梁，用于连接这2个部分

二、基本使用

添加依赖

implementation 'com.google.dagger:dagger:2.19'
annotationProcessor 'com.google.dagger:dagger-compiler:2.19'

1、基本使用（不使用Module）

（1）将我们需要注入的对象使用@Inject标注，告诉dagger2我们需要实例化这个类

public class Student {

    private static final String TAG = "Student";

    @Inject
    public Student() {
    }

    public void say() {
        Log.i(TAG, "say: 我们是学生");
    }
}

（2）创建一个接口，并使用@Component标注，然后写inject方法，这个方法表示，我们需要将依赖注入的位置

@Component
public interface PersonComponent {
    void inject(NoModuleActivity noModuleActivity);
}

（3）编译程序(Ctrl+F9)后，我们可以在我们需要注入的类中，先通过@Inject标注我们需要注入的类，然后使用系统生成的Component方法，系统会在我们的Component方法钱加上Dagger，因为我们需要注入类的构造方法没有参数，因此我们使用create()方法，然后注入我们的变量，这样我们就可以使用这个对象了

public class NoModuleActivity extends AppCompatActivity {

    @Inject
    Student mStudent;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_no_module);
        
        DaggerPersonComponent.create().inject(this);
        mStudent.say();
    }
}

（4）打印的日志如下，这就表示我们的对象注入成功了

10-31 21:53:28.753 1140-1140/com.example.active.loser.dagger I/Student: say: 我们是学生

注：我们可以发现，我们不使用module也是很简单，且可以获取对象，但是我们若是使用第三方的一些库对象就必须使用module了，因为我们无法对他们的构造函数添加注解

2、module使用(无参)

假设我们需要提供Retrofit

（1）添加Retrofit的依赖

implementation 'com.squareup.retrofit2:retrofit:2.4.0'

（2）创建module，这个类的写法通常以module结尾，并将这个类用@Module表示，然后创建一个类，并写一个方法，返回我们的对象，通常用 provide开头，并使用@Provides表示

@Module
public class RetrofitModule {
    @Provides
    public Retrofit provideRetrofit(){
        return new Retrofit.Builder()
                .baseUrl("https://www.hao123.com/")
                .build();
    }
}

（3）创建一个接口，并使用@Component标注，并在括号里引入我们的Module，然后写inject方法，这个方法表示，我们需要将依赖注入的位置

@Component(modules = {RetrofitModule.class})
public interface RetrofitComponent {
    void inject(Module1Activity module1Activity);
}

（4）使用

public class Module1Activity extends AppCompatActivity {

    private static final String TAG = "Module1Activity";
    @Inject
    Retrofit mRetrofit;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_module1);
        DaggerRetrofitComponent.create().inject(this);
        Log.i(TAG, "onCreate: " + mRetrofit.hashCode());
    }
}

输出信息：

10-31 22:13:18.233 1495-1495/com.example.active.loser.dagger I/Module1Activity: onCreate: 1249382912

2、module使用(有参)

Module有参数的使用和没有参数的使用方式基本相同，我们只在绑定的视图中绑定。

（1）我们还是用上面的例子，但是URL需要动态指定：

@Module
public class RetrofitModule {

    String url;

    public RetrofitModule(String url) {
        this.url=url;
    }

    @Provides
    public Retrofit provideRetrofit(){
        return new Retrofit.Builder()
                .baseUrl(url)
                .build();
    }
}

（2）使用的时候，我们通过builder()模式，然后传参。

public class Module1Activity extends AppCompatActivity {

    private static final String TAG = "Module1Activity";

    @Inject
    Retrofit mRetrofit;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_module1);
        DaggerRetrofitComponent.builder()
                .retrofitModule(new RetrofitModule("https://www.hao123.com/"))
                .build()
                .inject(this);
        Log.i(TAG, "onCreate: " + mRetrofit.hashCode());
    }
}

（3）输出：

10-31 22:25:40.866 1178-1178/? I/Module1Activity: onCreate: 1249612184

扩展：我们可能想到，假如我们的构造函数需要传入对象，那这个对象有2中方式获得，第一种写一个provide方法，第二种将我们需要传入的对象的构造方法用@Inject标注，另外，若构对象的造函数需要参数，一方面可以使用Module传入，另一个方面可以使用provide提供这个参数对象。

三、扩展使用

1、 include

》》Module依赖Module《《

include：可以简单的理解为Module和Module之间的监交互，使用的原因是因为若我们在RetrofitModule中和ModuleA中均需要使用Retrofit，我们只需要在RetrofitModule中提供Retrofit,在ModuleA中通过include引用RetrofitModule就可以使用了。

（1）假设我们需要在ApiServer使用Retrofit，我们通过构造参数传入

public class ApiServer {
    private Retrofit mRetrofit;

    public ApiServer(Retrofit retrofit) {
        mRetrofit = retrofit;
    }
}

（2）创建ApiServerModule，我们提供provideApiServer,然后用过includes引入RetrofitModule.class，这样RetrofitModule就可以使用RetrofitModule中的Retrofit了

@Module(includes = {RetrofitModule.class})
public class ApiServerModule {

    @Provides
    public ApiServer provideApiServer(Retrofit retrofit) {
        return new ApiServer(retrofit);
    }
}

(3）创建ApiServerComponent

@Component(modules = {ApiServerModule.class})
public interface ApiServerComponent {
    void inject(IncludeActivity includeActivity);
}

（4）使用

public class IncludeActivity extends AppCompatActivity {

    private static final String TAG = "IncludeActivity";

    @Inject
    ApiServer mApiServer;
    @Inject
    Retrofit mRetrofit;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_include);

        DaggerApiServerComponent.builder()
                .apiServerModule(new ApiServerModule())
                .retrofitModule(new RetrofitModule("https://www.hao123.com/"))
                .build()
                .inject(this);

        Log.i(TAG, "ApiServer: " + mApiServer.hashCode()+"Retrofit: " + mRetrofit.hashCode());
    }
}

（5）通过打印，我们可以看出已经使用Retrofit和ApiServer了。

10-31 22:49:07.806 1363-1363/com.example.active.loser.dagger I/IncludeActivity: ApiServer: 1249565216Retrofit: 1249369216

2、dependence & subComponent

》》Component依赖Component《《

当我们其中一个Component跟另外一个Component所提供的依赖有重复的时候，我们没有必要完全再写一遍，一个Component是可以依赖另外一个依赖的，理解起来就像extends，我们㓟

2.1、dependence：

父Component中要显式的写出需要暴露可提供给子Component的依赖；
子Component在注解中使用dependencies=来连接父Component；

使用

(1)我们还是使用之前的RetrofitComponent，我们用Retrofit getRetrofit();暴露可提供给子Component的依赖；

@Component(modules = {RetrofitModule.class})
public interface RetrofitComponent {

    Retrofit getRetrofit();

    void inject(Module1Activity module1Activity);

    void inject(DependenceActivity dependenceActivity);
}

(2)子Component在注解中使用dependencies=来连接父Component；

@Component(dependencies = {RetrofitComponent.class})
public interface DependenceComponent {
    void inject(DependenceFragment dependenceFragment);
}

(3)我们通常有很多方法既需要在Activity中使用，也需要在Fragment使用，下面通过简单的例子

public class DependenceActivity extends AppCompatActivity {
    private RetrofitComponent mRetrofitComponent;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_dependence);
        mRetrofitComponent = DaggerRetrofitComponent.builder()
                .retrofitModule(new RetrofitModule("https://www.hao123.com/"))
                .build();
        getSupportFragmentManager()
                .beginTransaction()
                .replace(R.id.fragment, new DependenceFragment())
                .commit();
    }

    //提供RetrofitComponent
    public RetrofitComponent getRetrofitComponent() {
        return mRetrofitComponent;
    }
}

public class DependenceFragment extends Fragment {

    private static final String TAG = "DependenceFragment";

    @Inject
    Retrofit mRetrofit;
    
    //........

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        RetrofitComponent retrofitComponent = ((DependenceActivity) getActivity())
                .getRetrofitComponent();
        if (retrofitComponent!=null) {
            DaggerDependenceComponent.builder()
                    .retrofitComponent(retrofitComponent)
                    .build()
                    .inject(this);
            Log.i(TAG, "onViewCreated: "+mRetrofit.hashCode());
        }
    }
}

输出

11-03 18:45:16.200 1446-1446/com.example.active.loser.dagger I/DependenceFragment: onViewCreated: 1249920380

2.2、subComponent：

Subcomponent的使用方法与dependence基本相同

先定义子Component，使用@Subcomponent标注（不可同时再使用@Component）；

@Subcomponent
public interface SubComponent {
    void inject(DependenceFragment dependenceFragment);
}

父Component中定义获得子Component的方法；

@Component(modules = {RetrofitModule.class})
public interface RetrofitComponent {
    void inject(DependenceActivity dependenceActivity);

    SubComponent getSubComponent();
}

3、@Singleton & @Scope

》》Component和Module《《

@Scope其实是一个 元注解，用于描述注解的注解，其中@Singleton是Scope默认提供的，表示单例，说到单例我们用一段简单的例子说明@Singleton& @Scope。

3.1、全局单例：

整个应用内只会存在一个对象，这也是我们在开发中常用的一种设计模式，一般写法都是这样:设计模式之单例，但是用了Dagger之后，我们只需要在需要创建单例的Module和Component添加@Singleton注解。

@Module
public class AppModule {

    //.......
 
    @Provides
    @Singleton//全局单例
    SharedPreferences provideSharedPreferences() {
        return application.getSharedPreferences("spfile", Context.MODE_PRIVATE);
    }
 
    @Provides
    MyApplication provideApplication() {
        return application;
    }
 }

@Singleton
@Component(modules = AppModule.class)
public interface AppComponent {
 
    SharedPreferences sharedPreferences();
 
    MyApplication myApplication();
}

3.2、局部单例：

局部单例简单的就是说我们的对象在某个Activity和Fragment中是单例，但在不同的View中则没有关系。

（1）自定义@Scope

@Scope  //声明这是一个自定义@Scope注解
@Retention(RUNTIME)
public @interface ActivityScope {
}

(2) 在Module中添加我们定义的注解

@Module
public class ActivityModule {
 
    private TestActivity activity;
    public ActivityModule(TestActivity activity) {
        this.activity = activity;
    }
 
    @Provides
    @ActivityScope//添加我们自定义的注解
    Student provideStudent() {
        return new Student();
    }
}

(3) 在Component中添加我们定义的注解

@ActivityScope//添加我们自定义的注解
@Component(modules = TestModule.class, dependencies = AppComponent.class)
public interface TestComponent { 
    void inject(TestActivity activity);
}

最后编辑于：2018.11.09 22:06:55

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