retrofit2.4.0结合adapter-rxjava,converter-gson,源码解析

retrofit2.4结合adapter-rxjava,converter-gson,源码解析

Retrofit作为时下android里比较常用的库，特别是结合着rxjava 后用起来很是酸爽啊，本篇就是剖析一下retrofit2.0结合adapter-rxjava,converter-gson后整个流程是怎样串起来的，以及源码的解析

先看下retrofit简介

retrofit基本使用这里不再赘述，直奔主题直接看源码了

retrofit源码地址 图一就是今天的重点了，图二是发起请求对应的注解种类了

都知道retrofit实际调用的是okhttp。也可以说retrofi就是在okhttp的基础上包了一层，通过大量的设计模式进行功能模块的解耦，使得整个整个流程变得整洁和清爽、

接口

阅读一个三方库 先从接口入手，先了解一下上层大致提供了哪些功能有助于快速理解

**Call **

对于okhttp 的call的的一个再包装，也是真正发出请求的对象接口
public interface Call extends Cloneable {

  Response execute() throws IOException;

  void enqueue(Callback callback);

  boolean isExecuted();

  void cancel();

  Call clone();

  /**返回的是okhttp的Request. */
  Request request();
}
复制代码

**CallAdapter **

//可以把Call对象转化为另外一个对象，如Observable，Flowable
public interface CallAdapter {
    //Type  返回值泛型的对象类型如：Flowable>里的Response
    Type responseType();
    
   //传入一个R返回一个T，T:返回值 一个Call或者Flowable
    T adapt(Call call);
//工厂里提供三个方法 1：根据返回值returnType获取具体请求的CallAdapter 2：根据返回值type 获取泛型里的数据类型
// 3：通过type获取class的类型，获取整个返回值的类型  如Observable，Flowable ，Call 
// 2,3 均为工具类
    abstract class Factory {
//abstract抽象方法，一定要被实现
 public abstract @Nullable  CallAdapter get(Type returnType, Annotation[] annotations, Retrofit retrofit);
 
 protected static Type getParameterUpperBound(int index, ParameterizedType type) {
  return Utils.getParameterUpperBound(index, type);  
     
 }

 protected static Class getRawType(Type type) {
 return Utils.getRawType(type);
  }
    }
}

**Callback **
请求回调
**Converter **
数据转换适配器，可以对请求的数据或者响应的数据再度处理
public interface Converter {
  T convert(F value) throws IOException;

  /** Creates {@link Converter} instances based on a type and target usage. */
  abstract class Factory {
    /**
     * 传入ResponseBody返回t，对响应数据进行解析，converter-gson会重写此方法
     */
    public @Nullable Converter responseBodyConverter(Type type,
        Annotation[] annotations, Retrofit retrofit) {
      return null;
    }

    /**
     *
     *传入T返回ResponseBody 对请求数据进行处理，只有在 申明@Body, @Part ，@PartMap
     *这三个注解时才会生效
     *
     */
    public @Nullable Converter requestBodyConverter(Type type,
        Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
      return null;
    }

    /**     * 
     *  {@link Field @Field}, {@link FieldMap @FieldMap} values,
     * {@link Header @Header}, {@link HeaderMap @HeaderMap}, {@link Path @Path},
     * {@link Query @Query}, and {@link QueryMap @QueryMap} values.
     对以上注解的值进行处理 而已已经被BuiltInConverters（默认解析类）类重写，外部重写无效
     */
    public @Nullable Converter stringConverter(Type type, Annotation[] annotations,
        Retrofit retrofit) {
      return null;
    }

    /**
   工具类作用与CallAdapter里的一样
     */
    protected static Type getParameterUpperBound(int index, ParameterizedType type) {
      return Utils.getParameterUpperBound(index, type);
    }
    
    protected static Class getRawType(Type type) {
      return Utils.getRawType(type);
    }
  }
}

复制代码

基本使用

获取 retrofit 实例以及添加上rxjava 请求适配器和converter-gson解析器
    public Retrofit getRetrofit(String baseurl, OkHttpClient client) {
        if (client == null)
            client = getOkHttpClient();
        Retrofit.Builder builder = new Retrofit.Builder();
        builder.baseUrl(baseurl);//baseurl路径
        builder.client(client)//添加客户端
                .addConverterFactory(GsonConverterFactory.create());//添加Gson格式化工厂
            //添加 rxjava
            builder.addCallAdapterFactory(RxJava2CallAdapterFactory
                    .createWithScheduler(Schedulers.from(AppExecutor.instance())));
      
        retrofit = builder.build();
        return retrofit;
    }
    //自定义的通用解析类，t为data内具体对象，msg和code为公用数据部分
   public class Response {
    private T data;
    private String msg;
    private String code;
       
   } 
//定义接口类
public interface ApiService {
     /**
     * 测试数据
     */
    @GET("data/福利/{num}/{page}")
    Flowable> getGirlList(@Path("num") int num, @Path("page") int page);   
}

//获取ApiService
ApiService  apiservice=getRetrofit(baseurl,OkHttpClient).create(serviceClass)

//发起请求，（这里未经封装，正常使用要再封装下）
apiservice.getGirlList(1,2).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribeWith(new ResourceSubscriber>() {
                @Override
                public void onNext(Response o) {
                    //结果回调
                }

                @Override
                public void onError(Throwable t) {

                }

                @Override
                public void onComplete() {

                }
            })

复制代码

源码分析

Retrofit实例是使用建造者模式通过Builder类进行创建的

核心类
这里只关心Android平台下的java8的不看
    static class Android extends Platform {
        // Guarded by API check.
        @Override
        boolean isDefaultMethod(Method method) {
            if (Build.VERSION.SDK_INT < 24) {
                return false;
            }
            return method.isDefault();
        }

        @Override
        public Executor defaultCallbackExecutor() {
            return new MainThreadExecutor();
        }
        /**
         * ExecutorCallAdapterFactory默认工厂类，
         * if (getRawType(returnType) != Call.class) {
          * return null;}
          *只解析返回类型为Call.class的数据，即原生retrofit的返回值都会使用这个工厂，原因后面
         */
        @Override
        List defaultCallAdapterFactories(
                @Nullable Executor callbackExecutor) {
            if (callbackExecutor == null) throw new AssertionError();
            return singletonList(new ExecutorCallAdapterFactory(callbackExecutor));
        }

        /**
         * android平台 默认为MainThreadExecutor，
         */
        static class MainThreadExecutor implements Executor {
            private final Handler handler = new Handler(Looper.getMainLooper());

            @Override
            public void execute(Runnable r) {
                handler.post(r);
            }
        }
    }
    
**默认CallAdapter实体类 提供了只解析解析返回Call.class类型的CallAdapter **
final class ExecutorCallAdapterFactory extends CallAdapter.Factory {
  final Executor callbackExecutor;

  ExecutorCallAdapterFactory(Executor callbackExecutor) {
    this.callbackExecutor = callbackExecutor;
  }

  @Override public @Nullable CallAdapter get(
      Type returnType, Annotation[] annotations, Retrofit retrofit) {
   if (getRawType(returnType) != Call.class) {
      return null;
    }
    final Type responseType = Utils.getCallResponseType(returnType);
    return new CallAdapter>() {
      @Override public Type responseType() {
        return responseType;
      }

      @Override public Call