retrofit

1、Retrofit介绍

http://blog.csdn.net/androidxiaogang/article/details/51725798
在上篇博客中介绍retrofit入门

官方介绍地址
http://square.github.io/retrofit/

2、流程示意图

1、Retrofit.build()创建Retrofit对象

1. OkhttpClient 创建OkhttpClient对象，封装的Okhttp请求
2. CallBackExecutor 创建CallBackExecutor对象，主要用于请求后的回调
3. CallAdapter 创建CallAdapter 对象（适用于Rxjava,Java8,Retrofit，通过泛型识别出adapter）
4. Convertor(GsonConverterFactory.create(),返回类型的转换，比如是json,xml,byte流等之类的)

---

2、ServiceMethod.build()

1. createCallAdapter()
2. createConvertor
3. parseAnnoatation 解析请求参数的注解

---

3、ExecutorCallBackCall 执行请求
ExecutorCallBackCall<>backCall callAdapter.adapt(OkHttpCall<>)

ExecutorCallBackCall.enqueue(new CallBack))
okHttpCall.enqueue(new CallBack){
handler.post(new Runnable){

callback.onResponse

})

requestConvertor

okhttp3.Request=okHttpCall.toRequest()

responseConvertor

Retrofit.Response=okHttpCall.toResponse();
}

3、Retrofit代码分析

API类中

public interface Api {
    //http://gank.io/api/data/福利/5/1
    @GET("api/data/福利/{pageCount}/{pageIndex}")
    Call<DataInfo> getData(@Path("pageCount") int pageCount,
                 @Path("pageIndex") int pageIndex);
}

请求示例

  private void initData(int pages) {
        //使用retrofit配置api
        Retrofit retrofit=new Retrofit.Builder()
                .baseUrl("http://gank.io/")
                .addConverterFactory(GsonConverterFactory.create())
                .build();
        Api api =retrofit.create(Api.class);
        Call<DataInfo> call=api.getData(5,pages);
        call.enqueue(new Callback<DataInfo>() {
            @Override
            public void onResponse(Call<DataInfo> call, Response<DataInfo> response) {

                arrayList.addAll(response.body().results);
                adapter.notifyDataSetChanged();
                refreshLayout.setRefreshing(false);

            }

            @Override
            public void onFailure(Call<DataInfo> call, Throwable t) {
                refreshLayout.setRefreshing(false);
            }
        });
    }

1、构造器模式创建Retrofit对象

Retrofit retrofit=new Retrofit.Builder()
                .baseUrl("http://gank.io/")
                .addConverterFactory(GsonConverterFactory.create())
                .build();

源码分析

 public Retrofit build() {
      if (baseUrl == null) {
        throw new IllegalStateException("Base URL required.");
      }
//通过工厂模式创建okhttpclient对象
      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
      //如果为空的话，就创建
        callFactory = new OkHttpClient();
      }
       //Executor对象，执行后返回，在主线程中（相当于handler）
      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }
      //把adapter添加到Call adapter中
      // Make a defensive copy of the adapters and add the default Call adapter.
      List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

      // Make a defensive copy of the converters.
      List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);

      return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
          callbackExecutor, validateEagerly);
    }
  }

然后走了callbackExecutor，在这callbackExecutor中异步请求，然后

//发起enqueue异步请求，然后通过callbackExecutor中Runnable把请求的结果回调到主线程中
@Override public void enqueue(final Callback<T> callback) {
      if (callback == null) throw new NullPointerException("callback == null");

      delegate.enqueue(new Callback<T>() {
      //callbackExecutor请求返回结果的回调
        @Override public void onResponse(final Call<T> call, final Response<T> response) {
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              if (delegate.isCanceled()) {
                // Emulate OkHttp's behavior of throwing/delivering an IOException on cancellation.
                callback.onFailure(call, new IOException("Canceled"));
              } else {
                callback.onResponse(call, response);
              }
            }
          });
        }
        //callbackExecutor失败的回调
        @Override public void onFailure(final Call<T> call, final Throwable t) {
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              callback.onFailure(call, t);
            }
          });
        }
      });
    }

2、请求参数的封装

通过上面得到retrofit对象后，然后进行请求参数封装

 Api api =retrofit.create(Api.class);

源码分析

public <T> T create(final Class<T> service) {
    Utils.validateServiceInterface(service);
    if (validateEagerly) {
      eagerlyValidateMethods(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, Object... args)
              throws Throwable {
            // If the method is a method from Object then defer to normal invocation.
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            //把http 请求接口中的参数，转换成真正的http call请求
            ServiceMethod serviceMethod = loadServiceMethod(method);
            OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }

然后serviceMethod，通过注解配置http请求

3、通过注解配置http请求（路径，参数）

请求示例代码

public interface Api {
    //http://gank.io/api/data/福利/5/1
    @GET("api/data/福利/{pageCount}/{pageIndex}")
    Call<DataInfo> getData(@Path("pageCount") int pageCount,
                 @Path("pageIndex") int pageIndex);
}

通过上面的serviceMethod，把我们配置的所有http请求，封装到http call中

4、发送请求

在主线程中的方法回调，

 call.enqueue(new Callback<DataInfo>() {
            @Override
            public void onResponse(Call<DataInfo> call, Response<DataInfo> response) {

                arrayList.addAll(response.body().results);
                adapter.notifyDataSetChanged();
                refreshLayout.setRefreshing(false);

            }

            @Override
            public void onFailure(Call<DataInfo> call, Throwable t) {
                refreshLayout.setRefreshing(false);
            }
        });

源码分析

public interface Call<T> extends Cloneable {
  /**
   * 同步的发送请求和相应
   *
   */
  Response<T> execute() throws IOException;

  /**
   *异步的发送请求和相应
   * 
   */
  void enqueue(Callback<T> callback);

  /**
   * 如果已经发送请求了，返回true
   */
  boolean isExecuted();

  /**
   * 取消请求
   */
  void cancel();

  /*
   * 请求是否取消
   */
  boolean isCanceled();

  /**
   *创建一个新的请求call,即使它已经存在了
   */
  Call<T> clone();

  /** 发送原始的http请求 */
  Request request();
}

4、retrofit中的设计思想

1、构建器模式

将复杂的对象构造它的部件创建相分离，android中很多都使用构建器模式，比如dialog弹窗

public interface Builder {  
    void buildCarWheel() ;  
    void buildSteeringWheel() ;  
    void buildEngine() ;  
    void buildCarFrame() ;  
    Car getCar() ;  
}  

2、工厂模式

工厂模式就相当于创建实例对象的new
在retrofit中创建，在这工厂的作用只是创建okhttpclient（可能拓展到httpurlconnection,httpclient）

 okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

3、代理模式

静态代理：由程序员创建或由特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
动态代理：在程序运行时，运用反射动态创建

在retrofit中运用动态代理的方式，来创建请求的类（类中的是普通retrofit请求，或者rxjava请求）
另外（动态代理是AOP,面向切面编程的核心，事实上spring的Aop也是建立在java的动态代理机制之上的。要理解spring，就要先理解java的动态代理机制。）

4、适配器模式

要将所有的适配给CallAdapter就需要不同的适配器（接头）
(RxJavaCallAapter,Java8Adapter,AndroidCallAdapter)

参考文章
http://www.jianshu.com/p/45cb536be2f4