基于Spring Boot构建Mock API平台：运行时创建API遇阻求助

你的核心问题在于：Spring Boot默认使用的GenericApplicationContext不支持多次刷新，且运行时编译生成的Controller类无法被已初始化的Spring容器识别——因为Spring的组件扫描和Bean注册是在上下文初始化阶段完成的，后续新增的类不会被自动纳入容器管理。

以下是几种可行的技术方案，无需动态编译Java类，更适合Mock API平台的动态需求：

方案一：通过Spring MVC的RequestMappingHandlerMapping动态注册接口 #

直接操作Spring MVC的请求映射处理器，无需生成Controller类，即可动态添加Mock接口：

@Component
public class DynamicMockRegistrar implements ApplicationListener<ContextRefreshedEvent> {

    @Autowired
    private RequestMappingHandlerMapping handlerMapping;

    // 模拟存储用户配置的Mock规则（实际可从数据库/缓存读取）
    private final List<MockConfig> mockConfigs = Arrays.asList(
            new MockConfig("/mock", HttpMethod.GET, "Hello"),
            new MockConfig("/api/user", HttpMethod.POST, "{\"id\":1,\"name\":\"test\"}")
    );

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        for (MockConfig config : mockConfigs) {
            // 创建动态处理逻辑的匿名对象
            Object mockHandler = new Object() {
                public String handleRequest() {
                    return config.getResponse();
                }
            };

            // 获取处理方法
            Method handlerMethod;
            try {
                handlerMethod = mockHandler.getClass().getMethod("handleRequest");
            } catch (NoSuchMethodException e) {
                throw new RuntimeException(e);
            }

            // 构建请求映射信息
            RequestMappingInfo mappingInfo = RequestMappingInfo
                    .paths(config.getPath())
                    .methods(config.getMethod())
                    .build();

            // 注册到Spring MVC的映射处理器
            handlerMapping.registerMapping(mappingInfo, mockHandler, handlerMethod);
        }
    }

    // Mock配置实体类
    static class MockConfig {
        private String path;
        private HttpMethod method;
        private String response;

        public MockConfig(String path, HttpMethod method, String response) {
            this.path = path;
            this.method = method;
            this.response = response;
        }

        // Getters
        public String getPath() { return path; }
        public HttpMethod getMethod() { return method; }
        public String getResponse() { return response; }
    }
}

方案二：使用Servlet Filter拦截并返回Mock响应 #

脱离Spring MVC的Controller机制，直接通过Filter拦截请求，根据用户配置返回Mock结果，这种方式更轻量化且灵活：

@Component
public class MockApiFilter implements Filter {

    // 模拟存储用户Mock规则（实际可持久化到数据库）
    private final Map<String, MockRule> mockRuleMap = new HashMap<>();

    @Override
    public void init(FilterConfig filterConfig) {
        // 初始化Mock规则示例
        mockRuleMap.put("/mock_GET", new MockRule(HttpMethod.GET, "Hello Mock"));
        mockRuleMap.put("/api/user_POST", new MockRule(HttpMethod.POST, "{\"code\":200,\"data\":{\"id\":1}}"));
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpReq = (HttpServletRequest) request;
        String key = httpReq.getRequestURI() + "_" + httpReq.getMethod();
        MockRule rule = mockRuleMap.get(key);

        if (rule != null) {
            HttpServletResponse httpResp = (HttpServletResponse) response;
            httpResp.setContentType("application/json;charset=UTF-8");
            httpResp.getWriter().write(rule.getResponse());
            return;
        }

        // 无Mock规则时，放行请求
        chain.doFilter(request, response);
    }

    static class MockRule {
        private HttpMethod method;
        private String response;

        public MockRule(HttpMethod method, String response) {
            this.method = method;
            this.response = response;
        }

        // Getters
        public HttpMethod getMethod() { return method; }
        public String getResponse() { return response; }
    }
}

方案三：提前注册动态生成的Bean定义（若坚持用Controller类） #

如果必须通过生成Controller类实现，需在Spring上下文初始化前注册Bean定义，而非启动后：

@Component
public class MockBeanDefinitionProcessor implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        // 此处替换为你运行时编译生成的MockController Class对象
        Class<?> mockControllerClass = compileMockController();

        // 构建Bean定义并注册到容器
        GenericBeanDefinition beanDef = new GenericBeanDefinition();
        beanDef.setBeanClass(mockControllerClass);
        registry.registerBeanDefinition("dynamicMockController", beanDef);
    }

    // 模拟运行时编译生成Controller类的方法
    private Class<?> compileMockController() {
        // 这里实现你的类编译逻辑，返回Class对象
        // 注意：需在上下文刷新前完成编译
        return null;
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {}
}

方案选择建议 #

• 若需要支持复杂的请求参数校验、响应动态生成，优先选方案一；
• 若追求轻量化、高灵活性，适合快速迭代Mock规则，优先选方案二；
• 方案三仅适合必须复用Spring MVC注解特性的场景，实现复杂度较高，不推荐作为Mock平台的核心方案。

内容的提问来源于stack exchange，提问作者Mr.Han