使用 Spring，JSF，EJB3 设计企业应用程序

在本文中，作者使用 Eclipse 开发了一个简单的应用，演示了使用 Spring 集成 Java EE 5 核心框架 - EJB 3.0 和 JSF 1.2 的过程。您将看到，Spring 使得访问和实现 EJB 更加方便。

Java EE 5.0 的核心框架是 EJB(Enterprise JavaBeans)3.0 和 JSF(JavaServerFaces)1.2 。 EJB 3.0 是一个基于 POJO(Plain Old Java Objects) 的服务端业务服务和数据库持久化的组件模型。 JSF 是一个基于 MVC(Model-View-Controller) 的 Web 应用框架。大多数的应用都将包含有业务逻辑的 EJB3 组件和用于 Web 应用前端显示的 JSF 组件。从表面上看，EJB3 和 JSF 互补，但是他们是根据各自的理念设计的独立的框架，这二者都无法独自解决所有的计算问题。例如，EJB3 使用注解（annotation）来配置服务，而 JSF 使用的是 XML 文件。 EJB3 和 JSF 组件在框架层面上是互不敏感，最好结合使用。但是 Java EE 5 规范并没有提供如何整合这两个组件模型的标准方法。要整合 EJB3 和 JSF，开发者必须手动地将业务组件(EJB) 与 Web 组件(JSF) 联结起来，以便能跨框架调用方法。

Spring 作为一个轻量级的容器，常被认为是 EJB 的替代品，对于很多应用情况，采用 Spring 作为容器，并借助它对事务和 ORM 等的支持，是一种比采用 EJB 容器以实现同样功能的另一个选择。但也不是使用了 Spring 就不能使用 EJB 了。实际上，Spring 使得访问和实现 EJB 更加方便。 Spring 分别提供了集成 JSF 和 EJB 的方法。本文将使用 Eclipse 开发一个示例来演示这个过程。

本文的示例实现了对产品信息的增删改查等基本操作。只用到了一个域模型：Product，下面是它的 UML 图：

本文的开发平台采用的是 Windows Vista 操作系统，因此以下的环境设置都是针 WindowsVista 操作系统的。

• 从 Java 站点 下载最新的 JDK，并安装至任意目录下。本文采用的是 jdk1.6.0_01 。
• 从 Eclipse 站点 下载 Eclipse for Java EE Developers 3.4 或更新版本，解压至任意目录。本文采用的是 eclipse3.4.1 。
• 从 JBoss 站点 下载 Jboss Application Server 4.2 或更新版本，解压至任意目录。本文采用的是 jboss-4.2.2.GA 。
• 从 Spring 站点 下载 Spring Framework 2.5 或更新版本，解压至任意目录。本文采用的是 spring-framework-2.5.4 。

1. 设置 JRE，这一步在 JBoss 运行时需要。依次打开 Windows > Preferences > Java > Installed JRES，确保选中的 JRE 的 Locaton 为 JDK 的安装目录。本文 JDK 安装目录为 C:/soft/Java/jdk1.6.0_01 。
   
   
   
2. 设置 Server Runtime Environments，这一步配置应用程序的运行环境。依次打开 Windows > Preferences > Server > Runtime Environments，点击 Add 按钮，选择 JBoss > JBoss v4.2，点击 Next 。 JRE 选择第一步中设置的 JRE，本文中为 jdk1.6.0_01，Application Server Directory 选择 [Jboss 安装目录 ]/ server/default 。点击完成按钮。如下图：
   
   
   
3. 新建名称为 simple 的 EAR Application Project，这个工程包括 3 个工程，分别是 JPA Project、EJB Project、WEB Project，以下步骤将分别介绍这三个工程。 Target Runtime 为 JBoss v4.2，EAR version 为 5.0，Configuration 为 Default Configuration for JBoss v4.2 。如下图：
   
   
   
   
   

   点击 Next 选择 Generate Deployment Descriptor，点击完成。

1. 新建名称为 simpleJPA 的 JPA 工程，Configuration 为 Default Configuration for JBoss v4.2，选中 Add project to anEAR，如下图：
   
   
   
   
   

   点击 Next，选择默认，点击完成。

2. 编辑 JPA persistence.xml 文件，内容如下：
   
   
   
   Java代码

   1.                            
   2. <?xml version="1.0" encoding="UTF-8"?>   
   3. <persistence version="1.0"  
   4.   xmlns="http://java.sun.com/xml/ns/persistence"    
   5.   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
   6.   xsi:schemaLocation="http://java.sun.com/xml/ns/persistence    
   7.   http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">   
   8.   <persistence-unit name="simpleJPA">   
   9.     <!-- 使用JBoss默认的数据源 -->   
   10.     <jta-data-source>java:/DefaultDS</jta-data-source>   
   11.     <properties>   
   12.       <!-- 使用Hibernate的hbm2ddl工具在启动时生成表结构 -->   
   13.       <property name="hibernate.hbm2ddl.auto" value="update"/>   
   14.       <!-- 显示最终执行的SQL -->   
   15.       <property name="hibernate.show_sql" value="true" />   
   16.       <!-- 格式化显示的SQL -->   
   17.       <property name="hibernate.format_sql" value="true" />   
   18.     </properties>   
   19.   </persistence-unit>   
   20. </persistence>  

   						
   <?xml version="1.0" encoding="UTF-8"?>
   <persistence version="1.0"
     xmlns="http://java.sun.com/xml/ns/persistence" 
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
     http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
     <persistence-unit name="simpleJPA">
       <!-- 使用JBoss默认的数据源 -->
       <jta-data-source>java:/DefaultDS</jta-data-source>
       <properties>
         <!-- 使用Hibernate的hbm2ddl工具在启动时生成表结构 -->
         <property name="hibernate.hbm2ddl.auto" value="update"/>
         <!-- 显示最终执行的SQL -->
         <property name="hibernate.show_sql" value="true" />
         <!-- 格式化显示的SQL -->
         <property name="hibernate.format_sql" value="true" />
       </properties>
     </persistence-unit>
   </persistence>
   

    
   

   persistence-unit 节点可以有一个或多个，每个 persistence-unit 节点定义了持久化内容名称、使用的数据源及持久化产品专有属性。 name 属性定义了 persistence-unit 的名称，该属性是必需的，本例设置的名称为“ simpleJPA ”。

   在 JavaEE 环境中的默认的事务是 JTA，而在 JavaSE 环境中则为 RESOURCE_LOCAL 。使用 <jta-data-source> 指定数据源的 JNDI 名称。 Jboss 数据源的 JNDI 名称在局部命名空间，因此数据源名称前必须带有 java:/ 前缀，数据源名称大小写敏感。在本文中采用 JBoss 容器中默认的数据源，JNDI 为 java:/DefaultDS，详情请查看：[Jboss 安装目录]/server/default/deployhsqldb-ds.xml。

   <properties> 指定持久化产品的专有属性，各个应用服务器使用的持久化产品都不一样，如 Jboss 使用 Hibernate，weblogic 使用 Kodo（实际上是基于 OpenJPA 的封装），glassfish/sun application server/Oralce 使用 Toplink 。对于 Hibernate 而言，它的 hibernate.hbm2ddl.auto 属性指定实体 Bean 发布时是否同步数据库结构， 如果 hibernate.hbm2ddl.auto 的值设为 create-drop，实体 Bean 发布及卸载时将自动创建及删除相应数据库表（注意：Jboss 服务器启动或关闭时也会引发实体 Bean 的发布及卸载）。 TopLink 产品的 toplink.ddl-generation 属性也起到同样的作用。关于 Hibernate 的可用属性及默认值您可以在 [Jboss 安装目录]/server/default/deploy/ejb3.deployer/META-INF/persistence.properties 文件中找到。在开发阶段，Hibernate 的 hibernate.show_sql 和 hibernate.format_sql 属性特别有用，它们可以格式化显示 Hibernate 执行的 SQL 语句。

3. 新建名称为 org.zhouxing.simple.Product 的 Entity class, 根据示例介绍小节中的 UML 类图添加 Entity Fields，如下图：

   
   
   
   
   
   

   id 为主键，在 EJB3.0 中，每个实体 Bean 必须具有一个主键，主键可以是基本类型，也可以是一个类。主键既作为实体 Bean 在内存中的标识符，也作为数据表中一行的标识符。它在实体 Bean 中是不可缺少的，并且必须是唯一的

   表名为 product。实体 Bean 的成员属性分别映射到 product 表的对应字段。

4. 修改主键的生成方式为自增，给主键添加如下代码：
   Java代码

   1. @GeneratedValue(strategy = GenerationType.AUTO)  

   @GeneratedValue(strategy = GenerationType.AUTO)
   

    
   

   @javax.persistence.GeneratedValue 注释指定主键值生成方式，该注释与 @Id 注释结合使用在主键属性上。只有在使用持久化驱动生成数据表 schema 时才需指定该注释。如果您的数据表已经存在，那么该注释不需要指定。 strategy() 属性指定字段值生成策略。 GenerationType.AUTO：由容器根据数据库类型选择一种合适的生成方式，这种方式带有随机性，不同的 JPA 实现产品的做法各有不同 (JBoss 将 JPA 实现为 Hibernate)，对于本文而言，Hibernate 知道 HSQL 支持 ID 自增长，所以会选择 GenerationType.IDENTITY。

   
   
   
   
   Java代码

   1. package org.zhouxing.simple;    
   2.   
   3. import java.io.Serializable;    
   4.   
   5. import javax.persistence.Entity;    
   6. import javax.persistence.GeneratedValue;    
   7. import javax.persistence.GenerationType;    
   8. import javax.persistence.Id;    
   9. import javax.persistence.Table;    
   10.   
   11. /**   
   12. Entity implementation class for Entity: Product   
   13. */    
   14. @Entity    
   15. @Table(name = "product")    
   16. public class Product implements Serializable {    
   17.   
   18.     @Id    
   19.     @GeneratedValue(strategy = GenerationType.AUTO)    
   20.     private long id;    
   21.     private String name;    
   22.     private String description;    
   23.     private Double price;    
   24.     private Integer inventory;    
   25.   
   26.     public Product() {    
   27.         super();    
   28.     }    
   29.     ...setters，getters 方法省略   
   30. }  

   package org.zhouxing.simple; 
   
   import java.io.Serializable; 
   
   import javax.persistence.Entity; 
   import javax.persistence.GeneratedValue; 
   import javax.persistence.GenerationType; 
   import javax.persistence.Id; 
   import javax.persistence.Table; 
   
   /** 
   Entity implementation class for Entity: Product 
   */ 
   @Entity 
   @Table(name = "product") 
   public class Product implements Serializable { 
   
       @Id 
       @GeneratedValue(strategy = GenerationType.AUTO) 
       private long id; 
       private String name; 
       private String description; 
       private Double price; 
       private Integer inventory; 
   
       public Product() { 
           super(); 
       } 
       ...setters，getters 方法省略
   }

    
   

   @javax.persistence.Entity 注释指明这是一个实体 Bean，name() 属性指定实体 bean 的名称，在本文中没有为该属性提供取值，默认值为 bean class 的非限定类名。 @javax.persistence.Table 注释指定了实体 Bean 所要映射的表，name() 属性指定映射表的名称。如果缺省 @Table 注释，系统默认采用实体名称作为映射表的名称。在本文中采用的表名为product 。

至此 JPA Project 完成，接下来是 EJB Project 。

1. 新建名称为 simpleEJB 的 EJB 工程，EJB Module version 为 3.0，Configuration 为 Default Configuration for JBoss v4.2，选中 Add project to anEAR，如下图：
   
   
   
   
   

   点击 Next，取消选择 Create an EJB Clicent JAR，点击完成。

2. 新建名称为 org.zhouxing.simple. ProductDAOBean 的 Session Bean，如下图：
   
   
   
   
   

   选择生成 Local 和 Remote 接口。

3. 同时实现 Remote 与 Local 接口是一种比较好的做法。这样您既可以在远程访问 EJB，也可以在本地访问 EJB 。在本地接口中写出业务方法，远程接口继承本地接口的所有方法。代码如下：
   
   
   
   Java代码

   1.                            
   2. 本地接口：   
   3. package org.zhouxing.simple;    
   4. import java.util.List;    
   5.   
   6. /**   
   7. 本地接口  
   8. *   
   9. @author 周行  
   10. */    
   11. public interface ProductDAOLocal {    
   12.     /**   
   13.     查询所有的 Product   
   14.     @return   
   15.     */    
   16.     public List<Product> findAll();    
   17.     /**   
   18.     添加 Product   
   19.     @param product   
   20.     */    
   21.     public void add(Product product);    
   22. }    
   23.   
   24.   
   25. 远程接口：   
   26. package org.zhouxing.simple;    
   27.   
   28. /**   
   29. 远程接口  
   30. @author 周行  
   31. */    
   32.   
   33. public interface ProductDAORemote extends ProductDAOLocal{    
   34.   
   35. }    
   36.   
   37.   
   38.   
   39. 无状态会话 BEAN    
   40. package org.zhouxing.simple;    
   41.   
   42. import java.util.List;    
   43.   
   44. import javax.ejb.Local;    
   45. import javax.ejb.Remote;    
   46. import javax.ejb.Stateless;    
   47. import javax.persistence.EntityManager;    
   48. import javax.persistence.PersistenceContext;    
   49. import javax.persistence.Query;    
   50.   
   51. /**   
   52. 无状态会话 BEAN   
   53. *   
   54. @author 周行  
   55. */    
   56. @Stateless    
   57. @Remote(ProductDAORemote.class)    
   58. @Local(ProductDAOLocal.class)    
   59. public class ProductDAOBean implements ProductDAORemote,    
   60.     ProductDAOLocal {    
   61.     /**   
   62.     注入 EntityManager   
   63.     */    
   64.     @PersistenceContext(unitName = "simpleJPA")    
   65.     protected EntityManager em;    
   66.   
   67.     /**   
   68.     Default constructor.   
   69.     */    
   70.     public ProductDAOBean() {    
   71.        
   72.     }    
   73.   
   74.     @Override    
   75.     public void add(Product product) {    
   76.         em.persist(product);    
   77.     }    
   78.   
   79.     @SuppressWarnings("unchecked")    
   80.     @Override    
   81.     public List<Product> findAll() {    
   82.         Query query = em.createQuery("select o from Product o");    
   83.         return query.getResultList();    
   84.     }    
   85.   
   86. }  

   						
   本地接口：
   package org.zhouxing.simple; 
   import java.util.List; 
   
   /** 
   本地接口
   * 
   @author 周行
   */ 
   public interface ProductDAOLocal { 
       /** 
       查询所有的 Product 
       @return 
       */ 
       public List<Product> findAll(); 
       /** 
       添加 Product 
       @param product 
       */ 
       public void add(Product product); 
   } 
   
   
   远程接口：
   package org.zhouxing.simple; 
   
   /** 
   远程接口
   @author 周行
   */ 
   
   public interface ProductDAORemote extends ProductDAOLocal{ 
   
   } 
   
   
   
   无状态会话 BEAN 
   package org.zhouxing.simple; 
   
   import java.util.List; 
   
   import javax.ejb.Local; 
   import javax.ejb.Remote; 
   import javax.ejb.Stateless; 
   import javax.persistence.EntityManager; 
   import javax.persistence.PersistenceContext; 
   import javax.persistence.Query; 
   
   /** 
   无状态会话 BEAN 
   * 
   @author 周行
   */ 
   @Stateless 
   @Remote(ProductDAORemote.class) 
   @Local(ProductDAOLocal.class) 
   public class ProductDAOBean implements ProductDAORemote, 
       ProductDAOLocal { 
       /** 
       注入 EntityManager 
       */ 
       @PersistenceContext(unitName = "simpleJPA") 
       protected EntityManager em; 
   
       /** 
       Default constructor. 
       */ 
       public ProductDAOBean() { 
       
       } 
   
       @Override 
       public void add(Product product) { 
           em.persist(product); 
       } 
   
       @SuppressWarnings("unchecked") 
       @Override 
       public List<Product> findAll() { 
           Query query = em.createQuery("select o from Product o"); 
           return query.getResultList(); 
       } 
   
   }
   

    
   

   @Stateless 注释指明这是一个无状态会话 Bean，@Remote 注释指定这个无状态 Bean 的 remote 接口。 Bean 类可以具有多个 remote 接口，每个接口之间用逗号分隔，如：@Remote ({ProductDAORemote.class,ProductDAORemote2.class,ProductDAORemote3.class}) 。如果您只有一个接口，您可以省略大括号，对于本文而言，可以写成这样：@Remote (ProductDAORemote.class) 。 @Local 注释指定这个无状态 Bean 的 local 接口，和 @Remote 注释一样，@Local 注释也可以定义多个本地接口。

   当 @Local 和 @Remote 注释都不存在时，容器会将 Bean class 实现的接口默认为 Local 接口。如果 EJB 与客户端部署在同一个应用服务器，采用 Local 接口访问 EJB 优于 Remote 接口。因为通过 Remote 接口访问 EJB 需要在 TCP/IP 协议基础上转换和解释 Corba IIOP 协议消息，在调用 EJB 的这一过程中存在对象序列化、协议解释、TCP/IP 通信等开销。而通过 Local 接口访问 EJB 是在内存中与 Bean 彼此交互的，没有了分布式对象协议的开销，大大提高了性能。

   @PersistenceContext 注释动态注入 EntityManager 对象。在 EJB 的 JNDI ENC 中注册一个指向该资源的引用。 EntityManager 是由 EJB 容器自动管理和配置的，这包括 EntityManager 的创

   建及清理工作。所以我们不需要调用它的 close() 方法释放资源， 如果您试图这样做， 反而会得到 IllegalStateException 例外。借助 EntityManager，我们可以创建、更新、删除及查询实体 bean 。 EntityManager 负责将固定数量的一组类映射到数据库中，这组类被称作持久化单元 (persistence unit) 。 persistence unit 是在 persistence.xml 中定义的。根据持久化规范的要求，该部署描述文件是必须提供的，如果不提供这一文件，则持久化单元也将不存在，因此应用也不能够获得和使用 EntityManager 。本文的持久化单元为simpleJPA 。

至此 EJB Project 开发完毕，接下来是 WEB Project 。

WEB Project 是本文的重点，在这小节中我们将用 JSF 通过 Spring 来调用 EJB，体验 Spring 的便利。

1. 新建名称为 simpleWEB 的 Dynamic WEB Project，Dynamic WEB Project version 为 2.5，Configuration 为 JavaServer Faces v1.1 Project，选中 Add project to anEAR，如下图：
   
   
   
   
   

   点击 Next，默认下一步，JSF Libraries 选择 Server Supplied JSF Implementation，修改 URL Mapping Patterns 为 *.jsf，如下图：

   
   
   
   
   
   

   所有以 *.jsf 结尾的请求都有 JSF 处理。

2. 配置 WEB Project 。

   拷贝 SPRING_HOME/dist/spring.jar 到 WebContent/WEB-INF/lib 目录。在 WebContent/WEB-INF 下新建 spring 配置文件 applicationContext.xml 。

   一个 Spring 为框架的 Web 项目，通常以 web.xml 为入口，在 Web 应用启动时，读入 context-param 中批量的配置文件，初始化配置文件里所定义的 Bean，通过ContextLoaderListener在 web 应用程序的 servlet context 建立后立即执行建立 Spring 的ApplicationContext。

3. 编辑 web.xml

   添加 ContextParam：

   Java代码

   1. <context-param>    
   2.     <param-name>contextConfigLocation</param-name>    
   3.     <param-value>/WEB-INF/applicationContext.xml</param-value>    
   4. </context-param>    
   5.    

   <context-param> 
       <param-name>contextConfigLocation</param-name> 
       <param-value>/WEB-INF/applicationContext.xml</param-value> 
   </context-param> 
    
   

    
   

   添加 Spring listener：

   Java代码

   1. <listener>    
   2.     <listener-class>    
   3.     org.springframework.web.context.ContextLoaderListener    
   4.     </listener-class>    
   5. </listener>  

   <listener> 
       <listener-class> 
       org.springframework.web.context.ContextLoaderListener 
       </listener-class> 
   </listener>
   

    

4. 编辑 applicationContext.xml，内容如下：

   
   
   
   
   Java代码

   1.                        
   2. <?xml version="1.0" encoding="UTF-8"?>    
   3. <beans xmlns="http://www.springframework.org/schema/beans"    
   4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    
   5. xmlns:jee="http://www.springframework.org/schema/jee"         
   6. xsi:schemaLocation="http://www.springframework.org/schema/beans    
   7. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd    
   8. http://www.springframework.org/schema/jee    
   9. http://www.springframework.org/schema/jee/spring-jee-2.5.xsd">    
   10.   
   11. <jee:jndi-lookup id="productDAO" jndi-name="simple/ProductDAOBean/remote"      
   12. proxy-interface="org.zhouxing.simple.ProductDAORemote" />    
   13. </beans>   

   						
    <?xml version="1.0" encoding="UTF-8"?> 
    <beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:jee="http://www.springframework.org/schema/jee"      
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd 
    http://www.springframework.org/schema/jee 
    http://www.springframework.org/schema/jee/spring-jee-2.5.xsd"> 
   
    <jee:jndi-lookup id="productDAO" jndi-name="simple/ProductDAOBean/remote"   
    proxy-interface="org.zhouxing.simple.ProductDAORemote" /> 
    </beans> 
   

    
   

   Spring 通过 jndi-lookup 来访问 EJB，以后就可以在本地 EJB 组件，远程 EJB 或者 POJO 这些变体之间透明地切换实现方式，而不需要改变客户端的代码。

   新建名称为 org.zhouxing.simple.ProductBean 的一个类作为 JSF 的 managed Bean 。 JSF 使用 JavaBean 来达到程序逻辑与视图分离的目的，在 JSF 中的 Bean 其角色是属于 Backing Bean，又称之为 Glue Bean，其作用是在真正的业务逻辑 Bean 及 UI 组件之间搭起桥梁，在 Backing Bean 中会呼叫业务逻辑 Bean 处理使用者的请求，或者是将业务处理结果放置其中，等待 UI 组件取出当中的值并显示结果给使用者。

   主要有两个方法实现业务功能，代码如下：

   
   
   
   
   Java代码

   1.                            
   2. package org.zhouxing.simple;    
   3.   
   4. import java.util.List;   
   5.   
   6. /**   
   7. JSF Managed Bean 实现 Product 的查询，添加  
   8. @author 周行  
   9. *  
   10. */    
   11. public class ProductBean {    
   12.     private ProductDAORemote productDAO;    
   13.     private Product product;    
   14.   
   15.     public ProductBean() {    
   16.         product = new Product();    
   17.     }    
   18.   
   19.     public void setProductDAO(ProductDAORemote productDAO) {   
   20.         this.productDAO = productDAO;    
   21.     }   
   22.   
   23.     public String add() {    
   24.         productDAO.add(product);    
   25.         return "";    
   26.     }   
   27.   
   28.     public List<Product> getProducts() {    
   29.         return productDAO.findAll();    
   30.     }   
   31.   
   32.     public Product getProduct() {    
   33.         return product;    
   34.     }    
   35. }  

   						
   package org.zhouxing.simple; 
   
   import java.util.List;
   
   /** 
   JSF Managed Bean 实现 Product 的查询，添加
   @author 周行
   *
   */ 
   public class ProductBean { 
       private ProductDAORemote productDAO; 
       private Product product; 
   
       public ProductBean() { 
           product = new Product(); 
       } 
   
       public void setProductDAO(ProductDAORemote productDAO) {
           this.productDAO = productDAO; 
       }
   
       public String add() { 
           productDAO.add(product); 
           return ""; 
       }
   
       public List<Product> getProducts() { 
           return productDAO.findAll(); 
       }
   
       public Product getProduct() { 
           return product; 
       } 
   }
   

    
   

   属性 productDAO 通过 JSF 配置文件用 Spring 注入，属性 product 为简单起见作为表单 Form 。

   在 JSF 中使用 Spring 的注入功能需要在 JSF 配置文件中使用 Spring 的变量解析器 DelegatingVariableResolver 类。 DelegatingVariableResolver 类首先会查询请求委派到 JSF 实现的默认的解析器中，然后才是 Spring 的“ business context ”。代码片段如下：

   
   
   
   
   Java代码

   1. <application>    
   2.     <variable-resolver>    
   3.         org.springframework.web.jsf.DelegatingVariableResolver    
   4.     </variable-resolver>    
   5.     <locale-config>    
   6.         <default-locale>en</default-locale>    
   7.     </locale-config>    
   8. </application>  

    <application> 
        <variable-resolver> 
            org.springframework.web.jsf.DelegatingVariableResolver 
        </variable-resolver> 
        <locale-config> 
            <default-locale>en</default-locale> 
        </locale-config> 
    </application>

    

5. 在 JSF 配置文件中配置 Managed Bean，代码片段如下：

   
   
   
   
   Java代码

   1. <managed-bean>    
   2.     <managed-bean-name>productBean</managed-bean-name>    
   3.     <managed-bean-class>org.zhouxing.simple.ProductBean</managed-bean-class>    
   4.     <managed-bean-scope>session</managed-bean-scope>    
   5.     <managed-property>    
   6.         <property-name>productDAO</property-name>    
   7.         <value>#{productDAO}</value>    
   8.     </managed-property>    
   9. </managed-bean>   

   <managed-bean> 
       <managed-bean-name>productBean</managed-bean-name> 
       <managed-bean-class>org.zhouxing.simple.ProductBean</managed-bean-class> 
       <managed-bean-scope>session</managed-bean-scope> 
       <managed-property> 
           <property-name>productDAO</property-name> 
           <value>#{productDAO}</value> 
       </managed-property> 
   </managed-bean> 
   

    
   

   #{productDAO} 表达式将通过 Spring 注入。

   在 JSF 配置文件中配置 navigation Rule，请求转向 index.jsp 。代码片段如下：

   
   
   
   
   Java代码

   1. <navigation-rule>    
   2.     <navigation-case>    
   3.         <to-view-id>/index.jsp</to-view-id>    
   4.     </navigation-case>    
   5. </navigation-rule>  

   <navigation-rule> 
       <navigation-case> 
           <to-view-id>/index.jsp</to-view-id> 
       </navigation-case> 
   </navigation-rule>

    

6. 创建 index.jsp，页面显示表单和查询结果。代码片段如下：

   
   
   
   
   Java代码

   1. <f:view>   
   2.     <h:form>   
   3.         名称 <h:inputText value="#{productBean.product.name}"/><p>   
   4.         存货 <h:inputText value="#{productBean.product.inventory}"/><p>   
   5.         单价 <h:inputText value="#{productBean.product.price}"/><p>   
   6.         描述 <h:inputTextarea value="#{productBean.product.description}"/>   
   7.         <h:commandButton value=" 添加 " action="#{productBean.add}" />    
   8.     </h:form>    
   9.   
   10.     <h:dataTable var="entry" value="#{productBean.products}"    
   11.         rendered="true">   
   12.         <h:column>   
   13.             <h:outputLabel value="#{entry.name}"/>   
   14.         </h:column>   
   15.         <h:column>   
   16.             <h:outputLabel value="#{entry.inventory}"/>   
   17.         </h:column>   
   18.         <h:column>   
   19.             <h:outputLabel value="#{entry.price}"/>   
   20.         </h:column>   
   21.         <h:column>   
   22.             <h:outputLabel value="#{entry.description}"/>   
   23.         </h:column>   
   24.     </h:dataTable>   
   25. </f:view>  

   <f:view>
       <h:form>
           名称 <h:inputText value="#{productBean.product.name}"/><p>
           存货 <h:inputText value="#{productBean.product.inventory}"/><p>
           单价 <h:inputText value="#{productBean.product.price}"/><p>
           描述 <h:inputTextarea value="#{productBean.product.description}"/>
           <h:commandButton value=" 添加 " action="#{productBean.add}" /> 
       </h:form> 
   
       <h:dataTable var="entry" value="#{productBean.products}" 
           rendered="true">
           <h:column>
               <h:outputLabel value="#{entry.name}"/>
           </h:column>
           <h:column>
               <h:outputLabel value="#{entry.inventory}"/>
           </h:column>
           <h:column>
               <h:outputLabel value="#{entry.price}"/>
           </h:column>
           <h:column>
               <h:outputLabel value="#{entry.description}"/>
           </h:column>
       </h:dataTable>
   </f:view>

    
   

   JSF 组件必须在 <f:view> 之间，<h:form> 会产生一个表单， <h: inputText> 来显示 product 对象的各个属性，<h:commandButton> 会产生一个提交按钮，调用 productBean 的 add 方法处理。<h:dataTable> 调用 productBean 的 getProducts 方法迭代所有 product 的信息。

现在该看看 simple 的运行效果了。可以导出 EAR 文件拷贝到 [Jboss 安装目录 ]/server/default 下，也可以用 Eclipse 的运行工具，下面介绍借助 Eclipse 运行应用程序。确保您的 simple 工程下的 META-INF/application.xml 文件内容包含以上开发的 3 个工程，代码如下：

<?xml version="1.0" encoding="UTF-8"?> 
<application 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:application="http://java.sun.com/xml/ns/javaee/application_5.xsd" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/application_5.xsd" 
    id="Application_ID" version="5">
    <display-name>simple</display-name> 
    <module> 
        <web> 
            <web-uri>simpleWEB.war</web-uri> 
            <context-root>simpleWEB</context-root> 
        </web> 
    </module> 
    <module> 
        <ejb>simpleEJB.jar</ejb> 
    </module> 
    <module> 
        <ejb>simpleJPA.jar</ejb> 
    </module> 
</application>

1. 右击 simple 工程选择 Run as > Run on Server 。
2. 在 server type 选项中选择 JBoss > JBoss v4.2, 点击 Next，默认，点击 Next 完成。服务器将启动并部署应用程序。
3. 打开 Web 浏览器，并访问 http://localhost:8080/simpleWEB/。

Spring 带来的解决方法是我们的代码更简洁更易扩展，不仅仅是 JSF 和 EJB，对 JDBC、Java mail、JCA 及一些开源框架都提供了很多便利。