Java @注入BaseActivity

我正在使用youtube上mitch的dagger 2课程进行编码。我对一些事情感到困惑。以下是我的课程： AppComponent.class

@Singleton
@Component(
        modules = {
                AndroidSupportInjectionModule.class,
                ActivityBuildersModule.class,
                AppModule.class,
                ViewModelFactoryModule.class,
        }
)
public interface AppComponent extends AndroidInjector<BaseApplication> {
    
    SessionManager sessionManager();

    @Component.Builder
    interface Builder{

        @BindsInstance
        Builder application(Application application);

        AppComponent build();
    }

}

基本活动

public abstract class BaseActivity extends DaggerAppCompatActivity {

    private static final String TAG = "BaseActivity";
    @Inject
    public SessionManager sessionManager;//confused here

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        subscribeObservers();
    }

    private void subscribeObservers() {
        sessionManager.getAuthUser().observe(this, userAuthResource -> {
            if (userAuthResource != null) {
                switch (userAuthResource.status) {
                    case LOADING: {
                        break;
                    }
                    case AUTHENTICATED: {
                        Log.d(TAG, "subsrcibeObservers: LOGIN SUCCESS:" + userAuthResource.data.getEmail());
                        break;
                    }
                    case ERROR: {
                        Toast.makeText(this, userAuthResource.message, Toast.LENGTH_SHORT).show();
                        break;
                    }
                    case NOT_AUTHENTICATED: {
                        navLoginScreen();
                        break;
                    }
                }
            }
        });
    }
    private void navLoginScreen(){
        Intent intent = new Intent(this, AuthActivity.class);
        startActivity(intent);
        finish();
    }

}

主要活动

public class MainActivity extends BaseActivity {
    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

会话管理器

@Singleton
public class SessionManager {
    private static final String TAG = "SessionManager";

    private MediatorLiveData<AuthResource<User>> cachedUser = new MediatorLiveData<>();

    @Inject
    public SessionManager() {

    }
    public void authenticaWithId(final LiveData<AuthResource<User>> source) {
        if (cachedUser != null) {
            cachedUser.setValue(AuthResource.loading(null));
            cachedUser.addSource(source, userAuthResource -> {
                cachedUser.setValue(userAuthResource);
                cachedUser.removeSource(source);
            });
        }
    }

    public void logOut(){
        Log.d(TAG, "logOut: logging out...");
        cachedUser.setValue(AuthResource.logout());
    }
    public LiveData<AuthResource<User>> getAuthUser(){
        return cachedUser;
    }
}

@Singleton
公共类会话管理器{
私有静态最终字符串TAG=“SessionManager”；
private MediatorLiveData cachedUser=new MediatorLiveData（）；
@注入
公共会话管理器（）{
}
public void authenticaWithId（最终LiveData源）{
if（cachedUser！=null）{
setValue（AuthResource.loading（null））；
cachedUser.addSource（source，userAuthResource->{
cachedUser.setValue（userAuthResource）；
cachedUser.removeSource（源）；
});
}
}
公开作废注销（）{
Log.d（标记“注销：注销…”）；
setValue（AuthResource.logout（））；
}
公共LiveData getAuthUser（）{
返回缓存器；
}
}

基本应用程序

public class BaseApplication extends DaggerApplication {
    @Override
    protected AndroidInjector<? extends DaggerApplication> applicationInjector() {
        return DaggerAppComponent.builder().application(this).build();
    }
}

公共类BaseApplication扩展了DaggerApplication{
@凌驾
受保护的AndroidJectorDagger将注入声明的参数类型及其超类型的任何带注释的字段和方法。您也可以在以下网站上阅读有关内容：

成员注入方法
成员注入方法具有单个参数，并将依赖项注入到传递实例的每个注入注释字段和方法中

[……]

关于协方差的注记
虽然类型的成员注入方法将接受其子类型的实例，但只注入参数类型及其超类型的带注释的成员

因此，如果您有一个
SubActivity
，那么将方法声明为
inject（activity:BaseActivity）
将只注入
BaseActivity
和任何超类型的字段，而
inject（activity:SubActivity）
将注入
SubActivity
以及任何父/超类型（
BaseActivity
在本例中，是您观察到的行为）.
它之所以有效，是因为
AppComponent
是
@Singleton
，而
SessionManager
也是
@Singleton
，因此Dagger将
@Singleton
SessionManager

范围内的提供者添加到

AppComponent

，所有

DaggerInjector

生成的子组件都从中继承fr嗯。但是我不确定为什么Androidjector可以自动注入基本字段。谢谢你的评论。我想我明白了这一点，多亏了David。谢谢你的回答。所以它被注入是因为MainActivitySubComponent是AppComponent的一个子组件，这意味着它可以提供来自AppComponent的依赖项，而且因为MainActivity是SubActivit对于BaseActivity，我们将MainActivity及其所有超类型和注入字段（在本例中为

SessionManager

）注入到您已经说过的内容中。@Jarnojr非常感谢您。

public class BaseApplication extends DaggerApplication {
    @Override
    protected AndroidInjector<? extends DaggerApplication> applicationInjector() {
        return DaggerAppComponent.builder().application(this).build();
    }
}