Mvp+clean框架代码

1.首先是UseCase

package com.example.meitu.cleandemo.base;

/**
 * google useCase框架

 */

public abstract class UseCase<T extends UseCase.Request, Q extends UseCase.Respose> {

    /***
     *
     */
    private int mCode;

    /**
     *
     */
    private T mRequest;

    private UseCaseCallback<Q> mUseCaseCallback;

    /**
     * 回调bean的框架
     */
    interface Respose {

    }

    /**
     * 请求参数
     */
    interface Request {

    }

    public void setRequest(T request) {
        this.mRequest = request;
    }

    public void setUseCaseCallback(UseCaseCallback<Q> useCaseCallback) {
        this.mUseCaseCallback = useCaseCallback;
    }

    public T getRequest() {
        return mRequest;
    }

    public UseCaseCallback<Q> getUseCaseCallback() {
        return mUseCaseCallback;
    }

    public void run() {
        excute(this.mRequest);
    }

    protected abstract void excute(T request);

    interface UseCaseCallback<R> {
        void onError(Integer code);

        void onSuccess(R respose);
    }
}

1.这个类主要是数据的执行体，包括回调，请求体还有执行任务等等

1.mCode请求的code

2.Request request 请求体

3.mUseCaseCallBack 请求完成的回调

a.onError(),失败的回调，返回失败的code

b.onSucess.成功的回调，返回Response数据

4.setRequest();设置请求参数

5.setCaseCallBack() 设置回调

6.excute(Request request) 任务执行方法，只要的功能实现，由子类继承重写

 

2.UseCaseSheduler

package com.example.meitu.cleandemo.base;

/**

 */

public interface UseCaseSheduler {
    void excute(Runnable runnable);

    <V extends UseCase.Respose> void notifiedSuccess(V response, UseCase.UseCaseCallback<V> useCaseCallback);

    <V extends UseCase.Respose> void notifiedError(Integer code, UseCase.UseCaseCallback<V> useCaseCallback);
}

任务轮询接口

 

3.UseCaseHandler，这个类设置单利，是任务的管理器，useCase都是通过这个单例去添加的

package com.example.meitu.cleandemo.base;

/**
 * @author zpb
 */

public class UseCaseHandler {

    /**
     * 轮询
     */
    private UseCaseSheduler useCaseSheduler;

    /**
     * 消息分发器，handler和callback相互持有，系统handler和message相互持有
     */
    private static UseCaseHandler instance;

    private UseCaseHandler(UseCaseSheduler useCaseSheduler) {
        this.useCaseSheduler = useCaseSheduler;

    }

    public UseCaseHandler getInstance(UseCaseSheduler sheduler) {
        if (instance == null) {
            instance = new UseCaseHandler(sheduler);
        }
        return instance;
    }

    public <V extends UseCase.Request, Q extends UseCase.Respose> void excute(final UseCase<V, Q> useCase, V values,
        UseCase.UseCaseCallback<Q> useCaseCallback) {
        /**
         * 执行的时候将useCase，依次放入线程池当中进行轮询操作
         */
        useCase.setRequest(values);
        // 每个UseCase都持有当前的Hanlder,每个handler持有当前的useCaseCallback
        useCase.setUseCaseCallback(new UIWrapCallBack<Q>(useCaseCallback, this));

        // 轮询执行useCase的方法体
        useCaseSheduler.excute(new Runnable() {
            @Override
            public void run() {
                // 重写excute方法，在适当时机调用 onError和onSuccess方法
                useCase.run();
                // 调用顺序
                // UseCaseCallBack.ONError -->持有的Handler.onError--->调用 useCaseSheduler.onError(post 到主线中) --->
                // useCallBack.onError
            }
        });

    }

    public <R extends UseCase.Respose> void notifyError(Integer code, UseCase.UseCaseCallback<R> caseCallback) {
        this.useCaseSheduler.notifiedError(code, caseCallback);

    }

    public <R extends UseCase.Respose> void notifySuccess(R response, UseCase.UseCaseCallback<R> caseCallback) {
        this.useCaseSheduler.notifiedSuccess(response, caseCallback);

    };

    public static class UIWrapCallBack<V extends UseCase.Respose> implements UseCase.UseCaseCallback<V> {
        private UseCase.UseCaseCallback<V> userBackCallBack;

        private UseCaseHandler useCaseHandler;

        public UIWrapCallBack(UseCase.UseCaseCallback<V> useCaseCallback, UseCaseHandler useCaseSheduler) {
            this.useCaseHandler = useCaseSheduler;
            this.userBackCallBack = useCaseCallback;

        }

        @Override
        public void onError(Integer code) {
            useCaseHandler.notifyError(code, this.userBackCallBack);

        }

        @Override
        public void onSuccess(V respose) {
            useCaseHandler.notifySuccess(respose, this.userBackCallBack);

        }
    }
}

1.首先 是 UseCaseSheduler useCaseSheduler; 这个是一个自定的线程轮询器，轮询的执行任务，可以是自己制定相应的想成池来执行相应的任务

2.主要的执行方法

 public <V extends UseCase.Request, Q extends UseCase.Respose> void excute(final UseCase<V, Q> useCase, V values,
        UseCase.UseCaseCallback<Q> useCaseCallback) {
        /**
         * 执行的时候将useCase，依次放入线程池当中进行轮询操作
         */
        useCase.setRequest(values);
        // 每个UseCase都持有当前的Hanlder,每个handler持有当前的useCaseCallback
        useCase.setUseCaseCallback(new UIWrapCallBack<Q>(useCaseCallback, this));

        // 轮询执行useCase的方法体
        useCaseSheduler.excute(new Runnable() {
            @Override
            public void run() {
                // 重写excute方法，在适当时机调用 onError和onSuccess方法
                useCase.run();
                // 调用顺序
                // UseCaseCallBack.ONError -->持有的Handler.onError--->调用 useCaseSheduler.onError(post 到主线中) --->
                // useCallBack.onError
            }
        });

    }

客户端，传入相应的一个自定义的UseCase,实现对应的excute方法，传入request参数，和callBack参数，在线程池中，加入新的任务，等待线程池的轮询执行

3.首先我们看下UIWrapCallBack这是一个装饰类，主要是将回调post到Ui线程中

1.首先假如我们在 自定义UseCase中调用onError,那么会调用UICallBack的OnError回调

  public static class UIWrapCallBack<V extends UseCase.Respose> implements UseCase.UseCaseCallback<V> {
        private UseCase.UseCaseCallback<V> userBackCallBack;

        private UseCaseHandler useCaseHandler;

        public UIWrapCallBack(UseCase.UseCaseCallback<V> useCaseCallback, UseCaseHandler useCaseSheduler) {
            this.useCaseHandler = useCaseSheduler;
            this.userBackCallBack = useCaseCallback;

        }

        @Override
        public void onError(Integer code) {
            useCaseHandler.notifyError(code, this.userBackCallBack);

        }

        @Override
        public void onSuccess(V respose) {
            useCaseHandler.notifySuccess(respose, this.userBackCallBack);

        }
    }

而UIwrapCallBack会通过 当前的Handler去通知轮询管理器，将回调的内容post到主线程当中去，执行，这样就通过一层包装将callBack传递到Ui线程中

主要流程如下：

// UIWrapperCallBack.ONError -->持有的Handler.onError--->调用 useCaseSheduler.onError(post 到主线中) --->
// useCallBack.onError(在主线程成中执行回调) 当然我们可以进行各种不同模式的回调封装。

 

以上就是Mvp+clean中useCase的大概使用架构，自己总结。