分别介绍：
一 ServletContext相关监听接口
补充知识：
通过ServletContext 的实例可以存取应用程序的全局对象以及初始化阶段的变量。
在JSP文件中，application 是 ServletContext 的实例，由JSP容器默认创建。Servlet 中调用 getServletContext()方法得到 ServletContext 的实例。
注意：
全局对象即Application范围对象，初始化阶段的变量指在web.xml中，经由<context-param>元素所设定的变量，它的范围也是Application范围，例如：

<context-param>
<param-name>Name</param-name>
<param-value>browser</param-value>
</context-param>
当容器启动时，会建立一个Application范围的对象，若要在JSP网页中取得此变量时：
String name = (String)application.getInitParameter("Name");
或者使用EL时：
${initPara.name}
若是在Servlet中，取得Name的值方法：
String name = (String)ServletContext.getInitParameter("Name");

1.ServletContextListener：
用于监听WEB 应用启动和销毁的事件，监听器类需要实现javax.servlet.ServletContextListener 接口。
ServletContextListener 是 ServletContext 的监听者，如果 ServletContext 发生变化，如服务器启动时 ServletContext 被创建，服务器关闭时 ServletContext 将要被销毁。

ServletContextListener接口的方法：
void contextInitialized(ServletContextEvent sce)
通知正在接受的对象，应用程序已经被加载及初始化。
void contextDestroyed(ServletContextEvent sce)
通知正在接受的对象，应用程序已经被载出。

ServletContextEvent中的方法：
ServletContext getServletContext()
取得ServletContext对象

2.ServletContextAttributeListener：用于监听WEB应用属性改变的事件，包括：增加属性、删除属性、修改属性，监听器类需要实现javax.servlet.ServletContextAttributeListener接口。

ServletContextAttributeListener接口方法：
void attributeAdded(ServletContextAttributeEvent scab)
若有对象加入Application的范围，通知正在收听的对象
void attributeRemoved(ServletContextAttributeEvent scab)
若有对象从Application的范围移除，通知正在收听的对象
void attributeReplaced(ServletContextAttributeEvent scab)
若在Application的范围中，有对象取代另一个对象时，通知正在收听的对象

ServletContextAttributeEvent中的方法：
java.lang.String getName()
回传属性的名称
java.lang.Object getValue()
回传属性的值

二、HttpSession相关监听接口
1.HttpSessionBindingListener接口
注意：HttpSessionBindingListener接口是唯一不需要再web.xml中设定的Listener

当我们的类实现了HttpSessionBindingListener接口后，只要对象加入Session范围（即调用HttpSession对象的setAttribute方法的时候）或从Session范围中移出（即调用HttpSession对象的removeAttribute方法的时候或Session Time out的时候）时，容器分别会自动调用下列两个方法：
void valueBound(HttpSessionBindingEvent event)
void valueUnbound(HttpSessionBindingEvent event)

思考：如何实现记录网站的客户登录日志， 统计在线人数？

2.HttpSessionAttributeListener接口
HttpSessionAttributeListener监听HttpSession中的属性的操作。
当在Session增加一个属性时，激发attributeAdded(HttpSessionBindingEvent se) 方法；当在Session删除一个属性时，激发attributeRemoved(HttpSessionBindingEvent se)方法；当在Session属性被重新设置时，激发attributeReplaced(HttpSessionBindingEvent se) 方法。这和ServletContextAttributeListener比较类似。

3.HttpSessionListener接口
HttpSessionListener监听HttpSession的操作。当创建一个Session时，激发session Created(HttpSessionEvent se)方法；当销毁一个Session时，激发sessionDestroyed (HttpSessionEvent se)方法。

4.HttpSessionActivationListener接口
主要用于同一个Session转移至不同的JVM的情形。

四、ServletRequest监听接口
1.ServletRequestListener接口
和ServletContextListener接口类似的，这里由ServletContext改为ServletRequest
2.ServletRequestAttributeListener接口
和ServletContextListener接口类似的，这里由ServletContext改为ServletRequest 

-----------------------------------------------------------------------------------------------------------

TextTitle类：
void setFont(Font font)     标题字体
void setPaint(Paint paint)    标题字体颜色
void setText(String text)    标题内容

-----------------------------------------------------------------------------------------------------------

StandardLegend(Legend)类：
void setBackgroundPaint(Paint paint)   图示背景色
void setTitle(String title)    图示标题内容
void setTitleFont(Font font)    图示标题字体
void setBoundingBoxArcWidth(int arcWidth)  图示边界圆角宽
void setBoundingBoxArcHeight(int arcHeight)  图示边界圆角高
void setOutlinePaint(Paint paint)   图示边界线条颜色
void setOutlineStroke(Stroke stroke)   图示边界线条笔触
void setDisplaySeriesLines(boolean flag)  图示项是否显示横线（折线图有效）
void setDisplaySeriesShapes(boolean flag)  图示项是否显示形状（折线图有效）
void setItemFont(Font font)    图示项字体
void setItemPaint(Paint paint)    图示项字体颜色
void setAnchor(int anchor)    图示在图表中的显示位置（参数常量在Legend类中定义）

-----------------------------------------------------------------------------------------------------------

Axis类：
void setVisible(boolean flag)    坐标轴是否可见
void setAxisLinePaint(Paint paint)   坐标轴线条颜色（3D轴无效）
void setAxisLineStroke(Stroke stroke)   坐标轴线条笔触（3D轴无效）
void setAxisLineVisible(boolean visible)  坐标轴线条是否可见（3D轴无效）
void setFixedDimension(double dimension)  （用于复合表中对多坐标轴的设置）
void setLabel(String label)    坐标轴标题
void setLabelFont(Font font)    坐标轴标题字体
void setLabelPaint(Paint paint)    坐标轴标题颜色
void setLabelAngle(double angle)`   坐标轴标题旋转角度（纵坐标可以旋转）
void setTickLabelFont(Font font)   坐标轴标尺值字体
void setTickLabelPaint(Paint paint)   坐标轴标尺值颜色
void setTickLabelsVisible(boolean flag)   坐标轴标尺值是否显示
void setTickMarkPaint(Paint paint)   坐标轴标尺颜色
void setTickMarkStroke(Stroke stroke)   坐标轴标尺笔触
void setTickMarksVisible(boolean flag)   坐标轴标尺是否显示

ValueAxis(Axis)类：
void setAutoRange(boolean auto)    自动设置数据轴数据范围
void setAutoRangeMinimumSize(double size)  自动设置数据轴数据范围时数据范围的最小跨度
void setAutoTickUnitSelection(boolean flag)  数据轴的数据标签是否自动确定（默认为true）
void setFixedAutoRange(double length)   数据轴固定数据范围（设置100的话就是显示MAXVALUE到MAXVALUE-100那段数据范围）
void setInverted(boolean flag)    数据轴是否反向（默认为false）
void setLowerMargin(double margin)   数据轴下（左）边距
void setUpperMargin(double margin)   数据轴上（右）边距
void setLowerBound(double min)    数据轴上的显示最小值
void setUpperBound(double max)    数据轴上的显示最大值
void setPositiveArrowVisible(boolean visible)  是否显示正向箭头（3D轴无效）
void setNegativeArrowVisible(boolean visible)  是否显示反向箭头（3D轴无效）
void setVerticalTickLabels(boolean flag)  数据轴数据标签是否旋转到垂直
void setStandardTickUnits(TickUnitSource source) 数据轴的数据标签（可以只显示整数标签，需要将AutoTickUnitSelection设false）

NumberAxis(ValueAxis)类：
void setAutoRangeIncludesZero(boolean flag)  是否强制在自动选择的数据范围中包含0
void setAutoRangeStickyZero(boolean flag)  是否强制在整个数据轴中包含0，即使0不在数据范围中
void setNumberFormatOverride(NumberFormat formatter) 数据轴数据标签的显示格式
void setTickUnit(NumberTickUnit unit)   数据轴的数据标签（需要将AutoTickUnitSelection设false）

DateAxis(ValueAxis)类：
void setMaximumDate(Date maximumDate)   日期轴上的最小日期
void setMinimumDate(Date minimumDate)   日期轴上的最大日期
void setRange(Date lower,Date upper)   日期轴范围
void setDateFormatOverride(DateFormat formatter) 日期轴日期标签的显示格式
void setTickUnit(DateTickUnit unit)   日期轴的日期标签（需要将AutoTickUnitSelection设false）
void setTickMarkPosition(DateTickMarkPosition position) 日期标签位置（参数常量在org.jfree.chart.axis.DateTickMarkPosition类中定义）

CategoryAxis(Axis)类：
void setCategoryMargin(double margin)   分类轴边距
void setLowerMargin(double margin)   分类轴下（左）边距
void setUpperMargin(double margin)   分类轴上（右）边距
void setVerticalCategoryLabels(boolean flag)  分类轴标题是否旋转到垂直
void setMaxCategoryLabelWidthRatio(float ratio)  分类轴分类标签的最大宽度

-----------------------------------------------------------------------------------------------------------

Plot类：
void setBackgroundImage(Image image)   数据区的背景图片
void setBackgroundImageAlignment(int alignment)  数据区的背景图片对齐方式（参数常量在org.jfree.ui.Align类中定义）
void setBackgroundPaint(Paint paint)   数据区的背景图片背景色
void setBackgroundAlpha(float alpha)   数据区的背景透明度（0.0～1.0）
void setForegroundAlpha(float alpha)   数据区的前景透明度（0.0～1.0）
void setDataAreaRatio(double ratio)   数据区占整个图表区的百分比
void setOutLinePaint(Paint paint)   数据区的边界线条颜色
void setOutLineStroke(Stroke stroke)   数据区的边界线条笔触
void setNoDataMessage(String message)   没有数据时显示的消息
void setNoDataMessageFont(Font font)   没有数据时显示的消息字体
void setNoDataMessagePaint(Paint paint)   没有数据时显示的消息颜色

CategoryPlot(Plot)类：
void setDataset(CategoryDataset dataset)  数据区的2维数据表
void setColumnRenderingOrder(SortOrder order)  数据分类的排序方式
void setAxisOffset(Spacer offset)   坐标轴到数据区的间距
void setOrientation(PlotOrientation orientation) 数据区的方向（PlotOrientation.HORIZONTAL或PlotOrientation.VERTICAL）
void setDomainAxis(CategoryAxis axis)   数据区的分类轴
void setDomainAxisLocation(AxisLocation location) 分类轴的位置（参数常量在org.jfree.chart.axis.AxisLocation类中定义）
void setDomainGridlinesVisible(boolean visible)  分类轴网格是否可见
void setDomainGridlinePaint(Paint paint)  分类轴网格线条颜色
void setDomainGridlineStroke(Stroke stroke)  分类轴网格线条笔触
void setRangeAxis(ValueAxis axis)   数据区的数据轴
void setRangeAxisLocation(AxisLocation location) 数据轴的位置（参数常量在org.jfree.chart.axis.AxisLocation类中定义）
void setRangeGridlinesVisible(boolean visible)  数据轴网格是否可见
void setRangeGridlinePaint(Paint paint)   数据轴网格线条颜色
void setRangeGridlineStroke(Stroke stroke)  数据轴网格线条笔触
void setRenderer(CategoryItemRenderer renderer)  数据区的表示者（详见Renderer组）
void addAnnotation(CategoryAnnotation annotation) 给数据区加一个注释
void addRangeMarker(Marker marker,Layer layer)  给数据区加一个数值范围区域

PiePlot(Plot)类：
void setDataset(PieDataset dataset)   数据区的1维数据表
void setIgnoreNullValues(boolean flag)   忽略无值的分类
void setCircular(boolean flag)    饼图是否一定是正圆
void setStartAngle(double angle)   饼图的初始角度
void setDirection(Rotation direction)   饼图的旋转方向
void setExplodePercent(int section,double percent) 抽取的那块（1维数据表的分类下标）以及抽取出来的距离（0.0～1.0），3D饼图无效
void setLabelBackgroundPaint(Paint paint)  分类标签的底色
void setLabelFont(Font font)    分类标签的字体
void setLabelPaint(Paint paint)    分类标签的字体颜色
void setLabelLinkMargin(double margin)   分类标签与图的连接线边距
void setLabelLinkPaint(Paint paint)   分类标签与图的连接线颜色
void setLabelLinkStroke(Stroke stroke)   分类标签与图的连接线笔触
void setLabelOutlinePaint(Paint paint)   分类标签边框颜色
void setLabelOutlineStroke(Paint paint)   分类标签边框笔触
void setLabelShadowPaint(Paint paint)   分类标签阴影颜色
void setMaximumLabelWidth(double width)   分类标签的最大长度（0.0～1.0）
void setPieIndex(int index)    饼图的索引（复合饼图中用到）
void setSectionOutlinePaint(int section,Paint paint) 指定分类饼的边框颜色
void setSectionOutlineStroke(int section,Stroke stroke) 指定分类饼的边框笔触
void setSectionPaint(int section,Paint paint)  指定分类饼的颜色
void setShadowPaint(Paint paint)   饼图的阴影颜色
void setShadowXOffset(double offset)   饼图的阴影相对图的水平偏移
void setShadowYOffset(double offset)   饼图的阴影相对图的垂直偏移
void setLabelGenerator(PieSectionLabelGenerator generator) 分类标签的格式，设置成null则整个标签包括连接线都不显示
void setToolTipGenerator(PieToolTipGenerator generator)  MAP中鼠标移上的显示格式
void setURLGenerator(PieURLGenerator generator)   MAP中钻取链接格式

PiePlot3D(PiePlot)类：
void setDepthFactor(double factor)   3D饼图的Z轴高度（0.0～1.0）

MultiplePiePlot(Plot)类：
void setLimit(double limit)    每个饼图之间的数据关联（详细比较复杂）   
void setPieChart(JFreeChart pieChart)   每个饼图的显示方式（见JFreeChart类个PiePlot类）

-----------------------------------------------------------------------------------------------------------

AbstractRenderer类：
void setItemLabelAnchorOffset(double offset)     数据标签的与数据点的偏移
void setItemLabelsVisible(boolean visible)     数据标签是否可见
void setItemLabelFont(Font font)      数据标签的字体
void setItemLabelPaint(Paint paint)      数据标签的字体颜色
void setItemLabelPosition(ItemLabelPosition position)    数据标签位置
void setPositiveItemLabelPosition(ItemLabelPosition position)   正数标签位置
void setNegativeItemLabelPosition(ItemLabelPosition position)   负数标签位置
void setOutLinePaint(Paint paint)      图形边框的线条颜色
void setOutLineStroke(Stroke stroke)      图形边框的线条笔触
void setPaint(Paint paint)       所有分类图形的颜色
void setShape(Shape shape)       所有分类图形的形状（如折线图的点）
void setStroke(Stroke stroke)       所有分类图形的笔触（如折线图的线）
void setSeriesItemLabelsVisible(int series,boolean visible)   指定分类的数据标签是否可见
void setSeriesItemLabelFont(int series,Font font)    指定分类的数据标签的字体
void setSeriesItemLabelPaint(int series,Paint paint)    指定分类的数据标签的字体颜色
void setSeriesItemLabelPosition(int series,ItemLabelPosition position)  数据标签位置
void setSeriesPositiveItemLabelPosition(int series,ItemLabelPosition position) 正数标签位置
void setSeriesNegativeItemLabelPosition(int series,ItemLabelPosition position) 负数标签位置
void setSeriesOutLinePaint(int series,Paint paint)    指定分类的图形边框的线条颜色
void setSeriesOutLineStroke(int series,Stroke stroke)    指定分类的图形边框的线条笔触
void setSeriesPaint(int series,Paint paint)     指定分类图形的颜色
void setSeriesShape(int series,Shape shape)     指定分类图形的形状（如折线图的点）
void setSeriesStroke(int series,Stroke stroke)     指定分类图形的笔触（如折线图的线）

AbstractCategoryItemRenderer(AbstractRenderer)类：
void setLabelGenerator(CategoryLabelGenerator generator)   数据标签的格式
void setToolTipGenerator(CategoryToolTipGenerator generator)   MAP中鼠标移上的显示格式
void setItemURLGenerator(CategoryURLGenerator generator)   MAP中钻取链接格式
void setSeriesLabelGenerator(int series,CategoryLabelGenerator generator) 指定分类的数据标签的格式
void setSeriesToolTipGenerator(int series,CategoryToolTipGenerator generator) 指定分类的MAP中鼠标移上的显示格式
void setSeriesItemURLGenerator(int series,CategoryURLGenerator generator) 指定分类的MAP中钻取链接格式

BarRenderer(AbstractCategoryItemRenderer)类：
void setDrawBarOutline(boolean draw)      是否画图形边框
void setItemMargin(double percent)      每个BAR之间的间隔
void setMaxBarWidth(double percent)      每个BAR的最大宽度
void setMinimumBarLength(double min)      最短的BAR长度，避免数值太小而显示不出
void setPositiveItemLabelPositionFallback(ItemLabelPosition position)  无法在BAR中显示的正数标签位置
void setNegativeItemLabelPositionFallback(ItemLabelPosition position)  无法在BAR中显示的负数标签位置

BarRenderer3D(BarRenderer)类：
void setWallPaint(Paint paint)    3D坐标轴的墙体颜色

StackedBarRenderer(BarRenderer)类：
没有特殊的设置

StackedBarRenderer3D(BarRenderer3D)类：
没有特殊的设置

GroupedStackedBarRenderer(StackedBarRenderer)类：
void setSeriesToGroupMap(KeyToGroupMap map)  将分类自由的映射成若干个组（KeyToGroupMap.mapKeyToGroup(series,group)）

LayeredBarRenderer(BarRenderer)类：
void setSeriesBarWidth(int series,double width)  设定每个分类的宽度（注意设置不要使某分类被覆盖）

WaterfallBarRenderer(BarRenderer)类：
void setFirstBarPaint(Paint paint)   第一个柱图的颜色
void setLastBarPaint(Paint paint)   最后一个柱图的颜色
void setPositiveBarPaint(Paint paint)   正值柱图的颜色
void setNegativeBarPaint(Paint paint)   负值柱图的颜色

IntervalBarRenderer(BarRenderer)类：
需要传IntervalCategoryDataset作为数据源

GanttBarRenderer(IntervalBarRenderer)类：
void setCompletePaint(Paint paint)   完成进度颜色
void setIncompletePaint(Paint paint)   未完成进度颜色
void setStartPercent(double percent)   设置进度条在整条中的起始位置（0.0～1.0）
void setEndPercent(double percent)   设置进度条在整条中的结束位置（0.0～1.0）

StatisticBarRenderer(BarRenderer)类：
需要传StatisticCategoryDataset作为数据源

LineAndShapeRenderer(AbstractCategoryItemRenderer)类：
void setDrawLines(boolean draw)    是否折线的数据点之间用线连
void setDrawShapes(boolean draw)   是否折线的数据点根据分类使用不同的形状
void setShapesFilled(boolean filled)   所有分类是否填充数据点图形
void setSeriesShapesFilled(int series,boolean filled) 指定分类是否填充数据点图形
void setUseFillPaintForShapeOutline(boolean use) 指定是否填充数据点的Paint也被用于画数据点形状的边框

LevelRenderer(AbstractCategoryItemRenderer)类：
void setItemMargin(double percent)   每个分类之间的间隔
void setMaxItemWidth(double percent)   每个分类的最大宽度

CategoryStepRenderer(AbstractCategoryItemRenderer)类：
void setStagger(boolean shouldStagger)   不同分类的图是否交错

MinMaxCategoryRenderer(AbstractCategoryItemRenderer)类：
void setDrawLines(boolean drawLines)   是否在每个分类线间画连接线
void setGroupPaint(Paint groupPaint)   一组图形连接线的颜色
void setGroupStroke(Stroke groupStroke)   一组图形连接线的笔触
void setMaxIcon(Icon maxIcon)    最大值的ICON
void setMinIcon(Icon minIcon)    最小值的ICON
void setObjectIcon(Icon objectIcon)   所有值的ICON

AreaRender(AbstractCategoryItemRenderer)类：
没有特殊的设置

StackedAreaRender(AreaRender)类：
没有特殊的设置

-----------------------------------------------------------------------------------------------------------

要获得上述对象，关键Struts 2.0中com.opensymphony.xwork2.ActionContext类。我们可以通过它的静态方法getContext()获取当前Action的上下文对象。 另外，org.apache.struts2.ServletActionContext作为辅助类（Helper Class），可以帮助您快捷地获得这几个对象。

HttpServletRequest request = ServletActionContext.getRequest();
HttpServletResponse response = ServletActionContext.getResponse();
HttpSession session = request.getSession();

XWork配置文件是以“xwork”命名的.xml文件，它必需放到类路径（classPath）的根目录， Web应用一般放在classes目录中，它需要遵守DTD的规范（现在是xwork-1.0.dtd）。这个文件定义了我们的Action，Interceptor，Result的配置和相互之间的映射。下面我们看看用户注册的完整XWork配置文件：

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN" "http://www.opensymphony.com/xwork/xwork-1.0.dtd">

<xwork>

    <include file="webwork-default.xml"/>

    <package name="example" extends="webwork-default">

       <action name="register" class="example.register.RegisterAction" >

           <result name="success" type="dispatcher">

              <param name="location">/register-result.jsp</param>

           </result>

           <interceptor-ref name="params"/>

       </action>

       <action name="registersupport" class="example.register.RegisterActionSupport" >

           <result name="success" type="dispatcher">

              <param name="location">/register-result.jsp</param>

           </result>

           <result name="input" type="dispatcher">

              <param name="location">/registerSupport.jsp</param>

           </result>

           <interceptor-ref name="validationWorkflowStack"/>

       </action>

    </package>

</xwork>

xwork.xml文件的标签元素

Xwork：xwork配置文件的所有内容，都是定义在<xwork>标签中，它的直接子标签有<package>和<include>。

Package：我们的Action，Interceptor，Result都是在此标签中定义。<package>标签有一个必需的属性“name”，它用来标识唯一的一个package。属性“extends”是可选的，它用来继承前面定义的一个或一个以上package配置信息，包括所有的interceptor、interceptor-stack和action的配置信息。注意，配置文件按文档的顺序，由上向下执行，因此，用“extends”引用的package必需在引用之前定义。属性“sbstract”是可选的，它用来设置package为抽象的package，它可以被继承同时它的Action配置信息在运行时将不可见。

属性namespace也是可选的，它用来分隔不同package定义的action，让这些action处于不同的命名空间（namespaces）。这样，我们不同的package可以有相同的action命名，因为可以通过命名空间来区分。如果不指定namespace，默认的是空字符串。命名空间也可以被用在安全控制方面，它可以根据不同的命名空间指定不同的访问权限。

Result-type：用来定义输出结果类型的Class，它用简单的名－值对来定义。当然，我们自己写的输出结果类型也必需在这里定义。例如：

<result-type name="dispatcher" class="com.opensymphony.webwork.dispatcher.ServletDispatcherResult" default="true"/>，default="true"表示如果在Action的result中不指定result-type，就使用这个默认的result-type。

Interceptors：它是一个简单的<interceptors>  <interceptors/>标签，我们的interceptor和interceptor-stack都在此标签内定义。

Interceptor：当然，就是用来定义我们的拦截器。它的定义非常简单，名－值对的形式。例如：<interceptor name="timer" class="com.opensymphony.xwork.interceptor.TimerInterceptor"/>。在action中，可以通过<interceptor-ref />来直接引用前面定义了的拦截器。

Interceptor-stack：用来将上面定义的interceptor组织成堆栈的形式，这样我们就可以创建一组标准的interceptor，让它按照顺序执行。在我们的Action中直接引用这个interceptor堆栈就可以了，不用逐个interceptor去引用。

例如：

<interceptor-stack name="validationWorkflowStack">

               <interceptor-ref name="defaultStack"/>

                <interceptor-ref name="validation"/>

                <interceptor-ref name="workflow"/>

            </interceptor-stack>

Interceptor Param：我们的interceptor是在ActionConfig级别被实例化和存储的，也就是说一个Action引用的每个interceptor都会有相应的实例。这样，我们在定义和引用interceptor的时候都可以为它设置相应的参数值。例如：

<interceptor name="test" class="com.opensymphony.xwork.TestInterceptor">

    <param name="foo">expectedFoo</param>

</interceptor>

在Action或Interceptor-stack中引用时也可以设置参数，例如：

<interceptor-ref name="test">

    <param name="expectedFoo">expectedFoo</param>

</interceptor-ref>

注意：在Action引用的时候，如果引用的是Interceptor-stack，则不允许设置参数，否则会报错。

Global-results：它允许我们定义全局的输出结果（global result），比如登陆页面、操作错误处理页面。只要继承它所在的package，这些输出结果都是可见的。

例如：

<global-results>

           <result name="login" type="dispatcher">

              <param name="location">/login.jsp</param>

           </result>

           <result name="error" type="dispatcher">

              <param name="location">/error.jsp</param>

           </result>

       </global-results>

如果我们的Action执行完返回“login”，它将调用上面的这个输出结果，将输出派遣到根目录下的login.jsp页面。

Action：用来配置Action的名称（name）和它对应的Class。我们将通过这个Action的名称和它所在package的namespace去配置文件中取得这个Action的配置信息。它可以通过<param>来设置参数，Action在执行的时候会取得配置文件里设置的参数（通过拦截器StaticParametersInterceptor）。

Action可以配置一个或多个输出结果(result)。一个输出结果的名称，对应于Action执行完成返回的字符串。<result>标签的type属性，对应我们前面定义过的result-type，说明reslut的类型。例如：

<action name="register" class="example.register.RegisterAction" >

           <result name="success" type="dispatcher">

              <param name="location">/register-result.jsp</param>

           </result>

           <interceptor-ref name="params"/>

       </action>

当然，我们的Action用到的拦截器也是在这里配置的，通过<interceptor-ref>标签，属性“name”的值，对应前面定义的interceptor或interceptor-stack。如果Action中没有用<interceptor-ref>标签指定拦截器，它将使用默认的<default-interceptor-ref>标签定义的拦截器。

Include：xwork..xml文件可以被分成好几个不同的文件，xwork..xml通过<include>标签引用被包含的文件，例如：<include file="webwork-default.xml"/>。被包含的文件必需是package标签里的内容，我们看看<include>标签在配置文件里的位置就知道了。如果要继承被包含文件的package，我们必需将<include>标签放在其上面，因为配置文件是按照由上而下的顺序解析的。

1. action
   通过指定命名空间和action名称,该标签允许你在jsp页面直接调用Action. 标签体用来渲染Action执行结果. 除非你设定了executeResult参数为true,否则你在xwork.xml中为该Action指定的Result Processor不会执行.
   

   名称	必填	缺省	类型	描述
   id	false		String	如果设定,将作为该Action在栈中的标识
   name	true		String	action名字(不包括后缀,如.action)
   namespace	false		String	action所在命名空间
   executeResult	false	false	Boolean	Action的result是否需要被执行
   ignoreContextParams	false	false	Boolean	request中的参数是否需要传入该Action

2. bean
   

   实例化一个符合JavaBeans规范的class,标签体内可以包含几个Param元素,用于调用setter方法给此class的属性赋值.如果是定了id属性,则该实例将会放到stack的context中.
   

   名称	必填	缺省	类型	描述
   name	true		String	要被实例化的class名字(必须符合JavaBeans规范)
   id	false		String/Object	标识该元素

3. debug
   
4. i18n
   将某个特定resource bundle放入value stack. 然后通过text标签拿到相应message, 而不是仅限于绑定到当前action的bundle.
   

   名称	必填	缺省	类型	描述
   name	true		String	要使用的resource bundle.(如 foo/bar/customBundle)
   id	false		String/Object	标识该元素

5. include
   包含servlet的输出(servlet或JSP页面)
   

   名称	必填	缺省	类型	描述
   value	true		String	包含的jsp或servlet
   id	false		Object/String	元素标识

   例子:
   <ww:include value="myJsp.jsp">
      <ww:param name="param1" value="value2" />
      <ww:param name="param2" value="value2" />
   </ww:include>
   
   
   
6. param
   

   为其他标签提供参数,比如include标签和bean标签.
   参数的name属性是可选的,如果提供,会调用Component的方法addParameter(String, Object),如果不提供,则外层嵌套标签必须实现UnnamedParametric接口(如TextTag).

   该标签的两个属性

   • name (String) - 参数名
   • value (Object) - 参数值
     

     注意 : value的提供有两种方式,通过value属性或者标签中间的text,不同之处我们看一下例子:

     <param name="color">blue</param> <-- (A) -->
             <param name="color" value="blue"/> <-- (B) -->

     (A)中,参数值会以String的格式放入statck. (B)中该值会以java.lang.Object的格式放入statck.

7. push
   push值到堆栈中,方便应用.
   

   名称	必填	缺省	类型	描述
   value	true		Object/String	要push到堆栈中的值
   id	false		Object/String	该元素标识

   <ww:push value="user">
       <ww:propery value="firstName" />
       <ww:propery value="lastName" />
   </ww:push>
   
   将user的值push到栈中,从而使property标签的能够获取user的属性(firstName, lastName etc)
   
8. set
   set标签赋予变量一个特定范围内的值. 当希望给一个变量赋一个复杂的表达式,每次访问该变量而不是复杂的表达式时用到.其在两种情况下非常有用: 复杂的表达式很耗时 (性能提升) 或者很难理解 (代码可读性提高).
   

   名称	必填	缺省	类型	描述
   name	true		String	变量的名字
   scope	false	action	String	变量作用域,可以为application, session, request, page, 或action.
   value	false		Object/String	将会赋给变量的值
   id	false		Object/String	元素标识

9. <ww:set name="personName" value="person.name"/>
   Hello, <ww:property value="#personName"/>. How are you?
10. text
    

    支持国际化信息的标签

    国际化信息必须放在一个和当前action同名的resource bundle中,如果没有找到相应message,tag body将被当作默认message,如果没有tag body,message的name会被作为默认message
    

    名称	必填	缺省	类型	描述
    name	true		Object/String	资源属性的名字
    name	false		Object/String	该元素标识

11. url
    

    该标签用于创建url,可以通过"param"标签提供request参数.

    注意:
    当includeParams的值时'all'或者'get', param标签中定义的参数将有优先权,也就是说其会覆盖其他同名参数的值.
    

    名称	必填	缺省	类型	描述
    includeParams	false	get	Object/String	值为'none', 'get' 或'all'.
    scheme	false		Object/String	scheme属性
    value	false		Object/String	value如果不提供就用当前action
    action	false		Object/String	用来生成url的action,如果没有则使用value
    namespace	false		Object/String	命名空间
    method	false		Object/String	使用的action的方法
    encode	false	true	Boolean	是否encode参数
    includeContext	false	true	Boolean	是否实际的上下文环境应该包含在url中
    portletMode	false		Object/String	结果portlet 的模式(mode)
    windowState	false		Object/String	结果portlet窗口的状态
    portletUrlType	false		Object/String	指定这时一个 portlet 输出还是一个 action url
    anchor	false		Object/String	URL的锚点( anchor)
    id	false		Object/String	该元素标识

12. <ww:url value="editGadget.action">
        <ww:param name="id" value="%{selected}" />
    </ww:url>

13. property
    得到'value'的属性,如果value没提供,默认为堆栈顶端的元素.
    

    名称	必填	缺省	类型	描述
    default	false		String	如果属性是null则显示的default值
    escape	false	true	Boolean	是否escape HTML
    value	false	<top of stack>	Object	value to be displayed
    id	false		Object/String	该元素标识

    
    

    <ww:push value="myBean">
        <!-- Example 1: -->
        <ww:property value="myBeanProperty" />
        <!-- Example 2: -->
        <ww:property value="myBeanProperty" default="a default value" />
        </ww:push>

1. if
   

   基本的流程控制.'If'标签可单独使用也可以和'Else If'标签和(或)一个多个'Else'一起使用.
   

   名称	必填	缺省	类型	描述
   test	true		Boolean	决定If标签内容是否显示的表达式
   id	false		Object/String	所指元素的Id. 对于UI和form标签此Id就作为所对应的html标签的id属性

   
   

2. elseIf / elseif
   基本的流程控制.'If'标签可单独使用也可以和'Else If'标签和(或)一个多个'Else'一起使用.
   

   名称	必填	缺省	类型	描述
   test	true		Boolean	决定If标签内容是否显示的表达式
   id	false		Object/String	所指元素的Id. 对于UI和form标签此Id就作为所对应的html标签的id属性

3. else
   

   基本的流程控制.'If'标签可单独使用也可以和'Else If'标签和(或)一个多个'Else'一起使用.
   

   名称	必填	缺省	类型	描述
   id	false		Object/String	所指元素的Id. 对于UI和form标签此Id就作为所对应的html标签的id属性

4. append
   

   常和Iterator标签一起使用, 功能就是将不同的迭代器组合在一起,使一个迭代器迭代完成后转移到下一个迭代器中继续迭代.

   例如有三个迭代器组合在一起 (每一个迭代器有三个元素), 下面说明了新生成的迭代器中的元素是如何被迭代的;

   1. 第一个迭代器中的第一个元素
   2. 第一个迭代器中的第二个元素
   3. 第一个迭代器中的第三个元素
   4. 第二个迭代器中的第一个元素
   5. 第二个迭代器中的第二个元素
   6. 第二个迭代器中的第三个元素
   7. 第三个迭代器中的第一个元素
   8. 第三个迭代器中的第二个元素
   9. 第三个迭代器中的第三个元素
   

   名称	必填	缺省	类型	描述
   id	false		Object/String	标明新产生的迭代器在stack context中的名字

   
   

5. generator
   

   NOTE: JSP-TAG
   由val属性提供的值产生一个迭代器.

   注意: 所产生的迭代器 总是 在value stack的顶端并在此标签结束后被pop出value statck
   
   

   名称	必填	缺省	类型	描述
   count	false		Integer	所生成迭代器中元素的数量
   separator	true		String	val属性中的分隔符
   val	true		String/Object	用于生成迭代器
   converter	false		com.opensymphony.webwork.util.IteratorGenerator.Converter	转换val属性提供的值转换为对象的转换器
   id	false		String	如果提供,将代表page context中生成的迭代器

6. iterator
   可以对java.util.Collection,java.util.Iterator类型的值进行迭代
   

   名称	必填	缺省	类型	描述
   status	false	false	Boolean	如果提供该属性 每次迭代时候将生成一个IteratorStatus实例并放入堆栈中
   value	false		Object/String	迭代源, 或者一个对象被放入最新创建的List
   id	false		Object/String	element的id属性

7. merge
   

   MergeIteratorTag的组件,作用是合并迭代器,合并后的迭代器迭代时依次调用每一个被合并的迭代器(除非这个迭代器已经迭代完毕)

   背后的工作是交给 MergeIteratorFilter完成的

   例如有三个list被合并,每一个有三个元素,以下就是调用顺序:

   1. 第一个list的第一个元素
   2. 第二个list的第一个元素
   3. 第三个list的第一个元素
   4. 第一个list的第二个元素
   5. 第二个list的第二个元素
   6. 第三个list的第二个元素
   7. 第一个list的第三个元素
   8. 第二个list的第三个元素
   9. 第三个list的第三个元素
   

   名称	必填	缺省	类型	描述
   id	false		Object/String	标明新产生的迭代器在stack context中的名字

8. sort
   NOTE:JSP-TAG
   用传入的 Comparator对List进行排序.如果提供id属性,该属性作为排序后的list在PageContext中的标识. 排序后的list放在堆栈顶端,并在此tag结束后弹出.
   

   名称	必填	缺省	类型	描述
   comparator	true		java.util.Comparator	用来做比较的comparator
   source	false		Object/String	迭代的内容来源
   id	false		String	tag元素的id属性

9. subset
   取一个迭代器的子集.内部实现是通过com.opensymphony.webwork.util.SubsetIteratorFilter.
   

   名称	必填	缺省	类型	描述
   count	false		Integer	子集中的元素个数
   source	false		Object/String	源集合
   start	false		Integer	子集在源集合中的开始索引(如从0开始)
   decider	false		com.opensymphony.webwork.util.SubsetIteratorFilter.Decider	用于判断是否某特定元素包含在子集中
   id	false		String	标签元素的id属性

　　还有一种方式是对J2EE容器进行编码设置，如果J2EE应用系统脱离该容器，则会发生乱码，而且指定容器配置不符合J2EE应用和容器分离的原则。

　　在Java内部运算中，涉及到的所有字符串都会被转化为UTF-8编码来进行运算。那么，在被Java转化之前，字符串是什么样的字符集？ Java总是根据操作系统的默认编码字符集来决定字符串的初始编码，而且Java系统的输入和输出的都是采取操作系统的默认编码。

　　因此，如果能统一Java系统的输入、输出和操作系统3者的编码字符集合，将能够使Java系统正确处理和显示汉字。这是处理Java系统汉字的一个原则，但是在实际项目中，能够正确抓住和控制住Java系统的输入和输出部分是比较难的。J2EE中，由于涉及到外部浏览器和数据库等，所以中文问题乱码显得非常突出。

　　J2EE应用程序是运行在J2EE容器中。在这个系统中，输入途径有很多种：一种是通过页面表单打包成请求（request）发往服务器的；第二种是通过数据库读入；还有第3种输入比较复杂，JSP在第一次运行时总是被编译成Servlet，JSP中常常包含中文字符，那么编译使用javac时，Java将根据默认的操作系统编码作为初始编码。除非特别指定，如在Jbuilder/eclipse中可以指定默认的字符集。

　　输出途径也有几种：第一种是JSP页面的输出。由于JSP页面已经被编译成Servlet，那么在输出时，也将根据操作系统的默认编码来选择输出编码，除非指定输出编码方式；还有输出途径是数据库，将字符串输出到数据库。

　　由此看来，一个J2EE系统的输入输出是非常复杂，而且是动态变化的，而Java是跨平台运行的，在实际编译和运行中，都可能涉及到不同的操作系统，如果任由Java自由根据操作系统来决定输入输出的编码字符集，这将不可控制地出现乱码。

　　正是由于Java的跨平台特性，使得字符集问题必须由具体系统来统一解决，所以在一个Java应用系统中，解决中文乱码的根本办法是明确指定整个应用系统统一字符集。

　　指定统一字符集时，到底是指定ISO8859_1 、GBK还是UTF-8呢？

　　（1）如统一指定为ISO8859_1，因为目前大多数软件都是西方人编制的，他们默认的字符集就是ISO8859_1，包括操作系统Linux和数据库MySQL等。这样，如果指定Jive统一编码为ISO8859_1，那么就有下面3个环节必须把握：

　　开发和编译代码时指定字符集为ISO8859_1。

　　运行操作系统的默认编码必须是ISO8859_1，如Linux。

　　在JSP头部声明：。

　　（2）如果统一指定为GBK中文字符集，上述3个环节同样需要做到，不同的是只能运行在默认编码为GBK的操作系统，如中文Windows。

　　统一编码为ISO8859_1和GBK虽然带来编制代码的方便，但是各自只能在相应的操作系统上运行。但是也破坏了Java跨平台运行的优越性，只在一定范围内行得通。例如，为了使得GBK编码在linux上运行，设置Linux编码为GBK。

　　那么有没有一种除了应用系统以外不需要进行任何附加设置的中文编码根本解决方案呢？

　　将Java/J2EE系统的统一编码定义为UTF-8。UTF-8编码是一种兼容所有语言的编码方式，惟一比较麻烦的就是要找到应用系统的所有出入口，然后使用UTF-8去“结扎”它。

　　一个J2EE应用系统需要做下列几步工作：

1. 开发和编译代码时指定字符集为UTF-8。JBuilder和Eclipse都可以在项目属性中设置。
2. 使用过滤器，如果所有请求都经过一个Servlet控制分配器，那么使用Servlet的filter执行语句，将所有来自浏览器的请求（request）转换为UTF-8，因为浏览器发过来的请求包根据浏览器所在的操作系统编码，可能是各种形式编码。关键一句：
   request.setCharacterEncoding(”UTF-8″)。
   网上有此filter的源码，Jdon框架源码中com.jdon.util.SetCharacterEncodingFilter
   需要配置web.xml 激活该Filter。
3. 在JSP头部声明：。
4. 在Jsp的html代码中，声明UTF-8:
5. 设定数据库连接方式是UTF-8。例如连接MYSQL时配置URL如下：
   jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
   注意，上述写法是JBoss的mysql-ds.xml写法，多亏网友提示，在tomcat中&要写成&即可。一般其他数据库都可以通过管理设置设定UTF-8
6. 其他和外界交互时能够设定编码时就设定UTF-8，例如读取文件，操作XML等。

　　　　 笔者以前在Jsp/Servlet时就采取这个原则，后来使用Struts、Tapestry、EJB、Hibernate、Jdon等框架时，从未被乱码困扰过，可以说适合各种架构。希望本方案供更多初学者分享，减少Java/J2EE的第一个拦路虎，也避免因为采取一些临时解决方案，导致中文问题一直出现在新的技术架构中。


另一篇文章


对于一个Java初学者来说，经常碰到的一个问题恐怕就是中文问题了。其实很正常，我们有几千年的悠久历史嘛，博大精深，岂能是小小的计算机语言所能包容的？呵呵，开个玩笑。但是不可否认的一个事实就是，就算是一个比较有经验的开发人员，也经常面对着屏幕上的乱码而大伤脑筋。

　　想究其原因、彻底解决这一问题吗？follow me……

乱码原因
　　java内核是unicode的。但Java总是根据操作系统的默认编码字符集来决定字符串的初始编码，而且Java系统的输入和输出的都是采取操作系统的默认编码，而数据库、文件、网络传输中的字节流……采用的编码更是各不相同。所以不可避免的就会出现烦人的乱码问题了。

解决办法
　　1、GB2312、GBK、Unicode（UTF8）？
　　从字符集的大小比较 GB2312 < GBK < UTF8，很显然，如果我们采用UTF8作为系统编码的话，是不会有错的。而且如果你要考虑国际化的话，UTF8似乎是你唯一的选择
　　2、开发和编译代码时指定字符集为UTF-8
　　JBuilder和Eclipse都可以在项目属性中设置。
　　3、使用过滤器
　　编写过滤器

struts.properties

package one;
import com.opensymphony.xwork2.ActionSupport;

public class HelloWorld extends ActionSupport{
    private String message;

    public void setMessage(String message) {
        this.message = message;
    }
    
    public String getMessage() {
        return message;
    }

    public String execute(){
        System.out.println("execute 测试..");
        message="Hello peidw";
        
        return ActionSupport.SUCCESS;
    }
}

常用的限定符
* 重复零次或更多次
+ 重复一次或更多次
? 重复零次或一次
{n} 重复n次
{n,} 重复n次或更多次
{n,m} 重复n到m次

常用的反义代码
\W 匹配任意不是字母，数字，下划线，汉字的字符
\S 匹配任意不是空白符的字符
\D 匹配任意非数字的字符
\B 匹配不是单词开头或结束的位置
[^x] 匹配除了x以外的任意字符
[^aeiou] 匹配除了aeiou这几个字母以外的任意字符

常用的正则表达式:

匹配中文字符的正则表达式： [\u4e00-\u9fa5], [\一-\龥] 可以.
评注：匹配中文还真是个头疼的事，有了这个表达式就好办了

匹配双字节字符(包括汉字在内)：[^\x00-\xff]
评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）

匹配空白行的正则表达式：\n\s*\r
评注：可以用来删除空白行

匹配HTML标记的正则表达式：<(\S*?)[^>]*>.*?</\1>|<.*? />
评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力

匹配首尾空白字符的正则表达式：^\s*|\s*$
评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式

匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
评注：表单验证时很实用

匹配网址URL的正则表达式：[a-zA-z]+://[^\s]*
评注：网上流传的版本功能很有限，上面这个基本可以满足需求

匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
评注：表单验证时很实用

匹配国内电话号码：\d{3}-\d{8}|\d{4}-\d{7}
评注：匹配形式如 0511-4405222 或 021-87888822

匹配腾讯QQ号：[1-9][0-9]{4,}
评注：腾讯QQ号从10000开始

匹配中国邮政编码：[1-9]\d{5}(?!\d)
评注：中国邮政编码为6位数字

匹配身份证：\d{15}|\d{18}
评注：中国的身份证为15位或18位

匹配ip地址：\d+\.\d+\.\d+\.\d+
评注：提取ip地址时有用

匹配特定数字：
^[1-9]\d*$　 　 //匹配正整数
^-[1-9]\d*$ 　 //匹配负整数
^-?[1-9]\d*$　　 //匹配整数
^[1-9]\d*|0$　 //匹配非负整数（正整数 + 0）
^-[1-9]\d*|0$　　 //匹配非正整数（负整数 + 0）
^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$　　 //匹配正浮点数
^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$　 //匹配负浮点数
^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$　 //匹配浮点数
^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$　　 //匹配非负浮点数（正浮点数 + 0）
^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$　　//匹配非正浮点数（负浮点数 + 0）
评注：处理大量数据时有用，具体应用时注意修正

匹配特定字符串：
^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串
^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串
^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串
^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串
^\w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串
评注：最基本也是最常用的一些表达式

import javax.servlet.http.HttpServletRequest;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.TagSupport;

import com.scitel.gdnumcommon.entity.Pagination;

/**
 *
 *
 * <p>Description: 分页标签类</p>
 *
 * <p>Copyright: Copyright (c) 2006</p>
 *
 * <p>Company: 深圳科讯数码有限公司</p>
 *
 * @author 
 * @version 1.0 时间 Mar 6, 2006
 */
public class PaginationTag extends TagSupport {
 /**
  * 唯一ID
  */
 private static final long serialVersionUID = 1673491971683216709L;
    /**
     * 链接路径
     */
 private String path = null;
 /**
  * 分页类保存在request中的名称,与类名相同
  */
 private String name = null;
 /**
  * 所带参数名称(page)
  */
 private String parameter = null;
 /**
  *表单名称
  */
 private String formName = null;
 
 /**
  * @param name The name to set.
  */
 public void setName(String name) {
  this.name = name;
 }
 /**
  * @param path The path to set.
  */
 public void setPath(String path) {
  this.path = path;
 }
 
 /**
  * @param parameter The parameter to set.
  */
 public void setParameter(String parameter) {
  this.parameter = parameter;
 }
 
 /**
  * @param formName The formName to set.
  */
 public void setFormName(String formName) {
  this.formName = formName;
 }
 
 /* (non-Javadoc)
  * @see javax.servlet.jsp.tagext.TagSupport#doStartTag()
  */
 public int doStartTag() throws JspException {
  // TODO Auto-generated method stub
  Pagination pagination = null;

  if(this.path == null){
   throw new NullPointerException("path属性不能为空");
  }
  
  if(this.name == null){
   this.name = "pagination";
  }
  
  if(this.parameter == null){
   this.parameter = "page";
  }
  
  pagination = (Pagination)pageContext.getRequest().getAttribute(name);
  
  if(pagination == null) {
   throw new NullPointerException(name + "在request中为空!");
  }
  
  try{
   JspWriter out = pageContext.getOut();

   String contextPath = encodeURL(this.path, this.parameter);
   if(this.formName != null && this.formName.length() > 0){
    if(pagination.isHasPreviousPage()){
     out.println("<a class=\"pagination\" href=\"" + contextPath + "1\" onclick=\"paginationSubmit('1');return false;\" title=\"第一页\">第一页</a>");
     out.println("<a class=\"pagination\" href=\"" + contextPath + pagination.getPreviousPage() + "\" onclick=\"paginationSubmit('" + pagination.getPreviousPage() + "');return false;\" title=\"上一页\">上一页</a>");
    }else{
     out.println("<span title=\"第一页\">第一页</span>");
     out.println("<span title=\"上一页\">上一页</span>");
    }
    
    if(pagination.isHasNextPage()){
     out.println("<a class=\"pagination\" href=\"" + contextPath + pagination.getNextPage() + "\" onclick=\"paginationSubmit('" + pagination.getNextPage() + "');return false;\"  title=\"下一页\">下一页</a>");
     out.println("<a class=\"pagination\" href=\"" + contextPath + pagination.getTotalPage() + "\" onclick=\"paginationSubmit('" + pagination.getTotalPage() + "');return false;\" title=\"最后一页\">最后一页</a>");
    }else{
     out.println("<span title=\"下一页\">下一页</span>");
     out.println("<span title=\"最后一页\">最后一页</span>");
    }
   }else{
    if(pagination.isHasPreviousPage()){
     out.println("<a class=\"pagination\" href=\"" + contextPath + "1\" title=\"第一页\">第一页</a>");
     out.println("<a class=\"pagination\" href=\"" + contextPath + pagination.getPreviousPage() + "\" title=\"上一页\">上一页</a>");
    }else{
     out.println("<span title=\"第一页\">第一页</span>");
     out.println("<span title=\"上一页\">上一页</span>");
    }
    
    if(pagination.isHasNextPage()){
     out.println("<a class=\"pagination\" href=\"" + contextPath + pagination.getNextPage() + "\" title=\"下一页\">下一页</a>");
     out.println("<a class=\"pagination\" href=\"" + contextPath + pagination.getTotalPage() + "\" title=\"最后一页\">最后一页</a>");
    }else{
     out.println("<span title=\"下一页\">下一页</span>");
     out.println("<span title=\"最后一页\">最后一页</span>");
    }
   }
   
   out.println("&nbsp;");
   out.println("共有" + pagination.getTotalCount() + "条");
   out.print("&nbsp;");
   out.println("每页" + pagination.getCount() + "条");
   out.print("&nbsp;");
   out.println("共" + pagination.getTotalPage() + "页");
   out.print("&nbsp;");
   out.println("本页是第" + pagination.getCurrPage() + "页");
   out.println("&nbsp;");
   out.println("跳转到第<input type=\"text\" id=\"" + this.parameter + "\" class=\"input1\" size=\"3\" maxlength=\"5\">页");
   out.println("&nbsp;");
   out.println("<button onclick=\"paginationGoto();\" class=\"buttonbg\">跳转</button>");
   out.println("<br />");
   /*创建CSS内容*/
   createCSS(out);
   if(this.formName != null && this.formName.length() > 0) {
    /*创建js内容*/
    createJS(out, contextPath, pagination.getTotalPage());
   }else{
    createNoFormJS(out, this.path, pagination.getTotalPage());
   }
   out.println();
  }catch(Exception e){
   throw new JspException(e);
  }
  
  return SKIP_BODY;
 }
 
 /* (non-Javadoc)
  * @see javax.servlet.jsp.tagext.TagSupport#doEndTag()
  */
 public int doEndTag() throws JspException {
  // TODO Auto-generated method stub
  return EVAL_PAGE;
 }
 
 /**
  * 改变URL使它能访问到action或servlet中去
  * @param href 从页面传来的href
  * @param param
  * @param queryStr 查询内容
  * @return
  * @author 
  */
 private final String encodeURL(String href, String param){
  StringBuffer buffer = new StringBuffer(100);
  
  HttpServletRequest request =
   (HttpServletRequest)this.pageContext.getRequest();
  buffer.append(request.getContextPath() + "/" + href);

  // 判断是否已经带有？号
  int question = href.indexOf("?");
  if(question > 0 ){
   buffer.append("&" + param + "=");
  }else{
   buffer.append("?" + param + "=");
  }
  
  return buffer.toString();
 }
 
 /**
  * 创建js内容如果提交form就用js提交
  * @param out
  * @param contextPath
  * @throws Exception
  * @author 
  */
 private final void createJS(JspWriter out, String contextPath, int totalPage) throws Exception {
  out.println("<script language=\"javascript\">");
  out.println("function paginationSubmit(pageNum_) { ");
  out.println("  document." + formName + ".action=\'" + contextPath + "\' + pageNum_ + \'\';");
  out.println("  document." + formName + ".submit();");
  out.println("}");
  /*跳转内容*/
  HttpServletRequest request =
   (HttpServletRequest)this.pageContext.getRequest();
  String contPath = request.getContextPath() + "/" + this.path;
  out.println("function paginationGoto() { ");
  out.println("  if(!controlNotNull(document.all." + this.parameter + ", '跳转页面')) {");
  out.println("    return;");
  out.println("  }");
  out.println("  ");
  out.println("  if(!controlIsInt(document.all." + this.parameter + ", '跳转页面')) {");
  out.println("    return;");
  out.println("  }");
  out.println("  ");
  out.println("  pageNum_ = document.all." + this.parameter + ".value");
  out.println("  if(pageNum_ > 0 && pageNum_ <= " + totalPage + ") {");
  out.println("    document." + formName + ".action=\'" + contPath + "&" + this.parameter + "=\' + pageNum_ + \'\';");
  out.println("    document." + formName + ".submit();");
  out.println("  } else { ");
  out.println("    alert(\"您输入的页数超出范围\");");
  out.println("  }");
  out.println("}");
  out.println("</script>");
  out.println();
 }
 
 /**
  * 创建没有form时的js
  * @param out
  * @param contextPath
  * @throws Exception
  * @author 
  */
 private final void createNoFormJS(JspWriter out, String href, int totalPage) throws Exception {
  HttpServletRequest request =
   (HttpServletRequest)this.pageContext.getRequest();
  String contPath = request.getContextPath() + "/" + href;

  out.println("<script language=\"javascript\">");
  out.println("function paginationGoto() { ");
  out.println("  if(!controlNotNull(document.all." + this.parameter + ", '跳转页面')) {");
  out.println("    return;");
  out.println("  }");
  out.println("  ");
  out.println("  if(!controlIsInt(document.all." + this.parameter + ", '跳转页面')) {");
  out.println("    return;");
  out.println("  }");
  out.println("  ");
  out.println("  pageNum_ = document.all." + this.parameter + ".value");
  out.println("  if(pageNum_ > 0 && pageNum_ <= " + totalPage + ") {");
  out.println("    document.location.href=\'" + contPath + "&" + this.parameter + "=\' + pageNum_ + \'\';");
  out.println("  } else { ");
  out.println("    alert(\"您输入的页数超出范围\");");
  out.println("  }");
  out.println("}");
  out.println("</script>");
  out.println();
 }
 
 /**
  * 创建css内容
  * @param out
  * @throws Exception
  * @author 

  */
 private final void createCSS(JspWriter out)throws Exception {
  out.println("<style type=\"text/css\">");
  out.println("a.pagination:visited { text-decoration: underline; color: #808080; } ");//#CCCCFF #c0c0c0
  out.println("a.pagination:link { text-decoration: underline; color: blue; } ");
  out.println("a.pagination:hover { text-decoration: none; color: #009933; } ");
  out.println("a.pagination:active { text-decoration: none; color: orangered; } ");
  out.println("</style>");
 }
}
========================================
<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
 "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
    <tlib-version>1.0</tlib-version>
 <jsp-version>1.2</jsp-version>
 <short-name>page</short-name>
 <description>
 @author
 pagination page 1-10
 </description>

 <tag>
  <name>pagination</name>
  <tag-class>com.scitel.gdnumcommon.ctag.PaginationTag</tag-class>
  <body-content>empty</body-content>

  <attribute>
   <name>path</name>
   <required>true</required>
   <rtexprvalue>true</rtexprvalue>
  </attribute>

  <attribute>
   <name>name</name>
   <required>false</required>
   <rtexprvalue>true</rtexprvalue>
  </attribute>

  <attribute>
   <name>parameter</name>
   <required>false</required>
   <rtexprvalue>true</rtexprvalue>
  </attribute>
  
  <attribute>
   <name>formName</name>
   <required>false</required>
   <rtexprvalue>true</rtexprvalue>
  </attribute>

 </tag>
</taglib>
=============================
页面使用代码
  <Td align="right" colspan="10">
  <page:pagination path="wfProcAction.do?method=queryWorkFlow" name="pagination" parameter="page" formName="form1" />
  </Td>
===============================================
Action 类中使用代码
     String page = request.getParameter("page");
     Pagination pagination = new Pagination();
     pagination.setTotalCount(didWf.size());
    
                 if (page != null && page.length() > 0) {
          pagination.setPage(Integer.parseInt(page));
     }else {
          pagination.setPage(1);
     }
                 int page_=pagination.getPage();
                 int row_start=(page_*pagination.getCount())-pagination.getCount();
                 int row_end=page_*pagination.getCount();
                 if(row_end>didWf.size()) {
                  row_end=didWf.size();
                 }
                 List datalist=didWf.subList(row_start,row_end);
                 request.setAttribute("wkList",datalist);
                
                 request.setAttribute("pagination", pagination);
===============================

1. 在JSP文件头加入

< %@ page contentType="text/html; charset=GBK" % >

指定该JSP采用的字符集。

2．在Weblogic.xml文件的< jsp-descriptor >中加入：

< jsp-param >

< param-name >encoding< /param-name >

< param-value >GBK< /param-value >

< /jsp-param >

指定JSP文件中采用的字符集，在JSP文件中的< %@ page contentType="text/html; charset=GBK" % >会覆盖该设置

3．在Weblogic.xml文件的< jsp-descriptor >中加入

< jsp-param >

< param-name >compilerSupportsEncoding< /param-name >

< param-value >true< /param-value >

< /jsp-param >

如果为TRUE，指定在编译JSP文件时，采用在JSP文件中定义的

< %@ page contentType="text/html; charset=GBK" % >或< jsp-descriptor >中定义的encoding参数中定义的字符集进行编码，如果为FALSE，则采用JVM中默认指定的字符集进行编码。

4． Weblogic Server需要把HTTP request(GET 和POST)中的数据从它的原始编码转化为Unicode，以便Java servlet API进行处理，为了做这种转换，Weblogic Server需要知道HPPT request中的数据的编码方式。这可以通过在Weblogic.xml的< context-param >中设置.

< input-charset >

< resource-path >/< /resource-path >

< java-charset-name >GBK< /java-charset-name >

< /input-charset >

5．从ORACLE数据库中检索出来的中文显示不正确时，在这种情况下，如果数据库使用的是中文字符集，并使用的是Type 2 JDBC Driver时，可加入Weblogic.codeset=GBK的属性来解决这个问题。代码如下：

java.util.Properties props = new java.util.Properties();

props.put("Weblogic.codeset", "GBK");

props.put("user", "scott");

props.put("password", "tiger");

String connectUrl = "jdbc:Weblogic:oracle";

Driver myDriver = (Driver)

Class.forName("Weblogic.jdbc.oci.Driver").newInstance();

Connection conn =

myDriver.connect(connectUrl, props);

6． 如果是采用WTC调用Tuxedo中的服务，在JSP页面中无法正确显示中文，必须使安装Tuxedo的服务器上的NLS_LANG环境变量与数据库中的字符集的设置一样。如后台Oracle数据库中的字符集设置为SIMPLIFIED CHINESE_CHINA.ZHS16GBK，那么Tuxedo应用服务器上的NLS_LANG环境变量应设置为：export NLS_LANG="SIMPLIFIED CHINESE_CHINA.ZHS16GBK"

import org.apache.commons.lang.builder.*;
import java.io.Serializable;

/**
 * VO基础类,在系统中希望VO与PO分离
i
 * @author peidw
 *
 */
public  abstract  class BaseVO implements Serializable{
 
 public String toString() {
  return ToStringBuilder.reflectionToString(this);
 }
 
 public boolean equals(Object obj) {
  return EqualsBuilder.reflectionEquals(this,obj);
 }
 
 public int hashCode() {
  return HashCodeBuilder.reflectionHashCode(this);
 }
}

import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.Types;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.scitel.gdnumcommon.entity.Pagination;
import com.scitel.gdnumcommon.entity.BaseVO;


public class BaseDAO {
 private static final Log log = LogFactory.getLog(BaseDAO.class);

 /**
  * 保存数据,新建和修改都用这个
  *
  * @param con
  * @param SQL
  * @param params
  * @throws Exception
  * @author
  */
 public void save(Connection con, String SQL, List params)
   throws Exception {
  PreparedStatement ps = null;
  try {
   ps = con.prepareStatement(SQL);
   if (SQL == null) {
    throw new Exception();
   }

   if (params != null && params.size() > 0) {
    int count = 0;
    for (Iterator iterator = params.iterator(); iterator.hasNext(); count++) {
     Object object = iterator.next();
     setObjectValue(ps, count + 1, object);
    }
   }
   ps.executeUpdate();
  } catch (Exception e) {
   log.error(e);
   throw e;
  } finally {
   try{
    if(ps != null) {
     ps.close();
    }
   }catch(Exception e){

   }
  }
 }

 /**
  * 保存数据,新建和修改都用这个,通过字段名称匹配类型
  * @param con
  * @param SQL
  * @param voclass
  * @param paramMap
  * @throws Exception
  * @author
  */
 public void save(Connection con, String SQL, Class voclass, Map paramMap)
   throws Exception {
  PreparedStatement ps = null;
  try {
   ps = con.prepareStatement(SQL);
   if (SQL == null) {
    throw new Exception();
   }

   if (paramMap != null && paramMap.size() > 0) {
    int count = 0;
    for (Iterator iterator = paramMap.keySet().iterator(); iterator.hasNext(); count++) {

     String key = (String)iterator.next();
     Object object = paramMap.get(key);
     setObjectValue(ps, voclass, count+1, key, object);
    }
   }
   ps.executeUpdate();
  } catch (Exception e) {
   log.error(e);
   throw e;
  } finally {
   try{
    if(ps != null) {
     ps.close();
    }
   }catch(Exception e){

   }
  }
 }

 /**
  * 删除数据
  *
  * @param con
  * @param SQL
  * @param params
  * @throws Exception
  * @author
  */
 public void remove(Connection con, String SQL, List params)
   throws Exception {
  PreparedStatement ps = null;
  try {
   ps = con.prepareStatement(SQL);
   if (SQL == null) {
    throw new Exception();
   }
   if (params != null && params.size() > 0) {
    int count = 0;
    for (Iterator iterator = params.iterator(); iterator.hasNext(); count++) {
     Object object = iterator.next();
     setObjectValue(ps, count + 1, object);
    }
   }
   ps.executeUpdate();
  } catch (Exception e) {
   log.error(e);
   throw e;
  } finally {
   try{
    if(ps != null) {
     ps.close();
    }
   }catch(Exception e){

   }
  }
 }

 /**
  * 根据ID选择数据
  *
  * @param con
  * @param SQL
  * @param id
  * @param voclass
  * @return
  * @throws Exception
  * @author
  */
 public BaseVO selectById(Connection con, String SQL, String id,
   Class voclass) throws Exception {
  Object po = null; // 承载值对象
  PreparedStatement ps = null;
  ResultSet rs = null;
  ResultSetMetaData rsm = null;
  try {
   ps = con.prepareStatement(SQL);
   if (SQL == null) {
    throw new Exception();
   }

   ps.setString(1, id);

   rs = ps.executeQuery();
   rsm = rs.getMetaData();
   if (rs.next()) {
    Map entity = new HashMap();
    for (int i = 1; i <= rsm.getColumnCount(); i++) {
     String columnName = rsm.getColumnName(i).toLowerCase();
     Object columnValue = getObjectValue(rs, voclass, i, columnName);
     entity.put(columnName, columnValue);
    }
    if (voclass != null) {
     po = voclass.newInstance();
     BeanUtils.populate(po, entity);
    }
    
   }
  } catch (Exception e) {
   log.error(e);
   throw e;
  } finally {
   try {
    if (rs != null) {
     rs.close();
    }
   } catch (Exception e) {

   }
   try {
    if (ps != null) {
     ps.close();
    }
   } catch (Exception e) {

   }
  }
  return (BaseVO) po;
 }

 /**
  * 选择记录,不分页
  * @param con
  * @param SQL
  * @param params
  * @param voclass
  * @return
  * @throws Exception
  * @author
  */
 public List select(Connection con, String SQL, List params, Class voclass)
   throws Exception {
  Object vo = null; // 承载值对象
  PreparedStatement ps = null;
  ResultSet rs = null;
  ResultSetMetaData rsm = null;
  List relist = null;
  try {
   ps = con.prepareStatement(SQL);
   if (SQL == null) {
    throw new Exception();
   }
   if (params != null && params.size() > 0) {
    int count = 0;
    for (Iterator iterator = params.iterator(); iterator.hasNext(); count++) {
     Object object = iterator.next();
     setObjectValue(ps, count + 1, object);
    }
   }
   rs = ps.executeQuery();
   rsm = rs.getMetaData();
   relist = new ArrayList();
   while (rs.next()) {
    Map entity = new HashMap();
    for (int i = 1; i <= rsm.getColumnCount(); i++) {
     String columnName = rsm.getColumnName(i).toLowerCase();
     Object columnValue = getObjectValue(rs, voclass, i, columnName);
     entity.put(columnName, columnValue);
     
    }
    if (voclass != null) {
     vo = voclass.newInstance();
     BeanUtils.populate(vo, entity);
     relist.add(vo);
    } else {
     relist.add(entity);
    }
   }
  } catch (Exception e) {
   log.error(e);
   throw e;
  } finally {
   try {
    if (rs != null) {
     rs.close();
    }
   } catch (Exception e) {

   }
   try {
    if (ps != null) {
     ps.close();
    }
   } catch (Exception e) {

   }
   
  }
  return relist;
 }

 /**
  * 分页查询
  *
  * @param con
  * @param SQL
  * @param params
  * @param voclass
  * @param pagination
  * @return
  * @throws Exception
  * @author
  */
 public List selectPagination(Connection con, String SQL, List params,
   Class voclass, Pagination pagination) throws Exception {
  if (SQL == null) {
   throw new NullPointerException("SQL不能为空!");
  }
  if (pagination == null) {
   throw new NullPointerException("分页类不能为空!");
  }

  // TODO Auto-generated method stub
  Object vo = null; // 承载值对象
  PreparedStatement ps = null;
  ResultSet rs = null;
  ResultSetMetaData rsm = null;
  List relist = null;
  try {

   ps = con.prepareStatement("select count(1) as count_ from ( " + SQL + " )");

   if (params != null && params.size() > 0) {
    int count = 0;
    for (Iterator iterator = params.iterator(); iterator.hasNext(); count++) {
     Object object = iterator.next();
     setObjectValue(ps, count + 1, object);
    }
   }

   rs = ps.executeQuery();
   if (rs.next()) {
    pagination.setTotalCount(rs.getInt(1));
    
   }
   

   if (pagination.getTotalCount() > 0) {
    /* 组成分页内容 */
    StringBuffer pagingSelect = new StringBuffer(100);
    pagingSelect
      .append("select * from ( select row_.*, rownum rownum_ from ( ");
    pagingSelect.append(SQL);
    pagingSelect
      .append(" ) row_ where rownum <= ?) where rownum_ > ?");

    ps = con.prepareStatement(pagingSelect.toString());
    int count = 0;
    if (params != null && params.size() > 0) {
     for (Iterator iterator = params.iterator(); iterator.hasNext(); count++) {
      Object object = iterator.next();
      setObjectValue(ps, count + 1, object);
     }
    }
    
    ps.setInt(count + 1, pagination.getPage()
      * pagination.getCount());
    ps.setInt(count + 2, (pagination.getPage() - 1)
      * pagination.getCount());

    log.info("pagination.getPage():" + pagination.getPage());
    log.info("pagination.getCount():" + pagination.getCount());
    rs = ps.executeQuery();
    rsm = rs.getMetaData();
    relist = new ArrayList();
    while (rs.next()) {
     Map entity = new HashMap();
     for (int i = 1; i <= rsm.getColumnCount(); i++) {
      String columnName = rsm.getColumnName(i).toLowerCase();
      Object columnValue = getObjectValue(rs, voclass, i, columnName);
      entity.put(columnName, columnValue);
     }
     if (voclass != null) {
      vo = voclass.newInstance();
      BeanUtils.populate(vo, entity);
      relist.add(vo);
     } else {
      relist.add(entity);
     }
    }
   }
  } catch (Exception e) {
   log.error(e);
   throw e;
  } finally {
   try {
    if (rs != null) {
     rs.close();
    }
   } catch (Exception e) {

   }
   try {
    if (ps != null) {
     ps.close();
    }
   } catch (Exception e) {

   }

  }
  return relist;
 }

 /**
  * 获得SequenceValue
  * @param sequenceName
  * @return
  * @throws Exception
  * @author
  */
 public Long getSequenceValue(Connection con, String sequenceName)throws Exception {
  PreparedStatement ps = null;
  ResultSet rs = null;
  Long sequenceValue = null;
  try{
   ps = con.prepareStatement("select " + sequenceName + ".nextval from dual");
   rs = ps.executeQuery();
   if(rs.next()) {
    sequenceValue = new Long(rs.getLong(1));
   }
  }catch(Exception e){
   log.error(e);
   throw e;
  }finally{
   try {
    if (rs != null) {
     rs.close();
    }
   } catch (Exception e) {

   }
   try {
    if (ps != null) {
     ps.close();
    }
   } catch (Exception e) {

   }
  }
  return sequenceValue;
 }
 /**
  * 把对象传入数据库
  * @param ps
  * @param count
  * @param object
  * @author
  */
 private final void setObjectValue(PreparedStatement ps, int count, Object object) throws Exception {
  log.debug("count is " + count + " object is " + object);
  if(object != null) {
   if(object instanceof Integer){
    ps.setInt(count, ((Integer)object).intValue());
   }else if(object instanceof Long) {
    ps.setLong(count, ((Long)object).longValue());
   }else if(object instanceof BigDecimal){
    ps.setBigDecimal(count, (BigDecimal)object);
   }else if(object instanceof String){
    ps.setString(count, (String)object);
   }else if(object instanceof java.util.Date) {
    if(object!=null){
     long time = ((java.util.Date)object).getTime();
     ps.setDate(count, new java.sql.Date(time));
    }else{
     ps.setDate(count, null);
    }
   }else{
    ps.setObject(count, object);
   }
  }else{
   ps.setNull(count, Types.INTEGER);
  }
 }

 /**
  * 把对象传入数据库
  * @param ps
  * @param clazz
  * @param count
  * @param columnName
  * @param object
  * @throws Exception
  * @author
  */
 private final void setObjectValue(PreparedStatement ps, Class clazz, int count,
   String columnName, Object object)throws Exception {
  log.debug("count is " + count + " columnName is " + columnName + " object is " + object);
  String classType = clazz.getDeclaredField(columnName).getType().getName();
  if(classType.equals("java.lang.Integer")){
   if(object != null) {
    ps.setInt(count, ((Integer)object).intValue());
   }else{
    ps.setNull(count, Types.INTEGER);
   }
  }else if(classType.equals("java.lang.Long")) {
   if(object != null ) {
    ps.setLong(count, ((Long)object).longValue());
   }else{
    ps.setNull(count, Types.INTEGER);
   }
  }else if(classType.equals("java.math.BigDecimal")){
   if(object != null) {
    ps.setBigDecimal(count, (BigDecimal)object);
   }else{
    ps.setNull(count, Types.NUMERIC);
   }
  }else if(classType.equals("java.lang.String")){
   if(object != null) {
    ps.setString(count, (String)object);
   }else{
    ps.setString(count, null);
   }
  }else if(classType.equals("java.util.Date")) {
   if(object!=null){
    long time = ((java.util.Date)object).getTime();
    ps.setDate(count, new java.sql.Date(time));
   }else{
    ps.setDate(count, null);
   }
  }else{
   ps.setObject(count, object);
  }
 }

 /**
  * 把数据从数据取出来
  * @param rs
  * @param clazz
  * @param count
  * @param columnName
  * @return
  * @throws Exception
  * @author
  */
 private final Object getObjectValue(ResultSet rs, Class clazz, int count, String columnName) throws Exception {
  Object fieldValue = null;
  log.debug("columnName is " + columnName + " count is " + count);
  if(columnName != null) {
   if("rownum".equals(columnName)) {
    fieldValue = new Long(rs.getLong(count));
   }else if("rownum_".equals(columnName)) {
    fieldValue = new Long(rs.getLong(count));
   }else if("count_".equals(columnName)) {
    fieldValue = new Long(rs.getLong(count));
   }else{
    String classType = clazz.getDeclaredField(columnName).getType().getName();

    if(classType.equals("java.lang.Integer")){
     fieldValue =new Integer( rs.getInt(count));
    }else if(classType.equals("java.lang.Long")) {
     fieldValue =new Long( rs.getLong(count));
    }else if(classType.equals("java.math.BigDecimal")){
     fieldValue = rs.getBigDecimal(count);
    }else if(classType.equals("java.lang.String")){
     fieldValue = rs.getString(count);
    }else if(classType.equals("java.util.Date")) {
     java.sql.Date date = rs.getDate(count);
     if(date!= null){
      fieldValue = new java.util.Date(date.getTime());
     }
    }else{
     fieldValue = rs.getString(count);
    }
   }
  }
  return fieldValue;
 }

}

banq http://www.jdon.com Mar 3, 2004 4:19 PM 回复

说明：这是Struts的一种高级用法，struts-el中有相关说明，这里讨论在一般struts标签库下如何实现。

场景：
有一个JavaBeans:如下：


publicclass LabelValueBean implements Serializable {
public LabelValueBean(String label, String value) {
this.label = label;
this.value = value;
}
private String label;

public String getLabel() {
returnthis.label;
}

publicvoid setLabel(String label) {
this.label = label;
}

private String value;

public String getValue() {
returnthis.value;
}

publicvoid setValue(String value) {
this.value = value;
}

public String toString() {
StringBuffer sb = new StringBuffer("LabelValueBean[");
sb.append(this.label);
sb.append(", ");
sb.append(this.value);
sb.append("]");
return (sb.toString());
}


}

时间：2003-11-28 作者：周海根 浏览次数： 3105 本文关键字：JMS, 基础, 教程, 概念

文章工具  推荐给朋友  打印文章

一. JMS简介
1. JMS基本概念
JMS(Java Message Service)是访问企业消息系统的标准API,它便于消息系
统中的Java应用程序进行消息交换,并且通过提供标准的产生、发送、接收消息的接口简化企业应用的开发。

2. JMS基本功能
JMS是用于和面向消息的中间件相互通信的应用程序接口。它既支持点对点(point-to-point)的域，又支持发布/订阅(publish/subscribe)类型的域，并且提供对下列类型的支持：经认可的消息传递,事务型消息的传递，一致性消息和具有持久性的订阅者支持。JMS还提供了另一种方式来对您的应用与旧的后台系统相集成。
3. WebLogic JMS Server介绍
WebLogic Server8.1符合JAVA规范,并通过Sun Microsystems J2EE 1.3认
证.作为WebLogic的一部分,当然WebLogic JMS Server也完全遵从JMS规范,还支持集群,并可以应用于实际企业系统.下图是WebLogic JMS Server体系结构.图中可以看到WebLogic JMS Server主要组件有: WebLogic JMS servers(用于消息通信),Java客户端,JNDI(用于域名查找), 后备存储(用于持久消息存储,基于文件或者JDBC数据库).

二. WebLogic JMS特性
1. 消息通信模型
JMS 支持两种消息通信模型：点到点（point-to-point）（PTP）模型和发布/订阅（Pub/Sub）模型。除了下列不同之外，这两种消息通信模型非常地相似：
PTP 模型规定了一个消息只能有一个接收者;Pub/Sub 模型允许一个消息可以有多个接收者。
2. 消息组成
消息传递系统的中心就是消息。
一条 Message 分为三个组成部分：
· 头（header）是个标准字段集，客户机和供应商都用它来标识和路由消息。
· 属性（property）支持把可选头字段添加到消息。如果您的应用程序需要不使用标准头字段对消息编目和分类，您就可以添加一个属性到消息以实现这个编目和分类。提供 set<Type>Property(...) 和 get<Type>Property(...) 方法以设置和获取各种 Java 类型的属性，包括 Object。JMS 定义了一个供应商选择提供的标准属性集。
· 消息的主体（body）包含要发送给接收应用程序的内容。每个消息接口特定于它所支持的内容类型。
JMS 为不同类型的内容提供了它们各自的消息类型，但是所有消息都派生自 Message 接口。
· StreamMessage：包含 Java 基本数值流，用标准流操作来顺序的填充和读取。
· MapMessage：包含一组名/值对；名称为 string 类型，而值为 Java 的基本类型。
· TextMessage：包含一个 String。
· ObjectMessage：包含一个 Serializable Java 对象；能使用 JDK 的集合类。
· BytesMessage：包含未解释字节流: 编码主体以匹配现存的消息格式。
· XMLMessage: 包含XML内容。扩展TextMessage,XMLMessage 类型的使用，使得消息过滤非常便利。
3. 消息确认模式
非事务性会话中，应用程序创建的会话有5 种确认模式,而在事务性会话中，确认模式被忽略。
五种确认模式说明:
· AUTO_ACKNOWLEDGE：自动确认模式。一旦接收方应用程序的方法调用从处理消息处返回，会话对象就会确认消息的接收。
· CLIENT_ACKNOWLEDGE：客户端确认模式。会话对象依赖于应用程序对被接收的消息调用一个acknowledge()方法。一旦这个方法被调用，会话会确认最后一次确认之后所有接收到的消息。这种模式允许应用程序以一个调用来接收，处理并确认一批消息。注意：在管理控制台中，如果连接工厂的Acknowledge Policy（确认方针）属性被设置为"Previous"（提前），但是你希望为一个给定的会话确认所有接收到的消息，那么就用最后一条消息来调用acknowledge()方法。
· DUPS_OK_ACKNOWLEDGE：允许副本的确认模式。一旦接收方应用程序的方法调用从处理消息处返回，会话对象就会确认消息的接收；而且允许重复确认。在需要考虑资源使用时，这种模式非常有效。注意：如果你的应用程序无法处理重复的消息的话，你应该避免使用这种模式。如果发送消息的初始化尝试失败，那么重复的消息可以被重新发送。
· NO_ACKNOWLEDGE：不确认模式。不确认收到的消息是需要的。消息发送给一个NO_ACKNOWLEDGE 会话后，它们会被WebLogic 服务器立即删除。在这种模式下，将无法重新获得已接收的消息，而且可能导致下面的结果：1. 消息可能丢失；和（或者）另一种情况：2. 如果发送消息的初始化尝试失败，会出现重复消息被发送的情况。
· MULTICAST_NO_ACKNOWLEDGE：IP组播下的不确认模式，同样无需确认。发送给一个MULTICAST_NO_ACKNOWLEDGE会话的消息， 会共享之前所述的NO_ACKNOWLEDGE 确认模式一样的特征。这种模式支持希望通过IP 组播方式进行消息通信的应用程序，而且无需依赖会话确认提供的服务质量。注意：如果你的应用程序无法处理消息的丢失或者重复，那么你应该避免使用这种模式。如果发送消息的初始化尝试失败的话，重复的消息可能会被再次发送。
注：在上表的5 种确认模式中，AUTO_ACKNOWLEDGE ，DUPS_OK_ACKNOWLEDGE 和
CLIENT_ACKNOWLEDGE 是JMS 规范定义的，NO_ACKNOWLEDGE 和MULTICAST_NO_ACKNOWLEDGE是WebLogic JMS 提供的。
三. 配置JMS
1. 创建连接工厂
(1) 启动WebLogic Server8.1,登录控制台,选中JMS Connection Factories节点,点击右边的" Configure a new JMS Connection Factory...";

(2) 填写连接工厂的名称SendJMSFactory和JNDI名称SendJMSFactory,点击"Create";

(3) 勾上"myserver",将SendJMSFactory应用到myserver;

2. 定义后备存储
(1) 选中JMS Stores节点,点击右边的" Configure a new JMS Connection Factory...";

(2) 填写文件后备存储的名称SendFileStore和目录Directionary E:\BEA\user_projects\domains\mydomain\sendfilestore,点击"Create".

3. 创建JMS服务器
(1) 选中JMS Servers节点,点击右边的" Configure a new JMSServer...";

(2) 填写JMS服务器的名称SendJMSServer和Paging Store设为" SendFileStore",点击"Create";

(3) Target选中"myserver",将SendJMSServer应用到myserver.

4. 创建消息队列
(1) 展开"SendJMSServer"节点,点击" Configure a new JMS Queue...";

(2) 填写消息队列的名称SendJMSQueue和JNDI名称SendJMSQueue,点击"Create";

四. JMS应用程序
一个 JMS 应用程序由下列元素组成：
· JMS 客户机。 用 JMS API 发送和接收消息的 Java 程序。
· 非 JMS（Non-JMS）客户机。 认识到这一点很重要 - 旧的程序经常成为整个 JMS 应用程序的一部分，而且它们的包含应该在设计时预先考虑。
· 消息。 在 JMS 和非 JMS 客户机之间交换的消息的格式和内容是 JMS 应用程序设计所必须考虑的部分。
· JMS 供应商。供应商必须提供特定于其 MOM 产品的具体的实现。
· 受管对象。 消息传递系统供应商的管理员创建了一个对象，它独立于供应商专有的技术。包括连接工厂ConnectionFactory和目的Destination。
一种典型的 JMS 程序需要经过下列步骤才能开始消息产生和使用:
· 通过 JNDI 查找 ConnectionFactory。
· 通过 JNDI 查找一个或多个 Destination。
· 用 ConnectionFactory 创建一个 Connection。
· 用 Connection 创建一个或多个 Session。
· 用 Session 和 Destination 创建所需的 MessageProducer 和 MessageConsumer。
· 启动 Connection。
下面利用上面配置的JMS资源演示点对点消息发送和接收的过程。
五. 设计消息发送端
1. 使用的JMS资源
服务器URL: t3://localhost:80
连接工厂: SendJMSFactory
队列: SendJMSQueue
2. 设计步骤
· 初始化JNDI Tree
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, PROVIDER_URL);
return new InitialContext(env);
· lookup ConnectionFactory
qconFactory = (QueueConnectionFactory) ctx.lookup(JMS_FACTORY);
· lookup Destination
queue = (Queue) ctx.lookup(queueName);
· 用 ConnectionFactory 创建Connection
qcon = qconFactory.createQueueConnection();
· 用 Connection 创建一个Session
qsession = qcon.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
· 用 Session 和 Destination 创建MessageProducer
qsender = qsession.createSender(queue);
· 启动 Connection。
qcon.start();
· 发送消息
msg = qsession.createTextMessage();
msg.setText(message);
qsender.send(msg);
3. 源代码
package jmssample;

import java.util.Hashtable;
import javax.jms.*;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/** This example shows how to establish a connection
* and send messages to the JMS queue. The classes in this
* package operate on the same JMS queue. Run the classes together to
* witness messages being sent and received, and to browse the queue
* for messages. The class is used to send messages to the queue.
*
* @author Copyright (c) 1999-2003 by BEA Systems, Inc. All Rights Reserved.
*/
public class QueueSend
{
// Defines the JNDI context factory.
public final static String JNDI_FACTORY="weblogic.jndi.WLInitialContextFactory";

// Defines the JNDI provider url.
public final static String PROVIDER_URL=" t3://localhost:80";

// Defines the JMS connection factory for the queue.
public final static String JMS_FACTORY="SendJMSFactory";

// Defines the queue.
public final static String QUEUE="SendJMSQueue";

private QueueConnectionFactory qconFactory;
private QueueConnection qcon;
private QueueSession qsession;
private QueueSender qsender;
private Queue queue;
private TextMessage msg;

/**
* Creates all the necessary objects for sending
* messages to a JMS queue.
*
* @param ctx JNDI initial context
* @param queueName name of queue
* @exception NamingException if operation cannot be performed
* @exception JMSException if JMS fails to initialize due to internal error
*/
public void init(Context ctx, String queueName)
throws NamingException, JMSException
{
qconFactory = (QueueConnectionFactory) ctx.lookup(JMS_FACTORY);
qcon = qconFactory.createQueueConnection();
qsession = qcon.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
queue = (Queue) ctx.lookup(queueName);
qsender = qsession.createSender(queue);
msg = qsession.createTextMessage();
qcon.start();
}

/**
* Sends a message to a JMS queue.
*
* @param message message to be sent
* @exception JMSException if JMS fails to send message due to internal error
*/
public void send(String message) throws JMSException {
msg.setText(message);
qsender.send(msg);
}

/**
* Closes JMS objects.
* @exception JMSException if JMS fails to close objects due to internal error
*/
public void close() throws JMSException {
qsender.close();
qsession.close();
qcon.close();
}
/** main() method.
*
* @param args WebLogic Server URL
* @exception Exception if operation fails
*/
public static void main(String[] args) throws Exception {
InitialContext ic = getInitialContext();
QueueSend qs = new QueueSend();
qs.init(ic, QUEUE);
readAndSend(qs);
qs.close();
}

private static void readAndSend(QueueSend qs)
throws IOException, JMSException
{
BufferedReader msgStream = new BufferedReader(new InputStreamReader(System.in));
String line=null;
boolean quitNow = false;
do {
System.out.print("Enter message (\"quit\" to quit): ");
line = msgStream.readLine();
if (line != null && line.trim().length() != 0) {
qs.send(line);
System.out.println("JMS Message Sent: "+line+"\n");
quitNow = line.equalsIgnoreCase("quit");
}
} while (! quitNow);

}

private static InitialContext getInitialContext()
throws NamingException
{
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, PROVIDER_URL);
return new InitialContext(env);
}

}

六. 设计消息接收端
1. 使用的JMS资源
服务器URL: t3://localhost:80
连接工厂: SendJMSFactory
队列: SendJMSQueue
2. 设计步骤
· 初始化JNDI Tree
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, PROVIDER_URL);
return new InitialContext(env);
· lookup ConnectionFactory
qconFactory = (QueueConnectionFactory) ctx.lookup(JMS_FACTORY);
· lookup Destination
queue = (Queue) ctx.lookup(queueName);
· 用 ConnectionFactory 创建Connection
qcon = qconFactory.createQueueConnection();
· 用 Connection 创建一个Session
qsession = qcon.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
· 用 Session 和 Destination 创建MessageConsumer
qreceiver = qsession.createReceiver(queue);
· 设置监听
qreceiver.setMessageListener(this);
· 启动 Connection
qcon.start();
3. 源代码
package jmssample;

import java.util.Hashtable;
import javax.jms.*;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.util.Hashtable;
import javax.jms.*;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

/**
* This example shows how to establish a connection to
* and receive messages from a JMS queue. The classes in this
* package operate on the same JMS queue. Run the classes together to
* witness messages being sent and received, and to browse the queue
* for messages. This class is used to receive and remove messages
* from the queue.
*
* @author Copyright (c) 1999-2003 by BEA Systems, Inc. All Rights Reserved.
*/
public class QueueReceive implements MessageListener
{
// Defines the JNDI context factory.
public final static String JNDI_FACTORY="weblogic.jndi.WLInitialContextFactory";

// Defines the JNDI provider url.
public final static String PROVIDER_URL=" t3://localhost:80";

// Defines the JMS connection factory for the queue.
public final static String JMS_FACTORY="SendJMSFactory";

// Defines the queue.
public final static String QUEUE="SendJMSQueue";

private QueueConnectionFactory qconFactory;
private QueueConnection qcon;
private QueueSession qsession;
private QueueReceiver qreceiver;
private Queue queue;
private boolean quit = false;

/**
* Message listener interface.
* @param msg message
*/
public void onMessage(Message msg)
{
try {
String msgText;
if (msg instanceof TextMessage) {
msgText = ((TextMessage)msg).getText();
} else {
msgText = msg.toString();
}

System.out.println("Message Received: "+ msgText );

if (msgText.equalsIgnoreCase("quit")) {
synchronized(this) {
quit = true;
this.notifyAll(); // Notify main thread to quit
}
}
} catch (JMSException jmse) {
jmse.printStackTrace();
}
}

/**
* Creates all the necessary objects for receiving
* messages from a JMS queue.
*
* @param ctx JNDI initial context
* @param queueName name of queue
* @exception NamingException if operation cannot be performed
* @exception JMSException if JMS fails to initialize due to internal error
*/
public void init(Context ctx, String queueName)
throws NamingException, JMSException
{
qconFactory = (QueueConnectionFactory) ctx.lookup(JMS_FACTORY);
qcon = qconFactory.createQueueConnection();
qsession = qcon.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
queue = (Queue) ctx.lookup(queueName);
qreceiver = qsession.createReceiver(queue);
qreceiver.setMessageListener(this);
qcon.start();
}

/**
* Closes JMS objects.
* @exception JMSException if JMS fails to close objects due to internal error
*/
public void close()throws JMSException
{
qreceiver.close();
qsession.close();
qcon.close();
}
/**
* main() method.
*
* @param args WebLogic Server URL
* @exception Exception if execution fails
*/

public static void main(String[] args) throws Exception {

InitialContext ic = getInitialContext();
QueueReceive qr = new QueueReceive();
qr.init(ic, QUEUE);

System.out.println("JMS Ready To Receive Messages (To quit, send a \"quit\" message).");

// Wait until a "quit" message has been received.
synchronized(qr) {
while (! qr.quit) {
try {
qr.wait();
} catch (InterruptedException ie) {}
}
}
qr.close();
}

private static InitialContext getInitialContext()
throws NamingException
{
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, PROVIDER_URL);
return new InitialContext(env);
}

}
七. 测试消息发送和接收
1. 设置WebLogic Classpath;

5. 输入发送消息"quit",接收程序结束.


总结
本文先简要介绍了JMS的一些基本概念,继而引入了WebLogic JMS Server的体系结构和相关特性。在此基础之上,图文并茂地讲述了JMS在WebLogic Server 8.1上的配置。最后在解剖JMS应用程序框架的同时,以点对点为例演示了JMS的发送接收消息流程。