MVP-Clean架构分析

分层

image.png
image.png

• Enterprise Business Rules：业务对象（实体）
• Application Business Rules：用于处理我们的业务对象，业务逻辑所在，也称为Interactor或者UseCase
• Interface Adapters： 接口转换，拿到我们需要的数据，视图层（View）、表现层（Presenters）和控制层（Controllers）就在这一层
• Frameworks and Drivers: 这里是所有具体的实现了：比如：数据库，网络，工具类，基础框架等等。

准则

• 框架独立：架构不依赖于一些满载功能的软件库。这可以让你像使用工具一样使用这样的框架，而不是把系统塞到他们有限的约束之中。
• 可测试性：业务规则可以在没有UI，数据库，Web服务器，或者其他外部元素的情况下完成测试。
• UI独立：在不改变系统其余部分的情况下完成UI的简易修改。如，Web UI可以在不改变业务规则的基础之上替换成控制台UI。
• 数据库独立：业务规则不绑定的数据库中，这样你可以更换Oracle or SQL Server, for Mongo, BigTable, CouchDB，或者其他数据库。
• 外部机制独立：事实上业务规则根本不知道外层的事情。
• 依赖准则：同心圆代表着软件的不同领域。一般来讲，越往里层，软件的级别就会越高。外环是机制，里环是策略（外环依赖里环）。

官方示例解析

image.png
仓库地址

Entities

实体就是应用的业务对象。它们封装着最普通的高级别业务规则，你不能希望这些实体对象被一个页面的分页导航功能改变，也不能被安全机制改变。操作实现层面的任何改变不能影响实体层，只有业务需求改变了才可以改变实体。

UseCases

在这个层的软件包含应用指定的业务规则，它封装和实现系统的所有用例，这些用例会混合各种来自实体的各种数据流程，并且指导这些实体使用企业规则来完成用例的功能目标。我们并不期望改变这层会影响实体层，我们也不期望这层被更外部如数据库、UI、普通框架影响，这层也是因为关注而外部分离的。我们期望应用层面的技术操作都不能影响用例层，如果需求中用例发生改变，这个层的代码才会发生改变。

public abstract class UseCase<Q extends UseCase.RequestValues, P extends UseCase.ResponseValue> {
    private Q mRequestValues;
    private UseCaseCallback<P> mUseCaseCallback;

    public void setRequestValues(Q requestValues) {
        mRequestValues = requestValues;
    }
    public Q getRequestValues() {
        return mRequestValues;
    }

    public UseCaseCallback<P> getUseCaseCallback() {
        return mUseCaseCallback;
    }
    public void setUseCaseCallback(UseCaseCallback<P> useCaseCallback) {
        mUseCaseCallback = useCaseCallback;
    }

    void run() {
       executeUseCase(mRequestValues);
    }
    protected abstract void executeUseCase(Q requestValues);
    
    //发起请求的数据
    public interface RequestValues {}
    //收到响应的数据
    public interface ResponseValue { }
    //回调接口
    public interface UseCaseCallback<R> {
        void onSuccess(R response);
        void onError();
    }
}

UserCaseHander：用例执行器，只是对用例的执行做了封装，并不属于架构的核心

public class UseCaseHandler {
    private static UseCaseHandler INSTANCE;
    private final UseCaseScheduler mUseCaseScheduler;
    public UseCaseHandler(UseCaseScheduler useCaseScheduler) {
        mUseCaseScheduler = useCaseScheduler;
    }
    
    //执行具体的业务事件
    public <T extends UseCase.RequestValues, R extends UseCase.ResponseValue> void execute(
            final UseCase<T, R> useCase, T values, UseCase.UseCaseCallback<R> callback) {
        useCase.setRequestValues(values);
        useCase.setUseCaseCallback(new UiCallbackWrapper(callback, this));
        EspressoIdlingResource.increment(); 
        mUseCaseScheduler.execute(new Runnable() {
            @Override
            public void run() {
                useCase.run();
                if (!EspressoIdlingResource.getIdlingResource().isIdleNow()) {
                    EspressoIdlingResource.decrement(); // Set app as idle.
                }
            }
        });
    }

    public <V extends UseCase.ResponseValue> void notifyResponse(final V response,
            final UseCase.UseCaseCallback<V> useCaseCallback) {
        mUseCaseScheduler.notifyResponse(response, useCaseCallback);
    }

    private <V extends UseCase.ResponseValue> void notifyError(
            final UseCase.UseCaseCallback<V> useCaseCallback) {
        mUseCaseScheduler.onError(useCaseCallback);
    }
    
    //具体业务事件的回调，是否切换线程取决于该具体业务的需求
    private static final class UiCallbackWrapper<V extends UseCase.ResponseValue> implements
            UseCase.UseCaseCallback<V> {
        private final UseCase.UseCaseCallback<V> mCallback;
        private final UseCaseHandler mUseCaseHandler;

        public UiCallbackWrapper(UseCase.UseCaseCallback<V> callback,
                UseCaseHandler useCaseHandler) {
            mCallback = callback;
            mUseCaseHandler = useCaseHandler;
        }

        @Override
        public void onSuccess(V response) {
            mUseCaseHandler.notifyResponse(response, mCallback);
        }

        @Override
        public void onError() {
            mUseCaseHandler.notifyError(mCallback);
        }
    }
}

UseCases实现类：具体的用例，这里用获取所有Todo事件作为一个用例

public class GetTasks extends UseCase<GetTasks.RequestValues, GetTasks.ResponseValue> {
    //任务仓库：
    private final TasksRepository mTasksRepository;
    private final FilterFactory mFilterFactory;

    public GetTasks(@NonNull TasksRepository tasksRepository, @NonNull FilterFactory filterFactory) {
        mTasksRepository = checkNotNull(tasksRepository, "tasksRepository cannot be null!");
        mFilterFactory = checkNotNull(filterFactory, "filterFactory cannot be null!");
    }
    
    //执行业务
    @Override
    protected void executeUseCase(final RequestValues values) {
        if (values.isForceUpdate()) {
            mTasksRepository.refreshTasks();
        }

        mTasksRepository.getTasks(new TasksDataSource.LoadTasksCallback() {
            @Override
            public void onTasksLoaded(List<Task> tasks) {
                //获取到数据
                TasksFilterType currentFiltering = values.getCurrentFiltering();
                TaskFilter taskFilter = mFilterFactory.create(currentFiltering);
                List<Task> tasksFiltered = taskFilter.filter(tasks);
                ResponseValue responseValue = new ResponseValue(tasksFiltered);
                getUseCaseCallback().onSuccess(responseValue);
            }

            @Override
            public void onDataNotAvailable() {
                //没有获取到数据
                getUseCaseCallback().onError();
            }
        });
    }
    
    //请求的数据
    public static final class RequestValues implements UseCase.RequestValues {
        private final TasksFilterType mCurrentFiltering;
        private final boolean mForceUpdate;

        public RequestValues(boolean forceUpdate, @NonNull TasksFilterType currentFiltering) {
            mForceUpdate = forceUpdate;
            mCurrentFiltering = checkNotNull(currentFiltering, "currentFiltering cannot be null!");
        }

        public boolean isForceUpdate() {
            return mForceUpdate;
        }

        public TasksFilterType getCurrentFiltering() {
            return mCurrentFiltering;
        }
    }
    
    //响应的数据
    public static final class ResponseValue implements UseCase.ResponseValue {
        private final List<Task> mTasks;

        public ResponseValue(@NonNull List<Task> tasks) {
            mTasks = checkNotNull(tasks, "tasks cannot be null!");
        }

        public List<Task> getTasks() {
            return mTasks;
        }
    }
}

V-P 接口

public interface TasksContract {
    interface View extends BaseView<Presenter> {
        void showTasks(List<Task> tasks);
    }

    interface Presenter extends BasePresenter {
        void loadTasks(boolean forceUpdate);
    }
}

Presenter

public class TasksPresenter implements TasksContract.Presenter {
    private final TasksContract.View mTasksView;
    private final GetTasks mGetTasks;
    private final UseCaseHandler mUseCaseHandler; 

    public TasksPresenter(@NonNull UseCaseHandler useCaseHandler,@NonNull TasksContract.View tasksView, @NonNull GetTasks getTasks) {
        mUseCaseHandler = checkNotNull(useCaseHandler, "usecaseHandler cannot be null");
        mTasksView = checkNotNull(tasksView, "tasksView cannot be null!");
        mGetTasks = checkNotNull(getTasks, "getTask cannot be null!");

        mTasksView.setPresenter(this);
    }
    
    public void loadTasks(boolean forceUpdate) {
        //请求的数据
        GetTasks.RequestValues requestValue = new GetTasks.RequestValues(forceUpdate,mCurrentFiltering);
        mUseCaseHandler.execute(mGetTasks, requestValue,
                new UseCase.UseCaseCallback<GetTasks.ResponseValue>() {
                    @Override
                    public void onSuccess(GetTasks.ResponseValue response) {
                        List<Task> tasks = response.getTasks();
                        if (mTasksView.isActive()) {
                           mTasksView.showTasks(tasks);
                        }  
                    }

                    @Override
                    public void onError() {
                        if (mTasksView.isActive()) {
                            mTasksView.showLoadingTasksError();
                        }
                    }
                });
    }
}

View

public class TasksFragment extends Fragment implements TasksContract.View {
    @Override
    public void showTasks(List<Task> tasks) {
        mListAdapter.replaceData(tasks);
        mTasksView.setVisibility(View.VISIBLE);
        mNoTasksView.setVisibility(View.GONE);
    }
}

DataSource

//数据操作的抽象接口
public interface TasksDataSource {
    void getTasks(@NonNull LoadTasksCallback callback);
}

//数据源集合
public class TasksRepository implements TasksDataSource {
    private final TasksDataSource mTasksRemoteDataSource;
    private final TasksDataSource mTasksLocalDataSource;
    //获取所有Todo事件
    @Override
    public void getTasks(@NonNull final LoadTasksCallback callback) {
        if (mCachedTasks != null && !mCacheIsDirty) {
            callback.onTasksLoaded(new ArrayList<>(mCachedTasks.values()));
            return;
        }

        if (mCacheIsDirty) {
            getTasksFromRemoteDataSource(callback);
        } else {
            mTasksLocalDataSource.getTasks(new LoadTasksCallback() {
                @Override
                public void onTasksLoaded(List<Task> tasks) {
                    refreshCache(tasks);
                    callback.onTasksLoaded(new ArrayList<>(mCachedTasks.values()));
                }

                @Override
                public void onDataNotAvailable() {
                    getTasksFromRemoteDataSource(callback);
                }
            });
        }
    }
}

//本地数据源
public class TasksLocalDataSource implements TasksDataSource {
    @Override
    public void getTasks(@NonNull final LoadTasksCallback callback) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                final List<Task> tasks = mTasksDao.getTasks();
                mAppExecutors.mainThread().execute(new Runnable() {
                    @Override
                    public void run() {
                        if (tasks.isEmpty()) {
                            callback.onDataNotAvailable();
                        } else {
                            callback.onTasksLoaded(tasks);
                        }
                    }
                });
            }
        };
        
        //执行在该任务指定的线程池
        mAppExecutors.diskIO().execute(runnable);
    }
}