在第一次创建 Maven 项目之前，最好确保正确配置了 IDE 以使用本地 Maven 安装和本地 Maven 资源库。不应使用嵌入式 Maven 快照来开发项目。

1. 在 IDE 中打开“选项”窗口。
2. 在“选项”窗口中选择“其他”类别，然后单击 "Maven" 标签。
3. 指定 Maven 在本地的安装位置（要求为 2.0.9 或更高版本）。
4. 检查本地 Maven 资源库的位置是否正确。
5. 选择“确定”以关闭“选项”窗口。

如果系统上未安装 Maven，则可以从 Maven 站点中下载安装程序。

本地和远程 Maven 资源库可用于代码完成以及生成项目。应更新 Maven 远程资源库索引，以确保在开发项目时可方便地使用所需的任何工件。可以在“选项”窗口的 "Maven" 标签中配置 IDE 检查更新的频率。您可以执行即时更新检查，并使用 Maven 资源库浏览器浏览本地和远程 Maven 资源库。

1. 选择“窗口”>“其他”>“Maven 资源库浏览器”。
2. 单击“Maven 资源库浏览器”窗口顶部的“更新索引”（）。

在单击“更新索引”时，IDE 将检查并下载每个 Maven 远程资源库的最新索引。索引表示位于资源库中的工件的当前状态，并用于提供对可用于应用程序的工件的引用。缺省情况下，在明确需要工件之前，IDE 不会从资源库中下载该工件。

注意：索引很大，可能需要一些时间才能全部更新。

在开发 Maven 应用程序时，通常不需要在生成应用程序之前指定应用服务器。不过，要利用 IDE 中的某些代码生成功能，本教程将在开始编写代码之前设置目标服务器。通过设置部署服务器，IDE 可以识别服务器支持的技术，并在某些向导中启用各种选项以生成针对该服务器优化的代码。

1. 启动 GlassFish 服务器。
2. 在“项目”窗口中右键单击 EJB 项目节点，然后选择“属性”。
3. 在“属性”窗口中选择“运行”类别。
4. 选择 "GlassFish Server"。单击“确定”。

通过在编码之前将 GlassFish 指定为部署服务器，IDE 将启用在向导中选择 JTA 的选项以创建持久性单元。还可以选择使用在服务器中注册的任何数据源。

创建持久性单元

在本练习中，将在 EJB 项目中创建一个持久性单元。持久性单元指定数据库连接详细信息以及如何管理事务。对于此应用程序，将在“新建持久性单元”向导中指定 JTA，因为您希望由 GlassFish 服务器管理事务。

要创建持久性单元，请执行以下步骤：

1. 右键单击 EJB 项目节点，然后从弹出式菜单中选择“新建”>“其他”以打开“新建文件”向导。
2. 从“持久性”类别中选择“持久性单元”。单击“下一步”。
3. 在“新建持久性单元”对话框中，选择 EclipseLink 作为持久性提供器。
4. 选择数据源（例如，如果要使用 JavaDB，则选择 "jdbc/sample"）。

   在安装 IDE 和 GlassFish 服务器时，jdbc/sample 的数据源将与 IDE 资源包捆绑在一起；但如果要使用不同的数据库，则可以指定不同的数据源。

   您可以保留其他缺省选项（持久性单元名称、EclipseLink 持久性提供器）。

5. 确保选中“使用 Java 事务 API”，并且将“表生成策略”设置为“创建”，以便在部署应用程序时创建基于实体类的表。单击“完成”。

在单击“完成”时，IDE 将创建 XML 文件 persistence.xml 并在编辑器中打开该文件。在“项目”窗口中，您可以看到在“其他源”> "src/main/resources" > "META-INF" 目录中创建了该文件。该文件包含连接到数据库以及如何管理事务的详细信息。如果在编辑器中单击 "XML"，则可以在 persistence.xml 中看到以下元素。

<persistence-unit name="com.mycompany_MavenEnterpriseApp-ejb_ejb_1.0-SNAPSHOTPU" transaction-type="JTA">
    <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
    <jta-data-source>jdbc/sample</jta-data-source>
    <exclude-unlisted-classes>false</exclude-unlisted-classes>
    <properties>
      <property name="eclipselink.ddl-generation" value="create-tables"/>
    </properties>
</persistence-unit>
            

您可以看到将 JTA 指定为事务类型，并且应用程序使用注册的数据源 jdbc/sample。

创建实体类

在本练习中，将在 EJB 项目中创建一个实体类以表示永久保存到数据库中的对象。要创建 NewsEntity 实体类，请执行以下步骤：

1. 右键单击“项目”窗口中的“EJB 模块”，然后选择“新建”＞“其他”打开“新建文件”向导。
2. 从“持久性”类别中选择“实体类”。单击“下一步”。
3. 键入 NewsEntity 作为类名。
4. 键入 ejb 作为包名并将“主键类型”保留为 Long。单击“完成”。

单击“完成”后，实体类 NewsEntity.java 在源代码编辑器中打开。在源代码编辑器中，执行以下步骤以添加一些字段。

1. 在该类中添加以下字段声明。

   private String title;
   private String body;

2. 在源代码编辑器中单击鼠标右键，选择“插入代码”，然后从弹出式菜单中选择 "getter 和 setter"。
3. 在“生成 getter 和 setter”对话框中，选择 "body" 和 "title" 字段。单击“生成”。
4. 修复导入并保存更改。

创建消息驱动 Bean

在本练习中，将在 EJB 项目中创建一个消息驱动 Bean。消息驱动 Bean 是一个可异步交换消息的企业 Bean。NewsApp 应用程序使用消息驱动 Bean 接收并处理Web 模块中的 Servlet 发送到队列的消息。

要在应用程序中使用消息驱动 Bean，需要在服务器中注册该 Bean 使用的连接器资源。在部署到 GlassFish 服务器时，您可以直接通过管理控制台在服务器上创建资源，也可以在部署时在 sun-resources.xml 文件中指定详细信息以创建资源。将应用程序部署到服务器时，服务器将基于 sun-resources.xml 注册资源。在 IDE 中使用“新建文件”向导创建消息驱动 Bean 时，IDE 将在 sun-resources.xml 中生成元素。

对于 Maven 项目，sun-resources.xml 文件位于“文件”窗口的项目节点下面的 src/main/setup 目录中。

1. 右键单击“项目”窗口中的“EJB 模块”，然后选择“新建”＞“其他”打开“新建文件”向导。
2. 从 "Java EE" 类别中，选择“消息驱动 Bean”。单击“下一步”。
3. 键入 NewMessage 作为 EJB 名称。
4. 从“包”下拉列表中选择 "ejb"。
5. 单击“项目目标”字段旁边的“添加”按钮，以打开“添加消息目标”对话框。
6. 在“添加消息目标”对话框中，键入 jms/NewMessage 并选择“队列”作为目标类型。单击“确定”。
   
7. 确保项目目标正确无误。单击“完成”。
   

   在单击“完成”时，IDE 生成 Bean 类，并添加以下标注（将该类标识为消息驱动 Bean）和配置属性。

   @MessageDriven(mappedName = "jms/NewMessage", activationConfig =  {
           @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
           @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue")
       })
   public class NewMessage implements MessageListener {
   
       public NewMessage() {
       }
   
       public void onMessage(Message message) {
       }
   }

8. 在类中添加以下带标注的字段，以将 MessageDrivenContext 资源注入到类中。

   public class NewMessageBean implements MessageListener {
   
   @Resource
   private MessageDrivenContext mdc;
   

9. 添加以下带标注的字段（以粗体显示），以将实体管理器引入到类中。

   public class NewMessage implements MessageListener {
   
   @Resource
   private MessageDrivenContext mdc;
   @PersistenceContext(unitName="com.mycompany_MavenEnterpriseApp-ejb_ejb_1.0-SNAPSHOTPU")
   private EntityManager em;
                      

   @PersistenceContext 标注通过声明持久性单元来指定上下文。unitName 值是持久性单元的名称。

10. 添加以下 save 方法（以粗体显示）。

    public NewMessage() {
    }
    
    public void onMessage(Message message) {
    }
    
    public void save(Object object) {
        em.persist(object);
    }

11. 在 onMessage 方法主体中，添加以下内容（以粗体显示）以修改该方法：

    public void onMessage(Message message) {
         ObjectMessage msg = null;
         try {
              if (message instanceof ObjectMessage) {
              msg = (ObjectMessage) message;
                  NewsEntity e = (NewsEntity) msg.getObject();
                  save(e);
              }
         } catch (JMSException e) {
              e.printStackTrace();
              mdc.setRollbackOnly();
         } catch (Throwable te) {
              te.printStackTrace();
         }
    }

12. 修复 import 语句 (Ctrl-Shift-I) 并保存更改。

    注意：在生成 import 语句时，您需要确保导入 jms 和 javax.annotation.Resource 库。

有关消息驱动 Bean 的更多详细信息，请参见 Java EE 6 教程第 I 部分中的什么是消息驱动 Bean？一章。

创建会话 Bean

在本练习中，将使用向导为 NewsEntity 实体类创建会话 Bean Facade。向导将生成一些常见方法（create、edit 和 find 方法），可通过 Web 应用程序项目中的 Servlet 进行访问。

1. 右键单击 EJB 模块，然后选择“新建”>“其他”。
2. 从“持久性”类别中，选择“实体类的会话 Bean”，然后单击“下一步”。
3. 从可用实体类的列表中选择 "ejb.NewsEntity"，然后单击“添加”以将该类移动到“选定的实体类”窗格中。单击“下一步”。
4. 检查是否将包设置为 "ejb"。您无需创建本地接口。
5. 单击“完成”。

在 Java EE 6 中，接口是可选的。在 Java EE 5 中，您需要为会话 Bean 创建本地接口，然后通过该接口调用会话 Bean。在 Java EE 6 中，本地接口是可选的，Web 模块中的 Servlet 可以直接通过无接口 Facade 访问会话 Bean。

创建 ListNews Servlet

在本练习中，将创建用于显示发布的消息列表的 ListNews Servlet。将使用标注注入会话 Facade，并访问 findAll 方法以检索发布的消息。

1. 右键单击 Web 模块项目，然后选择“新建”> "Servlet"。
2. 键入 ListNews 作为类名。
3. 键入 web 作为包名。单击“完成”。

   单击“完成”后，类 ListNews.java 在源代码编辑器中打开。

4. 在源代码编辑器中单击鼠标右键，选择“插入代码”，然后选择“调用企业 Bean”。
5. 在“调用企业 Bean”对话框中，展开 "NewsApp-ejb" 节点，然后选择 "NewsEntityFacade"。单击“确定”。
   

   在单击“确定”时，将使用 @EJB 标注将 EJB 资源注入到 Servlet 中。

   @WebServlet(name = "ListNews", urlPatterns = {"/ListNews"})
   public class ListNews extends HttpServlet {
       @EJB
       private NewsEntityFacade newsEntityFacade;

6. 在 processRequest 方法中，取消注释代码并在方法主体中添加以下代码行（以粗体显示）以修改该方法：

   out.println("<h1>Servlet ListNews at " + request.getContextPath () + "</h1>");
   
   List news = newsEntityFacade.findAll();
   for (Iterator it = news.iterator(); it.hasNext();) {
       NewsEntity elem = (NewsEntity) it.next();
       out.println(" <b>"+elem.getTitle()+" </b><br />");
       out.println(elem.getBody()+"<br /> ");
   }
   out.println("<a href='PostMessage'>Add new message</a>");
   
   out.println("</body>");
      

7. 修复导入 (Ctrl-Shift-I) 并保存更改。

   在生成 import 语句时，您希望导入 java.util 库。

创建 PostMessage Servlet

在本练习中，您将创建用于传递消息的 PostMessage Servlet。您将使用标注向该 Servlet 中直接注入创建的 JMS 资源，从而指定变量名称及其映射到的名称。然后，您将添加用于发送 JMS 消息的代码，以及用于在 HTML 表单中添加消息的代码。

1. 右键单击 Web 模块项目，然后选择“新建”> "Servlet"。
2. 键入 PostMessage 作为类名。
3. 选择 "web" 作为包名。单击“完成”。

   单击“完成”后，类 PostMessage.java 在源代码编辑器中打开。

4. 在源代码编辑器中，添加以下字段声明以使用标注注入 ConnectionFactory 和 Queue 资源。

   @WebServlet(name="PostMessage", urlPatterns={"/PostMessage"})
   public class PostMessage extends HttpServlet {
      @Resource(mappedName="jms/NewMessageFactory")
      private  ConnectionFactory connectionFactory;
   
      @Resource(mappedName="jms/NewMessage")
      private  Queue queue;

5. 修复 import 语句 (Ctrl-Shift-I) 以导入 javax.jms 库。
   

   注意：如果 IDE 未提供 javax.jms 选项，则可以在资源库中搜索正确的工件，方法是单击 private ConnectionFactory connectionFactory; 旁边的旁注中的建议图标，然后在“Maven 资源库”中选择“搜索依赖关系”。

   

   可以使用“在 Maven 资源库中搜索”对话框查找并选择包含 ConnectionFactory 的工件。

   
6. 添加以下代码以将 JMS 消息发送到 processRequest 方法。

   response.setContentType("text/html;charset=UTF-8");
   
   // Add the following code to send the JMS message
   String title=request.getParameter("title");
   String body=request.getParameter("body");
   if ((title!=null) && (body!=null)) {
       try {
           Connection connection = connectionFactory.createConnection();
           Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
           MessageProducer messageProducer = session.createProducer(queue);
   
           ObjectMessage message = session.createObjectMessage();
           // here we create NewsEntity, that will be sent in JMS message
           NewsEntity e = new NewsEntity();
           e.setTitle(title);
           e.setBody(body);
   
           message.setObject(e);
           messageProducer.send(message);
           messageProducer.close();
           connection.close();
           response.sendRedirect("ListNews");
   
       } catch (JMSException ex) {
           ex.printStackTrace();
       }
   }

7. 取消注释用于输出 HTML 的代码，并添加用于添加消息的 Web 窗体。

   out.println("Servlet PostMessage at " + request.getContextPath() + "</h1>");
   
   // The following code adds the form to the web page
   out.println("<form>");
   out.println("Title: <input type='text' name='title'><br/>");
   out.println("Message: <textarea name='body'></textarea><br/>");
   out.println("<input type='submit'><br/>");
   out.println("</form>");
   
   out.println("</body>");
       

8. 修复导入 (Ctrl-Shift-I) 并保存更改。

   注意：您需要导入 Connection、ConnectionFactory、Session 和 Queue 的 javax.jms 库。

处理项目依赖关系

在本练习中，将修改 Web 应用程序项目的 pom.xml，以防止在打包时将 EJB 归档包括在 WAR 中。这可防止 EAR 归档包含两个 EJB 归档副本。

每个 Maven 项目包含一个 pom.xml 文件，其中包含归档内容的详细信息。项目所需的任何外部库在 pom.xml 中作为依赖关系列出。可以修改 pom.xml 以指定在归档打包时需要包括的依赖关系。

在此应用程序中，EJB JAR 和 WAR 归档将打包到 EAR 归档中。如果查看组装项目的 pom.xml，则可以看到 EJB 和 WAR 已声明为依赖关系。

如果查看 Web 应用程序项目的 pom.xml，则可以看到 EJB 归档已声明为依赖关系。Web 应用程序项目要求将 EJB 归档作为依赖关系，但您不希望此应用程序在打包时将 EJB 归档包括到 WAR 中。将生成 EJB 归档并作为 EAR 归档的一部分提供给 Web 应用程序。

您可以在 pom.xml 中单击鼠标右键，然后选择“显示依赖关系图形”以查看项目依赖关系的可视表示形式。可以将光标放在工件上以显示包含工件详细信息的工具提示。

执行以下步骤，修改 Web 应用程序项目的 pom.xml 以将 scope 元素添加到 EJB 归档依赖关系中。

1. 展开 Web 应用程序项目下面的“项目文件”节点。
2. 双击 "pom.xml"，该文件在编辑器中打开。
3. 对 POM 进行编辑，添加以下 <scope>provided</scope> 元素以修改 MavenEnterpriseApp-ejb 工件的依赖关系。

   <dependency>
       <groupId>com.mycompany</groupId>
       <artifactId>MavenEnterpriseApp-ejb</artifactId>
       <scope>provided</scope>
       <version>1.0-SNAPSHOT</version>
   </dependency>

4. 保存所做的更改。

可以在 POM 编辑器中使用代码完成功能帮助编辑该文件。

通过声明提供了依赖关系，在生成 WAR 归档时，Maven 将不打包该工件。

使用依赖关系生成

Maven 生成框架包含一系列特定的阶段，每个阶段包含一个或多个目标，可以配置这些阶段以使用各种不同的 Maven 插件。“使用依赖关系生成”菜单项将映射到 Maven 生成生命周期的 install 阶段，并配置为使用 Reactor 插件。在弹出式菜单中选择“使用依赖关系生成”时，Maven 将生成应用程序和任何所需的依赖关系，并将生成工件复制到本地资源库中。

可以在项目“属性”对话框的“操作”面板中修改将 Maven 阶段和目标映射到菜单操作的方式。

要生成 EAR 归档，请执行以下步骤：

• 右键单击组装项目节点，然后选择“使用依赖关系生成”。

在使用 Reactor 插件生成组装项目时，将在生成组装项目之前生成子项目的依赖关系。“输出”窗口将显示生成顺序。

还会在“输出”窗口中显示生成结果。

在生成组装项目后，您可以在“文件”窗口中的组装项目节点下面的 "target" 目录中看到最终 EAR 归档。

如果使用缺省工件名称 com.mycompany，则可以在 Maven 资源库浏览器中展开“本地资源库”中的 com.mycompany 以查看生成工件。

有关生成 Maven 项目的详细信息，请参见 maven.apache.org 上的 Maven - Introduction to the Build Lifecycle（Maven - 生成生命周期简介）。

从 IDE 中部署

在本练习中，将修改映射到运行操作的 Maven 目标。在修改该操作后，您可以使用运行操作将 EAR 部署到服务器上。

1. 在“项目”窗口中右键单击组装项目节点，然后选择“属性”。
2. 从“属性”窗口的左面板的“类别”列表中选择“操作”。
3. 从右面板的“操作”列表中选择“运行项目”。
4. 在“执行目标”文本字段中，删除 package 目标并键入 install。单击“确定”。
   
5. 在“项目”窗口中右键单击组装项目节点，然后选择“运行”。
6. 在“选择部署服务器”对话框中选择 GlassFish 服务器。单击“确定”。
   

在选择部署服务器后，IDE 在服务器上创建 JMS 资源并部署 EAR 归档。

从 GlassFish 管理控制台中部署

在本练习中，将使用 GlassFish 管理控制台中的“部署”工具部署 EAR 归档。

1. 在“服务”窗口中展开“服务器”节点。
2. 启动 GlassFish 服务器。
3. 右键单击 GlassFish 服务器节点，然后选择“查看管理控制台”以在浏览器中打开 GlassFish 管理控制台。
4. 在管理控制台的左窗格中，单击“应用程序”节点。
5. 在管理控制台的主窗格中，单击“部署”按钮。
6. 单击“浏览”以查找企业应用程序的 EAR 归档。

   EAR 归档位于本地系统上的企业应用程序目录的 target 目录中。

7. 单击“确定”。

在单击“确定”时，GlassFish 部署工具将部署应用程序。

注意：如果使用部署工具部署应用程序，还需要手动创建应用程序所需的资源（如果不存在）。