dragger2学习

在gradle添加依赖

    compile 'com.google.dagger:dagger:2.11-rc2'
    annotationProcessor 'com.google.dagger:dagger-compiler:2.11-rc2'

注解	用法
@Module	Modules类里面的方法专门提供依赖，所以我们定义一个类，用@Module注解，这样Dagger在构造类的实例的时候，就知道从哪里去找到需要的依赖。modules的一个重要特征是它们设计为分区并组合在一起（比如说，在我们的app中可以有多个组成在一起的modules
@Provide	在modules中，我们定义的方法是用这个注解，以此来告诉Dagger我们想要构造对象并提供这些依赖。
@Singleton	当前提供的对象将是单例模式 ,一般配合@Provides一起出现
@Component	用于接口，这个接口被Dagger2用于生成用于模块注入的代码
@Inject	在需要依赖的地方使用这个注解。（你用它告诉Dagger这个构造方法，成员变量或者函数方法需要依赖注入。这样，Dagger就会构造一个这个类的实例并满足他们的依赖。）
@Scope	Scopes可是非常的有用，Dagger2可以通过自定义注解限定注解作用域。

dagger2创建实例的2中方式

1.第一种方式

先创建一个需要注入的对象


public class BeanForDagger {
    private String name = null;

    @Inject
    BeanForDagger() {
        name = "my car";
    }

    public String getName() {
        return name;
    }
}

创建使用者和被使用者之间的桥梁 Component

@Component
public interface BeanComponent {
    void injectBeanForDragger(MainActivity activity);
}

使用者


public class MainActivity extends AppCompatActivity {  
    @Inject
    BeanForDagger beanForDagger;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        DaggerBeanComponent.create().injectBeanForDragger(this);
       
        if (beanForDagger != null) {
            Toast.makeText(getApplicationContext(), beanForDagger.getName(), Toast.LENGTH_SHORT).show();
        }
    }

｝

这样就能运行了

第二种方式是Module+provide

public class Car {
    @Inject
    Car(){}
    public int getWheelCount(){
        return 4;
    }
}

@Component(modules = CarModule.class)
public interface CarComponent {
     void injectCar(MainActivity activity);
}

public class MainActivity extends AppCompatActivity {
    @Inject
    BeanForDagger beanForDagger;
    @Inject
    Car car;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        DaggerBeanComponent.create().injectBeanForDragger(this);
        DaggerCarComponent.create().injectCar(this);

        if (beanForDagger != null) {
            Toast.makeText(getApplicationContext(), beanForDagger.getName() + "------" + car.getWheelCount(), Toast.LENGTH_SHORT).show();
        }
    }
}

有兴趣的可以看下dagger2自动生成的代码


public final class Car_Factory implements Factory<Car> {
  private static final Car_Factory INSTANCE = new Car_Factory();

  @Override
  public Car get() {
    return new Car();
  }

  public static Factory<Car> create() {
    return INSTANCE;
  }

  /** Proxies {@link Car#Car()}. */
  public static Car newCar() {
    return new Car();
  }
}


public final class CarModule_ProvideCarFactory implements Factory<Car> {
  private static final CarModule_ProvideCarFactory INSTANCE = new CarModule_ProvideCarFactory();

  @Override
  public Car get() {
    return Preconditions.checkNotNull(
        CarModule.provideCar(), "Cannot return null from a non-@Nullable @Provides method");
  }

  public static Factory<Car> create() {
    return INSTANCE;
  }

  /** Proxies {@link CarModule#provideCar()}. */
  public static Car proxyProvideCar() {
    return CarModule.provideCar();
  }
}


public final class MainActivity_MembersInjector implements MembersInjector<MainActivity> {
  private final Provider<BeanForDagger> beanForDaggerProvider;

  private final Provider<Car> carProvider;

  public MainActivity_MembersInjector(
      Provider<BeanForDagger> beanForDaggerProvider, Provider<Car> carProvider) {
    assert beanForDaggerProvider != null;
    this.beanForDaggerProvider = beanForDaggerProvider;
    assert carProvider != null;
    this.carProvider = carProvider;
  }

  public static MembersInjector<MainActivity> create(
      Provider<BeanForDagger> beanForDaggerProvider, Provider<Car> carProvider) {
    return new MainActivity_MembersInjector(beanForDaggerProvider, carProvider);
  }

  @Override
  public void injectMembers(MainActivity instance) {
    if (instance == null) {
      throw new NullPointerException("Cannot inject members into a null reference");
    }
    instance.beanForDagger = beanForDaggerProvider.get();
    instance.car = carProvider.get();
  }

  public static void injectBeanForDagger(
      MainActivity instance, Provider<BeanForDagger> beanForDaggerProvider) {
    instance.beanForDagger = beanForDaggerProvider.get();
  }

  public static void injectCar(MainActivity instance, Provider<Car> carProvider) {
    instance.car = carProvider.get();
  }
}

猜你喜欢