Java EJB技术实战入门与实例大全

本文还有配套的精品资源，点击获取

简介：Java EJB是Java EE的核心组成部分，用于创建企业级应用组件，支持事务处理、安全性和可伸缩性。本压缩包提供了各种实例，包括Session Beans、Message Driven Beans和Entity Beans的基本概念和实际应用代码，旨在帮助Java初学者理解并掌握EJB的使用。通过实例学习如何定义、部署EJB，并理解EJB的事务管理、安全性管理和注入机制。

1. 企业级Java组件EJB简介

企业级Java Bean（EJB）的兴起

企业级Java Bean（EJB）是一种Java API，它定义了一种创建分布式商业逻辑组件的方式。随着企业需求的增长和对可伸缩性、安全性和事务管理的需求，EJB应运而生。EJB为开发人员提供了一种管理企业级应用中复杂性的手段，包括对数据库访问、消息传递和其他企业服务的抽象。

EJB的核心特性

EJB的核心特性包括事务管理、安全、持久化、负载均衡和群集支持。EJB组件运行在EJB容器中，容器提供许多底层服务，如生命周期管理、声明式安全性检查和依赖注入。EJB定义了多种组件类型，包括Session Beans（无状态和有状态）、Message Driven Beans和Entity Beans。

EJB的历史与现状

从EJB 1.0到现在的EJB 3.x，EJB不断进化，以适应现代开发的需求。EJB 3.x引入了注解和POJO模型，简化了EJB的开发，降低了使用门槛。虽然近年来微服务架构逐渐流行，但EJB依然在需要复杂企业级服务的企业环境中占据一席之地。

在本文中，我们将深入探讨EJB的不同组件类型，了解它们的特点以及在企业应用中的具体使用方法。我们会通过实例代码展示EJB的配置和部署流程，同时还会涉及到事务管理和安全性管理等高级主题，帮助读者充分利用EJB的强大功能。

2. Session Beans、Message Driven Beans、Entity Beans核心概念

2.1 Session Beans的原理与应用

2.1.1 Session Beans的类型与生命周期

Session Beans 是企业级 Java Bean (EJB) 的一种类型，它代表了一个客户端的业务处理会话。Session Beans 可以分为两种类型：Stateful（有状态）和Stateless（无状态）。Stateful Session Beans 保存了特定于单个客户端的信息和状态，而Stateless Session Beans 在执行方法调用时并不保存特定客户端的状态信息。

Stateful Session Beans： - 适用于需要跟踪客户端会话状态的业务场景。 - 拥有一个与客户端生命周期相关联的生命周期。 - 可以持有一个事务上下文，在多次方法调用间保持数据状态。

Stateless Session Beans： - 适用于无状态的业务逻辑处理，例如执行计算或转换数据。 - 生命周期通常比较短，每次方法调用可能都在不同的实例上执行。 - 由于它们不维护客户端状态，因此在容器中易于复用，有助于优化性能。

生命周期管理： - EJB容器负责Session Bean的生命周期管理，包括实例的创建、调用方法和销毁。 - 当客户端调用Session Bean时，容器会创建Bean的实例（如果尚未存在），并将其与客户端的调用关联起来。 - 当客户端完成调用后，容器可以选择回收该实例，或者为了性能优化暂时保持实例，直到达到容器的容量限制或一定的时间周期。

2.1.2 Stateful与Stateless Session Beans的区别与选择

Stateful和Stateless Session Beans在业务应用中扮演着不同的角色，选择正确的类型对系统性能和客户端体验至关重要。

Stateful Session Beans： - 适合于需要长时间保持状态和与用户交互的场景，比如网上购物车。 - 由于持有状态，可以为用户提供连续和一致的交互体验。 - 开发者需要额外注意状态管理，以避免内存泄漏和数据一致性问题。

Stateless Session Beans： - 适合于无状态的业务逻辑处理，通常用于服务层。 - 性能较高，因为容器可以轻松地重用实例，减少资源消耗。 - 每次调用都是独立的，可以并行处理，提高系统的并发处理能力。

选择和最佳实践： - 考虑业务逻辑是否依赖于特定客户端的状态信息来决定使用Stateful或Stateless Session Beans。 - 如果业务逻辑需要在多个方法调用间保持状态，使用Stateful Session Beans。 - 对于那些与特定用户无关的通用业务处理，例如数据校验、计算逻辑等，使用Stateless Session Beans。 - 注意资源管理，避免在Stateful Session Beans中保存过多的状态，以免造成性能瓶颈。 - 在需要高并发支持的场景下，尽量使用Stateless Session Beans。

2.2 Message Driven Beans的工作原理

2.2.1 异步消息处理的优势与场景

Message Driven Beans (MDBs) 是Java EE规范中EJB组件的一种，用于处理异步消息传递。它们允许应用组件以消息队列为基础，实现解耦合、异步处理和高可靠性的消息处理逻辑。

异步消息处理的优势： - 解耦合：发送方和接收方不必同时在线，消息队列为它们提供了异步交互的媒介。 - 可靠性：消息系统确保消息的到达和处理，即使接收方暂时不可用，消息也不会丢失。 - 扩展性：系统可以根据消息负载水平动态调整资源，提高系统的处理能力。

适用场景： - 系统集成：在不同的系统组件之间传递信息。 - 异步处理：对用户的请求进行后台处理，例如批量数据处理或报告生成。 - 负载均衡：通过消息队列平衡不同消费者的负载，提高系统的稳定性和性能。

2.2.2 Message-Driven Beans的配置与部署

在使用Message Driven Beans之前，需要配置消息队列并进行相应的部署设置。

配置消息队列： - 创建一个消息队列，用于接收消息。 - 设置消息队列的连接工厂，以便应用程序能够发送和接收消息。

MDB的配置： - 需要在EJB模块的部署描述文件中定义MDB。 - 配置消息监听器，指定消息类型、目的地和消息选择器。

部署步骤： - 将EJB打包成JAR或WAR文件。 - 部署到应用服务器，如WildFly或WebLogic。 - 确保消息队列服务运行并可接受来自MDB的连接。

2.3 Entity Beans与数据持久化

2.3.1 Entity Beans的角色与功能

Entity Beans代表了持久化存储的数据模型，通常与数据库表相对应。它们抽象化了数据持久化的细节，使得业务逻辑代码可以直接使用这些实体对象，而不需要关注底层数据的存储和检索。

角色： - 作为数据模型的载体，Entity Beans提供了对数据库表行的抽象。 - 提供了数据访问对象（DAO）模式的实现，使得业务逻辑与数据访问逻辑分离。 - 管理数据状态的生命周期，包括数据的创建、读取、更新和删除（CRUD）操作。

功能： - Entity Beans支持容器管理的持久性（CMP）和Bean管理的持久性（BMP）两种持久性机制。 - CMP通过容器自动管理实体的数据访问和持久化，开发者只需要声明实体的属性和关系。 - BMP则允许开发者编写自定义的数据库访问代码，提供了更高的控制度和灵活性。

2.3.2 实体关系映射(ORM)与数据持久化策略

实体关系映射（Entity-Relationship Mapping，简称ORM）是将对象模型映射到关系型数据库模型的过程。它简化了数据持久化的操作，使得开发者可以使用面向对象的方式来操作数据库。

ORM的优势： - 简化了数据库操作，开发者不需要编写底层SQL语句。 - 提高了代码的可维护性和可读性。 - 支持多种数据库，增加了应用的可移植性。

数据持久化策略： - 根据业务需求选择合适的持久化策略（CMP或BMP）。 - CMP易于实现，但BMP提供了更多的控制度，适用于复杂的业务逻辑和定制化的数据库操作。 - 选择合适的事务管理策略，以确保数据的一致性和完整性。

通过本章节的介绍，我们已经对Session Beans、Message Driven Beans和Entity Beans有了一个全面的了解，以及它们在企业级应用中的核心作用。下一章节我们将通过具体的代码实例，进一步探究EJB组件的实现和配置细节。

3. EJB代码实例与配置

3.1 Session Beans的代码实践

3.1.1 编写简单的Stateless Session Bean

无状态会话Bean（Stateless Session Bean）是EJB组件中非常基础且常用的一种类型。无状态会话Bean不保留任何客户端的状态信息，因此它们可以被容器重用，以服务多个客户端。下面是一个简单的无状态会话Bean的代码实现示例：

import javax.ejb.Stateless;
import javax.ejb.Remote;

@Stateless
@Remote(HelloService.class)
public class HelloServiceBean implements HelloService {
    @Override
    public String sayHello(String name) {
        return "Hello, " + name;
    }
}

interface HelloService {
    String sayHello(String name);
}

在上述代码中， @Stateless 注解表明这是一个无状态的Session Bean。 @Remote 注解则指明了该Bean的远程接口，远程客户端将通过此接口与Bean进行交互。方法 sayHello 是一个非常简单的业务逻辑，返回一个欢迎语。

代码逻辑解读分析

• @Stateless注解 ：这是EJB容器识别无状态会话Bean的关键注解。
• @Remote注解 ：用于定义可以被远程客户端访问的接口，客户端通过这个接口调用Bean中的业务方法。
• sayHello 方法：这个方法仅接受一个字符串参数（客户名称），并返回一个问候语，业务逻辑简单明了。

3.1.2 状态管理与会话跟踪

尽管Stateless Session Beans不保留状态信息，但在某些情况下，可能需要管理与会话相关的状态。为了实现这一点，我们可以使用 HttpSession 来跟踪会话信息，然后在EJB中通过JNDI（Java Naming and Directory Interface）查找对应的会话。

这里是一个增强的无状态Session Bean示例，它能够处理简单的会话跟踪：

import javax.ejb.Stateless;
import javax.ejb.Remote;
import javax.annotation.Resource;
import javax.servlet.http.HttpSession;

@Stateless
@Remote(SessionTrackingService.class)
public class SessionTrackingServiceBean implements SessionTrackingService {
    @Resource(name="java:comp/env/httpSession")
    private HttpSession httpSession;

    @Override
    public String getCounterValue() {
        Integer counter = (Integer) httpSession.getAttribute("counter");
        if (counter == null) {
            counter = 0;
        }
        counter++;
        httpSession.setAttribute("counter", counter);
        return "Current counter value is " + counter;
    }
}

interface SessionTrackingService {
    String getCounterValue();
}

在上述代码中， @Resource 注解用于注入由 java:comp/env/httpSession 定义的 HttpSession 对象，这样可以跨越HTTP请求维持状态。

代码逻辑解读分析

• @Resource注解 ：允许我们注入由JNDI名称定义的对象，即 HttpSession 对象。
• getCounterValue 方法：这个方法用于演示如何通过HttpSession跟踪和管理状态。首先，它尝试从会话中获取计数器的值，如果不存在，则初始化为0，之后每次调用此方法，计数器都会自增。
• 状态跟踪 ：通过 HttpSession 对象的属性来跟踪状态信息。

在实际应用中，需要注意的是，虽然可以在EJB中使用HttpSession对象，但这通常是在Web应用的上下文中使用的。非Web环境（例如EJB客户端通过RMI）中不支持HttpSession。

3.2 Entity Beans的代码实现

3.2.1 实体Bean的创建与查询

在EJB中，Entity Beans用于映射数据持久化层中的数据表，实现数据的CRUD操作。下面是一个简单的实体Bean实现示例，其中包括创建、保存和查询数据库记录的功能：

import javax.ejb.Stateless;
import javax.ejb.Remote;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.PersistenceContext;
import javax.persistence.EntityManager;

@Entity
@Stateless
@Remote(EntityService.class)
public class UserEntity implements UserEntityLocal {
    @Id
    private String username;
    private String email;

    // No-argument constructor is required by JPA
    public UserEntity() {}

    public UserEntity(String username, String email) {
        this.username = username;
        this.email = email;
    }

    @Override
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Override
    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

@Remote
public interface EntityService {
    void createUser(String username, String email);
    UserEntity getUser(String username);
}

public class EntityServiceBean implements EntityService {
    @PersistenceContext
    private EntityManager em;

    @Override
    public void createUser(String username, String email) {
        UserEntity user = new UserEntity(username, email);
        em.persist(user);
    }

    @Override
    public UserEntity getUser(String username) {
        return em.find(UserEntity.class, username);
    }
}

这个示例中， UserEntity 是一个实体类，它映射了数据库中的一个用户表。 EntityServiceBean 是一个无状态会话Bean，它实现了 EntityService 接口，提供了创建新用户和获取现有用户的方法。

代码逻辑解读分析

• 实体映射 ： @Entity 注解表明 UserEntity 类是一个实体类。 @Id 注解用于指定实体类中作为主键的属性。
• createUser 方法：此方法接收用户名和电子邮件地址作为参数，创建一个新的 UserEntity 对象，并使用 EntityManager 的 persist 方法将其保存到数据库。
• getUser 方法：此方法根据用户名查找用户， EntityManager 的 find 方法用于查询数据库中的记录，并返回一个 UserEntity 对象。

3.2.2 实体关系与事务属性的应用

在企业级应用中，实体之间往往存在复杂的关系，如一对一、一对多、多对多等。下面的代码示例将扩展上述用户实体，使其与一个地址实体建立一对多的关系：

@Entity
public class AddressEntity {
    @Id
    private Long addressId;
    private String street;
    private String city;
    private String country;
    @ManyToOne(fetch=FetchType.LAZY)
    private UserEntity user;
    // Getters and setters omitted for brevity
}

// Update UserEntity to establish a one-to-many relationship with AddressEntity
@Entity
public class UserEntity {
    // Existing fields omitted for brevity
    @OneToMany(mappedBy="user", fetch=FetchType.LAZY, cascade=CascadeType.ALL)
    private Set<AddressEntity> addresses;
    // Getters and setters omitted for brevity
}

在这个例子中， UserEntity 与 AddressEntity 建立了一对多的关系，一个用户可以拥有多个地址。 @OneToMany 注解用于表示一对多的关系，而 @ManyToOne 注解用于表示多对一的关系。

代码逻辑解读分析

• 一对一关系注解 ： @ManyToOne 注解定义了一个多对一的关系，指明多个 AddressEntity 实体将关联到一个 UserEntity 实体。
• 一对多关系注解 ： @OneToMany 注解定义了一个一对多的关系，指明一个 UserEntity 实体将关联多个 AddressEntity 实体。
• 持久化属性 ： mappedBy 属性指定哪个实体拥有外键关系。 fetch=FetchType.LAZY 表示当访问实体集合时采用懒加载模式。 cascade=CascadeType.ALL 表示对 UserEntity 的持久化操作将会级联到 addresses 集合中的 AddressEntity 实体。

在实际应用中，这样的关系管理需要借助于事务属性来控制持久化操作的一致性。EJB容器提供了声明式事务管理，通过 @TransactionManagement 注解和 @TransactionAttribute 注解，可以轻松地控制事务边界。

3.3 配置文件的作用与编写技巧

3.3.1 EJB部署描述文件ejb-jar.xml

EJB部署描述文件（ejb-jar.xml）用于定义EJB模块的配置信息。这个文件可以配置会话Bean的事务属性、安全性、超时、资源引用等。尽管现代Java EE应用更多地使用注解来简化配置，但理解和编写 ejb-jar.xml 文件仍然对于EJB的深入学习至关重要。

下面是一个 ejb-jar.xml 文件的配置示例：

<ejb-jar xmlns="***" 
         xmlns:xsi="***"
         xsi:schemaLocation="***" 
         version="3.0">
    <assembly-descriptor>
        <container-transaction>
            <method>
                <ejb-name>HelloServiceBean</ejb-name>
                <method-name>sayHello</method-name>
            </method>
            <trans-attribute>NotSupported</trans-attribute>
        </container-transaction>
    </assembly-descriptor>
</ejb-jar>

该示例定义了一个容器事务，指明了 HelloServiceBean 中的 sayHello 方法不使用容器管理的事务。

3.3.2 环境属性的配置与管理

除了事务属性之外，还可以在 ejb-jar.xml 中配置环境属性（环境条目）。这些属性可以在EJB代码中通过JNDI查找来获取。下面是一个环境属性配置的示例：

<environment-entries>
    <env-entry>
        <description>Mail server configuration</description>
        <env-entry-name>mail.server.host</env-entry-name>
        <env-entry-type>java.lang.String</env-entry-type>
        <env-entry-value>***</env-entry-value>
    </env-entry>
</environment-entries>

此代码段在EJB模块的部署描述文件中定义了一个环境条目，它定义了邮件服务器的主机名。客户端可以通过JNDI查找来访问此环境条目。

配置文件编写技巧

• 可选性 ：随着Java EE的演进，许多原先需要在 ejb-jar.xml 中配置的选项，现在可以通过注解完成，比如事务属性和安全性。
• 清晰性 ：在需要使用 ejb-jar.xml 时，使用清晰的XML结构，加上文档说明，以便于其他人理解和维护。
• 兼容性 ：了解不同版本的EJB规范之间的差异，确保 ejb-jar.xml 的兼容性。
• 最佳实践 ：保持配置文件的简洁，避免过度配置，尽量将业务逻辑相关的配置留在代码中。

通过上述各章节的详细解读，我们已经深入理解了EJB组件的代码实例与配置方法。在下一章节中，我们将深入探讨EJB的部署与运行过程，以及如何在实际应用环境中调试EJB应用。

4. EJB部署与运行方法

4.1 EJB的打包与部署过程

4.1.1 构建EJB模块与应用服务器配置

企业级Java组件（EJB）需要依赖于一个应用服务器来部署和运行。构建EJB模块的过程涉及将业务逻辑打包成一个或多个EJB模块，这些模块可以是.jar文件或更复杂的Web归档（.war）或企业归档（.ear）。以下是构建EJB模块的基本步骤：

1. 创建EJB项目 ：在开发环境中创建一个新的EJB项目，并将EJB类和相关的资源文件添加到项目中。
2. 编写配置文件 ：为EJB项目编写必要的配置文件，如 ejb-jar.xml 和 web.xml （如果使用Web组件）。这些文件用于定义EJB的属性、事务要求、安全性等。
3. 打包EJB ：使用构建工具（如Maven或Ant）将EJB项目打包成归档文件。如果是EJB项目，通常是ejb-jar文件；如果是包含Web应用的企业应用，则打包为EAR文件。
4. 配置应用服务器 ：将打包好的EJB归档文件部署到一个已配置好的应用服务器上。常用的Java EE应用服务器有GlassFish, WildFly, WebLogic, WebSphere等。

4.1.2 部署步骤与环境检查

部署EJB组件到应用服务器上，包括以下步骤：

1. 放置归档文件 ：将打包好的EJB归档文件放置到应用服务器的部署目录下，例如GlassFish的 domains/domain1/autodeploy 目录。
2. 启动应用服务器 ：启动应用服务器，它将自动检测部署目录并部署归档文件。
3. 验证部署 ：检查应用服务器的日志文件，确认EJB模块是否成功部署，没有错误发生。
4. 环境检查 ：利用应用服务器提供的管理控制台或命令行工具进行环境检查，验证EJB组件的运行状态，以及与数据库的连接是否正确建立。
5. 单元测试 ：执行针对EJB的单元测试，确保业务逻辑正确执行，所有异常情况都得到妥善处理。

EJB的打包与部署是一个需要综合应用服务器配置知识和开发实践技能的过程。通过上述步骤，EJB组件可以成功部署到企业应用环境中，为客户端提供服务。

4.2 EJB应用的运行与调试

4.2.1 客户端如何调用EJB

EJB组件被部署到应用服务器后，客户端通过远程接口调用EJB方法。以下是客户端调用EJB的基本步骤：

1. 创建远程接口的代理对象 ：客户端通过JNDI（Java Naming and Directory Interface）查找远程接口。当客户端调用接口方法时，代理对象负责将请求转发给服务器端的EJB实例。
2. 查找EJB ：客户端使用JNDI查找方法定位到EJB组件。EJB的查找名称通常在部署描述文件中定义，并可通过环境属性进行配置。
3. 方法调用 ：客户端代码执行EJB的业务方法。此时，调用在客户端本地进行，但是实际的业务逻辑在服务器端执行。

4.2.2 日志记录与性能监控

为了确保EJB应用的稳定运行，监控和日志记录是必不可少的。以下是如何记录日志和监控性能的方法：

1. 日志记录 ：在EJB代码中加入日志记录语句，使用如Log4j或Java EE自带的日志API记录关键操作。同时，配置应用服务器以收集和存储日志信息。
2. 性能监控 ：使用应用服务器提供的监控工具，如GlassFish的Admin Console，监控EJB实例的状态和响应时间，以及服务器资源的使用情况。
3. 分析和优化 ：定期分析性能数据，识别瓶颈。然后根据分析结果优化EJB代码或调整服务器配置。

客户端与EJB交互的过程、日志记录和性能监控是确保EJB应用高可用性和良好性能的重要环节。通过综合运用这些手段，能够及时发现并解决问题，保证企业应用的连续运行。

5. EJB事务管理实践

5.1 事务的概念与EJB中的应用

5.1.1 事务的ACID属性

在讨论EJB中的事务管理之前，我们需要对事务有一个基本的理解。事务（Transaction）是指一系列的操作，这些操作作为一个整体被执行，要么全部成功，要么全部失败。事务管理在企业应用中至关重要，它保证了数据的一致性和完整性。事务必须具备ACID属性，即原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）。

• 原子性 ：事务被视为一个不可分割的最小工作单元，事务中的操作要么全部完成，要么全部不完成。
• 一致性 ：事务必须将数据库从一个一致性状态转换到另一个一致性状态，不应该存在中间状态。
• 隔离性 ：事务的执行不应受到其他事务的干扰，即在并发环境中事务之间应该相互隔离。
• 持久性 ：一旦事务提交，对数据库所做的更改就是永久性的，即使系统崩溃也不会丢失。

在EJB中，事务管理是通过容器提供的服务来实现的。开发者无需担心底层事务管理机制的具体实现细节，而只需要在业务逻辑中使用声明式事务注解或者编程式API来控制事务的行为。

5.1.2 EJB中声明式与编程式事务管理

EJB规范提供了两种事务管理方式：声明式事务管理和编程式事务管理。

• 声明式事务管理 ：开发者通过在EJB的方法上使用特定的注解（例如@TransactionAttribute）来声明事务属性，事务边界和事务行为是由容器自动管理的。这种方式简单、易于使用，并且可以将业务逻辑从事务管理的细节中分离出来。

@Stateless
public class MyEJB {
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
    public void myMethod() {
        // method implementation
    }
}

• 编程式事务管理 ：在需要更细粒度控制事务的情况下，可以使用编程式事务管理API，如UserTransaction接口，开发者将需要在代码中显式调用事务的开始、提交和回滚等操作。

@Stateless
public class MyEJB {
    @Resource
    private UserTransaction utx;

    public void myMethod() throws Exception {
        utx.begin();
        try {
            // ***
            ***mit();
        } catch (Exception ex) {
            utx.rollback();
            throw ex;
        }
    }
}

5.2 事务管理的高级用法

5.2.1 事务超时与回滚规则

EJB容器允许开发者设置事务的超时时间，这是通过 @TransactionAttribute 注解的 timeout 属性来实现的。事务超时是指事务在指定的时间内没有完成时，会被自动回滚。

@Stateless
public class MyEJB {
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    @Timeout(value=10, unit=TimeUnit.SECONDS)
    public void myTimeoutMethod() {
        // method that may exceed the timeout
    }
}

此外，开发者可以通过编程式方式在代码中指定事务的回滚规则，当遇到特定的异常时事务将自动回滚。

@Stateless
public class MyEJB {
    @Resource
    private UserTransaction utx;

    public void myMethod() throws Exception {
        utx.begin();
        try {
            // transactional operations
            throw new RollbackException("Forced rollback.");
        } catch (RollbackException ex) {
            utx.rollback();
        } finally {
            ***mit();
        }
    }
}

5.2.2 分布式事务的处理

在微服务架构和分布式系统中，多个服务之间可能会进行跨数据库的操作。EJB支持分布式事务的处理，这通常涉及到两阶段提交协议（2PC），由事务协调器来管理多个资源管理器。

EJB容器会处理分布式事务的复杂性，并确保所有资源要么一起提交，要么一起回滚。使用分布式事务时，开发者需要注意性能开销和死锁的风险，因为这通常会涉及到网络通信和不同资源管理器之间的协调。

@Stateless
public class MyEJB {
    @Resource
    private UserTransaction utx;

    public void distributedTransactionMethod() throws Exception {
        utx.begin();
        try {
            // ***
            ***mit();
        } catch (Exception ex) {
            utx.rollback();
            throw ex;
        }
    }
}

在本章节中，我们深入探讨了EJB中的事务管理实践，从理解事务的基本ACID属性到在EJB中的应用，再到对分布式事务处理的高级用法进行了详细解读。事务管理是EJB强大功能的一个重要组成部分，它使得开发者可以专注于业务逻辑的实现，而将事务的复杂性委托给EJB容器。通过本章节的介绍，希望能够使读者对EJB事务管理有更深入的理解，并在自己的项目中应用这些知识，以提升应用程序的数据一致性和可靠性。

6. EJB安全性管理机制

6.1 EJB安全模型与角色

6.1.1 安全领域与认证授权

在EJB的安全模型中，安全领域（Security Domain）是一个核心概念，它定义了用户身份验证和授权的机制。安全领域可以是一个内置的机制，也可以是一个外部定义的领域，比如一个数据库、LDAP服务器或自定义的安全模块。EJB容器提供了一个集成点，使得应用程序可以通过配置来使用这些安全领域。

认证（Authentication）是确认用户身份的过程，通常涉及到用户名和密码的校验。授权（Authorization）则是在用户身份被验证后，确定用户是否有权限执行某个操作或访问特定资源的过程。在EJB中，这些是由容器负责管理的，确保了安全策略的集中式控制和实施。

6.1.2 方法级别的安全访问控制

EJB中的安全管理可以通过容器管理的安全访问控制来实现。这包括声明式安全注解，比如Java EE提供的 @RolesAllowed , @PermitAll , @DenyAll ，允许开发者指定哪些角色（或所有用户、无用户）可以访问企业级Bean的哪些方法。此外，编程式安全策略也是可能的，允许在业务逻辑中明确地调用安全API来判断访问权限。

为了实现这些安全机制，EJB容器会使用声明在部署描述文件（ejb-jar.xml）中的安全角色和安全约束。通过这些机制，可以为不同的用户定义不同的权限，从而实现精细粒度的访问控制。

6.2 安全策略的配置与实践

6.2.1 应用安全规则

要应用安全策略，首先需要在部署描述文件中配置安全角色和安全约束。这些角色可以与应用服务器中定义的用户和组对应。配置完成后，EJB容器会根据这些规则来执行安全检查。

安全角色定义了应用程序中使用的角色名称，这些角色名称将在业务方法的注解中使用。安全约束则指定了哪些角色可以访问特定的企业级Bean或其方法。下面是一个简单的安全角色定义示例：

<security-role>
    <role-name>admin</role-name>
</security-role>

对于编程式安全，下面是一个检查当前用户是否拥有管理员角色权限的代码段：

if (ctx.isCallerInRole("admin")) {
    // 允许访问
} else {
    // 拒绝访问
}

在上面的代码中， ctx 是一个 EJBContext 对象，通过这个对象，我们可以访问当前调用者的安全信息。

6.2.2 客户端与EJB安全交互实例

在客户端应用中，安全机制的实现通常是透明的。客户端应用程序需要通过身份验证过程来获得安全凭证。这些凭证随后会被用来调用EJB，并根据已配置的安全策略来进行授权检查。

在Java SE客户端，调用EJB可能看起来像下面这样：

Properties properties = new Properties();
// 配置连接属性，如主机名，端口等
properties.put(Context.INITIAL_CONTEXT_FACTORY, "***CtxFactory");
InitialContext ctx = new InitialContext(properties);
Object objref = ctx.lookup("java:global/MyApp/MyEJBBean!com.mycompany.MyEJBInterface");

MyEJBInterface myEJB = (MyEJBInterface) PortableRemoteObject.narrow(objref, MyEJBInterface.class);

// 调用EJB方法
if (myEJB.callSecuredMethod()) {
    System.out.println("Method call successful");
} else {
    System.out.println("Access denied");
}

在这个例子中， MyEJBInterface 是一个远程接口， MyEJBBean 是对应的Bean实现。在客户端调用任何方法之前，安全检查已经被容器自动进行。

总结而言，EJB的安全性管理机制为开发者提供了一套灵活且强大的安全控制框架，支持从粗粒度的容器管理安全到细粒度的方法级别的安全控制。通过配置和编程式实现，企业能够构建出既安全又符合业务需求的应用程序。在下一章节中，我们将探讨EJB的依赖注入机制及其使用，这是另一种强大的EJB特性，它能够简化企业应用开发并提高代码的可维护性。

7. EJB注入机制使用

依赖注入（Dependency Injection）是现代企业级Java应用程序中一个常见的设计模式，它可以帮助开发者减少组件之间的耦合度，使得代码更加易于测试和维护。EJB作为一种企业级组件模型，自然也支持依赖注入的实现，并且提供了一系列的工具和方法来支持依赖注入。

7.1 依赖注入的原理与好处

7.1.1 依赖注入的概念与优势

依赖注入是一种设计模式，允许我们从硬编码依赖关系中解耦。在传统的编码方式中，如果一个组件A需要使用另一个组件B，那么组件A可能会直接创建组件B的实例。这种方式被称为“控制反转”（Inversion of Control, IoC），而依赖注入是实现IoC的一种方式。在依赖注入中，组件之间的依赖关系是通过构造函数、工厂方法或者属性来传递的。

依赖注入的主要优势在于： - 提高了组件的可测试性 ：通过依赖注入，我们可以很容易地为组件提供模拟（Mock）依赖，这使得单元测试更加简单。 - 降低了组件之间的耦合度 ：组件不再直接创建它们依赖的组件，这样在修改组件时，就不需要修改其他组件的代码。 - 配置的灵活性 ：依赖注入允许在运行时动态地为组件提供依赖，这样可以更加灵活地进行配置和替换组件。

7.1.2 EJB的依赖注入实现方式

EJB容器支持通过注解和XML两种方式来实现依赖注入。常见的注解包括 @EJB , @Resource , @PersistenceContext 等，它们允许开发者在EJB组件中注入企业bean、资源以及持久化上下文。这种方式不仅简洁而且直观，能够有效地将EJB组件中的依赖关系清晰地展示出来。

7.2 注入机制在EJB中的实践

7.2.1 使用注解实现资源注入

在EJB中，使用注解是一种非常常见且方便的方式来实现依赖注入。下面的例子展示了如何使用 @EJB 注解在Session Bean中注入另一个Session Bean。

@Stateless
public class MyService {
    @EJB
    private AnotherService anotherService;
    public void doSomething() {
        // 使用anotherService组件的方法
    }
}

在上面的例子中， MyService 是一个无状态的Session Bean，通过 @EJB 注解，我们将名为 AnotherService 的另一个Session Bean注入到 MyService 中。这种方式简化了代码，使得 MyService 不需要自己负责创建 AnotherService 的实例。

7.2.2 代码示例：资源注入在业务逻辑中的应用

下面的示例展示了一个使用资源注入进行业务处理的具体场景：

@Stateless
public class OrderService {

    @Resource(name = "jdbc/OrderDB")
    private DataSource orderDataSource;

    @PersistenceContext(unitName = "OrderPU")
    private EntityManager entityManager;

    public void createOrder(Order order) {
        // 使用注入的EntityManager来保存订单
        entityManager.persist(order);
    }
    public List<Order> getAllOrders() {
        // 使用注入的数据源来查询所有订单
        return entityManager.createQuery("SELECT o FROM Order o", Order.class)
                            .getResultList();
    }
}

在这个 OrderService 的例子中，我们注入了一个数据源 orderDataSource 和一个持久化上下文 entityManager 。这些资源使得 OrderService 能够与数据库进行交互，实现订单数据的增删改查操作。

在这个例子中，我们使用了 @Resource 来注入特定的JDBC数据源，以及使用 @PersistenceContext 来注入一个持久化上下文。通过这些注入的资源，我们的 OrderService 能够执行数据持久化相关的操作，如保存订单和查询订单列表。

通过这些示例可以看出，依赖注入不仅提高了代码的模块化，还使得组件之间的协作更加简单。在EJB环境中，合理运用依赖注入可以有效地简化开发流程，并且提升代码的可维护性。

本文还有配套的精品资源，点击获取

简介：Java EJB是Java EE的核心组成部分，用于创建企业级应用组件，支持事务处理、安全性和可伸缩性。本压缩包提供了各种实例，包括Session Beans、Message Driven Beans和Entity Beans的基本概念和实际应用代码，旨在帮助Java初学者理解并掌握EJB的使用。通过实例学习如何定义、部署EJB，并理解EJB的事务管理、安全性管理和注入机制。

本文还有配套的精品资源，点击获取