SpringMVC系列（二）HandlerMapping初始化

最新推荐文章于 2024-06-28 11:50:04 发布
最新推荐文章于 2024-06-28 11:50:04 发布
阅读量227 收藏 1
点赞数
分类专栏： Spring
原文链接：https://blog.youkuaiyun.com/csdn_20150804/article/details/103943435
版权
本文详细剖析了Spring MVC在Spring Boot环境下初始化的核心流程，重点介绍了DispatcherServlet如何通过一系列策略模式初始化HandlerMappings等内容。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

版权声明：本文为优快云博主「雨剑yyy」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/csdn_20150804/article/details/103943435

文章目录


基于springboot2.1.4；
springmvc执行，核心逻辑是在DispatchServlet中，其中的若干属性，初始值都是null，如下： 

package org.springframework.web.servlet;

public class DispatcherServlet extends FrameworkServlet {
    ......
    protected void initStrategies(ApplicationContext context) {
        initMultipartResolver(context);
        initLocaleResolver(context);
        initThemeResolver(context);
        //主要分析这个
        initHandlerMappings(context);
        initHandlerAdapters(context);
        initHandlerExceptionResolvers(context);
        initRequestToViewNameTranslator(context);
        initViewResolvers(context);
        initFlashMapManager(context);
    }
    ......
}

上篇文章中，DispatchServlet在执行相关逻辑时，都是直接使用了上边这些属性，本文分析下这些属性是何时在哪里被初始化的，并以handlerMappings为例，着重分析。

DispatchServlet类是个servlet，包含init方法，tomcat容器在启动时，会默认执行init方法，而DispatchServlet的父类HttpServletBean实现了Servlet接口的init方法。因此我们从HttpServletBean#init() 方法开始。

1.HttpServletBean#init()

package org.springframework.web.servlet;

public abstract class HttpServletBean extends HttpServlet implements 
                                        EnvironmentCapable, EnvironmentAware {
	......
    public final void init() throws ServletException {

        // Set bean properties from init parameters.
        PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
        if (!pvs.isEmpty()) {
            try {
                BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
                ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
                bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
                initBeanWrapper(bw);
                bw.setPropertyValues(pvs, true);
            }
            catch (BeansException ex) {
                if (logger.isErrorEnabled()) {
                    logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
                }
                throw ex;
            }
        }

        // Let subclasses do whatever initialization they like.
        //此方法是个空方法，目的是留给子类自己去实现一些初始化动作
        initServletBean();
    }
	......
}

上面方法，其中关键方法是最后一行 initServletBean();这是个空方法，实现在其子类FrameworkServlet中实现，FrameworkServlet是DispatchServlet的直接父类。继续看下initServletBean的实现，

package org.springframework.web.servlet;

@SuppressWarnings("serial")
public abstract class FrameworkServlet extends HttpServletBean 
                                       implements ApplicationContextAware {
    ......
    protected final void initServletBean() throws ServletException {
        getServletContext().log("Initializing Spring " + getClass().getSimpleName() + " '" + getServletName() + "'");
        if (logger.isInfoEnabled()) {
            logger.info("Initializing Servlet '" + getServletName() + "'");
        }
        long startTime = System.currentTimeMillis();

        try {
            //初始化springmvc web容器
            this.webApplicationContext = initWebApplicationContext();
            //
            initFrameworkServlet();
        }
        catch (ServletException | RuntimeException ex) {
            logger.error("Context initialization failed", ex);
            throw ex;
        }

        if (logger.isDebugEnabled()) {
            String value = this.enableLoggingRequestDetails ?
                    "shown which may lead to unsafe logging of potentially sensitive data" :
                    "masked to prevent unsafe logging of potentially sensitive data";
            logger.debug("enableLoggingRequestDetails='" + this.enableLoggingRequestDetails +
                    "': request parameters and headers will be " + value);
        }

        if (logger.isInfoEnabled()) {
            logger.info("Completed initialization in " + (System.currentTimeMillis() - startTime) + " ms");
        }
    }
    ......   
}

其中initWebApplicationContext()表示初始化web容器，进入，

package org.springframework.web.servlet;

@SuppressWarnings("serial")
public abstract class FrameworkServlet extends HttpServletBean 
                                       implements ApplicationContextAware {
    ......
    protected WebApplicationContext initWebApplicationContext() {
        //得到根容器，也就是springmvc的父容器，spring容器ApplicationContext
        WebApplicationContext rootContext =
                WebApplicationContextUtils.getWebApplicationContext(getServletContext());
        WebApplicationContext wac = null;

        if (this.webApplicationContext != null) {
            // A context instance was injected at construction time -> use it
            wac = this.webApplicationContext;
            if (wac instanceof ConfigurableWebApplicationContext) {
                ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
                if (!cwac.isActive()) {
                    // The context has not yet been refreshed -> provide services such as
                    // setting the parent context, setting the application context id, etc
                    if (cwac.getParent() == null) {
                        // The context instance was injected without an explicit parent -> set
                        // the root application context (if any; may be null) as the parent
                        cwac.setParent(rootContext);
                    }
                    configureAndRefreshWebApplicationContext(cwac);
                }
            }
        }
        if (wac == null) {
            // No context instance was injected at construction time -> see if one
            // has been registered in the servlet context. If one exists, it is assumed
            // that the parent context (if any) has already been set and that the
            // user has performed any initialization such as setting the context id
            wac = findWebApplicationContext();
        }
        if (wac == null) {
            // No context instance is defined for this servlet -> create a local one
            wac = createWebApplicationContext(rootContext);
        }

        if (!this.refreshEventReceived) {
            // Either the context is not a ConfigurableApplicationContext with refresh
            // support or the context injected at construction time had already been
            // refreshed -> trigger initial onRefresh manually here.
            //刷新容器
            synchronized (this.onRefreshMonitor) {
                onRefresh(wac);
            }
        }

        if (this.publishContext) {
            // Publish the context as a servlet context attribute.
            String attrName = getServletContextAttributeName();
            getServletContext().setAttribute(attrName, wac);
        }

        return wac;
    }
    ......   
}

从上面方法可以看出，web容器实际上是spring容器的子容器，web容器内部包含了父容器的引用，然后再包含自己特有的一些内容，这些内容在onRefresh(wac);方法中初始化，继续进入onRefresh方法，

2.DispatcherServlet#onRefresh(ApplicationContext context)

package org.springframework.web.servlet;

public class DispatcherServlet extends FrameworkServlet {
    ......
    protected void onRefresh(ApplicationContext context) {
		initStrategies(context);
	}    
    
    protected void initStrategies(ApplicationContext context) {
        initMultipartResolver(context);
        initLocaleResolver(context);
        initThemeResolver(context);
        //初始化HandlerMappings
        initHandlerMappings(context);
        initHandlerAdapters(context);
        initHandlerExceptionResolvers(context);
        initRequestToViewNameTranslator(context);
        initViewResolvers(context);
        initFlashMapManager(context);
    }
    ......
}

这里使用了策略模式，其中initHandlerMappings(context);就是用来初始化handlerMappings属性的。

package org.springframework.web.servlet;

public class DispatcherServlet extends FrameworkServlet {
    ......
    private void initHandlerMappings(ApplicationContext context) {
		this.handlerMappings = null;

		if (this.detectAllHandlerMappings) {//默认是true，扫描所有
			// 从ApplicationContext中，找类型是HandlerMapping的bean
			Map<String, HandlerMapping> matchingBeans =
					BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
			if (!matchingBeans.isEmpty()) {
				//初始化handlerMappings属性
				this.handlerMappings = new ArrayList<>(matchingBeans.values());
				// We keep HandlerMappings in sorted order.
				AnnotationAwareOrderComparator.sort(this.handlerMappings);
			}
		}
		else {
			try {
				HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
				this.handlerMappings = Collections.singletonList(hm);
			}
			catch (NoSuchBeanDefinitionException ex) {
				// Ignore, we'll add a default HandlerMapping later.
			}
		}

		// Ensure we have at least one HandlerMapping, by registering
		// a default HandlerMapping if no other mappings are found.
		if (this.handlerMappings == null) {
		//如果容器中一个handlerMapping都没有，则给一个默认的，就是去DispatcherServlet.properties配置文件中读取
			this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
			if (logger.isTraceEnabled()) {
				logger.trace("No HandlerMappings declared for servlet '" + getServletName() +
						"': using default strategies from DispatcherServlet.properties");
			}
		}
	}
	......
}

上述方法中，handlerMappings是从上下文容器中直接get出来的，如果get不到，会使用默认的配置：其实从上述方法中的log信息中可以看出，有个叫DispatcherServlet.properties的配置文件。
打开看下：

org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver

org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping

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.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
	org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
	org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver

org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

从配置文件中我们可以发现，所有初始化所需要的内容都在这里了，其中包括HandlerMapping，共有两个。

但是，如果容器中有，就不会使用默认的，那么容器中是何时放进去的呢，
我们就直接分析springboot中的初始化逻辑。

3.WebMvcAutoConfiguration初始化配置

我们知道springboot在启动的时候，默认会加载spring.factories文件中的配置类，在spring-boot-autoconfigure.jar包下的spring.factories文件中，有如下内容：
org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration,

就是这个WebMvcAutoConfiguration，初始化了所有webmvc的配置，在这里面可以找到此配置类中还有个EnableWebMvcConfiguration内部类，可以发现他继承了WebMvcConfigurationSupport，所有HandlerMappings都能在这俩配置类中找到（代码比较多，就不贴出来了）。

4.RequestMappingHandlerMapping初始化

这里看下一个比较重要的HandlerMapping，RequestMappingHandlerMapping 的初始化代码，RequestMappingHandlerMapping专门用来处理@Controller修饰的bean，这种方式也是我们开发中最常用的。

package org.springframework.web.servlet.config.annotation;

public class WebMvcConfigurationSupport implements ApplicationContextAware, 
                                                    ServletContextAware {
    @Bean
    @SuppressWarnings("deprecation")
    public RequestMappingHandlerMapping requestMappingHandlerMapping(
        @Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager,
        @Qualifier("mvcConversionService") FormattingConversionService conversionService,
        @Qualifier("mvcResourceUrlProvider") ResourceUrlProvider resourceUrlProvider) {

        RequestMappingHandlerMapping mapping = createRequestMappingHandlerMapping();
        mapping.setOrder(0);
        mapping.setInterceptors(getInterceptors(conversionService, resourceUrlProvider));
        mapping.setContentNegotiationManager(contentNegotiationManager);
        mapping.setCorsConfigurations(getCorsConfigurations());

        PathMatchConfigurer configurer = getPathMatchConfigurer();

        Boolean useSuffixPatternMatch = configurer.isUseSuffixPatternMatch();
        if (useSuffixPatternMatch != null) {
            mapping.setUseSuffixPatternMatch(useSuffixPatternMatch);
        }
        Boolean useRegisteredSuffixPatternMatch = configurer.isUseRegisteredSuffixPatternMatch();
        if (useRegisteredSuffixPatternMatch != null) {
            mapping.setUseRegisteredSuffixPatternMatch(useRegisteredSuffixPatternMatch);
        }
        Boolean useTrailingSlashMatch = configurer.isUseTrailingSlashMatch();
        if (useTrailingSlashMatch != null) {
            mapping.setUseTrailingSlashMatch(useTrailingSlashMatch);
        }

        UrlPathHelper pathHelper = configurer.getUrlPathHelper();
        if (pathHelper != null) {
            mapping.setUrlPathHelper(pathHelper);
        }
        PathMatcher pathMatcher = configurer.getPathMatcher();
        if (pathMatcher != null) {
            mapping.setPathMatcher(pathMatcher);
        }
        Map<String, Predicate<Class<?>>> pathPrefixes = configurer.getPathPrefixes();
        if (pathPrefixes != null) {
            mapping.setPathPrefixes(pathPrefixes);
        }

        return mapping;
    }

	protected RequestMappingHandlerMapping createRequestMappingHandlerMapping() {
		return new RequestMappingHandlerMapping();
	}
}

上面这段代码，是告诉spring容器实例化一个RequestMappingHandlerMapping，并且设置了一些属性值。

而RequestMappingHandlerMapping类还实现了接口InitializingBean，所以在实例化后，会执行afterPropertiesSet()方法：

public class RequestMappingHandlerMapping extends RequestMappingInfoHandlerMapping
		implements MatchableHandlerMapping, EmbeddedValueResolverAware {
	......	
	public void afterPropertiesSet() {
		//初始化RequestMappingInfo的config
		this.config = new RequestMappingInfo.BuilderConfiguration();
		this.config.setUrlPathHelper(getUrlPathHelper());
		this.config.setPathMatcher(getPathMatcher());
		this.config.setSuffixPatternMatch(this.useSuffixPatternMatch);
		this.config.setTrailingSlashMatch(this.useTrailingSlashMatch);
		this.config.setRegisteredSuffixPatternMatch(this.useRegisteredSuffixPatternMatch);
		this.config.setContentNegotiationManager(getContentNegotiationManager());
		//调用父类方法
		super.afterPropertiesSet();
	}
	......

打开父类方法：

public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping 
													implements InitializingBean {
	......													
	public void afterPropertiesSet() {
		initHandlerMethods();
	}
	
	protected void initHandlerMethods() {
		//从spring容器中拿到所有bean，然后遍历
		for (String beanName : getCandidateBeanNames()) {
			if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
				//扫描所有handler方法，就是controller层的方法
				processCandidateBean(beanName);
			}
		}
		//记录个日志
		handlerMethodsInitialized(getHandlerMethods());
	}
	......
}

上述方法中，spring拿到容器中的诉苦有bean，然后遍历处理，让我们看下如何处理的，

public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping 
													implements InitializingBean {
	......	
	protected void processCandidateBean(String beanName) {
		Class<?> beanType = null;
		try {
			beanType = obtainApplicationContext().getType(beanName);
		}
		catch (Throwable ex) {
			// An unresolvable bean type, probably from a lazy bean - let's ignore it.
			if (logger.isTraceEnabled()) {
				logger.trace("Could not resolve type for bean '" + beanName + "'", ex);
			}
		}
		if (beanType != null && isHandler(beanType)) {
			//探测寻找Handler方法
			detectHandlerMethods(beanName);
		}
	}
	
	protected abstract boolean isHandler(Class<?> var1);
	......
}

上述代码逻辑就是判断一个bean是不是Handler（就是所谓的controller），如果是，那么就继续扫描Handler中的方法，并注册；其中判断isHandler(beanType)用来判断是否是handler。
因为我们这里分析的是RequestMappingHandlerMapping，所以isHandler方法在此类中实现：

public class RequestMappingHandlerMapping extends RequestMappingInfoHandlerMapping
		implements MatchableHandlerMapping, EmbeddedValueResolverAware {
	......	
	protected boolean isHandler(Class<?> beanType) {
		return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||
				AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));
	}
	......
}

就是判断bean上是否有@Controller注解或者@RequestMapping注解。

下面继续看下spring如何探测handler方法然后如何注册的，

public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping 
													implements InitializingBean {
	......
	protected void detectHandlerMethods(Object handler) {
	    //handler对象就是我们定义的一个Controller
		Class<?> handlerType = (handler instanceof String ?
				obtainApplicationContext().getType((String) handler) : handler.getClass());
	
		if (handlerType != null) {
			Class<?> userType = ClassUtils.getUserClass(handlerType);
			//扫描到Controller中的所有方法，key是方法名，value是路径名
			Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
					(MethodIntrospector.MetadataLookup<T>) method -> {
						try {
							return getMappingForMethod(method, userType);
						}
						catch (Throwable ex) {
							throw new IllegalStateException("Invalid mapping on handler class [" +
									userType.getName() + "]: " + method, ex);
						}
					});
			if (logger.isTraceEnabled()) {
				logger.trace(formatMappings(userType, methods));
			}
			//
			methods.forEach((method, mapping) -> {
				//如果有代理，这里要找到被代理后的方法
				Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
				//注册Method
				registerHandlerMethod(handler, invocableMethod, mapping);
			});
		}
	}
	......
}

上述代码逻辑，首先拿到Controller中的所有方法以及方法上的路径，如果方法有被代理，要使用被代理后的方法；然后遍历进行注册；
下面看下注册的逻辑：

public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping 
                                                   implements InitializingBean {
    private final AbstractHandlerMethodMapping<T>.MappingRegistry mappingRegistry = new AbstractHandlerMethodMapping.MappingRegistry();
    ......   
	protected void registerHandlerMethod(Object handler, Method method, T mapping) {
		this.mappingRegistry.register(mapping, handler, method);
	}
	...... 
}

其中，MappingRegistry是AbstractHandlerMethodMapping的内部类，里面维护了一堆map，

public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping 
                                                   implements InitializingBean {
    ......                                               
	class 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();
		......
	}
	......
}

注册就是往这些map中存东西：

public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping 
                                                   implements InitializingBean {
    ......         
    class MappingRegistry {
    	......
		public void register(T mapping, Object handler, Method method) {
			this.readWriteLock.writeLock().lock();
			try {
				HandlerMethod handlerMethod = createHandlerMethod(handler, method);
				assertUniqueMethodMapping(handlerMethod, mapping);
				//存储请求路径（包括请求方式）和请求方法的映射关系
				this.mappingLookup.put(mapping, handlerMethod);
		
				List<String> directUrls = getDirectUrls(mapping);
				for (String url : directUrls) {
				//存储url和请RequestMapping注解中的信息映射
					this.urlLookup.add(url, mapping);
				}
		
				String name = null;
				if (getNamingStrategy() != null) {
					name = getNamingStrategy().getName(handlerMethod, mapping);
					addMappingName(name, handlerMethod);
				}
		
				CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);
				if (corsConfig != null) {
					this.corsLookup.put(handlerMethod, corsConfig);
				}
		
				this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));
			}
			finally {
				this.readWriteLock.writeLock().unlock();
			}
		}
		......
	}	
}

说下参数：
mapping：是方法上的路径信息（@RequestMpping注解中的信息），包括请求方式GET/POST等；
handler：就是Controller对象；
method：Controller中的方法；
注册的过程就是MappingRegistry存请求路径处理方法等相关的映射关系，而这些东西最终会在DispatcherServlet处理前端请求时使用到，也就是上篇文章中，我们分析的内容。

本文先分析到这里，其他初始化内容也是和HandlerMapping一样的，具体代码就不再展示了，直接在配置类中搜索相关内容即可。

springmvchandlerAdapter和handlerMapping类在什么时候被初始化
小小少年的博客
04-15 417
springmvc
《学会 SpringMVC 系列 · 剖析初始化》
最新发布
山人行
08-04 920
前几篇博文，大致了解了SpringMVC请求流程中的源码分析和扩展运用，为知识连贯性，本篇介绍一下 SpringMVC 初始化过程中的相关源码解读。和请求流程相比，初始化流程更为简单，主要就是初始化得到一些准备数据，为后续请求过程服务。相关博文《学会 SpringMVC 系列 · 基础篇》《学会 SpringMVC 系列 · 剖析篇（上）》《学会 SpringMVC 系列 · 剖析入参处理》《学会 SpringMVC 系列 · 剖析出参处理》《学会 SpringMVC 系列 · 返回值处理器》
SpringMvc HandlerMappings 何时初始化？
weixin_34114823的博客
10-04 414
SpringMvc 的转发控制器 DispatcherServlet 执行 initStrategies（），在什么时候初始化 HandlerMappings ？ 在容器 AbstractApplicationContext 初始化的最后一步：    
Spring-mvc源码分析之handlerMappings初始化
chileimo1780的博客
08-01 315
在分析spring源码的时候，我们知道handlerMapping是springMvc的一个组件，他的作用就是通过HandlerMapping找到具体Controller的具体类。那么初始化的时候在DispatcherServlet中handlerMappings是怎么初始化的呢？ 1、我们...
【Spring MVC】HandlerMapping初始化详解（超详细过程源码分析）
weixin_39736194的博客
05-13 613
原文链接：https://blog.youkuaiyun.com/qq_38410730/article/details/79507465 Spring MVC的Control主要由HandlerMapping和HandlerAdapter两个组件提供。HandlerMapping负责映射用户的URL和对应的处理类，HandlerMapping并没有规定这个URL与应用的处理类如何映射，在HandlerMapping接口中只定义了根据一个URL必须返回一个由HandlerExecutionChain代表的处理链，我们
SpringMVC源码解读之 HandlerMapping - AbstractDetectingUrlHandlerMapping系列初始化
09-02
在初始化阶段，AbstractDetectingUrlHandlerMapping会调用`detectHandlers`方法，这个方法负责遍历当前ApplicationContext中的所有bean，并尝试为每个bean确定对应的URL。 在`detectHandlers`方法中，首先通过`...
SpringMVC源码解析一：HandlerMapping初始化
qq_28825857的博客
08-06 395
initHandlerMappings（）方法初始化有两种方式： 1.setApplicationContext（） 2.afterPropertiesSet（） 1.setApplicationContext（）实现方式如下： 首先进入DispatcherServlet 类中，可以看到DispatcherServlet 的继承关系： DispatcherServlet ex...
SpringMVC处理器映射器HandlerMapping详解
cj_eryue的博客
06-28 1404
昨天在进行spring的安全升级时，遇到一个奇葩问题：原始版本为4.1.9，升级至5.3.34，由于是几年前的项目，请求路径还是带有.action的老式写法（如login.action），而有的不带（如：index），升级完后，就发现了问题，login.action能访问到，请求index时，日志爆了 no mapping for GET。我们来看看是怎么回事。
SpringMVC核心组件之(HandlerMapping)
liuqi199707的博客
12-27 281
HandlerMapping url映射，也就是访问的url，对应的处理器。 在DispatcherServlet类中的initHandlerMappings()初始化HandlerMapping。 SpringMVC默认有两个HandlerMapping BeanNameUrlHandlerMapping：只要beanName或别名是以/开头就会添加到该映射处理器中。 RequestMappingHandlerMapping：@RequestMapping映射处理，最为常用的。 先看看代码块，如果需要
spring 动态修改servlet参数_Spring开发中经常遇到的HandlerMapping与HandlerAdapter
weixin_40005437的博客
12-18 213
一本书让你熟练使用Spring和SpringMVCHandlerMapping：Spring MVC使用HandlerMapping来找到并保存url请求和处理函数间的mapping关系。以DefaultAnnotationHandlerMapping为例来具体看HandlerMapping的作用：DefaultAnnotationHandlerMapping将扫描当前所有已经注册的Spring ...
Spring MVC与Web环境(三)：HandlerMapping的配置以及处理请求
SmilingCobra
11-09 687
在上一篇的博客中，我提到了关于HandlerMapping的作用。在原书中作者是这样定义它的。每一个HandlerMapping可以持有一系列从URL请求到Controller的映射。在每一个HandlerMapping中都定义了一个map来持有这一系列的映射关系。在这个方法的定义中，通过解析request请求获取其中请求的URL路径，然后找到对应的handler对象，将这个对象封装到Handle...
Spring MVC PathPatternMatchableHandlerMapping原理解析
qq_32868023的博客
03-06 1273
在Spring MVC框架中，路由机制是实现HTTP请求到具体处理器方法映射的核心。是Spring 5之后引入的一个新特性，它基于来提供更为灵活和强大的URL路径匹配能力。与传统的相比，提供了更丰富的路径模式匹配特性，如参数化路径、正则表达式匹配等。
Are you running in a Servlet container that supports JSR-356?
兔老大的胡萝卜
04-21 5037
java.lang.IllegalArgumentException: No 'javax.websocket.server.ServerContainer' ServletContext attribute. Are you running in a Servlet container that supports JSR-356? 将websocket的demo拉入自己的项目报错，其实显示的是...
Are you running in a Servlet container that supports JSR-356
张火火博客
04-20 1041
【代码】 Are you running in a Servlet container that supports JSR-356。
websocket链接报错：No ‘javax.websocket.server.ServerContainer‘ ServletContext attribute
m0_63209237的博客
09-27 2331
websocket链接报错：No 'javax.websocket.server.ServerContainer' ServletContext attribute。
springboot集成websocket报错Are you running in a Servlet container that supports JSR-356?
菜鸡笔录
09-16 2455
Are you running in a Servlet container that supports JSR-356?@TOC springboot集成websocket springboot项目添加spring-boot-starter-websocket依赖后，一直报错Are you running in a Servlet container that supports JSR-356? 猜测是tomcat的问题！ 移除tomcat 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标
SpringMVC源码分析（二）-URL映射的注册
eejron的专栏
12-04 1283
​ 首先我们来看下AbstractHandlerMethodMapping这个类，它实现了InitializingBean接口，里面有个afterPropertiesSet()方法。这个接口是spring-beans这个组件的内容，想一想，平时使用搭建SpringMVC的时候，是不是把这个jar包也扔到项目里头了？对于spring-beans这个组件在这里就 不拓展了，我们只要知道实现了Init
【小家Spring】Spring MVC容器的web九大组件之---HandlerMapping源码详解(一)---BeanNameUrlHandlerMapping系列
架构师：通透，才能写出好代码！
05-04 2800
前言 在这篇文章里： 【小家Spring】Spring MVC容器启动时，web九大组件初始化详解（Spring MVC的运行机制） 已经大概介绍过web九大组，本文文章聚焦于Spring MVC中最重要的一个组件：HandlerMapping HandlerMapping 用来查找Handler的。在SpringMVC中会有很多请求，每个请求都需要一个Handler处理，具体接收到一个请求之后使...
Spring与SpringMVC父子容器关系及初始化解析
"本文将深入探讨Spring和SpringMVC之间的父子容器关系以及它们各自的初始化流程。" 在Java Web开发中，Spring框架是一个广泛使用的全面解决方案，涵盖了依赖注入、AOP（面向切面编程）、数据访问等多种功能。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值