Android 我的Retrofit+Rxjava封装,不搞花里胡俏

初始化:

NetWorkManager.init(String baseUrl, Application context)
复制代码

难点1 BaseBean:

作为一个库,这个类是一个头疼的问题.因为强耦合.

我们一般写的baseBaen都是这样的:

class BaseBean<T>{
  String code;
  T data;
  String msg;
}
复制代码

用这个库是这样的(ParseInfo):

你只需要定义自己的basebean规则

NetWorkManager.addParseInfo(
                new RxParseInfo("code", "data", "msg", "200") //200的意思是成功的code.
        );

复制代码

这里传入的参数都是key的名字.

目前支持4个key值.我觉得基本够用了.

codeKey 判断成功

dataKey 返回数据

msgKey 服务器返回消息

库是如何判断接口请求成功的

ParseInfo 里默认通过判断 successCode 与返回的 codeKey 的值进行比较的

public boolean isSuccess(JsonObject asJsonObject) {
        if (checkSuccess != null) {
            return checkSuccess.isSuccess(asJsonObject);
        }
        String code = asJsonObject.get(codeKey).toString();
        return TextUtils.equals(code, successCode);
    }
复制代码

也可以自定义判断是否请求成功

ParseInfo使用setCheckSuccess().非必须.主要是为了扩展.

new ParseInfo("code", "data", "msg", "200")
 .setCheckSuccess(new ParseInfo.CheckSuccess() {
                    @Override
                    public boolean isSuccess(JsonObject asJsonObject) {
                        return false;
                    }
                })
复制代码

请求:

public interface JApi {

    /**
     * 上传文件
      */
    @POST
    @Multipart
    Observable<String> post(@Url String url, @PartMap HashMap<String, RequestBody> params);

    /**
     * 通用POST
     *
     */
    @POST
    Observable<String> post(@Url String url, @Body String json);

    /**
     * 通用POST
     */
    @POST
    Observable<String> post(@Url String url, @Body SimpleParams json);

    /**
     * 通用get
     */
    @GET
    Observable<String> get(@Url String url, @QueryMap SimpleParams params);

}
复制代码

这里写了4个通用的retrofit的请求.我个人觉得是可以满足大部分的需求了.

如果满足不了.就写点定制的就好了.有人会觉得这么写不行,实际上,我就用这个已经写了很多项目了.

有人会问,为什么这里都是 Observable<String> ,往后面看就知道了.嘿嘿

RetrofitUtil

这里使用了饿汉式懒加载单例.

public class RetrofitUtil {
    /**
     * 服务器地址
     */
    private static String API_HOST;
    private static Application mContext;
    private static final HashMap<Class, Object> apis = new HashMap<>();

    @SuppressWarnings("unchecked")
    public static <T> T getApi(Class<T> c) {
        Object o = apis.get(c);
        if (null == o) {
            o = getInstance().create(c);
            apis.put(c, o);
        }
        return (T) o;
    }

    public static synchronized void init(String baseUrl, Application context) {
        if (TextUtils.isEmpty(baseUrl)) {
            return;
        }
        mContext = context;
        API_HOST = baseUrl;
        Instance.retrofit = Instance.getRetrofit();
        apis.clear();
    }

    public static Retrofit getInstance() {
        return Instance.retrofit;
    }

    private static class Instance {
        private static Retrofit retrofit = getRetrofit();

        private static Retrofit getRetrofit() {
            OkHttpClient.Builder client = new OkHttpClient.Builder()
                    //拦截并设置缓存
                    .addNetworkInterceptor(new CacheInterceptor())
                    //拦截并设置缓存
                    .addInterceptor(new CacheInterceptor())
                    .cache(new Cache(mContext.getCacheDir(), 10240 * 1024));
            // 设置代理
            if (NetWorkManager.getProxy() != null) {
                client.proxy(NetWorkManager.getProxy());
            }

            for (Interceptor i : NetWorkManager.mInterceptors) {
                client.addInterceptor(i);
            }
            if (BuildConfig.DEBUG) {
                HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
                interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
                client.addInterceptor(interceptor);
            }
            return new Retrofit.Builder()
                    .client(client.build())
                    .baseUrl(API_HOST)
                    .addConverterFactory(GsonConverterFactory.create())
                    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                    .build();
        }
    }

复制代码

可以设置缓存,添加代理,重置baseurl

对Retrofit.create创建的实体类,进行了缓存.

看了半天,先来个例子吧:

Disposable login = RetrofitUtil.getApi(JApi.class)
                .get("/login", SimpleParams.create()
                        .putP("key1", 1)
                        .putP("key2", 2)
                        .putP("key3", 2)
                        .putP("key4", 3)
                )
                .compose(JRxCompose.normal())
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {

                    }
                });
复制代码

一个简单的请求就是这样的.

有人看了会问, JRxCompose 是啥?

JRxCompose

先来张目录图

再来张代码

这里为什么要写 JsonArrayParesTransformer 和 JsonParesTransformer .

因为在组件化的时候,跨组件使用时,泛型是会丢失的.我不知道现在解决没.

所以使用这两个来统一解析结果.

如果你细心就会发现. JApi 的方法,的返回参数都是 Observable<String>

也就是统一先用String接收结果,然后再解析成最终结果.

看到这里,你满足了吗? 我是不满足的.哈哈

难点2 取消网络请求

如何舒服的取消请求回调一直是个头疼的问题

不取消就会内存泄露,调用已关闭的activity,造成崩溃.

当然,现在有 RxLifecyle 之类的库,很方便.

这里简单我实现了一个.

JApiImpl

public class JApiImpl implements JApi, LifecycleObserver, ObservableTransformer<String, String> {

    public static JApi getApi() {
        return RetrofitUtil.getApi(JApi.class);
    }

    public static JApiImpl with(Lifecycle lifecycle) {
        JApiImpl JApiImpl = new JApiImpl();
        lifecycle.addObserver(JApiImpl);
        return JApiImpl;
    }

    public static JApiImpl with(Fragment fragment) {
        return with(fragment.getLifecycle());
    }

    public static JApiImpl with(AppCompatActivity activity) {
        return with(activity.getLifecycle());
    }

    private Disposable disposable;

    @Override
    public ObservableSource<String> apply(Observable<String> upstream) {
        return upstream.doOnSubscribe(disposable -> this.disposable = disposable);
    }

    private void cancel() {
        if (this.disposable != null && !disposable.isDisposed()) {
            disposable.dispose();
        }
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        this.cancel();
        Log.i("233", "取消了请求");
    }

    @Override
    public Observable<String> post(String url, HashMap<String, RequestBody> params) {
        return getApi().post(url, params).compose(this);
    }

    @Override
    public Observable<String> post(String url, String json) {
        return getApi().post(url, json).compose(this);
    }

    @Override
    public Observable<String> post(String url, SimpleParams params) {
        return getApi().post(url, params).compose(this);
    }

    @Override
    public Observable<String> get(String url, SimpleParams params) {
        return getApi().post(url, params).compose(this);
    }

}

复制代码

实现了 JApi , LifecycleObserver , ObservableTransformer

LifecycleObserver 是为了利用现在android自带的Lifecycle实现取消回调

ObservableTransformer 是为了转换Observer.拿到Disposable.

这么改一下后.请求就可以这样:

JApiImpl.with(this)
                .get("/login", SimpleParams.create()
                        .putP("key1", 1)
                        .putP("key2", 2)
                        .putP("key3", 2)
                        .putP("key4", 3)
                )
                .compose(JRxCompose.normal())
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {

                    }
                });
复制代码

添加加密/解密

NetWorkManager.initKey("私钥", "公钥");//加密解密
复制代码

设置超时时间

NetWorkManager.setDefaultTimeOut(20);//秒
复制代码

设置重试次数

NetWorkManager.setDefaultRetry(5);//重试次数
复制代码

设置全局异常统一回调

NetWorkManager.setExceptionListener(new onExceptionListener() {
            @Override
            public String onError(Throwable throwable) {
                return null; 
            }
        });
复制代码

设置添加全局code状态处理

NetWorkManager.setApiCallBack(new APICallBack() {
            @Override
            public String callback(String code, String resultData) {
                JsonElement jsonElement = JSONFactory.parseJson(resultData);
                return JSONFactory.getValue(jsonElement, "message");
            }
        });
复制代码

设置打开服务器返回msg异常

如果callback不处理,并打开isOpenApiException,则抛出服务器返回msg信息

NetWorkManager.setOpenApiException(true);
复制代码

异常的处理逻辑

String errorMsg = null;
    //通过code获取注册的接口回调.
    APICallBack apiCallback = NetWorkManager.getApiCallback();
    if (apiCallback != null) {
        String callbackMsg = apiCallback.callback(code, response);
        if (!TextUtils.isEmpty(callbackMsg)) {
            errorMsg = callbackMsg;
        }
    }

    //如果callback不处理,并打开isOpenApiException,则抛出服务器返回msg信息
    if (TextUtils.isEmpty(errorMsg) && NetWorkManager.isOpenApiException()) {
        errorMsg = msg;
    }
    //抛出异常,走到onError.
    throw new APIException(code, errorMsg);
复制代码