前面长篇大论的基本都在介绍概念,下面我们看看Dagger2的基本应用。关于Dagger2的依赖配置就不在这里占用篇幅去描述了,大家可以到它的github主页下去查看官方教程https://github.com/google/dagger。接下来我们还是拿前面的Car和Engine来举例。
1、案例A
Car类是需求依赖方,依赖了Engine类;因此我们需要在类变量Engine上添加@Inject来告诉Dagger2来为自己提供依赖。
public class Car {
@Inject
Engine engine;
public Car() {
DaggerCarComponent.builder().build().inject(this);
}
public Engine getEngine() {
return this.engine;
}
}
Engine类是依赖提供方,因此我们需要在它的构造函数上添加@Inject
public class Engine {
@Inject
Engine(){}
public void run(){
System.out.println("引擎转起来了~~~");
}
}
接下来我们需要创建一个用@Component标注的接口CarComponent,这个CarComponent其实就是一个注入器,这里用来将Engine注入到Car中。
@Component
public interface CarComponent {
void inject(Car car);
}
完成这些之后我们需要Build下项目,让Dagger2帮我们生成相关的Java类。接着我们就可以在Car的构造函数中调用Dagger2生成的DaggerCarComponent来实现注入(这其实在前面Car类的代码中已经有了体现)
public Car() {
DaggerCarComponent.builder().build().inject(this);
}
2、案例B
如果创建Engine的构造函数是带参数的呢?比如说制造一台引擎是需要齿轮(Gear)的。或者Eggine类是我们无法修改的呢?这时候就需要@Module和@Provide上场了。
同样我们需要在Car类的成员变量Engine上加上@Inject表示自己需要Dagger2为自己提供依赖;Engine类的构造函数上的@Inject也需要去掉,应为现在不需要通过构造函数上的@Inject来提供依赖了。
public class Car {
@Inject
Engine engine;
public Car() {
DaggerCarComponent.builder().markCarModule(new MarkCarModule())
.build().inject(this);
}
public Engine getEngine() {
return this.engine;
}
}
接着我们需要一个Module类来生成依赖对象。前面介绍的@Module就是用来标准这个类的,而@Provide则是用来标注具体提供依赖对象的方法(这里有个不成文的规定,被@Provide标注的方法命名我们一般以provide开头,这并不是强制的但有益于提升代码的可读性)。
@Module
public class MarkCarModule {
public MarkCarModule(){ }
@Provides Engine provideEngine(){
return new Engine("gear");
}
}
接下来我们还需要对CarComponent进行一点点修改,之前的@Component注解是不带参数的,现在我们需要加上modules = {MarkCarModule.class},用来告诉Dagger2提供依赖的是MarkCarModule这个类。
@Component(modules = {MarkCarModule.class})
public interface CarComponent {
void inject(Car car);
}
Car类的构造函数我们也需要修改,相比之前多了个markCarModule(new MarkCarModule())方法,这就相当于告诉了注入器DaggerCarComponent把MarkCarModule提供的依赖注入到了Car类中。
public Car() {
DaggerCarComponent.builder()
.markCarModule(new MarkCarModule())
.build().inject(this);
}
这样一个最最基本的依赖注入就完成了,接下来我们测试下我们的代码。
public static void main(String[] args){
Car car = new Car();
car.getEngine().run();
}
输出
引擎转起来了~~~
3、案例C
那么如果一台汽车有两个引擎(也就是说Car类中有两个Engine变量)怎么办呢?没关系,我们还有@Qulifier!首先我们需要使用Qulifier定义两个注解:
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface QualifierA { }
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface QualifierB { }
同时我们需要对依赖提供方做出修改
@Module
public class MarkCarModule {
public MarkCarModule(){ }
@QualifierA
@Provides
Engine provideEngineA(){
return new Engine("gearA");
}
@QualifierB
@Provides
Engine provideEngineB(){
return new Engine("gearB");
}
}
接下来依赖需求方Car类同样需要修改
public class Car {
@QualifierA @Inject Engine engineA;
@QualifierB @Inject Engine engineB;
public Car() {
DaggerCarComponent.builder().markCarModule(new MarkCarModule())
.build().inject(this);
}
public Engine getEngineA() {
return this.engineA;
}
public Engine getEngineB() {
return this.engineB;
}
}
最后我们再对Engine类做些调整方便测试
public class Engine {
private String gear;
public Engine(String gear){
this.gear = gear;
}
public void printGearName(){
System.out.println("GearName:" + gear);
}
}
测试代码
public static void main(String[] args) {
Car car = new Car();
car.getEngineA().printGearName();
car.getEngineB().printGearName();
}
执行结果:
GearName:gearA
GearName:gearB
4、案例D
接下来我们看看@Scope是如何限定作用域,实现局部单例的。
首先我们需要通过@Scope定义一个CarScope注解:
@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface CarScope {
}
接着我们需要用这个@CarScope去标记依赖提供方MarkCarModule。
@Module
public class MarkCarModule {
public MarkCarModule() {
}
@Provides
@CarScope
Engine provideEngine() {
return new Engine("gear");
}
}
同时还需要使用@Scope去标注注入器Compoent
@CarScope
@Component(modules = {MarkCarModule.class})
public interface CarComponent {
void inject(Car car);
}
为了便于测试我们对Car和Engine类做了一些改造:
public class Car {
@Inject Engine engineA;
@Inject Engine engineB;
public Car() {
DaggerCarComponent.builder()
.markCarModule(new MarkCarModule())
.build().inject(this);
}
}
public class Engine {
private String gear;
public Engine(String gear){
System.out.println("Create Engine");
this.gear = gear;
}
}
如果我们不适用@Scope,上面的代码会实例化两次Engine类,因此会有两次"Create Engine"输出。现在我们在有@Scope的情况测试下劳动成果:
public static void main(String[] args) {
Car car = new Car();
System.out.println(car.engineA.hashCode());
System.out.println(car.engineB.hashCode());
}
输出
Create Engine
bingo!我们确实通过@Scope实现了局部的单例。