android 网络操作新框架Retrofit

Android Retrofit 使用

1.定义

    最近这一年内Retrofit在Android开发中使用是非常的火，使用这个框架后网络请求代码边的非常的简洁，提高了代码的维护性和可读性。

   官网地址：Retrofit官网

   官网上面对他的定义是：

A type-safe HTTP client for Android and Java

根据定义来看是一种Http的请求工具，目前为止这种http请求的工具框架是很对的，比如google的Volley，以及OkHttp。读他们的源码你会发现他们其实都是对原始的Http代码加以封装，实现代码的重用和耦合。简化了代码的调用。能够为我们更好的使用。

2.如何使用

  1.定义你返回的数据和请求的方式

public interface GitHubService {
     //获取用户列表
    @GET("GetUserListByResource")
    Call<List<GsonBean>> getUserInfo(@Query("application") String application, @Query("orgGuid") String orgGuid, @Query("resourceName") String resourceName, @Query("isRootOrg") String isRootOrg);
}

   这个的意思是采用的请求方式是GET.

返回的数据是经过Gson解析成一个集合，传递的参数有四个,

2.创建Retrofit对象实现获取数据

Retrofit retrofit = new Retrofit.Builder()
   .baseUrl("http://地址/api/UserData/")
   .addConverterFactory(GsonConverterFactory.create())
   .build();
GitHubService service = retrofit.create(GitHubService.class);
Call<List<GsonBean>> call = service.getUserInfo("parmeara1","pamera2","pamera3","pamera4");
call.enqueue(new Callback<List<GsonBean>>() {
   @Override
   public void onResponse(Call<List<GsonBean>> call, Response<List<GsonBean>> response) {
      try{
         if(response != null){

//这里返回的就是你定义的数据的格式是一个集合列表，我这里只是
                      if(response.body() != null ){
                          for(GsonBean entity : response.body()){
                              if(entity != null){
                                  LogUtil.i("Account==",entity.getAccount());
                                  LogUtil.i("Name==",entity.getName());
                                  LogUtil.i("手机==",entity.get手机());
                                  LogUtil.i("创建时间==",entity.get创建时间());
                              }
                          }
                      }
                  }
      }catch (Exception e){
         e.printStackTrace();
      }
   }

   @Override
   public void onFailure(Call<List<GsonBean>> call, Throwable t) {
              LogUtil.d("数据===", call.toString() );
   }
});

这是最简单的使用方法，服务器端采用的webApi的方式来搞的。因为他集成了Gson的解析过程

所以我们在定义服务的时候就就将解析给加上了。这样一个网络请求加数据解析就完成了。

这个用法看上去和其他的有关网络请求的操作是完全不一样的，比如Volley,其他的网络请求要设置请求方式，Url，参数，以及成功失败的回调操作，还有网络请求等，要写一系列的代码，而采用Retrofit的话我们只需要定义一个接口，设置请求方式，以及参数就行了。非常的便捷。

但是你从本质上而言，其实Retrofit和其他网络请求的方式本质上是一样的，只是这个框架 描述HTTP请求的方式不一样而已 。因此， 你可以发现上面的 GitHubService 接口其实就是 Retrofit 对一个HTTP请求的描述。

3.Retrofit实现原理

对于接口服务使用，官网上面给出的这句解释我完全没有看懂。

The Retrofit class generates an implementation of the GitHubService interface.

实例化Retrofit对象采用的是建造者的模式来创建的，创建的同时已经设置好了请求的地址，和JSON的自动转换。

但是下面这句代码完全没有搞懂，读源码才发现。这个采用的（java的动态代理）

GitHubService service = retrofit.create(GitHubService.class);

源码如下：

/**
 * Create an implementation of the API endpoints defined by the {@code service} interface.
 * <p>
 * The relative path for a given method is obtained from an annotation on the method describing
 * the request type. The built-in methods are {@link retrofit2.http.GET GET},
 * {@link retrofit2.http.PUT PUT}, {@link retrofit2.http.POST POST}, {@link retrofit2.http.PATCH
 * PATCH}, {@link retrofit2.http.HEAD HEAD}, {@link retrofit2.http.DELETE DELETE} and
 * {@link retrofit2.http.OPTIONS OPTIONS}. You can use a custom HTTP method with
 * {@link HTTP @HTTP}. For a dynamic URL, omit the path on the annotation and annotate the first
 * parameter with {@link Url @Url}.
 * <p>
 * Method parameters can be used to replace parts of the URL by annotating them with
 * {@link retrofit2.http.Path @Path}. Replacement sections are denoted by an identifier
 * surrounded by curly braces (e.g., "{foo}"). To add items to the query string of a URL use
 * {@link retrofit2.http.Query @Query}.
 * <p>
 * The body of a request is denoted by the {@link retrofit2.http.Body @Body} annotation. The
 * object will be converted to request representation by one of the {@link Converter.Factory}
 * instances. A {@link RequestBody} can also be used for a raw representation.
 * <p>
 * Alternative request body formats are supported by method annotations and corresponding
 * parameter annotations:
 * <ul>
 * <li>{@link retrofit2.http.FormUrlEncoded @FormUrlEncoded} - Form-encoded data with key-value
 * pairs specified by the {@link retrofit2.http.Field @Field} parameter annotation.
 * <li>{@link retrofit2.http.Multipart @Multipart} - RFC 2388-compliant multipart data with
 * parts specified by the {@link retrofit2.http.Part @Part} parameter annotation.
 * </ul>
 * <p>
 * Additional static headers can be added for an endpoint using the
 * {@link retrofit2.http.Headers @Headers} method annotation. For per-request control over a
 * header annotate a parameter with {@link Header @Header}.
 * <p>
 * By default, methods return a {@link Call} which represents the HTTP request. The generic
 * parameter of the call is the response body type and will be converted by one of the
 * {@link Converter.Factory} instances. {@link ResponseBody} can also be used for a raw
 * representation. {@link Void} can be used if you do not care about the body contents.
 * <p>
 * For example:
 * <pre>
 * public interface CategoryService {
 *   &#64;POST("category/{cat}/")
 *   Call&lt;List&lt;Item&gt;&gt; categoryList(@Path("cat") String a, @Query("page") int b);
 * }
 * </pre>
 */
@SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety.
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);
          }
          ServiceMethod serviceMethod = loadServiceMethod(method);
          OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
          return serviceMethod.callAdapter.adapt(okHttpCall);
        }
      });
}

看到注释了吗？我看到注释也是懵逼了，这么长的注释看完只知道这个是一个接口，采用的是代理的方式来执行，结 果返回了一个动态代理的调用。那么你对java的动态代理熟悉不？如果不熟悉的话，问题就来了，因为你不熟悉动态代理的话你根本就看不懂代码。那建议看看这篇文章java动态代理详解。

接下来这行代码

Each Call from the created GitHubService can make a synchronous or asynchronous HTTP request to the remote webserver.

Call<List<GsonBean>> call = service.getUserInfo("parmeara1","pamera2","pamera3","pamera4");

//意思是通过创建的接口来得到Call对象，call对象是用来获取数据采用同步或者异步的方式从服务器端。这个执行的结果是通过这行代码生成了一个Http的请求，包括header和Url，Params等这些参数。然后通过call.enqueue(CallBack<List<GsonBean>>)

执行异步或者同步的网络操作。相当于发送一个请求到服务器端。这样就玩成了整个操作。

4.Retrofit源码分析

要彻底的理解Retrofit的原理的话，还是要从源码入手看看。官网上面的版本目前是2.0.2.

Retrofit的源码分为二部分，结构图如下所示。

1.Http包，这个是一些http请求的基本使用方法的注解，包括HTTP,POST,GET,PUSH,HEAD的注解。结构如下图：

2.其他结构的包，包括对GSON的解析转换，真正的网络请求是交给OkHttp来执行的，所以代码是比较少的。

Callback<T>

这个接口中定义了二个方法一个请求成功后用来回调接收http响应数据的。另外一个是请求失败后的通知操作。

public interface Callback<T> {
  /**
   * Invoked for a received HTTP response.
   * <p>
   * Note: An HTTP response may still indicate an application-level failure such as a 404 or 500.
   * Call {@link Response#isSuccessful()} to determine if the response indicates success.
   */
  void onResponse(Call<T> call, Response<T> response);

  /**
   * Invoked when a network exception occurred talking to the server or when an unexpected
   * exception occurred creating the request or processing the response.
   */
  void onFailure(Call<T> call, Throwable t);
}

第二个接口Convert<F,T>,这个接口是用来转换数据的。源码结构如下

/**
 * Convert objects to and from their representation in HTTP. Instances are created by {@linkplain
 * Factory a factory} which is {@linkplain Retrofit.Builder#addConverterFactory(Factory) installed}
 * into the {@link Retrofit} instance.
 */
public interface Converter<F, T> {
  T convert(F value) throws IOException;

  /** Creates {@link Converter} instances based on a type and target usage. */
  abstract class Factory {
    /**
     * Returns a {@link Converter} for converting an HTTP response body to {@code type}, or null if
     * {@code type} cannot be handled by this factory. This is used to create converters for
     * response types such as {@code SimpleResponse} from a {@code Call<SimpleResponse>}
     * declaration.
     */
    public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
        Retrofit retrofit) {
      return null;
    }

    /**
     * Returns a {@link Converter} for converting {@code type} to an HTTP request body, or null if
     * {@code type} cannot be handled by this factory. This is used to create converters for types
     * specified by {@link Body @Body}, {@link Part @Part}, and {@link PartMap @PartMap}
     * values.
     */
    public Converter<?, RequestBody> requestBodyConverter(Type type,
        Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
      return null;
    }

    /**
     * Returns a {@link Converter} for converting {@code type} to a {@link String}, or null if
     * {@code type} cannot be handled by this factory. This is used to create converters for types
     * specified by {@link Field @Field}, {@link FieldMap @FieldMap} values,
     * {@link Header @Header}, {@link Path @Path}, {@link Query @Query}, and
     * {@link QueryMap @QueryMap} values.
     */
    public Converter<?, String> stringConverter(Type type, Annotation[] annotations,
        Retrofit retrofit) {
      return null;
    }
  }
}

这个设计还是蛮诡异的，接口里面创建一个类。我平时在代码中很少这样写，这个接口是何GsonConverterFactory这个类一起使用的。核心的代码都在这里了

public final class GsonConverterFactory extends Converter.Factory {
  /**
   * Create an instance using a default {@link Gson} instance for conversion. Encoding to JSON and
   * decoding from JSON (when no charset is specified by a header) will use UTF-8.
   */
  public static GsonConverterFactory create() {
    return create(new Gson());
  }

  /**
   * Create an instance using {@code gson} for conversion. Encoding to JSON and
   * decoding from JSON (when no charset is specified by a header) will use UTF-8.
   */
  public static GsonConverterFactory create(Gson gson) {
    return new GsonConverterFactory(gson);
  }

  private final Gson gson;

  private GsonConverterFactory(Gson gson) {
    if (gson == null) throw new NullPointerException("gson == null");
    this.gson = gson;
  }

  @Override
  public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
      Retrofit retrofit) {
    TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
    return new GsonResponseBodyConverter<>(gson, adapter);
  }

  @Override
  public Converter<?, RequestBody> requestBodyConverter(Type type,
      Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
    TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
    return new GsonRequestBodyConverter<>(gson, adapter);
  }
}

看到最后二个方法了吗？这才是这个类的核心所在。

Call<T> 

这个接口才是开始发送请求的回调，代码如下

/**
 * An invocation of a Retrofit method that sends a request to a webserver and returns a response.
 * Each call yields its own HTTP request and response pair. Use {@link #clone} to make multiple
 * calls with the same parameters to the same webserver; this may be used to implement polling or
 * to retry a failed call.
 *
 * <p>Calls may be executed synchronously with {@link #execute}, or asynchronously with {@link
 * #enqueue}. In either case the call can be canceled at any time with {@link #cancel}. A call that
 * is busy writing its request or reading its response may receive a {@link IOException}; this is
 * working as designed.
 *
 * @param <T> Successful response body type.
 */
public interface Call<T> extends Cloneable {
  /**
   * Synchronously send the request and return its response.
   *
   * @throws IOException if a problem occurred talking to the server.
   * @throws RuntimeException (and subclasses) if an unexpected error occurs creating the request
   * or decoding the response.
   */
  Response<T> execute() throws IOException;

  /**
   * Asynchronously send the request and notify {@code callback} of its response or if an error
   * occurred talking to the server, creating the request, or processing the response.
   */
  void enqueue(Callback<T> callback);

  /**
   * Returns true if this call has been either {@linkplain #execute() executed} or {@linkplain
   * #enqueue(Callback) enqueued}. It is an error to execute or enqueue a call more than once.
   */
  boolean isExecuted();

  /**
   * Cancel this call. An attempt will be made to cancel in-flight calls, and if the call has not
   * yet been executed it never will be.
   */
  void cancel();

  /** True if {@link #cancel()} was called. */
  boolean isCanceled();

  /**
   * Create a new, identical call to this one which can be enqueued or executed even if this call
   * has already been.
   */
  Call<T> clone();

  /** The original HTTP request. */
  Request request();
}

看到没有你们熟悉的方法，其实这个Call主要使用的是okHttp中的Call。只是在这里做了一个转换，你看Retrofit源码中的create方法。

enqueue(CallBack<T>); 异步的请求

 Response<T> execute() ;同步请求

  CallAdapter<T>这个接口中有一个属性responeType。还有一个<R> T adapt(Call<R> call)的方法，这个接口的实现只有一个DefaultCallAdapter。这个方法的主要作用格式将Call对象转换成另一个对象，可能是为了支持RxJava。这个在项目中目前还没有用。后续估计会加入。
CallAdapter的代码我贴上来。

/**
 * Adapts a {@link Call} into the type of {@code T}. Instances are created by {@linkplain Factory a
 * factory} which is {@linkplain Retrofit.Builder#addCallAdapterFactory(Factory) installed} into
 * the {@link Retrofit} instance.
 */
public interface CallAdapter<T> {
  /**
   * Returns the value type that this adapter uses when converting the HTTP response body to a Java
   * object. For example, the response type for {@code Call<Repo>} is {@code Repo}. This type
   * is used to prepare the {@code call} passed to {@code #adapt}.
   * <p>
   * Note: This is typically not the same type as the {@code returnType} provided to this call
   * adapter's factory.
   */
  Type responseType();

  /**
   * Returns an instance of {@code T} which delegates to {@code call}.
   * <p>
   * For example, given an instance for a hypothetical utility, {@code Async}, this instance would
   * return a new {@code Async<R>} which invoked {@code call} when run.
   * <pre><code>
   * &#64;Override
   * public &lt;R&gt; Async&lt;R&gt; adapt(final Call&lt;R&gt; call) {
   *   return Async.create(new Callable&lt;Response&lt;R&gt;&gt;() {
   *     &#64;Override
   *     public Response&lt;R&gt; call() throws Exception {
   *       return call.execute();
   *     }
   *   });
   * }
   * </code></pre>
   */
  <R> T adapt(Call<R> call);

  /**
   * Creates {@link CallAdapter} instances based on the return type of {@linkplain
   * Retrofit#create(Class) the service interface} methods.
   */
  abstract class Factory {
    /**
     * Returns a call adapter for interface methods that return {@code returnType}, or null if it
     * cannot be handled by this factory.
     */
    public abstract CallAdapter<?> get(Type returnType, Annotation[] annotations,
        Retrofit retrofit);

    /**
     * Extract the upper bound of the generic parameter at {@code index} from {@code type}. For
     * example, index 1 of {@code Map<String, ? extends Runnable>} returns {@code Runnable}.
     */
    protected static Type getParameterUpperBound(int index, ParameterizedType type) {
      return Utils.getParameterUpperBound(index, type);
    }

    /**
     * Extract the raw class type from {@code type}. For example, the type representing
     * {@code List<? extends Runnable>} returns {@code List.class}.
     */
    protected static Class<?> getRawType(Type type) {
      return Utils.getRawType(type);
    }
  }
}

在Retrofit中使用的时候采用这种方式来实现；

public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
  adapterFactories.add(checkNotNull(factory, "factory == null"));
  return this;
}

5.总结

Retrofit非常巧妙的用注解来描述一个HTTP请求，将一个HTTP请求抽象成一个Java接口，然后用了Java动态代理的方式，动态的将这个接口的注解“翻译”成一个HTTP请求，最后再执行这个HTTP请求

Retrofit的功能非常多的依赖Java反射，代码中其实还有很多细节，比如异常的捕获、抛出和处理，大量的Factory设计模式（为什么要这么多使用Factory模式？）

Retrofit中接口设计的恰到好处，在你创建Retrofit对象时，让你有更多更灵活的方式去处理你的需求，比如使用不同的 、使用不同的ConverAdapter ，这也就提供了你使用RxJava来调用Retrofit的可能

我也慢慢看了Picasso 和 Retrofit 的代码了，收获还是很多的，也更加深入的理解面向接口的编程方法，这个写代码就是 好的代码就是依赖接口而不是实现 最好的例子.这样的就是好的代码，扩展性强、低耦合、插件化。可以说对面向对象的设计是出神入化。