分层
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);
}
}
