springMVC工作流程及源码剖析

最新推荐文章于 2024-08-04 14:44:29 发布
置顶 最新推荐文章于 2024-08-04 14:44:29 发布
阅读量1k 收藏 1
点赞数
分类专栏： SpringMVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012401711/article/details/74372615
版权

一、首先了解springMVC的组件定义及用途

1.DisPatcherServlet：前端控制器（不需要程序员开发）

用户请求到达前端控制器，它相当于MVC模式中的C（Controller），DispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，DispatcherServlet的存       在降低了组件之间的耦合性。

作用：作为接受请求，相应结果，相当于转发器，中央处理器，减少其他组件之间的耦合度。

2.HandlerMapping：处理器映射器（不需要程序员开发）

HandlerMapping负责根据用户请求找到Handler（即：处理器），SpringMVC提供了不同的映射器实现实现不同的映射方式，例如：配置文件方式、实现接口方式、注解方        式等。

作用：根据请求的Url 查找Handler

3.HandLer：处理器（需要程序员开发）

Handler是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下，Handler对具体的用户请求进行处理。

由于Handler设计到具体的用户业务请求，所以一般情况需要程序员根据业务需求开发Handler。

注意：编写Handler时按照HandlerAdpter的要求去做，这样才可以去正确执行Handler。

4.HandlerAdapter：处理器适配器

通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

作用：按照特定的规则（HandlerAdapter要求的规则）去执行Handler

5.ViewResolver：视图解析器（不需要程序员开发）

ViewResolver负责将处理结果生成View视图，ViewResolver首先根据逻辑视图名解析成物理视图名，即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面的展示给用户。SpringMVC框架提供了很多View视图类型，包括：JSTLView、freemarkerView、pdfView等等.

作用：进行视图解析，根据逻辑视图名解析成真正的视图（view）。

6.View视图 （需要程序员开发 jsp）

View是一个接口，实现类支持不同的View类型（jsp、freemarker、pdf）

一般情况下需要通过页面标签或者页面模板技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面。

二、流程图

    

描述：

1.用户发送请求至 前端控制器DispatcherServlet。

2.前端控制器DispatcherServlet收到请求后调用处理器映射器HandlerMapping。

3.处理器映射器HandlerMapping根据请求的Url找到具体的处理器，生成处理器对象Handler及处理器拦截器HandlerIntercepter（如果有则生成）一并返回给前端控制器 DispatcherServlet。

4.前端控制器DispatcherServlet通过处理器适配器HandlerAdapter调用处理器Controller。

5.执行处理器（Controller，也叫后端控制器）

6.处理器Controller执行完后返回ModelAnView。

7.处理器映射器HandlerAdapter将处理器Controller执行返回的结果ModelAndView返回给前端控制器DispatcherServlet。

8.前端控制器DispatcherServlet将ModelAnView传给视图解析器ViewResolver。

9.视图解析器ViewResolver解析后返回具体的视图View。

10.前端控制器DispatcherServlet对视图View进行渲染视图（即：将模型数据填充至视图中）

11. 前端控制器DispatcherServlet响应用户。

三、源码剖析

❶前端控制器接收请求

入口程序，web.xml

	<!-- springmvc前端控制器 -->
	<servlet>
		<servlet-name>springmvc</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<!-- contextConfigLocation配置springmvc加载的配置文件（配置处理器映射器、适配器等等） 如果不配置contextConfigLocation，
                默认加载的是/WEB-INF/servlet名称-serlvet.xml（springmvc-servlet.xml） -->
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:spring/springmvc.xml</param-value>
		</init-param>
	</servlet>

查看DispatcherServlet源码发现没有doGet()、doPost()方法，但是DispatcherServlet继承了FrameworkServlet

public class DispatcherServlet extends FrameworkServlet {}

FrameworkServlet 中doGet()和doPost()源码，发现都执行了processRequest(request, response);

	@Override
	protected final void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		processRequest(request, response);
	}

	/**
	 * Delegate POST requests to {@link #processRequest}.
	 * @see #doService
	 */
	@Override
	protected final void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		processRequest(request, response);
	}
processRequest(request, response); 

protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		long startTime = System.currentTimeMillis();
		Throwable failureCause = null;

		LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
		LocaleContext localeContext = buildLocaleContext(request);

		RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
		ServletRequestAttributes requestAttributes = null;
		if (previousAttributes == null || (previousAttributes instanceof ServletRequestAttributes)) {
			requestAttributes = new ServletRequestAttributes(request);
		}

		initContextHolders(request, localeContext, requestAttributes);

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
		asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), getRequestBindingInterceptor(request));

		try {
			doService(request, response);
		}
		catch (ServletException ex) {
			failureCause = ex;
			throw ex;
		}
		catch (IOException ex) {
			failureCause = ex;
			throw ex;
		}
		catch (Throwable ex) {
			failureCause = ex;
			throw new NestedServletException("Request processing failed", ex);
		}

		finally {
			resetContextHolders(request, previousLocaleContext, previousAttributes);
			if (requestAttributes != null) {
				requestAttributes.requestCompleted();
			}

			if (logger.isDebugEnabled()) {
				if (failureCause != null) {
					this.logger.debug("Could not complete request", failureCause);
				} else {
					if (asyncManager.isConcurrentHandlingStarted()) {
						if (logger.isDebugEnabled()) {
							logger.debug("Leaving response open for concurrent processing");
						}
					}
					else {
						this.logger.debug("Successfully completed request");
					}
				}
			}
			if (this.publishEvents) {
				// Whether or not we succeeded, publish an event.
				long processingTime = System.currentTimeMillis() - startTime;
				this.webApplicationContext.publishEvent(
						new ServletRequestHandledEvent(this,
								request.getRequestURI(), request.getRemoteAddr(),
								request.getMethod(), getServletConfig().getServletName(),
								WebUtils.getSessionId(request), getUsernameForRequest(request),
								processingTime, failureCause));
			}
		}
	}
通过processRequest方法可以查看到try中方法doService(request, response);进一步查看 

	protected abstract void doService(HttpServletRequest request, HttpServletResponse response)
			throws Exception;
doService是个抽象方法，那子类将实现这个方法，查看子类就回到了DispatcherServlet

追踪源码发现最后的方法是DispatcherServlet中的doService()

/**
	 * Exposes the DispatcherServlet-specific request attributes and delegates to {@link #doDispatch}
	 * for the actual dispatching.
	 */
	@Override
	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {

		if (logger.isDebugEnabled()) {
			String requestUri = urlPathHelper.getRequestUri(request);
			String resumed = WebAsyncUtils.getAsyncManager(request).hasConcurrentResult() ? " resumed" : "";
			logger.debug("DispatcherServlet with name '" + getServletName() + "'" + resumed +
					" processing " + request.getMethod() + " request for [" + requestUri + "]");
		}

		// Keep a snapshot of the request attributes in case of an include,
		// to be able to restore the original attributes after the include.
		Map<String, Object> attributesSnapshot = null;
		if (WebUtils.isIncludeRequest(request)) {
			logger.debug("Taking snapshot of request attributes before include");
			attributesSnapshot = new HashMap<String, Object>();
			Enumeration<?> attrNames = request.getAttributeNames();
			while (attrNames.hasMoreElements()) {
				String attrName = (String) attrNames.nextElement();
				if (this.cleanupAfterInclude || attrName.startsWith("org.springframework.web.servlet")) {
					attributesSnapshot.put(attrName, request.getAttribute(attrName));
				}
			}
		}

		// Make framework objects available to handlers and view objects.
		request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
		request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
		request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
		request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());

		FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
		if (inputFlashMap != null) {
			request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
		}
		request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
		request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);

		try {
			doDispatch(request, response);
		}
		finally {
			if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
				return;
			}
			// Restore the original attribute snapshot, in case of an include.
			if (attributesSnapshot != null) {
				restoreAttributesAfterInclude(request, attributesSnapshot);
			}
		}
	}
其核心方法即是doDispath() 

    /**
     * Process the actual dispatching to the handler.
     * <p>The handler will be obtained by applying the servlet's HandlerMappings in order.
     * The HandlerAdapter will be obtained by querying the servlet's installed HandlerAdapters
     * to find the first that supports the handler class.
     * <p>All HTTP methods are handled by this method. It's up to HandlerAdapters or handlers
     * themselves to decide which methods are acceptable.
     * @param request current HTTP request
     * @param response current HTTP response
     * @throws Exception in case of any kind of processing failure
     */
    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.
                mappedHandler = getHandler(processedRequest, false);
                if (mappedHandler == null || mappedHandler.getHandler() == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }

                // Determine handler adapter for the current request.
                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()) {
                        String requestUri = urlPathHelper.getRequestUri(request);
                        logger.debug("Last-Modified value for [" + requestUri + "] is: " + lastModified);
                    }
                    if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                        return;
                    }
                }

                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }

                try {
                    // Actually invoke the handler.
                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                }
                finally {
                    if (asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }
                }

                applyDefaultViewName(request, mv);
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            }
            catch (Exception ex) {
                dispatchException = ex;
            }
            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        }
        catch (Exception ex) {
            triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
        }
        catch (Error err) {
            triggerAfterCompletionWithError(processedRequest, response, mappedHandler, err);
        }
        finally {
            if (asyncManager.isConcurrentHandlingStarted()) {
                // Instead of postHandle and afterCompletion
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                return;
            }
            // Clean up any resources used by a multipart request.
            if (multipartRequestParsed) {
                cleanupMultipart(processedRequest);
            }
        }
    }
这才是真正的核心，查看类名称即 调度

❷前端控制器调用处理器映射器查找 Handler

HandlerExecutionChain mappedHandler = null;流程图第三步即是返回HandlerExecutionChain

mappedHandler = getHandler(processedRequest, false);此方法即是流程图第二步和第三步，调用处理器映射器返回执行器链

	/**
	 * Return the HandlerExecutionChain for this request.
	 * <p>Tries all handler mappings in order.
	 * @param request current HTTP request
	 * @return the HandlerExecutionChain, or <code>null</code> if no handler could be found
	 */
	protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
		for (HandlerMapping hm : this.handlerMappings) {
			if (logger.isTraceEnabled()) {
				logger.trace(
						"Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");
			}
			HandlerExecutionChain handler = hm.getHandler(request);
			if (handler != null) {
				return handler;
			}
		}
		return null;
	}

❸调用处理器适配器执行Handler，得到执行结果ModelAndView

HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());  获取处理器适配器

mv = ha.handle(processedRequest, response, mappedHandler.getHandler());此方法是流程图第四步和第七步，通过处理器适配器调用具体的Hander，返回ModelAndView


开发时一般使用的就是基于注解的处理器适配器 <mvc:annotation-driven/>

	<!--注解映射器 -->
	<!-- <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/> -->
	<!--注解适配器 -->
	<!-- <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/> -->
	
	<!-- 使用 mvc:annotation-driven代替上边注解映射器和注解适配器配置
	mvc:annotation-driven默认加载很多的参数绑定方法，
	比如json转换解析器就默认加载了，如果使用mvc:annotation-driven不用配置上边的RequestMappingHandlerMapping和RequestMappingHandlerAdapter
	实际开发时使用mvc:annotation-driven
	 -->
	<mvc:annotation-driven/>
以注解方式为例查看其源码实现 

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

		Class<?> clazz = ClassUtils.getUserClass(handler);
		Boolean annotatedWithSessionAttributes = this.sessionAnnotatedClassesCache.get(clazz);
		if (annotatedWithSessionAttributes == null) {
			annotatedWithSessionAttributes = (AnnotationUtils.findAnnotation(clazz, SessionAttributes.class) != null);
			this.sessionAnnotatedClassesCache.put(clazz, annotatedWithSessionAttributes);
		}

		if (annotatedWithSessionAttributes) {
			// Always prevent caching in case of session attribute management.
			checkAndPrepare(request, response, this.cacheSecondsForSessionAttributeHandlers, true);
			// Prepare cached set of session attributes names.
		}
		else {
			// Uses configured default cacheSeconds setting.
			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);
				}
			}
		}

		return invokeHandlerMethod(request, response, handler);
	}
在注意到有核心方法invokeHandlerMethod(request, response, handler)； 此方法是流程图第五步和第六步，通过反射机制获取执行真正的Handle方法 
protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		ServletHandlerMethodResolver methodResolver = getMethodResolver(handler);
		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;
	}
❹ 视图渲染，将model数据填充到request域
处理器适配器执行完成返回ModelAndView，再次查看org.springframework.web.servlet.DispatcherServlet类中的doDispatch()方法源码

doDispatch()方法中存在processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);通过名称可以知道，返回结果

/**
	 * Handle the result of handler selection and handler invocation, which is
	 * either a ModelAndView or an Exception to be resolved to a ModelAndView.
	 */
	private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
			HandlerExecutionChain mappedHandler, ModelAndView mv, Exception exception) throws Exception {

		boolean errorView = false;

		if (exception != null) {
			if (exception instanceof ModelAndViewDefiningException) {
				logger.debug("ModelAndViewDefiningException encountered", exception);
				mv = ((ModelAndViewDefiningException) exception).getModelAndView();
			}
			else {
				Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
				mv = processHandlerException(request, response, handler, exception);
				errorView = (mv != null);
			}
		}

		// Did the handler return a view to render?
		if (mv != null && !mv.wasCleared()) {
			render(mv, request, response);
			if (errorView) {
				WebUtils.clearErrorRequestAttributes(request);
			}
		}
		else {
			if (logger.isDebugEnabled()) {
				logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +
						"': assuming HandlerAdapter completed request handling");
			}
		}

		if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
			// Concurrent handling started during a forward
			return;
		}

		if (mappedHandler != null) {
			mappedHandler.triggerAfterCompletion(request, response, null);
		}
	}

视图解析，得到view:

render(mv, request, response); 
/**
	 * Render the given ModelAndView.
	 * <p>This is the last stage in handling a request. It may involve resolving the view by name.
	 * @param mv the ModelAndView to render
	 * @param request current HTTP servlet request
	 * @param response current HTTP servlet response
	 * @throws ServletException if view is missing or cannot be resolved
	 * @throws Exception if there's a problem rendering the view
	 */
	protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
		// Determine locale for request and apply it to the response.
		Locale locale = this.localeResolver.resolveLocale(request);
		response.setLocale(locale);

		View view;
		if (mv.isReference()) {
			// We need to resolve the view name.
			view = resolveViewName(mv.getViewName(), mv.getModelInternal(), locale, request);
			if (view == null) {
				throw new ServletException(
						"Could not resolve view with name '" + mv.getViewName() + "' in servlet with name '" +
								getServletName() + "'");
			}
		}
		else {
			// No need to lookup: the ModelAndView object contains the actual View object.
			view = mv.getView();
			if (view == null) {
				throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " +
						"View object in servlet with name '" + getServletName() + "'");
			}
		}

		// Delegate to the View object for rendering.
		if (logger.isDebugEnabled()) {
			logger.debug("Rendering view [" + view + "] in DispatcherServlet with name '" + getServletName() + "'");
		}
		view.render(mv.getModelInternal(), request, response);
	}
view = resolveViewName(mv.getViewName(), mv.getModelInternal(), locale, request); 此方法是流程图第八步、第九步和第十步，通过视图解析器返回View，并渲染填充到request域

view.render(mv.getModelInternal(), request, response);此方法是流程图第十步渲染

render是抽象方法，查看实现类org.springframework.web.servlet.view.AbstractView

	/**
	 * Prepares the view given the specified model, merging it with static
	 * attributes and a RequestContext attribute, if necessary.
	 * Delegates to renderMergedOutputModel for the actual rendering.
	 * @see #renderMergedOutputModel
	 */
	public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
		if (logger.isTraceEnabled()) {
			logger.trace("Rendering view with name '" + this.beanName + "' with model " + model +
				" and static attributes " + this.staticAttributes);
		}

		Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);

		prepareResponse(request, response);
		renderMergedOutputModel(mergedModel, request, response);
	}
renderMergedOutputModel(mergedModel, request, response);还是一个抽象的方法，其实现类org.springframework.web.servlet.view.InternalResourceView

实现renderMergedOutputModel的方法

/**
	 * Render the internal resource given the specified model.
	 * This includes setting the model as request attributes.
	 */
	@Override
	protected void renderMergedOutputModel(
			Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {

		// Determine which request handle to expose to the RequestDispatcher.
		HttpServletRequest requestToExpose = getRequestToExpose(request);

		// Expose the model object as request attributes.
		exposeModelAsRequestAttributes(model, requestToExpose);

		// Expose helpers as request attributes, if any.
		exposeHelpers(requestToExpose);

		// Determine the path for the request dispatcher.
		String dispatcherPath = prepareForRendering(requestToExpose, response);

		// Obtain a RequestDispatcher for the target resource (typically a JSP).
		RequestDispatcher rd = getRequestDispatcher(requestToExpose, dispatcherPath);
		if (rd == null) {
			throw new ServletException("Could not get RequestDispatcher for [" + getUrl() +
					"]: Check that the corresponding file exists within your web application archive!");
		}

		// If already included or response already committed, perform include, else forward.
		if (useInclude(requestToExpose, response)) {
			response.setContentType(getContentType());
			if (logger.isDebugEnabled()) {
				logger.debug("Including resource [" + getUrl() + "] in InternalResourceView '" + getBeanName() + "'");
			}
			rd.include(requestToExpose, response);
		}

		else {
			// Note: The forwarded resource is supposed to determine the content type itself.
			exposeForwardRequestAttributes(requestToExpose);
			if (logger.isDebugEnabled()) {
				logger.debug("Forwarding to resource [" + getUrl() + "] in InternalResourceView '" + getBeanName() + "'");
			}
			rd.forward(requestToExpose, response);
		}
	}
exposeModelAsRequestAttributes(model, requestToExpose);核心方法，将model即Map结构设置进去request域中 
/**
	 * Expose the model objects in the given map as request attributes.
	 * Names will be taken from the model Map.
	 * This method is suitable for all resources reachable by {@link javax.servlet.RequestDispatcher}.
	 * @param model Map of model objects to expose
	 * @param request current HTTP request
	 */
	protected void exposeModelAsRequestAttributes(Map<String, Object> model, HttpServletRequest request) throws Exception {
		for (Map.Entry<String, Object> entry : model.entrySet()) {
			String modelName = entry.getKey();
			Object modelValue = entry.getValue();
			if (modelValue != null) {
				request.setAttribute(modelName, modelValue);
				if (logger.isDebugEnabled()) {
					logger.debug("Added model object '" + modelName + "' of type [" + modelValue.getClass().getName() +
							"] to request in view with name '" + getBeanName() + "'");
				}
			}
			else {
				request.removeAttribute(modelName);
				if (logger.isDebugEnabled()) {
					logger.debug("Removed model object '" + modelName +
							"' from request in view with name '" + getBeanName() + "'");
				}
			}
		}
	}

org.springframework.web.servlet.view.InternalResourceViewResolver类即是在spring-mvc.xml中配置的视图解析器

	<!-- 视图解析器
	解析jsp解析，默认使用jstl标签，classpath下的得有jstl的包
	 -->
	<bean
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<!-- 配置jsp路径的前缀 -->
		<property name="prefix" value="/WEB-INF/jsp/"/>
		<!-- 配置jsp路径的后缀 -->
		<property name="suffix" value=".jsp"/>
	</bean>






JAVA_DIRECTION
关注
专栏目录
Spring MVC的流程及源码分析
BorisCao的博客
04-27 1161
1.Spring MVC通过前置控制器DispatcherServlet处理客户端请求,这里用到了DispatcherServlet的doService方法中的doDispatch DispatcherServlet.java protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception { logRequest(request);` .....省略其他代码 t
spring MVC原理
yingxiongtnt的专栏
04-13 1016
Spring MVC工作流程图   图一   图二   Spring工作流程描述 1. 用户向服务器发送请求，请求被Spring 前端控制Servelt DispatcherServlet捕获； 2.DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI）。然后根据该URI，调用HandlerMapping获得该Handler配置的所有相关...
springMVC核心源码解析 ---请求执行流程，前后端分离场景一看就懂
最新发布
weixin_48296576的博客
08-04 925
SpringMVC源码解读，用到的环境是SpringBoot项目
SpringMVC的工作原理的解释和它的流程图
u011738183的专栏
11-06 1779
SpringMVC的工作原理的解释和它的流程图
SpringMVC的工作流程源码解读
李哈zzz的博客
01-05 765
SpringMVC工作流程超级仔细的源码解读，1、用户发送请求首先会到SpringMVC中央处理器dispatcherServlet接收到请求，2、HandleMapping解析请求，3、HandleAdpater执行请求返回ModelAndView，4、ViewResolver视图解析器解析ModelAndView返回View，5、View获取真正的视图返回给dispatcherServlet，6、dispatcherServlet返回给前段！
springmvc工作流程（一）（源码解读）
西木风落
12-23 478
springmvc是对servlet的封装，核心的DispatcherServlet最终继承自HttpServlet。同时，springmvc做为spring家族一员，将和web相关的处理器托付给springmvc容器，使得对象的管理和spring保持一致。
SpringMVC源码剖析（三）- DispatcherServlet的初始化流程1
08-03
理解这一流程有助于我们更好地掌握SpringMVC的工作原理，从而在实际开发中更有效地利用这个框架。通过深入研究SpringMVC的源码，我们可以发现更多关于依赖注入、AOP、资源管理等方面的高级概念，这对于提升我们的...
SpringMVC源码剖析（一）- 从抽象和接口说起1
08-03
总的来说，SpringMVC通过核心接口和组件的协同工作，解决了Web开发中URL映射、请求参数绑定和响应生成等关键问题。通过源码分析，我们可以更好地理解其设计哲学，从而更高效地利用SpringMVC进行Web应用的开发。在...
Java进阶之SpringMVC源码深度剖析共12页.pd
11-20
本资料“Java进阶之SpringMVC源码深度剖析共12页.pdf”是对SpringMVC核心原理的深入探讨，通过分析源码来帮助开发者更深入地理解其工作原理。 1. **SpringMVC概述** SpringMVC是Spring框架的一个模块，主要负责...
SpringMVC源码剖析（二）- DispatcherServlet的前世今生1
08-03
【SpringMVC源码剖析（二）- DispatcherServlet的前世今生1】 在Spring MVC框架中，DispatcherServlet扮演着至关重要的角色，它是整个框架的核心。本文将深入探讨DispatcherServlet的两个核心设计原则及其在Spring ...
SpringMVC源码剖析（四）- DispatcherServlet请求转发的实现1
08-03
然而，这也意味着Spring MVC的应用在某种程度上受限于Servlet容器，如果想要在非Servlet环境（如非Java平台）运行，可能需要额外的适配工作。 总的来说，Spring MVC通过DispatcherServlet实现了高效且灵活的请求...
SpringMVC工作流程源码剖析
代码宇宙
03-14 534
原文链接： https://juejin.im/post/5e6b0ee3e51d4526f65cdb50. 0x0 先看名词 DispactherServlet：SpringMVC 的心脏，所有的请求从这里进入，也从这里出去 HandlerAdapter：请求处理器 HandlerMapping:请求和处理对象间的映射关系，可以理解为 地址 /api 对应 @RequestMapping("/...
springmvc工作流程以及相关源码解析
cb_lcl的博客
06-23 1173
springmvc经典流程图：图一图二SpringMVC流程1、  用户发送请求至前端控制器DispatcherServlet。web.xml中配置DispatcherServlet，如图：2、  DispatcherServlet收到请求调用HandlerMapping处理器映射器。HandlerMapping定义请求和处理程序对象之间的映射。其中： RequestMappingHandlerM...
SpringMVC的工作流程和源码分析
JinKin_OldWang的博客
03-20 367
SpringMVC框架是一个基于请求驱动的Web框架，并且使用了‘前端控制器’模型来进行设计，再根据‘请求映射规则’分发给相应的页面控制器进行处理。 整体流程 具体步骤： 1、 首先用户发送请求到前端控制器，前端控制器根据请求信息（如 URL）来决定选择哪一个页面控制器进行处理并把请求委托给它，即以前的控制器的控制逻辑部分；图中的 1、2 步骤； 2、 页面控制器接收到请求后，进行...
SpringMVC执行流程（源码分析）
qq_43600166的博客
10-16 1615
SpringMVC大体流程，请求URL如何与HandlerMethod对应？AbstractHandlerMethodMapping初始化HandlerMethod。源码分析AbstractHandlerMethodMapping初始化HandlerMethod流程。一个请求到SpringMVC的完整流程，DispatcherServlet如何接收用户请求？ 分析DispatchServlet.doDispatch方法如何处理请求
SpringMVC 执行流程源码解析
weixin_42346558的博客
12-16 419
文章目录前言一、DispatcherServlet1、doServcie2、doDispatch3、getHandler3、getHandlerAdapter二、AbstractHandlerMapping1、getHandler三、RequestMappingHandlerMapping1、afterPropertiesSet2、initHandlerMethods3、detectHandlerMethods3、getHandlerInternal4、lookupHandlerMethod总结 办公设备租
springmvc项目在启动完成之后执行一次方法_SpringMVC源码分析
weixin_39558804的博客
11-26 542
一 SpringMVC运行原理二 SpingMVC源码分析1 DispatcherServlet1.1 DispatcherServlet继承结构ServletConfig对象获取Init标签中的配置信息1.1.1 HttpServletBean HttpServletBean复习了init方法，主要做一些初始化的工作麻将web.xml中配置的参数 设置到Servlet...
springmvc的工作流程源码
蒋蒋
08-28 125
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception { HttpServletRequest processedRequest = request; HandlerExecutionChain mappedHandler = null; ...
SpringMVC源码分析
长沙老码农
01-22 3022
目录 1、SpringMVC架构图 2、SpringMVC初始化流程图 3、SpringMVC执行流程图 4、SpringMVC组件解析 5、SpringMVC的工作机制 6、源码分析 6.1 初始化流程 6.2 请求执行流程 7、谈谈SpringMVC的优化 1、SpringMVC架构图 2、SpringMVC初始化流程图 3、SpringMVC执行流程图 用户发送请求至前端控制器DispatcherServlet。 DispatcherServl.
SpringMVC执行流程详解：深度剖析与入门指南
通过源码分析、编译器断点调试以及Spring核心类的UML图，作者帮助读者深入理解了SpringMVC的工作原理，这对于学习者理解和使用SpringMVC框架具有实际的指导意义。通过了解这个执行流程，开发者能够更好地组织代码，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值