前言
在Dagger2神器入门(二)中,我们通过简单的demo初步入门了Dagger2的简单使用,我们了解了@Inject,@Module,@Provides和@Componet等注解的使用方法。在这一章节中我们主要解决上篇文章中留下的3个问题:
1 为什么要使用Dagger2来替代文章一开头的写法?
2 如果@Inject的构造器有多个怎么办?
3 如何存在依赖链怎么办?
1 为什么要使用Dagger2来替代文章一开头的写法?
我们先回回顾一下文章开头的写法:
public class Car {
private Engine engine;
private Seat seat;
private Wheel wheel;
public Car() {
engine = new Engine();
seat = new Seat();
wheel = new Wheel();
Log.d(Config.TAG, "new Car()");
}
}
再看看使用Dagger2之后的代码:
public class Car {
@Inject
Engine engine;
@Inject
Seat seat;
@Inject
Wheel wheel;
// private Engine engine;
// private Seat seat;
// private Wheel wheel;
public Car() {
// engine = new Engine();
// seat = new Seat();
// wheel = new Wheel();
DaggerCarComponent
.builder()
.carModule(new CarModule())
.build()
.inject(this);
Log.d(Config.TAG, "new Car()");
}
}
那么问题来了?这样的写法好处在哪?
1 如果我修改Engine类的构造器,那么对于第一种做法应该同时修改Car构造器的;如果还有N个地方依赖了我的Engine构造器怎么办?只能一个一个的去修改,这就增加了代码修改难度;而使用Dagger2呢?你的@Inject依赖还是不会变 ,只要修改一下Module类即可。
2 再来看看第一种写法,虽然目的达到了,但是耦合度非常高;而第二种写法达到了解耦的目的。不能绝对的说哪种方式更好,这得看你的实际项目。
2 @Inject注解的Class有多个构造器怎么办?
神马意思呢?比如我们的车座可能会带一个座套,那么车座可能提供无车套车座和有车套车座。
public class Seat {
//默认无车套车座
public Seat(){
Log.d(Config.TAG,"new Seat()");
}
//提供有车套车座
public Seat(String str){
Log.d(Config.TAG,str);
}
}
那么接着第二章代码,会输出啥呢?
06-28 22:20:28.980 15053-15053/? D/TAG: new Engine()
06-28 22:20:28.981 15053-15053/? D/TAG: new Seat()
06-28 22:20:28.981 15053-15053/? D/TAG: new Wheel()
06-28 22:20:28.981 15053-15053/? D/TAG: new Car()
还是一样的输出?why?我们要想到我们提供依赖者?
@Provides
public Seat provideSeat(){
return new Seat();
}
因为这里提供的构造器就是无参的,我们换一个有参数的试试?
@Provides
public Seat provideSeat(){
return new Seat("有车套");
}
输出
06-28 22:22:55.886 17342-17342/? D/TAG: new Engine()
06-28 22:22:55.886 17342-17342/? D/TAG: 有车套
06-28 22:22:55.886 17342-17342/? D/TAG: new Wheel()
06-28 22:22:55.886 17342-17342/? D/TAG: new Car()
那么有人会问,一个类能够提供2个provide呢?在Module中像这样写:
@Provides
public Seat provideSeat(){
return new Seat();
}
@Provides
public Seat provideSeat2(){
return new Seat("有车套");
}
我们通过代码试试不就知道了?
Error:(13, 11) 错误: com.bae.basicandext.dagger.blog.bean.Seat is bound multiple times:
@Provides com.bae.basicandext.dagger.blog.bean.Seat com.bae.basicandext.dagger.blog.dagger.CarModule.provideSeat()
@Provides com.bae.basicandext.dagger.blog.bean.Seat com.bae.basicandext.dagger.blog.dagger.CarModule.provideSeats()
错误显示Seat类被绑定了多次。也就是说一个类只能提供一个构造器作为依赖。到这一步,我希望能够找到相关说明文档来再次验证自己的想法,因为我担心自己代码的错误导致自己错误的理解,官方文档给出的解释是100%正确的。
@Inject官方解释
@Inject can apply to at most one constructor per class。
这就验证了我的做法是正确的,同时也验证我的猜想是正确的。
3 如果存在依赖链怎么办?
什么意思?这让我想起了设计模式中的责任链模式,在学习的过程中不断的联想,这是一种比较好的学习方法,因为我们要遵循艾宾浩斯遗忘曲线去学习,不但的巩固才能不断的提高自己。
那么我们这里的依赖链是怎么回事呢?其实很简单,比如A依赖B,B依赖C,C依赖D...
回归到我们的例子,我们的车座要依赖于皮革(leather),那么我们怎么办?
public class Leather {
public Leather(){
Log.d(Config.TAG,"new Leather()");
}
}
修改一下我们的车座,提供皮革依赖注入
public class Seat {
private Leather leather;
public Seat(){
Log.d(Config.TAG,"new Seat()");
}
public Seat(String str){
Log.d(Config.TAG,str);
}
public Seat(Leather leather){
this.leather = leather;
Log.d(Config.TAG,"new Seat(Leather)");
}
}
可以看到,我们在原有的基础之上增加了一个构造器Seat(leather), 而该构造器是存在依赖参数的。而我们需要在@Inject的时候就能自动调用该构造器,怎么办? 在之前讲到的提供依赖Module类修改
@Provides
public Seat provideSeat(Leather leather){
return new Seat(leather);
}
仅仅这样是不行的,因为Module去寻找依赖Leather的时候会找不到对应对象,还需要添加
@Provides
public Leather provideLeather(){
return new Leather();
}
这样在执行provideSeat() 时,能够找到相应的Leather();
那么我们run下,先猜猜在
@Inject
Seat seat;
这个中如何执行的?
07-07 01:00:41.035 8144-8144/com.bae.basicandext D/TAG: new Engine()
07-07 01:00:41.035 8144-8144/com.bae.basicandext D/TAG: new Leather()
07-07 01:00:41.035 8144-8144/com.bae.basicandext D/TAG: new Seat(Leather)
07-07 01:00:41.035 8144-8144/com.bae.basicandext D/TAG: new Wheel()
07-07 01:00:41.035 8144-8144/com.bae.basicandext D/TAG: new Car()
很明了了,它能够自动找到Leather依赖。其实关键的关键还是在Module类中。
讲到这里,相信大家对Dagger2有一个初步认识,并且结合相关Api文档能够达到入门的目的了。接下来会一起学习一些其他Dagger2注解,期待吧...
上一篇Dagger2神器入门(二)
下一篇Dagger2神器入门(四)