struts中的RequestProcessor

在Struts中，擔任 MVC / Model 2 中Controller角色的是ActionServlet，所有的請求都必須先通過它，然而在Struts 1.1後，有關於請求的處理大部份已交由RequestProcessor，當ActionServlet收到GET或POST的請求，其doGet() 或doPost()會呼叫process()方法來處理請求：

protected void process(HttpServletRequest request,
                        HttpServletResponse response)
                   throws IOException, ServletException {
    RequestUtils.selectApplication(request,
                                   getServletContext());
    getApplicationConfig(
         request).getProcessor().process(request, response);
}

RequestUtils是個工具類，ActionServlet呼叫其selectApplication()方法，藉由 request.getServletPath()來取得請求路徑以選擇應用程式模塊來處理請求，之後從ApplicationConfig物件取得 RequestProcessor物件，將使用者的請求委託它來進行處理。

通常是將ActionServlet當作黑盒子，您只要使用它，然而您也可以繼承ActionServlet來定義自己的控制器，但由於在Struts 1.1中大部份的請求已經委託RequestProcessor來處理，繼承ActionServlet來定義自己的控制器請求處理意義已經不大，通常的目的是重新定義ActionServlet的init()方法，增加自己的初始化動作：

public class CustomActionServlet extends ActionServlet {
    public void init() throws ServletException {
        super.init();

        // 增加自己的初始化動作
        ....
    }
}

預設的RequestProcessor物件是org.apache.struts.action.RequestProcessor，您可以藉由觀看 process()方法的原始碼來瞭解它作了哪些事情：

public void process(HttpServletRequest request,
                     HttpServletResponse response)
                  throws IOException, ServletException {
    // 處理 contentType 為 multipart/form-data 的 POST 請求
    request = processMultipart(request);

    // 取得 URI 路徑
    String path = processPath(request, response);
    if(path == null)
        return;
    .....

    // 確定客戶端的位置
    // 是否要將一個Locale物件儲存在 session 中
    // 配合 <controller> 的 locale 屬性使用
    processLocale(request, response);

    // 確定contentType，預設是 text/html
    processContent(request, response);

    // 判斷<controller>屬性nocache是否被設定
    // 若是，在 response 中加入防止快取的header
    processNoCache(request, response);

    // 前置處理，預設返回 true
    //子類可以重新定義它以決定要不要繼續處理
    if(!processPreProcess(request, response)) {
        return;
    }

    // 從URI路徑確定ActionMapping
    ActionMapping mapping =
                   processMapping(request, response, path);
    if(mapping == null) {
        return;
    }

    ....

    // 處理ActionForm
    // 如果沒有就新增一個，之後一直使用它
    ActionForm form =
            processActionForm(request, response, mapping);

    // 將表單的欄位值填入ActionForm
    processPopulate(request, response, form, mapping);

    // 判斷是否執行ActionForm的validate()方法
    if(!processValidate(request, response, form, mapping)) {
        return;
    }

    // 判斷 <action> 標籤的 forward 或 include 標籤
    // 是不是被設定，這兩個標籤在設定一個路徑
    // 其與 type 屬性是互斥的，當設定其中一個屬性時
    // 調用 RequestDispatcher 的 forward() 或 include()
    // 其作用與設定ForwardAction或IncludeAction相同
    // 直接繞送而不再使用Action物件進行接下來的處理
    if(!processForward(request, response, mapping)) {
        return;
    }
    if(processInclude(request, response, mapping)) {
        return;
    }

    // 處理Action，如果沒有就生成一個，之後一直使用它
    Action action =
            processActionCreate(request, response, mapping);
    if(action == null) {
        return;
    }

    // 呼叫Action的execute()或perform()方法
    // 並返回ActionForward
    ActionForward forward =
                    processActionPerform(request,
                                         response,
                                         action,
                                         for, mapping);

    // 處理ActionForward
    processActionForward(request, response, forward);
}

您可以繼承RequestProcessor，並改寫其中的processXXXXX()方法來自定義請求的處理方式，如果您要使用自己的 RequestProcessor，要在struts-config.xml中使用<controller>標籤來定義，例如：

struts-config.xml

...
 <controller 
    contentType="text/html;charset=Big5" 
    locale="true" 
    nocache="true"
    processorClass="caterpillar.CustomRequestProcessor"/> 
...

在Struts 1.1後，新增了<controller>標籤，它可以用於指定ActionServlet的一些參數，在Struts 1.1之前，這些參數是在<init-params>中加以指定，使用<controller>標籤，應用程式中不同的模組也可以指定各自的參數給ActionServlet。
Struts框架只允许应用中存在一个ActionServlet类,但是可以存在多个客户化的RequestProcessor类,每个子应用模块都可以有单独的RequestProcessor类,


ActionServlet主要负责初始化,以及介绍请求并找到合适的RequestRrocessor,之后真正干活的是RequestProecssor和Action.
上回说到ActionServlet的process方法最终会调用RequestProcessor类的process方法.下面介绍这个方法.
[align=center][color=red]一.RequestProcessor的process方法 [/color][/align]

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

	    }   

[color=red]1) 调用processMultipart()方法 [/color]
如果HTTP请求方式为post,并且contentType为”multipart/form-data”开头,标准的HttpServletRequest对象将被重新包装,以方便处理”multipart”类型的HTTP请求.如果请求方式为get,或正congtentType属性不是”mulitipart”,就直接返回原始的HttpServletRequest对象.

[color=red]2) 调用processPath()方法[/color]
获得请求的URI的路径,这一信息可用于选择合适的Struts Action组件.

[color=red]3) 调用processLocale方法 [/color]
当ControllerConfig对象的locale属性为true,将读取用户请求中包含的Locale信息,然后把Locale实例保存在session范围内.

[color=red]4) 调用processContendType(contentType)方法 [/color]
读取ControllerConfig对象的conttentType属性,然后调用response.setContentType(contentType)方法,设置响应结果的文档类型和字符编码.
processContent()方法如下

	protected void processContent(HttpServletRequest request,   
	                                 HttpServletResponse response) {   

	       String contentType = moduleConfig.getControllerConfig().getContentType();   
	       if (contentType != null) {   
	           response.setContentType(contentType);   
	       }   

	   } 

[color=red]5) 调用processNoCache()方法 [/color]
读取ControllerConfig对象的nocache属性,如果nocache属性为true,在响应结果中将加入特定的头参数:Pragma,Cache-Control和Expires,
防止页面被存储在客户的浏览器的缓存中,processNoCache方法的代码如下:

protected void processNoCache(HttpServletRequest request,   
	                                  HttpServletResponse response) {   

	        if (moduleConfig.getControllerConfig().getNocache()) {   
	            response.setHeader("Pragma", "No-cache");   
	            response.setHeader("Cache-Control", "no-cache,no-store,max-age=0");   
	            response.setDateHeader("Expires", 1);   
	        }   
	    }  

[color=red]6)调用processPreprocess()方法[/color]
该方法不执行任何操作.直接返回true.子类可以覆盖这个方法.
执行客户化的预处理请求操作.
[color=red]
7)调用processMapping()方法 [/color]
寻找和用户请求的URI匹配的ActionMapping,如果不存在这样的ActionMapping,则向用户返回恰当的错误信息.

[color=red]8)调用processRoles()方法 [/color]
先判断是否为Action配置了安全角色,如果配置了安全角色,就调用isUserInRole()方法判断当前用户是否具备必需的角色,如果不具备,就结束请求处理流程.,向用户返回恰当的错误消息.

[color=red]9)调用processActionForm()方法 [/color]
先判断是否为ActionMapping配置了ActionForm,如果配置了ActionForm,就先从ActionForm的存在范围内（request或session）寻找改ActionForm实例,如果不存在,就创建一个实例,接下来把它保存在合适的范围内,保存时使用的属性key为ActionMapping的name属性。

[color=red]10）调用processPopulate()方法 [/color]
如果为ActionMapping配置了ActionForm，就先调用ActionForm的reset（）方法，再把请求中的表单数据组装到ActionForm中。

[color=red]11）调用processValidate（）方法 [/color]
如果为ActionMapping配置了ActionForm，并且ActionMapping的validate属性为true，就调用ActionForm的validate（）方法，如果validate方法返回的ActionErrors对象中包含ActionMessage对象，说明表单验证失败。就把ActionErrors对象放在request范围内，再把请求转发到ActionMapping的input属性指定的Web组件。如果ActionForm的validate方法执行表单验证成功，就继续执行下面的处理流程。

[color=red]12）调用processForward()方法 [/color]
判断是否在ActionMapping中配置了forward属性。如果配置了这个属性，就调用RequestDispatcher的forward方法，请求处理流程结束。否则进行下一步。

[color=red]13）调用processInclude()方法 [/color]
判断是否在ActionMapping中配置了include属性。如果配置了这个属性，就调用RequestDispatcher的include方法，请求处理流程结束。否则进行下一步。

[color=red]14）调用processActionCreate（）方法 [/color]
先判断是否在Action缓存中存在这个Action实例，如果没有就新建一个Action实例，把它放在Action缓存中。可以看出Action也是只有一个实例在运行的。

[color=red]15）调用processActionPerform [/color]
该方法调用Action实例的execute方法，该方法位于try/catch中，以及捕获异常。processActionPerform（）方放代码如下。

	protected ActionForward   
	       processActionPerform(HttpServletRequest request,   
	                            HttpServletResponse response,   
	                            Action action,   
	                            ActionForm form,   
	                            ActionMapping mapping)   
	       throws IOException, ServletException {   
	       try {   
	           return (action.execute(mapping, form, request, response));   
	       } catch (Exception e) {   
	           return (processException(request, response,   
	                                    e, form, mapping));   
	       }   

[color=red]16)调用processActionForward方法[/color]
把你的Action的excute方法返回的ActionFoward对象作为参数传给它，processActionForward对象包的请求转发信息来执行请求转发或重定向。

在RequestProcessor类的process方法中，会访问ControllerConfig、ActionMappig和ActionForward实力的属性，ControllerConfig类和struts配置文件的<controlle>r元素对应，ActionMapping类和<action>元素对应，ActionForward和<forward>元素对应，process方法通过访问这三个类实例的属性来获得相关的配置信息。
写了这么多，RequestProcessor干得事够多的吧。
[align=center][color=red]二、扩展RequestProcessor类 [/color][/align]
如果想修改RequestProcessor的一些默认功能,改易覆盖RequestProcessor基类中的相关方法.

Public class CustomRequestProcessor extends RequestProcessor{   
	  protected void processPreprocess (HttpServletRequest request,   
	                                 HttpServletResponse response) {    
	………………….   
	}   
	}  

在struts配置文件中，<controller>元素的processorClass属性用于配置你自己的RequestProcessor类

</controller    
	contentType＝“text/html:charset=”GB2312”   
	locale=”true” nocache=”true” processorCalss=”com.test.CustomRequestProcessor”/>