Dagger简单使用

要实现注入,至少需要@Component可以简单理解为注入器,由它将需要注入和对象实例提供连接起来.还需要@Inject来标示需要注入的对象.我们从个简单的例子来看看Dagger是怎么实现注入的:

//这里是一个需要注入的UseModel,用@Inject标示
@Inject
UseModel mUseModel;

//还需要一个Component
@Component(modules = UseModule.class)
interface UseComponent
{
    //这个方法比较特殊,它的作用在于提供需要注入的地方.注意:参数一定要是具体类型
    void inject(MainActivity activity);
}

现在有了需要注入的对象和注入器,那还少什么呢?还少了提供对象实例的源.Dagger并没有什么魔力,能凭空生成类实例,它只是用了巧妙的用了工厂设计模式,这个以后会讲到.那这个实例源要怎么写呢?

Dagger提供两种方法:

1. 如果类有无参构造方法,那么只要将@Inject标示在上面就可以:

//注意:如果构造方法是含参的,就需要提供参数,这种情况后面会讲到
@Inject
public UseModel()
{
    mName = "null";
    mAge = 0;
    Logger.d("无参数构造方法");
}

2. 还有就是使用@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
• 使用Provider和Lazy
• 使用MembersInjector