任务管理模块技术文档

1. 概述

任务管理模块是i-Husky运维服务系统的核心功能组件，负责工单子任务的创建、分配、执行、跟踪和完成管理。该模块采用前后端分离架构，提供完整的任务生命周期管理功能，支持多端协作和实时状态同步。

1.1 技术栈

前端: Vue 3 + Composition API + Element Plus + Vite
后端: Spring Boot 2.5.15 + MyBatis-Plus + MySQL
安全: Spring Security + JWT
缓存: Redis
文件存储: 阿里云OSS
移动端: UniApp (Vue 3)

1.2 核心特性

任务生命周期管理: 完整的状态流转和权限控制
智能任务分配: 基于技术员技能和负载的分配算法
实时进度跟踪: 动态进度计算和可视化展示
处理记录时间线: 完整的执行历史和附件管理
团队协作: 支持评论、回复和多角色协作
多端同步: Web管理端和移动技术员端数据实时同步

2. 系统架构

2.1 整体架构图

┌─────────────────────────────────────────────────────────────┐
│                    任务管理模块架构                        │
├─────────────────────────────────────────────────────────────┤
│  前端展示层                                               │
│  ┌─────────────────┐  ┌─────────────────┐              │
│  │  Web管理端      │  │  移动技术员端   │              │
│  │  (Vue 3 +      │  │  (UniApp)       │              │
│  │   Element Plus) │  │                 │              │
│  └─────────────────┘  └─────────────────┘              │
├─────────────────────────────────────────────────────────────┤
│  API接口层                                                │
│  ┌─────────────────────────────────────────────────────────┐ │
│  │ REST API + JWT认证统一接口                            │ │
│  └─────────────────────────────────────────────────────────┘ │
├─────────────────────────────────────────────────────────────┤
│  业务逻辑层                                               │
│  ┌─────────────────┐  ┌─────────────────┐              │
│  │ 任务管理Service │  │ 处理记录Service │              │
│  │                 │  │                 │              │
│  │ - 任务CRUD      │  │ - 时间线管理    │              │
│  │ - 状态管理      │  │ - 附件管理      │              │
│  │ - 进度计算      │  │ - 评论协作      │              │
│  │ - 分配算法      │  │                 │              │
│  └─────────────────┘  └─────────────────┘              │
├─────────────────────────────────────────────────────────────┤
│  数据访问层                                               │
│  ┌─────────────────┐  ┌─────────────────┐              │
│  │ MyBatis Mapper  │  │ 数据库          │              │
│  │                 │  │                 │              │
│  │ - XML映射       │  │ - 任务表        │              │
│  │ - 动态SQL       │  │ - 处理记录表    │              │
│  │ - 关联查询      │  │ - 状态变更表    │              │
│  │                 │  │                 │              │
│  └─────────────────┘  └─────────────────┘              │
├─────────────────────────────────────────────────────────────┤
│  基础支撑层                                               │
│  ┌─────────────────┐  ┌─────────────────┐              │
│  │ 权限管理        │  │ 通知服务        │              │
│  │                 │  │                 │              │
│  │ - 角色权限      │  │ - 邮件通知      │              │
│  │ - 数据权限      │  │ - WebSocket     │              │
│  │ - 操作日志      │  │ - 异步任务      │              │
│  └─────────────────┘  └─────────────────┘              │
└─────────────────────────────────────────────────────────────┘

2.2 数据流程图

工单创建 → 任务拆解 → 技术员分配 → 任务执行 → 进度更新 → 任务完成
    ↓         ↓         ↓         ↓         ↓         ↓
  维护计划  智能算法  负载均衡  处理记录  实时计算  状态同步
    ↓         ↓         ↓         ↓         ↓         ↓
  模板应用  批量生成  邮件通知  附件上传  工单更新  完成通知

3. 前端架构

3.1 组件层次结构

ui/src/views/business/subtask/
├── index.vue                           # 主列表页面
├── components/                        # 子组件目录
│   ├── task-processing.vue            # 任务处理对话框
│   ├── subtask-execution.vue          # 任务详情视图
│   ├── process-record-timeline.vue    # 处理记录时间线
│   ├── subtask-collaboration.vue      # 协作评论组件
│   └── assign-technician.vue          # 技术员分配组件
└── [其他组件...]

3.2 核心组件技术实现

3.2.1 任务处理组件 (task-processing.vue)

技术特点:

使用Composition API进行状态管理
响应式表单验证和动态字段控制
文件上传组件集成与状态同步
自动状态更新机制

关键代码实现:

// 处理结果与状态映射
const mapProcessResultToStatus = (processResult) => {
  const mapping = {
    'processing': 'processing',
    'completed': 'completed',
    'problem': 'processing',
    'need_help': 'processing',
    'paused': 'paused',
    'cancelled': 'cancelled'
  };
  return mapping[processResult] || 'processing';
};

// 使用带状态更新的处理记录API
const res = await addProcessRecordWithStatusUpdate(submitData);

3.2.2 处理记录时间线组件 (process-record-timeline.vue)

技术特点:

时间线数据的动态加载和分页
附件的缩略图预览和批量管理
图片懒加载和性能优化
响应式布局适配

关键功能:

// 附件列表处理
const getImageList = (attachments) => {
  if (!attachments) return [];
  return attachments.split(',').filter(url => url.trim());
};

// 快速预览功能
const handleQuickPreview = (image) => {
  // 实现图片预览逻辑
};

3.2.3 协作评论组件 (subtask-collaboration.vue)

技术特点:

评论与回复的层级数据结构
实时字数统计和输入验证
图片上传预览和压缩
权限控制和编辑管理

3.3 状态管理模式

采用Vue 3的响应式引用进行状态管理：

// 响应式状态定义
const subtask = ref({});
const loading = ref(false);
const submitting = ref(false);

// 表单状态管理
const processForm = reactive({
  subtaskId: props.subtaskId,
  processResult: '',
  detailDescription: '',
  attachments: [],
  attachmentsKey: '',
  remark: ''
});

3.4 API接口设计

统一的RESTful API接口调用：

// 任务相关API
import {
  getWorkOrderSubtask,        // 获取任务详情
  startSubtask,              // 开始任务
  pauseSubtask,             // 暂停任务
  completeSubtask,          // 完成任务
  updateSubtaskStatus       // 更新任务状态
} from '@/api/business/workOrderSubtask.js';

// 处理记录API
import {
  addProcessRecordWithStatusUpdate,  // 添加处理记录并更新状态
  getProcessTimeline                 // 获取处理时间线
} from '@/api/business/subtaskProcessRecord.js';

4. 后端架构

4.1 分层架构设计

com.husky.business/
├── controller/                    # 控制器层
│   └── BzWorkOrderSubtaskController.java
├── service/                       # 业务逻辑层
│   ├── IBzWorkOrderSubtaskService.java    # 服务接口
│   └── impl/                              # 服务实现
│       └── BzWorkOrderSubtaskServiceImpl.java
├── domain/                        # 数据模型层
│   ├── BzWorkOrderSubtask.java           # 任务实体
│   └── BzSubtaskProcessRecord.java       # 处理记录实体
├── mapper/                        # 数据访问层
│   └── BzWorkOrderSubtaskMapper.java
└── dto/vo/                       # 数据传输对象

4.2 核心业务逻辑

4.2.1 任务生命周期管理

/**
 * 任务状态流转业务逻辑
 */
@Transactional
public int startSubtask(Long subtaskId) {
    // 1. 验证任务状态
    if (!"pending".equals(subtask.getStatus())) {
        log.error("任务状态不正确，无法开始执行");
        return 0;
    }

    // 2. 更新任务状态和时间戳
    subtask.setStatus("in_progress");
    subtask.setStartedTime(DateUtils.getNowDate());
    subtask.setUpdateTime(DateUtils.getNowDate());

    // 3. 保存更改
    return bzWorkOrderSubtaskMapper.updateBzWorkOrderSubtask(subtask);
}

4.2.2 进度计算算法

/**
 * 工单整体进度计算
 */
public Integer calculateWorkOrderProgress(Long orderId) {
    // 获取所有子任务
    List<BzWorkOrderSubtask> subtasks =
        bzWorkOrderSubtaskMapper.selectBzWorkOrderSubtaskByOrderId(orderId);

    // 计算平均完成进度
    int totalProgress = 0;
    for (BzWorkOrderSubtask subtask : subtasks) {
        totalProgress += subtask.getProgressPercentage() != null ?
            subtask.getProgressPercentage() : 0;
    }

    return totalProgress / subtasks.size();
}

4.3 数据库设计

4.3.1 任务主表结构 (bz_work_order_subtask)

CREATE TABLE `bz_work_order_subtask` (
  `subtask_id` bigint NOT NULL AUTO_INCREMENT,
  `order_id` bigint DEFAULT NULL COMMENT '关联工单ID',
  `subtask_code` varchar(100) DEFAULT NULL COMMENT '任务编码',
  `subtask_title` varchar(500) DEFAULT NULL COMMENT '任务标题',
  `subtask_description` text COMMENT '任务描述',
  `subtask_type` varchar(50) DEFAULT NULL COMMENT '任务类型',
  `equipment_id` bigint DEFAULT NULL COMMENT '关联设备ID',
  `assigned_technician_id` bigint DEFAULT NULL COMMENT '分配技术员ID',
  `status` varchar(50) DEFAULT NULL COMMENT '任务状态',
  `priority` varchar(20) DEFAULT NULL COMMENT '优先级',
  `progress_percentage` int DEFAULT '0' COMMENT '完成进度(0-100)',
  `estimated_duration` int DEFAULT NULL COMMENT '预计耗时(分钟)',
  `actual_duration` int DEFAULT NULL COMMENT '实际耗时(分钟)',
  `planned_start_time` datetime DEFAULT NULL COMMENT '计划开始时间',
  `started_time` datetime DEFAULT NULL COMMENT '实际开始时间',
  `completed_time` datetime DEFAULT NULL COMMENT '完成时间',
  `result` text COMMENT '处理结果',
  `solution` text COMMENT '解决方案',
  `attachment_images` text COMMENT '图片附件',
  `attachment_files` text COMMENT '文件附件',
  `notes` text COMMENT '备注',
  `del_flag` char(1) DEFAULT '0' COMMENT '删除标志',
  `create_by` varchar(64) DEFAULT NULL COMMENT '创建者',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `update_by` varchar(64) DEFAULT NULL COMMENT '更新者',
  `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  PRIMARY KEY (`subtask_id`),
  KEY `idx_order_id` (`order_id`),
  KEY `idx_status` (`status`),
  KEY `idx_technician_id` (`assigned_technician_id`)
) ENGINE=InnoDB COMMENT='工单子任务表';

4.3.2 处理记录表结构 (bz_subtask_process_record)

CREATE TABLE `bz_subtask_process_record` (
  `record_id` bigint NOT NULL AUTO_INCREMENT,
  `subtask_id` bigint DEFAULT NULL COMMENT '子任务ID',
  `process_result` varchar(50) DEFAULT NULL COMMENT '处理结果',
  `detail_description` text COMMENT '详细描述',
  `attachments` text COMMENT '附件URL列表',
  `process_type` varchar(50) DEFAULT NULL COMMENT '处理类型',
  `operator_id` bigint DEFAULT NULL COMMENT '操作者ID',
  `operator_name` varchar(100) DEFAULT NULL COMMENT '操作者姓名',
  `operator_role` varchar(50) DEFAULT NULL COMMENT '操作者角色',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `remark` text COMMENT '备注',
  PRIMARY KEY (`record_id`),
  KEY `idx_subtask_id` (`subtask_id`),
  KEY `idx_operator_id` (`operator_id`)
) ENGINE=InnoDB COMMENT='子任务处理记录表';

4.4 MyBatis映射文件设计

4.4.1 动态SQL查询

<!-- 多条件动态查询 -->
<select id="selectBzWorkOrderSubtaskList" parameterType="BzWorkOrderSubtask"
        resultMap="BzWorkOrderSubtaskWithOrderResult">
    <include refid="selectBzWorkOrderSubtaskWithOrderVo"/>
    <where>
        <if test="orderId != null"> and st.order_id = #{orderId}</if>
        <if test="subtaskTitle != null and subtaskTitle != ''">
            and st.subtask_title like concat('%', #{subtaskTitle}, '%')
        </if>
        <if test="status != null and status != ''">
            and st.status = #{status}
        </if>
        <if test="assignedTechnicianId != null">
            and st.assigned_technician_id = #{assignedTechnicianId}
        </if>
    </where>
    order by st.create_time desc
</select>

4.4.2 批量操作优化

<!-- 批量插入子任务 -->
<insert id="batchInsertBzWorkOrderSubtask" parameterType="java.util.List">
    insert into bz_work_order_subtask
    (order_id, subtask_code, subtask_title, subtask_type, ...)
    values
    <foreach collection="list" item="item" separator=",">
        (#{item.orderId}, #{item.subtaskCode}, #{item.subtaskTitle}, ...)
    </foreach>
</insert>

5. API接口设计

5.1 RESTful API规范

5.1.1 任务管理接口

@RestController
@RequestMapping("/afterservice/workOrderSubtask")
public class BzWorkOrderSubtaskController extends BaseController {

    // 基础CRUD操作
    @GetMapping("/list")                           // 查询任务列表
    @PostMapping                                  // 新增任务
    @PutMapping                                   // 修改任务
    @DeleteMapping("/{subtaskIds}")                // 删除任务

    // 生命周期管理
    @PutMapping("/start/{subtaskId}")             // 开始任务
    @PutMapping("/pause/{subtaskId}")             // 暂停任务
    @PutMapping("/complete/{subtaskId}")          // 完成任务
    @PutMapping("/cancel/{subtaskId}")            // 取消任务

    // 进度和分配管理
    @PutMapping("/progress/{subtaskId}")          // 更新进度
    @PutMapping("/assign/{subtaskId}")            // 分配技术员
    @PutMapping("/reassign/{subtaskId}")          // 重新分配

    // 统计查询
    @GetMapping("/statistics/{orderId}")          // 工单统计
    @GetMapping("/workloadByTechnician/{id}")     // 技术员工作量

    // 技术员端接口
    @GetMapping("/technician/list")               // 技术员任务列表
    @PutMapping("/{subtaskId}/accept")            // 接受任务
    @PutMapping("/{subtaskId}/complete")          // 完成任务
}

5.2 权限控制设计

// 基于注解的权限控制
@PreAuthorize("@ss.hasPermi('business:subtask:list')")
@GetMapping("/list")
public TableDataInfo list(BzWorkOrderSubtask bzWorkOrderSubtask)

@PreAuthorize("@ss.hasPermi('business:subtask:edit')")
@PutMapping("/start/{subtaskId}")
public AjaxResult startSubtask(@PathVariable Long subtaskId)

5.3 统一响应格式

// 标准响应格式
public AjaxResult toAjax(int rows) {
    return rows > 0 ? AjaxResult.success() : AjaxResult.error();
}

// 带数据的成功响应
public AjaxResult success(Object data) {
    return AjaxResult.success("操作成功", data);
}

// 错误响应
public AjaxResult error(String msg) {
    return AjaxResult.error(msg);
}

6. 关键技术实现

6.1 状态联动机制

6.1.1 状态流转引擎

/**
 * 状态联动服务接口
 */
public interface IStatusLinkageService {
    /**
     * 带联动效果的状态变更
     */
    int changeStatusWithLinkage(String entityType, Long entityId,
                              String newStatus, Long userId,
                              String userName, String remark);

    /**
     * 获取允许的下一个状态列表
     */
    List<String> getAllowedNextStatuses(String entityType, String currentStatus);
}

6.1.2 状态变更历史

/**
 * 状态变更日志记录
 */
@Transactional
public int recordStatusChange(Long subtaskId, String oldStatus,
                             String newStatus, String remark) {
    // 记录状态变更历史
    BzStatusChangeLog log = new BzStatusChangeLog();
    log.setEntityType("subtask");
    log.setEntityId(subtaskId);
    log.setOldStatus(oldStatus);
    log.setNewStatus(newStatus);
    log.setRemark(remark);

    return bzStatusChangeLogService.insertBzStatusChangeLog(log);
}

6.2 通知服务机制

6.2.1 邮件通知服务

/**
 * 邮件通知服务
 */
@Service
public class BzEmailNotificationServiceImpl implements IBzEmailNotificationService {

    /**
     * 发送任务分配通知
     */
    public void sendSubtaskAssignmentNotification(BzWorkOrderSubtask subtask,
                                               String technicianName,
                                               String email) {
        // 构建邮件内容
        String subject = "任务分配通知 - " + subtask.getSubtaskCode();
        String content = buildAssignmentEmailContent(subtask, technicianName);

        // 发送邮件
        emailService.send(email, subject, content);

        // 记录邮件日志
        recordEmailLog(email, technicianName, subject, "SUBTASK_ASSIGNMENT");
    }
}

6.2.2 异步任务处理

/**
 * 异步任务管理器
 */
public class AsyncManager {

    /**
     * 执行异步任务
     */
    public void execute(TimerTask task) {
        // 使用线程池执行异步任务
        scheduledExecutor.schedule(task, 0, TimeUnit.MILLISECONDS);
    }
}

/**
 * 工单完成异步任务工厂
 */
public class AsyncFactory {

    /**
     * 记录工单完成信息
     */
    public static TimerTask recordWorkOrderCompletion(BzWorkOrder workOrder) {
        return new TimerTask() {
            @Override
            public void run() {
                // 异步记录完成信息、发送通知等
                workOrderCompletionService.recordCompletion(workOrder);
            }
        };
    }
}

6.3 文件上传与管理

6.3.1 统一附件上传组件

<!-- UnifiedAttachmentUpload 组件 -->
<template>
  <el-upload
    :action="uploadUrl"
    :headers="headers"
    :before-upload="beforeUpload"
    :on-success="handleSuccess"
    :on-error="handleError"
    :limit="limit"
    :file-size="maxSize"
    multiple
  >
    <el-button type="primary">选择文件</el-button>
  </el-upload>
</template>

<script setup>
// 文件上传前验证
const beforeUpload = (file) => {
  // 文件类型验证
  const isValidType = checkFileType(file);
  // 文件大小验证
  const isValidSize = checkFileSize(file);
  return isValidType && isValidSize;
};

// 上传成功处理
const handleSuccess = (response, file) => {
  // 更新文件列表
  uploadedFiles.value.push(response.data);
  emit('update:modelValue', uploadedFiles.value);
};
</script>

6.4 数据库性能优化

6.4.1 索引优化策略

-- 任务表关键索引
CREATE INDEX idx_order_status ON bz_work_order_subtask(order_id, status);
CREATE INDEX idx_technician_status ON bz_work_order_subtask(assigned_technician_id, status);
CREATE INDEX idx_create_time ON bz_work_order_subtask(create_time);

-- 处理记录表索引
CREATE INDEX idx_subtask_time ON bz_subtask_process_record(subtask_id, create_time);
CREATE INDEX idx_operator_time ON bz_subtask_process_record(operator_id, create_time);

6.4.2 查询性能优化

<!-- 分页查询优化 -->
<select id="selectBzWorkOrderSubtaskList" resultMap="BzWorkOrderSubtaskResult">
    SELECT * FROM bz_work_order_subtask
    WHERE del_flag = '0'
    ORDER BY create_time DESC
    LIMIT #{pageSize} OFFSET #{pageNum}
</select>

<!-- 统计查询优化 -->
<select id="calculateWorkOrderProgress" resultType="Integer">
    SELECT
        CASE WHEN COUNT(*) = 0 THEN 0
             ELSE ROUND(SUM(progress_percentage) / COUNT(*))
        END as progress
    FROM bz_work_order_subtask
    WHERE order_id = #{orderId} AND del_flag = '0'
</select>

7. 安全性设计

7.1 权限控制体系

7.1.1 基于角色的访问控制(RBAC)

@PreAuthorize("@ss.hasPermi('business:subtask:add')")
@PostMapping
public AjaxResult add(@RequestBody BzWorkOrderSubtask bzWorkOrderSubtask)

@PreAuthorize("@ss.hasPermi('business:subtask:edit')")
@PutMapping("/start/{subtaskId}")
public AjaxResult startSubtask(@PathVariable Long subtaskId)

7.1.2 数据权限控制

// 技术员只能查看分配给自己的任务
@GetMapping("/technician/list")
public TableDataInfo getTechnicianTasks(BzWorkOrderSubtask bzWorkOrderSubtask) {
    Long currentUserId = getCurrentUserId();
    bzWorkOrderSubtask.setAssignedTechnicianId(currentUserId);

    List<BzWorkOrderSubtask> list =
        bzWorkOrderSubtaskService.selectBzWorkOrderSubtaskList(bzWorkOrderSubtask);
    return getDataTable(list);
}

7.2 操作日志审计

7.2.1 操作日志记录

@Log(title = "开始子任务", businessType = BusinessType.UPDATE)
@PutMapping("/start/{subtaskId}")
public AjaxResult startSubtask(@PathVariable Long subtaskId) {
    return toAjax(bzWorkOrderSubtaskService.startSubtask(subtaskId));
}

7.2.2 数据变更历史

/**
 * 记录状态变更历史
 */
public int recordStatusChange(Long subtaskId, String oldStatus,
                           String newStatus, String remark) {
    BzStatusChangeLog log = new BzStatusChangeLog();
    log.setEntityType("subtask");
    log.setEntityId(subtaskId);
    log.setOldStatus(oldStatus);
    log.setNewStatus(newStatus);
    log.setChangeBy(SecurityUtils.getUsername());
    log.setChangeTime(new Date());
    log.setRemark(remark);

    return statusChangeLogMapper.insertBzStatusChangeLog(log);
}

8. 性能优化策略

8.1 缓存策略

8.1.1 Redis缓存应用

@Service
public class BzWorkOrderSubtaskServiceImpl implements IBzWorkOrderSubtaskService {

    @Cacheable(value = "subtask", key = "#subtaskId")
    public BzWorkOrderSubtask selectBzWorkOrderSubtaskBySubtaskId(Long subtaskId) {
        return bzWorkOrderSubtaskMapper.selectBzWorkOrderSubtaskBySubtaskId(subtaskId);
    }

    @CacheEvict(value = "subtask", key = "#subtask.subtaskId")
    public int updateBzWorkOrderSubtask(BzWorkOrderSubtask subtask) {
        return bzWorkOrderSubtaskMapper.updateBzWorkOrderSubtask(subtask);
    }
}

8.2 数据库优化

8.2.1 批量操作优化

@Transactional
public int batchInsertBzWorkOrderSubtask(List<BzWorkOrderSubtask> subtaskList) {
    if (subtaskList == null || subtaskList.isEmpty()) {
        return 0;
    }

    // 批量插入，减少数据库IO
    return bzWorkOrderSubtaskMapper.batchInsertBzWorkOrderSubtask(subtaskList);
}

8.2.2 查询优化

<!-- 避免N+1查询问题 -->
<resultMap type="BzWorkOrderSubtask" id="BzWorkOrderSubtaskWithOrderResult">
    <!-- 基本字段映射 -->
    <association property="workOrder" javaType="BzWorkOrder">
        <id property="orderId" column="order_id"/>
        <result property="orderTitle" column="order_title"/>
        <result property="orderCode" column="order_code"/>
    </association>
</resultMap>

8.3 前端性能优化

8.3.1 组件懒加载

// 路由懒加载
const routes = [
  {
    path: '/business/subtask',
    component: () => import('@/views/business/subtask/index.vue'),
    meta: { requiresAuth: true }
  }
];

8.3.2 图片懒加载和压缩

<template>
  <el-image
    :src="image.url"
    :lazy="true"
    fit="cover"
    :preview-src-list="previewList"
  >
    <template #error>
      <div class="image-error">加载失败</div>
    </template>
  </el-image>
</template>

9. 部署和监控

9.1 部署配置

9.1.1 数据库配置

# application.yml
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3307/husky_afterservice_db?useUnicode=true&characterEncoding=utf8
    username: root
    password: password
    druid:
      initial-size: 10
      max-active: 800
      min-idle: 10
      max-wait: 60000

9.1.2 缓存配置

spring:
  redis:
    host: localhost
    port: 6379
    database: 0
    timeout: 10000ms
    lettuce:
      pool:
        max-active: 200
        max-wait: -1ms
        max-idle: 10
        min-idle: 0

9.2 监控指标

9.2.1 性能监控

// Druid数据源监控
@RestController
@RequestMapping("/druid")
public class DruidController {

    @GetMapping("/stat")
    public AjaxResult getDataSourceStat() {
        // 返回数据源统计信息
        return AjaxResult.success(DruidStatManager.getInstance().getDataSourceStatList());
    }
}

9.2.2 业务监控

@Service
public class SubtaskMonitoringService {

    /**
     * 监控任务处理时效
     */
    public void monitorTaskProcessingTime() {
        // 监控任务从分配到完成的平均处理时间
        // 监控各环节的处理效率
        // 发现异常任务并预警
    }

    /**
     * 监控技术员工作量
     */
    public void monitorTechnicianWorkload() {
        // 监控技术员任务分配均衡性
        // 监控任务完成质量
        // 生成工作量报表
    }
}

10. 扩展性设计

10.1 插件化架构

10.1.1 任务分配策略插件

/**
 * 任务分配策略接口
 */
public interface TaskAssignmentStrategy {

    /**
     * 为任务分配技术员
     * @param subtask 任务信息
     * @param candidates 候选技术员列表
     * @return 推荐的技术员
     */
    BzTechnician assignTechnician(BzWorkOrderSubtask subtask,
                                 List<BzTechnician> candidates);
}

/**
 * 负载均衡分配策略
 */
@Service("loadBalanceStrategy")
public class LoadBalanceAssignmentStrategy implements TaskAssignmentStrategy {

    @Override
    public BzTechnician assignTechnician(BzWorkOrderSubtask subtask,
                                        List<BzTechnician> candidates) {
        // 基于当前任务数量进行负载均衡分配
        return candidates.stream()
            .min(Comparator.comparingInt(t -> getCurrentTaskCount(t.getTechnicianId())))
            .orElse(null);
    }
}

10.2 事件驱动架构

10.2.1 任务状态事件

/**
 * 任务状态变更事件
 */
public class TaskStatusChangeEvent {
    private Long subtaskId;
    private String oldStatus;
    private String newStatus;
    private Long operatorId;
    private Date changeTime;

    // 事件监听器
    @EventListener
    public void handleTaskStatusChange(TaskStatusChangeEvent event) {
        // 处理状态变更后的业务逻辑
        // 更新工单进度、发送通知等
    }
}

11. 最佳实践

11.1 代码规范

11.1.1 命名规范

// 实体类命名：Bz + 业务名称 + 实体类型
public class BzWorkOrderSubtask {
    private Long subtaskId;           // 主键ID
    private Long orderId;            // 关联工单ID
    private String subtaskTitle;      // 任务标题
    // ...
}

// Service接口命名：I + 业务名称 + Service
public interface IBzWorkOrderSubtaskService {
    public BzWorkOrderSubtask selectBzWorkOrderSubtaskBySubtaskId(Long subtaskId);
    // ...
}

11.1.2 注解规范

// 事务注解
@Transactional
public int updateSubtaskStatus(Long subtaskId, String status) {
    // 业务逻辑
}

// 权限注解
@PreAuthorize("@ss.hasPermi('business:subtask:edit')")
@PutMapping("/start/{subtaskId}")
public AjaxResult startSubtask(@PathVariable Long subtaskId)

// 日志注解
@Log(title = "开始子任务", businessType = BusinessType.UPDATE)

11.2 异常处理

11.2.1 统一异常处理

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(BusinessException.class)
    public AjaxResult handleBusinessException(BusinessException e) {
        log.error("业务异常：{}", e.getMessage());
        return AjaxResult.error(e.getMessage());
    }

    @ExceptionHandler(Exception.class)
    public AjaxResult handleException(Exception e) {
        log.error("系统异常", e);
        return AjaxResult.error("系统异常，请联系管理员");
    }
}

11.3 测试策略

11.3.1 单元测试

@SpringBootTest
public class BzWorkOrderSubtaskServiceTest {

    @Autowired
    private IBzWorkOrderSubtaskService subtaskService;

    @Test
    public void testStartSubtask() {
        // 准备测试数据
        BzWorkOrderSubtask subtask = createTestSubtask();

        // 执行测试
        int result = subtaskService.startSubtask(subtask.getSubtaskId());

        // 验证结果
        assertEquals(1, result);
        assertEquals("in_progress", subtask.getStatus());
    }
}

12. 总结

12.1 技术架构优势

分层清晰：严格的三层架构，职责分明，便于维护
技术先进：采用Vue 3、Spring Boot等现代化技术栈
性能优化：多层次的缓存策略和数据库优化
安全可靠：完善的权限控制和操作审计
扩展性强：插件化架构和事件驱动设计

12.2 业务价值

提高效率：自动化任务分配和进度跟踪
降低成本：优化技术员工作负载和资源利用
提升质量：标准化的处理流程和质量控制
增强协作：多端协作和实时信息同步
数据驱动：完整的业务数据统计和分析

12.3 未来发展方向

AI智能化：引入机器学习优化任务分配算法
移动化：完善移动端功能和离线支持
物联网集成：与设备监控系统的深度集成
大数据分析：构建预测性维护模型
微服务化：向微服务架构演进

文档版本: 1.0
创建日期: 2025年10月15日
适用系统版本: i-Husky运维服务系统 v3.9.0+
维护责任人: 技术架构团队

作者：聂盼盼创建时间：2025-10-15 23:44
最后编辑：聂盼盼更新时间：2025-10-28 19:53

任务管理的技术文档

任务管理模块技术文档

1. 概述

1.1 技术栈

1.2 核心特性

2. 系统架构

2.1 整体架构图

2.2 数据流程图

3. 前端架构

3.1 组件层次结构

3.2 核心组件技术实现

3.2.1 任务处理组件 (task-processing.vue)

3.2.2 处理记录时间线组件 (process-record-timeline.vue)

3.2.3 协作评论组件 (subtask-collaboration.vue)

3.3 状态管理模式

3.4 API接口设计

4. 后端架构

4.1 分层架构设计

4.2 核心业务逻辑

4.2.1 任务生命周期管理

4.2.2 进度计算算法

4.3 数据库设计

4.3.1 任务主表结构 (bz_work_order_subtask)

4.3.2 处理记录表结构 (bz_subtask_process_record)

4.4 MyBatis映射文件设计

4.4.1 动态SQL查询

4.4.2 批量操作优化

5. API接口设计

5.1 RESTful API规范

5.1.1 任务管理接口

5.2 权限控制设计

5.3 统一响应格式

6. 关键技术实现

6.1 状态联动机制

6.1.1 状态流转引擎

6.1.2 状态变更历史

6.2 通知服务机制

6.2.1 邮件通知服务

6.2.2 异步任务处理

6.3 文件上传与管理

6.3.1 统一附件上传组件

6.4 数据库性能优化

6.4.1 索引优化策略

6.4.2 查询性能优化

7. 安全性设计

7.1 权限控制体系

7.1.1 基于角色的访问控制(RBAC)

7.1.2 数据权限控制

7.2 操作日志审计

7.2.1 操作日志记录

7.2.2 数据变更历史

8. 性能优化策略

8.1 缓存策略

8.1.1 Redis缓存应用

8.2 数据库优化

8.2.1 批量操作优化

8.2.2 查询优化

8.3 前端性能优化

8.3.1 组件懒加载

8.3.2 图片懒加载和压缩

9. 部署和监控

9.1 部署配置

9.1.1 数据库配置

9.1.2 缓存配置

9.2 监控指标

9.2.1 性能监控

9.2.2 业务监控

10. 扩展性设计

10.1 插件化架构

10.1.1 任务分配策略插件

10.2 事件驱动架构

10.2.1 任务状态事件

11. 最佳实践

11.1 代码规范

11.1.1 命名规范

11.1.2 注解规范

11.2 异常处理

11.2.1 统一异常处理

11.3 测试策略

11.3.1 单元测试