适配器模式

Retrofit retrofit = new Retrofit.Builder()
         .baseUrl("")
         .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
         .build();
//  Retrofit的create方法源码       
public <T> T create(final Class<T> service) {
   ......
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
        new InvocationHandler() {
          private final Platform platform = Platform.get();

          @Override public Object invoke(Object proxy, Method method, @Nullable Object[] args)
              throws Throwable {
        ......
            ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.adapt(okHttpCall);
          }
        });
  }

public interface Call<T> {
    void enqueue();
}

public interface CallAdapter<R,T> {

    T adapt(Call<R> call);

    abstract class Factory{
       public abstract CallAdapter<?,?> get();
    }
}
public class OkHttpCall<T> implements Call<T> {
    @Override
    public void enqueue() {
      //请求网络
    }
}

public class ExecutorCallAdapterFactory extends CallAdapter.Factory {
    @Override
    public CallAdapter<?, ?> get() {
        return new CallAdapter<Object, Call<?>>() {
            @Override
            public Call<?> adapt(Call<Object> call) {
                System.out.println("default 方式");
                return new ExectorCallbackCall<>();
            }
        };
    }
    static final class ExectorCallbackCall<T> implements Call<T>{

        @Override
        public void enqueue() {

        }
    }
}

public class RxJavaCallAdapterFactory extends CallAdapter.Factory {
    @Override
    public CallAdapter<?, ?> get() {
        return new CallAdapter<Object, Observable<?>>() {
            @Override
            public  Observable<?> adapt(Call<Object> call) {
                System.out.println("rxjava 方式");
                ObservableOnSubscribe subscribe = new ObservableOnSubscribe() {
                    @Override
                    public void subscribe(ObservableEmitter emitter) throws Exception {

                    }
                };
                return Observable.create(subscribe);
            }
        };
    }
}

public class Retrofit {

    private CallAdapter.Factory mFactory;

    private Retrofit(CallAdapter.Factory factory) {
        mFactory = factory;
    }

    public CallAdapter callAdapter(){
        return mFactory.get();
    }

    public <T> T create(){
      ServiceMethod serviceMethod = new ServiceMethod.Builder<>(this).build();
      OkHttpCall okHttpCall = new OkHttpCall();
      return (T) serviceMethod.adapt(okHttpCall);
    }

    public static final class Builder{
        CallAdapter.Factory mFactory;
        public Builder addCallAdapterFactory(CallAdapter.Factory factory){
            mFactory = factory;
            return this;
        }
        public Retrofit build(){
            if(mFactory == null){
                return new Retrofit(new ExecutorCallAdapterFactory());
            }
            return new Retrofit(mFactory);
        }
    }
}

public class ServiceMethod<R,T> {

    private CallAdapter<R,T> mCallAdapter;

    private <R, T> ServiceMethod(Builder builder) {
       mCallAdapter = builder.mCallAdapter;
    }

    T adapt(Call<R> call){
        return mCallAdapter.adapt(call);
    };

    static final class Builder<R,T>{
        Retrofit mRetrofit;
        CallAdapter<R,T> mCallAdapter;

        public Builder(Retrofit retrofit) {
            mRetrofit = retrofit;
        }
        public ServiceMethod build(){
            mCallAdapter = createCallAdapter();
            return new ServiceMethod(this);
        }

        private CallAdapter<R, T> createCallAdapter() {
            return mRetrofit.callAdapter();
        }
    }
}

Retrofit retrofit = new Retrofit.Builder()
              .addCallAdapterFactory(new RxJavaCallAdapterFactory())
              .build();
retrofit.create();