一、从1.X升级到2.X需要做以下事情：
1、改变你的taglib声明中的URI。
 <% at taglib uri="http://struts-menu.sf.net/tag" prefix="menu" %>
2、改变<plug-in>,使用新的包名"net.sf.navigator." 。
 <plug-in className="net.sf.navigator.menu.MenuPlugIn">
3、改变你的menu-config.xml文件，使用新的包名"net.sf.navigator." 。
 <Displayer name="Simple"
   type="net.sf.navigator.displayer.SimpleMenuDisplayer"/>

二、快速开始：
1、下载最新的struts-menu版本；
2、解包到本地目录；
3、下载Tomcat或者其它Servlet容器；
4、把struts-menu.war包放入Tomcat安装目录的wabapps目录下，并重启Tomcat服务。
5、打开htpp://localhost:8080/struts-menu/

三、把Struts Menu整合到你的应用程序中：
Struts Menu能够被轻易的整合到你的Struts应用程序中，它也可以整合到一个非Struts的应用程序中，但是我不喜欢这样做，所以在此没有提供相应的教程。这里将一步步的带你整合这个标签库。
你需要把struts-menu.jar放到你的WEB-INF/lib目录下。然后使用URI标签声明你的JSP文件中想使用的这个标签库。
如果使用Struts Menu 2.1，你还需要 Jakarta's Standard Tag Library JAR包放入你的WEB-INF/lib目录下。下载地址：http://ibiblio.org/maven/taglibs/jars/standard-1.0.4.jar，这个文件包括例程WAR包文件和二进制发布包。
1、放入struts-menu.jar包到你的应用程序的WEB-INF/lib目录中。
2、在你的struts-config.xml文件中加入plug-in设置。
 <plug-in className="net.sf.navigator.menu.MenuPlugIn">
   <set-property property="menuConfig"
     value="/WEB-INF/menu-config.xml"/>
 </plug-in>
3、你将需要在你的应用程序的/WEB-INF/menu-config.xml文件中定义你的菜单，这里提供一个简单的片断：
 <Menu name="contactMenu" title="Contact" location="?Contact">
   <Item name="email" title="E-Mail" location="?EMail"/>
   <Item name="phone" title="Phone" location="?Phone"/>
 </Menu>
　　更多全面的例程，请查看应用程序的web/WEB-INF目录中的menu-config.xml文件，你可以截取一段作为你需要的菜单。完整的属性列表，可以查看MenuBase class's javadocs（http://struts-menu.source......avigator/menu/MenuBase.html）。
4、在你的JSP文件的顶部加入taglib声明：
 <% at taglib uri="http://struts-menu.sf.net/tag" prefix="menu" %>
5、在你的JSP文件中要放置菜单的位置加入taglib代码：
 <menu:useMenuDisplayer name="TabbedMenu"
   bundle="org.apache.struts.action.MESSAGE">
   <menu:displayMenu name="Home"/>
   <menu:displayMenu name="About"/>
 </menu:useMenuDisplayer>
　　属性name="TabbedMenu"被定义在menu-config.xml文件的顶部：
 <Displayer name="TabbedMenu"
   type="net.sf.navigator.displayer.TabbedMenuDisplayer"/>

(译注：其实到此步即可在你的JSP文件中添加相应的菜单了，只不过是没有结合Velocity。在menu-config.xml文件的头部可以定义多个Displayer，每个Displayer都有name和type属性，name属性与JSP文件中menu:useMenuDisplayer标签的name属性相对应，即表明使用何种样式，具体的样式定义便在type属性中定义，type属性中是一个class。在menu-config.xml文件中的菜单定义中的name属性则与JSP文件中的menu:displayMenu标签的name属性相对应。)

使用定制的Velocity模版实施你的菜单，你需要整合Velocity到你的WEB应用程序中。如果需要这样做的话，请完成下面的步骤：
1、确定你的menu-config.xml文件有“Velocity”的displayer定义：
 <Displayer name="Velocity"
     type="net.sf.navigator.displayer.VelocityMenuDisplayer"/>
2、加入Velocity的JARs包到你的WEB-INF/lib目录中，下载velocity-1.4-rc1.jar（http://www.ibiblio.org/ma......y/jars/velocity-1.4-rc1.jar）和velocity-tools-view-1.0.jar（http://www.ibiblio.org/ma......velocity-tools-view-1.0.jar）。
3、加入globalMacros.vm（http://cvs.sourceforge.net/viewcvs.py/*checkout*/struts-menu/navigator/web/WEB-INF/classes/globalMacros.vm?content-type=text%2Fplain&rev=1.1（右键另存为））到你的WEB-INF/lib目录中。
4、改变你的JSP文件中displayer的值为“Velocity”，“config”属性指向一个文件（如config="/templates/tabs.html"）或者如果tabs.htm在你的WEB-INF/classes目录中的话，则可设config="tabs.html"。

这里提供了一些使用Velocity的displayer例子，可在sample application（http://demo.raibledesigns.com/struts-menu/index.jsp）中查看。它总是在你的菜单需要的时候显示CSS，JavaScript和图像文件。下面有一些在当前的Struts Menu中用到的Velocity模版的例子的链接：
 CoolMenus: Demo（http://demo.raibledesigns......menu/velocity-coolmenu4.jsp）,
  　 Template（http://struts-menu.sourceforge.net/templates/coolmenus.html）
 NiceTabs: Demo, Template
 Tabs: Demo, Template
 XTree: Demo, Template

所有相关的有用的文件如果你需要的话都可以在下面的站点上下载：
 Images （http://struts-menu.sourceforge.net/menu-images/）
 Stylesheets （http://struts-menu.sourceforge.net/styles/）
 Scripts （http://struts-menu.sourceforge.net/scripts/）
 Templates （http://struts-menu.sourceforge.net/templates/）

更多的基于roles的显示/隐藏菜单的信息，请查看FAQs（http://struts-menu.sourceforge.net/faq.html）。

四、在Struts之外使用Struts Menu:
在2.2版中，Menu Repository能够使用MenuContextListener载入：
 <!--
    - Loads the menu-config.xml for struts-menu at startup,
    - by default from "/WEB-INF/menu-config.xml".
    - To override this, add a context-param named "menuConfigLocation"
    - web.xml file.
    -->
 <listener>
     <listener-class>net.sf.navigator.menu.MenuContextListener</listener-class>
 </listener>

或者如果你使用Spring，甚至更容易。仅仅需要加入下面的部分到你的applicationContext.xml文件中：
 <bean id="menu" class="net.sf.navigator.menu.MenuLoader">
   <property name="menuConfig">
     <value>/WEB-INF/menu-config.xml</value>
   </property>
 </bean>
 <!-- The menuConfig property is an optional attribute.  It is set to
     /WEB-INF/menu-config.xml by default. -->
感谢Dan Luputan提供MenuLoader类的源代码。

五、从源文件编译：
要从源文件编译这个项目，执行下面的步骤：
1、下载并安装Maven（http://maven.apache.org/）；
2、创建一个环境变量MAVEN＿HOME指出你的Maven的安装目录，然后添加$MAVEN_HOME/bin到你的PATH变量中；
3、操纵这个目录你可以扩展源代码，执行“maven.jar”创建target/struts-menu.jar。

要展开struts-menu例程，需要下面的步骤：
1、下载和安装Tomcat；
2、创建一个环境变量CATALINA＿HOME指出你的Tomcat的安装目录；
3、执行“maven deploy”把应用程序展开到Tomcat中；
4、打开http://localhost:8080/struts-menu在你喜爱的浏览器中。

如果你喜欢使用Eclipse开发项目，请参考此份开发向导（http://struts-menu.sourceforge.net/devguide.html）。

 Struts 2为大家提供了不少常用的很酷的表单标志，简化了我们程序员的工作。不过，由于这些都是新标志，大家可能在使用上还存在不少疑问。本文将就朋友们的回复、留言或Email上的问题，分别对这些酷标志进行讲述。

表单标志使用小技巧

Struts 2的表单标志在输出（render）HTML时，使用了模板的概念，增加了复杂性（因为它不像Struts 1.x的表单标志，它通常都是一个标志对应HTML的一个元素），因此大家在使用时，需要一些技巧：

1. Struts 2的UI标志的表单标志默认是以表格布局，按钮是右对齐的。如果你不喜欢此风格，你可以简单地将<s:form />标志的“theme”属性设为“simple”，然后用以往的做法自已布局表单元素（注意：此法有利有弊，弊就是当你将“theme”属性设为“simple”时，表单标志以最简单方式输出HTML，所以你可能失去一些默认输出提供的便利，如：友好的错误信息的显示，或客户端的表单验证等）。当然更好的做法是通过CSS或自定义主题（theme）然后应用到整个应用程序，这样可以获得一致的页面风格，加强用户体验（我会在以后的文章对此进行讲解）；
2. 当你在页面上加入某些标志（如：<s:doubleselect />等）时，应该通过action来访问页面，而不是通过*.jsp的URL直接访问。

下面我将分别对这些标志进行讲述：

1、<s:checkboxlist />

大家对<s:checkboxlist />的最大的疑问可能是：“如何在默认情况下，选中某些checkbox？”

答案其实很简单，只需要将其“value”属性设为你的要选中的值，如以代码所示：

分布运行应用程序，在浏览器中键入：http://localhost:8080/Struts2_CoolTags/checkboxlist.jsp，出现如下图所示页面：

清单2 checkboxlist.jsp页面

2、<s:doubleselect />

大家看Struts 2的showcase的例子，<s:doubleselect />的用法如下所示：

很多朋友问：“上面的‘list’属性只有两个值，如果我有三个或更多的值，‘doublelist’属性应该如何设定呢？”

我建议的做法是先定义一个Map类型的对象，键为“list”的集合，值则为“doubleList”的集合，然后“doubleList”的OGNL写成“#myMap[top]”，如以下代码所示：

分布运行应用程序，在浏览器中键入：http://localhost:8080/Struts2_CoolTags/doubleselect.action，出现如下图所示页面：

清单5 doubleselect.jsp页面

3、<s: token />

这个标志可能大家不常用，不过本人认为它还是挺有用的。在使用Struts 1.x时，因为跳转通常是用Forward（而不是Redirect）实现的，所以当用户完成请求后，按“F5”刷新页面时，就会重新提交上次的请求，这样经常会出错。要解决这个问题，<s:token />可以帮你忙。

实现原理

在页面加载时，<s: token />产生一个GUID（Globally Unique Identifier，全局唯一标识符）值的隐藏输入框如：

同时，将GUID放到会话（session）中；在执行action之前，“token”拦截器将会话token与请求token比较，如果两者相同，则将会话中的token删除并往下执行，否则向actionErrors加入错误信息。如此一来，如果用户通过某种手段提交了两次相同的请求，两个token就会不同。

具体实现

首先看一下Action的代码：

package tutorial;

import com.opensymphony.xwork2.ActionSupport;

public class CoolTagAction extends ActionSupport {    
   private static final long serialVersionUID = 6820659617470261780L;
   
   private String message;
       
   public String getMessage() {
       return message;
   }

   public void setMessage(String message) {
       this.message = message;
   }
   
   @Override
   public String execute() {
       System.out.println("Executing action, your message is " + message);
       return SUCCESS;
   }    
}

以上代码一目了然，再看看JSP的写法：

JSP也很简单，就是加入<s:token />标志。接下来是Actoin配置的XML片段：

以上XML片段值注意的是加入了“token”拦截器和“invalid.token”结果，因为“token”拦截器在会话token与请求token不一致时，将会直接返回“invalid.token”结果。

发布运行应用程序，在浏览器中键入：http://localhost:8080/Struts2_CoolTags/token.jsp，出现如下图所示页面：

清单10 正常显示的token.jsp页面

随便填点东西并提交页面，一切正常返回以上页面，然后按“F5”刷新页面，在弹出的对话框中点击“Retry”，出现如下图所示页面：

清单11 重复提交出错显示

4、<s:datetimepicker />、<s:optiontransferselect />和<s:updownselect />

这几个标志的使用相对简单，所以我想小举一例即可，以下是JSP的代码：

发布运行应用程序，在浏览器中键入：http://localhost:8080/Struts2_CoolTags/others.jsp，出现如下图所示页面：

清单13 其它表单标志页面

总结

Struts 2在标志上的确比Struts 1.x丰富了许多，同时模板机制也给程序员带来不少方便（如果你不太喜欢个性化的风格）。另外，Struts 2还有一些AJAX（如<s: autocompleter />等）的标志和非表单的UI标志（如<s: tree />等），我会在以后的文章中讲述其使用。

Struts2提供了对不同种类返回结果的支持，常见的有JSP，FreeMarker，Velocity等。

Struts2支持的不同类型的返回结果为：

名字	说明
Chain Result	用来处理Action链
Dispatcher Result	用来转向页面，通常处理JSP
FreeMarker Result	处理FreeMarker模板
HttpHeader Result	用来控制特殊的Http行为
Redirect Result	重定向到一个URL
Redirect Action Result	重定向到一个Action
Stream Result	向浏览器发送InputSream对象，通常用来处理文件下载
Velocity Result	处理Velocity模板
XLS Result	处理XML/XLST模板
PlainText Result	显示原始文件内容，例如文件源代码
S2PLUGINS:Tiles Result	结合Tile使用

另外第三方的Result类型还包括JasperReports Plugin，专门用来处理JasperReport类型的报表输出。

在struts-default.xml文件中已经有了对于所有类型Result的定义：

<result-types>

    <result-type name="chain"

             class="com.opensymphony.xwork2.ActionChainResult"/>

    <result-type name="dispatcher"

             class="org.apache.struts2.dispatcher.ServletDispatcherResult"

             default="true"/>

    <result-type name="freemarker"

             class="org.apache.struts2.views.freemarker.FreemarkerResult"/>

    <result-type name="httpheader"

             class="org.apache.struts2.dispatcher.HttpHeaderResult"/>

    <result-type name="redirect"

             class="org.apache.struts2.dispatcher.ServletRedirectResult"/>

    <result-type name="redirectAction"

             class="org.apache.struts2.dispatcher.ServletActionRedirectResult"/>

    <result-type name="stream"

             class="org.apache.struts2.dispatcher.StreamResult"/>

    <result-type name="velocity"

             class="org.apache.struts2.dispatcher.VelocityResult"/>

    <result-type name="xslt"

             class="org.apache.struts2.views.xslt.XSLTResult"/>

    <result-type name="plainText"

             class="org.apache.struts2.dispatcher.PlainTextResult" />

    <!-- Deprecated name form scheduled for removal in Struts 2.1.0.

         The camelCase versions are preferred. See ww-1707 -->

    <result-type name="redirect-action"

             class="org.apache.struts2.dispatcher.ServletActionRedirectResult"/>

    <result-type name="plaintext"

             class="org.apache.struts2.dispatcher.PlainTextResult" />

</result-types>

从上述代码中可以看出在不指定Result类型的时候使用dispatcher类型。

定义一个Result值，

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

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

</result>

由于type默认值是dispatcher，所以这里不需要定义，另外name的默认值为success所以这里也不需要定义。

上述代码可以简写为：

<result>

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

</result>

另外location参数也可以直接卸载result标签内部，所以上述代码的最简单的写法为：

<result>/ThankYou.jsp</result>

我们也可以定义多个不同的Result

<action name="Hello">

 <result>/hello/Result.jsp</result>

 <result name="error">/hello/Error.jsp</result>

 <result name="input">/hello/Input.jsp</result>

</action>

上述代码的含义为，名字为Hello的Action有三个返回结果，并且都是dispatcher类型（默认类型），这三个返回值的名字分别为success（默认值），error，input，对应的页面的路径分别为/hello/Result.jsp，/hello/Error.jsp，/hello/Input.jsp。

有些时候我们需要一个定义在全局的Result，这个时候我们可以在package内部定义全局的Result，例如：

<global-results>

 <result name="error">/Error.jsp</result>

 <result name="invalid.token">/Error.jsp</result>

 <result name="login" type="redirect-action">Logon!input</result>

</global-results>

动态返回结果

有些时候，只有当Action执行完璧的时候我们才知道要返回哪个结果，这个时候我们可以在Action内部定义一个属性，这个属性用来存储Action执行完璧之后的Result值，例如：

private String nextAction; 

public String getNextAction() {

    return nextAction;

}

在strutx.xml配置文件中，我们可以使用${nextAction}来引用到Action中的属性，通过${nextAction}表示的内容来动态的返回结果，例如：

<action name="fragment" class="FragmentAction">

 <result name="next" type="redirect-action">${nextAction}</result>

</action>

上述Action的execute方法返回next的时候，还需要根据nextAction的属性来判断具体定位到哪个Action。

在strutx.xml配置文件中，我们可以使用method=""来设置调用类的哪个方法，这样就可以在一个JAVA类中使用不同的方法来实现不同的功能,就无需每个功能写一类了,例如：

<action name="fragment" class="FragmentAction" method="add">

      <result>/success.jsp</result>

</action>

表达式语言主要有以下几大好处：

避免(MyType) request.getAttribute()和myBean.getMyProperty()之类的语句，使页面更简洁；
支持运算符（如+-*/），比普通的标志具有更高的自由度和更强的功能；
简单明了地表达代码逻辑，使用代码更可读与便于维护。
Struts 2中的表达式语言
Struts 2支持以下几种表达式语言：

OGNL（Object-Graph Navigation Language），可以方便地操作对象属性的开源表达式语言；
JSTL（JSP Standard Tag Library），JSP 2.0集成的标准的表达式语言；
Groovy，基于Java平台的动态语言，它具有时下比较流行的动态语言（如Python、Ruby和Smarttalk等）的一些起特性；
Velocity，严格来说不是表达式语言，它是一种基于Java的模板匹配引擎，具说其性能要比JSP好。
Struts 2默认的表达式语言是OGNL，原因是它相对其它表达式语言具有下面几大优势：

支持对象方法调用，如xxx.doSomeSpecial()；
支持类静态的方法调用和值访问，表达式的格式为@[类全名（包括包路径）]@[方法名 |   值名]，例如：@java.lang.String@format('foo %s', 'bar')或@tutorial.MyConstant@APP_NAME；
支持赋值操作和表达式串联，如price=100, discount=0.8, calculatePrice()，这个表达式会返回80；
访问OGNL上下文（OGNL context）和ActionContext；
操作集合对象。
OGNL的用法
OGNL是通常要结合Struts 2的标志一起使用，如<s:property value="xx" />等。大家经常遇到的问题是#、%和$这三个符号的使用。下面我想通过例子讲述这个问题：

首先新建名为Struts2_OGNL的Web工程，配置开发环境。之前很多朋友在使用Struts 2的过程中都遇到乱码问题。当然乱码问题由来已久，而且涉及多方面的知识，所以并非三言两语可以说明白，而且互联网上也已经有很多这方便的文章，大家可以Google一下。不过，如果你在开发的过程，多注意一下，避免乱码问题也不难。乱码多数是由于编码与解码所使用的方式不同造成的，所以我建议大家将编码方式都设为“utf-8”，如<%@   page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8" %>。另外，在配置web.xml时使用ActionContextCleanUp过滤器（Filter），如下面代码所示：

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_9" version="2.4"
     xmlns="http://java.sun.com/xml/ns/j2ee"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

     <display-name>Struts 2 OGNL</display-name>
    
     <filter>
         <filter-name>struts-cleanup</filter-name>
         <filter-class>
             org.apache.struts2.dispatcher.ActionContextCleanUp
         </filter-class>
     </filter>
    
     <filter-mapping>
         <filter-name>struts-cleanup</filter-name>
         <url-pattern>/*</url-pattern>
     </filter-mapping>
    
     <filter>
         <filter-name>struts2</filter-name>
         <filter-class>
             org.apache.struts2.dispatcher.FilterDispatcher
         </filter-class>
     </filter>

     <filter-mapping>
         <filter-name>struts2</filter-name>
         <url-pattern>/*</url-pattern>
     </filter-mapping>

     <welcome-file-list>
         <welcome-file>index.html</welcome-file>
     </welcome-file-list>

</web-app>清单1 WebContent/WEB-INF/web.xml
“#”主要有三种用途：

访问OGNL上下文和Action上下文，#相当于ActionContext.getContext()；下表有几个ActionContext中有用的属性：   名称 作用 例子
parameters 包含当前HTTP请求参数的Map #parameters.id[0]作用相当于request.getParameter("id")
request 包含当前HttpServletRequest的属性（attribute)的Map #request.userName相当于request.getAttribute("userName")
session 包含当前HttpSession的属性（attribute）的Map #session.userName相当于session.getAttribute("userName")
application 包含当前应用的ServletContext的属性（attribute）的Map #application.userName相当于application.getAttribute("userName")
attr 用于按request > session > application顺序访问其属性（attribute） #attr.userName相当于按顺序在以上三个范围（scope）内读取userName属性，直到找到为止

用于过滤和投影（projecting)集合，如books.{?#this.price<100}；
构造Map，如#{'foo1':'bar1', 'foo2':'bar2'}。
下面让我们它们的具体写法，首先是Action类代码：

package tutorial.action;

import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;

import org.apache.struts2.interceptor.ServletRequestAware;
import org.apache.struts2.interceptor.SessionAware;
import org.apache.struts2.util.ServletContextAware;

import tutorial.model.Book;

import com.opensymphony.xwork2.ActionSupport;

public class OgnlAction extends ActionSupport implements ServletRequestAware, SessionAware, ServletContextAware   {
     private static final long serialVersionUID = 1L;
    
     private HttpServletRequest request;
     private Map<String, String> session;
     private ServletContext application;
     private List<Book> books;
            
     public void setServletRequest(HttpServletRequest request) {
         this.request = request;    
     }

     @SuppressWarnings("unchecked")
     public void setSession(Map session) {
         this.session = session;        
     }

     public void setServletContext(ServletContext application) {
         this.application = application;
     }
    
     public List<Book> getBooks() {
         return books;
     }

     @Override
     public String execute() {
         request.setAttribute("userName", "Max From request");
         session.put("userName", "Max From session");
         application.setAttribute("userName", "Max From application");
        
         books = new LinkedList<Book>();
         books.add(new Book("978-0735619678", "Code Complete, Second Edition", 32.99));
         books.add(new Book("978-0596007867", "The Art of Project Management", 35.96));
         books.add(new Book("978-0201633610", "Design Patterns: Elements of Reusable Object-Oriented Software", 43.19));
         books.add(new Book("978-0596527341", "Information Architecture for the World Wide Web: Designing Large-Scale Web Sites", 25.19));
         books.add(new Book("978-0735605350", "Software Estimation: Demystifying the Black Art", 25.19));
        
         return SUCCESS;
     }
}清单2 src/tutorial/action/OgnlAction.java

以上代码分别在request、session和application的范围内添加“userName”属性，然后再在JSP页面使用OGNL将其取回。我还创建了Book对象的列表用于演示“用于过滤和投影（projecting)集合”的功能，至于Book的代码大家可以在我前一文章《在Struts 2中实现CRUD》看到。

下面是Ognl.jsp的代码，内容如下：

<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
     <title>Struts OGNL Demo</title>
</head>
<body>    
     <h3>访问OGNL上下文和Action上下文</h3>
     <p>parameters: <s:property value="#parameters.userName" /></p>
     <p>request.userName: <s:property value="#request.userName" /></p>
     <p>session.userName: <s:property value="#session.userName" /></p>
     <p>application.userName: <s:property value="#application.userName" /></p>
     <p>attr.userName: <s:property value="#attr.userName" /></p>
     <hr />
     <h3>用于过滤和投影（projecting)集合</h3>
     <p>Books more than $35</p>
     <ul>
         <s:iterator value="books.{?#this.price > 35}">
             <li><s:property value="title" /> - $<s:property value="price" /></li>
         </s:iterator>
     </ul>
     <p>The price of "Code Complete, Second Edition" is: <s:property value="books.{?#this.title=='Code Complete, Second Edition'}.{price}[0]"/></p>
     <hr />
     <h3>构造Map</h3>
     <s:set name="foobar" value="#{'foo1':'bar1', 'foo2':'bar2'}" />
     <p>The value of key "foo1" is <s:property value="#foobar['foo1']" /></p>
</body>
</html>清单3 WebContent/Ognl.jsp
以上代码值得注意的是“<s:property value="books.{?#this.title=='Code Complete, Second Edition'}.{price}[0]"/>”，因为“books.{?#this.title=='Code Complete, Second Edition'}.{price}”返回的值是集合类型，所以要用“[索引]”来访问其值。

最后是Struts 2的配置文件struts.xml，内容如下：

<?xml version="1.0" encoding="UTF-8"?>

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

<struts>
     <constant name="struts.devMode" value="true" />
     <package name="Struts2_OGNL_DEMO" extends="struts-default">
         <action name="Ognl" class="tutorial.action.OgnlAction">
             <result>/Ognl.jsp</result>
         </action>        
     </package>
</struts>清单4 src/struts.xml

发布运行应用程序，结果如下所示：

清单5 示例运行结果1

“%”符号的用途是在标志的属性为字符串类型时，计算OGNL表达式的值。例如在Ognl.jsp中加入以下代码：

<hr />
     <h3>%的用途</h3>
     <p><s:url value="#foobar['foo1']" /></p>
     <p><s:url value="%{#foobar['foo1']}" /></p>清单6 演示%用途的代码片段
刷新页面，结果如下所示：

清单7 示例运行结果2

“$”有两个主要的用途

用于在国际化资源文件中，引用OGNL表达式，例子请参考《在Struts 2.0中国际化(i18n)您的应用程序》
在Struts 2配置文件中，引用OGNL表达式，如 <action name="AddPhoto" class="addPhoto">
             <interceptor-ref name="fileUploadStack" />            
             <result type="redirect">ListPhotos.action?albumId=${albumId}</result>
         </action>清单8 演示$用途的代码片段
总结
OGNL是一种功能很大的表达式语言，熟悉它可以使我们的开发变得更快捷。

<jsp-property-group>

<deferred-syntax-allowed-as-literal>

true

</deferred-syntax-allowed-as-literal>





</jsp-property-group>

<%@page  language="java" deferredSyntaxAllowedAsLiteral="true" %>



办法3 ：不用 jsp2.1 el



>   <jsp-config>

>     <jsp-property-group>

>       <url-pattern>*.jsp</url-pattern>

>       <el-ignored>true</el-ignored>

>     </jsp-property-group>

>   </jsp-config>




http://www.mail-archive.com/dev@struts.apache.org/msg28920.html


我现在的疑问

在一个页面中采用两个 el 引擎，是否会对性能造成一定影响？

较小。

将： 

<ww:radio list="#{"D":"草稿箱","S":"直接发表"}"    name="savePosition"></ww:radio>

改：

<ww:radio list="#@java.util.HashMap@{"D":"草稿箱","S":"直接发表"}"    name="savePosition"></ww:radio> 

 弄清楚struts-config.xml中各项元素的作用，对于我们构建web项目有莫大的好处。<struts-config>是struts的根元素，它主要有8个子元素，DTD定义如下：

<!ELEMENT struts-config
(data-sources?,form-beans?,global-exceptions?,global-forwards?,action-mappings?,controller?,message-resources*,plug-in*)
>
以上8个元素，下面一一描述：
1. date-sources元素
　　date-sources元素用来配置应用程序所需要的数据源。java语言提供了javax.sql.DateSource接口，所有数据源必须实现该接口。如下配置：
<data-sources>
　　<data-source type="org.apache.commons.dbcp.BasicDataSource">
　　　　………………
　　</data-source>
</data-sources>
在Action中访问方式如：
javax.sql.DataSource dataSource;
java.sql.Connection myConnection;
try
{
　　dataSource = getDataSource(request);
　　myConnection　＝　dataSource.getConnection();
}
…………
　　如果是多数据源，可用如下配置：
<data-sources>
　　<data-source key="a"  type="org.apache.commons.dbcp.BasicDataSource">
　　　　………………
　　</data-source>
　　<data-source key="b"   type="org.apache.commons.dbcp.BasicDataSource">
　　　　………………
　　</data-source>
</data-sources>
访问方式：dataSource = getDataSource(request,"a");

 2. form-beans元素
　　该元素主要用来配置表单验证的类。它包含如下属性：
　　1. classname：一般用得少，指定和form-bean无素对应的配置类，默认为org.apache.struts.config.FormBeanConfig，如果自定义，则必须扩展FormBeanConfig类。可有可无。
　　2. name：ActionForm Bean的惟一标识。必须。
　　3. type：ActionForm的完整类名。必须。
如下所示：
<form-beans>
　　<form-bean
　　　　　　name="Loign"
　　　　　　type="com.ha.login">
　　</form-bean>
</form-beans>
　　如果是动态Action FormBean，还必须配置form-bean元素的form-property子元素。它包含四个属性，上面三个，还有一个initial 元素：以字符串的形式设置表单字段的初始值，如果没有设置该属性，则是基本类型为0，如果是对象则为null。可有可无。如下所示：
<form-beans>
　　<form-bean
　　　　　　name="Loign"
　　　　　　type="com.ha.login">
　　　　　<form-property name="ok"  type="java.lang.String"/>
　　　　　<form-property name="oks"  type="java.lang.String"/>
　　　　　<form-property name="okss"  type="java.lang.Integer" initial="20"/>
　　</form-bean>
</form-beans>

 3. global-exceptions元素
　　该元素主要配置异常处理，它的exception子元素代表全局的异常配置。struts采取配置的方式来处理异常。它用来设置java异常和异常处理类org.apache.struts.action.ExceptionHandler之间的映射。它有七个属性，如下所示：
　　1. className：指定和exception元素对应的配置类，默认为：org.apache.struts.config.ExceptionConfig。可有可无。
　　2. Handler：指定异常得理类，默认为：org.apache.struts.action.ExceptionHandler。可有可无
　　3. key：指定在Resource Bundle中描述该异常的消息key
　　4. path：指定当异常发生时的转发路径。
　　5. scope：指定ActionMessages实例的存放范围，可选值包括：request和session，默认为request。可有可无。
　　6. type：指定所需处理异常类的名字，必须。
　　7. bundle：指定Resource Bundle
如下所示：
<global-exceptions>
　　<exception
　　　　　　key="global.error.invalidlogin"
　　　　　　path="/error.jsp"
　　　　　　scope="request"
　　　　　　type="com.hn.tree"
　　/>
</global-exceptions>

 4. global-forwards元素
　　该元素主要用来声明全局的转发关系，它具有以下四个属性：
　　1. className：和forward元素对应的配置类，默认为：org.apache.struts.action.ActionForward。可有可无。
　　2. contextRelative：此项为true时，表时path属性以＂/＂开头，相对于当前上下文的URL，默认为false．可有可无。　
　　3. name：转发路径的逻辑名．必填。
　　4. path：转发或重定向的URL，当contextRelative=false时，URL路径相对于当前应用（application），当为ture时，表示URL路径相对于当前上下文（context）。
　　5.  redirect：当此项为ture时，表示执行重定向操作。当此项为false时表示转向操作。默认为false。
如下所示：
<global-forwards>
　　<forward  name="forms1"  path="/a.do"/>
　　<forward  name="forms2"  path="/nb.jsp"/>
<global-forwards>

 5. action-mappings元素
　　描述从特定的请求路径到相应的Action类的映射。它具有以下几个属性：
　　1. attribute：设置和Action关联的ActionForm Bean在request和session范围内的key。如：Form Bean存在于request范围内，此项设为“myBenas”，则在request.getAttribute("myBenas")就可以返回该Bean的实例。
　　2. classsName：和action元素对应的配置元素，默认为：org.apache.struts.action.ActionMapping.
　　3. forward：转发的URL路径。
　　4. include：指定包含的URL路径。
　　5. input：输入表单的URL路径，当表单验证失败时，将把请求转发到该URL。
　　6. name：指定和Action关联的Action FormBean的名字，该名字必须在Form-Bean定义过。
　　7. path：指定访问Action的路径，以“/”开头，无扩展名。
　　8. parameter：指定Actgion的配置参数，在Action类的execute()方法中，可以调用ActionMapping对象的getParameter()方法来读取该配置参数。
　　9. roles：指定允许调用该Action的安全角色，多个角色之间用，隔开，在处理请求时，RequestProcessor会根据该配置项来决定用户是否有权限调用Action权限。
　　10. scope：指定ActionForm Bean的存在范围，可选取为request和session，默认为session。
　　11. type：指定Action类的完整类名。
　　12. unknown：如果此项为true，表示可以处理用户发出的所有无效的Action URL，默认为false；
　　13. validate：指定是否要调用Action FormBean的validate方法，默认值为ture.
注：forward、include、type属性只能选中其中一项。
如下：
<action path="/search"
　　　　type="zxj.okBean"
　　　　name="a1"
　　　　scope="request"
　　　　validate="true"
　　　　input="/b.jsp">
　　<forward name="tig" path="/aa.jsp"/>
</action>
注：此中的forward是指局部的转发路径。global-forwards表示全局的转发路径。

 6. controller元素
　　该元素用于配置ActionServlet。它具有以下属性。
　　1. bufferSize：指定上载文件的输入缓冲大小，可选，默认为4096
　　2. className：指定和controller元素对应的配置类，默认为org.apache.struts.config.ControllerConfig
　　3. conentType：字符编码，如果在Action和JSP网页中设置了，则覆盖该设置。
　　4. locale：指定是否把Locale对象保存到当前用户的session中，默认值为false.
　　5. processorClass：指定负责请求的java类完整路径。
　　6. tempDir：指定处理文件的临时工作目录，如果此项没有设置，将采用Servlet容器为web应用分配的临时工作目录。
　　7. nochache：如果为true：在响应结果中将加入特定的头参数：Pragma,Cache-Control和Expise，防止页面被保存在客户端的浏览器中，默认为false
如下：
<controller
　　contentType="text/html;charset="UTF-8""
　　locale="true"
　　processorClass="con.ok"/>

 7. message-resources元素
　　主要配置本地化消息文本，它具有以下属性。
　　1. className：和message-resources元素对应的配置类，默认为org.apache.struts.config.MessageResourcesConfig。
　　2. factory：指定消息资源的工厂类，默认为：org.apache.struts.util.PropertyMessageResourcesFactory类
　　3. key：指定Resource Bundle存放的ServletContext对象中时采用的属性Key，默认由Globals.MESSAGES_KEY定义的字符串常量，只允许一个Resource Bundle采用默认的属性Key。
　　4. null：指定MessageSources类如何处理未知消息的key，如果为true，则返回空字符串，如果为false，则返回相关字串，默认为false
　　5. prameter：指定MessageSources的资源文件名，如果为：a.b.ApplicationResources，则实际对应的文件路径为：WEB-INF/classes/a/b/ApplicationResources.properties.
如：
<message-resources null="false" parameter="defaultResource"/>
<message-resources key="num1" null="false" parameter="test"/>
访问为：
<bean:message  key="zxj"/>
<bean:message  key="zxj"  bundle="num1"/>
其中，zxj表法，messagesource资源文件中的一个字符串。

 8. plugin-in元素
　　配置Struts的插件，属性如下：
　　1. className：指定的Struts插件类，必须实现org.apache.struts.action.PlugiIn接口。如：
<plug-in
　　className="a.b.c.">
　　<set-property property="xxx" value="/WEB-INF/aa.xml"  />
</plug-in>

 后记，多模块的配置，可以供多个应用应用不同的struts-config.xml

(转载于：http://blog.csdn.net/zxjcool/archive/2006/06/18/810305.aspx)

struts.configuration
          The org.apache.struts2.config.Configuration implementation class
            org.apache.struts2.config.Configuration接口名

struts.configuration.files
          A list of configuration files automatically loaded by Struts 
           struts自动加载的一个配置文件列表

struts.configuration.xml.reload
          Whether to reload the XML configuration or not
           是否加载xml配置(true,false)

struts.continuations.package
           The package containing actions that use Rife continuations
           含有actions的完整连续的package名称

struts.custom.i18n.resources
          Location of additional localization properties files to load 
           加载附加的国际化属性文件（不包含.properties后缀）

struts.custom.properties
          Location of additional configuration properties files to load
           加载附加的配置文件的位置

struts.devMode
          Whether Struts is in development mode or not
           是否为struts开发模式

struts.dispatcher.parametersWorkaround
          Whether to use a Servlet request parameter workaround necessary for some versions of WebLogic
            （某些版本的weblogic专用）是否使用一个servlet请求参数工作区（PARAMETERSWORKAROUND）

struts.enable.DynamicMethodInvocation
          Allows one to disable dynamic method invocation from the URL
            允许动态方法调用

struts.freemarker.manager.classname
          The org.apache.struts2.views.freemarker.FreemarkerManager implementation class 
           org.apache.struts2.views.freemarker.FreemarkerManager接口名

struts.i18n.encoding
          The encoding to use for localization messages
           国际化信息内码

struts.i18n.reload
          Whether the localization messages should automatically be reloaded
           是否国际化信息自动加载

struts.locale
          The default locale for the Struts application
           默认的国际化地区信息

struts.mapper.class
          The org.apache.struts2.dispatcher.mapper.ActionMapper implementation class
            org.apache.struts2.dispatcher.mapper.ActionMapper接口

struts.multipart.maxSize
          The maximize size of a multipart request (file upload)
           multipart请求信息的最大尺寸（文件上传用）

struts.multipart.parser
          The org.apache.struts2.dispatcher.multipart.MultiPartRequest parser implementation for a multipart request (file upload) 
          专为multipart请求信息使用的org.apache.struts2.dispatcher.multipart.MultiPartRequest解析器接口（文件上传用）

struts.multipart.saveDir
          The directory to use for storing uploaded files 
           设置存储上传文件的目录夹

struts.objectFactory
          The com.opensymphony.xwork2.ObjectFactory implementation class
           com.opensymphony.xwork2.ObjectFactory接口（spring）

struts.objectFactory.spring.autoWire
          Whether Spring should autoWire or not
           是否自动绑定Spring

struts.objectFactory.spring.useClassCache
          Whether Spring should use its class cache or not
           是否spring应该使用自身的cache

struts.objectTypeDeterminer
          The com.opensymphony.xwork2.util.ObjectTypeDeterminer implementation class
            com.opensymphony.xwork2.util.ObjectTypeDeterminer接口

struts.serve.static.browserCache
          If static content served by the Struts filter should set browser caching header properties or not 
           是否struts过滤器中提供的静态内容应该被浏览器缓存在头部属性中

struts.serve.static
          Whether the Struts filter should serve static content or not 
           是否struts过滤器应该提供静态内容

struts.tag.altSyntax
          Whether to use the alterative syntax for the tags or not 
           是否可以用替代的语法替代tags

struts.ui.templateDir
          The directory containing UI templates
           UI templates的目录夹

struts.ui.theme
          The default UI template theme
           默认的UI template主题

struts.url.http.port
          The HTTP port used by Struts URLs
           设置http端口

struts.url.https.port
          The HTTPS port used by Struts URLs 
           设置https端口

struts.url.includeParams
          The default includeParams method to generate Struts URLs 
          在url中产生 默认的includeParams

struts.velocity.configfile
          The Velocity configuration file path
           velocity配置文件路径

struts.velocity.contexts
          List of Velocity context names
           velocity的context列表

struts.velocity.manager.classname
          org.apache.struts2.views.velocity.VelocityManager implementation class
           org.apache.struts2.views.velocity.VelocityManager接口名

struts.velocity.toolboxlocation
          The location of the Velocity toolbox
           velocity工具盒的位置
struts.xslt.nocache
          Whether or not XSLT templates should not be cached
           是否XSLT模版应该被缓存 

为避免重复文件名
FormFile file = theForm.getTheFile();

String fileName= file.getFileName();
            
int i = fileName.lastIndexOf(".");
      if(i != -1)
     {
        fileName = fileName.substring(i);
     }else
     {
        fileName = ".bin";
      }
     fileName = new Date().getTime()+fileName;

最后别忘了file.destroy();

其他的就用struts里面自带的例子搞定.
InputStream stream = file.getInputStream();
OutputStream bos = new FileOutputStream(pathMyDir+fileName);
    int bytesRead = 0;
    byte[] buffer = new byte[8192];
    while ((bytesRead = stream.read(buffer, 0, 8192)) != -1) {
          bos.write(buffer, 0, bytesRead);
         }
      bos.close();
      stream.close();

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=250969

 一、简介
  Struts-Menu是一组从基于XML的配置文件中生成多种样式的菜单的JSP Tags，并且可以结合API开发通过数据库生成的动态菜单。Struts-Menu支持国际化和多种权限控制。

二、运行环境
  Windows 2000 Professional
  JDK 1.4.2_03
  Eclipse 3.1
  Tomcat 5.0.28
  Tomcat Plugin 3.1Beta
  Struts 1.2.7
  Commons-Lang 2.1
  Commons-Collections 3.1
  Struts-Menu 2.3
  MySQL 4.1.10a-nt

三、下载与安装
  1：从http://java.sun.com下载J2SDK，当前1.4.x系列的最新版本为1.4.2_08
  2：从http://www.eclipse.org下载Eclipse，当前最新版本为3.1正式版
  3：从http://jakarta.apache.org/tomcat下载Tomcat，当前5.x系列的最新版本为5.0.28
  4：从http://www.sysdeo.com/eclipse/tomcatplugin下载Eclipse的Tomcat插件，对应Eclipse3.1x的最新版本为3.1Beta
  5：从http://struts.apache.org下载Struts，当前最新版本为1.2.7
  6：从http://jakarta.apache.org/commons/下载Commons-Lang，当前最新版本为2.1，下载Commons-Collections，当前最新版本为3.1
  7：从http://struts-menu.sourceforge.net下载Struts Menu，当前最新版本为2.3
  8：从http://www.mysql.com下载MySQL数据库，4.x系列的最新版本是4.1.12a
  9：MySQL、JDK、Eclipse、Tomcat和TomcatPlugin的安装及配置请参考相关资料

四、运行示例程序
  1：安装好Tomcat后，解压缩struts-menu-2.3.zip，将struts-menu.war释放到Tomcat安装目录下的webapps下，运行Tomcat
  2：在地址栏输入http://localhost:8080/struts-menu

五、安装与配置
  1：在Eclipse中新建Tomcat项目，Context为/mymenu，Subdirectory为/web
  2：在项目目录下面新建lib目录和web目录及WEB-INF，在web/WEB-INF目录下新建web.xml，内容如下：
<?xml version="1.0" encoding="ISO-8859-1"?>

<!DOCTYPE web-app
    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
  <display-name>My Example Application -- Vinton Lee</display-name>
     
  <!-- ============= The Struts ActionServlet Configuration ============= -->
  <servlet>
    <servlet-name>action</servlet-name>
    <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
    <init-param>
      <param-name>config</param-name>
      <param-value>/WEB-INF/struts-config.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <!-- ================================================================== -->
   
  <!-- ============= The Struts Action Servlet Mapping ================== -->
  <servlet-mapping>
    <servlet-name>action</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
  <!-- ================================================================== -->
 
  <!-- The Welcome File List -->
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>

  <!-- =============== The Struts Taglib Definition ===================== -->
  <taglib>
    <taglib-uri>struts-bean</taglib-uri>
    <taglib-location>/WEB-INF/struts-bean.tld</taglib-location>
  </taglib>
  <taglib>
    <taglib-uri>struts-html</taglib-uri>
    <taglib-location>/WEB-INF/struts-html.tld</taglib-location>
  </taglib>
  <taglib>
    <taglib-uri>struts-logic</taglib-uri>
    <taglib-location>/WEB-INF/struts-logic.tld</taglib-location>
  </taglib>
  <taglib>
    <taglib-uri>struts-nested</taglib-uri>
    <taglib-location>/WEB-INF/struts-nested.tld</taglib-location>
  </taglib>
  <taglib>
    <taglib-uri>struts-tiles</taglib-uri>
    <taglib-location>/WEB-INF/struts-tiles.tld</taglib-location>
  </taglib>
  <!-- ================================================================== -->
 
  <!-- ============= The Struts-Menu Taglib Definition ================== -->
  <taglib>
    <taglib-uri>struts-menu</taglib-uri>
    <taglib-location>/WEB-INF/struts-menu.tld</taglib-location>
  </taglib>
  <!-- ================================================================== -->
</web-app>

  3：解压缩struts-1.2.7.zip，将压缩包中的lib目录下所有的8个jar释放到lib目录中，将5个tld文件释放到web\WEB-INF目录中，在web\WEB-INF目录中新建struts-config.xml，内容如下：
<?xml version="1.0" encoding="ISO-8859-1" ?>

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

<struts-config>

    <!-- ========== Data Source Configuration =============================== -->
    <data-sources />

    <!-- ========== Form Bean Definitions =================================== -->
    <form-beans />

    <!-- ========== Global Exception Definitions ============================ -->
    <global-exceptions />

    <!-- ========== Global Forward Definitions ============================== -->
    <global-forwards />

    <!-- ========== Action Mapping Definitions ============================== -->
    <action-mappings />

    <!-- ========== Controller Configuration ================================ -->

    <!-- ========== Message Resources Definitions =========================== -->
    <message-resources parameter="application" />

    <!-- ========== Plug Ins Configuration ================================== -->
    <plug-in className="net.sf.navigator.menu.MenuPlugIn">
      <set-property property="menuConfig" value="/WEB-INF/menu-config.xml"/>
    </plug-in>

</struts-config>

  4：解压缩struts-menu-2.3.zip，将压缩包中的jstl-1.0.6.jar、standard-1.0.6.jar、struts-menu-2.3.jar释放到lib目录中，将压缩包中的struts-menu.tld、struts-menu-el.tld释放到web\WEB-INF目录中，解压缩commons-lang-2.1.zip，将commons-lang-2.1.jar解压缩到lib目录中，注意，在Struts-Menu的文档中没有看到需要这个包，但是没有这个包却无法成功加载。在web\WEB-INF目录中新建menu-config.xml，内容如下：
<?xml version="1.0" encoding="UTF-8" ?>

<MenuConfig>

  <Displayers>
    <Displayer   name="DropDown"
                 type="net.sf.navigator.displayer.DropDownMenuDisplayer"/>
    <Displayer   name="Simple"
                 type="net.sf.navigator.displayer.SimpleMenuDisplayer"/>
    <Displayer   name="CoolMenu"
                 type="net.sf.navigator.displayer.CoolMenuDisplayer"/>
    <Displayer   name="CoolMenu4"
                 type="net.sf.navigator.displayer.CoolMenuDisplayer4"/>
    <Displayer   name="MenuForm"
                 type="net.sf.navigator.example.PermissionsFormMenuDisplayer"/>
    <Displayer   name="ListMenu"
                 type="net.sf.navigator.displayer.ListMenuDisplayer"/>
    <Displayer   name="TabbedMenu"
                 type="net.sf.navigator.displayer.TabbedMenuDisplayer"/>
    <Displayer   name="Velocity"
                 type="net.sf.navigator.displayer.VelocityMenuDisplayer"/>
  </Displayers>

  <Menus>
    <Menu  name="DoorSite"  title="DoorSite"  description="Some famous doorsite" width="50">
       <Item   name="Yahoo"   title="Yahoo">
           <Item   name="YahooIndex"   title="Yahoo Index"   location="http://www.yahoo.com.cn"/>
           <Item   name="YahooMail"    title="Yahoo Mail"    location="http://cn.mail.yahoo.com"/>
       </Item>
       <Item    name="Sohu"  title="Sohu"   location="http://www.sohu.com"/>
       <Item    name="Sina"  title="Sina"   location="http://www.sina.com.cn"/>
    </Menu>
  </Menus>

</MenuConfig>

  5：将第四步的示例程序中的struts-menu应用目录下的images、scripts、styles三个目录中的内容复制到web目录下

  6：你的目录结构应该类似如下：
    %PROJECT_HOME%\classes
    %PROJECT_HOME%\lib
    %PROJECT_HOME%\lib\antlr.jar
    %PROJECT_HOME%\lib\commons-beanutils.jar
    %PROJECT_HOME%\lib\commons-digester.jar
    %PROJECT_HOME%\lib\commons-fileupload.jar
    %PROJECT_HOME%\lib\commons-lang-2.1.jar
    %PROJECT_HOME%\lib\commons-logging.jar
    %PROJECT_HOME%\lib\commons-validator.jar
    %PROJECT_HOME%\lib\jakarta-oro.jar
    %PROJECT_HOME%\lib\jstl-1.0.6.jar
    %PROJECT_HOME%\lib\standard-1.0.6.jar
    %PROJECT_HOME%\lib\struts.jar
    %PROJECT_HOME%\lib\struts-menu-2.3.jar
    %PROJECT_HOME%\src
    %PROJECT_HOME%\src\log4j.properties
    %PROJECT_HOME%\src\application.properties
    %PROJECT_HOME%\src\application_zh_CN.properties
    %PROJECT_HOME%\web
 %PROJECT_HOME%\web\images\...
 %PROJECT_HOME%\web\scripts\...
 %PROJECT_HOME%\web\styles\...
    %PROJECT_HOME%\web\WEB-INF
    %PROJECT_HOME%\web\WEB-INF\menu-config.xml
    %PROJECT_HOME%\web\WEB-INF\struts-bean.tld
    %PROJECT_HOME%\web\WEB-INF\struts-config.xml
    %PROJECT_HOME%\web\WEB-INF\struts-html.tld
    %PROJECT_HOME%\web\WEB-INF\struts-logic.tld
    %PROJECT_HOME%\web\WEB-INF\struts-menu.tld
    %PROJECT_HOME%\web\WEB-INF\struts-menu-el.tld
    %PROJECT_HOME%\web\WEB-INF\struts-nested.tld
    %PROJECT_HOME%\web\WEB-INF\struts-tiles.tld
    %PROJECT_HOME%\web\WEB-INF\web.xml

六、实战Struts-Menu
  1：使用配置文件实现静态菜单
  新建JSP文件web/static-menu.jsp，内容如下：
<%@ page contentType="text/html; charset=GBK" %>
<%@ taglib uri="struts-menu" prefix="menu" %>

<menu:useMenuDisplayer name="ListMenu"
    bundle="org.apache.struts.action.MESSAGE">
    <menu:displayMenu name="DoorSite"/>
</menu:useMenuDisplayer>
  运行Tomcat，在IE地址栏输入http://localhost:8080/mymenu/static-menu.jsp查看

  2：实现中文化
  > 在src\application_zh_CN.properties中增加下面的内容，Unicode可以通过JDK自带的native2ascii工具得到：
#门户网站
menu.DoorSite=\u95e8\u6237\u7f51\u7ad9
#雅虎
menu.Yahoo=\u96c5\u864e
#雅虎首页
menu.YahooIndex=\u96c5\u864e\u9996\u9875
#雅虎邮件
menu.YahooMail=\u96c5\u864e\u90ae\u4ef6
#搜狐
menu.Sohu=\u641c\u72d0
#新浪
menu.Sina=\u65b0\u6d6a
  > 在src\application.properties中增加下面的内容：
#门户网站
menu.DoorSite=DoorSite
#雅虎
menu.Yahoo=Yahoo
#雅虎首页
menu.YahooIndex=Yahoo Index
#雅虎邮件
menu.YahooMail=Yahoo Mail
#搜狐
menu.Sohu=Sohu
#新浪
menu.Sina=Sina
  > 修改menu-config.xml文件<Menus></Menus>部分：
  <Menus>
    <Menu  name="DoorSite"  title="menu.DoorSite"  description="Some famous doorsite" width="50">
       <Item   name="Yahoo"   title="menu.Yahoo">
           <Item   name="YahooIndex"   title="menu.YahooIndex"   location="http://www.yahoo.com.cn"/>
           <Item   name="YahooMail"    title="menu.YahooMail"    location="http://cn.mail.yahoo.com"/>
       </Item>
       <Item    name="Sohu"  title="menu.Sohu"   location="http://www.sohu.com"/>
       <Item    name="Sina"  title="menu.Sina"   location="http://www.sina.com.cn"/>
    </Menu>
  </Menus>
  重起Tomcat，在IE地址栏输入http://localhost:8080/mymenu/static-menu.jsp查看

  3：结合数据库实现动态菜单
  > 新建数据myexamples：
CREATE DATABASE myexamples
  > 新建数据库表menu_item：
CREATE TABLE menu_item (
   id BIGINT not null,
   parent_name VARCHAR(30),
   name VARCHAR(30),
   title VARCHAR(30),
   titleCN VARCHAR(30),
   description VARCHAR(50),
   location VARCHAR(255),
   target VARCHAR(10),
   onclick VARCHAR(100),
   onmouseover VARCHAR(100),
   onmouseout VARCHAR(100),
   image VARCHAR(50),
   altImage VARCHAR(30),
   tooltip VARCHAR(100),
   roles VARCHAR(100),
   page VARCHAR(255),
   width VARCHAR(5),
   height VARCHAR(5),
   forward VARCHAR(50),
   action VARCHAR(50),
   primary key (id)
)
  > 插入测试数据：
INSERT INTO menu_item
    (id, parent_name, name, title, titleCN, location)
VALUES
    (1,null,'DatabaseMenu','Database Menu','数据库动态菜单',null),
    (2,'DatabaseMenu','Yahoo','Yahoo Mail','雅虎邮件','http://mail.yahoo.com'),
    (3,'DatabaseMenu','JavaBlogs','JavaBlogs','Java博客','http://javablogs.com'),
    (4,null,'StandaloneMenu','Standalone Menu','独立的菜单','http://www.sohu.com')
  > 将数据库驱动程序放到lib目录中，并加入到Build Path，如MySQL的数据库驱动mysql-connector-java-3.1.8-bin.jar，解压缩commons-collections-3.1.zip，将commons-collections-3.1.jar释放到lib目录，并加入Build Path
  > 新建一个Struts的Action，代码如下：
package cn.appex.menu;

import java.io.UnsupportedEncodingException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.ListResourceBundle;
import java.util.Map;

import com.mysql.jdbc.Driver;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import net.sf.navigator.menu.MenuComponent;
import net.sf.navigator.menu.MenuRepository;
import net.sf.navigator.menu.PermissionsAdapter;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

public class MenuAction extends Action {
    public ActionForward execute(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response)
            throws Exception {
        buildMenuRepository(request);
        buildMenuResourceBundle(request);
        buildMenuPermissions(request);
        return (mapping.findForward("success"));
    }

    /**
     * 创建菜单数据结构
     *
     * @param request
     */
    private void buildMenuRepository(HttpServletRequest request) {
        MenuRepository repository = new MenuRepository();
        // Get the repository from the application scope - and copy the
        // DisplayerMappings from it.
        MenuRepository defaultRepository = (MenuRepository) request
                .getSession().getServletContext().getAttribute(
                        MenuRepository.MENU_REPOSITORY_KEY);
        repository.setDisplayers(defaultRepository.getDisplayers());

        Map[] menus = getMenuComponents();
        for (int i=0; i < menus.length; i++) {
            MenuComponent mc = new MenuComponent();
            Map row = menus[i];
            String name = (String) row.get("name");
            mc.setName(name);
            String parent = (String) row.get("parent_name");
            System.out.println(name + ", parent is: " + parent);
            if (parent != null) {
                MenuComponent parentMenu = repository.getMenu(parent);
                if (parentMenu == null) {
                    System.out.println("parentMenu '" + parent + "' doesn't exist!");
                    // create a temporary parentMenu
                    parentMenu = new MenuComponent();
                    parentMenu.setName(parent);
                    repository.addMenu(parentMenu);
                }

                mc.setParent(parentMenu);
            }
            String title = (String) row.get("title");
            mc.setTitle(title);
            String location = (String) row.get("location");
            mc.setLocation(location);
            String description = (String) row.get("description");
            mc.setDescription(description);
            repository.addMenu(mc);
        }
       
        request.setAttribute("examplesRepository", repository);
    }

    /**
     * 从数据库中读取菜单配置信息
     *
     * @return
     */
    private Map[] getMenuComponents() {
        ArrayList list = new ArrayList();
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rest = null;
        String sql = "select name,parent_name,title,location,description from menu_item order by id";
        try {
            Class.forName("com.mysql.jdbc.Driver").newInstance();
            conn = DriverManager.getConnection("jdbc:mysql://localhost/myexamples?user=root&password=mywangya&useUnicode=true&characterEncoding=UTF-8");
            pstmt = conn.prepareStatement(sql);
            rest = pstmt.executeQuery();
            while (rest.next()) {
                int i = 1;
                HashMap map = new HashMap();
                map.put("name", rest.getString(i++));
                map.put("parent_name", rest.getString(i++));
                map.put("title", rest.getString(i++));
                map.put("location", rest.getString(i++));
                map.put("description", rest.getString(i++));
                list.add(map);
            }
        } catch (SQLException ex) {
            ex.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (null!=rest) rest.close();
                if (null!=pstmt) pstmt.close();
                if (null!=conn) conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
       
        return (Map[]) list.toArray(new HashMap[0]);
    }
   
    /**
     * 构造菜单权限
     *
     * @param request
     */
    private void buildMenuPermissions(HttpServletRequest request) {
        PermissionsAdapter permession = new PermissionsAdapter() {
            public boolean isAllowed(MenuComponent menu) {
                // 名称等于StandaloneMenu的菜单不显示
                return !"StandaloneMenu".equalsIgnoreCase(menu.getName());
            }
        };
        request.setAttribute("examplesPermession", permession);
    }

    /**
     * 构造菜单显示标题
     *
     * @param request
     */
    private void buildMenuResourceBundle(HttpServletRequest request) {
        MenuResourceBundle resourceBundle = new MenuResourceBundle();
        request.setAttribute("examplesBundle", resourceBundle);
    }
   
    /**
     * MenuResourceBundle树状菜单国际语言显示
     *
     * @author wenbin.zhang
     * 
     */
    class MenuResourceBundle extends ListResourceBundle {
        private ArrayList list = new ArrayList();

        public MenuResourceBundle() {
            Connection conn = null;
            PreparedStatement pstmt = null;
            ResultSet rest = null;
            String sql = "select title,titleCN from menu_item order by id";
            try {
                Class.forName("com.mysql.jdbc.Driver").newInstance();
                conn = DriverManager.getConnection("jdbc:mysql://localhost/myexamples?user=root&password=mywangya&useUnicode=true&characterEncoding=UTF-8");
                pstmt = conn.prepareStatement(sql);
                rest = pstmt.executeQuery();
                while (rest.next()) {
                    int i = 1;
                    String[] message = new String[2];
                    message[0] = rest.getString(i++);
                    try {
                        message[1] = new String(rest.getString(i++).getBytes("latin1"), "gbk");
                    } catch (UnsupportedEncodingException e) {
                        e.printStackTrace();
                    }
                    if (message[0] != null && message[1] != null) {
                        list.add(message);
                    }
                }
            } catch (SQLException ex) {
                ex.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (null!=rest) rest.close();
                    if (null!=pstmt) pstmt.close();
                    if (null!=conn) conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

        }

        public Object[][] getContents() {
            return (String[][]) list.toArray(new String[0][0]);
        }
    }
}

  > 将struts-config.xml文件的<action-mappings />部分修改为：
<action-mappings>
  <action path="/menuAction" type="cn.appex.menu.MenuAction" >
    <forward name="success" path="/struts-menu/dynamic-menu.jsp" />
  </action>
</action-mappings>
  > 新建JSP文件web/dynamic-menu.jsp，内容如下：
<%@ page contentType="text/html; charset=GBK" %>
<%@ taglib uri="struts-menu" prefix="menu" %>

<p>没有使用Bundle和权限控制:
<menu:useMenuDisplayer name="ListMenu" repository="examplesRepository">
    <menu:displayMenu name="DatabaseMenu"/>
    <menu:displayMenu name="StandaloneMenu"/>
</menu:useMenuDisplayer></p>

<p>使用Bundle, 没有使用权限控制:
<menu:useMenuDisplayer name="ListMenu" bundle="examplesBundle" repository="examplesRepository">
    <menu:displayMenu name="DatabaseMenu"/>
    <menu:displayMenu name="StandaloneMenu"/>
</menu:useMenuDisplayer></p>

<p>使用Bundle和权限控制:
<menu:useMenuDisplayer name="ListMenu" permissions="examplesPermession"  bundle="examplesBundle" repository="examplesRepository">
    <menu:displayMenu name="DatabaseMenu"/>
    <menu:displayMenu name="StandaloneMenu"/>
</menu:useMenuDisplayer></p>
  重起Tomcat，在地址栏输入http://localhost:8080/mymenu/menuAction.do

七、关于Struts-Menu配置文件和API的使用方法，请参考附录中的官方网站

附：
Struts-Menu官方网站：http://struts-menu.sourceforge.net
数据库驱动的动态菜单：http://demo.raibledesigns.com/struts-menu/dynamicMenu.jsp

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=496331

下载struts menu, 解压其中的示例包(struts-menu里面有些库没有提供,但示例里面有) 步骤

1,新建一个tomcat工程

2,添加webProject支持

3,增加struts支持

4,增加jstl支持

5, 拷贝必要的jar库文件到dbMenuWEB-INFlib        log4j-1.2.8.jar velocity-1.4.jar velocity-tools-view-1.0.jar struts-menu-2.3.jar

6,创建menu-config.xml文件在dbMenuWEB-INF目录。内容如下:

<?xml version="1.0" encoding="UTF-8" ?>

<MenuConfig>

  <Displayers>
    <Displayer   name="DropDown"
                 type="net.sf.navigator.displayer.DropDownMenuDisplayer"/>
    <Displayer   name="Simple"
                 type="net.sf.navigator.displayer.SimpleMenuDisplayer"/>
    <Displayer   name="CoolMenu"
                 type="net.sf.navigator.displayer.CoolMenuDisplayer"/>
    <Displayer   name="CoolMenu4"
                 type="net.sf.navigator.displayer.CoolMenuDisplayer4"/>
    <Displayer   name="MenuForm"
                 type="net.sf.navigator.example.PermissionsFormMenuDisplayer"/>
    <Displayer   name="ListMenu"
                 type="net.sf.navigator.displayer.ListMenuDisplayer"/>
    <Displayer   name="TabbedMenu"
                 type="net.sf.navigator.displayer.TabbedMenuDisplayer"/>
    <Displayer   name="Velocity"
                 type="net.sf.navigator.displayer.VelocityMenuDisplayer"/>
  </Displayers>
  
</MenuConfig>

 

 

 

   <plug-in className="net.sf.navigator.menu.MenuPlugIn">
      <set-property property="menuConfig"
        value="/WEB-INF/menu-config.xml"/>
   </plug-in>

8,拷贝必要的文件

       Images/*.*        Scripts/        menuExpandable.js xtree.js        Styles/     menuExpandable.css   global.css   xtree.css        Templates/xtree.html        dbMenuWEB-INFclassesglobalMacros.vm   (这个文件好像必须要最后拷贝,否则会自动没了why???)

10, 拷贝tld文件到dbMenuWEB-INF

       struts-menu.tld
       struts-menu-el.tld

11, 不知道什么原因,需要修改web.xml文件中的version=2.3

<web-app version="2.3">

       Web.xml中增加

<context-param>
        <param-name>javax.servlet.jsp.jstl.fmt.localizationContext</param-name>
        <param-value>TrackerRes</param-value>
    </context-param>

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

12,填写数据库

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=640825

一、简介
  Struts-Menu是一组从基于XML的配置文件中生成多种样式的菜单的JSP Tags，并且可以结合API开发通过数据库生成的动态菜单。Struts-Menu支持国际化和多种权限控制。

二、运行环境
  Windows 2000 Professional
  JDK 1.4.2_03
  Eclipse 3.1
  Tomcat 5.0.28
  Tomcat Plugin 3.1Beta
  Struts 1.2.7
  Commons-Lang 2.1
  Commons-Collections 3.1
  Struts-Menu 2.3
  MySQL 4.1.10a-nt

三、下载与安装
  1：从http://java.sun.com下载J2SDK，当前1.4.x系列的最新版本为1.4.2_08
  2：从http://www.eclipse.org下载Eclipse，当前最新版本为3.1正式版
  3：从http://jakarta.apache.org/tomcat下载Tomcat，当前5.x系列的最新版本为5.0.28
  4：从http://www.sysdeo.com/eclipse/tomcatplugin下载Eclipse的Tomcat插件，对应Eclipse3.1x的最新版本为3.1Beta
  5：从http://struts.apache.org下载Struts，当前最新版本为1.2.7
  6：从http://jakarta.apache.org/commons/下载Commons-Lang，当前最新版本为2.1，下载Commons-Collections，当前最新版本为3.1
  7：从http://struts-menu.sourceforge.net下载Struts Menu，当前最新版本为2.3
  8：从http://www.mysql.com下载MySQL数据库，4.x系列的最新版本是4.1.12a
  9：MySQL、JDK、Eclipse、Tomcat和TomcatPlugin的安装及配置请参考相关资料

四、运行示例程序
  1：安装好Tomcat后，解压缩struts-menu-2.3.zip，将struts-menu.war释放到Tomcat安装目录下的webapps下，运行Tomcat
  2：在地址栏输入http://localhost:8080/struts-menu

五、安装与配置
  1：在Eclipse中新建Tomcat项目，Context为/mymenu，Subdirectory为/web
  2：在项目目录下面新建lib目录和web目录及WEB-INF，在web/WEB-INF目录下新建web.xml，内容如下：
<?xml version="1.0" encoding="ISO-8859-1"?>

<!DOCTYPE web-app
    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
  <display-name>My Example Application -- Vinton Lee</display-name>
     
  <!-- ============= The Struts ActionServlet Configuration ============= -->
  <servlet>
    <servlet-name>action</servlet-name>
    <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
    <init-param>
      <param-name>config</param-name>
      <param-value>/WEB-INF/struts-config.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <!-- ================================================================== -->
   
  <!-- ============= The Struts Action Servlet Mapping ================== -->
  <servlet-mapping>
    <servlet-name>action</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
  <!-- ================================================================== -->
 
  <!-- The Welcome File List -->
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>

  <!-- =============== The Struts Taglib Definition ===================== -->
  <taglib>
    <taglib-uri>struts-bean</taglib-uri>
    <taglib-location>/WEB-INF/struts-bean.tld</taglib-location>
  </taglib>
  <taglib>
    <taglib-uri>struts-html</taglib-uri>
    <taglib-location>/WEB-INF/struts-html.tld</taglib-location>
  </taglib>
  <taglib>
    <taglib-uri>struts-logic</taglib-uri>
    <taglib-location>/WEB-INF/struts-logic.tld</taglib-location>
  </taglib>
  <taglib>
    <taglib-uri>struts-nested</taglib-uri>
    <taglib-location>/WEB-INF/struts-nested.tld</taglib-location>
  </taglib>
  <taglib>
    <taglib-uri>struts-tiles</taglib-uri>
    <taglib-location>/WEB-INF/struts-tiles.tld</taglib-location>
  </taglib>
  <!-- ================================================================== -->
 
  <!-- ============= The Struts-Menu Taglib Definition ================== -->
  <taglib>
    <taglib-uri>struts-menu</taglib-uri>
    <taglib-location>/WEB-INF/struts-menu.tld</taglib-location>
  </taglib>
  <!-- ================================================================== -->
</web-app>

  3：解压缩struts-1.2.7.zip，将压缩包中的lib目录下所有的8个jar释放到lib目录中，将5个tld文件释放到web\WEB-INF目录中，在web\WEB-INF目录中新建struts-config.xml，内容如下：
<?xml version="1.0" encoding="ISO-8859-1" ?>

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

<struts-config>

    <!-- ========== Data Source Configuration =============================== -->
    <data-sources />

    <!-- ========== Form Bean Definitions =================================== -->
    <form-beans />

    <!-- ========== Global Exception Definitions ============================ -->
    <global-exceptions />

    <!-- ========== Global Forward Definitions ============================== -->
    <global-forwards />

    <!-- ========== Action Mapping Definitions ============================== -->
    <action-mappings />

    <!-- ========== Controller Configuration ================================ -->

    <!-- ========== Message Resources Definitions =========================== -->
    <message-resources parameter="application" />

    <!-- ========== Plug Ins Configuration ================================== -->
    <plug-in className="net.sf.navigator.menu.MenuPlugIn">
      <set-property property="menuConfig" value="/WEB-INF/menu-config.xml"/>
    </plug-in>

</struts-config>

  4：解压缩struts-menu-2.3.zip，将压缩包中的jstl-1.0.6.jar、standard-1.0.6.jar、struts-menu-2.3.jar释放到lib目录中，将压缩包中的struts-menu.tld、struts-menu-el.tld释放到web\WEB-INF目录中，解压缩commons-lang-2.1.zip，将commons-lang-2.1.jar解压缩到lib目录中，注意，在Struts-Menu的文档中没有看到需要这个包，但是没有这个包却无法成功加载。在web\WEB-INF目录中新建menu-config.xml，内容如下：
<?xml version="1.0" encoding="UTF-8" ?>

<MenuConfig>

  <Displayers>
    <Displayer   name="DropDown"
                 type="net.sf.navigator.displayer.DropDownMenuDisplayer"/>
    <Displayer   name="Simple"
                 type="net.sf.navigator.displayer.SimpleMenuDisplayer"/>
    <Displayer   name="CoolMenu"
                 type="net.sf.navigator.displayer.CoolMenuDisplayer"/>
    <Displayer   name="CoolMenu4"
                 type="net.sf.navigator.displayer.CoolMenuDisplayer4"/>
    <Displayer   name="MenuForm"
                 type="net.sf.navigator.example.PermissionsFormMenuDisplayer"/>
    <Displayer   name="ListMenu"
                 type="net.sf.navigator.displayer.ListMenuDisplayer"/>
    <Displayer   name="TabbedMenu"
                 type="net.sf.navigator.displayer.TabbedMenuDisplayer"/>
    <Displayer   name="Velocity"
                 type="net.sf.navigator.displayer.VelocityMenuDisplayer"/>
  </Displayers>

  <Menus>
    <Menu  name="DoorSite"  title="DoorSite"  description="Some famous doorsite" width="50">
       <Item   name="Yahoo"   title="Yahoo">
           <Item   name="YahooIndex"   title="Yahoo Index"   location="http://www.yahoo.com.cn"/>
           <Item   name="YahooMail"    title="Yahoo Mail"    location="http://cn.mail.yahoo.com"/>
       </Item>
       <Item    name="Sohu"  title="Sohu"   location="http://www.sohu.com"/>
       <Item    name="Sina"  title="Sina"   location="http://www.sina.com.cn"/>
    </Menu>
  </Menus>

</MenuConfig>

  5：将第四步的示例程序中的struts-menu应用目录下的images、scripts、styles三个目录中的内容复制到web目录下

  6：你的目录结构应该类似如下：
    %PROJECT_HOME%\classes
    %PROJECT_HOME%\lib
    %PROJECT_HOME%\lib\antlr.jar
    %PROJECT_HOME%\lib\commons-beanutils.jar
    %PROJECT_HOME%\lib\commons-digester.jar
    %PROJECT_HOME%\lib\commons-fileupload.jar
    %PROJECT_HOME%\lib\commons-lang-2.1.jar
    %PROJECT_HOME%\lib\commons-logging.jar
    %PROJECT_HOME%\lib\commons-validator.jar
    %PROJECT_HOME%\lib\jakarta-oro.jar
    %PROJECT_HOME%\lib\jstl-1.0.6.jar
    %PROJECT_HOME%\lib\standard-1.0.6.jar
    %PROJECT_HOME%\lib\struts.jar
    %PROJECT_HOME%\lib\struts-menu-2.3.jar
    %PROJECT_HOME%\src
    %PROJECT_HOME%\src\log4j.properties
    %PROJECT_HOME%\src\application.properties
    %PROJECT_HOME%\src\application_zh_CN.properties
    %PROJECT_HOME%\web
 %PROJECT_HOME%\web\images\...
 %PROJECT_HOME%\web\scripts\...
 %PROJECT_HOME%\web\styles\...
    %PROJECT_HOME%\web\WEB-INF
    %PROJECT_HOME%\web\WEB-INF\menu-config.xml
    %PROJECT_HOME%\web\WEB-INF\struts-bean.tld
    %PROJECT_HOME%\web\WEB-INF\struts-config.xml
    %PROJECT_HOME%\web\WEB-INF\struts-html.tld
    %PROJECT_HOME%\web\WEB-INF\struts-logic.tld
    %PROJECT_HOME%\web\WEB-INF\struts-menu.tld
    %PROJECT_HOME%\web\WEB-INF\struts-menu-el.tld
    %PROJECT_HOME%\web\WEB-INF\struts-nested.tld
    %PROJECT_HOME%\web\WEB-INF\struts-tiles.tld
    %PROJECT_HOME%\web\WEB-INF\web.xml

六、实战Struts-Menu
  1：使用配置文件实现静态菜单
  新建JSP文件web/static-menu.jsp，内容如下：
<%@ page contentType="text/html; charset=GBK" %>
<%@ taglib uri="struts-menu" prefix="menu" %>

<menu:useMenuDisplayer name="ListMenu"
    bundle="org.apache.struts.action.MESSAGE">
    <menu:displayMenu name="DoorSite"/>
</menu:useMenuDisplayer>
  运行Tomcat，在IE地址栏输入http://localhost:8080/mymenu/static-menu.jsp查看

  2：实现中文化
  > 在src\application_zh_CN.properties中增加下面的内容，Unicode可以通过JDK自带的native2ascii工具得到：
#门户网站
menu.DoorSite=\u95e8\u6237\u7f51\u7ad9
#雅虎
menu.Yahoo=\u96c5\u864e
#雅虎首页
menu.YahooIndex=\u96c5\u864e\u9996\u9875
#雅虎邮件
menu.YahooMail=\u96c5\u864e\u90ae\u4ef6
#搜狐
menu.Sohu=\u641c\u72d0
#新浪
menu.Sina=\u65b0\u6d6a
  > 在src\application.properties中增加下面的内容：
#门户网站
menu.DoorSite=DoorSite
#雅虎
menu.Yahoo=Yahoo
#雅虎首页
menu.YahooIndex=Yahoo Index
#雅虎邮件
menu.YahooMail=Yahoo Mail
#搜狐
menu.Sohu=Sohu
#新浪
menu.Sina=Sina
  > 修改menu-config.xml文件<Menus></Menus>部分：
  <Menus>
    <Menu  name="DoorSite"  title="menu.DoorSite"  description="Some famous doorsite" width="50">
       <Item   name="Yahoo"   title="menu.Yahoo">
           <Item   name="YahooIndex"   title="menu.YahooIndex"   location="http://www.yahoo.com.cn"/>
           <Item   name="YahooMail"    title="menu.YahooMail"    location="http://cn.mail.yahoo.com"/>
       </Item>
       <Item    name="Sohu"  title="menu.Sohu"   location="http://www.sohu.com"/>
       <Item    name="Sina"  title="menu.Sina"   location="http://www.sina.com.cn"/>
    </Menu>
  </Menus>
  重起Tomcat，在IE地址栏输入http://localhost:8080/mymenu/static-menu.jsp查看

  3：结合数据库实现动态菜单
  > 新建数据myexamples：
CREATE DATABASE myexamples
  > 新建数据库表menu_item：
CREATE TABLE menu_item (
   id BIGINT not null,
   parent_name VARCHAR(30),
   name VARCHAR(30),
   title VARCHAR(30),
   titleCN VARCHAR(30),
   description VARCHAR(50),
   location VARCHAR(255),
   target VARCHAR(10),
   onclick VARCHAR(100),
   onmouseover VARCHAR(100),
   onmouseout VARCHAR(100),
   image VARCHAR(50),
   altImage VARCHAR(30),
   tooltip VARCHAR(100),
   roles VARCHAR(100),
   page VARCHAR(255),
   width VARCHAR(5),
   height VARCHAR(5),
   forward VARCHAR(50),
   action VARCHAR(50),
   primary key (id)
)
  > 插入测试数据：
INSERT INTO menu_item
    (id, parent_name, name, title, titleCN, location)
VALUES
    (1,null,'DatabaseMenu','Database Menu','数据库动态菜单',null),
    (2,'DatabaseMenu','Yahoo','Yahoo Mail','雅虎邮件','http://mail.yahoo.com'),
    (3,'DatabaseMenu','JavaBlogs','JavaBlogs','Java博客','http://javablogs.com'),
    (4,null,'StandaloneMenu','Standalone Menu','独立的菜单','http://www.sohu.com')
  > 将数据库驱动程序放到lib目录中，并加入到Build Path，如MySQL的数据库驱动mysql-connector-java-3.1.8-bin.jar，解压缩commons-collections-3.1.zip，将commons-collections-3.1.jar释放到lib目录，并加入Build Path
  > 新建一个Struts的Action，代码如下：
package cn.appex.menu;

import java.io.UnsupportedEncodingException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.ListResourceBundle;
import java.util.Map;

import com.mysql.jdbc.Driver;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import net.sf.navigator.menu.MenuComponent;
import net.sf.navigator.menu.MenuRepository;
import net.sf.navigator.menu.PermissionsAdapter;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

public class MenuAction extends Action {
    public ActionForward execute(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response)
            throws Exception {
        buildMenuRepository(request);
        buildMenuResourceBundle(request);
        buildMenuPermissions(request);
        return (mapping.findForward("success"));
    }

    /**
     * 创建菜单数据结构
     *
     * @param request
     */
    private void buildMenuRepository(HttpServletRequest request) {
        MenuRepository repository = new MenuRepository();
        // Get the repository from the application scope - and copy the
        // DisplayerMappings from it.
        MenuRepository defaultRepository = (MenuRepository) request
                .getSession().getServletContext().getAttribute(
                        MenuRepository.MENU_REPOSITORY_KEY);
        repository.setDisplayers(defaultRepository.getDisplayers());

        Map[] menus = getMenuComponents();
        for (int i=0; i < menus.length; i++) {
            MenuComponent mc = new MenuComponent();
            Map row = menus[i];
            String name = (String) row.get("name");
            mc.setName(name);
            String parent = (String) row.get("parent_name");
            System.out.println(name + ", parent is: " + parent);
            if (parent != null) {
                MenuComponent parentMenu = repository.getMenu(parent);
                if (parentMenu == null) {
                    System.out.println("parentMenu '" + parent + "' doesn't exist!");
                    // create a temporary parentMenu
                    parentMenu = new MenuComponent();
                    parentMenu.setName(parent);
                    repository.addMenu(parentMenu);
                }

                mc.setParent(parentMenu);
            }
            String title = (String) row.get("title");
            mc.setTitle(title);
            String location = (String) row.get("location");
            mc.setLocation(location);
            String description = (String) row.get("description");
            mc.setDescription(description);
            repository.addMenu(mc);
        }
       
        request.setAttribute("examplesRepository", repository);
    }

    /**
     * 从数据库中读取菜单配置信息
     *
     * @return
     */
    private Map[] getMenuComponents() {
        ArrayList list = new ArrayList();
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rest = null;
        String sql = "select name,parent_name,title,location,description from menu_item order by id";
        try {
            Class.forName("com.mysql.jdbc.Driver").newInstance();
            conn = DriverManager.getConnection("jdbc:mysql://localhost/myexamples?user=root&password=mywangya&useUnicode=true&characterEncoding=UTF-8");
            pstmt = conn.prepareStatement(sql);
            rest = pstmt.executeQuery();
            while (rest.next()) {
                int i = 1;
                HashMap map = new HashMap();
                map.put("name", rest.getString(i++));
                map.put("parent_name", rest.getString(i++));
                map.put("title", rest.getString(i++));
                map.put("location", rest.getString(i++));
                map.put("description", rest.getString(i++));
                list.add(map);
            }
        } catch (SQLException ex) {
            ex.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (null!=rest) rest.close();
                if (null!=pstmt) pstmt.close();
                if (null!=conn) conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
       
        return (Map[]) list.toArray(new HashMap[0]);
    }
   
    /**
     * 构造菜单权限
     *
     * @param request
     */
    private void buildMenuPermissions(HttpServletRequest request) {
        PermissionsAdapter permession = new PermissionsAdapter() {
            public boolean isAllowed(MenuComponent menu) {
                // 名称等于StandaloneMenu的菜单不显示
                return !"StandaloneMenu".equalsIgnoreCase(menu.getName());
            }
        };
        request.setAttribute("examplesPermession", permession);
    }

    /**
     * 构造菜单显示标题
     *
     * @param request
     */
    private void buildMenuResourceBundle(HttpServletRequest request) {
        MenuResourceBundle resourceBundle = new MenuResourceBundle();
        request.setAttribute("examplesBundle", resourceBundle);
    }
   
    /**
     * MenuResourceBundle树状菜单国际语言显示
     *
     * @author wenbin.zhang
     * 
     */
    class MenuResourceBundle extends ListResourceBundle {
        private ArrayList list = new ArrayList();

        public MenuResourceBundle() {
            Connection conn = null;
            PreparedStatement pstmt = null;
            ResultSet rest = null;
            String sql = "select title,titleCN from menu_item order by id";
            try {
                Class.forName("com.mysql.jdbc.Driver").newInstance();
                conn = DriverManager.getConnection("jdbc:mysql://localhost/myexamples?user=root&password=mywangya&useUnicode=true&characterEncoding=UTF-8");
                pstmt = conn.prepareStatement(sql);
                rest = pstmt.executeQuery();
                while (rest.next()) {
                    int i = 1;
                    String[] message = new String[2];
                    message[0] = rest.getString(i++);
                    try {
                        message[1] = new String(rest.getString(i++).getBytes("latin1"), "gbk");
                    } catch (UnsupportedEncodingException e) {
                        e.printStackTrace();
                    }
                    if (message[0] != null && message[1] != null) {
                        list.add(message);
                    }
                }
            } catch (SQLException ex) {
                ex.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (null!=rest) rest.close();
                    if (null!=pstmt) pstmt.close();
                    if (null!=conn) conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

        }

        public Object[][] getContents() {
            return (String[][]) list.toArray(new String[0][0]);
        }
    }
}

  > 将struts-config.xml文件的<action-mappings />部分修改为：
<action-mappings>
  <action path="/menuAction" type="cn.appex.menu.MenuAction" >
    <forward name="success" path="/struts-menu/dynamic-menu.jsp" />
  </action>
</action-mappings>
  > 新建JSP文件web/dynamic-menu.jsp，内容如下：
<%@ page contentType="text/html; charset=GBK" %>
<%@ taglib uri="struts-menu" prefix="menu" %>

<p>没有使用Bundle和权限控制:
<menu:useMenuDisplayer name="ListMenu" repository="examplesRepository">
    <menu:displayMenu name="DatabaseMenu"/>
    <menu:displayMenu name="StandaloneMenu"/>
</menu:useMenuDisplayer></p>

<p>使用Bundle, 没有使用权限控制:
<menu:useMenuDisplayer name="ListMenu" bundle="examplesBundle" repository="examplesRepository">
    <menu:displayMenu name="DatabaseMenu"/>
    <menu:displayMenu name="StandaloneMenu"/>
</menu:useMenuDisplayer></p>

<p>使用Bundle和权限控制:
<menu:useMenuDisplayer name="ListMenu" permissions="examplesPermession"  bundle="examplesBundle" repository="examplesRepository">
    <menu:displayMenu name="DatabaseMenu"/>
    <menu:displayMenu name="StandaloneMenu"/>
</menu:useMenuDisplayer></p>
  重起Tomcat，在地址栏输入http://localhost:8080/mymenu/menuAction.do

七、关于Struts-Menu配置文件和API的使用方法，请参考附录中的官方网站

附：
Struts-Menu官方网站：http://struts-menu.sourceforge.net
数据库驱动的动态菜单：http://demo.raibledesigns.com/struts-menu/dynamicMenu.jsp

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=496331

Struts Menu应用是一个JSP标记的集合，支持从XML文件生成各种不同菜单系统。Struts Menu 2.0进行了重构，使用Velocity Templates定义菜单。

2.       User Guide

 

2.1.       从1.x迁移到2.x

 

要从Struts Menu1.x升级到2.x，需要做如下改变：

l         修改标记库声明的URI，去掉“1.2”

<%@ taglib uri="http://struts-menu.sf.net/tag" prefix="menu" %>

l         修改<plug-in>，使用新的包名“net.sf.navigator”

<plug-in className="net.sf.navigator.menu.MenuPlugIn">

l         修改menu-config.xml文件，使用新的包名“net.sf.navigator”

<Displayer name="Simple" type="net.sf.navigator.displayer.SimpleMenuDisplayer"/>

2.2.       快速启动

 

l         下载struts-menu分发包

l         解压缩到本地目录

l         下载并安装Tomcat或其它Java Servlet容器

l         将struts-menu.war文件拷贝到Tomcat服务器的webapps目录下，启动服务器

l         浏览http://localhost:8080/struts-menu

2.3.       将Struts Menu集成到应用中

 

Struts Menu可以很方便得集成到Struts应用中，也将能够集成到其它非struts的应用中。下面是继承标记库的步骤。

你所需要做的就是将struts-menu.jar文件拷贝到WEB-INF/lib目录下，并在JSP页面中使用标记的URI以声明标记库。

对于Struts Menu 2.1，还需要将Jakarta的Standard Tag Library Jar拷贝到WEB-INF/lib目录下。

l         将struts-menu.jar文件拷贝到WEB-INF/lib目录下

l         在struts-config.xml文件中添加<plug-in>设置

<plug-in className="net.sf.navigator.menu.MenuPlugIn">

<set-property property="menuConfig" value="/WEB-INF/menu-config.xml"/>

</plug-in>

l         在WEB-INF/menu-config.xml文件中声明菜单属性。下面是一个示例：

<Menu name="contactMenu" title="Contact" location="?Contact">

  <Item name="email" title="E-Mail" location="?EMail"/>

  <Item name="phone" title="Phone" location="?Phone"/>

</Menu>

详细情况请参考例子应用的WEB-INF目录下的menu-config.xml文件，并修改该文件以适应自己的应用。如果要了解所有相关属性，请参考MenuBase类的标准文档。

l         在JSP页面中添加标记库的声明

<%@ taglib uri="http://struts-menu.sf.net/tag" prefix="menu" %>

l         在JSP页面中添加标记库代码以生成菜单

<menu:useMenuDisplayer name="TabbedMenu"

bundle="org.apache.struts.action.MESSAGE">

  <menu:displayMenu name="Home"/>

  <menu:displayMenu name="About"/>

</menu:useMenuDisplayer>

其中，name="TabbedMenu"是在menu-config.xml文件中定义的。如下：

<Displayer name="TabbedMenu" type="net.sf.navigator.displayer.TabbedMenuDisplayer"/>

要使用可定制的Velocity模板生成菜单，需要将Velocity集成到web应用中。具体步骤如下：

l         确保menu-config.xml文件有如下定义：

   <Displayer name="Velocity" type="net.sf.navigator.displayer.VelocityMenuDisplayer"/>

l         将Velocity的相关jar文件拷贝到WEB-INF/lib目录下

l         将globalMacros.vm文件添加到WEB-INF/classes目录下

l         在JSP页面中，修改为name="Velocity"，并将config属性指到一个文件（如config="/templates/tabs.html"），如果文件在WEB-INF/classes目录下，就是config="tabs.html"。

3.       FAQ

 

3.1.        在使用菜单访问JSP时抛出异常：

org.apache.jasper.JasperException: Could not obtain the menu repository

解决方法：

检查struts-config.xml文件，确保添加如下plug-in设置

<plug-in className="net.sf.navigator.menu.MenuPlugIn">

  <set-property property="menuConfig" value="/WEB-INF/menu-config.xml"/>

</plug-in>

<!-- The menuConfig property is an optional attribute. It is set to /WEB-INF/menu-config.xml by default. -->

3.2.        如何基于角色隐藏/显示菜单项

先在JSP页面中添加属性permissions="rolesAdapter"到<menu:useMenuDisplayer>标记中；然后在menu-config.xml文件中加入允许看到此菜单项的角色列表，角色之间以逗号分隔。

3.3.        基于数据库的动态菜单

Action 类:
• Struts1要求Action类继承一个抽象基类。Struts1的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action类可以实现一个Action接口，也可实现其他接口，使可选和定制的服务成为可能。Struts2提供一个ActionSupport基类去实现 常用的接口。Action接口不是必须的，任何有execute标识的POJO对象都可以用作Struts2的Action对象。
线程模式:
• Struts1 Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的。
• Struts2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）

Servlet 依赖:
• Struts1 Action 依赖于Servlet API ,因为当一个Action被调用时HttpServletRequest 和 HttpServletResponse 被传递给execute方法。
• Struts 2 Action不依赖于容器，允许Action脱离容器单独被测试。如果需要，Struts2 Action仍然可以访问初始的request和response。但是，其他的元素减少或者消除了直接访问HttpServetRequest 和 HttpServletResponse的必要性。

可测性:
• 测试Struts1 Action的一个主要问题是execute方法暴露了servlet API（这使得测试要依赖于容器）。一个第三方扩展－－Struts TestCase－－提供了一套Struts1的模拟对象（来进行测试）。
• Struts 2 Action可以通过初始化、设置属性、调用方法来测试，“依赖注入”支持也使测试更容易。

捕获输入:
• Struts1 使用ActionForm对象捕获输入。所有的ActionForm必须继承一个基类。因为其他JavaBean不能用作ActionForm，开发者经常创建多余的类捕获输入。动态Bean（DynaBeans）可以作为创建传统ActionForm的选择，但是，开发者可能是在重新描述(创建)已经存在的JavaBean（仍然会导致有冗余的javabean）。
• Struts 2直接使用Action属性作为输入属性，消除了对第二个输入对象的需求。输入属性可能是有自己(子)属性的rich对象类型。Action属性能够通过web页面上的taglibs访问。Struts2也支持ActionForm模式。rich对象类型，包括业务对象，能够用作输入/输出对象。这种ModelDriven 特性简化了taglib对POJO输入对象的引用。

表达式语言：
• Struts1 整合了JSTL，因此使用JSTL EL。这种EL有基本对象图遍历，但是对集合和索引属性的支持很弱。
• Struts2可以使用JSTL，但是也支持一个更强大和灵活的表达式语言－－"Object Graph Notation Language" (OGNL).

绑定值到页面（view）:
• Struts 1使用标准JSP机制把对象绑定到页面中来访问。
• Struts 2 使用 "ValueStack"技术，使taglib能够访问值而不需要把你的页面（view）和对象绑定起来。ValueStack策略允许通过一系列名称相同但类型不同的属性重用页面（view）。
　
类型转换：
• Struts 1 ActionForm 属性通常都是String类型。Struts1使用Commons-Beanutils进行类型转换。每个类一个转换器，对每一个实例来说是不可配置的。
• Struts2 使用OGNL进行类型转换。提供基本和常用对象的转换器。

校验：
• Struts 1支持在ActionForm的validate方法中手动校验，或者通过Commons Validator的扩展来校验。同一个类可以有不同的校验内容，但不能校验子对象。
• Struts2支持通过validate方法和XWork校验框架来进行校验。XWork校验框架使用为属性类类型定义的校验和内容校验，来支持chain校验子属性

Action执行的控制：
• Struts1支持每一个模块有单独的Request Processors（生命周期），但是模块中的所有Action必须共享相同的生命周期。
• Struts2支持通过拦截器堆栈（Interceptor Stacks）为每一个Action创建不同的生命周期。堆栈能够根据需要和不同的Action一起使用。

本文引用地址：http://cnpoint.com/web/2006/1023/content_4392.htm

其实，Struts 1.x在此部分已经做得相当不错了。它极大地简化了我们程序员在做国际化时所需的工作，例如，如果您要输出一条国际化的信息，只需在代码包中加入FILE-NAME_xx_XX.properties（其中FILE-NAME为默认资源文件的文件名），然后在struts-config.xml中指明其路径，再在页面用<bean:message>标志输出即可。

不过，所谓“没有最好，只有更好”。Struts 2.0并没有在这部分止步，而是在原有的简单易用的基础上，将其做得更灵活、更强大。

国际化Hello World

下面让我们看一个例子——HelloWorld。这个例子演示如何根据用户浏览器的设置输出相应的HelloWorld。

1. 在Eclipse创建工程配置开发和运行环境（如果对这个步骤有问题，可以参考我早前的文章《为Struts 2.0做好准备》）。
   
2. 在src文件夹中加入struts.properties文件，内容如下：
   
   struts.custom.i18n.resources=globalMessages

   Struts 2.0有两个配置文件，struts.xml和struts.properties都是放在WEB-INF/classes/下。 struts.xml用于应用程序相关的配置 struts.properties用于Struts 2.0的运行时（Runtime）的配置

3. 在src文件夹中加入globalMessages_en_US.properties文件，内容如下：
   
   HelloWorld=Hello World!
4. 在src文件夹中加入globalMessages_zh_CN.properties文件，内容如下：
   
   HelloWorld=你好，世界！

   在此想和大家分享一个不错的编写properties文件的Eclipse插件（plugin），有了它我们在编辑一些简体中文、繁体中文等Unicode文本时，就不必再使用native2ascii编码了。您可以通过Eclipse中的软件升级（Software Update）安装此插件，步骤如下： 1、展开Eclipse的Help菜单，将鼠标移到Software Update子项，在出现的子菜单中点击Find and Install； 2、在Install/Update对话框中选择Search for new features to install，点击Next； 3、在Install对话框中点击New Remote Site； 4、在New Update Site对话框的Name填入“PropEdit”或其它任意非空字符串，在URL中填入http://propedit.sourceforge.jp/eclipse/updates/； 5、在Site to include to search列表中，除上一步加入的site外的其它选项去掉，点击Finsih； 6、在弹出的Updates对话框中的Select the features to install列表中将所有结尾为“3.1.x”的选项去掉（适用于Eclipse 3.2版本的朋友）； 7、点击Finish关闭对话框； 8、在下载后，同意安装，再按提示重启Eclipse，在工具条看到形似vi的按钮表示安装成功，插件可用。此时，Eclpise中所有properties文件的文件名前有绿色的P的图标作为标识。

5. 在WebContent文件夹下加入HelloWorl.jsp文件，内容如下：
   
   <%@ page  contentType="text/html; charset=UTF-8"%>
   <%@taglib prefix="s" uri="/struts-tags"%>
   <html>
   <head>
       <title>Hello World</title>
   </head>
   <body>
       <h2><s:text name="HelloWorld"/></h2>
       <h2><s:property value="%{getText('HelloWorld')}"/></h2>
   </body>
   </html>
6. 发布运行应用程序，在浏览器地址栏中输入http://localhost:8080/Struts2_i18n/HelloWorld.jsp ，出现图1所示页面。
   
   图1 中文输出
7. 将浏览器的默认语言改为“英语（美国）”，刷新页面，出现图2所示页面。
   
   图2 英文输出

资源文件查找顺序

之所以说Struts 2.0的国际化更灵活是因为它可以能根据不同需要配置和获取资源（properties）文件。在Struts 2.0中有下面几种方法：

1. 使用全局的资源文件，方法如上例所示。这适用于遍布于整个应用程序的国际化字符串，它们在不同的包（package）中被引用，如一些比较共用的出错提示；
2. 使用包范围内的资源文件。做法是在包的根目录下新建名的package.properties和package_xx_XX.properties文件。这就适用于在包中不同类访问的资源；
3. 使用Action范围的资源文件。做法为Action的包下新建文件名（除文件扩展名外）与Action类名同样的资源文件。它只能在该Action中访问。如此一来，我们就可以在不同的Action里使用相同的properties名表示不同的值。例如，在ActonOne中title为“动作一”，而同样用title在ActionTwo表示“动作二”，节省一些命名工夫；
4. 使用<s:i18n>标志访问特定路径的properties文件。使用方法请参考我早前的文章《常用的Struts 2.0的标志（Tag）介绍》。在您使用这一方法时，请注意<s:i18n>标志的范围。在<s:i18n name="xxxxx">到</s:i18n>之间，所有的国际化字符串都会在名为xxxxx资源文件查找，如果找不到，Struts 2.0就会输出默认值（国际化字符串的名字）。

上面我列举了四种配置和访问资源的方法，它们的范围分别是从大到小，而Struts 2.0在查找国际化字符串所遵循的是特定的顺序，如图3所示：

假设我们在某个ChildAction中调用了getText("user.title")，Struts 2.0的将会执行以下的操作：

1. 查找ChildAction_xx_XX.properties文件或ChildAction.properties；
2. 查找ChildAction实现的接口，查找与接口同名的资源文件MyInterface.properties；
3. 查找ChildAction的父类ParentAction的properties文件，文件名为ParentAction.properties；
4. 判断当前ChildAction是否实现接口ModelDriven。如果是，调用getModel()获得对象，查找与其同名的资源文件；
5. 查找当前包下的package.properties文件；
6. 查找当前包的父包，直到最顶层包；
7. 在值栈（Value Stack）中，查找名为user的属性，转到user类型同名的资源文件，查找键为title的资源;
8. 查找在struts.properties配置的默认的资源文件，参考例1;
9. 输出user.title。

参数化国际化字符串

许多情况下，我们都需要在动行时（runtime）为国际化字符插入一些参数，例如在输入验证提示信息的时候。在Struts 2.0中，我们通过以下两种方法做到这点：

1. 在资源文件的国际化字符串中使用OGNL，格式为${表达式}，例如：
   
   validation.require=${getText(fileName)} is required
2. 使用java.text.MessageFormat中的字符串格式，格式为{ 参数序号（从0开始）, 格式类形（number | date | time | choice）, 格式样式}，例如：
   
   validation.between=Date must between {0, date, short} and {1, date, short}

1. 使用标志的value0、value1...valueN的属性，如：
   
   <s:text name="validation.required" value0="User Name"/>
2. 使用param子元素，这些param将按先后顺序，代入到国际化字符串的参数中，例如：
   
   <s:text name="validation.required">
      <s:param value="User Name"/>
   </s:text>

让用户方便地选择语言

开发国际化的应用程序时，有一个功能是必不可少的——让用户快捷地选择或切换语言。在Struts 2.0中，通过ActionContext.getContext().setLocale(Locale arg)可以设置用户的默认语言。不过，由于这是一个比较普遍的应用场景（Scenario），所以Struts 2.0为您提供了一个名i18n的拦截器（Interceptor），并在默认情况下将其注册到拦截器链（Interceptor chain）中。它的原理为在执行Action方法前，i18n拦截器查找请求中的一个名为"request_locale"的参数。如果其存在，拦截器就将其作为参数实例化Locale对象，并将其设为用户默认的区域（Locale），最后，将此Locale对象保存在session的名为“WW_TRANS_I18N_LOCALE”的属性中。

下面，我将提供一完整示例演示它的使用方法。

package tutorial;

import java.util.Hashtable;
import java.util.Locale;
import java.util.Map;

publicclass Locales {
   public Map<String, Locale> getLocales() {
       Map<String, Locale> locales =new Hashtable<String, Locale>(2);
       locales.put("American English", Locale.US);
       locales.put("Simplified Chinese", Locale.CHINA);
       return locales;
   }
}

上述代码的原理为，LangSelector.jsp先实例化一个Locales对象，并把对象的Map类型的属性locales赋予下拉列表（select） 。如此一来，下拉列表就获得可用语言的列表。大家看到LangSelector有<s:form>标志和一段Javascript脚本，它们的作用就是在用户在下拉列表中选择了后，提交包含“reqeust_locale”变量的表单到Action。在打开页面时，为了下拉列表的选中的当前区域，我们需要到session取得当前区域（键为“WW_TRANS_I18N_LOCALE”的属性），而该属性在没有设置语言前是为空的，所以通过值栈中locale属性来取得当前区域（用户浏览器所设置的语言）。

可能大家会问为什么一定要通过Action来访问页面呢？ 你可以试一下不用Action而直接用JSP的地址来访问页面，结果会是无论你在下拉列表中选择什么，语言都不会改变。这表示不能正常运行的。其原因为如果直接使用JSP访问页面，Struts 2.0在web.xml的配置的过滤器（Filter）就不会工作，所以拦截器链也不会工作。

言归正传，Interceptor（以下译为拦截器）是Struts 2的一个强有力的工具，有许多功能（feature）都是构建于它之上，如国际化、转换器，校验等。

什么是拦截器

拦截器，在AOP（Aspect-Oriented Programming）中用于在某个方法或字段被访问之前，进行拦截然后在之前或之后加入某些操作。拦截是AOP的一种实现策略。

在Webwork的中文文档的解释为——拦截器是动态拦截Action调用的对象。它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码，也可以在一个action执行前阻止其执行。同时也是提供了一种可以提取action中可重用的部分的方式。

谈到拦截器，还有一个词大家应该知道——拦截器链（Interceptor Chain，在Struts 2中称为拦截器栈Interceptor Stack）。拦截器链就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。

实现原理

Struts 2的拦截器实现相对简单。当请求到达Struts 2的ServletDispatcher时，Struts 2会查找配置文件，并根据其配置实例化相对的拦截器对象，然后串成一个列表（list），最后一个一个地调用列表中的拦截器，如图1所示。

图１　拦截器调用序列图

已有的拦截器

Struts 2已经为您提供丰富多样的，功能齐全的拦截器实现。大家可以到struts2-all-2.0.1.jar或struts2-core-2.0.1.jar包的struts-default.xml查看关于默认的拦截器与拦截器链的配置。

在本文使用是Struts 2的最新发布版本2.0.1。需要下载的朋友请点击以下链接： http://apache.justdn.org/struts/binaries/struts-2.0.1-all.zip

以下部分就是从struts-default.xml文件摘取的内容：