Android之dagger2的简单运用和详细解读(入门)

dagger2的使用和理解

dagger2的使用，给程序带来了非常好的解耦，废话不多说，直接开始

基本的配置：

在project根目录build.gradle添加

dependencies {
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.4'
}

在module 的build.gradle添加

apply plugin: 'com.neenbedankt.android-apt'
dependencies { ...
compile 'com.google.dagger:dagger:2.0'
apt 'com.google.dagger:dagger-compiler:2.0'
compile 'org.glassfish:javax.annotation:10.0-b28' // Java标注
}

注意：

1.使用@Inject时，不能用private修饰符修饰类的成员属性。

2.项目中同时用了Butterknife，需要在module build.gradle添加

packagingOptions { exclude 'META-INF/services/javax.annotation.processing.Processor' }

3.使用@Scope注解的Component不能被没有使用其注解的Component所依赖。

一：dagger2在android中依赖注入代码实现

这是我之前一个项目关于dagger2的相关代码，具体里面的内容不用管，我们只需要关注每个@provides方法的传入参数以及返回结果就可以。每一行代码都注释得很清楚，相信大家读完，基本的流程也就明白了。

1.建立接口component，表示连接器,并且用注解Component标记，如果有Module,可以在引入。（Component是连接@Module和@Inject的桥梁）

@Singleton @Component(modules = {ApplicationMoudle.class, ApiMoudle.class})
public interface ApplicationComponent {
Context getContext();//对外暴露Context ，这个context由ApplicationMoudle提供
//对外暴露OkHttpHelper，这个context由ApplicationMoudle提供
OkHttpHelper getOkHttpHelper();
//对外暴露UserStorage ，这个context由ApplicationMoudle提供
UserStorage getUserStorage();
//对外暴露UserApi ，这个context由ApiMoudle提供
UserApi getUserApi();
//对外暴露TicketApi ，这个context由ApiMoudle提供
TicketApi getTicketApi();
//要注入到MyApplication
void inject(MyApplication application);
}

2.创建类module一个或多个，并且用注解@Module标记。

@Provides 表示对外提供

@Singleton 表示单例，对象只会被初始化一次，之后的每次都会被直接注入相同的对象

@Named 表示

@Module
public class ApplicationMoudle {
private Context context;
//构造方法会在创建component的时候，手动去new创建，并且传入context，和普通对象是一模一样的
public ApplicationMoudle(Context context){
this.context = context;
}
//向外提供Context
@Provides @Singleton
public Context provideApplicationContext(){
return context;
}
//向外提供OkHttpClient ，并且用@Named(“api”)做标记,因为这个Module里面有两个提供OkHttpClient 的方法，需要区分。
@Provides @Singleton @Named("api")
OkHttpClient provideApiOkHttpClient(){
OkHttpClient.Builder builder = new OkHttpClient.Builder()
.connectTimeout(10, TimeUnit.SECONDS)
.readTimeout(10, TimeUnit.SECONDS)
.writeTimeout(10, TimeUnit.SECONDS);
HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
builder.addInterceptor(loggingInterceptor);
return builder.build();
}
//向外提供OkHttpClient ,这个参数OkHttpClient 从上一个标记了@Named("api") 方法提供而来。
@Provides @Singleton
OkHttpClient provideOkHttpClient(@Named("api") OkHttpClient mOkHttpClient) {
OkHttpClient.Builder builder = mOkHttpClient.newBuilder()
.connectTimeout(30, TimeUnit.SECONDS)
.readTimeout(30, TimeUnit.SECONDS)
.retryOnConnectionFailure(true);
builder.interceptors().clear();
return builder.build();
}
//向外提供LayoutInflater
@Provides @Singleton
LayoutInflater provideLayoutInflater(Context context) {
return (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
}
//向外提供UserStorage
@Provides @Singleton
UserStorage proviceUserStorage(Context mContext){
return new UserStorage(mContext);
}
//向外提供RequestHelper，参数UserStorage 由proviceUserStorage方法提供而来。
@Provides @Singleton
RequestHelper proviceRequestHelper(Context mContext,UserStorage mUserStorage){
return new RequestHelper(mContext,mUserStorage);
}
//向外提供OkHttpHelper ，参数OkHttpClient 由provideOkHttpClient()方法提供而来。
@Provides @Singleton
OkHttpHelper provideOkHttpHelper(OkHttpClient mOkHttpClient) {
return new OkHttpHelper(mOkHttpClient);
}
}

@Module
public class ApiMoudle {
//向外提供UserApi ，参数OkHttpClient 由ApplicationModule的提供方法provideOkHttpClient()提供而来。
@Provides @Singleton
public UserApi proviceUserApi(@Named("api") OkHttpClient okHttpClient){
return new UserApi(okHttpClient);
}
//向外提供TicketApi ，参数OkHttpClient 由ApplicationModule的提供方法provideOkHttpClient()提供而来。
@Provides @Singleton
public TicketApi proviceTicketApi(@Named("api") OkHttpClient okHttpClient){
return new TicketApi(okHttpClient);
}
}

可以发现，每一个提供出去的对象，又可以为其他的提供方法提供参数，也为@inject标注的构造函数提供参数。

总而言之：

如果@Provides方法有参数，这个参数需要通过其他的@Provides方法或者@Inject注解的构造方法获得。

3.建立普通类，我们需要注入的类。在构造函数上方通过@Inject注解标记。

public class MainPresenter  {
private Context context;
@Inject
public MainPresenter(Context context){//
this.context = context;
}
}

4.在Application里面的使用

public class MyApplication extends Application {
private ApplicationComponent mApplicationComponent;
@Inject MainPresenter  mMainPresenter ;//
@Override
public void onCreate() {
super.onCreate();
initComponent();
}

private void initComponent() {
mApplicationComponent =
DaggerApplicationComponent.builder()
.applicationMoudle(new ApplicationMoudle(this))
.apiMoudle(new ApiMoudle())
.build();
mApplicationComponent.inject(this);//这样，就会把所有@Inject标记的对象进行注入操作
}
}

dagger2的调用步骤：

1.创建DaggerApplicationComponent对象，创建需要Component依赖的Module对象（在程序中手动new创建）。

2.调用inject()注入。

dagger2的工作方式：

可以看到@Inject MainPresenter mMainPresenter 一句话就实现了注入（创建对象）。

我们可以看到MainPresenter的构造函数有一个@Inject注解

@Inject

public MainPresenter(Context context){

this.context = context;

}

1.对于@Inject标记的MainPresenter对象，dagger2首先会去到MainPresenter去找构造函数。如果该构造函数恰好也被@Inject标记，那么就会调用这个方法会new出对象，但是这里的构造函数需要一个参数context,而ApplicationModule有一个提供context的方法，所以context由ApplicationModule可以得到提供。那么，创建对象，就顺利完成了。

如果该构造函数没有被@Inject标记，那么就直接去Module里面去寻找对应的提供MainPresenter的方法，从而实现实例化创建对象。

那么，其实我们根本不需要Module，一样可以实现注入，使用构造器注入即可。

使用构造器注入具有局限性：

1.不能给这个类中的多个构造器作@Inject注解。

2.第三方类，系统类，我们就无法在他构造方法前面加@inject。