Dagger2 使用及编译后源码解读

示例代码

• bean

@Singleton //对象单例
public class Animal {
    Context mContext;

    @Inject //可实例化
    public Animal(Context context) {
        mContext = context;
    }
}

• module

@Module
public class AnimalModule {
    Context context;

    public AnimalModule(Context context) {
        this.context = context;
    }

    @Singleton //对象单例
    @Provides //提供者
    Context getContext() {
        return context;
    }
}

• component

@Singleton //对象单例
@Component(modules = AnimalModule.class) //提供组件
public interface AnimalComponent {
    void inject(Dagger2Activity dagger2Activity);
}

• 使用

 @Inject //Dagger2Activity 中使用
 Animal animal;
 @Inject
 Animal animal_1;

DaggerAnimalComponent.builder().animalModule(new AnimalModule(this)).build().inject(this)；

编译后解读源码

• 主要看DaggerAnimalComponent类，该类实现了AnimalComponent接口和接口中的方法。

  • DaggerAnimalComponent类中的静态内部类Builder类。

  public static final class Builder {
      //DaggerAnimalComponent.builder() 创建Builder类对象
      //.animalModule(new AnimalModule(this)) 将AnimalModule 类存储起来
      //.build() 创建DaggerAnimalComponent 对象，并将Builder对象传递过去，然后会执行initialize()方法，该方法的作用是为getContextProvider，animalProvider对象赋值。
      //.inject(this) 最终会执行injectDagger2Activity()方法
      private AnimalModule animalModule;
      private Builder() {
      }
      public AnimalComponent build() {
          Preconditions.checkBuilderRequirement(animalModule, AnimalModule.class);
          //this 为 builder 里面包含了animalModule对象
          return new DaggerAnimalComponent(this);
      }
      public Builder animalModule(AnimalModule animalModule) {
          this.animalModule = Preconditions.checkNotNull(animalModule);
          return this;
  

  • DaggerAnimalComponent类

  //该类继承于写的AnimalComponent接口，需要实现inject接口
  //从源码可以看出，被注释可实例化的类最终该类的代理类对象都会在DaggerAnimalComponent类中汇聚集中，若该类需要依赖其他类实现，在规定Component的时候，可以自己引入相应的Module，该Module定义的时候可以为实例化类提供所需的条件。
  public final class DaggerAnimalComponent implements AnimalComponent {
      //Animal_Module对象代理类 DoubleCheck对象
      private Provider<Context> getContextProvider;
      //Animal_Factory对象代理类 DoubleCheck 对象
      private Provider<Animal> animalProvider;
  
      private DaggerAnimalComponent(Builder builder) {
          initialize(builder);
      }
  
      public static Builder builder() {
          return new Builder();
      }
  
      @SuppressWarnings("unchecked")
      private void initialize(final Builder builder) {
          //DoubleCheck.provider();该方法返回的是一个实现provider接口的类对象，该类实现get()方法，该get()方法最终会执行AnimalModule_GetContextFactory工厂类对象的get()方法，AnimalModule_GetContextFactory工厂类中的get()方法最终会调用AnimalModule对象中的getContext()方法，getContext()方法是我自己定义的，用来返回context。
          //DaggerAnimalComponent 类中静态内部类Builder类，该类可以携带Module类。
          this.getContextProvider = DoubleCheck.provider(AnimalModule_GetContextFactory.create(builder.animalModule));
          //将getContextProvider代理类传递到Animal_Factory类中保存，再生成一个DoubleCheck代理类对象。
          this.animalProvider = DoubleCheck.provider(Animal_Factory.create(getContextProvider));
      }
  
      @Override
      public void inject(Dagger2Activity dagger2Activity) {
          injectDagger2Activity(dagger2Activity);
      }
  
      private Dagger2Activity injectDagger2Activity(Dagger2Activity instance) {
          //DoubleCheck对象的animalProvider get()方法，最终会调用Animal_Factory对象中的get()方法，该方法会创建一个Animal对象，当创建Animal对象的时候还会调用getContextProvider中的get()方法，该方法最终会调用AnimalModule_GetContextFactory中的get()方法，AnimalModule_GetContextFactory工厂类中的get()方法最终会调用AnimalModule对象中的getContext()方法，getContext()方法是我自己定义的，用来返回context。Fuck
          //injectAnimal()方法将为Activity中的对象赋值
          Dagger2Activity_MembersInjector.injectAnimal(instance, animalProvider.get());
          Dagger2Activity_MembersInjector.injectAnimal_1(instance, animalProvider.get());
          return instance;
      }
  }
  

• Dagger2Activity_MembersInjector 类，最主要的方法就是为Activity中的被inject注释的对象赋值。

public static void injectAnimal(Dagger2Activity instance, Animal animal) {
  //instance对象为Activity对象，为animal对象赋值
  instance.animal = animal;
}
public static void injectAnimal_1(Dagger2Activity instance, Animal animal_1) {
  instance.animal_1 = animal_1;
}

• Animal_Factory 类

public final class Animal_Factory implements Factory<Animal> {
  private final Provider<Context> contextProvider;
    
  public Animal_Factory(Provider<Context> contextProvider) {
    this.contextProvider = contextProvider;
  }
  //最终返回Animal对象
  @Override
  public Animal get() {
    return provideInstance(contextProvider);
  }

  public static Animal provideInstance(Provider<Context> contextProvider) {
    //contextProvider.get() DoubleCheck 代理对象将执行get()方法；
    return new Animal(contextProvider.get());
  }

  public static Animal_Factory create(Provider<Context> contextProvider) {
    return new Animal_Factory(contextProvider);
  }

  public static Animal newAnimal(Context context) {
    return new Animal(context);
  }
}

• AnimalModule_GetContextFactory类

public final class AnimalModule_GetContextFactory implements Factory<Context> {
  private final AnimalModule module;
  public AnimalModule_GetContextFactory(AnimalModule module) {
    this.module = module;
  }

  @Override
  public Context get() {
    return provideInstance(module);
  }

  public static Context provideInstance(AnimalModule module) {
    return proxyGetContext(module);
  }
  public static AnimalModule_GetContextFactory create(AnimalModule module) {
    return new AnimalModule_GetContextFactory(module);
  }

  public static Context proxyGetContext(AnimalModule instance) {
      //getContext() 自己在AnimalModule中写的方法
    return Preconditions.checkNotNull(
        instance.getContext(), "Cannot return null from a non-@Nullable @Provides method");
  }
}