前言

上一篇文章简单的说了RxJava，Retrofit，MVP的简单用法，这篇我们继续上一篇结尾时说的几个需要优化的地方（封装），先回顾下之前说的几个需要优化地方：

• 每次请求都写一串代码创建Retrofit
• 每次订阅Observable时都有一大串重写的方法，然而我们只关心请求成功与否和请求成功后返回的数据
• 每次都需要设置Obserable和Observer在哪个线程里工作
• 如果请求未完成但是界面却退出了就会存在内存泄漏的风险
• 每次请求添加公共参数（例如设备号，版本信息等等）

先来看下全部封装完的项目结构：

package.png

• base:放一些基类，例如：BaseView，BaseModel，BaseObserver等等。
• bean:放实体类。
• callback:回调接口。
• model:M层。
• presenter:P层。
• ui:放置Activity,Fragment等UI界面。
• view:V层接口。

下面开始一步步进行封装：

Retrofit2封装

创建RetrofitHelper类，主要用于对Retrofit进行初始化，以及每次实例化时都需要写一串配置信息，以及每次请求时的公共参数添加

下面直接贴上代码，都写上了注释：

public class RetrofitHelper {

    private static OkHttpClient mOkHttpClient;

    private RetrofitHelper() {
        throw new UnsupportedOperationException("u can't init me");
    }

    static {
        initOkHttpClient();
    }

    //创建一个请求
    public static Api getBoobApi() {
        return createApi(Api.class, "https://api.douban.com/");
    }


    /**
     * 根据传入的baseUrl，和api创建retrofit
     */
    private static <T> T createApi(Class<T> clazz, String baseUrl) {
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(baseUrl) //这个一般是接口地址（一定要以/结尾）
                .client(mOkHttpClient)
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) //集成rxjava
                .addConverterFactory(GsonConverterFactory.create()) //gson解析
                .build();
        return retrofit.create(clazz);
    }


    /**
     * 初始化OKHttpClient,设置超时时间,设置打印日志,设置Request拦截器
     */
    private static void initOkHttpClient() {
        //打印所有okhttp请求日志
        HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
        interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
        if (mOkHttpClient == null) {
            synchronized (RetrofitHelper.class) {
                if (mOkHttpClient == null) {
                    mOkHttpClient = new OkHttpClient.Builder()
                            .addInterceptor(interceptor)//添加网络log拦截器
                            .addInterceptor(new RequestInterceptor())//添加网络请求拦截器
                            .retryOnConnectionFailure(true) //当失败时重复请求
                            .connectTimeout(30, TimeUnit.SECONDS)//连接超时时间
                            .writeTimeout(20, TimeUnit.SECONDS)
                            .readTimeout(20, TimeUnit.SECONDS)
                            .build();
                }
            }
        }
    }

    private static class RequestInterceptor implements Interceptor {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            if (request.method().equals("POST")) {
                //这里分两种post提交方式
                // FormBoy:以表单方式提交  MultipartBody:是有多个参数(其中包括文件)
                if (request.body() instanceof FormBody) {
                    request = addPostFormParams(request);
                } else if (request.body() instanceof MultipartBody) {
                    request = addPostMultiParams(request);
                }
            } else if (request.method().equals("GET")) {
                request = addGetParams(chain);
            }
            return chain.proceed(request);
        }
    }

    //post附带图片时
    private static Request addPostMultiParams(Request request) {
        // 添加公共参数
        MultipartBody.Builder builder = new MultipartBody.Builder().addFormDataPart("deviceId", "123456");
        MultipartBody oldBody = (MultipartBody) request.body();
        for (int i = 0; i < oldBody.size(); i++) {
            builder.addPart(oldBody.part(i));
        }
        oldBody = builder.build();
        request = request.newBuilder().post(oldBody).build();
        return request;
    }

    //post参数时
    private static Request addPostFormParams(Request request) {
        FormBody.Builder bodyBuilder = new FormBody.Builder();
        FormBody formBody = (FormBody) request.body();
        //把原来的参数添加到新的构造器，（因为没找到直接添加，所以就new新的）
        for (int i = 0; i < formBody.size(); i++) {
            bodyBuilder.addEncoded(formBody.encodedName(i), formBody.encodedValue(i));
        }
        //添加公共参数
        formBody = bodyBuilder
                .addEncoded("deviceId", "123456").build();
        request = request.newBuilder().post(formBody).build();
        return request;
    }

    private static Request addGetParams(Interceptor.Chain chain) {
        Request request;
        Request oldRequest = chain.request();
        // 添加公共参数
        HttpUrl authorizedUrlBuilder = oldRequest.url()
                .newBuilder()
                .addQueryParameter("deviceId", "123456").build();
        request = oldRequest.newBuilder()
                .url(authorizedUrlBuilder)
                .build();
        return request;
    }
}

以上便是对Retrofit的封装。

对Observer和实体类封装

创建BaseObserver类，主要是用来对返回的实体类进行处理。
创建BaseBaseResult类，对返回的数据处理（这里的处理是对一些返回的公共部分做一个提取，下面会有图片说明）

以此Demo为例，请求https://api.douban.com/v2/book/search?q=西游记时返回数据类型如下图：

json.png

　　这里面公共的参数就是count，start，total，books，所以我们只需要对这些参数进行封装（还有参数不全，参数错误等情况去请求服务器，服务器返回的错误code等等），这里我们只对books感兴趣，那么我们只需要对count判断就能得出是否搜索到书籍。

下面我们看看这个BaseResult代码：

public class BaseResult<T> {

    private int count;
    private int start;
    private int total;
    private T books;

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public int getStart() {
        return start;
    }

    public void setStart(int start) {
        this.start = start;
    }

    public int getTotal() {
        return total;
    }

    public void setTotal(int total) {
        this.total = total;
    }

    public T getBooks() {
        return books;
    }

    public void setBooks(T books) {
        this.books = books;
    }
}

注（大坑）：这里的books是返回的json数组的名字，而不是固定死的（之前用别人的data，然而发现一直是null，原来是gson解析时没找到这个json字段的名字）
　　
　　封装完BaseResult那么就要来封装Observer了，毕竟数据是在Observer里面回调的，真正对数据处理的是Observer这个大佬，数据到了这想要走，还不得一顿判断，以此为例，当count为0的时候说明没有搜索到那么我们需要处理下返回提示信息，当count>0时我们把搜索到的书籍返回，当搜索出错时走到onError时我们也要返回个提示信息，当然这里还能做许多操作（加些提示框，加载框等等）这里就不一一实现了。

看下BaseObserver代码：

public abstract class BaseObserver<T> implements Observer<BaseResult<T>> {

    @Override
    public void onSubscribe(@NonNull Disposable d) {
        //订阅刚开始的时候
    }

    @Override
    public void onNext(@NonNull BaseResult<T> tBaseResult) {
        //这里面就用BaseResult包裹着实体类
        if (tBaseResult.getCount() > 0) {
            handleData(tBaseResult.getBooks());
        } else {
            errorMsg("未搜索到");
        }
    }

    @Override
    public void onError(@NonNull Throwable e) {
        if (e instanceof ConnectException)
            errorMsg("无网络");
        errorMsg(e.getMessage());
    }

    @Override
    public void onComplete() {
      //完成的时候
    }

    //处理过的数据
    public abstract void handleData(T t);
    //错误信息
    public abstract void errorMsg(String msg);
}

当然请求的接口也改变了（其实也就在外面套了个BaseResult）

public interface Api {
    @GET("v2/book/search")
    Observable<BaseResult<List<Book>>> searchBook(@Query("q") String bookName);
}

线程调度

每次请求时候的时候都需要.subscribeOn(Schedulers.io())和.observeOn(AndroidSchedulers.mainThread())这样不是很麻烦？特别是在Android中只能在主线程更新UI这个规矩，那么数据返回要在主线程中咯，这样我们就封装下两个就不用每次都写了。

代码如下:

public class BaseRx {

    private BaseRx() {
       throw new RuntimeException("u con't instantiate me");
    }

    public static <T> ObservableTransformer<T, T> io4main() {
        return new ObservableTransformer<T, T>() {
            @Override
            public ObservableSource<T> apply(@NonNull Observable<T> upstream) {
                return upstream.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).unsubscribeOn(Schedulers.io());
            }
        };
    }
}

这样我们如果是用到在IO线程中操作，在主线程中取数据，就可以用到此工具类，只需要RxJava的操作符compose就可以了（下面有完整例子）。

下面我们把封装好的全部来跑一遍

RetrofitHelper.getBoobApi().searchBook(mEtBook.getText().toString().trim())
                .compose(BaseRx.<BaseResult<List<Book>>>io4main()) //使用compose转换线程
                .subscribe(new BaseObserver<List<Book>>() {
            @Override
            public void handleData(List<Book> books) {
                for (int i = 0; i < books.size(); i++) {
                    if(!TextUtils.isEmpty(books.get(i).getPublisher())){
                        mStringBuilder.append(books.get(i).getPublisher() + "\n");
                    }
                    mBook.setText(mStringBuilder);
                }
            }

            @Override
            public void errorMsg(String msg) {
                mBook.setText(msg);
            }
        });

运行下效果：

request.gif
　　是不是感觉封装完看着都很爽，代码少，逻辑清晰，当然这还没有结合ＭVP一起使用，结合起来也是一大杀器，撸码犹如神助，好啦，下次再说与MVP封装，明天又是周末，美滋滋。

RxJava+Retrofit+MVP封装（一）

RxJava+Retrofit+MVP封装（二）

RxJava+Retrofit+MVP封装（三）