Dagger2使用(二)

2017-01-14 10:22:18来源:http://www.jianshu.com/p/89c7d46916a2作者:奋斗的Leo人点击

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<CoffeeModel> create
(
CoffeeModule module,
Provider<WaterModel> waterModelProvider,
Provider<MachineModel> 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
使用ProviderLazy
使用MembersInjector



最新文章

123

最新摄影

微信扫一扫

第七城市微信公众平台