关于Dragger2与RXjava集合框架的项目随笔

(1)从usecase中 注意 buildUseCaseObservable方法，绑定观察者监听，以下是删除活动的Dragger2注入代码(注意activity是指活动)

@Provides
@PerActivity
@Named("deleteActivity")
DeleteActivityUseCase provideDeleteActivityUseCase(FamilyRepository activityRepository,
                                             ThreadExecutor threadExecutor,
                                             PostExecutionThread postExecutionThread){
    return new DeleteActivityUseCase(activityRepository, threadExecutor, postExecutionThread);
}

以下是DeleteActivityUseCase代码

DeleteActivityUseCase

public class DeleteActivityUseCase extends UseCase{

    private final FamilyRepository activityRepository;
    private Activity activity;
    private Long valueType;

    @Inject
    public DeleteActivityUseCase(FamilyRepository mActivityRepository,
                                 ThreadExecutor threadExecutor,
                                 PostExecutionThread postExecutionThread){
        super(threadExecutor, postExecutionThread);
        this.activityRepository = mActivityRepository;
    }

    public  void setActivityId(Activity activity){
        this.activity = activity;
    }

    public void setValueType(Long valueType) { this.valueType = valueType; }

    @Override
    protected Observable<Activity> buildUseCaseObservable() {
        return activityRepository.deleteActivity(activity , valueType);
    }
}

(2)在对应的Repository中，有相应的接口，Repository的监听实例，初始化是通过Dragger2实现的 , 具体参看以下实例 

@Named("quitActivity") QuitActivityUseCase mQuitActivityUseCase,这是根据Dragger2规则实现的，熟悉注入规则，@Named目前在这非必须

(3)在presenter处理层，我们将usecase实例化出来之后，通过this.QuitActivityCase.execute(new DefaultSubscriber<Activity>(){})方法进行监听绑定，相当于开始了相应的逻辑处理。(实例化

的都是usecase的子类，继承了excuse方法)

(4)注意application中的单例方法，同样依赖于Dragger2注入框架构造，讲解例如：

FamilyRepository这个Dragger2接口类，在通过框架注入后，被实例化为FamilyDataRepository。实例过程如下：

在ApplicationModule中有这样一段代码

@Provides @Singleton

    FamilyRepository provideFamilyRepository(FamilyDataRepository familyDataRepository){

        return familyDataRepository;

    }

这一段代码将Repository注入实例，进行异步处理操作。

(5)往下，比如我要进行活动删除操作，那么在实例化的data类中，需要提供删除操作的实现逻辑，如下：

public Observable<Activity> deleteActivity(Activity activity, long typeValue) {

        return activityDataStoreFactory.createApiSource().deleteActivity(activity, typeValue)

                .doOnNext(activity1 -> {

                    activityDataStoreFactory.createDatabaseSource().deleteActivity(activity1, typeValue).subscribe();

                });

    }

这里用到了RXJAVA的框架基础。进行异步监听，关于RXJAVA是另一套框架逻辑。

(6)这里的activityDataStoreFactory.createApiSource().deleteActivity(activity, typeValue)就是进行网络传输的请求,

这里RXJAVA的简便性就体现出来了，下一步操作是在随后进行处理。

这里的activityDataStoreFactory.createDatabaseSource().deleteActivity(activity1, typeValue)进行数据库的操作请求。

(7)至此所有的异步请求大功告成，那么在哪边进行所谓的回调处理呢。

这里涉及到RXJAVA的框架逻辑。依然是在这一套逻辑中，我们看到这么一段代码，以下：

/**

     * 删除当前活动

     */

    public void deleteCurrentActivity(Activity activity , Long typeValue){

        this.DeleteActivityCase.setActivityId(activity);

        this.DeleteActivityCase.setValueType(typeValue);

        this.DeleteActivityCase.execute(new DefaultSubscriber<Activity>(){

            @Override

            public void onNext(Activity activity) {

                //此处为删除后的操作

                view.renderActivityDeleteDone(activity);

            }

            @Override

            public void onError(Throwable e) {

                //错误处理逻辑

                showErrorMessage(new DefaultErrorHandler((Exception) e));

            }

        });

    }

这一段代码中有一个onNext和onError继承。

(8)onNext涉及到RXJAVA的框架逻辑：

在onNext中，是观察者对于监听结果的反馈操作，这里采用了重新绘制activity活动的操作，根据相应的activity操作结果。

onError为错误处理的逻辑。