Spring MVC 九大组件

于 2023-07-24 14:30:43 发布
阅读量145 收藏
点赞数
分类专栏： 源码 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45336090/article/details/131394575
版权
onRefresh方法在DispatcherServlet中用于刷新和初始化SpringMVC中的关键组件，如文件上传解析器、区域信息解析器、主题解析器、Handler映射、Handler适配器等。当在ApplicationContext中找不到相应的bean时，会使用默认的策略对象。这些组件是SpringMVC处理Web请求的核心部分。
摘要由CSDN通过智能技术生成

onRefresh()是FrameworkServlet父类中提供的方法，在子类DispatcherServlet中进行了重写
主要用于刷新Spring在Web功能实现中所必须使用的全局变量

1.onRefresh()

	@Override
	protected void onRefresh(ApplicationContext context) {
		initStrategies(context);
	}
	//初始化九大组件
	protected void initStrategies(ApplicationContext context) {
		initMultipartResolver(context);
		initLocaleResolver(context);
		initThemeResolver(context);
		initHandlerMappings(context);
		initHandlerAdapters(context);
		initHandlerExceptionResolvers(context);
		initRequestToViewNameTranslator(context);
		initViewResolvers(context);
		initFlashMapManager(context);
	}

2.Spring MVC 九大组件

	/** 文件上传解析器 */
	@Nullable
	private MultipartResolver multipartResolver;

	/** 区域信息解析器 */
	@Nullable
	private LocaleResolver localeResolver;

	/** 主题解析器 */
	@Nullable
	private ThemeResolver themeResolver;

	/** Handler映射 */
	@Nullable
	private List<HandlerMapping> handlerMappings;

	/** Handler适配器 */
	@Nullable
	private List<HandlerAdapter> handlerAdapters;

	/** Handler异常解析器 */
	@Nullable
	private List<HandlerExceptionResolver> handlerExceptionResolvers;

	/** 请求转为视图名 */
	@Nullable
	private RequestToViewNameTranslator viewNameTranslator;

	/** 重定向携带数据 */
	@Nullable
	private FlashMapManager flashMapManager;

	/** 视图解析器 */
	@Nullable
	private List<ViewResolver> viewResolvers;

3.initMultipartResolver()

	private void initMultipartResolver(ApplicationContext context) {
		try {
			this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class);
			if (logger.isTraceEnabled()) {
				logger.trace("Detected " + this.multipartResolver);
			}
			else if (logger.isDebugEnabled()) {
				logger.debug("Detected " + this.multipartResolver.getClass().getSimpleName());
			}
		}
		catch (NoSuchBeanDefinitionException ex) {
			//默认不需要文件上传解析器
			this.multipartResolver = null;
			if (logger.isTraceEnabled()) {
				logger.trace("No MultipartResolver '" + MULTIPART_RESOLVER_BEAN_NAME + "' declared");
			}
		}
	}

4.initLocaleResolver()

	private void initLocaleResolver(ApplicationContext context) {
		try {
			this.localeResolver = context.getBean(LOCALE_RESOLVER_BEAN_NAME, LocaleResolver.class);
			if (logger.isTraceEnabled()) {
				logger.trace("Detected " + this.localeResolver);
			}
			else if (logger.isDebugEnabled()) {
				logger.debug("Detected " + this.localeResolver.getClass().getSimpleName());
			}
		}
		catch (NoSuchBeanDefinitionException ex) {
			//使用默认的策略对象
			this.localeResolver = getDefaultStrategy(context, LocaleResolver.class);
			if (logger.isTraceEnabled()) {
				logger.trace("No LocaleResolver '" + LOCALE_RESOLVER_BEAN_NAME +
						"': using default [" + this.localeResolver.getClass().getSimpleName() + "]");
			}
		}
	}

5.initThemeResolver()

	private void initThemeResolver(ApplicationContext context) {
		try {
			this.themeResolver = context.getBean(THEME_RESOLVER_BEAN_NAME, ThemeResolver.class);
			if (logger.isTraceEnabled()) {
				logger.trace("Detected " + this.themeResolver);
			}
			else if (logger.isDebugEnabled()) {
				logger.debug("Detected " + this.themeResolver.getClass().getSimpleName());
			}
		}
		catch (NoSuchBeanDefinitionException ex) {
			//使用默认的策略对象
			this.themeResolver = getDefaultStrategy(context, ThemeResolver.class);
			if (logger.isTraceEnabled()) {
				logger.trace("No ThemeResolver '" + THEME_RESOLVER_BEAN_NAME +
						"': using default [" + this.themeResolver.getClass().getSimpleName() + "]");
			}
		}
	}

6.initHandlerMappings()

	private void initHandlerMappings(ApplicationContext context) {
		this.handlerMappings = null;

		if (this.detectAllHandlerMappings) {
			// Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
			Map<String, HandlerMapping> matchingBeans =
					BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
			if (!matchingBeans.isEmpty()) {
				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.
			}
		}

		//确保至少有一个Handler映射
		if (this.handlerMappings == null) {
			this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
			if (logger.isTraceEnabled()) {
				logger.trace("No HandlerMappings declared for servlet '" + getServletName() +
						"': using default strategies from DispatcherServlet.properties");
			}
		}

		for (HandlerMapping mapping : this.handlerMappings) {
			if (mapping.usesPathPatterns()) {
				this.parseRequestPath = true;
				break;
			}
		}
	}

7.initHandlerAdapters()

	private void initHandlerAdapters(ApplicationContext context) {
		this.handlerAdapters = null;

		if (this.detectAllHandlerAdapters) {
			// Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
			Map<String, HandlerAdapter> matchingBeans =
					BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
			if (!matchingBeans.isEmpty()) {
				this.handlerAdapters = new ArrayList<>(matchingBeans.values());
				// We keep HandlerAdapters in sorted order.
				AnnotationAwareOrderComparator.sort(this.handlerAdapters);
			}
		}
		else {
			try {
				HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class);
				this.handlerAdapters = Collections.singletonList(ha);
			}
			catch (NoSuchBeanDefinitionException ex) {
				// Ignore, we'll add a default HandlerAdapter later.
			}
		}

		//确保至少有一些Handler适配器
		if (this.handlerAdapters == null) {
			this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
			if (logger.isTraceEnabled()) {
				logger.trace("No HandlerAdapters declared for servlet '" + getServletName() +
						"': using default strategies from DispatcherServlet.properties");
			}
		}
	}

8.initHandlerExceptionResolvers()

	private void initHandlerExceptionResolvers(ApplicationContext context) {
		this.handlerExceptionResolvers = null;

		if (this.detectAllHandlerExceptionResolvers) {
			// Find all HandlerExceptionResolvers in the ApplicationContext, including ancestor contexts.
			Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils
					.beansOfTypeIncludingAncestors(context, HandlerExceptionResolver.class, true, false);
			if (!matchingBeans.isEmpty()) {
				this.handlerExceptionResolvers = new ArrayList<>(matchingBeans.values());
				// We keep HandlerExceptionResolvers in sorted order.
				AnnotationAwareOrderComparator.sort(this.handlerExceptionResolvers);
			}
		}
		else {
			try {
				HandlerExceptionResolver her =
						context.getBean(HANDLER_EXCEPTION_RESOLVER_BEAN_NAME, HandlerExceptionResolver.class);
				this.handlerExceptionResolvers = Collections.singletonList(her);
			}
			catch (NoSuchBeanDefinitionException ex) {
				// Ignore, no HandlerExceptionResolver is fine too.
			}
		}

		//确保至少有一些Handler异常解析器
		if (this.handlerExceptionResolvers == null) {
			this.handlerExceptionResolvers = getDefaultStrategies(context, HandlerExceptionResolver.class);
			if (logger.isTraceEnabled()) {
				logger.trace("No HandlerExceptionResolvers declared in servlet '" + getServletName() +
						"': using default strategies from DispatcherServlet.properties");
			}
		}
	}

9.initRequestToViewNameTranslator()

	private void initRequestToViewNameTranslator(ApplicationContext context) {
		try {
			this.viewNameTranslator =
					context.getBean(REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME, RequestToViewNameTranslator.class);
			if (logger.isTraceEnabled()) {
				logger.trace("Detected " + this.viewNameTranslator.getClass().getSimpleName());
			}
			else if (logger.isDebugEnabled()) {
				logger.debug("Detected " + this.viewNameTranslator);
			}
		}
		catch (NoSuchBeanDefinitionException ex) {
			//使用默认的策略对象
			this.viewNameTranslator = getDefaultStrategy(context, RequestToViewNameTranslator.class);
			if (logger.isTraceEnabled()) {
				logger.trace("No RequestToViewNameTranslator '" + REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME +
						"': using default [" + this.viewNameTranslator.getClass().getSimpleName() + "]");
			}
		}
	}

10.initViewResolvers()

	private void initViewResolvers(ApplicationContext context) {
		this.viewResolvers = null;

		if (this.detectAllViewResolvers) {
			// Find all ViewResolvers in the ApplicationContext, including ancestor contexts.
			Map<String, ViewResolver> matchingBeans =
					BeanFactoryUtils.beansOfTypeIncludingAncestors(context, ViewResolver.class, true, false);
			if (!matchingBeans.isEmpty()) {
				this.viewResolvers = new ArrayList<>(matchingBeans.values());
				// We keep ViewResolvers in sorted order.
				AnnotationAwareOrderComparator.sort(this.viewResolvers);
			}
		}
		else {
			try {
				ViewResolver vr = context.getBean(VIEW_RESOLVER_BEAN_NAME, ViewResolver.class);
				this.viewResolvers = Collections.singletonList(vr);
			}
			catch (NoSuchBeanDefinitionException ex) {
				// Ignore, we'll add a default ViewResolver later.
			}
		}

		//确保至少有一个视图解析器
		if (this.viewResolvers == null) {
			this.viewResolvers = getDefaultStrategies(context, ViewResolver.class);
			if (logger.isTraceEnabled()) {
				logger.trace("No ViewResolvers declared for servlet '" + getServletName() +
						"': using default strategies from DispatcherServlet.properties");
			}
		}
	}

11.initFlashMapManager()

	private void initFlashMapManager(ApplicationContext context) {
		try {
			this.flashMapManager = context.getBean(FLASH_MAP_MANAGER_BEAN_NAME, FlashMapManager.class);
			if (logger.isTraceEnabled()) {
				logger.trace("Detected " + this.flashMapManager.getClass().getSimpleName());
			}
			else if (logger.isDebugEnabled()) {
				logger.debug("Detected " + this.flashMapManager);
			}
		}
		catch (NoSuchBeanDefinitionException ex) {
			//使用默认的策略对象
			this.flashMapManager = getDefaultStrategy(context, FlashMapManager.class);
			if (logger.isTraceEnabled()) {
				logger.trace("No FlashMapManager '" + FLASH_MAP_MANAGER_BEAN_NAME +
						"': using default [" + this.flashMapManager.getClass().getSimpleName() + "]");
			}
		}
	}

12.getDefaultStrategies()

	protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
		if (defaultStrategies == null) {
			try {
				//从属性文件中加载默认策略
				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());
			}
		}

		String key = strategyInterface.getName();
		String value = defaultStrategies.getProperty(key);
		if (value != null) {
			String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
			List<T> strategies = new ArrayList<>(classNames.length);
			for (String className : classNames) {
				try {
					Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
					//创建默认的策略对象
					Object strategy = createDefaultStrategy(context, clazz);
					strategies.add((T) strategy);
				}
				catch (ClassNotFoundException ex) {
					throw new BeanInitializationException(
							"Could not find DispatcherServlet's default strategy class [" + className +
							"] for interface [" + key + "]", ex);
				}
				catch (LinkageError err) {
					throw new BeanInitializationException(
							"Unresolvable class definition for DispatcherServlet's default strategy class [" +
							className + "] for interface [" + key + "]", err);
				}
			}
			return strategies;
		}
		else {
			return Collections.emptyList();
		}
	}
这个需求做不了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring MVC 的九大组件
qq_40179479的博客
10-28 300
HandlerMapping HandlerMapping是用来查找Handler 的，也就是处理器，具体的表现形式可以是类，也可以是方法。比如，标注了@RequestMapping的每个方法都可以看成一个 Handler。Handler 负责实际的请求处理，在请求到达后，HandlerMapping的作用便是找到请求相应的处理器Handler和Interceptor. HandlerAdapter 从名字上看，HandlerAdapter 是一个适配器。因为Spring MVC中Handler 可以是任意
Spring MVC 五大核心组件和配置
Hi_KaiSa的博客
09-18 562
Spring MVC（一）五大核心组件和配置 一,五大核心组件 　　1.DispatcherServlet　　请求入口 　　2.HandlerMapping　　 请求派发,负责请求和控制器建立一一对应的关系 　　3.Controller　　　　　 处理器 　　4.ModelAndView　　　 封装模型信息和视图信息 　　5.ViewResolver　　　　视图处理器,定位页面 二,Spring MVC的编写步骤(访问WEB-INF下的.jsp) 　　1.建立项目,导入jar包(ioc...
【SpringMVC】9大组件概览
热门推荐
Dream it Possible
06-23 2万+
【SpringMVC】9大组件概览SpringMVC中的Servlet一共有三个层次，分别是HttpServletBean、FrameworkServlet和 DispatcherServlet。HttpServletBean直接继承自java的HttpServlet，其作用是将Servlet中配置的参数设置到相应的属性；FrameworkServlet初始化了WebApplicationConte
springmvc的九大组件
weixin_56311692的博客
07-13 227
springmvc的九大组件
SpringMvc内置的九大组件
weixin_47068446的博客
08-22 1216
1、注解 @Controller2、实现Controller接口3、实现HttpRequestHandler第二种和第三种实现Controller必须在配置文件中定义bean信息，定义的名称必须加上"/"
SpringMVC 9大组件
weixin_44134725的博客
01-20 494
DispatcherServlet中有几个引用类型的属性，我们成为SpringMVC 9大组件 //多部件解析器：文件上传 @Nullable private MultipartResolver multipartResolver; //区域信息解析器：和国际化有关 @Nullable private LocaleResolver localeResolver; //主题解析器：强大的主题效果更换 @Nullable private ThemeResolver themeResolve
Spring MVC核心组件之HandlerMapping详解
最新发布
05-21
### Spring MVC核心组件之HandlerMapping详解 #### 一、引言 在Java Web开发领域，Spring MVC框架因其灵活且强大的特性而备受青睐。它提供了一种简洁的方式来构建可维护、可扩展的应用程序。Spring MVC的核心组件之...
Spring MVC + Mybatis+Spring实现的个人博客系统
06-05
Spring是Java企业级应用的核心框架，它提供了依赖注入（DI）和面向切面编程（AOP）等特性，使得应用的组件解耦，便于测试和维护。在本项目中，Spring作为容器管理了所有bean的生命周期，包括Spring MVC的控制器、...
Spring mvc 教程
08-16
- **DispatcherServlet**：这是 Spring MVC 的前端控制器，负责接收 HTTP 请求并分发给合适的后端组件处理。 - **WebApplicationContext**：这是一个特殊的 Bean 容器，用于管理 Web 应用中的所有 Bean。 - **默认的...
Spring MVC 学习记录总结1
08-03
在这个学习记录总结中，我们将深入理解Spring MVC的核心概念、主要组件以及其工作流程。 1. Spring MVC 概述 Spring MVC 是Spring框架的一部分，它基于Spring IoC（Inversion of Control，控制反转）容器，简化了...
SpringMVC九大常用注解
11-03
SpringMVC九大常用注解 SpringMVC
SpringMVC的九大组件
LucyYe
12-24 163
multipartResolver 文件上传的解析器 localeResolver 国际化解析器 themeResolver 主题解析器 handlerMapping 根据请求对象找到Hander处理器对象 handlerAdapter 处理器的适配器 handlerExceptionResolver 异常解析器 viewNameT...
谈谈你对Spring MVC中的九大组件的理解？
Tom弹架构
09-28 488
说谈谈你对Spring MVC中的九大组件的理解。
13.Spring MVC的九大组件概述？核心架构的具体流程？（HandlerMapping、HandlerAdapter、ViewResolver...）
相互学习 共同进步
04-28 702
DispatcherServlet：作为前端控制器，整个流程控制的中心，控制其它组件执行，统一调度，降低组件之间的耦合性，提高每个组件的扩展性。 DispatcherServlet使用了特殊的bean来处理请求、渲染视图等，这些特定的bean是Spring MVC框架的一部分。如果想指定使用哪个特定Bean，可以在web应用上下文WebApplicationContext中简单地配置它们。当然这只是可选的，Spring MVC维护了一个默认的bean列表，如果没有进行特别的配置，框架将会使用默认的
Spring MVC九大组件简介说明
msbz7的博客
10-09 315
让固定的Servlet处理方法调用Handler来进行处理，这一步工作便是 HandlerAdapter要做的事。如，在处理用户订单提交时，为了避免重复提交，可以处理完post请求后redirect到一个get请求。从方法的定义就可以看出，Controller层返回的String类型的视图名viewName ,这个组件的主要作用，便是将String类型的视图名和Locale解析为View类型的视图。和所用的技术（其实也就是视图的类型，如JSP啊还是其他什么Blabla的)填入参数。
SpringMV 九大组件
焱童鞋
04-19 390
Spring MVC的九大组件是： 1、MultipartResolver（多文件上传组件） 2、LocaleResolver（初始本地语言环境组件） 3、ThemeResolver（模板处理器组件） 4、HandlerMappings（保存url映射关系组件） 5、HandlerAdapters（动态参数适配器组件） 6、HandlerExceptionResolvers（异常拦截器组件） 7、RequestToViewNameTranslator（视图预处理器组件） 8、ViewResolvers（视
SpringMVC原理流程代码解析以及SpringMVC的9大组件
xiao_chainiao的博客
08-02 175
SpringMVC的底层原理， DispathcherServlet会在内部从Spring容器中拿到HandlerMapping对象 { else{ try{ HanderMapping hm = context.getBean(HANDER_MAPPING_BEAN_NAME, HanderMapping.class); ...
Spring MVC 9大组件
Details Inside Spring
01-01 648
名称 简介 HandlerMapping 处理句柄映射 HandlerAdapter 处理句柄适配器 HandlerExceptionResolver 处理句柄异常解析器 ViewResolver 视图解析器 RequestToViewNameTranslator 请求到视图名称的翻译器 LocaleResolver Locale解析器，处理本地化/国际化语言相...
Spring MVC入门与核心组件解析
"Spring MVC 入门、核心组件和实例演示" Spring MVC 是一款基于 Java 的流行 Web 开发框架，用于构建 MVC（Model-View-Controller）架构的应用程序。它为开发者提供了灵活、高效的工具，使得开发人员能够更专注于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值