使用Dagger2创建的第一个小例子

将Dagger系列的咖啡壶例子再做一下简化，作为Dagger2的入门的第一个小例子。

场景描述：有一个电水壶，它使用一个加热器来烧水。电水壶具备的功能有：开始加热（on方法），结束加热（off方法），倒水（brew方法）。

正确使用Dagger2要按照以下5个步骤来进行：

1.确定依赖对象和被依赖对象

本例中，水壶是依赖对象(dependent object)，加热器是被依赖对象(dependent object’s dependency)，而与此同时，加热器本身并不依赖谁，所以它是一个独立的个体(independent model)。

加热器：src/bean/Heater.java

public class Heater {
	private boolean isHot;
	public void on(){
		System.out.println("开始烧开水啦");
		isHot = true;
	}
	public void off(){
		System.out.println("关闭加热器");
		isHot = false;
	}
	public boolean isHot(){
		return isHot;
	}
}

电水壶：src/bean/Kettle.java

public class Kettle {
	private Heater heater;//电水壶依赖于加热器
	
	public Kettle(Heater heater) {
		super();
		this.heater = heater;
	}
	public void on(){
		heater.on();
	}
	public void off(){
		heater.off();
	}
	public void brew(){
		if(heater.isHot()){
			System.out.println("倒一杯开水");
		}
	}
}

2.创建@Module类

Module类的作用就是提供各种方法，来返回满足依赖关系的对象。这些方法需要添加上@Provides注解。

src/module/KettleModule.java

@Module
public class KettleModule {
	@Singleton
	@Provides
	Heater providesHeater(){
		return new Heater();
	}
	@Singleton
	@Provides
	Kettle providesKettle(Heater heater){
		return new Kettle(heater);
	}
}

3．当有了@Module类，提供所需的依赖和被依赖对象，那么我们就在需要的地方进行取用即可。取用的方式是通过@Inject注解。现在修改以下之前的Kettle类：

<pre name="code" class="java" style="font-size: 18px;">public class Kettle {
	private Heater heater;//电水壶依赖于加热器
	<span style="color:#ff6666;">@Inject</span>
	public Kettle(Heater heater) {
		super();
		this.heater = heater;
	}
	public void on(){
		heater.on();
	}
	public void off(){
		heater.off();
	}
	public void brew(){
		if(heater.isHot()){
			System.out.println("倒一杯开水");
		}
	}
}

唯一修改的就是为构造器添加了@Inject注解。Dagger2中，@Inject注解可以添加在构造器、方法和属性本身的前面。本例就通过构造器进行注入。

4．创建一个接口，让@Inject和@Module建立起联系

写一个接口，并用@Component进行注解，该注解有一个属性module，它用来指明与@Inject建立联系的将是哪一个（或哪一些）@Module类。如果@Inject和@Module匹配正确，那么在接口中定义的方法的返回值对象，都将是被正确注入了依赖关系的对象了：

src/module/KettleComponent：

@Singleton
@Component(modules=KettleModule.class)
public interface KettleComponent {
	Kettle providesKettle();
}

5.获得第4步中声明的接口对象的实例，进而获得接口中定义方法的返回值

@Component接口的实现类由Dagger2自动生成。这个类的命名规范是Dagger前缀加上@Component类的名称，那么本例中，这个类的名称就是DaggerKettleComponent了。

写一个测试类，测试一下注入的结果：

src/main/Test：

public class Test {
	public static void main(String[] args) {
		KettleComponent component = DaggerKettleComponent.builder().build();
		Kettle kettle = component.providesKettle();
		kettle.on();
		kettle.brew();
		kettle.off();
	}
}

这里一定要注意，DaggerKettleComponent类是Daager2根据注解自动生成的一个类。我们可以看一下这个类的源码，就知道为什么要这么调用才能生成一个KettleComponent对象了。

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class DaggerKettleComponent implements KettleComponent {
  private Provider<Heater> providesHeaterProvider;
  private Provider<Kettle> providesKettleProvider;

  private DaggerKettleComponent(Builder builder) {  
    assert builder != null;
    initialize(builder);
  }

  public static Builder builder() {  
    return new Builder();
  }

  public static KettleComponent create() {  
    return builder().build();
  }

  private void initialize(final Builder builder) {  
    this.providesHeaterProvider = ScopedProvider.create(KettleModule_ProvidesHeaterFactory.create(builder.kettleModule));
    this.providesKettleProvider = ScopedProvider.create(KettleModule_ProvidesKettleFactory.create(builder.kettleModule, providesHeaterProvider));
  }

  @Override
  public Kettle providesKettle() {  
    return providesKettleProvider.get();
  }

  public static final class Builder {
    private KettleModule kettleModule;
  
    private Builder() {  
    }
  
    public KettleComponent build() {  
      if (kettleModule == null) {
        this.kettleModule = new KettleModule();
      }
      return new DaggerKettleComponent(this);
    }
  
    public Builder kettleModule(KettleModule kettleModule) {  
      if (kettleModule == null) {
        throw new NullPointerException("kettleModule");
      }
      this.kettleModule = kettleModule;
      return this;
    }
  }
}

DaggerKettleComponent实现了KettleCommpoment接口，并重写了providesKettle方法。

首先调用静态方法builder是为了创建静态内部类Builder类的对象，创建对象后调用方法kettleModule方法为Builder的kettleModule属性赋值，随后再调用静态内部类Builder对象的build方法创建DaggerKettleComponent的对象。在DaggerKettleComponent构造器中会首先对静态内部类Builder对象进行一下判空，然后调用initialize(builder)方法，利用这个静态内部类Builder对象为自己的两个属性赋值：providesHeaterProvider属性和providesKettleProvider属性。并且providesKettleProvider属性值的创建要依赖于providesHeaterProvider属性值。随着providesHeaterProvider属性和providesKettleProvider属性初始化完毕，DaggerKettleComponent对象也就创建完毕了。当调用providesKettle方法的时候，返回的是providesKettleProvider的get方法的返回值。

最后测试程序的执行结果为：