Dagger2使用详解
什么是依赖注入？
依赖注入就是将调用者依赖的对象实例通过一定的方式从外部传入，解决了各个类之间的耦合问题。
这个外部，正是dagger2容器。需要什么对象从容器中取就行了，调用和被调用方被隔离开，通过一个容器将他们联系起来，从而实现了解耦。
Dagger2是Google出的依赖注入框架。Dagger2的原理是在编译期生成相应的依赖注入代码。其他框架是在运行时期反射获取注解内容，影响运行效率。
引入Dagger2
在app的build.grade中引入android-apt，并添加dagger2依赖
apply plugin: 'com.neenbedankt.android-apt'
dependencies {
apt "com.google.dagger:dagger-compiler:2.11-rc1"
provided 'org.glassfish:javax.annotation:10.0-b28'
compile "com.google.dagger:dagger:2.11-rc1"
｝在project级别的build.grade中添加android-apt
buildscript {
repositories {
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:2.2.2'
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
}
}Dagger2基本用法
@Inject
通常在需要依赖的地方使用这个注解，换句话说，你用它告诉dagger2这个类或这个字断需要依赖注入，这样dagger2就会构造一个这个类的实例去满足他们的依赖
@Module
Module类里面的方法专门提供依赖，所以我们定义一个类，用@Module注解，这样dagger2在构造类实例的时候就知道去哪里找这些依赖。
@Provide
在Module中，我们定义的方法使用这个注解，告诉dagger2我们想要构造对象并提供这些依赖
@Component
Component是一个注入器，也可以说是连接Inject和Module的桥梁
下面看个例子，通过例子来看下dagger2的基本用法：
// MainActivity.java
public class MainActivity extends AppCompatActivity {
@Inject LoginManager loginManager;
@Override protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerLoginModuleComponent.create().inject(this);
loginManager.login();
}
}调用LoginManager的login接口，因此需要将LoginManager对象注入到MainActivity中,注入的操作由DaggerLoginModuleComponent调用inject方法完成的，LoginModuleComponent是怎么和LoginManager关联上的呢？
// LoginModuleComponent.java
@Component(modules = {LoginModule.class})
public interface LoginModuleComponent {
void inject(MainActivity activity);
}事实上，LoginModuleComponent只是LoginModule和MainActivity的连接器，可以想象成注射器，把LoginModule提供的对象注射到MainActivity中，完成依赖注入的过程。再看下LoginModule中提供了哪些对象？
// LoginModule.java
@Module
public class LoginModule {
@Provides
public LoginManager providerLoginManager() {
return new LoginManager();
}
}
// LoginManager.java
public class LoginManager {
public void login() {
Log.i("dagger2", "--- login ---");
}
}
可以看到是通过Provides注解来提供LoginManager对象的，用起来还是很简单的，运行一下：
04-27 18:38:05.893 2343-2343/com.testdes.des I/dagger2: --- login ---Dagger2模块化
LoginManager中执行login操作，需要OkHttpClient对象，我们从构造方法中传入，如下：
// LoginManager.java
public class LoginManager {
OkHttpClient client;
public LoginManager(OkHttpClient client) {
this.client = client;
}
public void login() {
Log.i("dagger2", "--- login:" + client);
}
}
// LoginModule.java
@Module
public class LoginModule {
@Provides
public LoginManager providerLoginMgr(OkHttpClient client) {
Log.i("dagger2", "--providerLoginMgr");
return new LoginManager(client);
}
@Provides
public OkHttpClient okHttpClient() {
return new OkHttpClient();
}
}考虑到OkHttpClient不仅仅在登录的时候使用，其它网络操作也需要这个对象，因此把OkHttpClient做成公共模块，通过HttpModule提供出来。
// HttpModule.java
@Module
public class HttpModule {
@Provides
public OkHttpClient providerOKHTTP() {
return new OkHttpClient();
}
}
// LoginModule.java
@Module(includes = {HttpModule.class})
public class LoginModule {
@Provides
public LoginManager providerLoginMgr(OkHttpClient client) {
Log.i("dagger2", "--providerLoginMgr");
return new LoginManager(client);
}
}在LoginModule中通过includes属性把HttpModule引入进来就可以了，实现了简单的HttpModule模块化，当然还有其他的方式，比如在LoginModuleComponent中引入HttpModule
@Component(modules = {LoginModule.class, HttpModule.class})
public interface LoginModuleComponent {
void inject(MainActivity activity);
}或者创建HttpComponent，通过dependencies依赖，如下：
@Component(modules = {LoginModule.class}, dependencies = HttpComponent.class)
public interface LoginModuleComponent {
void inject(MainActivity activity);
}Dagger2单例
单例只需要使用@Singleton注解来声明，当HttpModule的providerOKHTTP使用了Singleton，LoginModuleComponent也需要使用Singleton来标注，如下：
// HttpModule.java
@Module
public class HttpModule {
@Provides
public OkHttpClient providerOKHTTP() {
return new OkHttpClient();
}
}
// LoginModuleComponent.java
@Component(modules = {HttpModule.class})
@Singleton
public interface LoginModuleComponent {
void inject(MainActivity activity);
}
// MainActivity.java
public class MainActivity extends AppCompatActivity {
@Inject OkHttpClient okHttpClient;
@Inject OkHttpClient okHttpClient2;
@Override protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerLoginModuleComponent.create().inject(this);
Log.i("dagger2", ""+okHttpClient);
Log.i("dagger2", ""+okHttpClient2);
}
}运行一下，确实是单例
04-28 14:47:03.553 8497-8497/com.testdes.des I/dagger2: com.testdes.des.dagger2.OkHttpClient@3ef1ff
04-28 14:47:03.553 8497-8497/com.testdes.des I/dagger2: com.testdes.des.dagger2.OkHttpClient@3ef1ff我们在增加一个页面SettingActivity,假设有个登出的功能，也需要用到OkHttpClient，代码不贴了，运行一下：
04-28 15:29:47.999 9781-9781/com.testdes.des I/dagger2: MainActivity:com.testdes.des.dagger2.OkHttpClient@3ef1ff
04-28 15:29:48.068 9781-9781/com.testdes.des I/dagger2: SettingActivity:com.testdes.des.dagger2.OkHttpClient@ba0d601哇擦，又发现不单例了！！这是什么鬼？
这里解释下，dagger2的单例和传统java单例不一样，我们通常说的单例是在静态域里初始化的，只要程序不退出就一直保持单例，而dagger2单例是依附于component，即使声明了singleton,不同的component也不是单例，参考文章末尾的注意事项第7条。
所以我们如果要实现单例，需要怎么做呢？
思路是定义一个HttpComponent，作为其他component的dependencies component，具体如下：
// HttpComponent.java
@Component(modules = {HttpModule.class})
@Singleton
public interface HttpComponent {
}
// LoginModuleComponent.java
@Component(dependencies = {HttpComponent.class})
@Singleton
public interface LoginModuleComponent {
void inject(MainActivity activity);
}运行一下，发现报错了
Error:(11, 1) error: This @Singleton component cannot depend on scoped components:
@Singleton com.testdes.des.dagger2.HttpComponent错误原因参考文章末尾注意事项第4条，Singleton是一个scope, LoginModuleComponent和HttpComponent的scope不能相同，那我们只好给LoginModuleComponent自定义一个scope了,怎么定义可以参考Singleton
// ActivityScope.java
@Scope
@Documented
@Retention(RUNTIME)
public @interface ActivityScope {
}
// LoginModuleComponent.java
@Component(dependencies = {HttpComponent.class})
@ActivityScope
public interface LoginModuleComponent {
void inject(MainActivity activity);
}运行一下，终于还是报错了
Error:(13, 8) error: com.testdes.des.dagger2.OkHttpClient cannot be provided without an @Inject constructor or from an @Provides- or @Produces-annotated method.
com.testdes.des.dagger2.OkHttpClient is injected at
com.testdes.des.MainActivity.okHttpClient
com.testdes.des.MainActivity is injected at
com.testdes.des.dagger2.LoginModuleComponent.inject(activity)LoginModuleComponent没有办法得到HttpComponent提供的OkHttpClient对象，这是需要做一个桥接,增加一个get方法（名字任意取），返回一个OkHttpClient对象，如下
@Component(modules = {HttpModule.class})
@Singleton
public interface HttpComponent {
OkHttpClient get();
}BUILD SUCCESSFUL
在MainActivity中注入的方法修改下：
// MainActivity.java
DaggerLoginModuleComponent.builder()
.httpComponent(DaggerHttpComponent.create()).build().inject(this);需要构建一个httpComponent对象，按照上面的写法，每次用到都要调用DaggerHttpComponent.create()显然不合理，因此我们把httpComponent构建操作放到Application初始化的时候执行一次，如下：
// TestApplication.java
public class TestApplication extends Application{
HttpComponent httpComponent;
@Override public void onCreate() {
super.onCreate();
System.out.println("start TestApplication");
httpComponent = DaggerHttpComponent.create();
}
public HttpComponent getHttpComponent() {
return httpComponent;
}
}
// MainActivity.java
DaggerLoginModuleComponent.builder()
.httpComponent(((TestApplication)getApplication()).getHttpComponent()).build().inject(this);
SettingActivity中的写法和MainActivity保持一致，然后运行一下：
04-28 16:25:50.715 11228-11228/com.testdes.des I/dagger2: MainActivity:com.testdes.des.dagger2.OkHttpClient@39f1d88
04-28 16:25:50.769 11228-11228/com.testdes.des I/dagger2: SettingActivity:com.testdes.des.dagger2.OkHttpClient@39f1d88终于单例了，以上是dagger2的基本用法和单例的实现，谢谢~
注意事项
- component的inject方法接收父类型参数，而传入的是子类型的对象则无法注入
- component关联的modules中不能有重复的provide
- module中的provide方法使用了scope,则component需要使用同一个注解
- component的dependencies与component自身不能使用同一个scope,即组件之间的scope不能相同
- singleton的组件不能依赖其他scope组件，只能其他scope组件依赖singleton
- 没有scope的组件不能依赖有scope的组件
- @singleton的生命周期依附于component，同一个module provide singleton，不同的component也不是单例
5657
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
