[Android从头开始] 初识Clean Architecture

首先讲解什么叫做Clean架构。既是在Clean架构中，代码被分层成洋葱形，层层包裹，其中有一个依赖性规则：内层不能依赖外层，即内层不知道有关外层的任何事情，所以这个架构是向内依赖的。

说白了，就是最里面的根本不知道外面发生了什么

并且外面的只能调用比他里面的一层

Bob大叔的Clean架构

为什么大家都想改成Clean模式，因为其遵循着应用的最基本的法则

1. 易维护
2. 易测试
3. 高聚合
4. 低耦合

一般Clean模式分为三层

Data Layer  数据层
Domain Layer 领域层 
Presentation Layer 表现层

这里参考下Google的Clean图

Google的Clean架构

解释下各个层什么意思

Data Layer 数据层：

1、从网络获取数据，向网络提交数据，总之就是和网络打交道。
2、从本地DB，shareprefence等等，内存等，总之就是本地获取数据，缓存数据，总之就是和本地数据打交道的
反正就是对数据的获取
--这里他不知道有Android系统的存在

Domain Layer 领域层

对DataLayer对数据做处理，仅此而已。
--这里他不知道有Android系统的存在，他只知道依靠Data Layer

Presentation Layer 表现层

根据Domain Layer的数据进行界面显示，此处注意：它只知道Domain Layer,什么Data Layer他根本不知道他是谁
--此处有Android系统的存在

---

OK,这里我们看下比较出名的Clean架构的Demo android10/Android-CleanArchitecture

用到了rxjava + okhttp + dagger的代码构造

代码结构图

从上面可以看出，他按照上述说的 dataLayer->domainLayer->PresentationLayer进行划分

这里有个疑问？？？

看到这份代码使用的姿势感觉跟我刚才说的不一样啊，Presentation居然调用data domain.而不是调用domain
data居然依赖于domain,domain 没有直接使用data
或许这还不是最规范的Clean模式吧

但是这个Demo向我们展示了一个Clean的架构

此处需要了解domain中UseCase的使用姿势，好多框架参考这种写法
直接贴代码

UseCase使用rxjava方式进行事件订阅

public abstract class UseCase {

  /**
   * 工作的线程
   */
  private final ThreadExecutor threadExecutor;
  /**
   * 展示的线程
   */
  private final PostExecutionThread postExecutionThread;
  /**
   * 管理observer的集合
   */
  private final CompositeDisposable disposables;

  UseCase(ThreadExecutor threadExecutor, PostExecutionThread postExecutionThread) {
    this.threadExecutor = threadExecutor;
    this.postExecutionThread = postExecutionThread;
    this.disposables = new CompositeDisposable();
  }

  /**
   * Builds an {@link Observable} which will be used when executing the current {@link UseCase}.
   */
  abstract Observable buildUseCaseObservable(Params params);

  /**
   * Executes the current use case.
   *
   * @param observer {@link DisposableObserver} which will be listening to the observable build
   * by {@link #buildUseCaseObservable(Params)} ()} method.
   * @param params Parameters (Optional) used to build/execute this use case.
   */
  public void execute(DisposableObserver observer, Params params) {
    Preconditions.checkNotNull(observer);
    final Observable observable = this.buildUseCaseObservable(params)
            // 工作的线程
        .subscribeOn(Schedulers.from(threadExecutor))
            // 展示的线程
        .observeOn(postExecutionThread.getScheduler());
    addDisposable(observable.subscribeWith(observer));
  }

  /**
   * Dispose from current {@link CompositeDisposable}.
   */
  public void dispose() {
    if (!disposables.isDisposed()) {
      disposables.dispose();
    }
  }

  /**
   * Dispose from current {@link CompositeDisposable}.
   */
  private void addDisposable(Disposable disposable) {
    Preconditions.checkNotNull(disposable);
    Preconditions.checkNotNull(disposables);
    disposables.add(disposable);
  }
}

继承UseCase实现指定的UseCase实现

public class GetUserDetails extends UseCase {

  private final UserRepository userRepository;

  @Inject
  GetUserDetails(UserRepository userRepository, ThreadExecutor threadExecutor,
      PostExecutionThread postExecutionThread) {
    super(threadExecutor, postExecutionThread);
    this.userRepository = userRepository;
  }

  @Override Observable buildUseCaseObservable(Params params) {
    Preconditions.checkNotNull(params);
    return this.userRepository.user(params.userId);
  }

  public static final class Params {

    private final int userId;

    private Params(int userId) {
      this.userId = userId;
    }

    public static Params forUser(int userId) {
      return new Params(userId);
    }
  }
}

/**
 * Interface that represents a Repository for getting {@link User} related data.
 */
public interface UserRepository {
  /**
   * Get an {@link Observable} which will emit a List of {@link User}.
   */
  Observable> users();

  /**
   * Get an {@link Observable} which will emit a {@link User}.
   *
   * @param userId The user id used to retrieve user data.
   */
  Observable user(final int userId);
}

其实这里data模块使用rxjava+okhttp实现了网络请求，其实就是retrofit形式的网络请求

现在的网络架构大抵都是
rxjava + retrofit + clean架构

如有兴趣，可以依照上面的构造写一个自己的网络库

PS：公司的项目是这样，所以研究下Clean架构

参考资料

The clean architecture by Uncle Bob

使用Clean架构开发Android应用详细指南

一种更清晰的Android架构

学习 CleanArchitecture 心得体会

Github上关于Clean的项目

android10/Android-CleanArchitecture

googlesamples/android-architecture

dmilicic/Android-Clean-Boilerplate