Dagger2——Lazy injections，Provider injections

2021年01月03日 22:42 · 阅读 272

懒加载——Lazy

有时候，某些对象需要被懒加载，不用在一开始就创建出来，这样可以减少内存开销以及初始化时间。那么，对于任何的类型T，都可以创建一个Lazy类型的对象，它会在第一次被调用get()方法时返回一个T类型的实例。如果T是一个单例，那么在范围内，所有的注入返回的都是同一个Lazy实例。否则，每次注入都返回的是各自的Lazy实例。

BMWWheel：

public class BMWWheel implements IWheel {
    @Inject
    public BMWWheel() {
        super();
    }
//。。。
}
复制代码

WheelModule:

@Module
abstract class WheelModel {
    @Binds
    abstract IWheel provideBMWWheel(BMWWheel wheel);
}
复制代码

CarComponent：

@Component(modules = WheelModel.class)
public interface CarComponent {
    BMW makeBmw();
}
复制代码

测试：

public class CarMain {
    public static void main(String[] args) {
        CarComponent component = DaggerCarComponent.create();
        BMW bmw = component.makeBmw();
        System.out.println(bmw.wheel);
        System.out.println(bmw.wheel);
        System.out.println(bmw.wheel);
        System.out.println(bmw.wheel);
    }
}
复制代码

结果可以看到每次打印的wheel是同一个对象。

实现原理：

DaggerCarComponent：

public final class DaggerCarComponent implements CarComponent {
  private DaggerCarComponent() {

  }

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

  public static CarComponent create() {
    return new Builder().build();
  }

  @Override
  public BMW makeBmw() {
    return injectBMW(BMW_Factory.newInstance());}

  private BMW injectBMW(BMW instance) {
    BMW_MembersInjector.injectWheel(instance, DoubleCheck.lazy((Provider) BMWWheel_Factory.create()));
    return instance;
  }

  public static final class Builder {
    private Builder() {
    }

    public CarComponent build() {
      return new DaggerCarComponent();
    }
  }
}
复制代码

可以看到，DaggerCarComponent注入到BMW对象实例中的wheel属性是一个DoubleCheck类型。而DoubleCheck内部实现了get()方法，使用synchronized保证了每次获取到的都是同一个对象。

  @Override
  public T get() {
    Object result = instance;
    if (result == UNINITIALIZED) {
      synchronized (this) {
        result = instance;
        if (result == UNINITIALIZED) {
          result = provider.get();
          instance = reentrantCheck(instance, result);
          /* Null out the reference to the provider. We are never going to need it again, so we
           * can make it eligible for GC. */
          provider = null;
        }
      }
    }
    return (T) result;
  }
复制代码

其中的reentrantCheck()方法有些费解。。

另一种测试：

public class CarMain {
    public static void main(String[] args) {
        CarComponent component = DaggerCarComponent.create();
        System.out.println(component.makeBmw().wheel);
        System.out.println(component.makeBmw().wheel);
        System.out.println(component.makeBmw().wheel);
    }
}
复制代码

很明显，每次打印的wheel对象都是不一样的，说明Lazy注入只跟Lazy对象有关，如果Lazy对象实例不一样，切注入的类型T不是单例的，那么每次返回的都是不同的对象。

Provider注入

如果想每次获取到的T类型的实例都不一样，那么可以使用Provider注入，即Provider。这样每次调用get()方法时都会重新调用Module里面的绑定逻辑。如果每次Module中提供的都是一个新的对象实例，那么每次调用Provider的get()方法都是同一个实例。

BMWWheel同上

BMW:

public class BMW {
    @Inject
    public BMW(){
        super();
    }

    @Inject
    Provider<IWheel> wheel;
}
复制代码

区别就是此处注入的是Provider，而不是IWheel，或者Lazy

BMWModule和CarComponent同上。

测试：

public class CarMain {
    public static void main(String[] args) {
        CarComponent component = DaggerCarComponent.create();

        BMW bmw = component.makeBmw();
        System.out.println(bmw.wheel.get());
        System.out.println(bmw.wheel.get());
        System.out.println(bmw.wheel.get());
    }
}
复制代码

明显的，每次打印的IWheel实例都不一样。

实现原理，可以想到主要逻辑在DaggerCarComponent中：

public final class DaggerCarComponent implements CarComponent {
  private DaggerCarComponent() {

  }
    //...
  private BMW injectBMW(BMW instance) {
    BMW_MembersInjector.injectWheel(instance, WheelModel_ProvideBMWWheelFactory.create());
    return instance;
  }
	//...
}
复制代码

可以看到，注入到BMW对象中的是一个工厂类的实例-WheelModel_ProvideBMWWheelFactory：

public final class WheelModel_ProvideBMWWheelFactory implements Factory<IWheel> {
  @Override
  public IWheel get() {
    return provideBMWWheel();
  }

  public static WheelModel_ProvideBMWWheelFactory create() {
    return InstanceHolder.INSTANCE;
  }

  public static IWheel provideBMWWheel() {
    return Preconditions.checkNotNull(WheelModel.provideBMWWheel(), "Cannot return null from a non-@Nullable @Provides method");
  }

  private static final class InstanceHolder {
    private static final WheelModel_ProvideBMWWheelFactory INSTANCE = new WheelModel_ProvideBMWWheelFactory();
  }
}
复制代码

可以看到，这个WheelModel_ProvideBMWWheelFactory工厂类是一个静态内部类实现的单例。也就是说，不同的BMW实例中的Provider类型的wheel变量其实引用了同一个单例。

它实现了get()方法，内部会再调用provideBMWWheel()方法，而这个方法内部又会调用WheelModel.provideBMWWheel()方法，所以就验证了之前的说法，每次调用Provider的get()方法都会重新调用@Module类中的提供依赖的方法。因此，也可以想到Provider不能保证每次获取到的T类型的实例都是不一样的，这取决于@Module中的实现，以下这种@Singleton的方式就会一样。

BMW:(给BMWWheel增加@Singleton)

@Singleton
public class BMWWheel implements IWheel {
    @Inject
    public BMWWheel() {
        super();
    }
//。。。
}
复制代码

WheelModel：

@Module
abstract class WheelModel {
    @Binds
    abstract IWheel provideBMWWheel(BMWWheel wheel);
}
复制代码

并给CarComponent增加@Singleton

那么显然，每次调用WheelModel的provideBMWWheel()其实得到的都是同一个BMWWheel实例，这是因为@Singleton在Component中有效。