深入理解RequestMappingHandlerMapping设计思想

最新推荐文章于 2024-06-30 14:45:27 发布
最新推荐文章于 2024-06-30 14:45:27 发布
阅读量796 收藏 2
点赞数
分类专栏： SpringMVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33553218/article/details/108600794
版权

简介

本文从类的设计角度分析SpringMVC从RequestMappingHandlerMapping获取handler的整体流程，分析了RequestMappingHandlerMapping及其父类之间的关系。

getHandler干了什么

getHandler主要干下面三件事情：

  1. 根据request找到handler
  2. 根据request找到handlerInterceptor
  3. 把handler和handlerInterceptor一起放到一个HandlerExecutionChain里面，返回这个HandlerExecutionChain。

在开始看代码之前先了解一下HandlerExecutionChain是个什么东西

public class HandlerExecutionChain {

   private final Object handler;

   @Nullable
   private HandlerInterceptor[] interceptors;

   @Nullable
   private List<HandlerInterceptor> interceptorList;
}

其实就是handler+HandlerInterceptor列表

那handler又是什么东西？注意到它的类型是Object，在RequestMappingHandlerMapping中它就是HandlerMethod。

public class HandlerMethod {

   private final Object bean;

   @Nullable
   private final BeanFactory beanFactory;

   private final Class<?> beanType;

   private final Method method;

   private final Method bridgedMethod;

   private final MethodParameter[] parameters;

   @Nullable
   private HttpStatus responseStatus;

   @Nullable
   private String responseStatusReason;

   @Nullable
   private HandlerMethod resolvedFromHandlerMethod;
}

HandlerMethod包含了处理 的方法的各种信息。

继承关系

先看一下继承关系

在这里插入图片描述

AbstractHandlerMapping主要实现找handlerInterceptor，子类实现找handler。

我们先从AbstractHandlerMapping开始分析。

AbstractHandlerMapping

先看最重要的方法getHandler，这是dispatcherServlet调用HandlerMapping的入口。

主逻辑
// AbstractHandlerMapping
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
   // 子类实现
   Object handler = getHandlerInternal(request);
   // hander相关的一些判断操作
   // 当前类实现，获得handlerInterceptor，组合成HandlerExecutionChain
   HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);

   // cors相关
   if (hasCorsConfigurationSource(handler) || CorsUtils.isPreFlightRequest(request)) {
       CorsConfiguration config = getCorsConfiguration(handler, request);
       if (getCorsConfigurationSource() != null) {
           CorsConfiguration globalConfig = getCorsConfigurationSource().getCorsConfiguration(request);
           config = (globalConfig != null ? globalConfig.combine(config) : config);
       }
       executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
	}
   return executionChain;
}

getHandlerInternal是子类实现的，这个之后再看，先分析getHandlerExecutionChain。

// AbstractHandlerMapping

// HandlerInterceptor列表
private final List<HandlerInterceptor> adaptedInterceptors = new ArrayList<>();

protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
   HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
         (HandlerExecutionChain) handler : new HandlerExecutionChain(handler));

   for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
      // 处理MappedInterceptor
      if (interceptor instanceof MappedInterceptor) {
         MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
         if (mappedInterceptor.matches(request)) {
            //把Interceptor加到HandlerExecutionChain里面
            chain.addInterceptor(mappedInterceptor.getInterceptor());
         }
      } else {
         // 处理普通Interceptor
         chain.addInterceptor(interceptor);
      }
   }
   return chain;
}

逻辑很简单，遍历this.adaptedInterceptors，把里面符合当前request的加到HandlerExecutionChain就好了。

唯一的问题就是这个this.adaptedInterceptors是怎么来的？

adaptedInterceptors初始化

答案就在initApplicationContext这个方法里，AbstractHandlerMapping继承了ApplicationObjectSupport，而 ApplicationObjectSupport实现了ApplicationContextAware，所以initApplicationContext这个方法会在bean初始化的时候被调用。

// AbstractHandlerMapping
protected void initApplicationContext() throws BeansException {
    // 空方法
   extendInterceptors(this.interceptors);
    // 找所有的MappedInterceptors，放到this.adaptedInterceptors里面
   detectMappedInterceptors(this.adaptedInterceptors);
    // 初始化Interceptors
   initInterceptors();
}

// 就是按类查找
protected void detectMappedInterceptors(List<HandlerInterceptor> mappedInterceptors) {
		mappedInterceptors.addAll(BeanFactoryUtils.beansOfTypeIncludingAncestors(
				obtainApplicationContext(), MappedInterceptor.class, true, false).values());
}

// 把interceptors列表中的interceptor做个类型转换，然后放到adaptedInterceptors列表中
protected void initInterceptors() {
   if (!this.interceptors.isEmpty()) {
      for (int i = 0; i < this.interceptors.size(); i++) {
         Object interceptor = this.interceptors.get(i);
         if (interceptor == null) {
            throw new IllegalArgumentException("Entry number " + i + " in interceptors array is null");
         }
         this.adaptedInterceptors.add(adaptInterceptor(interceptor));
      }
   }
}

上面找的是所有的MappedInterceptor，它和普通的Interceptor的关系是什么?

MappedInterceptor和Interceptor的关系

从xml配置文件看，它们的关系就是 < mvc:interceptor > 整体 和 MyInterceptor 的关系

<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/abc/**" />
        <mvc:exclude-mapping path="/xyz//*" />
        <bean class="com.a.b.c.MyInterceptor" />
    </mvc:interceptor>
</mvc:interceptors>

从代码中可以发现MappedInterceptor里面有具体的interceptor还有一些匹配路径相关的东西。

public final class MappedInterceptor implements HandlerInterceptor {

   private static PathMatcher defaultPathMatcher = new AntPathMatcher();

   @Nullable
   private final PathPattern[] includePatterns;

   @Nullable
   private final PathPattern[] excludePatterns;

   private PathMatcher pathMatcher = defaultPathMatcher;

   private final HandlerInterceptor interceptor;
}

AbstractHandlerMapping就分析完了，接下去看AbstractHandlerMethodMapping

AbstractHandlerMethodMapping

从AbstractHandlerMapping留给子类的getHandlerInternal开始分析

// AbstractHandlerMethodMapping

// 存储mapping和HandlerMethod的映射，mapping包含了匹配某个handler method需要的条件。
// 通俗的说mapping就是用来描述@RequestMapping里面的各种条件
private final MappingRegistry mappingRegistry = new MappingRegistry();

protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
    // 从request获取路径
   String lookupPath = initLookupPath(request);
    // mappingRegistry上锁
   this.mappingRegistry.acquireReadLock();
   try {
       // 从mappingRegistry里面找到handlerMethod
      HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
      return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
   }
   finally {
      this.mappingRegistry.releaseReadLock();
   }
}

接下来先来认识一下MappingRegistry。

T就表示mapping的类型，具体是RequestMappingInfo，在其子类RequestMappingInfoHandlerMapping中定义。

class MappingRegistry {
    // 通过@RequestMapping里面的条件，得到各种映射信息，具体初始化位置见MappingRegistry初始化

   private final Map<T, MappingRegistration<T>> registry = new HashMap<>();

   private final Map<T, HandlerMethod> mappingLookup = new LinkedHashMap<>();

   private final MultiValueMap<String, T> urlLookup = new LinkedMultiValueMap<>();

   private final Map<String, List<HandlerMethod>> nameLookup = new ConcurrentHashMap<>();

   private final Map<HandlerMethod, CorsConfiguration> corsLookup = new ConcurrentHashMap<>();

   private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
}
lookupHandlerMethod
protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
   List<Match> matches = new ArrayList<>();
   // 根据url找所有的mapping
   List<T> directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);
   if (directPathMatches != null) {
      // 遍历根据url找到的所有的mapping，找和当前request匹配的，存到matches里面
      addMatchingMappings(directPathMatches, matches, request);
   }
   if (matches.isEmpty()) {
      // No choice but to go through all mappings...
      addMatchingMappings(this.mappingRegistry.getMappings().keySet(), matches, request);
   }

   if (!matches.isEmpty()) {
      Match bestMatch = matches.get(0);
      // 处理匹配到好几个的情况
      if (matches.size() > 1) {
          // 比较器留给子类实现
         Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
         matches.sort(comparator);
         bestMatch = matches.get(0);
         if (logger.isTraceEnabled()) {
            logger.trace(matches.size() + " matching mappings: " + matches);
         }
         if (CorsUtils.isPreFlightRequest(request)) {
            return PREFLIGHT_AMBIGUOUS_MATCH;
         }
         Match secondBestMatch = matches.get(1);
         if (comparator.compare(bestMatch, secondBestMatch) == 0) {
            Method m1 = bestMatch.handlerMethod.getMethod();
            Method m2 = secondBestMatch.handlerMethod.getMethod();
            String uri = request.getRequestURI();
            throw new IllegalStateException(
                  "Ambiguous handler methods mapped for '" + uri + "': {" + m1 + ", " + m2 + "}");
         }
      }
      request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.handlerMethod);
      // 有没有好奇过template uri里面的变量是怎么被传到入参里的
      // 里面会把template uri（比如hi/{id}）中的值解析，以map的形式存到request里面，之后在绑定入参时就可以用了
      handleMatch(bestMatch.mapping, lookupPath, request);
      return bestMatch.handlerMethod;
   } else {
      return handleNoMatch(this.mappingRegistry.getMappings().keySet(), lookupPath, request);
   }
}

private void addMatchingMappings(Collection<T> mappings, List<Match> matches, HttpServletRequest request) {
   for (T mapping : mappings) {
       // 留给子类实现
      T match = getMatchingMapping(mapping, request);
      if (match != null) {
         matches.add(new Match(match, this.mappingRegistry.getMappings().get(mapping)));
      }
   }
}
MappingRegistry初始化
// AbstractHandlerMethodMapping
@Override
public void afterPropertiesSet() {
   initHandlerMethods();
}

protected void initHandlerMethods() {
   // 获得所有的beanName
   for (String beanName : getCandidateBeanNames()) {
      if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
         // 找所有的handler method方法，如果有代理就找到代理方法，注册到mappingRegistry里面。
         processCandidateBean(beanName);
      }
   }
   // 没有逻辑代码，就log一下
   handlerMethodsInitialized(getHandlerMethods());
}

RequestMappingInfoHandlerMapping

继承AbstractHandlerMethodMapping，传入了具体的mapping类型：RequestMappingInfo。

public final class RequestMappingInfo implements RequestCondition<RequestMappingInfo> {
    private final String name;

	@Nullable
	private final PathPatternsRequestCondition pathPatternsCondition;

	@Nullable
	private final PatternsRequestCondition patternsCondition;

	private final RequestMethodsRequestCondition methodsCondition;

	private final ParamsRequestCondition paramsCondition;

	private final HeadersRequestCondition headersCondition;

	private final ConsumesRequestCondition consumesCondition;

	private final ProducesRequestCondition producesCondition;

	private final RequestConditionHolder customConditionHolder;

	private final int hashCode;
}

从父类AbstractHandlerMethodMapping留的getMatchingMapping和getMappingComparator方法开始分析。

getMatchingMapping
// RequestMappingInfoHandlerMapping
protected RequestMappingInfo getMatchingMapping(RequestMappingInfo info, HttpServletRequest request) {
   return info.getMatchingCondition(request);
}

// RequestMappingInfo
public RequestMappingInfo getMatchingCondition(HttpServletRequest request) {
   RequestMethodsRequestCondition methods = this.methodsCondition.getMatchingCondition(request);
   if (methods == null) {
      return null;
   }
   ParamsRequestCondition params = this.paramsCondition.getMatchingCondition(request);
   if (params == null) {
      return null;
   }
   HeadersRequestCondition headers = this.headersCondition.getMatchingCondition(request);
   if (headers == null) {
      return null;
   }
   ConsumesRequestCondition consumes = this.consumesCondition.getMatchingCondition(request);
   if (consumes == null) {
      return null;
   }
   ProducesRequestCondition produces = this.producesCondition.getMatchingCondition(request);
   if (produces == null) {
      return null;
   }
   PathPatternsRequestCondition pathPatterns = null;
   if (this.pathPatternsCondition != null) {
      pathPatterns = this.pathPatternsCondition.getMatchingCondition(request);
      if (pathPatterns == null) {
         return null;
      }
   }
   PatternsRequestCondition patterns = null;
   if (this.patternsCondition != null) {
      patterns = this.patternsCondition.getMatchingCondition(request);
      if (patterns == null) {
         return null;
      }
   }
   RequestConditionHolder custom = this.customConditionHolder.getMatchingCondition(request);
   if (custom == null) {
      return null;
   }
   return new RequestMappingInfo(
         this.name, pathPatterns, patterns, methods, params, headers, consumes, produces, custom);
}

上述代码就是从request中找到符合当前RequestMappingInfo的条件，然后根据这些条件重新创建一个RequestMappingInfo。

getMappingComparator
// RequestMappingInfoHandlerMapping
protected Comparator<RequestMappingInfo> getMappingComparator(final HttpServletRequest request) {
   return (info1, info2) -> info1.compareTo(info2, request);
}

// RequestMappingInfo
public int compareTo(RequestMappingInfo other, HttpServletRequest request) {
   int result;
   // Automatic vs explicit HTTP HEAD mapping
   if (HttpMethod.HEAD.matches(request.getMethod())) {
      result = this.methodsCondition.compareTo(other.getMethodsCondition(), request);
      if (result != 0) {
         return result;
      }
   }
   result = getActivePatternsCondition().compareTo(other.getActivePatternsCondition(), request);
   if (result != 0) {
      return result;
   }
   result = this.paramsCondition.compareTo(other.getParamsCondition(), request);
   if (result != 0) {
      return result;
   }
   result = this.headersCondition.compareTo(other.getHeadersCondition(), request);
   if (result != 0) {
      return result;
   }
   result = this.consumesCondition.compareTo(other.getConsumesCondition(), request);
   if (result != 0) {
      return result;
   }
   result = this.producesCondition.compareTo(other.getProducesCondition(), request);
   if (result != 0) {
      return result;
   }
   // Implicit (no method) vs explicit HTTP method mappings
   result = this.methodsCondition.compareTo(other.getMethodsCondition(), request);
   if (result != 0) {
      return result;
   }
   result = this.customConditionHolder.compareTo(other.customConditionHolder, request);
   if (result != 0) {
      return result;
   }
   return 0;
}

就是按照不同条件的优先级，进行比较。

RequestMappingHandlerMapping

在AbstractHandlerMethodMapping初始化过程中，调用了的processCandidateBean方法，其中用到的两个两个方法都是留给子类去实现的。

// AbstractHandlerMethodMapping
protected abstract boolean isHandler(Class<?> beanType);

@Nullable
protected abstract T getMappingForMethod(Method method, Class<?> handlerType);

// RequestMappingHandlerMapping
protected boolean isHandler(Class<?> beanType) {
    // 检查类上有没有Controller或者RequestMapping注解
   return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||
         AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));
}

protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
    // 获取方法上的信息
   RequestMappingInfo info = createRequestMappingInfo(method);
   if (info != null) {
       // 获取类上的信息，合并
      RequestMappingInfo typeInfo = createRequestMappingInfo(handlerType);
      if (typeInfo != null) {
         info = typeInfo.combine(info);
      }
      String prefix = getPathPrefix(handlerType);
      if (prefix != null) {
         info = RequestMappingInfo.paths(prefix).options(this.config).build().combine(info);
      }
   }
   return info;
}

总结

下面斜体部分表示具体功能由子类实现。

AbstractHandlerMapping
  1. 提供了getHandler这个主逻辑，getHandler主要分两部分：1. 获得Interceptors，2. 获得handler(具体逻辑子类实现)
  2. 完成获得Interceptors的步骤。
  3. 预留getHandlerInternal方法，由子类完成获得handler。
AbstractHandlerMethodMapping

这个类是获得method形式的handler的类，主要是有两部分，都是围绕MappingRegistry。MappingRegistry中mapping的具体类型是RequestMappingInfoHandlerMapping定义的。

初始化MappingRegistry

  1. 找到handler方法

  2. 获取handler方法的mapping，注册到MappingRegistry里面。

    这两部分的具体实现会涉及到RequestMappingHandlerMapping。

通过MappingRegistry获得handler

  1. 重载了AbstractHandlerMapping留的getHandlerInternal方法，返回一个HandlerMethod。这个过程主要分三部分：1. 获得mappings，2. 从mappings中找到和request匹配的(具体逻辑子类实现)，3. 如果有好几个匹配的话需要排序(具体逻辑子类实现）。
  2. 预留getMatchingMapping方法，由RequestMappingInfoHandlerMapping重载，完成从mappings中找到和request匹配的。
  3. 预留getMappingComparator方法，由RequestMappingInfoHandlerMapping重载，完成mapping的排序。
RequestMappingInfoHandlerMapping
  1. 定义了AbstractHandlerMethodMapping中的mapping的具体类型RequestMappingInfo
  2. 重载了getMatchingMapping，实现从多个mappings中找到和request匹配的。
  3. 重载了getMappingComparator，实现mapping的排序。
RequestMappingHandlerMapping
  1. 重载AbstractHandlerMethodMapping初始化MappingRegistry过程中用到的两个函数isHandler和getMappingForMethod，实现从标了@RequestMapping的方法 到 mapping的转换。
haikuc
关注
专栏目录
Spring MVC学习教程之RequestMappingHandlerMapping匹配
08-26
在Spring MVC框架中，`RequestMappingHandlerMapping`是一个关键组件，它负责映射HTTP请求到相应的处理器方法（`HandlerMethod`）。...理解这个组件的工作原理对于深入学习Spring MVC和优化应用程序性能至关重要。
Spring Boot 2.6以后版本优雅解决PatternsRequestCondition.getPatterns()“ because “this.condition“ is null问题
每天进步一点
10-29 7202
就可以了，这个我之前就这么用的，最近springboot版本升级到2.7.4了，也顺带了解了下springboot3.0版本升级事项，目前pathmatch 这个配置虽然在3.0也保留了，但是spring官网建议还是让我们调整；如果想省事就用上面的，但是我为了后面好升级，就找了下解决方案，通过这个问题，我发现，还是到官网去找，性能高一些。这里有两种解决方案，第一个是我上面写的，第二个是webmvc处理器来进行处理的，我看了下评论有些局限性，大家可以尝试下。其实网上已经有了，通过。
RequestMappingHandlerMapping的工作原理
WannaRunning的博客
07-23 1208
使用SpringMVC开发的人都知道最常用的定义接口的方式就是借助于@Controller和@RequestMapping等注解实现。而RequestMappingHandlerMapping类就是用于扫描注解和生成URL映射，处理请求时的URL映射匹配等关键功能的。 请求时如何到达对应的方法的 在DispatchServlet中，doDispatch方法会历各种HandlerMapping。当遍历到RequestMappingHandlerMapping时，RequestMappingHandlerM
RequestMappingHandlerMapping工作原理和应用实践
最新发布
发现问题，面对问题，分析问题，解决问题，总结问题
06-30 947
RequestMappingHandlerMapping 的主要任务是扫描 Spring 容器中的所有处理器（标注了 @Controller 或 @RestController 注解的类），并找到其中标注了 @RequestMapping、@GetMapping、@PostMapping 等注解的方法，将这些方法注册到一个映射表中，以便在接收到 HTTP 请求时能快速找到并执行对应的处理器方法。
详解SpringMVC-RequestMappingHandlerMapping
m0_71777195的博客
02-26 2901
使用SpringBoot进行web开发时，控制器类由@注解修饰，通常@注解与@配合使用，被修饰的类用于处理由分发下来的web请求。那么当一个web请求到达时，是如何将请求下发给对应的控制器处理呢。该篇文章将结合SpringMVC源码，对在分发请求过程中起重要作用的类进行学习。SpringBoot2.4.1主要用于@Controller注解和@注解结合使用的场景，能够将我们编写的控制器信息缓存并在请求到来时根据请求信息找到最合适的控制器来处理请求。那么的作用就是将Controller类里面所有的。
【SpringMVC源码三千问】@RequstMapping和RequestCondition
老王的专栏
05-24 1122
是 SpringMVC 中最常用的定义请求映射关系的注解。下面我们来分析一下它的源码。
SpringMVC源码解析之RequestMappingHandlerMapping：getHandler
翻身已碰头的博客
06-24 2953
SpringMVC源码解析之Servlet SpringMVC源码解析之GenericServlet和HttpServlet SpringMVC源码解析之DispatcherServlet：生命周期init()和destroy() SpringMVC源码解析之DispatcherServlet：请求处理 SpringMVC源码解析之RequestMappingHandlerMapping：getH...
Spring RequestMappingHandlerMapping详解.pdf
05-21
### Spring RequestMappingHandlerMapping详解 #### 一、前言 `RequestMappingHandlerMapping`是Spring MVC框架中的核心组件之一，主要用于处理HTTP请求与控制器方法之间的映射关系。通过使用这一组件，开发者可以...
Spring_MVC_教程_快速入门_深入分析
09-11
以上这些内容构成了Spring MVC快速入门的基础，通过本教程的学习，即便是Spring MVC的菜鸟也能快速上手并深入理解框架的精髓。此外，通过比较Spring MVC与Struts2、Servlet等其他MVC框架，本教程也强调了选择Spring ...
SpringMVC-lean:看透SpringMVC源码分析与实战笔记
03-23
总之，深入理解SpringMVC的源码分析，不仅可以帮助我们解决实际开发中的问题，还能提升我们的设计能力和代码质量，让Web应用更加高效、稳定。通过实战项目，将理论知识运用到实践中，进一步巩固和提升技能。
SpringMVC源码分析系列
08-10
深入理解这些关键组件及其实现机制，对于掌握SpringMVC源码以及深入理解Web MVC框架的工作原理是非常重要的。通过对源码的分析，可以知晓在用户通过浏览器访问时，SpringMVC是如何确定要调用哪个Controller中的具体...
RequestMappingHandlerMapping源码解析
OceanSky的专栏
06-29 3760
RequestMappingHandlerMapping的作用是在容器启动后将系统中所有控制器方法的请求条件（RequestMappingInfo）和控制器方法(HandlerMethod)的对应关系注册到RequestMappingHandlerMapping Bean的内存中，待接口请求系统的时候根据请求条件和内存中存储的系统接口信息比对，再执行对应的控制器方法。 1.首先分析下HandlerMethod（控制器方法包装对象） public class HandlerMethod { //bean.
解决WebMvcPatternsRequestConditionWrapper.getPatterns NullPointerException 启动失败
qq_35425070的博客
03-13 9004
Spring Boot2.6之后，swagger的包，WebMvcPatternsRequestConditionWrapper.getPatterns NPE 异常 文章目录Spring Boot2.6之后，swagger的包，WebMvcPatternsRequestConditionWrapper.getPatterns NPE 异常报错现象堆栈截图排查过程解决方案 报错现象 堆栈 2022-03-13 02:40:28.000 ERROR [16312] --- [ main]
RequestMappingHandlerMapping详解
zpx_Smart的博客
05-08 6376
我们先理简单梳理一个关系 关系梳理 spring ioc 是spring的核心，用来管理spring bean的生命周期 MVC 是一种使用 MVC（Model View Controller 模型-视图-控制器）设计创建 Web 应用程序的模式 spring mvc 是spring的一个独立的模块，就像AOP一样 在spring mvc中把web框架和spring ioc融合在一起，是通过ContextLoaderListener监听servlet上下文的创建后来加载父容器完成的，然后通过配置一个serv
HandlerMapping之RequestMappingHandlerMapping作用详解
男神的专栏
02-13 1731
上回我们知道HandlerMapping是用来寻找Handler的，并不与Handler的类型或者实现绑定，而是根据需要定义的。那么为什么要单独给@RequestMapping实现一个HandlerMapping？这次咱们就来专门看看这个RequestMappingHandlerMapping。由于@RequestMapping支持灵活的请求匹配条件，而不只是简单的路径，只能开发出RequestMappingHandlerMapping进行支持。
【Spring】抽丝剥茧SpringMVC-RequestMappingHandlerMapping
beFocused的博客
12-07 1004
HandlerMapping是DispatcherServlet主要的组件之一，其作用是帮助request找到合适的Handler。RequestMappingHandlerMapping是HandlerMapping主要实现类之前，对应着注解@RequestMapping
springboot动态加载接口、根据字符串生成Class对象
Ferrari215B的博客
07-07 3321
1.利用Groovy脚本将字符串文本转换成Class对象 2.获取Class对象中的方法 3.组装mvc请求映射信息RequestMappingInfo 4.动态将接口注入spring中
SpringBoot中动态注册接口
pp_lan的博客
01-05 1404
spring动态注册接口
RequestMappingHandlerMapping
08-31
RequestMappingHandlerMapping 是 Spring Framework 中的一个类，它是用来管理和处理请求映射的。它会扫描应用程序中的所有控制器类，并根据其中的注解信息来建立请求与处理方法之间的映射关系。 @RequestMapping ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值