前言
最近在做项目中，用到了Dagger2，所以找了一些博客和其他的一些学习资源，算是知道如何使用了，但是对其理解还相差很远。所以这篇文章重点针对与使用，和使用中常见的一些问题。对更深层的东西我就不再这里不懂装懂了。如果以后有机会或需要会在以后学习更加深入后在另写文章。
Dagger2
根据官网来说他就是一个快速的依赖注入框架。如果对依赖注入不太了解，那么请看这篇文章依赖注入原理，在这里我就不过多介绍了。其实他的作用重点就是解耦和管理实例对象。那我们看看他具体有什么好处：
依赖的注入和配置独立于组件之外，注入的对象在一个独立、不耦合的地方初始化，这样在改变注入对象时，我们只需要修改对象的实现方法，而不用大改代码库。
依赖可以注入到一个组件中：我们可以注入这些依赖的模拟实现，这样使得测试更加简单。
app中的组件不需要知道有关实例创建和生命周期的任何事情，这些由我们的依赖注入框架管理的
这是网上的一切说法。对于文字我们不好理解，还是看看在具体应用中我们该如何去使用。不过在使用之前我们先简单的理解及概念。
@Inject:
通常在需要依赖的地方使用这个注解。换句话说，你用它告诉Dagger这个类或者字段需要依赖注入。这样，Dagger就会构造一个这个类的实例并满足他们的依赖。
@Module:
Modules类里面的方法专门提供依赖，所以我们定义一个类，用@Module注解，这样Dagger在构造类的实例的时候，就知道从哪里去找到需要的 依赖。modules的一个重要特征是它们设计为分区并组合在一起（比如说，我们的app中可以有多个组成在一起的modules）
@Provide:
在modules中，我们定义的方法是用这个注解，以此来告诉Dagger我们想要构造对象并提供这些依赖。
@Component:
Components从根本上来说就是一个注入器，也可以说是@Inject和@Module的桥梁，它的主要作用就是连接这两个部分。
读不懂也没关系，我们接下来实战代码。在讲解后在结合概念我们就能很好的理解了
引入
引入方法有2种：
第一种：
在工程的build.gradle文件中添加android-apt插件（该插件后面介绍）
buildscript {
....
dependencies {
classpath 'com.android.tools.build:gradle:2.1.0'
// 添加android-apt 插件
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
}
}
在app的中的build.gradle文件中添加配置
apply plugin: 'com.android.application'
// 应用插件
apply plugin: 'com.neenbedankt.android-apt'
android {
compileSdkVersion 23
buildToolsVersion "23.0.2"
defaultConfig {
applicationId "com.mahao.alex.architecture"
minSdkVersion 15
targetSdkVersion 23
versionCode 1
versionName "1.0"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
}
dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
testCompile 'junit:junit:4.12'
compile 'com.android.support:appcompat-v7:23.3.0'
// dagger 2 的配置
compile 'com.google.dagger:dagger:2.4'
apt 'com.google.dagger:dagger-compiler:2.4'
compile 'org.glassfish:javax.annotation:10.0-b28'// 添加java 注解库
}
以上两个配置就可以了。
android-apt是Gradle编译器的插件，根据其官方文档，主要两个目的：
编译时使用该工具，最终打包时不会将该插件打入到apk中。
能够根据设置的源路径，在编译时期生成相应代码。
在导入类库时，
compile 'com.google.dagger:dagger:2.4'
apt 'com.google.dagger:dagger-compiler:2.4'
dagger是主要的工具类库。dagger-compiler为编译时期生成代码等相关的类库。
在android-apt的文档中，也推荐使用这种方式。因为，编译时期生成代码的类库在运行期并不需要，那么将其分为两个库，（运行类库dagger）和（编译器生成代码类库（dagger-compiler）），那么在打包时，就不需要将dagger-compiler打入其中（用不到），减小APK 的大小
第二种：
这种方法比较简单(Android Studio2.2以上)，直接引入依赖
compile 'com.google.dagger:dagger:2.9'
annotationProcessor 'com.google.dagger:dagger-compiler:2.9'
推荐第一种方式
实践
public class ApiService {
public void register() {
//注册的方法
Log.i("TAG", "ApiService: ");
}
}
public class UserStroe {
public void login(){
//登录的方法
}
}
首先假设我们现在有两个方法，一个是注册，另一个是登录。如果我们现在MainActivity中调用register();我们一般会这么写：
ApiSeivie apiServce=new ApiService();
apiService.register();
如果们们使用Dagger2该如何使用呢？
- module
首先：我们先创建module(他是主要提供实例的类)，这里我们定义为UserModule：
@Module
public class UserModule {
public UserModule() {
}
@Provides
public ApiService provideApiService() {
return new ApiService();
}
}
@Module:
Modules类里面的方法专门提供依赖，所以我们定义一个类，用@Module注解，这样Dagger在构造类的实例的时候，就知道从哪里去找到需要的依赖。
@Provide:
在modules中，我们定义的方法是用这个注解，以此来告诉Dagger我们想要构造对象并提供这些依赖。
现在我们回头在看看概念是不就明白其中的含义了。
可以看到我们在MainActivity中需要ApiService，我们在module中创建他的实例。等他需要的时候我们就给他。现在module创建好了。我们还需要调用者(MainActivity)和被调用者(module)之间的桥梁，这就是Component。
注意，在module中，我们创建的方法必须是public不可以是privite。这个也很好理解。我们创建的方法本来就是给外界调用的，如果你用privite的话只能本类使用了。
Component：
@Component(modules = {UserModule.class})
public interface UserComponet {
void inject(MainActivity activity);
}
注意：inject方法接收父类型参数，而调用时传入的是子类型对象则无法注入。比如你想作用BaseActivity，inject()就传入BaseActivity,但是只能作用BaseActivity不能作用子类MainActivity。反之亦然；
@Component：
我们定义UserComponet并加上@Component注解。表明他是一个桥梁。首先他必须是一个接口。其次我们必须依赖一个module(当然，从{}这个符号我们就可以看到，他可以同时依赖多个module)，它还有另一参数dependencies，这里我们先不说他，等后面讲到了再说他。这里我们看到他里面只有一个方法 void inject().这里我们传入MainActivity，因为我们想在这个类中使用我们实例ApiService。这样module和MainActivity通过Component就关联起来了。创建好这些类以后我们需要Rebuild Progect。
这是会生成一个DaggerUserComponet类，这个类命名是以Dagger开头接上我们UserComponet类名。这个类方法很少，主要就是将我们的MainActivity和Component关联起来，通过：
DaggerUserComponet.create().inject(this);
将我们的MainActivity传入Component的inject()方法中，这样这个桥梁就就通了，我们就可以使用了，如下：
public class MainActivity extends AppCompatActivity {
@Inject
ApiService mApiService;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerUserComponet.create().inject(this);
mApiService.register();
Log.d("TAG", "onCreate: " + mApiService);
}
}
注意 这里我们 @Inject注解的对象不能用privite修饰。
在我们的想要的创建的对象加上@Inject注解并且调用DaggerUserComponet.create().inject(this);后我们就可以使用这个对象了。我们运行看看结果：
dagger2 D/TAG: ApiService:
com.example.ggxiaozhi.dagger2 D/TAG: onCreate: com.example.ggxiaozhi.dagger2.ApiService@4a7c73b4
可以看到正常运行没有问题了。实例对象已经被我们创建出来了。我们用2张图总结一下：
这张图从概念出发，我们再从我们的例子中总结出来经验概括就是这样的：
明白了流程后那他是怎么解耦的呢？使用方法就这么简单就结束了吗？答案是肯定的。我们一定不止这么简单，关于解耦的话我就举一个简单的例子。之前我们创建了2个类注册和登录，现在我们再创建一个类去管理他们：
public class UserManager {
UserStroe mUserStroe;
ApiService mApiService;
public UserManager() {
mApiService = new ApiService();
mUserStroe = new UserStroe();
}
public void register() {
mApiService.register();
mUserStroe.login();
}
}
然后我们在MainActivity中去调用UserManager中的register方法。这么一个看好像是没什么问题，但是如果我们mApiService.register();需要一个Context参数怎么办？你可能会这么该：
public class UserManager {
UserStroe mUserStroe;
ApiService mApiService;
public UserManager(Context context) {
mApiService = new ApiService(context);
mUserStroe = new UserStroe();
}
public void register() {
mApiService.register();
mUserStroe.login();
}
}
调用处new UserManager(this);但是你注意看，我们只是需要一个context就要将UserManager和MainActivity中的代码都要改，要是在实际项目中，需要改更多的参数呢？所以我们来看下用Dagger2该如何解决。这里我把需求再复杂话一些。首先我们还是先从module来看：
这里我们将例子复杂一下假设ApiService需要一个context，userStroe需要一个url。我们就可以这样写
@Module
public class UserModule {
Context context;
public UserModule(Context context) {
this.context = context;
}
@Provides
public ApiService provideApiService() {
return new ApiService(context);
}
@Provides
public String providerUrl() {
return "www.baidu.com";
}
@Provides
public UserManager provideUserManager(ApiService apiService, UserStroe userStroe) {
return new UserManager(userStroe, apiService);
}
}
public class UserManager {
UserStroe mUserStroe;
ApiService mApiService;
public UserManager(UserStroe mUserStroe, ApiService mApiService) {
this.mUserStroe = mUserStroe;
this.mApiService = mApiService;
}
public void register() {
mApiService.register();
mUserStroe.login();
}
}
public class UserStroe {
@Inject
public UserStroe(String url) {
Log.d("TAG", "UserStroe: " + url);
}
public void login() {
Log.d("TAG", "UserStroe: ");
}
}
public class MainActivity extends AppCompatActivity {
@Inject
UserManager mManager;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerUserComponet.builder().userModule(new UserModule(this)).build().inject(this);
mManager.register();
Log.d("TAG", "onCreate: " + mManager);
}
}
这里我们创建DaggerUserComponet用了方法：
DaggerUserComponet.builder().userModule(new UserModule(this)).build().inject(this);
这个方法与之前用的其实内部都是一样的，因为我们UserModule需要context参数，所以我们选择这种构建方法
可以看到在创建对象时我们可以在module中像之前一样提供一个创建的方法，第二种我们也可以通过在对象的构造函数上加上@Inject注解，这里我们需要一个url和context，我们只需要提供一个创建String的url方法即可，并通过UserModule的构造函数将conetxnt传入，最后提供一个创建UserManager的方法将两个参数穿进去，最后运行一下：
dagger2 D/TAG: UserStroe: www.baidu.com
com.example.ggxiaozhi.dagger2 D/TAG: ApiService:
com.example.ggxiaozhi.dagger2 D/TAG: UserStroe:
com.example.ggxiaozhi.dagger2 D/TAG: onCreate: com.example.ggxiaozhi.dagger2.UserManager@4a7c6f00
可以看到我们修改了这么多，又需要URL，又需要context但是我们创建UserManager和调用方法没变，因为我们只是需要UserManager中的方法，里面你需要什么，怎么实现的对MainActivity它并不关心。所以这样就大大做到了解耦的目的。其实使用Dagger2就说白了就是调用者需要什么实例我就在module中创建什么实例，如果这个实例需要参数，需要什么参数，我就在mudule给你创建你想要的参数。
结语
这篇文章属于入门，下一章才是重点，我们会介绍@Qualifier，@Named ，@Singleton以及自定义注解。
