Retrofit 回到1.0时代

项目Git地址

前言

如图:Retrofit 1代的最后一版1.9.0 已经停留在了3年前,可以直接替换android原生的URLConnection和HttpClient框架,这么优秀的设计为啥被抛弃了呢。三年后我们重新捡起1代,来满足我们开发中需要整合的框架。

image

从我开始研究Retrofit的实现原理,到实现一个1代的版本,前后花费了不少的时间,其实我应该从1.9.0版本fork过来,然后修改,但这样我就不能研究到每一个设计细节,一来自己对框架的架构有了更深刻的认识,二来以后维护起来更加顺手,不至于遇到问题还要去研究框架的逻辑。毕竟公司这么多人用,不能拿一个别人写的东西直接上手,肯定会遇到一些奇葩的需求,对框架的扩展以及维护都要有百分百的信心不是。想看Retrofit的原理讲解,请点我

工作中有很多人会遇到这样的问题,大多数人会选择一个合适的框架,只要星星够多,够活跃,也可以放心使用,跟着他们更新的脚步走,但总会遇到一些新的问题,或者一些隐藏的问题,在上线后突然发现,最终有可能需要替换框架,这样说实话很尴尬。讲了这么多废话,回过头来说下这次博客的主题是什么,本次主要是写一下如何使用1.0版的Retrofit,框架不完美,但每个模块足够简单,学习起来容易,保持了Retrofit原有的框架结构,扩展性,稳定性等。

如何集成

目前提供AAR方式,主要还是以学习为目的,后期完善后,提交jcenter仓库。

用例

继承 Converter.Factory 实现 Gson序列化的逻辑

public final class GsonConverterFactory extends Converter.Factory {

    private final Gson gson;

    private GsonConverterFactory(Gson gson) {
        if (gson == null) throw new NullPointerException("gson == null");
        this.gson = gson;
    }

    static GsonConverterFactory create() {
        try {
            return new GsonConverterFactory(new Gson());
        } catch (Exception e) {
            throw new IllegalArgumentException("com.google.gson.Gson must not be null");
        }
    }

    @Override
    public Converter<?, String> stringConverter(Type type, Annotation[] annotations, JLRetrofit retrofit) {
        return new ToGsonConverter(gson);
    }

    static final class ToGsonConverter implements Converter<Object, String> {

        final Gson gson;
        private HashMap<String, Object> commonParameters = new HashMap<>();

        ToGsonConverter(Gson gson) {
            this.gson = gson;
        }

        @Override
        public String convert(Object value) {
            Map<String, Object> finalParmares = new HashMap<>();
            finalParmares.put("common", commonParameters);
            finalParmares.put("params", value);
            return gson.toJson(finalParmares);
        }
    }

    @Override
    public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
                                                            JLRetrofit retrofit) {
        TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
        return new GsonResponseBodyConverter<>(gson, adapter);
    }
}
final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
  private final Gson gson;
  private final TypeAdapter<T> adapter;

  GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {
    this.gson = gson;
    this.adapter = adapter;
  }

  @Override public T convert(ResponseBody value) throws IOException {
    JsonReader jsonReader = gson.newJsonReader(value.charStream());
    try {
      T result = adapter.read(jsonReader);
      if (jsonReader.peek() != JsonToken.END_DOCUMENT) {
        throw new JsonIOException("JSON document was not fully consumed.");
      }
      return result;
    } finally {
      value.close();
    }
  }
}

这里实现了两个部分,一个是将Request的数据 stringConverter 转成JSON数据格式,一个是将responseBody的数据 responseBodyConverter 转成Call<T>中 T类型的数据。设计上和现在版本的Retrofit完全一致。

定义接口

public interface ServiceApi {

    @POST("users/post")
    Call<DemoResponseBean> getBaidu2(@Body DemoBean ccc);

}

这里也是跟原来一样的逻辑

初始化及网络请求

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //这里是对http层的封装配置的地方,
        //不属于该库里的内容,如果替换http,这里不需要出现
        NetConfig.setContext(this); 
        NetConfig.setLogEnable(true);

        Call<DemoResponseBean> call = new JLRetrofit.Builder()
                .baseUrl("http://192.168.5.238:3000/")
                .addConverterFactory(GsonConverterFactory.create())
                .isEnableLog(true) //扩展的日志开关
                .build()
                .create(ServiceApi.class).getBaidu2(new DemoBean());
        new Thread(() -> {
            try {
                Response<DemoResponseBean> response = call.execute();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();

    }
}

使用上跟现在的Retrofit没什么区别,还原了替换底层Http的能力,又加了些如日志开关的功能。

如何替换http

public class OkHttpCall<T> implements Call<T> {
    private String TAG = "JLRetrofitLogTag";
    private final RequestFactory requestFactory;
    private final Object[] args;
    private final Converter<Object, T> responseConverter;
    private volatile boolean canceled;
    private boolean executed;

    private RequestClient requestClient;
    private Throwable creationFailure;

    OkHttpCall(RequestFactory requestFactory, Object[] args, Converter<Object, T> reponseConverter) {
        this.requestFactory = requestFactory;
        this.args = args;
        this.responseConverter = reponseConverter;
    }

    @Override
    public Response<T> execute() throws IOException {
        synchronized (this) {
            if (executed) throw new IllegalStateException("Already executed.");
            executed = true;
            if (creationFailure != null) {
                if (creationFailure instanceof IOException) {
                    throw new RuntimeException("Unable to create request.", creationFailure);
                } else if (creationFailure instanceof RuntimeException) {
                    throw (RuntimeException) creationFailure;
                } else {
                    throw (Error) creationFailure;
                }
            }
            try {
                requestClient = createRawCall();
                RequestClient.Courier courier = requestClient.execute();
                Response response = new Response();
                response.isSuccessful = courier.isSuccessful;
                response.code = courier.code;
                response.body = responseConverter.convert(ResponseBody.create(null, courier.body));
                response.exception = courier.exception;
                Logger.d(TAG, "response:", response.toString());
                return response;
            } catch (RuntimeException | Error e) {
                throwIfFatal(e);
                creationFailure = e;
                throw e;
            } catch (IOException e) {
                creationFailure = e;
                throw new RuntimeException("Unable to create request.", e);
            }

        }
    }

    @Override
    public void enqueue(Callback<T> var1) {

    }

    @Override
    public boolean isExecuted() {
        return executed;
    }

    @Override
    public void cancel() {
        canceled = true;
        if (requestClient != null)
            requestClient.cancel();
    }

    @Override
    public boolean isCanceled() {
        return canceled;
    }

    @SuppressWarnings("CloneDoesntCallSuperClone")
    // We are a final type & this saves clearing state.
    @Override
    public Call<T> clone() {
        return new OkHttpCall<>(requestFactory, args, responseConverter);
    }

    @Override
    public Request request() {
        return null;
    }

    private RequestClient createRawCall() throws IOException {
        RequestBuilder requestBuilder = requestFactory.create(args);
        Logger.d(TAG, "request: " + requestBuilder.toString());
        JLRequestBuilder jlRequestBuilder = new JLRequestBuilder(new JLRequestDataBox());

        String relativeUrl = requestBuilder.getRelativeUrl();
        String baseUrl = requestBuilder.getBaseUrl();
        if (relativeUrl.startsWith("http")) {
            jlRequestBuilder.setUrl(requestBuilder.getRelativeUrl());
        } else {
            jlRequestBuilder.setUrl(baseUrl + relativeUrl);
        }
        HashMap<String, String> hashMap = requestBuilder.getHeaders();
        hashMap.put("X-COMJIA-DEBUG","");//todo 目前先写死,后面添加灵活的用法。
        jlRequestBuilder.getDataBox().addHeaders(hashMap);
        jlRequestBuilder.setParametersObject(requestBuilder.getBody());
        jlRequestBuilder.readCacheBefore(false).readCacheAfter(false);
        return jlRequestBuilder.build();
    }
}

这里面最关键的就是execute() 的实现,最终由 createRawCall 构建JLRequestBuilder 请求,JLRequestBuilder是我们封装的一个底层实现,RequestFactory 就是对方法所有注解的数据分析结果集,最终组织要如何请求该数据,注意:目前只有post请求,还没有做其他方法的扩展,使用的时候要注意。
这里的JLRequestBuilder就是要替换的对象,可以根据自己的网络层框架封装进来,加入特殊的功能需求实现,如:实现对单个接口的加解密,对单个接口打印Log日志,可以实现接口的二级缓存,如果网络异常可以从缓存中读取等等,保持项目只对JLRetrofit的依赖,不要跨层依赖,做好层层隔离,保持项目的耦合度最低。对于一些追求包体极简的项目中,预计就是用HttpURLConnection实现了,毕竟okhttp占了一部分包体大小,能省100k就省100k。毕竟现在okhttp 4.2 已经快700k了


Okhttp

计划

  • 底层用HttpURLConnection实现
  • 提供接口无缝替换HttpURLConnection
  • 完善Get、Put、Delete常用请求方式
  • 完善其他注解
  • 提供两种生命周期方式:一种跟应用周期一样、一种根据界面的消失自动释放请求
  • 提供线程池管理
  • doing..

总结

经过这次实践,我们的团队不光在满足业务的同时,对技术的掌控也越来越深入,包括最近做日志模块,PUSH模块,报警模块,音视频模块等都逐步推广并完善。相信我们会打造一个完美的Android的框架库,来为公司未来无限扩展的业务助力。