`
lujar
  • 浏览: 511980 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

开始使用Commons Chain (第一部分)

    博客分类:
  • JAVA
阅读更多
作为程序开发人员,我们经常需要对一个实际上程序性的系统应用面向对象的方法。商业分析家和管理人员描述这样的系统时通常不使用类层次和序列图,而是使用流程图和工作流图表。但是不论如何,使用面向对象的方法解决这些问题时会带来更多的灵活性。面向对象的设计模式提供了有用的结构和行为来描述这种顺序的处理,比如模版方法(Template Method)[GoF]和责任链(Chain of Responsibility)[GoF]。

Jakarta Commons的子项目Chain将上述两个模式组合成一个可复用的Java框架用于描述顺序的处理流程。这个在Jakarta Commons project社区中开发的框架,已经被广泛的接受并且使用于许多有趣的应用中,特别的是他被Struts和Shale应用框架作为处理HTTP请求处理的基础机制。你可以在需要定义和执行一组连续的步骤时使用Commons Chain。

至于经典设计模式,开发者和架构师普遍使用模版方法(Template Method)造型顺序处理。模版方法(Template Method)中使用一个抽象的父类定义使用的算法:处理的步骤,具体实现交给子类。当然,父类也可以为算法所使用的方法提供一个缺省实现。

由于模版方法(Template Method)依赖继承——子类必须继承定义了算法的父类——因此使用这个模式的软件表现出紧耦合而且缺少灵活性。又由于实现类添加自己的行为前必须扩展父类,沟每⑷嗽北幌拗朴诶嗖愦沃校佣拗屏顺绦蛏杓频牧榛钚浴ommons Chain使用配置文件定义算法,在程序运行时解析配置文件,从而很好的解决了这个问题。

现在来看一下Commons Chain是怎样工作的,我们从一个人造的例子开始:二手车销售员的商业流程。下面是销售流程的步骤:
1.        得到用户信息
2.        试车
3.        谈判销售
4.        安排财务
5.        结束销售

现在假设使用模版方法(Template Method)造型这个流程。首先建立一个定义了算法的抽象类:

清单1
public abstract class SellVehicleTemplate {
        public void sellVehicle() {
        getCustomerInfo();
        testDriveVehicle();
        negotiateSale();
        arrangeFinancing();
        closeSale();
        }

        public abstract void getCustomerInfo();
        public abstract void testDriveVehicle();
        public abstract void negotiateSale();
        public abstract void arrangeFinancing();
        public abstract void closeSale();        
}


现在来看一下怎样用Commons Chain实现这个流程。首先,下载Commons Chain。你可以直接下载最新的zip或tar文件,也可以从CVS或者SubVersion源码库检出Commons Chain模块得到最新的代码。解压缩打包文件,将commons-chain.jar放入你的classpath中。

使用Commons Chain实现这个商业流程,必须将流程中的每一步写成一个类,这个类需要有一个public的方法execute()。这和传统的命令模式(Command pattern)实现相同。下面简单实现了“得到用户信息”:

清单2
package com.jadecove.chain.sample;

import org.apache.commons.chain.Command;
import org.apache.commons.chain.Context;

public class GetCustomerInfo implements Command {
        public boolean execute(Context ctx) throws Exception {
                System.out.println("Get customer info");
                ctx.put("customerName","George Burdell");
                return false;
        }
}


由于只是演示,这个类并没有做很多工作。这里将用户名放入了Context对象ctx中。这个Context对象连接了各个命令。暂时先将这个对象想象成根据关键字存取值的哈希表。所有后来的命令可以通过它访问刚才放入的用户名。TestDriveVehicle,NegotiateSale和 ArrangeFinancing命令的实现只是简单的打印了将执行什么操作。

清单3
package com.jadecove.chain.sample;

import org.apache.commons.chain.Command;
import org.apache.commons.chain.Context;

public class TestDriveVehicle implements Command {
        public boolean execute(Context ctx) throws Exception {
                System.out.println("Test drive the vehicle");
                return false;
        }
}

public class NegotiateSale implements Command {
        public boolean execute(Context ctx) throws Exception {
                System.out.println("Negotiate sale");
                return false;
        }
}

public class ArrangeFinancing implements Command {
        public boolean execute(Context ctx) throws Exception {
                System.out.println("Arrange financing");
                return false;
        }
}


CloseSale从Context对象中取出GetCustomerInfo放入的用户名,并将其打印。
清单4
package com.jadecove.chain.sample;

import org.apache.commons.chain.Command;
import org.apache.commons.chain.Context;

public class CloseSale implements Command {
        public boolean execute(Context ctx) throws Exception {
                System.out.println("Congratulations "
                  +ctx.get("customerName")
                        +", you bought a new car!");
                return false;
        }
}


现在你可以将这个流程定义成一个序列(或者说“命令链”)。
清单5
package com.jadecove.chain.sample;

import org.apache.commons.chain.impl.ChainBase;
import org.apache.commons.chain.Command;
import org.apache.commons.chain.Context;
import org.apache.commons.chain.impl.ContextBase;

public class SellVehicleChain extends ChainBase {
        public SellVehicleChain() {
                super();
                addCommand(new GetCustomerInfo());
                addCommand(new TestDriveVehicle());
                addCommand(new NegotiateSale());
                addCommand(new ArrangeFinancing());
                addCommand(new CloseSale());
        }
        public static void main(String[] args) throws Exception {
                Command process = new SellVehicleChain();
                Context ctx = new ContextBase();
                process.execute(ctx);
        }
}


运行这个类将会输出以下结果:
Get customer info
Test drive the vehicle
Negotiate sale
Arrange financing
Congratulations George Burdell, you bought a new car!


在进一步深入之前,让我们来看一下我们使用了的Commons Chain的类和接口。

image
图1

Command 类和Chain类的关系就是组合模式(Composite pattern)[GoF]的例子:Chain不仅由多个Command组成,而且自己也是Command。这使你可以非常简单得将单个命令(Command)替换成由多个命令(Command)组成的链(Chain)。这个由Command对象唯一操作定义的方法代表了一个直接的命令:

public boolean execute(Context context);

参数context仅仅是一个存放了名称-值对的集合。接口Context在这里作为一个标记接口:它扩展了java.util.Map但是没有添加任何特殊的行为。于此相反,类ContextBase不仅提供了对Map的实现而且增加了一个特性:属性-域透明。这个特性可以通过使用Map的put和get 方法操作JavaBean的域,当然这些域必须使用标准的getFoo和setFoo方法定义。那些通过JavaBean的“setter”方法设置的值,可以通过对应的域名称,用Map的get方法得到。同样,那些用Map的put方法设置的值可以通过JavaBean的“getter”方法得到。

例如,我们可以创建一个专门的context提供显式的customerName属性支持。
清单6
package com.jadecove.chain.sample;

import org.apache.commons.chain.impl.ContextBase;

public class SellVehicleContext extends ContextBase {

        
        private String customerName;

        public String getCustomerName() {
                return customerName;
        }
        
        public void setCustomerName(String name) {
                this.customerName = name;
        }
}


现在你既可以进行Map的一般属性存取操作同时也可以使用显式的JavaBean的访问和修改域的方法,这两个将产生同样的效果。但是首先你需要在运行SellVehicleChain时实例化SellVehiceContext而不是ContextBase。
清单7
public static void main(String[] args) throws Exception {
                Command process = new SellVehicleChain();
                Context ctx = new SellVehicleContext();
                process.execute(ctx);
        }


尽管你不改变GetCustomerInfo中存放用户名的方法——仍然使用ctx.put("customerName", "George Burdell")——你可以在CloseSale中使用getCustomerName()方法得到用户名。
清单8
        public boolean execute(Context ctx) throws Exception {
            SellVehicleContext myCtx = (SellVehicleContext) ctx;
            System.out.println("Congratulations "
                                   + myCtx.getCustomerName()
                                  + ", you bought a new car!");
            return false;
        }


那些依赖类型安全和context的显式域的命令(Command)可以利用标准的getter和setter方法。当一些新的命令(Command)被添加时,它们可以不用考虑context的具体实现,直接通过Map的get和put操作属性。不论采用何种机制,ContextBase类都可以保证命令(Command)间可以通过context互操作。

下面这个例子展示了如何使用Commons Chain的API建立并执行一组顺序的命令。当然,和现在大多数Java软件一样,Commons Chain可以使用XML文件作为配置文件。你可以将“汽车销售”流程的步骤在XML文件中定义。这个文件有个规范的命名chain- config.xml。

清单9
<catalog>
  <chain name="sell-vehicle">
    <command   id="GetCustomerInfo"
        className="com.jadecove.chain.sample.GetCustomerInfo"/>
    <command   id="TestDriveVehicle"
        className="com.jadecove.chain.sample.TestDriveVehicle"/>
    <command   id="NegotiateSale"
        className="com.jadecove.chain.sample.NegotiateSale"/>
    <command   id="ArrangeFinancing"
        className="com.jadecove.chain.sample.ArrangeFinancing"/>
    <command   id="CloseSale"
        className="com.jadecove.chain.sample.CloseSale"/>
  </chain>
</catalog>


Chain的配置文件可以包含多个链定义,这些链定义可以集合进不同的编目中。在这个例子中,链定义在一个默认的编目中定义。事实上,你可以在这个文件中定义多个名字的编目,每个编目可拥有自己的链组。

现在你可以使用Commons Chain提供的类载入编目并得到指定的链,而不用像SellVehicleChain中那样自己在程序中定义一组命令:
清单10
package com.jadecove.chain.sample;

import org.apache.commons.chain.Catalog;
import org.apache.commons.chain.Command;
import org.apache.commons.chain.Context;
import org.apache.commons.chain.config.ConfigParser;
import org.apache.commons.chain.impl.CatalogFactoryBase;

public class CatalogLoader {
        private static final String CONFIG_FILE =
                "/com/jadecove/chain/sample/chain-config.xml";
        private ConfigParser parser;
        private Catalog catalog;
        
        public CatalogLoader() {
                parser = new ConfigParser();
        }
        public Catalog getCatalog() throws Exception {
                if (catalog == null) {
                
        parser.parse(this.getClass().getResource(CONFIG_FILE));                
        
                }
                catalog = CatalogFactoryBase.getInstance().getCatalog();
                return catalog;
        }
        public static void main(String[] args) throws Exception {
                CatalogLoader loader = new CatalogLoader();
                Catalog sampleCatalog = loader.getCatalog();
                Command command = sampleCatalog.getCommand("sell-vehicle");
                Context ctx = new SellVehicleContext();
                command.execute(ctx);
        }
}


Chain 使用Commons Digester来读取和解析配置文件。因此你需要将Commons Digester.jar加入classpath中。我使用了1.6版本并且工作得很好。Digester使用了Commons Collectios(我使用的版本是3.1),Commons Logging(版本1.0.4),Commons BeanUtils(1.7.0),因此你也需要将它们的jar文件加入classpath中。在加入这些jar后,CatalogLoader就可以被编译和运行,它的输出和另外两个测试完全相同。

现在你可以在XML文件中定义链,并可以在程序中得到这个链(别忘了链也是命令),这样扩展的可能性和程序的灵活性可以说是无限的。假设过程“安排财务”实际上由一个完全分离的商业部门处理。这个部门希望为这种销售建立自己的工作流程。 Chain提供了嵌套链来实现这个要求。因为链本身就是命令,因此你可以用指向另一个链的引用替换一个单一用途的命令。下面是增加了新流程的链的定义:
清单11
<catalog name="auto-sales">
   <chain name="sell-vehicle">
         <command   id="GetCustomerInfo"
                 className="com.jadecove.chain.sample.GetCustomerInfo"/>
         <command   id="TestDriveVehicle"
                 className="com.jadecove.chain.sample.TestDriveVehicle"/>
         <command   id="NegotiateSale"
                 className="com.jadecove.chain.sample.NegotiateSale"/>
         <command
                 className="org.apache.commons.chain.generic.LookupCommand"
             catalogName="auto-sales"
                      name="arrange-financing"
                  optional="true"/>
         <command   id="CloseSale"
                 className="com.jadecove.chain.sample.CloseSale"/>
   </chain>
   <chain name="arrange-financing">
         <command   id="ArrangeFinancing"
                 className="com.jadecove.chain.sample.ArrangeFinancing"/>
   </chain>
</catalog>


Commons Chain提供了一个常用的命令LookupCommand来查找和执行另一个链。属性optional用于控制当指定的嵌套链没有找到时如何处理。 optional=true时,即使链没找到,处理也会继续。反之,LookupCommand将抛出 IllegalArgumentException,告知指定的命令未找到。

在下面三种情况下,命令链将结束:
1.        命令的execute方法返回true
2.        运行到了链的尽头
3.        命令抛出异常

当链完全处理完一个过程后,命令就返回true。这是责任链模式(Chain of Responsibility)的基本概念。处理从一个命令传递到另一个命令,直到某个命令(Command)处理了这个命令。如果在到达命令序列尽头时仍没有处理返回true,也假设链已经正常结束。

当有命令抛出错误时链就会非正常结束。在Commons Chain中,如果有命令抛出错误,链的执行就会中断。不论是运行时错误(runtime exception)还是应用错误(application exception),都会抛出给链的调用者。但是许多应用都需要对在命令之外定义的错误做明确的处理。Commons Chain提供了Filter接口来满足这个要求。Filter继承了Command,添加了一个名为postprocess的方法。

public boolean postprocess(Context context, Exception exception);
只要Filter的execute方法被调用,不论链的执行过程中是否抛出错误,Commons Chain都将保证Filter的postprocess方法被调用。和servlet的过滤器(filter)相同,Commons Chain的Filter按它们在链中的顺序依次执行。同样,Filter的postprocess方法按倒序执行。你可以使用这个特性实现自己的错误处理。下面是一个用于处理我们例子中的错误的Filter:
清单12
package com.jadecove.chain.sample;

import org.apache.commons.chain.Context;
import org.apache.commons.chain.Filter;

public class SellVehicleExceptionHandler implements Filter {

        public boolean execute(Context context) throws Exception {
                System.out.println("Filter.execute() called.");
                return false;
        }

        public boolean postprocess(Context context,
                                 Exception exception) {
                if (exception == null) return false;
                System.out.println("Exception "
                              + exception.getMessage()
                              + " occurred.");
                return true;
        }
}


Filter在配置文件中的定义就和普通的命令(Command)定义相同:
清单13
<chain name="sell-vehicle">
  <command   id="ExceptionHandler"
     className =
           "com.jadecove.chain.sample.SellVehicleExceptionHandler"/>
  <command   id="GetCustomerInfo"
      className="com.jadecove.chain.sample.GetCustomerInfo"/>


Filter 的execute方法按定义的序列调用。然而,它的postprocess方法将在链执行完毕或抛出错误后执行。当一个错误被抛出时, postprocess方法处理完后会返回true,表示错误处理已经完成。链的执行并不会就此结束,但是本质上来说这个错误被捕捉而且不会再向外抛出。如果postprocess方法返回false,那错误会继续向外抛出,然后链就会非正常结束。

让我们假设ArrangeFinancing因为用户信用卡损坏抛出错误。SellVehicleExceptionHandler就能捕捉到这个错误,程序输出如下:
Filter.execute() called.
Get customer info
Test drive the vehicle
Negotiate sale
Exception Bad credit occurred.


结合了过滤器(filter)和子链技术后,你就可以造型很复杂的工作流程。

Commons Chain是一个很有前途的框架,现在仍在开发,新的功能被频繁地添加到其中。在下一篇关于Commons Chain的文章中,我们将研究Struts 1.3中是如何使用Commons Chain的。

Struts 1.3中用完全使用Commons Chain的类替换了原来的处理HTTP请求的类。如果你以前自己定制过Struts的请求处理(request processor),你将发现处理这个问题时Commons Chain为程序带来了很好的灵活性。
 
分享到:
评论

相关推荐

    org.apache.commons 系列源文件

    5. **Commons Chain** (commons-chain-1.2-src.zip): Chain 提供了一种可配置的命令链(Chain of Responsibility)模式实现,用于构建和执行复杂的业务流程。开发者可以定义一系列处理命令,并根据需要组合它们,...

    SpringMVC依赖包

    5. **commons-chain**:它提供了一种定义和执行命令链的方式,这在 Spring MVC 中可以用于实现复杂的业务逻辑流程,通过定义一系列处理步骤,按顺序或条件执行。 6. **commons-digester**:这是一个 XML 解析器,...

    s2sh整合中jar包作用介绍

    11. commons-chain-1.2.jar:Apache Commons Chain库,实现命令模式和责任链模式,常用于业务流程控制。 12. 其他Jakarta Commons库:如commons-包含其他Apache Commons项目的组件,增强Java的功能。 五、总结: S2...

    信息安全_数据安全_AppSecEU2016-Ikka-Turunen-Chain-of-Trust.pdf

    进一步分析显示,组织从中央仓库下载的组件中,有相当一部分含有已知漏洞和限制性许可证。这意味着在质量控制方面存在缺陷,可能导致安全隐患的引入。例如,OpenSSL在2014年的几个高知名度漏洞(如CVE-2014-3470、...

    JSP中文乱码解决集锦

    可以使用第三方库如Apache Commons FileUpload或Spring MVC的MultipartFile来处理文件上传,它们通常内置了对多部分请求的正确编码处理。 总之,解决JSP中文乱码问题的关键在于确保整个请求处理链中的字符编码一致...

    SSH整合类库分析spring3.0.4+hibernate3.5.5+struts2.2.1

    除了SSH框架的直接依赖,还有一些共同使用的第三方库,如: 1. `aopalliance-1.0.jar`:提供AOP联盟接口,Spring和其他AOP框架遵循的标准。 2. `classworlds-1.1.jar`:类加载器框架,用于动态加载类。 3. `commons...

    较全的struts1.3.8-apps

    7. **其他依赖的第三方库**,如Commons Logging、Commons Chain、Commons FileUpload等,这些都是Struts框架正常运行所必需的。 此外,可能还有配置文件如`struts-config.xml`,这是Struts应用的主要配置文件,定义...

    chap8.rar

    标题“chap8.rar”可能指的是一个压缩文件,其中包含了第8章或第8部分的相关内容。由于标签为空,我们无法直接获取更多的上下文信息。不过,我们可以根据常见的压缩文件使用场景来推测可能包含的知识点。 在IT行业...

    mina框架开发全部相关jar包

    教程部分通常会有逐步指导,帮助开发者从零开始搭建一个简单的Mina应用。 4. **使用Mina框架的优点**: - **高性能**:Mina利用了Java NIO,可以处理大量的并发连接。 - **模块化**:Mina的Filter Chain设计允许...

    GoF Design Patterns with examples using Java and UML2

    ### 第一章:创建型模式 #### 1.1 工厂模式(Factory) 工厂模式是一种用于创建对象的接口,但允许子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。 #### 1.2 抽象工厂模式(Abstract Factory) ...

    struts相关的jar包文件

    5. **第三方依赖**:Struts可能依赖于其他库,如`commons-logging.jar`(日志服务抽象层)、`commons-chain.jar`(业务流程管理)、`commons-digester.jar`(XML解析)、`commons-fileupload.jar`(文件上传)和`...

    Struts1与Struts2本质区别

    - **Struts 1**:使用`Commons-Beanutils`进行类型转换,但转换器不可配置,缺乏灵活性。 - **Struts 2**:使用OGNL进行类型转换,支持更多的数据类型转换,提高了灵活性。 #### 9. 数据校验的对比 - **Struts 1**...

    OGNL中文参考手册.pdf

    - 从字符数组中取出第一个字符(索引为0)。 - 调用`Character`对象的`getNumericValue()`方法获取字符的数值。 - 最后将得到的整型数值转换为字符串。 #### 五、OGNL表达式详解 - **表达式结构**: - 属性...

    Struts1.xpdf文件

    Struts 1.x是Apache Struts框架的第一个版本,它是一个用于开发Java Web应用程序的开源MVC(Model-View-Controller)框架。Struts 1.x的设计目的是为了解决Web应用程序开发中的常见问题,比如将业务逻辑与用户界面...

    java 框架总结

    - **Chain**:执行一系列Action。 ##### 4. 通配符映射规则 - **匹配原则**:当存在多个匹配项时,无通配符的优先。 - **通配符使用**: - `*`:匹配零个或多个字符(不包括`/`)。 - `{n}`:匹配第n个子串。 ...

    第十九讲:职责链模式

    一个请求会作为参数传递给链上的第一个对象,该对象可以选择处理请求或者将请求传递给链中的下一个对象。这种模式在事件驱动或回调机制中尤其常见,例如在某些框架或工具的实现中。 博客文章“第十九讲:职责链模式...

    OGNL Language Guide 中文版

    - 获取数组的第一个字符。 - 获取该字符的 `numericValue` 属性。 - 将结果转换为字符串。 - **注意事项**: 该示例仅能用于获取值,不能用于赋值。 #### 四、OGNL表达式 - **表达式类型**: - **常量**: 数字...

    struts2简明参考

    **环境搭建** 是使用任何框架的第一步,对于Struts2来说也不例外。以下是详细的环境搭建步骤: 1. **下载必要的JAR包**:为了构建一个最基础的Struts2项目,你需要以下JAR包: - `struts2-core-2.0.12.jar`:...

    JavaWeb中的监听器与过滤器

    - **创建**:当第一次调用`request.getSession()`方法时,如果还没有为该用户创建过`HttpSession`对象,则会创建一个新的`HttpSession`对象。 - **销毁**:默认情况下,如果`HttpSession`对象30分钟内没有活动,则...

Global site tag (gtag.js) - Google Analytics