Dagger是一个很古老的框架了，当初诞生时候，主要是为了模块之间的解耦。本篇文章主要介绍一下如何使用dagger2，后续会介绍其原理。
AS集成
对于现在的AS项目，一般都是会集成Kotlin和Java混写，所以可以在想要使用dagger的模块module的gradle下加入如下配置。
implementation 'com.google.dagger:dagger:2.21'
kapt 'com.google.dagger:dagger-compiler:2.21'
注意这里用到了kapt，这就要求我们对应module的gradle顶部有如下配置：
apply plugin: 'kotlin-kapt'
如何使用
假设我们现在存在一个类TestA, 结构如下：
public class TestA {
private int count = 0;
public String getValue() {
return "123321";
}
public int addSelf(){
return ++count;
}
}
我们现在呢，要在TestB中使用到TestA的对象实例，常规写法呢，就是new一个对象进行方法调用：
- 常规写法
public class TestB {
private final TestA testA = new TestA();
public void show() {
for (int i = 0; i < 2; i++) {
testA.addSelf();
System.out.println(testA.getValue());
}
}
}
- 使用dagger
常规写法要求我们对于一个对象必须要实例化，才能使用。那么在项目比较大型的时候，如果很多地方都用到了该对象，且进行了实例化。那么后续只要对象构造器里增加一个入参，那么就需要修改所有地方。
这样很容易出错，dagger这个时候就可以起作用了，dagger可以帮我们自动去书写实例化对象的代码，而我们只需要关注使用testA对象即可。
让我们看下使用dagger，这里代码怎么写。
public class TestB {
@Inject
TestA testA;
public void show() {
for (int i = 0; i < 2; i++) {
testA.addSelf();
System.out.println(testA.getValue());
}
}
}
可以看到，区别就是将new TestA去掉了，加上了@Inject注解，让Dagger自动帮我们去进行TestA的实例化，我们只需要加上注解后，在下方直接使用其方法即可。
现在我们知道了dagger的作用和简单的使用场景，我们来看下如果要实现上述例子中TestA这种直接加注解来实例对象的方式，该怎么操作。
使用dagger来实现TestA自动实例化
下图是Dagger里最基本的几个注解的使用及关系。
image.png
对于上述TestA的例子。我们首先按照上图所示，定义一个Module，如下：
@Module
public class TestAModule {
@Provides
public TestA provide() {
return new TestA();
}
}
这里对于provide方法可以任意命名，只要返回值是TestA就可以。同时TestAModule也可以任意命名，只要加上Module注解即可。
接着，我们定义桥梁Component，类和方法也可以随意命名。
@Component(modules = TestAModule.class)
public interface TestAComponent {
void injectIntoTestB(TestB testB);
}
注意Component上要写上，该Component所对应的Module，以便Dagger可以关联两者。同时内部定义一个接口也需要传入TestB对象，以便告诉Dagger，我们想要在哪个类中使用TestA实例。
做完这些，最后一步就是在TestB中使用了。
public class TestB {
@Inject
TestA testA;
public void show() {
for (int i = 0; i < 2; i++) {
testA.addSelf();
System.out.println(testA.getValue());
}
}
}
注意这里TestA不可以是private修饰。
我们需要先build一下，编译完成后，还需要最后一步，在TestB中运行一下Dagger。可以在show方法中加上如下方法：
DaggerTestAComponent.create().injectIntoTestB(this);
DaggerTestAComponent是Dagger在我们构建编译时候为我们生成的，所以此时不编译是看不到这个类的，必须编译一下。
运行一下，我们就可以使用这个类了。所有Dagger自动生成的类都是以Dagger开头。
如果找不到文件！！\color{red}{如果找不到文件！！}如果找不到文件！！
可能某些小伙伴发现，编译后仍然找不到这个类，那么说明你的项目开启了增量编译，需要gradle.properties中将其关闭。 在 gradle.properties 中加上如下配置，然后删除build文件夹，重新编译。
kapt.incremental.apt = false
最后我们运行一下，发现日志可以成功打印，说明执行成功了。
注意这个时候，TestB文件中张这样。
public class TestB {
@Inject
TestA testA;
public void show() {
DaggerTestAComponent.create().injectIntoTestB(this);
for (int i = 0; i < 2; i++) {
testA.addSelf();
System.out.println(testA.getValue());
}
}
实现单例
上述我们简单实现了个例子，同时我们可以在类中直接实例化一个对象并进行使用。我们看下如何实现。
我们可以在Provides注解标注的方法上加上Singleton注解，表示通过该方法生成的对象为单例对象，但是要注意，该单例的范围仅限于inject时候传入的对象。
比如：
@Module
public class TestAModule {
@Provides
@Singleton
public TestA provide() {
return new TestA();
}
}
注意在Component上也要加上Singleton注解。
@Component(modules = TestAModule.class)
@Singleton
public interface TestAComponent {
void injectIntoTestB(TestB testB);
void injectIntoTestC(TestC testC);
}
对于上述方法，我在TestB和TestC中使用时候：
public class TestB {
@Inject
TestA testA1;
@Inject
TestA testA2;
public void show() {
DaggerTestAComponent.create().injectIntoTestB(this);
System.out.println(testA1);
System.out.println(testA2);
}
}
public class TestC {
@Inject
TestA testA1;
@Inject
TestA testA2;
public void dd() {
DaggerTestAComponent.create().injectIntoTestC(this);
System.out.println("C:" + testA1);
System.out.println("C:" + testA2);
}
}
我们同时运行dd和show方法时候，会发现两个dd方法内地址打印一样，show方法内地址打印一样，但是dd方法和show方法打印的地址就不一样了。这是因为单例的范围和inject传入的对象有关，只在传入的对象范围内生效。
name标签
Dagger存在一个Name标签，主要用于确定对象的不同生成方式。比如我们TestA存在多个构造器。
public class TestA {
public TestA() {
}
public TestA(int count) {
this.count = count;
}
private int count = 0;
public String getValue() {
return "123321 " + count;
}
那么可以在module中使用name来区分不同方式来生成对象实例。
@Module
public class TestAModule {
@Provides
@Named("11")
public TestA provide() {
return new TestA();
}
@Provides
@Named("22")
public TestA provide2() {
return new TestA(22);
}
我们在TestB中使用，
public class TestB {
@Inject
@Named("11")
TestA testA1;
@Inject
@Named("22")
TestA testA2;
public void show() {
DaggerTestAComponent.create().injectIntoTestB(this);
System.out.println("11=>" + testA1.getValue());
System.out.println("22=>" + testA2.getValue());
}
运行一下方法 show，可以看到此时testA1和testA2分别调用了不同的构造器生成了对象。
总结
个人感觉，dagger在当下直接使用，比较鸡肋，想不到很合适的使用场景，毕竟当下这么多框架和新技术，对于各种场景，完全有更合适的框架。所以本文只打算对dagger研究这么多。为后续Hilt学习打个基础吧。
网友评论