层层递进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（八）之总结》