{
  "data": [
        {
         "title":"Retrofit使用简介",
         "desc":"Retrofit是一款面向Android和Java的HttpClient",
         "link":"http://www.exm.com/retrofit"
        },
        {
         "title":"Retrofit使用简介",
         "desc":"Retrofit是一款面向Android和Java的HttpClient",
         "link":"http://www.exm.com/retrofit"
        },
        {
         "title":"Retrofit使用简介",
         "desc":"Retrofit是一款面向Android和Java的HttpClient",
         "link":"http://www.exm.com/retrofit"
        } 
     ]
 }

compile 'com.squareup.retrofit:retrofit:2.0.0-beta2'
//gson解析
compile 'com.squareup.retrofit:converter-gson:2.0.0-beta2'

Retrofit retrofit = new Retrofit.Builder()
          .baseUrl("http://www.exm.com")
          .addConverterFactory(GsonConverterFactory.create())
          .client(new OkHttpClient())
          .build();

public interface RestApi {
    @GET("/search.json")
    Call<List<SearchResult>> search(
      @Query("key") String key
       );

      //可以定义其它请求
      @GET("/something.json")
      Call<SomeThing> dosomething(
          @Query("params") long params
          .......
          .......
       );

}

 RestApi restApi = retrofit.create(RestApi.class);
 Call<List<SearchResult>> searchResultsCall = resetApi.search("retrofit");
 //Response<List<SearchResult> searchResults = searchResultsCall.execute();  同步方法
 searchResultsCall.enqueue(new Callback<List<SearchResult>>() {
        @Override
        public void onResponse(Response<List<SearchResult>> response, Retrofit retrofit) {
          content.setText(response.body().toString());
        }

        @Override
        public void onFailure(Throwable t) {
          content.setText("error");
        }
      });

RestApi restApi = retrofit.create(RestApi.class);  //产生一个RestApi的实例

public <T> T create(final Class<T> service) {
 //返回一个动态代理类的实例
 return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
  //这个InvocationHandler是关键所在，以后调用restapi接口中的方法都会被发送到这里
  new InvocationHandler() {
   private final Platform platform = Platform.get();

   @Override 
   public Object invoke(Object proxy, Method method, Object... args)
     throws Throwable {
    /* 如果是Object的方法，如toString()等，直接调用InvocationHandler的方法，
     *注意，这里其实是没有任何意义的，因为InvocationHandler其实是一个命令传送者
     *在动态代理中，这些方法是没有任何语义的，所以不需要在意
     */
    if (method.getDeclaringClass() == Object.class) {
     return method.invoke(this, args);
    }
    //对于Java8的兼容，在Android中不需要考虑
    if (platform.isDefaultMethod(method)) {
     return platform.invokeDefaultMethod(method, service, proxy, args);
    }
    //返回一个Call对象
    return loadMethodHandler(method).invoke(args);
   } 
  });
}

Call<List<SearchResult>> searchResultsCall = resetApi.search("retrofit"); 

  @Override 
   public Object invoke(Object proxy, Method method, Object... args)
     throws Throwable {
     //proxy对象就是你在外面调用方法的resetApi对象
     //method是RestApi中的函数定义，
     //据此，我们可以获取定义在函数和参数上的注解，比如@GET和注解中的参数
     //args,实际参数，这里传送的就是字符串"retrofit"

    //这里必然是return 一个Call对象
    return loadMethodHandler(method).invoke(args);
   }

//这个OkHttp的工厂，用于产生一个OkHttp类库中的Call，实际上就是传入配置的Builder的OkHttpClient
private final okhttp3.Call.Factory callFactory;
//通过Method中的注解和传入的参数，组建一个OkHttp的Request
private final RequestFactory requestFactory;
//用于对Retrofit中的Call进行代理
private final CallAdapter<?> callAdapter;
//用于反序列化返回结果
private final Converter<ResponseBody, ?> responseConverter;

// 返回一个Call对象
Object invoke(Object... args) { 
  return callAdapter.adapt(new OkHttpCall<>(callFactory, requestFactory, args, responseConverter));
}

 new CallAdapter.Factory {
   @Override 
    public <R> Call<R> adapt(Call<R> call) { return call;}
 }

class CacheCall implements Call {
  Call delegate;
   CacheCall(Call call) {
     this.delegate = call;
  }

  @Override
  public void enqueue(Callback<T> callback) {
    //查看是否有缓存，否则直接走网络
    if(cached) {
      return cache;
    }
    this.delegate.enqueue(callback);
  }
}

@Override 
public void enqueue(final Callback<T> callback) {
 okhttp3.Call rawCall;
 try {
  //创建一个okhttp的Call
  rawCall = createRawCall();
 } catch (Throwable t) {
  callback.onFailure(t);
  return;
 }
 //直接调用okhttp的入队操作
rawCall.enqueue(new okhttp3.Callback() {
 private void callFailure(Throwable e) {
  try {
   callback.onFailure(e);
  } catch (Throwable t) {
   t.printStackTrace();
  }
 }

 private void callSuccess(Response<T> response) {
  try {
   callback.onResponse(response);
  } catch (Throwable t) {
   t.printStackTrace();
  }
 }

 @Override 
 public void onFailure(Request request, IOException e) {
  callFailure(e);
 }

 @Override 
  public void onResponse(okhttp3.Response rawResponse) {
  Response<T> response;
  try {
   //解析结果
   response = parseResponse(rawResponse);
  } catch (Throwable e) {
   callFailure(e);
   return;
  }
  callSuccess(response);
 }
});
}