Android单排上王者系列之Dagger2使用解析

2017-01-14 15:49:11来源:http://www.jianshu.com/p/98e344cadd8b作者:study_zhxu人点击

第七城市
本篇文章已授权微信公众号 guolin_blog (郭霖)独家发布
前言

现在Dagger2在项目中的使用越来越多,Dagger2是Dagger的升级版本,Dagger没有使用过,但是本篇说的是Dagger2,主要讲解的是Dagger2是如何使用的。对了,忘了说Dagger其实是一个依赖注入的框架。


什么是依赖注入

依赖注入是一种面向对象的编程模式,它的出现是为了降低耦合性,所谓耦合就是类之间依赖关系,所谓降低耦合就是降低类和类之间依赖关系。可能有的人说自己之前并没有使用过依赖注入,其实真的没有使用过吗?当我们在一个类的构造函数中通过参数引入另一个类的对象,或者通过set方法设置一个类的对象其实就是使用的依赖注入。


通常依赖注入有以下几种方式
通过接口注入
interface ClassBInterface { 
void setB(ClassB b);
}
public class ClassA implements ClassBInterface {
ClassB classB;
@override
void setB(ClassB b) {
classB = b;
}
}

通过set方法注入
public class ClassA { 
ClassB classB;
public void setClassB(ClassB b) {
classB = b;
}
}

通过构造方法注入
public class ClassA { 
ClassB classB;
public void ClassA(ClassB b) {
classB = b;
}
}

通过注解的方式注入
public class ClassA { 
//此时并不会完成注入,还需要依赖注入框架的支持,如Dagger2
@inject
ClassB classB;
public ClassA() {
}
}

下面我们就来说说如何通过Dagger2来实现依赖注入吧。引入Dagger2
添加apt插件
dependencies { 
classpath 'com.android.tools.build:gradle:2.1.2' //添加apt插件
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
}

添加依赖(在build.gradle中添加如下代码)
apply plugin: 'com.android.application' //添加如下代码,应用apt插件 
apply plugin: 'com.neenbedankt.android-apt'
...
dependencies {
...
compile 'com.google.dagger:dagger:2.4' apt 'com.google.dagger:dagger-compiler:2.4' //java注解
compile 'org.glassfish:javax.annotation:10.0-b28'
...
}

使用Dagger2
添加完Dagger的依赖后我们如何在项目中使用Dagger呢?
在项目中绝大多数的使用都是Dagger结合MVP架构使用的,在MVP中使用是非常典型的降低耦合的使用。不懂MVP的可以看这里。
本篇文章中的示例是一个简单的登陆功能的示例,代码沿用上篇讲解MVP的登陆代码,看这里,该示例采用MVP架构设计通过Dagger2进行解耦合,下面就来看看如何使用吧。
在使用Dagger2前我们最好简单的了解一下MVP,主要是为了理解本篇中的代码。简单了解MVP即使不会写MVP也可以看的懂本篇的代码。
为什么要选择在MVP模式中使用Dagger2呢?
因为在MVP模式中Activity持有presenter的引用,同时presenter也持有view的引用,这样便于更新UI界面,这样Activity就和presenter仅仅的耦合在一起了,而Dagger2是依赖注入框架就是解耦合的,所以子MVP中使用Dagger2也就再好不过了。
在上篇文章讲解MVP时我们可以明显的看到如下代码
public class LoginActivity extends AppCompatActivity implements ILoginView,View.OnClickListener{ 
private Button mLogin ;
private Button mClear ;
private EditText mName ;
private EditText mPassWord ;
ILoginPresenter loginPresenter ;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mLogin = (Button) findViewById(R.id.btn_login);
mClear = (Button) findViewById(R.id.btn_clear);
mName = (EditText) findViewById(R.id.et_name);
mPassWord = (EditText) findViewById(R.id.et_password);
mLogin.setOnClickListener(this);
mClear.setOnClickListener(this); //持有presenter的引用并且创建对象
loginPresenter = new LoginPresenterCompl(this) ;
}
........
}

在上述代码中可以看到activity持有了presenter的引用并且创建了该对象,但是如果presenter的构造函数发生改变则这里也需要改变,其实所有和presenter构造函数相关的代码都要改变。
但是如果我们使用Dagger2依赖框架该如何使用呢?
请看下面代码activity中的代码
public class LoginActivity extends AppCompatActivity implements ILoginView,View.OnClickListener{ 
..........
//注意此处使用了注解
@Inject LoginPresenterCompl loginPresenter ;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mLogin = (Button) findViewById(R.id.btn_login);
mClear = (Button) findViewById(R.id.btn_clear);
mName = (EditText) findViewById(R.id.et_name);
mPassWord = (EditText) findViewById(R.id.et_password);
mLogin.setOnClickListener(this);
mClear.setOnClickListener(this);
DaggerMainComponent.builder().mainModule(new MainModule(this)).build().inject(this);
}
.......
}

LoginPresenterCompl中的代码
public class LoginPresenterCompl implements ILoginPresenter { 
private ILoginView loginView ;
private User user ;
//注意此处使用了注解
@Inject public LoginPresenterCompl(ILoginView view){
loginView = view ;
user = new User("张三","123456") ;
}
......
}

只有上述两个注解还无法完成依赖注入,还需要如下两个新增类新增的MainModule类
@Modulepublic 
class MainModule {
private final ILoginView view ;
public MainModule(ILoginView view){
this.view = view ;
}
@Provides
ILoginView provideILogView(){
return view ;
}
}

新增的MainComponent接口
@Component(modules = MainModule.class)
public interface MainComponent {
public void inject(LoginActivity activity) ;
}

通过直接注解和上述两个接口类即可完成Dagger2的依赖注入。在LoginActivity中是通过
DaggerMainComponent.builder().mainModule(new MainModule(this)).build().inject(this)

完成依赖注入的。看完上面的代码后,一脸的懵逼,WTF(what the fuck),这TM是什么,这么复杂,还不如之前的简单呢,新增了两个类还有这么多代码,得不偿失呀!
同志们,如果你们第一眼看到后是这样想的话,说明和我想的一样,呵呵。每一个刚接触Dagger2的人可能都会这样想,因为我们只看到了表面。
不错,表面上我们是多了一个类和接口也多了很多代码,但是这样的组合其实是可以理解的。因为通常简单的代码具有耦合性,而要想降低这样的耦合就需要其他的辅助代码,其实少代码量和低耦合这两者并不能同时兼顾,古人云:鱼和熊掌不可兼得。我们作为堂堂聪明绝顶的程序猿怎么可能会输给古人呢。
好!下面来认真讲解Dagger2是如何完成依赖注入的。
首先我们来看看LoginActivity代码LoginActivity中有这么一段代码
@Inject
LoginPresenterCompl loginPresenter ;

同样在LoginPresenterCompl中也有这么一段代码
@Inject
public LoginPresenterCompl(ILoginView view){
loginView = view ;
user = new User("张三","123456") ;
}

之所以挑出这两段代码是因为它们都添加了@Inject注解。
在LoginActivity中其实只有这么一句提到loginPresenter,在接下来的代码中并没有对其进行初始化。那loginPresenter是如何进行初始化的呢(此处注意添加@Inject注解的变量不能被private修饰)?
直观上我们可以这样理解,被@Inject注解的代码存在某种联系,当代码执行到@Inject的时候程序会自动进入到这个类的构造方法中,如果正巧这个构造方法也被@Inject修饰了,那么系统就会帮我们自动创建对象。
这只是表面的理解,这其中肯定还有很多我们没有看到的“猫腻”。这俩不会无缘无故的有联系,肯定还有第三者,通过这个第三者这两个被@Inject注解修饰的代码才会产生联系。
这个第三者是谁呢?
自然的我们就会想到我们添加的这个类和接口。
首先我们来分析MainComponent接口代码如下
@Component(modules = MainModule.class)
public interface MainComponent {
public void inject(LoginActivity activity) ;
}

MainComponent是一个接口(也可以是一个抽象类),在这个接口中我们定义了一个inject()方法,其中参数是LoginActivity对象,同时MainComponent还被@Component注解着,注解中modules的值是MainModule.class,这个内容会在接下来的地方进行说明,暂时先放一放。
此时在Android studio中,如果我们rebuild的一下项目就会有新的发现。在项目的build/generated/source/apt/debug/项目包名/dragger目录下生成对应的包其中包含DaggerMainComponent类,这个类名其实不是固定的,是根据我们上面写的MainComponent,加了Dagger前缀生成的DaggerMainComponent。其实在这个时候我们就已经完成了present的依赖注入。但是在
DaggerMainComponent.builder().mainModule(new MainModule(this)).build().inject(this)

中我们看到还有一个MainModule,这个是我们自己创建的一个类MainModule代码如下
@Modulepublic 
class MainModule {
private final ILoginView view ;
public MainModule(ILoginView view){
this.view = view ;
}
@Provides
ILoginView provideILogView(){
return view ;
}
}

我们可以看到这个类被@Module注解修饰,内部有一个ILoginView的变量和一个构造方法还有一个被@Provides修饰的provideILogView方法。
看到这还是一脸懵逼,这个类是干嘛的?
在MainComponent接口中我们看到这么一个注解@Component(modules = MainModule.class),这里用到了MainModule,可见MainComponent需要MainModule一起才能完成工作。其实这个类我们可以理解成提供参数的,也就是提供参数依赖的,如何理解呢?
在MainModule中我们为什么要提供ILoginView类型的对象?为什么不是其他的呢?这是因为LoginPresenterCompl的构造函数需要这么一个参数,所以我们在这里提供这么一个相同的参数,并通过被@Provides注解修饰的方法将其返回出去,如果LoginPresenterCompl还需要其他的参数,同样我们也可以在这里添加对应类型的参数然后通过另一个被@Provides注解修饰的方法返回出去。在MainComponent接口中提供的inject()方法的参数是LoginActivity,这个参数的含义是LoginPresenter要在什么地方注入。

了解了各个类的功能后我们来总结一下


@Inject 程序会将Dagger2会将带有此注解的变量或者构造方法参与到依赖注入当中,Dagger2会实例化这个对象- @Module 带有该注解的类需要对外提供依赖,其实就是提供实例化需要的参数,Dagger2在实例化的过程中发现一些参数,Dagger2就会到该类中寻找带有@Provides注解的以provide开头的需找对应的参数
@Component 带有该注解的接口或抽象类起到一个关联桥梁的作用,作用就是将带有@Inject的方法或对象和带有@Module的类进行关联,只有通过该接口或抽象类才可以在实例化的时候到带有@Module中类中去寻找需要的参数,也就是依赖注入。

OK,下面我们来捋捋思路。


1、在这个示例代码中,LoginActivity中需要LoginPresenterCompl,所以在LoginActivity中定义了该对象并且通过@Inject将其注解,同时到LoginPresenterCompl的构造方法中也通过@Inject将其注解,表明这些是需要依赖注入的。
2、因为在LoginPresenterCompl的构造方法需要ILoginView类型的参数,所以需要通过依赖将获取这些参数,所以就需要带有@Module注解的类用于获取需要的参数,在@Module注解的类中通过被@Provides注解的以provide开头的方法对外提供需要的参数,一般而言有几个参数就需要有几个带有@Provides的方法。
3、此时还需要一个桥梁将两者联系到一起,带有@Component的接口或抽象类就起到这个桥梁的作用。注解中有一个module的值,这个值指向需要依赖的Module类,同时其中有一个抽象方法inject(),其中的参数就是我们需要在哪个类中实例化LoginPreserentCompl,因为我们需要在LoginActivity中实例化,所以参数类型就是LoginActivity类型。然后在Android studio中rebuild我们的项目,就会生成DaggerMainComponent类,通过
DaggerMainComponent.builder().mainModule(new MainModule(this)).build().inject(this);

完成我们需要的依赖注入。###总结可能我们通过上面的讲解,知道了如何使用Dagger2了,也知道具体的流程了,但是可能还会有些疑惑,为什么?Dagger2是如何通过一些接口和类就完成依赖注入的?在此声明,别着急,知道如何使用这只是第一步,在下一篇文章中将会讲解Dagger2实现依赖注入的原理。敬请期待!!!



第七城市

最新文章

123

最新摄影

微信扫一扫

第七城市微信公众平台