Dagger 2 - 构造函数注入 - 非活动

Question

刚开始学习 Dagger 2 是为了解决一个特定问题：我正在尝试遵循 MVVM 架构，而我的应用程序有一个存储库类，该存储库类可以将设置提取并保存在基本上包装 SharedPreferences 的 CacheData 类中。但是，SharedPreferences 具有上下文依赖性。由于我完成了将存储库和数据层与 View 和 Application 类分离的所有工作，因此传递上下文似乎是倒退了一步。

这里是存储库类

public class ImgurRepository {
    private ImgurDatabase imgurDatabase;
    private ImgurGalleryDao galleryDao;

    private CompositeDisposable disposables;
    private LiveData<List<ImgurGallery>> imgurGalleries;



    public ImgurRepository(){
        this.imgurDatabase = ImgurDatabase.getInstance(MyRxApplication.getAppContext());
        this.galleryDao = imgurDatabase.getGalleryDao();
        disposables = new CompositeDisposable();
    }

    public String getCachedSearchTerm() {
        CachedData cachedData = new CachedData();
        return cachedData.getCachedSearchTerm();
    }

    public String getCachedSearchWindow(){
        CachedData cachedData = new CachedData();
        return cachedData.getCachedSearchWindow();
    }
    public String getCachedSearchType(){
        CachedData cachedData = new CachedData();
        return cachedData.getCachedSearchType();
    }

    public void setCachedSearchParams(@NonNull final String term,
                                    @NonNull final String type,
                                    @NonNull final String window) {
        CachedData cachedData = new CachedData();
        cachedData.setCachedSearchParams(term, type, window);
    }

    public LiveData<List<ImgurGallery>> getCachedGalleries() {
        return this.imgurGalleries;
    }

    public LiveData<List<ImgurGallery>> fetchGalleries(@NonNull final String searchType,
                                                              @NonNull final String searchWindow,
                                                              @NonNull final String searchTerm,
                                                              final int resultsPage){
        requestGalleries(searchType, searchWindow, searchTerm, resultsPage);
        return galleryDao.getAll();
    }

    private void requestGalleries(@NonNull final String searchType,
                               @NonNull final String searchWindow,
                               @NonNull final String searchTerm,
                               final int resultsPage) {
        Timber.d("Running fetchGalleries with arguments:\nsort='%s' \nwindow='%s'\nsearch='%s'\npage='%s'",
                searchType,
                searchWindow,
                searchTerm,
                resultsPage);
        ServiceGenerator.changeApiBaseUrl(IMGUR_API_BASE_URL);
        ImgurService service = ServiceGenerator.createService(ImgurService.class);
        Timber.d("finishing fetchGalleries request.");
        disposables.add(service.getSearchGallery(searchType,searchWindow,resultsPage,searchTerm)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Response<ImgurGalleryList>>() {
                    @Override
                    public void accept(@NonNull final Response<ImgurGalleryList> response) throws Exception {
                        Timber.d("Consumer is subscribed to imgurGalleryObservable.");
                        Timber.d(response.body().toString());
                        List<ImgurGallery> galleries = response.body().getData();
                        galleryDao.insertAll(galleries);
                    }

                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Timber.e(throwable);
                    }
                }));
    }

    public void clearGalleries() {
        galleryDao.deleteAll();
    }

}

这是每个 Samuel 的 cmets 固定 CachedData 类：

public class CachedData {
    private final String CACHED_SEARCH_TERM_KEY = "cached_search_term";
    private final String CACHED_SEARCH_WINDOW_KEY = "cached_search_window";
    private final String CACHED_SEARCH_TYPE_KEY = "cached_search_type";

    @Inject public SharedPreferences sharedPrefs;
    @Inject public Context context;

    public CachedData() {}

    public String getCachedSearchTerm() {
        return sharedPrefs.getString(CACHED_SEARCH_TERM_KEY, "");
    }
    public String getCachedSearchWindow(){
        return sharedPrefs.getString(CACHED_SEARCH_WINDOW_KEY, "");
    }
    public String getCachedSearchType(){
        return sharedPrefs.getString(CACHED_SEARCH_TYPE_KEY, "");
    }

    public void setCachedSearchParams(@Nullable final String term,
                                        @Nullable final String window,
                                        @Nullable final String type) {
        SharedPreferences.Editor editor = sharedPrefs.edit();
        if (term != null) editor.putString((CACHED_SEARCH_TERM_KEY), term);
        if (window  != null) editor.putString(CACHED_SEARCH_WINDOW_KEY, window);
        if (type != null) editor.putString(CACHED_SEARCH_TYPE_KEY, type);
        editor.apply();

    }

}

固定 AppComponent 类：

@Singleton
@Component(modules = AppModule.class)
public interface AppComponent {

    void inject(MyRxApplication app);
    void inject(CachedData cachedData);
    void inject(BaseActivity activity);
}

AppModule 类：

@Module
public class AppModule {
    private final String SHARED_PREFERENCE_KEY = "PREFERENCE_FILE_KEY";
    private final MyRxApplication application;

    public AppModule(MyRxApplication application) {
        this.application = application;
    }

    @Provides
    @Singleton
    public Context provideApplicationContext(){
        return application;
    }

    @Provides
    @Singleton
    public SharedPreferences provideSharedPreferences() {
        return application
                .getSharedPreferences(
                        SHARED_PREFERENCE_KEY,
                        Context.MODE_PRIVATE);
    }
}

应用类：

public class MyRxApplication extends Application {
    private static Context context;
    private AppComponent appComponent;

    public MyRxApplication() {
    }

    @Override
    public void onCreate() {
        super.onCreate();
        MyRxApplication.context = getApplicationContext();
        if (LeakCanary.isInAnalyzerProcess(this)) {
            // This process is dedicated to LeakCanary for heap analysis.
            // You should not init your app in this process.
            return;
        }
        LeakCanary.install(this);

        Stetho.initializeWithDefaults(this);

        if (BuildConfig.DEBUG) {
            Timber.plant(new Timber.DebugTree());
        }

        appComponent = buildComponent();
        appComponent.inject(this);
        appComponent.cachedData();

    }

    public AppComponent buildComponent(){
        return DaggerAppComponent
                .builder()
                .appModule(new AppModule(this))
                .build();
    }

    public AppComponent getAppComponent() {
        return appComponent;
    }

    public static Context getAppContext() {
        return MyRxApplication.context;
    }

}

是否可以使用 Dagger 将 SharedPreferences 对象注入到 CachedData 构造函数中？我正在构造许多 CachedData 对象，因为我最初不想使用单例，但是将 CachedData 对象作为单例注入是否有意义？我真的不确定现在使用 Dagger 并让它工作的正确方法，因为我在 CacheData 构造函数中设置的每个参数都需要在我创建它时提供，即使我认为我正在使用 Dagger 来做到这一点...... ?

Answer 1

嗯，据我所知，您的附加评论是，您不想为您的课程使用注入 CachedData，因此想手动实例化它。如果是这种情况，您可以像这样删除注入的构造函数参数并直接注入变量：

@Inject
SharedPreferences sharedPrefs;
@Inject
Context context;

@Inject
public CachedData() {}