SpringMvc-初识DispatcherServlet

最新推荐文章于 2024-03-15 02:46:18 发布
最新推荐文章于 2024-03-15 02:46:18 发布
阅读量155 收藏
点赞数
分类专栏： Spring mvc 源码 文章标签： DispatcherServlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40852944/article/details/102606140
版权 
    DispatcherServlet作为MVC核心控制器，今天主要了解一下它及它的父类，我们都知道，spring mvc都是基于servlet实现的，下图为他们之间的关系：

Servlet 主要是接口方法定义，从该类中也可以很明了的知道servlet的生命周期，分别为：

  1. public void init(ServletConfig config) throws ServletException;
  2. public void service(ServletRequest req, ServletResponse res)
        throws ServletException, IOException;
  3. public void destroy();
GenericServlet 抽象类则是对Servlet，及ServletConfig的简单实现，最主要的变化是在init方法的实现上，接收了serveltConfig的配置，暴露给子类无参的init方法
public void init(ServletConfig config) throws ServletException {
        this.config = config;
        this.init();
    }

public void init() throws ServletException {
    }
   public void destroy() {
    }

HttpServlet 是对service()方法的实现，根据req.getMethod()判断请求为get,post,delete,put...，从而外接调用直接继承HttpServlet类，并且实现对应的doGet()，doPost()，doDelete....方法
protected void service(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        String method = req.getMethod();

        if (method.equals(METHOD_GET)) {
            long lastModified = getLastModified(req);
            if (lastModified == -1) {
                doGet(req, resp);
            } else {
                long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                if (ifModifiedSince < (lastModified / 1000 * 1000)) {
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                }
            }

        } else if (method.equals(METHOD_HEAD)) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);

        } else if (method.equals(METHOD_POST)) {
            doPost(req, resp);

        } else if (method.equals(METHOD_PUT)) {
            doPut(req, resp);

        } else if (method.equals(METHOD_DELETE)) {
            doDelete(req, resp);

        } else if (method.equals(METHOD_OPTIONS)) {
            doOptions(req, resp);

        } else if (method.equals(METHOD_TRACE)) {
            doTrace(req, resp);

        } else {
            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);

            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
        }
    }

上述都为java对外包括的Servlet,而spring mvc是如何基于它封装的呢？？？继续往下看

HttpServletBean抽象类，第一眼看到了什么Bean就很有Spring的感觉了~，自己的理解是，要先将HttpServlet封装成一个可以在spring框架内使用的bean对象，具体它做了啥？
public abstract class HttpServletBean extends HttpServlet implements EnvironmentCapable, EnvironmentAware {
	
	protected final Log logger = LogFactory.getLog(getClass());

	private final Set<String> requiredProperties = new HashSet<String>();

	private ConfigurableEnvironment environment;
	
	protected final void addRequiredProperty(String property) {
		this.requiredProperties.add(property);
	}

	@Override
	public final void init() throws ServletException {
		try {
			PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
			BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
			ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
			bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
			initBeanWrapper(bw);
			bw.setPropertyValues(pvs, true);
		}
		catch (BeansException ex) {
			if (logger.isErrorEnabled()) {
				logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
			}
			throw ex;
		}
		initServletBean();
	}
	
	protected void initBeanWrapper(BeanWrapper bw) throws BeansException {
	}

	protected void initServletBean() throws ServletException {
	}

}
  1. 继承了HttpServlet，实现了EnvironmentCapable, EnvironmentAware两个接口，主要为bean属性环境配置初始化做了抽象封装；
  2. init的方法用了final修饰，表示Spring中的对象继承HttpServletBean后，就不需要再去实现Servlet中的init方法了，如果想实现，则暴露了initServletBean()方法；
  3. 并且对外暴露initBeanWrapper()方法用于对bean包装的处理
FrameworkServlet抽象类则是对HttpServletBean的继承，实现ApplicationContextAware接口
  1. 注入应用上下文
@Override
	public void setApplicationContext(ApplicationContext applicationContext) {
		if (this.webApplicationContext == null && applicationContext instanceof WebApplicationContext) {
			this.webApplicationContext = (WebApplicationContext) applicationContext;
			this.webApplicationContextInjected = true;
		}
	}

 对 HttpServletBean中暴露出来的initServletBean进行了final实现，并且调用了initFrameworkServlet（）方法；

@Override
	protected final void initServletBean() throws ServletException {
		
		long startTime = System.currentTimeMillis();

		try {
			this.webApplicationContext = initWebApplicationContext();
			initFrameworkServlet();
		}
		catch (ServletException ex) {
			this.logger.error("Context initialization failed", ex);
			throw ex;
		}
		catch (RuntimeException ex) {
			this.logger.error("Context initialization failed", ex);
			throw ex;
		}
	}

initWebApplicationContext()方法则是对应用的上下文bean做初始化，其中会调用onRefresh（）方法，在看Spring的源码时，貌似也有onRefresh()方法，该方法主要会对bean做初始化，此处的onRefresh也是这个意思，只是初始化的是，mvc的bean对象

protected WebApplicationContext initWebApplicationContext() {
		WebApplicationContext rootContext =
				WebApplicationContextUtils.getWebApplicationContext(getServletContext());
		WebApplicationContext wac = null;

		if (this.webApplicationContext != null) {
			
			wac = this.webApplicationContext;
			if (wac instanceof ConfigurableWebApplicationContext) {
				ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
				if (!cwac.isActive()) {
					
					if (cwac.getParent() == null) {
						cwac.setParent(rootContext);
					}
					configureAndRefreshWebApplicationContext(cwac);
				}
			}
		}
		if (wac == null) {
			wac = findWebApplicationContext();
		}
		if (wac == null) {
			wac = createWebApplicationContext(rootContext);
		}

		if (!this.refreshEventReceived) {
			onRefresh(wac);
		}

		if (this.publishContext) {
			String attrName = getServletContextAttributeName();
			getServletContext().setAttribute(attrName, wac);
			if (this.logger.isDebugEnabled()) {
				this.logger.debug("Published WebApplicationContext of servlet '" + getServletName() +
						"' as ServletContext attribute with name [" + attrName + "]");
			}
		}

		return wac;
	}

protected void onRefresh(ApplicationContext context) {
		// For subclasses: do nothing by default.
	}

同时，对destory方法做了实现，在应用关闭时，做一些资源关闭处理

@Override
	public void destroy() {
		getServletContext().log("Destroying Spring FrameworkServlet '" + getServletName() + "'");
		// Only call close() on WebApplicationContext if locally managed...
		if (this.webApplicationContext instanceof ConfigurableApplicationContext && !this.webApplicationContextInjected) {
			((ConfigurableApplicationContext) this.webApplicationContext).close();
		}
	}

实现了service，并且用final修饰符实现了doGet,doPost,doDelete,do....，他们最终都跳转到processRequest()中进行处理；

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

		HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
		if (HttpMethod.PATCH == httpMethod || httpMethod == null) {
			processRequest(request, response);
		}
		else {
			super.service(request, response);
		}
	}

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

		processRequest(request, response);
	}
    
    @Override
	protected final void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		processRequest(request, response);
	}

    ...

 而final修饰的processRequest的处理，经过前期处理后最终调到doService()抽象方法

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 = buildRequestAttributes(request, response, previousAttributes);

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

		initContextHolders(request, localeContext, requestAttributes);

		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();
			}

			publishRequestHandledEvent(request, response, startTime, failureCause);
		}
	}

protected abstract void doService(HttpServletRequest request, HttpServletResponse response)
			throws Exception;

最后最后。。。核心类DispatcherServlet终于登场了，它集成FrameworkServlet

首先它实现了onRefresh()方法，这里也是mvc中bean初始化的顺序所在

    @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);
	}

 

其次他实现了doService()方法，也就是基本上所有的服务请求过来，都会到达这里，并且进行处理。

@Override
	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
		if (logger.isDebugEnabled()) {
			String resumed = WebAsyncUtils.getAsyncManager(request).hasConcurrentResult() ? " resumed" : "";
			logger.debug("DispatcherServlet with name '" + getServletName() + "'" + resumed +
					" processing " + request.getMethod() + " request for [" + getRequestUri(request) + "]");
		}

		// 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)) {
			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()) {
				// Restore the original attribute snapshot, in case of an include.
				if (attributesSnapshot != null) {
					restoreAttributesAfterInclude(request, attributesSnapshot);
				}
			}
		}
	}

 

 

 
 
 
weixin_40852944
关注
专栏目录
如何在web.xml里配置spring容器
sdzhangshulong的博客
01-07 649
springmvc   org.springframework.web.servlet.DispatcherServlet     contextConfigLocation   classpath:applicationContext.xml     1       springmvc   *.do
SpringMVC - 初识
最新发布
mjb709的专栏
08-11 1171
Spring MVC是一个创建Web应用程序的框架，它是遵循Model-View-Controller的设计模式。Spring MVC通过DispatcherServlet来接收请求，然后对应对具体的controllers, models和views.
浅谈SpringMVC之DispatcherServlet
weixin_34238633的博客
01-22 127
2019独角兽企业重金招聘Python工程师标准>>> ...
spring-mvc
u014605300的博客
01-16 313
3.1、DispatcherServlet作用 DispatcherServlet是前端控制器设计模式的实现，提供Spring Web MVC的集中访问点，而且负责职责的分派，而且与Spring IoC容器无缝集成，从而可以获得Spring的所有好处。 具体请参考第二章的图2-1。 DispatcherServlet主要用作职责调度工作，本身主要用于控制流程，主要职责如下： ...
SpringMVC--DispatcherServlet
厚积薄发
04-18 5955
DispatcherServlet是前端控制器设计模式的实现。提供SpringMVC集中访问点，而且负责职责的分派，并且与Spring IOC 容器无缝集成，从而可以获得Spring所有的优点。如下图： DispatcherServlet主要的职责是调度，本身主要用于控制流程： 1，文件上传解析 2，通过HandlerMapping，将请求映射到处理（返回一个HandlerExecu
SpringMvc丨DispatcherServlet
爱媳妇儿爱编程
09-08 5181
​ ​ DispatcherServlet 是一个 Servlet，它继承自 javax.servlet.http.HttpServlet 类，并由 Spring MVC 框架提供和管理，它负责将客户端请求映射到相应的控制器，然后调用控制器处理请求并返回响应结果。DispatcherServlet 是一个 Servlet，它继承自 javax.servlet.http.HttpServlet 类，并由 Spring MVC 框架提供和管理。
SpringMVC---初识SpringMVC
本人随手记录，内容只是个人看懂程度，对内容有任何疑问请勿打扰
05-04 164
什么是SpringMVC 建议百度 SpringMVC的使用 在JavaWeb开发中，我们需要创建Servlet然后去web.xml去注册。 而在SpringMVC中，用controller去代替了Servlet，而且也不再需要去web.xml去注册了。 但还是要去web.xml注册配置DispatchServlet这个类。 DispatchServlet SpringMVC的核心：请求分发器，前端控制器。 按照JavaWeb的理解就是，这个类帮我们去注册Servlet。 再SpringMVC中也就是帮我们
初识SpringMVC--利用SpringMVC实现请求和响应的原理
weixin_44976835的博客
01-02 357
特点： 1. 轻量级、简单易学 2. 高效、基于请求响应的MVC框架 3. 与Spring兼容性好 4. 约定大于配置 5. 功能强大 6. 简洁灵活 底层基于DispatcherServlet 下面用一个SpringMVC程序来说明SpringMVC原理 首先在父项目中导入依赖： <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>
springMVC源码研究--初识篇1 / 2（springboot 自动化配置springMVC以及mvc初始化机制）
一个有梦想的男人
01-09 226
最近使用springboot 做微服务开发，对外提供的都是http接口，那么就来研究下springMvc。 Servlet 是web容器对http请求进行处理的基本集成单元，应用程序处理的所有请求都是通过servlet转发controller里面对应的方法上的， 那么： springboot是怎么样自动配置启用了springMvc功能？ springmvc是怎么做到的接受servlet转发的...
初识SpringMVC以及springmvc基本应用入门案例彩色PPT版本.pptx
05-29
1. 容器初始化：SpringMVC 会初始化 DispatcherServlet，加载配置文件，扫描并实例化所有 Controller 类。 2. 单次请求工作流程：当收到 HTTP 请求时，DispatcherServlet 会根据请求路径查找匹配的 HandlerMapping，...
spring mvc -- DispatcherServlet
lerist的专栏
04-13 286
Spring的web mvc框架跟其他web mvc框架一样，请求驱动，围绕一个中心Servlet设计。Servlet分发请求到控制器，并且提供其他功能，使得web应用开发便捷。但是，Spring的DispatcherServlet做的不仅仅是这些，它整合了Spring的IoC容器，这样我们就可以使用Spring其它特点。Spring Web MVC DispatcherServlet请求处理流如...
SpringMVC-DispatcherServlet
LexNg的博客
08-01 680
dispatcherServlet在spring中充当前端控制器的角色，核心功能分发请求。 1、Handle：用于处理dispatcherServlet分发的请求的Java类 注册成为Handle： （1）早期：实现org.springframework.web.servlet.mvc.Controller接口并实现handleRequest方法; ModelAndView handleR
Spring MVC（一）— DispatcherServlet
KEEP CODING
03-15 991
DispatcherServlet 是Spring MVC框架的HTTP 请求处理器的中央调度器。它具有以下的功能： 1）基于IoC容器JavaBean配置机制。 2）使用HandlerMappingl来实现请求到处理器的路由映射。 3）使用HandlerAdapter 来处理不同的处理器。 4）处理器抛出的异常解决策略由HandlerExceptionResolver指定。 5）视图解析策略可以通过ViewResolver实现指定。 6）文件上传策略通过MultipartResolver来确
游戏思路借鉴三——贪吃蛇他来了！（一）
小杜爱吃肉
12-06 281
如果学计算机不是为了开心，那还有什么意义。结束了vb的全部课程，闲来无事也可以做一做小游戏来放松一下，下面就是我利用空闲时间制作的一款贪吃蛇小游戏，我将会还原整个制作过程，再一次体会小蛇所体现出来的计算机思想 效果视频，没有录屏软件，只能手机拍了 最开始我们要完成以下基础工作： 1使用绘画line画蛇 2绘画史一节一节的画出来 3确定每一节????身的位置 4切丁每一节蛇身的长度 我们利用line函数来画出蛇来，大家都知道line可以画矩形，所所以一届一届的蛇身我们就用line来画就好了，这时候，我们还需要
【Spring】抽丝剥茧SpringMVC-DispatcherServlet
beFocused的博客
11-30 393
DispatcherServlet 使用SpringMVC框架的同学一定知道DispatcherServlet。SpringMVC处理Http请求就是从DispatcherServlet开始。SpringMC简化了Servlet规范的开发模式，定义了通用了Servlet(DispatcherServlet)与Servlet容器(jetty/tomcat)交互。开发者专注于业务逻辑的开发。下图是DispatcherServlet的类图 可以看出DispatcherServlet其实就是...
SpringMVC之DispatcherServlet（一）
热门推荐
业精于勤荒于嬉 行成于思毁于随
02-18 1万+
上一篇介绍了ContextLoaderListener，作用就是容器启动时创建WebApplicationContext存储在ServletContext中。本文将介绍SpringMVC核心DispatcherServlet，它是Servlet接口的实现类 Servlet是一个Java编写的程序，基于Http协议，在服务端运行，主要处理客户端的请求并将结果发送给客户端。其生命周期由Servlet...
SpringMVC源码之DispatcherServlet
wangjianren0000的博客
03-06 183
DispatcherServlet是SpringMVC的核心类，所有其他的组件如拦截器，适配器，视图解析器等都是在这个servlet中应用，所以明白DispatcherServlet的初始化流程以及执行请求的流程就很重了。基于自己看的源码和自己的理解，写一个关于SpringMVC的小系列，如有错误，望各位看官不吝赐教! 1.DispatcherServlet 的继承体系如下： ...
SpringMVC源码分析之DispatcherServlet
Dreamer.
07-23 445
SpringMVC核心就是DispatcherServlet，被称为前端控制器，所有请求都会转发到DispatcherServlet，然后再通过DispatcherServlet执行具体的控制层，最后返回modelAndView给客户端视图展示。 SpringMVC中常用的几个概念，处理器映射器（HandlerMapping）、处理器适配器（HandlerAdapter）和视图解析器（ViewR...
Spring MVC —— 关于 DispatcherServlet
小水牛的博客
03-08 1634
DispatcherServlet
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值