SpringMVC之HanderAdapter

最新推荐文章于 2023-09-19 16:27:16 发布
最新推荐文章于 2023-09-19 16:27:16 发布
阅读量1.4k 收藏 6
点赞数
分类专栏： SpringMVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/pzjtian/article/details/96039595
版权

在上一篇HandlerMapping中，HandlerMapping在初始化时就将@RequestMapping对应的url与Controller建立了对应关系，前端的Http请求通过对应关系找到Controller，这就是HandlerMapping的使命，接下来就是HandlerAdapter来进行处理了。在HandlerMapping中有讲到DispatcherServlet的初始化中会调用initStrategies()方法，这里面也包含了HanderAdapter的初始化

initHandlerAdapters(context);

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<HandlerAdapter>(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.
			}
		}

		// Ensure we have at least some HandlerAdapters, by registering
		// default HandlerAdapters if no other adapters are found.
		if (this.handlerAdapters == null) {
			this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
			if (logger.isDebugEnabled()) {
				logger.debug("No HandlerAdapters found in servlet '" + getServletName() + "': using default");
			}
		}
	}

同HandlerMapping初始化一样，默认的HanderAdapter实现也是配置在DispatcherServlet.properties文件中

org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
	org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
	org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter

配置可以看出，HandlerAdapter默认有三种类型的实现，分别是：HttpRequestHandlerAdapter、SimpleControllerHandlerAdapter、AnnotationMethodHandlerAdapter

现在回到DispatcherServlet中来，看到请求处理的方法doDispatch()方法中有这么一段：

mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

这段就是通过HandlerMapping返回的Handler，来找到对应的Controller执行相应的逻辑，下面我们来具体看一下内部实现

//重点看一下AnnotationMethodHandlerAdapter的handler方法
public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
        //获取class对象
		Class<?> clazz = ClassUtils.getUserClass(handler);
		//检查class对象是否含有SessionAttributes注解
		Boolean annotatedWithSessionAttributes = this.sessionAnnotatedClassesCache.get(clazz);
		if (annotatedWithSessionAttributes == null) {
			annotatedWithSessionAttributes = (AnnotationUtils.findAnnotation(clazz, SessionAttributes.class) != null);
			this.sessionAnnotatedClassesCache.put(clazz, annotatedWithSessionAttributes);
		}

		if (annotatedWithSessionAttributes) {
			checkAndPrepare(request, response, this.cacheSecondsForSessionAttributeHandlers, true);
		}
		else {
			checkAndPrepare(request, response, true);
		}

		// Execute invokeHandlerMethod in synchronized block if required.
		if (this.synchronizeOnSession) {
			HttpSession session = request.getSession(false);
			if (session != null) {
				Object mutex = WebUtils.getSessionMutex(session);
				synchronized (mutex) {
					return invokeHandlerMethod(request, response, handler);
				}
			}
		}
		//重点是invoke方法来做的调用
		return invokeHandlerMethod(request, response, handler);
	}
	protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
        //我们知道handler就是从上一步HandlerMapping拿到的Controller，这里通过handler拿到HandlerMethodResolver
        //那HandlerMethodResolver到底是个什么鬼？它里面主要是存储Controller中方法上@RequestMapping的url以及所有的方法
		ServletHandlerMethodResolver methodResolver = getMethodResolver(handler);
		//通过methodResolver与当前的request进行匹配，通过请求的url找到需要调用的方法
		Method handlerMethod = methodResolver.resolveHandlerMethod(request);
		ServletHandlerMethodInvoker methodInvoker = new ServletHandlerMethodInvoker(methodResolver);
		ServletWebRequest webRequest = new ServletWebRequest(request, response);
		ExtendedModelMap implicitModel = new BindingAwareModelMap();

        //重点看该方法调用，看下面具体源码
		Object result = methodInvoker.invokeHandlerMethod(handlerMethod, handler, webRequest, implicitModel);
		ModelAndView mav =
				methodInvoker.getModelAndView(handlerMethod, handler.getClass(), result, implicitModel, webRequest);
		methodInvoker.updateModelAttributes(handler, (mav != null ? mav.getModel() : null), implicitModel, webRequest);
		return mav;
	}
	
	public final Object invokeHandlerMethod(Method handlerMethod, Object handler,
			NativeWebRequest webRequest, ExtendedModelMap implicitModel) throws Exception {

		Method handlerMethodToInvoke = BridgeMethodResolver.findBridgedMethod(handlerMethod);
		try {
			boolean debug = logger.isDebugEnabled();
			for (String attrName : this.methodResolver.getActualSessionAttributeNames()) {
				Object attrValue = this.sessionAttributeStore.retrieveAttribute(webRequest, attrName);
				if (attrValue != null) {
					implicitModel.addAttribute(attrName, attrValue);
				}
			}
			for (Method attributeMethod : this.methodResolver.getModelAttributeMethods()) {
				Method attributeMethodToInvoke = BridgeMethodResolver.findBridgedMethod(attributeMethod);
				Object[] args = resolveHandlerArguments(attributeMethodToInvoke, handler, webRequest, implicitModel);
				if (debug) {
					logger.debug("Invoking model attribute method: " + attributeMethodToInvoke);
				}
				String attrName = AnnotationUtils.findAnnotation(attributeMethod, ModelAttribute.class).value();
				if (!"".equals(attrName) && implicitModel.containsAttribute(attrName)) {
					continue;
				}
				ReflectionUtils.makeAccessible(attributeMethodToInvoke);
				Object attrValue = attributeMethodToInvoke.invoke(handler, args);
				if ("".equals(attrName)) {
					Class<?> resolvedType = GenericTypeResolver.resolveReturnType(attributeMethodToInvoke, handler.getClass());
					attrName = Conventions.getVariableNameForReturnType(attributeMethodToInvoke, resolvedType, attrValue);
				}
				if (!implicitModel.containsAttribute(attrName)) {
					implicitModel.addAttribute(attrName, attrValue);
				}
			}
			//这里即将调用方法的参数，对参数进行处理
			Object[] args = resolveHandlerArguments(handlerMethodToInvoke, handler, webRequest, implicitModel);
			if (debug) {
				logger.debug("Invoking request handler method: " + handlerMethodToInvoke);
			}
			ReflectionUtils.makeAccessible(handlerMethodToInvoke);
			//将参数传入，利用反射来进行方法调用
			return handlerMethodToInvoke.invoke(handler, args);
		}
		catch (IllegalStateException ex) {
			// Internal assertion failed (e.g. invalid signature):
			// throw exception with full handler method context...
			throw new HandlerMethodInvocationException(handlerMethodToInvoke, ex);
		}
		catch (InvocationTargetException ex) {
			// User-defined @ModelAttribute/@InitBinder/@RequestMapping method threw an exception...
			ReflectionUtils.rethrowException(ex.getTargetException());
			return null;
		}
	}

好，进行到这里已经调用完了方法，再回到上一步看看返回值的情况

protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
        //我们知道handler就是从上一步HandlerMapping拿到的Controller，这里通过handler拿到HandlerMethodResolver
        //那HandlerMethodResolver到底是个什么鬼？它里面主要是存储Controller中方法上@RequestMapping的url以及所有的方法
		ServletHandlerMethodResolver methodResolver = getMethodResolver(handler);
		//通过methodResolver与当前的request进行匹配，通过请求的url找到需要调用的方法
		Method handlerMethod = methodResolver.resolveHandlerMethod(request);
		ServletHandlerMethodInvoker methodInvoker = new ServletHandlerMethodInvoker(methodResolver);
		ServletWebRequest webRequest = new ServletWebRequest(request, response);
		ExtendedModelMap implicitModel = new BindingAwareModelMap();

        //进行方法调用返回Object
		Object result = methodInvoker.invokeHandlerMethod(handlerMethod, handler, webRequest, implicitModel);
		//将返回的Object对象进行封装，返回ModelAndView给DispatcherServlet
		ModelAndView mav =
				methodInvoker.getModelAndView(handlerMethod, handler.getClass(), result, implicitModel, webRequest);
		//BindingResult、SessionAttribute等后续处理
		methodInvoker.updateModelAttributes(handler, (mav != null ? mav.getModel() : null), implicitModel, webRequest);
		//处理完成，返回ModelAndView给Dispathcher
		return mav;
	}

下面来看一下ModelAndView是个啥？

//根据handler处理的结果，封装一个ModelAndView给前端
public ModelAndView getModelAndView(Method handlerMethod, Class<?> handlerType, Object returnValue,
				ExtendedModelMap implicitModel, ServletWebRequest webRequest) throws Exception {

			ResponseStatus responseStatus = AnnotatedElementUtils.findMergedAnnotation(handlerMethod, ResponseStatus.class);
			if (responseStatus != null) {
				HttpStatus statusCode = responseStatus.code();
				String reason = responseStatus.reason();
				if (!StringUtils.hasText(reason)) {
					webRequest.getResponse().setStatus(statusCode.value());
				}
				else {
					webRequest.getResponse().sendError(statusCode.value(), reason);
				}

				// to be picked up by the RedirectView
				webRequest.getRequest().setAttribute(View.RESPONSE_STATUS_ATTRIBUTE, statusCode);

				this.responseArgumentUsed = true;
			}

			// Invoke custom resolvers if present...
			if (customModelAndViewResolvers != null) {
				for (ModelAndViewResolver mavResolver : customModelAndViewResolvers) {
					ModelAndView mav = mavResolver.resolveModelAndView(
							handlerMethod, handlerType, returnValue, implicitModel, webRequest);
					if (mav != ModelAndViewResolver.UNRESOLVED) {
						return mav;
					}
				}
			}
            //以下是判断返回值的各种类型，给出不同的处理
			if (returnValue instanceof HttpEntity) {
				handleHttpEntityResponse((HttpEntity<?>) returnValue, webRequest);
				return null;
			}
			//@ResponseBody注解的处理
			else if (AnnotationUtils.findAnnotation(handlerMethod, ResponseBody.class) != null) {
				handleResponseBody(returnValue, webRequest);
				return null;
			}
			//看这里，就是我们很熟悉的ModelAndView的处理
			else if (returnValue instanceof ModelAndView) {
				ModelAndView mav = (ModelAndView) returnValue;
				mav.getModelMap().mergeAttributes(implicitModel);
				return mav;
			}
			//返回Model
			else if (returnValue instanceof Model) {
				return new ModelAndView().addAllObjects(implicitModel).addAllObjects(((Model) returnValue).asMap());
			}
			//返回View
			else if (returnValue instanceof View) {
				return new ModelAndView((View) returnValue).addAllObjects(implicitModel);
			}
			//@ModelAttribute注解的处理
			else if (AnnotationUtils.findAnnotation(handlerMethod, ModelAttribute.class) != null) {
				addReturnValueAsModelAttribute(handlerMethod, handlerType, returnValue, implicitModel);
				return new ModelAndView().addAllObjects(implicitModel);
			}
			//返回Map
			else if (returnValue instanceof Map) {
				return new ModelAndView().addAllObjects(implicitModel).addAllObjects((Map<String, ?>) returnValue);
			}
			//返回String
			else if (returnValue instanceof String) {
				return new ModelAndView((String) returnValue).addAllObjects(implicitModel);
			}
			//返回null的处理
			else if (returnValue == null) {
				// Either returned null or was 'void' return.
				if (this.responseArgumentUsed || webRequest.isNotModified()) {
					return null;
				}
				else {
					// Assuming view name translation...
					return new ModelAndView().addAllObjects(implicitModel);
				}
			}
			else if (!BeanUtils.isSimpleProperty(returnValue.getClass())) {
				// Assume a single model attribute...
				addReturnValueAsModelAttribute(handlerMethod, handlerType, returnValue, implicitModel);
				return new ModelAndView().addAllObjects(implicitModel);
			}
			else {
				throw new IllegalArgumentException("Invalid handler method return value: " + returnValue);
			}
		}

总结一下：

  1. HanderAdapter从上一步HandlerMapping拿到Controller
  2. 通过Controller，经过反射拿到Controller中@requestMapping上url与方法的对应关系,返回ServletHandlerMethodResolver
  3. 通过request请中的url与ServletHandlerMethodResolver中的mappings匹配，可以找到需要调用的方法
  4. 利用反射调用找到的方法，返回Object
  5. 处理返回结果，根据不同的返回值类型（ModelAndView、String、Map、View等）进行处理后，封装成ModelAndView返回给前台
SpringBoot开发之SpringMVC
10-15
SpringMVC作为Spring框架的一部分，是构建Web应用程序的重要组件。在这个专题中，我们将深入探讨SpringBoot如何与SpringMVC结合，以实现高效、简洁的Web开发。 一、SpringBoot简介 SpringBoot是由Pivotal团队提供的...
浅谈HandlerAdapter
qq_53322735的博客
04-10 4421
HandlerAdapter顾名思义就是一个适配器，（肯定也采用了适配器模式这里不做过多的解释），那么它的主要作用是什么呢？HandlerMapping存储了所有都请求映射，请求过来找到相应的请求映射后，返回给我们一个Handler 看这里的代码： @Nullable protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception { if (this....
HandlerAdapter接口类的简介说明
qq_25073223的博客
11-11 634
HandlerAdapter接口类的简介说明
SpringMVC之简单理解 HandlerAdapter的作用
weixin_38399962的博客
12-27 1万+
写在最前面         HandlerAdapter字面上的意思就是处理适配器，它的作用用一句话概括就是调用具体的方法对用户发来的请求来进行处理。当handlerMapping获取到执行请求的controller时，DispatcherServlte会根据controller对应的controller类型来调用相应的HandlerAdapter来进行处理。        1.Handle...
SpringMVC源码分析-HandlerAdapter(3)-RequestMappingHandlerAdapter请求处理
BraveWangDev
07-08 655
RequestMappingHanderAdapter的请求处理 RequestMappingHanderAdapter处理请求的入口方法是handleInternal: @Override protected ModelAndView handleInternal(HttpServletRequest request, HttpServletResponse response...
HandlerAdapter
杜甫之心
01-16 2589
1、HandlerAdapter是一个接口，是具体使用Handler来干活的； 2、方法： <1>supports：传入一个Object类型的handler判断是否支持处理该handler； <2>handle：具体使用handler处理请求的过程，返回类型为ModelAndView； <3>getLastModified：获取资源上一次更改的时间； ...
Java进阶之SpringMVC应用附录共11页.pdf
11-20
这个“Java进阶之SpringMVC应用附录共11页.pdf”文档很可能是对SpringMVC深入使用的详细教程，涵盖了一些高级主题和实践技巧。 1. **SpringMVC核心组件**：SpringMVC的核心组件包括DispatcherServlet、Controller、...
Java进阶之SpringMVCSSM整合共8页.pdf
11-20
在Java开发领域，SpringMVC和SSM（Spring、SpringMVC、MyBatis）是两个非常重要的框架，常用于构建高效的企业级Web应用程序。本文将深入探讨SpringMVC和SSM整合的相关知识点，帮助开发者提升技能水平。 首先，...
Java进阶之SpringMVC应用共16页.pdf.zi
11-20
在Java进阶之SpringMVC的应用中，我们通常会探讨以下几个核心知识点： 1. **依赖注入（Dependency Injection, DI）**：SpringMVC的基础是Spring框架的核心特性——依赖注入，它允许对象之间的关系在运行时动态配置...
Java进阶之SpringMVC源码深度剖析共12页.pd
11-20
本资料“Java进阶之SpringMVC源码深度剖析共12页.pdf”是对SpringMVC核心原理的深入探讨，通过分析源码来帮助开发者更深入地理解其工作原理。 1. **SpringMVC概述** SpringMVC是Spring框架的一个模块，主要负责...
SpringMVC组件之一： HandlerAdapter 深入学习
ZULJ131的博客
09-11 1099
HandlerAdapter了解
SpringMVC(二) -- HandlerAdapter
最新发布
weixin_44175409的博客
09-19 181
Adapter作为SpringMVC最重要的组件之一，跟Interceptor同等地位，它可以帮助我们在调用接口的前后做一个自定义的拓展。return;通过源码分析我们可以知道，提供了三个方法主要。
SpringMVC工作原理之：HandlerAdapter
liangkun_java的博客
07-31 2467
根据 Handler 来找到支持它的 HandlerAdapter，通过 HandlerAdapter 执行这个 Handler 得到 ModelAndView 对象。HandlerAdapter 接口中的方法如下： supports(Object handler); // 当前 HandlerAdapter 是否支持这个 Handler handle(HttpServletRequest...
springMVC 中的HandlerAdapter和HandlerMapping
jack的博客
07-23 1193
springMVC在初始化自己的上下文之后就会进行initStrategies方法进行初始化组件 HttpServletBean是实现了获取web.xml中的配置元素的值；FrameworkServlet实现了SpringMVC上下文并根据不同的DispatcherServlet放在以servlet-name为key值severtContext中；DispatcherServlet主要实现了初始...
看springmvc适配器模式---HandlerAdapter
青水温酒
05-24 2万+
适配器模式 就是你有一个类接口，但是这个接口不太符合你的预期，如果要用他就需要在他的源码上进行一些修改，这时你可以作一个适配器，在不修改原来这个接口源码的情况下，在适配器上对这个接口进行运用，使得适配器符合你的规范。 适配器模式（Adapter Pattern），把一个类的接口变换成客户端所期待的另一种接口， Adapter模式使原本因接口不匹配（或者不兼容）而无法在一起工作的两个类能够在一起...
第四章 SpringMVC之HandlerAdapter解析
热门推荐
屌丝程序员的奋斗之路
01-20 3万+
HandlerAdapter字面上的意思就是处理适配器，它的作用用一句话概括就是调用具体的方法对用户发来的请求来进行处理。当handlerMapping获取到执行请求的controller时，DispatcherServlte会根据controller对应的controller类型来调用相应的HandlerAdapter来进行处理。         在贴源码之前先说一下HandlerAdapte
SpringMVC源码分析----HandlerAdapter
Visonws的博客
08-22 3080
HandlerAdapter的结构图：        如上所示：总共五个实现类，有一个还被摒弃了，除了RequestMappingHandlerAdapter适配器，其他都很简单，只需要调用各自的方法就可以了。HttpReqeustHandlerAdapter、SimpleServletHandlerAdapter和SimpleControllerHandlerAdapter分别适配Http...
11.SpringMVC 请求处理 - HandlerAdapter
一把空心菜
08-24 7156
基本概念SpringMVC 通过 HandlerAdapter 的 handler 方法来调用请求处理函数。在 DispatcherServlet 中根据请求路径利用 Handlermapping 找到对应的 handler 后，首先检查当前 Ioc 容器中所有可用的 HandlerAdapter ，再利用 HandlerAdapter 中的 supports 方法找到可以使用的HandlerAda
Java进阶与SpringMVC高级技术要点解析
从提供的文件信息来看，存在标题、描述和标签信息的不一致，但我们可以推断出文件的主内容是关于“SpringMVC”的“Java进阶”知识。以下是对知识点的详细说明。 ### 知识点一：SpringMVC概述 SpringMVC是Spring...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值