如何应对Android面试官-＞Retrofit中注解、反射、动态代理、手写实现

关注

原创最新推荐文章于 2026-06-08 13:17:32 发布 1.1k 阅读 AI 写同款· GEO 优化 ›

Retrofit核心源码分析（一）- 注解解析和动态代理 Retrofit是目前Android平台上比较流行的网络请求框架之一，它提供了一种简洁、灵活的方式来处理HTTP请求和响应。Retrofit的设计目的是使网络请求的代码更加容易编写和阅读，同时还提供了许多有用的特性，如注解解析、动态代理等。在本文中，我们将对Retrofit的注解解析和动态代理进行详细的分析。阅读详情

注解反射可以查看上一章的讲解如何应对Android面试官->Java中的注解、反射、手写ButterKnife核心实现

代理模式

静态代理

代理模式类图

静态代理主要分三个角色：抽象角色、真实角色、代理角色

抽象角色：指代理角色和真实角色对外提供的公共方法，一般为一个接口；

public interface Message { 
    void message(); 
}

真实角色：需要实现抽象角色接口，定义了真实角色索要实现的业务逻辑，以便代理角色调用，也是真正的业务逻辑在此；

 public class Alvin implements Message { 
    public void message() { // } 
}

代理角色：需要实现抽象角色接口，是真实角色的代理，通过真实角色的业务逻辑来实现抽象方法，并可以附加自己的操作，将统一流程控制放到代理角色中处理；

通过代理，把调用者对真实对象的调用隔离了起来；

public class Agent implements Message() { 
    private Message message; 
    public Agent(Message message) { 
        this.message = message; 
    } 
    public void message() { 
        // before(); 
        message.message(); 
        after(); 
    } 
    private void before() { } 
    private void after() { } 
}

静态代理模式的实际应用

网络请求框架的封装

隔离层就是我们的代理对象，而真实对象就是我们的封装层，当我们发起网络请求的时候，业务并不需要关心具体使用的是哪个网络框架来发起请求，只需要操作隔离层的 HttpRequest 就行，当我们需要用 Volley 的时候，就只需要把我们的 Volley 的封装层实现赋值给隔离层的 HttpRequest 即可，那么就会使用 Volley 发起网络请求，如果要切换到 OkHttp，那么就只需要创建 OKHttp 的实现并赋值给隔离层的 HttpReqeust 即可；

动态代理

通过一个代理类，来实现全部的代理功能；在运行时再创建代理类和其实例，因此显然效率更低。要完成这个场景，需要在运行期动态创建一个Class。JDK提供了Proxy 来完成这件事；

基本使用

抽象角色

interface Api {
    void test(String passName);
}

真实角色

class ApiImpl implements Api {
    @Override    public void test(String passName) {
        System.out.println("真实实现：" + passName);
    }
}

创建真实实例角色

ApiImpl impl = new ApiImpl();

JDK动态代理实现

Proxy.newProxyInstance(getClass().getClassLoader(), new Class[] {Api.class}, new InvocationHandler() {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
        return Method.invoke(impl, args);
    }
})

实际上， Proxy.newProxyInstance 会创建一个 Class，与静态代理不同，这个 Class 不是由具体的 .java 源文件编译而来，即没有真正的文件，只是在内存中按照 Class 格式生成了一个Class。

动态代理的原理

Android SDK 中的 Proxy.java 中的具体实现

final Class<?> [] intfs = interfaces.clone(); // 对接口进行了一个拷贝，获取了一个 Class 对象的集合；
Class<?> cl = getProxyClass0(loader, intfs); // 获取一个 class
final Constructor<?> cons = cl.getConstuctor(constructorParams); // 获取这个 class 的构造函数
cons.newInstance(new Object[]{h}); // 对这个 class 进行实例化

所以：newProxyInstance() 返回的是一个 class 对象；

那么，这个 Class<?> cl 是怎么来的？它里面的代码是什么样的呢？

那么这个 .class 的实例对象是怎么生成的？

这里要额外提到一点类的生命周期

class 是由 javac 把 .java 文件编译成 .class，是一个实实在在存在的文件，存放在我们的硬盘中，而动态代理帮我们生成了一个 .class 是没有这个文件的，而是直接在内存中一份实例化对象。

通过 ProxyGenerator.generateProxyClass 生成

String var23 = var16 + "$Proxy" + var19;
byte[] var22 = ProxyGenerator.generateProxyClass(var23, var2, var17);
try {    
    return Proxy.defineClass0(var1, var23, var22, 0, var22.length);
} catch (ClassFormatError var14) {    
    throw new IllegalArgumentException(var14.toString());
}

也就是说，我们将 byte[] var22 这个数组写入到一个文件中，就可以看到动态代理帮我们生成的 class 实例对象都有哪些内容

String name = Api.class.getName()+"$Proxy0";
//生成代理指定接口的Class数据
byte[] bytes = ProxyGenerator.generateProxyClass(name, new Class[]{Api.class});
FileOutputStream fos = new FileOutputStream("lib/" + name+".class");
fos.write(bytes);fos.close();

生成的文件中可以查看我们的代理类

在初始化时，获得method 备用。而这个代理类中所有方法的实现变为：

这里的 h 其实就是 InvocationHandler 接口，所以我们在使用动态代理时，传递的InvocationHandler 就是一个监听，在代理对象上执行方法，都会由这个监听回调出来。

手写Retrofit实现

Retrofit 核心实现主要分为四部分注解、Retrofit、ServiceMethod、Parameter

Retrofit的核心实现主要是动态代理、注解解析、构建请求参数、封装Call.Factory发起网络请求。

Retorfit时序图如下：

注解

手写只实现了 @POST、@GET、@QUERY、@FIELD

@Target(METHOD)
@Retention(RUNTIME)
public @interface POST {    
    String value() default "";
}
@Target(METHOD)
@Retention(RUNTIME)
public @interface GET {    
    String value() default "";
}
@Target(PARAMETER)
@Retention(RUNTIME)
public @interface Query {    
    String value();
}
@Target(PARAMETER)
@Retention(RUNTIME)
public @interface Field {    
    String value();
}

动态代理 MyRetrofit

OKHttp 发起网络请求，主要依靠的就是 Call.Factory HttpUrl

Call.Factory 提供了newCall方法用来发起请求，HttpUrl 用来构建请求参数和请求方式

MyRetrofit 也参考 Retorfit 采用建造者模式实现，主要用来让调用方传递构建的 Call.Factory 和 HttpUrl，以及动态代理创建代理对象，调用 ServiceMethod 用来解析注解并封装请求参数；

public class MyRetrofit {    
    // 参考 Retrofit 的实现，也增加一层缓存
    final Map<Method, ServiceMethod> serviceMethodCache = new ConcurrentHashMap<>();    
    // 使用 OKhttp 提供的 Call.Factory
    final Call.Factory callFactory;  
    // 使用 OKHttp 提供的 HttpUrl      
    final HttpUrl baseUrl;
    
    MyRetrofit(Call.Factory callFactory, HttpUrl baseUrl) {                this.callFactory = callFactory;        
        this.baseUrl = baseUrl;    
    }
    
    // 参考 Retrofit 的动态代理  
    public <T> T create(final Class<T> service) {        
        return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class[]{service},                
            new InvocationHandler() {                    
            @Override                    
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                        
                //解析这个method 上所有的注解信息                        
                ServiceMethod serviceMethod = loadServiceMethod(method);                        
                //args:                        
                return serviceMethod.invoke(args);                    
            }                
        });    
    }  
      
    private ServiceMethod loadServiceMethod(Method method) {        
        //先不上锁，避免synchronized的性能损失        
        ServiceMethod result = serviceMethodCache.get(method);        
        if (result != null) 
            return result;        
        //多线程下，避免重复解析,        
        synchronized (serviceMethodCache) {            
            result = serviceMethodCache.get(method);            
            if (result == null) {                
                result = new ServiceMethod.Builder(this, method).build();                
                serviceMethodCache.put(method, result);            
            }        
        }        
        return result;    
    }
    
    /**     
      * 构建者模式，将一个复杂对象的构建和它的表示分离，可以使使用者不必知道内部组成的细节。     
      */    
    public static final class Builder {        
        private HttpUrl baseUrl;        
        //Okhttp->OkhttClient        
        private okhttp3.Call.Factory callFactory;  
        //null        
        public Builder callFactory(okhttp3.Call.Factory factory) {            
            this.callFactory = factory;            
            return this;        
        }        
        
        public Builder baseUrl(String baseUrl) {            
            this.baseUrl = HttpUrl.get(baseUrl);            
            return this;        
        }        
        
        public MyRetrofit build() {            
            if (baseUrl == null) {                
                throw new IllegalStateException("Base URL required.");            
            }            
            okhttp3.Call.Factory callFactory = this.callFactory;            
            if (callFactory == null) {                
                callFactory = new OkHttpClient();            
            }            
            return new EnjoyRetrofit(callFactory, baseUrl);        
        }    
    }
}

ServiceMethod

用来解析注解，记录请求类型，参数、完整地址

public class ServiceMethod {    
    private final Call.Factory callFactory;    
    private final String relativeUrl;    
    private final boolean hasBody;    
    private final ParameterHandler[] parameterHandler;    
    private FormBody.Builder formBuild;    
    HttpUrl baseUrl;    
    String httpMethod;    
    HttpUrl.Builder urlBuilder;    
    public ServiceMethod(Builder builder) {        
        baseUrl = builder.enjoyRetrofit.baseUrl;        
        callFactory = builder.enjoyRetrofit.callFactory;        
        httpMethod = builder.httpMethod;        
        relativeUrl = builder.relativeUrl;        
        hasBody = builder.hasBody;        
        parameterHandler = builder.parameterHandler;        
        //如果是有请求体,创建一个okhttp的请求体对象        
        if (hasBody) {            
            formBuild = new FormBody.Builder();        
        }    
    }    

    public Object invoke(Object[] args) {        
        /**         
          * 1  处理请求的地址与参数         
          */        
        for (int i = 0; i < parameterHandler.length; i++) {            
            ParameterHandler handlers = parameterHandler[i];            
            // handler内本来就记录了key,现在给到对应的value            
            handlers.apply(this, args[i].toString());        
        }        
        //获取最终请求地址        
        HttpUrl url;        
        if (urlBuilder == null) {            
            urlBuilder = baseUrl.newBuilder(relativeUrl);        
        }        
        url = urlBuilder.build();        
        //请求体        
        FormBody formBody = null;        
        if (formBuild != null) {            
            formBody = formBuild.build();        
        }        
        Request request = new Request.Builder().url(url).method(httpMethod, formBody).build();        
        return callFactory.newCall(request);    
    }    
    
    // get请求,把 k-v 拼到 url 里面    
    public void addQueryParameter(String key, String value) {        
        if (urlBuilder == null) {            
            urlBuilder = baseUrl.newBuilder(relativeUrl);        
        }        
        urlBuilder.addQueryParameter(key, value);    
    }    

    // Post,把 k-v 放到 请求体中    
    public void addFiledParameter(String key, String value) {        
        formBuild.add(key, value);    
    }    

    public static class Builder {        
        private final MyRetrofit enjoyRetrofit;        
        private final Annotation[] methodAnnotations;        
        private final Annotation[][] parameterAnnotations;        
        ParameterHandler[] parameterHandler;        
        private String httpMethod;        
        private String relativeUrl;        
        private boolean hasBody;        
        
        public Builder(MyRetrofit enjoyRetrofit, Method method) {            
            this.enjoyRetrofit = enjoyRetrofit;            
            //获取方法上的所有的注解            
            methodAnnotations = method.getAnnotations();            
            //获得方法参数的所有的注解 (一个参数可以有多个注解,一个方法又会有多个参数)            
            parameterAnnotations = method.getParameterAnnotations();        
        }        

        public ServiceMethod build() {            
            /**             
              * 1 解析方法上的注解, 只处理POST与GET             
              */            
            for (Annotation methodAnnotation : methodAnnotations) {                
                if (methodAnnotation instanceof POST) {                    
                    //记录当前请求方式                    
                    this.httpMethod = "POST";                    
                    //记录请求url的path                    
                    this.relativeUrl = ((POST) methodAnnotation).value();
                    // 是否有请求体                    
                    this.hasBody = true;                
                } else if (methodAnnotation instanceof GET) {                    
                    this.httpMethod = "GET";                    
                    this.relativeUrl = ((GET) methodAnnotation).value();                    
                    this.hasBody = false;                
                }
                // 待处理其他注解            
            }            
            /**             
              * 2 解析方法参数的注解             
              */            
            int length = parameterAnnotations.length;            
            parameterHandler = new ParameterHandler[length];            
            for (int i = 0; i < length; i++) {                
                // 一个参数上的所有的注解                
                Annotation[] annotations = parameterAnnotations[i];                
                // 处理参数上的每一个注解                
                for (Annotation annotation : annotations) {                    
                    //todo 可以加一个判断:如果httpMethod是get请求,现在又解析到 Filed 注解,可以提示使用者使用 Query 注解                    
                    if (annotation instanceof Field) {                        
                        //得到注解上的value: 请求参数的key                        
                        String value = ((Field) annotation).value();                        
                        parameterHandler[i] = new ParameterHandler.FiledParameterHandler(value);                    
                    } else if (annotation instanceof Query) {                        
                        String value = ((Query) annotation).value();                        
                        parameterHandler[i] = new ParameterHandler.QueryParameterHandler(value);                    
                    }                
                }            
            }            
            return new ServiceMethod(this);        
        }    
    }
}

ParameterHandler

QUERY、FIELD 请求参数封装，桥接到 HttpUrl 的addQueryParameter formBuild.add

public abstract class ParameterHandler {    
    abstract void apply(ServiceMethod serviceMethod, String value);    
    static class QueryParameterHandler extends ParameterHandler {        
        String key;        
        public QueryParameterHandler(String key) {            
            this.key = key;        
        }        
        //serviceMethod: 回调        
        @Override        
        void apply(ServiceMethod serviceMethod, String value) {            
            serviceMethod.addQueryParameter(key,value);        
        }    
    }  
      
    static class FiledParameterHandler extends ParameterHandler {        
        String key;        
        public FiledParameterHandler(String key) {            
            this.key = key;        
        }        
        @Override        
        void apply(ServiceMethod serviceMethod, String value) {            
            serviceMethod.addFiledParameter(key,value);        
        }    
     }
}