Dagger2的使用总结
Dagger是一个完全静态的，在编译时进行依赖注入的框架，原来是由Square公司维护的然后现在把这堆东西扔给Google维护了。Dagger解决了基于反射带来的开发和性能上的问题（因为Dagger并没有用反射来做依赖注入）说了那么多，其实就是告诉我们这家伙可以用来做依赖注入哦。
依赖注入：我们在做项目时，经常需要在一个对象里去创建另一个对象的实例，这种行为是产生耦合的常见形式，对于一个大型项目来说，过多的相互依赖会导致代码难以维护，很容易就会碰到修改一个小需求需要大面积的修改各种代码，特别是代码原来不是自己维护的，撸着代码的你就开始问候别人家的亲友了。
在需要依赖的类中不要通过new来创建依赖而是通过方法提供的参数注入进来，这样我们的需要依赖的类和提供依赖的类的实现方法分隔开了，一切又变得如此美好咯。
dagger2是一个依赖注入框架，在编译期间自动生成代码，负责依赖对象的创建。
用dagger2提供依赖有什么好处：为了进一步解耦和方便测试，我们会使用依赖注入的方式构建对象 (不使用 new 来创建依赖对象)。在mvp中，presenter层会持有view和model层的依赖，依赖注入主要用于解耦，通过依赖注入创建对象，不再使用new来创建对象。
依赖注入的目的是：给你提供一个对象依赖。
Dagger2的常用注解:
@Inject：此注解用于告诉Dagger2，我们需要这个类的实例对象。主要用于标记哪个类是需要注入的。
@Module：此注解里面全是方法，用于对外提供对象，自己定义方法，方法上使用@Provides。自定义一个类，以Module结尾，用@Module注解。
@Provides：此注解用于标记方法，表示可以通过这个方法获取一个对象，一般用于自定义类中。
@Component：此注解主要用于关联自定义module类和MainActivity；关联module使用：@Component(modules={UserModule.class})；关联Activity，以方法参数的形式传入MainActivity到连接器中
@Named与@Qualifier：用于区别不同对象的实例。必须要成对出现，否则会报错。
@PerActivity：限定对象的生命周期和Activity一样。一般应用于自定义的Component上。
@Singleton：标记为单例模式，如果在自定义Module中使用了此注解，在自定义的Component上也要使用该注解。
使用方式：
1）自定义Module，里面的方法用于提供依赖，
2）自定义Component接口，里面全是Activity的注入方法，
3）按Ctrl+F9进行编译。
自定义Module类：
自定义module中的方法 要以provide开头
通过构造方法传递Context
如果定义的module，需要传参数，就需要在Activity使用build进行诸如
添加依赖：
//添加依赖
compile 'com.google.dagger:dagger:2.9'
annotationProcessor 'com.google.dagger:dagger-compiler:2.9'MainActivity代码：此依赖注入的目的是获取ApiService类的实例，然后调用其中的register方法；编译后会自动生成DaggerUserComponent类
package com.example.administrator.testdragger2.old;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import com.example.administrator.testdragger2.R;
import javax.inject.Inject;
public class MainActivity extends AppCompatActivity {
@Inject
ApiService apiService;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//Dagger会自动创建这个类，以Dagger开头+UserComponent
DaggerUserComponent.create().inject(this);
apiService.register();
}
}package com.example.administrator.testdragger2.old;
import dagger.*;
/**
* Created on 2017/5/8.
* Author:crs
* Description: UserComponent连接器,桥梁
*/
@Component(modules = {UserModule.class})
public interface UserComponent {
//当前只能写MainActivity，不能写Activity，要不然会出现空指针。
void inject(MainActivity activity);
}package com.example.administrator.testdragger2.old;
import dagger.Module;
import dagger.Provides;
/**
* Created on 2017/5/8.
* Author:crs
* Description:用于提供依赖
*/
@Module
public class UserModule {
@Provides
ApiService provideApiService(){
return new ApiService();
}
}package com.example.administrator.testdragger2.old;
import android.util.Log;
/**
* Created on 2017/5/8.
* Author:crs
* Description:ApiService
*/
public class ApiService {
private static final String TAG = "ApiService";
public void register() {
//请求网络数据
Log.i(TAG,"测试数据");
}
}———————————————————————————————————————>
如果自定义类module中的方法，需要一个对象参数，怎么处理？需要一个方法去提供这个对象。
1)在类的构造方法上添加@Inject注解
2)自己写一个方法去提供参数对象
package com.example.administrator.testdaggger2;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import javax.inject.Inject;
public class MainActivity extends AppCompatActivity {
@Inject
UserStore userStore;
@Inject
UserManager userManager;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//主要两个问题:
//1）自定义Module需要传递上下文怎么办
//2）自定义Module中的方法中需要参数对象怎么处理？(构造函数、自己提供方法)
//Dagger会自动创建这个类，以Dagger开头+UserComponent,编译时注入，按Ctrl+F9编辑即可
//DaggerUserComponnent.create().inject(this);
//userManager.register();
//Dagger的关系非常简单，MainActivity中需要对象，那么就在Module中提供对象；而他们之间的桥梁就是componnent
//自定义类Module的构造方法中需要传入一个上下文对象，那么在MainActivity中就需要传递进去。
//使用下面的这种方式进行参数传递:this就是上下文
DaggerUserComponnent.builder().userModule(new UserModule(this)).build().inject(this);
userManager.register();
}
}package com.example.administrator.testdaggger2;
import android.content.Context;
import dagger.Module;
import dagger.Provides;
/**
* Created on 2017/5/9.
* Author:crs
* Description:XXX
*/
@Module
public class UserModule {
//在Module中传递上下文对象
private Context mContext;
public UserModule(Context context) {
this.mContext = context;
}
@Provides
UserStore provideUserStore(){
return new UserStore();
}
//如果自定义Module中的方法需要对象参数，怎么处理？
//1）通过Module中的方法进行提供，比如provideUserStore()
//2）通过类的构造函数进行提供对象，注释掉上面的provideUserStore()方法
//3）代码执行顺序:创建参数对象的方法先执行，比如构造；
@Provides
UserManager provideUserManager(UserStore userStore) {
return new UserManager(userStore);
}
}package com.example.administrator.testdaggger2;
import android.util.Log;
import javax.inject.Inject;
/**
* Created on 2017/5/9.
* Author:crs
* Description:UserStore 用户数据存储
*/
public class UserStore {
//通过构造函数提供依赖
@Inject
public UserStore() {
}
private static final String TAG = "UserStore";
public void register(){
Log.i(TAG,"测试数据");
}
}———————————————————————————————————————>
模块化开发：自定义module之间相互include，component之间相互依赖
通过@Named @Qualifier：区别不同对象的实例
同一个类，可能要创建两个对象，处理不同的业务逻辑
通过类型进行注入，根据@Inject标记的变量类型ApiService，在Module中寻找返回值为ApiService的方法进行调用。但是如果Module中有多个方法，它们的返回值都为ApiService，那么就需要使用@Named注解用于区别。（区分不同对象的实例@Qualifier）
比如：访问测试服务器，访问正式服务器
代码如下：
package com.example.administrator.testdragger2.dagger2;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import com.example.administrator.testdragger2.R;
import javax.inject.Inject;
import javax.inject.Named;
/**
* Created on 2017/5/9.
* Author:crs
* Description:TestMainActivity
*/
public class TestMainActivity extends AppCompatActivity {
private static final String TAG ="TestMainActivity" ;
//访问测试服务器
@Named("dev")
@Inject
ApiService apiServiceDev;
//访问正式服务器
@Named("release")
@Inject
ApiService apiServiceRelease;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_test);
DaggerUserComponent.builder().httpModule(new HttpModule()).userModule(new UserModule(this)).build().inject(this);
//此时这两个两个对象的内存地址是不一样的
Log.i(TAG,apiServiceDev.toString());
Log.i(TAG,apiServiceRelease.toString());
//apiServiceDev.register();
//apiServiceRelease.register();
}
}Component连接两个Module（可以连接多个Module）
package com.example.administrator.testdragger2.dagger2;
import dagger.Component;
/**
* Created on 2017/5/9.
* Author:crs
* Description:UserComponent
*/
@Component(modules={UserModule.class,HttpModule.class})
public interface UserComponent {
void inject(TestMainActivity activity);
}package com.example.administrator.testdragger2.dagger2;
import android.content.Context;
import javax.inject.Named;
import dagger.Module;
import dagger.Provides;
import okhttp3.OkHttpClient;
/**
* Created on 2017/5/9.
* Author:crs
* Description:自定义Module类
*/
//表示当前module引用HttpModule，进而提供OkHttpClient的对象
@Module(includes = {HttpModule.class})
public class UserModule {
private Context mContext;
UserModule(Context context) {
this.mContext=context;
}
//此时缺少OkHttpClient的实例，并且当前自定义Module中并没有提供，如何处理？
@Named("dev")
@Provides
ApiService provideApiServiceDev(OkHttpClient client){
return new ApiService(client);
}
@Named("release")
@Provides
ApiService provideApiServiceRelease(OkHttpClient client){
return new ApiService(client);
}
}package com.example.administrator.testdragger2.dagger2;
import java.io.IOException;
import javax.inject.Inject;
import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
/**
* Created on 2017/5/9.
* Author:crs
* Description:ApiService网络请求
*/
public class ApiService {
//常用类：OKHttpClient，Request，RequestBody，CallBack
OkHttpClient client;
//构造函数
@Inject
public ApiService(OkHttpClient client) {
this.client=client;
}
//主要用于网络请求
public void register(){
RequestBody body=RequestBody.create(null,"");
Request request = new Request.Builder()
.url("")
.post(body)
.build();
client.newCall(request).enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
}
@Override
public void onResponse(Call call, Response response) throws IOException {
}
});
}
}