面试官问MyBatis/OpenFeign的原理？我手搓了个MyHttp怼回去！(反八股版)

一、前言

自从有了AI、大模型、DeepSeek、豆包、GPT......，就再也没写过技术文章了。毕竟，在它们面前写什么内容都是多余的。我甚至问过AI"AI 时代写技术博客还有意义吗"这个问题，它给出了如下结论：

结论：AI 时代，技术博客不仅有意义，反而变得 更重要 了。
虽然 AI 能快速生成内容，但真正的价值恰恰在于人类的独特思考和实践经验，
这是 AI 无法完全复制的 "极值"（而 AI 只能产出 "平均值"）。
行动建议： 不要犹豫是否开始，而是思考如何将 AI 变成你的创作助手。
本周就选定一个小而精的技术主题，尝试 "人类构思 + AI 辅助" 的创作模式，体验效率与质量的双重提升。
记住：在 AI 时代，最有价值的不是 "写什么"，而是 "你为什么这样写" 的独特视角。

总感觉它在一本正经的胡说八道，但又拿不出来证据，偶尔还会被它的"心灵鸡汤"戳中。有时候想想也是：

AI 是很牛逼，但它写不出我深夜改 bug 改到脱发的崩溃；

AI 是很万能，但它写不出"一个 bug 是 bug，两个 bug 是 feature"的玄学代码；

AI 是能给方案，但它给不出在办公室用底层原理驯服测试小姐姐的那种拿捏感。

以上便是今天这篇博文的引子，字里行间表达了作者对故乡的思念之情，对童年时光的怀念之情，爱国之情，对小日子的痛恨之情等等。

二、背景

问：MyBatis为什么写一个public interface UserMapper接口类，就能访问数据库？

问：OpenFeign为什么写一个public interface UserFeignClient接口类，就能发送HTTP请求？

此时你一脸懵逼的说：我平常项目就是这么开发的，接口会调用xml中我写好的sql，接口会调用我注解中的url地址。

遗憾的是，要是面试时你这么答，面试官大概率直接给你打零分 ------ 他要的不是 "怎么用"，而是 "为什么能这么用"。

要搞懂这些问题的核心，就绕不开 "动态代理"------ 这正是面试官想考察的底层思维，咱们今天就掰烂了揉碎了说说"动态代理的那些事儿"。接下来咱们不背八股，直接手搓一个类 OpenFeign 的 "MyHttp"，把动态代理扒明白。

三、手搓一个"MyHttp"

我们要实现的东西暂且叫做"MyHttp"，他的目标就是像OpenFeign一样，定义一个接口就能发送HTTP请求，不需要任何配置和任何实现类。

我们首先来看，常规调用HTTP接口的代码大概长下面这个样子：

private static RegisterResponse registerUser(RegisterUserRequest requestParam) throws IOException, ParseException {
    try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
        //构建POST请求
        HttpPost httpPost = new HttpPost("http://localhost:8080/api/user/register");
        //设置请求头
        httpPost.setHeader("Content-Type", ContentType.APPLICATION_JSON.toString());
        //将请求参数序列化为JSON字符串
        String requestJson = OBJECT_MAPPER.writeValueAsString(requestParam);
        HttpEntity requestEntity = new StringEntity(requestJson, ContentType.APPLICATION_JSON);
        httpPost.setEntity(requestEntity);
        //执行请求，获取响应
        try (CloseableHttpResponse response = httpClient.execute(httpPost)) {
            //解析响应实体
            HttpEntity responseEntity = response.getEntity();
            if (responseEntity == null) {
                throw new RuntimeException("注册接口返回空响应");
            }
            //将响应JSON字符串反序列化为实体类
            String responseJson = EntityUtils.toString(responseEntity);
            return OBJECT_MAPPER.readValue(responseJson, RegisterResponse.class);
        }
    }
}

"MyHttp"的目标是这个样子：

@HttpClient(baseUrl="http://localhost:8080/api")
public interface UserHttp {
    @HttpPost(url = "/user/register")
    RegisterResponse registerUser(RegisterUserRequest requestParam);
}

看起来是不是很清爽？接下来我们基于动态代理一步一步实现它。

四、先搞几个核心注解

**@HttpClient：**放到接口类上，表示这是一个基于"MyHttp"的接口，放一个属性baseUrl，定义这个接口下的所有HTTP调用的url根路径：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface HttpClient {
    String baseUrl() default "";
}

当然，如果你愿意，还可以扩展其它属性，比如你想设置连接超时时间、读超时时间，再比如你的baseUrl是动态的，或者是个地址列表要负载均衡去调用等等：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface HttpClient {
    String baseUrl() default "";
    int connectTimeout() default -1;
    int readTimeout() default -1;
    Class<? extends BaseUrlSource> baseUrlSource() default BaseUrlSource.class; 
} 
public interface BaseUrlSource { 
    List<String> getBaseUrls(); 
}

**@HttpPost：**放在接口方法上，表示这个方法具体要调用哪个接口，报文头怎么设置，超时参数等等：

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface HttpPost {
    String url() default "";
    String contentType() default MediaType.APPLICATION_JSON_VALUE;
    int connectTimeout() default -1;
    int readTimeout() default -1;
}

当然，如果你愿意，仍然可以扩展很多很多属性，但这不是本文重点。

五、再实现一下InvocationHandler

简单说一下InvocationHandler ：是 JDK 动态代理的 "调用处理器"，当我们通过Proxy.newProxyInstance（JDK 动态代理的核心方法，作用是 "绑定接口和代理逻辑，生成最终可用的代理对象"）的方式生成对象并调用目标方法时，JVM 会自动将调用转发到 InvocationHandler 的 invoke 方法，由该方法完成最终的方法执行 + 自定义增强逻辑。

翻译成人话：用 InvocationHandler 把 "被代理的接口" 包一层，生成一个 "代理对象"；之后调用接口方法时，其实是在调代理对象的方法，自然就会走进 invoke 里咱们写的逻辑。

以下例子中，我们便在invoke方法中拿到了被代理的接口类和接口方法，这时候我们就能拿到所有注解，进而根据注解信息组装HTTP报文并发送请求。

/**
 * HTTP动态代理处理器：拦截接口方法调用，自动发送HTTP请求
 */
public class HttpInvocationHandler implements InvocationHandler {
    // JSON序列化工具（全局复用）
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
    
    // HttpClient客户端
    private static final CloseableHttpClient HTTP_CLIENT = HttpClients.createDefault();
    
    // 目标接口的Class对象（用于解析注解）
    private final Class<?> targetInterface;

    public HttpInvocationHandler(Class<?> targetInterface) {
        this.targetInterface = targetInterface;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 解析接口级@HttpClient注解，获取基础URL
        HttpClient httpClientAnnotation = targetInterface.getAnnotation(HttpClient.class);
        String baseUrl = httpClientAnnotation.baseUrl();

        // 解析方法级@HttpPost注解，获取子路径
        HttpPost httpPostAnnotation = method.getAnnotation(HttpPost.class);
        String subUrl = httpPostAnnotation.url();
        String contentType = httpPostAnnotation.contentType();
        
        // 拼接完整请求URL
        String fullUrl = baseUrl + subUrl;
        //处理请求参数
        String requestJson = OBJECT_MAPPER.writeValueAsString(args[0]);
        
        //发送HTTP POST请求
        HttpPost httpPost = new HttpPost(fullUrl);
        // 设置请求头：JSON格式
        httpPost.setHeader("Content-Type", contentType);
        // 设置请求体
        HttpEntity requestEntity = new StringEntity(requestJson);
        httpPost.setEntity(requestEntity);

        // 执行请求并获取响应
        try (var response = HTTP_CLIENT.execute(httpPost)) {
            HttpEntity responseEntity = response.getEntity();
            // 解析响应JSON
            String responseJson = EntityUtils.toString(responseEntity);
            //响应结果反序列化为方法返回类型
            Type returnType = method.getGenericReturnType();
            return OBJECT_MAPPER.readValue(responseJson, OBJECT_MAPPER.constructType(returnType));
        }
    }
} 

六、再写个代理工厂

现在我们只差如何创建代理对象了，这也是最后一步，这时候我们用到了Proxy.newProxyInstance。这个方法你可以想象成：被代理对象，通过Proxy.newProxyInstance的方式与代理对象绑定了起来，这样当被代理对象的方法被调用时，实际就变成了代理对象在帮你调用，那么就会进入代理对象的invoke方法，从而执行我们的增强逻辑。

/**
 * HTTP代理工厂：封装动态代理对象的创建逻辑
 */
public class HttpProxyFactory {
    /**
     * 创建HTTP接口的代理对象
     * @param interfaceClass 目标接口Class（如UserHttp.class）
     * @return 接口代理对象
     * @param <T> 接口类型
     */
    public static <T> T createProxy(Class<T> interfaceClass) {
        // 创建自定义InvocationHandler
        HttpInvocationHandler handler = new HttpInvocationHandler(interfaceClass);
        // 生成动态代理对象
        return (T) Proxy.newProxyInstance(
                interfaceClass.getClassLoader(), 
                new Class<?>[]{interfaceClass},  
                handler                          
        );
    }
}

七、核心逻辑串一串

进度条走到这里，核心逻辑基本梳理完了，咱们先简单总结一下整体流程：接口注解定义 → 代理工厂创建代理对象 → 调用接口方法触发 invoke → 解析注解组装 HTTP 请求 → 响应反序列化返回。

八、测试一下

@RestController
@RequestMapping("/demo")
public class DemoController {
    @PostMapping("/register")
    public RegisterResponse register(@RequestBody RegisterUserRequest request) {
        //创建UserHttp接口的代理对象
        UserHttp userHttp = HttpProxyFactory.createProxy(UserHttp.class);
        // 调用接口方法，底层自动发送HTTP请求
        return userHttp.registerUser(request);
    }
}

至此，上面的实现已经能跑通，但总觉得还缺点什么？

九、还缺点什么？

有人说，你怎么通过UserHttp userHttp = HttpProxyFactory.createProxy(UserHttp.class);的方式才能调用？我平常项目里都是这样就能调用了：

@Autowired
private UserHttp userHttp;

这里就涉及到Spring 的 FactoryBean 接口和注解扫描注册器，并不是本文重点，但还是给大家补全这个 "实战最后一公里"。

首先要实现FactoryBean （Spring 的 "特殊 Bean 工厂"，专门用来创建 "不是简单 new 出来" 的 Bean，比如咱们的动态代理对象）：

/**
 * 自定义FactoryBean：生成HTTP接口的动态代理对象
 * @param <T> 目标接口类型（如UserHttp）
 */
public class HttpProxyFactoryBean<T> implements FactoryBean<T> {
    // 目标接口的Class对象
    private Class<T> interfaceClass;

    // 构造器注入接口类型
    public HttpProxyFactoryBean(Class<T> interfaceClass) {
        this.interfaceClass = interfaceClass;
    }

    /**
     * 创建Bean实例（返回动态代理对象）
     */
    @Override
    @Nullable
    public T getObject() throws Exception {
        // 调用之前的动态代理工厂生成代理对象
        return HttpProxyFactory.createProxy(interfaceClass);
    }

    /**
     * 返回Bean的类型（接口类型）
     */
    @Override
    public Class<?> getObjectType() {
        return interfaceClass;
    }

    /**
     * 单例模式（代理对象复用）
     */
    @Override
    public boolean isSingleton() {
        return true;
    }
}

然后实现ImportBeanDefinitionRegistrar扫描所有标记了@HttpClient的接口，自动注册为 Spring Bean：

public class HttpProxyBeanRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //创建扫描器：只扫描标记@HttpClient的接口
        ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
        scanner.addIncludeFilter(new AnnotationTypeFilter(HttpClient.class));

        //扫描指定包，需替换为实际包名
        String basePackage = "com.demo.http"; 
        scanner.findCandidateComponents(basePackage).forEach(beanDefinition -> {
            try {
                //获取接口的Class对象
                String className = beanDefinition.getBeanClassName();
                Class<?> interfaceClass = ClassUtils.forName(className, ClassUtils.getDefaultClassLoader());//构建BeanDefinition：指定Bean类型为HttpProxyFactoryBean
                BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(HttpProxyFactoryBean.class);
                //构造器注入接口Class对象
                builder.addConstructorArgValue(interfaceClass);
                //注册Bean，Bean名称默认用接口类名首字母小写，如userHttp
                registry.registerBeanDefinition(ClassUtils.getShortNameAsProperty(interfaceClass), builder.getBeanDefinition());
            } catch (ClassNotFoundException e) {
                throw new RuntimeException("扫描HTTP接口失败：" + e.getMessage(), e);
            }
        });
    }
}

最后别忘了关键的一步：增加一个配置类，导入自定义bean注册器

@Configuration
@Import(HttpProxyBeanRegistrar.class)
public class HttpProxyAutoConfiguration {
    
}

十、再测试一下

@RestController
@RequestMapping("/demo")
public class DemoController {
    //自动注入UserHttp接口
    @Autowired
    private UserHttp userHttp;

    @PostMapping("/register")
    public RegisterResponse register(@RequestBody RegisterUserRequest request) {
        // 调用接口方法，底层自动发送HTTP请求
        return userHttp.registerUser(request);
    }
}

这个代码，是不是就非常有感觉了。有了这一套，面试时被问 "OpenFeign 为什么能直接注入接口用"，你不光能说清动态代理，还能说清 Spring 是怎么管理这些代理 Bean 的，直接碾压八股文选手。

十一、结语：手搓的意义，不止于 "会用"

好像没啥可说的了，用AI生成一段吧：

写到这，咱们的 "MyHttp" 就彻底跑通了 ------ 从注解定义到动态代理拦截，再到 Spring 自动注入，核心逻辑和 OpenFeign、MyBatis 的接口代理思想完全一致。
可能有人会说："有现成的框架用，为啥还要手搓？" 答案很简单：
面试时，"会用" 只能拿及格分，"懂原理 + 能手搓" 才能拿 Offer；
工作中，遇到框架适配问题时，底层原理才是你解决问题的底气。
就像面试官问 "OpenFeign 为什么能直接调用接口"，你要是能把今天这一套手搓逻辑讲清楚，再对比一下 JDK 动态代理和 CGLIB 的区别，
他大概率会觉得 "这小子是真懂，不是背八股"。

以此表达作者对故乡的思念之情，对童年时光的怀念之情，爱国之情，对小日子的痛恨之情等等。