首先讲解什么叫做Clean架构。既是在Clean架构中，代码被分层成洋葱形，层层包裹，其中有一个依赖性规则：内层不能依赖外层，即内层不知道有关外层的任何事情，所以这个架构是向内依赖的。
说白了，就是最里面的根本不知道外面发生了什么
并且外面的只能调用比他里面的一层
为什么大家都想改成Clean模式，因为其遵循着应用的最基本的法则
1. 易维护
2. 易测试
3. 高聚合
4. 低耦合
一般Clean模式分为三层
Data Layer 数据层
Domain Layer 领域层
Presentation Layer 表现层
这里参考下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<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实现指定的UseCase实现
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);
}
其实这里data模块使用rxjava+okhttp实现了网络请求，其实就是retrofit形式的网络请求
现在的网络架构大抵都是
rxjava + retrofit + clean架构
如有兴趣，可以依照上面的构造写一个自己的网络库
PS：公司的项目是这样，所以研究下Clean架构
参考资料
The clean architecture by Uncle Bob
Github上关于Clean的项目
android10/Android-CleanArchitecture
