tags: [dagger2,架构,android]
categories: dagger2
toc: true
img: /featureImg/dagger.jpg
summary: 先把dagger2用起来
—-

dagger2确实学习曲线比较陡峭，但是忘掉生命周期，忘掉局部单例，忘掉SubComponent这样的进阶用法，只用最基础最简单的部分一样可以给项目带来一定程度的便利

依赖的提供方式

  • @Inject注解构造器
  • @Provides注解提供依赖的方法

@Inject注解构造器-用来提供依赖

  • 表示该类可以作为依赖注入到依赖需求方
  • 如果构造器带参数，则这些参数也需要是可以提供的依赖，dagger2会自动找到这些依赖并注入
  • 对于有多个构造器的类，@Inject只能注解其中一个
  1. public class SimpleInjectExtraBean {
  2.     @Inject
  3.     public SimpleInjectExtraBean() {
  4.     }
  5. }

@Inject构造函数带参数的情况

构造函数中的参数需要是@Inject注解构造器的对象或者是@Provides方法提供的依赖

  1. public class SimpleInjectBean extends BaseBean {
  2.     public SimpleModuleBean mSimpleModuleBean;
  3.     public SimpleInjectExtraBean mSimpleInjectExtraBean;
  5.     @Inject
  6.     public SimpleInjectBean(SimpleModuleBean simpleModuleBean,
  7.             SimpleInjectExtraBean simpleInjectExtraBean) {
  8.         mSimpleModuleBean = simpleModuleBean;
  9.         mSimpleInjectExtraBean = simpleInjectExtraBean;
  10.     }
  11. }

@Module @Provides提供无法修改构造器的依赖

使用@Inject注解构造器是最简单的提供依赖的方式，但是如果是一个第三方库中的代码无法修改构造函数添加注解呢，这时候就需要module出场了

  1. @Module //@Module注解可以提供依赖的类
  2. public class SimpleModule {
  4.     @Provides // @Provides 注解提供依赖的方法
  5.     public SimpleModuleBean provideSimpleModuleBean() {
  6.         return new SimpleModuleBean();
  7.     }
  8. }

@Provides注解的方法带参数

和@Inject注解的构造函数带的参数一样，也需要是@Inject注解构造器的对象或者是@Provides方法提供的依赖

依赖的接收方式

@Inject注解实例变量-用来接受依赖

  1. public class SimpleActivity extends AppCompatActivity {
  2.     @Inject
  3.     SimpleInjectBean mSimpleInjectBean;
  4.     ...
  5. }

连接依赖提供方和依赖接收方的Component

component是依赖提供方和依赖需求方的连接者，使用@Component注解，注意dagger2只能注解接口和抽象类，具体类注解了也生成不了注入相关的代码

对于@Inject不需要在Component中显示指定

对于module，需要在用@Component的modules属性显示指定

  1. @Component(modules = SimpleModule.class)
  2. public interface SimpleComponent {
  3.     void inject(SimpleActivity simpleActivity);
  4. }

框架会生成DaggerXXXComponent的类，使用DaggerXXXComponent完成注入

  1. public class SimpleActivity extends AppCompatActivity {
  2.     @Inject
  3.     SimpleInjectBean mSimpleInjectBean;
  4.     @Inject
  5.     SimpleInjectExtraBean mSimpleInjectExtraBean;
  6.     @Inject
  7.     SimpleModuleBean mSimpleModuleBean;
  8.     ...
  9.     private SimpleComponent mSimpleComponent;
  11.     @Override
  12.     protected void onCreate(@Nullable Bundle savedInstanceState) {
  13.         super.onCreate(savedInstanceState);
  14.         mSimpleComponent = DaggerSimpleComponent.create();
  15.         mSimpleComponent.inject(this);
  16.         ...
  17.     }
  18. }

以上就用dagger2实现了最简单的依赖注入
不过这基本上接近于写了一个HelloWorld
下面看一下更接近真实的简单场景

提供一个运行时的依赖

dagger2实现依赖注入的实质是创建编译期可以确定的所有类的工厂，在运行时通过dagger2生成的工厂代码（依赖注入框架内部）完成依赖的创建与管理

但是像Application，Activity这样的对象的创建过程是android框架完成的，dagger2无法接管这个过程，而非常多的对象的创建会依赖于context，activity这样的对象

为了解决这样的问题，需要将这些运行时对象作为参数提供给dagger框架

为dagger框架提供参数有两种方式

构造器带参数的Module

以Application为例

  1. @Module
  2. public class BaseAppModule {
  3.     private Application mApplication;
  5.     public BaseAppModule(Application application) {
  6.         mApplication = application;
  7.     }
  9.     @Provides
  10.     @Singleton
  11.     Application provideApplication() {
  12.         return mApplication;
  13.     }
  15.     @Provides
  16.     @Singleton
  17.     Context provideContext() {
  18.         return mApplication;
  19.     }
  20. }

Component的获取方式也会变化

  1. //before Component依赖的所有module的构造函数都没带参数，则可以直接通过DaggerXXXComponent.create()直接获取对应的Component实例
  2. DaggerBaseAppComponent.create();
  3. //等价于DaggerXXXComponent.builder().build();
  4. DaggerBaseAppComponent.builder().build();
  6. //after 如果module中带了参数，则编译期不会生成create()方法
  7. //需要使用.builder()传入对应的Module作为参数，这时可以将Application实例作为Module的构造参数传入
  8. DaggerBaseAppComponent.builder().baseAppModule(new BaseAppModule(this)).build();

直接通过@Component.Builder传入参数

@Component.Builder注解一个用来向Component绑定参数的接口

这里以Activity为例,在Component.Builder中使用@BindsInstance注解一个传入Activity的方法

  1. //provideSimpleModuleActivityBean有一个Activity作为参数
  2. @Module
  3. public class SimpleModule {
  5.     @Provides
  6.     public SimpleModuleActivityBean provideSimpleModuleActivityBean(Activity activity) {
  7.         return new SimpleModuleActivityBean(activity);
  8.     }
  9. }
  11. @Component(modules = SimpleModule.class)
  12. public interface SimpleComponent {
  13.     void inject(SimpleActivity simpleActivity);
  15.     @Component.Builder
  16.     interface Builder {
  17.         //创建Component的时候绑定实例
  18.         @BindsInstance
  19.         Builder simpleActivity(Activity simpleActivity);
  21.         SimpleComponent build();
  22.     }
  23. }

注意：如果SimpleModule构造函数还带了参数，因为此时的Component.Builder是按照我们定义的而不是完全自动生成的，所以为能够传入Module中需要的参数，需要显式指定该module作为builder的参数

  1. @Component(modules = SimpleModule.class)
  2. @SimpleScope
  3. public interface SimpleComponent {
  4.     void inject(SimpleActivity simpleActivity);
  6.     @Component.Builder
  7.     interface Builder {
  8.         //创建Component的时候绑定实例
  9.         @BindsInstance
  10.         Builder simpleActivity(Activity simpleActivity);
  12.         //使用了Builder就需要显式的指定带参数的module作为builder的参数
  13.         Builder simpleModule(SimpleModule simpleModule);
  15.         SimpleComponent build();
  16.     }
  17. }

总结

这篇文章介绍了为dagger提供依赖和注入依赖以及提供运行时参数的方法，不过离真实场景还是有一定的区别那就是生命周期的管理

下一篇文章将介绍dagger2中依赖的生命周期管理

相关文章

dagger2从入门到放弃-概念
dagger2从入门到放弃-最基础的用法介绍
dagger2从入门到放弃-Component的继承体系、局部单例
dagger2从入门到放弃-ActivityMultibindings
dagger2从入门到放弃-dagger.android
dagger2从入门到放弃-其他用法
dagger2从入门到放弃-多模块项目下dagger的使用
dagger2从入门到放弃-为何放弃

参考资料

https://google.github.io/dagger/
https://github.com/google/dagger
使用Dagger 2依赖注入
Dagger 2 完全解析

示例代码

DaggerInAction
欢迎star
master分支上最新的代码可能会比当前文章的示例代码稍微复杂点，提交记录里包含了每一步的迭代过程,可以顺藤摸瓜