Java任务指派案例如何开发

本文目录导读：

1. 系统架构设计
2. 数据库设计
3. 核心代码实现
4. 业务规则验证器
5. 前端示例代码
6. 高级功能扩展
7. 性能优化建议
8. 测试示例

我来详细介绍Java任务指派案例的开发流程和关键实现，这是一个经典的管理信息系统功能，通常用于任务分配、工作流管理等场景。

系统架构设计

技术栈建议

• 后端: Spring Boot + MyBatis/Spring Data JPA
• 前端: Vue/React + Element UI/Ant Design
• 数据库: MySQL
• 缓存: Redis

数据库设计

-- 用户表
CREATE TABLE `user` (
  `id` bigint PRIMARY KEY AUTO_INCREMENT,
  `username` varchar(50) NOT NULL,
  `real_name` varchar(50),
  `role` varchar(20) COMMENT 'admin/manager/user',
  `status` tinyint DEFAULT 1
);
-- 任务表
CREATE TABLE `task` (
  `id` bigint PRIMARY KEY AUTO_INCREMENT, varchar(200) NOT NULL,
  `description` text,
  `priority` tinyint COMMENT '1-低 2-中 3-高 4-紧急',
  `status` tinyint COMMENT '0-待指派 1-待执行 2-执行中 3-已完成 4-已取消',
  `create_user_id` bigint,
  `assign_user_id` bigint,
  `deadline` datetime,
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);
-- 任务指派记录表
CREATE TABLE `task_assignment` (
  `id` bigint PRIMARY KEY AUTO_INCREMENT,
  `task_id` bigint,
  `from_user_id` bigint,
  `to_user_id` bigint,
  `remark` varchar(500),
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP
);

核心代码实现

Entity类

@Entity
@Table(name = "task")
@Data
public class Task {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String description;
    @Column(name = "priority")
    private Integer priority;
    @Column(name = "status")
    private Integer status = 0; // 默认待指派
    @Column(name = "create_user_id")
    private Long createUserId;
    @Column(name = "assign_user_id")
    private Long assignUserId;
    private LocalDateTime deadline;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

Service层实现

@Service
@Transactional
public class TaskService {
    @Autowired
    private TaskRepository taskRepository;
    @Autowired
    private TaskAssignmentRepository assignmentRepository;
    @Autowired
    private UserRepository userRepository;
    // 创建任务
    public Task createTask(Task task) {
        task.setStatus(0); // 待指派
        task.setCreateTime(LocalDateTime.now());
        return taskRepository.save(task);
    }
    // 指派任务
    public Task assignTask(Long taskId, Long assignUserId, Long currentUserId) {
        Task task = taskRepository.findById(taskId)
            .orElseThrow(() -> new RuntimeException("任务不存在"));
        // 验证任务状态
        if (task.getStatus() != 0) {
            throw new RuntimeException("当前任务状态不可指派");
        }
        // 更新任务
        task.setAssignUserId(assignUserId);
        task.setStatus(1); // 待执行
        task.setUpdateTime(LocalDateTime.now());
        taskRepository.save(task);
        // 记录指派记录
        TaskAssignment assignment = new TaskAssignment();
        assignment.setTaskId(taskId);
        assignment.setFromUserId(currentUserId);
        assignment.setToUserId(assignUserId);
        assignment.setCreateTime(LocalDateTime.now());
        assignmentRepository.save(assignment);
        return task;
    }
    // 更新任务进度
    public Task updateTaskStatus(Long taskId, Integer status, Long userId) {
        Task task = taskRepository.findById(taskId)
            .orElseThrow(() -> new RuntimeException("任务不存在"));
        // 权限验证：只有执行者可以更新
        if (!task.getAssignUserId().equals(userId)) {
            throw new RuntimeException("无权操作此任务");
        }
        // 状态流转验证
        if (status == 2 && task.getStatus() != 1) {
            throw new RuntimeException("任务状态流转错误");
        }
        task.setStatus(status);
        task.setUpdateTime(LocalDateTime.now());
        return taskRepository.save(task);
    }
    // 获取用户的任务列表
    public Page<Task> getUserTasks(Long userId, Integer status, Pageable pageable) {
        Specification<Task> spec = Specification.where(null);
        // 过滤指派给当前用户的任务
        spec = spec.and((root, query, cb) -> 
            cb.equal(root.get("assignUserId"), userId));
        if (status != null) {
            spec = spec.and((root, query, cb) -> 
                cb.equal(root.get("status"), status));
        }
        return taskRepository.findAll(spec, pageable);
    }
    // 任务的重新指派
    public Task reassignTask(Long taskId, Long newUserId, String remark, Long currentUserId) {
        Task task = taskRepository.findById(taskId)
            .orElseThrow(() -> new RuntimeException("任务不存在"));
        // 记录重新指派
        TaskAssignment assignment = new TaskAssignment();
        assignment.setTaskId(taskId);
        assignment.setFromUserId(task.getAssignUserId());
        assignment.setToUserId(newUserId);
        assignment.setRemark(remark);
        assignment.setCreateTime(LocalDateTime.now());
        assignmentRepository.save(assignment);
        // 更新任务
        task.setAssignUserId(newUserId);
        task.setStatus(1); // 重新待执行
        task.setUpdateTime(LocalDateTime.now());
        return taskRepository.save(task);
    }
}

Controller层

@RestController
@RequestMapping("/api/tasks")
public class TaskController {
    @Autowired
    private TaskService taskService;
    // 创建任务
    @PostMapping
    public Result createTask(@RequestBody Task task, 
                            @RequestAttribute Long currentUserId) {
        task.setCreateUserId(currentUserId);
        return Result.success(taskService.createTask(task));
    }
    // 指派任务
    @PostMapping("/{taskId}/assign")
    public Result assignTask(@PathVariable Long taskId,
                            @RequestBody AssignRequest request,
                            @RequestAttribute Long currentUserId) {
        return Result.success(
            taskService.assignTask(taskId, request.getAssignUserId(), currentUserId)
        );
    }
    // 获取用户的任务列表
    @GetMapping("/my")
    public Result getMyTasks(@RequestParam(required = false) Integer status,
                            Pageable pageable,
                            @RequestAttribute Long currentUserId) {
        return Result.success(
            taskService.getUserTasks(currentUserId, status, pageable)
        );
    }
    // 更新任务状态
    @PutMapping("/{taskId}/status")
    public Result updateStatus(@PathVariable Long taskId,
                              @RequestBody StatusUpdateRequest request,
                              @RequestAttribute Long currentUserId) {
        return Result.success(
            taskService.updateTaskStatus(taskId, request.getStatus(), currentUserId)
        );
    }
}

业务规则验证器

@Component
public class TaskValidator {
    // 验证任务指派规则
    public void validateAssignment(Task task, Long assignUserId) {
        // 验证用户是否存在且可用
        User user = userRepository.findById(assignUserId)
            .orElseThrow(() -> new RuntimeException("被指派用户不存在"));
        if (user.getStatus() != 1) {
            throw new RuntimeException("被指派用户已禁用");
        }
        // 验证任务创建者不能给自己指派
        if (task.getCreateUserId().equals(assignUserId)) {
            throw new RuntimeException("不能指派给自己创建的任务");
        }
        // 验证用户权限（可选）
        if (!"user".equals(user.getRole())) {
            throw new RuntimeException("只能指派给普通用户");
        }
        // 验证负荷（用户当前待执行任务数量）
        long pendingCount = taskRepository.countByAssignUserIdAndStatusIn(
            assignUserId, Arrays.asList(1, 2));
        if (pendingCount >= 5) {
            throw new RuntimeException("该用户当前待处理任务已达上限");
        }
    }
    // 验证状态流转
    public void validateStatusTransition(Integer currentStatus, Integer newStatus) {
        Map<Integer, List<Integer>> validTransitions = new HashMap<>();
        validTransitions.put(0, Arrays.asList(1, 4)); // 待指派 -> 待执行/取消
        validTransitions.put(1, Arrays.asList(2, 4)); // 待执行 -> 执行中/取消
        validTransitions.put(2, Arrays.asList(3));    // 执行中 -> 已完成
        List<Integer> allowedStatus = validTransitions.get(currentStatus);
        if (allowedStatus == null || !allowedStatus.contains(newStatus)) {
            throw new RuntimeException("不允许的状态变更");
        }
    }
}

前端示例代码

// Vue组件示例
<template>
  <div class="task-assign">
    <el-dialog title="任务指派" :visible.sync="dialogVisible">
      <el-form :model="assignForm" :rules="rules" ref="assignForm">
        <el-form-item label="指派给" prop="userId">
          <el-select v-model="assignForm.userId" 
                     filterable
                     placeholder="请选择用户">
            <el-option v-for="user in userList" 
                       :key="user.id" 
                       :label="user.realName" 
                       :value="user.id">
              <span>{{ user.realName }}</span>
              <span class="task-count">(待处理: {{ user.pendingCount }})</span>
            </el-option>
          </el-select>
        </el-form-item>
        <el-form-item label="备注">
          <el-input type="textarea" v-model="assignForm.remark"></el-input>
        </el-form-item>
      </el-form>
      <span slot="footer">
        <el-button @click="dialogVisible = false">取消</el-button>
        <el-button type="primary" @click="handleAssign">确认指派</el-button>
      </span>
    </el-dialog>
  </div>
</template>
<script>
export default {
  data() {
    return {
      dialogVisible: false,
      taskId: null,
      userList: [],
      assignForm: {
        userId: null,
        remark: ''
      },
      rules: {
        userId: [
          { required: true, message: '请选择用户', trigger: 'change' }
        ]
      }
    }
  },
  methods: {
    // 打开指派对话框
    openAssign(taskId) {
      this.taskId = taskId
      this.getAvailableUsers()
      this.dialogVisible = true
    },
    // 获取可指派的用户列表
    async getAvailableUsers() {
      const res = await this.$api.getUsersWithPendingCount()
      this.userList = res.data
    },
    // 执行指派
    async handleAssign() {
      this.$refs.assignForm.validate(async (valid) => {
        if (valid) {
          await this.$api.assignTask(this.taskId, this.assignForm)
          this.$message.success('指派成功')
          this.dialogVisible = false
          this.$emit('assigned')
        }
      })
    }
  }
}
</script>

高级功能扩展

自动指派策略

@Service
public class AutoAssignStrategy {
    @Autowired
    private UserRepository userRepository;
    @Autowired
    private TaskRepository taskRepository;
    // 负载均衡策略：选择待处理任务最少的用户
    public User getLeastLoadUser() {
        List<User> activeUsers = userRepository.findByRoleAndStatus("user", 1);
        User selectedUser = null;
        int minLoad = Integer.MAX_VALUE;
        for (User user : activeUsers) {
            int load = taskRepository.countByAssignUserIdAndStatusIn(
                user.getId(), Arrays.asList(1, 2));
            if (load < minLoad) {
                minLoad = load;
                selectedUser = user;
            }
        }
        return selectedUser;
    }
    // 轮询策略
    public User getRoundRobinUser() {
        // 实现轮询算法，记录上次分配的用户ID
        // ...
    }
    // 能力匹配策略
    public User getSkillMatchUser(Set<String> requiredSkills) {
        // 根据任务所需的技能匹配用户
        // ...
    }
}

性能优化建议

• 缓存用户信息: 使用Redis缓存用户列表和工作负载
• 异步处理: 复杂的指派逻辑使用消息队列异步处理
• 索引优化: 在task表的assign_user_id和status字段创建复合索引
• 分页查询: 用户任务列表必须分页，避免大范围数据查询

测试示例

@SpringBootTest
class TaskServiceTest {
    @Autowired
    private TaskService taskService;
    @Test
    void testAssignTask() {
        // 创建任务
        Task task = new Task();
        task.setTitle("开发用户模块");
        task.setPriority(3);
        task = taskService.createTask(task);
        // 指派任务
        Task assigned = taskService.assignTask(task.getId(), 2L, 1L);
        // 验证
        assertEquals(1, assigned.getStatus().intValue());
        assertEquals(2L, assigned.getAssignUserId().longValue());
    }
    @Test
    void testReassignTask() {
        // 验证重新指派会更新状态
        // ...
    }
}

这个完整的案例涵盖了任务指派系统的基本功能，包括创建、指派、重新指派、状态管理等核心功能，以及权限验证、业务规则等企业级实践，根据具体需求，还可以扩展通知功能、审批流程、任务统计等模块。