Java后端-JavaEE-EJB企业级组件深入理解-5

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import jakarta.ejb.Stateless;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import java.util.List;

@Stateless
public class UserService {
    
    @PersistenceContext
    private EntityManager em;
    
    // 查询用户（无状态，每次独立）
    public User findUser(Long id) {
        return em.find(User.class, id);
    }
    
    // 查询所有用户
    public List<User> findAllUsers() {
        return em.createQuery("SELECT u FROM User u", User.class)
                 .getResultList();
    }
    
    // 更新用户
    public void updateUser(User user) {
        em.merge(user);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

import jakarta.ejb.Stateful;
import jakarta.ejb.Remove;
import java.util.ArrayList;
import java.util.List;

@Stateful
public class ShoppingCartService {
    
    // 购物车商品列表（会话状态）
    private List<String> items = new ArrayList<>();
    
    // 添加商品
    public void addItem(String item) {
        items.add(item);
        System.out.println("添加商品：" + item + "，当前购物车：" + items.size() + "件");
    }
    
    // 移除商品
    public void removeItem(String item) {
        items.remove(item);
    }
    
    // 获取购物车所有商品
    public List<String> getItems() {
        return new ArrayList<>(items);
    }
    
    // 结账（清理购物车）
    @Remove
    public void checkout() {
        System.out.println("结账完成，商品：" + items);
        items.clear();
        // @Remove 标记的方法执行后，容器会销毁该 Stateful Bean 实例
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

import jakarta.ejb.Singleton;
import jakarta.ejb.Startup;
import jakarta.ejb.Lock;
import jakarta.ejb.LockType;
import jakarta.annotation.PostConstruct;
import java.util.concurrent.atomic.AtomicInteger;

@Singleton
@Startup  // 应用启动时立即创建实例
public class SystemConfigService {
    
    private AtomicInteger visitCount = new AtomicInteger(0);
    private String systemName;
    private boolean maintenanceMode;
    
    @PostConstruct
    public void init() {
        // 应用启动时初始化
        this.systemName = "My Enterprise System";
        this.maintenanceMode = false;
        System.out.println("系统配置服务初始化完成，系统名称：" + systemName);
    }
    
    // 读方法：允许多个线程并发读
    @Lock(LockType.READ)
    public String getSystemName() {
        return systemName;
    }
    
    // 写方法：同一时间只允许一个线程写
    @Lock(LockType.WRITE)
    public void setMaintenanceMode(boolean mode) {
        this.maintenanceMode = mode;
        System.out.println("维护模式已切换为：" + mode);
    }
    
    @Lock(LockType.READ)
    public boolean isMaintenanceMode() {
        return maintenanceMode;
    }
    
    // 访问计数（原子类保证线程安全）
    public int incrementAndGetVisitCount() {
        return visitCount.incrementAndGet();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

import jakarta.ejb.MessageDriven;
import jakarta.jms.Message;
import jakarta.jms.MessageListener;
import jakarta.jms.TextMessage;
import jakarta.jms.JMSException;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;

@MessageDriven(mappedName = "java:jboss/queue/orderQueue")
public class OrderProcessorMDB implements MessageListener {
    
    @PersistenceContext
    private EntityManager em;
    
    @Override
    public void onMessage(Message message) {
        try {
            // 1. 接收消息
            if (message instanceof TextMessage) {
                TextMessage textMsg = (TextMessage) message;
                String orderJson = textMsg.getText();
                System.out.println("收到订单消息：" + orderJson);
                
                // 2. 处理业务逻辑（解析JSON、保存订单、扣减库存等）
                // processOrder(orderJson);
                
                // 3. 消息处理成功，容器自动确认（ACK）
                System.out.println("订单处理完成");
            }
        } catch (JMSException e) {
            // 异常发生时，容器可根据配置决定是否重试
            System.err.println("处理消息失败：" + e.getMessage());
            // 抛出 RuntimeException 会触发消息重发
            throw new RuntimeException("消息处理失败", e);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

import jakarta.ejb.Stateless;
import jakarta.ejb.TransactionAttribute;
import jakarta.ejb.TransactionAttributeType;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;

@Stateless
public class OrderService {
    
    @PersistenceContext
    private EntityManager em;
    
    // 默认 REQUIRED：有事务则加入，无则新建
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public void createOrder(Order order) {
        em.persist(order);
        // 方法正常结束 → 容器自动提交事务
    }
    
    // REQUIRES_NEW：总是新建独立事务
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
    public void createAuditLog(String action) {
        // 即使外层事务回滚，审计日志也会被独立提交
        AuditLog log = new AuditLog(action);
        em.persist(log);
    }
    
    // 抛出 RuntimeException → 容器自动回滚事务
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public void transferMoney(Long fromId, Long toId, BigDecimal amount) {
        Account from = em.find(Account.class, fromId);
        Account to = em.find(Account.class, toId);
        
        if (from.getBalance().compareTo(amount) < 0) {
            throw new RuntimeException("余额不足"); // 自动回滚事务
        }
        
        from.setBalance(from.getBalance().subtract(amount));
        to.setBalance(to.getBalance().add(amount));
        // 正常结束 → 自动提交
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

import jakarta.ejb.Stateless;
import jakarta.ejb.TransactionManagement;
import jakarta.ejb.TransactionManagementType;
import jakarta.annotation.Resource;
import jakarta.transaction.UserTransaction;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;

@Stateless
@TransactionManagement(TransactionManagementType.BEAN)  // 声明使用 BMT
public class OrderServiceBMT {
    
    @Resource
    private UserTransaction utx;  // 注入事务管理器
    
    @PersistenceContext
    private EntityManager em;
    
    public void createOrderWithBMT(Order order) {
        try {
            // 1. 手动开启事务
            utx.begin();
            
            // 2. 执行业务逻辑
            em.persist(order);
            
            // 3. 手动提交事务
            utx.commit();
            
        } catch (Exception e) {
            try {
                // 4. 异常时手动回滚
                utx.rollback();
            } catch (Exception rollbackEx) {
                rollbackEx.printStackTrace();
            }
            throw new RuntimeException("订单创建失败", e);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import jakarta.ejb.Stateless;
import jakarta.annotation.security.RolesAllowed;
import jakarta.annotation.security.PermitAll;
import jakarta.annotation.security.DenyAll;

@Stateless
public class AdminService {
    
    // 仅 admin 和 manager 角色可访问
    @RolesAllowed({"admin", "manager"})
    public void deleteUser(Long userId) {
        // 删除用户逻辑
        System.out.println("用户 " + userId + " 已被删除");
    }
    
    // 仅 admin 角色可访问
    @RolesAllowed("admin")
    public void resetSystem() {
        // 系统重置逻辑
        System.out.println("系统已重置");
    }
    
    // 所有角色都可访问
    @PermitAll
    public String getPublicInfo() {
        return "公开信息";
    }
    
    // 禁止任何角色访问
    @DenyAll
    public void internalMethod() {
        // 此方法不会被外部调用
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

import jakarta.ejb.Stateless;
import jakarta.ejb.EJBContext;
import jakarta.annotation.Resource;

@Stateless
public class DocumentService {
    
    @Resource
    private EJBContext context;  // 注入 EJBContext
    
    public void deleteDocument(Long docId) {
        // 编程式权限检查
        if (!context.isCallerInRole("admin")) {
            throw new SecurityException("只有管理员可以删除文档");
        }
        // 删除逻辑...
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// EJB 中使用 CDI 注入
import jakarta.ejb.Stateless;
import jakarta.inject.Inject;

@Stateless
public class OrderService {
    
    @Inject
    private PaymentProcessor paymentProcessor;  // CDI Bean
    
    @Inject
    @ConfigValue("max.retry.count")  // 自定义 Qualifier
    private int maxRetryCount;  // CDI 注入配置值
    
    public void processOrder(Order order) {
        // 使用 CDI 注入的依赖
        paymentProcessor.process(order, maxRetryCount);
    }
}

// CDI Bean 中使用 EJB
import jakarta.inject.Named;
import jakarta.ejb.EJB;

@Named
public class OrderController {
    
    @EJB
    private OrderService orderService;  // 注入 EJB
    
    public String createOrder(Order order) {
        orderService.processOrder(order);
        return "success";
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// Task.java
import jakarta.persistence.*;
import java.time.LocalDateTime;

@Entity
@Table(name = "t_task")
public class Task {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String title;
    
    private String description;
    
    private String status;  // PENDING, IN_PROGRESS, COMPLETED, CANCELLED
    
    @Column(name = "assignee_id")
    private Long assigneeId;
    
    @Column(name = "create_time")
    private LocalDateTime createTime;
    
    @Column(name = "update_time")
    private LocalDateTime updateTime;
    
    // getter/setter 省略
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

import jakarta.ejb.Stateless;
import jakarta.ejb.TransactionAttribute;
import jakarta.ejb.TransactionAttributeType;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import jakarta.annotation.security.RolesAllowed;
import jakarta.annotation.security.PermitAll;
import java.time.LocalDateTime;
import java.util.List;

@Stateless
public class TaskService {
    
    @PersistenceContext
    private EntityManager em;
    
    // 创建任务（需要登录用户）
    @RolesAllowed({"user", "admin"})
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public Task createTask(String title, String description, Long assigneeId) {
        Task task = new Task();
        task.setTitle(title);
        task.setDescription(description);
        task.setAssigneeId(assigneeId);
        task.setStatus("PENDING");
        task.setCreateTime(LocalDateTime.now());
        task.setUpdateTime(LocalDateTime.now());
        
        em.persist(task);
        return task;
    }
    
    // 查询用户的任务
    @PermitAll
    public List<Task> findTasksByUser(Long userId) {
        return em.createQuery(
            "SELECT t FROM Task t WHERE t.assigneeId = :userId ORDER BY t.createTime DESC",
            Task.class)
            .setParameter("userId", userId)
            .getResultList();
    }
    
    // 更新任务状态（管理员可更新任何任务）
    @RolesAllowed({"admin"})
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public void updateTaskStatus(Long taskId, String status) {
        Task task = em.find(Task.class, taskId);
        if (task == null) {
            throw new IllegalArgumentException("任务不存在");
        }
        task.setStatus(status);
        task.setUpdateTime(LocalDateTime.now());
        // 事务提交时自动 UPDATE
    }
    
    // 完成任务（普通用户只能完成自己的任务）
    @RolesAllowed({"user", "admin"})
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public void completeTask(Long taskId, Long currentUserId) {
        Task task = em.find(Task.class, taskId);
        if (task == null) {
            throw new IllegalArgumentException("任务不存在");
        }
        // 权限校验：非管理员只能完成自己的任务
        if (!isAdmin(currentUserId) && !task.getAssigneeId().equals(currentUserId)) {
            throw new SecurityException("只能完成自己分配的任务");
        }
        task.setStatus("COMPLETED");
        task.setUpdateTime(LocalDateTime.now());
    }
    
    private boolean isAdmin(Long userId) {
        // 实际项目应从数据库或安全上下文获取角色
        return false;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

import jakarta.ejb.Singleton;
import jakarta.ejb.Startup;
import jakarta.ejb.Lock;
import jakarta.ejb.LockType;
import jakarta.annotation.PostConstruct;
import java.util.concurrent.ConcurrentHashMap;

@Singleton
@Startup
public class SystemConfigService {
    
    private ConcurrentHashMap<String, String> configMap;
    private int maxTaskPerUser;
    
    @PostConstruct
    public void init() {
        configMap = new ConcurrentHashMap<>();
        configMap.put("system.name", "Task Management System");
        configMap.put("system.version", "1.0.0");
        maxTaskPerUser = 10;  // 默认值
        System.out.println("系统配置服务初始化完成");
    }
    
    @Lock(LockType.READ)
    public String getConfig(String key) {
        return configMap.get(key);
    }
    
    @Lock(LockType.WRITE)
    public void setConfig(String key, String value) {
        configMap.put(key, value);
    }
    
    @Lock(LockType.READ)
    public int getMaxTaskPerUser() {
        return maxTaskPerUser;
    }
    
    @Lock(LockType.WRITE)
    public void setMaxTaskPerUser(int max) {
        if (max < 1) {
            throw new IllegalArgumentException("最大任务数不能小于1");
        }
        this.maxTaskPerUser = max;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

import jakarta.ejb.Stateful;
import jakarta.ejb.Remove;
import java.util.ArrayList;
import java.util.List;

@Stateful
public class UserSessionService {
    
    private Long userId;
    private String username;
    private List<String> recentOperations = new ArrayList<>();
    
    public void login(Long userId, String username) {
        this.userId = userId;
        this.username = username;
        recentOperations.clear();
        recentOperations.add("登录系统");
        System.out.println("用户 " + username + " 登录，会话已建立");
    }
    
    public Long getCurrentUserId() {
        return userId;
    }
    
    public String getCurrentUsername() {
        return username;
    }
    
    public void addOperation(String operation) {
        recentOperations.add(operation);
        if (recentOperations.size() > 20) {
            recentOperations.remove(0);  // 只保留最近20条
        }
    }
    
    public List<String> getRecentOperations() {
        return new ArrayList<>(recentOperations);
    }
    
    @Remove
    public void logout() {
        System.out.println("用户 " + username + " 登出，会话已销毁");
        userId = null;
        username = null;
        recentOperations.clear();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

import jakarta.ejb.MessageDriven;
import jakarta.jms.Message;
import jakarta.jms.MessageListener;
import jakarta.jms.TextMessage;
import jakarta.jms.JMSException;
import jakarta.ejb.ActivationConfigProperty;

@MessageDriven(
    activationConfig = {
        @ActivationConfigProperty(
            propertyName = "destinationType",
            propertyValue = "jakarta.jms.Queue"
        ),
        @ActivationConfigProperty(
            propertyName = "destination",
            propertyValue = "queue/taskNotification"
        )
    }
)
public class TaskNotificationMDB implements MessageListener {
    
    @Override
    public void onMessage(Message message) {
        try {
            if (message instanceof TextMessage) {
                TextMessage textMsg = (TextMessage) message;
                String content = textMsg.getText();
                System.out.println("【通知】" + content);
                
                // 实际项目：发送邮件、推送通知等
                // sendEmail(content);
                // pushNotification(content);
            }
        } catch (JMSException e) {
            System.err.println("处理通知消息失败：" + e.getMessage());
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

import jakarta.ejb.EJB;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;
import java.io.IOException;
import java.util.List;

@WebServlet("/task")
public class TaskServlet extends HttpServlet {
    
    @EJB
    private TaskService taskService;
    
    @EJB
    private SystemConfigService configService;
    
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        HttpSession session = req.getSession();
        Long userId = (Long) session.getAttribute("userId");
        
        if (userId == null) {
            resp.sendRedirect("/login");
            return;
        }
        
        // 查询用户的任务列表
        List<Task> tasks = taskService.findTasksByUser(userId);
        
        // 获取系统配置
        String systemName = configService.getConfig("system.name");
        int maxTask = configService.getMaxTaskPerUser();
        
        resp.setContentType("text/html;charset=UTF-8");
        resp.getWriter().println("<html><body>");
        resp.getWriter().println("<h1>" + systemName + "</h1>");
        resp.getWriter().println("<p>最大任务数：" + maxTask + "</p>");
        resp.getWriter().println("<h2>我的任务</h2>");
        resp.getWriter().println("<ul>");
        for (Task task : tasks) {
            resp.getWriter().println("<li>" + task.getTitle() + " - " + task.getStatus() + "</li>");
        }
        resp.getWriter().println("</ul>");
        resp.getWriter().println("</body></html>");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

┌─────────────────────────────────────────────────────────────────┐
│                        客户端（浏览器/APP）                      │
└────────────────────────────┬────────────────────────────────────┘
                             │ HTTP
                             ▼
┌─────────────────────────────────────────────────────────────────┐
│                    Web 层（Servlet/JSP）                        │
│                  注入 EJB（@EJB）调用业务逻辑                   │
└────────────────────────────┬────────────────────────────────────┘
                             │
                             ▼
┌─────────────────────────────────────────────────────────────────┐
│                      EJB 层（业务逻辑）                         │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────┐  │
│  │ TaskService  │  │UserSession   │  │ SystemConfigService  │  │
│  │ (Stateless)  │  │(Stateful)    │  │   (Singleton)        │  │
│  │ 事务: CMT    │  │ 会话状态     │  │   全局配置            │  │
│  │ 安全:注解    │  │ @Remove      │  │   @Startup           │  │
│  └──────┬───────┘  └──────────────┘  └──────────────────────┘  │
│         │                                                       │
│         │ 发送消息                                              │
│         ▼                                                       │
│  ┌──────────────────────────────────────────────────────────┐   │
│  │            TaskNotificationMDB (Message-Driven Bean)     │   │
│  │                    异步处理通知消息                       │   │
│  └──────────────────────────────────────────────────────────┘   │
└────────────────────────────┬────────────────────────────────────┘
                             │ JPA
                             ▼
┌─────────────────────────────────────────────────────────────────┐
│                        JPA（数据持久化）                        │
│                         EntityManager                          │
└────────────────────────────┬────────────────────────────────────┘
                             │ JDBC
                             ▼
┌─────────────────────────────────────────────────────────────────┐
│                        数据库（MySQL）                          │
└─────────────────────────────────────────────────────────────────┘