Dagger简单使用
要实现注入,至少需要@Component
可以简单理解为注入器,由它将需要注入和对象实例提供连接起来.还需要@Inject
来标示需要注入的对象.我们从个简单的例子来看看Dagger是怎么实现注入的:
//这里是一个需要注入的UseModel,用@Inject标示
@Inject
UseModel mUseModel;
//还需要一个Component
@Component(modules = UseModule.class)
interface UseComponent
{
//这个方法比较特殊,它的作用在于提供需要注入的地方.注意:参数一定要是具体类型
void inject(MainActivity activity);
}
现在有了需要注入的对象和注入器,那还少什么呢?还少了提供对象实例的源.Dagger并没有什么魔力,能凭空生成类实例,它只是用了巧妙的用了工厂设计模式,这个以后会讲到.那这个实例源要怎么写呢?
Dagger提供两种方法:
- 如果类有无参构造方法,那么只要将
@Inject
标示在上面就可以:
//注意:如果构造方法是含参的,就需要提供参数,这种情况后面会讲到
@Inject
public UseModel()
{
mName = "null";
mAge = 0;
Logger.d("无参数构造方法");
}
- 还有就是使用
@Module
:
//@Provides标示,这个方法通过返回值提供注入对象的实例
@Provides
UseModel providesUseModel()
{
return new UseModel("leo",23);
}
使用@Module
的参数includes
,可以导入其他@Module
,可以增加@Module
的复用
@Module(includes = CarModule.class)
public class UseModule
{
@Provides
@Singleton
UseModel providesUseModel()
{
return new UseModel("leo",23);
}
}
现在注入器,实例源,注入方法也有了,那应该怎么使用:
if (mUseComponent == null)
{
//Dagger%Component是Component编译生成的,所以写好Component后,要clean,build项目后才能生成,没有就标示存在语法错误
mUseComponent = DaggerUseComponent.create();
}
mUseComponent.inject(this);
这里有个需要注意的地方,如果同时使用两种方式,优先使用第二种方式产生的
按上面的步骤写好,我们已经能简单使用Dagger了,不过Dagger还提供了其他好用的功能,也一一了解下.
注解的使用
+ #### `@Scope`的使用
`@Scope`是个用来标示范围的注解,默认是没有范围.如果提供实例的源(如`@Inject`标注的构造方法或是`@Provides`标示的方法)标示了`@Scope`(可以自定义Scope),那么对应的`@Compontent`也需要标示该`@Scope`,不然编译不通过,而且`@Scope`只能标示一个.
自定义`@Scope`的作用主要是在编译时候起_提醒范围_作用,不过Dagger会对`@Singleton`这些进行特殊处理,而自定义的则不行,这是需要注意的地方.
+ #### `@Singleton`的使用
使用`@Singleton`可以实现单例模式,还是通过代码来看下用法:
```
@Component(modules = UseModule.class)
@Singleton
interface UseComponent
{
void inject(MainActivity activity);
}
@Module
public class UseModule
{
@Provides
@Singleton
UseModel providesUseModel()
{
return new UseModel("leo",23);
}
}
```
从上面的代码看,有两个地方要用`@Singleton`标示,分别是在Component,Provides中,这里要注意的是,Component是必须使用`@Singleton`标示,不然编译不通过.这也是`@Scope`的主要作用:_保证Component作用范围_,但仅仅是`@Scope`的作用,如果要实现`@Singleton`的单例作用,需要在`@Provides`上也要添加标示,这是起单例作用的地方,而如果是通过构造方法提供实例的话,`@Singleton`标示应该放在类上,不然编译不通过,这是需要特别注意的地方:
```
@Singleton
public class UseModel
{
@Inject
public UseModel()
{
mName = "null";
mAge = 0;
Logger.d("无参数构造方法");
}
}
```
注入的时候,也要注意,只有使用同个Compenton才有单例作用:
```
if (mUseComponent == null)
{
mUseComponent = DaggerUseComponent.create();
}
mUseComponent.inject(this);
```
到这里,我们已经能写个单例注入例子了,至于为什么使用`@Singleton`能产生单例?这个后面可以通过查看编译产生的`Dagger%Componton`,可以大概了解一下.
+ #### @Named的使用
这个注解作用是标示使用不同的类实例,用法也比较简单,看下代码就可以了:
```
//Module中标示产生不同的CarModel实例
@Provides
@Named("baoma")
static CarModel providesCarModelBaoMa()
{
return new CarModel("baoma",10000);
}
@Provides
@Named("benchi")
static CarModel providesCarModelBenChi()
{
return new CarModel("benchi",2000);
}
//注入的时候,也要标示使用的实例
@Named("baoma")
@Inject
CarModel mCarModel1;
@Named("benchi")
@Inject
CarModel mCarModel2;
```
这个标注使用比较简单,不过有几个要注意的地方,使用注入的地方,使用的`@Named`的值,在`@Provides`要有,如果没有使用`@Named`,那么`@Provides`中也要提供没有用`@Named`标示,不然编译不通过
+ #### @Subcomponent的使用
这个注解的作用跟使用`@Component`的参数`dependencies`类似,用法不一样.`@Subcomponent`可以用来标示一个Component,表示这个是子Component,需要依赖于其他`@Component`才能注入.看下代码:
```
//这里除了将Component换成Subcomponent,没有其他不同
@Subcomponent(modules = CoffeeModule.class)
public interface CoffeeComponent
{
void inject(CoffeeActivity activity);
}
@Module
public class CoffeeModule
{
private String mCoffeeName;
public CoffeeModule(String coffeeName)
{
mCoffeeName = coffeeName;
}
//可以看到WaterModel和MachineModel,是需要从外部注入的,如果不标示Subcomponent,编译不通过
@Provides
CoffeeModel providesCoffee(WaterModel waterModel, MachineModel machineModel)
{
return new CoffeeModel(mCoffeeName,machineModel,waterModel);
}
}
```
从上面的代码,我们可以知道,CoffeeModel实例化需要WaterModel和MachineModel两个实例,但在CoffeeModule中,我们并没有提供所需要的实例,也没有在`@Component`中使用`dependencies`去依赖其他`@Component`,那这个`@Subcomponent`该怎么去注入呢?还是看代码:
```
//可以看到ConfigModule中提供了CoffeeModel所需要的实例,那怎么样能让两者之间产生联系呢?继续往下看.
@Module
public class ConfigModule
{
@Provides
WaterModel providesWaterModel()
{
return new WaterModel(200);
}
@Provides
MachineModel providesMachineModel()
{
return new MachineModel("dog");
}
}
//跟inject方法是不是有种相似的感觉,在这里去返回CoffeeComponent的实例
@Component(modules = ConfigModule.class)
public interface ConfigComponent
{
CoffeeComponent newCoffeeComponent(CoffeeModule coffeeModule);
}
//实现注入
if (mCoffeeComponent == null)
{
mCoffeeComponent = DaggerConfigComponent.create().newCoffeeComponent(new CoffeeModule("狗屎咖啡"));
}
mCoffeeComponent.inject(this);
```
看到这里,可能会有点迷糊,稍微看下Dagger帮我们生成的代码,可能更好了解一下:
```
@Override
public CoffeeComponent newCoffeeComponent(CoffeeModule coffeeModule)
{
//当我们调用newCoffeeComponent,会去生成一个CoffeeComponentImpl实例
return new CoffeeComponentImpl(coffeeModule);
}
//跳过其他代码,以后再具体看下,直接看关键代码块就行
public static Factory create
(
CoffeeModule module,
Provider waterModelProvider,
Provider machineModelProvider)
{
//CoffeeModule_ProvidesCoffeeFactory可以产生我们需要的CoffeeModel,而所需要的其他两个实例,就是在这里传递进去的
return new CoffeeModule_ProvidesCoffeeFactory(module, waterModelProvider, machineModelProvider);
}
```
其他注解有待补充......
依赖构建图
Dagger可以非常方便解决对象实例之间的依赖,具体有以下几种方式:
- 常规方式是通过使用
@Inject
标示构造方法和使用@Provides
标示的返回值为所需要实例的方法,这里要注意下:@Provides
要在@Module
中才能使用. -
@Component
之间可以通过dependencies
实现依赖,还是通过代码来看下使用:
//在这里通过指定dependencies=ConfigComponent.class,来实现CoffeeComponent对ConfigComponent的依赖
@Component(dependencies = ConfigComponent.class, modules = CoffeeModule.class)
public interface CoffeeComponent
{
void inject(CoffeeActivity activity);
}
@Component(modules = ConfigModule.class)
public interface ConfigComponent
{
//这两个方法是必须的,作用在于将CoffeeComponent所需要的WaterModel和MachineModel暴露出来
WaterModel water();
MachineModel machine();
}
//下面是两个Module的代码
@Module
public class CoffeeModule
{
private String mCoffeeName;
public CoffeeModule(String coffeeName)
{
mCoffeeName = coffeeName;
}
//可以看出,实例化CoffeeModel,需要WaterModel和MachineModel,但在CoffeeModule中,我们并不能找到哪里提供,实际上,它们是在ConfigModule中提供
@Provides
CoffeeModel providesCoffee(WaterModel waterModel, MachineModel machineModel)
{
return new CoffeeModel(mCoffeeName,machineModel,waterModel);
}
}
//ConfigModule中提供了CoffeeModule中所需要的WaterModel和MachineModel
@Module
public class ConfigModule
{
@Provides
WaterModel providesWaterModel()
{
return new WaterModel(100);
}
@Provides
MachineModel providesMachineModel()
{
return new MachineModel("android");
}
}
综合上面的代码,我们可以猜测出来,通过使用dependencies
指定依赖的Component,再在依赖的Component中暴露返回实例的方法,就可以使用所依赖Component中产生类实例
-
Component
还可以依赖于自身://相对于使用dependencies,不需要下面这两行: WaterModel water(); MachineModel machine(); @Provides WantClass providesWantClass(DependA dependA, DependB dependB) { return new WantClass(dependA, dependB); } @Provides DependA providesDependA(DependC dependC) { return new DependA(dependC); } @Provides DependC providesDependC(DependD dependD) { return new DependC(dependD); } @Provides DependD providesDependD() { return new DependD(); } @Provides DependB providesDependB() { return new DependB(); }
- 待续
无论是通过哪种方式去,去实现注入,最终都是产生为一张Building the Graph
,这个是官方文档的定义,简单来说就是,依赖构建图.起点是通过@Inject
或@Provides
提供的实例源,终点就是所需要注入的对象.这个可能有点抽象,但是Dagger的核心所在.可以想象为,工厂组装机器流程.首先需要原料,在Dagger中就是@Provides
,从原料组装为成品,需要设计图来提供所需要原料和原料用量等等,在Dagger中,我们通过使用dependencies
,@Subcomponent
,@Inject
等等提供类实例产生所需要的依赖关系图,最后的产品就是我们需要的类实例.
以下是可以作为依赖关系,并且可以用来产生构建图(翻译于官方文档)
- 通过
@Provides
标示的方法 -
@Inject
标示的构造方法 - 使用
dependencies
的Components所提供的@Provides
-
Components
本身 - 使用
@Subcomponent
标示的Components - 使用
Provider
和Lazy
- 使用
MembersInjector