项目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的框架库，来为公司未来无限扩展的业务助力。