在Android上写过网络请求的小伙伴对Retrofit应该不陌生，这里我们先来简单回顾一下Retrofit。

Retrofit

Retrofit 是由Square公司开源的适用于Android和java的类型安全的Http客户端。

使用方法相当简单，首先将需要的http请求以接口的形式定义出来：

public interface GitHubService {
  @GET("users/{user}/repos")
  Call<List<Repo>> listRepos(@Path("user") String user);
}

接着使用Retrofit生成GitHubService接口的实例。

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build();

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

接着只需要调用对应接口即可：

Call<List<Repo>> repos = service.listRepos("octocat");

以上调用会使用get方式请求https://api.github.com/users/octocat/repos

分析实现原理

如果只是简单看上面的demo，会发现 Retrofit 似乎给我们变了一个小魔术，让我们的接口直接就能做网络请求了。但魔术终归只是障眼法，我们来分析一下魔术背后的原理。

首先，为什么定义了接口就能直接用了，其实这在 java 中也不是什么新鲜事了，有很多手段可以实现这个。其中最简单的就是 Proxy 的 newProxyInstance() 方法，它可以动态生成一个接口的实例。

接着就是get网络请求 url:https://api.github.com/users/octocat/repos 是如何得到的？这个其实也很简单，Retrofit 使用 Get 这个注解来标明这是一个 get 请求，然后使用 Path 来表示请求中需要被替换的 path，最后使用将 baseUrl 中拿到的 url 和 Get 中的路径拼接，就能得到最后需要的 url 了。

魔术背后的原理都知道了，接下来就看看怎么进行表演网络请求这个魔术了。

实现一个最简单的 Get 请求

接下来我们实现这么一个简单的请求百度首页的功能：

    interface SimpleRequest{
        @GET
        String goBaidu(@Url String url);
    }

SimpleRequest simpleRequest = new Retro.
                Builder().
                build().
                create(SimpleRequest.class);
println(simpleRequest.goBaidu("http://www.baidu.com"));

上面我们定义了一个 SimpleRequest 的接口，定义了 goBaidu 这个方法，使用 Get 来表示它是一个 get 请求，用 Url 来表示参数 url 就是这个请求的完整的地址。

接着使用 Retro 这个类来生成 SimpleRequest 的实例，最后使用 println 来打印出 goBaidu("http://www.baidu.com") 这个调用的结果。

定义 GET 和 Url 注解

首先定义 GTE 和 Url 这两个注解：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface GET {
    String value() default "";
}


@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
public @interface Url {
}

这两个注解比较简单，不多说什么。

定义 Retro

接着定义Retro这个类：

public class Retro {
    
    @SuppressWarnings("unchecked")
    public <T> T create(final Class<T> server){
        return (T)Proxy.newProxyInstance(server.getClassLoader(), new Class<?>[]{server}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                ServiceMethod.Builder builder = new ServiceMethod.Builder(Retro.this,method,args);
                ServiceMethod serviceMethod = builder.build();
                return serviceMethod.call();
            }
        });
    }

}

目前Retro这个类只有一个方法 create 方法，其接受一个 Class 对象，并返回这个 Class 所对应的实例。由于使用的是 Proxy 的 newProxyInstance 方法，所有的方法都会被 InvocationHandler 对象的 invoke 方法拦截，也可以说是被代理了。

接着我们在 invoke 方法中看到了 ServiceMethod 这个类，它是这里的关键，所有请求相关的处理都是在其中被完成。接着我们就来看一下 ServiceMethod 应该怎么编写。

定义 ServiceMethod

由于需要在 ServiceMethod 处理相关数据，所以需要将 Retro,method,args 这几个对象传递给它。其中 Retro 用于获得一些全局的变量，这里暂时用不到。 method 用于获得 http 的请求方法和 Url 注解所标注的 url。 args 则是 Url 注解所标注的实际参数。

知道了这些以后就可以编写代码了：

public static final class Builder{

        private String baseUrl;

        private Object args[];

        private String httpMethod ;

        private Class<?>[] methodParamsTypes;

        private final Annotation[] methodAnnotations;
        private final Annotation[][] methodParamsAnnotations;
        
        public Builder(Retro retro, Method method, Object[] args){
            this.args = args;
            this.methodAnnotations = method.getAnnotations();
            this.methodParamsAnnotations = method.getParameterAnnotations();
            this.methodParamsTypes = method.getParameterTypes();
        }

        public ServiceMethod build(){
            for(int i = 0;i<methodAnnotations.length;i++){
                parseMethodAnnotation(methodAnnotations[i]);
            }
            for(int i = 0;i<methodParamsAnnotations.length;i++){
                parseMethodParamsAnnotation(methodParamsAnnotations[i],args[i],methodParamsTypes[i]);
            }

            return new ServiceMethod(this);
        }

        private void parseMethodAnnotation(Annotation annotation){
            if(annotation instanceof GET){
                parseHttpMethodAndPath("GET",((GET)annotation).value(),false);
            }
        }

        private void parseMethodParamsAnnotation(Annotation[] annotations,Object value,Class<?> type){
            if(annotations.length == 1){
                Annotation annotation = annotations[0];
                if(annotation instanceof Url){
                    baseUrl = String.valueOf(value);
                }
            }
        }
        private void parseHttpMethodAndPath(String httpMethod,String value,boolean hasBody){
            this.httpMethod = httpMethod;
        }
    }

ServiceMethod 还是使用 Builder 来构建，看 build 方法，首先对方法的注解进行处理，即需要得到这里的 GET 注解，看 parseMethodAnnotation 方法，

 private void parseMethodAnnotation(Annotation annotation){
     if(annotation instanceof GET){
         parseHttpMethodAndPath("GET",((GET)annotation).value(),false);
     }
 }

这里过滤我们的 GET 注解，让后调用 parseHttpMethodAndPath 方法对其进行处理：

   private void parseHttpMethodAndPath(String httpMethod,String value,boolean hasBody){
       this.httpMethod = httpMethod;
   }

这里我们就得到了 http 的请求方法，即 GET 。

接着看 parseMethodParamsAnnotation 这个方法，用于解析方法参数的标注，即这里的 Url 标注。

private void parseMethodParamsAnnotation(Annotation[] annotations,Object value,Class<?> type){
    if(annotations.length == 1){
        Annotation annotation = annotations[0];
        if(annotation instanceof Url){
            baseUrl = String.valueOf(value);
        }
    }
}

这个方法会遍历所有参数的标注，如果有 Url 标注，就拿到对应参数的值，将其赋值给 baseUrl。

最后返回 ServiceMethod 实例。

下面看一下 ServiceMethod 的主要代码：

public class ServiceMethod{

    private final String mBaseUrl;

    private final String mHttpMethod;

    ServiceMethod(Builder builder){
        mBaseUrl = builder.baseUrl;
        mHttpMethod = builder.httpMethod;
    }

    public String call(){

        try {
            URL url = new URL(mBaseUrl);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setDoInput(true);
            connection.setDoOutput(true);
            //set heep method
            connection.setRequestMethod(mHttpMethod);

            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            InputStream inputStream = connection.getInputStream();
            int len ;
            byte[] buffer = new byte[1024];
            while ((len = inputStream.read(buffer))>0){
                bos.write(buffer,0,len);
            }
            String body = new String(bos.toByteArray());
            connection.disconnect();
            return body;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "";
    }

    ...

我们可以看到在 ServiceMethod 的构造方法中，拿到了 Builder 中的 baseUrl 和 httpMethod，有了这两个标量其实就能做实际的 http 请求了。

接着看 call 这个方法，魔术的最终一环就是在这里完成的，单看 call 这个方法中的内容很简单，就是使用 URL 进行一次 http 请求。请求方法为 mHttpMethod，url 为 mBaseUrl，即一开始的 "http://www.baidu.com" 。
最后将请求到的数据转换成 String 对象返回，即对应下面的 serviceMethod.call() 。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    ServiceMethod.Builder builder = new ServiceMethod.Builder(Retro.this,method,args);
    ServiceMethod serviceMethod = builder.build();
    return serviceMethod.call();
}

运行结果

自后我们跑一下下面的方法：

    @Test
    public void testAnnotation_Url(){
        SimpleRequest simpleRequest = new Retro().
                create(SimpleRequest.class);
        println(simpleRequest.goBaidu("http://www.baidu.com"));

    }

总结

到这里一个简单的类似 Retrofit 的 http 客户端就完成了，它可以完成最简单 http 的 get 请求。
当然这篇主要讲的是 Retro 的一个大体结构，用于了解类似 Retrofit 这类第三方库的实现思路。后面还会推出一系列文章，用于讲解如何实现 GET 注解自定义 Path，POST 注解及表单处理，返回类型转换，错误处理等功能。