Business Process Management，BPM）不是一个新概念，甚至不是一个新名词。它是从相关的业务流程变革领域，如业务流程改进（BPI）、业务流程重组（BPR）、业务流程革新中发展起来的。流程管理技术也是从早期的工作流管理、EAI企业应用集成（Enterprise Application Integration，）、流程自动化、流程集成、流程建模、流程优化等技术中发展起来的。

BPM管理系统能够提供方便迅速分析业务流程、商业数据的工具，以便企业决定用最适和流程引导商业目的的实现。也就是BPM必须能用一种通用的语言传达给商业伙伴对于特殊业务流程的清晰明确的描述。 
BPM的定义是：BPM是一个描述一组服务和工具的一般名词，这些服务和工具为显式的流程管理(如流程的分析、定义、执行、监视和管理)提供支持。

目前，BPM方面的研究主要集中在： 
◎ 理论基础：BPM的体系、模型、定义语言的研究； 
◎ 实现技术：BPM的仿真和评估；流程的事务特性；Web Service、XML、组件技术等在BPM中的应用
◎ 应用：BPM的实施技术；在不同领域内的应用方法。

BPM的生命周期 
             

从整体上将BPM生命周期划分为五个阶段，分别是：业务流程发掘（Business Process Discovery）、业务流程设计（Business Process Design）、业务流程执行（Business Process Execution）、业务流程管理维护(Business Process Administration)，以及业务流程最优化（Business Process Optimization）。对于这五个阶段，各个厂商之间并不存在过多的异议。

1. 业务流程发掘 
企业要全面应用BPM，首先面临的工作当然是要搞清楚知道企业现行流程的工作方式与工作状况，这是后续所有工作的出发点和基石，因此理应得到足够的重视。其中，最为重要的是当前流程中的信息流(Message flow)、事件流(Event flow)以及控制流(Control flow)。更为具体一点，企业需要了解哪些流程可以实施自动化？哪些流程需要人工参与？各个流程都是需要什么人来参与？需要多少人？相关流程是在组织内部执行，还是在外部被执行？风险如何评估？现有流程的瓶颈可能位于哪个环节？诸如此类，不一而足。在这个阶段，通常有两个方面的工作需要进行。第一个工作是进行流程评估(BPA，Business Process Assessment)，一般的做法是聘请企业外部的顾问管理公司或者行业专家进行，评估的范围可能涵盖策略与管理目标与流程的连结。完成了流程评估之后，接下来就是配合导入一些管理主题（譬如ISO质量管理体系或六西格玛等），进行流程再造(BPR，Business Process Reengineering)。然后，将得到的信息和数据反馈到第二个阶段。 
2. 业务流程设计 
这个阶段是根据前期的工作对未来进行流程的定位和设计。本阶段分为四个步骤，分别是建模(Modeling)、分析(Analyzing)、模拟 (Simulation)和流程重构(Redesigning)。如图1所示，这四个步骤是一个反复的循环，循环的目的是力求得到更准确、更有价值的业务流程。 
首先是建模，通常我们将建模所采用的工具称作Process Designer（进程设计器），一般来说它包括四个比较重要的部分：结构表格(Organization Chart)、流程图(Activity Diagram)、商业规则（Business Rule），以及电子窗体(e-Form)设计工具（电子窗体指的是信息显现的接口，一般而言企业可以把应用系统的数据与流程相关的数据，通过电子窗体来展现，这样做有助于处理第三个阶段中人机互动的步骤，而呈现的方式则可以通过特定的工具进行快速的订制）， 
分析是从流程定义的语意与理论上进行推论，仿真则可设定机率变量与行为假设让系统自动跑出期望值或变异差数据。市场上有些产品则仅提供自动执行(Automation)或手动逐步执行以观测流程行为。 
需要注意的是，建模并不是孤立的，在建模之后企业一定要进行流程执行动作前的分析与仿真，以便验证设计出来的流程是否正确并且适用于本企业，此外它还能提供初步设计的流程可能遇到的瓶颈信息，以避免在业务流程执行后才发现相关问题进而导致重大的运营损失。与此同时，如果分析和模拟出来的结果并不尽如人意，可以多次反复和循环本阶段的四个步骤，直至满意为止。这样做的好处还在于，面对外部巨大的竞争压力与种种商机，企业在进行经营和管理中（非模拟状态），对于一些细微的流程变化(Fine-grained process change)，可以做出实时有效的反应，以便于企业快速地进行重构流程的工作。 
3. 业务流程执行 
经过多次的建模、分析、仿真和确定了企业的业务流程之后，接下来面临的就是流程的执行。 
业务流程的执行分为三个步骤，分别是部署（deployment）、自动操作（automation）和人机交互（interaction）这三个步骤并非一个循环的关系，而是由部署引出自动操作和人机交互两个步骤，自动操作与人机交互并行进行。 
布署是将设计好的流程推出上线，并且让所有的参与者来执行。这里所说的参与者是泛指的，它可能是人，也可能是某些系统应用或者其他流程。对于这个步骤，企业的主要目的应该是以最少的工作量达到运算资源(Computing Resource)与组织人员的优化和整合，最少的工作量并不意味着偷工减料或者有意地减少工作，其目的是减少企业资源占有，降低成本，从而达到效益的最大化。 
在自动操作这一步骤中，负责控制执行的模块我们可称之为工作流引擎(Workflow Engine)或流程服务器(Process Server)。这个步骤具有一个重要的特点，那就是无需技术人员的亲自参与，流程的使用者依然可以自行编辑和修改既有的商业逻辑。企业可以借助调度日程 (Scheduler) 来设定启动自动操作的时间和周期频率，另外有些厂商提供的BPM解决方案还会提供规则引擎 (Rule Engine)来进行商业规则的判别与推理。 
通常情况下，并非企业的所有流程都可以自动操作，因此BPM还应提供能够让人管理自动流程与人工流程之间的接口（有的时候这种流程接口本身也是一个流程）。负责与人互动的接口被称为工作项目处理器 (Workitem Handler)。几年前工作项目处理器大都比较简单，然而在实际工作中，由于种种原因，企业往往需要的是那种能订制、个性化，并且能整合在不同系统的接口，因此很多厂商纷纷推出了更加符合用户需求的流程入口(Process Portal)。应当说，这是一个可喜的变化。 
4. 业务流程管理维护 
当流程上线后，伴随而来的自然是管理维护的问题，这其中包括三个步骤的工作：运行（operation）、维护（maintaining）和监测（Activity monitoring）。如图1所示，这三个工作并行进行，相互之间不存在递进或者循环的关系。 
前两个步骤相对简单，这里不再赘述，我们重点关注一下流程的监测。由于在运营中，企业内外部各种状况不断出现，人员组织也会出现一些变更以及其他一些变化，业务流程的使用者或管理者需要随时掌握流程的执行状态与过程，因此他们就要求系统具备预警功能，同时可以让他们设定流程要追踪的关卡，并得到系统主动回报相关信息，及时处理相关问题。另外，服务器的流量与执行监控及流程存储（Process Repository）的数据维护功能也相当重要。 
5. 业务流程最佳化 
这是所有五个阶段的最后一步，也是业务流程管理系统生命周期迈入下一个循环的“前夜”，不是终结，而是开始。本阶段包括三个步骤:测定（Measurement）、报告（Reporting）和改进（Improvement）。三者呈逐步推进的关系，缺一不可。 
测定能够向使用者和管理者提供流程的执行效率；通过报告工具（Reporting Tool），企业可以对自己的组织行为有充分的了解，并将之作为持续改善的依据，这样企业才有可能策划出改进与最佳化的策略；改进是个持续性的活动，不断反复，朝向最佳化迈进。 
有专家指出，这个阶段跟商业智能(BI， Business Intelligence)的技术与主题有异曲同工之处，不过我们应该看出，它们之间的差异在于BPM可以自动记录和收集与流程有关的数据，让企业主管清楚哪些流程是在标准差内，哪些是在失控状态。同时，系统提供的报表都是使用者自行定义或查询的，而且无需IT人员的参与。 
从整个生命周期中，BPM的重点在： 
◎ 业务流程的分析(BPA)和设计(BPD)； 
◎ 业务流程的改进(BPI)和优化(BPO)； 
◎ 业务流程自动化(BPA)； 
◎ 业务过程集成(BPI)； 
◎ 业务过程重组(BPR)——革命性变更； 
◎ 业务过程外包(BPO)——聚焦核心业务。

BPM的未来趋势 
               
我们期望最后为客户达到以下5点： 
图形化工具——设计来分析，模块和定义流程。这些工具专为需要建立流程流和设计新流的业务分析人员设计。这些流然后为将来执行而设定。 
运行时间执行引擎——这是一个根本的统计机器执行定义流程流。随着流程流的执行，引擎可能要求自动服务或任务必须人力完成。服务可能由程序提供–遗留和新的服务–或通过企业可能是交易伙伴或分包商。运行时间环境维持每个流程当时的状态。 
机敏工具——这个功能涉及流程调整，工作单管理和优先工作。 
监控和管理流的工具——监控可能包括流程表现，完成程度或呼出条件，流程管理可能包括流程终止，扑救流程，工作平衡和重新流转。 
完成后分析工具——这些工具用收到的统计数据衡量和调整业务流程。

This chapter provides an overview of the JavaFX™ Script programming language. At a high level, this chapter describes the programming language's main features, saving detailed coverage of specific constructs for subsequent chapters. This book is intended for designers and developers of rich Internet client applications and elements, that run in web pages, as Java™ Web Start software, or as traditional desktop applications. Its content assumes the reader is familiar with either the JavaScript or Java™ programming language, or both. While this document does not define a formal language specification, it can be considered a complete reference for all currently supported language features.

本章提供了JavaFx脚本编程语言的一个概览。本章概述了这门编程语言的主要特性，后续章节将会详细介绍这些特性的细节。本书适用于副Internet客户端应用的设计者和开发者。这些应用可以作为Java Web Start软件运行在网页中或者作为传统的桌面应用。本书假定读者熟悉了javascript或java编程语言或者两者都熟悉。但是本书并不是正式的语言规范，可仅仅做为当前JavaFx支持的语言特性的一个完整的参考。

The JavaFX Script programming language has the following distinctions:

JavaFX脚本编程语言有如下的语言特色：

The following sections present a quick tour of the JavaFX Script programming language. These sections provide a general introduction to its core syntax and capabilities, comparing and contrasting to the Java programming language where appropriate. Each topic is then covered in greater detail in subsequent chapters.

接下来的小节是JavaFX脚本编程语言的一个快速指南，介绍了JavaFx的关键语法和能力，并且比较了它跟java编程语言之间的差异，每个主题将在后续的章节中详细的介绍。

var ten : Integer = 10;

java.lang.System.out.println("Twice {ten} is {2 * ten}.");   

Twice 10 is 20.

class Rectangle {



attribute width: Integer;

attribute height: Integer;



function grow(): Void {

grow(1);

}



function grow(amount: Integer): Void {

width += amount;

height += amount;

}



}

Rectangle {



width: 100

height: 100



}

var myRect = Rectangle {



width: 100

height: 100

}

var week = ["Monday","Tuesday","Wednesday","Thursday",

"Friday","Saturday","Sunday"];

var mon = week[0];

var wed = week[2];

var fri = week[4];

var week = ["Monday","Tuesday","Wednesday","Thursday",

"Friday","Saturday","Sunday"];

var weekdays = week[0..4]; // first slice

var weekend = week[5..6]; // second slice

import javafx.application.Frame;

import javafx.application.Stage;

import javafx.scene.text.Text;



var myString = "Hello World!";



Frame {

width: 50

height: 50

visible: true

stage: Stage {

content: Text {

content: bind myString

}

}

}



// If some other part of code changes myString

// then the GUI's text will automatically change

// as well.

import java.lang.System;



ReplaceDemo {



mySensitiveData: "Will anyone notice?"



}



class ReplaceDemo {

attribute mySensitiveData: String

on replace {

System.out.println("I noticed a change!");                      

};



// application-specific safeguarding code would go here 

}

接下来的推导分为两个阶段，第一阶段先推导支撑技术，第二阶段再推导以什么样的开发方式将这些支撑技术串起来，达到快速开发的目的。

下表中列出了对上面的核心组成要素（数据+服务）的一些支撑技术：

下面在列一些辅助支撑技术，这些技术是为了让企业应用这些大厦能够构建的更快，毕竟盖房子，有了水泥和砖是不够的，还要有扁担，簸箕等等。

Java 5 在 Java Database Connectivity (JDBC) 方面加强了支持，其中加入了新的包 javax.sql.rowset，javax.sql.rowset.serial，javax.sql.rowset.spi。本文将通过实例来演示这些新的特性。

RowSet 新特性简介

Java 5在Java Database Connectivity (JDBC)方面加强了支持，其中加入了新的包javax.sql.rowset，javax.sql.rowset.serial，javax.sql.rowset.spi。从RowSet接口继承规定了五个新的接口：

1. CachedRowSet： CachedRowset可以不用与数据源建立长期的连接，只有当从数据库读取数据或是往数据库写入数据的时候才会与数据库建立连接，它提供了一种轻量级的访问数据库的方式，其数据均存在内存中。

2. JdbcRowSet：对ResultSet的对象进行包装，使得可以将ResultSet对象做为一个JavaBeans ™ 组件。

3. FilteredRowSet：继承自CachedRowSet，可以根据设置条件得到数据的子集。

4. JoinRowSet：继承自CachedRowSet，可以将多个RowSet对象进行SQL Join语句的合并。

5. WebRowSet：继承自CachedRowSet，可以将WebRowSet对象输出成XML格式。

下面分别演示如何使用这五个新接口。

实验环境

IBM DB2 Universal 8.1
数据库名：DemoDB
数据库用户名：db2admin
数据库密码：password

回页首

CachedRowSet

CachedRowSet可以通过调用populate(ResuletSet rs)来生成数据，一旦获得数据，CachedRowSet就可以断开与数据库的连接，直到往数据库写入数据的时候才需建立连接。

可以使用自己扩展的或是使用Reference Implement的实现类进行访问数据库。下面的代码演示了如何根据ResultSet建立一个CachedRowSet对象，在中断与数据库连接的情况下，读取数据，并做更新，最后再获取数据库连接，将更新落实到数据库中。

												
														public static void testCachedRowSet(){
	Connection conn = null;
	try {
		// 获得数据库连接
	    conn= DriverManager.getConnection(DB2URL, DB2USER, DB2PASSWORD);
	    Statement stmt = conn.createStatement();
	    // 查询数据库，获得表数据
	    ResultSet rs = stmt.executeQuery("select * from student");//$NON-NLS-1$
	    // 根据ResultSet对象生成CachedRowSet类型的对象
	    CachedRowSetImpl crs = new CachedRowSetImpl();
	    crs.populate(rs);
	    // 关闭ResultSet
		rs.close();
	    // 关闭数据库的连接
	    conn.close();
	    // 在中断与数据库连接的情况下，对CachedRowSet进行操作
	    operateOnRowSet(crs);
	    // 重新获取与数据库的连接
	    conn= DriverManager.getConnection(DB2URL, DB2USER, DB2PASSWORD);
	    // 将CachedRowSet的内容更新到数据库
	    crs.acceptChanges(conn);
	    // 关闭CachedRowSet
	    crs.close();
	    // 关闭数据库连接
	    conn.close();
	} catch (InstantiationException e) {
	    System.out.println("Andrew: InstantiationException!");//$NON-NLS-1$
	} catch (IllegalAccessException e) {
	    System.out.println("Andrew: IllegalAccessException!");//$NON-NLS-1$
	} catch (ClassNotFoundException e) {
	    System.out.println("Andrew: ClassNotFoundException!");//$NON-NLS-1$
	}catch (SQLException e) {
	  	System.out.println("Andrew: SQLException!");//$NON-NLS-1$
		e.printStackTrace();
	}	
}

												
										

其中operateOnRowSet方法遍历读取RowSet中的元素，并将id值加1。RowSet允许注册监听器，可以在光标移动，RowSet发生改变时触发。其具体代码如下：

												
														public static void operateOnRowSet(RowSet rs){
	// 为RowSet注册监听器
	MyRowsetListener myListener = new MyRowsetListener();
    rs.addRowSetListener(myListener);
    // 操作RowSet数据
	try{
		// 遍历读取数据
		while (rs.next()) {
			String id = rs.getString("ID");//$NON-NLS-1$
	        String name = rs.getString("NAME");//$NON-NLS-1$
	        System.out.println("ID="+id+",NAME="+name);//$NON-NLS-1$
	        //在id最末位连接"1"
	        rs.updateString(1, id+"1");
	    }
	}catch (SQLException e) {
	    System.out.println("Andrew: SQLException!");//$NON-NLS-1$
		e.printStackTrace();
	}
}
class MyRowsetListener implements RowSetListener{
	// 光标发生移动
	public void cursorMoved(RowSetEvent event) {
		System.out.println("cursor moved");
	}
	// row发生改变
	public void rowChanged(RowSetEvent event) {
		System.out.println("row changed");
	}
	// RowSet发生改变
	public void rowSetChanged(RowSetEvent event) {
		System.out.println("row set changed");
	}
}
public static void main(String[] args) {
	try {
		Class.forName(DB2DRIVER).newInstance();
	} catch (InstantiationException e) {
		System.out.println("Andrew: InstantiationException!");//$NON-NLS-1$
	} catch (IllegalAccessException e) {
		System.out.println("Andrew: IllegalAccessException!");//$NON-NLS-1$
	} catch (ClassNotFoundException e) {
		System.out.println("Andrew: ClassNotFoundException!");//$NON-NLS-1$
	}
	testCachedRowSet();
}

												
										

上面的程序的运行结果如下：

												
														cursor moved
ID=001,NAME=zhou
cursor moved
ID=002,NAME=zhang
cursor moved
cursor moved
cursor moved
cursor moved
cursor moved
cursor moved
row set changed

												
										

并且数据库中的id更新为0011，0021。

回页首

JdbcRowSet

JdbcRowSet功能与ResultSet类似，与CachedRowSet不同，JdbcRowSet在操作时保持与数据库的连接。可以将与数据库连接的URL，用户名，密码以及执行的SQL语句通过setXXX形式绑定。另外，JdbcRowSet返回的结果默认是可以上下滚动和可更新的，当然这需要数据库厂商提供的JDBC Driver支持。下面的代码演示了如何通过set方法设定数据库连接参数，以及如何操作JdbcRowSet对象。

												
														public static void testJdbcRowSet() {
	JdbcRowSetImpl jrs = new JdbcRowSetImpl();
	try {
		// 设置连接数据库的URL
		jrs.setUrl(DB2URL);
		// 设置连接数据库的用户名
		jrs.setUsername(DB2USER);
		// 设置连接数据库的密码
		jrs.setPassword(DB2PASSWORD);
		// 设置执行数据库的SQL语句
		jrs.setCommand("select * from student");
		// 执行操作
		jrs.execute();
		// 对获得的JdbcRowSet进行操作
		operateOnRowSet(jrs);
		// 关闭JdbcRowset
		jrs.close();
	} catch (SQLException e) {
		System.out.println("Andrew: SQLException!");//$NON-NLS-1$
		e.printStackTrace();
	}
}

public static void operateOnRowSet(RowSet rs) {
	// 为RowSet注册监听器
	MyRowsetListener myListener = new MyRowsetListener();
	rs.addRowSetListener(myListener);
	// 操作RowSet数据
	try {
		// 遍历读取数据
		while (rs.next()) {
			String id = rs.getString("ID");//$NON-NLS-1$
			String name = rs.getString("NAME");//$NON-NLS-1$
			System.out.println("ID=" + id + ",NAME=" + name);//$NON-NLS-1$
		}
	} catch (SQLException e) {
		System.out.println("Andrew: SQLException!");//$NON-NLS-1$
		e.printStackTrace();
	}
}
	
												
										

其运行结果如下：

												
														cursor moved
ID=0011,NAME=zhou
cursor moved
ID=0021,NAME=zhang
cursor moved

												
										

回页首

FilteredRowSet

FilteredRowSet接口中规定了可以设定过滤器，其过滤接口为Predicate接口，必须实现Predicate接口中的evaluate方法。具体的代码如下：

												
														public static void testFilteredRowSet() {
	try {
		// 获得数据库连接
		Connection conn = DriverManager.getConnection(DB2URL, DB2USER,
			DB2PASSWORD);
		Statement stmt = conn.createStatement();
		// 查询数据库，获得表数据
		ResultSet rs = stmt.executeQuery("select * from student");//$NON-NLS-1$
		FilteredRowSet frs = new FilteredRowSetImpl();
		frs.populate(rs);
		// 设置过滤器
		MyDBFilter filter = new MyDBFilter(11, 100);
		frs.setFilter(filter);
		operateOnRowSet(frs);
		// 关闭FilteredRowSet
		frs.close();
		// 关闭与数据库的连接
		conn.close();
	} catch (SQLException e) {
		System.out.println("Andrew: SQLException!");//$NON-NLS-1$
		e.printStackTrace();
	}
}

public static void operateOnRowSet(RowSet rs) {
	// 为RowSet注册监听器
	System.out.println("operateOnRowSet!");//$NON-NLS-1$
	MyRowsetListener myListener = new MyRowsetListener();
	rs.addRowSetListener(myListener);
	// 操作RowSet数据
	try {
		// 遍历读取数据
		while (rs.next()) {
			String id = rs.getString("ID");//$NON-NLS-1$
			String name = rs.getString("NAME");//$NON-NLS-1$
			System.out.println("ID=" + id + ",NAME=" + name);//$NON-NLS-1$
		}
	} catch (SQLException e) {
		System.out.println("Andrew: SQLException!");//$NON-NLS-1$
		e.printStackTrace();
	}
}

public static void main(String[] args) {
	try {
		Class.forName(DB2DRIVER).newInstance();
	} catch (InstantiationException e) {
		System.out.println("Andrew: InstantiationException!");//$NON-NLS-1$
	} catch (IllegalAccessException e) {
		System.out.println("Andrew: IllegalAccessException!");//$NON-NLS-1$
	} catch (ClassNotFoundException e) {
		System.out.println("Andrew: ClassNotFoundException!");//$NON-NLS-1$
	}
	testFilteredRowSet();
}

												
										

其中MyDBFilter实现了Predicate接口，其实现代码如下：

												
														class MyDBFilter implements Predicate {
	private int low;
	private int high;
	public MyDBFilter(int low, int high) {
		this.low = low;
		this.high = high;
	}
	public boolean evaluate(RowSet rs) {
		CachedRowSet crs=(CachedRowSet)rs;
		//如果id在low和high之间返回真
		try {
			String id = (String) crs.getString("id");
			int idValue = Integer.parseInt(id);
			if (low < idValue && idValue < high) {
				return true;
			}
		} catch (SQLException e) {
			
		}
		return false;
	}
	public boolean evaluate(Object arg0, int arg1) throws SQLException {
		return false;
	}

	public boolean evaluate(Object arg0, String arg1) throws SQLException {
		return false;
	}
}

												
										

其运行结果如下：

												
														cursor moved
ID=0021,NAME=zhang
cursor moved

												
										

回页首

JoinRowSet

JoinRowSet可以将多个RowSet对象进行join合并，Join的列可以通过每个RowSet通过调用setMatchColumn方法来设置。setMatchColumn方式是Joinable接口定义的方法，五种类型的RowSet规定都需要实现该接口。下面的代码演示将student表和intern表中id相同的数据进行join操作。JoinRowSet不需要保持与数据库的连接。

												
														public static void testJoinRowSet(){
	Connection conn = null;
	try {
		JoinRowSet jrs = new JoinRowSetImpl();
		// 获得数据库连接
		conn = DriverManager.getConnection(DB2URL, DB2USER, DB2PASSWORD);
		Statement stmt = conn.createStatement();
		// 查询数据库，获得表数据
		ResultSet rs1 = stmt.executeQuery("select id,name from student");//$NON-NLS-1$
		// 根据ResultSet对象生成CachedRowSet类型的对象
		CachedRowSetImpl crs1 = new CachedRowSetImpl();
		crs1.populate(rs1);
		crs1.setMatchColumn(1);
		// 关闭ResultSet
		jrs.addRowSet(crs1);
		rs1.close();
		
		// 查询数据库，获得表数据
		ResultSet rs2 = stmt.executeQuery("select id,company from intern");//$NON-NLS-1$
		// 根据ResultSet对象生成CachedRowSet类型的对象
		CachedRowSetImpl crs2 = new CachedRowSetImpl();
		crs2.populate(rs2);
		crs2.setMatchColumn(1);
		// 关闭ResultSet
		rs2.close();
		// 将Result2放入JoinRowSet中进行Join操作
		jrs.addRowSet(crs2);
		// 关闭数据库连接
		conn.close();
		
		while (jrs.next()) {
			String id = jrs.getString(1);
			String name = jrs.getString(2);
			String company = jrs.getString(3);
			//$NON-NLS-1$
			System.out.println("ID=" + id + ",NAME=" + name+",COMPNAY="+company);
		}
	} catch (SQLException e) {
		System.out.println("Andrew: SQLException!");//$NON-NLS-1$
		e.printStackTrace();
	}
}

												
										

其输出结果为

												
														ID=001111,NAME=zhou,COMPNAY=companyA

												
										

回页首

WebRowSet

WebRowSet继承自CachedRowSet，支持XML格式的查询，更新等操作，下面的代码将WebRowSet对象输出成XML格式到文件。

												
														public static void testWebRowSet(){
	try {
		// 获得数据库连接
		Connection conn = DriverManager.getConnection(DB2URL, DB2USER,
				DB2PASSWORD);
		Statement stmt = conn.createStatement();
		// 查询数据库，获得表数据
		ResultSet rs = stmt.executeQuery("select * from student");//$NON-NLS-1$
		WebRowSetImpl wrs = new WebRowSetImpl();
		wrs.populate(rs);
		FileOutputStream out = new FileOutputStream("data.xml");
		wrs.writeXml(out);
		wrs.close();
		// 关闭与数据库的连接
		conn.close();
	} catch (SQLException e) {
		System.out.println("Andrew: SQLException!");//$NON-NLS-1$
		e.printStackTrace();
	} catch(IOException e){
		System.out.println("Andrew: IOException!");//$NON-NLS-1$
		e.printStackTrace();
	}
}

												
										

其运行结果data.xml大致如下：

												
														<?xml version="1.0"?>
XML文件属性格式 
……
<metadata>
    <column-count>2</column-count>
    <column-definition>
      <column-index>1</column-index>
      <auto-increment>false</auto-increment>
      <case-sensitive>true</case-sensitive>
      <currency>false</currency>
      <nullable>0</nullable>
      <signed>false</signed>
      <searchable>true</searchable>
      <column-display-size>10</column-display-size>
      <column-label>ID</column-label>
      <column-name>ID</column-name>
      <schema-name>ZHOUDP  </schema-name>
      <column-precision>10</column-precision>
      <column-scale>0</column-scale>
      <table-name>STUDENT</table-name>
      <catalog-name>TEST</catalog-name>
      <column-type>12</column-type>
      <column-type-name>VARCHAR</column-type-name>
    </column-definition>
    <column-definition>
      <column-index>2</column-index>
      <auto-increment>false</auto-increment>
      <case-sensitive>true</case-sensitive>
      <currency>false</currency>
      <nullable>1</nullable>
      <signed>false</signed>
      <searchable>true</searchable>
      <column-display-size>50</column-display-size>
      <column-label>NAME</column-label>
      <column-name>NAME</column-name>
      <schema-name>ZHOUDP  </schema-name>
      <column-precision>50</column-precision>
      <column-scale>0</column-scale>
      <table-name>STUDENT</table-name>
      <catalog-name>TEST</catalog-name>
      <column-type>12</column-type>
      <column-type-name>VARCHAR</column-type-name>
    </column-definition>
  </metadata>
  <data>
    <currentRow>
      <columnValue>0011</columnValue>
      <columnValue>zhou</columnValue>
    </currentRow>
    <currentRow>
      <columnValue>0021</columnValue>
      <columnValue>zhang</columnValue>
    </currentRow>
  </data>
</webRowSet>

												
										

“Java 认证和授权服务”（Java Authentication and Authorization Service，JAAS）是对 Java 2 SDK 的扩展。在 JAAS 下，可以给予用户或服务特定的许可权来执行 Java 类中的代码。在本文中，软件工程师 Carlos Fonseca 向您展示如何为企业扩展 JAAS 框架。向 JAAS 框架添加类实例级授权和特定关系使您能够构建更动态、更灵活并且伸缩性更好的企业应用程序。请单击文章顶部或底部的 讨论，在 讨论论坛与作者和其他读者分享您对本文的想法。

大多数 Java 应用程序都需要某种类实例级的访问控制。例如，基于 Web 的、自我服务的拍卖应用程序的规范可能有下列要求：

任何已注册（经过认证）的用户都可以创建一个拍卖，但只有创建拍卖的用户才可以修改这个拍卖。

这意味着任何用户都可以执行被编写用来创建 Auction 类实例的代码，但只有拥有该实例的用户可以执行用来修改它的代码。通常情况下，创建 Auction 实例的用户就是所有者。这被称为 类实例所有者关系（class instance owner relationship）。

该应用程序的另一个要求可能是：

任何用户都可以为拍卖创建一个投标，拍卖的所有者可以接受或拒绝任何投标。

再一次，任何用户都可以执行被编写用来创建 Bid 类实例的代码，但只有拥有该实例的用户会被授予修改该实例的许可权。而且， Auction 类实例的所有者必须能够修改相关的 Bid 类实例中的接受标志。这意味着在 Auction 实例和相应的 Bid 实例之间有一种被称为 特定关系（special relationship）的关系。

不幸的是，“Java 认证和授权服务”（JAAS）― 它是 Java 2 平台的一部分 ― 没有考虑到类实例级访问控制或者特定关系。在本文中，我们将扩展 JAAS 框架使其同时包含这两者。推动这种扩展的动力是允许我们将访问控制分离到一个通用的框架，该框架使用基于所有权和特定关系的策略。然后管理员可以在应用程序的生命周期内更改这些策略。

在深入到扩展 JAAS 框架之前，我们将重温一下 Java 2 平台的访问控制机制。我们将讨论策略文件和许可权的使用，并讨论 SecurityManager 和 AccessController 之间的关系。

Java 2 平台中的访问控制

在 Java 2 平台中，所有的代码，不管它是本地代码还是远程代码，都可以由策略来控制。 策略（policy）由不同位置上的代码的一组许可权定义，或者由不同的签发者定义、或者由这两者定义。 许可权允许对资源进行访问；它通过名称来定义，并且可能与某些操作关联在一起。

抽象类 java.security.Policy 被用于表示应用程序的安全性策略。缺省的实现由 sun.security.provider.PolicyFile 提供，在 sun.security.provider.PolicyFile 中，策略被定义在一个文件中。清单 1 是一个典型策略文件示例：

														
																// Grant these permissions to code loaded from a sample.jar file
// in the C drive and if it is signed by XYZ
grant codebase "file:/C:/sample.jar", signedby "XYZ" {
	// Allow socket actions to any host using port 8080
	permission java.net.SocketPermission "*:8080", "accept, connect, 
	  listen, resolve";
	// Allows file access (read, write, execute, delete) in
	// the user's home directory.
	Permission java.io.FilePermission "${user.home}/-", "read, write, 
	  execute, delete";
};

														
												

SecurityManager 对 AccessController

在标准 JDK 分发版中，控制代码源访问的机制缺省情况下是关闭的。在 Java 2 平台以前，对代码源的访问都是由 SecurityManager 类管理的。 SecurityManager 是由 java.security.manager 系统属性启动的，如下所示：

														
																java -Djava.security.manager

														
												

在 Java 2 平台中，可以将一个应用程序设置为使用 java.lang.SecurityManager 类或者 java.security.AccessController 类管理敏感的操作。 AccessController 在 Java 2 平台中是新出现的。为便于向后兼容， SecurityManager 类仍然存在，但把自己的决定提交 AccessController 类裁决。 SecurityManager 和 AccessController 都使用应用程序的策略文件确定是否允许一个被请求的操作。清单 2 显示了 AccessController 如何处理 SocketPermission 请求：

														
																Public void someMethod() {
	Permission permission = 
	  new java.net.SocketPermission("localhost:8080", "connect");
	AccessController.checkPermission(permission);
	// Sensitive code starts here
	Socket s = new Socket("localhost", 8080);
}

														
												

在这个示例中，我们看到 AccessController 检查应用程序的当前策略实现。如果策略文件中定义的任何许可权暗示了被请求的许可权，该方法将只简单地返回；否则抛出一个 AccessControlException 异常。在这个示例中，检查实际上是多余的，因为缺省套接字实现的构造函数也执行相同的检查。

在下一部分，我们将更仔细地看一下 AccessController 如何与 java.security.Policy 实现共同合作安全地处理应用程序请求。

回页首

运行中的 AccessController

AccessController 类典型的 checkPermission(Permission p) 方法调用可能会导致下面的一系列操作：

1. AccessController 调用 java.security.Policy 类实现的 getPermissions(CodeSource codeSource) 方法。
2. getPermissions(CodeSource codeSource) 方法返回一个 PermissionCollection 类实例，这个类实例代表一个相同类型许可权的集合。
3. AccessController 调用 PermissionCollection 类的 implies(Permission p) 方法。
4. 接下来， PermissionCollection 调用集合中包含的单个 Permission 对象的 implies(Permission p) 方法。如果集合中的当前许可权对象暗示指定的许可权，则这些方法返回 true ，否则返回 false 。

现在，让我们更详细地看一下这个访问控制序列中的重要元素。

PermissionCollection 类

大多数许可权类类型都有一个相应的 PermissionCollection 类。这样一个集合的实例可以通过调用 Permission 子类实现定义的 newPermissionCollection() 方法来创建。 java.security.Policy 类实现的 getPermissions() 方法也可以返回 Permissions 类实例 ― PermissionCollection 的一个子类。这个类代表由 PermissionCollection 组织的不同类型许可权对象的一个集合。 Permissions 类的 implies(Permission p) 方法可以调用单个 PermissionCollection 类的 implies(Permission p) 方法。

CodeSource 和 ProtectionDomain 类

许可权组合与 CodeSource （被用于验证签码（signed code）的代码位置和证书）被封装在 ProtectionDomain 类中。有相同许可权和相同 CodeSource 的类实例被放在相同的域中。带有相同许可权，但不同 CodeSource 的类被放在不同的域中。一个类只可属于一个 ProtectionDomain 。要为对象获取 ProtectionDomain ，请使用 java.lang.Class 类中定义的 getProtectionDomain() 方法。

许可权

赋予 CodeSource 许可权并不一定意味着允许所暗示的操作。要使操作成功完成，调用栈中的每个类必须有必需的许可权。换句话说，如果您将 java.io.FilePermission 赋给类 B，而类 B 是由类 A 来调用，那么类 A 必须也有相同的许可权或者暗示 java.io.FilePermission 的许可权。

在另一方面，调用类可能需要临时许可权来完成另一个拥有那些许可权的类中的操作。例如，当从另一个位置加载的类访问本地文件系统时，我们可能不信任它。但是，本地加载的类被授予对某个目录的读许可权。这些类可以实现 PrivilegedAction 接口来给予调用类许可权以便完成指定的操作。调用栈的检查在遇到 PrivilegedAction 实例时停止，有效地将执行指定操作所必需的许可权授予所有的后继类调用。

回页首

使用 JAAS

顾名思义，JAAS 由两个主要组件组成：认证和授权。我们主要关注扩展 JAAS 的授权组件，但开始我们先简要概述一下 JAAS 认证，紧接着看一下一个简单的 JAAS 授权操作。

JAAS 中的用户认证

JAAS 通过添加基于 subject 的策略加强了 Java 2 中定义的访问控制安全性模型。许可权的授予不仅基于 CodeSource ，还基于执行代码的用户。显然，要使这个模型生效，每个用户都必须经过认证。

JAAS 的认证机制建立在一组可插登录模块的基础上。JAAS 分发版包含几个 LoginModule 实现。 LoginModules 可以用于提示用户输入用户标识和密码。 LoginContext 类使用一个配置文件来确定使用哪个 LoginModule 对用户进行认证。这个配置可以通过系统属性 java.security.auth.login.config 指定。一个示例配置是：

														
																java -Djava.security.auth.login.config=login.conf

														
												

下面是一个登录配置文件的样子：

														
																Example {
  com.ibm.resource.security.auth.LoginModuleExample required 
    debug=true userFile="users.xml" groupFile="groups.xml";
};

														
												

认识您的主体

Subject 类被用于封装一个被认证实体（比如用户）的凭证。一个 Subject 可能拥有一个被称为 主体（principal）的身份分组。例如，如果 Subject 是一个用户，用户的名字和相关的社会保险号可能是 Subject 的某些身份或主体。主体是与身份名关联在一起的。

Principal 实现类及其名称都是在 JAAS 策略文件中指定的。缺省的 JAAS 实现使用的策略文件与 Java 2 实现的策略文件相似 ― 除了每个授权语句必须与至少一个主体关联在一起。 javax.security.auth.Policy 抽象类被用于表示 JAAS 安全性策略。它的缺省实现由 com.sun.security.auth.PolicyFile 提供，在 com.sun.security.auth.PolicyFile 中策略定义在一个文件中。清单 3 是 JAAS 策略文件的一个示例：

														
																// Example grant entry
grant codeBase "file:/C:/sample.jar", signedby "XYZ",
  principal com.ibm.resource.security.auth.PrincipalExample "admin" {
    // Allow socket actions to any host using port 8080
    permission java.net.SocketPermission 
      "*:8080", "accept, connect, listen, resolve";
    // Allows file access (read, write, execute, delete) in
    // the user's home directory.
    Permission java.io.FilePermission 
      "${user.home}/-", "read, write, execute, delete";
};

														
												

这个示例与清单 1 中所示的标准 Java 2 策略文件相似。实际上，唯一的不同是主体语句，该语句声明只有拥有指定主体和主体名字的 subject（用户）被授予指定的许可权。

再一次，使用系统属性 java.security.auth.policy 指出 JAAS 策略文件驻留在何处，如下所示：

														
																java -Djava.security.auth.policy=policy.jaas

														
												

Subject 类包含几个方法来作为特殊 subject 执行工作；这些方法如下所示：

														
																public static Object 
  doAs(Subject subject, java.security.PrivilegedAction action)
public static Object 
  doAs(Subject subject, java.security.PrivilegedAction action)
  throws java.security.PrivilegedActionException	

														
												

注意，用来保护敏感代码的方法与“Java 2 代码源访问控制”（Java 2 CodeSource Access Control）概述中描述的方法相同。请参阅 参考资料部分以了解更多关于 JAAS 中代码源访问控制和认证的信息。

回页首

JAAS 中的授权

清单 4 显示一个授权请求的结果，该请求使用清单 3 中显示的 JAAS 策略文件。假设已经安装了 SecurityManager ，并且 loginContext 已经认证了一个带有名为“admin”的 com.ibm.resource.security.auth.PrincipalExample 主体的 Subject 。

														
																public class JaasExample {
	public static void main(String[] args) {
		...
		// where authenticatedUser is a Subject with
		// a PrincipalExample named admin.
		Subject.doAs(authenticatedUser, new JaasExampleAction());
		...
	}
}

public class JaasExampleAction implements PrivilegedAction {
	public Object run() {
		FileWriter fw = new FileWriter("hi.txt");
		fw.write("Hello, World!");
		fw.close();
	}
}	

														
												

这里，敏感代码被封装在 JaasExampleAction 类中。还要注意，调用类不要求为 JaasExampleAction 类代码源授予许可权，因为它实现了一个 PrivilegedAction 。

回页首

扩展 JAAS

大多数应用程序都有定制逻辑，它授权用户不仅仅在类上执行操作，而且还在该类的实例上执行操作。这种授权通常建立在用户和实例之间的关系上。这是 JAAS 的一个小缺点。然而，幸运的是，这样设计 JAAS 使得 JAAS 可以扩展。只要做一点工作，我们将可以扩展 JAAS，使其包含一个通用的、类实例级的授权框架。

在文章开头处我已经说明了，抽象类 javax.security.auth.Policy 被用于代表 JAAS 安全性策略。它的缺省实现是由 com.sun.security.auth.PolicyFile 类提供。 PolicyFile 类从 JAAS 格式的文件（象清单 3 中显示的那个一样）中读取策略。

我们需要向这个文件添加一个东西为类实例级授权扩展策略定义：一个与许可权语句相关的可选关系参数。

缺省 JAAS 许可权语句的格式如下：

														
																permission <permission implementation class> [name], [actions];	

														
												

我们在这个许可权语句的末尾添加一个可选的关系参数来完成策略定义。下面是新许可权语句的格式：

														
																permission <permission implementation class> 
  [name], [actions], [relationship];

														
												

在为类实例级授权扩展 JAAS 时要注意的最重要的一点是：许可权实现类必须有一个带三个参数的构造函数。第一个参数是名称参数，第二个是行为参数，最后一个是关系参数。

解析新文件格式

既然文件格式已经改变，就需要一个新的 javax.security.auth.Policy 子类来解析文件。

为简单起见，我们的示例使用了一个新的 javax.security.auth.Policy 子类 com.ibm.resource.security.auth.XMLPolicyFile ，来从 XML 文件读取策略。在实际的企业应用程序中，关系数据库更适合执行这个任务。

使用 XMLPolicyFile 类代替缺省的 JAAS 访问控制策略实现的最容易的方法是向 java.security 属性文件添加 auth.policy.provider=com.ibm.resource.security.auth.XMLPolicyFile 条目。 java.security 属性文件位于 Java 2 平台运行时的 lib/security 目录下。清单 5 是与 XMLPolicyFile 类一起使用的样本 XML 策略文件：

														
																<?xml version="1.0"?>
<policy>
    <grant codebase="file:/D:/sample_actions.jar">
      <principal classname=
        "com.ibm.resource.security.auth.PrincipalExample" name="users">
        <permission classname=
          "com.ibm.resource.security.auth.ResourcePermission"
          name="com.ibm.security.sample.Auction"
          actions="create" />
        <permission classname=
         "com.ibm.resource.security.auth.ResourcePermission"
          name="com.ibm.security.sample.Auction"
          actions="read" />
        <permission classname=
         "com.ibm.resource.security.auth.ResourcePermission"
          name="com.ibm.security.sample.Auction"
          actions="write"
          relationship="owner" />
        <permission classname=
         "com.ibm.resource.security.auth.ResourcePermission"
          name="com.ibm.security.sample.Bid"
          actions="create" />
        <permission classname=
         "com.ibm.resource.security.auth.ResourcePermission"
          name="com.ibm.security.sample.Bid"
          actions="read" />
        <permission classname=
         "com.ibm.resource.security.auth.ResourcePermission"
          name="com.ibm.security.sample.Bid"
          actions="write"
          relationship="owner" />
        <permission classname=
         "com.ibm.resource.security.auth.ResourcePermission"
          name="com.ibm.security.sample.Bid"
          actions="accept"
          relationship="actionOwner" />
    </principal>
  </grant>
</policy>	

														
												

在这个示例策略文件中，任何与名为 PrincipalExample 的用户有关的用户（ Subject ）都可以创建并读取一个 Auction.class 实例。但是，只有创建该实例的用户才可以更新（写）它。这是第三个 permission 元素定义的，该元素包含值为 owner 的 relationship 属性。 Bid.class 实例也是一样，除了相应 Auction.class 实例的所有者可以更改投标接受标志。

Resource 接口

要求类实例级访问控制的类必须实现 Resource 接口。该接口的 getOwner() 方法返回类实例的所有者。 fulfills(Subject subject, String relationship) 方法被用于处理特定关系。另外，这些类使用 com.ibm.resource.security.auth.ResourcePermission 类保护敏感代码。例如， Auction 类拥有下列构造函数：

														
																public Auction() {
  Permission permission = 
    new ResourcePermission("com.ibm.security.sample.Auction", "create");
  AccessController.checkPermission(permission);
	}	

														
												

所有者关系

ResourcePermission 类的 implies(Permission p) 方法是这个框架的关键。 implies() 方法就等同性比较名称和行为属性。如果定义了一个关系，那么必须把受保护的类实例（ Resource ）传递到 ResourcePermission 构造函数中。 ResourcePermission 类理解所有者关系。它将类实例的所有者与执行代码的 subject（用户）进行比较。特定关系被委托给受保护类的 fulfills() 方法。

例如，在清单 5 中所示的 XML 策略文件中，只有 Auction 类实例的所有者可以更新（写）文件。该类的 setter 方法使用清单 6 中显示的保护代码：

														
																public void setName(String newName) {
  Permission permission = 
    new ResourcePermission("com.ibm.security.sample.Auction", "write", this);
  AccessController.checkPermission(permission);
  // sensitive code
  this.name = newName;
}

														
												

被传递到 ResourcePermission 构造函数中的 this 引用代表 Auction 类实现的 Resource 接口。由于策略文件中列出的关系是 owner，所以 ResourcePermission 类使用这个引用检查当前 Subject （用户）是否拥有与实例所有者相匹配的主体。如果指定了另一个关系，那么 ResourcePermission 类调用 Auction 类的 fulfills(Subject subject, String relationship) 方法。由 Resource 实现类提供 fulfills() 方法中的逻辑。

XML 策略文件中列出的 Bid 类拥有清单 7 中所示的方法（假设 Bid 类实例有一个对相应 Auction 类实例的引用 ― auction）。

														
																public void setAccepted(boolean flag) {
  Permission permission = 
    new ResourcePermission("com.ibm.security.sample.Auction", "accept", this);
  AccessController.checkPermission(permission);
  // sensitive code
  this.accepted = flag;
  }
	
public boolean fulfills(Subject user, String relationship) {
  if( relationship.equalsIgnoreCase("auctionOwner") ) {
    String auctionOwner = auction.getOwner();
    Iterator principalIterator = user.getPrincipals().iterator();
    while(principalIterator.hasNext()) {
      Principal principal = (Principal) principalIterator.next();
      if( principal.getName().equals(auctionOwner) )
        return true;
    }
  }
  return false;
}

														
												

传递到 fulfills() 方法中的关系字符串是策略文件中列出的关系。在这个案例中，我们使用了“ auctionOwner ”字符串。

缺省情况下， XMLPolicyFile 类在当前工作目录中查找名为 ResourcePolicy.xml 的文件。系统属性 com.ibm.resource.security.auth.policy 可以用于指定另一个不同的文件名和位置。

WebSphere Application Server 示例 除命令行示例之外，您可能还想运行这个简单的程序，该程序 为了 IBM WebSphere Application Server，version 4.0.2 而被优化。

回页首

一个可运行的示例

综合这些信息，我们将运行一个简单的命令行示例。该示例程序包含三个 jar 文件：

• resourceSecurity.jar
• example.jar
• exampleActions.jar

resourceSecurity.jar 文件包含允许实例级访问控制的 JAAS 扩展框架。它还包含一个 LoginModuleExample 类，这个类从 XML 文件读取用户认证信息。用户标识和密码存储在 users.xml 文件中。用户组存储在 groups.xml 文件中。关于 LoginModuleExample 的更多信息，请参阅 参考资料部分。

该示例包含四个附加的文件：

• login.conf
• policy
• resourcePolicy.xml
• run.bat

在试图运行这个示例程序之前，请确保更新了 run.bat、policy 和 resourcePolicy.xml 文件中的路径。缺省情况下，所有的密码都是“passw0rd”。

示例如何工作

该示例程序提示输入用户标识和密码。它用 users.xml 文件中的条目核对所提供的用户标识和密码。在认证了用户之后，程序设法创建一个 UserProfile 类实例，修改它并从中读取。缺省情况下， UserProfile 类的所有者是 Jane（jane）。当 Jane 登录时，三个操作全部成功。当 John（john）登录时，只有创建操作成功。当 Jane 的经理 Lou（lou）登录时，只有第一个和最后一个操作成功。当系统管理员（admin）登录时，操作全部成功。当然，只有当提供的 ResourcePolicy.xml 文件未被修改时，上述这些才都是真的。

示例安装
下面的安装指导假设您正在使用 JDK 1.3 并且已经把文件解压缩到 d:\JaasExample 目录。通过将文件解压缩到这个目录，您可以省去一些工作；否则您就必须使用正确的路径名修改 policy 和 ResourceSecurity.xml 策略文件。

下面是运行该示例需要做的工作：

1. 下载这个示例的 源文件。
2. 把 jaas.jar 和 jaasmod.jar 复制到 JDK jre\lib\ext 目录（即 D:\JDK1.3\jre\lib\ext）。
3. 向位于 JDK 的 jre\lib\security 目录（即 D:\JDK1.3\jre\lib\security）中的 java.security 文件的末尾添加下面的字符串： auth.policy.provider=com.ibm.resource.security.auth.XMLPolicyFile 。
4. 执行 run.bat 文件。

回页首

结束语

类实例级授权把访问控制分离到一个通用框架（该框架使用基于所有权和特定关系的策略）中。然后管理员可以在应用程序的生命周期内更改这些策略。用这种方法扩展 JAAS 减少了您或另一个程序员必须在应用程序生命周期内业务规则发生更改时重写代码的可能性。

通过将关系字符串抽象为类可以进一步扩展特定关系这个概念。不调用 Resource 实现类的 fulfills(Subject user, String relationship) 方法，而只要调用 Relationship 实现类中定义的新 fulfills(Subject user, Resource resource) 方法。这样就会允许许多 Resource 实现类使用相同的关系逻辑。

用五个步骤轻松替代 JSP

文档选项 将此页作为电子邮件发送 将此页作为电子邮件发送 未显示需要 JavaScript 的文档选项 样例代码 最新推荐 Java 应用开发源动力 － 下载免费软件，快速启动开发

级别: 中级

George Franciscus , 首席顾问, Nexcel

2005 年 10 月 17 日

Struts Recipes 的合著者 George Franciscus 带您一步步地把 Velocity 模板引擎集成进 Struts 应用程序。结果是一个快速、灵活的 JSP 替代物，同时带有希望从 Struts 得到的所有方便。

Java™ 服务器页面（JSP）技术是如此普及，以至于人们忘记了在创建 Web 页面时还有其他选择。但是最近，有些开发人员已经转向模板引擎，以获得在 JSP 中得不到的灵活性。虽然用 JSP 和模板引擎都可以把数据嵌入 HTML，但是每种技术都有自己的处理方式。Velocity 模板是一个特别流行的 JSP 替代品。Velocity 提供了平缓的学习曲线和巨大的易用性。开发人员喜欢它简洁的语法，而且性能分析也证明它的性能超出 JSP。Velocity 也非常容易集成进 Struts 应用程序。

在这篇文章中，我将介绍如何在 Struts 应用程序中集成和使用 Velocity 模板引擎。我会首先提供一个公式，然后逐步展开它。生成的应用程序组合了 Struts 和 Velocity —— 一个第一流的组合，可能会让您怀疑自己对 JSP 的忠诚！

请参阅 下载 一节，在开始之前下载这篇文章的源代码，以及 Struts、Velocity 和 Velocity 工具包。请注意，本文假设您熟悉使用 Struts 框架进行 MVC 编程。

关于模板引擎

在开始集成 Struts 和 Velocity 的简单任务之前，让我们先确保您理解模板引擎和它们在视图生成中的角色。模板引擎作为整体概念，Velocity 作为具体实现，它们的生命在 HTML 之外。Velocity 把数据合并到文本主体中不同的点上。文本可以是文字、电子邮件或 HTML。由于采用这种方式，Velocity 模板引擎有点儿像 Microsoft Word 的“邮件合并”特性。邮件合并允许您方便地把动态数据（例如姓名、地址和电话号码）合并到信件中。在早期的日子里，组织用这项特性生成大型邮件列表并把它们送到邮局，导致垃圾邮件的产生！

Velocity 是什么？ Velocity 是一个基于 Java 的模板引擎，它提供了简单的基于模板的语言，可以用类似脚本的方式引用对象。Velocity 促进了分离团队成员之间的责任：允许 Web 设计人员专注于视图（即页面的观感），而 Java 程序员专注于后端代码。把 Java 代码从页面布局中分离出来，会让 Web 应用程序未来更易维护。当 Velocity 与 Sruts 这样的 MVC 框架结合时，就成了 JSP 或 PHP 可行的替代。

在 Web 应用程序中，Velocity 实现的目标与 JSP 相同：可以用它在向 HttpServletResponse 的 OutputStream 发送之前生成要发送的 HTML。在 Struts 应用程序中使用 Velocity 的一种方式是在 Struts 的 Action 内部写入响应，然后返回 null 的 ActionForward。虽然这种技术可行，但却有严重的缺陷：无法使用 struts-config.xml 文件把响应抽象出来。把视图放在 Action 内部，意味着如果想要修改响应，就必须修改 Action。

因为这种技术剥夺了 Struts 最好的一项特性（即从视图中抽象出重点的能力），所以我更愿意把所有响应指向一个 servlet，由它负责访问 Velocity 模板，合并上下文的数据，生成响应，然后再送回浏览器。稍后就会学到，Velocity 的设计者们已经把这些步骤全都捆绑在了一起：您需要做的只是跟着我来看如何一步步地实现它们。如果您还没有 访问“下载”一节，现在是访问的时候了。

回页首

Velocity 的五步

把 Struts 与 Velocity 模板引擎组合起来很简单，也很直接；实际上，只要用五步就可以实现：

1. 把 Velocity JAR 放在类路径中。
2. 修改 web.xml 文件让它识别 Velocity servlet。
3. 把 Velocity toolbox.xml 放在应用程序的 WEB-INF 目录下。
4. 修改 struts-config，把它的视图指向 Velocity 模板而不是 JSP。
5. 为每个需要显示的页面创建 Velocity 模板。

我将用一个熟悉的搜索用例来演示 Struts 与 Velocity 的集成。在这个示例中，一个简单的应用程序允许用户按照图书的 ISBN 编号搜索图书。应用程序的结果页面显示与 ISBN 编号匹配的图书。

放弃 Struts 标记 —— 不！ 现在，您可能会想，是不是需要放弃那些过去让您节约了许多编码时间的很好的 Struts 标记。如果不使用 JSP，那么肯定没有使用 Struts 的 JSP 标记！幸运的是，您可以使用 Velocity 工具。Velocity 的 Struts 工具提供了所有您熟悉的 Struts 方便特性，但是添加了 Velocity 的灵活性。

第 1 步：把 Velocity JAR 放在 WEB-INF/lib 下

如果您还没下载 Velocity，那么现在需要下载它。Velocity 本身是很棒的，但是它的工具包可以帮助您把工作做得更好更快。特别是 Struts 工具模拟了您以前熟悉的 Struts 标记。请参阅 下载 一节下载 Velocity 模板引擎和 Velocity 工具。

请注意不同时候，需要的 jar 也会略有不同。在这里我不想列出一个 JAR 列表，只是想建议您访问 Velocity 的主页（请参阅 参考资料）并阅读那里的安装指南。一旦得到了需要的 JAR，只需把它们放在 WEB-INF\lib 下面即可。

第 2 步：修改 web.xml，让它识别 Velocity 的 servlet

下一步是修改 Struts 的 web.xml 文件，让它识别 Velocity 的 servlet 并把所有以 .vm 结尾的资源请求定向到 Velocity servlet，如清单 1 所示。

												
																		
<servlet>
  <servlet-name>velocity</servlet-name> |(1)
  <servlet-class> |(2)
         org.apache.velocity.tools.view.servlet.VelocityViewServlet 
  </servlet-class>                                            

  <init-param> |(3)
    <param-name>org.apache.velocity.toolbox</param-name> 
    <param-value>/WEB-INF/toolbox.xml</param-value>      
 </init-param>                                                 

 <load-on-startup>10</load-on-startup> |(4)
</servlet>

<!-- Map *.vm files to Velocity -->
<servlet-mapping> |(5)
  <servlet-name>velocity</servlet-name>
  <url-pattern>*.vm</url-pattern>      
</servlet-mapping> 

												
										

让我们来看看清单 1 中发生了什么：

• （1）声明了 Velocity servlet 并给了它一个 velocity 句柄。
• （2）声明了 Velocity servlet 的类名。

Velocity servlet 接受“toolbox”参数。toolbox 是声明应用程序的可用工具的位置。因此，在清单 1 中，我还做了以下工作：

• （3）告诉 VelocityServlet 在哪里可以找到 toolbox 的配置。
  
  
• （4）设置了 load-on-startup 标记，确保在正确的时间装入 Velocity servlet。任何大于或等于 0 的值都会迫使容器通过调用 servlet 的 init() 方法来装入它。放在 load-on-startup 标记体中的值决定了不同的 servlet 的 init 方法调用的次序。例如，0 在 1 之前调用，而 1 在 2 之前调用。缺少的标记或负值允许 servlet 容器根据自己的选择装入 servlet。
  
  
• （5）声明了 servlet 映射，强迫所有用 .vm 结尾的资源请求定向到 Velocity servlet。请注意（5）中的<servlet-name> 必须与（1）中的<servlet-name> 匹配。交错的声明和映射会在日志中生成错误。

第 3 步：把 toolbox.xml 放在 WEB-INF 下

利用 Velocity，可以使用（或创建）包含许多工具的工具箱。用来登记类的工具箱中包含有用的函数，常常会用到。幸运的是，Velocity 提供了许多预先构建好的工具。还创建了许多 Struts 工具来模拟原始的 Struts 标记。如果发现需要构建自己的工具，也可以自由地构建。在清单 2 中显示的 toolbox.xml 可以在 Velocity 工具下载中找到。这个文件应当随 Velocity JAR 一起放在 WEB-INF 下。

												
																		
<?xml version="1.0"?>
<toolbox>
  <tool>
     <key>link</key>
     <scope>request</scope>
     <class>
       org.apache.velocity.tools.struts.StrutsLinkTool
     </class>
  </tool>
  <tool>
     <key>msg</key>
     <scope>request</scope>
     <class>
       org.apache.velocity.tools.struts.MessageTool
     </class>
  </tool>
  <tool>
     <key>errors</key>
     <scope>request</scope>
     <class>
       org.apache.velocity.tools.struts.ErrorsTool
     </class>
  </tool>
  <tool>
     <key>form</key>
     <scope>request</scope>
     <class>
       org.apache.velocity.tools.struts.FormTool
     </class>
  </tool>
  <tool>
     <key>tiles</key>
     <scope>request</scope>
     <class>
       org.apache.velocity.tools.struts.TilesTool
     </class>
  </tool>
  <tool>
     <key>validator</key>
     <scope>request</scope>
     <class>
       org.apache.velocity.tools.struts.ValidatorTool
     </class>
  </tool>
</toolbox>

												
										

第 4 步：修改 struts-config

下一步是修改 struts-config.xml，指向 Velocity 视图而不是 JSP。新的配置文件如清单 3 所示。

												
																		
<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE struts-config PUBLIC
          "-//Apache Software Foundation//DTD Struts Configuration 1.0//EN"
          "http://jakarta.apache.org/struts/dtds/struts-config_1_0.dtd">

<struts-config>
    <form-beans>
        <form-bean name="searchForm" type="app.SearchForm"/> 
    </form-beans>

    <global-forwards>
        <forward name="welcome" path="/welcome.do"/>
    </global-forwards>
 
   <action-mappings>
        <action 
            path="/welcome"
            type="org.apache.struts.actions.ForwardAction"
            parameter="/pages/search.vm"/> |(1)

        <action 
            path="/search"
            type="app.SearchAction"
            name="searchForm"    
            scope="request"
            input="/pages/search.vm"> |(2)
            <forward name="success" 
              path="/pages/results.vm"/> |(3)
        </action>
    </action-mappings>
</struts-config>

												
										

清单 3 看起来就像一个非常典型的 Struts 应用程序，只有一个小小的不同。响应没有把客户转向到 JSP，而直接转向到 .vm 文件（请参阅清单 3 中的引用 1、2 和 3）。在大多数情况下，把 Struts 应用程序从 JSP 迁移到 Velocity 视图，需要做的仅仅是全局搜索，把 .jsp 替换成 .vm。其他所有东西都可以保持不变！模板可以同样保存在以前保存 JSP 的位置；所需要做的只是用 Velocity 命令代替 JSP 标记。

第 5 步：创建 Velocity 模板

在清单 4 中，可以看到示例应用程序搜索页面的 Velocity 模板。

												
																		
<HTML>
  <HEAD>
    <TITLE>Search</TITLE>
  </HEAD>
  <BODY>
    $!errors.msgs()||(1)
    <FORM method="POST" 
      action="$link.setAction('/search')"> |(2)
      <h2>Book Search</h2>
      ISBN:<INPUT type="text" name="isbn">
      <INPUT type="submit" value="Submit" name="submit">
    </FORM>
  </BODY>
</HTML>

												
										

清单 4 是一个没有 JSP 或 Struts 标记的典型的 HTML 页面。但是，以下元素看起来可能不是那么熟悉：

• （1）用 $!errors.msgs() 得到错误消息队列中的错误消息。
• （2）用 $link.setAction('/search') 获得搜索转发的 URL。

这就成功了 —— 模板剩下的部分看起来几乎与以前熟悉的 HTML 文件相同。清单 5 显示了应用程序结果页面的模板。

												
																		
<html>
  <body>

  <h1>Book Details</h1>
  <a href="$link.setForward("searchEntry")">Search again</a> |(1)

  <h3>$book.title</h3> |(2)

    <b>ISBN:</b>$book.isbn<br>|(3)
    <b>Title:</b>$book.title<br>|(4)
    <b>Author:</b>$book.author<br>|(5)
    <b>Price:</b>$book.price<br>|(6)
    <b>No Pages:</b>$book.pages<br>|(7)
    <b>Description:</b>$book.description<br>|(8)
    <b>Publisher:</b>$book.publisher<br>|(9)
  </body>
<html>

												
										

可以注意到，清单 5 中不包含 JSP 标记或 Struts 标记。我们来详细看看它：

• （1）用 Struts 的链接工具把 <a> 标记的 href 设置为 Struts 转发。
• （2）访问 $book title 属性。
• （3）访问 $book isbn 属性。
• （4）再次访问 $book title 属性。
• （5）访问 $book author 属性。
• （6）访问 $book price 属性。
• （7）访问 $book pages 属性。
• （8）访问 $book description 属性。
• （9）访问 $book publisher 属性。

回页首

讨论

这就是把 Struts 与 Velocity 模板引擎集成的全部工作。表面看起来非常简单（实际上也很简单），但是请想想是什么让这个集成能够工作的呢？

Struts 动作映射可以定义任何视图，不仅限于 JSP。在这篇文章中，我只是把动作映射修改为以 vm 结尾而不是以 jsp 结尾的返回文件。然后，我声明了 Velocity servlet，并告诉 Servlet 容器把以 vm 结尾的文件发送给 VelocityViewServlet。

VelocityViewServlet 把 Velocity 命令表示成 HTML 响应。通过这种方式，VelocityViewServlet 充当了视图响应的拦截器。Struts 控制器把视图转发给 VelocityViewServlet，后者在向客户端发送响应之前处理 vm 文件。请参阅 参考资料 获得关于将 Velocity 视图集成进 Struts 应用程序的更多内容。

回页首

结束语

正如在本文中看到的，Struts 与 Velocity 的集成很简单。只需五个步骤就可以把所有东西连在一起。针对不同的引擎和场景，采用模板引擎而不是 JSP 的优势各有不同。在 Velocity 的情况下，优势就是简单性、容易学习以及更好的性能。

回页首

下载

	关于下载方法的信息			Get Adobe® Reader®

HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java.net 包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活。HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。HttpClient 已经应用在很多的项目中，比如 Apache Jakarta 上很著名的另外两个开源项目 Cactus 和 HTMLUnit 都使用了 HttpClient，更多使用 HttpClient 的应用可以参见http://wiki.apache.org/jakarta-httpclient/HttpClientPowered。HttpClient 项目非常活跃，使用的人还是非常多的。目前 HttpClient 版本是在 2005.10.11 发布的 3.0 RC4 。

HttpClient 功能介绍

以下列出的是 HttpClient 提供的主要的功能，要知道更多详细的功能可以参见 HttpClient 的主页。

• 实现了所有 HTTP 的方法（GET,POST,PUT,HEAD 等）
• 支持自动转向
• 支持 HTTPS 协议
• 支持代理服务器等

下面将逐一介绍怎样使用这些功能。首先，我们必须安装好 HttpClient。

• HttpClient 可以在http://jakarta.apache.org/commons/httpclient/downloads.html下载
• HttpClient 用到了 Apache Jakarta common 下的子项目 logging，你可以从这个地址http://jakarta.apache.org/site/downloads/downloads_commons-logging.cgi下载到 common logging，从下载后的压缩包中取出 commons-logging.jar 加到 CLASSPATH 中
• HttpClient 用到了 Apache Jakarta common 下的子项目 codec，你可以从这个地址http://jakarta.apache.org/site/downloads/downloads_commons-codec.cgi 下载到最新的 common codec，从下载后的压缩包中取出 commons-codec-1.x.jar 加到 CLASSPATH 中

HttpClient 基本功能的使用

GET 方法

使用 HttpClient 需要以下 6 个步骤：

1. 创建 HttpClient 的实例

2. 创建某种连接方法的实例，在这里是 GetMethod。在 GetMethod 的构造函数中传入待连接的地址

3. 调用第一步中创建好的实例的 execute 方法来执行第二步中创建好的 method 实例

4. 读 response

5. 释放连接。无论执行方法是否成功，都必须释放连接

6. 对得到后的内容进行处理

根据以上步骤，我们来编写用GET方法来取得某网页内容的代码。

• 大部分情况下 HttpClient 默认的构造函数已经足够使用。

  HttpClient httpClient = new HttpClient();

  
  
• 创建GET方法的实例。在GET方法的构造函数中传入待连接的地址即可。用GetMethod将会自动处理转发过程，如果想要把自动处理转发过程去掉的话，可以调用方法setFollowRedirects(false)。

  GetMethod getMethod = new GetMethod("http://www.ibm.com/");

  
  
• 调用实例httpClient的executeMethod方法来执行getMethod。由于是执行在网络上的程序，在运行executeMethod方法的时候，需要处理两个异常，分别是HttpException和IOException。引起第一种异常的原因主要可能是在构造getMethod的时候传入的协议不对，比如不小心将"http"写成"htp"，或者服务器端返回的内容不正常等，并且该异常发生是不可恢复的；第二种异常一般是由于网络原因引起的异常，对于这种异常 （IOException），HttpClient会根据你指定的恢复策略自动试着重新执行executeMethod方法。HttpClient的恢复策略可以自定义（通过实现接口HttpMethodRetryHandler来实现）。通过httpClient的方法setParameter设置你实现的恢复策略，本文中使用的是系统提供的默认恢复策略，该策略在碰到第二类异常的时候将自动重试3次。executeMethod返回值是一个整数，表示了执行该方法后服务器返回的状态码，该状态码能表示出该方法执行是否成功、需要认证或者页面发生了跳转（默认状态下GetMethod的实例是自动处理跳转的）等。

  //设置成了默认的恢复策略，在发生异常时候将自动重试3次，在这里你也可以设置成自定义的恢复策略getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler()); //执行getMethodint statusCode = client.executeMethod(getMethod);if (statusCode != HttpStatus.SC_OK) { System.err.println("Method failed: " + getMethod.getStatusLine());}

  
  
• 在返回的状态码正确后，即可取得内容。取得目标地址的内容有三种方法：第一种，getResponseBody，该方法返回的是目标的二进制的byte流；第二种，getResponseBodyAsString，这个方法返回的是String类型，值得注意的是该方法返回的String的编码是根据系统默认的编码方式，所以返回的String值可能编码类型有误，在本文的"字符编码"部分中将对此做详细介绍；第三种，getResponseBodyAsStream，这个方法对于目标地址中有大量数据需要传输是最佳的。在这里我们使用了最简单的getResponseBody方法。

  byte[] responseBody = method.getResponseBody();

  
  
• 释放连接。无论执行方法是否成功，都必须释放连接。

  method.releaseConnection();

  
  
• 处理内容。在这一步中根据你的需要处理内容，在例子中只是简单的将内容打印到控制台。

  System.out.println(new String(responseBody));

  
  

下面是程序的完整代码。

												package test;import java.io.IOException;import org.apache.commons.httpclient.*;import org.apache.commons.httpclient.methods.GetMethod;import org.apache.commons.httpclient.params.HttpMethodParams;public class GetSample{  public static void main(String[] args) {  //构造HttpClient的实例  HttpClient httpClient = new HttpClient();  //创建GET方法的实例  GetMethod getMethod = new GetMethod("http://www.ibm.com");  //使用系统提供的默认的恢复策略  getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,    new DefaultHttpMethodRetryHandler());  try {   //执行getMethod   int statusCode = httpClient.executeMethod(getMethod);   if (statusCode != HttpStatus.SC_OK) {    System.err.println("Method failed: "      + getMethod.getStatusLine());   }   //读取内容    byte[] responseBody = getMethod.getResponseBody();   //处理内容   System.out.println(new String(responseBody));  } catch (HttpException e) {   //发生致命的异常，可能是协议不对或者返回的内容有问题   System.out.println("Please check your provided http address!");   e.printStackTrace();  } catch (IOException e) {   //发生网络异常   e.printStackTrace();  } finally {   //释放连接   getMethod.releaseConnection();  } }}
										

POST方法

根据RFC2616，对POST的解释如下：POST方法用来向目的服务器发出请求，要求它接受被附在请求后的实体，并把它当作请求队列（Request-Line）中请求URI所指定资源的附加新子项。POST被设计成用统一的方法实现下列功能：

• 对现有资源的注释（Annotation of existing resources）
• 向电子公告栏、新闻组，邮件列表或类似讨论组发送消息
• 提交数据块，如将表单的结果提交给数据处理过程
• 通过附加操作来扩展数据库

调用HttpClient中的PostMethod与GetMethod类似，除了设置PostMethod的实例与GetMethod有些不同之外，剩下的步骤都差不多。在下面的例子中，省去了与GetMethod相同的步骤，只说明与上面不同的地方，并以登录清华大学BBS为例子进行说明。

• 构造PostMethod之前的步骤都相同，与GetMethod一样，构造PostMethod也需要一个URI参数，在本例中，登录的地址是http://www.newsmth.net/bbslogin2.php。在创建了PostMethod的实例之后，需要给method实例填充表单的值，在BBS的登录表单中需要有两个域，第一个是用户名（域名叫id），第二个是密码（域名叫passwd）。表单中的域用类NameValuePair来表示，该类的构造函数第一个参数是域名，第二参数是该域的值；将表单所有的值设置到PostMethod中用方法setRequestBody。另外由于BBS登录成功后会转向另外一个页面，但是HttpClient对于要求接受后继服务的请求，比如POST和PUT，不支持自动转发，因此需要自己对页面转向做处理。具体的页面转向处理请参见下面的"自动转向"部分。代码如下：

  String url = "http://www.newsmth.net/bbslogin2.php";PostMethod postMethod = new PostMethod(url);// 填入各个表单域的值NameValuePair[] data = { new NameValuePair("id", "youUserName"), new NameValuePair("passwd", "yourPwd") };// 将表单的值放入postMethod中postMethod.setRequestBody(data);// 执行postMethodint statusCode = httpClient.executeMethod(postMethod);// HttpClient对于要求接受后继服务的请求，象POST和PUT等不能自动处理转发// 301或者302if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY || statusCode == HttpStatus.SC_MOVED_TEMPORARILY) { // 从头中取出转向的地址 Header locationHeader = postMethod.getResponseHeader("location"); String location = null; if (locationHeader != null) { location = locationHeader.getValue(); System.out.println("The page was redirected to:" + location); } else { System.err.println("Location field value is null."); } return;}

下面介绍在使用HttpClient过程中常见的一些问题。

字符编码

某目标页的编码可能出现在两个地方，第一个地方是服务器返回的http头中，另外一个地方是得到的html/xml页面中。

• 在http头的Content-Type字段可能会包含字符编码信息。例如可能返回的头会包含这样子的信息：Content-Type: text/html; charset=UTF-8。这个头信息表明该页的编码是UTF-8，但是服务器返回的头信息未必与内容能匹配上。比如对于一些双字节语言国家，可能服务器返回的编码类型是UTF-8，但真正的内容却不是UTF-8编码的，因此需要在另外的地方去得到页面的编码信息；但是如果服务器返回的编码不是UTF-8，而是具体的一些编码，比如gb2312等，那服务器返回的可能是正确的编码信息。通过method对象的getResponseCharSet()方法就可以得到http头中的编码信息。
• 对于象xml或者html这样的文件，允许作者在页面中直接指定编码类型。比如在html中会有这样的标签；或者在xml中会有
• 这样的标签，在这些情况下，可能与http头中返回的编码信息冲突，需要用户自己判断到底那种编码类型应该是真正的编码。

自动转向

根据RFC2616中对自动转向的定义，主要有两种：301和302。301表示永久的移走（Moved Permanently），当返回的是301，则表示请求的资源已经被移到一个固定的新地方，任何向该地址发起请求都会被转到新的地址上。302表示暂时的转向，比如在服务器端的servlet程序调用了sendRedirect方法，则在客户端就会得到一个302的代码，这时服务器返回的头信息中location的值就是sendRedirect转向的目标地址。

HttpClient支持自动转向处理，但是象POST和PUT方式这种要求接受后继服务的请求方式，暂时不支持自动转向，因此如果碰到POST方式提交后返回的是301或者302的话需要自己处理。就像刚才在POSTMethod中举的例子：如果想进入登录BBS后的页面，必须重新发起登录的请求，请求的地址可以在头字段location中得到。不过需要注意的是，有时候location返回的可能是相对路径，因此需要对location返回的值做一些处理才可以发起向新地址的请求。

另外除了在头中包含的信息可能使页面发生重定向外，在页面中也有可能会发生页面的重定向。引起页面自动转发的标签是：

。如果你想在程序中也处理这种情况的话得自己分析页面来实现转向。需要注意的是，在上面那个标签中url的值也可以是一个相对地址，如果是这样的话，需要对它做一些处理后才可以转发。

处理HTTPS协议

HttpClient提供了对SSL的支持，在使用SSL之前必须安装JSSE。在Sun提供的1.4以后的版本中，JSSE已经集成到JDK中，如果你使用的是JDK1.4以前的版本则必须安装JSSE。JSSE不同的厂家有不同的实现。下面介绍怎么使用HttpClient来打开Https连接。这里有两种方法可以打开https连接，第一种就是得到服务器颁发的证书，然后导入到本地的keystore中；另外一种办法就是通过扩展HttpClient的类来实现自动接受证书。

方法1，取得证书，并导入本地的keystore：

1. 安装JSSE （如果你使用的JDK版本是1.4或者1.4以上就可以跳过这一步）。本文以IBM的JSSE为例子说明。先到IBM网站上下载JSSE的安装包。然后解压开之后将ibmjsse.jar包拷贝到\lib\ext\目录下。
2. 取得并且导入证书。证书可以通过IE来获得：

   1． 用IE打开需要连接的https网址，会弹出如下对话框：

   
   
   
   

   2． 单击"View Certificate"，在弹出的对话框中选择"Details"，然后再单击"Copy to File"，根据提供的向导生成待访问网页的证书文件

   
   
   
   

   3． 向导第一步，欢迎界面，直接单击"Next"，

   
   
   
   

   4． 向导第二步，选择导出的文件格式，默认，单击"Next"，

   
   
   
   

   5． 向导第三步，输入导出的文件名，输入后，单击"Next"，

   
   
   
   

   6． 向导第四步，单击"Finish"，完成向导

   
   
   
   

   7． 最后弹出一个对话框，显示导出成功

   
   
   
   

3. 用keytool工具把刚才导出的证书倒入本地keystore。Keytool命令在\bin\下，打开命令行窗口，并到\lib\security\目录下，运行下面的命令：

   keytool -import -noprompt -keystore cacerts -storepass changeit -alias yourEntry1 -file your.cer

   
   

   其中参数alias后跟的值是当前证书在keystore中的唯一标识符，但是大小写不区分；参数file后跟的是刚才通过IE导出的证书所在的路径和文件名；如果你想删除刚才导入到keystore的证书，可以用命令：

   keytool -delete -keystore cacerts -storepass changeit -alias yourEntry1

   
   
4. 写程序访问https地址。如果想测试是否能连上https，只需要稍改一下GetSample例子，把请求的目标变成一个https地址。

   GetMethod getMethod = new GetMethod("https://www.yourdomain.com");

   
   

   运行该程序可能出现的问题：

   1. 抛出异常java.net.SocketException: Algorithm SSL not available。出现这个异常可能是因为没有加JSSEProvider，如果用的是IBM的JSSE Provider，在程序中加入这样的一行：

   if(Security.getProvider("com.ibm.jsse.IBMJSSEProvider") == null) Security.addProvider(new IBMJSSEProvider());

   
   

   或者也可以打开\lib\security\java.security，在行

   security.provider.1=sun.security.provider.Sunsecurity.provider.2=com.ibm.crypto.provider.IBMJCE

   
   

   后面加入security.provider.3=com.ibm.jsse.IBMJSSEProvider

   2. 抛出异常java.net.SocketException: SSL implementation not available。出现这个异常可能是你没有把ibmjsse.jar拷贝到\lib\ext\目录下。

   3. 抛出异常javax.net.ssl.SSLHandshakeException: unknown certificate。出现这个异常表明你的JSSE应该已经安装正确，但是可能因为你没有把证书导入到当前运行JRE的keystore中，请按照前面介绍的步骤来导入你的证书。

方法２，扩展HttpClient类实现自动接受证书

因为这种方法自动接收所有证书，因此存在一定的安全问题，所以在使用这种方法前请仔细考虑您的系统的安全需求。具体的步骤如下：

• 提供一个自定义的socket factory（test.MySecureProtocolSocketFactory）。这个自定义的类必须实现接口org.apache.commons.httpclient.protocol.SecureProtocolSocketFactory，在实现接口的类中调用自定义的X509TrustManager(test.MyX509TrustManager)，这两个类可以在随本文带的附件中得到
• 创建一个org.apache.commons.httpclient.protocol.Protocol的实例，指定协议名称和默认的端口号

  Protocol myhttps = new Protocol("https", new MySecureProtocolSocketFactory (), 443);

  
  
• 注册刚才创建的https协议对象

  Protocol.registerProtocol("https ", myhttps);

  
  
• 然后按照普通编程方式打开https的目标地址，代码请参见test.NoCertificationHttpsGetSample

处理代理服务器

HttpClient中使用代理服务器非常简单，调用HttpClient中setProxy方法就可以，方法的第一个参数是代理服务器地址，第二个参数是端口号。另外HttpClient也支持SOCKS代理。





httpClient.getHostConfiguration().setProxy(hostName,port);





结论

从上面的介绍中，可以知道HttpClient对http协议支持非常好，使用起来很简单，版本更新快，功能也很强大，具有足够的灵活性和扩展性。对于想在Java应用中直接访问http资源的编程人员来说，HttpClient是一个不可多得的好工具。

网上出现了很多讲解AspectJ的资料，但大多是从讲解AspectJ语法开始,本文从另一个角度讲解AspectJ，作者着重介绍了AspectJ的设计思路和运行原理。

1. 序

Aspect Oriented Programming (AOP)是近来一个比较热门的话题。

AspectJ是AOP的Java语言的实现，获得了Java程序员的广泛关注。

关于AspectJ和AOP的具体资料，请从下列链接中查找：

http://www.eclipse.org/aspectj/
http://www.parc.com/research/csl/projects/aspectj/
http://aosd.net/

网上出现了很多讲解AspectJ的资料，但大多是从讲解AspectJ语法开始，然后讲解如何应用AspectJ，如何分离软件开发过程的不同方面（Aspect）--Log，Session，Authentication and Authorization，Transaction，等等。

初次接触AspectJ的读者看到这些资料（或者语法手册），会感到AspectJ有些神秘。他们想知道，AspectJ是如何做到这些的？AspectJ是怎样工作的？AspectJ需要特殊的运行环境吗？

本文从另一个角度讲解AspectJ，本文从讲解AspectJ的设计思路、运行原理入手，回答上述问题。

本文讲解的主要内容，按照概念的重要程度，排列如下：

1. AspectJ是一个代码生成工具（Code Generator）。
2. AspectJ语法就是用来定义代码生成规则的语法。您如果使用过Java Compiler Compiler (JavaCC)，您会发现，两者的代码生成规则的理念惊人相似。
3. AspectJ有自己的语法编译工具，编译的结果是Java Class文件，运行的时候，classpath需要包含AspectJ的一个jar文件（Runtime lib）。
4. AspectJ和xDoclet的比较。AspectJ和EJB Descriptor的比较。

本文的原则是，只细讲其他资料没有讲到的东西，其他资料讲过的东西，不讲或略讲。以节省网络资源，更为了节省大家宝贵的时间。J

回页首

2．Aspect Oriented Programming (AOP)

本节简单介绍AOP的概念，解释我们为什么需要AOP。

AOP是Object Oriented Programming（OOP）的补充。

OOP能够很好地解决对象的数据和封装的问题，却不能很好的解决Aspect（"方面"）分离的问题。下面举例具体说明。

比如，我们有一个Bank（银行）类。Bank有两个方法，deposit（存钱）和withdraw（取钱）。

类和方法的定义如下：

														
																Code 2.1 Bank.java
class Bank{
public float deposit(AccountInfo account, float money){
  // 增加account账户的钱数，返回账户里当前的钱数
}

public float withdraw(AccountInfo account, float money){
  // 减少account账户的钱数，返回取出的钱数
}
};

														
												

这两个方法涉及到用户的账户资金等重要信息，必须要非常小心，所以编写完上面的商业逻辑之后，项目负责人又提出了新的要求--给Bank类的每个重要方法加上安全认证特性。

于是，我们不得不分别在上面的两个方法中加入安全认证的代码。

类和方法的定义如下：（新增加的代码用不同的背景标出）

														
																Code 2.2 Bank.java
class Bank{
public float deposit(AccountInfo account, float money){
  // 验证account是否为合法用户
  // 增加account账户的钱数，返回账户里当前的钱数
}

public float withdraw(AccountInfo account, float money){
  // 验证account是否为合法用户
  // 减少account账户的钱数，返回取出的钱数
}
};

														
												

这两个方法都需要操作数据库，为了保持数据完整性，项目负责人又提出了新的要求--给Bank类的每个操作数据库的方法加上事务控制。

于是，我们不得不分别在上面的两个方法中加入安全认证的代码。

类和方法的定义如下：（新增加的代码用不同的背景标出）

														
																Code 2.3 Bank.java
class Bank{
public float deposit(AccountInfo account, float money){
  // 验证account是否为合法用户
  // Begin Transaction
  // 增加account账户的钱数，返回账户里当前的钱数
  // End Transaction
}

public float withdraw(AccountInfo account, float money){
  // 验证account是否为合法用户
  // Begin Transaction
  // 减少account账户的钱数，返回取出的钱数
  // End Transaction
}
};

														
												

我们看到，这些与商业逻辑无关的重复代码遍布在整个程序中。实际的工程项目中涉及到的类和函数，远远不止两个。如何解决这种问题？

我们首先来看看OOP能否解决这个问题。

我们利用Design Pattern的Template Pattern，可以抽出一个框架，改变上面的例子的整个设计结构。

类和方法的定义如下：

														
																Code 2.4 Base.java
abstract class Base{
public float importantMethod(AccountInfo account, float money){
  // 验证account是否为合法用户
  // Begin Transaction
  
  float result = yourBusiness(account, money)

  // End Transaction
  return result;	
}

protected abstract float yourBusiness(AccountInfo account, float money);
};

Code 2.5 BankDeposit.java
class BankDeposit extends Base{ 
protected float yourBusiness(AccountInfo account, float money){
  // 增加account账户的钱数，返回账户里当前的钱数
}
};

Code 2.6 BankWithdraw.java
class BankWithdraw extends Base{ 
protected float yourBusiness(AccountInfo account, float money){
  // 减少account账户的钱数，返回取出的钱数
}
};

														
												

这里我们用一种很勉强的方法实现了认证和事务代码的重用。而且，有心的读者可能会注意到，这种方法的前提是，强制所有的方法都遵守同样的signature。

如果有一个转账方法transfer(AccountInfo giver, AccountInfo receiver, float money)，由于transfer方法的signature不同于yourBusiness的signature，这个方法无法使用上面的框架。

这个例子中提到的认证，事务等方面，就是AOP所关心的Aspect。

AOP就是为了解决这种问题而出现的。AOP的目的就是--Separation of Aspects (or Separation of Concerns).

下面的章节，解释EJB Descriptor，AspectJ，xDoclet等工具如何解决Separation of Aspects的问题。

回页首

3．EJB Descriptor

如果我们使用EJB实现上面的例子，Bank类可以作为一个Stateless Session Bean实现。

在Bank的代码中只用考虑商业逻辑，不用考虑认证和事务等方面。

认证和事务等方面在EJB Descriptor中定义，由EJB Container提供这些方面的实现。

我们来看一下，如何使用EJB Descriptor描述上面的例子。

EJB Descriptor包括一个ejb-jar.xml文件。ejb-jar.xml文件包含两大部分，enterprise-beans和assembly-descriptor部分。enterprise-beans部分包含EJB的定义--JNDI Name，EJB Home, Interface, Bean Class Path等；assembly-descriptor部分包括配置信息的定义--安全角色，事务控制等等。

下面给出上面例子对应的模拟EJB Descriptor。

														
																<ejb-jar>
<enterprise-beans>
  <session>
     <ejb-name>Bank</ejb-name>
     …
     <ejb-class>example.Bank</ejb-class>
     <session-type>Stateless</session-type>
     <transaction-type>Container</transaction-type>
<security-role-ref>
<role-name>bank-account</role-name>
</security-role-ref>
  </session>
</enterprise-beans>

<assembly-descriptor>
  <security-role>
    <role-name>bank-account</role-name>
  </security-role>

<method-permission>
<role-name>employee</role-name>
<method>
<ejb-name>Bank</ejb-name>
<method-name>deposit</method-name>
</method>
<method>
<ejb-name>Bank</ejb-name>
<method-name>withdraw</method-name>
</method>
</method-permission>

<container-transaction>
<method>
<ejb-name>Bank</ejb-name>
<method-name>deposit</method-name>
</method>
<method>
<ejb-name>Bank</ejb-name>
<method-name>withdraw</method-name>
</method>

<trans-attribute>Required</trans-attribute>
</container-transaction>
</assembly-descriptor>
</ejb-jar>

														
												

本文后面会讲到如何用AspectJ实现上例中的Separation of Aspects。

读者可以比较一下AspectJ语法和EJB Descriptor定义之间的对应关系。

两者都提供了类名、方法名的匹配规则，能够把类的方法映射到认证，事务等Aspect（方面）。

回页首

4．AspectJ

这一节我们来看看AspectJ如何实现上例中的Separation of Aspects。

使用AspectJ，我们不用对原有的代码做任何修改，就可以为代码提供不同的Aspect（方面）--比如，认证，事务等。

我们只需要提供两个不同的Aspect--认证Aspect和事务Aspect。

														
																Code 4.1 AuthAspect.java
aspect AuthAspect{
  pointcut bankMethods() : execution (* Bank.deposit(…)) || execution (* Bank. withdraw (…));

  Object around(): bankMethods(){
  // 验证account是否为合法用户

  return proceed();
  }
};

Code 4.2 TransactionAspect.java
aspect TransactionAspect{
  pointcut bankMethods() : execution(* Bank.deposit(…)) || execution (* Bank. withdraw (…));

  Object around(): bankMethods(){
  // Begin Transaction
  Object result = proceed();
  // End Transaction
  return result;
  }
};

														
												

如果您暂时不能理解这段代码，没有关系，后面会讲到，这些aspect的定义，不过是定义了一些代码生成规则。

我们用AspectJ编译器编译Bank文件和含有aspect的这个文件，出来的结果就是带有安全认证和事务处理的Bank类。编译出来的这个Bank类调用了AspectJ Runtime Lib，所以，如果你要运行这个Bank类，你需要把AspectJ Runtime Lib设置在你的classpath里面。

我们来看看，AspectJ编译器为我们做了什么事情。

1. 首先，AspectJ从文件列表里取出所有的文件名，然后读取这些文件，进行分析。
2. AspectJ发现一些文件含有aspect的定义，在这个例子里，就是AuthAspect和TransactionAspect的定义；这些aspect就是代码生成规则。
3. AspectJ根据这些aspect代码生成规则，修改添加你的源代码。在这个例子里，就是修改添加Bank文件。
4. AspectJ读取AuthAspect的定义，发现了一个pointcut--bankMethods()；这个pointcut的定义是execution(* Bank.deposit(…)) || execution(* Bank. withdraw (…))，表示所有对Bank类的deposit和withdraw方法的执行点。
5. AspectJ继续读取AuthAspect的定义，发现了一个around()，这在AspectJ中叫做Advice，我不明白为什么叫这个名字，不过没关系，我们只要知道它是干什么的就行了。Advice允许你在某个类的方法的调用之前或调用之后，加入另外的代码。Code 4.1所示代码中的around()的" // 验证account是否为合法用户"部分，就是要加入的代码。这段代码要加在哪里呢？around()后面跟了一个pointcut--bankMethods()。根据这个pointcut，AspectJ会把这段代码加入到Bank.deposit和Bank.withdraw两个方法的执行之前。达到的效果就如同Code 2.2所示。
6. AspectJ读取TransactionAspect的定义，象第（4）步一样，发现了发现了一个pointcut--bankMethods()。
7. AspectJ继续读取AuthAspect的定义，发现了一个around()。这次AspectJ把"Begin Transaction"和"End Transaction"两段代码加在Bank.deposit和Bank. withdraw两个方法的执行前后。达到的效果就如同Code 2.3所示。

如何验证这一点？您可以到 http://www.eclipse.org/aspectj/下载安装AspectJ，编译里面的Sample，把编译结果反编译一下，就可以看到AspetJ自动生成的代码。

我们看到，AspectJ是一种代码自动生成工具。你编写一段通用的代码，比如认证方面的代码，事务方面的代码，然后根据AspectJ语法定义一套代码生成规则（aspect定义），AspectJ就会帮助你自动把这段通用代码分布到对应的代码里面去，简单快捷，算无遗策。

无独有偶，一个著名的编译器生成工具--Java Compiler Compiler (JavaCC)，也采用了非常相似的代码生成机制。JavaCC允许你在语法定义规则文件中，加入你自己的Java代码，用来处理读入的各种语法元素。

AspectJ令你的代码更精简，结构更良好。AspectJ的好处，我就不多说了，网上很多精彩的文章探讨AspectJ的各种用途。

下面介绍一个著名的代码自动生成器--xDoclet，和EJB Descriptor，AspectJ之间的联系和比较。

回页首

5．xDoclet

我们知道，Doclet用来生成Javadoc，xDoclet是Doclet的扩展，不仅仅能生成Javadoc，还能够生成源代码和配置信息等。

Doclet和xDoclet的工作原理，就是处理源代码中的注释中的tag，生成相应的信息。这些tag都以@开头，你可以自己定义tag和对tag的处理，生成自定义的信息。

（这里提一下Apache Maven Project。Maven是一种Project Build工具。用Maven进行管理的项目，能够同时生成Javadoc和XRef。XRef是Source Code Cross Reference。)

JBoss就利用xDoclet为EJB自动生成EJB Home和EJB Object Interface源文件，和EJB Descriptor文件。

在Sourceforge.net上看到一个叫做Barter的开源项目，利用xDoclet为类方法生成AspectJ代码。

请注意，EJB Descriptor和AspectJ都是把方方面面的Aspects集中在一处进行管理，而xDoclet的思想是处理散布在源代码中的各种tag。

xDoclet在生成EJB Descriptor和AspectJ等方面的应用，正应了中国的一句古话--分久必合，合久必分。

回页首

6．总结

开源项目的出现，打破了软件技术领域的众多壁垒，推动软件技术进程的日新月异。

同时，一些新名词，新概念也层出不穷，令人眼花缭乱，无所适从。其实，很多东西都是换汤不换药，我们理解应用这些新技术的时候，要抓住本质，要破除迷信，破除任何人为的神秘感。

举个例子，现在炒作的很热的一些概念，"Web Service"，还有"Grid Computation"（网格计算），都是基于原有的各种技术发展出来的。媒体和技术文章不应该人为地制造任何神秘感。

互联网时代的权威，不是说出来的，而是做出来的。

另外，围绕着一些有前途的新技术，总会出现大量的"快速入门手册"，有些简直就是对该技术帮助文档的翻译，而且，有难度的地方没有翻译出来，大家都明白的地方翻译得非常详尽，详尽到了没有必要的地步。这种因为市场需求而产生的应景时文，大量地出现在技术文章领域。

笔者对本文的期望是，决不迷信，决不重复。并试图引入一种洁净的，毫无废话的文风。笔者期待一针见血的驳斥和批评。

Struts 的 Token 机制可以解决这个问题。

1．   防止通过超链接重复访问 Struts Action 。

如果我们要防止 A 的默认页面 J 中指向 K 的超链接重复提交数据，按照下列步骤即可：

a．   如果 J 是从 Struts Action 转发而来，我们要在该 Struts Action 的 execute 方法中添加下面的一行：

    saveToken(request);

b．   如果 J 不是从 Struts Action 转发而来，那么新建一个 Struts Action ，在该 Struts Action 的 excute 方法中增加上面的一行，然后再从该 action 转到 J 页面。

c．   在 J 页面中使用 Struts 标签生成指向 K 的超链接，如：

   <html:link action="/deleteLayoutAction?layoutId=0" transaction="true" >delete</html:link>

   注意红色字体部分。

d．   在 <html:link> 标签指向的 action 的 excute 方法中加入下面的代码：

   if (!isTokenValid(request)) {

                     return mapping.findForward(" 这种情况下就是重复提交，转到相应的页面 ");

              }

e ． All Done.

2．   防止通过表单重复提交数据。

a．   如果 J 是从 Struts Action 转发而来，我们要在该 Struts Action 的 execute 方法中添加下面的一行：

    saveToken(request);

b．   如果 J 不是从 Struts Action 转发而来，那么新建一个 Struts Action ，在该 Struts Action 的 excute 方法中增加上面的一行，然后再从该 action 转到 J 页面。

c．   在 J 页面中表单 Action 属性指向的 Struts action 的 excute 方法中加入下面的代码：

   if (!isTokenValid(request)) {

           saveToken(request);

                     return mapping.findForward(" 这种情况下就是重复提交，转到相应的页面 ");

   saveToken(request);

              }

e ． All Done.