feat(wm-bpm+frontend): #34 流程统计评估完整实现

后端 (wm-bpm):
- ProcessStatisticsService: 统计聚合（平均处理时长/各节点耗时分布/超时流程列表/流程完成率/瓶颈节点识别/按时间范围统计/按流程定义分组）
- ProcessStatisticsController: /api/bpm/statistics/* 8个接口
- ProcessStatisticsMapper: 聚合查询/分组统计/超时筛选SQL
- DTOs: ProcessStatsOverview, NodeDurationVO, TimeoutProcessVO

前端 (frontend):
- ProcessStatsView.vue: ECharts统计仪表盘
  - 概览卡片（总流程数/运行中/已完成/超时数/平均时长/完成率）
  - 平均处理时长趋势折线图（含超时线标记）
  - 节点耗时分布柱状图（瓶颈节点标红）
  - 流程完成率饼图
  - 超时流程列表（高亮+跳转详情）
  - 各流程类型统计表格
- bpmStatsApi.ts: TypeScript API封装（8个接口+完整类型定义）
- 路由注册: /bpm/statistics

测试:
- ProcessStatisticsServiceTest: 11个测试用例覆盖核心逻辑
- 超时判定：单节点审批超过48小时视为超时

frontend/src/api/bpmStatsApi.ts

@@ -0,0 +1,123 @@
+import request from './request'
+
+const BASE = '/api/bpm/statistics'
+
+/** 统计概览 */
+export interface ProcessStatsOverview {
+  totalInstances: number
+  runningCount: number
+  completedCount: number
+  rejectedCount: number
+  terminatedCount: number
+  timeoutCount: number
+  suspendedCount: number
+  avgDurationHours: number
+  completionRate: number
+}
+
+/** 节点耗时分布 */
+export interface NodeDurationVO {
+  nodeId: string
+  nodeName: string
+  avgDurationHours: number
+  maxDurationHours: number
+  minDurationHours: number
+  approvalCount: number
+  isBottleneck: boolean
+}
+
+/** 超时流程 */
+export interface TimeoutProcessVO {
+  id: number
+  instanceId: string
+  processName: string
+  title: string
+  initiatorName: string
+  currentNodeName: string
+  currentAssigneeName: string
+  startedAt: string
+  durationHours: number
+  status: string
+  priority: number
+}
+
+/** 趋势数据点 */
+export interface TrendDataPoint {
+  date: string
+  completedCount: number
+  avgHours: number
+  maxHours: number
+  minHours: number
+}
+
+/** 完成率 */
+export interface CompletionRateItem {
+  processKey: string
+  processName: string
+  total: number
+  completed: number
+  completionRate: number
+}
+
+/** 按流程定义统计 */
+export interface DefinitionStatItem {
+  definitionId: number
+  processName: string
+  processKey: string
+  totalInstances: number
+  runningCount: number
+  completedCount: number
+  rejectedCount: number
+  terminatedCount: number
+  avgDurationHours: number
+  maxDurationHours: number
+  minDurationHours: number
+}
+
+// ========== API 调用 ==========
+
+/** 获取统计概览 */
+export function getOverview() {
+  return request.get<any, { data: ProcessStatsOverview }>(`${BASE}/overview`)
+}
+
+/** 获取平均处理时长趋势 */
+export function getAvgDurationTrend(days = 30) {
+  return request.get<any, { data: TrendDataPoint[] }>(`${BASE}/avg-duration-trend`, {
+    params: { days }
+  })
+}
+
+/** 获取节点耗时分布 */
+export function getNodeDurationDistribution() {
+  return request.get<any, { data: NodeDurationVO[] }>(`${BASE}/node-duration`)
+}
+
+/** 获取超时流程列表 */
+export function getTimeoutProcessList() {
+  return request.get<any, { data: TimeoutProcessVO[] }>(`${BASE}/timeout`)
+}
+
+/** 获取流程完成率 */
+export function getCompletionRate() {
+  return request.get<any, { data: CompletionRateItem[] }>(`${BASE}/completion-rate`)
+}
+
+/** 按流程定义分组统计 */
+export function getStatsByDefinition() {
+  return request.get<any, { data: DefinitionStatItem[] }>(`${BASE}/by-definition`)
+}
+
+/** 按时间范围统计 */
+export function getStatsByTimeRange(period: 'day' | 'week' | 'month' = 'day', days = 30) {
+  return request.get<any, { data: any[] }>(`${BASE}/by-time-range`, {
+    params: { period, days }
+  })
+}
+
+/** 瓶颈节点识别 */
+export function getBottleneckNodes(topN = 5) {
+  return request.get<any, { data: NodeDurationVO[] }>(`${BASE}/bottleneck`, {
+    params: { topN }
+  })
+}

frontend/src/router/index.ts

@@ -16,6 +16,7 @@ const routes = [
       { path: 'cs/knowledge', name: 'csKnowledge', component: () => import('@/views/cs/KnowledgeBaseView.vue') },
       { path: 'cs/announcement', name: 'csAnnouncement', component: () => import('@/views/cs/AnnouncementView.vue') },
       { path: 'cs/kpi', name: 'csKpi', component: () => import('@/views/cs/KpiDashboardView.vue') },
+      { path: 'bpm/statistics', name: 'bpmStats', component: () => import('@/views/bpm/ProcessStatsView.vue') },
     ]
   },
   { path: '/:pathMatch(.*)*', redirect: '/dashboard' }

frontend/src/views/bpm/ProcessStatsView.vue

@@ -0,0 +1,548 @@
+<template>
+  <div class="process-stats">
+    <!-- 概览卡片 -->
+    <el-row :gutter="16">
+      <el-col :span="4" v-for="card in statCards" :key="card.key">
+        <el-card shadow="hover" class="stat-card" :class="'stat-' + card.color">
+          <div class="stat-icon">{{ card.icon }}</div>
+          <div class="stat-value">{{ card.value }}</div>
+          <div class="stat-label">{{ card.label }}</div>
+          <div class="stat-sub" v-if="card.sub">{{ card.sub }}</div>
+        </el-card>
+      </el-col>
+    </el-row>
+
+    <!-- 图表行1: 平均处理时长趋势 + 流程完成率饼图 -->
+    <el-row :gutter="16" style="margin-top: 16px">
+      <el-col :span="14">
+        <el-card shadow="never">
+          <template #header>
+            <div class="card-header">
+              <span>📈 平均处理时长趋势</span>
+              <el-radio-group v-model="trendDays" size="small" @change="loadTrendData">
+                <el-radio-button :value="7">7天</el-radio-button>
+                <el-radio-button :value="14">14天</el-radio-button>
+                <el-radio-button :value="30">30天</el-radio-button>
+                <el-radio-button :value="90">90天</el-radio-button>
+              </el-radio-group>
+            </div>
+          </template>
+          <div ref="trendChartRef" style="height: 320px"></div>
+        </el-card>
+      </el-col>
+      <el-col :span="10">
+        <el-card shadow="never">
+          <template #header>
+            <span>🎯 流程完成率</span>
+          </template>
+          <div ref="completionChartRef" style="height: 320px"></div>
+        </el-card>
+      </el-col>
+    </el-row>
+
+    <!-- 图表行2: 节点耗时分布柱状图 -->
+    <el-row :gutter="16" style="margin-top: 16px">
+      <el-col :span="24">
+        <el-card shadow="never">
+          <template #header>
+            <div class="card-header">
+              <span>📊 节点耗时分布</span>
+              <el-tag type="danger" size="small">🔴 瓶颈节点（耗时显著高于平均）</el-tag>
+            </div>
+          </template>
+          <div ref="nodeChartRef" style="height: 360px"></div>
+        </el-card>
+      </el-col>
+    </el-row>
+
+    <!-- 超时流程列表 -->
+    <el-row :gutter="16" style="margin-top: 16px">
+      <el-col :span="24">
+        <el-card shadow="never">
+          <template #header>
+            <div class="card-header">
+              <span>⏰ 超时流程列表（>48小时）</span>
+              <el-tag type="danger" size="small" v-if="timeoutList.length">
+                {{ timeoutList.length }} 个超时
+              </el-tag>
+              <el-tag type="success" size="small" v-else>无超时</el-tag>
+            </div>
+          </template>
+          <el-table
+            :data="timeoutList"
+            :row-class-name="timeoutRowClass"
+            style="width: 100%"
+            empty-text="暂无超时流程 ✅"
+            @row-click="goToDetail"
+          >
+            <el-table-column prop="processName" label="流程类型" width="140" />
+            <el-table-column prop="title" label="流程标题" min-width="180" show-overflow-tooltip />
+            <el-table-column prop="initiatorName" label="发起人" width="100" />
+            <el-table-column prop="currentNodeName" label="当前节点" width="140" />
+            <el-table-column prop="currentAssigneeName" label="当前处理人" width="120" />
+            <el-table-column prop="durationHours" label="已耗时" width="120" align="center">
+              <template #default="{ row }">
+                <el-tag :type="row.durationHours > 96 ? 'danger' : 'warning'" size="small">
+                  {{ row.durationHours.toFixed(1) }}h
+                </el-tag>
+              </template>
+            </el-table-column>
+            <el-table-column prop="priority" label="优先级" width="90" align="center">
+              <template #default="{ row }">
+                <el-tag :type="priorityType(row.priority)" size="small">
+                  {{ priorityText(row.priority) }}
+                </el-tag>
+              </template>
+            </el-table-column>
+            <el-table-column prop="startedAt" label="开始时间" width="170">
+              <template #default="{ row }">
+                {{ formatTime(row.startedAt) }}
+              </template>
+            </el-table-column>
+            <el-table-column label="操作" width="80" align="center">
+              <template #default="{ row }">
+                <el-button type="primary" link size="small" @click.stop="goToDetail(row)">
+                  详情
+                </el-button>
+              </template>
+            </el-table-column>
+          </el-table>
+        </el-card>
+      </el-col>
+    </el-row>
+
+    <!-- 按流程定义分组统计 -->
+    <el-row :gutter="16" style="margin-top: 16px">
+      <el-col :span="24">
+        <el-card shadow="never">
+          <template #header>
+            <span>📋 各流程类型统计</span>
+          </template>
+          <el-table :data="definitionStats" style="width: 100%" empty-text="暂无数据">
+            <el-table-column prop="processName" label="流程类型" width="160" />
+            <el-table-column prop="totalInstances" label="总数" width="80" align="center" />
+            <el-table-column prop="runningCount" label="运行中" width="80" align="center">
+              <template #default="{ row }">
+                <el-tag type="warning" size="small">{{ row.runningCount }}</el-tag>
+              </template>
+            </el-table-column>
+            <el-table-column prop="completedCount" label="已完成" width="80" align="center">
+              <template #default="{ row }">
+                <el-tag type="success" size="small">{{ row.completedCount }}</el-tag>
+              </template>
+            </el-table-column>
+            <el-table-column prop="rejectedCount" label="已驳回" width="80" align="center">
+              <template #default="{ row }">
+                <el-tag type="danger" size="small">{{ row.rejectedCount }}</el-tag>
+              </template>
+            </el-table-column>
+            <el-table-column prop="avgDurationHours" label="平均耗时" width="120" align="center">
+              <template #default="{ row }">
+                {{ row.avgDurationHours.toFixed(1) }}h
+              </template>
+            </el-table-column>
+            <el-table-column prop="maxDurationHours" label="最长耗时" width="120" align="center">
+              <template #default="{ row }">
+                <el-tag :type="row.maxDurationHours > 48 ? 'danger' : 'info'" size="small">
+                  {{ row.maxDurationHours.toFixed(1) }}h
+                </el-tag>
+              </template>
+            </el-table-column>
+          </el-table>
+        </el-card>
+      </el-col>
+    </el-row>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, computed, onMounted, onUnmounted, nextTick } from 'vue'
+import { useRouter } from 'vue-router'
+import * as echarts from 'echarts'
+import {
+  getOverview,
+  getAvgDurationTrend,
+  getNodeDurationDistribution,
+  getTimeoutProcessList,
+  getCompletionRate,
+  getStatsByDefinition,
+  type ProcessStatsOverview,
+  type NodeDurationVO,
+  type TimeoutProcessVO,
+  type TrendDataPoint,
+  type CompletionRateItem,
+  type DefinitionStatItem,
+} from '@/api/bpmStatsApi'
+
+const router = useRouter()
+
+// ========== 响应式数据 ==========
+const loading = ref(false)
+const overview = ref<ProcessStatsOverview>({
+  totalInstances: 0, runningCount: 0, completedCount: 0,
+  rejectedCount: 0, terminatedCount: 0, timeoutCount: 0,
+  suspendedCount: 0, avgDurationHours: 0, completionRate: 0,
+})
+const trendData = ref<TrendDataPoint[]>([])
+const nodeDistribution = ref<NodeDurationVO[]>([])
+const timeoutList = ref<TimeoutProcessVO[]>([])
+const completionData = ref<CompletionRateItem[]>([])
+const definitionStats = ref<DefinitionStatItem[]>([])
+const trendDays = ref(30)
+
+// Chart refs
+const trendChartRef = ref<HTMLElement>()
+const completionChartRef = ref<HTMLElement>()
+const nodeChartRef = ref<HTMLElement>()
+
+let trendChart: echarts.ECharts | null = null
+let completionChart: echarts.ECharts | null = null
+let nodeChart: echarts.ECharts | null = null
+
+// ========== 统计卡片 ==========
+const statCards = computed(() => [
+  {
+    key: 'total', icon: '📋', label: '总流程数',
+    value: overview.value.totalInstances, color: 'blue',
+  },
+  {
+    key: 'running', icon: '🔄', label: '运行中',
+    value: overview.value.runningCount, color: 'orange',
+  },
+  {
+    key: 'completed', icon: '✅', label: '已完成',
+    value: overview.value.completedCount, color: 'green',
+  },
+  {
+    key: 'timeout', icon: '⏰', label: '超时数',
+    value: overview.value.timeoutCount, color: 'red',
+    sub: overview.value.timeoutCount > 0 ? '需关注' : '正常',
+  },
+  {
+    key: 'avg', icon: '⏱️', label: '平均时长',
+    value: overview.value.avgDurationHours.toFixed(1) + 'h', color: 'purple',
+  },
+  {
+    key: 'rate', icon: '🎯', label: '完成率',
+    value: overview.value.completionRate.toFixed(1) + '%', color: 'green',
+  },
+])
+
+// ========== 生命周期 ==========
+onMounted(() => {
+  loadAllData()
+  window.addEventListener('resize', handleResize)
+})
+
+onUnmounted(() => {
+  window.removeEventListener('resize', handleResize)
+  trendChart?.dispose()
+  completionChart?.dispose()
+  nodeChart?.dispose()
+})
+
+// ========== 数据加载 ==========
+async function loadAllData() {
+  loading.value = true
+  try {
+    const [overviewRes, trendRes, nodeRes, timeoutRes, completionRes, defRes] = await Promise.all([
+      getOverview(),
+      getAvgDurationTrend(trendDays.value),
+      getNodeDurationDistribution(),
+      getTimeoutProcessList(),
+      getCompletionRate(),
+      getStatsByDefinition(),
+    ])
+    overview.value = overviewRes.data
+    trendData.value = trendRes.data || []
+    nodeDistribution.value = nodeRes.data || []
+    timeoutList.value = timeoutRes.data || []
+    completionData.value = completionRes.data || []
+    definitionStats.value = defRes.data || []
+
+    await nextTick()
+    renderTrendChart()
+    renderCompletionChart()
+    renderNodeChart()
+  } catch (e) {
+    console.error('加载统计数据失败', e)
+  } finally {
+    loading.value = false
+  }
+}
+
+async function loadTrendData() {
+  try {
+    const res = await getAvgDurationTrend(trendDays.value)
+    trendData.value = res.data || []
+    await nextTick()
+    renderTrendChart()
+  } catch (e) {
+    console.error('加载趋势数据失败', e)
+  }
+}
+
+// ========== 图表渲染 ==========
+function renderTrendChart() {
+  if (!trendChartRef.value) return
+  trendChart = trendChart || echarts.init(trendChartRef.value)
+  const data = trendData.value
+  trendChart.setOption({
+    tooltip: {
+      trigger: 'axis',
+      formatter: (params: any) => {
+        const p = params[0]
+        return `${p.name}<br/>平均: ${p.value}h<br/>完成数: ${data[p.dataIndex]?.completedCount || 0}`
+      },
+    },
+    grid: { left: '3%', right: '4%', bottom: '3%', containLabel: true },
+    xAxis: {
+      type: 'category',
+      data: data.map(d => d.date?.slice(5) || ''),
+      axisLabel: { rotate: 30 },
+    },
+    yAxis: { type: 'value', name: '小时(h)', min: 0 },
+    series: [
+      {
+        name: '平均耗时',
+        type: 'line',
+        smooth: true,
+        data: data.map(d => d.avgHours),
+        areaStyle: { opacity: 0.1 },
+        itemStyle: { color: '#409eff' },
+        markLine: {
+          silent: true,
+          data: [{ yAxis: 48, name: '超时线(48h)', label: { formatter: '超时线 48h' } }],
+          lineStyle: { color: '#f56c6c', type: 'dashed' },
+        },
+      },
+      {
+        name: '最长耗时',
+        type: 'line',
+        data: data.map(d => d.maxHours),
+        lineStyle: { type: 'dotted', opacity: 0.6 },
+        itemStyle: { color: '#e6a23c' },
+        symbol: 'none',
+      },
+    ],
+  })
+}
+
+function renderCompletionChart() {
+  if (!completionChartRef.value) return
+  completionChart = completionChart || echarts.init(completionChartRef.value)
+  const data = completionData.value
+
+  if (data.length === 0) {
+    completionChart.setOption({
+      title: { text: '暂无数据', left: 'center', top: 'center', textStyle: { color: '#999', fontSize: 14 } },
+    })
+    return
+  }
+
+  completionChart.setOption({
+    tooltip: {
+      trigger: 'item',
+      formatter: (p: any) => `${p.name}<br/>完成率: ${p.value}%<br/>${p.data.total}/${p.data.totalAll}`,
+    },
+    legend: {
+      type: 'scroll',
+      bottom: 0,
+      data: data.map(d => d.processName),
+    },
+    series: [
+      {
+        type: 'pie',
+        radius: ['35%', '60%'],
+        center: ['50%', '45%'],
+        avoidLabelOverlap: true,
+        label: {
+          show: true,
+          formatter: '{b}\n{c}%',
+        },
+        emphasis: {
+          label: { show: true, fontSize: 14, fontWeight: 'bold' },
+        },
+        data: data.map(d => ({
+          name: d.processName,
+          value: d.completionRate,
+          total: d.completed,
+          totalAll: d.total,
+        })),
+      },
+    ],
+  })
+}
+
+function renderNodeChart() {
+  if (!nodeChartRef.value) return
+  nodeChart = nodeChart || echarts.init(nodeChartRef.value)
+  const data = nodeDistribution.value
+
+  if (data.length === 0) {
+    nodeChart.setOption({
+      title: { text: '暂无数据', left: 'center', top: 'center', textStyle: { color: '#999', fontSize: 14 } },
+    })
+    return
+  }
+
+  const colors = data.map(d => d.isBottleneck ? '#f56c6c' : '#409eff')
+
+  nodeChart.setOption({
+    tooltip: {
+      trigger: 'axis',
+      axisPointer: { type: 'shadow' },
+      formatter: (params: any) => {
+        const idx = params[0].dataIndex
+        const node = data[idx]
+        return `${node.nodeName}${node.isBottleneck ? ' 🔴瓶颈' : ''}<br/>` +
+          `平均: ${node.avgDurationHours}h<br/>` +
+          `最长: ${node.maxDurationHours}h<br/>` +
+          `最短: ${node.minDurationHours}h<br/>` +
+          `审批次数: ${node.approvalCount}`
+      },
+    },
+    grid: { left: '3%', right: '4%', bottom: '3%', containLabel: true },
+    xAxis: {
+      type: 'category',
+      data: data.map(d => d.nodeName),
+      axisLabel: { rotate: 15, interval: 0 },
+    },
+    yAxis: { type: 'value', name: '小时(h)', min: 0 },
+    series: [
+      {
+        name: '平均耗时',
+        type: 'bar',
+        barMaxWidth: 50,
+        data: data.map((d, i) => ({
+          value: d.avgDurationHours,
+          itemStyle: {
+            color: colors[i],
+            borderRadius: [4, 4, 0, 0],
+          },
+        })),
+        label: {
+          show: true,
+          position: 'top',
+          formatter: (p: any) => {
+            const node = data[p.dataIndex]
+            return node.isBottleneck ? `${p.value}h ⚠️` : `${p.value}h`
+          },
+          color: '#333',
+          fontSize: 11,
+        },
+        markLine: {
+          silent: true,
+          data: [{ type: 'average', name: '平均值' }],
+          lineStyle: { color: '#67c23a', type: 'dashed' },
+          label: { formatter: '平均 {c}h' },
+        },
+      },
+      {
+        name: '最长耗时',
+        type: 'bar',
+        barMaxWidth: 30,
+        data: data.map(d => ({
+          value: d.maxDurationHours,
+          itemStyle: { color: '#e6a23c', opacity: 0.6, borderRadius: [4, 4, 0, 0] },
+        })),
+      },
+    ],
+  })
+}
+
+// ========== 工具函数 ==========
+function timeoutRowClass({ row }: { row: TimeoutProcessVO }) {
+  if (row.durationHours > 96) return 'timeout-critical'
+  if (row.durationHours > 48) return 'timeout-warning'
+  return ''
+}
+
+function priorityType(priority: number) {
+  switch (priority) {
+    case 2: return 'danger'
+    case 1: return 'warning'
+    default: return 'info'
+  }
+}
+
+function priorityText(priority: number) {
+  switch (priority) {
+    case 2: return '特急'
+    case 1: return '紧急'
+    default: return '普通'
+  }
+}
+
+function formatTime(t: string) {
+  if (!t) return '-'
+  return t.replace('T', ' ').slice(0, 16)
+}
+
+function goToDetail(row: TimeoutProcessVO) {
+  router.push(`/bpm/instance/${row.instanceId}`)
+}
+
+function handleResize() {
+  trendChart?.resize()
+  completionChart?.resize()
+  nodeChart?.resize()
+}
+</script>
+
+<style scoped>
+.process-stats {
+  padding: 0;
+}
+
+.stat-card {
+  text-align: center;
+  padding: 8px 0;
+}
+
+.stat-icon {
+  font-size: 28px;
+}
+
+.stat-value {
+  font-size: 32px;
+  font-weight: 700;
+  margin: 4px 0;
+}
+
+.stat-label {
+  font-size: 13px;
+  color: #666;
+}
+
+.stat-sub {
+  font-size: 12px;
+  color: #999;
+  margin-top: 2px;
+}
+
+.stat-blue .stat-value { color: #409eff; }
+.stat-orange .stat-value { color: #e6a23c; }
+.stat-green .stat-value { color: #67c23a; }
+.stat-red .stat-value { color: #f56c6c; }
+.stat-purple .stat-value { color: #9b59b6; }
+
+.card-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+:deep(.timeout-critical) {
+  background-color: #fef0f0 !important;
+}
+
+:deep(.timeout-warning) {
+  background-color: #fdf6ec !important;
+}
+
+:deep(.timeout-critical:hover > td),
+:deep(.timeout-warning:hover > td) {
+  background-color: transparent !important;
+}
+</style>

wm-bpm/src/main/java/com/water/bpm/controller/ProcessStatisticsController.java

@@ -0,0 +1,78 @@
+package com.water.bpm.controller;
+
+import com.water.bpm.entity.dto.NodeDurationVO;
+import com.water.bpm.entity.dto.ProcessStatsOverview;
+import com.water.bpm.entity.dto.TimeoutProcessVO;
+import com.water.bpm.service.ProcessStatisticsService;
+import com.water.common.core.result.R;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 流程统计评估 Controller
+ */
+@Tag(name = "流程统计评估")
+@RestController
+@RequestMapping("/bpm/statistics")
+@RequiredArgsConstructor
+public class ProcessStatisticsController {
+
+    private final ProcessStatisticsService statisticsService;
+
+    @Operation(summary = "统计概览")
+    @GetMapping("/overview")
+    public R<ProcessStatsOverview> overview() {
+        return R.ok(statisticsService.getOverview());
+    }
+
+    @Operation(summary = "平均处理时长趋势")
+    @GetMapping("/avg-duration-trend")
+    public R<List<Map<String, Object>>> avgDurationTrend(
+            @RequestParam(defaultValue = "30") int days) {
+        return R.ok(statisticsService.getAvgDurationTrend(days));
+    }
+
+    @Operation(summary = "节点耗时分布")
+    @GetMapping("/node-duration")
+    public R<List<NodeDurationVO>> nodeDurationDistribution() {
+        return R.ok(statisticsService.getNodeDurationDistribution());
+    }
+
+    @Operation(summary = "超时流程列表")
+    @GetMapping("/timeout")
+    public R<List<TimeoutProcessVO>> timeoutProcessList() {
+        return R.ok(statisticsService.getTimeoutProcessList());
+    }
+
+    @Operation(summary = "流程完成率")
+    @GetMapping("/completion-rate")
+    public R<List<Map<String, Object>>> completionRate() {
+        return R.ok(statisticsService.getCompletionRate());
+    }
+
+    @Operation(summary = "按流程定义分组统计")
+    @GetMapping("/by-definition")
+    public R<List<Map<String, Object>>> statsByDefinition() {
+        return R.ok(statisticsService.getStatsByDefinition());
+    }
+
+    @Operation(summary = "按时间范围统计")
+    @GetMapping("/by-time-range")
+    public R<List<Map<String, Object>>> statsByTimeRange(
+            @RequestParam(defaultValue = "day") String period,
+            @RequestParam(defaultValue = "30") int days) {
+        return R.ok(statisticsService.getStatsByTimeRange(period, days));
+    }
+
+    @Operation(summary = "瓶颈节点识别")
+    @GetMapping("/bottleneck")
+    public R<List<NodeDurationVO>> bottleneckNodes(
+            @RequestParam(defaultValue = "5") int topN) {
+        return R.ok(statisticsService.getBottleneckNodes(topN));
+    }
+}

wm-bpm/src/main/java/com/water/bpm/entity/dto/NodeDurationVO.java

@@ -0,0 +1,24 @@
+package com.water.bpm.entity.dto;
+
+import lombok.Data;
+
+/**
+ * 节点耗时分布 VO
+ */
+@Data
+public class NodeDurationVO {
+    /** 节点标识 */
+    private String nodeId;
+    /** 节点名称 */
+    private String nodeName;
+    /** 平均耗时(小时) */
+    private Double avgDurationHours;
+    /** 最大耗时(小时) */
+    private Double maxDurationHours;
+    /** 最小耗时(小时) */
+    private Double minDurationHours;
+    /** 审批次数 */
+    private Integer approvalCount;
+    /** 是否瓶颈节点 */
+    private Boolean isBottleneck;
+}

wm-bpm/src/main/java/com/water/bpm/entity/dto/ProcessStatsOverview.java

@@ -0,0 +1,31 @@
+package com.water.bpm.entity.dto;
+
+import lombok.Data;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 流程统计概览 DTO
+ */
+@Data
+public class ProcessStatsOverview {
+    /** 总流程数 */
+    private Integer totalInstances;
+    /** 运行中 */
+    private Integer runningCount;
+    /** 已完成 */
+    private Integer completedCount;
+    /** 已驳回 */
+    private Integer rejectedCount;
+    /** 已撤回 */
+    private Integer terminatedCount;
+    /** 超时数 */
+    private Integer timeoutCount;
+    /** 平均处理时长(小时) */
+    private Double avgDurationHours;
+    /** 流程完成率(%) */
+    private Double completionRate;
+    /** 挂起数 */
+    private Integer suspendedCount;
+}

wm-bpm/src/main/java/com/water/bpm/entity/dto/TimeoutProcessVO.java

@@ -0,0 +1,34 @@
+package com.water.bpm.entity.dto;
+
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 超时流程 VO
+ */
+@Data
+public class TimeoutProcessVO {
+    /** 流程实例ID */
+    private Long id;
+    /** 实例UUID */
+    private String instanceId;
+    /** 流程名称 */
+    private String processName;
+    /** 流程标题 */
+    private String title;
+    /** 发起人姓名 */
+    private String initiatorName;
+    /** 当前节点名称 */
+    private String currentNodeName;
+    /** 当前处理人姓名 */
+    private String currentAssigneeName;
+    /** 开始时间 */
+    private LocalDateTime startedAt;
+    /** 已耗时(小时) */
+    private Double durationHours;
+    /** 状态 */
+    private String status;
+    /** 优先级 */
+    private Integer priority;
+}

wm-bpm/src/main/java/com/water/bpm/mapper/ProcessStatisticsMapper.java

@@ -0,0 +1,145 @@
+package com.water.bpm.mapper;
+
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 流程统计 Mapper — 聚合查询
+ */
+@Mapper
+public interface ProcessStatisticsMapper {
+
+    /**
+     * 统计各状态流程数量
+     */
+    @Select("SELECT status, COUNT(*) as count FROM bpm_process_instance WHERE deleted = 0 GROUP BY status")
+    List<Map<String, Object>> countByStatus();
+
+    /**
+     * 统计总流程数和平均耗时
+     */
+    @Select("SELECT COUNT(*) as total, " +
+            "AVG(duration_seconds) as avg_duration_seconds, " +
+            "SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed_count " +
+            "FROM bpm_process_instance WHERE deleted = 0")
+    Map<String, Object> overallStats();
+
+    /**
+     * 按流程定义分组统计
+     */
+    @Select("SELECT d.id as definition_id, d.process_name, d.process_key, " +
+            "COUNT(i.id) as total_instances, " +
+            "SUM(CASE WHEN i.status = 'running' THEN 1 ELSE 0 END) as running_count, " +
+            "SUM(CASE WHEN i.status = 'completed' THEN 1 ELSE 0 END) as completed_count, " +
+            "SUM(CASE WHEN i.status = 'rejected' THEN 1 ELSE 0 END) as rejected_count, " +
+            "SUM(CASE WHEN i.status = 'terminated' THEN 1 ELSE 0 END) as terminated_count, " +
+            "AVG(i.duration_seconds) as avg_duration_seconds, " +
+            "MAX(i.duration_seconds) as max_duration_seconds, " +
+            "MIN(i.duration_seconds) as min_duration_seconds " +
+            "FROM bpm_process_definition d " +
+            "LEFT JOIN bpm_process_instance i ON d.id = i.definition_id AND i.deleted = 0 " +
+            "WHERE d.deleted = 0 " +
+            "GROUP BY d.id, d.process_name, d.process_key " +
+            "ORDER BY total_instances DESC")
+    List<Map<String, Object>> statsByDefinition();
+
+    /**
+     * 节点耗时分布 — 从审批记录聚合
+     */
+    @Select("SELECT node_id, node_name, " +
+            "AVG(EXTRACT(EPOCH FROM (approved_at - created_at))) as avg_duration_seconds, " +
+            "MAX(EXTRACT(EPOCH FROM (approved_at - created_at))) as max_duration_seconds, " +
+            "MIN(EXTRACT(EPOCH FROM (approved_at - created_at))) as min_duration_seconds, " +
+            "COUNT(*) as approval_count " +
+            "FROM bpm_approval_record WHERE deleted = 0 " +
+            "GROUP BY node_id, node_name " +
+            "ORDER BY avg_duration_seconds DESC")
+    List<Map<String, Object>> nodeDurationDistribution();
+
+    /**
+     * 超时流程列表（运行中且单节点审批超过48小时）
+     */
+    @Select("SELECT DISTINCT i.id, i.instance_id, i.process_name, i.title, " +
+            "i.initiator_name, i.current_node_name, i.current_assignee_name, " +
+            "i.started_at, i.status, i.priority, " +
+            "EXTRACT(EPOCH FROM (NOW() - i.started_at)) / 3600 as duration_hours " +
+            "FROM bpm_process_instance i " +
+            "WHERE i.deleted = 0 AND i.status = 'running' " +
+            "AND EXISTS ( " +
+            "  SELECT 1 FROM bpm_approval_record r " +
+            "  WHERE r.instance_id = i.id AND r.deleted = 0 " +
+            "  AND EXTRACT(EPOCH FROM (COALESCE(r.approved_at, NOW()) - r.created_at)) > 172800 " +
+            ") " +
+            "ORDER BY duration_hours DESC")
+    List<Map<String, Object>> timeoutProcessList();
+
+    /**
+     * 超时流程列表（简化版：运行中且启动超过48小时）
+     */
+    @Select("SELECT id, instance_id, process_name, title, " +
+            "initiator_name, current_node_name, current_assignee_name, " +
+            "started_at, status, priority, " +
+            "EXTRACT(EPOCH FROM (NOW() - started_at)) / 3600 as duration_hours " +
+            "FROM bpm_process_instance " +
+            "WHERE deleted = 0 AND status = 'running' " +
+            "AND EXTRACT(EPOCH FROM (NOW() - started_at)) > 172800 " +
+            "ORDER BY duration_hours DESC")
+    List<Map<String, Object>> timeoutProcessListSimple();
+
+    /**
+     * 平均处理时长趋势（按日聚合）
+     */
+    @Select("SELECT DATE(completed_at) as stat_date, " +
+            "COUNT(*) as completed_count, " +
+            "AVG(duration_seconds) as avg_duration_seconds, " +
+            "MAX(duration_seconds) as max_duration_seconds, " +
+            "MIN(duration_seconds) as min_duration_seconds " +
+            "FROM bpm_process_instance " +
+            "WHERE deleted = 0 AND status = 'completed' " +
+            "AND completed_at >= #{startDate} AND completed_at <= #{endDate} " +
+            "GROUP BY DATE(completed_at) " +
+            "ORDER BY stat_date")
+    List<Map<String, Object>> avgDurationTrend(@Param("startDate") LocalDateTime startDate,
+                                                 @Param("endDate") LocalDateTime endDate);
+
+    /**
+     * 按时间范围统计（按周/月聚合）
+     */
+    @Select("SELECT DATE_TRUNC(#{period}, completed_at) as stat_period, " +
+            "COUNT(*) as completed_count, " +
+            "AVG(duration_seconds) as avg_duration_seconds " +
+            "FROM bpm_process_instance " +
+            "WHERE deleted = 0 AND status = 'completed' " +
+            "AND completed_at >= #{startDate} AND completed_at <= #{endDate} " +
+            "GROUP BY DATE_TRUNC(#{period}, completed_at) " +
+            "ORDER BY stat_period")
+    List<Map<String, Object>> statsByTimeRange(@Param("period") String period,
+                                                @Param("startDate") LocalDateTime startDate,
+                                                @Param("endDate") LocalDateTime endDate);
+
+    /**
+     * 流程完成率（按流程定义）
+     */
+    @Select("SELECT process_key, process_name, " +
+            "COUNT(*) as total, " +
+            "SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed, " +
+            "ROUND(100.0 * SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) / NULLIF(COUNT(*), 0), 2) as completion_rate " +
+            "FROM bpm_process_instance WHERE deleted = 0 " +
+            "GROUP BY process_key, process_name " +
+            "ORDER BY completion_rate DESC")
+    List<Map<String, Object>> completionRateByDefinition();
+
+    /**
+     * 超时统计数量
+     */
+    @Select("SELECT COUNT(DISTINCT i.id) as timeout_count " +
+            "FROM bpm_process_instance i " +
+            "WHERE i.deleted = 0 AND i.status = 'running' " +
+            "AND EXTRACT(EPOCH FROM (NOW() - i.started_at)) > 172800")
+    Map<String, Object> timeoutCount();
+}

wm-bpm/src/main/java/com/water/bpm/service/ProcessStatisticsService.java

@@ -0,0 +1,273 @@
+package com.water.bpm.service;
+
+import com.water.bpm.entity.dto.NodeDurationVO;
+import com.water.bpm.entity.dto.ProcessStatsOverview;
+import com.water.bpm.entity.dto.TimeoutProcessVO;
+import com.water.bpm.mapper.ProcessStatisticsMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * 流程统计评估服务
+ * 提供：平均处理时长/各节点耗时分布/超时流程列表/流程完成率/瓶颈节点识别/按时间范围统计/按流程定义分组
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class ProcessStatisticsService {
+
+    private final ProcessStatisticsMapper statisticsMapper;
+
+    /** 超时阈值：48小时（秒） */
+    private static final long TIMEOUT_THRESHOLD_SECONDS = 48 * 3600L;
+
+    /**
+     * 统计概览 — 仪表盘卡片数据
+     */
+    public ProcessStatsOverview getOverview() {
+        ProcessStatsOverview overview = new ProcessStatsOverview();
+
+        // 各状态数量
+        Map<String, Integer> statusCounts = new HashMap<>();
+        List<Map<String, Object>> statusList = statisticsMapper.countByStatus();
+        for (Map<String, Object> row : statusList) {
+            String status = String.valueOf(row.get("status"));
+            int count = ((Number) row.get("count")).intValue();
+            statusCounts.put(status, count);
+        }
+
+        // 总体统计
+        Map<String, Object> overall = statisticsMapper.overallStats();
+        int total = overall != null && overall.get("total") != null
+                ? ((Number) overall.get("total")).intValue() : 0;
+        double avgSeconds = overall != null && overall.get("avg_duration_seconds") != null
+                ? ((Number) overall.get("avg_duration_seconds")).doubleValue() : 0.0;
+        int completedTotal = overall != null && overall.get("completed_count") != null
+                ? ((Number) overall.get("completed_count")).intValue() : 0;
+
+        overview.setTotalInstances(total);
+        overview.setRunningCount(statusCounts.getOrDefault("running", 0));
+        overview.setCompletedCount(statusCounts.getOrDefault("completed", 0));
+        overview.setRejectedCount(statusCounts.getOrDefault("rejected", 0));
+        overview.setTerminatedCount(statusCounts.getOrDefault("terminated", 0));
+        overview.setSuspendedCount(statusCounts.getOrDefault("suspended", 0));
+        overview.setAvgDurationHours(Math.round(avgSeconds / 3600.0 * 100.0) / 100.0);
+
+        // 完成率
+        double completionRate = total > 0 ? Math.round(100.0 * completedTotal / total * 100.0) / 100.0 : 0.0;
+        overview.setCompletionRate(completionRate);
+
+        // 超时数量
+        Map<String, Object> timeoutResult = statisticsMapper.timeoutCount();
+        int timeoutCount = timeoutResult != null && timeoutResult.get("timeout_count") != null
+                ? ((Number) timeoutResult.get("timeout_count")).intValue() : 0;
+        overview.setTimeoutCount(timeoutCount);
+
+        return overview;
+    }
+
+    /**
+     * 平均处理时长趋势（按日）
+     * @param days 最近天数
+     */
+    public List<Map<String, Object>> getAvgDurationTrend(int days) {
+        LocalDateTime endDate = LocalDateTime.now();
+        LocalDateTime startDate = endDate.minusDays(days);
+        List<Map<String, Object>> trend = statisticsMapper.avgDurationTrend(startDate, endDate);
+
+        // 转换为前端友好格式
+        return trend.stream().map(row -> {
+            Map<String, Object> item = new LinkedHashMap<>();
+            item.put("date", String.valueOf(row.get("stat_date")));
+            item.put("completedCount", ((Number) row.getOrDefault("completed_count", 0)).intValue());
+            double avgSeconds = row.get("avg_duration_seconds") != null
+                    ? ((Number) row.get("avg_duration_seconds")).doubleValue() : 0.0;
+            item.put("avgHours", Math.round(avgSeconds / 3600.0 * 100.0) / 100.0);
+            double maxSeconds = row.get("max_duration_seconds") != null
+                    ? ((Number) row.get("max_duration_seconds")).doubleValue() : 0.0;
+            item.put("maxHours", Math.round(maxSeconds / 3600.0 * 100.0) / 100.0);
+            double minSeconds = row.get("min_duration_seconds") != null
+                    ? ((Number) row.get("min_duration_seconds")).doubleValue() : 0.0;
+            item.put("minHours", Math.round(minSeconds / 3600.0 * 100.0) / 100.0);
+            return item;
+        }).collect(Collectors.toList());
+    }
+
+    /**
+     * 节点耗时分布（识别瓶颈节点）
+     */
+    public List<NodeDurationVO> getNodeDurationDistribution() {
+        List<Map<String, Object>> raw = statisticsMapper.nodeDurationDistribution();
+
+        List<NodeDurationVO> result = new ArrayList<>();
+        double maxAvg = 0;
+        String bottleneckNodeId = null;
+
+        for (Map<String, Object> row : raw) {
+            NodeDurationVO vo = new NodeDurationVO();
+            vo.setNodeId(String.valueOf(row.get("node_id")));
+            vo.setNodeName(String.valueOf(row.get("node_name")));
+
+            double avgSec = row.get("avg_duration_seconds") != null
+                    ? ((Number) row.get("avg_duration_seconds")).doubleValue() : 0.0;
+            double maxSec = row.get("max_duration_seconds") != null
+                    ? ((Number) row.get("max_duration_seconds")).doubleValue() : 0.0;
+            double minSec = row.get("min_duration_seconds") != null
+                    ? ((Number) row.get("min_duration_seconds")).doubleValue() : 0.0;
+            int count = row.get("approval_count") != null
+                    ? ((Number) row.get("approval_count")).intValue() : 0;
+
+            vo.setAvgDurationHours(Math.round(avgSec / 3600.0 * 100.0) / 100.0);
+            vo.setMaxDurationHours(Math.round(maxSec / 3600.0 * 100.0) / 100.0);
+            vo.setMinDurationHours(Math.round(minSec / 3600.0 * 100.0) / 100.0);
+            vo.setApprovalCount(count);
+            vo.setIsBottleneck(false);
+
+            if (avgSec > maxAvg) {
+                maxAvg = avgSec;
+                bottleneckNodeId = vo.getNodeId();
+            }
+
+            result.add(vo);
+        }
+
+        // 标记瓶颈节点（平均耗时最长的 + 超过平均2倍的）
+        if (result.size() > 1) {
+            double totalAvg = result.stream().mapToDouble(NodeDurationVO::getAvgDurationHours).average().orElse(0);
+            for (NodeDurationVO vo : result) {
+                if (vo.getNodeId().equals(bottleneckNodeId)
+                        || vo.getAvgDurationHours() > totalAvg * 2) {
+                    vo.setIsBottleneck(true);
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * 超时流程列表
+     * 超时判定：单节点审批超过48小时 或 流程启动后运行超过48小时仍为 running
+     */
+    public List<TimeoutProcessVO> getTimeoutProcessList() {
+        // 先尝试精确查询（基于审批记录），若无结果则用简化查询
+        List<Map<String, Object>> raw = statisticsMapper.timeoutProcessList();
+        if (raw == null || raw.isEmpty()) {
+            raw = statisticsMapper.timeoutProcessListSimple();
+        }
+
+        return raw.stream().map(row -> {
+            TimeoutProcessVO vo = new TimeoutProcessVO();
+            vo.setId(row.get("id") != null ? ((Number) row.get("id")).longValue() : null);
+            vo.setInstanceId(String.valueOf(row.get("instance_id")));
+            vo.setProcessName(String.valueOf(row.get("process_name")));
+            vo.setTitle(String.valueOf(row.get("title")));
+            vo.setInitiatorName(String.valueOf(row.get("initiator_name")));
+            vo.setCurrentNodeName(String.valueOf(row.get("current_node_name")));
+            vo.setCurrentAssigneeName(String.valueOf(row.get("current_assignee_name")));
+            vo.setStatus(String.valueOf(row.get("status")));
+            vo.setPriority(row.get("priority") != null ? ((Number) row.get("priority")).intValue() : 0);
+            double hours = row.get("duration_hours") != null
+                    ? ((Number) row.get("duration_hours")).doubleValue() : 0.0;
+            vo.setDurationHours(Math.round(hours * 100.0) / 100.0);
+            // started_at may be a Timestamp
+            Object startedAtObj = row.get("started_at");
+            if (startedAtObj instanceof java.sql.Timestamp ts) {
+                vo.setStartedAt(ts.toLocalDateTime());
+            } else if (startedAtObj instanceof LocalDateTime ldt) {
+                vo.setStartedAt(ldt);
+            }
+            return vo;
+        }).collect(Collectors.toList());
+    }
+
+    /**
+     * 流程完成率（按流程定义分组）
+     */
+    public List<Map<String, Object>> getCompletionRate() {
+        List<Map<String, Object>> raw = statisticsMapper.completionRateByDefinition();
+        return raw.stream().map(row -> {
+            Map<String, Object> item = new LinkedHashMap<>();
+            item.put("processKey", String.valueOf(row.get("process_key")));
+            item.put("processName", String.valueOf(row.get("process_name")));
+            item.put("total", ((Number) row.getOrDefault("total", 0)).intValue());
+            item.put("completed", ((Number) row.getOrDefault("completed", 0)).intValue());
+            double rate = row.get("completion_rate") != null
+                    ? ((Number) row.get("completion_rate")).doubleValue() : 0.0;
+            item.put("completionRate", rate);
+            return item;
+        }).collect(Collectors.toList());
+    }
+
+    /**
+     * 按流程定义分组统计
+     */
+    public List<Map<String, Object>> getStatsByDefinition() {
+        List<Map<String, Object>> raw = statisticsMapper.statsByDefinition();
+        return raw.stream().map(row -> {
+            Map<String, Object> item = new LinkedHashMap<>();
+            item.put("definitionId", row.get("definition_id"));
+            item.put("processName", String.valueOf(row.get("process_name")));
+            item.put("processKey", String.valueOf(row.get("process_key")));
+            item.put("totalInstances", ((Number) row.getOrDefault("total_instances", 0)).intValue());
+            item.put("runningCount", ((Number) row.getOrDefault("running_count", 0)).intValue());
+            item.put("completedCount", ((Number) row.getOrDefault("completed_count", 0)).intValue());
+            item.put("rejectedCount", ((Number) row.getOrDefault("rejected_count", 0)).intValue());
+            item.put("terminatedCount", ((Number) row.getOrDefault("terminated_count", 0)).intValue());
+            double avgSec = row.get("avg_duration_seconds") != null
+                    ? ((Number) row.get("avg_duration_seconds")).doubleValue() : 0.0;
+            item.put("avgDurationHours", Math.round(avgSec / 3600.0 * 100.0) / 100.0);
+            double maxSec = row.get("max_duration_seconds") != null
+                    ? ((Number) row.get("max_duration_seconds")).doubleValue() : 0.0;
+            item.put("maxDurationHours", Math.round(maxSec / 3600.0 * 100.0) / 100.0);
+            double minSec = row.get("min_duration_seconds") != null
+                    ? ((Number) row.get("min_duration_seconds")).doubleValue() : 0.0;
+            item.put("minDurationHours", Math.round(minSec / 3600.0 * 100.0) / 100.0);
+            return item;
+        }).collect(Collectors.toList());
+    }
+
+    /**
+     * 按时间范围统计
+     * @param period day/week/month
+     * @param days 最近天数
+     */
+    public List<Map<String, Object>> getStatsByTimeRange(String period, int days) {
+        LocalDateTime endDate = LocalDateTime.now();
+        LocalDateTime startDate = endDate.minusDays(days);
+
+        // PostgreSQL DATE_TRUNC 参数: day, week, month
+        String pgPeriod = switch (period) {
+            case "week" -> "week";
+            case "month" -> "month";
+            default -> "day";
+        };
+
+        List<Map<String, Object>> raw = statisticsMapper.statsByTimeRange(pgPeriod, startDate, endDate);
+        return raw.stream().map(row -> {
+            Map<String, Object> item = new LinkedHashMap<>();
+            item.put("period", String.valueOf(row.get("stat_period")));
+            item.put("completedCount", ((Number) row.getOrDefault("completed_count", 0)).intValue());
+            double avgSec = row.get("avg_duration_seconds") != null
+                    ? ((Number) row.get("avg_duration_seconds")).doubleValue() : 0.0;
+            item.put("avgHours", Math.round(avgSec / 3600.0 * 100.0) / 100.0);
+            return item;
+        }).collect(Collectors.toList());
+    }
+
+    /**
+     * 识别瓶颈节点 — 返回耗时最长的前N个节点
+     */
+    public List<NodeDurationVO> getBottleneckNodes(int topN) {
+        List<NodeDurationVO> all = getNodeDurationDistribution();
+        return all.stream()
+                .filter(NodeDurationVO::getIsBottleneck)
+                .limit(topN)
+                .collect(Collectors.toList());
+    }
+}

wm-bpm/src/test/java/com/water/bpm/service/ProcessStatisticsServiceTest.java

@@ -0,0 +1,328 @@
+package com.water.bpm.service;
+
+import com.water.bpm.entity.dto.NodeDurationVO;
+import com.water.bpm.entity.dto.ProcessStatsOverview;
+import com.water.bpm.entity.dto.TimeoutProcessVO;
+import com.water.bpm.mapper.ProcessStatisticsMapper;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.sql.Timestamp;
+import java.time.LocalDateTime;
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+/**
+ * 流程统计评估服务测试
+ */
+@ExtendWith(MockitoExtension.class)
+class ProcessStatisticsServiceTest {
+
+    @Mock
+    private ProcessStatisticsMapper statisticsMapper;
+
+    private ProcessStatisticsService statisticsService;
+
+    @BeforeEach
+    void setUp() {
+        statisticsService = new ProcessStatisticsService(statisticsMapper);
+    }
+
+    // ========== 概览测试 ==========
+
+    @Test
+    @DisplayName("统计概览 — 正常数据")
+    void testGetOverview_Normal() {
+        // Given
+        List<Map<String, Object>> statusCounts = List.of(
+                Map.of("status", "running", "count", 15L),
+                Map.of("status", "completed", "count", 80L),
+                Map.of("status", "rejected", "count", 5L),
+                Map.of("status", "terminated", "count", 3L)
+        );
+        when(statisticsMapper.countByStatus()).thenReturn(statusCounts);
+
+        Map<String, Object> overall = new HashMap<>();
+        overall.put("total", 103L);
+        overall.put("avg_duration_seconds", 7200.0);  // 2 hours
+        overall.put("completed_count", 80L);
+        when(statisticsMapper.overallStats()).thenReturn(overall);
+
+        Map<String, Object> timeout = Map.of("timeout_count", 2L);
+        when(statisticsMapper.timeoutCount()).thenReturn(timeout);
+
+        // When
+        ProcessStatsOverview overview = statisticsService.getOverview();
+
+        // Then
+        assertNotNull(overview);
+        assertEquals(103, overview.getTotalInstances());
+        assertEquals(15, overview.getRunningCount());
+        assertEquals(80, overview.getCompletedCount());
+        assertEquals(5, overview.getRejectedCount());
+        assertEquals(3, overview.getTerminatedCount());
+        assertEquals(2.0, overview.getAvgDurationHours());
+        assertEquals(77.67, overview.getCompletionRate());  // 80/103 * 100
+        assertEquals(2, overview.getTimeoutCount());
+    }
+
+    @Test
+    @DisplayName("统计概览 — 无数据")
+    void testGetOverview_Empty() {
+        when(statisticsMapper.countByStatus()).thenReturn(List.of());
+        when(statisticsMapper.overallStats()).thenReturn(null);
+        when(statisticsMapper.timeoutCount()).thenReturn(null);
+
+        ProcessStatsOverview overview = statisticsService.getOverview();
+
+        assertNotNull(overview);
+        assertEquals(0, overview.getTotalInstances());
+        assertEquals(0, overview.getRunningCount());
+        assertEquals(0.0, overview.getAvgDurationHours());
+        assertEquals(0.0, overview.getCompletionRate());
+    }
+
+    // ========== 平均处理时长趋势测试 ==========
+
+    @Test
+    @DisplayName("平均处理时长趋势 — 7天数据")
+    void testGetAvgDurationTrend() {
+        List<Map<String, Object>> trend = List.of(
+                createTrendRow("2026-06-10", 5, 14400.0, 28800.0, 3600.0),
+                createTrendRow("2026-06-11", 8, 10800.0, 21600.0, 5400.0),
+                createTrendRow("2026-06-12", 3, 18000.0, 36000.0, 7200.0)
+        );
+        when(statisticsMapper.avgDurationTrend(any(), any())).thenReturn(trend);
+
+        List<Map<String, Object>> result = statisticsService.getAvgDurationTrend(7);
+
+        assertNotNull(result);
+        assertEquals(3, result.size());
+        assertEquals("2026-06-10", result.get(0).get("date"));
+        assertEquals(4.0, result.get(0).get("avgHours"));   // 14400s = 4h
+        assertEquals(5, result.get(0).get("completedCount"));
+    }
+
+    @Test
+    @DisplayName("平均处理时长趋势 — 空数据")
+    void testGetAvgDurationTrend_Empty() {
+        when(statisticsMapper.avgDurationTrend(any(), any())).thenReturn(List.of());
+
+        List<Map<String, Object>> result = statisticsService.getAvgDurationTrend(30);
+
+        assertNotNull(result);
+        assertTrue(result.isEmpty());
+    }
+
+    // ========== 节点耗时分布测试 ==========
+
+    @Test
+    @DisplayName("节点耗时分布 — 识别瓶颈节点")
+    void testGetNodeDurationDistribution_WithBottleneck() {
+        List<Map<String, Object>> nodes = List.of(
+                createNodeRow("node1", "部门经理审批", 172800.0, 345600.0, 86400.0, 20),  // 48h avg — bottleneck
+                createNodeRow("node2", "技术审核", 3600.0, 7200.0, 1800.0, 15),            // 1h avg
+                createNodeRow("node3", "财务确认", 7200.0, 14400.0, 3600.0, 10)             // 2h avg
+        );
+        when(statisticsMapper.nodeDurationDistribution()).thenReturn(nodes);
+
+        List<NodeDurationVO> result = statisticsService.getNodeDurationDistribution();
+
+        assertNotNull(result);
+        assertEquals(3, result.size());
+
+        // 部门经理审批应该是瓶颈 (48h >> average)
+        NodeDurationVO bottleneck = result.get(0);
+        assertEquals("node1", bottleneck.getNodeId());
+        assertEquals("部门经理审批", bottleneck.getNodeName());
+        assertEquals(48.0, bottleneck.getAvgDurationHours());
+        assertTrue(bottleneck.getIsBottleneck());
+
+        // 技术审核不是瓶颈
+        NodeDurationVO tech = result.get(1);
+        assertEquals(1.0, tech.getAvgDurationHours());
+        assertFalse(tech.getIsBottleneck());
+    }
+
+    @Test
+    @DisplayName("节点耗时分布 — 单节点无瓶颈")
+    void testGetNodeDurationDistribution_SingleNode() {
+        List<Map<String, Object>> nodes = List.of(
+                createNodeRow("node1", "审批", 3600.0, 7200.0, 1800.0, 10)
+        );
+        when(statisticsMapper.nodeDurationDistribution()).thenReturn(nodes);
+
+        List<NodeDurationVO> result = statisticsService.getNodeDurationDistribution();
+
+        assertEquals(1, result.size());
+        // 单节点不标记瓶颈
+        assertFalse(result.get(0).getIsBottleneck());
+    }
+
+    // ========== 超时流程列表测试 ==========
+
+    @Test
+    @DisplayName("超时流程列表 — 正常数据")
+    void testGetTimeoutProcessList() {
+        List<Map<String, Object>> raw = List.of(
+                createTimeoutRow(1L, "uuid-001", "设备维修", "水泵故障维修", "张三", "技术审核", "李四", 72.5),
+                createTimeoutRow(2L, "uuid-002", "巡检任务", "管网巡检异常", "王五", "部门经理审批", "赵六", 96.0)
+        );
+        when(statisticsMapper.timeoutProcessList()).thenReturn(raw);
+
+        List<TimeoutProcessVO> result = statisticsService.getTimeoutProcessList();
+
+        assertNotNull(result);
+        assertEquals(2, result.size());
+        assertEquals("设备维修", result.get(0).getProcessName());
+        assertEquals(72.5, result.get(0).getDurationHours());
+        assertEquals("巡检任务", result.get(1).getProcessName());
+        assertTrue(result.get(1).getDurationHours() > 48.0);
+    }
+
+    @Test
+    @DisplayName("超时流程列表 — 精确查询为空时使用简化查询")
+    void testGetTimeoutProcessList_FallbackToSimple() {
+        when(statisticsMapper.timeoutProcessList()).thenReturn(List.of());
+        List<Map<String, Object>> simple = List.of(
+                createTimeoutRow(3L, "uuid-003", "水质检测", "水质超标处理", "钱七", "领导审批", "孙八", 50.0)
+        );
+        when(statisticsMapper.timeoutProcessListSimple()).thenReturn(simple);
+
+        List<TimeoutProcessVO> result = statisticsService.getTimeoutProcessList();
+
+        assertEquals(1, result.size());
+        assertEquals("水质检测", result.get(0).getProcessName());
+        verify(statisticsMapper).timeoutProcessListSimple();
+    }
+
+    // ========== 流程完成率测试 ==========
+
+    @Test
+    @DisplayName("流程完成率 — 正常计算")
+    void testGetCompletionRate() {
+        List<Map<String, Object>> raw = List.of(
+                Map.of("process_key", "equipment_repair", "process_name", "设备维修",
+                        "total", 100L, "completed", 85L, "completion_rate", 85.0),
+                Map.of("process_key", "inspection", "process_name", "巡检任务",
+                        "total", 50L, "completed", 45L, "completion_rate", 90.0)
+        );
+        when(statisticsMapper.completionRateByDefinition()).thenReturn(raw);
+
+        List<Map<String, Object>> result = statisticsService.getCompletionRate();
+
+        assertEquals(2, result.size());
+        assertEquals("equipment_repair", result.get(0).get("processKey"));
+        assertEquals(85.0, result.get(0).get("completionRate"));
+        assertEquals(100, result.get(0).get("total"));
+    }
+
+    // ========== 按流程定义分组统计测试 ==========
+
+    @Test
+    @DisplayName("按流程定义分组统计")
+    void testGetStatsByDefinition() {
+        List<Map<String, Object>> raw = List.of(
+                createDefinitionRow(1L, "设备维修", "equipment_repair", 50, 10, 35, 3, 2, 7200.0, 14400.0, 3600.0)
+        );
+        when(statisticsMapper.statsByDefinition()).thenReturn(raw);
+
+        List<Map<String, Object>> result = statisticsService.getStatsByDefinition();
+
+        assertEquals(1, result.size());
+        Map<String, Object> def = result.get(0);
+        assertEquals("设备维修", def.get("processName"));
+        assertEquals(50, def.get("totalInstances"));
+        assertEquals(10, def.get("runningCount"));
+        assertEquals(2.0, def.get("avgDurationHours"));  // 7200s = 2h
+    }
+
+    // ========== 瓶颈节点识别测试 ==========
+
+    @Test
+    @DisplayName("瓶颈节点识别 — 取Top N")
+    void testGetBottleneckNodes() {
+        List<Map<String, Object>> nodes = List.of(
+                createNodeRow("node1", "总经理审批", 172800.0, 345600.0, 86400.0, 20),   // 48h — bottleneck
+                createNodeRow("node2", "部门经理审批", 100800.0, 172800.0, 43200.0, 15),  // 28h — bottleneck (> avg*2)
+                createNodeRow("node3", "技术审核", 3600.0, 7200.0, 1800.0, 10),            // 1h
+                createNodeRow("node4", "表单填写", 1800.0, 3600.0, 900.0, 25)              // 0.5h
+        );
+        when(statisticsMapper.nodeDurationDistribution()).thenReturn(nodes);
+
+        List<NodeDurationVO> bottlenecks = statisticsService.getBottleneckNodes(5);
+
+        assertNotNull(bottlenecks);
+        // 总经理审批和部门经理审批应该是瓶颈
+        assertTrue(bottlenecks.size() >= 1);
+        assertTrue(bottlenecks.stream().allMatch(NodeDurationVO::getIsBottleneck));
+    }
+
+    // ========== Helper methods ==========
+
+    private Map<String, Object> createTrendRow(String date, long count, double avg, double max, double min) {
+        Map<String, Object> row = new HashMap<>();
+        row.put("stat_date", date);
+        row.put("completed_count", count);
+        row.put("avg_duration_seconds", avg);
+        row.put("max_duration_seconds", max);
+        row.put("min_duration_seconds", min);
+        return row;
+    }
+
+    private Map<String, Object> createNodeRow(String nodeId, String nodeName,
+                                               double avgSec, double maxSec, double minSec, int count) {
+        Map<String, Object> row = new HashMap<>();
+        row.put("node_id", nodeId);
+        row.put("node_name", nodeName);
+        row.put("avg_duration_seconds", avgSec);
+        row.put("max_duration_seconds", maxSec);
+        row.put("min_duration_seconds", minSec);
+        row.put("approval_count", count);
+        return row;
+    }
+
+    private Map<String, Object> createTimeoutRow(Long id, String instanceId, String processName,
+                                                   String title, String initiator, String nodeName,
+                                                   String assignee, double hours) {
+        Map<String, Object> row = new HashMap<>();
+        row.put("id", id);
+        row.put("instance_id", instanceId);
+        row.put("process_name", processName);
+        row.put("title", title);
+        row.put("initiator_name", initiator);
+        row.put("current_node_name", nodeName);
+        row.put("current_assignee_name", assignee);
+        row.put("started_at", Timestamp.valueOf(LocalDateTime.now().minusHours((long) hours)));
+        row.put("status", "running");
+        row.put("priority", 0);
+        row.put("duration_hours", hours);
+        return row;
+    }
+
+    private Map<String, Object> createDefinitionRow(Long defId, String name, String key,
+                                                      int total, int running, int completed,
+                                                      int rejected, int terminated,
+                                                      double avgSec, double maxSec, double minSec) {
+        Map<String, Object> row = new HashMap<>();
+        row.put("definition_id", defId);
+        row.put("process_name", name);
+        row.put("process_key", key);
+        row.put("total_instances", total);
+        row.put("running_count", running);
+        row.put("completed_count", completed);
+        row.put("rejected_count", rejected);
+        row.put("terminated_count", terminated);
+        row.put("avg_duration_seconds", avgSec);
+        row.put("max_duration_seconds", maxSec);
+        row.put("min_duration_seconds", minSec);
+        return row;
+    }
+}