1. 首先，查看你的应用程序的软件包结构及其依赖关系。详情请参考 第 3.1.2.3 节 “根据类加载的修改更新应用程序的依赖关系”。

2. 如果你的应用程序使用了日志，你需要制定正确的模块依赖关系。请查看 第 3.1.4.1 节 “修改日志依赖关系” 里的相关细节。
3. 由于模块化类加载的修改，你可能需要修改 EAR 或 WAR 的软件包结构。详情请参考 第 3.1.5.1 节 “修改 EAR 和 WAR 的打包”。

过程 3.1. 了解模块依赖关系

1. 了解隐性依赖关系

   服务器里的部署者隐性地自动添加一些常用的模块依赖关系，如javax.api 和 sun.jdk。这使得类在运行时对于部署可见，并让开发人员不用显性地添加依赖关系。关于如何和何时添加这些隐性的依赖关系，请查看 https://access.redhat.com/site/documentation/JBoss_Enterprise_Application_Platform/ 上的《JBoss EAP 6 开发指南》里的『类记载和模块』章节的『隐性模块依赖关系』。

2. 理解显性依赖关系

   对于其他类，模块必须显性地制定，否则缺失的依赖关系会导致部署或运行时错误。如果缺失了依赖关系，你可以在服务器日志里看到 ClassNotFoundExceptions 或 NoClassDefFoundErrors 跟踪信息。如果多于一个模块加载了相同的 JAR 或一个模块加载的类扩展了不同模块加载的类，你会在服务器日志里看到 ClassCastExceptions。要显性地制定依赖关系，请修改 MANIFEST.MF 或创建一个 JBoss 专有的部署描述符文件 jboss-deployment-structure.xml。关于模块依赖关系的更多信息，请查看 https://access.redhat.com/site/documentation/JBoss_Enterprise_Application_Platform/《JBoss EAP 6 开发指南》里的『开发应用程序起步』章节的『类记载和模块概述』。

过程 3.2. 

1. 如果你在开发 WAR 归档，你必须将这些属性包裹至 WAR 的 WEB-INF/classes/ 目录里。

2. 如果你想要 EAP 里所有组件都可以访问这些属性，那你必须将其打包到 JAR 的根目录并将 JAR 放入 EAR 的 lib/ 目录下。

过程 3.3. 创建自定义模块

1. 创建和填充 module/ 目录结构。
   1. 在 EAP_HOME/module 目录下创建一个目录结构来包含文件和 JAR。例如：

      $ cd EAP_HOME/modules/ $ mkdir -p myorg-conf/main/properties
      
      

   2. 将属性文件移到你在前一步骤里创建的 EAP_HOME/modules/myorg-conf/main/properties/ 目录里。
   3. 在 EAP_HOME/modules/myorg-conf/main/ 目录里创建一个包含下列 XML 内容的 module.xml 文件：

      <module xmlns="urn:jboss:module:1.1" name="myorg-conf">
          <resources>
              <resource-root path="properties"/>
          </resources>
      </module>
      
      

2. 修改服务器配置文件里的 ee 子系统。你可以使用 JBoss CLI 或手动编辑这个文件。
   • 按照下列步骤使用 JBoss CLI 来修改服务器配置文件。
     1. 启动服务器并连接至管理 CLI。
        • 对于 Linux，输入下列命令：

          $ EAP_HOME/bin/jboss-cli.sh --connect
          $ Connected to standalone controller at localhost:9999
          

        • 对于 Windows，输入下列命令：

          C:\>EAP_HOME\bin\jboss-cli.bat --connect
          C:\> Connected to standalone controller at localhost:9999
          

     2. 要在 ee 子系统里创建 myorg-conf<global-modules> 元素，输入下列命令：

        /subsystem=ee:write-attribute(name=global-modules, value=[{"name"=>"myorg-conf","slot"=>"main"}])
        

        你应该看到下面的结果：

        {"outcome" => "success"}
        

   • 如果你向手动编辑服务器配置文件，请按照下列步骤进行。
     1. 停止服务器并打开服务器配置文件。如果你使用的是独立服务器，这个文件是 EAP_HOME/standalone/configuration/standalone.xml，如果是受管域，这个文件是 EAP_HOME/domain/configuration/domain.xml。
     2. 找到 ee 子系统并为 myorg-conf 添加全局模块。下面是 ee 子系统元素的例子，已经进行修改并包含了 myorg-conf 元素：

        <subsystem xmlns="urn:jboss:domain:ee:1.0" >            
            <global-modules>
                <module name="myorg-conf" slot="main" />            
            </global-modules>
        </subsystem>
        
        

3. 假设你复制了一个名为 my.properties 的文件到正确的模块位置，你现在可以使用下面的代码来加载属性文件了：

   Thread.currentThread().getContextClassLoader().getResource("my.properties");
   

过程 3.4. 更新程序日志代码

1. 第 3.1.4.2 节 “为第三方日志框架更新应用程序代码”
2. 第 3.1.4.3 节 “修改代码以使用新的 JBoss Logging 框架”

过程 3.5. 配置 JBoss EAP 6 以使用 log4j.properties 或 log4j.xml 文件

1. 用下列内容创建一个 jboss-deployment-structure.xml 文件：

   <jboss-deployment-structure>
       <deployment>
           <!-- Exclusions allow you to prevent the server from automatically adding some dependencies -->
           <exclusions>
               <module name="org.apache.log4j" />
           </exclusions>
       </deployment>
   </jboss-deployment-structure>
   
   

2. 如果你在部署 WAR 文件，将 jboss-deployment-structure.xml文件放入 META-INF/ 目录或者 WEB-INF/，如果是部署 EAR 文件则放入 META-INF/。
3. 将 log4j.properties 或 log4j.xml 文件包含在 EAR 的 lib/ 目录、或者 WAR 的 WEB-INF/classes/ 目录里。
4. 部署你的应用程序

过程 3.6. 修改代码和依赖关系以使用新的 JBoss Logging 框架

1. 修改你的导入和日志代码

   下面是一个使用新的 JBoss Logging 框架的例子：

   import org.jboss.logging.Level;
   import org.jboss.logging.Logger;
   
   private static final Logger logger = Logger.getLogger(MyClass.class.toString());
   
   if(logger.isTraceEnabled()) {
       logger.tracef("Starting...", subsystem);
   }
   

2. 添加日志依赖关系

   包含 JBoss Logging 类的 JAR 位于名为 org.jboss.logging 的模块。你的 MANIFEST-MF 文件应该类似要：

   Manifest-Version: 1.0
   Dependencies: org.jboss.logging
   

   关于如何查找模块依赖关系的更多信息，请参考 第 3.1.2.3 节 “根据类加载的修改更新应用程序的依赖关系” and 第 4.2.1 节 “调试和解决移植问题”。

过程 3.7. 修改归档的打包

1. 打包 WAR

   WAR 是一个模块，它里面的所有类都用相同的类加载器加载。这意味着打包在 WEB-INF/lib/ 目录里的类将和 WEB-INF/classes 里的一样被对待。

2. 打包 EAR

   EAR 由多个模块组成。EAR/lib/ 目录是一个单个的模块且 EAR 里每个 WAR 或 EJB JAR 都是一个独立的模块。除非定义了显性的依赖关系，类不能访问 EAR 里其他模块里的类。子部署总是对父部署有着自动的依赖关系，这让它们可以访问 EAR/lib/ 目录里的类。然而，子部署并不总由自动的依赖关系来允许它们访问彼此。这个行为是通过设置 ee 子系统配置里的 <ear-subdeployments-isolated> 元素来控制的：

   <subsystem xmlns="urn:jboss:domain:ee:1.0" >            
     <ear-subdeployments-isolated>false</ear-subdeployments-isolated>
   </subsystem>
   

   在默认情况下，它被设置为 false，这允许子部署查看属于 EAR 里其他子部署的类。
   关于类加载的更多信息，请参考 https://access.redhat.com/site/documentation/JBoss_Enterprise_Application_Platform/ 上的《JBoss 开发指南》里的『类加载和模块』章节。

1. 如果你的应用程序使用了数据源，请参考： 第 3.1.6.2 节 “更新数据源配置”。

2. 如果你的应用程序使用了 JPA 且捆绑了 Hibernate JAR，请参考下列移植选项： 第 3.1.6.4 节 “为 Hibernate 或 JPA 配置数据源”。
3. 如果你的应用程序使用了资源适配器，请参考： 第 3.1.6.5 节 “更新资源适配器配置”。
4. 关于如何配置基本安全性，请参考： 第 3.1.7.1 节 “应用程序安全性的修改”。

过程 3.8. 安装和配置 JDBC 驱动

1. 安装 JDBC 驱动

   1. 将 JDBC 驱动作为部署安装

      这是我们推荐的安装驱动的方法。当 JDBC 驱动作为部署安装时，它会被部署为常规的 JAR。如果 JBoss EAP 实例作为独立服务器运行，请将兼容 JDBC 4.0 的 JAR复制到 EAP_HOME/standalone/deployments/ 目录。如过服务器是运行在受管域里，请将 JAR 复制到 EAP_HOME/domain/deployments/ 目录。
      下面是一个安装为独立服务器的部署的 MySQL JDBC 驱动示例：

      $cp mysql-connector-java-5.1.15.jar EAP_HOME/standalone/deployments/

      任何兼容 JDBC 4.0 的驱动都自动会被承认且根据名称和版本安装至系统里。兼容 JDBC 4.0 的 JAR 都包含一个名为 META-INF/services/java.sql.Driver 的文本文件，它指定驱动类的名称。如果这个驱动不兼容 JDBC 4.0，它可以用下列方法来部署：

      • 创建并添加 java.sql.Driver 文件到 META-INF/services/ 路径下的 JAR。这个文件应该包含驱动类的名称，例如：

        com.mysql.jdbc.Driver

      • 在部署目录里创建一个 java.sql.Driver 文件。对于作为独立服务器运行的 JBoss EAP 6 实例，这个文件应该位于：EAP_HOME/standalone/deployments/META-INF/services/java.sql.Driver。如果服务器位于受管域里，那么这个文件应该是：EAP_HOME/domain/deployments/META-INF/services/java.sql.Driver。
      这种方法的优点是：

      • 因为不需要定义模块，所以这是最简单的方法。
      • 当服务器运行在受管域里时，使用这个方法的部署将自动传播到域里的所有服务器。这意味着管理员不需要手动分发这个驱动 JAR。

      这种方法的缺点是：

      • 如果 JDBC 驱动由多个 JAR 组成，如驱动 JAR 以及依赖的许可证 JAR 或本地化 JAR，你不能将驱动安装为部署。你必须将其安装为核心模块。
      • 如果这个驱动不兼容 JDBC 4.0，你必须创建一个包含驱动类名的文件并导入至 JAR 或覆盖到 deployments/ 目录。

   2. 将 JDBC 驱动安装为核心模块

      要将 JDBC 驱动安装为核心模块，你必须在 EAP_HOME/modules/ 下创建一个文件路径结构。这个结构包含 JDBC 驱动 JAR，任何其他供应商许可证或本地化 JAR，以及一个定义模块的 module.xml 文件。

      • 将 MySQL JDBC 驱动安装为核心模块

        1. 创建一个目录结构 EAP_HOME/modules/com/mysql/main/
        2. 在 main/ 子目录里，创建一个包含下列为 MySQL JDBC 驱动定义的 module.xml 文件：

           <?xml version="1.0" encoding="UTF-8"?>
           <module xmlns="urn:jboss:module:1.0" name="com.mysql">
           <resources>
               <resource-root path="mysql-connector-java-5.1.15.jar"/>
           </resources>
           <dependencies>
               <module name="javax.api"/>
           </dependencies>
           </module>
           
           
           

           模块名 “com.mysql”，映射了这个模块的目录结构。<dependencies> 元素用来指定这个模块对其他模块的依赖关系。在这种情况下，所有的 JDBC 数据源都依赖于在另一个名为 javax.api 的模块里定义的 Java JDBC API。这个模块位于 modules/system/layers/base/javax/api/main/ 目录。

           注意

           确保你在 module.xml 文件的开头没有留下一个空格，否则你会遇到 "New missing/unsatisfied dependencies" 错误。
        3. 复制 MySQL JDBC 驱动 JAR 到 EAP_HOME/modules/com/mysql/main/ 目录：

           $ cp mysql-connector-java-5.1.15.jar EAP_HOME/modules/com/mysql/main/

      • 将 IBM DB2 JDBC 驱动和 license JAR 安装为核心模块

        这个例子只是用来演示如何部署要求 JDBC Driver JAR 之外的 JAR 的驱动。
        1. 创建目录结构 EAP_HOME/modules/com/ibm/db2/main/。
        2. 在 main/ 子目录里，创建一个包含下列用于 IBM DB2 JDBC 驱动和许可证的模块定义的 module.xml 文件：

           <?xml version="1.0" encoding="UTF-8"?>
           <module xmlns="urn:jboss:module:1.1" name="com.ibm.db2">
             <resources>
               <resource-root path="db2jcc.jar"/>
               <resource-root path="db2jcc_license_cisuz.jar"/>
             </resources>
             <dependencies>
               <module name="javax.api"/>
               <module name="javax.transaction.api"/>
             </dependencies>
           </module>
           
           

           注意

           确保你在 module.xml 文件的开头没有留下一个空格，否则你会遇到 "New missing/unsatisfied dependencies" 错误。
        3. 复制 JDBC 驱动和 license JAR 到 EAP_HOME/modules/com/ibm/db2/main/ 目录里。

           $ cp db2jcc.jar EAP_HOME/modules/com/ibm/db2/main/
           $ cp db2jcc_license_cisuz.jar EAP_HOME/modules/com/ibm/db2/main/

      这种方法的优点是：

      • 当 JDBC 驱动由多个 JAR 组成时，这是唯一的途径。
      • 用这个方法，不兼容 JDBC 4.0 的驱动可以无需修改驱动 JAR 或创建覆盖文件就进行安装。

      这种方法的缺点是：

      • 通过设置模块要更为困难。
      • 你必须手动将模块复制到运行在受管域里的每个服务器里。

2. 配置数据源

   1. 添加数据库驱动

      在相同的文件的 <drivers> 元素了添加 <driver> 元素。它也包含了之前的 *-ds.xml 文件里定义的一些数据源信息。
      首先确定驱动 JAR 是否兼容 JDBC 4.0。兼容 JDBC 4.0 的 JAR 包含一个指定驱动类名的 META-INF/services/java.sql.Driver。这个服务器使用这个文件来在 JAR 里查找驱动类的名称。兼容 JDBC 4.0 的 JAR 不要求 <driver-class> 元素，因为在 JAR 里它已被指定。下面是一个 JDBC 4.0 兼容的 MySQL 驱动的 driver 元素示例：

      <driver name="mysql-connector-java-5.1.15.jar" module="com.mysql"/>
      

      不兼容 JDBC 4.0 的驱动要求一个 <driver-class> 属性来确定驱动类，这是因为没有 META-INF/services/java.sql.Driver 文件来指定驱动类名。下面是一个不兼容 JDBC 4.0 的 MySQL 驱动的 driver 元素示例：

      <driver name="mysql-connector-java-5.1.15.jar" module="com.mysql"><driver-class>com.mysql.jdbc.Driver</driver-class></driver>
      
      

   2. 创建数据源

      在 standalone.xml 文件的 <datasources> 部分创建一个 <datasource> 元素。这个文件包含之前的 *-ds.xml 文件里定义的大部分数据源信息。

      重要

      要使修改在服务器重启后仍然生效，你必须在编辑服务器配置文件前停止服务器。
      下面是 standalone.xml 文件里的一个 MySQL 数据源元素示例：

      <datasource jndi-name="java:/YourDatasourceName" pool-name="YourDatasourceName">
        <connection-url>jdbc:mysql://localhost:3306/YourApplicationURL</connection-url>
        <driver>mysql-connector-java-5.1.15.jar</driver>
        <transaction-isolation>TRANSACTION_READ_COMMITTED</transaction-isolation>
        <pool>
          <min-pool-size>100</min-pool-size>
          <max-pool-size>200</max-pool-size>
        </pool>
        <security>
          <user-name>USERID</user-name>
          <password>PASSWORD</password>
        </security>
        <statement>
          <prepared-statement-cache-size>100</prepared-statement-cache-size>
          <share-prepared-statements/>
        </statement>
      </datasource>
      
      

过程 3.9. 删除 Hibernate 捆绑

1. 从你的应用程序的库目录里将 Hibernate JAR 删除。

2. 当不再需要 <hibernate.transaction.manager_lookup_class> 元素时，在 persistence.xml 里将其删除或注释。

过程 3.10. 修改 JNDI 查找

1. 了解更多的 第 3.1.8.2 节 “可移植的 JNDI 命名语法”

2. 第 3.1.8.3 节 “复核 JNDI 命名空间规则”
3. 第 3.1.8.4 节 “修改应用程序以遵循新的 JNDI 命名规则”

过程 3.11. 

1. 第 3.2.2.2 节 “修改使用 Hibernate 和 JPA 的应用程序的配置”

2. 第 3.2.2.4 节 “更新 Hibernate 3 应用程序以使用 Hibernate 4”

3. 第 3.2.2.9 节 “更新你的应用程序以遵循 JPA 2.0 规格”

4. 第 3.2.2.10 节 “用 Infinispan 替换 JPA/Hibernate 二级缓存”

5. 第 3.2.2.12 节 “移植到 Hibernate Validator 4”

过程 3.12. 配置应用程序

1. 复制所需的 Hibernate 3 JAR 到你的应用程序库。

   你可以复制包含缺失类的特定 Hibernate 4 JAR 到应用程序的 lib/ 目录，或者使用其他方法添加它们到 classpath 来解决这个问题。在某些情况下，由于混合使用 Hibernate 版本，这可能会导致 ClassCastExceptions 或其他类加载问题。如果发生了这种情况，你需要使用下一个方法。

2. 设置服务器只使用 Hibernate 3 库。

   JBoss EAP 6 允许你将 Hibernate 3.5 (或更高版本) 持久化提供者 JAR 和应用程序打包。为了让服务器只使用 Hibernate 3 库而排除 Hibernate 4 库，你需要在 persistence.xml 里设置 jboss.as.jpa.providerModule 为 hibernate3-bundled：

   <?xml version="1.0" encoding="UTF-8"?>
   <persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
       <persistence-unit name="plannerdatasource_pu">
           <description>Hibernate 3 Persistence Unit.</description>
           <jta-data-source>java:jboss/datasources/PlannerDS</jta-data-source>
           <properties>
               <property name="hibernate.show_sql" value="false" />
               <property name="jboss.as.jpa.providerModule" value="hibernate3-bundled" />
           </properties>
       </persistence-unit>
   </persistence>
   
   

   Java Persistence API (JPA) 开发人员将检测到应用程序里持久性提供者的存在并使用 Hibernate 3 库。关于 JPA 持久性属性的更多信息，请参考 第 3.2.2.3 节 “持久化单元属性”。

3. 禁用 Hibernate 的二级缓存

   Hibernate 3 的二级缓存在 JBoss EAP 6 没有展现和以前版本里一样的行为。如果你在应用程序里是了 Hibernate 二级缓存，你必须禁用它，直至你升级到 Hibernate 4。要禁用二级缓存，你需要在 persistence.xml 文件里将 <hibernate.cache.use_second_level_cache> 设置为 false。

过程 3.13. 更新应用程序以使用 Hibernate 4

1. 自动增量序列生成器的默认行为在 JBoss EAP 6 已经进行了修改。详情请参考 第 3.2.2.5 节 “Hibernate 标识符自动生成值”。
2. 确定应用程序当前使用的 Hibernate 版本并选择下面正确的更新过程。
   • 第 3.2.2.6 节 “移植你的 Hibernate 3.3.x 应用程序到 Hibernate 4.x”
   • 第 3.2.2.7 节 “移植你的 Hibernate 3.5.x 应用程序到 Hibernate 4.x”
3. See 第 3.2.2.8 节 “修改运行在群集环境里的移植的 Seam 和 Hibernate 应用程序的持久化属性” 如果你准备在群集环境里运行你的应用程序。

过程 3.14. 

1. 映射 Hibernate text 类型为 JDBC LONGVARCHAR

   在 Hibernate 3.5 以前的版本里，text 类型被映射为 JDBC CLOB。Hibernate 4 里引入了一个新的 Hibernate 类型materialized_clob，将 Java String 属性映射为 JDBC CLOB。如果你的应用程序里有属性需要将 type="text" 映射为 JDBC CLOB，你必须这样：
   1. 如果你的应用程序使用了 hbm 映射文件，请将这个属性修改为 type="materialized_clob"。
   2. 如果你的应用程序使用了注解，你应该将 @Type(type = "text") 替换为 @Lob。

2. 复查代码以找出返回值类型的修改

   数字型组合标准的 Projection 现在返回的是 HQL 对应类型的值。因此，org.hibernate.criterion 里的下列 projection 的返回类型已经有了改动。
   1. CountProjection、Projections.rowCount()、Projections.count(propertyName) 和 Projections.countDistinct(propertyName) 里的修改，count 和 count distinct projection 现在返回的是 Long 型值。
   2. 由于 Projections.sum(propertyName) 里的修改， sum projection 现在返回依赖于属性类型的值。

      注意

      没有修改你的代码可能导致 java.lang.ClassCastException。
      1. 对映射为 Long、Short、Integer 或原始类型的属性，将返回 Long 值。
      2. 对映射为 Float、Double 或原始浮点类型的属性，将返回 Double 值。

过程 3.15. 

1. 合并 AnnotationConfiguration 到配置里

   AnnotationConfiguration 已废弃，它不应该影响应用程序的移植。
   如果你还在使用 hbm.xml 文件，你应该意识到 JBoss EAP 6 现在在 AnnotationConfiguration 里使用 org.hibernate.cfg.EJB3NamingStrategy，而不是以前版本里的 org.hibernate.cfg.DefaultNamingStrategy。这可能导致命名不匹配。如果你依赖于这个命名策略来设置关系（多对多和元素集合）表的默认名称，你可能会遇到这个现象。要解决这个问题，你可以调用 Configuration#setNamingStrategy 传入 org.hibernate.cfg.DefaultNamingStrategy#INSTANCE 让 Hibernate 使用旧的org.hibernate.cfg.DefaultNamingStrategy。

2. 修改这个命名空间以遵循新的 Hibernate DTD 文件名称规则。

   表 3.5. 

   以前的 DTD 命名空间	新的 DTD 命名空间
   http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd	http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd
   http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd	http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd

3. 修改环境变量

   1. 如果你在使用 Oracle 以及 materialized_clob 或materialized_blob 属性，全局环境变量 hibernate.jdbc.use_streams_for_binary 必须设置为 true。
   2. 如果你在使用 PostgreSQL 以及 CLOB 或 BLOB 属性，全局环境变量 hibernate.jdbc.use_streams_for_binary 必须设置为 false。

过程 3.16. 设置持久化属性以运行在群集环境里

1. 设置 hibernate.session_factory_name 为唯一的名字。这个名字必须在 JBoss EAP 实例里的所有应用程序部署里是唯一的。例如：

   <property name="hibernate.session_factory_name" value="jboss-seam-booking.ear_session_factory"/>
   
   

2. 设置 hibernate.ejb.entitymanager_factory_name 为唯一的名字。这个名字必须在 JBoss EAP 实例里的所有应用程序部署里是唯一的。例如：

   <property name="hibernate.ejb.entitymanager_factory_name" value="seam-booking.ear_PersistenceUnitName"/>
   
   

过程 3.17. 修改 persistence.xml 文件以使用 Infinispan

1. 为 JBoss EAP 6 里的 JPA 应用程序配置 Infinispan

   这是如何用 JBoss EAP 6 里的 Infinispan 来指定属性以实现用于 JPA 应用程序的相同配置：

   <property name="hibernate.cache.use_second_level_cache" value="true"/>
   
   

   此外，你需要指定一个值为 ENABLE_SELECTIVE 或 ALL 的 shared-cache-mode：
   • ENABLE_SELECTIVE 是默认的推荐值。它表示实体不会被缓存，除非你显性地将它标记为可缓存的。

     <shared-cache-mode>ENABLE_SELECTIVE</shared-cache-mode>
     
     

   • ALL 表示实体总是被缓存，即使你将其标记为不可缓存的。

     <shared-cache-mode>ALL</shared-cache-mode>
     
     

2. 为 JBoss EAP 6 里的原生 Hibernate 应用程序配置 Infinispan

   这是如何用 JBoss EAP 6 里的 Infinispan 来指定用于原生 Hibernate 应用程序的相同配置：

   <property name="hibernate.cache.region.factory_class"
        value="org.jboss.as.jpa.hibernate4.infinispan.InfinispanRegionFactory"/>
   <property name="hibernate.cache.infinispan.cachemanager"
        value="java:jboss/infinispan/container/hibernate"/>     
   <property name="hibernate.transaction.manager_lookup_class"
        value="org.hibernate.transaction.JBossTransactionManagerLookup"/>
   <property name="hibernate.cache.use_second_level_cache" value="true"/>
   
   
   

   你也必须将下列依赖关系添加至 MANIFEST.MF 文件：

   Manifest-Version: 1.0
   Dependencies: org.infinispan, org.hibernate
   

过程 3.18. 你可能需要执行一个或多个下面的任务：

1. 访问默认的 ValidatorFactory

   JBoss EAP 6 捆绑了一个默认的 ValidatorFactory java:comp/ValidatorFactory 到 JNDI 上下文。

2. 理解生命周期触发的检验

   和 Hibernate Core 4 一起使用时，Hibernate Core 将自动启用基于生命周期的检验。

   1. 检验发生在实体 INSERT、UPDATE 和 DELETE 操作上。

   2. 你可以配置组通过使用下列属性的事件类型来检验：

      • javax.persistence.validation.group.pre-persist，
      • javax.persistence.validation.group.pre-update，和
      • javax.persistence.validation.group.pre-remove。

      这些属性的值是用逗号隔开的、要检验的组的全限定类名。
      Validation 组是 Bean Validation 规格的一个新功能。如果你不想利用这个功能，移植到 Hibernate Validator 4 时无需进行任何修改。
   3. 你可以设置 javax.persistence.validation.mode 属性为 none 来禁用基于生命周期的检验。这个属性的其他值还有 auto（默认值），callback 和 ddl。

3. 配置你的应用程序以使用手动检验

   1. 如果你想手动控制检验，你可以用下列方法创建一个 Validator：

      • 用 getValidator() 方法从 ValidatorFactory 创建一个 Validator 实例。
      • 注入 Validator 实例到 EJB、CDI Bean 或其他 Java EE 可注入的资源。
   2. 你可以使用 ValidatorFactory.usingContext() 返回的 ValidatorContext 来定制你的 Validator 实例。使用这个 API，你可以配置一个自定义的 MessageInterpolator、 TraverableResolver 和 ConstraintValidatorFactory。Bean Validator 规格里指定了这些接口，在 Hibernate Validator 4 里它们是新的接口。

4. 修改代码以使用新的 Bean Validation 约束

   当移植到 Hibernate Validator 4 时新的 Bean 级别的检验约束需要修改代码。

   1. 要升级到 Hibernate Validator 4，你必须使用下列包里的约束：

      • javax.validation.constraints
      • org.hibernate.validator.constraints
   2. Hibernate Validator 3 里所有的约束在 Hibernate Validator 4 里仍然可用。要使用它们，你需要导入指定的类，且在某些情况下，修改其约束参数的名称或类型。

5. 使用自定义的约束

   在 Hibernate Validator 3 里，自定义的约束需要实现 org.hibernate.validator.Validator 接口。 在 Hibernate Validator 4 里，你需要实现 javax.validation.ConstraintValidator 接口。这个接口包含了和以前接口相同的 initialize() 和 isValid() 方法，但方法签名有了变动。此外，Hibernate Validator 4 不再支持 DDL 修改。

过程 3.19. 配置 JMS 桥

1. 在 JBoss EAP 6 的 deploy 目录里创建一个子目录来包含 SAR，如EAP5_HOME/server/PROFILE_NAME/deploy/myBridge.sar。
2. 在 EAP5_HOME/server/PROFILE_NAME/deploy/myBridge.sar/ 里创建一个名为 META-INF 的子目录。
3. 在 EAP5_HOME/server/PROFILE_NAME/deploy/myBridge.sar/META-INF/ 目录里创建一个包含类似于下列信息的 jboss-service.xml 文件。

   <server>
      <loader-repository>
         com.example:archive=unique-archive-name
         <loader-repository-config>java2ParentDelegation=false</loader-repository-config>
      </loader-repository> 
   
      <!-- JBoss Enterprise Application Platform 6 JMS Provider --> 
      <mbean code="org.jboss.jms.jndi.JMSProviderLoader" name="jboss.messaging:service=JMSProviderLoader,name=EnterpriseApplicationPlatform6JMSProvider">
         <attribute name="ProviderName">EnterpriseApplicationPlatform6JMSProvider</attribute>
         <attribute name="ProviderAdapterClass">org.jboss.jms.jndi.JNDIProviderAdapter</attribute>
         <attribute name="FactoryRef">jms/RemoteConnectionFactory</attribute> 
         <attribute name="QueueFactoryRef">jms/RemoteConnectionFactory</attribute>  
         <attribute name="TopicFactoryRef">jms/RemoteConnectionFactory</attribute>      
         <attribute name="Properties">
            java.naming.factory.initial=org.jboss.naming.remote.client.InitialContextFactory
            java.naming.provider.url=remote://EnterpriseApplicationPlatform6host:4447
            java.naming.security.principal=jbossuser
            java.naming.security.credentials=jbosspass
         </attribute>
      </mbean> 
   
      <mbean code="org.jboss.jms.server.bridge.BridgeService" name="jboss.jms:service=Bridge,name=MyBridgeName" xmbean-dd="xmdesc/Bridge-xmbean.xml">      
         <depends optional-attribute-name="SourceProviderLoader">jboss.messaging:service=JMSProviderLoader,name=JMSProvider</depends>          
         <depends optional-attribute-name="TargetProviderLoader">jboss.messaging:service=JMSProviderLoader,name=EnterpriseApplicationPlatform6JMSProvider</depends>          
         <attribute name="SourceDestinationLookup">/queue/A</attribute>      
         <attribute name="TargetDestinationLookup">jms/queue/test</attribute>       
         <attribute name="QualityOfServiceMode">1</attribute>           
         <attribute name="MaxBatchSize">1</attribute>      
         <attribute name="MaxBatchTime">-1</attribute>           
         <attribute name="FailureRetryInterval">60000</attribute>      
         <attribute name="MaxRetries">-1</attribute>      
         <attribute name="AddMessageIDInHeader">false</attribute>
         <attribute name="TargetUsername">jbossuser</attribute>
         <attribute name="TargetPassword">jbosspass</attribute>
      </mbean>
   </server>
           
   
   

   注意

   <load-repository> 确保了 SAR 具有隔离的类加载器。而且请注意 JNDI 查找和桥 “目标” 都包含了用户 "jbossuser"/密码 "jbosspass" 的安全凭证。这是因为 EAP 6 默认是有设置安全性的。名为 "jbossuser" /密码为 "jbosspass" 的用户是在角色为 guest 的 ApplicationRealm 里用 EAP_HOME/bin/add_user.sh 脚本来创建的。
4. 将下列 JAR 从 EAP_HOME/modules/system/layers/base/ 目录复制到 EAP5_HOME/server/PROFILE_NAME/deploy/myBridge.sar/ 目录。用实际的版本号替换每个 VERSION_NUMBER。

   • org/hornetq/main/hornetq-core-VERSION_NUMBER.jar
   • org/hornetq/main/hornetq-jms-VERSION_NUMBER.jar
   • org/jboss/ejb-client/main/jboss-ejb-client-VERSION_NUMBER.jar
   • org/jboss/logging/main/jboss-logging-VERSION_NUMBER.jar
   • org/jboss/logmanager/main/jboss-logmanager-VERSION_NUMBER.jar
   • org/jboss/marshalling/main/jboss-marshalling-VERSION_NUMBER.jar
   • org/jboss/marshalling/river/main/jboss-marshalling-river-VERSION_NUMBER.jar
   • org/jboss/remote-naming/main/jboss-remote-naming-VERSION_NUMBER.jar
   • org/jboss/remoting3/main/jboss-remoting-VERSION_NUMBER.jar
   • org/jboss/sasl/main/jboss-sasl-VERSION_NUMBER.jar
   • org/jboss/netty/main/netty-VERSION_NUMBER.jar
   • org/jboss/remoting3/remote-jmx/main/remoting-jmx-VERSION_NUMBER.jar
   • org/jboss/xnio/main/xnio-api-VERSION_NUMBER.jar
   • org/jboss/xnio/nio/main.xnio-nio-VERSION_NUMBER.jar

   注意

   不要简单地复制 EAP_HOME/bin/client/jboss-client.jar，因为 javax API 类会和 JBoss EAP 5.x 里的类相冲突。

过程 3.20. 在开始之前

1. 关闭客户和服务器。
2. 备份任何 JBoss Messaging 数据。消息数据保存在数据库中前缀为 JBM_ 的表里。

过程 3.21. 修改提供者为 HornetQ

1. 转移配置

   请转移现有的 JBoss Messaging 配置到 JBoss EAP。下面的配置可在位于 JBoss Messaging 服务器的上的部署描述符里找到：
   • 连接工厂服务的配置
     这个配置描述了和 JBoss Messaging 服务器一起部署的 JMS 连接工厂。JBoss Messaging 用一个名为 connection-factories-service.xml 的文件来配置连接工厂，这个文件位于应用服务器的 deployment 目录里。
   • 目的地配置
     这个配置描述了和 JBoss Messaging 一同部署的 JMS 队列和主题。在默认情况下，JBoss Messaging 在一个名为 destinations-service.xml 的文件里配置目的地，这个文件位于应用服务器的 deployment 目录下。
   • 消息桥服务配置
     这个配置描述了和 JBoss Messaging 服务器一起部署的桥服务。在默认情况下不会部署桥，所以部署文件的名称根据 JBoss Messaging 安装而有所不同。

2. 修改你的程序代码

   如果应用程序代码使用了标准的 JMS，你不需要修改代码。然而，如果应用程序将连至群集，你必须小心地查看 HornetQ 文档里关于群集模式的内容。群集超出了 JMS 规格和 HornetQ 的范围，JBoss Messaging 采用了很不一样的方法来实现群集功能。
   如果应用程序使用 JBoss Messaging 专有的功能，你必须修改代码以使用 HornetQ 里相等的功能。
   关于如何用 HornetQ 配置消息系统，请参考 第 3.2.6.4 节 “用 HornetQ 配置消息系统”。

3. 移植现有的消息

   使用 JMS 桥移动 JBoss Messaging 数据库里的任何消息到 HornetQ 日志。配置 JMS 桥的说明可以在这里找到： 第 3.2.6.2 节 “配置 JMS 桥以移植现有的 JMS 消息到到 JBoss EAP 6 ”。

过程 3.22. 

1. 启动启用了群集的 JBoss EAP 6

   要在 JBoss EAP 5.x 里启用群集，你需要使用 all 配置集或其衍生配置集来启动服务器实例，如：
   $ EAP5_HOME/bin/run.sh -c all
   在 JBoss EAP 6 里，启用群集的方法取决于服务器是独立的还是运行在受管域里。

   1. 为运行在受管域l里的服务器启用群集

      要为使用域控制器启动的服务器的群集，请更新你的 domain.xml 并指定一个服务器组来使用 ha 配置集和 ha-sockets 套接字绑定组。例如：

      <server-groups>
        <server-group name="main-server-group" profile="ha">
          <jvm name="default">
            <heap size="64m" max-size="512m"/>
          </jvm>
          <socket-binding-group ref="ha-sockets"/>
        </server-group>
      </server-group>
      

   2. 为独立服务器启用群集

      要为独立服务器启用群集，用下列配置文件启动服务器 $ EAP_HOME/bin/standalone.sh --server-config=standalone-ha.xml -Djboss.node.name=UNIQUE_NODE_NAME：

2. 指定绑定地址

   在 JBoss EAP 5.x 里，你通常要用 -b 命令行参数来指定用于群集的绑定地址：$ EAP_HOME/bin/run.sh -c all -b 192.168.0.2
   在 JBoss EAP 6 里，绑定地址是在 EAP 6 配置文件里的相关套接字绑定部分显性定义的。对于用域控制器启动的服务器，绑定地址是在 domain/configuration/host.xml 文件里定义的；而对于独立服务器， 绑定地址是在 standalone-ha.xml 文件里定义的：

   <interfaces>
         <interface name="management">
       <inet-address value="192.168.0.2"/>
         </interface>
         <interface name="public">
       <inet-address value="192.168.0.2"/>
     </interface>
     </interfaces>
   

   <socket-binding-groups>
         <socket-binding-group name="ha-sockets" default-interface="public">
       <!-- ... -->
         </socket-binding-group>
     </socket-binding-groups>
   

   在上面的例子里，public 接口被指定为 ha-sockets 套接字绑定组里的所有套接字的默认接口。

3. 配置 jvmRoute 以支持 mod_jk 和 mod_proxy

   在 JBoss EAP 5 里，web 服务器 jvmRoute 是用 server.xml 文件里的一个属性进行配置的。在 JBoss EAP 6 里，jvmRoute 属性使用 instance-id 属性在服务器配置文件的 web subsystem 部分进行配置。

   <subsystem xmlns="urn:jboss:domain:web:1.1" default-virtual-server="default-host" native="false" instance-id="{JVM_ROUTE_SERVER}">
   
   

   上面的 {JVM_ROUTE_SERVER} 应该用 jvmRoute 服务器 ID 替换。
   instance-id 也可以用管理控制台来设置。

4. 指定多点传送地址和端口

   在 JBoss EAP 5.x 里，你可以使用命令行参数 -u 和 -m 分别指定用于群集间通讯的多点传送地址和端口，如：$ EAP_HOME/bin/run.sh -c all -u 228.11.11.11 -m 45688
   在 JBoss EAP 6 里，用于群集间通讯的多点传送地址和端口是用相关的 JGroups 协议栈引用的 socket-binding 定义的。

   <subsystem xmlns="urn:jboss:domain:jgroups:1.0" default-stack="udp">
       <stack name="udp">
           <transport type="UDP" socket-binding="jgroups-udp"/>
           <!-- ... -->
       </stack>
   </subsystem>
   

   <socket-binding-groups>
       <socket-binding-group name="ha-sockets" default-interface="public">
           <!-- ... -->
           <socket-binding name="jgroups-udp" port="55200" multicast-address="228.11.11.11" multicast-port="45688"/>
           <!-- ... -->
       </socket-binding-group>
   </socket-binding-groups>
   
   

   如果你想在命令行指定多点传送地址和端口，你可以将多点传送地址和端口定义为系统属性并在启动服务器时在命令行使用这些属性。在下面的例子里， jboss.mcast.addr 是多点传送地址的变量名，而 jboss.mcast.port 是端口的变量名。

   <socket-binding name="jgroups-udp" port="55200"
    multicast-address="${jboss.mcast.addr:230.0.0.4}" multicast-port="${jboss.mcast.port:45688}"/>
   
   

   你可以用下列命令行参数启动服务器：$ EAP_HOME/bin/domain.sh -Djboss.mcast.addr=228.11.11.11 -Djboss.mcast.port=45688

5. 使用其他的协议栈

   在 JBoss EAP 5.x 里，你可以使用 jboss.default.jgroups.stack 系统属性来操纵用于群集服务的默认协议栈。$ EAP_HOME/bin/run.sh -c all -Djboss.default.jgroups.stack=tcp
   在 JBoss EAP 6 里，默认的协议栈是由 domain.xml 或 standalone-ha.xml里的 JGroups 子系统定义的：

   <subsystem xmlns="urn:jboss:domain:jgroups:1.0" default-stack="udp">
       <stack name="udp">
           <!-- ... -->
       </stack>
   </subsystem>
   

过程 3.23. 实现 HA 单点登录服务

1. 编写 HA 单点登录服务应用程序。

   下面是用 SingletonService decorater 包裹的服务作为单点登录服务部署的一个简单例子。

   1. 创建单点登录服务。

      下面是一个 singleton 服务的例子：

      package com.mycompany.hasingleton.service.ejb;
      
      import java.util.concurrent.atomic.AtomicBoolean;
      import java.util.logging.Logger;
      
      import org.jboss.as.server.ServerEnvironment;
      import org.jboss.msc.inject.Injector;
      import org.jboss.msc.service.Service;
      import org.jboss.msc.service.ServiceName;
      import org.jboss.msc.service.StartContext;
      import org.jboss.msc.service.StartException;
      import org.jboss.msc.service.StopContext;
      import org.jboss.msc.value.InjectedValue;
      
      /**
       * @author <a href="mailto:wfink@redhat.com">Wolf-Dieter Fink</a>
       */
      public class EnvironmentService implements Service<String> {
          private static final Logger LOGGER = Logger.getLogger(EnvironmentService.class.getCanonicalName());
          public static final ServiceName SINGLETON_SERVICE_NAME = ServiceName.JBOSS.append("quickstart", "ha", "singleton");
          /**
           * A flag whether the service is started.
           */
          private final AtomicBoolean started = new AtomicBoolean(false);
      
          private String nodeName;
      
          private final InjectedValue<ServerEnvironment> env = new InjectedValue<ServerEnvironment>();
      
          public Injector<ServerEnvironment> getEnvInjector() {
              return this.env;
          }
      
          /**
           * @return the name of the server node
           */
          public String getValue() throws IllegalStateException, IllegalArgumentException {
              if (!started.get()) {
                  throw new IllegalStateException("The service '" + this.getClass().getName() + "' is not ready!");
              }
              return this.nodeName;
          }
      
          public void start(StartContext arg0) throws StartException {
              if (!started.compareAndSet(false, true)) {
                  throw new StartException("The service is still started!");
              }
              LOGGER.info("Start service '" + this.getClass().getName() + "'");
              this.nodeName = this.env.getValue().getNodeName();
          }
      
          public void stop(StopContext arg0) {
              if (!started.compareAndSet(true, false)) {
                  LOGGER.warning("The service '" + this.getClass().getName() + "' is not active!");
              } else {
                  LOGGER.info("Stop service '" + this.getClass().getName() + "'");
              }
          }
      }
      
      

   2. 创建一个 Singleton EJB 在服务器启动时将这个服务作为 SingletonService 启动。

      下面是在服务器启动时启动 SingletonService 的 Singleton EJB 的例子：

      package com.mycompany.hasingleton.service.ejb;
      
      import java.util.Collection;
      import java.util.EnumSet;
      
      import javax.annotation.PostConstruct;
      import javax.annotation.PreDestroy;
      import javax.ejb.Singleton;
      import javax.ejb.Startup;
      
      import org.jboss.as.clustering.singleton.SingletonService;
      import org.jboss.as.server.CurrentServiceContainer;
      import org.jboss.as.server.ServerEnvironment;
      import org.jboss.as.server.ServerEnvironmentService;
      import org.jboss.msc.service.AbstractServiceListener;
      import org.jboss.msc.service.ServiceController;
      import org.jboss.msc.service.ServiceController.Transition;
      import org.jboss.msc.service.ServiceListener;
      import org.slf4j.Logger;
      import org.slf4j.LoggerFactory;
      
      
      /**
       * A Singleton EJB to create the SingletonService during startup.
       * 
       * @author <a href="mailto:wfink@redhat.com">Wolf-Dieter Fink</a>
       */
      @Singleton
      @Startup
      public class StartupSingleton {
        private static final Logger LOGGER = LoggerFactory.getLogger(StartupSingleton.class);
      
        /**
         * Create the Service and wait until it is started.<br/>
         * Will log a message if the service will not start in 10sec. 
         */
        @PostConstruct
        protected void startup() {
          LOGGER.info("StartupSingleton will be initialized!");
      
          EnvironmentService service = new EnvironmentService();
          SingletonService<String> singleton = new SingletonService<String>(service, EnvironmentService.SINGLETON_SERVICE_NAME);
          // if there is a node where the Singleton should deployed the election policy might set,
          // otherwise the JGroups coordinator will start it
          //singleton.setElectionPolicy(new PreferredSingletonElectionPolicy(new NamePreference("node2/cluster"), new SimpleSingletonElectionPolicy()));
          ServiceController<String> controller = singleton.build(CurrentServiceContainer.getServiceContainer())
              .addDependency(ServerEnvironmentService.SERVICE_NAME, ServerEnvironment.class, service.getEnvInjector())
              .install();
      
          controller.setMode(ServiceController.Mode.ACTIVE);
          try {
            wait(controller, EnumSet.of(ServiceController.State.DOWN, ServiceController.State.STARTING), ServiceController.State.UP);
            LOGGER.info("StartupSingleton has started the Service");
          } catch (IllegalStateException e) {
            LOGGER.warn("Singleton Service {} not started, are you sure to start in a cluster (HA) environment?",EnvironmentService.SINGLETON_SERVICE_NAME);
          }
        }
      
        /**
         * Remove the service during undeploy or shutdown
         */
        @PreDestroy
        protected void destroy() {
          LOGGER.info("StartupSingleton will be removed!");
          ServiceController<?> controller = CurrentServiceContainer.getServiceContainer().getRequiredService(EnvironmentService.SINGLETON_SERVICE_NAME);
          controller.setMode(ServiceController.Mode.REMOVE);
          try {
            wait(controller, EnumSet.of(ServiceController.State.UP, ServiceController.State.STOPPING, ServiceController.State.DOWN), ServiceController.State.REMOVED);
          } catch (IllegalStateException e) {
            LOGGER.warn("Singleton Service {} has not be stopped correctly!",EnvironmentService.SINGLETON_SERVICE_NAME);
          }
        }
      
        private static <T> void wait(ServiceController<T> controller, Collection<ServiceController.State> expectedStates, ServiceController.State targetState) {
          if (controller.getState() != targetState) {
            ServiceListener<T> listener = new NotifyingServiceListener<T>();
            controller.addListener(listener);
            try {
              synchronized (controller) {
                int maxRetry = 2;
                while (expectedStates.contains(controller.getState()) && maxRetry > 0) {
                  LOGGER.info("Service controller state is {}, waiting for transition to {}", new Object[] {controller.getState(), targetState});
                  controller.wait(5000);
                  maxRetry--;
                }
              }
            } catch (InterruptedException e) {
              LOGGER.warn("Wait on startup is interrupted!");
              Thread.currentThread().interrupt();
            }
            controller.removeListener(listener);
            ServiceController.State state = controller.getState();
            LOGGER.info("Service controller state is now {}",state);
            if (state != targetState) {
              throw new IllegalStateException(String.format("Failed to wait for state to transition to %s.  Current state is %s", targetState, state), controller.getStartException());
            }
          }
        }
      
        private static class NotifyingServiceListener<T> extends AbstractServiceListener<T> {
          @Override
          public void transition(ServiceController<? extends T> controller, Transition transition) {
            synchronized (controller) {
              controller.notify();
            }
          }
        }
      }
      
      

   3. 创建一个 Stateless Session Bean 从客户端访问服务。

      下面是一个通过客户端访问服务的 stateless session bean 的例子：

      package com.mycompany.hasingleton.service.ejb;
      
      import javax.ejb.Stateless;
      
      import org.jboss.as.server.CurrentServiceContainer;
      import org.jboss.msc.service.ServiceController;
      import org.slf4j.Logger;
      import org.slf4j.LoggerFactory;
      
      /**
       * A simple SLSB to access the internal SingletonService.
       * 
       * @author <a href="mailto:wfink@redhat.com">Wolf-Dieter Fink</a>
       */
      @Stateless
      public class ServiceAccessBean implements ServiceAccess {
          private static final Logger LOGGER = LoggerFactory.getLogger(ServiceAccessBean.class);
      
          public String getNodeNameOfService() {
              LOGGER.info("getNodeNameOfService() is called()");
              ServiceController<?> service = CurrentServiceContainer.getServiceContainer().getService(
                      EnvironmentService.SINGLETON_SERVICE_NAME);
              LOGGER.debug("SERVICE {}", service);
              if (service != null) {
                  return (String) service.getValue();
              } else {
                  throw new IllegalStateException("Service '" + EnvironmentService.SINGLETON_SERVICE_NAME + "' not found!");
              }
          }
      }
      
      

   4. 创建单点登录服务的商业逻辑接口。

      下面是一个用于 SingletonService 的商业逻辑接口的例子：

      package com.mycompany.hasingleton.service.ejb;
      
      import javax.ejb.Remote;
      
      /**
       * Business interface to access the SingletonService via this EJB
       * 
       * @author <a href="mailto:wfink@redhat.com">Wolf-Dieter Fink</a>
       */
      @Remote
      public interface ServiceAccess {
          public abstract String getNodeNameOfService();
      } 
      
      
      

2. 启动每个启用了群集的 JBoss EAP 6 实例。

   启用群集的方法取决于服务器是否是独立服务器还是运行在受管域里。

   1. 为运行在受管域l里的服务器启用群集。

      你可以使用管理 CLI 启用群集或者你可以手动编辑配置文件。

      • 使用管理 CLI 启用群集。

        1. 启动你的域控制器。

        2. 在你的操作系统里打开一个命令行提示窗口。

        3. 连接至管理 CLI，传入域控制器 IP 地址或 DNS 名称。

           在这个例子里，我们假设域控制器的 IP 地址是 192.168.0.14。
           • 对于 Linux，输入下列命令：

             $ EAP_HOME/bin/jboss-cli.sh --connect --controller=192.168.0.14
             $ Connected to domain controller at 192.168.0.14
             

           • 对于 Windows，输入下列命令：

             C:\>EAP_HOME\bin\jboss-cli.bat --connect --controller=192.168.0.14
             C:\> Connected to domain controller at 192.168.0.14
             

        4. 添加 main-server 服务器组。

           [domain@192.168.0.14:9999 /] /server-group=main-server-group:add(profile="ha",socket-binding-group="ha-sockets") 
           {
               "outcome" => "success",
               "result" => undefined,
               "server-groups" => undefined
           }
           

        5. 创建一个名为 server-one 的服务器并将其添加至 main-server 服务器组。

           [domain@192.168.0.14:9999 /]  /host=station14Host2/server-config=server-one:add(group=main-server-group,auto-start=false)
           {
               "outcome" => "success",
               "result" => undefined
           }
           

        6. 为 main-server 服务器组配置 JVM。

           [domain@192.168.0.14:9999 /] /server-group=main-server-group/jvm=default:add(heap-size=64m,max-heap-size=512m)
           {
               "outcome" => "success",
               "result" => undefined,
               "server-groups" => undefined
           }
           

        7. 创建一个名为 server-two 的服务器，将其放在独立的服务器组里并将端口偏移量设置为 100。

           [domain@192.168.0.14:9999 /]  /host=station14Host2/server-config=server-two:add(group=distinct2,socket-binding-port-offset=100)
           {
               "outcome" => "success",
               "result" => undefined
           }
           

      • 通过手动编辑服务器配置文件来启用群集。

        1. 停止 JBoss EAP 服务器。

           重要

           要使修改在服务器重启后仍然生效，你必须在编辑服务器配置文件前停止服务器。

        2. 打开 domain.xml 配置文件

           指定一个服务器组来使用 ha 配置集和 ha-sockets 套接字绑定组：

           <server-groups>
             <server-group name="main-server-group" profile="ha">
               <jvm name="default">
                 <heap size="64m" max-size="512m"/>
               </jvm>
               <socket-binding-group ref="ha-sockets"/>
             </server-group>
           </server-groups>
           
           

        3. 打开 host.xml 配置文件

           像下面这样修改这个文件：

           <servers>
             <server name="server-one" group="main-server-group" auto-start="false"/>
             <server name="server-two" group="distinct2">
               <socket-bindings port-offset="100"/>
             </server>
           <servers>
           
           

        4. 启动服务器。

           • 对于 Linux,，输入：EAP_HOME/bin/domain.sh。
           • 对于 Microsoft Windows，输入 EAP_HOME\bin\domain.bat。

   2. 为独立服务器启用群集

      要为独立服务器启用群集，用节点名称和 standalone-ha.xml 配置文件启动服务器：
      • 对于 Linux，输入：EAP_HOME/bin/standalone.sh --server-config=standalone-ha.xml -Djboss.node.name=UNIQUE_NODE_NAME
      • 对于 Microsoft Windows，输入：EAP_HOME\bin\standalone.bat --server-config=standalone-ha.xml -Djboss.node.name=UNIQUE_NODE_NAME

   注意

   为了避免在同一主机上运行多个服务器时出现端口冲突， 为每个服务器实例配置standalone-ha.xml 以绑定独立的接口。或者，你可以用端口偏移启动随后的服务器实例，如使用下列命令行里的参数：-Djboss.socket.binding.port-offset=100。

3. 将应用程序部署到服务器上

   如果你使用 Maven 来部署应用程序，请使用 Maven 命令部署到在默认端口运行的服务器：
   mvn clean install jboss-as:deploy
   要部署其他服务器，在命令行传入服务器名和端口号：
   mvn clean package jboss-as:deploy -Ddeploy.hostname=localhost -Ddeploy.port=10099

过程 3.24. 为 session bean 的远程商业接口添加 Maven 项目依赖关系。

1. 添加所需的项目依赖关系

   必须更新项目的 pom.xml 以包含必要的依赖关系。

2. 添加 jboss-ejb-client.properties 文件

   JBoss EJB 客户 API 期望在项目根目录找到名为 jboss-ejb-client.properties 的文件，它包含 JNDI 服务的连接信息。添加这个文件到项目的 src/main/resources/ 目录并包含下列内容。

   remote.connectionprovider.create.options.org.xnio.Options.SSL_ENABLED=false
   
   remote.connections=default
   
   remote.connection.default.host=localhost
   remote.connection.default.port = 4447
   remote.connection.default.connect.options.org.xnio.Options.SASL_POLICY_NOANONYMOUS=false
   
   

   根据你的服务器来修改主机名和端口号。4447 是默认的端口号码。对于安全的连接，请将 SSL_ENABLED 一行设置为 true 并取消 SSL_STARTTLS 行的注释。容器里的 Remoting 接口支持使用相同端口的安全和不安全的连接。

3. 为远程商业接口添加依赖关系

   在 pom.xml 里为 session bean 的远程商业接口添加 Maven 依赖关系。

   <dependency>
      <groupId>org.jboss.as.quickstarts</groupId>
      <artifactId>jboss-as-ejb-remote-server-side</artifactId>
      <type>ejb-client</type>
      <version>${project.version}</version>
   </dependency>
   

过程 3.25. 用 JNDI 获取 Bean 代理并调用 Bean 的方法

1. 处理 checked 异常

   下面代码里的两个方法 (InitialContext() 和 lookup()) 都会抛出类型为 javax.naming.NamingException 的 checked 异常。这些方法调用必须包括在捕获 NamingException 的 try/catch 块里，或者是再声明抛出 NamingException 的方法里。ejb-remote quickstart 使用了第二种方法。

2. 创建一个 JNDI 上下文

   JNDI 上下文对象提供了从服务器请求资源的机制。请使用下列代码创建 JNDI 上下文：

   final Hashtable jndiProperties = new Hashtable();
   jndiProperties.put(Context.URL_PKG_PREFIXES, "org.jboss.ejb.client.naming");
   final Context context = new InitialContext(jndiProperties);
   

   JNDI 服务的连接属性是从 jboss-ejb-client.properties 文件里读取的。

3. 使用 JNDI Context's lookup() 方法来获取 bean 代理

   调用 bean 代理的 lookup() 方法并将你请求的 session bean 的 JNDI 名称传入。这将返回一个对象，它必须转换为包含你要调用的方法的远程商业接口的类型。

   
   final RemoteCalculator statelessRemoteCalculator = (RemoteCalculator) context.lookup(
       "ejb:/jboss-as-ejb-remote-server-side/CalculatorBean!" + 
       RemoteCalculator.class.getName());
   
   

   Session bean JNDI 名称是用特殊语法定义的。

4. 调用方法

   现在你已有一个代理 bean 对象，你可以调用远程商业接口里包含的任何方法了。

   int a = 204;
   int b = 340;
   System.out.println("Adding " + a + " and " + b + " via the remote stateless calculator deployed on the server");
   int sum = statelessRemoteCalculator.add(a, b);
   System.out.println("Remote calculator returned sum = " + sum);
   

   代理 bean 将方法调用请求传入服务器上的 session bean。其结果被返回到代理 bean，然后再返回给调用者。代理 bean 和远程 session bean 间的通讯对于调用者来说是透明的。

过程 3.26. 在 EAP 6 上运行 EJB 2.x

1. 修改代码以使用新的 JNDI 命名空间规则

   和 EJB 3.0 不同，对于 EJB 2.x，你必须使用完整的 JNDI 前缀。关于新的 JNDI 命名空间规则和代码示例，请参考 第 3.1.8.1 节 “更新应用程序 JNDI 命名空间的名称”。
   以前版本里显示如何更新 JNDI 命名空间的示例可以在这里找到： 第 3.1.8.5 节 “以前版本的 JNDI 命名空间示例和它们在 JBoss EAP 6 里是如何指定的”。

2. 替换 JBoss AOP 拦截器

   EAP 6 里不再包含 JBoss AOP (Aspect Oriented Programming，面向方面编程) 。在以前的版本里，EJB 容器使用了 JBoss AOP。然而，在 JBoss EAP 6 里，EJB 容器使用了新的机制。如果你的应用程序使用 JBoss AOP，你需要象下面这样修改你的代码。

   • ejb3-interceptors-aop.xml 里的标准 EJB3 配置现在已经在服务器配置文件里完成了。对于独立的服务器，就是 standalone/configuration/standalone-full.xml 文件。如果你在受管域里运行服务器，这个文件将是 domain/configuration/domain.xml。
   • 集成 AOP 拦截器到 EJB 层的应用程序必须注册以使用 EJB3 拦截器和 CDI。服务器端的拦截器可以修改为 EJB3 拦截器。

3. 修改 jboss-web.xml 文件描述符

   对每个 <ejb-ref> 的 <jndi-name> 进行修改以使用新的 JNDI 全限定查找格式。

4. 替换 jboss.xml 部署描述符文件

   jboss-ejb3.xml 部署描述符替换 jboss.xml 以覆盖和添加 Java EE 定义的 ejb-jar.xml 里提供的功能。这个新文件和 jboss.xml 兼容，而目前的部署里已经忽略了jboss.xml。

5. 用 Full 配置集启动服务器

   EJB 2.x 要求 Java EE 6 的 Full 配置集。要用 Full 配置集启动 EAP 6，在启动服务器时请在命令行使用参数 -c standalone-full.xml。

过程 3.27. 移植 Seam 2.2 归档

1. 更新数据源配置

   某些 Seam 2.2 示例使用名为 java:/ExampleDS 的默认 JDBC 数据源。JBoss EAP 6 里已经修改了这个默认的数据源为 java:jboss/datasources/ExampleDS。如果你的应用程序使用了 example 数据库，你可以：

   • 如果你想使用 JBoss EAP 6 附带的示例数据库，请修改 META-INF/persistence.xml 文件以替换现有的 jta-data-source 元素为示例数据库数据源 JNDI 名：

     <!-- <jta-data-source>java:/ExampleDS</jta-data-source> -->
     <jta-data-source>java:jboss/datasources/ExampleDS</jta-data-source>
     

   • 如果你像保留现有的数据库，你可以在 EAP_HOME/standalone/configuration/standalone.xml 文件里添加数据源定义。

     重要

     要使修改在服务器重启后仍然生效，你必须在编辑服务器配置文件前停止服务器。
     下面是在 JBoss EAP 6 里定义的默认 HSQL 数据源定义：

     <datasource name="ExampleDS" jndi-name="java:/ExampleDS" enabled="true" jta="true" use-java-context="true" use-ccm="true">
        <connection-url>jdbc:h2:mem:test;DB_CLOSE_DELAY=-1</connection-url>
        <driver>h2</driver>
        <security>
           <user-name>sa</user-name>
           <password>sa</password>
        </security>
     </datasource>
     

   • 你也可以用 jbossadmin 命令行接口添加数据源定义。下面是你添加数据源所必须使用的语法。结尾的 "\" 表示下一行仍是命令行的一部分。

     例 3.1. 添加数据源定义的语法示例

     $ EAP_HOME/bin/jboss-cli --connect 
     [standalone@localhost:9999 /] data-source add --name=ExampleDS --jndi-name=java:/ExampleDS \ 
           --connection-url=jdbc:h2:mem:test;DB_CLOSE_DELAY=-1 --driver-name=h2 \ 
           --user-name=sa --password=sa
     

   关于如何配置数据源的更多信息，请参考 第 3.1.6.2 节 “更新数据源配置”。

2. 添加所需的依赖关系

   既然 Seam 2.2 应用程序使用了 JSF 1.2，你需要添加 JSF 1.2 模块的依赖关系并排除 JSF 2.0 模块。为了实现这一点，你需要在包含下列数据的 EAR 的 META-INF/ 目录下创建一个 jboss-deployment-structure.xml 文件：

   <jboss-deployment-structure xmlns="urn:jboss:deployment-structure:1.0">
     <deployment>
         <dependencies>
           <module name="javax.faces.api" slot="1.2" export="true"/>
                 <module name="com.sun.jsf-impl" slot="1.2" export="true"/>
         </dependencies>
     </deployment>
     <sub-deployment name="jboss-seam-booking.war">
       <exclusions>
           <module name="javax.faces.api" slot="main"/>
                 <module name="com.sun.jsf-impl" slot="main"/>
         </exclusions>
         <dependencies>
           <module name="javax.faces.api" slot="1.2"/>
                 <module name="com.sun.jsf-impl" slot="1.2"/>
         </dependencies>
     </sub-deployment>
   </jboss-deployment-structure>
   

   如果你的应用程序使用了第三方的日志框架，你需要添加如下这些依赖关系：第 3.1.4.1 节 “修改日志依赖关系”.

3. 如果你的应用程序使用了 Hibernate 3.x，请首先用 Hibernate 4 库来运行应用程序。

   如果你的应用程序没有使用 Seam Managed Persistence Context、Hibernate search、validation 或其他 Hibernate 4 里已修改的功能，你应该可以用 Hibernate 4 库来运行它。然而，如果你看到指向 Hiberante 类的 ClassNotFoundExceptions 或ClassCastExceptions，或者看到类似于下面的错误信息，你就可能需要遵循下一步的说明并修改应用程序以使用 Hibernate 3.x 库。

           Caused by: java.lang.LinkageError: loader constraint violation in interface itable initialization: when resolving method "org.jboss.seam.persistence.HibernateSessionProxy.getSession(Lorg/hibernate/EntityMode;)Lorg/hibernate/Session;" the class loader (instance of org/jboss/modules/ModuleClassLoader) of the current class, org/jboss/seam/persistence/HibernateSessionProxy, and the class loader (instance of org/jboss/modules/ModuleClassLoader) for interface org/hibernate/Session have different Class objects for the type org/hibernate/Session used in the signature
   

4. 从外部框架或其他位置复制依赖的归档

   如果你的应用程序使用了 Hibernate 3.x 且你无法成功使用 Hibernate 4，你需要像下面这样复制 Hibernate 3.x JAR 到 /lib 目录并在 META-INF/jboss-deployment-structure.xml 里的 deployment 部分排除 Hibernate 库：

   <jboss-deployment-structure xmlns="urn:jboss:deployment-structure:1.0">
    <deployment>
      <exclusions>
        <module name="org.hibernate"/>
      </exclusions>
    <deployment>
   </jboss-deployment-structure>
   

   当你的应用程序捆绑 Hibernate 3.x 时你还必须采取一些其他的步骤。相关的信息，请参考 第 3.2.2.2 节 “修改使用 Hibernate 和 JPA 的应用程序的配置”。

5. 调试和解决 Seam 2.2 JNDI 错误

   当你移植 Seam 2.2 应用程序时，你可能会在日志里使用 javax.naming.NameNotFoundException错误：

   javax.naming.NameNotFoundException: Name 'jboss-seam-booking' not found in context ''

   如果你不想修改代码里的 JNDI 查找，你可以修改应用程序的 components.xml 文件：

   1. 替换现有的 core-init 元素

      首先，你需要替换现有的 core-init 元素：

      <!-- <core:init jndi-pattern="jboss-seam-booking/#{ejbName}/local" debug="true" distributable="false"/>   -->
      <core:init debug="true" distributable="false"/>
      
      

   2. 找到服务器日志里的 JNDI 绑定 INFO 消息

      然后，在服务器日志里找到应用程序部署时的 JNDI 绑定 INFO 消息。JNDI 绑定消息应该类似于：

      INFO org.jboss.as.ejb3.deployment.processors.EjbJndiBindingsDeploymentUnitProcessor (MSC service thread 1-1) JNDI bindings for session bean
      named AuthenticatorAction in deployment unit subdeployment "jboss-seam-booking.jar" of deployment "jboss-seam-booking.ear" are as follows:
          java:global/jboss-seam-booking/jboss-seam-booking.jar/AuthenticatorAction!org.jboss.seam.example.booking.Authenticator
          java:app/jboss-seam-booking.jar/AuthenticatorAction!org.jboss.seam.example.booking.Authenticator
          java:module/AuthenticatorAction!org.jboss.seam.example.booking.Authenticator
          java:global/jboss-seam-booking/jboss-seam-booking.jar/AuthenticatorAction
          java:app/jboss-seam-booking.jar/AuthenticatorAction
          java:module/AuthenticatorAction
      

   3. 添加组件元素

      对于日志里的每个 JNDI 绑定 INFO 消息，添加匹配的 component 元素 components.xml 文件：

      <component class="org.jboss.seam.example.booking.AuthenticatorAction" jndi-name="java:app/jboss-seam-booking.jar/AuthenticatorAction" />
      

   关于如何调试和解决移植问题的更多信息，请参考 第 4.2.1 节 “调试和解决移植问题”。
   关于 Seam 2 归档的已知移植问题列表，请参考 第 3.2.11.2 节 “Seam 2.2 归档移植的问题”。