开始使用Commons Chain （第二部分）

就像我们在第一部分中讨论的那样，Commons Chain提供了一个基于Java的框架和API来描述顺序的处理过程。现在这个在Javarta Commons项目下开发的框架正在最新的Struts发布版（在这指的是1.3版本）中接受考验。在这一部分，我将具体描述Struts如何使用Chain简化HTTP请求处理。

Commons Chain允许你定义多组顺序的命令。每一组命令（也就是链）负责实现某种处理。链中每一个命令都是一个实现了Command接口的Java类。这个接口只包含了一个execute方法，方法有一个类型是Context的参数。execute方法返回true来声明请求的处理已完成，这时链的执行就会结束。如果返回false，处理将交给下个命令继续。

你可以使用Commons Chain的API或者XML文件定义链。使用XML文件可以提供最大的灵活性，因为这样做你可以在部署期修改链的定义。下面是我在第一篇文章中使用的链定义文件：

  
            className="com.jadecove.chain.sample.GetCustomerInfo"/>
            className="com.jadecove.chain.sample.TestDriveVehicle"/>
            className="com.jadecove.chain.sample.NegotiateSale"/>
            className="com.jadecove.chain.sample.ArrangeFinancing"/>
            className="com.jadecove.chain.sample.CloseSale"/>
  

Struts使用Chain替换了原来传统的在RequestProcessor类中执行的HTTP请求处理。Struts的ActionServlet通过struts-config.xml决定使用哪个RequestProcessor。如果没有显式的指出，ActionServlet将使用org.apache.struts.action.RequestProcessor。他首先得到一个RequestProcessor的实例，调用实例的init方法，然后执行实例的process方法。

下面是RequestProcessor的init方法：

public void init(ActionServlet servlet,
                 ModuleConfig moduleConfig)
    throws ServletException {

    synchronized (actions) {
         actions.clear();
    }
        
    this.servlet = servlet;
    this.moduleConfig = moduleConfig;
}

没有什么不可思议的地方——这个方法只是简单的清除了Action实例缓存，设置了几个实例变量。RequestProcessor的核心在它的process方法。这个方法里定义了处理请求和响应的顺序算法。

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;
    }
        
    // 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);
    if (!processValidate(request, response, form, mapping)) {
        return;
    }

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

}

这个处理就是为Commons Chain定制的。（一些Struts的拥护者同时也是Chain的拥护者决不是巧合。）这个处理由一串顺序的步骤组成，这些步骤是一些名为processFoo的方法。它们的输入主要由request和response对象组成。其中一些方法会返回Struts的对象，如ActionMapping和ActionForm。如果这些对象为null就返回false，表示处理无法继续；另一些方法直接返回true或false，false用于表示请求已被处理而且无法继续执行。

Struts 1.3提供了一个新的请求处理类（ComposableRequestProcessor）来使用Commons Chain，这个类继承RequestProcessor，覆盖了init和process方法。ComposableRequestProcessor的init方法从链编目中载入请求处理链。默认情况下，这个编目名是struts，命令名是servlet-standard。

public void init(ActionServlet servlet,
                     ModuleConfig moduleConfig)
           throws ServletException {

    super.init(servlet, moduleConfig);

    ControllerConfig controllerConfig = 
        moduleConfig.getControllerConfig();

    String catalogName = controllerConfig.getCatalog();
    catalog = CatalogFactory.getInstance().getCatalog(catalogName);
    if (catalog == null) {
        throw new ServletException("Cannot find catalog '" +
                                       catalogName + "'");
    }

    String commandName = controllerConfig.getCommand();
    command = catalog.getCommand(commandName);
    if (command == null) {
        throw new ServletException("Cannot find command '" +
                                       commandName + "'");
    }
}

为了运行链（也就是运行命令）ComposableRequestProcessor覆盖了process方法：

public void process(HttpServletRequest request,
                        HttpServletResponse response)
        throws IOException, ServletException {

    // Wrap the request in the case of a multipart request
    request = processMultipart(request);
        
    // Create and populate a Context for this request
    ActionContext context = contextInstance(request, response);

    // Create and execute the command.
    try {
        command.execute(context);
    } catch (Exception e) {
        // Execute the exception processing chain??
        throw new ServletException(e);
    }

    // Release the context.
    context.release();
}

处理请求的步骤在一个名为chain-config.xml的XML文件中定义，这个文件里定义了一组需要顺序执行的命令。（在这processMultipart方法是个例外。这个在ComposableRequestProcessor里实现的方法包装了内容类型是multipart/form-data的请求）。为了了解它是如何工作的，我们来仔细察看一下chain-config.xml的内容。首先，Struts使用了子链，Commons Chain中通过使用LookupCommand将整个链看成是一个命令。Struts使用了元素define使基于LookupCommand的子链定义更便捷。


ComposableRequestProcessor执行了名为servlet-standard的链。这个链包含了3个命令：

servlet-exception        处理异常的Chain过滤器。过滤器是一种实现了postprocess方法的特殊命令。postprocess会在链中命令执行后调用（实际上是在那些在过滤器声明之后的命令执行后调用）。
process-action        处理请求并执行恰当的action的主要流程。
process-view        处理到视图的转向（例如JSP页面）。

    
              className="org.apache.struts.chain.commands.ExceptionCatcher"
        catalogName="struts"
   exceptionCommand="servlet-exception"/>

            catalogName="struts"
               name="process-action"
           optional="false"/>

            catalogName="struts"
               name="process-view"
           optional="false"/>

process-action链定义了处理请求和调用你自己的action的命令组：

               optional="true"/>

      "org.apache.struts.chain.commands.servlet.SelectLocale"
  />
      "org.apache.struts.chain.commands.servlet.RequestNoCache"
  />
      "org.apache.struts.chain.commands.servlet.SetContentType"
  />        
      "org.apache.struts.chain.commands.servlet.SelectAction"
  />
      "org.apache.struts.chain.commands.servlet.AuthorizeAction"
  />    
      "org.apache.struts.chain.commands.servlet.CreateActionForm"
  />
      "org.apache.struts.chain.commands.servlet.PopulateActionForm"
  />
      "org.apache.struts.chain.commands.servlet.ValidateActionForm"
  />
      "org.apache.struts.chain.commands.servlet.SelectInput"
  />
      "org.apache.struts.chain.commands.ExecuteCommand"
  />
      "org.apache.struts.chain.commands.servlet.SelectForward"
  />
      "org.apache.struts.chain.commands.SelectInclude"
  />
      "org.apache.struts.chain.commands.servlet.PerformInclude"
  />
      "org.apache.struts.chain.commands.servlet.CreateAction"
  />
      "org.apache.struts.chain.commands.servlet.ExecuteAction"
  />

原始的RequestProcessor中的方法processFoo被实现了Command接口类重写了实现。在Struts里，每一个Command的实现都继承了一个抽象的基类。这个基类实现了Command的execute方法。这个execute方法调用具体的子类方法执行实际的操作。
我们来考察如何在HTTP请求中存取locale。首先，下面是原始的RequestProcessor中processLocale的实现：

protected void processLocale(HttpServletRequest request,
                             HttpServletResponse response) {

    // Are we configured to select the Locale automatically?
    if (!moduleConfig.getControllerConfig().getLocale()) {
        return;
    }

    // Has a Locale already been selected?
    HttpSession session = request.getSession();
    if (session.getAttribute(Globals.LOCALE_KEY) != null) {
        return;
    }

    // Use the Locale returned by the servlet container (if any)
    Locale locale = request.getLocale();
    if (locale != null) {
        session.setAttribute(Globals.LOCALE_KEY, locale);
    }
}

新的用链处理locale的实现使用了两个类：AbstractSelectLocale和SelectLocale。抽象类AbstractSelectLocale实现了execute方法：

public boolean execute(Context context) throws Exception {
    ActionContext actionCtx = (ActionContext) context;

    // Are we configured to select Locale automatically?
    ModuleConfig moduleConfig = actionCtx.getModuleConfig();
    if (!moduleConfig.getControllerConfig().getLocale()) {
        return (false);
    }

    // Retrieve and cache appropriate Locale for this request
    Locale locale = getLocale(actionCtx);
    actionCtx.setLocale(locale);

    return (false);
}

SelectLocale继承了AbstractSelectLocale并实现了抽象方法getLocale：

protected Locale getLocale(ActionContext context) {

    ServletActionContext saContext = (ServletActionContext) context;

    // Has a Locale already been selected?
    HttpSession session = saContext.getRequest().getSession();
    Locale locale = (Locale) session.getAttribute(Globals.LOCALE_KEY);
    if (locale != null) {
        return (locale);
    }

    // Select and cache the Locale to be used
    locale = saContext.getRequest().getLocale();
    if (locale == null) {
        locale = Locale.getDefault();
    }
    session.setAttribute(Globals.LOCALE_KEY, locale);
    return (locale);

}

抽象类和它的实现类都充分使用了接收到的context对象。在Commons Chain里，Context对象作为链中的命令的共享存储空间。与RequestProcessor直接操作HTTP请求和响应不同的是，命令需要做一些额外的工作来操作他们。上面的抽象命令将context向下转型成ActionContext类型。ActionContext可以显式地操作Struts相关属性，例如消息资源（message resource）、正在执行的Action以及请求（request）和会话（session）的资源和服务。但是，ActionContext并不依赖Servlet API。命令的具体实现类进一步将context向下转型到ServletActionContext类型。ServletActionContext实现了ActionContext接口，并且包装了Commons Chain的ServletWebContext。ServletWebContext包含了一些servlet对象，例如HttpServletRequest、HttpServletResponse和ServletContext。

下面的类图展示了Struts是如何使用Chain提供的类和接口的：


图1.

Struts 1.3的开发人员尽力降低了和Servlet API的耦合。通过构建上面显示的使用Chain Context的结构，Struts将对Servlet API的依赖隔离到了最底层：具体的命令实现类。事实上，你会发现Struts的命令遵循了一个及其一致的模式：
1.        一个抽象命令实现了Command的execute方法，它只对ActionContext做处理。
2.        在execute方法中，这个抽象的基类调用一个自定义的抽象方法完成特定的servlet工作。
3.        具体的子类实现了自定义的抽象方法，将ActionContext向下转型到ServletActionContext，然后使用HttpServletRequest和HttpSession等执行特殊的工作。
4.        根据抽象方法返回的结果，抽象命令会返回false（链继续执行）或true（链停止执行）。

如果你想自定义ComposableRequestProcessor的行为就需要了解ComposableRequestProcessor和链配置。Commons Chain为开发人员提供了多种方法自定义Struts的请求处理。例如，假设你想自定义locale的处理，你可以使用下面任意一种技术：
•        你自己继承AbstractSelectLocale并实现getLocale方法。将chain-config.xml中的className改成你自己写的类名。
•        自己实现Command接口，然后替换原来的类。将chain-config.xml中的className改成你自己写的类名。
•        最后一种：使用LookupCommand，你可以将处理locale的单一命令替换成一个子链。

如果你曾经自定义过Struts的RequestProcessor，你可能覆盖过processPreprocess方法来执行自定义的请求处理。Struts 1.3通过Chain来提供类似的处理方法。process-action链中第一个命令的定义如下：

               name="servlet-standard-preprocess"
           optional="true"/>

这个元素声明了一个子链作为process-action链的第一个命令。这的optional=true确保子链未定义时父链仍能继续执行。在Jakarta Struts Cookbook中，我展示了如何通过覆盖RequestProcessor的processPreprocess方法来检查用户是否登录。作为例子，我们来看在Struts Mail Reader示例应用中如何加入这个行为。下面这个命令检查了User对象是否已绑定到会话（session）上。参数checkUser用于指明是否要执行检查。

package com.jadecove.chain.commands;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.chain.Command;
import org.apache.commons.chain.Context;
import org.apache.struts.apps.mailreader.Constants;
import org.apache.struts.chain.contexts.ActionContext;
import org.apache.struts.chain.contexts.ServletActionContext;

public class CheckUser implements Command {

  public boolean execute(Context ctx) throws Exception {
    ActionContext context = (ActionContext) ctx;
    Object user = context.getSessionScope().get(Constants.USER_KEY);
    if (user == null &&
        context.getParameterMap().containsKey("checkUser")) {
        HttpServletResponse response = 
        ((ServletActionContext) ctx).getResponse();
        response.sendError(403, "User not logged in.");
        return true;
    }
    return false;
  }

}

现在我们需要声明一个包含这个命令的链。但是我们把这个XML加在哪？有两种方法可以解决这个问题：第一种方法，你可以将这个链加入Struts提供的chain-config.xml文件中。这是最直接的办法，但是当你更新Struts的时候，你需要保证在新的配置文件中加入这些修改。另外一个更好的方法是为你的子链单独创建一个配置文件，然后告诉Struts将你的链定义文件和Struts自带的一起使用。要使用这个方法，首先你要在你应用的WEB-INF文件夹下面建立一个名为costom-chain-config.xml的文件，添加下面的链声明：

然后你需要修改struts-config.xml文件，让ActionServlet在载入Struts自己的链配置时载入你的链配置文件

    action
    
      org.apache.struts.action.ActionServlet
    
    
        config
        
            /WEB-INF/struts-config.xml,
            /WEB-INF/struts-config-registration.xml
        
    
    
        chainConfig
        
            /WEB-INF/chain-config.xml, 
            /WEB-INF/custom-chain-config.xml
        
    
    1

当你访问Mail Reader的欢迎页面时，会显示图2所示的页面：


图2.

但是当你加上checkUser参数再次访问时，CheckUser命令终止了链的执行并返回它产生的响应，如图3所示：


图3.

如果比起创建一个链你更愿意替换命令，那你只需要简单地修改chain-config.xml文件。
在我为Struts和Chain加上包装前，让我们看一下Struts是如何使用Chain过滤器处理异常的。Struts定义了一个捕捉异常的命令作为servlet-standart链的第一个元素：

        catalogName="struts"
   exceptionCommand="servlet-exception"/>

我们已经讨论过命令元素是如何使用属性的；但在这catalogName和exceptionCommand是两个新的属性。实际上它们没有什么不可思议的地方。它们在Chain中没有任何内在的意义。当Commons Chain解析链配置时（使用Commons Digester），任何在Chain中没有显式处理的属性都使用JavaBean的setter方法处理。换句话说，当Chain解析上面的命令时，它会获取一个ExceptionCatcher对象，然后象下面的代码那样设置JavaBean的属性：

exceptionCatcher.setCatalogName("struts");
exceptionCatcher.setExceptionCommand("servlet-exception");

类ExceptionCatcher实现了Filter。实现Filter的类必须实现下面两个方法：

// (From the Command interface) Called when the Filter is first
// processed in sequence 
public boolean execute(Context context); 

// Called after a chain command throws an exception
// or the chain reaches its end
public boolean postprocess(Context context, Exception exception);

类ExceptionCatcher的execute方法只是简单的重置了命令，将ActionContext中的当前异常设置成null，然后返回false（告诉链继续执行）。所有有趣的东西都在postprocess方法里。如果这个方法接收到的异常不是null，它会通过catalogName和exceptionCommand找到对应的命令（也可以是一个链）并执行。

public boolean postprocess(Context context, Exception exception) {
    // Do nothing if there was no exception thrown
    if (exception == null) {
        return (false);
    }

    // Store the exception in the context
    ActionContext actionCtx = (ActionContext) context;
    actionCtx.setException(exception);

    // Execute the specified command
    try {
        Command command = lookupExceptionCommand();
        if (command == null) {
            throw new IllegalStateException
                ("Cannot find exceptionCommand '" +
                     exceptionCommand + "'");
        }
        command.execute(context);
    } catch (Exception e) {
        throw new IllegalStateException
           ("Exception chain threw exception");
    }
    return (true);
}

servlet-exception链中配置了Struts的异常处理流程：

    

    
            "org.apache.struts.chain.commands.servlet.ExceptionHandler"
    />
    
            "org.apache.struts.chain.commands.servlet.PerformForward"
    />

这个链中使用的类完成了和Struts 1.2的错误处理类同样的功能。ExceptionHandler是AbstractExceptionHandler的子类，这里的第一个命令会定位已经声明的Struts异常处理程序（如果存在的话）并执行它的execute方法。返回的ActionForward被存储在ActionContext中由通用的PerformForward命令处理。

我希望我已将Struts如何使用链解释清楚了。现在Commons Chain和Struts 1.3仍在不断变化中，所以上面说的可能会有变化。你最好下载最新的Struts的源码，仔细看看它是如何使用Chain的。我想你会发现这样实现是经过深思熟虑的；现在为Struts的请求处理加入自定义的行为要比以前更容易，更不受束缚。