RxJava2+Retrofit2+RxLifecycle3+OkHttp3网络请求封装（动态演示）

时间 2021-03-03

标签 java json 缓存网络 app 框架 ide 组件化 this 栏目 Java 繁體版

原文原文链接

入职公司后，公司要求组件化开发，通过讨论后我将网络请求框架单独进行了封装，不过当时框架里将经常使用的 util 和 ui 均放入到了共同的 Common 包下，致使里面部分代码耦合，后来为了下降耦合性又将 Common 拆分为了lib_common和lib_ui，可是 lib_ui 依赖了 lib_common，仍是致使部分代码耦合，最新一期为了下降组件之间的耦合性，因此单独将 lib_common 中的网络请求单独拆分，而且我又作了新的封装和完善，总之网络框架通过3次大的改造后，使用已经很是稳定了。

使用步骤

1.在Application类中进行初始化操做java

 ApiConfig build = new ApiConfig.Builder()
                 .setBaseUrl(baseUrl)//BaseUrl，这个地方加入后项目中默认使用该url
                .setInvalidateToken(0)//Token失效码
                .setSucceedCode(200)//成功返回码
                .setFilter("com.mp5a5.quit.broadcastFilter")//失效广播Filter设置
                //.setDefaultTimeout(2000)//响应时间，能够不设置，默认为2000毫秒
                //.setHeads(headMap)//动态添加的header，也能够在其余地方经过ApiConfig.setHeads()设置
                //.setOpenHttps(true)//开启HTTPS验证
                //.setSslSocketConfigure(sslSocketConfigure)//HTTPS认证配置
                .build();
 build.init(this);

2.定义接口json

 public interface NBAApiT {

    @GET("onebox/basketball/nba")
    Observable<NBAEntity> getNBAInfo(@QueryMap ArrayMap<String, Object> map);
}

3.建立请求实例缓存

单例模式建立Service，推荐使用这种
public class NbaService {

    private NBAApiT nbaApiT;

    private NbaService() {
        nbaApiT = RetrofitFactory.getInstance().create(NBAApiT.class);
    }

    public static NbaService getInstance() {
        return Nbaservice1Holder.S_INSTANCE;
    }

    private static class Nbaservice1Holder {
        private static final NbaService S_INSTANCE = new NbaService();
    }

    public Observable<NBAEntity> getNBAInfo(String key) {
        ArrayMap<String, Object> map = new ArrayMap<>();
        map.put("key", key);
        return nbaApiT.getNBAInfo(map);
    }

}

4.发送请求网络

findViewById(R.id.btnNBA).setOnClickListener(v -> {
            NbaService.getInstance()
                    .getNBAInfo("6949e822e6844ae6453fca0cf83379d3")
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .compose(this.bindToLifecycle())
                    .subscribe(new BaseObserver<NBAEntity>(){

                        @Override
                        public void onSuccess(NBAEntity response) {
                            Toast.makeText(TestNBAActivity.this, response.result.title, Toast.LENGTH_SHORT).show();
                        }

                    });
        });

5.效果展现app

封装思想

返回参数回调框架

因为 JDK1.8 中接口能够有默认不须要实现的方法，因此我采用了JDK1.8的新特新封装了网络请求返回参数的回调。这样作的好处就是有些状况下，咱们是只须要处理成功的需求，可是失败和错误咱们并非太关心，因此在观察者类 BaseObserver 中我对失败和错误作了统一的封装，这样咱们能够不须要每次写回调参数的时候，都去处理失败和错误。大大的减轻了代码量。ide

public interface OnBaseResponseListener {

      void onSuccess(R response);

      default void onFailing(R response) {}

      default void onError() {}

}

其中 onSuccess() 方法是必须实现的，onFailing(R response) 和 onError() 能够不用实现，若是项目中想处理网络请求失败和错误，则须要重写onFailing(R response) 和 onError()方法，若是用到了封装的 loading 框和Toast，则须要 super.onFailing(response) 和 super.onError(e),不然则能够不用 super。组件化

网络请求返回的实体类Bean

这个类是全部用到网络请求实体类的父类，根据这个类中的code,咱们在观察者类BaseObserver 中判断网络请求是成功仍是失败或者token失效。ui

public class BaseResponseEntity implements Serializable {

  private static final long serialVersionUID = 1L;

  public int code;

  public String msg;

  public boolean success() {
    return ApiConfig.getSucceedCode() == code;
  }

  public int getTokenInvalid() {
    return ApiConfig.getInvalidateToken();
  }

}

例如这个请求NBA返回的实体类，咱们只须要继承自 BaseResponseEntity。this

public class NBAEntity extends BaseResponseEntity {

    @SerializedName("error_code")
    public int code;
    public String reason;
    public ResultBean result;

    public static class ResultBean {
      public String title;
      }
}

因为个人项目返回的 code 码这个字段并非 BaseResponseEntity 中的 code，因此能够采用起别名的方式，

    @SerializedName("error_code")
    public int code;

这样就能够解决公司返回的code码字段和我封装的字段不相同的问题，固然每一个bean都写这段代码显然不是特别友好，因此你能够再封装一个bean继承自BaseResponseEntity，而后给code起别名就能够了，那样项目中的其余的bean只须要继承你本身封装的bean。

网络状态的封装类BaseObserver

这个类继承自rxjava中的观察者类Observer，这个类中我在onNext()方法中对返回参数进行判断，若是code是成功的code码表示本次网络请求是成功的，若是code不是成功的code码，那表明网络请求是失败的，对失败作了统一封装处理，若是返回的code值为token失效，这样我发送了一条动态广播，在本身的项目中，你只要在activity中的基类中接收该动态广播，而后作退出登陆、清空数据等操做，一样在onError()方法中，我对错误作了处理。在上面我已经提示过了，失败onFailing(response)和错误onError(Throwable e)方法能够不用实现的。由于我在这个类已经作了统一处理。

public abstract class BaseObserver<T extends BaseResponseEntity> implements Observer<T> {

    、、、

    @Override
    public void onNext(T response) {

        if (response.success()) {
            try {
                onSuccess(response);
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else if (response.getTokenInvalid() == response.code) {
            //token失效捕捉，发送广播，在项目中接收该动态广播而后作退出登陆等一些列操做
            Intent intent = new Intent();
            intent.setAction(ApiConfig.getQuitBroadcastReceiverFilter());
            intent.putExtra(TOKEN_INVALID_TAG, QUIT_APP);
            AppContextUtils.getContext().sendBroadcast(intent);

        } else {
            try {
                onFailing(response);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void onError(Throwable e) {

        if (e instanceof retrofit2.HttpException) {
            //HTTP错误
            onException(ExceptionReason.BAD_NETWORK);
        } else if (e instanceof ConnectException || e instanceof UnknownHostException) {
            //链接错误
            onException(ExceptionReason.CONNECT_ERROR);
        } else if (e instanceof InterruptedIOException) {
            //链接超时
            onException(ExceptionReason.CONNECT_TIMEOUT);
        } else if (e instanceof JsonParseException || e instanceof JSONException || e instanceof ParseException) {
            //解析错误
            onException(ExceptionReason.PARSE_ERROR);
        } else {
            //其余错误
            onException(ExceptionReason.UNKNOWN_ERROR);
        }
    }

    、、、

    @Override
    public void onComplete() {
       、、、
    }

    public abstract void onSuccess(T response);

    public void onFailing(T response) {
        String message = response.msg;
        if (TextUtils.isEmpty(message)) {
            Toast.makeText(AppContextUtils.getContext(), RESPONSE_RETURN_ERROR, Toast.LENGTH_SHORT).show();
        } else {
            Toast.makeText(AppContextUtils.getContext(), message, Toast.LENGTH_SHORT).show();
        }
    }
    、、、

}

Retrofit 封装 RetrofitFactory

这个类是配合okttp、Gson、拦截器等，对Retrofit进行的封装。这里对请求超时的时间，请求头拦截器、请求缓存大小、日志拦截器、https认证、返回json处理等、都在这个类作了处理，能够说这个类是处理Retrofit的核心类。

public class RetrofitFactory {

    、、、

    private RetrofitFactory() {

        // 指定缓存路径,缓存大小100Mb
        File cacheFile = new File(AppContextUtils.getContext().getCacheDir(), "HttpCache");
        Cache cache = new Cache(cacheFile, 1024 * 1024 * 100);

        OkHttpClient.Builder httpClientBuilder = new OkHttpClient().newBuilder()
                .readTimeout(ApiConfig.getDefaultTimeout(), TimeUnit.MILLISECONDS)
                .connectTimeout(ApiConfig.getDefaultTimeout(), TimeUnit.MILLISECONDS)
                .addInterceptor(HttpLoggerInterceptor.getLoggerInterceptor())
                .addInterceptor(new HttpHeaderInterceptor())
                .addNetworkInterceptor(new HttpCacheInterceptor())
                .cache(cache);

        if (ApiConfig.getOpenHttps()) {
            httpClientBuilder.sslSocketFactory(1 == ApiConfig.getSslSocketConfigure().getVerifyType() ?
                    SslSocketFactory.getSSLSocketFactory(ApiConfig.getSslSocketConfigure().getCertificateInputStream()) :
                    SslSocketFactory.getSSLSocketFactory(), new UnSafeTrustManager());
            httpClientBuilder.hostnameVerifier(new UnSafeHostnameVerify());
        }

        OkHttpClient httpClient = httpClientBuilder.build();

        Gson gson = new GsonBuilder()
                .setDateFormat("yyyy-MM-dd HH:mm:ss")
                .serializeNulls()
                .registerTypeAdapterFactory(new NullTypeAdapterFactory())
                .create();

        retrofit = new Retrofit.Builder()
                .client(httpClient)
                .addConverterFactory(GsonConverterFactory.create(gson))
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create());

        if (!TextUtils.isEmpty(ApiConfig.getBaseUrl())) {
            build = retrofit.baseUrl(ApiConfig.getBaseUrl()).build();
        }

    }

    、、、

    public <T> T create(Class<T> clazz) {
        checkNotNull(build, "BaseUrl not init,you should init first!");
        return build.create(clazz);
    }

    public <T> T create(String baseUrl, Class<T> clazz) {
        return retrofit.baseUrl(baseUrl).build().create(clazz);
    }

}

使用配置类ApiConfig

这个类是对全部初始化参数进行配置的地方，好比返回码 code，BaseUrl，失效InvalidateToken，请求头 Heads，是否开启 https 认证等的一系配置。能够在项目的 application 中对本身须要的参数进行配置，这样项目中只需写请求相关的代码，而不须要处理请求baseUrl、返回code等繁琐的任务。

public class ApiConfig implements Serializable {

    private static int mInvalidateToken;
    private static String mBaseUrl;
     、、、
    private ApiConfig(Builder builder) {
        mInvalidateToken = builder.invalidateToken;
        mBaseUrl = builder.baseUrl;
        、、、
    }

    public void init(Context appContext) {
        AppContextUtils.init(appContext);
    }

    public static int getInvalidateToken() {
        return mInvalidateToken;
    }

    public static String getBaseUrl() {
        return mBaseUrl;
    }

    、、、

    public static final class Builder  {

        private int invalidateToken;

        private String baseUrl;

        、、、

        public Builder setBaseUrl(String mBaseUrl) {
            this.baseUrl = mBaseUrl;
            return this;
        }

        public Builder setInvalidateToken(int invalidateToken) {
            this.invalidateToken = invalidateToken;
            return this;
        }

        、、、

        public ApiConfig build() {
            return new ApiConfig(this);
        }
    }
}

文章不易，若是你们喜欢这篇文章，或者对你有帮助但愿你们多多，点赞，转发，关注 哦。文章会持续更新的。绝对干货！！！