Tomcat请求处理(五) -- 请求在容器间的流动

最新推荐文章于 2019-06-25 15:14:54 发布
最新推荐文章于 2019-06-25 15:14:54 发布
阅读量98 收藏
点赞数
分类专栏： Tomcat 文章标签： Tomcat Comet Servlet JSP Apache
请求在Tomcat中传到了CoyoteAdapter的#service()方法中后，就要准备进入Pipeline了，如#service()方法中的这句所示：
connector.getContainer().getPipeline().getFirst().invoke(request, response);

这里的Container是Engine，然后得到它的Pipeline对象，然后得到他的第一个Valve，如果没有配置的话第一个Valve就是Basic的了，这里就是org.apache.catalina.core.StandardEngineValve，最后调用了它的#invoke()方法，源代码如下所示： 

	public final void invoke(Request request, Response response) throws IOException,
			ServletException {

		// 获得Host对象
		Host host = request.getHost();
		if (host == null) {
			response.sendError(HttpServletResponse.SC_BAD_REQUEST, sm.getString(
					"standardEngine.noHost", request.getServerName()));
			return;
		}

		// 将请求传递给Host
		host.getPipeline().getFirst().invoke(request, response);

	}


这个Valve并没做什么实质性的东西，只是将请求继续传递，当然可以定义自己的Valve实现一些特殊的行为。
还是来继续请求的处理过程，和上边Engine的情况类似，请求这次到了org.apache.catalina.core.StandardHostValve的#invoke()方法，源代码如下所示： 

	public final void invoke(Request request, Response response) throws IOException,
			ServletException {

		// 获得Context对象
		Context context = request.getContext();
		if (context == null) {
			response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, sm
					.getString("standardHost.noContext"));
			return;
		}

		// 如果没有设置Loader，那么设置为context自己的ClassLoader
		if (context.getLoader() != null) {
			Thread.currentThread().setContextClassLoader(context.getLoader().getClassLoader());
		}

		// 将请求通过Pipeline给Context
		context.getPipeline().getFirst().invoke(request, response);

		if (Globals.STRICT_SERVLET_COMPLIANCE) {
			request.getSession(false);
		}

		// 处理错误页
		response.setSuspended(false);

		Throwable t = (Throwable) request.getAttribute(Globals.EXCEPTION_ATTR);

		if (t != null) {
			throwable(request, response, t);
		} else {
			status(request, response);
		}

		// 恢复ClassLoader
		Thread.currentThread().setContextClassLoader(StandardHostValve.class.getClassLoader());

	}

不出意外的，请求下边就到了org.apache.catalina.core.StandardContextValve，源代码如下： 

	public final void invoke(Request request, Response response) throws IOException,
			ServletException {

		// 不允许请求访问META-INF和WEB-INF文件夹下的内容。
		MessageBytes requestPathMB = request.getRequestPathMB();
		if ((requestPathMB.startsWithIgnoreCase("/META-INF/", 0))
				|| (requestPathMB.equalsIgnoreCase("/META-INF"))
				|| (requestPathMB.startsWithIgnoreCase("/WEB-INF/", 0))
				|| (requestPathMB.equalsIgnoreCase("/WEB-INF"))) {
			notFound(response);
			return;
		}

		// 如果系统正在重新载入中，那么暂停请求。
		boolean reloaded = false;
		while (context.getPaused()) {
			reloaded = true;
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				;
			}
		}

		// 如果正在重载，停止老的WebappClassLoader并创建一个新的
		if (reloaded && context.getLoader() != null && context.getLoader().getClassLoader() != null) {
			Thread.currentThread().setContextClassLoader(context.getLoader().getClassLoader());
		}

		// 获得Wrapper对象
		Wrapper wrapper = request.getWrapper();
		if (wrapper == null) {
			notFound(response);
			return;
		} else if (wrapper.isUnavailable()) {
			wrapper = (Wrapper) container.findChild(wrapper.getName());
			if (wrapper == null) {
				notFound(response);
				return;
			}
		}

		// 获得Listener列表
		Object instances[] = context.getApplicationEventListeners();

		ServletRequestEvent event = null;

		if ((instances != null) && (instances.length > 0)) {
			event = new ServletRequestEvent(((StandardContext) container).getServletContext(),
					request.getRequest());

			for (int i = 0; i < instances.length; i++) {
				if (instances[i] == null)
					continue;
				if (!(instances[i] instanceof ServletRequestListener))
					continue;
				ServletRequestListener listener = (ServletRequestListener) instances[i];
				try {
					// 调用请求初始化事件
					listener.requestInitialized(event);
				} catch (Throwable t) {
					container.getLogger().error(
							sm.getString("standardContext.requestListener.requestInit",
									instances[i].getClass().getName()), t);
					ServletRequest sreq = request.getRequest();
					sreq.setAttribute(Globals.EXCEPTION_ATTR, t);
					return;
				}
			}
		}

		// 调用Wrapper的Valve
		wrapper.getPipeline().getFirst().invoke(request, response);

		if ((instances != null) && (instances.length > 0)) {
			for (int i = 0; i < instances.length; i++) {
				if (instances[i] == null)
					continue;
				if (!(instances[i] instanceof ServletRequestListener))
					continue;
				ServletRequestListener listener = (ServletRequestListener) instances[i];
				try {
					// 调用请求结束事件
					listener.requestDestroyed(event);
				} catch (Throwable t) {
					container.getLogger().error(
							sm.getString("standardContext.requestListener.requestDestroy",
									instances[i].getClass().getName()), t);
					ServletRequest sreq = request.getRequest();
					sreq.setAttribute(Globals.EXCEPTION_ATTR, t);
				}
			}
		}

	}

这个Valve重要的是包括了对Listener的调用，最后来看一下Wrapper的Valve调用(org.apache.catalina.core.StandardWrapperValve)。 

public final void invoke(Request request, Response response) throws IOException,
			ServletException {

		boolean unavailable = false;
		Throwable throwable = null;

		long t1 = System.currentTimeMillis();
		requestCount++;
		// 获得Wrapper所关联的对象
		StandardWrapper wrapper = (StandardWrapper) getContainer();
		// Servlet对象
		Servlet servlet = null;
		// 获得Context对象
		Context context = (Context) wrapper.getParent();

		if (!context.getAvailable()) {
			response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, sm
					.getString("standardContext.isUnavailable"));
			unavailable = true;
		}

		if (!unavailable && wrapper.isUnavailable()) {
			container.getLogger().info(
					sm.getString("standardWrapper.isUnavailable", wrapper.getName()));
			long available = wrapper.getAvailable();
			if ((available > 0L) && (available < Long.MAX_VALUE)) {
				response.setDateHeader("Retry-After", available);
				response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, sm.getString(
						"standardWrapper.isUnavailable", wrapper.getName()));
			} else if (available == Long.MAX_VALUE) {
				response.sendError(HttpServletResponse.SC_NOT_FOUND, sm.getString(
						"standardWrapper.notFound", wrapper.getName()));
			}
			unavailable = true;
		}

		try {
			if (!unavailable) {
				// 分配一个Servelt实例
				servlet = wrapper.allocate();
			}
		} catch (UnavailableException e) {
			container.getLogger().error(
					sm.getString("standardWrapper.allocateException", wrapper.getName()), e);
			long available = wrapper.getAvailable();
			if ((available > 0L) && (available < Long.MAX_VALUE)) {
				response.setDateHeader("Retry-After", available);
				response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, sm.getString(
						"standardWrapper.isUnavailable", wrapper.getName()));
			} else if (available == Long.MAX_VALUE) {
				response.sendError(HttpServletResponse.SC_NOT_FOUND, sm.getString(
						"standardWrapper.notFound", wrapper.getName()));
			}
		} catch (ServletException e) {
			container.getLogger().error(
					sm.getString("standardWrapper.allocateException", wrapper.getName()),
					StandardWrapper.getRootCause(e));
			throwable = e;
			exception(request, response, e);
			servlet = null;
		} catch (Throwable e) {
			container.getLogger().error(
					sm.getString("standardWrapper.allocateException", wrapper.getName()), e);
			throwable = e;
			exception(request, response, e);
			servlet = null;
		}

		boolean comet = false;
		if (servlet instanceof CometProcessor
				&& request.getAttribute("org.apache.tomcat.comet.support") == Boolean.TRUE) {
			comet = true;
			request.setComet(true);
		}

		// 告知Request已经收到
		try {
			response.sendAcknowledgement();
		} catch (IOException e) {
			request.removeAttribute(Globals.JSP_FILE_ATTR);
			container.getLogger().warn(
					sm.getString("standardWrapper.acknowledgeException", wrapper.getName()), e);
			throwable = e;
			exception(request, response, e);
		} catch (Throwable e) {
			container.getLogger().error(
					sm.getString("standardWrapper.acknowledgeException", wrapper.getName()), e);
			throwable = e;
			exception(request, response, e);
			servlet = null;
		}
		MessageBytes requestPathMB = null;
		if (request != null) {
			requestPathMB = request.getRequestPathMB();
		}

		request.setAttribute(ApplicationFilterFactory.DISPATCHER_TYPE_ATTR,
				ApplicationFilterFactory.REQUEST_INTEGER);
		request.setAttribute(ApplicationFilterFactory.DISPATCHER_REQUEST_PATH_ATTR, requestPathMB);
		// 创建FilterChain
		ApplicationFilterFactory factory = ApplicationFilterFactory.getInstance();
		ApplicationFilterChain filterChain = factory.createFilterChain(request, wrapper, servlet);

		request.setComet(false);

		try {
			// web.xml中的<jsp-file>标签
			String jspFile = wrapper.getJspFile();
			if (jspFile != null)
				request.setAttribute(Globals.JSP_FILE_ATTR, jspFile);
			else
				request.removeAttribute(Globals.JSP_FILE_ATTR);

			// 调用Filter
			if ((servlet != null) && (filterChain != null)) {
				if (context.getSwallowOutput()) {
					try {
						SystemLogHandler.startCapture();
						if (comet) {
							filterChain.doFilterEvent(request.getEvent());
							request.setComet(true);
						} else {
							filterChain.doFilter(request.getRequest(), response.getResponse());
						}
					} finally {
						String log = SystemLogHandler.stopCapture();
						if (log != null && log.length() > 0) {
							context.getLogger().info(log);
						}
					}
				} else {
					if (comet) {
						request.setComet(true);
						filterChain.doFilterEvent(request.getEvent());
					} else {
						filterChain.doFilter(request.getRequest(), response.getResponse());
					}
				}

			}
			request.removeAttribute(Globals.JSP_FILE_ATTR);
		} catch (ClientAbortException e) {
			request.removeAttribute(Globals.JSP_FILE_ATTR);
			throwable = e;
			exception(request, response, e);
		} catch (IOException e) {
			request.removeAttribute(Globals.JSP_FILE_ATTR);
			container.getLogger().error(
					sm.getString("standardWrapper.serviceException", wrapper.getName()), e);
			throwable = e;
			exception(request, response, e);
		} catch (UnavailableException e) {
			request.removeAttribute(Globals.JSP_FILE_ATTR);
			container.getLogger().error(
					sm.getString("standardWrapper.serviceException", wrapper.getName()), e);

			wrapper.unavailable(e);
			long available = wrapper.getAvailable();
			if ((available > 0L) && (available < Long.MAX_VALUE)) {
				response.setDateHeader("Retry-After", available);
				response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, sm.getString(
						"standardWrapper.isUnavailable", wrapper.getName()));
			} else if (available == Long.MAX_VALUE) {
				response.sendError(HttpServletResponse.SC_NOT_FOUND, sm.getString(
						"standardWrapper.notFound", wrapper.getName()));
			}

		} catch (ServletException e) {
			request.removeAttribute(Globals.JSP_FILE_ATTR);
			Throwable rootCause = StandardWrapper.getRootCause(e);
			if (!(rootCause instanceof ClientAbortException)) {
				container.getLogger().error(
						sm.getString("standardWrapper.serviceException", wrapper.getName()),
						rootCause);
			}
			throwable = e;
			exception(request, response, e);
		} catch (Throwable e) {
			request.removeAttribute(Globals.JSP_FILE_ATTR);
			container.getLogger().error(
					sm.getString("standardWrapper.serviceException", wrapper.getName()), e);
			throwable = e;
			exception(request, response, e);
		}

		if (filterChain != null) {
			if (request.isComet()) {
				filterChain.reuse();
			} else {
				filterChain.release();
			}
		}

		// 释放Servlet对象
		try {
			if (servlet != null) {
				wrapper.deallocate(servlet);
			}
		} catch (Throwable e) {
			container.getLogger().error(
					sm.getString("standardWrapper.deallocateException", wrapper.getName()), e);
			if (throwable == null) {
				throwable = e;
				exception(request, response, e);
			}
		}

		try {
			if ((servlet != null) && (wrapper.getAvailable() == Long.MAX_VALUE)) {
				wrapper.unload();
			}
		} catch (Throwable e) {
			container.getLogger().error(
					sm.getString("standardWrapper.unloadException", wrapper.getName()), e);
			if (throwable == null) {
				throwable = e;
				exception(request, response, e);
			}
		}
		long t2 = System.currentTimeMillis();

		long time = t2 - t1;
		processingTime += time;
		if (time > maxTime)
			maxTime = time;
		if (time < minTime)
			minTime = time;

	}

这段代码的关键点是Servlet实例的构建(servlet = wrapper.allocate();)和Filter Chain的调用(filterChain.doFilter(request.getRequest(), response.getResponse());)，具体的还要进入方法内部去仔细看一下。comet方式以后再详细看。
silvery_white
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Tomcat请求源码流程分析(图解及源码注释) (六)
hyc的博客
08-18 581
Tomcat源码系列: 本章为Tomcat请求解析流程的第二章,主要内容为在请求转交给Coyote适配器后的流程分析
tomcat源码解析-container
Forward__的博客
09-17 252
在tomcat中，容器主要分为四种，engine,host,context,wrapper。在详细分析tomcat源码之前，我们先来看看容器的类继承层级是怎样的。 这里，我们先说明一下容器的包含关系。engine包含多个host,host包含多个context,context包含多个wrapper,每个wrapper对应一个servlet。 engine,我们可以看成是容器对外提供功能的入口，每个Engine是Host的集合，用于管理各个Host。 Host，我们可以看成虚拟主机，一个tomcat可以支
Tomcat对HTTP请求的处理(三)
weixin_30511107的博客
02-04 300
摘要：本文主要介绍了tomcat内部处理HTTP请求的Container部分,即剩余的部分 上一篇文章讲到CoyoteAdapter对HTTP请求的处理,主要查看了postParseRequest()方法对request的处理填充。我们继续往下看： //代码清单1 // Parse and set Catalina and configuration specific // request par...
tomcat-redis-session-manager for tomcat8.5
11-14
文件名写错了，此压缩文件支持tomcat8.5。是否支持8.0请自行测试，本人只测试了8.5，可以使用。压缩文件包括tomcat-redis-session-manager-...apache-tomcat-8.5.33.tar.gz，nginx-1.6.2.tar.gz也打包进去，一步到位。
tomcat-embed-el-9.0.16.jar
01-08
tomcat-embed-el-9.0.16.jar
tomcat-redis-session-manager-2.0.0.jar
04-26
tomcat-redis-session-manager-2.0.0.jar
Tomcat处理请求.vsdx
05-30
Tomcat处理请求.vsdx
tomcat-redis-session-manager jar包
12-20
使用tomcat-redis-session-manager进行统一session管理所需jar包，包括tomcat6-jdk6、tomcat7-jdk7、tomcat8-jdk8
Tomcat请求处理(三) -- coyote请求处理
臭美
12-19 594
在上一篇文章文章中，Tomcat的请求处理到了JIoEndpoint$Worker#run()方法的handler.process(socket)这个调用中。 这个handler在JIoEndpoint中是这样定义的： [code="java"]protected Handler handler = null;[/code] 这个Handler是在JIoEndpoint内部定义...
tomcat启动(Ⅷ)--请求最终目的地 getContainer().getPipeline().getFirst().invoke(request, response)...
weixin_30251587的博客
11-14 244
当tomcat的Conector保存着StandardService实例，而StandardService保存着Container的实例 当Http11NioProcessor.process()方法内调用getAdapter.service(request,response)时会调用CoyoteAdapter.service() 上面会调用请求对应的container的方法。 在这之前有...
Tomcat源码分析（四）------ Request和Response处理的全过程
热门推荐
走向架构师之路
12-28 1万+
从Tomcat源码分析（二）可知，用户的一个请求会经过n个环节的处理，最后到达开发人员写的Servlet，传给Servlet也就是HttpServletRequest和HttpServletResponse，因此可以认为这一路走下来无非就是把最原始的Socket包装成Servlet里用到的HttpServletRequest和HttpServletResponse，只不过每个环节完成的包装功能和部
tomcat请求处理分析(六)servlet的处理过程
jack_Zheng的博客
08-19 1011
1.1.1.1  servlet的解析过程 servlet的解析分为两步实现，第一个是匹配到对应的Wrapper,第二个是加载对应的servlet并进行数据，这些数据是怎么到界面的，response.getWrite()获取对应的流，然后写入这个流中，这个流中就有上文的outputBuffer。 匹配到对应Wrapper        在上文中我们曾经走到过了doRun方法，现在就直接从
Tomcat之session详解
马万明的专栏
08-17 5899
深入Tomcat源码分析Session到底是个啥! Session到底是个啥？ 我们都知道，HTTP协议本身是无状态的(Stateless)，这对于一些简单的页面展示来说，功能足够，不受影响。而对于日渐复杂的动态页面、应用，各种需要登录认证等场景，就力不从心了。试想对于一个已经登录的用户仍然一次次的提示登录，会是什么感受呢？ 因此，多数需要保持
Tomcat源码---请求处理四(1)
dxsksk的专栏
03-25 107
   一,现在到了StandardWrapperValve#invoke下,现在才算是真正的调用,主要实现了对servlet,filter执行   /** * Invoke the servlet we are managing, respecting the rules regarding * servlet lifecycle and SingleThreadMo...
[Tomcat源码系列]结构解析 3）请求处理控制结构
potato123的博客
03-28 113
一、请求处理控制结构基础      与生命期结构类似，请求处理也是一个两层的结构 1.Valve：Valve是最小的处理单元，我们看看Valve的定义 A Valve is a request processing component associated with a particular Container. A series of Valves are generally assoc...
tomcat原理解析(七)：执行servlet
qiangcai的专栏
06-07 2683
一 概述   前面章节已经说到http的请求到达了管道处理。最后的一个管道是StandardWrapper中的管道，它最后的阀门是StandardWrapperValve，阀门中的invoke代码 主要做了两件事情：1.执行过滤器链，2调用http请求servlet的service方法。 二过滤器 这里再次贴下invoke中的代码，部分省略掉： @Override p
tomcat & spring-ecurity异常处理流程
dark
06-25 614
框架准备 自定义Filter public class HttpMethodAllowedFilter extends OncePerRequestFilter { @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain fil...
tomcat7下载tomcat-redis-session-manager
最新发布
09-12
注意：在下载和安装Tomcat-Redis-Session-Manager时，需要确保Tomcat版本与Tomcat-Redis-Session-Manager的兼容性。同时，根据自己的需求，可以对Tomcat-Redis-Session-Manager进行进一步的配置和调整。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值