Java后端-JavaEE-JavaEE 架构实战与项目落地-12

 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

package com.example.task.ejb.entity;

import jakarta.persistence.*;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

@Entity
@Table(name = "t_user")
@NamedQueries({
    @NamedQuery(name = "User.findByUsername", 
                query = "SELECT u FROM User u WHERE u.username = :username"),
    @NamedQuery(name = "User.findByEmail", 
                query = "SELECT u FROM User u WHERE u.email = :email"),
    @NamedQuery(name = "User.findAll", 
                query = "SELECT u FROM User u ORDER BY u.id")
})
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @NotBlank
    @Size(min = 3, max = 50)
    @Column(nullable = false, unique = true, length = 50)
    private String username;
    
    @NotBlank
    @Size(min = 6, max = 100)
    @Column(nullable = false)
    private String password;  // 实际应存储加密后的密码
    
    @Email
    @NotBlank
    @Column(nullable = false, unique = true, length = 100)
    private String email;
    
    @Column(length = 50)
    private String fullName;
    
    @Column(nullable = false)
    private String role = "USER";  // USER, ADMIN
    
    @Column(nullable = false)
    private boolean active = true;
    
    @Column(name = "create_time", nullable = false, updatable = false)
    private LocalDateTime createTime;
    
    @Column(name = "update_time")
    private LocalDateTime updateTime;
    
    @OneToMany(mappedBy = "assignee", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<Task> assignedTasks = new ArrayList<>();
    
    @OneToMany(mappedBy = "creator", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<Task> createdTasks = new ArrayList<>();
    
    @PrePersist
    protected void onCreate() {
        createTime = LocalDateTime.now();
        updateTime = LocalDateTime.now();
    }
    
    @PreUpdate
    protected void onUpdate() {
        updateTime = LocalDateTime.now();
    }
    
    // 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
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102

package com.example.task.ejb.entity;

import jakarta.persistence.*;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import java.time.LocalDateTime;

@Entity
@Table(name = "t_task")
@NamedQueries({
    @NamedQuery(name = "Task.findByAssignee", 
                query = "SELECT t FROM Task t WHERE t.assignee.id = :userId ORDER BY t.createTime DESC"),
    @NamedQuery(name = "Task.findByCreator", 
                query = "SELECT t FROM Task t WHERE t.creator.id = :userId ORDER BY t.createTime DESC"),
    @NamedQuery(name = "Task.findByStatus", 
                query = "SELECT t FROM Task t WHERE t.status = :status ORDER BY t.createTime DESC"),
    @NamedQuery(name = "Task.countByStatus", 
                query = "SELECT COUNT(t) FROM Task t WHERE t.status = :status"),
    @NamedQuery(name = "Task.findOverdue", 
                query = "SELECT t FROM Task t WHERE t.dueDate < :now AND t.status != 'COMPLETED'")
})
public class Task {
    
    public enum Status {
        PENDING("待处理"),
        IN_PROGRESS("进行中"),
        COMPLETED("已完成"),
        CANCELLED("已取消");
        
        private final String label;
        Status(String label) { this.label = label; }
        public String getLabel() { return label; }
    }
    
    public enum Priority {
        LOW("低"),
        MEDIUM("中"),
        HIGH("高"),
        URGENT("紧急");
        
        private final String label;
        Priority(String label) { this.label = label; }
        public String getLabel() { return label; }
    }
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @NotBlank
    @Size(min = 1, max = 200)
    @Column(nullable = false, length = 200)
    private String title;
    
    @Size(max = 2000)
    @Column(length = 2000)
    private String description;
    
    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private Status status = Status.PENDING;
    
    @Enumerated(EnumType.STRING)
    private Priority priority = Priority.MEDIUM;
    
    @Column(name = "due_date")
    private LocalDateTime dueDate;
    
    @Column(name = "create_time", nullable = false, updatable = false)
    private LocalDateTime createTime;
    
    @Column(name = "update_time")
    private LocalDateTime updateTime;
    
    @Column(name = "complete_time")
    private LocalDateTime completeTime;
    
    @ManyToOne
    @JoinColumn(name = "assignee_id")
    private User assignee;  // 被分配人
    
    @ManyToOne
    @JoinColumn(name = "creator_id", nullable = false)
    private User creator;  // 创建人
    
    @PrePersist
    protected void onCreate() {
        createTime = LocalDateTime.now();
        updateTime = LocalDateTime.now();
    }
    
    @PreUpdate
    protected void onUpdate() {
        updateTime = LocalDateTime.now();
        if (status == Status.COMPLETED && completeTime == null) {
            completeTime = LocalDateTime.now();
        }
    }
    
    // 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

package com.example.task.ejb.entity;

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

@Entity
@Table(name = "t_audit_log")
@NamedQuery(name = "AuditLog.findByUser", 
            query = "SELECT a FROM AuditLog a WHERE a.userId = :userId ORDER BY a.createTime DESC")
public class AuditLog {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "user_id")
    private Long userId;
    
    @Column(name = "username")
    private String username;
    
    @Column(nullable = false)
    private String action;  // 操作类型
    
    @Column(length = 2000)
    private String detail;  // 操作详情
    
    @Column(name = "ip_address", length = 50)
    private String ipAddress;
    
    @Column(name = "create_time", nullable = false)
    private LocalDateTime createTime;
    
    @PrePersist
    protected void onCreate() {
        createTime = LocalDateTime.now();
    }
    
    // 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

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="https://jakarta.ee/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="https://jakarta.ee/xml/ns/persistence
             https://jakarta.ee/xml/ns/persistence/persistence_3_0.xsd"
             version="3.0">
    
    <persistence-unit name="taskPU" transaction-type="JTA">
        <jta-data-source>java:jboss/datasources/TaskDS</jta-data-source>
        
        <properties>
            <!-- 自动建表/更新表结构 -->
            <property name="jakarta.persistence.schema-generation.database.action" 
                      value="update"/>
            
            <!-- 显示 SQL -->
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.format_sql" value="true"/>
            
            <!-- 二级缓存 -->
            <property name="hibernate.cache.use_second_level_cache" value="true"/>
            <property name="hibernate.cache.region.factory_class" 
                      value="org.hibernate.cache.jcache.JCacheRegionFactory"/>
            
            <!-- 事务隔离级别 -->
            <property name="hibernate.connection.isolation" value="2"/>  <!-- READ_COMMITTED -->
        </properties>
    </persistence-unit>
</persistence>

  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
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102

package com.example.task.ejb.service;

import com.example.task.ejb.entity.User;
import com.example.task.ejb.entity.AuditLog;
import com.example.task.common.exception.ResourceNotFoundException;
import com.example.task.common.exception.BusinessException;
import jakarta.ejb.Stateless;
import jakarta.ejb.TransactionAttribute;
import jakarta.ejb.TransactionAttributeType;
import jakarta.inject.Inject;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import jakarta.annotation.security.RolesAllowed;
import jakarta.annotation.security.PermitAll;
import java.util.List;

@Stateless
public class UserService {
    
    @PersistenceContext
    private EntityManager em;
    
    @Inject
    private AuditService auditService;
    
    // 注册用户（不需要认证）
    @PermitAll
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public User registerUser(String username, String email, String password, String fullName) {
        // 检查用户名是否已存在
        List<User> existing = em.createNamedQuery("User.findByUsername", User.class)
                .setParameter("username", username)
                .getResultList();
        if (!existing.isEmpty()) {
            throw new BusinessException("用户名已被占用");
        }
        
        User user = new User();
        user.setUsername(username);
        user.setEmail(email);
        user.setPassword(password);  // 生产环境需加密
        user.setFullName(fullName);
        user.setRole("USER");
        user.setActive(true);
        
        em.persist(user);
        auditService.log(user.getId(), username, "REGISTER", "用户注册成功");
        return user;
    }
    
    // 查询所有用户（仅管理员）
    @RolesAllowed("ADMIN")
    @TransactionAttribute(TransactionAttributeType.SUPPORTS)
    public List<User> findAllUsers() {
        return em.createNamedQuery("User.findAll", User.class)
                 .getResultList();
    }
    
    // 根据 ID 查询用户
    @PermitAll
    @TransactionAttribute(TransactionAttributeType.SUPPORTS)
    public User findUserById(Long id) {
        User user = em.find(User.class, id);
        if (user == null) {
            throw new ResourceNotFoundException("用户不存在，ID：" + id);
        }
        return user;
    }
    
    // 根据用户名查询用户
    @PermitAll
    @TransactionAttribute(TransactionAttributeType.SUPPORTS)
    public User findByUsername(String username) {
        return em.createNamedQuery("User.findByUsername", User.class)
                .setParameter("username", username)
                .getSingleResult();
    }
    
    // 更新用户（仅管理员）
    @RolesAllowed("ADMIN")
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public User updateUser(Long id, String email, String fullName, String role, Boolean active) {
        User user = findUserById(id);
        if (email != null) user.setEmail(email);
        if (fullName != null) user.setFullName(fullName);
        if (role != null) user.setRole(role);
        if (active != null) user.setActive(active);
        
        auditService.log(id, user.getUsername(), "UPDATE_USER", "用户信息已更新");
        return user;
    }
    
    // 删除用户（仅管理员）
    @RolesAllowed("ADMIN")
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public void deleteUser(Long id) {
        User user = findUserById(id);
        String username = user.getUsername();
        em.remove(user);
        auditService.log(id, username, "DELETE_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
 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
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

package com.example.task.ejb.service;

import com.example.task.ejb.entity.Task;
import com.example.task.ejb.entity.User;
import com.example.task.common.exception.ResourceNotFoundException;
import com.example.task.common.exception.BusinessException;
import com.example.task.ejb.event.TaskCreatedEvent;
import com.example.task.ejb.event.TaskStatusChangedEvent;
import jakarta.ejb.Stateless;
import jakarta.ejb.TransactionAttribute;
import jakarta.ejb.TransactionAttributeType;
import jakarta.inject.Inject;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import jakarta.annotation.security.RolesAllowed;
import jakarta.annotation.security.PermitAll;
import jakarta.enterprise.event.Event;
import java.time.LocalDateTime;
import java.util.List;

@Stateless
public class TaskService {
    
    @PersistenceContext
    private EntityManager em;
    
    @Inject
    private UserService userService;
    
    @Inject
    private AuditService auditService;
    
    @Inject
    private Event<TaskCreatedEvent> taskCreatedEvent;      // CDI 事件
    
    @Inject
    private Event<TaskStatusChangedEvent> taskStatusEvent; // CDI 事件
    
    // 创建任务
    @RolesAllowed({"USER", "ADMIN"})
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public Task createTask(String title, String description, 
                           Long assigneeId, String priority, LocalDateTime dueDate,
                           Long creatorId) {
        User creator = userService.findUserById(creatorId);
        User assignee = userService.findUserById(assigneeId);
        
        Task task = new Task();
        task.setTitle(title);
        task.setDescription(description);
        task.setAssignee(assignee);
        task.setCreator(creator);
        task.setPriority(Task.Priority.valueOf(priority));
        task.setDueDate(dueDate);
        task.setStatus(Task.Status.PENDING);
        
        em.persist(task);
        
        auditService.log(creatorId, creator.getUsername(), "CREATE_TASK", 
                        "创建任务：" + title + "，分配给：" + assignee.getUsername());
        
        // 发布 CDI 事件（异步通知）
        taskCreatedEvent.fire(new TaskCreatedEvent(task.getId(), title, 
                                                   assignee.getId(), creator.getId()));
        
        return task;
    }
    
    // 查询分配给当前用户的任务
    @RolesAllowed({"USER", "ADMIN"})
    @TransactionAttribute(TransactionAttributeType.SUPPORTS)
    public List<Task> findTasksByAssignee(Long userId) {
        return em.createNamedQuery("Task.findByAssignee", Task.class)
                .setParameter("userId", userId)
                .getResultList();
    }
    
    // 查询由当前用户创建的任务
    @RolesAllowed({"USER", "ADMIN"})
    @TransactionAttribute(TransactionAttributeType.SUPPORTS)
    public List<Task> findTasksByCreator(Long userId) {
        return em.createNamedQuery("Task.findByCreator", Task.class)
                .setParameter("userId", userId)
                .getResultList();
    }
    
    // 查询所有任务（仅管理员）
    @RolesAllowed("ADMIN")
    @TransactionAttribute(TransactionAttributeType.SUPPORTS)
    public List<Task> findAllTasks(int page, int size) {
        return em.createQuery("SELECT t FROM Task t ORDER BY t.createTime DESC", Task.class)
                .setFirstResult((page - 1) * size)
                .setMaxResults(size)
                .getResultList();
    }
    
    // 更新任务状态
    @RolesAllowed({"USER", "ADMIN"})
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public Task updateTaskStatus(Long taskId, String newStatus, Long operatorId) {
        Task task = findTaskById(taskId);
        User operator = userService.findUserById(operatorId);
        Task.Status oldStatus = task.getStatus();
        Task.Status status = Task.Status.valueOf(newStatus);
        
        // 验证状态流转合法性
        if (task.getStatus() == Task.Status.COMPLETED || 
            task.getStatus() == Task.Status.CANCELLED) {
            throw new BusinessException("任务已完成或已取消，无法更改状态");
        }
        
        task.setStatus(status);
        
        auditService.log(operatorId, operator.getUsername(), "UPDATE_TASK_STATUS",
                        "任务 " + task.getTitle() + " 状态从 " + oldStatus + " 变更为 " + status);
        
        // 发布状态变更事件
        taskStatusEvent.fire(new TaskStatusChangedEvent(taskId, task.getTitle(), 
                                                        oldStatus.toString(), newStatus,
                                                        task.getAssignee().getId()));
        
        return task;
    }
    
    // 删除任务（仅管理员）
    @RolesAllowed("ADMIN")
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public void deleteTask(Long taskId, Long operatorId) {
        Task task = findTaskById(taskId);
        User operator = userService.findUserById(operatorId);
        
        em.remove(task);
        auditService.log(operatorId, operator.getUsername(), "DELETE_TASK",
                        "删除任务：" + task.getTitle());
    }
    
    // 按状态统计任务数量
    @RolesAllowed("ADMIN")
    @TransactionAttribute(TransactionAttributeType.SUPPORTS)
    public long countTasksByStatus(String status) {
        return em.createNamedQuery("Task.countByStatus", Long.class)
                .setParameter("status", Task.Status.valueOf(status))
                .getSingleResult();
    }
    
    // 查询超时未完成的任务
    @RolesAllowed("ADMIN")
    @TransactionAttribute(TransactionAttributeType.SUPPORTS)
    public List<Task> findOverdueTasks() {
        return em.createNamedQuery("Task.findOverdue", Task.class)
                .setParameter("now", LocalDateTime.now())
                .getResultList();
    }
    
    private Task findTaskById(Long id) {
        Task task = em.find(Task.class, id);
        if (task == null) {
            throw new ResourceNotFoundException("任务不存在，ID：" + id);
        }
        return task;
    }
}

 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

package com.example.task.ejb.service;

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> configs;
    
    @PostConstruct
    public void init() {
        configs = new ConcurrentHashMap<>();
        configs.put("system.name", "企业任务管理平台");
        configs.put("system.version", "1.0.0");
        configs.put("task.max.per.user", "20");
        configs.put("notification.enabled", "true");
        System.out.println("系统配置服务初始化完成");
    }
    
    @Lock(LockType.READ)
    public String getConfig(String key) {
        return configs.getOrDefault(key, "");
    }
    
    @Lock(LockType.READ)
    public String getConfig(String key, String defaultValue) {
        return configs.getOrDefault(key, defaultValue);
    }
    
    @Lock(LockType.WRITE)
    public void setConfig(String key, String value) {
        configs.put(key, value);
    }
    
    @Lock(LockType.READ)
    public int getMaxTaskPerUser() {
        return Integer.parseInt(configs.getOrDefault("task.max.per.user", "20"));
    }
}

 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

package com.example.task.ejb.service;

import com.example.task.ejb.entity.AuditLog;
import jakarta.ejb.Stateless;
import jakarta.ejb.TransactionAttribute;
import jakarta.ejb.TransactionAttributeType;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;

@Stateless
public class AuditService {
    
    @PersistenceContext
    private EntityManager em;
    
    // 独立事务：外层回滚不影响审计日志
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
    public void log(Long userId, String username, String action, String detail) {
        AuditLog log = new AuditLog();
        log.setUserId(userId);
        log.setUsername(username);
        log.setAction(action);
        log.setDetail(detail);
        em.persist(log);
    }
}

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

package com.example.task.web.config;

import jakarta.ws.rs.ApplicationPath;
import jakarta.ws.rs.core.Application;
import java.util.HashSet;
import java.util.Set;

@ApplicationPath("/api")
public class ApplicationConfig extends Application {
    
    @Override
    public Set<Class<?>> getClasses() {
        Set<Class<?>> classes = new HashSet<>();
        // 资源类
        classes.add(UserResource.class);
        classes.add(TaskResource.class);
        // Provider
        classes.add(GlobalExceptionMapper.class);
        classes.add(AuthenticationFilter.class);
        classes.add(CorsFilter.class);
        return classes;
    }
}

 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

package com.example.task.web.rest;

import com.example.task.ejb.entity.User;
import com.example.task.ejb.service.UserService;
import com.example.task.common.dto.UserDTO;
import jakarta.ejb.EJB;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import jakarta.annotation.security.RolesAllowed;
import jakarta.annotation.security.PermitAll;
import org.eclipse.microprofile.openapi.annotations.Operation;
import org.eclipse.microprofile.openapi.annotations.tags.Tag;

import java.util.List;

@Path("/users")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@Tag(name = "用户管理")
public class UserResource {
    
    @EJB
    private UserService userService;
    
    // 注册（公开接口）
    @POST
    @PermitAll
    @Path("/register")
    @Operation(summary = "用户注册")
    public Response register(UserDTO.RegisterRequest request) {
        User user = userService.registerUser(
            request.getUsername(),
            request.getEmail(),
            request.getPassword(),
            request.getFullName()
        );
        return Response.status(Response.Status.CREATED)
                .entity(UserDTO.fromEntity(user))
                .build();
    }
    
    // 查询所有用户（仅管理员）
    @GET
    @RolesAllowed("ADMIN")
    @Operation(summary = "查询所有用户")
    public Response listUsers() {
        List<User> users = userService.findAllUsers();
        return Response.ok(users.stream().map(UserDTO::fromEntity).toList())
                .build();
    }
    
    // 查询单个用户
    @GET
    @Path("/{id}")
    @RolesAllowed({"USER", "ADMIN"})
    @Operation(summary = "根据ID查询用户")
    public Response getUser(@PathParam("id") Long id) {
        User user = userService.findUserById(id);
        return Response.ok(UserDTO.fromEntity(user)).build();
    }
}

  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
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

package com.example.task.web.rest;

import com.example.task.ejb.entity.Task;
import com.example.task.ejb.service.TaskService;
import com.example.task.common.dto.TaskDTO;
import jakarta.ejb.EJB;
import jakarta.security.enterprise.SecurityContext;
import jakarta.inject.Inject;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import jakarta.annotation.security.RolesAllowed;
import jakarta.annotation.security.PermitAll;
import org.eclipse.microprofile.openapi.annotations.Operation;
import org.eclipse.microprofile.openapi.annotations.tags.Tag;

import java.time.LocalDateTime;
import java.util.List;

@Path("/tasks")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@Tag(name = "任务管理")
public class TaskResource {
    
    @EJB
    private TaskService taskService;
    
    @Inject
    private SecurityContext securityContext;
    
    // 创建任务
    @POST
    @RolesAllowed({"USER", "ADMIN"})
    @Operation(summary = "创建任务")
    public Response createTask(TaskDTO.CreateRequest request) {
        Long currentUserId = getCurrentUserId();
        Task task = taskService.createTask(
            request.getTitle(),
            request.getDescription(),
            request.getAssigneeId(),
            request.getPriority(),
            request.getDueDate(),
            currentUserId
        );
        return Response.status(Response.Status.CREATED)
                .entity(TaskDTO.fromEntity(task))
                .build();
    }
    
    // 查询当前用户的任务
    @GET
    @RolesAllowed({"USER", "ADMIN"})
    @Path("/my-tasks")
    @Operation(summary = "查询当前用户的任务")
    public Response getMyTasks() {
        Long currentUserId = getCurrentUserId();
        List<Task> tasks = taskService.findTasksByAssignee(currentUserId);
        return Response.ok(tasks.stream().map(TaskDTO::fromEntity).toList())
                .build();
    }
    
    // 查询所有任务（仅管理员）
    @GET
    @RolesAllowed("ADMIN")
    @Operation(summary = "查询所有任务")
    public Response listTasks(@QueryParam("page") @DefaultValue("1") int page,
                              @QueryParam("size") @DefaultValue("20") int size) {
        List<Task> tasks = taskService.findAllTasks(page, size);
        return Response.ok(tasks.stream().map(TaskDTO::fromEntity).toList())
                .build();
    }
    
    // 更新任务状态
    @PUT
    @Path("/{id}/status")
    @RolesAllowed({"USER", "ADMIN"})
    @Operation(summary = "更新任务状态")
    public Response updateStatus(@PathParam("id") Long id, 
                                  TaskDTO.StatusUpdateRequest request) {
        Long currentUserId = getCurrentUserId();
        Task task = taskService.updateTaskStatus(id, request.getStatus(), currentUserId);
        return Response.ok(TaskDTO.fromEntity(task)).build();
    }
    
    // 删除任务（仅管理员）
    @DELETE
    @Path("/{id}")
    @RolesAllowed("ADMIN")
    @Operation(summary = "删除任务")
    public Response deleteTask(@PathParam("id") Long id) {
        Long currentUserId = getCurrentUserId();
        taskService.deleteTask(id, currentUserId);
        return Response.noContent().build();
    }
    
    // 统计任务（仅管理员）
    @GET
    @RolesAllowed("ADMIN")
    @Path("/stats")
    @Operation(summary = "任务统计")
    public Response getStats() {
        long pending = taskService.countTasksByStatus("PENDING");
        long inProgress = taskService.countTasksByStatus("IN_PROGRESS");
        long completed = taskService.countTasksByStatus("COMPLETED");
        long cancelled = taskService.countTasksByStatus("CANCELLED");
        return Response.ok(new TaskDTO.Stats(pending, inProgress, completed, cancelled))
                .build();
    }
    
    // 获取当前用户 ID
    private Long getCurrentUserId() {
        String username = securityContext.getCallerPrincipal().getName();
        // 实际应查询 UserService 根据用户名获取 ID
        // 此处简化，实际通过 SecurityContext 获取
        return 1L;
    }
}

 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

package com.example.task.ejb.event;

public class TaskCreatedEvent {
    private Long taskId;
    private String taskTitle;
    private Long assigneeId;
    private Long creatorId;
    private LocalDateTime createTime;
    
    public TaskCreatedEvent(Long taskId, String taskTitle, 
                            Long assigneeId, Long creatorId) {
        this.taskId = taskId;
        this.taskTitle = taskTitle;
        this.assigneeId = assigneeId;
        this.creatorId = creatorId;
        this.createTime = LocalDateTime.now();
    }
    // getter 省略
}

public class TaskStatusChangedEvent {
    private Long taskId;
    private String taskTitle;
    private String oldStatus;
    private String newStatus;
    private Long assigneeId;
    private LocalDateTime changeTime;
    
    public TaskStatusChangedEvent(Long taskId, String taskTitle, 
                                   String oldStatus, String newStatus, Long assigneeId) {
        this.taskId = taskId;
        this.taskTitle = taskTitle;
        this.oldStatus = oldStatus;
        this.newStatus = newStatus;
        this.assigneeId = assigneeId;
        this.changeTime = LocalDateTime.now();
    }
    // getter 省略
}

 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

package com.example.task.ejb.listener;

import com.example.task.ejb.event.TaskCreatedEvent;
import com.example.task.ejb.event.TaskStatusChangedEvent;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.enterprise.event.Observes;
import jakarta.enterprise.event.ObservesAsync;
import jakarta.inject.Inject;
import jakarta.jms.*;

@ApplicationScoped
public class TaskNotificationListener {
    
    @Inject
    private JMSContext jmsContext;
    
    @Resource(lookup = "java:jboss/queue/taskNotification")
    private Queue notificationQueue;
    
    // 同步监听：记录日志（快速执行）
    public void onTaskCreated(@Observes TaskCreatedEvent event) {
        System.out.println("[通知] 任务创建：" + event.getTaskTitle() + 
                           "，分配给：" + event.getAssigneeId());
    }
    
    // 异步监听：发送 JMS 消息（耗时操作，不阻塞主流程）
    public void sendNotificationAsync(@ObservesAsync TaskCreatedEvent event) {
        try {
            String message = String.format(
                "新任务通知：任务【%s】已分配给用户 %d，请及时处理。",
                event.getTaskTitle(), event.getAssigneeId()
            );
            TextMessage msg = jmsContext.createTextMessage(message);
            msg.setStringProperty("eventType", "TASK_CREATED");
            msg.setLongProperty("taskId", event.getTaskId());
            jmsContext.createProducer().send(notificationQueue, msg);
            System.out.println("[JMS] 任务创建通知已发送到消息队列");
        } catch (Exception e) {
            System.err.println("发送 JMS 消息失败：" + e.getMessage());
        }
    }
    
    // 同步监听状态变更
    public void onTaskStatusChanged(@Observes TaskStatusChangedEvent event) {
        System.out.println("[通知] 任务状态变更：" + event.getTaskTitle() + 
                           " [" + event.getOldStatus() + " → " + event.getNewStatus() + "]");
    }
}

 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

package com.example.task.ejb.mdb;

import jakarta.ejb.MessageDriven;
import jakarta.jms.Message;
import jakarta.jms.MessageListener;
import jakarta.jms.TextMessage;
import jakarta.jms.JMSException;
import jakarta.ejb.ActivationConfigProperty;
import jakarta.mail.*;
import jakarta.mail.internet.*;
import jakarta.annotation.Resource;

@MessageDriven(
    activationConfig = {
        @ActivationConfigProperty(
            propertyName = "destinationType",
            propertyValue = "jakarta.jms.Queue"
        ),
        @ActivationConfigProperty(
            propertyName = "destination",
            propertyValue = "queue/taskNotification"
        ),
        @ActivationConfigProperty(
            propertyName = "acknowledgeMode",
            propertyValue = "Auto-acknowledge"
        )
    }
)
public class NotificationMDB implements MessageListener {
    
    @Resource(lookup = "java:jboss/mail/Default")
    private Session mailSession;
    
    @Override
    public void onMessage(Message message) {
        try {
            if (message instanceof TextMessage) {
                TextMessage textMsg = (TextMessage) message;
                String content = textMsg.getText();
                String eventType = textMsg.getStringProperty("eventType");
                Long taskId = textMsg.getLongProperty("taskId");
                
                System.out.println("[MDB] 收到消息：类型=" + eventType + 
                                   "，任务ID=" + taskId + "，内容=" + content);
                
                // 模拟发送邮件
                // sendEmail("[email protected]", "任务通知", content);
            }
        } catch (JMSException e) {
            System.err.println("处理 JMS 消息失败：" + e.getMessage());
            throw new RuntimeException("消息处理失败", e);
        }
    }
    
    // 邮件发送（示例）
    private void sendEmail(String to, String subject, String body) {
        try {
            MimeMessage msg = new MimeMessage(mailSession);
            msg.setFrom(new InternetAddress("[email protected]"));
            msg.setRecipient(Message.RecipientType.TO, new InternetAddress(to));
            msg.setSubject(subject);
            msg.setText(body);
            Transport.send(msg);
            System.out.println("[邮件] 已发送邮件到：" + to);
        } catch (MessagingException e) {
            System.err.println("邮件发送失败：" + e.getMessage());
        }
    }
}