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);
這里有個需要注意的地方,如果同時使用兩種方式,優(yōu)先使用第二種方式產生的
按上面的步驟寫好,我們已經能簡單使用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所需要的實例,那怎么樣能讓兩者之間產生聯系呢?繼續(xù)往下看.
@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可以非常方便解決對象實例之間的依賴,具體有以下幾種方式:
- 常規(guī)方式是通過使用
@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(); } - 待續(xù)
無論是通過哪種方式去,去實現注入,最終都是產生為一張Building the Graph,這個是官方文檔的定義,簡單來說就是,依賴構建圖.起點是通過@Inject或@Provides提供的實例源,終點就是所需要注入的對象.這個可能有點抽象,但是Dagger的核心所在.可以想象為,工廠組裝機器流程.首先需要原料,在Dagger中就是@Provides,從原料組裝為成品,需要設計圖來提供所需要原料和原料用量等等,在Dagger中,我們通過使用dependencies,@Subcomponent,@Inject等等提供類實例產生所需要的依賴關系圖,最后的產品就是我們需要的類實例.
以下是可以作為依賴關系,并且可以用來產生構建圖(翻譯于官方文檔)
- 通過
@Provides標示的方法 -
@Inject標示的構造方法 - 使用
dependencies的Components所提供的@Provides -
Components本身 - 使用
@Subcomponent標示的Components - 使用
Provider和Lazy - 使用
MembersInjector
