EJB 简介 - 《ZetCode 中文系列教程》

第一个 EJB
使用实体 bean 持久化数据
使用 Maven 构建项目

在本教程中，我们学习如何使用 Enterprise JavaBeans。我们使用 GlassFish，NetBeans，Derby 和 Maven。

Enterprise JavaBean （EJB）是服务器端组件，封装了应用的业务逻辑。 EJB 在 EJB 容器中运行，该容器负责各种系统级服务，包括事务管理，安全性和并发控制。 EJB 是 Java EE 规范的一部分。

GlassFish 是 Java EE 的参考实现，它包括 Enterprise JavaBeans 容器。我们将在 GlassFish 中运行示例。 Apache Derby 是完全用 Java 实现的开源关系数据库。 Oracle 以 Java DB 的名义分发相同的二进制文件。

第一个 EJB

我们在 NetBeans 中创建一个新的 Web 应用。该项目将称为MyFirstEJB。从“服务器和设置”页面，选择 GlassFish 服务器，并将上下文更改为myfirstejb。

EJB 简介 - 图1

图：服务器和设置

在此对话框中，我们选择应用服务器，Java EE 版本和上下文路径。

index.html

<!DOCTYPE html>
<html>
    <head>
        <title>Test page</title>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
    </head>
    <body>
        <p>Test page</p>
    </body>
</html>

这是我们的index.html页面。如果我们访问应用的根页面，它将返回。

我们右键单击应用图标，然后选择一个 Session Bean 类型的新 EJB。我们将 bean 称为MyFirstBean，键入com.zetcode.ejb包，然后选择无状态会话类型。

EJB 简介 - 图2

图：在 NetBeans 中创建一个新的会话 Bean

无状态会话 Bean 不维护与客户端的对话状态。当客户端调用无状态 Bean 的方法时，该 Bean 的实例变量可能包含特定于该客户端的状态，但仅在调用期间包含。该方法完成后，客户端特定的状态将丢失。

FirstBean.java

package com.zetcode.ejb;
import javax.ejb.Stateless;
@Stateless
public class FirstBean {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String sayHello() {
        StringBuilder sb = new StringBuilder("Hello ");
        sb.append(this.getName()).append("!");
        return sb.toString();
    }
}

MyFirstBean是无状态会话 Bean。使用@Stateless装饰创建一个无状态会话 bean。它具有no-interface view，其中不使用本地业务接口，并且 Bean 类的所有公共方法都自动向调用者公开。

public String sayHello() {
    StringBuilder sb = new StringBuilder("Hello ");
    sb.append(this.getName()).append("!");
    return sb.toString();
}

MyFirstBean's的工作是构造对调用者的问候。

接下来，我们通过右键单击项目图标并从 Web 类别中选择 Servlet 文件类型来创建一个新的 Servlet。我们将 servlet 称为Greet，然后键入com.zetcode.web包。我们将 URL 模式更改为/greet。

EJB 简介 - 图3

图：创建新的 servlet

在新的 Servlet 对话框中，我们提供 Servlet 名称及其包。

Greet.java

package com.zetcode.web;
import com.zetcode.ejb.FirstBean;
import java.io.IOException;
import java.io.PrintWriter;
import javax.ejb.EJB;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet(name = "Greet", urlPatterns = {"/greet"})
public class Greet extends HttpServlet {
    @EJB
    private FirstBean firstBean;
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/plain;charset=UTF-8");
        firstBean.setName(request.getParameter("name"));
        String msg = firstBean.createMessage();
        try (PrintWriter out = response.getWriter()) {
            out.println(msg);
        }
    }
}

Greet Servlet 从客户端发送的 URL 中读取名称参数，调用 EJB 的createMessage()业务方法，并以纯文本形式返回响应。

@EJB
private FirstBean firstBean;

@EJB注解将 EJB 注入 Servlet。

response.setContentType("text/plain;charset=UTF-8");

servelt 响应以 UTF-8 字符集的纯文本格式显示。

firstBean.setName(request.getParameter("name"));

我们从请求中检索name参数，并将其设置为 EJB。

String msg = firstBean.createMessage();

我们将其称为createMessage()业务方法。

EJB 简介 - 图4

图：MyFirstEJB 项目结构

我们构建应用并将其部署到 GlassFish 服务器。要构建应用，请右键单击项目图标，然后选择“构建”。要部署应用，请右键单击项目图标，然后选择“部署”。

$ curl localhost:8080/myfirstejb/greet?name=Jan
Hello Jan!

使用curl工具，我们连接到myfirstejb Web 应用的Greet servlet，并向其传递参数。 Web 应用以问候语响应。

$ curl localhost:8080/myfirstejb/
<!DOCTYPE html>
<html>
    <head>
        <title>Test page</title>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
    </head>
    <body>
        <p>Test page</p>
    </body>
</html>

访问根页面，应用将返回 HTML 测试页面。

使用实体 bean 持久化数据

在第二个示例中，我们创建一个将读取和保存汽车的 Web 应用。汽车对象将保存在 Derby 数据库中。

我们使用car-app名称创建一个新的 Java Web 应用。然后，我们创建一个新的Car实体。实体类文件类型位于持久性类别中。包将为com.zetcode.persistence。主键类型为Long，并选中了创建持久性单元选项。

在下一页中，我们将持久性单元名称更改为carpu，然后选择默认的EclipseLink持久性供应器。我们选择jdbc/sample数据源，并选择了Create表生成策略。 jdbc/sample数据源是指默认情况下位于用户主目录的.netbeans-derby子目录中的sample数据库。

EJB 简介 - 图5

图：持久性供应器

在此视图中，我们提供了持久性单元名称，持久性供应器，数据源和表生成策略。

实体 Bean

实体 Bean 是一种 Enterprise JavaBean，它表示持久存储中存在的业务实体对象。实体 bean 由主键标识。与在客户端会话的生存期内生存的会话 Bean 不同，实体 Bean 即使在 EJB 容器崩溃时也可以幸免。

Car.java

package com.zetcode.persistence;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="Cars")
public class Car implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name="Id")
    private Long id;    
    @Column(name="Name")
    private String name;
    @Column(name="Price")
    private int price;      
    public Car() { }
    public Car(String name, int price) {
        this.name = name;
        this.price = price;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }    
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
}

Car是 EJB 实体 Bean。它是要存储在 Derby 数据库中的业务对象。

@Entity
@Table(name="Cars")
public class Car implements Serializable {

实体 bean 用@Entity注解修饰。该实体映射到Cars表。

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name="Id")
private Long id;

每个实体都有一个唯一的对象标识符。此唯一标识符或主键使客户端能够定位特定的实体实例。 @Id声明此实体 bean 的标识符属性，@GeneratedValue注解用于指定主键的生成方式，@Column将标识符映射到数据库表的Id列。

public Car() { }

持久性框架需要无参数的构造器。

EJB

我们创建一个本地无状态ManageCarBean企业 bean。这次 EJB 具有本地接口视图。

ManageCarBeanLocal.java

package com.zetcode.ejb;
import javax.ejb.Local;
import com.zetcode.persistence.Car;
@Local
public interface ManageCarBeanLocal {
    void saveCar(Car car);
    void setPrice(int price);
    void setName(String name);
    Car getCar(Long id);
}

该接口定义了 EJB 客户端要使用的方法。客户端只能通过 bean 的业务接口中定义的方法来访问会话 bean。

@Local
public interface ManageCarBeanLocal {

@Local装饰指定该接口是本地业务接口。

ManageCarBean.java

package com.zetcode.ejb;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import com.zetcode.persistence.Car;
@Stateless
public class ManageCarBean implements ManageCarBeanLocal {
    private String name;
    private int price;
    @PersistenceContext(unitName = "carpu")
    private EntityManager em;
    public String getName() {
        return name;
    }
    @Override
    public void setName(String name) {
        this.name = name;
    }
    public int getPrice() {
        return price;
    }
    @Override
    public void setPrice(int price) {
        this.price = price;
    }
    @Override
    public void saveCar(Car car) {
        em.persist(car);
    }
    @Override
    public Car getCar(Long id) {
        Car car = em.find(Car.class, id);
        return car;
    }
}

ManageCarBean读取并保存汽车对象。

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

容器使用persistence.xml中的信息创建EntityManager。 @PersistenceContext注解将实体管理器注入到 Bean 中。管理器已映射到carpu持久性单元。实体管理器用于通过持久性上下文与数据进行交互。

@Override
public void saveCar(Car car) {
    em.persist(car);
}

saveCar()方法将汽车对象保存到数据库中；在我们的例子中是 Derby。

@Override
public Car getCar(Long id) {
    Car car = em.find(Car.class, id);
    return car;
}

getCar()方法通过其 ID 查找汽车。

persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
  <persistence-unit name="carpu" transaction-type="JTA">
    <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>
</persistence>

persistence.xml文件是一个配置文件，其中包含有关我们在应用中使用的数据库的信息。 jdbc/sample是 GlassFish 服务器随附的内置数据源。在我们的应用中，我们将数据保存在 Derby 的预先创建的sample数据库中。如果eclipselink.ddl-generation属性不存在，则会自动导致创建Cars表。

EJB 简介 - 图6

图：NetBeans Derby 工具

我们可以使用 NetBeans Derby 工具来连接和管理数据库中的数据。该工具位于“服务”窗口中。

servlet

我们创建两个 servlet：SaveCar和ReadCar。我们将它们放入com.zetcode.web包中。 Servlet 是从 NetBeans Web 类别创建的。两个 servlet 均以纯文本形式响应。

EJB 简介 - 图7

图：Apache Common Lang JAR

我们还包括用于帮助程序方法的 Apache Common Lang JAR。可以从项目网站下载该库。

ValidateParameter.java

package com.zetcode.util;
import org.apache.commons.lang3.math.NumberUtils;
public class ValidateParameter {
    private static final int MAX_PRICE_CAR = 10_000_000;
    public static boolean validateName(String param) {
        return !(null == param || "".equals(param) || 
                NumberUtils.isNumber(param));
    }
    public static boolean validateId(String param) {
        return !(null == param || "".equals(param) || 
                !NumberUtils.isNumber(param));
    }   
    public static boolean validatePrice(String param) {
       if (null == param || "".equals(param) || !NumberUtils.isNumber(param)) {
           return false;
       }
       int price = Integer.valueOf(param);
       return !(price < 0 || price > MAX_PRICE_CAR);
    }     
}

ValidateParameter类用于验证请求参数。参数不能为null或为空，并且 ID 和价格值必须为数字。另外，价格必须在合理范围内。我们使用 Apache Common Lang 的NumberUtils.isNumber()检查数字值。

SaveCar.java

package com.zetcode.web;
import java.io.IOException;
import java.io.PrintWriter;
import javax.ejb.EJB;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.zetcode.ejb.ManageCarBeanLocal;
import com.zetcode.persistence.Car;
import com.zetcode.util.ValidateParameter;
@WebServlet(name = "SaveCar", urlPatterns = {"/save"})
public class SaveCar extends HttpServlet {
    @EJB
    private ManageCarBeanLocal manageCarBean;
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String sname = request.getParameter("name");
        String sprice = request.getParameter("price");
        String message;
        if (ValidateParameter.validateName(sname)
                && ValidateParameter.validatePrice(sprice)) {
            message = String.format("%s car is saved", sname);
            int price = Integer.valueOf(sprice);
            Car car = new Car(sname, price);
            manageCarBean.saveCar(car);
        } else {
            message = "Wrong parameters";
        }
        response.setContentType("text/plain;charset=UTF-8");
        try (PrintWriter out = response.getWriter()) {
            out.println(message);
        }
    }
}

SaveCar Servlet 的目的是调用适当的 EJB 来保存汽车。汽车对象的数据是从客户端发送的 URL 中读取的。

@WebServlet(name = "SaveCar", urlPatterns = {"/save"})

@WebServlet注解将SaveCar Servlet 映射到/save路径。

@EJB
private ManageCarBeanLocal manageCarBean;

ManageCarBeanLocal企业 bean 被注入到 servlet 中。

String sname = request.getParameter("name");
String sprice = request.getParameter("price");

从请求中读取参数。

if (ValidateParameter.validateName(sname)
        && ValidateParameter.validatePrice(sprice)) {

参数正在验证中。

Car car = new Car(sname, price);
manageCarBean.saveCar(car);

创建一个新的汽车对象并将其保存到数据库。为了保存汽车对象，我们利用了ManageCarBean的saveCar()方法。

ReadCar.java

package com.zetcode.web;
import com.zetcode.ejb.ManageCarBeanLocal;
import java.io.IOException;
import java.io.PrintWriter;
import javax.ejb.EJB;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.zetcode.persistence.Car;
import com.zetcode.util.ValidateParameter;
@WebServlet(name = "ReadCar", urlPatterns = {"/read"})
public class ReadCar extends HttpServlet {
    @EJB
    private ManageCarBeanLocal manageCarBean;
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/plain;charset=UTF-8");
        String message;
        String pid = request.getParameter("id");
        if (ValidateParameter.validateId(pid)) {
            Long carId = Long.valueOf(pid);
            Car rcar = manageCarBean.getCar(carId);
            if (null != rcar) {
                message = String.format("Name: %s, Price: %d",
                        rcar.getName(), rcar.getPrice());
            } else {
                message = "Cannot find car with this ID";
            }
        } else {
            message = "Wrong parameters";
        }
        try (PrintWriter out = response.getWriter()) {
            out.println(message);
        }
    }
}

ReadCar servlet 调用ManageCarBean企业 bean 从数据库中读取数据；它根据提供的 ID 选择汽车对象。

String sid = request.getParameter("id");

从 URL 读取 ID。

Long carId = Long.valueOf(pid);
Car rcar = manageCarBean.getCar(carId);
if (null != rcar) {
    message = String.format("Name: %s, Price: %d",
            rcar.getName(), rcar.getPrice());
} else {
    message = "Cannot find car with this ID";
}

ManageCarBean的readCar()方法用于检索汽车对象。

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>
    <error-page>
        <error-code>404</error-code>
        <location>/error404.txt</location>
    </error-page>
    <error-page>
        <location>/error.txt</location>
    </error-page>    
</web-app>

在web.xml文件中，我们提供了两个错误页面。 error.txt是所有错误的默认错误页面，error404.txt是 404 错误的错误页面，当客户端请求不存在的资源时触发。注意，error404.txt必须先于error.txt。

EJB 简介 - 图8

图：错误页面s

我们将两个文本文件放置在网页中。

error.txt

Error has occurred, check the GlassFish log file

这是一般错误页面。

error404.txt

404 : Page was not found

这是 404 错误的错误页面。

部署方式

是时候部署应用了。通过右键单击 Web 项目并选择 Deploy 命令来部署应用。请注意，当我们清理项目时，将取消部署该应用。如果未运行所选的应用服务器，那么 deploy 命令还将启动它。

$ ./asadmin list-applications
MyFirstEJB  <ejb, web>
car-app     <ejb, web>  
Command list-applications executed successfully.

GlassFish 的asadmin工具可用于确定当前已部署的应用。

GlassFish 启动时，NetBeans 会自动启动 Derby 服务器。可以在 GlassFish 服务器设置中将其关闭。

EJB 简介 - 图9

图：GlassFish 服务器属性

在 NetBeans 的“服务”选项卡中，我们展开“服务器”节点，然后选择 GlassFish 属性。在那里，我们可以看到“启动已注册 Derby 服务器”选项。

$ curl localhost:8080/car-app/doread
404 : Page was not found

如果尝试访问不存在的资源，则会收到自定义 404 错误消息。

$ curl "localhost:8080/car-app/save?name=Volvo&price=29000"
Volvo car is saved

沃尔沃汽车将保存到数据库中。注意 URL 的双引号的用法。

$ curl "localhost:8080/car-app/save?name=Bentley&price=299000000"
Wrong parameters

验证器发现了不切实际的高汽车价格。

$ curl localhost:8080/car-app/read?id=401
Name: Volvo, Price: 29000

我们从数据库中读取了一辆汽车。

使用 Maven 构建项目

NetBeans 在开发过程中为我们节省了许多繁琐的工作。但是使用 Maven 手动构建项目是有益的。

mvn archetype:generate -DgroupId=com.zetcode -DartifactId=car-app 
    -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false

我们创建一个新的 Maven 项目。我们使用maven-archetype-webapp类型。

$ tree 
.
└── car-app
    ├── pom.xml
    └── src
        └── main
            ├── resources
            └── webapp
                ├── index.jsp
                └── WEB-INF
                    └── web.xml
6 directories, 3 files

tree命令向我们显示了创建的项目结构。

$ mkdir -p src/main/java/com/zetcode/ejb
$ mkdir src/main/java/com/zetcode/persistence
$ mkdir src/main/java/com/zetcode/web
$ mkdir src/main/java/com/zetcode/util
$ mkdir src/main/resources/META-INF

我们创建目录。

复制应用源文件后，项目结构如下所示：

$ tree
.
├── pom.xml
└── src
    └── main
        ├── java
        │   └── com
        │       └── zetcode
        │           ├── ejb
        │           │   ├── ManageCarBean.java
        │           │   └── ManageCarBeanLocal.java
        │           ├── persistence
        │           │   └── Car.java
        │           ├── util
        │           │   └── ValidateParameter.java
        │           └── web
        │               ├── ReadCar.java
        │               └── SaveCar.java
        ├── resources
        │   └── META-INF
        │       └── persistence.xml
        └── webapp
            ├── index.jsp
            └── WEB-INF
                └── web.xml

不要忘记复制web.xml文件。 Maven 为我们创建了一个空的web.xml文件。

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.zetcode</groupId>
    <artifactId>car-app</artifactId>
    <packaging>war</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>car-app Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupId>org.eclipse.persistence</groupId>
            <artifactId>eclipselink</artifactId>
            <version>2.5.0</version>
        </dependency>   
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.0</version>
        </dependency>        
        <dependency>  
            <groupId>javax</groupId>    
            <artifactId>javaee-web-api</artifactId>    
            <version>7.0</version>  
        </dependency>     
    </dependencies>  
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                <source>1.8</source>
                <target>1.8</target>
                </configuration>
            </plugin>            
        </plugins>    
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
        <finalName>car-app</finalName>
    </build>         
</project>

pom.xml是一个文件，其中包含有关项目的信息以及 Maven 用于构建项目的配置详细信息。我们提供了 Eclipse 链接持久性供应器，Apache Commons lang 库和 Java EE Web API 的依赖项。我们指示 Maven 使用 Java8。最终的构建文件称为car-app.war，位于target子目录中。

$ mvn package

该项目是使用mvn package命令构建的。

$ ./asadmin start-domain

从 GlassFish 的bin目录中，启动 GlassFish 服务器。

$ ./asadmin start-database --db-home ~/.netbeans-derby

Derby 服务器已启动。 NetBeans 在.netbeans-derby目录中创建 Derby 系统主目录，该目录位于用户的主目录中。在这里，我们可以找到我们之前使用过的sample数据库。

$ ~/bin/glassfish-4.1.1/glassfish/bin/asadmin deploy target/car-app.war

我们部署应用。我们看到警告语Table/View 'CARS' already exists in Schema 'APP'。这是eclipselink.ddl-generation属性的结果，该属性设置为create_tables。我们可以忽略警告。

$ curl localhost:8080/car-app/read?id=401
Name: Volvo, Price: 29000

我们检索先前创建的汽车。

在本教程中，我们为一些简单的业务逻辑创建了 Enterprise JavaBeans。我们已使用 NetBeans，Derby 和 Maven 作为示例。 ZetCode 具有以下相关教程： Derby 教程， Java 教程和 Stripes 教程。