SpringMVC原理学习（一）RequestMappingHandlerMapping 与 RequestMappingHandlerAdapter

最新推荐文章于 2024-05-17 14:43:29 发布
最新推荐文章于 2024-05-17 14:43:29 发布
阅读量1.4k 收藏 4
点赞数
文章标签： SpringMVC原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51409098/article/details/127760279
版权

一、 DispatcherServlet 初始化

1、DispatcherServlet 初始化时机

主启动类：

public class A20 {
    public static void main(String[] args) throws Exception {
        //支持内嵌 Tomcat 容器的 Spring 容器实现
        AnnotationConfigServletWebServerApplicationContext context =
                new AnnotationConfigServletWebServerApplicationContext(WebConfig.class);
    }
}

配置类 

@Configuration
@ComponentScan
//指定资源文件读取的位置
@PropertySource("classpath:application.properties")
//让使用了 @ConfigurationProperties 注解的类生效,并且将该类注入到 IOC 容器中,交由 IOC 容器进行管理
@EnableConfigurationProperties({WebMvcProperties.class, ServerProperties.class})
public class WebConfig {

    // 内嵌 web 容器工厂
    @Bean
    public TomcatServletWebServerFactory tomcatServletWebServerFactory(ServerProperties serverProperties) {
        return new TomcatServletWebServerFactory(serverProperties.getPort());
    }

    // 创建 DispatcherServlet
    @Bean
    public DispatcherServlet dispatcherServlet() {
        return new DispatcherServlet();
    }

    // 向 Tomcat 注册 DispatcherServlet, Spring MVC 的入口
    @Bean
    public DispatcherServletRegistrationBean dispatcherServletRegistrationBean(
            DispatcherServlet dispatcherServlet, WebMvcProperties webMvcProperties) {
        DispatcherServletRegistrationBean registrationBean =
                new DispatcherServletRegistrationBean(dispatcherServlet, "/");
        return registrationBean;
    }
}

启动容器时:

第一次访问时：

DispatcherServlet初始化不是 Spring 管理 ，是 Tomcat 服务器在首次使用到 DispatcherServlet时，才由 Tomcat 服务器 进行初始化。

我们可以设置 LoadOnStartup ，让 Tomcat 启动时初始化 DispatcherServlet。

一旦设置大于 0 的值，就会在 Tomcat 启动时初始化。数字大小代表优先级，如果有多个 Servlet，数字小的优先级高。

    @Bean
    public DispatcherServletRegistrationBean dispatcherServletRegistrationBean(
            DispatcherServlet dispatcherServlet, WebMvcProperties webMvcProperties) {
        DispatcherServletRegistrationBean registrationBean =
                new DispatcherServletRegistrationBean(dispatcherServlet, "/");
        registrationBean.setLoadOnStartup(webMvcProperties.getServlet().getLoadOnStartup());
        return registrationBean;
    }

2、DispatcherServlet 初始化都做了什么

DispatcherServlet 初始化时，会执行 onRefresh() 方法，从 Spring 容器中找一些 Web 需要的组件, 如 HandlerMapping、HandlerAdapter 等，并逐一调用它们的初始化

public class DispatcherServlet extends FrameworkServlet {

    protected void onRefresh(ApplicationContext context) {
        this.initStrategies(context);
    }

    protected void initStrategies(ApplicationContext context) {
        this.initMultipartResolver(context);
        this.initLocaleResolver(context);
        this.initThemeResolver(context);
        this.initHandlerMappings(context);
        this.initHandlerAdapters(context);
        this.initHandlerExceptionResolvers(context);
        this.initRequestToViewNameTranslator(context);
        this.initViewResolvers(context);
        this.initFlashMapManager(context);
    }
}

二、RequestMappingHandlerMapping

RequestMappingHandlerMapping 初始化时，会收集所有 @RequestMapping 映射信息，封装为 Map，其中

  • key 是 RequestMappingInfo 类型，包括请求路径、请求方法等信息

  • value 是 HandlerMethod 类型，包括控制器方法对象、控制器对象

  • 有了这个 Map，就可以在请求到达时，快速完成映射，找到 HandlerMethod 并与匹配的拦截器一起返回给 DispatcherServlet

1、初始化 HandlerMapping

​private void initHandlerMappings(ApplicationContext context) {
    this.handlerMappings = null;
    // 该值默认为 true 但是可以设置为 false
    // 如果设置为 false 那  Spring MVC就只会查找名为“handlerMapping”的bean，并作为当前系统的唯一的HandlerMapping
    // 如果是 ture 则查询所有的..
    if (this.detectAllHandlerMappings) {
        //在ApplicationContext中查找所有handler映射，包括父类上下文。
        Map<String, HandlerMapping> matchingBeans =
            BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
        //如果不为空
        if (!matchingBeans.isEmpty()) {
            // 将获取的 HandlerMapping 转换成集合..
            this.handlerMappings = new ArrayList<>(matchingBeans.values());
            // 排序
            AnnotationAwareOrderComparator.sort(this.handlerMappings);
        }
    }
    else {
        try {
            // 从容器中获取 HandlerMapping ，如果获取不到 下面则会添加默认的..
            HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
            this.handlerMappings = Collections.singletonList(hm);
        }
        catch (NoSuchBeanDefinitionException ex) {
        }
    }
 
    //通过注册，确保至少有一个HandlerMapping
    //如果找不到其他映射，则为默认的HandlerMapping。
    if (this.handlerMappings == null) {
        this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
    }
 
    for (HandlerMapping mapping : this.handlerMappings) {
        if (mapping.usesPathPatterns()) {
            this.parseRequestPath = true;
            break;
        }
    }
}

​
protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
    if (defaultStrategies == null) {
        try {
            // 从配置文件加载默认的 简单的说 加载 DispatcherServlet.properties 这个文件...
            ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
            // 默认的策略~~~
            defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
        }
        catch (IOException ex) {
            throw new IllegalStateException("Could not load '" + DEFAULT_STRATEGIES_PATH + "': " + ex.getMessage());
        }
    }
    //获取 org.springframework.web.servlet.HandlerMapping
    String key = strategyInterface.getName();
    // 配置文件中定义了三个 默认组件
    // org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping
    // org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping
    // org.springframework.web.servlet.function.support.RouterFunctionMapping
    String value = defaultStrategies.getProperty(key);
    if (value != null) {
        // 将 获取的 value 转换成数组
        String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
        List<T> strategies = new ArrayList<>(classNames.length);
        // 循环
        for (String className : classNames) {
            try {
                //  根据 路径获取 class
                Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
                //  创建...
                Object strategy = createDefaultStrategy(context, clazz);
                // 添加到集合中
                strategies.add((T) strategy);
            }
            catch (ClassNotFoundException ex) {
               // 抛出异常
            }
            catch (LinkageError err) {
               // 抛出异常
            }
        }
        return strategies;
    }
    else {
        return new LinkedList<>();
    }
}

2、代码测试

配置类添加RequestMappingHandlerMapping，如果用 DispatcherServlet 初始化时默认添加的组件, 并不会放到 Spring 容器里，给测试带来困扰。

    @Bean
    public RequestMappingHandlerMapping requestMappingHandlerMapping(){
        return new RequestMappingHandlerMapping();
    }

 Controller类

@Controller
public class Controller1 {

    private static final Logger log = LoggerFactory.getLogger(Controller1.class);

    @GetMapping("/test1")
    public ModelAndView test1() throws Exception {
        log.debug("test1()");
        return null;
    }

    @PostMapping("/test2")
    public ModelAndView test2(@RequestParam("name") String name) {
        log.debug("test2({})", name);
        return null;
    }

    @PutMapping("/test3")
    public ModelAndView test3(String token) {
        log.debug("test3({})", token);
        return null;
    }

    @RequestMapping("/test4")
    public User test4() {
        log.debug("test4");
        return new User("张三", 18);
    }

    public static class User {
        private String name;
        private int age;

        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }

        public void setName(String name) {
            this.name = name;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }
}

 主启动类

public class A20 {
    public static void main(String[] args) throws Exception {
        //支持内嵌 Tomcat 容器的 Spring 容器实现
        AnnotationConfigServletWebServerApplicationContext context =
                new AnnotationConfigServletWebServerApplicationContext(WebConfig.class);

        RequestMappingHandlerMapping handlerMapping = context.getBean(RequestMappingHandlerMapping.class);
        //收集所有 @RequestMapping 映射信息，封装为 Map
        Map<RequestMappingInfo, HandlerMethod> handlerMethods = handlerMapping.getHandlerMethods();
        handlerMethods.forEach((k, v) -> {
            System.out.println(k + " = " + v);
        });
    }
}

结果：

{GET [/test1]} = com.itheima.a20.Controller1#test1()
{PUT [/test3]} = com.itheima.a20.Controller1#test3(String)
{ [/test4]} = com.itheima.a20.Controller1#test4()
{POST [/test2]} = com.itheima.a20.Controller1#test2(String)

有了这个 Map，就可以在请求到达时，快速完成映射，找到 HandlerMethod 并与匹配的拦截器一起返回给 DispatcherServlet。

可以使用 MockHttpServletRequest 模拟请求， Spring 提供的用于测试使用

案例一

MockHttpServletRequest request = new MockHttpServletRequest("POST", "/test2");
request.setParameter("name", "张三");
HandlerExecutionChain chain = handlerMapping.getHandler(request);
System.out.println(chain);

结果：

HandlerExecutionChain with [com.itheima.a20.Controller1#test2(String)] and 0 interceptors

案例二

MockHttpServletRequest request = new MockHttpServletRequest("PUT", "/test3");
request.addHeader("token", "令牌");
HandlerExecutionChain chain = handlerMapping.getHandler(request);
System.out.println(chain);

结果： 

HandlerExecutionChain with [com.itheima.a20.Controller1#test3(String)] and 0 interceptors

三、RequestMappingHandlerAdapter

RequestMappingHandlerAdapter 初始化时，会准备 HandlerMethod 调用时需要的各个组件，如：

  • HandlerMethodArgumentResolver 解析控制器方法参数
  • HandlerMethodReturnValueHandler 处理控制器方法返回值

1、初始化HandlerAdapter

源码和 初始化HandlerMapping 类似，默认添加的组件如下

org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
	org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter,\
	org.springframework.web.servlet.function.support.HandlerFunctionAdapter

2、代码测试

继续加入RequestMappingHandlerAdapter, 会替换掉 DispatcherServlet 默认的 4 个HandlerAdapter

    @Bean
    public MyRequestMappingHandlerAdapter requestMappingHandlerAdapter(){
        MyRequestMappingHandlerAdapter handlerAdapter = new MyRequestMappingHandlerAdapter();
        return handlerAdapter;
    }

使用 MyRequestMappingHandlerAdapter 原因：RequestMappingHandlerAdapter的 invokeHandlerMethod 方法作用域是 protected，反射调用太麻烦，就写了个子类，调用子类的方法即可。

public class MyRequestMappingHandlerAdapter extends RequestMappingHandlerAdapter {
    @Override
    public ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
        return super.invokeHandlerMethod(request, response, handlerMethod);
    }
}

主启动类

public class A20 {
    public static void main(String[] args) throws Exception {
        //支持内嵌 Tomcat 容器的 Spring 容器实现
        AnnotationConfigServletWebServerApplicationContext context =
                new AnnotationConfigServletWebServerApplicationContext(WebConfig.class);
        MyRequestMappingHandlerAdapter handlerAdapter = context.getBean(MyRequestMappingHandlerAdapter.class);

        System.out.println(">>>>>>>>>>>>>>所有的参数解析器");
        for (HandlerMethodArgumentResolver argumentResolver : handlerAdapter.getArgumentResolvers()) {
            System.out.println(argumentResolver);
        }

        System.out.println(">>>>>>>>>>>>>>所有的返回值解析器");
        for (HandlerMethodReturnValueHandler returnValueHandler : handlerAdapter.getReturnValueHandlers()) {
            System.out.println(returnValueHandler);
        }
    }
}

结果：

 调用 invokeHandlerMethod 执行 控制器方法

public class A20 {
    public static void main(String[] args) throws Exception {
        //支持内嵌 Tomcat 容器的 Spring 容器实现
        AnnotationConfigServletWebServerApplicationContext context =
                new AnnotationConfigServletWebServerApplicationContext(WebConfig.class);

        RequestMappingHandlerMapping handlerMapping = context.getBean(RequestMappingHandlerMapping.class);
        MyRequestMappingHandlerAdapter handlerAdapter = context.getBean(MyRequestMappingHandlerAdapter.class);

        //MockHttpServletRequest: Spring提供的模拟request对象，用于测试使用
        MockHttpServletRequest request = new MockHttpServletRequest("POST", "/test2");
        request.setParameter("name", "张三");

        MockHttpServletResponse response = new MockHttpServletResponse();
        //返回处理器执行链对象
        HandlerExecutionChain chain = handlerMapping.getHandler(request);
       
        handlerAdapter.invokeHandlerMethod(request, response, (HandlerMethod) chain.getHandler());

    }
}

结果：

[DEBUG] 10:40:09.745 [main] com.itheima.a20.Controller1  - test2(张三)

四、自定义参数与返回值处理器

自定义的注解：

// 例如经常需要用到请求头中的 token 信息, 用下面注解来标注由哪个参数来获取它
@Target(ElementType.PARAMETER) // 注解位置：方法参数上
@Retention(RetentionPolicy.RUNTIME) // 注解作用范围：运行期
public @interface Token {
}
// 与 @ResponseBody 注解功能类似，不过返回的是 yml 格式的字符串
@Target(ElementType.METHOD) // 注解位置：方法上
@Retention(RetentionPolicy.RUNTIME) //注解作用范围：运行期
public @interface Yml {
}

Controller类

@Controller
public class Controller1 {

    private static final Logger log = LoggerFactory.getLogger(Controller1.class);

    @GetMapping("/test1")
    public ModelAndView test1() throws Exception {
        log.debug("test1()");
        return null;
    }

    @PostMapping("/test2")
    public ModelAndView test2(@RequestParam("name") String name) {
        log.debug("test2({})", name);
        return null;
    }

    @PutMapping("/test3")
    public ModelAndView test3(@Token String token) {
        log.debug("test3({})", token);
        return null;
    }

    @RequestMapping("/test4")
    @Yml
    public User test4() {
        log.debug("test4");
        return new User("张三", 18);
    }

    public static class User {
        private String name;
        private int age;

        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }

        public void setName(String name) {
            this.name = name;
        }

        public void setAge(int age) {
            this.age = age;
        }

    }
}

1、自定义参数处理器

实现 HandlerMethodArgumentResolver 接口

public class TokenArgumentResolver implements HandlerMethodArgumentResolver {
    @Override
    //是否支持某个参数
    public boolean supportsParameter(MethodParameter parameter) {
        Token token = parameter.getParameterAnnotation(Token.class);
        return token != null;
    }

    @Override
    //解析参数
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        return webRequest.getHeader("token");
    }
}

将自定义的参数解析器加到handleAdapter 

    @Bean
    public MyRequestMappingHandlerAdapter requestMappingHandlerAdapter(){
        TokenArgumentResolver tokenArgumentResolver = new TokenArgumentResolver();
        MyRequestMappingHandlerAdapter handlerAdapter = new MyRequestMappingHandlerAdapter();
        //将自定义的参数解析器加到handleAdapter
        handlerAdapter.setCustomArgumentResolvers(Arrays.asList(tokenArgumentResolver));
        return handlerAdapter;
    }

主启动类

public class A20 {
    public static void main(String[] args) throws Exception {
        //支持内嵌 Tomcat 容器的 Spring 容器实现
        AnnotationConfigServletWebServerApplicationContext context =
                new AnnotationConfigServletWebServerApplicationContext(WebConfig.class);

        RequestMappingHandlerMapping handlerMapping = context.getBean(RequestMappingHandlerMapping.class);
        MyRequestMappingHandlerAdapter handlerAdapter = context.getBean(MyRequestMappingHandlerAdapter.class);

        MockHttpServletRequest request = new MockHttpServletRequest("PUT", "/test3");
        request.addHeader("token", "令牌");
        MockHttpServletResponse response = new MockHttpServletResponse();
        //返回处理器执行链对象
        HandlerExecutionChain chain = handlerMapping.getHandler(request);

        handlerAdapter.invokeHandlerMethod(request, response, (HandlerMethod) chain.getHandler());
    }
}

结果：

[DEBUG] 10:51:26.150 [main] com.itheima.a20.Controller1  - test3(令牌)

2、自定义返回值处理器

实现 HandlerMethodReturnValueHandler 接口

public class YmlReturnValueHandler implements HandlerMethodReturnValueHandler {
    @Override
    public boolean supportsReturnType(MethodParameter returnType) {
        Yml yml = returnType.getMethodAnnotation(Yml.class);
        return yml != null;
    }

    @Override
    public void handleReturnValue(Object returnValue, MethodParameter returnType,
                                  ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
        //returnValue : 返回值对象
        //1. 转换返回结果为 yaml 字符串
        String str = new Yaml().dump(returnValue);

        //2. 将 yaml 字符串写入响应
        //获取原始的响应对象
        HttpServletResponse response = webRequest.getNativeResponse(HttpServletResponse.class);
        //设置发送到客户端的响应的内容类型为文本格式
        response.setContentType("text/plain;charset=utf-8");
        response.getWriter().print(str);

        //3.设置请求已经处理完毕
        mavContainer.setRequestHandled(true);
    }
}

将自定义的返回值解析器加到 handleAdapter

    @Bean
    public MyRequestMappingHandlerAdapter requestMappingHandlerAdapter(){
        MyRequestMappingHandlerAdapter handlerAdapter = new MyRequestMappingHandlerAdapter();
        YmlReturnValueHandler ymlReturnValueHandler = new YmlReturnValueHandler();
        //将自定义的返回值解析器加到handleAdapter
        handlerAdapter.setCustomReturnValueHandlers(Arrays.asList(ymlReturnValueHandler));
        return handlerAdapter;
    }

主启动类

public class A20 {
    public static void main(String[] args) throws Exception {
        //支持内嵌 Tomcat 容器的 Spring 容器实现
        AnnotationConfigServletWebServerApplicationContext context =
                new AnnotationConfigServletWebServerApplicationContext(WebConfig.class);

        RequestMappingHandlerMapping handlerMapping = context.getBean(RequestMappingHandlerMapping.class);
        MyRequestMappingHandlerAdapter handlerAdapter = context.getBean(MyRequestMappingHandlerAdapter.class);

        MockHttpServletRequest request = new MockHttpServletRequest("Get", "/test4");
        MockHttpServletResponse response = new MockHttpServletResponse();
        //返回处理器执行链对象
        HandlerExecutionChain chain = handlerMapping.getHandler(request);

        handlerAdapter.invokeHandlerMethod(request, response, (HandlerMethod) chain.getHandler());

        //检查响应
        byte[] content = response.getContentAsByteArray();
        System.out.println(new String(content, StandardCharsets.UTF_8));

    }
}

 结果：

!!com.itheima.a20.Controller1$User {age: 18, name: 张三}
小鲁蛋儿
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
springmvc中RequestMappingHandlerAdapter与HttpMessageConverter的装配讲解
08-26
今天小编就为大家分享一篇关于springmvc中RequestMappingHandlerAdapter与HttpMessageConverter的装配讲解，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
这一次搞懂SpringMVC原理说明
09-07
这一次深入理解SpringMVC原理，将帮助我们更好地掌握这个强大的Web框架在处理HTTP请求时的工作流程。SpringMVC是Spring框架的重要组成部分，主要用于构建Web应用的Model-View-Controller架构。在本文中，我们将探讨...
RequestMappingHandlerMapping详解
zpx_Smart的博客
05-08 6159
我们先理简单梳理一个关系 关系梳理 spring ioc 是spring的核心，用来管理spring bean的生命周期 MVC 是一种使用 MVC（Model View Controller 模型-视图-控制器）设计创建 Web 应用程序的模式 spring mvc 是spring的一个独立的模块，就像AOP一样 在spring mvc中把web框架和spring ioc融合在一起，是通过ContextLoaderListener监听servlet上下文的创建后来加载父容器完成的，然后通过配置一个serv
Spring RequestMappingHandlerMapping详解
最新发布
老码农的博客
05-17 727
RequestMappingHandlerMapping是Spring MVC中的一个请求映射处理器，它负责将HTTP请求映射到特定的@RequestMapping注解的方法上。
Error creating bean with name ‘org.springframework.web.servlet.mvc.method.annotation.RequestMapping
m0_50142175的博客
03-29 5129
报错信息： Error creating bean with name 'org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping': Invocation of init method failed; nested exception is java.lang.IllegalStateException: Invalid mapping on handler class [ssm.bean.Emp
Spring MVC HandlerMapping : RequestMappingHandlerMapping 源代码解析
Details Inside Spring
03-30 2013
源代码版本 : spring-webmvc-5.1.4.RELEASE 概述 RequestMappingHandlerMapping是HandlerMapping的一个实现，主要用于针对控制器类(带有注解@Controller)中类级别或者方法级别的注解@RequestMapping创建RequestMappingInfo并管理。 RequestMappingHandlerMapping的实...
SpringMVC系列:HandlerMapping初始化
yygr的博客
03-31 504
https://blog.csdn.net/csdn_20150804/article/details/103943435 文章目录 1.HttpServletBean#init() 2.DispatcherServlet#onRefresh(ApplicationContext context) 3.WebMvcAutoConfiguration初始化配置 4.RequestMappingHandlerMapping初始化 基于s
RequestMappingHandlerMapping 使用
weixin_43262188的博客
05-07 9506
RequestMappingHandlerMapping 简单使用 RequestMappingHandlerMapping 是一个非常便捷的类，它在springMVc启动时加载，有一个最重要方法就是 Map<RequestMappingInfo, HandlerMethod> handlerMethods =requestMappingHandlerMapping.getHandl...
SpringMVC工作原理实例详解
08-24
SpringMVC 工作原理实例详解中，通过示例代码介绍了非常详细，对大家的学习或者工作具有一定的参考学习价值。 在 SpringMVC 中，我们可以使用 @Controller 和 @RequestMapping 注解来处理浏览器中的请求。然而，...
SpringMVC原理共3页.pdf.zip
10-30
SpringMVC原理共3页.pdf.zip
SpringMvc学习资料
05-30
内含200页word文档，包含了大量源码，通过项目带你学习SpringMvc
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter问题
CodAlun的博客
06-02 3900
今天在启动tomcat项目的时候报了这个错误，刚看到的时候很懵不知道怎么回事，经过网上查阅发现是Spring MVC和jackson的版本不兼容问题。在这里记录一下。 我之前采用的是Spring MVC 5.2.2；jackson是1.9.13； 后来发现org.codehaus.jackson的jar包升级后更名为org.codehaus.jackson，所以我使用了Spring MVC 4.3.6 ;jackson 2.8.x；发现成功了！！ 下面是Maven依赖 <!--SpringMVC使用
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter异常
LDM228247714的博客
10-14 1275
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter之Jackson问题 话不多说,我报这个异常的原因是忘了添加Jackson包的依赖,版本自行选择适合spring的。 ...
Springboot项目获取所有的接口
小石潭记丶
11-27 5176
@Autowired private WebApplicationContext applicationContext; @Override public List getAllUrl() { RequestMappingHandlerMapping mapping = applicationContext.getBean(RequestMappingHandlerMapping.class); // 获取url与类和方法的对应信息 Map<RequestMappingIn.
SpringMVC项目启动报RequestMappingHandlerMapping异常
chengqinxia4767的博客
05-22 971
严重: Exception sending context initialized event to listener instance of class org.springframework.web.context.ContextLoaderListener org.springfram...
springboot-RequestMappingHandlerMapping
weixin_30577801的博客
10-09 1151
作用：查看应用请求对应的ur和方法l情况 实例： RequestMappingHandlerMapping mapping =applicationContext.getBean("requestMappingHandlerMapping",RequestMappingHandlerMapping.class); Map<RequestMappingInfo, Handl...
springmvc源码学习(一)RequestMappingHandlerMapping
码易的博客
07-18 939
目录前言一、RequestMappingHandlerMapping实例化二、使用步骤1.引入库2.读入数据总结 前言 RequestMappingHandlerMapping用于。 提示：以下是本篇文章正文内容，下面案例可供参考 一、RequestMappingHandlerMapping实例化 （1）WebMvcRequestHandlerProvider 在servlet的web环境下会加载该配置类，在类构造方法执行时，会初始化三个参数，其中一个参数是handlerMappings，此时对应的..
HandlerMapping解析
沐雨金鳞
10-04 6845
Spingmvc中的HandlerMapping负责解析请求URL，对应到Handler进行处理（这里的Handler一般为Controller里的一个方法method，也可以为servlet或者Controller等） 来看一个http请求的入口DispatcherServlet： DispatcherServlet继承FrameworkServlet，FrameworkServlet继承HttpServletBean，HttpServletBean继承HttpServlet。 可以看出..
SpringMVC
qq_34922830的博客
10-14 630
DispatcherServlet 是在第一次被访问时执行初始化, 也可以通过配置修改为 Tomcat 启动后就初始化 registrationBean.setLoadOnStartup()首先创建了 Servlet 容器，其次创建了 Servlet 的前端控制器，最后将 容器和控制器进行组合。每个具体的init的方法中都会去收集自定义的 Resolver 如果没有则会加载默认的配置。调用控制器方法、并处理方法参数与方法返回值。可查看 Tomcat 启动日志查看。
springMVC原理
07-22
Spring MVC是Spring框架中用于开发Web应用程序的模块，它的核心原理是基于前端控制器、处理器映射器、处理器适配器和视图解析器等组件的协作。 1. 前端控制器（Front Controller）：Spring MVC的核心是一个Servlet，称为DispatcherServlet，它充当了应用程序的前端控制器。当请求到达应用程序时，DispatcherServlet负责接收请求并将其分派给相应的处理器。 2. 处理器映射器（Handler Mapping）：处理器映射器负责将请求映射到相应的处理器（Controller）上。它根据请求的URL或其他条件来确定请求应该由哪个处理器来处理。 3. 处理器适配器（Handler Adapter）：处理器适配器负责将请求发送给正确的处理器，并根据处理器的类型和方法来调用相应的方法进行处理。处理器适配器能够适配各种类型的处理器，包括带注解的控制器、基于接口的控制器等。 4. 控制器（Controller）：控制器是Spring MVC应用程序的核心组件，它负责处理请求并返回相应的结果。控制器可以是一个普通的Java类，通过注解或配置来标识其为一个控制器，并定义处理请求的方法。 5. 视图解析器（View Resolver）：视图解析器负责将处理器返回的逻辑视图名解析为实际的视图对象。它可以根据配置文件或约定来解析视图，将数据模型与视图进行合并，并最终生成响应结果。 6. 视图（View）：视图是最终呈现给用户的界面，它可以是JSP、HTML、JSON、XML等格式。控制器将处理结果传递给视图，由视图负责生成最终的响应内容。 在整个请求处理过程中，前端控制器DispatcherServlet负责协调各个组件的工作，并提供了一种灵活的扩展机制，可以通过拦截器、异常处理器等进行功能增强和定制。Spring MVC的原理是基于这些组件的协作，实现了请求的分发、处理和响应等功能，使得开发Web应用程序更加简单和高效。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小鲁蛋儿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值