Retrofit是一个在OKhttp的基础上，使用注解和动态代理实现的网络请求框架

官网上给出了非常简洁的使用示例:

retrofit_sl.jpg

本文不在于说明retrofit怎么使用，官方文档写的很详细。主要是通过retrofit去了解注解和动态代理，retrofit是如何通过注解和动态代理去把复杂的网络请求配置简化成寥寥几行代码的。

注解

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

使用过retrofit都知道@GET("users/{user}/repos")和 @Path("user")都是具有特殊含义的。
我们先来看看这两个注解类

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

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.PARAMETER})
public @interface Path {
    String value();

    boolean encoded() default false;
}

简单的介绍一下

@Documented

Documented的英文意思是文档。它的作用是能够将注解中的元素包含到javadoc中去。

@ Retention

Retention英文意思是保留、保持的意思，它表示注解存在阶段是保留在源码（编译器），字节码（类加载）或者运行期（JVM中运行）。在@ Retention注解中使用枚举RetentionPolicy来表示注解保留时期

• @Retention(RetentionPolicy.SOURCE)，注解仅存在于源码中，在class字节码文件中不包含
• @Retention(RetentionPolicy.CLASS)，默认的保留策略，注解会在class字节码文件中保存，但运行时无法获得
• @Retention(RetentionPolicy.RUNTIME)，注解会在class字节码文件中保存，在运行时可以通过反射获取

很显然上面的两个注解都是帮助我们完成网络请求配置的，它们使用的都是@Retention(RetentionPolicy.RUNTIME)

@Target

Target的英文意思是目标，这个很容易理解，使用@Target元注解表示我们的注解作用的范围，可以是类、函数、函数参数变量等

• @Target(ElementType.TYPE) 作用接口、类、枚举、注解
• @Target(ElementType.FIELD) 作用属性字段、枚举的常量
• @Target(ElementType.METHOD) 作用方法
• @Target(ElementType.PARAMETER) 作用方法参数
• @Target(ElementType.CONSTRUCTOR) 作用构造函数
• @Target(ElementType.LOCAL_VARIABLE)作用局部变量
• @Target(ElementType.ANNOTATION_TYPE)作用于注解（@Retention注解中就使用该属性）
• @Target(ElementType.PACKAGE) 作用于包
• @Target(ElementType.TYPE_PARAMETER) 作用于类型泛型，即泛型方法、泛型类、泛型接口 （jdk1.8加入）
• @Target(ElementType.TYPE_USE) 类型使用.可以用于标注任意类型除了 class （jdk1.8加入）

GET作用于函数，它使用的是ElementType.METHOD
Path作用于函数参数，它使用的是ElementType.PARAMETER

大致看一下就行，重点是如何在需要的时候去获取这些注解信息
为了说一下如何获取类上的注解信息，我特地建了一个Test的注解，作用目标是类,有一个string类的属性

@Documented
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {
    String value() default "";
}

GitHubService类是这样的

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

下面就贴分别如何获取类、函数、参数上的注解信息的代码

package retrofittest

import retrofit2.http.FieldMap
import retrofit2.http.GET
import retrofit2.http.Path

/**
 * Author:wangling
 * Email:wl_0420@163.com
 * Date:6/21/21 4:19 PM
 */
fun main() {
    // 获取类上的注解

    var java = GitHubService::class.java//获取类对象
    if (java.isAnnotationPresent(Test::class.java)) {//判断是否包含@Test 注解
        java.getAnnotation(Test::class.java)?.let {//获取 @Test 注解
            println("获取类上的注解的信息：" + it.value)
        }
    }


    // 获取函数上的注解
    var method = GitHubService::class.java.getDeclaredMethod("listRepos", String::class.java)//从类里获取名称为listRepos的函数的Method
    if (method.isAnnotationPresent(GET::class.java)) {//判断是否包含@GET 注解
        method.getAnnotation(GET::class.java)?.let {//获取@GET 注解
            println("获取函数上注解的信息：" + it.value)
        }
    }
    //获取函数参数上的注解
    //注意 method.parameterAnnotations 是一个二维数组 [][]  第一个坐标代表是第几个参数   第二个坐标代表当前参数的第几个注解
    // 因为参数前可以添加多个注解,,一个参数上不可以添加相同的注解,同一个注解可以加在不同的参数上
    for (ann in method.parameterAnnotations) {
        println("ann: $ann")
        for (a in ann) {
            println("a: $a")
            if (FieldMap::class.java.isInstance(a)) {
                a as FieldMap
                println("获取参数上的注解信息：" + a.encoded)

            } else if (Path::class.java.isInstance(a)) {
                a as Path
                println("获取参数上的注解信息：" + a.value)
                println("获取参数上的注解信息：" + a.encoded)
            }
        }
    }
}

打印

获取类上的注解的信息：testinterface
获取函数上注解的信息：users/{user}/repos
ann: [Ljava.lang.annotation.Annotation;@f6f4d33
a: @retrofit2.http.FieldMap(encoded=false)
获取参数上的注解信息：false
a: @retrofit2.http.Path(encoded=false, value=user)
获取参数上的注解信息：user
获取参数上的注解信息：false

那么注解在retrofit中的作用就完成了，简洁且明了的提供了网络请求必须的参数

动态代理

代理模式是23种设计模式之一。
定义：为其它对象提供一种代理以控制对这个对象的访问
使用场景：当无法或不想直接访问某个对象时可以通过一个代理对象来间接访问，为了保证客户端使用的透明性，委托对象与代理对象必须实现相同的接口。
下面通过代码简单示例一个静态代理

// 定义一个接口
public interface BuyHouse {
    void buyHosue();
}

//创建一个实现类，也就是被代理类
public class BuyHouseImpl implements BuyHouse {
    @Override
    public void buyHosue() {
        System.out.println("我要买房");
    }
}
//创建一个代理类
public class BuyHouseProxy implements BuyHouse {
    public BuyHouse buyHouse;

    public BuyHouseProxy(final BuyHouse buyHouse) {
        this.buyHouse = buyHouse;
    }

    @Override
    public void buyHosue() {
        System.out.println("买房前准备");
        buyHouse.buyHosue();
        System.out.println("买房后装修");
    }
}

代理类BuyHouseProxy持有被代理类BuyHouseImpl的对象，通过调用BuyHouseProxy示例的方法就可以间接的调用BuyHouseImpl的方法。

在一般情况使用静态代理并没有什么问题，但是在需要代理的类很多时，每个被代理类去实现一个代理类就会很麻烦，于是动态代理应运而生。

//编写一个动态处理期
public class DynamicProxyHandler implements InvocationHandler {
    private Object object;

    public DynamicProxyHandler(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("买房前准备");
        Object invoke = method.invoke(object, args);
        System.out.println("买房后装修");
        return invoke;
    }
}
//编写一个测试类
public class DynamicProxyTest {
    public static void main(String[] args) {
        BuyHouse buyHouse = new BuyHouseImpl();
        BuyHouse proxyBuyHouse = (BuyHouse) Proxy.newProxyInstance(BuyHouse.class.getClassLoader(), new Class[]{BuyHouse.class}, new DynamicProxyHandler(buyHouse));
        proxyBuyHouse.buyHosue();
    }
}

要使用动态代理就是这么简单，而动态代理的原理就不阐述了，急于想探究新世界的小伙伴可以点击JAVA动态代理查看

看到这里可能有小伙伴发出了质疑，上面的动态代理示例中，要使用动态代理必须有一个实现类也就是被代理类，可是我们在使用的过程中只是定义了Service接口，利用不同的注解给方法及参数设置了一些配置信息。那么这个实现类该怎么获取。
看retrofit的源码
Retrofit.class

...  关键位置，就是在这里实现动态代理
    public <T> T create(final Class<T> service) {
        Utils.validateServiceInterface(service);
        if (this.validateEagerly) {
            this.eagerlyValidateMethods(service);
        }

        return Proxy.newProxyInstance(service.getClassLoader(), new Class[]{service}, new InvocationHandler() {
            private final Platform platform = Platform.get();

            public Object invoke(Object proxy, Method method, Object... args) throws Throwable {
                if (method.getDeclaringClass() == Object.class) {//没看懂。。。
                    return method.invoke(this, args);
                } else if (this.platform.isDefaultMethod(method)) {
                    return this.platform.invokeDefaultMethod(method, service, proxy, args);
                } else {
                    ServiceMethod serviceMethod = Retrofit.this.loadServiceMethod(method);
                    OkHttpCall okHttpCall = new OkHttpCall(serviceMethod, args);
                    return serviceMethod.callAdapter.adapt(okHttpCall);
                }
            }
        });
    }
...

重点看

    ServiceMethod serviceMethod = Retrofit.this.loadServiceMethod(method);
    OkHttpCall okHttpCall = new OkHttpCall(serviceMethod, args);
    return serviceMethod.callAdapter.adapt(okHttpCall);

ServiceMethod是一个负责转化(适配)的类，负责把一个接口的抽象方法的执行过程的结果转化(适配)成一个网络请求(HTTP call)。
ServiceMethod是如何获得的
ServiceMethod serviceMethod = Retrofit.this.loadServiceMethod(method);
点进去查看

    ServiceMethod loadServiceMethod(Method method) {
        synchronized(this.serviceMethodCache) {
             //现在缓存查找
            ServiceMethod result = (ServiceMethod)this.serviceMethodCache.get(method);
            if (result == null) {
                没有就创建一个，并保存到缓存里
                result = (new retrofit2.ServiceMethod.Builder(this, method)).build();
                this.serviceMethodCache.put(method, result);
            }

            return result;
        }
    }

怎么创建的？
看Builder

        public Builder(Retrofit retrofit, Method method) {
            this.retrofit = retrofit;
            this.method = method;
            this.methodAnnotations = method.getAnnotations();
            this.parameterTypes = method.getGenericParameterTypes();
            this.parameterAnnotationsArray = method.getParameterAnnotations();
        }

有没有发现是熟悉的地方。
method.getAnnotations();获取方法的所有注解
method.getParameterAnnotations();获得方法参数上的所有注解
有个这些，ServiceMethod是不是就可以获取到了我们设置的配置信息了。至此retrofit、动态代理、注解就可以串起来了。

当然retrofit还有很多设置，如序列化设置addConverterFactory、rxjava支持addCallAdapterFactory这里就不说了