Android 底层封装之基于Rxjava与Okhttp网络请求封装(1)

废话：由于很忙一直没分享，但不知道分享什么。所以就索性来点最好的干货。这个底层封装是我们项目正在使用的数据请求封装。使用起来简单方便，我相信你们看了这篇

文章后会爱我的。。哈哈哈。。迎娶高帅富，走上人生巅峰。。。（我是男的）！！

前言:分享总共3篇，网络请求封装，定位的封装，自定义分享功能的封装

其他集成功能总共3篇: 指纹解锁，支付功能（支付宝和微信），第3方登陆（QQ，微信）;

其他:待定。。（说句好听的给我听，我就速度快点。。。妹子效果加倍！！！）

不要直接粘贴，不然使用不了。

直接使用去我的Githup上下载.

package com.sda.lib.newHttp;
import android.content.Context;
import android.text.TextUtils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.google.gson.Gson;
import com.sda.lib.HttpCore.TextHandler;
import com.sda.lib.util.Logs;

import java.io.File;
import java.io.IOException;
import java.util.Date;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import okhttp3.Cache;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okhttp3.logging.HttpLoggingInterceptor;
import rx.Observable;
import rx.Observer;
import rx.Subscriber;
import rx.android.schedulers.AndroidSchedulers;
import rx.schedulers.Schedulers;


/**
 * Created by scorpio on 2016/10/11.
 */

public class MyHttp {
    private static String BASE_URL = "";
    private static OkHttpClient okHttpClient;
    private static int timeout = 15;
    private static int cache_size = 20;
    private enum Method {
        GET,
        POST
    }

    public static int getTimeout() {
        return timeout;
    }

    public static void setTimeout(int timeout) {
        MyHttp.timeout = timeout;
    }

    /**
     * 初始化
     * @param context
     * @param baseUrl api接口地址
     */
    public static void init(Context context, String baseUrl) {
        BASE_URL = baseUrl;
        // cookie 持久化
        ClearableCookieJar cookieJar = new PersistentCookieJar(new SetCookieCache(), new SharedPrefsCookiePersistor(context));
        // 请求缓存
        File httpCacheDirectory = new File(context.getCacheDir(), "responses");
        int cacheSize = cache_size * 1024 * 1024; // 10 MiB

        // log
        HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
        loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.HEADERS);

        OkHttpClient.Builder builder = new OkHttpClient.Builder()
                .followRedirects(true)// 遵循重定向
                .followSslRedirects(true) // 遵循SSL重定向
                .connectTimeout(timeout, TimeUnit.SECONDS)
                .writeTimeout(timeout, TimeUnit.SECONDS)
                .readTimeout(timeout, TimeUnit.SECONDS)
                .addInterceptor(loggingInterceptor)
                .addInterceptor(new CacheInterceptor())
                .cache(new Cache(httpCacheDirectory, cacheSize))
                .cookieJar(cookieJar); // cookie 持久化;
        okHttpClient = builder.build();
    }


    /**
     * 获取请求链接
     * @param relativeUrl RESTful 接口key
     * @return
     */
    public static String getAbsoluteUrl(String relativeUrl) {
        if (relativeUrl.startsWith("http")) {
            return relativeUrl;
        } else {
            return BASE_URL + relativeUrl;
        }
    }

    /**
     * get 请求 返回 string
     * @param url     请求地址
     * @param params  请求参数
     * @param handler 接口回调方法
     */
    public static void get(Context context,final String url, final RequestParams params, final TextHandler handler) {
        obs(url, params, Method.GET)
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<EntityResponse>() {
                    @Override
                    public void onCompleted() {
                    }
                    @Override
                    public void onError(Throwable e) {
                        handler.onFailure(e);
                    }
                    @Override
                    public void onNext(EntityResponse response) {
                        handler.onSuccess(response.getHeader(),response.getData());
                    }
                });
    }

    /**
     * get 请求 直接返回对象
     *
     * @param url     请求地址
     * @param params  请求参数
     * @param handler 接口回调方法
     */

    public static void get(final String url, final RequestParams params, final ObjectHandler handler) {
        obs(url, params, Method.GET)
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<EntityResponse>() {
                    @Override
                    public void onCompleted() {

                    }
                    @Override
                    public void onError(Throwable e) {
                        handler.onFailur("error",new Exception(e));
                    }

                    @Override
                    public void onNext(EntityResponse response) {
                        ParseResponse(response,handler,url);

                    }
                });
    }

    /**
     * post 请求 直接返回对象
     * @param url     请求地址
     * @param params  请求参数
     * @param handler 接口回调方法
     */
    public static void post(final String url, final RequestParams params, final ObjectHandler handler) {
        obs(url, params, Method.POST)
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<EntityResponse>() {
                    @Override
                    public void onCompleted() {
                    }

                    @Override
                    public void onError(Throwable e) {
                        handler.onFailur("error",new Exception(e));
                    }

                    @Override
                    public void onNext(EntityResponse response) {
                        ParseResponse(response,handler,url);

                    }
                });
    }


    /**
     * post 请求 返回 string
     *
     * @param url     请求地址
     * @param params  请求参数
     * @param handler 接口回调方法
     */
    public static void post(final String url, final RequestParams params, final TextHandler handler) {
        obs(url, params, Method.POST)
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<EntityResponse>() {
                    @Override
                    public void onCompleted() {
                    }
                    @Override
                    public void onError(Throwable e) {
                        handler.onFailure(e);
                    }
                    @Override
                    public void onNext(EntityResponse response) {
                        handler.onSuccess(response.getHeader(),response.getData());
                    }
                });
    }
    /**
     * 处理返回结果Response
     *
     * @param response
     * @param handler
     * @param url
     */
    private static void ParseResponse(EntityResponse response, ObjectHandler handler, String url) {
        try {
            if (response.getData().startsWith("[")){
                if (TextUtils.isEmpty(handler.key)){
                    Logs.Debug("json==="+response.getData()+"=="+handler.mType.toString());
                    Object o = new Gson().fromJson(response.getData(), handler.mType);
                    handler.onSuccess(response.getHeader(), o);
                    return;
                }
            }
            JSONObject jsonObject = JSON.parseObject(response.getData());
            if (handler.mType == String.class) {
                handler.onSuccess(response.getHeader(), response.getData());
            } else {
                try {
                    if (TextUtils.isEmpty(handler.key)){
                        Logs.Debug("json==="+response.getData()+"=="+handler.mType.toString());
                        Object o = new Gson().fromJson(response.getData(), handler.mType);
                        handler.onSuccess(response.getHeader(), o);
                        return;
                    }
                    if (jsonObject.containsKey(handler.key)) {
                        Object o = new Gson().fromJson(jsonObject.getString(handler.key), handler.mType);
                        handler.onSuccess(response.getHeader(), o);
                    } else {
                        String error = "error==[ fix= 解析json错误 ，检查key准确性：" + jsonObject + " , error= not found key (" + handler.key + ")]";
                        Logs.Error(error);
                        if (jsonObject.containsKey("msg")) {
                            handler.onFailur(jsonObject.getString("msg"), new Exception(error));
                        } else {
                            handler.onFailur(response.toString(), new Exception(error));
                        }
                    }
                } catch (Exception e) {
                    Logs.Error("error==[ fix= 检查url准确性：" + getAbsoluteUrl(url) + " json 解析出错 ， error=" + e.toString() + "]");
                    handler.onFailur(e.toString(), e);
                }
            }
        } catch (Exception e) {
            Logs.Error("error==[ fix= 检查url准确性：" + getAbsoluteUrl(url) + " , error=" + e.toString() + "]");
            handler.onFailur(e.toString(), e);
        }
    }


    /**
     * rxAndroid 线程控制
     * @param url
     * @param params
     * @param method
     * @return
     */
    public static Observable<EntityResponse> obs(final String url, final RequestParams params, final Method method) {

        return Observable.create(new Observable.OnSubscribe<EntityResponse>() {
            @Override
            public void call(Subscriber<? super EntityResponse> subscriber) {
                try {
                    subscriber.onNext(httpCore(url, params, method));
                    subscriber.onCompleted();
                } catch (IOException e) {
                    subscriber.onError(new Throwable(e));
                }
            }
        }).subscribeOn(Schedulers.io());
    }
    /**
     *请求
     * @param url
     * @param params
     * @param method
     * @return
     */
    public static EntityResponse httpCore(final String url, RequestParams params, Method method) throws IOException {
        Request.Builder builder = new Request.Builder();
        EntityResponse entityResponse = new EntityResponse();
        switch (method) {
            case GET:
                if (TextUtils.isEmpty(params.toString())) {
                    builder.url(getAbsoluteUrl(url));
                } else {
                    if (url.contains("?")){
                        builder.url(getAbsoluteUrl(url)+"&"+ params.toString());
                    }else {
                        builder.url(getAbsoluteUrl(url) + "?" + params.toString());
                    }
                }
                break;
            case POST:
                builder.url(getAbsoluteUrl(url));
                // 添加文件
                MultipartBody.Builder multiBody = new MultipartBody.Builder();
                multiBody.setType(MultipartBody.FORM);
                if (params.fileParams.entrySet().size() > 0) {
                    for (Map.Entry<String, RequestParams.FileWrapper>
                            fileEntry : params.fileParams.entrySet() ) {
                        String filename = fileEntry.getValue().getFile().getName();
                        RequestBody fileBody = RequestBody.create(null, fileEntry.getValue().getFile());
                        multiBody.addFormDataPart(fileEntry.getKey(), filename, fileBody);
                    }
                }
                // 添加参数
                if (params.mStringParams.size() > 0) {
                    for (Map.Entry<String, String> entry : params.mStringParams.entrySet()) {
                        multiBody.addFormDataPart(entry.getKey(), entry.getValue());
                    }
                }
                builder.post(multiBody.build());
                break;
        }
        Request request = builder.build();
        Response response = okHttpClient.newCall(request).execute();
     //    Logs.Debug("response==="+ response.cacheResponse().body());
        if (response.isSuccessful()) {
            entityResponse.setData(response.body().string());
            entityResponse.setHeader(response.code());
            return entityResponse;
        } else {
            entityResponse.setThrowable(new Throwable("CODE =" + response.code() + response.toString()));
            return entityResponse;
        }
    }
}

··