Spring MVC 执行流程 (DispatcherServlet)

最新推荐文章于 2022-11-30 22:27:43 发布
最新推荐文章于 2022-11-30 22:27:43 发布
阅读量589 收藏
点赞数
文章标签： spring spring MVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cmmchenmm/article/details/84550172
版权

Spring MVC 执行流程 (DispatcherServlet)

  1. Servlet容器将http请求封装为HttpServletRequest和HttpServletReponse
  2. 交于Spring MVC 的前端总控制器 DispatcherServlet 处理（门面模式）
  3. 执行DispatcherServlet#service
  4. 执行DispatcherServlet#doService
  5. 执行DispatcherServlet#doDispatch
  6. HandlerExecutionChain -> mappedHandler
  7. HandlerAdapter
  8. 执行HandlerExecutionChain 前置执行方法 -> applyPreHandle
  9. HandlerAdapter 执行 HandlerAdapter#handle 获取一个 ModelAndView
  10. 给ModelAndView设置viewName （转发路径）
  11. 执行HandlerExecutionChain 后置方法 -> applyPostHandle
  12. 执行DispatcherServlet#processDispatchResult -> 处理调度结果 (返回前端的数据)

通过图片可以看出 HandlerExecutionChain -> mappedHandler 其中的 handler 就是我们Controller层中对应映射的执行方法。在mappedHandler还有一些HandlerInterceptor 方法执行之前的拦截器

DispatcherServlet#doDispatch 源码

以下为DispatcherServlet类的doDispatch方法

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
		HandlerExecutionChain mappedHandler = null;
		boolean multipartRequestParsed = false;

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

		try {
			ModelAndView mv = null;
			Exception dispatchException = null;

			try {
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);

				// Determine handler for the current request.
				// 根据当前的HttpServletRequest获取HandlerExecutionChain
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null) {
					//没有获取到目前处理器
					//但是根据debug情况当404时其实是有HandlerExecutionChain的
					//并且其中的handler为ResourceHttpRequestHandler
					//ResourceHttpRequestHandler [locations=[class path resource [META-INF/resources/], 
					//class path resource [resources/], class path resource [static/], 
					//class path resource [public/], ServletContext resource [/]], 
					//resolvers=[org.springframework.web.servlet.resource.PathResourceResolver@7b92bcde]]
					noHandlerFound(processedRequest, response);
					return;
				}

				// Determine handler adapter for the current request.
				// 获取 HandlerAdapter （适配器）
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

				// Process last-modified header, if supported by the handler.
				String method = request.getMethod();
				boolean isGet = "GET".equals(method);
				if (isGet || "HEAD".equals(method)) {
					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
					if (logger.isDebugEnabled()) {
						logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
					}
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}
				// 执行HandlerExecutionChain前置方法
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				// Actually invoke the handler.
				// 使用HandlerAdapter执行方法
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}
				// 设置 viewName 内部转发 
				applyDefaultViewName(processedRequest, mv);
				// 执行HandlerExecutionChain后置方法
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}
			
			// 执行方法过程中如果发生异常 就将 Exception dispatchException 赋值
			catch (Exception ex) {
				dispatchException = ex;
			}
			catch (Throwable err) {
				// As of 4.3, we're processing Errors thrown from handler methods as well,
				// making them available for @ExceptionHandler methods and other scenarios.
				dispatchException = new NestedServletException("Handler dispatch failed", err);
			}
			// 页面渲染 404 500 等页面也会进行渲染 将上一步过程中的异常一起渲染 常见的就是500状态码错误
			// 处理调度结果 (返回前端的数据)
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		catch (Exception ex) {
			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
		}
		catch (Throwable err) {
			triggerAfterCompletion(processedRequest, response, mappedHandler,
					new NestedServletException("Handler processing failed", err));
		}
		finally {
			if (asyncManager.isConcurrentHandlingStarted()) {
				// Instead of postHandle and afterCompletion
				if (mappedHandler != null) {
					mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
				}
			}
			else {
				// Clean up any resources used by a multipart request.
				if (multipartRequestParsed) {
					cleanupMultipart(processedRequest);
				}
			}
		}
	}

HandlerAdapter是如何执行handle方法 （RequestMappingHandlerAdapter）

在上述的方法进行debug 最后会执行 RequestMappingHandlerAdapter 的 handle 方法

首先RequestMappingHandlerAdapter 是继承 AbstractHandlerMethodAdapter这个抽象类的

所以先看看AbstractHandlerMethodAdapter

@Override
@Nullable
public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
		throws Exception {
	
	//注意这里 Object handler 进行了强制类型转换
	return handleInternal(request, response, (HandlerMethod) handler);
}

@Nullable
protected abstract ModelAndView handleInternal(HttpServletRequest request,
		HttpServletResponse response, HandlerMethod handlerMethod) throws Exception;

所以在观察RequestMappingHandlerAdapter之前，我们可以先看看 HandlerExecutionChain 是什么样的


public class HandlerExecutionChain {

	private static final Log logger = LogFactory.getLog(HandlerExecutionChain.class);

	//这里的 handler 是 Object 类型的
	private final Object handler;

	//有一组按照顺序执行的HandlerInterceptor
	
	@Nullable
	private HandlerInterceptor[] interceptors;

	@Nullable
	private List<HandlerInterceptor> interceptorList;

	private int interceptorIndex = -1;
	
	...
}

HandlerInterceptor 是什么样子的

public interface HandlerInterceptor {

	//前置处理方法
	default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		return true;
	}

	//后置处理方法
	default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable ModelAndView modelAndView) throws Exception {
	}
	
	//完成请求处理后，即渲染后回调视图。将调用处理程序执行的任何结果，从而允许进行适当的资源清理。（谷歌翻译）
	default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable Exception ex) throws Exception {
	}

}

我们再看看AbstractHandlerMethodAdapter#handleInternal中涉及到了handler的强制类型转换 转换成了HandlerMethod
那么就看看HandlerMethod

public class HandlerMethod {

	/** Logger that is available to subclasses */
	protected final Log logger = LogFactory.getLog(getClass());

	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
	//HTTP协议的状态码 200 500 404 403 等
	private HttpStatus responseStatus;

	@Nullable
	private String responseStatusReason;

	@Nullable
	private HandlerMethod resolvedFromHandlerMethod;

	...
	
	/**
	 * Create an instance from a bean instance and a method.
	 */
	public HandlerMethod(Object bean, Method method) {
		Assert.notNull(bean, "Bean is required");
		Assert.notNull(method, "Method is required");
		this.bean = bean;
		this.beanFactory = null;
		this.beanType = ClassUtils.getUserClass(bean);
		this.method = method;
		this.bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
		this.parameters = initMethodParameters();
		evaluateResponseStatus();
	}
}

我们是时候看看RequestMappingHandlerAdapter#handleInternal

@Override
	protected ModelAndView handleInternal(HttpServletRequest request,
			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
		ModelAndView mav;
		checkRequest(request);

		// 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) {
					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;
	}

可以看出 最终都是 ==mav = invokeHandlerMethod(request, response, handlerMethod);==这句代码


//这里就是invoke的核心了
@Nullable
protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
		HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

	ServletWebRequest webRequest = new ServletWebRequest(request, response);
	try {
		//这里两步就获取一些参数绑定  InvocableHandlerMethod 其实 在之前的一篇文章中有涉及到Spring MVC 参数获取
		//这里就是进入前的步骤 
		//CSDN 地址 https://blog.csdn.net/cmmchenmm/article/details/82774568
		WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
		ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);

		// ServletInvocableHandlerMethod extends InvocableHandlerMethod
		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 mavContainer = new ModelAndViewContainer();
		mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
		modelFactory.initModel(webRequest, mavContainer, invocableMethod);
		mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);

		AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
		asyncWebRequest.setTimeout(this.asyncRequestTimeout);

		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();
			if (logger.isDebugEnabled()) {
				logger.debug("Found concurrent result value [" + result + "]");
			}
			invocableMethod = invocableMethod.wrapConcurrentResult(result);
		}

		invocableMethod.invokeAndHandle(webRequest, mavContainer);
		if (asyncManager.isConcurrentHandlingStarted()) {
			return null;
		}

		return getModelAndView(mavContainer, modelFactory, webRequest);
	}
	finally {
		webRequest.requestCompleted();
	}
}

使用 HandlerInterceptor 做鉴权？

首先编写一个 HandlerInterceptor 的实现类

/**
 *
 * 希望利用 HandlerInterceptor 方式实现 注解校验 Token
 * @author chenmingming
 * @date 2018/11/24
 */
@Component
public class TokenHandlerInterceptor implements HandlerInterceptor {

    @Autowired
    private ModelRepo modelRepo;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        try {

            if(handler instanceof HandlerMethod){
                HandlerMethod handlerMethod = (HandlerMethod) handler;
                boolean needToken = handlerMethod.getMethod().getAnnotation(Token.class) != null;
                if(needToken){
                    String token = request.getHeader("token");
                    Optional<Model> byId = modelRepo.findById(token);
                    Model model = byId.get();
                    request.setAttribute("token",model);
                }
            }
            return true;
        }catch (Exception e){
            e.printStackTrace();
            throw new Exception("Token Error",e);
        }

    }
}

编写配置类 可以查看Spring 官网的推荐配置 （基于 Spring Boot 2.x,Spring 5.x）

@Configuration
public class TokenWebConfigurer implements WebMvcConfigurer {

    @Autowired
    private TokenHandlerInterceptor tokenHandlerInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(tokenHandlerInterceptor);
    }
}

编写注解以及测试Contrller


@Target({ElementType.METHOD,ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Token {
}

@RestController
@RequestMapping("/token")
public class TokenController {

    @GetMapping("/t")
    @Token
    public Object test(@RequestAttribute("token") Model model){
        return model;
    }

}

最终结果截图

NewshiJ
关注
SpringMVC请求如何到DispatcherServlet（二）
qq_38330846的博客
04-07 668
请求如何由浏览器到服务器的？ 请求进入服务器程序的第一个入口就是HttpServlet类的service()方法， 看一下该类的继承关系，DispatcherServlet继承了FrameworkServlet继承了HttpServletBean继承了HttpServlet 继承了 GenericServlet实现了Servlet 继承：如果多个类的某个部分的功能相同，那么可以抽象出一个类出来，把他们的相同部分都放到父类里，让他们都继承这个类。 实现：如果多个类处理...
DispatcherServlet的工作流程
最新发布
lovezjiayi的博客
08-23 457
首先客户端发送/hello请求被DisapatcherServlet拦截，然后DisapatcherServlet去读取Config File内容(即扫描所有controller)，spring会为带@Controller注解的创建对象并注入到IOC容器中。从图三知道，这里传入的/hello请求被被HelloController的一个映射名为/hello的helloWorld方法进行对应，代码入下，结果输出hello。前端控制器从称为配置文件(Config File)的特殊文件中获取内容后进行操作。
SpringMVC DispatcherServlet 运行的大致流程
kitahiragawa的博客
08-27 569
引言 在使用SpringMVC之前，我们写请求处理都是自己写Servlet（Servlet实现类），来实现对请求的响应处理，还要为每个Servlet写一对请求地址映射配置，比较麻烦。使用了SpringMVC，我们只需要利用SpringMVC提供好的API就可以方便的实现请求的处理，而且我们只需要写一个Servlet的配置就行了，这个Servlet就是DispatcherServlet。 DispatcherServlet的作用 我们发来的http请求都会被DispatcherServlet统一处理，Disp
浅谈SpringMVC源码的DispatcherServlet组件执行流程
持续Java学习中
10-24 2406
文章目录一、基础概念1、初始化变量数据2、urlLookup集合3、策略设计模式4、前期的基本流程二、doDispatch1、文件相关2、拦截器三、getHandler（重点）1、HandlerMapping2、getHandlerInternal3、getHandlerExecutionChain四、getHandlerAdapter（重点）1、getHandlerAdapter方法2、ha.handle()3、invokeHandlerMethod4、invokeAndHandle5、invokeFor
从DispatcherServlet开始到结束，浅谈springmvc执行流程
wjw的博客
09-21 440
这篇文章，DispatcherServlet是个重点，谈springmvc绕不开他，我们使用他作为springmvc接管web项目request的入口(在web.xml)中配置。 所以，接下来，将这位老大哥的身子贴在下面，请大家文明阅览: protected void doDispatch(HttpServletRequest request, HttpServletResponse res...
SpringMvc的执行流程 -----DispatcherServlet
Anyuqiao的博客
11-30 216
SpringMvc的执行流程
Spring MVC学习之DispatcherServlet请求处理详析
08-26
理解DispatcherServlet的工作流程，对于深入掌握Spring MVC框架至关重要。在实际开发中，我们可以根据需求自定义HandlerMapping和HandlerAdapter，以满足特定的应用场景，实现更加定制化的请求处理。
SpringMVC的执行流程、DispatcherServlet 处理流程
m0_61454947的博客
05-24 300
SpringMVC的执行流程 1) 用户向服务器发送请求，请求被SpringMVC 前端控制器 DispatcherServlet捕获。 2) DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI），判断请求URI对应的映射： a) 不存在 i. 再判断是否配置了mvc:default-servlet-handler ii. 如果没配置，则控制台报映射查找不到，客户端展示404错误 iii. 如果有配置，则访问目标资源（一般为静态资源，如：JS,CSS,H.
Spring MVC中的DispatcherServlet的使用
01-20
Servlet ...Servlet 生命周期（容器管理） 1. 实例化 – 构造器  默认第一访问，可配置程序启动就初始化 2. 初始化 – init() ...doGet() doPost() doPut()早期版本默认无效 doDelete() 早期版本默认无效 ...
Spring MVC[01]附DispatcherServlet执行流程图
Toozky的博客
05-05 251
spring_mvc[01] IDEA创建maven-archetype-webapp项目 pom.xml properties标签中添加spring.version标签 <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.compiler.source>1.7</maven.compiler.source>
spring mvc执行流程
05-21
### Spring MVC 执行流程详解 #### 一、概述 Spring MVC 是 Spring 框架中的一个重要组成部分，主要用于构建基于 Web 的应用程序。它提供了一个清晰的架构来管理 Web 层的业务逻辑，使得开发者能够轻松地处理 ...
【JavaEE】描述SpringMVC和DispatcherServlet的工作流程
分享记录开发中的问题，欢迎一起探讨！
02-11 1214
(1)用户发送请求至前端控制器DispatcherServlet; (2) DispatcherServlet收到请 求后，调用HandlerMapping处理器映射器，请求获取 Handle; (3)处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果 有则生成)一并返回给DispatcherServlet; (4) DispatcherServlet 调用HandlerAdapter处理器适配器; (5) HandlerAdapter 经过适配调用具体处理器(Handler，也
SpringMVC—DispatchServlet运行流程
小Gd 的博客
05-16 544
DispatchServlet—通用的客户端请求处理 图中实线部分为SpringMVC代为处理，虚线部分为自行处理。 1、DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收并拦截请求。 我们假设请求的url为：http://localhost:8080/SpringMVC/hello 将如上url拆分为三部分： http://localhost:8080服务器域名 SpringMVC部署在服务器上的web站点 hel
【源码分析】SpringMVC DispatcherServlet执行流程
starchao
06-06 474
1、Web 开发中的请求-响应模型 我们都知道在Web世界里都是 1、客户端浏览器发起请求； 2、服务器接收、处理并响应（一般为HTML页面）； 3、客户端浏览器对接收的内容进行视图渲染。 2、Web MVC 模型 MVC模型：是模型、视图、控制器的简写，是一种架构模型，是一种软件设计规范，是开发的最佳实践。本身并不引入新功能，只是帮助我们将开发的组织的更加合理。使模型、视图、控制相分离，责任分离。 Model(模型)：数据模型，提供要显示的数据，包含数据和行为。比如JavaBean组件。通常又分为数
DispatcherServlet Servlet
qq 117791303
07-12 283
Spring进阶 - SpringMVC实现原理之DispatcherServlet处理请求的过程
m0_67698950的博客
07-19 730
前文我们有了IOC的源码基础以及SpringMVC的基础，我们便可以进一步深入理解SpringMVC主要实现原理，包含DispatcherServlet的初始化过程和DispatcherServlet处理请求的过程的源码解析。本文是第二篇DispatcherServlet处理请求的过程的源码解析。@pdai。...
Spring MVC 菜鸟教程 5 DispatcherServlet执行流程涉及处理类
菜鸟教程
03-23 1929
DispatcherServlet是前端控制器设计模式的实现，提供Spring Web MVC的集中访问点，而且负责职责的分派，而且与Spring IoC容器无缝集成，从而可以获得Spring的所有好处。
Spring MVC之DispatcherServlet_动力节点Java学院整理
10-19
总的来说，DispatcherServlet是Spring MVC的核心组件，负责请求分发和控制流程。理解其配置和工作原理对于有效利用Spring MVC开发Web应用至关重要。通过合理的配置，我们可以实现灵活的请求处理策略，以满足复杂的...
DispatcherServlet执行流程
wzs535131的博客
10-13 2744
spring MVC中的DispatcherServlet执行流程图如下： DispatcherServlet执行流程图 1、用户发送请求至前端控制器DispatcherServlet。 2、DispatcherServlet收到请求调用HandlerMapping处理器映射器。 3、处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。 4、 DispatcherServlet调用Hand.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值