层层递进Struts1（五）之处理流程
这篇博客我们深入Struts框架执行部分源码，从ActionServlet的process函数开始，看一下其内在的执行过程。
流程图
以下流程图展示的是ActionServlet和RequestProcessor两个类用到的函数，如RequestProcessor调用的其它类的函数不再说明。
函数说明
我们选择几个重要的函数说明，其它函数则简单说明一下即可。
ActionServlet
process
/**
* <p>Perform the standard request processing for this request, and create
* the corresponding response.</p>
*
* @param request The servlet request we are processing
* @param response The servlet response we are creating
*
* @exception IOException if an input/output error occurs
* @exception ServletException if a servlet exception is thrown
*/
protected void process(HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException {
ModuleUtils.getInstance().selectModule(request, getServletContext());
ModuleConfig config = getModuleConfig(request);
RequestProcessor processor = getProcessorForModule(config);
if (processor == null) {
processor = getRequestProcessor(config);
}
processor.process(request, response);
}
}
在调试时首先进入这个函数（Tomcat启动完毕，产生请求后），这个函数的作用是获取加载阶段产生的Module对象，产生struts逻辑处理的主要对象RequestProcessor。
RequestProcessor
process
/**
* <p>Process an <code>HttpServletRequest</code> and create the
* corresponding <code>HttpServletResponse</code> or dispatch
* to another resource.</p>
*
* @param request The servlet request we are processing
* @param response The servlet response we are creating
*
* @exception IOException if an input/output error occurs
* @exception ServletException if a processing exception occurs
*/
public void process(HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException {
// Wrap multipart requests with a special wrapper
request = processMultipart(request);
// Identify the path component we will use to select a mapping
String path = processPath(request, response);
if (path == null) {
return;
}
if (log.isDebugEnabled()) {
log.debug("Processing a '" + request.getMethod() +
"' for path '" + path + "'");
}
// Select a Locale for the current user if requested
processLocale(request, response);
// Set the content type and no-caching headers if requested
processContent(request, response);
processNoCache(request, response);
// General purpose preprocessing hook
if (!processPreprocess(request, response)) {
return;
}
this.processCachedMessages(request, response);
// Identify the mapping for this request
ActionMapping mapping = processMapping(request, response, path);
if (mapping == null) {
return;
}
// Check for any role required to perform this action
if (!processRoles(request, response, mapping)) {
return;
}
// Process any ActionForm bean related to this request
ActionForm form = processActionForm(request, response, mapping);
processPopulate(request, response, form, mapping);
// Validate any fields of the ActionForm bean, if applicable
try {
if (!processValidate(request, response, form, mapping)) {
return;
}
} catch (InvalidCancelException e) {
ActionForward forward = processException(request, response, e, form, mapping);
processForwardConfig(request, response, forward);
return;
} catch (IOException e) {
throw e;
} catch (ServletException e) {
throw e;
}
// Process a forward or include specified by this mapping
if (!processForward(request, response, mapping)) {
return;
}
if (!processInclude(request, response, mapping)) {
return;
}
// Create or acquire the Action instance to process this request
Action action = processActionCreate(request, response, mapping);
if (action == null) {
return;
}
// Call the Action instance itself
ActionForward forward =
processActionPerform(request, response,
action, form, mapping);
// Process the returned ActionForward instance
processForwardConfig(request, response, forward);
}
process是RequestProcessor对象主要的逻辑处理函数，根据上面的流程图可以看到，整个逻辑处理都是在这个函数中完成，它所调用的函数实现的功能如下：
processMultipart
这个函数的作用是判断是否是文件上传请求，如果是则特殊处理。
/**
* <p>If this is a multipart request, wrap it with a special wrapper.
* Otherwise, return the request unchanged.</p>
*
* @param request The HttpServletRequest we are processing
*/
protected HttpServletRequest processMultipart(HttpServletRequest request) {
if (!"POST".equalsIgnoreCase(request.getMethod())) {
return (request);
}
String contentType = request.getContentType();
if ((contentType != null) &&
contentType.startsWith("multipart/form-data")) {
return (new MultipartRequestWrapper(request));
} else {
return (request);
}
}
processPath
获取并截取请求，处理后变为需要的字符串，例如请求：http://localhost:8080/struts_login/login.do，处理后的字符串为/login.do。
/**
* <p>Identify and return the path component (from the request URI) that
* we will use to select an <code>ActionMapping</code> with which to dispatch.
* If no such path can be identified, create an error response and return
* <code>null</code>.</p>
*
* @param request The servlet request we are processing
* @param response The servlet response we are creating
*
* @exception IOException if an input/output error occurs
*/
protected String processPath(HttpServletRequest request,
HttpServletResponse response)
throws IOException {
String path = null;
// For prefix matching, match on the path info (if any)
path = (String) request.getAttribute(INCLUDE_PATH_INFO);
if (path == null) {
path = request.getPathInfo();
}
if ((path != null) && (path.length() > 0)) {
return (path);
}
// For extension matching, strip the module prefix and extension
path = (String) request.getAttribute(INCLUDE_SERVLET_PATH);
if (path == null) {
path = request.getServletPath();
}
String prefix = moduleConfig.getPrefix();
if (!path.startsWith(prefix)) {
String msg = getInternal().getMessage("processPath");
log.error(msg + " " + request.getRequestURI());
response.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
return null;
}
path = path.substring(prefix.length());
int slash = path.lastIndexOf("/");
int period = path.lastIndexOf(".");
if ((period >= 0) && (period > slash)) {
path = path.substring(0, period);
}
return (path);
}
设置相关函数
processLocale、processContent、processNoCache、processCachedMessages，这四个函数的作用分别是：设置国际化文件、设置内容类型、设置取消缓存、设置清楚session中struts的错误信息。
processMapping
根据上面生成的path，实例化对应的ActionMapping对象，如果此对象不为空则加载到request中，对应名称为Globals.MAPPING_KEY，如果为空，发送异常并添加到response中。
// If a mapping is found, put it in the request and return it
if (mapping != null) {
request.setAttribute(Globals.MAPPING_KEY, mapping);
return (mapping);
}
// Locate the mapping for unknown paths (if any)
ActionConfig configs[] = moduleConfig.findActionConfigs();
for (int i = 0; i < configs.length; i++) {
if (configs[i].getUnknown()) {
mapping = (ActionMapping) configs[i];
request.setAttribute(Globals.MAPPING_KEY, mapping);
return (mapping);
}
}
processRoles
Action执行是否需要特定的角色权限，如果不需要，则继续执行。
String roles[] = mapping.getRoleNames();
if ((roles == null) || (roles.length < 1)) {
return (true);
}
processActionForm
创建ActionForm并检测此Action的作用域，如果是Request则添加到request中，如果是Session则添加到session中。
// Create (if necessary) a form bean to use
ActionForm instance = RequestUtils.createActionForm
(request, mapping, moduleConfig, servlet);
if (instance == null) {
return (null);
}
// Store the new instance in the appropriate scope
if (log.isDebugEnabled()) {
log.debug(" Storing ActionForm bean instance in scope '" +
mapping.getScope() + "' under attribute key '" +
mapping.getAttribute() + "'");
}
if ("request".equals(mapping.getScope())) {
request.setAttribute(mapping.getAttribute(), instance);
} else {
HttpSession session = request.getSession();
session.setAttribute(mapping.getAttribute(), instance);
}
ActionForm相关
processPopulate这个函数的作用是：调用processPopulate()方法，如果存在为ActionMapping配置的ActionForm，则封装请求对象中的数据到ActionForm 中，在进行封装之前，先调用ActionForm 的reset()方法进行属性值的默认化
processValidate：如果action元素的属性validate被设置为true ，则进一步调用validate()方法进行规则校验。如果validate()方法校验失败，就会保存一个ActionErrors 对象到请求区域中，请求将会自动重定向到action映射的input属性所指定的页面中；如果校验通过或在action 映射中没有配置ActionForm，则继续处理请求。
异常处理
process这个函数中，包含一个try...catch块，如果出现InvalidCancelException则执行两个函数。
processException，将异常写入日志警告文件，并跑出异常；processForwardConfig，与下面最后执行的一个函数相同，捕获结束
跳转路径
processForward、processInclude：这个两个函数的作用是，检测struts-config下<action>元素的forward和include属性的值，如有配置，则把forward和include 请求放在配置的页面内；processForward()调用 RequestDispatcher.forward(),而processInclude()调用RequestDispatcher.include()。
如果同时配置了forward 和include 属性，Struts会优先选择forward。
processActionCreate
这个函数的作用是从struts-config下<action>的type属性得到Action类名，创建并返回它的实例。
Action instance = null;
synchronized (actions) {
// Return any existing Action instance of this class
instance = (Action) actions.get(className);
if (instance != null) {
if (log.isTraceEnabled()) {
log.trace(" Returning existing Action instance");
}
return (instance);
}
// Create and return a new Action instance
if (log.isTraceEnabled()) {
log.trace(" Creating new Action instance");
}
try {
instance = (Action) RequestUtils.applicationInstance(className);
// :TODO: Maybe we should propagate this exception
// instead of returning null.
} catch (Exception e) {
log.error(
getInternal().getMessage("actionCreate", mapping.getPath()),
e);
response.sendError(
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
getInternal().getMessage("actionCreate", mapping.getPath()));
return (null);
}
instance.setServlet(this.servlet);
actions.put(className, instance);
}
return (instance);
processActionPerform
执行自己写的Action中execute函数，当然包含跳转逻辑：
try {
return (action.execute(mapping, form, request, response));
} catch (Exception e) {
return (processException(request, response,
e, form, mapping));
}
processForwardConfig
获取即将跳转的路径：
String forwardPath = forward.getPath();
String uri = null;
// paths not starting with / should be passed through without any processing
// (ie. they're absolute)
if (forwardPath.startsWith("/")) {
uri = RequestUtils.forwardURL(request, forward, null); // get module relative uri
} else {
uri = forwardPath;
}
doForward
获取RequestDispatcher，并执行跳转。
if (request instanceof MultipartRequestWrapper) {
request = ((MultipartRequestWrapper) request).getRequest();
}
RequestDispatcher rd = getServletContext().getRequestDispatcher(uri);
if (rd == null) {
response.sendError(
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
getInternal().getMessage("requestDispatcher", uri));
return;
}
rd.forward(request, response);
总结
如果我们忽略函数，只从宏观上看，可以总结为：
- 读取配置文件
- 获取访问地址
- 设置Struts
- 创建、赋值、验证ActionForm
- 异常处理
- 创建Action
- 执行Action中的逻辑
- 页面跳转
至此，如果不追究到最底层的函数，struts的执行流程已经讲解完毕，如果有问题，欢迎大家指出。
更多相关博客，请至《层层递进Struts1（八）之总结》
