spring-web HandlerAdapter 源码分析

于 2023-05-09 17:30:41 发布
阅读量662 收藏 1
点赞数
分类专栏： spring-web Java 文章标签： spring servlet spring-web springMVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43735348/article/details/130584831
版权

说明

  1. 本文基于 jdk 8, spring-framework 5.2.x 编写。
  2. @author JellyfishMIX - github / blog.jellyfishmix.com
  3. LICENSE GPL-2.0

HandlerAdapter 接口

提供作为处理器适配器的能力。

  1. supports 方法判断是否支持该 handler。
public interface HandlerAdapter {
	/**
	 * 判断是否支持该 handler
	 */
	boolean supports(Object handler);

	/**
	 * handler 执行，返回 ModelAndView 结果
	 */
	@Nullable
	ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;

	/**
	 * 返回请求的最新更新时间，如果不支持该操作，则返回 -1 即可
	 */
	long getLastModified(HttpServletRequest request, Object handler);
}

类层次

img

HandlerAdapter 的定位/职责

HandlerAdapter 存在的原因是，springMVC 通过 HandlerMapping 为请求找到合适的 HandlerExecutionChain 处理器执行链，包含处理器(handler)和拦截器(interceptors)。其中处理器(handler)的实现有多种，例如实现 Controller 接口，实现 HttpRequestHandler 接口，或者使用 @RequestMapping 注解将方法作为一个处理器等。导致 springMVC 无法直接执行这个处理器，所以这里需要一个适配器(adapter)，由它去执行处理器(handler)。

HandlerAdapter 也有多种，哪种 adapter 支持处理这种类型的 handler，则由该 adapter 去执行，如下:

  • HttpRequestHandlerAdapter: 适配实现了 HttpRequestHandler 接口的处理器。
  • SimpleControllerHandlerAdapter: 适配实现了 Controller 接口的处理器。
  • SimpleServletHandlerAdapter: 适配实现了 Servlet 接口的处理器。
  • RequestMappingHandlerAdapter: 适配 HandlerMethod 类型的处理器，也就是通过 @RequestMapping 注解标注的方法。

重点关注 RequestMappingHandlerAdapter，这种方式是目前使用最普遍的。

HandlerAdapter 初始化过程

DispatcherServlet 重写 FrameworkServlet#onRefresh 方法，调用 DispatcherServlet#initHandlerAdapters 方法，初始化 HandlerAdapter。

org.springframework.web.servlet.DispatcherServlet#onRefresh

	/**
	 * This implementation calls {@link #initStrategies}.
	 */
	@Override
	protected void onRefresh(ApplicationContext context) {
		initStrategies(context);
	}

	/**
	 * Initialize the strategy objects that this servlet uses.
	 * <p>May be overridden in subclasses in order to initialize further strategy objects.
	 */
	protected void initStrategies(ApplicationContext context) {
		initMultipartResolver(context);
		initLocaleResolver(context);
		initThemeResolver(context);
		initHandlerMappings(context);
		initHandlerAdapters(context);
		initHandlerExceptionResolvers(context);
		initRequestToViewNameTranslator(context);
		initViewResolvers(context);
		initFlashMapManager(context);
	}

DispatcherServlet#initHandlerAdapters 方法

org.springframework.web.servlet.DispatcherServlet#initHandlerAdapters

  1. 如果探测功能开启，则扫描已注册的 HandlerAdapter 的 beans，添加到 handlerAdapters 集合中，默认开启。这里会进行排序，可以通过实现 Order 接口设置排序值。

  2. 如果探测功能关闭，则获得 beanName 为 “handlerAdapter” 对应的 bean，添加至 handlerAdapters。

  3. 未获取到 handlerAdapter 则获取默认的，如下: HttpRequestHandlerAdapter, SimpleControllerHandlerAdapter, RequestMappingHandlerAdapter

    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

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

		// 如果探测功能开启，则扫描已注册的 HandlerAdapter 的 beans，添加到 handlerAdapters 集合中，默认开启。这里会进行排序，可以通过实现 Order 接口设置排序值。
		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);
			}
		}
		// 如果探测功能关闭，则获得 beanName 为 "handlerAdapter" 对应的 bean，添加至 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.
		// 未获取到 handlerAdapter 则获取默认的
		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");
			}
		}
	}

AbstractHandlerMethodAdapter#handle 方法 – 处理请求

org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter#handle

处理请求，封装了一层内部调用，具体逻辑 handleInternal 交由子类实现。由 DispatcherServlet#doDispatch 调用。

	@Override
	@Nullable
	public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
		return handleInternal(request, response, (HandlerMethod) handler);
	}

三个默认的 HandlerAdapter

org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter

对于 HttpRequestHandlerAdapter, SimpleControllerHandlerAdapter，阅读 HandlerAdapter 接口的定义后，没有太多需要说明的。我们重点关注 RequestMappingHandlerAdapter。

public class HttpRequestHandlerAdapter implements HandlerAdapter {
	@Override
	public boolean supports(Object handler) {
		return (handler instanceof HttpRequestHandler);
	}

	@Override
	@Nullable
	public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		((HttpRequestHandler) handler).handleRequest(request, response);
		return null;
	}

	@Override
	public long getLastModified(HttpServletRequest request, Object handler) {
		if (handler instanceof LastModified) {
			return ((LastModified) handler).getLastModified(request);
		}
		return -1L;
	}
}

public class SimpleControllerHandlerAdapter implements HandlerAdapter {

	@Override
	public boolean supports(Object handler) {
		return (handler instanceof Controller);
	}

	@Override
	@Nullable
	public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		return ((Controller) handler).handleRequest(request, response);
	}

	@Override
	public long getLastModified(HttpServletRequest request, Object handler) {
		if (handler instanceof LastModified) {
			return ((LastModified) handler).getLastModified(request);
		}
		return -1L;
	}

}

RequestMappingHandlerAdapter

RequestMappingHandlerAdapter#afterPropertiesSet 方法 – 初始化 adapter

org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#afterPropertiesSet

RequestMappingHandlerAdapter 实现了 InitializingBean 接口，在 spring-ioc 初始化 RequestMappingHandlerAdapter 的 bean 实例时候，会调用此方法，完成一些初始化工作。

public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter implements BeanFactoryAware, InitializingBean {
	@Override
	public void afterPropertiesSet() {
		// Do this first, it may add ResponseBody advice beans
		// 初始化 ControllerAdvice 相关
		initControllerAdviceCache();

		// 初始化 argumentResolvers 属性
		if (this.argumentResolvers == null) {
			List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
			this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
		}
		// 初始化 initBinderArgumentResolvers 属性
		if (this.initBinderArgumentResolvers == null) {
			List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers();
			this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
		}
		// 初始化 returnValueHandlers 属性
		if (this.returnValueHandlers == null) {
			List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
			this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
		}
	}
}
@ControllerAdvice 注解

用于 Controller 类的增强，@ControllerAdvice 加载增强类上，此类中可使用方法级别的注解增强方法，例如 @ExceptionHandler 注解加载方法上，用于处理 Controller 抛出的异常。demo:

@Order(Integer.MAX_VALUE)
@ControllerAdvice
public class DefaultExceptionHandler {
    protected Logger log = LoggerFactory.getLogger(DefaultExceptionHandler.class);

    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public ResponseEntity defaultErrorHandler(Exception e) {
        // ...
        return xxx;
    }
}

RequestMappingHandlerAdapter#getDefaultArgumentResolvers 方法 – 获取默认的参数解析器

org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#getDefaultArgumentResolvers

获取默认的参数解析器，按顺序添加了多个参数解析器对象。

	private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {
		List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>(30);

		// Annotation-based argument resolution
		resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
		resolvers.add(new RequestParamMapMethodArgumentResolver());
		resolvers.add(new PathVariableMethodArgumentResolver());
		resolvers.add(new PathVariableMapMethodArgumentResolver());
		resolvers.add(new MatrixVariableMethodArgumentResolver());
		resolvers.add(new MatrixVariableMapMethodArgumentResolver());
		resolvers.add(new ServletModelAttributeMethodProcessor(false));
		resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
		resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters(), this.requestResponseBodyAdvice));
		resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory()));
		resolvers.add(new RequestHeaderMapMethodArgumentResolver());
		resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory()));
		resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));
		resolvers.add(new SessionAttributeMethodArgumentResolver());
		resolvers.add(new RequestAttributeMethodArgumentResolver());

		// Type-based argument resolution
		resolvers.add(new ServletRequestMethodArgumentResolver());
		resolvers.add(new ServletResponseMethodArgumentResolver());
		resolvers.add(new HttpEntityMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
		resolvers.add(new RedirectAttributesMethodArgumentResolver());
		resolvers.add(new ModelMethodProcessor());
		resolvers.add(new MapMethodProcessor());
		resolvers.add(new ErrorsMethodArgumentResolver());
		resolvers.add(new SessionStatusMethodArgumentResolver());
		resolvers.add(new UriComponentsBuilderMethodArgumentResolver());

		// Custom arguments
		if (getCustomArgumentResolvers() != null) {
			resolvers.addAll(getCustomArgumentResolvers());
		}

		// Catch-all
		resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));
		resolvers.add(new ServletModelAttributeMethodProcessor(true));

		return resolvers;
	}

RequestMappingHandlerAdapter#getDefaultInitBinderArgumentResolvers 方法 – 获取默认的参数绑定器

org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#getDefaultInitBinderArgumentResolvers

获取默认的参数绑定器，按顺序添加了多个参数解析器对象。

	private List<HandlerMethodArgumentResolver> getDefaultInitBinderArgumentResolvers() {
		List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>(20);

		// Annotation-based argument resolution
		resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
		resolvers.add(new RequestParamMapMethodArgumentResolver());
		resolvers.add(new PathVariableMethodArgumentResolver());
		resolvers.add(new PathVariableMapMethodArgumentResolver());
		resolvers.add(new MatrixVariableMethodArgumentResolver());
		resolvers.add(new MatrixVariableMapMethodArgumentResolver());
		resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));
		resolvers.add(new SessionAttributeMethodArgumentResolver());
		resolvers.add(new RequestAttributeMethodArgumentResolver());

		// Type-based argument resolution
		resolvers.add(new ServletRequestMethodArgumentResolver());
		resolvers.add(new ServletResponseMethodArgumentResolver());

		// Custom arguments
		if (getCustomArgumentResolvers() != null) {
			resolvers.addAll(getCustomArgumentResolvers());
		}

		// Catch-all
		resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));

		return resolvers;
	}

RequestMappingHandlerAdapter#getDefaultReturnValueHandlers 方法 – 获取默认的返回值处理器

org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#getDefaultReturnValueHandlers

获取默认的返回值处理器，按顺序添加了多个返回值处理器对象。

	private List<HandlerMethodReturnValueHandler> getDefaultReturnValueHandlers() {
		List<HandlerMethodReturnValueHandler> handlers = new ArrayList<>(20);

		// Single-purpose return value types
		handlers.add(new ModelAndViewMethodReturnValueHandler());
		handlers.add(new ModelMethodProcessor());
		handlers.add(new ViewMethodReturnValueHandler());
		handlers.add(new ResponseBodyEmitterReturnValueHandler(getMessageConverters(),
				this.reactiveAdapterRegistry, this.taskExecutor, this.contentNegotiationManager));
		handlers.add(new StreamingResponseBodyReturnValueHandler());
		handlers.add(new HttpEntityMethodProcessor(getMessageConverters(),
				this.contentNegotiationManager, this.requestResponseBodyAdvice));
		handlers.add(new HttpHeadersReturnValueHandler());
		handlers.add(new CallableMethodReturnValueHandler());
		handlers.add(new DeferredResultMethodReturnValueHandler());
		handlers.add(new AsyncTaskMethodReturnValueHandler(this.beanFactory));

		// Annotation-based return value types
		handlers.add(new ModelAttributeMethodProcessor(false));
		handlers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(),
				this.contentNegotiationManager, this.requestResponseBodyAdvice));

		// Multi-purpose return value types
		handlers.add(new ViewNameMethodReturnValueHandler());
		handlers.add(new MapMethodProcessor());

		// Custom return value types
		if (getCustomReturnValueHandlers() != null) {
			handlers.addAll(getCustomReturnValueHandlers());
		}

		// Catch-all
		if (!CollectionUtils.isEmpty(getModelAndViewResolvers())) {
			handlers.add(new ModelAndViewResolverMethodReturnValueHandler(getModelAndViewResolvers()));
		}
		else {
			handlers.add(new ModelAttributeMethodProcessor(true));
		}

		return handlers;
	}

RequestMappingHandlerAdapter#handleInternal 方法 – 处理请求

org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#handleInternal

处理请求，由 AbstractHandlerMethodAdapter#handle 方法触发。

	@Override
	protected ModelAndView handleInternal(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
		ModelAndView mav;
		// 校验请求(requestMethod 和 pre-session 的校验)
		checkRequest(request);

		// Execute invokeHandlerMethod in synchronized block if required.
		// 调用 HandlerMethod 方法，同步相同 Session 的逻辑，默认情况 false
		if (this.synchronizeOnSession) {
			HttpSession session = request.getSession(false);
			if (session != null) {
				// 获取 session 的锁对象
				Object mutex = WebUtils.getSessionMutex(session);
				synchronized (mutex) {
					mav = invokeHandlerMethod(request, response, handlerMethod);
				}
			}
			else {
				// No HttpSession available -> no mutex necessary
				mav = invokeHandlerMethod(request, response, handlerMethod);
			}
		}
		else {
			// No synchronization on session demanded at all...
			mav = invokeHandlerMethod(request, response, handlerMethod);
		}

		if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
			if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
				applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
			}
			else {
				prepareResponse(response);
			}
		}

		return mav;
	}

RequestMappingHandlerAdapter#invokeHandlerMethod

org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#invokeHandlerMethod

处理请求，由 RequestMappingHandlerAdapter#handleInternal 方法触发。

  1. 创建 ServletWebRequest 对象，包含了 request 和 response。创建 WebDataBinderFactory 对象，和数据绑定相关。创建 ModelFactory 对象，和往 Model 对象设置数据相关。创建 ServletInvocableHandlerMethod 对象，ModelAndViewContainer 对象，AsyncWebRequest 对象，WebAsyncManager 对象，并初始其相关属性。
  2. 核心，调用 ServletInvocableHandlerMethod#invokeAndHandle 方法处理请求。
  3. 获得 ModelAndView 对象，标记请求完成。
	@Nullable
	protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
		// 创建 ServletWebRequest 对象，包含了 request 和 response
		ServletWebRequest webRequest = new ServletWebRequest(request, response);
		try {
			// 创建 WebDataBinderFactory 对象，和数据绑定相关
			WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
			// 创建 ModelFactory 对象，和往 Model 对象设置数据相关
			ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);

			// 创建 ServletInvocableHandlerMethod 对象，并设置其相关属性
			ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
			if (this.argumentResolvers != null) {
				invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
			}
			if (this.returnValueHandlers != null) {
				invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
			}
			invocableMethod.setDataBinderFactory(binderFactory);
			invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);

			// 创建 ModelAndViewContainer 对象，并初始其相关属性
			ModelAndViewContainer mavContainer = new ModelAndViewContainer();
			mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
			modelFactory.initModel(webRequest, mavContainer, invocableMethod);
			mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);

			// 创建 AsyncWebRequest 异步请求对象
			AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
			asyncWebRequest.setTimeout(this.asyncRequestTimeout);

			// 创建 WebAsyncManager 异步请求管理器对象
			WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
			asyncManager.setTaskExecutor(this.taskExecutor);
			asyncManager.setAsyncWebRequest(asyncWebRequest);
			asyncManager.registerCallableInterceptors(this.callableInterceptors);
			asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);

			// 异步处理，并发结果相关
			if (asyncManager.hasConcurrentResult()) {
				Object result = asyncManager.getConcurrentResult();
				mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0];
				asyncManager.clearConcurrentResult();
				LogFormatUtils.traceDebug(logger, traceOn -> {
					String formatted = LogFormatUtils.formatValue(result, !traceOn);
					return "Resume with async result [" + formatted + "]";
				});
				invocableMethod = invocableMethod.wrapConcurrentResult(result);
			}

			// 核心，由 ServletInvocableHandlerMethod 处理请求
			invocableMethod.invokeAndHandle(webRequest, mavContainer);
			if (asyncManager.isConcurrentHandlingStarted()) {
				return null;
			}

			// 获得 ModelAndView 对象
			return getModelAndView(mavContainer, modelFactory, webRequest);
		}
		finally {
			// 标记请求完成
			webRequest.requestCompleted();
		}
	}
JellyfishMIX
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spring源码解析-web系列(四):九大组件之HandlerAdapter
civil的专栏
08-04 1778
HandlerAdapter HandlerMapping通过request找到Handler，HandlerAdapter通过Handler来干活。HandlerAdapter的继承关系如下： 图1： HandlerAdapter的继承结构很简单，且右边4个类都很简单，只需关注AbstractHandlerMethodAdapter和RequestMappingHandlerAdapter即可...
Spring 知识面面通 之 HandlerMethodArgumentResolver方法参数解析器
键盘上流淌的日子
11-26 853
  HandlerMethodArgumentResolver是一个策略接口，用于在给定请求上下文中解析方法参数。平时开发中使用的频次比较高，@CookieValue、@RequestBody、@PathVariable、@RequestParam等等这些注解都是基于这个策略接口来完成参数解析的。   HandlerMethodArgumentResolver API定义 package org.springframework.web.method.support; import org.springfr
四. springmvc之HandlerAdapter
Haonan的博客
06-18 1752
springmvc之HandlerAdapter 一. 概述 ​ 前面HandlerMapping的作用是根据request找到Handler。通过分析我们也知道Handler可能有很多种，我们自定义的类，方法，还有springmvc给我们内置的一些。每种Handler的调用方式都不尽相同，因此就需要HandlerAdapter。 ​ 顾名思义，HandlerAdapter是一种适配器，对于某种类型的Handler，都有一种对应的Adapter，用来完成对Handler的调用。 // Deter
Spring源码系列：HandlerAdapter接口
DemoTransfer
06-25 130
HandlerAdapter接口源码如下： /** * MVC framework SPI, allowing parameterization of the core MVC workflow. * * <p>Interface that must be implemented for each handler type to handle a request. * This...
Spring中的拦截器
daniel_fei的博客
02-23 899
Spring中的拦截器 定义spring拦截器两种基本方式 1. 实现接口：org.springframework.web.servlet.HandlerInterceptor。 接口中有如下方法需要重写： 注意：参数中的Object handler是下一个拦截器。 a) public boolean preHandle (HttpServletRequest request,Http
springfox-spring-web-2.9.2-API文档-中文版.zip
07-13
赠送jar包：springfox-spring-web-2.9.2.jar； 赠送原API文档：springfox-spring-web-2.9.2-javadoc.jar； 赠送源代码：springfox-spring-web-2.9.2-sources.jar； 赠送Maven依赖信息文件：springfox-spring-web-...
springfox-spring-webmvc-3.0.0-API文档-中英对照版.zip
05-03
赠送jar包：springfox-spring-webmvc-3.0.0.jar； 赠送原API文档：springfox-spring-webmvc-3.0.0-javadoc.jar； 赠送源代码：springfox-spring-webmvc-3.0.0-sources.jar； 赠送Maven依赖信息文件：springfox-...
spring-web-5.2.3.RELEASE和spring-webmvc-5.2.3.RELEASE
02-25
最新版spring-web-5.2.3.RELEASE和spring-webmvc-5.2.3.RELEASE
spring-web-5.3.6 jar包.rar
07-26
这个jar文件包含Web应用开发时，用到Spring框架时所需的核心类， 包括自动载入WebApplicationContext特性的类、Struts与JSF集成类、文件上传的支持类、Filter类和大量工具辅助类。 spring的核心类，提供了核心HTTP...
spring-web.jar
03-22
spring-web.jar
JavaWeb学习之——Spring篇之HandlerMapping
chuandie7960的博客
01-15 592
1.HandlerMapping HandlerMapping接口只有一个方法 HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception; 就是根据Reuqest返回HandlerExec...
异步环境下请求处理的核心 -Spring Boot + Spring WebFlux 的 WebHandler
q1472750149的博客
11-25 911
我们创建的简易网关，外层的服务容器其实就是基于 Netty 和 Project Reactor 的容器，我们跳过这些，直接进入 Spring Boot 相关的处理逻辑。我们只需要知道，请求和其对应的响应，会被外层的容器封装成为 ServerHttpRequest request 和 ServerHttpResponse response(都在 org.springframework.http.server.reactive 这个包下)。 然后，会交由 WebHandler 进行处理。WebHandler
已弃用 ‘org.springframework.web.servlet.handler.HandlerInterceptorAdapter‘
qq_45699590的博客
03-28 3816
已弃用 'org.springframework.web.servlet.handler.HandlerInterceptorAdapter’ 新版本idea中使用拦截器的时候出现如下报错 解决方法如下： 在public class…前面添加依赖： @Deprecated 然后重新编译后，拦截器就可以正常使用了！ ...
SpringMVC源码系列(五)HandlerAdapter中handle方法的调用过程
二狗家有矿
02-18 338
1.写在前面 笔者前面已经介绍过了如何获取对应的Handler,以及如何获取对应的HandlerAdapter，也就是从Url和方法的映射到找到对应的适配器，笔者已经讲完了。接下笔者讲的是如何调用，以及视图的解析。今天这篇博客要讲的就是HandlerAdapter的调用 2.HandlerAdapter的调用 笔者还是带大家看下原来的代码，具体的内容如下： protected void doDispatch(HttpServletRequest request, HttpServletRespon
Spring-web-HandlerMethodReturnValueHandler
文天大人
09-22 1021
怀念二抱三抱
spring MVC关于org.springframework.web.servlet.handler.SimpleUrlHandlerMapping的使用
06-03 8942
1，spring MVC的优点 1.spring mvc使用简单，学习成本低。 2.spring mvc灵活方便。 3.spring mvc能够写出很好的程序。 2，spring 的核心类与接口 DispatcherServlet   -- 前置控制器 HandlerMapping接口 -- 处理请求的映射 HandlerMapping接口的实现类：
SpringMvc 学习 （三） 三大组件的配置
Mr_黑_ 的博客
01-28 3504
SpringMvc三大组件的配置
SpringMVC之HandlerAdapter解析
gsls181711的专栏
07-05 1200
HandlerAdapter字面上的意思就是处理适配器，它的作用用一句话概括就是调用具体的方法对用户发来的请求来进行处理。当handlerMapping获取到执行请求的controller时，DispatcherServlte会根据controller对应的controller类型来调用相应的HandlerAdapter来进行处理。         在贴源码之前先说一下HandlerAdap
SpringMVC源码总结（一）HandlerMapping和HandlerAdapter入门
weixin_33918114的博客
02-07 249
2019独角兽企业重金招聘Python工程师标准>>> ...
dynamic-datasource-spring-boot-starter 源码分析
最新发布
09-05
对于 dynamic-datasource-spring-boot-starter 的源码分析，可以从以下几个方面进行思考： 1. 数据源的自动装配：源码中可能会使用 Spring Boot 的自动配置功能，通过扫描配置类或者注解的方式，自动将数据源相关的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

JellyfishMIX

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

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

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

打赏作者

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

抵扣说明：

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

余额充值