Zeal27
Zeal27

Dagger2学习笔记

Dagger2是第一个使用生成代码的方式实现依赖注入的框架。作为Dagger的升级版本，自然有它的优势，优先注重的是执行效率。本文着重介绍Dagger2。官方据点传送门： https://google.github.io/dagger//users-guide.html

首先来看一下依赖注入和控制反转

在软件工程领域，DI是一种实现控制反转用来解决依赖的设计模式，依赖是一个可以被使用的对象（服务），注入是把依赖传递给依赖它的对象(客户)，即要使用它的对象，这样，服务就成了客户组成的一部分。传递服务到客户，而不是让客户创建或寻找服务，是这个模式的基本要求。

依赖注入允许程序设计遵循依赖倒置原则，客户把为它提供依赖的责任委托给外部代码（依赖注入器），它自身不允许使用注入器的代码，而是注入器创建服务并把他们注入到客户。这意味着客户不需要知道注入器代码，不需要知道如何创建服务，不需要知道自己使用的具体是什么服务，而只需要知道如何使用服务的接口定义。这就分离了创建和使用的关系。

客户接受依赖注入有三种方式：

  1. 1.      基于Setter
  2. 2.      基于接口
  3. 3.      基于构造函数

Setter和构造函数注入的方式主要看什么时候会使用到依赖，接口注入方式在于依赖可以控制自己的注入。三者都需要独立的注入代码来负责引入客户和依赖之间的相互关系。

控制反转即IoC (Inversion of Control)，它把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管理。所谓的“控制反转”概念就是对组件对象控制权的转移，从程序代码本身转移到了外部容器。引用51CTO的一张图：

Dagger2学习笔记_第1张图片

 

实现控制反转主要有两种方式：依赖注入和依赖查找。两者的区别在于，前者是被动的接收对象，在类A的实例创建过程中即创建了依赖的B对象，通过类型或名称来判断将不同的对象注入到不同的属性中，而后者是主动索取响应名称的对象，获得依赖对象的时间也可以在代码中自由控制。

 

Dagger2

Dagger2是第一个使用生成代码的方式实现依赖注入的框架。指导思想是模拟生成开发者写的代码来确保依赖注入足够简单，可跟踪、可执行。

Dagger2创建类的实例并满足他们的依赖，它使用javax.inject.Inject 注解来识别感兴趣的构造函数和字段。

以下大部分内容译自官网：https://google.github.io/dagger//users-guide.html

这里使用一个CoffeeApp的例子来说明如何使用Dagger。

声明依赖

使用@Inject来注解Dagger2应该用来创建对象实例的构造函数，当一个新的对象实例被请求的时候，Dagger会取得要求的参数（如果有）并调用这个构造函数。

class Thermosiphon implements Pump {

  private final Heater heater;

 

  @Inject

  Thermosiphon(Heater heater) {

    this.heater = heater;

  }

 

  ...

}

 

Dagger能够直接注入字段。在下面的例子中，它为heater字段取得Heater的实例，为pump字段取得Pump的实例。

class CoffeeMaker {
  @Inject Heater heater;
  @Inject Pump pump;
 
  ...
}

 

如果你的类有@Inject注解的字段却没有对应的@Inject注解的构造函数，在请求这些字段时Dagger也会注入他们，但是不会去创建新的对象。你可以添加并注解一个无参构造函数来指示Dagger可以创建对象实例。

Dagger也支持方法注入，尽管构造函数和字段注入更受欢迎。

方法注入就是用@Inject注解T的Public方法，Dagger会在（自动或手动）调用T_MembersInjector. injectMembers(T)方法时提供方法所需要的参数依赖并调用该方法（即跟注入字段在同一时机）。

Dagger无法创建没有使用@Inject注解构造函数的类的实例。

 

满足依赖

默认情况下，Dagger会像上面描述的创建所请求的类的实例来满足每一个依赖。当你请求一个CoffeeMaker的时候，它会通过调用new CoffeeMaker()并注入可注入的字段来获取一个实例。但是@Inject在下面情形时无能为力：

  1. Interface无法实例化。
  2. 第三方类无法注解。
  3. 可配置的对象必须采用配置的方式。

在这些@Inject无能为力的地方，可以使用@Provides注解的方法来满足依赖。方法的返回类型定义了要满足的依赖。

例如，当Heater被请求时，provideHeater()方法会被调用。

@Provides static Heater provideHeater() {
  return new ElectricHeater();
}

 

@Provides注解的方法可以有自己的依赖。在Pump被请求的时候，下面的方法返回了Thermosiphon的实例。

@Provides static Pump providePump(Thermosiphon pump) {
  return pump;
}

 

所有@Provides注解的方法必须属于一个Module。下面就是用@Module注解的类。

@Module
class DripCoffeeModule {
  @Provides static Heater provideHeater() {
    return new ElectricHeater();
  }
 
  @Provides static Pump providePump(Thermosiphon pump) {
    return pump;
  }
}

 

按照惯例，@Provides注解的方法命名带上provide前缀，@Module注解的类命名会带上Module后缀。

 

建立对象图

@Inject和@Provides注解的类通过依赖连接形成一副对象图。像应用的main方法一样调用代码，或者像Android应用通过一套定义良好的根集合来访问对象图。在Dagger中，这个集合是通过一个声明不带参数、返回指定类型的方法的接口来定义的。在这样的接口上添加@Component注解并给module参数指定Module类型，Dagger就会按照约定完整的生成一套组件实现。

@Component(modules = DripCoffeeModule.class)

interface CoffeeShop {

  CoffeeMaker maker();

}

 

这个组件实现会有和接口一样的名字，但是会加上Dagger前缀。在这个组件实现上调用builder()方法，为返回的builder设置依赖，再调用build（）就可以获取一个对象实例。

CoffeeShop coffeeShop = DaggerCoffeeShop.builder()

    .dripCoffeeModule(new DripCoffeeModule())

    .build();

 

注意，如果你的@Component注解的类不是一个顶级类，生成的组件名将会包括以下划线连接的外层嵌套类的名字，例如下面的代码会生成名为DaggerFoo_Bar_BazComponent.的组件。

class Foo {

  static class Bar {

    @Component

    interface BazComponent {}

  }

}

 

对于任何带有可访问的默认构造函数的module，Dagger都会在没有设置过对象实例的时候自动创建它的实例。

对于所有的@Provides注解方法都是Static的module，这个组件实现就不需要对象实例了。如果所有的依赖都不需要通过开发者创建实例来构建，那么生成的组件实现也会有一个create()用来获取对象实例，而不需要使用builder。

CoffeeShop coffeeShop = DaggerCoffeeShop.create();

 

现在我们的CoffeeApp可以简单的使用Dagger生成的CoffeeShop组件实现来获取一个完全注入的CoffeeMaker了。

public class CoffeeApp {
  public static void main(String[] args) {
    CoffeeShop coffeeShop = DaggerCoffeeShop.create();
    coffeeShop.maker().brew();
  }
}

 

现在对象图已经被构建，入口也已经注入，我们可以运行CoffeeApp。

$ java -cp ... coffee.CoffeeApp
~ ~ ~ heating ~ ~ ~
=> => pumping => =>
 [_]P coffee! [_]P

 

对象图的绑定

上面的例子展示了如何用一些典型的绑定构建一个组件（Component），还有很多机制来完善对象图的绑定。下面是一些可以用来产生一个不错的组件的依赖选择。

  1. 那些用@Module注解声明@Provides注解方法的类直接被@Component.module引用或者间接被@Module.module引用。
  2. 任何一个使用@Inject注解构造函数的没有范围限定的类型，或者有一个@Scope注解匹配组件的一个范围限定的类型。
  3. 组件依赖的规定方法（Provision method，规定方法属于Component，没有参数，返回一个Inject或Provide的类型，也可以带qualifier）。
  4. 组件自身。
  5. 被包含的子组件的未限制（unqualified）的builders。
  6. 以上所有绑定的Provider或者Lazy包装。
  7. 任何一种类型的成员注入器（MemberInjector，用于注入类字段）。

 

单例和Scope的绑定

用@Singleton注解@Provides方法或可注入的类，对象图会为所有的调用者使用一个单例对象（相对于Component的生命周期而非Application的生命周期）。

@Provides @Singleton static Heater provideHeater() {
  return new ElectricHeater();
}

 

在可注入类上注解@Singleton也有@Document的作用（用Document注解的注解默认会被javadoc或同类工具文档化）。它会提醒维护者这个类会被多个线程分享。

@Singleton
class CoffeeMaker {
  ...
}

 

由于Dagger在对象图中关联了Scope的类实例和组件实现的实例，组件自身需要声明它们所代表的Scope。例如，将@Singleton绑定和@RequestScoped绑定放到一个组件中是没有任何意义的，因为它们有不同的生命周期，应该放在不同生命周期的组件中。在组件接口上直接应用Scope注解就可以声明组件的scope

@Component(modules = DripCoffeeModule.class)
@Singleton
interface CoffeeShop {
  CoffeeMaker maker();
}

 

组件可以应用多个scope注解,这表明它们都是同一个scope的别名，这样组件就可以用它声明的任何一种scope来包含scope绑定。

###Reusable scope

有时候你可能想要限制@Inject注解的构造函数或@Provides注解的方法的调用次数，但是你不需要保证在组件或子组件的生命周期中使用的确实是相同的实例。这在像Android这样分配内存代价昂贵的环境中是非常有用的。

对于这样的绑定，你可以使用@Reusable注解(Dagger2.3加入)。@Reusable绑定，不像其他的Scope——它不和任何单独的component关联，而是实际使用绑定的component缓存返回或初始化的实例。

这意味着如果你在组件中引入一个有@Reusable绑定的模块，但是只有一个子组件实际用到这个绑定，那么只有这个子组件会缓存这个绑定。如果共享祖先的两个子组件各自使用到这个绑定，那它们各自都会缓存自己的对象。如果一个组件的祖先已经缓存了这个对象，子组件会直接使用它。

因为无法保证组件只会调用这个绑定一次，所以应用@Reusable到返回易变对象的绑定中，或者必须要使用相同实例的对象上，是很危险的。如果不用关心实例化次数的话，在unscope对象上用@Reusable是安全的。

@Reusable // It doesn't matter how many scoopers we use, but don't waste them.
class CoffeeScooper {
  @Inject CoffeeScooper() {}
}
 
@Module
class CashRegisterModule {
  @Provides
  @Reusable // DON'T DO THIS! You do care which register you put your cash in.
            // Use a specific scope instead.
  static CashRegister badIdeaCashRegister() {
    return new CashRegister();
  }
}
 
  
@Reusable // DON'T DO THIS! You really do want a new filter each time, so this
          // should be unscoped.
class CoffeeFilter {
  @Inject CoffeeFilter() {}
}

 

Lazy injection

有时候你需要一个类被懒实例化，对于任何的绑定T，你可以创建一个Lazy来让它懒实例化——直到第一次调用Lazy.get()。如果T是一个单例，在对象图中，对于所有的注入，Lazy是同一个实例，否则，每一个注入点都会有自己的Lazy实例。不用管它，后续对任何Lazy对象的调用都会返回相同的底层的T的实例。

class GridingCoffeeMaker {
  @Inject Lazy lazyGrinder;
 
  public void brew() {
    while (needsGrinding()) {
      // Grinder created once on first call to .get() and cached.
      lazyGrinder.get().grind();
    }
  }
}

 

 

Provider注入

有时候你需要不同的实例被返回而不是简单的注入一个对象实例。当你有几个选择得时候（如工厂、建造器等），一个选择是注入一个Provider而不仅仅是T。每一次.get()被调用的时候，Provider都会调用绑定逻辑。如果那个绑定逻辑是一个@Inject构造函数，一个新的实例会被创建，而一个@Provides的方法无法保证这样。

class BigCoffeeMaker {
  @Inject Provider filterProvider;
 
  public void brew(int numberOfPots) {
  ...
    for (int p = 0; p < numberOfPots; p++) {
      maker.addFilter(filterProvider.get()); //new filter every time.
      maker.addCoffee(...);
      maker.percolate();
      ...
    }
  }
}

 

注意：注入Provider可能会创建让人迷惑的代码，并且你的对象图设计里可能会有作用域混乱或结构混乱的味道。你通常会想用工厂、Lazy或者重组代码的生命周期和结构的方式以便只需要注入一个T。然而，在某些情况下使用Provider将会拯救你：一个常见的用法是当你必须用一个遗留架构而不会增长对象的生命周期的时候（例如，Servlets被设计成单例，但是只会在请求特定数据的上下文中有效）。

 

限定符

有时候单靠类型不足以说明依赖，例如，一个复杂的Coffee maker应用可能会需要不同的加热器来加热水和碟子。

在这种情况下，我们添加一个限定符注解。这是一个它自身有一个@Qualifier注解的注解。下面是@Named注解的声明，它是一个包含在javax.inject中的限定符注解。

@Qualifier
@Documented
@Retention(RUNTIME)
public @interface Named {
  String value() default "";
}

 

你可以创建自己的限定符注解或者直接使用@Named。用限定符来注解感兴趣的字段或参数，类型和限定符注解都会被用来识别依赖。

class ExpensiveCoffeeMaker {

  @Inject @Named("water") Heater waterHeater;

  @Inject @Named("hot plate") Heater hotPlateHeater;

  ...

}

 

在相应的@Provides方法上注解限定值

@Provides @Named("hot plate") static Heater provideHotPlateHeater() {

  return new ElectricHeater(70);

}
@Provides @Named("water") static Heater provideWaterHeater() {

  return new ElectricHeater(93);

}

 

依赖不会有多个限定符注解。

编译时验证

Dagger的注解处理器是非常严格的，如果有任何无效或不完整的绑定，它会引起编译错误。例如，下面这个被引入组件模块，缺少一个Executor的绑定。

@Module

class DripCoffeeModule {

  @Provides static Heater provideHeater(Executor executor) {

    return new CpuHeater(executor);

  }

}

 

编译的时候，javac会拒绝缺少的绑定

[ERROR] COMPILATION ERROR :

[ERROR] error: java.util.concurrent.Executor cannot be provided without an @Provides-annotated method.

在组件的任何一个模块中添加Executor的@Provides注解的方法可以解决这个问题。虽然@Inject、@Module、@Provides都是单独验证的，所有绑定关系的验证都是在Component层进行。Dagger1严格使用@Module级验证（可不受运行时行为影响），但是Dagger2省略了这种验证（以及在@Module上配套的配置参数），更偏向于完整对象图验证。

编译时代码生成

Dagger的注解处理器（需要启用注解处理器）也可以生成类似以CoffeeMaker_Factory.java 或者CoffeeMaker_MembersInjector.java命名的源文件，这些文件是Dagger实现的细节，虽然他们在单步调试注入时很方便顺手，你不需要直接使用它们。在代码里你应该使用的唯一文件是以Dagger为前缀的组件文件。

 

多重绑定

Dagger允许你用多重绑定来把多个对象绑定到一个集合，即使这些对象已经绑定到不同的模块。Dagger聚集了这个（依赖）集合，这样应用代码就可以注入它，而不需要直接依赖单独的绑定。

你可以用多重绑定来实现一个插件架构。比如，多个模块可以贡献不同的插件接口实现，中心类可以使用整个插件集。或者可以让多个模块贡献不同的服务提供者到一个以名字为Key的Map。

多重绑定不能用Set,Map之类的绑定。

## Set multibindings

要贡献元素到一个可注入的多重绑定集合，在模块中添加返回元素的方法，这个方法应该以@Provides(type=SET)注解。

@Module

class MyModuleA {

  @Provides(type = SET)

  static String provideOneString(DepA depA, DepB depB) {

    return "ABC";

  }

}

 

你也可以通过在模块中添加以@Provides(type=SET_VALUES)注解返回一个子集的方法来一次贡献多个元素。

@Module

class MyModuleB {

  @Provides(type = SET_VALUES)

  static Set provideSomeStrings(DepA depA, DepB depB) {

    return new HashSet(Arrays.asList("DEF", "GHI"));

  }

}

 

这样组件里的绑定就可以依赖这个集合：

class Bar {

  @Inject Bar(Set strings) {

    assert strings.contains("ABC");

    assert strings.contains("DEF");

    assert strings.contains("GHI");

  }

}

 

或者组件可以提供这个集合：

@Component(modules = {MyModuleA.class, MyModuleB.class})

interface MyComponent {

  Set strings();

}

 

@Test void testMyComponent() {

  MyComponent myComponent = DaggerMyComponent.create();

  assertThat(myComponent.strings()).containsExactly("ABC", "DEF", "GHI");

}

 

对于其他的绑定，除了可以依赖多重绑定Set，还可以依赖Provider>和Lazy>,但是不能依赖Set>[I1] 。

要贡献一个有Qualifier的多重绑定集合，用qualifier来注解每一个@Provides方法：

@Module

class MyModuleC {

  @Provides(type = SET)

  @MyQualifier

  static Foo provideOneFoo(DepA depA, DepB depB) {

    return new Foo(depA, depB);

  }

}

 

@Module

class MyModuleD {

  @Provides

  static FooSetUser provideFooSetUser(@MyQualifier Set foos) { … }

}

 

 ## Map multibindings

 

Dagger可以让你用多重绑定来贡献入口到一个可注入的Map，只要Map的Key在编译时是知道的。

为了贡献入口到多重绑定Map，在模块中添加以@Provides(type = MAP)注解返回入口值的方法，还要用一个自定义的注解来指定入口在Map中的Key。要贡献一个入口到有限定的多重绑定Map中，用限定符注解每一个@Provides(type = MAP)的方法。

然后你可以注入Map自身(Map)，也可以注入一个包含值Provider的Map (Map>)。如果你想要一次取得一个值而不需要每个值都初始化，或者你想要每次查询Map的时候都得到一个新的实例，那么第二种方式很有用。

简单的Map keys

对于用字符串、Class或者装箱类型作为key的map，在dagger.mapkeys中使用如下标准注解之一：

@Module
class MyModule {
  @Provides(type = MAP)
  @StringKey("foo")
  static Long provideFooValue() {
    return 100L;
  }
 
  @Provides(type = MAP)
  @ClassKey(Thing.class)
  static String provideThingValue() {
    return "value for Thing";
  }
}
 
@Component(modules = MyModule.class)
interface MyComponent {
  Map longsByString();
  Map, String> stringsByClass();
}
 
@Test void testMyComponent() {
  MyComponent myComponent = DaggerMyComponent.create();
  assertThat(myComponent.longsByString().get("foo")).isEqualTo(100L);
  assertThat(myComponent.stringsByClass().get(Thing.class))
      .isEqualTo("value for Thing");
}

 

对于Key为枚举或者更特殊的参数化的类的Map，写一个以@MapKey注解的注解类型，这个注解类应该包括一个Map key类型的成员：

enum MyEnum {
  ABC, DEF;
}
 
@MapKey
@interface MyEnumKey {
  MyEnum value();
}
 
@MapKey
@interface MyNumberClassKey {
  Classextends Number> value();
}
 
@Module
class MyModule {
  @Provides(type = MAP)
  @MyEnumKey(MyEnum.ABC)
  static String provideABCValue() {
    return "value for ABC";
  }
 
  @Provides(type = MAP)
  @MyNumberClassKey(BigDecimal.class)
  static String provideBigDecimalValue() {
    return "value for BigDecimal";
  }
}
 
@Component(modules = MyModule.class)
interface MyComponent {
  Map myEnumStringMap();
  Mapextends Number>, String> stringsByNumberClass();
}
 
@Test void testMyComponent() {
  MyComponent myComponent = DaggerMyComponent.create();
  assertThat(myComponent.myEnumStringMap().get(MyEnum.ABC)).isEqualTo("value for ABC");
  assertThat(myComponent.stringsByNumberClass.get(BigDecimal.class))
      .isEqualTo("value for BigDecimal");
}

 

注解的唯一成员可以用除Arrays以外的任何有效的注解成员类型，还可以取任意名称。

 

复杂的Map keys

如果Map 的key很难用一个注解成员表达，你可以设置@MapKey’s unwrapValue为false以使用全部的注解作为Map key，在这种情况下，注解也可以有数组元素。

@MapKey(unwrapValue = false)
@interface MyKey {
  String name();
  Class implementingClass();
  int[] thresholds();
}
 
@Module
class MyModule {
  @Provides(type = MAP)
  @MyKey(name = "abc", implementingClass = Abc.class, thresholds = {1, 5, 10})
  static String provideAbc1510Value() {
    return "foo";
  }
}
 
@Component(modules = MyModule.class)
interface MyComponent {
  Map myKeyStringMap();
}

 

 

使用@AutoAnnotation 来创建注解实例

如果你的map用了复杂的keys，你需要在运行时创建@MapKey注解的实例并传递给map的get(Object)方法，最简单的做法是用@AutoAnnotation注解创建一个实例化注解的静态方法。更多细节可以查看@AutoAnnotation的文档。

class MyComponentTest {
  @Test void testMyComponent() {
    MyComponent myComponent = DaggerMyComponent.create();
    assertThat(myComponent.myKeyStringMap()
        .get(createMyKey("abc", Abc.class, new int[] {1, 5, 10}))
        .isEqualTo("foo");
  }
 
  @AutoAnnotation
  static MyKey createMyKey(String name, Class implementingClass, int[] thresholds) {
    return new AutoAnnotation_MyComponentTest_createMyKey(name, implementingClass, thresholds);
  }
}

 

 

在编译时不知道Keys的Map

多重绑定Map仅仅对在编译时知道Key并且Key可以用注解来表示的情况有效。如果Map的keys不符合这个条件，就不能创建多重绑定Map。但是你可以变通一下，用多重绑定集合来绑定一个对象集合，然后把它转变成一个非多重绑定的Map：

@Module
class MyModule {
  @Provides(type = SET)
  static Map.Entry entryOne(…) {
    Foo key = …;
    Bar value = …;
    return new SimpleImmutableEntry(key, value);
  }
 
  @Provides(type = SET)
  static Map.Entry entryTwo(…) {
    Foo key = …;
    Bar value = …;
    return new SimpleImmutableEntry(key, value);
  }
}
 
@Module
class MyMapModule {
  @Provides
  static Map fooBarMap(Set> entries) {
    Map fooBarMap = new LinkedHashMap<>(entries.size());
    for (Map.Entry entry : entries) {
      fooBarMap.put(entry.getKey(), entry.getValue());
    }
    return fooBarMap;
  }
}

 

注意，这个技术也不会自动绑定Map>，如果想要一个包含Providers 的map,多重绑定集合中的Map.Entry对象就应该包括Providers，这样，非多重绑定的Map就可以有Provider值：

@Module
class MyModule {
  @Provides(type = SET)
  static Map.Entry> entry(
      Provider barSubclassProvider) {
    Foo key = …;
    return new SimpleImmutableEntry(key, barSubclassProvider);
  }
}
 
@Module
class MyProviderMapModule {
  @Provides
  static Map> fooBarProviderMap(
      Set>> entries) {
    return …;
  }
}

 

声明多重绑定

可以在一个模块中嵌套一个@Multibindings注解的接口来声明多重绑定Set或Map，这个接口应该包括返回你想要声明的Set或Map的方法。

对于至少有一个元素的Set或Map使用@Multibindings没有必要，如果它们可能为空的话就必须要声明。

@Module
class MyModule {
  @Multibindings
  interface MyMultibindings {
    Set aSet();
    @MyQualifier Set aQualifiedSet();
    Map aMap();
    @MyQualifier Map aQualifiedMap();
  }
}

 

接口上的所有方法和父类型（除了Object中的方法）都被用来声明多重绑定，而接口的名字和方法会被忽略。一个Set或Map的多重绑定可以被声明无数次并且不会发生错误。Dagger不会实现这个接口或者调用它的方法。

### Alternative: SET_VALUES returning an empty set

单就空集合来说，作为一种候选方式，你可以添加一个@Provides(type = SET_VALUES)的方法来返回一个空集合：

@Module
class MyEmptySetModule {
  @Provides(type = SET_VALUES)
  static Set primeEmptyFooSet() {
    return Collections.emptySet();
  }
}

 

子组件（继承）的多重绑定

子组件的绑定可以依赖于父类的多重绑定Set或Map，就像它可以依赖父类的其它任意绑定一样。它可以通过在模块中添加合适的@Provides方法来添加元素到父类的多重绑定集合或Map中。

这样做之后，Set或Map会因为注入的地方而不同。当它注入到子组件定义的绑定时，就会同时具有父子组件定义的多重绑定的值或者入口了。当它注入到父类定义的绑定中时，就只会有父类定义的值或入口了。

@Component(modules = ParentModule.class)
interface ParentComponent {
  Set strings();
  Map stringMap();
  ChildComponent childComponent();
}
 
@Module
class ParentModule {
  @Provides(type = SET)
  static String string1() {
    "parent string 1";
  }
 
  @Provides(type = SET)
  static String string2() {
    "parent string 2";
  }
 
  @Provides(type = MAP)
  @StringKey("a")
  static String stringA() {
    "parent string A";
  }
 
  @Provides(type = MAP)
  @StringKey("b")
  static String stringB() {
    "parent string B";
  }
}
 
@Subcomponent(modules = ChildModule.class)
interface ChildComponent {
  Set strings();
  Map stringMap();
}
 
@Module
class ChildModule {
  @Provides(type = SET)
  static String string3() {
    "child string 3";
  }
 
  @Provides(type = SET)
  static String string4() {
    "child string 4";
  }
 
  @Provides(type = MAP)
  @StringKey("c")
  static String stringC() {
    "child string C";
  }
 
  @Provides(type = MAP)
  @StringKey("d")
  static String stringD() {
    "child string D";
  }
}
 
@Test void testMultibindings() {
  ParentComponent parentComponent = DaggerParentComponent.create();
  assertThat(parentComponent.strings()).containsExactly(
      "parent string 1", "parent string 2");
  assertThat(parentComponent.stringMap().keySet()).containsExactly("a", "b");
 
  ChildComponent childComponent = parentComponent.childComponent();
  assertThat(childComponent.strings()).containsExactly(
      "parent string 1", "parent string 2", "child string 3", "child string 4");
  assertThat(childComponent.stringMap().keySet()).containsExactly(
      "a", "b", "c", "d");
}

 

 

子组件

子组件是继承和扩展父组件对象图的组件。可以用来把应用的对象图分割成子图，

这样就可以压缩应用的各个部分，或者在一个组件上使用多个范围限定。子组件中绑定的对象除了可以依赖在它自己的模块中绑定的对象，还可以依赖父组件或上层组件中绑定的对象。反过来说，在父组件中绑定的对象不能依赖子组件中绑定的对象。当然，子组件中绑定的对象也不能依赖于同级子组件中绑定的对象。换句话说，父组件的对象图是子组件对象图的子图。

声明子组件

跟顶级组件一样，你写一个抽象类或接口，在里面声明返回应用关心的类型的抽象方法。这里不使用@Component来注解它，而是使用@Subcomponent注解并引入需要的模块。

@Subcomponent(modules = RequestModule.class)
inferface RequestComponent {
  RequestHandler requestHandler();
}

 

把子组件加入到父组件

要添加子组件到父组件中，在父组件中添加一个返回子组件的抽象工厂方法。如果子组件有一个没有默认构造函数的Module，并且这个Module不会被引入父组件，那么这个工厂方法必须有一个模块类型的参数。这个抽象方法可以有引入到子组件中的其他Module类型的参数，但是不可以有引入到父组件的模块类型的参数（子组件会自动在它和它的父组件之间分享已经分享的模块的实例）。

@Component(modules = {ServerModule.class, AuthModule.class})
interface ServerComponent {
  Server server();
  SessionComponent sessionComponent(SessionModule sessionModule);
}
 
@Subcomponent(modules = SessionModule.class)
interface SessionComponent {
  SessionInfo sessionInfo();
  RequestComponent requestComponent();
}
 
@Subcomponent(modules = {RequestModule.class, AuthModule.class})
interface RequestComponent {
  RequestHandler requestHandler();
}

 

SessionComponent的模块中的绑定可以依赖ServerComponent的模块中的绑定，RequestComponent的模块中的绑定可以同时依赖SessionComponent和ServerComponent的模块中的绑定。

为了创建子组件的实例，调用父组件实例的工厂方法：

ServerComponent serverComponent = DaggerServerComponent.create();
SessionComponent sessionComponent =
    serverComponent.sessionComponent(new SessionModule(…));
RequestComponent requestComponent = sessionComponent.requestComponent();

 

通常你需要从父组件的一个对象范围内创建子组件，你可以基于组件的任何绑定都依赖于组件自身类型的事实来这样做：

class BoundInServerComponent {
  @Inject ServerComponent serverComponent;
 
  void doSomethingWithSessionInfo() {
    SessionComponent sessionComponent =
        serverComponent.sessionComponent(new SessionModule(…));
    sessionComponent.sessionInfo().doSomething();
  }
}

 

子组件Builders

你也可以为子组件定义一个Buidler，和组件Buidler的定义相似：

@Component(modules = {ServerModule.class, AuthModule.class})
interface ServerComponent {
  Server server();
  SessionComponent.Builder sessionComponentBuilder();
}
 
@Subcomponent(modules = SessionModule.class)
interface SessionComponent {
  @Subcomponent.Builder
  interface Builder {
    Builder sessionModule(SessionModule sessionModule);
    SessionComponent build();
  }
}
 
ServerComponent serverComponent = DaggerServerComponent.create();
SessionComponent sessionComponent = serverComponent.sessionComponentBuilder()
    .sessionModule(new SessionModule(…))
    .build();

 

注入子组件Buidlers

和组件一样，子组件Buidlers被绑定到对象图并且也可以被注入，所以可以注入Buidlers自身，而不用注入组件然后在组件上调用子组件的builder方法。

/** Injecting the subcomponent builder. This is simpler than what's below. */
  class SessionStarterInjectingSubcomponentBuilder {
    private final SessionComponent.Builder sessionComponentBuilder;
    
    @Inject SessionStarterInjectingSubcomponentBuilder(
        SessionComponent.Builder sessionComponentBuilder) {
      this.sessionComponentBuilder = sessionComponentBuilder;
    }
    
    Session startSession() {
      return sessionComponentBuilder
          .sessionModule(new SessionModule(…))
          .build()
          .session();
    }
  }
 
  /**
   * Injecting the component and calling the factory method. Not as simple as
   * what's above.
   */
  class SessionStarterInjectingComponent {
    private final ServerComponent serverComponent;
    
    @Inject SessionStarterInjectingComponent(ServerComponent serverComponent) {
      this.serverComponent = serverComponent;
    }
 
    Session startSession() {
      return serverComponent.sessionComponentBuilder()
          .sessionModule(new SessionModule(…))
          .build()
          .session();
    }
  }

 

注意SessionStarterInjectingSubcomponentBuilder根本没有提到ServerComponent。

 

子组件和范围限定

把应用的组件分割成子组件的原因之一是为了使用范围限定。对于普通的无范围限定的绑定，每个注入类型的使用者都会获得一个新的、独立的实例。但是如果这个绑定加上了范围限定，在范围限定的生命周期内这个绑定的所有用户都会获得绑定类型的同一实例。

标准的范围限定是@Singleton，单例限定绑定的用户会获得相同的实例（相对于Component的生命周期而非应用生命周期）。

在Dagger中，用@Scope注解组件就可以加上范围限定。在这种情况下，组件实现会保存对所有加上范围限定的类实例的引用以便重用。有范围限定的带有@Provides方法的模块只能被拥有相同范围限定的组件引用。

(有@Inject构造函数的类型也可以用Scope注解，这种隐含绑定也会被这个Scope的组件和它的子组件使用。这个Scope实例会被绑定到正确的Scope里。)

虽然两个不能互相访问的组件可以关联到相同的Scope上（因为存储Scope对象的地方明确，虽然使用相同的范围限定，两个子组件会有不同的Scope实例），但是没有子组件会关联到和它祖先相同的Scope上。

例如下面的组件树中，BadChildComponent有和它的父类RootComponent相同的@RootScope，这是错的。但是SiblingComponentOne和SiblingComponentTwo都可以使用@ChildScope注解，因为二者的绑定关系不会混乱：

@RootScope @Component
interface RootComponent {
  BadChildComponent badChildComponent(); // ERROR!
  SiblingComponentOne siblingComponentOne();
  SiblingComponentTwo siblingComponentTwo();
}
 
@RootScope @Subcomponent
interface BadChildComponent {…}
 
@ChildScope @Subcomponent
interface SiblingComponentOne {…}
 
@ChildScope @Subcomponent
interface SiblingComponentTwo {…}

 

因为子组件是通过调用父组件的方法来初始化的，它的生命周期会短于父组件。这意味着在子组件上关联较小的范围限定，在父组件上关联较大的范围限定才有意义。实际上，你几乎总会想让RootComponent使用@Singleton的范围限定。

在下面的Scope例子中， RootComponent使用了@Singleton。@SessionScope内嵌于@Singleton之中，@RequestScope内嵌于@SessionScope之中。注意FooRequestComponent和BarRequestComponent都和@RequestScope关联（因为他们是同级，彼此没有继承关系）。

@Singleton @Component
interface RootComponent {
  SessionComponent sessionComponent();
}
 
@SessionScope @Subcomponent
interface SessionComponent {
  FooRequestComponent fooRequestComponent();
  BarRequestComponent barRequestComponent();
}
 
@RequestScope @Subcomponent
interface FooRequestComponent {…}
 
@RequestScope @Subcomponent
interface BarRequestComponent {…}

 

 

子组件封装

使用子组件的另一个原因是可以封装应用内的各个部分。例如你服务器上的两个服务（或者应用的两个界面）共享一些绑定，假设用于授权和验证，但是它们每个都有彼此不相关的其他绑定，这时为每个服务（或界面）创建单独的子组件，并把共享的绑定放入父组件会比较有意义。

在上面的例子中，FooRequestComponent和BarRequestComponent是独立的，同级的组件，你可以把他们（和他们的模块）放到一个@RequestScope的组件中，但是可能会有一些绑定冲突。

 

 

细节

扩展多重绑定

和其他的绑定一样，父组件中的多重绑定对于子组件是可见的，子组件也可以添加多重绑定到父组件中绑定的Map和Set中。任何这种形式的附加绑定都只对子组件及它的子组件可见，而父组件不可见。

@Component(modules = ParentModule.class)
interface Parent {
  Map map();
  Set set();
 
  Child child();
}
 
@Module
class ParentModule {
  @Provides(type = MAP)
  @StringKey("one") static int one() {
    return 1;
  }
 
  @Provides(type = MAP)
  @StringKey("two") static int two() {
    return 2;
  }
 
  @Provides(type = SET)
  static String a() {
    return "a"
  }
 
  @Provides(type = SET)
  static String b() {
    return "b"
  }
}
 
@Subcomponent(modules = Child.class)
interface Child {
  Map map();
  Set set();
}
 
@Module
class ChildModule {
  @Provides(type = MAP)
  @StringKey("three") static int three() {
    return 3;
  }
 
  @Provides(type = MAP)
  @StringKey("four") static int four() {
    return 4;
  }
 
  @Provides(type = SET)
  static String c() {
    return "c"
  }
 
  @Provides(type = SET)
  static String d() {
    return "d"
  }
}
 
Parent parent = DaggerParent.create();
Child child = parent.child();
assertThat(parent.map().keySet()).containsExactly("one", "two");
assertThat(child.map().keySet()).containsExactly("one", "two", "three", "four");
assertThat(parent.set()).containsExactly("a", "b");
assertThat(child.set()).containsExactly("a", "b", "c", "d");

 

 

重复的模块

当相同的模块类型被引入到同一个组件或者它的子组件中时，这些组件都会自动使用同一个模块实例。这意味着如果子组件的工厂方法包括一个重复的模块作为参数或者你传入一个重复的模块来调用子组件的Builder方法是错误的（后者是一个运行时错误，在编译时不能被检查）。

@Component(modules = {RepeatedModule.class, …})
interface ComponentOne {
  ComponentTwo componentTwo(RepeatedModule repeatedModule); // COMPILE ERROR!
  ComponentThree.Builder componentThreeBuilder();
}
 
@Subcomponent(modules = {RepeatedModule.class, …})
interface ComponentTwo { … }
 
@Subcomponent(modules = {RepeatedModule.class, …})
interface ComponentThree {
  @Subcomponent.Builder
  interface Builder {
    Builder repeatedModule(RepeatedModule repeatedModule);
    ComponentThree build();
  }
}
 
DaggerComponentOne.create().componentThreeBuilder()
    .repeatedModule(new RepeatedModule()) // UnsupportedOperationException!
    .build();

 

Producers

Producers是Dagger的扩展，它实现了Java中的异步注入。

概述

假设你已经熟悉了Dagger的API和Guava 的 ListenableFuture。

Producers引入了新的注解@ProducerModule, @Produces, 和@ProductionComponent，分别对应@Module,@Provides, 和 @Component。我们把@ProducerModule注解的类视为producer modules，@Produces注解的方法视为producer methods，@ProductionComponent注解的接口视为producer graphs(类似于modules, provider methods, 和object graphs)。

和原始Dagger最关键的不同在于producer方法会返回ListenableFuture，并且后面的producer会依赖于这个未封装的T，当future可用的时候，框架会计划执行后续的方法。

下面是一个模拟服务器处理请求工作流的例子：

@ProducerModule(includes = UserModule.class)

final class UserResponseModule {

  @Produces

  static ListenableFuture lookUpUserData(

      User user, UserDataStub stub) {

    return stub.lookUpData(user);

  }

 

  @Produces

  static Html renderHtml(UserData data, UserHtmlTemplate template) {

    return template.render(data);

  }

}

 

@Module

final class ExecutorModule {

  @Provides

  @Production

  static Executor executor() {

    return Executors.newCachedThreadPool();

  }

}

 

 

在下面的例子中，我们描述的算法是：

  1. 调用lookUpUserData方法。
  2. 当future可用的时候，获取结果，调用renderHtml方法。

（注意我们没有明确的指出User, UserDataStub, 或者UserHtmlTemplate是怎么来的，假设（Dagger module ）UserModule 提供了这些类型。）

我们可以通过绑定@Production Executor来指定一个线程池，每一个Producer 的方法都会在这个线程池中被计划执行。注意，即使指定executor的provides方法是unscoped的，production component也只会从这个provider获取一个实例，所以只会创建一个线程池。

我们用了一个ProductionComponent来建立图：

@ProductionComponent(modules = UserResponseModule.class)
interface UserResponseComponent {
  ListenableFuture html();
}
 
// ...
 
UserResponseComponent component = DaggerUserResponseComponent.create();
 
ListenableFuture htmlFuture = component.html();

 

Dagger生成UserResponseComponent的实现，它的html()方法的行为和上面描述的一样：首先调用lookUpUserData，当future可用的时候，调用renderHtml()。

两个producer 方法都在提供的线程池上被计划执行，所以执行模型完全是用户指定的。

注意，就像在上面的例子中，producer modules可以和原生module无缝结合，但是有一点儿限制： provided types不能依赖于produced types。

异常处理

默认情况下，如果producer method抛出了异常，或者它返回future失败，那么所有有依赖关系的producer methods将会被跳过——这个模型在调用栈中向上传递异常。如果producer method想要捕获这个异常，它可以请求一个Produced而不是T。例如：

@Produces
static Html renderHtml(
    Produced data,
    UserHtmlTemplate template,
    ErrorHtmlTemplate errorTemplate) {
  try {
    return template.render(data.get());
  } catch (ExecutionException e) {
    return errorTemplate.render("user data failed", e.getCause());
  }
}

 

在这个例子中，如果产生UserData抛出了异常（可以是producer method抛出异常，或者获取future失败），那么readHtml方法会捕获它并返回一个错误模板。

如果没有producer method捕获，异常会一直向上传递到组件的入口点，那么component返回的future就会因异常而失败。

 

延迟注入

Producer methods可以请求一个类似于Provider的Producer,它可以延迟关联绑定计算直到get()方法被调用。Producer不会阻塞，它的get()方法返回一个后面可以反馈给框架的ListenableFuture，例如：

@Produces
static ListenableFuture lookUpUserData(
    Flags flags,
    @Standard Producer standardUserData,
    @Experimental Producer experimentalUserData) {
  return flags.useExperimentalUserData()
      ? experimentalUserData.get()
      : standardUserData.get();
}

 

 

在这个例子里，如果experimental user data被请求，那么standard user data不会被计算。注意Flags可能是一个请求时间标识，或者甚至是RPC（（Remote Procedure Call Protocol）——远程过程调用协议）的结果，让用户构建灵活的条件图。

多重绑定

和普通的Dagger一样，同一类型的多个绑定可以被整理到一个Set或者Map中。例如：

@ProducerModule
final class UserDataModule {
  @Produces(type = SET) static ListenableFuture standardData(…) { … }
  @Produces(type = SET) static ListenableFuture extraData(…) { … }
  @Produces(type = SET) static Data synchronousData(…) { … }
  @Produces(type = SET_VALUES) static Set> rest(…) { … }
 
  @Produces static … collect(Set data) { … }
}

 

在这个例子中，当贡献到Set的所有producer methods都有完成的futures的时候，Set会被创建，并调用collect()方法。

 

Map多重绑定

和Set多重绑定相似：

@MapKey @interface DispatchPath {
  String value();
}
 
@ProducerModule
final class DispatchModule {
  @Produces(type = MAP) @DispatchPath("/user")
  static ListenableFuture dispatchUser(…) { … }
 
  @Produces(type = MAP) @DispatchPath("/settings")
  static ListenableFuture dispatchSettings(…) { … }
 
  @Produces
  static ListenableFuture dispatch(
      Map> dispatchers, Url url) {
    return dispatchers.get(url.path()).get();
  }
}

 

注意，dispatch()请求Map>的方式确保了只有被请求的dispatch handler会被执行。

 

 

Scoping（范围限定）

Producer methods 和production components 已经被隐含的Scope上了@ProductionScope，和普通的Scoped bindings一样，在组件的上下文中每个方法只会执行一次，并且它的结果会被缓存。这样就可以完全控制每个绑定的生存时间——和它内嵌的component实例的生存时间一样。

@ProductionScope也可以被应用到普通的provisions上，这样它们就会被Scope到绑定它们的Production component上。Production components也可以像普通的components一样拥有其他的Scope。

Executor

提供Executor的主要方式是在ProductionComponent 或ProductionSubcomponent中绑定@Production Executor。这个绑定将会隐含的Scope到@ProductionScope。对于subcomponents，executor可以被绑定到任何父component，并且绑定会被子组件继承（和所有的绑定一样）。

 

组件依赖

和普通的 Components一样, ProductionComponents 可能会依赖于其他的接口:

interface RequestComponent {
  ListenableFuture request();
}
 
@ProducerModule
final class UserDataModule {
  @Produces static ListenableFuture userData(Request request, …) { … }
}
 
@ProductionComponent(
    modules = UserDataModule.class,
    dependencies = RequestComponent.class)
interface UserDataComponent {
  ListenableFuture userData();
}

 

因为UserDataComponent 依赖于RequestComponent，绑定UserDataComponent的时候，Dagger会要求提供一个RequestComponent的实例，然后这个实例会用来满足它提供的getter方法的绑定：

ListenableFuture userData = DaggerUserDataComponent.builder()
    .requestComponent(/* a particular RequestComponent */)
    .build()
    .userData();

 

Subcomponents（子组件）

Dagger producers引入了一个对应于@Subcomponent的新注解@ProductionSubcomponent，Production subcomponents可以是components或production components的子组件。

子组件会继承父组件的所有绑定，所以建.立嵌套Scope是最简单的方式。可以参考子组件介绍。

 

Monitoring（监控）

ProducerMonitor可以被用来监视producer methods的执行，它的方法对应producer生命周期的不同阶段。

要引入ProducerMonitor，需要贡献到一个ProductionComponentMonitor.Factory的集合绑定中。例如：

@Module
final class MyMonitorModule {
  @Provides(type = SET)
  static ProductionComponentMonitor.Factory provideMonitorFactory(
      MyProductionComponentMonitor.Factory monitorFactory) {
    return monitorFactory;
  }
}
 
@ProductionComponent(modules = {MyMonitorModule.class, MyProducerModule.class})
interface MyComponent {
  ListenableFuture someType();
}

 

当这个component被创建的时候，贡献到集合中的每一个monitor factory都会被要求为这个component创建一个monitor，在component的生存期会保存生成的实例（一个），这个实例会被用来为每个producer method创建独立的monitor。

Timing, Logging and Debugging

到2016.3月，还没有实现。

 

测试Dagger

使用Dagger这样的依赖注入框架的好处之一是可以让代码测试更加简单。下面谈到一些使用到Dagger的应用的测试策略。

别用Dagger做单元测试

如果你想写一个小的单元测试来测试一个@Inject注解的类，你根本不需要用到Dagger，直接调用@Inject注解的构造方法、方法，设置@Inject的字段（如果有的话），直接传递伪造或模拟的依赖。

final class ThingDoer {
  private final ThingGetter getter;
  private final ThingPutter putter;
 
  @Inject ThingDoer(ThingGetter getter, ThingPutter putter) {
    this.getter = getter;
    this.putter = putter;
  }
 
  String doTheThing(int howManyTimes) { /* … */ }
}
 
public class ThingDoerTest {
  @Test
  public void testDoTheThing() {
    ThingDoer doer = new ThingDoer(fakeGetter, fakePutter);
    assertEquals("done", doer.doTheThing(5));
  }
}

 

Replace bindings for functional/integration/end-to-end testing

功能、集成、端到端测试通常用在产品型应用上，在替换存储、后端和验证系统之后，让剩下的部分正常运行。这种方式让应用自身有一个（或者有限个数）测试配置，可以替换其中的某些绑定。

Option 1: Override bindings by subclassing modules (don’t do this!)

替换绑定最简单的方式是在子类中重写module的@Provides方法（但是看看下面的问题）。

当你创建Dagger component的实例时，会传递它用到的modules（你不需要传递有无参构造函数或没有实例方法的module的实例，但是你可以这样做）。这意味着你可以传递这些模块的子类实例，并且这些子类可以重写@Provides方法来替换一些绑定。

@Component(modules = {AuthModule.class, /* … */})
interface MyApplicationComponent { /* … */ }
 
@Module
class AuthModule {
  @Provides AuthManager authManager(AuthManagerImpl impl) {
    return impl;
  }
}
 
class FakeAuthModule extends AuthModule {
  @Override
  AuthManager authManager(AuthManagerImpl impl) {
    return new FakeAuthManager();
  }
}
 
MyApplicationComponent testingComponent = DaggerMyApplicationComponent.builder()
    .authModule(new FakeAuthModule())
    .build();

 

 

但是这种方法有一些限制：

1.使用module子类不能改变绑定图的静态形状：它不能添加或移除绑定，或者改变绑定依赖。特别是：

（1）重写@Provides方法不能改变它的参数类型，并且限制了返回类型（可能在绑定图上没有意义）。在上面的例子中，testingComponent仍然要求AuthManagerImpl和它所有依赖的绑定，即使它们没有用处。

 

（2）类似的，重写的module不能添加绑定到图上，包括新的多重绑定贡献（虽然你可以重写SET_VALUES方法来返回不同的集合）。子类中任何新的@Provides方法会被Dagger静默忽略。实际上，这意味着你的模拟不能充分利用依赖注入的优势。

2.用这种方式重写的@Provides方法不能是静态的，所以它们的module实例不能被省略。

 

### Option 2: Separate component configurations

另一种方式要求应用更加前瞻性的设计Module。应用（产品和测试）的每个配置用一个不同的component配置。测试的component类型扩展产品的component类型并且引用一个不同的modules集合。

@Component(modules = {
  OAuthModule.class, // real auth
  FooServiceModule.class, // real backend
  OtherApplicationModule.class,
  /* … */ })
interface ProductionComponent {
  Server server();
}
 
@Component(modules = {
  FakeAuthModule.class, // fake auth
  FakeFooServiceModule.class, // fake backend
  OtherApplicationModule.class,
  /* … */})
interface TestComponent extends ProductionComponent {
  FakeAuthManager fakeAuthManager();
  FakeFooService fakeFooService();
}

 

现在测试代码的主方法调用DaggerTestComponent.builder()而不是DaggerProductionComponent.builder()。注意Test component接口可以添加provision handles到伪造的实例（fakeAuthManager() 和fakeFooService()）上，这样测试在必要的时候就可以访问他们来控制缰绳（控制他们）。

但是你如何设计modules才能让这种模式简单一点儿呢？

 

组织Module提高可测试性

Module类是一种实用类：一个独立的@Provides方法集，它们每个都会被注入器用来提供应用使用到的类型（实例）。

（在一个依赖于其他类型的Module中，虽然多个@Provides 方法是相关联的，他们通常不会互相调用或者依赖同样的易变状态。在实际并不独立的情况下，一些@Provides方法确实用到同样的实例字段，建议把@Provides方法当成实用方法对待，因为它可以很容易替换modules来做测试）

那么你如何决定哪些@Provides方法应该一起放入一个module呢？

一种方式认为可以对绑定分为published bindings和internal bindings，然后再更多考虑哪一个发行绑定有合理的替代（alternatives）。

published bindings提供功能供应用其他部分使用。像AuthManager、User和DocDatabase这样的类型都是published bindings：它们被绑定到一个module以便于应用的其他部分使用它们。

internal bindings就是除了published bindings剩下的部分：在一些published的类型的实现中使用并且不会被当作它的一部分的绑定。例如，OAuth client ID和OAuthKeyStore的绑定配置只趋向于让AuthManager的OAuth实现使用，而不让应用的剩余部分使用。这些绑定通常是Package-private的类型或者使用package-private限定符限定了。

一些published bindings会有reasonable alternatives，特别是为了测试。比如，可能会存在针对某种类型（像AuthManager）的替代绑定：一种是用于测试，其它的用于不同的验证、授权协议。

但是另一方面，如果AuthManager接口有一个返回当前登录的user的方法，你可能想在AuthManager中publish一个通过简单的调用getCurrentUser()来提供user的绑定。这个published绑定不可能需要一个alternative。

一旦你已经把绑定分类成为有reasonable alternatives的published bindings、无reasonable alternatives的published bindings和internal bindings，考虑像下面这样把他们放到module中：

1.每一个有reasonable alternative的published bindings作为一个module（如果你也在写alternatives，让它们都有自己的module）。这个module准确的包含一个published binding，和它需要的所有internal bindings。

2.所有没有reasonable alternatives的published bindings都放到按功能划分的modules中。

3. published-binding modules应该包括（include）要求public bindings提供的no-reasonable-alternative modules。[I2] 

以描述module提供的published bindings的方式把它文档化是一个不错的选择。

下面是一个使用auth domain的例子。如果存在一个AuthManager接口，就可以有OAuth的实现和一个伪造实现用于测试。如上所述，对于当前user会有一个你不想在配置切换时改变的明确绑定。

/**
 * Provides auth bindings that will not change in different auth configurations,
 * such as the current user.
 */
@Module
class AuthModule {
  @Provides static User currentUser(AuthManager authManager) {
    return authManager.currentUser();
  }
  // Other bindings that don’t differ among AuthManager implementations.
}
 
/** Provides a {@link AuthManager} that uses OAuth. */
@Module(includes = AuthModule.class) // Include no-alternative bindings.
class OAuthModule {
  @Provides static AuthManager authManager(OAuthManager authManager) {
    return authManager;
  }
  // Other bindings used only by OAuthManager.
}
 
/** Provides a fake {@link AuthManager} for testing. */
@Module(includes = AuthModule.class) // Include no-alternative bindings.
class FakeAuthModule {
  @Provides static AuthManager authManager(FakeAuthManager authManager) {
    return authManager;
  }
  // Other bindings used only by FakeAuthManager.
}

 

像上面描述的，这样你的production configuration会使用真实的modules，testing configuration使用伪造的modules。

 

下一篇文章，我将介绍如何在Android开发中应用Dagger2。

 

参考:

Martin fowler论依赖注入：http://www.martinfowler.com/articles/injection.html

依赖注入： https://en.wikipedia.org/wiki/Dependency_injection

 

 

 

你可能感兴趣的:(架构,依赖注入,控制反转,Dagger2)

  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 腾讯云技术深度探索：构建高效云原生微服务架构 我的运维人生 云原生架构腾讯云运维开发技术共享
    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
  • 关于提高复杂业务逻辑代码可读性的思考 编程经验分享 开发经验java数据库开发语言
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
  • 18、架构-可观测性之聚合度量 大树~~ 架构javapython后端架构
    聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
  • BART&BERT Ambition_LAO 深度学习
    BART和BERT都是基于Transformer架构的预训练语言模型。模型架构：BERT(BidirectionalEncoderRepresentationsfromTransformers)主要是一个编码器（Encoder）模型，它使用了Transformer的编码器部分来处理输入的文本，并生成文本的表示。BERT特别擅长理解语言的上下文，因为它在预训练阶段使用了掩码语言模型（MLM）任务，即
  • 系统架构设计师 需求分析篇二 AmHardy 软件架构设计师系统架构需求分析面向对象分析分析模型UML和SysML
    面向对象分析方法1.用例模型构建用例模型一般需要经历4个阶段：识别参与者：识别与系统交互的所有事物。合并需求获得用例：将需求分配给予其相关的参与者。细化用例描述：详细描述每个用例的功能。调整用例模型：优化用例之间的关系和结构，前三个阶段是必需的。2.用例图的三元素参与者：使用系统的用户或其他外部系统和设备。用例：系统所提供的服务。通信关联：参与者和用例之间的关系，或用例与用例之间的关系。3.识别参
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Armv8.3 体系结构扩展--原文版 代码改变世界ctw ARM-TEE-Androidarmv8嵌入式arm架构安全架构芯片TrustzoneSecureboot
    快速链接:.ARMv8/ARMv9架构入门到精通-[目录]付费专栏-付费课程【购买须知】:个人博客笔记导读目录(全部)TheArmv8.3architectureextensionTheArmv8.3architectureextensionisanextensiontoArmv8.2.Itaddsmandatoryandoptionalarchitecturalfeatures.Somefeat
  • 【ARM Cortex-M 系列 2.3 -- Cortex-M7 Debug event 详细介绍】 主公讲 ARM #ARM系列arm开发debugevent
    请阅读【嵌入式开发学习必备专栏】文章目录Cortex-M7DebugeventDebugeventsCortex-M7Debugevent在ARMCortex-M7架构中，调试事件（DebugEvent）是由于调试原因而触发的事件。一个调试事件会导致以下几种情况之一发生：进入调试状态：如果启用了停滞调试（HaltingDebug），一个调试事件会使处理器在调试状态下停滞。通过将DHCSR.C_DE
  • 基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程 极客小张 stm32qt机器人物联网人机交互毕业设计c语言
    一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • ARMV8体系结构简介：概述 简单同学 ARMV8体系结构ARMV8
    1.前言本文主要概括的介绍ARMV8体系结构定义了哪些内容，概括的说：ARM体系结构定义了PE的行为，不会定义具体的实现ARM体系结构也定义了debug体系结构和trace体系结构ARM体系结构采用RISC指令集（1）长度一致的寄存器；（2）load/store架构，数据处理操作只能对寄存器内容进行处理，不会直接对内存的内容进行处理；（3）简单寻址方式，load/store地址来源于寄存器或指令域
  • Table列表复现框实现【勾选-搜索-再勾选】 ～四时春～ java开发语言elementuivue
    Table列表复现框实现【勾选-搜索-再勾选】概要整体架构流程代码实现技术细节注意参考文献概要最近在开发时遇到一个问题，在进行表单渲染时，正常选中没有问题，单如果需要搜索选中时，一个是已选中的不会回填，二是在搜索的结果中进行选中，没有实现，经过排查，查找资料后实现。例如：整体架构流程具体的实现效果如下：代码实现{{scope.row.userName}}已选区{{userItem.userName
  • 深入浅出 -- 系统架构之负载均衡Nginx的性能优化 xiaoli8748_软件开发 系统架构系统架构负载均衡nginx
    一、Nginx性能优化到这里文章的篇幅较长了，最后再来聊一下关于Nginx的性能优化，主要就简单说说收益最高的几个优化项，在这块就不再展开叙述了，毕竟影响性能都有多方面原因导致的，比如网络、服务器硬件、操作系统、后端服务、程序自身、数据库服务等，对于性能调优比较感兴趣的可以参考之前《JVM性能调优》中的调优思想。优化一：打开长连接配置通常Nginx作为代理服务，负责分发客户端的请求，那么建议开启H
  • AI大模型的架构演进与最新发展 季风泯灭的季节 AI大模型应用技术二人工智能架构
    随着深度学习的发展，AI大模型（LargeLanguageModels,LLMs）在自然语言处理、计算机视觉等领域取得了革命性的进展。本文将详细探讨AI大模型的架构演进，包括从Transformer的提出到GPT、BERT、T5等模型的历史演变，并探讨这些模型的技术细节及其在现代人工智能中的核心作用。一、基础模型介绍：Transformer的核心原理Transformer架构的背景在Transfo
  • 信息系统安全相关概念(上) YuanDaima2048 课程笔记基础概念安全信息安全笔记
    文章总览：YuanDaiMa2048博客文章总览下篇:信息系统安全相关概念(下)信息系统安全相关概念[上]信息系统概述信息系统信息系统架构信息系统发展趋势：信息系统日趋大型化、复杂化信息系统面临的安全威胁信息系统安全架构设计--以云计算为例信息系统安全需求及安全策略自主访问控制策略DAC强制访问控制策略MAC信息系统概述信息系统用于收集、存储和处理数据以及传递信息、知识和数字产品的一组集成组件。几
  • 程序员架构师主要是做什么_程序员架构师：职责、技能与挑战 绿色小猪
    免费备考资料（2024年11月软考）：历年试题+视频课合集+电子讲义点击领取>>>免费刷题：2024年11月软考备考刷题点此进入>>>程序员架构师的角色定位在软件开发领域，程序员架构师是一个至关重要的角色。他们不仅需要深入理解业务需求，还要将其转化为技术上的解决方案。程序员架构师是项目中的技术领航者，负责制定和维护软件系统的整体架构，确保系统的可扩展性、可维护性和性能。他们的工作涉及从概念化到实现
  • metaRTC8.0，一个全新架构的webRTC SDK库 metaRTC webrtc音视频
    概述metaRTC8.0是metaRTC开源以来架构变化最大的一个版本，是metaIPC3.0等高性能的基础。metaRTC8.0是一个全新架构版本，并非在metaRTC7.0版本上简单升级，在QOS/语音对讲/内存占用/视频文件录制读取等方面新增多个模块，在弱网对抗/语音对讲/内存优化等效果上有显著提升。metaRTC8.0在一年多的开发中进行了近200次迭代，metaRTC8.0社区版计划在2
  • 鲲鹏 ARM 架构 麒麟 Lylin v10 安装 Nginx (离线) 焚木灵 arm开发架构nginx服务器
    最近做一个银行的项目，银行的服务器是鲲鹏ARM架构的服务器，并且是麒麟v10的系统，这里记录一下在无法访问外网安装Nginx的方法。其他文章：鲲鹏ARM架构麒麟Lylinv10安装Mysql8.3(离线)-CSDN博客鲲鹏ARM架构麒麟Lylinv10安装Node和NVM(离线)-CSDN博客鲲鹏ARM架构麒麟Lylinv10安装Pm2(离线)-CSDN博客鲲鹏ARM架构麒麟Lylinv10安装P
  • Nginx的使用场景：构建高效、可扩展的Web架构 张某布响丸辣 nginx前端架构
    Nginx，作为当今最流行的Web服务器和反向代理软件之一，凭借其高性能、稳定性和灵活性，在众多Web项目中扮演着核心角色。无论是个人博客、中小型网站，还是大型企业级应用，Nginx都能提供强大的支持。本文将探讨Nginx的几个主要使用场景，帮助读者理解如何在实际项目中充分利用Nginx的优势。1.静态文件服务对于包含大量静态文件（如HTML、CSS、JavaScript、图片等）的网站，Ngin
  • Hadoop架构 henan程序媛 hadoop大数据分布式
    一、案列分析1.1案例概述现在已经进入了大数据(BigData)时代，数以万计用户的互联网服务时时刻刻都在产生大量的交互，要处理的数据量实在是太大了，以传统的数据库技术等其他手段根本无法应对数据处理的实时性、有效性的需求。HDFS顺应时代出现，在解决大数据存储和计算方面有很多的优势。1.2案列前置知识点1.什么是大数据大数据是指无法在一定时间范围内用常规软件工具进行捕捉、管理和处理的大量数据集合，
  • Web安全:Web体系架构存在的安全问题和解决方室 程序员-张师傅 前端安全web安全前端
    Web体系架构在提供丰富功能和高效服务的同时，也面临着诸多安全问题。这些问题可能涉及数据泄露、服务中断、系统被控制等多个方面，对企业和个人造成不可估量的损失。以下是对Web体系架构中存在的安全问题及解决方案的详细分析：Web体系架构存在的安全问题注入攻击SQL注入：攻击者通过在输入字段中插入恶意SQL代码，操控后台数据库，窃取、篡改或删除数据。OS命令注入：攻击者通过输入字段插入恶意代码，执行系统
  • Gobelieve 架构 weixin_34099526 数据库golangjson
    Gobelievegithub地址声明:转简书JackieF的文章,为了自己方便copy了一份,加一些自己的东西.链接：https://www.jianshu.com/p/8121d6e85282IMCore主要分三大块:im客户连接服务器（可分布式部署，暂无负载均衡模块)imr路由查询服务器（主要解决im分布式部署的问题）ims存储服务器(主从部署)基础模块1.数据包协议包：header(12)
  • Go 面向包的设计和架构分层 云满笔记 golang架构directorylayoutsrcproject
    标题Go面向包的设计和架构分层序前项目架构分层工具包项目应用项目cmd/internal/internal/pkg/pkg/vendor/面向包的设计和验证包的位置依赖包导入应用级别的策略数据的发送和接收错误处理测试捕获错误不建议的目录结论Go面向包的设计和架构分层序本篇内容主要讲解golang项目的面向包设计准则和基础的架构分层。信息来自原文ArdanLabs:Package-Oriented-
  • Java面试笔记记录6 今天背八股了吗 java面试笔记
    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
  • Go 语言基本架构 Fe_cow丿 Go
    Go基本架构一、Go基本架构：packagemainimport"fmt"funcmain(){fmt.Println("hello,world")}go文件的后缀是.go；packagemain：表示文件所在的包是main；每个Go应用程序都包含一个为main的包；所有包名都应该使用小写字母；import“fmt”：表示引入一个包，包名为fmt，引入该包后，就可以使用fmt包的函数；比如：fmt
  • 从单体到微服务：FastAPI ‘挂载’子应用程序的转变 黑金IT fastapi微服务fastapi架构
    在现代Web应用开发中，模块化架构是一种常见的设计模式，它有助于将大型应用程序分解为更小、更易于管理的部分。FastAPI，作为一个高性能的PythonWeb框架，提供了强大的支持来实现这种模块化设计。通过“挂载”子应用程序，我们可以为不同的功能区域（如前端接口、管理员接口和用户中心）创建独立的应用程序，并将它们整合到一个主应用程序中。本文将详细介绍如何在FastAPI中使用“挂载”子应用程序的方
  • Kafka详细解析与应用分析 芊言芊语 kafka分布式
    Kafka是一个开源的分布式事件流平台（EventStreamingPlatform），由LinkedIn公司最初采用Scala语言开发，并基于ZooKeeper协调管理。如今，Kafka已经被Apache基金会纳入其项目体系，广泛应用于大数据实时处理领域。Kafka凭借其高吞吐量、持久化、分布式和可靠性的特点，成为构建实时流数据管道和流处理应用程序的重要工具。Kafka架构Kafka的架构主要由
  • 使用FPGA接收MIPI CSI RX信号并进行去抖动、RGB转YUV处理：FX3014 USB3.0 UVC传输与帧率控制源代码，FPGA实现MIPI CSI RX接收，去Debayer， RGB转 kVfINoSzdrt fpga开发程序人生
    fpgamipicsirx接收去debayer,rgb转yuv,fx3014usb3.0uvc传输与帧率控制源代码，具体架构看图，除dphy物理层外，mipi均为源码sensorimx219mipi源码mipi4lanecsirxraw10fpgamachXO3lf-690usb3.0fx301432bityuvdatawithframesync测试模式3280*246415fps1920*108
  • ASM系列四 利用Method 组件动态注入方法逻辑 lijingyao8206 字节码技术jvmAOP动态代理ASM
            这篇继续结合例子来深入了解下Method组件动态变更方法字节码的实现。通过前面一篇，知道ClassVisitor 的visitMethod()方法可以返回一个MethodVisitor的实例。那么我们也基本可以知道，同ClassVisitor改变类成员一样，MethodVIsistor如果需要改变方法成员，注入逻辑，也可以
  • java编程思想 --内部类 百合不是茶 java内部类匿名内部类
    内部类;了解外部类 并能与之通信 内部类写出来的代码更加整洁与优雅   1,内部类的创建  内部类是创建在类中的 package com.wj.InsideClass; /* * 内部类的创建 */ public class CreateInsideClass { public CreateInsideClass(
  • web.xml报错 crabdave web.xml
    web.xml报错   The content of element type "web-app" must match "(icon?,display-  name?,description?,distributable?,context-param*,filter*,filter-mapping*,listener*,servlet*,s
  • 泛型类的自定义 麦田的设计者 javaandroid泛型
       为什么要定义泛型类，当类中要操作的引用数据类型不确定的时候。 采用泛型类，完成扩展。   例如有一个学生类     Student{ Student(){ System.out.println("I'm a student....."); } }  有一个老师类  
  • CSS清除浮动的4中方法 IT独行者 JavaScriptUIcss
    清除浮动这个问题，做前端的应该再熟悉不过了，咱是个新人，所以还是记个笔记，做个积累，努力学习向大神靠近。CSS清除浮动的方法网上一搜，大概有N多种，用过几种，说下个人感受。 1、结尾处加空div标签 clear:both 1 2 3 4 .div 1 { background : #000080 ; border : 1px   s
  • Cygwin使用windows的jdk 配置方法 _wy_ jdkwindowscygwin
    1.[vim /etc/profile]    JAVA_HOME="/cgydrive/d/Java/jdk1.6.0_43"  (windows下jdk路径为D:\Java\jdk1.6.0_43)    PATH="$JAVA_HOME/bin:${PATH}"    CLAS
  • linux下安装maven 无量 mavenlinux安装
    Linux下安装maven(转) 1.首先到Maven官网 下载安装文件，目前最新版本为3.0.3，下载文件为 apache-maven-3.0.3-bin.tar.gz，下载可以使用wget命令； 2.进入下载文件夹，找到下载的文件，运行如下命令解压 tar -xvf  apache-maven-2.2.1-bin.tar.gz 解压后的文件夹
  • tomcat的https 配置,syslog-ng配置 aichenglong tomcathttp跳转到httpssyslong-ng配置syslog配置
    1) tomcat配置https,以及http自动跳转到https的配置     1)TOMCAT_HOME目录下生成密钥(keytool是jdk中的命令)      keytool -genkey -alias tomcat -keyalg RSA -keypass changeit -storepass changeit
  • 关于领号活动总结 alafqq 活动
    关于某彩票活动的总结 具体需求，每个用户进活动页面，领取一个号码，1000中的一个； 活动要求 1，随机性，一定要有随机性； 2，最少中奖概率，如果注数为3200注，则最多中4注 3，效率问题，（不能每个人来都产生一个随机数，这样效率不高）； 4，支持断电（仍然从下一个开始），重启服务；（存数据库有点大材小用，因此不能存放在数据库） 解决方案 1，事先产生随机数1000个，并打
  • java数据结构 冒泡排序的遍历与排序 百合不是茶 java
    java的冒泡排序是一种简单的排序规则   冒泡排序的原理：           比较两个相邻的数，首先将最大的排在第一个，第二次比较第二个 ，此后一样；         针对所有的元素重复以上的步骤，除了最后一个     例题；将int array[]
  • JS检查输入框输入的是否是数字的一种校验方法 bijian1013 js
    如下是JS检查输入框输入的是否是数字的一种校验方法： <form method=post target="_blank"> 数字：<input type="text" name=num onkeypress="checkNum(this.form)"><br> </form>
  • Test注解的两个属性：expected和timeout bijian1013 javaJUnitexpectedtimeout
    JUnit4：Test文档中的解释： 　　The Test annotation supports two optional parameters. 　　The first, expected, declares that a test method should throw an exception. 　　If it doesn't throw an exception or if it
  • [Gson二]继承关系的POJO的反序列化 bit1129 POJO
    父类     package inheritance.test2; import java.util.Map; public class Model { private String field1; private String field2; private Map<String, String> infoMap
  • 【Spark八十四】Spark零碎知识点记录 bit1129 spark
    1. ShuffleMapTask的shuffle数据在什么地方记录到MapOutputTracker中的 ShuffleMapTask的runTask方法负责写数据到shuffle map文件中。当任务执行完成成功，DAGScheduler会收到通知，在DAGScheduler的handleTaskCompletion方法中完成记录到MapOutputTracker中  
  • WAS各种脚本作用大全 ronin47 WAS 脚本
    　　　http://www.ibm.com/developerworks/cn/websphere/library/samples/SampleScripts.html 　　　无意中，在WAS官网上发现的各种脚本作用，感觉很有作用，先与各位分享一下 　　　 获取下载 这些示例 jacl 和 Jython 脚本可用于在 WebSphere Application Server 的不同版本中自
  • java-12.求 1+2+3+..n不能使用乘除法、 for 、 while 、 if 、 else 、 switch 、 case 等关键字以及条件判断语句 bylijinnan switch
    借鉴网上的思路，用java实现： public class NoIfWhile { /** * @param args * * find x=1+2+3+....n */ public static void main(String[] args) { int n=10; int re=find(n); System.o
  • Netty源码学习-ObjectEncoder和ObjectDecoder bylijinnan javanetty
    Netty中传递对象的思路很直观： Netty中数据的传递是基于ChannelBuffer（也就是byte[]）； 那把对象序列化为字节流，就可以在Netty中传递对象了 相应的从ChannelBuffer恢复对象，就是反序列化的过程 Netty已经封装好ObjectEncoder和ObjectDecoder 先看ObjectEncoder ObjectEncoder是往外发送
  • spring 定时任务中cronExpression表达式含义 chicony cronExpression
    一个cron表达式有6个必选的元素和一个可选的元素，各个元素之间是以空格分隔的，从左至右，这些元素的含义如下表所示： 代表含义            是否必须 允许的取值范围         &nb
  • Nutz配置Jndi ctrain JNDI
    1、使用JNDI获取指定资源： var ioc = { dao : { type :"org.nutz.dao.impl.NutDao", args : [ {jndi :"jdbc/dataSource"} ] } } 以上方法,仅需要在容器中配置好数据源,注入到NutDao即可.
  • 解决 /bin/sh^M: bad interpreter: No such file or directory daizj shell
    在Linux中执行.sh脚本，异常/bin/sh^M: bad interpreter: No such file or directory。   分析：这是不同系统编码格式引起的：在windows系统中编辑的.sh文件可能有不可见字符，所以在Linux系统下执行会报以上异常信息。 解决： 1）在windows下转换： 利用一些编辑器如UltraEdit或EditPlus等工具
  • [转]for 循环为何可恨？ dcj3sjt126com 程序员读书
      Java的闭包(Closure)特征最近成为了一个热门话题。 一些精英正在起草一份议案，要在Java将来的版本中加入闭包特征。 然而，提议中的闭包语法以及语言上的这种扩充受到了众多Java程序员的猛烈抨击。 不久前，出版过数十本编程书籍的大作家Elliotte Rusty Harold发表了对Java中闭包的价值的质疑。 尤其是他问道“for 循环为何可恨？”[http://ju
  • Android实用小技巧 dcj3sjt126com android
    1、去掉所有Activity界面的标题栏 　　修改AndroidManifest.xml 　　在application 标签中添加android:theme="@android:style/Theme.NoTitleBar"   2、去掉所有Activity界面的TitleBar 和StatusBar  　　修改AndroidManifes
  • Oracle 复习笔记之序列 eksliang Oracle 序列sequenceOracle sequence
    转载请出自出处：http://eksliang.iteye.com/blog/2098859 1.序列的作用 序列是用于生成唯一、连续序号的对象 一般用序列来充当数据库表的主键值 2.创建序列语法如下：   create sequence s_emp start with 1 --开始值 increment by 1 --増长值 maxval
  • 有“品”的程序员 gongmeitao 工作
    完美程序员的10种品质　　   完美程序员的每种品质都有一个范围，这个范围取决于具体的问题和背景。没有能解决所有问题的   完美程序员（至少在我们这个星球上），并且对于特定问题，完美程序员应该具有以下品质： 　　1. 才智非凡- 能够理解问题、能够用清晰可读的代码翻译并表达想法、善于分析并且逻辑思维能力强   （范围：用简单方式解决复杂问题）　　
  • 使用KeleyiSQLHelper类进行分页查询 hvt sql.netC#asp.nethovertree
    本文适用于sql server单主键表或者视图进行分页查询，支持多字段排序。KeleyiSQLHelper类的最新代码请到http://hovertree.codeplex.com/SourceControl/latest下载整个解决方案源代码查看。或者直接在线查看类的代码：http://hovertree.codeplex.com/SourceControl/latest#HoverTree.D
  • SVG 教程 （三）圆形，椭圆，直线 天梯梦 svg
    SVG <circle> SVG 圆形 - <circle> <circle> 标签可用来创建一个圆： 下面是SVG代码： <svg xmlns="http://www.w3.org/2000/svg" version="1.1"> <circle cx="100" c
  • 链表栈 luyulong java数据结构
    public class Node { private Object object; private Node next; public Node() { this.next = null; this.object = null; } public Object getObject() { return object; } public
  • 基础数据结构和算法十：2-3 search tree sunwinner Algorithm2-3 search tree
      Binary search tree works well for a wide variety of applications, but they have poor worst-case performance. Now we introduce a type of binary search tree where costs are guaranteed to be loga
  • spring配置定时任务 stunizhengjia springtimer
    最近因工作的需要，用到了spring的定时任务的功能,觉得spring还是很智能化的,只需要配置一下配置文件就可以了,在此记录一下，以便以后用到：     //------------------------定时任务调用的方法------------------------------ /** * 存储过程定时器 */ publi
  • ITeye 8月技术图书有奖试读获奖名单公布 ITeye管理员 活动
    ITeye携手博文视点举办的8月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 8月试读活动回顾： http://webmaster.iteye.com/blog/2102830 本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 《跨终端Web》 gleams：http