spring boot项目06：Web请求探秘-整个过程

JDK 8

Spring Boot 2.4.5

Eclipse Version: 2021-03 (4.19.0)

---

今天安排了一个任务：调查Spring Web（Servlet、Tomcat、HTTP 1.1）应用的 HTTP请求是怎么处理的，于是，熬夜（start at 00:41）到现在才终于了解了整个流程。

目标是了解 GET、POST 两种请求的处理过程，结果，忙活了一天，就把 GET 探究了一遍，POST的，大概差不多吧，不同请求方法小地方有差别。

准备：

1、会使用Eclipse进行调试（会其它IDE调试也行，或许效果更好，Step Into/Over/Return）

2、打开Spring Boot项目的调试日志（命令行添加 --debug，够了，，如果使用 --trace，会处理不过来）

3、知识储备：Java NIO相关，比如，selectKey之类的——调试到Poller、Connector时需要。

DispatcherServlet，久闻其名，未见其真容，今天算是“见面”了。除了它，还有FrameworkServlet、HttpServlet等。

public abstract class GenericServlet implements Servlet, ServletConfig,
        java.io.Serializable {
}

public abstract class HttpServlet extends GenericServlet {
}

public abstract class HttpServletBean extends HttpServlet implements EnvironmentCapable, EnvironmentAware {
}

public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
}

public class DispatcherServlet extends FrameworkServlet {
}

关系大概如下：依次继承extends

注：

上面的DispatcherServlet、FrameworkServlet 属于 package org.springframework.web.servlet，而HttpServlet 属于package javax.servlet.http。

思路：

DispatcherServlet中有两个函数比较出名：doDispatch、doService，于是，端点就从这两个函数开始设置；

然后，沿着这两个请求一直找函数调用方；

直到，涉及到 org.apache.tomcat.util.net.NioEndpoint#Poller、org.apache.catalina.connector.Connector 的使用时停止——到这里就很难调试下去了。

调试步骤：

0、设置各种端点——从DispatchServlet类开始，整个过程中，自己设置了几十个断点（有些不会用到）；

1、Eclipse中以调试模式启动项目（调试时可以使用快捷键）；

2、使用 Postman 访问准备的接口；

	@GetMapping("hello")
	public String hello(@RequestParam(value="name", defaultValue = "World") String name) {
		return String.format("Hello, %s", name);
	}

注：写文章前最后一次调试耗时近 2小时！（太费精时了！）

3、重复上面的步骤，直到找到一个请求被 Spring Web 处理的完整路径。

打开Postman，发送GET请求，此时 Postman、Eclipse展示如下：

- 请求在调试结束前，一直处于发送状态

- 发出请求，停止了第一个断点位置——AbstractProtocol 类的 process 函数，左边可以看到对应线程的调用栈（stack），在右边（下图未展示），还可以看到当前的变量（鼠标放到变量上也可以看到）。

当前方法变量表——可以看变量的值：

接下来，开始各种执行各种调试命令，出发！

……若干小时后……

调查结果

public abstract class AbstractProtocol<S> implements ProtocolHandler, MBeanRegistration {
    protected static class ConnectionHandler<S> implements AbstractEndpoint.Handler<S> {
        public SocketState process(SocketWrapperBase<S> wrapper, SocketEvent status) {
			Processor processor = (Processor) wrapper.getCurrentProcessor();
			processor = recycledProcessors.pop();
			processor = getProtocol().createProcessor(); // Http11NioProtocol, Http11Processor
			wrapper.setCurrentProcessor(processor); // NioEndpoint#NioSocketWrapper
			state = processor.process(wrapper, status);
				AbstractProcessorLight#process
					status == SocketEvent.OPEN_READ
					|
					state = service(socketWrapper); // Http11Processor#service
						setSocketWrapper(socketWrapper);
							super.setSocketWrapper(socketWrapper);
						prepareRequestProtocol(); // Http11Processor
						getAdapter() // CoyoteAdapter
							.service(request, response); // CoyoteAdapter#service
								connector.getService() // StandardService
									.getContainer() // StandardEngine
										.getPipeline() // StandardPipeline
											.getFirst() // StandardEngineValve
												.invoke(request, response); // StandardEngineValve#invoke
													host.getPipeline().getFirst().invoke(request, response); // ErrorReportValve#invoke ?
														getNext().invoke(request, response); // StandardHostValve#invoke
															Context context = request.getContext(); // TomcatEmbeddedContext
															context.getPipeline().getFirst().invoke(request, response); // AuthenticatorBase#invoke
																getNext().invoke(request, response); // StandardContextValve#invoke
																	Wrapper wrapper = request.getWrapper(); // StandardWrapper
																	response.sendAcknowledgement(ContinueResponseTiming.IMMEDIATELY); // Response#action#ACK
																		hook.action(actionCode, param); // hook=Http11Processor
																			ack((ContinueResponseTiming) param);
																	wrapper.getPipeline().getFirst().invoke(request, response); // 最后一句，StandardWrapperValve#invoke
																		StandardWrapper wrapper = (StandardWrapper) getContainer(); // StandardWrapper
																		Context context = (Context) wrapper.getParent(); // TomcatEmbeddedContext
																		servlet = wrapper.allocate();
																		ApplicationFilterChain filterChain = 
																			ApplicationFilterFactory.createFilterChain(request, wrapper, servlet); // 5个 ApplicationFilterConfig
																		Container container = this.container; // StandardWrapper
																		filterChain.doFilter(request.getRequest(), response.getResponse()); // ApplicationFilterChain#doFilter
																			internalDoFilter(request,response);
																				ApplicationFilterConfig filterConfig = filters[pos++];
																				Filter filter = filterConfig.getFilter();
																				filter.doFilter(request, response, this); // OrderedCharacterEncodingFilter#doFilter // 第一次
																					doFilterInternal(httpRequest, httpResponse, filterChain); # CharacterEncodingFilter#doFilterInternal
																						String encoding = getEncoding(); // UTF-8
																						filterChain.doFilter(request, response); // 开始第二轮，Return
																		filterChain.doFilter(request.getRequest(), response.getResponse()); // ApplicationFilterChain#doFilter
																			TomcatEmbeddedContext
																			WebMvcMetricsFilter
																			filter.doFilter(request, response, this); // OncePerRequestFilter#doFilter
																				doFilterInternal(httpRequest, httpResponse, filterChain); // WebMvcMetricsFilter#doFilterInternal
																					filterChain.doFilter(request, response); // // ApplicationFilterChain#doFilter
																		filterChain.doFilter(request.getRequest(), response.getResponse()); // ApplicationFilterChain#doFilter
																			internalDoFilter(request,response);
																				FormContentFilter
																				filter.doFilter(request, response, this); // OncePerRequestFilter#doFilter
																					doFilterInternal(httpRequest, httpResponse, filterChain); // FormContentFilter
																						filterChain.doFilter(request, response);
																		filterChain.doFilter(request.getRequest(), response.getResponse()); // ApplicationFilterChain#doFilter
																			internalDoFilter(request,response);
																				RequestContextFilter
																				filter.doFilter(request, response, this);
																					doFilterInternal(httpRequest, httpResponse, filterChain); // RequestContextFilter
																						filterChain.doFilter(request, response);
																		filterChain.doFilter(request.getRequest(), response.getResponse()); // ApplicationFilterChain#doFilter
																			internalDoFilter(request,response);
																				WsFilter
																				filter.doFilter(request, response, this); // 不同！WsFilter#doFilter
																					chain.doFilter(request, response);
																		filterChain.doFilter(request.getRequest(), response.getResponse()); // ApplicationFilterChain#doFilter
																			internalDoFilter(request,response);
																				// 5个filter用完，继续向下执行
																				servlet.service(request, response); // servlet=DispatchServlet，实际执行HttpServlet#service
																					service(request, response); // 执行FrameworkServlet#service
																						super.service(request, response); // 执行 HttpServlet#service-长
																							doGet(req, resp); // GET请求，执行FrameworkServlet#doGet
																								processRequest(request, response);
																									initContextHolders(request, localeContext, requestAttributes);
																									doService(request, response); // 执行 DispatchServlet#doService
																										logRequest(request); // 打印第一条调试日志！
																										doDispatch(request, response); // 执行 DispatchServlet#doDispatch
																											mappedHandler = getHandler(processedRequest); // 第二条DEBUG日志, HandlerExecutionChain
																											HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler()); // RequestMappingHandlerAdapter, Spring容器中存在此Bean
																											mv = ha.handle(processedRequest, response, mappedHandler.getHandler()); // 执行 AbstractHandlerMethodAdapter#handle
																												return handleInternal(request, response, (HandlerMethod) handler); // 执行 RequestMappingHandlerAdapter#handleInternal
																													mav = invokeHandlerMethod(request, response, handlerMethod);
																														ServletWebRequest webRequest = new ServletWebRequest(request, response);
																														WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod); // ServletRequestDataBinderFactory
																														ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);// ModelFactory
																														ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod); // com.benzl.prj1.Prj1Application#hello(String)
																														AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response); // StandardServletAsyncWebRequest
																														WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request); // WebAsyncManager
																														invocableMethod.invokeAndHandle(webRequest, mavContainer); // ServletInvocableHandlerMethod#invokeAndHandle
																															Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs); // InvocableHandlerMethod#invokeForRequest
																																Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
																																	args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory); // HandlerMethodArgumentResolverComposite#resolveArgument
																																		HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
																																		return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory); // AbstractNamedValueMethodArgumentResolver#resolveArgument
																																			NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);
																																			handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);
																																return doInvoke(args);
																																	Method method = getBridgedMethod();  // 执行 HandlerMethod#getBridgedMethod
																																	return method.invoke(getBean(), args); // getBean()=com.benzl.prj1.Prj1Application$$EnhancerBySpringCGLIB$$3f2d7a4c@fb0bff5 // 反射Method#invoke
																															this.returnValueHandlers.handleReturnValue(returnValue, getReturnValueType(returnValue), mavContainer, webRequest); // HandlerMethodReturnValueHandlerComposite#handleReturnValue
																																handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest); // RequestResponseBodyMethodProcessor 
																																	writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage); // AbstractMessageConverterMethodProcessor#writeWithMessageConverters
																																	// 输出第三条DEBUG日志
																																	// 输出第四条DEBUG日志
																																	((HttpMessageConverter) converter).write(body, selectedMediaType, outputMessage); // AbstractHttpMessageConverter#write
																																	// 这里断片了---------------↓
																																	CoyoteOutputStream#flush
																																		OutputBuffer#flush
																																			OutputBuffer#doFlush
																																				coyoteResponse.sendHeaders();
																																					action(ActionCode.COMMIT, this); // Response#action ? 怎么来这里了？actionCode=COMMIT
																																						hook.action(actionCode, param); // hook=Http11Processor, 执行 AbstractProcessor#action
																																							case COMMIT:
																																							prepareResponse();
																																					setCommitted(true);
																																				coyoteResponse.action(ActionCode.CLIENT_FLUSH, null); // Respone#action, actionCode=CLIENT_FLUSH
																																					hook.action(actionCode, this);
																																						case CLIENT_FLUSH:
																																						action(ActionCode.COMMIT, null); // AbstractProcessor#action
																																						flush(); // 客户端（浏览器、postman收到 响应）！！！
																																	// 这里断片了---------------↑
																																	回
																																回
																															回
																														return getModelAndView(mavContainer, modelFactory, webRequest);
																														finally: webRequest.requestCompleted();
																													return mav;	
																												回				
																											回 DispatchServlet#doDispatch，继续执行...
																											processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
																										回 DispatchServlet#doService
																										...不继续了
		}

上面的调查结果请拷贝到 Notepad++ 里面打开，然后，视图->取消（不选）自动换行，再细看。

针对调查结果，下面再做一个简要介绍：

本文从 AbstractProtocol 开始：其实，上面停止了 AbstractProtocol的子类ConnectionHandler 的process函数中（起点）。

用到的协议对象 Http11NioProtocol，对于的处理器 Http11Processor；

NioEndpoint 是配置 HTTP1.1 使用的，其下包含 Poller内部类，NioSocketWrapper静态内部类，以及其它内部类；

Http11Processor 源码：继承了 AbstractProcessor，所以，调用时就会用到其父类中的方法（Java基础，同上面的 *Servlet类）

public interface Processor {
}

public abstract class AbstractProcessorLight implements Processor {
}

public abstract class AbstractProcessor extends AbstractProcessorLight implements ActionHook {
}

public class Http11Processor extends AbstractProcessor {
}

ConnectionHandler中的 process方法调用 processor.process(wrapper, status)，实际调用的是 AbstractProcessorLight#process；

接着，调用 Http11Processor#service：其中重要的调用 prepareRequestProtocol()、getAdapter().service(request, response)；

getAdapter().service(request, response) 中，获取的 org.apache.catalina.connector.CoyoteAdapter 对象，再执行其 service方法；

CoyoteAdapter#service 中最重要的调用：

// Calling the container
connector.getService().getContainer().getPipeline().getFirst().invoke(request, response);

最终的 invoke 实际调用的是 org.apache.catalina.core.StandardEngineValve#invoke。

final class StandardEngineValve extends ValveBase {
}

注意，上面 ValveBase 是抽象类，其下的很多子类会在本地分析中被用到：

StandardEngineValve#invoke 中的重要调用：host.getPipeline().getFirst().invoke(request, response)，实际执行的是 ErrorReportValve#invoke；

ErrorReportValve#invoke 中调用 getNext().invoke(request, response)，实际执行 StandardHostValve#invoke；

然后又是 TomcatEmbeddedContext对象、AuthenticatorBase#invoke、StandardContextValve#invoke，

最后，调用了 StandardWrapperValve#invoke。

在StandardWrapperValve#invoke 调用中，完成了 请求处理、请求响应的全过程！

1、servlet = wrapper.allocate(); 分配 servlet；

2、ApplicationFilterFactory.createFilterChain(request, wrapper, servlet)

创建过滤器链，包含五个过滤器（调试工具中可以看到）：

[
	FilterMap[filterName=characterEncodingFilter, urlPattern=/*], 
	FilterMap[filterName=webMvcMetricsFilter, urlPattern=/*], 
	FilterMap[filterName=formContentFilter, urlPattern=/*], 
	FilterMap[filterName=requestContextFilter, urlPattern=/*], 
	FilterMap[filterName=Tomcat WebSocket (JSR356) Filter, urlPattern=/*]
]

3、filterChain.doFilter(request.getRequest(), response.getResponse())

过滤器链建好后，多次“触发”上面的调用——千万注意，是一个扣一个的链式，而不是循环调用！

疑问：做什么用呢？

4、ApplicationFilterChain#internalDoFilter 中调用 servlet.service(request, response)

这里的 servlet 实际是 DispatchServlet对象，实际执行的是 HttpServlet#service，进一步调用 FrameworkServlet#service。

注意，HttpServlet 中有两个 service函数，都是两个参数，但一个签名长，一个短（下面的签名没有抛出异常的信息，不是完整的哦！）：

// 短 会 调用 长的
public void service(ServletRequest req, ServletResponse res)
// 长
protected void service(HttpServletRequest req, HttpServletResponse resp)

注意了！注意了！注意了！

关键点来了：

HttpServlet 中签名长的 service函数中包含各种处理请求的方法调用——doGet、doHead、doPost、doPut、doDelete、doOptions、doTrace。

本文近分析了 doGet 分支，其它的应该类似的。

其后，有陆续调用了 DispatchServlet#doService、DispatchServlet#doDispatch等，不再具体分析，可以看前面的调查结果以及自行调试。

最终，调用 HandlerMethodReturnValueHandlerComposite#handleReturnValue 想要客户端，得到响应。

注：调查过程中，发现很多对象是在 Spring容器中存在的，比如，webEndpointServletHandlerMapping、managementServletContext。

---本文完---

疑问：

1、请求数据怎么定制？Servlet中的过滤器、拦截器、AOP 等怎么使用？

2、本文的HTTP 是 1.1，其它还有 HTTP 2、WebSocket、ReactiveWeb，可以进行类似的分析；

3、响应数据怎么定制？

4、Web应用的初始化是怎么做的呢？还需调试入口类的 run方法——又是几多精时啊。

还要继续探究才是。

posted @ 2021-08-14 02:24 快乐的总统95 阅读(714) 评论(0) 编辑收藏举报

刷新页面返回顶部

`三一三`

用问题刺激思想，用执行消灭懒散，

spring boot项目06：Web请求探秘-整个过程

公告