创建项目

1. 从主菜单中选择 "File"（文件）> "New Project"（新建项目）（Ctrl-Shift-N 组合键；在 Mac 上为 ⌘-Shift-N 组合键）。
2. 从 "Java Web" 类别中选择 "Web Application"（Web 应用程序）。单击 "Next"（下一步）。
3. 将项目命名为 WebAppJUnit 并设置项目位置。
4. 取消选中 "Use Dedicated Folder"（使用专用文件夹）选项（如果该选项处于选中状态）。
   单击 "Next"（下一步）。
5. 将服务器设置为 GlassFish Server，并将 Java EE 版本设置为 Java EE 6 Web 或 Java EE 7 Web。
   单击 "Finish"（完成）。

创建会话 Bean

在本练习中，将创建一个非常简单的会话 Bean，它包含一个添加两个数字的方法。

1. 在 "Projects"（项目）窗口中右键单击 "WebAppJUnit" 项目，然后选择 "New"（新建）> "Other"（其他）。
2. 选择 "Enterprise JavaBeans" 类别中的 "Session Bean"（会话 Bean）。单击 "Next"（下一步）。
3. 键入 MyBean 作为 EJB 名称。
4. 键入 bean 作为包名。
5. 选择 "Stateless"（无状态）作为会话类型。单击 "Finish"（完成）。

   单击 "Finish"（完成），此时将在编辑器中打开新类。

6. 在编辑器中，将以下 addNumbers 方法添加到类中。

   @Stateless
   public class MyBean {
       public int addNumbers(int numberA, int numberB) {
           return numberA + numberB;
       }
   }

   注：在本教程中，无需添加 @LocalBean 标注或实现接口。默认情况下，当未显式指定视图时，Bean 将公开无界面视图。

7. 保存所做的更改。

测试会话 Bean

在本练习中，将为会话 Bean 创建一个测试类以测试 addNumbers 方法。IDE 可以根据目标类中的方法，生成新的测试类和框架测试方法。

1. 在 "Projects"（项目）窗口中右键单击 MyBean 类，然后选择 "Tools"（工具）> "Create Tests"（创建测试）。
2. 在 "Frameworks"（框架）下拉列表中选择 "JUnit"。
3. 在 "Create Tests"（创建测试）对话框中，使用默认值。单击 "OK"（确定）。
   

   注：首次创建 JUnit 单元测试时，您需要指定 JUnit 版本。在 "Select JUnit Version"（选择 JUnit 版本）对话框中，选择 "JUnit 4.x"，然后单击 "Select"（选择）。

   单击 "OK"（确定）后，IDE 将生成 MyBeanTest.java 文件并在编辑器中打开该类。

   在 "Projects"（项目）窗口中，您可以看到 IDE 在 "Test Packages"（测试包）节点下面生成了测试类。默认情况下，IDE 在测试类中生成一个框架测试方法，它通过调用 javax.ejb.embeddable.EJBContainer.createEJBContainer() 来创建 EJB 容器实例。createEJBContainer() 方法是 EJB 3.1 可嵌入 API 中包含的 EJBContainer 类中的方法之一。

   如果在 "Projects"（项目）窗口中展开 "Test Libraries"（测试库）节点，您可以看到 IDE 自动添加了 GlassFish Server（可嵌入容器）和 JUnit 4.x 作为测试库。如果展开 GlassFish Server 库，则可以看到该库包含 glassfish-embedded-static-shell.jar。

   

   注：glassfish-embedded-static-shell.jar JAR 不包含嵌入的 EJB 容器的源代码。glassfish-embedded-static-shell.jar JAR 要求在本地安装 GlassFish。本地 GlassFish 安装的类路径是由项目的目标服务器确定的。您可以在项目的 "Properties"（属性）对话框中更改目标服务器。

4. 修改生成的框架测试方法以指定 numberA、numberB 和 expResult 的值，然后删除会失败的默认调用。

   @Test
   public void testAddNumbers() throws Exception {
       System.out.println("addNumbers");
       int numberA = 1;
       int numberB = 2;
       EJBContainer container = javax.ejb.embeddable.EJBContainer.createEJBContainer();
       MyBean instance = (MyBean)container.getContext().lookup("java:global/classes/MyBean");
       int expResult = 3;
       int result = instance.addNumbers(numberA, numberB);
       assertEquals(expResult, result);
       container.close();
   }

5. 在 "Projects"（项目）窗口中右键单击项目，然后选择 "Test"（测试）。

运行测试时，将在 IDE 中打开 "Test Results"（测试结果）窗口并显示测试进度和结果。

将在 "Output"（输出）窗口中看到类似以下的内容。

Testsuite: bean.MyBeanTest
addNumbers
...
Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 31.272 sec

------------- Standard Output ---------------
addNumbers
...
------------- ---------------- ---------------
test-report:
test:
BUILD SUCCESSFUL (total time: 35 seconds)

修改测试以指定容器属性

使用创建测试向导时，IDE 生成一个默认框架测试类，它包含用于启动 EJB 容器的代码。在本练习中，将修改用于启动该容器的生成代码，以便为嵌入的容器实例指定其他属性。

1. 将以下代码（粗体）添加到测试类中。

   @Test
   public void testAddNumbers() throws Exception {
       System.out.println("addNumbers");
       int numberA = 1;
       int numberB = 2;
   
       // Create a properties map to pass to the embeddable container:
       Map<String, Object> properties = new HashMap<String, Object>();
       // Use the MODULES property to specify the set of modules to be initialized,
       // in this case a java.io.File 
       properties.put(EJBContainer.MODULES, new File("build/jar"));
   
       // Create the container instance, passing it the properties map:
       EJBContainer container = javax.ejb.embeddable.EJBContainer.createEJBContainer(properties);
   
       // Create the instance using the container context to look up the bean 
       // in the directory that contains the built classes
       MyBean instance = (MyBean) container.getContext().lookup("java:global/classes/MyBean");
   
       int expResult = 3;
   
       // Invoke the addNumbers method on the bean instance:
       int result = instance.addNumbers(numberA, numberB);
   
       assertEquals(expResult, result);
   
       // Close the embeddable container:
       container.close();
   }

2. 在编辑器中右键单击，然后选择 "Fix Imports"（修复导入）（Alt-Shift-I 组合键；在 Mac 上为 ⌘-Shift-I 组合键）添加 java.util.HashMap 和 java.util.Map 的 import 语句。
3. 再次运行测试，以确认修改的测试正常工作并且正确创建了容器。

   您可以在 "Test Results"（测试结果）窗口中单击 "Rerun"（重新运行）按钮。

使用 @BeforeClass 和 @AfterClass 标注

在本练习中，将修改创建单个方法所需的测试类，以便创建和关闭容器实例。如果要运行几个可使用相同容器实例的测试，这可能是非常有用的。这样，您就不需要针对每个测试打开和关闭容器实例，只需在运行测试之前创建一个实例，并在完成所有测试后关闭该实例。

在本练习中，您需要将用于创建 EJB 容器的代码移到 setUpClass 方法中。setUpClass 方法是使用 @BeforeClass 标注的，用于指示在测试类中的其他方法运行之前将要运行的某个方法。在本示例中，将在 testAddNumbers 测试方法之前创建容器实例，并且该容器在关闭之前将一直存在。

同样，您需要将用于关闭该容器的代码移到 tearDownClass 方法中，该方法是使用 @AfterClass 标注的。

1. 将以下字段添加到测试类中。

   private static EJBContainer container;

2. 将用于创建容器的代码从 testAddNumbers 测试方法复制到 setUpClass 方法和

   @BeforeClass
   public static void setUpClass() throws Exception {
       Map<String, Object> properties = new HashMap<String, Object>();
       properties.put(EJBContainer.MODULES, new File("build/jar"));
       container = EJBContainer.createEJBContainer(properties);
       System.out.println("Opening the container");
   }

3. 将用于关闭容器的代码从 testAddNumbers 测试方法复制到 tearDownClass 方法中。

   @AfterClass
   public static void tearDownClass() throws Exception {
       container.close();
       System.out.println("Closing the container");
   }

4. 从 testAddNumbers 方法中删除多余的代码。保存所做的更改。

现在，测试类应如下所示。

public class MyBeanTest {
    private static EJBContainer container;

    public MyBeanTest() {
    }

    @BeforeClass
    public static void setUpClass() throws Exception {
        Map<String, Object> properties = new HashMap<String, Object>();
        properties.put(EJBContainer.MODULES, new File("build/jar"));
        container = EJBContainer.createEJBContainer(properties);
        System.out.println("Opening the container");
    }

    @AfterClass
    public static void tearDownClass() throws Exception {
        container.close();
        System.out.println("Closing the container");
    }

    @Before
    public void setUp() {
    }

    @After
    public void tearDown() {
    }

    /**
     * Test of addNumbers method, of class MyBean.
     */ 
    @Test
    public void testAddNumbers() throws Exception {
        System.out.println("addNumbers");
        int numberA = 1;
        int numberB = 2;

        // Create the instance using the container context to look up the bean 
        // in the directory that contains the built classes
        MyBean instance = (MyBean) container.getContext().lookup("java:global/classes/MyBean");

        int expResult = 3;

        // Invoke the addNumbers method on the bean instance:
        int result = instance.addNumbers(numberA, numberB);

        assertEquals(expResult, result);
    }
}

如果再次运行测试以确认正确创建和关闭了容器，则 "Test Results"（测试结果）窗口中将会显示类似下面的输出。

您可以看到在 addNumbers 测试之前运行了 setUpClass 方法并输出了 "Opening the container"。

创建实体类

在本节中，将通过新建实体类向导使用数据库连接详细信息创建一个实体类和持久性单元。

1. 在 "Projects"（项目）窗口中右键单击 "WebAppJUnit" 项目，然后选择 "New"（新建）> "Other"（其他）。
2. 在 "Persistence"（持久性）类别中选择 "Entity Class"（实体类）。单击 "Next"（下一步）。
3. 在 "Class Name"（类名）中键入 SimpleEntity。
4. 从 "Package"（包）下拉列表中选择 "Bean"。
5. 在 "Primary Key Type"（主键类型）中键入 int。单击 "Next"（下一步）。
6. 使用默认的持久性单元名称和持久性提供器。
7. 选择 jdbc/sample 作为数据源，然后选 "Drop and Create"（删除并创建）作为策略。单击 "Finish"（完成）。
   

   单击 "Finish"（完成），此时将在编辑器中打开新的实体类。如果在 "Projects"（项目）窗口中展开 "Configuration Files"（配置文件）节点，则可以看到 IDE 自动生成了 persistence.xml 文件，该文件定义了 WebAppJUnitPU 持久性单元的属性。

8. 在编辑器中，将以下私有字段添加到实体类中。

   private String name;

9. 在源代码编辑器中右键单击，选择 "Insert Code"（插入代码）（Alt-Insert 组合键；在 Mac 上为 Ctrl-I 组合键），然后选择 "Getter and Setter"（Getter 和 Setter），以打开 "Generate Getters and Setters"（生成 Getter 和 Setter）对话框。
10. 在对话框中选择 name 字段。单击 "Generate"（生成）。
    
11. 将以下方法添加到类中。

    public SimpleEntity(int id) {
        this.id = id;
        name = "Entity number " + id + " created at " + new Date();
    }

12. 使用 @NamedQueries 和 @NamedQuery 标注来创建指定的 SQL 查询。

    @Entity
    @NamedQueries({@NamedQuery(name = "SimpleEntity.findAll", query = "select e from SimpleEntity e")})
    public class SimpleEntity implements Serializable {

13. 创建一个默认构造函数。

    如果希望 IDE 生成构造函数，您可以单击类声明旁边的装订线中显示的建议图标。

14. 修复导入以添加 javax.persistence.NamedQueries、javax.persistence.NamedQuery 和 java.util.Date 的 import 语句。保存所做的更改。

除了默认的生成代码以外，实体类现在应类似于以下内容：

package bean;

import java.io.Serializable;
import java.util.Date;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;


@Entity
@NamedQueries({@NamedQuery(name = "SimpleEntity.findAll", query = "select e from SimpleEntity e")})
public class SimpleEntity implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private int id;

    private String name;

    public SimpleEntity() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public SimpleEntity(int id) {
        this.id = id;
        name = "Entity number " + id + " created at " + new Date();
    }

    

    ...

}

修改会话 Bean

在本练习中，将编辑 MyBean 会话 Bean 以添加在数据库表中插入和检索数据的方法。

1. 在编辑器中打开 MyBean.java。
2. 在编辑器中右键单击，选择 "Insert Code"（插入代码）（Alt-Insert 组合键；在 Mac 上为 Ctrl-I 组合键），然后从弹出式菜单中选择 "Use Entity Manager"（使用实体管理器）。

   选择 "Use Entity Manager"（使用实体管理器）时，IDE 将在类中添加以下代码以注入实体管理器。您可以看到自动生成了持久性单元的名称。

   @PersistenceContext(unitName="WebAppJUnitPU")
   private EntityManager em;

3. 添加以下 verify 和 insert 方法。

   @PermitAll
   public int verify() {
       String result = null;
       Query q = em.createNamedQuery("SimpleEntity.findAll");
       Collection entities = q.getResultList();
       int s = entities.size();
       for (Object o : entities) {
           SimpleEntity se = (SimpleEntity)o;
           System.out.println("Found: " + se.getName());
       }
   
       return s;
   }
   
   @PermitAll
   public void insert(int num) {
       for (int i = 1; i <= num; i++) {
           System.out.println("Inserting # " + i);
           SimpleEntity e = new SimpleEntity(i);
           em.persist(e);
       }
   }

4. 修复导入以导入 javax.persistence.Query 并保存所做的更改。

测试实体类

在本练习中，将编辑测试类以添加一个方法，测试应用程序是否可以查找 EJB 以及 insert 和 verify 方法是否正常工作。

1. 启动 JavaDB 数据库。
2. 在编辑器中打开 MyBeanTest.java 测试类。
3. 编辑该测试类以添加以下 testInsert 测试方法。

   @Test
   public void testInsert() throws Exception {
   
       // Lookup the EJB
       System.out.println("Looking up EJB...");
       MyBean instance = (MyBean) container.getContext().lookup("java:global/classes/MyBean");
   
       System.out.println("Inserting entities...");
       instance.insert(5);
       int res = instance.verify();
       System.out.println("JPA call returned: " + res);
       System.out.println("Done calling EJB");
   
       Assert.assertTrue("Unexpected number of entities", (res == 5));
       System.out.println("..........SUCCESSFULLY finished embedded test");
   }

4. 在 "Projects"（项目）窗口中右键单击项目节点，然后从弹出式菜单中选择 "Test"（测试）。

此时将打开 "Test Results"（测试结果）窗口并显示类似下面的输出。

您可以通过添加到测试类中的输出消息查看测试进度和测试运行顺序。