Android 匕首2基类注入

在Dagger1中，我有一个基类设置，这样它就可以创建一个范围图并将依赖项注入到当前对象中。例如

public abstract class MyBaseActivity extends Activity {
  private ObjectGraph graph;

  protected void onCreate(Bundle savedInstanceState) {
    graph = ((MyApp) getApplication()).plus(getModules());
    graph.inject(this);
  }

  protected Object[] getModules();
}

public class MyClass extends MyBaseActivity {

  @Inject SomeDep someDep;

  @Override
  protected Object[] getModules() {
    return new Object[/* Contains a module that provides SomeDep */];
  }
}

这允许每个子类在标准应用程序模块之外补充自己的模块集

在玩了匕首2之后，似乎不可能处理类似的场景

public abstract class MyBaseActivity extends Activity {
  private MyBaseActivityComponent component;

  protected void onCreate(Bundle savedInstanceState) {
    component = ((MyApp) getApplication()).component().plus(/* Can not accept an array */);
    component.inject(this);
  }
}

我通过修改MyBaseActivityComponent来解决上述问题，这样它就可以列出它可能使用的所有模块

@Subcomponent(modules = {
  Module1.class,
  Module2.class
})
public interface MyBaseActivityComponent {
  public void inject(MyBaseActivity activity);
}

所以现在我可以做这样的事情

public abstract class MyBaseActivity extends Activity {
  private MyBaseActivityComponent component;

  protected void onCreate(Bundle savedInstanceState) {
    component = ((MyApp) getApplication()).component().plus(new Module1(), new Module2());
    component.inject(this);
  }
}

---

但是现在我遇到了一个问题，注入将为MyBaseActivity注入依赖项，而不是它的子类。建议？

理论上，你可以这样做

1.）指定子作用域

@Scope
@Retention(RUNTIME)
public @interface PerActivity {
}

2.）指定父组件

@Singleton
@Component(modules={Module1.class, Module2.class)
public interface MyApplicationComponent {
    Dependency1 providesDependency1();
    Dependency2 providesDependency2();
}

@PerActivity
@Component(dependencies={MyApplicationComponent.class}, modules={Module3.class})
public interface MyBaseActivityComponent extends MyApplicationComponent {
    void inject(BaseActivity baseActivity);

    Dependency3 providesDependency3();
}

public class BaseActivity extends AppCompatActivity {
    private MyBaseActivityComponent baseComponent;

    @Override
    public void onCreate(Bundle saveState) {
        super.onCreate(saveState);
        baseComponent = DaggerBaseActivityComponent.builder()
                    .applicationComponent(((MyApp)getApplication()).component())
                    .build();
    }

    public MyBaseActivityComponent baseComponent() {
        return baseComponent;
    }

    @Override
    public void onDestroy() {
        component = null;
        super.onDestroy();
    }
}

3.）指定子组件

@Singleton
@Component(modules={Module1.class, Module2.class)
public interface MyApplicationComponent {
    Dependency1 providesDependency1();
    Dependency2 providesDependency2();
}

@PerActivity
@Component(dependencies={MyApplicationComponent.class}, modules={Module3.class})
public interface MyBaseActivityComponent extends MyApplicationComponent {
    void inject(BaseActivity baseActivity);

    Dependency3 providesDependency3();
}

public class BaseActivity extends AppCompatActivity {
    private MyBaseActivityComponent baseComponent;

    @Override
    public void onCreate(Bundle saveState) {
        super.onCreate(saveState);
        baseComponent = DaggerBaseActivityComponent.builder()
                    .applicationComponent(((MyApp)getApplication()).component())
                    .build();
    }

    public MyBaseActivityComponent baseComponent() {
        return baseComponent;
    }

    @Override
    public void onDestroy() {
        component = null;
        super.onDestroy();
    }
}

4.）创建您的模块

@Module
public class Module3 {
     @Provides
     @PerActivity
     public Dependency3 providesDependency3() {
         return new Dependency3();
     }
}

5.）创建活动级别范围的组件

@Singleton
@Component(modules={Module1.class, Module2.class)
public interface MyApplicationComponent {
    Dependency1 providesDependency1();
    Dependency2 providesDependency2();
}

@PerActivity
@Component(dependencies={MyApplicationComponent.class}, modules={Module3.class})
public interface MyBaseActivityComponent extends MyApplicationComponent {
    void inject(BaseActivity baseActivity);

    Dependency3 providesDependency3();
}

public class BaseActivity extends AppCompatActivity {
    private MyBaseActivityComponent baseComponent;

    @Override
    public void onCreate(Bundle saveState) {
        super.onCreate(saveState);
        baseComponent = DaggerBaseActivityComponent.builder()
                    .applicationComponent(((MyApp)getApplication()).component())
                    .build();
    }

    public MyBaseActivityComponent baseComponent() {
        return baseComponent;
    }

    @Override
    public void onDestroy() {
        component = null;
        super.onDestroy();
    }
}

请回复是否有效，之前我忘记在

组件中指定依赖项，并出现编译错误，但它应该是这样工作的

此外，如果需要为每个
活动指定子组件，则只需在
BaseActivityComponent
组件中指定具有供应方法的依赖项即可

@PerActivity
@Component(dependencies={MyBaseActivityComponent.class}, modules={Module4.class})
public interface MyActivityComponent extends MyBaseActivityComponent {
    public void inject(MyActivity myActivity);

    Dependency4 providesDependency4();
}

@Module
public class Module4 {
    @PerActivity
    @Provides
    public Dependency4 providesDependency4(Dependency3 dependency3) {
        return new Dependency4(dependency3);
    }
}

public class MyActivity extends MyBaseActivity {
    private MyActivityComponent component;

    @Override
    public void onCreate(Bundle saveInstanceState) {
        super.onCreate(saveInstanceState);
        component = DaggerMyActivityComponent.builder()
           .applicationComponent(((MyApp)getApplication()).component())
           .myBaseActivityComponent(baseComponent())
           .build();
    }

    @Override
    public void onDestroy() {
        component = null;
        super.onDestroy();
    }
}

编辑：
@Subcomponent
仅当您使用以下模式时（即，使用供应/工厂方法定义将子组件嵌入父组件中），才可根据使用子组件工厂方法替换组件依赖项：

在哪里

确保调用
super.onCreate（savedInstanceState）'mkay，完成了，尽管我在脑海中输入了这个，我希望它能工作。这并没有消除显式调用注入的需要，对吗？BaseActivity的每个子类本质上都需要调用
组件。我尝试在android优先级作业队列中注入
BaseJob
，但它似乎不起作用。