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. 修改 ResourceBundle 属性的位置

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
          

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

          C:\>EAP_HOME\bin\jboss-cli.bat --connect
          

        您应该看到下面的结果：

        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. 在 EAR 的 lib/ 或 WAR 部署的 WEB-INF/classes/ 里包含 log4j.properties 或 log4j.xml 文件。如果您想将文件放到 lib/ 目录里，您必须在 jboss-deployment-structure.xml 文件里指定 <resource-root> 路径。

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

4. 用下列 runtime 参数启动 JBoss EAP 6 服务器以防止在部署应用程序时控制台出现 ClassCastException。

   -Dorg.jboss.as.logging.per-deployment=false

5. 部署您的应用程序

过程 3.6. 配置 JBoss EAP 6.3 或更新版本的日志依赖关系

1. 用下列 runtime 参数启动 JBoss EAP 6 服务器以防止在部署应用程序时控制台出现 ClassCastException。

   -Dorg.jboss.as.logging.per-deployment=false

2. 打开终端窗口并连接至管理 CLI。
   • 对于 Linux，输入下列命令：

     $ EAP_HOME/bin/jboss-cli.sh --connect
     

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

     C:\>EAP_HOME\bin\jboss-cli.bat --connect
     

3. 修改日志子系统里的 add-logging-api-dependencies 属性。
   这个属性控制容器是否添加隐性的 logging API 依赖关系到部署里。

   • 如果为 true（默认值），将添加所有隐性的 logging API 依赖关系。
   • 如果设置为 false，依赖关系不会添加到部署里。
   要排除第三方的日志框架依赖关系，您必须用下列命令设置这个属性为 false。

   /subsystem=logging:write-attribute(name=add-logging-api-dependencies, value=false)

   这个命令添加了 <add-logging-api-dependencies> 元素到 standalone.xml 配置文件的 logging 子系统里。

   <subsystem xmlns="urn:jboss:domain:logging:1.4">
       <add-logging-api-dependencies value="false"/>
       ....
   </subsystem>
   
   

4. 部署您的应用程序

过程 3.7. 修改代码和依赖关系以使用新的 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.8. 修改归档的打包

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.9. 安装和配置 JDBC 驱动

1. 安装 JDBC 驱动。

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

      这是我们推荐的安装驱动的方法。当 JDBC 驱动作为部署安装时，它会被部署为常规的 JAR。如果 JBoss EAP 实例作为独立服务器运行，请将兼容 JDBC 4.0 的 JAR 复制到 EAP_HOME/standalone/deployments/ 目录。对于受管域，您必须使用管理控制台或管理 CLI 将 JAR 部署到服务器组里。
      下面是一个安装为独立服务器的部署的 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

      • 在 deployment 目录里创建一个 java.sql.Driver 文件。对于作为独立服务器运行的 JBoss EAP 6 实例，这个文件应该位于：EAP_HOME/standalone/deployments/META-INF/services/java.sql.Driver。如果服务器位于受管服务器，您必须使用管理控制台或管理 CLI 来部署这个文件。
      这种方法的优点是：

      • 因为不需要定义模块，所以这是最简单的方法。
      • 当服务器运行在受管域里时，使用这个方法的部署将自动传播到域里的所有服务器。这意味着管理员不需要手动分发这个驱动 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. 更新程序代码里的 JNDI 引用。

   您必须在程序源代码里替换过时的 JNDI 查找名称以使用新的 JNDI 标准化数据源名称。详情请参考： 第 3.1.8.4 节 “修改应用程序以遵循新的 JNDI 命名规则”。
   您也必须让现有的访问数据源的 @Resource 注解使用新的 JNDI 名称。例如：

   @Resource(name = "java:/YourDatasourceName").
   

过程 3.10. 删除 Hibernate 捆绑

1. 从您的应用程序的库目录里将 Hibernate JAR 删除。
2. 当不再需要 <hibernate.transaction.manager_lookup_class> 元素时，在 persistence.xml 里将其删除或注释。

过程 3.11. 禁用额外的授权检查

• 您可以禁用额外的授权检查并通过下列方法之一坚持使用现有的 PicketLink 部署。

  • 设置系统属性

    您可以通过设置 org.jboss.ws.cxf.disableHandlerAuthChecks 属性为 true 来禁用服务器级别的额外授权检查。这个方法会影响应用服务器上的所有部署。
    关于设置系统属性的信息，请参考《管理和配置指南》里的 『用管理 CLI 配置系统属性』。

  • 在部署的 Web 服务描述文件里创建一个属性

    您可以通过设置 jboss-webservices.xml 文件里的 org.jboss.ws.cxf.disableHandlerAuthChecks 属性为 true 来禁用部署级别的额外授权检查。这个方法只会影响专有的部署。
    1. 在您要禁用额外授权检查的部署的 META-INF/ 目录里创建一个 jboss-webservices.xml 文件。
    2. 添加下列内容：

       <?xml version="1.1" encoding="UTF-8"?>
       <webservices xmlns="http://www.jboss.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         version="1.2" xsi:schemaLocation="http://www.jboss.com/xml/ns/javaee">
         <property>
           <name>org.jboss.ws.cxf.disableHandlerAuthChecks</name>
           <value>true</value>
         </property>
       </webservices>
       

过程 3.12. 修改 JNDI 查找

1. 了解更多的 第 3.1.8.2 节 “可移植的 EJB JNDI 名称”
2. 第 3.1.8.3 节 “复核 JNDI 命名空间规则”
3. 第 3.1.8.4 节 “修改应用程序以遵循新的 JNDI 命名规则”

过程 3.13. 配置应用程序

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.14. 更新应用程序以使用 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 应用程序的持久化属性” 如果您准备在群集环境里运行您的应用程序。

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 值。

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. DTS 命名空间映射表

   以前的 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.15. 设置持久化属性以运行在群集环境里

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.16. 修改 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.17. 您可能需要执行一个或多个下面的任务：

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.18. 创建 JMS 桥

1. 配置源 JBoss EAP 5.x 服务器上的 JMS 桥

   为了避免版本间类的冲突，您必须使用下列过程配置 JBoss EAP 5.x 上的 JMS 桥。SAR 目录和桥的名称可以是任意的，也可以进行修改。
   1. 在 JBoss EAP 5 的 deployment 目录里创建一个子目录来包含 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 EAP 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 查找和桥 "target" 都包括用户 "jbossuser"（密码 "jbosspass"）的安全性凭证。这是因为 JBoss 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 里的类相冲突。

2. 配置目的 JBoss EAP 6 服务器上的 JMS 桥

   在 JBoss EAP 6.1 以后的版本里，JMS 桥可以用于从任何兼容 JMS 1.1 的服务器上桥接消息。因为源和目标 JMS 资源是用 JNDI 进行查找的，源消息供应商或消息中介的 JNDI 查找类必须捆绑在 JBoss 模块里。下面的过程使用了虚拟的 'MyCustomMQ' 消息中介作为例子。
   1. 为消息供应商创建 JBoss 模块。
      1. 在 EAP_HOME/modules/system/layers/base/ 下为新的模块创建一个目录结构。main/ 子目录将包含客户 JAR 和 module.xml 文件。下面是为消息供应商 MyCustomMQ 创建的一个目录结构示例：EAP_HOME/modules/system/layers/base/org/mycustommq/main/。
      2. 在 main/ 子目录里，创建一个包含消息供应商的模块定义的 module.xml 文件。下面是为消息供应商 MyCustomMQ 创建的 module.xml 示例。

         <?xml version="1.0" encoding="UTF-8"?>
         <module xmlns="urn:jboss:module:1.1" name="org.mycustommq">
             <properties>
                 <property name="jboss.api" value="private"/>
             </properties> 
         
             <resources>
                 <!-- Insert resources required to connect to the source or target   -->
                 <resource-root path="mycustommq-1.2.3.jar" />
                 <resource-root path="mylogapi-0.0.1.jar" />
             </resources> 
         
             <dependencies>
                <!-- Add the dependencies required by JMS Bridge code                 -->
                <module name="javax.api" />
                <module name="javax.jms.api" />
                <module name="javax.transaction.api"/>
                <!-- Add a dependency on the org.hornetq module since we send         -->
                <!-- messages tothe HornetQ server embedded in the local EAP instance -->
                <module name="org.hornetq" />
             </dependencies>
         </module>
         
         

      3. 从源资源复制消息供应商用于 JNDI 查找的的 JAR 到模块的 main/ 子目录。MyCustomMQ 模块的目录结构应该类似于：

         modules/
         `-- system
             `-- layers
                 `-- base
                     `-- org
                           `-- mycustommq
                               `-- main
                                   |-- mycustommq-1.2.3.jar
                                   |-- mylogapi-0.0.1.jar
                                   |-- module.xml
         

   2. 配置部署到 JBoss EAP 6 服务器的 messaging 子系统的 JMS 桥。
      1. 在开始之前，请先停止服务器并备份当前的服务器配置文件。如果是作为独立服务器运行，它是 EAP_HOME/standalone/configuration/standalone-full-ha.xml。如果是运行的受管域，请备份 EAP_HOME/domain/configuration/domain.xml 以及 EAP_HOME/domain/configuration/host.xml。
      2. 在服务器配置文件里的 messaging 子系统里添加 jms-bridge 元素。source 和 target 元素提供的用于 JNDI 查找的 JMS 资源的名称。如果指定了 user 和 password 凭证，当创建 JMS 连接时它们会作为参数传入。
         下面是一个为消息供应商 MyCustomMQ 配置的 jms-bridge 元素例子：

         <subsystem xmlns="urn:jboss:domain:messaging:1.3">
            ...
            <jms-bridge name="myBridge" module="org.mycustommq">
               <source>
                  <connection-factory name="ConnectionFactory"/>
                  <destination name="sourceQ"/>
                  <user>user1</user>
                  <password>pwd1</password>
                  <context>
                     <property key="java.naming.factory.initial" value="org.mycustommq.jndi.MyCustomMQInitialContextFactory"/>
                     <property key="java.naming.provider.url"    value="tcp://127.0.0.1:9292"/>
                  </context>
               </source>
               <target>
                  <connection-factory name="java:/ConnectionFactory"/>
                  <destination name="/jms/targetQ"/>
               </target>
               <quality-of-service>DUPLICATES_OK</quality-of-service>
               <failure-retry-interval>500</failure-retry-interval>
               <max-retries>1</max-retries>
               <max-batch-size>500</max-batch-size>
               <max-batch-time>500</max-batch-time>
               <add-messageID-in-header>true</add-messageID-in-header>
            </jms-bridge>
         </subsystem>
         
         

         在上面的例子里，JNDI 属性是在 source 的 context 元素里定义的。如上面的 target 例子，如果忽略了 context 元素，JMS 资源将在本地实例里进行查找。

过程 3.19. 在开始之前

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

过程 3.20. 修改提供者为 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.7.5 节 “用 HornetQ 配置消息系统”。

3. 移植现有的消息

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

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 命令行参数来指定用于群集的绑定地址：

   $ EAP5_HOME/bin/run.sh -c all -b 192.168.0.2

   JBoss EAP 6 绑定套接字到 standalone.xml、domain.xml 和 host.xml 文件里 <interfaces> 元素的 IP 地址和接口。JBoss EAP 6 附带的标准配置包含两个接口配置：

   <interfaces>
       <interface name="management">
           <inet-address value="${jboss.bind.address.management:127.0.0.1}"/>
       </interface>
       <interface name="public">
          <inet-address value="${jboss.bind.address:127.0.0.1}"/>
       </interface>
   </interfaces>
   

   这些接口配置使用了系统属性 jboss.bind.address.management 和 jboss.bind.address 的值。如果没有设置这些系统属性，默认的 127.0.0.1 将被使用。
   您也可以在启动服务器时指定绑定地址为命令行参数，或者您可以在 JBoss EAP 6 服务器配置文件里显性地定义它。
   • 在启动 JBoss EAP 独立服务器时在命令行指定绑定参数。
     下面是一个如何在命令行为独立服务器指定绑定地址的例子：

     EAP_HOME/bin/standalone.sh -Djboss.bind.address=127.0.0.1

     注意

     您也可以使用 -b 参数，它是 -Djboss.bind.address=127.0.0.1 的快捷方式。

     EAP_HOME/bin/standalone.sh -b=127.0.0.1

     JBoss EAP 5 的语法格式仍被支持：

     EAP_HOME/bin/standalone.sh -b 127.0.0.1

     请注意 -b 参数只会修改 public 接口。它不会影响 management 接口。
   • 在服务器配置文件里指定绑定地址。
     对于运行在受管域里的服务器，请在 domain/configuration/host.xml 文件里指定绑定地址。对于独立服务器，请在 standalone-ha.xml 文件里指定绑定地址。
     在下面的例子里，public 接口被指定为 ha-sockets 套接字绑定组里的所有套接字的默认接口。

     <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>
     

     注意

     如果您用硬编码值而不是配置文件里的系统属性来指定绑定地址，那您无法用命令行参数来覆盖它。

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 分别指定用于群集间通讯的多点传送地址和端口，如：

   $ EAP5_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 系统属性来操纵用于群集服务的默认协议栈。

   $ EAP5_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>
   

6. 替换 Buddy Replication

   JBoss EAP 5.x 使用 JBoss Cache Buddy Replication 来抑制将数据复制到群集里的所有实例。
   在 JBoss EAP 6 里，Buddy Replication 已被 Infinispan 的分布式缓存（也称为 DIST 模式）所替代。Distribution 是一个强大的群集模式，它允许 Infinispan 在添加更多服务器到群集里时进行线性扩充。下面是配置服务器使用 DIST 缓存模式的例子。
   1. 打开命令行窗口并用 HA 或 Full 配置集启动服务器，例如：

      EAP_HOME/bin/standalone.sh -c standalone-ha.xml

   2. 打开另外一个命令行窗口并连接至管理 CLI。
      • 对于 Linux，输入下列命令：

        $ EAP_HOME/bin/jboss-cli.sh --connect
        

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

        C:\>EAP_HOME\bin\jboss-cli.bat --connect
        

      您应该看到下面的结果：

      Connected to standalone controller at localhost:9999

   3. 运行下列命令：

      /subsystem=infinispan/cache-container=web/:write-attribute(name=default-cache,value=dist)
      /subsystem=infinispan/cache-container=web/distributed-cache=dist/:write-attribute(name=owners,value=3)
      :reload
      

      您应该在每条命令后看到下面的结果：

      "outcome" => "success"
      

      这些命令修改了 standalone-ha.xml 文件的 infinispan 子系统的 web <cache-container> 配置里的 dist <distributed-cache> 元素：

      <cache-container name="web" aliases="standard-session-cache" default-cache="dist" module="org.jboss.as.clustering.web.infinispan">
          <transport lock-timeout="60000"/>
          <replicated-cache name="repl" mode="ASYNC" batching="true">
              <file-store/>
          </replicated-cache>
          <replicated-cache name="sso" mode="SYNC" batching="true"/>
          <distributed-cache name="dist" owners="3" l1-lifespan="0" mode="ASYNC" batching="true">
              <file-store/>
          </distributed-cache>
      </cache-container>
      
      

      更多的信息请参考客户门户 https://access.redhat.com/site/documentation/JBoss_Enterprise_Application_Platform/ 上的《JBoss EAP 6 开发指南》里的『Web 应用程序里的群集』章节。

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

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

   下面是一个将部署为单点登录服务的用 SingletonService decorator 包裹的 Service 的简单例子。完整的例子请参考 JBoss EAP 6 附带的 cluster-ha-singleton quickstart。这个 Quickstart 包含构建和部署应用程序的所有说明。

   1. 创建服务。

      下面是一个服务的示例：

      package org.jboss.as.quickstarts.cluster.hasingleton.service.ejb;
      
      import java.util.Date;
      import java.util.concurrent.atomic.AtomicBoolean;
      
      import javax.naming.InitialContext;
      import javax.naming.NamingException;
      
      import org.jboss.logging.Logger;
      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;
      
      
      /**
       * @author <a href="mailto:wfink@redhat.com">Wolf-Dieter Fink</a>
       */
      public class HATimerService implements Service<String> {
          private static final Logger LOGGER = Logger.getLogger(HATimerService.class);
          public static final ServiceName SINGLETON_SERVICE_NAME = ServiceName.JBOSS.append("quickstart", "ha", "singleton", "timer");
      
          /**
           * A flag whether the service is started.
           */
          private final AtomicBoolean started = new AtomicBoolean(false);
      
          /**
           * @return the name of the server node
           */
          public String getValue() throws IllegalStateException, IllegalArgumentException {
              LOGGER.infof("%s is %s at %s", HATimerService.class.getSimpleName(), (started.get() ? "started" : "not started"), System.getProperty("jboss.node.name"));
              return "";
          }
      
          public void start(StartContext arg0) throws StartException {
              if (!started.compareAndSet(false, true)) {
                  throw new StartException("The service is still started!");
              }
              LOGGER.info("Start HASingleton timer service '" + this.getClass().getName() + "'");
      
              final String node = System.getProperty("jboss.node.name");
              try {
                  InitialContext ic = new InitialContext();
                  ((Scheduler) ic.lookup("global/jboss-cluster-ha-singleton-service/SchedulerBean!org.jboss.as.quickstarts.cluster.hasingleton.service.ejb.Scheduler")).initialize("HASingleton timer @" + node + " " + new Date());
              } catch (NamingException e) {
                  throw new StartException("Could not initialize timer", e);
              }
          }
      
          public void stop(StopContext arg0) {
              if (!started.compareAndSet(true, false)) {
                  LOGGER.warn("The service '" + this.getClass().getName() + "' is not active!");
              } else {
                  LOGGER.info("Stop HASingleton timer service '" + this.getClass().getName() + "'");
                  try {
                      InitialContext ic = new InitialContext();
                      ((Scheduler) ic.lookup("global/jboss-cluster-ha-singleton-service/SchedulerBean!org.jboss.as.quickstarts.cluster.hasingleton.service.ejb.Scheduler")).stop();
                  } catch (NamingException e) {
                      LOGGER.error("Could not stop timer", e);
                  }
              }
          }
      }
      
      

   2. 创建一个将 Service 安装为群集单点登录服务的激活器。

      下面的列表是一个服务激活器的例子，它将 HATimerService 安装为群集单点登录服务：

      package org.jboss.as.quickstarts.cluster.hasingleton.service.ejb;
      
      import org.jboss.as.clustering.singleton.SingletonService;
      import org.jboss.logging.Logger;
      import org.jboss.msc.service.DelegatingServiceContainer;
      import org.jboss.msc.service.ServiceActivator;
      import org.jboss.msc.service.ServiceActivatorContext;
      import org.jboss.msc.service.ServiceController;
      
      
      /**
       * Service activator that installs the HATimerService as a clustered singleton service
       * during deployment.
       *
       * @author Paul Ferraro
       */
      public class HATimerServiceActivator implements ServiceActivator {
          private final Logger log = Logger.getLogger(this.getClass());
      
          @Override
          public void activate(ServiceActivatorContext context) {
              log.info("HATimerService will be installed!");
      
              HATimerService service = new HATimerService();
              SingletonService<String> singleton = new SingletonService<String>(service, HATimerService.SINGLETON_SERVICE_NAME);
              /*
               * To pass a chain of election policies to the singleton, for example, 
               * to tell JGroups to prefer running the singleton on a node with a
               * particular name, uncomment the following line:
               */
              // singleton.setElectionPolicy(new PreferredSingletonElectionPolicy(new SimpleSingletonElectionPolicy(), new NamePreference("node2/cluster")));
      
              singleton.build(new DelegatingServiceContainer(context.getServiceTarget(), context.getServiceRegistry()))
                      .setInitialMode(ServiceController.Mode.ACTIVE)
                      .install()
              ;
          }
      }
      
      

      注意

      上面的代码示例使用了 org.jboss.as.clustering.singleton.SingletonService 类，它是 JBoss EAP 私有 API 的一部分。JBoss EAP 7 里将有可用的公共 API，私有 API 会被废弃，但在 EAP 6.x 发行周期里我们仍将维护这个类。

   3. 创建 ServiceActivator 文件

      在应用程序的 resources/META-INF/services/ 目录里创建一个名为 org.jboss.msc.service.ServiceActivator 的文件。请添加包含之前步骤里创建的 ServiceActivator 类的全限定名称的一行内容。

      org.jboss.as.quickstarts.cluster.hasingleton.service.ejb.HATimerServiceActivator 

   4. 创建一个 Singleton bean，它实现了用作群集内 Singleton Timer 的 Timer。

      这个 Singleton bean 不能有 remote 接口，而且您不能从任何应用程序里的其他 EJB 引用其 local 接口。这阻止了客户或其他组件的查找，从而确保 SingletonService 可以完全控制单点登录。

      1. 创建 Scheduler 接口

         package org.jboss.as.quickstarts.cluster.hasingleton.service.ejb;
         
         /**
          * @author <a href="mailto:wfink@redhat.com">Wolf-Dieter Fink</a>
          */
         public interface Scheduler {
         
             void initialize(String info);
         
             void stop();
         
         } 
         
         

      2. 创建实现群集内 Singleton Timer 的 Singleton bean。

         package org.jboss.as.quickstarts.cluster.hasingleton.service.ejb;
         
         import javax.annotation.Resource;
         import javax.ejb.ScheduleExpression;
         import javax.ejb.Singleton;
         import javax.ejb.Timeout;
         import javax.ejb.Timer;
         import javax.ejb.TimerConfig;
         import javax.ejb.TimerService;
         
         import org.jboss.logging.Logger;
         
         
         /**
          * A simple example to demonstrate a implementation of a cluster-wide singleton timer.
          *
          * @author <a href="mailto:wfink@redhat.com">Wolf-Dieter Fink</a>
          */
         @Singleton
         public class SchedulerBean implements Scheduler {
             private static Logger LOGGER = Logger.getLogger(SchedulerBean.class);
             @Resource
             private TimerService timerService;
         
             @Timeout
             public void scheduler(Timer timer) {
                 LOGGER.info("HASingletonTimer: Info=" + timer.getInfo());
             }
         
             @Override
             public void initialize(String info) {
                 ScheduleExpression sexpr = new ScheduleExpression();
                 // set schedule to every 10 seconds for demonstration
                 sexpr.hour("*").minute("*").second("0/10");
                 // persistent must be false because the timer is started by the HASingleton service
                 timerService.createCalendarTimer(sexpr, new TimerConfig(info, false));
             }
         
             @Override
             public void stop() {
                 LOGGER.info("Stop all existing HASingleton timers");
                 for (Timer timer : timerService.getTimers()) {
                     LOGGER.trace("Stop HASingleton timer: " + timer.getInfo());
                     timer.cancel();
                 }
             }
         }
         
         

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

   要为独立服务器启用群集，您必须用 HA 配置集启动每个服务器并对每个实例使用唯一的节点名称和端口偏移量。
   • 对于 Linux，请使用下列命令行语法启动服务器：

     EAP_HOME/bin/standalone.sh --server-config=standalone-ha.xml -Djboss.node.name=UNIQUE_NODE_NAME -Djboss.socket.binding.port-offset=PORT_OFFSET

     例 3.1. 在 Linux 上启动多个独立服务器实例

     $ EAP_HOME/bin/standalone.sh --server-config=standalone-ha.xml -Djboss.node.name=node1
     $ EAP_HOME/bin/standalone.sh --server-config=standalone-ha.xml -Djboss.node.name=node2 -Djboss.socket.binding.port-offset=100

   • 对于 Microsoft Windows，请使用下列命令行语法启动服务器：

     EAP_HOME\bin\standalone.bat --server-config=standalone-ha.xml -Djboss.node.name=UNIQUE_NODE_NAME -Djboss.socket.binding.port-offset=PORT_OFFSET

     例 3.2. 在 Microsoft Windows 上启动多个独立服务器实例

     C:> EAP_HOME\bin\standalone.bat --server-config=standalone-ha.xml -Djboss.node.name=node1
     C:> EAP_HOME\bin\standalone.bat --server-config=standalone-ha.xml -Djboss.node.name=node2 -Djboss.socket.binding.port-offset=100

   注意

   如果您不想使用命令行参数，您可以为每个服务器实例配置 standalone-ha.xml 文件以绑定到单独的接口上。

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

   下面的 Maven 命令部署应用程序到运行在默认端口的独立服务器上。

   mvn clean install jboss-as:deploy

   要部署到其他的服务器，请传入服务器名称。如果位于不同的主机，在命令行上要指定端口号码：

   mvn clean package jboss-as:deploy -Djboss-as.hostname=localhost -Djboss-as.port=10099

   设置 JBoss EAP 6 附带的 cluster-ha-singleton quickstart 的 Maven 配置和部署细节。

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

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

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

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

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

   # In the following line, set SSL_ENABLED to true for SSL
   remote.connectionprovider.create.options.org.xnio.Options.SSL_ENABLED=false
   remote.connections=default
   # Uncomment the following line to set SSL_STARTTLS to true for SSL
   # remote.connection.default.connect.options.org.xnio.Options.SSL_STARTTLS=true
   remote.connection.default.host=localhost
   remote.connection.default.port = 4447
   remote.connection.default.connect.options.org.xnio.Options.SASL_POLICY_NOANONYMOUS=false
   # Add any of the following SASL options if required
   # remote.connection.default.connect.options.org.xnio.Options.SASL_POLICY_NOANONYMOUS=false
   # remote.connection.default.connect.options.org.xnio.Options.SASL_POLICY_NOPLAINTEXT=false
   # remote.connection.default.connect.options.org.xnio.Options.SASL_DISALLOWED_MECHANISMS=JBOSS-LOCAL-USER
   
   

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

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

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

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

过程 3.23. 用 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-ejb-remote-server-side//CalculatorBean!" + 
       RemoteCalculator.class.getName());
   
   

   Session bean 的 JNDI 名称是用特殊语法定义的。详情请参考 第 3.2.10.3 节 “EJB 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.25. 移植 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>
     

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

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

     $ 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.13.2 节 “Seam 2.2 归档移植的问题”。