本文是作者在学习Dagger2入门的一篇很好的文章,特此在此转载,非原创
Dagger官网
Dagger Document API
从零开始的Android新项目4
http://www.bozhiyue.com/anroid/boke/2016/0719/273761.html
环境配置
这里以Gradle配置为例子,实用得是AndroidStudio:
- 打开project 的 build.gradle ,添加
dependencies {
classpath 'com.android.tools.build:gradle:2.2.2'
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files
//dagger2
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
}
- 打开 app module 的 build.gradle,添加
apply plugin: 'com.android.application'
//dagger2
apply plugin: 'com.neenbedankt.android-apt'
//...
dependencies {
//...
//dagger2
compile 'com.google.dagger:dagger:2.4'
apt 'com.google.dagger:dagger-compiler:2.4'
compile 'org.glassfish:javax.annotation:10.0-b28'
}
- 然后sync gradle一下,环境就配置好了,在实用dagger2的时候,会自动生成一些类,所以最好记一下 build project的快捷键 ctrl+F9,写好dagger代码,然后build一下,就会自动生成 DaggerXXX 开头的一些类。
入门实例
好了,下面我们来看一个入门实例,实用Dagger2到底是怎么依赖注入的。
现在又一个Person类(这里为了简单起见),然后MainActivity中又一个成员变量person。
Person.java
public class Person {
public Person() {
System.out.println("a person created");
}
}
MainActivity.java
public class MainActivity extends AppCompatActivity {
Person person;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
person = new Person();
}
}
如果不适用依赖注入,那么我们只能在MainActivity中自己new一个Person对象,然后使用。
使用依赖注入:
public class MainActivity extends AppCompatActivity {
@Inject
Person person;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}
在Person对象上添加一个 @Inject
注解,即可自动注入对象。
那么问题来了,就一个@Inject
注解,系统就会自动给我创建一个对象? 当然不是,这个时候我们需要一个Person类的提供者。估计叫它: MainModule
MainModule.java
@Module
public class MainModule {
@Provides
Person providesPerson() {
System.out.println("a person created from MainModule");
return new Person();
}
}
里面两个注解,@Module
和 @Provides
,Module标注的对象,你可以把它想象成一个工厂,可以向外提供一些类的对象。那么到底提供什么对象呢?
@Provides
标注的方法就是提供对象的,这种方法一般会返回一个对象实例,例如上面返回一个 Person对象
那么好了,现在Perso类的提供者也有了,我们是不是可以运行起来了。ctrol+F9
build一下项目,然后运行。发现没有任何输出(如果创建Person对象,会打印消息)。为什么了?
这个时候需要引入第3个东东,component容器。可以把它想成一个容器, module中产出的东西都放在里面,然后将component与我要注入的MainActivity做关联,MainActivity中需要的person就可以冲 component中去去取出来。
MainComponent.java
@Component(modules = {MainModule.class})
public interface MainComponent {
void inject(MainActivity mainActivity);
}
看到一个新注入 @Component 表示这个接口是一个容器,并且与 MainModule.class 关联,它生产的东西都在这里。
void inject(MainActivity mainActivity);
表示我怎么和要注入的类关联。这个比较抽象!这个时候我们可以 build 一下项目。
然后在MainActivity中将component 关联进去:
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
MainComponent component = DaggerMainComponent.builder()
.mainModule(new MainModule()).build();
component.inject(this);
}
下面就是将 MainActivity和Module通过Component关联起来的代码,那么这个时候系统看到 有一个 @Inject
修饰的Person,就知道在这个 MainComponent中去找,并且是有 MainModule 的 Provides修饰的方法提供的。
MainComponent component = DaggerMainComponent.builder()
.mainModule(new MainModule()).build();
component.inject(this);
然后 build 项目,运行项目,发现打印:
person from module
a person created
说明确实系统创建了对象,并且注入到MainActivity中。
细心的同学会发现,MainComponent, MainModule, MainActivity 都是我们自己创建的,上面还有一个 DaggerMainComponent 是上面鬼?这就是你 build project 的时候,dagger自己为你生成的具体的component类(我们自己定义的是MainComponent接口)。感兴趣的可以直接跟到代码里面去看看。
好了,上面我们把 DI (Dependency Inject) 最基本的流程走了一遍,用到了几个注解:
- @Inject
- @Module
- @Component
- @Provides
下面来介绍另外几个常用的注解。
其他注解和情况
如果只有最简单的情况,那么上面的几个注解已经够了,但是其实还有很多情形,我们稍微展示几个
单例模式 @Singleton(基于Component)
基于Component的单例模式,怎么理解呢?也是是 在这个Component 对象中,一个对象是单例对象。如果又新创建了一个Component,那么两个Component中的当你对象是不一样的。具体的看后面介绍。
上面的MainActivity代码不变,我们再在MainActivity中添加一个 @Inejct Person person2
,并打印两个 person对象,结果如下:
person from module
a person created
person from module
a person created
org.yxm.daggerlearn2.data.Person@64cf4a2
org.yxm.daggerlearn2.data.Person@899b533
发现person会被创建两次,并且两个person对象也不同,如果我们希望只有一个 person 和 person2 都指向同一个Person对象了? 使用 @Singleton
注解
两个地方需要加:
1. MainModule.java 的 provides方法上需要添加 @Singleton
注解
@Module
public class MainModule {
private static final String TAG = "MainModule";
@Singleton
@Provides
public Person providesPerson() {
Log.d(TAG, "person from module");
return new Person();
}
}
- MainComponent.java 类上添加
@Singleton
@Component(modules = {MainModule.class})
public interface MainComponent {
void inject(MainActivity mainActivity);
}
再运行,发现只创建了一次,并且两个person指向同一个对象。
person from module
a person created
org.yxm.daggerlearn2.data.Person@64cf4a2
org.yxm.daggerlearn2.data.Person@64cf4a2
需要非常注意的是:单例是基于Component的,所以不仅 Provides 的地方要加 @Singleton
,Component上也需要加。并且如果有另外一个OtherActivity,并且创建了一个MainComponent,也注入Person,这个时候 MainActivity和OtherActivity中的Person是不构成单例的,因为它们的Component是不同的。
带有参数的依赖对象
如果构造Person类,需要一个参数Context,我们怎么注入呢? 要知道注入的时候我们只有一个 @Inject
注解,并不能带参数。所以我们需要再 MainModule 中提供context,并且由 providesXXX 函数自己去构造。如:
Person.java
public class Person {
private Context context;
public Person(Context context) {
Log.d(TAG, "a person created with context:"+context);
}
}
修改MainModule.java
@Module
public class MainModule {
private static final String TAG = "MainModule";
private Context context;
public MainModule(Context context) {
this.context = context;
}
@Provides
public Context providesContext() {
return this.context;
}
@Singleton
@Provides
public Person providesPerson(Context context) {
Log.d(TAG, "person from module");
return new Person(context);
}
}
这里需要强调的是, providesPerson(Context context)
中的 context,不能直接使用 成员变量 this.context
,而是要在本类中提供一个 Context providesContext()
的 @Provides
方法,这样在发现需要 context 的时候会调用 provideContext 来获取,这也是为了解耦。
依赖一个组件
如果组件之间有依赖,比如 Activity 依赖 Application一样,Application中的东西,Activity要直接可以注入,怎么实现呢?
例如,现在由 AppModule 提供Context对象, ActivityModule 自己无需提供Context对象,而只需要依赖于 AppModule,然后获取Context 对象即可。
AppModule.java
@Module
public class AppModule {
private Context context;
public AppModule(Context context) {
this.context = context;
}
@Provides
public Context providesContext() {
return context;
}
}
AppComponent.java
@Component(modules = {AppModule.class})
public interface AppComponent {
// 向下层提供Context
Context getContext();
}
ActivityModule.java
@Module
public class ActivityModule {
@Provides
Person providePerson(Context context) {
return new Person(context);
}
}
ActivityComponent.java
@Component(dependencies = {AppComponent.class}, modules = {ActivityModule.class})
public interface ActivityComponent {
void inject(MainActivity mainActivity);
}
通过上面例子,我们需要注意:
1. ActivityModule 也需要创建Person时的Context对象,但是本类中却没有 providesContext() 的方法,因为它通过 ActivityComponent依赖于 AppComponent,所以可以通过 AppComponent中的 providesContext() 方法获取到Context对象。
2. AppComponent中必须提供 Context getContext();
这样返回值是 Context 对象的方法接口,否则ActivityModule中无法获取。
使用方法:一定要在 activityComponent中注入 appComponent 这个它依赖的组件。我们可以看到,由于AppComponent没有直接和 MainActivity发生关系,所以它没有 void inject(...);
这样的接口
AppComponent appComponent = DaggerAppComponent.builder()
.appModule(new AppModule(this))
.build();
ActivityComponent activityComponent = DaggerActivityComponent.builder()
.appComponent(appComponent)
.activityModule(new ActivityModule())
.build();
activityComponent.inject(this);
自定义标记 @Qualifier 和 @Named
如果Person中有两个构造方法,那么在依赖注入的时候,它怎么知道我该调用哪个构造方法呢?
修改Person类,两个不同的构造方法
Person.java
public class Person {
private static final String TAG = "Person";
private Context context;
private String name;
public Person(Context context) {
Log.d(TAG, "a person created with context:" + context);
}
public Person(String name) {
this.name = name;
Log.d(TAG, "a person created with name:" + name);
}
}
有两种方法可以解决这个问题:
@Named(“…”)
@Module
public class MainModule {
private static final String TAG = "MainModule";
private Context context;
public MainModule(Context context) {
this.context = context;
}
@Provides
public Context providesContext() {
return this.context;
}
@Named("context")
@Provides
public Person providesPersonWithContext(Context context) {
return new Person(context);
}
@Named("string")
@Provides
public Person providesPersonWithName() {
return new Person("yxm");
}
}
分别在两个提供Person的provides方法上添加 @Named
标签,并指定。
然后在要依赖注入的地方,同样添加 @Name 标注表示要注入时使用哪一种
@Named("string")
@Inject
Person p1;
@Named("context")
@Inject
Person p2;
@Qualifier自定义标签
使用@Named 会使用到 字符串 ,如果两边都必须写对才能成功,并且字符串总是不那么优雅的,容易出错,所以我们可以自定义标签来解决上面的问题。
PersonWithContext.java
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface PersonWithContext {
}
PersonWithName.java
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface PersonWithName {
}
这样就自定义了两个标签,然后在刚刚所有使用到 @Named 的地方替换成我们自定义的标签即可:
MainModule.java
// ...
@PersonWithContext
@Provides
public Person providesPersonWithContext(Context context) {
return new Person(context);
}
@PersonWithName
@Provides
public Person providesPersonWithName() {
return new Person("yxm");
}
依赖注入的地方:
@PersonWithContext
@Inject
Person p1;
@PersonWithContext
@Inject
Person p2;
输入:调用了两种构造方法
a person created with context:org.yxm.daggerlearn2.MainActivity@8018a6e
a person created with name:yxm
懒加载Lazy和强制重新加载Provider
在注入时分别使用 Lazy 和 Provider 修饰要注入的对象:
@Inject
Lazy lazyPerson;
@Inject
Provider providerPerson;
在使用的地方,用 .get()
方法获取:
Person p1 = lazyPerson.get();
Person p2 = lazyPerson.get();
Person p3 = providerPerson.get();
Person p4 = providerPerson.get();
打印结果:
a person created with context:org.yxm.daggerlearn2.MainActivity@8018a6e
a person created with name:yxm
a person created with name:yxm
说明 lazyPerson 多次get 的是同一个对象,providerPerson多次get,每次get都会尝试创建新的对象。
@Scope 自定义生命周期
通过前面的例子,我们遇到了 @Singleton
这个标签,它可以保证在同一个Component中,一个对象是单例对象。其实可以跟进去看代码:
Singleton.java
@Scope
@Documented
@Retention(RUNTIME)
public @interface Singleton {}
就这么多东西。利用单例和组件间依赖的关系,是不是我们也可以定义生命周期来满足我们的需求呢?比如 Application,Activity 这样的生命周期。下面我们来创建这两个生命周期:
Application生命周期
ApplicationScope.java
@Scope
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface ApplicationScope {
}
Activity生命周期
ActivityScope.java
@Scope
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface ActivityScope {
}
除了名字,其他都和 @Singleton 是一样的。
然后用 ApplicationScope 来修饰 AppModule和AppComponent,ActivityScope 修饰 ActivityModule和ActivityComponent
AppModule.java
@Module
public class AppModule {
private Context context;
public AppModule(Context context) {
this.context = context;
}
@ApplicationScope
@Provides
public Context providesContext() {
return context;
}
}
AppComponent.java
@ApplicationScope
@Component(modules = {AppModule.class})
public interface AppComponent {
// 向下层提供Context
Context getContext();
}
ActivityModule.java
@Module
public class ActivityModule {
@ActivityScope
@PersonWithContext
@Provides
Person providesPersonWithContext(Context context) {
return new Person(context);
}
@ActivityScope
@PersonWithName
@Provides
Person providesPersonWithString() {
return new Person("yxm");
}
}
ActivityComponent.java
@ActivityScope
@Component(dependencies = {AppComponent.class}, modules = {ActivityModule.class})
public interface ActivityComponent {
void inject(MainActivity mainActivity);
}
然后创建自定义Application:
App.java
public class App extends Application {
public static AppComponent appComponent;
@Override
public void onCreate() {
super.onCreate();
appComponent = DaggerAppComponent.builder()
.appModule(new AppModule(this))
.build();
}
}
在MainActivity中注入:
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
@PersonWithContext
@Inject
Person p1;
@PersonWithContext
@Inject
Person p2;
@PersonWithName
@Inject
Person p3;
@PersonWithName
@Inject
Person p4;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ActivityComponent activityComponent = DaggerActivityComponent.builder()
.appComponent(App.appComponent)
.activityModule(new ActivityModule())
.build();
activityComponent.inject(this);
Log.d(TAG, "" + p1);
Log.d(TAG, "" + p2);
Log.d(TAG, "" + p3);
Log.d(TAG, "" + p4);
}
}
可以看到我们注入了4个Person对象,打印结果:
a person created with context:org.yxm.daggerlearn2.App@103efff
a person created with name:yxm
org.yxm.daggerlearn2.data.Person@711cc
org.yxm.daggerlearn2.data.Person@711cc
org.yxm.daggerlearn2.data.Person@a36ec15
org.yxm.daggerlearn2.data.Person@a36ec15
只创建了两次,说明在ActivityScope生命周期中,创建了两种 Person,并且它们保持各自的单例。
其实看到这里,再说单例我都觉得不是很准确了,它其实就是说的在这个Component中可以又几个这样的对象。如果是普通的就可能有很多个,如果是Scope修饰的,就只有一个。
总结
哎哟我去,还是写了很长,这篇还是主要展示了Dagger2中最基本的环境配置,和常用的标签以及特性,列举一下:
- @Inject
- @Module
- @Component
- @Singleton
- @Scope
- @Named, @Qualifier
- Lazy, Provider
- modules, dependencys
然后也踩了一些坑,很无知的错误:
- 在Component中我们会使用:
void inject(实体类)
,表示这个Component 可以与实体类关联,然后为它注入。注意这里的实体类必须是直接关联的那个类,如果你填它的父类,按照多态你也可以在compoment.inject(...)
的时候成功,但是却无法注入 。纠结了好一会儿。 - 一旦使用
compoment.inject(...)
使某个实体类和Component发生了关系,那么对应Component的 Module 中必须提供@Inject
修饰的所有对象的 providesXXX 方法,而且如果有两种构造方法,必须提供两种 providesXXX 方法哦!又被坑了好一会儿。 - 如果被依赖的 Component 使用了Scope,那么依赖他的 Component 也必须使用Scope才能使用。典型例子就是:AppComponent使用了 Scope,那么ActivityComponent也必须使用Scope,否则会编译出错。