日韩欧美深夜在线,久久精品人妻成人久久

首先講解什么叫做Clean架構(gòu)。既是在Clean架構(gòu)中，代碼被分層成洋蔥形，層層包裹，其中有一個(gè)依賴性規(guī)則：內(nèi)層不能依賴外層，即內(nèi)層不知道有關(guān)外層的任何事情，所以這個(gè)架構(gòu)是向內(nèi)依賴的。

說(shuō)白了，就是最里面的根本不知道外面發(fā)生了什么

并且外面的只能調(diào)用比他里面的一層

Bob大叔的Clean架構(gòu)

為什么大家都想改成Clean模式，因?yàn)槠渥裱鴳?yīng)用的最基本的法則

1. 易維護(hù)
2. 易測(cè)試
3. 高聚合
4. 低耦合

一般Clean模式分為三層

Data Layer  數(shù)據(jù)層
Domain Layer 領(lǐng)域?qū)?
Presentation Layer 表現(xiàn)層

這里參考下Google的Clean圖

Google的Clean架構(gòu)

解釋下各個(gè)層什么意思

Data Layer 數(shù)據(jù)層：

1、從網(wǎng)絡(luò)獲取數(shù)據(jù)，向網(wǎng)絡(luò)提交數(shù)據(jù)，總之就是和網(wǎng)絡(luò)打交道。
2、從本地DB，shareprefence等等，內(nèi)存等，總之就是本地獲取數(shù)據(jù)，緩存數(shù)據(jù)，總之就是和本地?cái)?shù)據(jù)打交道的
反正就是對(duì)數(shù)據(jù)的獲取
--這里他不知道有Android系統(tǒng)的存在

Domain Layer 領(lǐng)域?qū)?/h5>

對(duì)DataLayer對(duì)數(shù)據(jù)做處理，僅此而已。
--這里他不知道有Android系統(tǒng)的存在，他只知道依靠Data Layer

Presentation Layer 表現(xiàn)層

根據(jù)Domain Layer的數(shù)據(jù)進(jìn)行界面顯示，此處注意：它只知道Domain Layer,什么Data Layer他根本不知道他是誰(shuí)
--此處有Android系統(tǒng)的存在

OK,這里我們看下比較出名的Clean架構(gòu)的Demo android10/Android-CleanArchitecture

用到了rxjava + okhttp + dagger的代碼構(gòu)造

代碼結(jié)構(gòu)圖

從上面可以看出，他按照上述說(shuō)的 dataLayer->domainLayer->PresentationLayer進(jìn)行劃分

這里有個(gè)疑問(wèn)？？？

看到這份代碼使用的姿勢(shì)感覺(jué)跟我剛才說(shuō)的不一樣啊，Presentation居然調(diào)用data domain.而不是調(diào)用domain
data居然依賴于domain,domain 沒(méi)有直接使用data
或許這還不是最規(guī)范的Clean模式吧

但是這個(gè)Demo向我們展示了一個(gè)Clean的架構(gòu)

此處需要了解domain中UseCase的使用姿勢(shì)，好多框架參考這種寫(xiě)法
直接貼代碼

UseCase使用rxjava方式進(jìn)行事件訂閱

public abstract class UseCase<T, Params> {

  /**
   * 工作的線程
   */
  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<T> 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<T> observer, Params params) {
    Preconditions.checkNotNull(observer);
    final Observable<T> 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實(shí)現(xiàn)指定的UseCase實(shí)現(xiàn)

public class GetUserDetails extends UseCase<User, GetUserDetails.Params> {

  private final UserRepository userRepository;

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

  @Override Observable<User> 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<List<User>> users();

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