如何在不使用@Controller或@RestController的情况下注册一个Controller

于 2024-08-02 16:04:09 发布
阅读量545 收藏 18
点赞数 22
文章标签： java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50470705/article/details/136435630
版权

文章目录

问题起源于同事的一个提问：怎么自定义一个Controller？

乍一听这个问题似乎不太正常，我们使用@Controller或者@RestController（当然@ControllerAdvice或者@RestControllerAdvice也是一样的）不就能正常定义一个Controller吗。细问之下，果然别有用意：

如何在不使用@Controller或@RestController的情况下注册一个Controller？

这个需求似乎是希望能以动态的方式引入Controller（原话是说在类上加上个@Controller注解太丑了😂😂😂），总之，大致要满足这两个条件：

  1. 需要注册一个 Bean，并且是条件注册，不能在包扫描期间直接完成注册
  2. 这个 Bean 必须是一个 Controller，里面标注的 @RequestMapping 要能被 DispatcherServlet 感知到，作为 Controller 要有正常的功能；硬性条件是类上不加 @Controller 类似的注解（当然也包括@Component、@Service、@Repository等等，耍小聪明容易翻车哦😅），所以如果想使用 @ConditionalOnXxx 注解的各位可以换个思路了。不过如果希望类上或者类里不用任何注解，那么这边建议亲考虑回归初心自定义Servlet😅😅😅，这里就不提了

综上，目前想到的比较简单可行的方案和思考过程如下，如果只是要个方案的可以只看第一个大标题了

以下方案在 springboot v2.3.12.RELEASE 与 v2.7.16 版本验证有效，文中源码以及内容如不单独说明则以 v2.7.16 版本为例

一、解决方案

方案一、@RequestMapping + @Bean

这里的 @RequestMapping 特指 Controller 类上标注，而非具体方法上的标注

当然，@Bean 也并非特指配置类中的注册方法，也可以采用诸如 @Import 或者 BeanDefinitionRegistry 等方法，总之要保证注册成为一个 Bean

配置类示例如下（要放在扫描路径下）：

@Configuration
public class WebControllerConfig {
	@Bean
	public CustomizedController customizedController() {
		return new CustomizedController();
	}
}

自定义类 CustomizedController 如下：

@RequestMapping
@ResponseBody
public class CustomizedController {
	@GetMapping("customized")
	public String custom() {
		return "This is a method from customized controller.";
	}
}

CustomizedController 类上的 @ResponseBody 注解可以根据需要写，但是类上的 @RequestMapping 是必须的（这个是代替 @Controller 注解的关键）

方案二、配置类中通过反射调用 RequestMappingHandlerMapping 的方法探测 Controller

参考 springboot手动动态注入controller和service，采用反射的方式调用 RequestMappingHandlerMapping 父类 AbstractHandlerMethodMapping 的方法 detectHandlerMethods，这是一个 protected 类型的方法，所以需要反射调用，注册器 ReflectRequestMappingControllerRegistry 及公共接口 ControllerRegistrar 例程如下：

package gemini.utils.mvc;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.util.ClassUtils;
import org.springframework.util.ReflectionUtils;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.locks.ReentrantLock;

public class ReflectRequestMappingControllerRegistry implements ControllerRegistry, ApplicationContextAware {

    private static final Logger logger = LoggerFactory.getLogger(ReflectRequestMappingControllerRegistry.class);

    private ApplicationContext ctx;

    private RequestMappingHandlerMapping mapping;

    private static final HashMap<Class<?>, Set<Object>> REGISTERED_HANDLERS = new HashMap<>();

    private static final ReentrantLock LOCK = new ReentrantLock();

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        try {
            this.ctx = applicationContext;
            this.mapping = applicationContext.getBean(RequestMappingHandlerMapping.class);
        } catch (Exception e) {
            this.mapping = null;
        }
    }

    @Override
    public ApplicationContext getApplicationContext() {
        return ctx;
    }

    /**
     * 注册 controller
     *
     * @param controller    controller object, bean name or class
     * @return true if register success
     */
    public boolean registerController(Object controller) {
        if (controller == null || this.ctx == null || this.mapping == null) {
            return false;
        }
        LOCK.lock();
        try {
            controller = parseControllerInstance(controller);
            if (controller == null) {
                logger.warn("Controller can not be instantiated.");
                return false;
            }
            Set<Object> handlers = REGISTERED_HANDLERS.getOrDefault(controller.getClass(), new HashSet<>());
            if (handlers.contains(controller)) {
                logger.warn("Controller already registered: " + controller.getClass().getName());
                return false;
            }
            // 注册 controller method
            try {
                Method method = this.mapping.getClass().getSuperclass().getSuperclass()
                        .getDeclaredMethod("detectHandlerMethods", Object.class);
                method.setAccessible(true);
                method.invoke(this.mapping, controller);
                return true;
            } catch (Exception e) {
                // failed to register controller
                logger.warn("Failed to register controller", e);
                return false;
            } finally {
                handlers.add(controller);
                REGISTERED_HANDLERS.putIfAbsent(controller.getClass(), handlers);
            }
        } finally {
            LOCK.unlock();
        }

    }

    /**
     * 注销 controller
     *
     * @param controller   controller object, bean name or class
     * @return true if success
     */
    public boolean unregisterController(Object controller) {
        if (controller == null || this.ctx == null || this.mapping == null) {
            return false;
        }
        LOCK.lock();
        try {
            Class<?> type = parseControllerType(controller);
            boolean isBean = controller instanceof String;
            if (type == null) {
                if (isBean) {
                    logger.warn("Controller bean is not exists: " + controller);
                    return false;
                }
                logger.warn("Controller type is unknown");
                return false;
            }
            if (!isBean && !REGISTERED_HANDLERS.getOrDefault(type, new HashSet<>()).remove(controller)) {
                logger.warn("Controller is not registered: " + type.getName());
                return false;
            }
            final Class<?> targetClass = type;
            List<Method> failedMethods = new ArrayList<>();
            ReflectionUtils.doWithMethods(targetClass, new ReflectionUtils.MethodCallback() {
                public void doWith(Method method) {
                    Method specificMethod = ClassUtils.getMostSpecificMethod(method, targetClass);
                    try {
                        Method createMappingMethod = RequestMappingHandlerMapping.class.
                                getDeclaredMethod("getMappingForMethod", Method.class, Class.class);
                        createMappingMethod.setAccessible(true);
                        RequestMappingInfo requestMappingInfo =(RequestMappingInfo)
                                createMappingMethod.invoke(mapping, specificMethod, targetClass);
                        if (requestMappingInfo != null) {
                            mapping.unregisterMapping(requestMappingInfo);
                        }
                    } catch (Exception e) {
                        // failed to unregister controller method
                        failedMethods.add(specificMethod);
                        logger.warn("Failed to unregister controller method: " + specificMethod, e);
                    }
                }
            }, ReflectionUtils.USER_DECLARED_METHODS);
            if (!failedMethods.isEmpty()) {
                logger.warn("Failed to unregister controller method: " + failedMethods);
            }
            return true;
        } finally {
            LOCK.unlock();
        }
    }

}

package gemini.utils.mvc;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.util.ReflectionUtils;

public interface ControllerRegistry {

    boolean registerController(Object controller);

    boolean unregisterController(Object controller);

    ApplicationContext getApplicationContext();

    default Object parseControllerInstance(Object controller) {
        Class<?> type;
        ApplicationContext ctx = getApplicationContext();
        if (controller instanceof String) {
            // 获取 bean
            try {
                if (ctx == null) {
                    return null;
                }
                type = ctx.getType((String) controller);
                if (type != null) {
                    controller = ctx.getBean(type);
                }
                if (type == null || controller == null) {
                    return null;
                }
                return controller;
            } catch (BeansException e) {
                return null;
            }
        } else if (controller instanceof Class) {
            // class 实例化
            type = (Class<?>) controller;
            try {
                return ReflectionUtils.accessibleConstructor(type).newInstance();
            } catch (Exception e) {
                return null;
            }
        }
        return controller;
    }

    default Class<?> parseControllerType(Object controller) {
        ApplicationContext ctx = getApplicationContext();
        if (controller instanceof String) {
            // 获取 bean
            try {
                return ctx.getType((String) controller);
            } catch (BeansException e) {
                return null;
            }
        } else if (controller instanceof Class) {
            return  (Class<?>) controller;
        }
        return controller.getClass();
    }

}

将 ControllerRegistrar 的 bean 注册到容器中（例程中使用 @Component 注册，可换成其它方式），在需要动态注册 Controller 的地方注入该注册器 bean，调用对应的 registerController 和 unregisterController 即可实现注册和注销

这个方法优势在于能够动态注册/注销，不过过程中使用了反射，可以根据场景考虑是否适用

注意：不能连续多次调用 registerController 或注册已有的 Controller

方案三、继承 WebMvcConfigurationSupport 接管 MVC 配置（方案二强化版）

package gemini.utils.mvc;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.core.MethodIntrospector;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.ReentrantLock;

public class RequestMappingControllerRegistry extends RequestMappingHandlerMapping
        implements ControllerRegistry, ApplicationContextAware {

    private static final Logger logger = LoggerFactory.getLogger(RequestMappingControllerRegistry.class);

    private static final HashMap<Class<?>, Set<Object>> REGISTERED_HANDLERS = new HashMap<>();

    private static final ReentrantLock LOCK = new ReentrantLock();

    private static final AtomicBoolean INITIALIZED = new AtomicBoolean(false);

    public RequestMappingControllerRegistry() {
    }

    public RequestMappingControllerRegistry(ApplicationContext ctx) {
        setApplicationContext(ctx);
    }

    @Override
    public void afterPropertiesSet() {
        if (INITIALIZED.compareAndSet(false, true)) {
            logger.info("{} init!", getClass().getName());
            super.afterPropertiesSet();
        }
    }

    /**
     * 注册 controller
     *
     * @param controller    controller object, bean name or class
     * @return true if register success
     */
    @Override
    public boolean registerController(Object controller) {
        if (controller == null || getApplicationContext() == null) {
            return false;
        }
        LOCK.lock();
        try {
            controller = parseControllerInstance(controller);
            if (controller == null) {
                logger.warn("Controller can not be instantiated");
                return false;
            }
            Class<?> type = controller.getClass();
            Set<Object> handlers = REGISTERED_HANDLERS.getOrDefault(type, new HashSet<>());
            if (handlers.contains(controller)) {
                logger.warn("Controller has been registered");
                return false;
            }
            try {
                detectHandlerMethods(controller);
            } catch (Exception e) {
                // failed to register controller
                logger.warn("Failed to register controller", e);
                return false;
            } finally {
                handlers.add(controller);
                REGISTERED_HANDLERS.putIfAbsent(type, handlers);
            }
        } finally {
            LOCK.unlock();
        }
        return false;
    }

    /**
     * 注销 controller
     *
     * @param controller   controller object, bean name or class
     * @return true if success
     */
    @Override
    public boolean unregisterController(Object controller) {
        if (controller == null || getApplicationContext() == null) {
            return false;
        }
        LOCK.lock();
        try {
            Class<?> type = parseControllerType(controller);
            boolean isBean = controller instanceof String;
            if (type == null) {
                if (isBean) {
                    logger.warn("Controller bean is not exists: " + controller);
                } else {
                    logger.warn("Controller type is unknown");
                }
                return false;
            }
            if (!isBean && !REGISTERED_HANDLERS.getOrDefault(type, new HashSet<>()).remove(controller)) {
                logger.warn("Controller is not registered: " + type.getName());
                return false;
            }
            List<Method> failedMethods = new ArrayList<>();
            Map<Method, RequestMappingInfo> mappingInfoMap = MethodIntrospector.selectMethods(type,
                    (MethodIntrospector.MetadataLookup<RequestMappingInfo>) method -> {
                        try {
                            return getMappingForMethod(method, type);
                        } catch (Throwable ex) {
                            failedMethods.add(method);
                            logger.warn("Invalid mapping on handler method [" + method + "]: " + ex.getMessage());
                            return null;
                        }
                    });
            mappingInfoMap.forEach((method, requestMappingInfo) -> {
                try {
                    if (requestMappingInfo != null) {
                        unregisterMapping(requestMappingInfo);
                    }
                } catch (Exception ex) {
                    failedMethods.add(method);
                    logger.warn("removeHandlerMethod error, method [" + method + "]: " + ex.getMessage());
                }
            });
            if (!failedMethods.isEmpty()) {
                logger.warn("Failed to unregister controller methods: " + failedMethods);
            }
            return true;
        } finally {
            LOCK.unlock();
        }
    }

}

然后通过继承 DelegatingWebMvcConfiguration 配置类的方式替换掉默认的 RequestMappingHandlerMapping

@Configuration
public class WebaConfig extends DelegatingWebMvcConfiguration {
    private static final Logger logger = LoggerFactory.getLogger(WebAlphaConfigProxy.class);

    private final RequestMappingControllerRegistry controllerRegistry = new RequestMappingControllerRegistry();

    @Override
    protected RequestMappingHandlerMapping createRequestMappingHandlerMapping() {
        return controllerRegistry;
    }

    @Bean
    public ControllerRegistry controllerRegistry() {
        return controllerRegistry;
    }

}
码农小白Gemini
关注
  • 22
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
如何详细介绍@RestController注解的使用方法，并提供多个示例演示其在实际项目中的应用
专注于深入研究多种编程语言，以实战为导向，逐步拓展开发技能，提升工程化编码和思维能力，展现无敌技术实力。
07-21 1016
@RestController是Spring Framework中的一个注解，用于标识控制器类，使其成为RESTful风格的控制器。通过使用@RestController注解，我们可以将普通的Java类转换为处理HTTP请求的控制器，同时自动进行对象的序列化和反序列化，简化了RESTful API的开发。
Spring Boot进阶(30)：@RestController与@Controller的区别及使用场景详解，附带精彩实战演示
**My Coding Family**
02-26 821
@RestController和@Controller 注解使用区别，实战演示
动态注册SpringMVC Controller类
盲目的拾荒者的博客
07-10 1224
主要类源码核心代码。
手动配置Controller和基于注解实现Controller
weixin_42581455的博客
04-17 1116
目录 1、编写测试类并实现controller接口 2、配置spring-mvc.xml 3、要跳转的页面test.jsp(放在/WEB-INF/jsp/目录下) 4、结果 5、缺点:一个控制器中只有一个方法，如果要多个方法则需要定义多个Controller。定义的·方式比较麻烦 1、编写测试类并实现controller接口 public class TestController implements Controller { public M...
Spring Boot项目中不使用@RequestMapping相关注解，如何动态发布自定义URL路径
Coder-文小白的博客
02-27 2680
在Spring Boot项目开发过程中，对于接口API发布URL访问路径，一般都是在类上标识或者注解，然后在方法上标识注解，通过设置注解属性，发布URL。在某些场景下，我觉得这样发布URL太麻烦了，不适用，有没有什么其他方法自由发布定义的接口呢？答案是肯定的。参考步骤二的测试截图效果，我们自定义发布一个URL。/*** 注册一个web容器初始化以后的事件监听，注册自定义URL/*** 标识事件监听器是否已经注册，避免重复注册/*** 需要发布的地址。
第1天：SpringBoot Controller
weixin_46443403的博客
02-05 396
SpringBoot Controller
@Controller、@RestController注解区别详解
08-25
然而，@Controller标记在一个类上还不能真正意义上说它就是SpringMVC的控制器，应为这个时候Spring还不认识它，这个时候需要把这个控制器交给Spring来管理。用下面方式管理：在applicationContext.xml文件里面配置...
Springboot中的@Controller和@RestController的区别
渴望飞的鱼的博客
06-25 5243
目录 项目目录结构 Controller （1）编写控制层 （2）在pom.xml文件中添加如下模块依赖 （3）编写页面 （4）重新启动，完成 RestController （1）编写控制层 （2）启动项目 Springboot中，根据需要一般都会在Controller上加上@Controller注解，但是也有时候也见有加上@RestController。今天试了下她们的区别...
Spring Boot应用控制器使用@RestController和使用@Controller的问题
qq_42508802的博客
07-22 381
在Spring Boot应用中，如果在控制器中使用@RestController注解的话，会将控制器返回值解析为字符串（使用application.properties配置视图解析），而不是直接使用视图解析器进行解析。 下面分别为使用@Controller注解和@RestController注解的实验结果 视图解析器 /WEB-INF/views/index.jsp Spring Boot应用中的控制器，使用@Controller注解 使用@Controller注解访问结果 S
SpringBoot http请求注解@RestController原理解析
08-25
例如，在上面的代码中，我们可以看到当我们使用@RestController注解时，方法testGet()返回的是一个Map对象，但是客户端接收到的却是一个Json字符串。 如果我们将@RestController换成@Controller，那么情况就会有所...
『Java安全』Java Spring内存马_动态注册Controller内存马
Ho1aAs‘s Blog
04-03 4998
文章目录前言Controller注册分析register()Controller内存马原理Ⅰ. 获取RequestMappingHandlerMappingⅡ. 生成RequestMappingInfoⅢ. 写恶意ControllerⅣ. 反射获取恶意方法Ⅴ. 向RequestMappingHandlerMapping注册代码运行截图注意事项参考引用完 前言 SpringBoot版本2.4.5 <parent> <groupId>org.springframe
详解SpringMVC请求的时候是如何找到正确的Controller[附带源码分析]
weixin_33738555的博客
05-26 694
目录 前言 源码分析 重要接口介绍 SpringMVC初始化的时候做了什么 HandlerExecutionChain的获取 实例 资源文件映射 总结 参考资料 前言 SpringMVC是目前主流的Web MVC框架之一。 如果有同学对它不熟悉，那么请参考它的入门blog：http://www.cnblogs.com/fangjian0423/p/sp...
Java —— 想直接使用依赖中的controller应该如何注入？（ImportBeanDefinitionRegistrar ）
看了就会暴富的博客！
12-24 3419
问题 当前有一个项目A， 以maven依赖的形式提供给项目B。 在A中，有一个controller，里面有接口Inter，Inter已经配置好了接口访问路径。 想要在项目B中直接调用这个接口，应该如何处理呢？ 解决 想要使用A中controller中的某个接口，必须要将这个controller进行注入。因为在项目B中是不会将其扫描自动注入的。 可以在项目A中以注解的形式，手动注入。 代码 手动注册controller代码 import org.springframework.beans.
Spring 手动注册bean 定义
热门推荐
lilongjiu的专栏
05-22 1万+
手动注册bean的两种方式： 实现ImportBeanDefinitionRegistrar 实现BeanDefinitionRegistryPostProcessor 1. ImportBeanDefinitionRegistrar ImportBeanDefinitionRegistrar其本质也是通过BeanDefinitionRegistryPostProcessor来实现的。实...
springboot手动动态注入controller和service
JustPlay1994的专栏
05-24 1万+
springboot手动动态注入controller和service package test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.beans.factory.support.BeanDefinitionBuilder; import
Spring MVC手动注册requestMapping
GAMELOFT9----纸上得来终觉浅，绝知此事要躬行
08-13 5059
      之前写过一个Api Mock的小工具，没有什么高大上的技术，比较值得一提的是手动注册requestMapping。一般情况下，controller都是提前写好的，例如： /** * 检查接口序号是否已经占用 * */ @RequestMapping(value = "/getApiInfoByIndex.do", method = RequestMet...
Spring3系列7- 自动扫描组件或Bean
weixin_34150503的博客
02-13 244
Spring3系列7- 自动扫描组件或Bean   一、      Spring Auto Scanning Components —— 自动扫描组件　　　　 　　　　1.      Declares Components Manually——手动配置component 　　　　2.      Auto Components Scanning——自动扫描组件 　　　　3.      Cu...
请简要说明@Controller与@@RestController用法的区别
最新发布
05-27
@Controller和@RestController都是Spring MVC框架中用于处理HTTP请求的注解，其中@Controller用于处理网页视图相关的请求，而@RestController用于处理RESTful API相关的请求。 具体而言，@Controller注解的方法可以返回一个视图，它可以在视图中渲染模型数据，并将其呈现给用户。而@RestController注解的方法则返回一个对象（通常是JSON/XML格式的数据），该对象会被直接写入HTTP响应中，而不是呈现为视图。 此外，@RestController相当于@Controller和@ResponseBody注解的组合，它可以让我们更加方便地编写RESTful API，并且可以减少代码量。 下面是一些相关问题：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值