graph TB
    subgraph "前端层"
        A[智能文件选择器] --> B[分批处理引擎]
        B --> C[后台处理监控]
        C --> D[实时进度展示]
    end

    subgraph "后端服务层"
        E[批量上传接口] --> F[异步处理服务]
        F --> G[并行文件处理器]
        G --> H[认证缓存管理]
    end

    subgraph "数据存储层"
        I[Redis缓存] --> J[批次状态管理]
        K[MySQL数据库] --> L[文件信息存储]
    end

    subgraph "实时通信层"
        M[WebSocket服务] --> N[进度推送]
        N --> O[状态同步]
    end

    subgraph "第三方服务"
        P[文件解析服务] --> Q[认证服务]
    end

    A --> E
    F --> I
    F --> K
    F --> M
    G --> P
    H --> Q
    M --> D

// 智能文件选择逻辑
const handleFileChange = (event) => {
  const files = Array.from(event.target.files);
  const currentCount = fileList.value.length;
  const availableSlots = props.limit - currentCount;

  if (files.length > availableSlots) {
    if (availableSlots <= 0) {
      ElMessage.warning(`已达到文件数量上限${props.limit}个`);
      return;
    } else {
      // 智能截取：只选择前面的文件
      const originalCount = files.length;
      files.splice(availableSlots);
      ElMessage.info(
        `已自动选择前${availableSlots}个文件，忽略了${originalCount - availableSlots}个文件`
      );
    }
  }

  // 添加到文件列表
  files.forEach(file => {
    fileList.value.push({
      originalFile: file,
      name: file.name,
      size: file.size,
      status: 'ready',
      percentage: 0
    });
  });

  emit('change', fileList.value);
};

// 分批处理核心逻辑
const handleBatchUpload = async () => {
  // 设置上传状态，防止对话框关闭时清空文件列表
  batchUploading.value = true;

  try {
    // 保存总文件数
    currentProcessingTotalFiles.value = pendingFiles.value.length;

    // 计算批次数量
    const batchSize = 100;
    totalBatches.value = Math.ceil(pendingFiles.value.length / batchSize);

    ElMessage.success(`开始分批处理，共 ${totalBatches.value} 个批次`);

    // 关闭文件选择对话框，显示进度框
    open.value = false;
    showBatchProgress.value = true;

    // 逐批处理文件
    for (let i = 0; i < totalBatches.value; i++) {
      await processBatch(i);

      // 批次间延迟，确保系统稳定
      if (i < totalBatches.value - 1) {
        console.log(`批次 ${i + 1} 完成，等待3秒后开始下一批次...`);
        await new Promise(resolve => setTimeout(resolve, 3000));
      }
    }

    // 处理完成统计
    const successBatches = batchResults.value.filter(
      b => ['SUCCESS', 'PARTIAL_SUCCESS'].includes(b.status)
    ).length;

    if (successBatches === totalBatches.value) {
      ElMessage.success('所有批次处理完成！');
    } else {
      ElMessage.warning(`处理完成，成功批次: ${successBatches}`);
    }

  } catch (error) {
    ElMessage.error('批量处理失败: ' + error.message);
  } finally {
    batchUploading.value = false;
    // 清空文件列表
    pendingFiles.value = [];
  }
};

// 后台处理状态管理
const backgroundProcessing = ref(false);
const backgroundResults = ref({
  totalFiles: 0,
  successCount: 0,
  failedCount: 0,
  completedBatches: 0,
  totalBatches: 0
});

// 进度框关闭处理
const handleBatchProgressClose = (visible) => {
  if (!visible) {
    showBatchProgress.value = false;
    progressDialogClosedByUser.value = true;

    // 如果批次还在进行中，启用后台处理
    if (batchProgress.value &&
        ['SUBMITTED', 'PROCESSING'].includes(batchProgress.value.status)) {
      backgroundProcessing.value = true;

      backgroundResults.value = {
        totalFiles: currentProcessingTotalFiles.value,
        successCount: 0,
        failedCount: 0,
        completedBatches: batchResults.value.filter(
          b => ['SUCCESS', 'FAILED', 'PARTIAL_SUCCESS'].includes(b.status)
        ).length,
        totalBatches: totalBatches.value
      };

      ElMessage.info('批量处理已转入后台执行，完成后将通知您结果');
    }
  }
};

// 后台处理完成通知
const showBackgroundCompletionNotification = () => {
  const { totalFiles, successCount, failedCount } = backgroundResults.value;
  const successRate = totalFiles > 0 ?
    ((successCount / totalFiles) * 100).toFixed(1) : '0.0';

  ElNotification({
    title: '批量文件处理完成',
    message: `
      <div style="line-height: 1.5;">
        <p><strong>处理结果：</strong></p>
        <p>📁 总文件数：${totalFiles} 个</p>
        <p>✅ 成功处理：${successCount} 个</p>
        <p>❌ 处理失败：${failedCount} 个</p>
        <p>📊 成功率：${successRate}%</p>
      </div>
    `,
    dangerouslyUseHTMLString: true,
    type: successCount === totalFiles ? 'success' :
          (successCount > 0 ? 'warning' : 'error'),
    duration: 8000,
    position: 'top-right'
  });

  backgroundProcessing.value = false;
  getList(); // 刷新列表
};

@Service
@Slf4j
public class AsyncBatchProcessService {

    @Autowired
    private IThsBaseProjectService thsBaseProjectService;

    @Autowired
    private IThsParsingService thsParsingService;

    @Autowired
    private BatchProcessManager batchProcessManager;

    // 并发控制：最多同时处理30个文件
    private final Semaphore parsingSemaphore = new Semaphore(30);

    /**
     * 异步并行处理批量文件
     */
    @Async("threadPoolTaskExecutor")
    public void processBatchAsync(String batchId, TempFileInfo[] tempFiles,
                                  String areaId, String userId) {
        try {
            log.info("开始异步并行处理批次: {}, 用户ID: {}, 文件数量: {}",
                    batchId, userId, tempFiles.length);

            // 更新批次状态为处理中
            batchProcessManager.updateBatchStatus(batchId, "PROCESSING",
                    "正在并行处理文件...");

            // 获取批次进度信息
            BatchUploadParseVO batchProgress = batchProcessManager.getBatchProgress(batchId);
            if (batchProgress == null) {
                log.error("无法获取批次进度信息: {}", batchId);
                return;
            }

            // 🚀 核心优化：并行处理所有文件
            Arrays.stream(tempFiles)
                    .parallel()  // 启用并行流
                    .forEach(tempFileInfo -> {
                        try {
                            // 获取信号量，控制并发数
                            parsingSemaphore.acquire();

                            // 检查批次是否被取消
                            BatchUploadParseVO currentProgress =
                                    batchProcessManager.getBatchProgress(batchId);
                            if (currentProgress == null ||
                                "CANCELLED".equals(currentProgress.getStatus())) {
                                log.info("批次 {} 已被取消，跳过文件处理: {}",
                                        batchId, tempFileInfo.getOriginalFileName());
                                return;
                            }

                            // 跳过创建临时文件失败的文件
                            if (tempFileInfo == null) {
                                log.warn("跳过处理失败的文件: tempFileInfo为null");
                                return;
                            }

                            // 找到对应的文件结果对象
                            FileProcessResult fileResult =
                                    findFileResult(currentProgress, tempFileInfo);
                            if (fileResult != null) {
                                log.info("开始并行处理文件: {}",
                                        tempFileInfo.getOriginalFileName());
                                // 异步处理单个文件
                                processSingleFileAsync(batchId, tempFileInfo,
                                                     areaId, fileResult, userId);
                            }

                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                            log.error("处理文件时被中断: {}",
                                    tempFileInfo.getOriginalFileName());
                        } catch (Exception e) {
                            log.error("处理文件异常: {}, 错误: {}",
                                    tempFileInfo.getOriginalFileName(), e.getMessage());
                        } finally {
                            parsingSemaphore.release();
                        }
                    });

            // 等待所有文件处理完成后检查最终状态
            checkAndUpdateFinalStatus(batchId);

        } catch (Exception e) {
            log.error("批量处理异常，批次ID: {}, 错误: {}", batchId, e.getMessage(), e);
            batchProcessManager.updateBatchStatus(batchId, "FAILED",
                    "批次处理异常: " + e.getMessage());
        }
    }

    /**
     * 检查并更新批次最终状态
     */
    private void checkAndUpdateFinalStatus(String batchId) {
        try {
            // 等待一段时间让所有异步任务完成
            Thread.sleep(3000);

            BatchUploadParseVO batchProgress =
                    batchProcessManager.getBatchProgress(batchId);
            if (batchProgress == null) {
                return;
            }

            // 统计处理结果
            long totalFiles = batchProgress.getTotalFiles();
            long successCount = batchProgress.getSuccessFiles().stream()
                    .filter(f -> "SUCCESS".equals(f.getStatus()))
                    .count();
            long failedCount = batchProgress.getSuccessFiles().stream()
                    .filter(f -> Arrays.asList("FAILED", "PARSE_FAILED", "PARSE_TIMEOUT")
                                       .contains(f.getStatus()))
                    .count();

            // 更新最终状态
            if (failedCount == 0 && successCount == totalFiles) {
                batchProcessManager.updateBatchStatus(batchId, "SUCCESS",
                        "所有文件处理成功");
            } else if (successCount > 0) {
                batchProcessManager.updateBatchStatus(batchId, "PARTIAL_SUCCESS",
                        String.format("部分文件处理成功，成功: %d, 失败: %d",
                                    successCount, failedCount));
            } else {
                batchProcessManager.updateBatchStatus(batchId, "FAILED",
                        "所有文件处理失败");
            }

        } catch (Exception e) {
            log.error("检查批次最终状态失败: {}", batchId, e);
        }
    }
}

@Component
@ConfigurationProperties("parsing-service")
public class ParsingServiceConfig {

    // 创建缓存，默认5分钟过期
    private TimedCache<String, String> timedCache;

    // 用于同步获取token的锁对象
    private final Object tokenLock = new Object();

    /**
     * 获取授权（优化并发访问）
     * 🚀 核心优化：双重检查锁定 + 缓存机制
     */
    public String getAuthToken() {
        // 第一次检查：快速路径，无锁检查缓存
        if (timedCache.containsKey(userId)) {
            String cachedToken = timedCache.get(userId, false);
            if (cachedToken != null) {
                log.debug("从缓存获取token成功");
                return cachedToken;
            }
        }

        // 使用同步块确保只有一个线程去获取token
        synchronized (tokenLock) {
            // 第二次检查：在锁内再次检查缓存
            if (timedCache.containsKey(userId)) {
                String cachedToken = timedCache.get(userId, false);
                if (cachedToken != null) {
                    log.debug("在同步块中从缓存获取token成功");
                    return cachedToken;
                }
            }

            // 缓存中确实没有token，开始获取新token
            log.info("缓存中无有效token，开始向第三方服务获取新token");
            TimeInterval timer = DateUtil.timer();

            try {
                // 获取加密后的密码
                String encryptedData = encryptionPassWord();

                // 构建请求参数
                Map<String, Object> params = new HashMap<>();
                params.put("userId", userId);
                params.put("password", encryptedData);

                // 发起 HTTP 请求
                String resultData = HttpUtil.post(apiUrl + authorizeApi, params);
                if (resultData == null || resultData.isEmpty()) {
                    log.error("认证请求返回空数据");
                    return null;
                }

                // 解析返回的 JSON 数据
                JSONObject resultJson = JSONUtil.parseObj(resultData);
                if (!resultJson.containsKey("code") ||
                    !resultJson.get("code").equals(200)) {
                    log.error("获取 token 失败，返回数据: {}", resultData);
                    return null;
                }

                // 获取 token 并缓存
                String token = resultJson.get("data").toString();
                if (ObjectUtil.isEmpty(token)) {
                    log.error("返回的 token 为空");
                    return null;
                }

                // 将 token 存入缓存
                timedCache.put(userId, token);
                log.info("成功获取并缓存新token，耗时：{} 毫秒", timer.intervalMs());
                return token;

            } catch (Exception e) {
                log.error("获取认证异常：{}", e.getMessage(), e);
                return null;
            }
        }
    }
}

@Configuration
public class ThreadPoolConfig {

    @Value("${thread.pool.corePoolSize:50}")
    private int corePoolSize;

    @Value("${thread.pool.maxPoolSize:200}")
    private int maxPoolSize;

    @Value("${thread.pool.queueCapacity:1000}")
    private int queueCapacity;

    @Value("${thread.pool.keepAliveSeconds:300}")
    private int keepAliveSeconds;

    /**
     * 高性能线程池配置
     */
    @Bean(name = "threadPoolTaskExecutor")
    public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

        // 核心配置
        executor.setCorePoolSize(corePoolSize);           // 核心线程数：50
        executor.setMaxPoolSize(maxPoolSize);             // 最大线程数：200
        executor.setQueueCapacity(queueCapacity);         // 队列容量：1000
        executor.setKeepAliveSeconds(keepAliveSeconds);   // 空闲时间：5分钟

        // 优化配置
        executor.setThreadNamePrefix("BatchProcess-");    // 线程命名前缀
        executor.setRejectedExecutionHandler(            // 拒绝策略
                new ThreadPoolExecutor.CallerRunsPolicy());
        executor.setWaitForTasksToCompleteOnShutdown(true); // 优雅关闭
        executor.setAwaitTerminationSeconds(60);         // 等待时间

        executor.initialize();
        return executor;
    }
}

@Component
@Slf4j
public class BatchProcessWebSocketHandler {

    @Autowired
    private SimpMessagingTemplate messagingTemplate;

    /**
     * 推送批次进度更新
     */
    public void sendBatchProgressUpdate(String userId, BatchUploadParseVO batchProgress) {
        try {
            String destination = "/user/" + userId + "/queue/batch-progress";
            messagingTemplate.convertAndSend(destination, batchProgress);
            log.debug("推送批次进度更新到用户: {}, 批次ID: {}", userId, batchProgress.getBatchId());
        } catch (Exception e) {
            log.error("推送批次进度失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 推送文件处理进度
     */
    public void sendFileProgressUpdate(String userId, FileProgressUpdate fileUpdate) {
        try {
            String destination = "/user/" + userId + "/queue/file-progress";
            messagingTemplate.convertAndSend(destination, fileUpdate);
            log.debug("推送文件进度更新到用户: {}, 文件: {}",
                     userId, fileUpdate.getFileResult().getFileName());
        } catch (Exception e) {
            log.error("推送文件进度失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 推送批次完成通知
     */
    public void sendBatchCompletionNotification(String userId,
                                               BatchCompletionNotification notification) {
        try {
            String destination = "/user/" + userId + "/queue/batch-completion";
            messagingTemplate.convertAndSend(destination, notification);
            log.info("推送批次完成通知到用户: {}, 成功: {}, 失败: {}",
                    userId, notification.getSuccessCount(), notification.getFailedCount());
        } catch (Exception e) {
            log.error("推送批次完成通知失败: {}", e.getMessage(), e);
        }
    }
}

// WebSocket配置
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        // 启用简单消息代理
        config.enableSimpleBroker("/queue", "/topic");
        // 设置应用程序目标前缀
        config.setApplicationDestinationPrefixes("/app");
        // 设置用户目标前缀
        config.setUserDestinationPrefix("/user");
    }

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        // 注册STOMP端点
        registry.addEndpoint("/ws")
                .setAllowedOriginPatterns("*")
                .withSockJS();
    }
}

@Service
public class BatchProcessManager {

    @Autowired
    private RedisCache redisCache;

    private static final String BATCH_PROGRESS_KEY = "batch:progress:";

    /**
     * 保存批次进度到Redis
     */
    public void saveBatchProgress(String batchId, BatchUploadParseVO batchProgress) {
        try {
            String key = BATCH_PROGRESS_KEY + batchId;
            redisCache.setCacheObject(key, batchProgress, 24, TimeUnit.HOURS);
            log.info("批次进度已保存到Redis，批次ID: {}", batchId);
        } catch (Exception e) {
            log.error("保存批次进度到Redis失败: {}", e.getMessage(), e);
            throw new RuntimeException("保存批次进度失败", e);
        }
    }

    /**
     * 从Redis获取批次进度
     */
    public BatchUploadParseVO getBatchProgress(String batchId) {
        try {
            String key = BATCH_PROGRESS_KEY + batchId;
            return redisCache.getCacheObject(key);
        } catch (Exception e) {
            log.error("从Redis获取批次进度失败: {}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * 更新批次状态
     */
    public void updateBatchStatus(String batchId, String status, String message) {
        BatchUploadParseVO batchProgress = getBatchProgress(batchId);
        if (batchProgress != null) {
            batchProgress.setStatus(status);
            batchProgress.setMessage(message);
            batchProgress.setUpdateTime(new Date());

            // 保存到Redis
            saveBatchProgress(batchId, batchProgress);

            // 推送WebSocket消息
            webSocketHandler.sendBatchProgressUpdate(
                    batchProgress.getUserId(), batchProgress);
        }
    }
}

// 1. 并行流处理
Arrays.stream(tempFiles)
        .parallel()  // 🚀 启用并行处理
        .forEach(tempFileInfo -> {
            // 处理逻辑
        });

// 2. 信号量控制并发数
private final Semaphore parsingSemaphore = new Semaphore(30);

// 3. 异步方法配置
@Async("threadPoolTaskExecutor")
public void processBatchAsync(...) {
    // 异步处理逻辑
}

public String getAuthToken() {
    // 第一次检查：无锁快速路径
    if (timedCache.containsKey(userId)) {
        return timedCache.get(userId, false);
    }

    // 同步块：确保只有一个线程获取token
    synchronized (tokenLock) {
        // 第二次检查：防止重复获取
        if (timedCache.containsKey(userId)) {
            return timedCache.get(userId, false);
        }

        // 真正的token获取逻辑
        String token = fetchTokenFromThirdParty();
        timedCache.put(userId, token);
        return token;
    }
}

// 1. 及时释放大文件引用
private void cleanupTempFiles(TempFileInfo[] tempFiles) {
    for (TempFileInfo tempFile : tempFiles) {
        if (tempFile != null && tempFile.getTempFile() != null) {
            try {
                Files.deleteIfExists(tempFile.getTempFile().toPath());
            } catch (IOException e) {
                log.warn("删除临时文件失败: {}", tempFile.getOriginalFileName());
            }
        }
    }
}

// 2. Redis缓存自动过期
redisCache.setCacheObject(key, batchProgress, 24, TimeUnit.HOURS);

// 3. 线程池合理配置
executor.setCorePoolSize(50);    // 核心线程数
executor.setMaxPoolSize(200);    // 最大线程数
executor.setQueueCapacity(1000); // 队列容量

# application.yml
server:
  port: 8080
  servlet:
    context-path: /api

spring:
  # 数据库配置
  datasource:
    url: jdbc:mysql://localhost:3306/cost_db?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8
    username: ${DB_USERNAME:root}
    password: ${DB_PASSWORD:password}
    driver-class-name: com.mysql.cj.jdbc.Driver
    hikari:
      maximum-pool-size: 50
      minimum-idle: 10
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000

  # Redis配置
  redis:
    host: ${REDIS_HOST:localhost}
    port: ${REDIS_PORT:6379}
    password: ${REDIS_PASSWORD:}
    database: 0
    timeout: 5000ms
    lettuce:
      pool:
        max-active: 50
        max-idle: 20
        min-idle: 5
        max-wait: 3000ms

  # 文件上传配置
  servlet:
    multipart:
      max-file-size: 2GB
      max-request-size: 10GB
      enabled: true

# 线程池配置
thread:
  pool:
    corePoolSize: 50
    maxPoolSize: 200
    queueCapacity: 1000
    keepAliveSeconds: 300

# 第三方服务配置
parsing-service:
  api-url: ${PARSING_API_URL:<http://external-service.com>}
  user-id: ${PARSING_USER_ID:your_user_id}
  password: ${PARSING_PASSWORD:your_password}
  authorize-api: /api/auth/login
  parse-api: /api/parse/file

# 日志配置
logging:
  level:
    com.thsware.business.service.AsyncBatchProcessService: INFO
    com.thsware.business.config.ParsingServiceConfig: INFO
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"

# Dockerfile
FROM openjdk:17-jdk-slim

# 设置工作目录
WORKDIR /app

# 复制jar包
COPY target/cost-db-management-*.jar app.jar

# 设置JVM参数
ENV JAVA_OPTS="-Xms2g -Xmx8g -XX:+UseG1GC -XX:MaxGCPauseMillis=200"

# 暴露端口
EXPOSE 8080

# 启动应用
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar app.jar"]

# docker-compose.yml
version: '3.8'

services:
  # 应用服务
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      - DB_HOST=mysql
      - DB_USERNAME=root
      - DB_PASSWORD=password
      - REDIS_HOST=redis
      - REDIS_PORT=6379
    depends_on:
      - mysql
      - redis
    volumes:
      - ./logs:/app/logs
      - ./uploads:/app/uploads

  # MySQL数据库
  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: cost_db
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql

  # Redis缓存
  redis:
    image: redis:7.0-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data

  # Nginx反向代理
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./ssl:/etc/nginx/ssl
    depends_on:
      - app

volumes:
  mysql_data:
  redis_data:

# nginx.conf
events {
    worker_connections 1024;
}

http {
    upstream backend {
        server app:8080;
    }

    # WebSocket支持
    map $http_upgrade $connection_upgrade {
        default upgrade;
        '' close;
    }

    server {
        listen 80;
        server_name your-domain.com;

        # 文件上传大小限制
        client_max_body_size 10G;

        # API代理
        location /api/ {
            proxy_pass <http://backend>;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;

            # 超时配置
            proxy_connect_timeout 60s;
            proxy_send_timeout 300s;
            proxy_read_timeout 300s;
        }

        # WebSocket代理
        location /ws/ {
            proxy_pass <http://backend>;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection $connection_upgrade;
            proxy_set_header Host $host;
            proxy_cache_bypass $http_upgrade;
        }

        # 静态文件
        location / {
            root /usr/share/nginx/html;
            index index.html;
            try_files $uri $uri/ /index.html;
        }
    }
}

@Component
public class BatchProcessMonitor {

    private final MeterRegistry meterRegistry;
    private final Counter batchCounter;
    private final Timer batchTimer;
    private final Gauge activeThreads;

    public BatchProcessMonitor(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;

        // 批次处理计数器
        this.batchCounter = Counter.builder("batch.process.count")
                .description("批量处理计数")
                .register(meterRegistry);

        // 批次处理耗时
        this.batchTimer = Timer.builder("batch.process.duration")
                .description("批量处理耗时")
                .register(meterRegistry);

        // 活跃线程数
        this.activeThreads = Gauge.builder("batch.process.active.threads")
                .description("活跃处理线程数")
                .register(meterRegistry, this, BatchProcessMonitor::getActiveThreadCount);
    }

    public void recordBatchStart(String batchId) {
        batchCounter.increment();
        log.info("批次开始监控: {}", batchId);
    }

    public void recordBatchComplete(String batchId, Duration duration) {
        batchTimer.record(duration);
        log.info("批次完成监控: {}, 耗时: {}ms", batchId, duration.toMillis());
    }

    private double getActiveThreadCount() {
        ThreadPoolTaskExecutor executor =
                (ThreadPoolTaskExecutor) applicationContext.getBean("threadPoolTaskExecutor");
        return executor.getActiveCount();
    }
}

# Prometheus + Grafana监控配置
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
  endpoint:
    health:
      show-details: always
    metrics:
      enabled: true
  metrics:
    export:
      prometheus:
        enabled: true
    distribution:
      percentiles-histogram:
        http.server.requests: true
        batch.process.duration: true

@Slf4j
public class BatchProcessLogger {

    public void logBatchStart(String batchId, String userId, int fileCount) {
        log.info("批次处理开始 - batchId: {}, userId: {}, fileCount: {}, timestamp: {}",
                batchId, userId, fileCount, Instant.now());
    }

    public void logFileProcessed(String batchId, String fileName, String status, long duration) {
        log.info("文件处理完成 - batchId: {}, fileName: {}, status: {}, duration: {}ms",
                batchId, fileName, status, duration);
    }

    public void logBatchComplete(String batchId, int successCount, int failedCount, long totalDuration) {
        log.info("批次处理完成 - batchId: {}, success: {}, failed: {}, totalDuration: {}ms",
                batchId, successCount, failedCount, totalDuration);
    }

    public void logError(String batchId, String operation, Exception error) {
        log.error("批次处理错误 - batchId: {}, operation: {}, error: {}",
                batchId, operation, error.getMessage(), error);
    }
}

# alerting-rules.yml
groups:
  - name: batch-processing-alerts
    rules:
      # 批次处理失败率告警
      - alert: BatchProcessingFailureRate
        expr: rate(batch_process_failed_total[5m]) / rate(batch_process_total[5m]) > 0.1
        for: 2m
        labels:
          severity: warning
        annotations:
          summary: "批次处理失败率过高"
          description: "过去5分钟批次处理失败率超过10%"

      # 线程池使用率告警
      - alert: ThreadPoolUtilization
        expr: batch_process_active_threads / batch_process_max_threads > 0.8
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "线程池使用率过高"
          description: "线程池使用率超过80%，可能影响性能"

      # Redis连接异常告警
      - alert: RedisConnectionFailure
        expr: redis_connected_clients == 0
        for: 30s
        labels:
          severity: critical
        annotations:
          summary: "Redis连接失败"
          description: "Redis连接中断，批次状态管理受影响"

// ✅ 正确的异步方法实现
@Async("threadPoolTaskExecutor")
public CompletableFuture<String> processFileAsync(String fileId, String userId) {
    try {
        // 在主线程中获取用户信息，传递给异步方法
        String result = doProcessFile(fileId, userId);
        return CompletableFuture.completedFuture(result);
    } catch (Exception e) {
        log.error("文件处理失败: {}", fileId, e);
        return CompletableFuture.failedFuture(e);
    }
}

// ❌ 错误的做法：在异步方法中获取用户信息
@Async("threadPoolTaskExecutor")
public void processFileAsyncWrong(String fileId) {
    // 这样会失败，因为SecurityContext在异步线程中不可用
    String userId = SecurityUtils.getUserId(); // ❌
}

public class BatchErrorHandler {

    public void handleFileError(String batchId, FileProcessResult fileResult, Exception error) {
        if (error instanceof TimeoutException) {
            // 超时错误 - 可重试
            handleRetryableError(batchId, fileResult, error);
        } else if (error instanceof SecurityException) {
            // 安全错误 - 不可重试
            handleFatalError(batchId, fileResult, error);
        } else {
            // 一般错误 - 记录并继续
            handleGeneralError(batchId, fileResult, error);
        }
    }

    private void handleRetryableError(String batchId, FileProcessResult fileResult, Exception error) {
        if (fileResult.getRetryCount() < 3) {
            fileResult.setRetryCount(fileResult.getRetryCount() + 1);
            scheduleRetry(batchId, fileResult);
        } else {
            markAsFailed(batchId, fileResult, "重试次数超限");
        }
    }
}

# JVM参数优化
JAVA_OPTS="-Xms4g -Xmx8g \\
           -XX:+UseG1GC \\
           -XX:MaxGCPauseMillis=200 \\
           -XX:+HeapDumpOnOutOfMemoryError \\
           -XX:HeapDumpPath=/app/logs/heapdump.hprof"

# 系统参数优化
echo 'vm.max_map_count=262144' >> /etc/sysctl.conf
echo 'fs.file-max=1000000' >> /etc/sysctl.conf
ulimit -n 65536

@Component
public class FileSecurityValidator {

    private static final Set<String> ALLOWED_EXTENSIONS = Set.of(".xml", ".swt");
    private static final long MAX_FILE_SIZE = 2L * 1024 * 1024 * 1024; // 2GB

    public boolean validateFile(MultipartFile file) {
        // 1. 文件名验证
        String fileName = file.getOriginalFilename();
        if (fileName == null || fileName.contains("..")) {
            return false;
        }

        // 2. 扩展名验证
        String extension = getFileExtension(fileName).toLowerCase();
        if (!ALLOWED_EXTENSIONS.contains(extension)) {
            return false;
        }

        // 3. 文件大小验证
        if (file.getSize() > MAX_FILE_SIZE) {
            return false;
        }

        // 4. 文件头验证
        return validateFileHeader(file);
    }

    private boolean validateFileHeader(MultipartFile file) {
        try {
            byte[] header = new byte[8];
            file.getInputStream().read(header);
            return isValidFileHeader(header);
        } catch (IOException e) {
            return false;
        }
    }
}

<!-- 动态标题显示当前批次 -->
<el-dialog :title="dialogTitle" width="800px">
  <!-- 批次信息标签 -->
  <el-tag type="info" size="small" v-if="totalBatches > 1">
    正在处理第 {{ currentBatch }} 批，共 {{ totalBatches }} 批
  </el-tag>
</el-dialog>

// 动态标题计算
const dialogTitle = computed(() => {
  if (props.totalBatches > 1) {
    return `批量处理进度 - 第 ${props.currentBatch}/${props.totalBatches} 批`
  }
  return '批量处理进度'
})

<!-- 根据批次数量显示不同的取消按钮 -->
<template v-if="canCancel">
  <el-button v-if="totalBatches > 1" type="warning" @click="cancelBatch">
    取消当前批次
  </el-button>
  <el-button v-if="totalBatches > 1" type="danger" @click="cancelAllBatches">
    取消所有批次
  </el-button>
  <el-button v-if="totalBatches <= 1" type="danger" @click="cancelBatch">
    取消处理
  </el-button>
</template>

// 计算所有批次的整体文件统计
const calculateOverallStats = () => {
  let totalFiles = 0;
  let successFiles = 0;
  let failedFiles = 0;

  batchResults.value.forEach(batch => {
    if (batch.result && batch.result.successFiles) {
      const batchFiles = batch.result.successFiles;
      totalFiles += batchFiles.length;

      batchFiles.forEach(file => {
        if (['SUCCESS', 'PARSE_SUCCESS'].includes(file.status)) {
          successFiles++;
        } else if (['FAILED', 'PARSE_FAILED', 'PARSE_TIMEOUT'].includes(file.status)) {
          failedFiles++;
        }
      });
    }
  });

  return { totalFiles, successFiles, failedFiles };
};

// 显示整体统计信息
if (overallStats.failedFiles === 0) {
  ElMessage.success(`所有文件处理完成！总计 ${overallStats.totalFiles} 个文件全部成功`);
} else if (overallStats.successFiles > 0) {
  const successRate = ((overallStats.successFiles / overallStats.totalFiles) * 100).toFixed(1);
  ElMessage.warning(`批量处理完成！总计 ${overallStats.totalFiles} 个文件，成功 ${overallStats.successFiles} 个，失败 ${overallStats.failedFiles} 个，成功率 ${successRate}%`);
}

// 智能完成判断：不仅检查状态，还检查文件处理情况
const checkIfBatchReallyComplete = (progress) => {
  if (progress.status === 'CANCELLED') {
    return true;
  }

  // 检查是否还有文件在处理中
  if (progress.successFiles && Array.isArray(progress.successFiles)) {
    const processingCount = progress.successFiles.filter(file =>
      ['UPLOADING', 'PARSING', 'PENDING'].includes(file.status)
    ).length;

    // 如果还有文件在处理中，说明没有真正完成
    if (processingCount > 0) {
      return false;
    }
  }

  return ['SUCCESS', 'FAILED', 'PARTIAL_SUCCESS'].includes(progress.status);
};

// 修复过早完成的问题
if (['SUCCESS', 'FAILED', 'CANCELLED', 'PARTIAL_SUCCESS'].includes(progress.status)) {
  if (isReallyComplete) {
    console.log(`批次真正完成，状态: ${progress.status}`);
    return; // 确认完成后才返回
  } else {
    console.log(`收到完成状态但还有文件在处理中，继续等待...`);
    // 继续轮询，不返回
  }
}

// 改进统计处理结果的逻辑
List<BatchUploadParseVO.FileProcessResult> allFiles = batchProgress.getSuccessFiles();
if (allFiles == null) {
    allFiles = new ArrayList<>();
}

long successCount = allFiles.stream()
        .filter(f -> "SUCCESS".equals(f.getStatus()) || "PARSE_SUCCESS".equals(f.getStatus()))
        .count();
long failedCount = allFiles.stream()
        .filter(f -> "FAILED".equals(f.getStatus()) ||
                "PARSE_FAILED".equals(f.getStatus()) ||
                "PARSE_TIMEOUT".equals(f.getStatus()))
        .count();

// 统计其他状态的文件
long otherCount = allFiles.stream()
        .filter(f -> !Arrays.asList("SUCCESS", "PARSE_SUCCESS", "FAILED", "PARSE_FAILED",
                                   "PARSE_TIMEOUT", "UPLOADING", "PARSING", "PENDING")
                           .contains(f.getStatus()))
        .count();

// 详细的状态分布日志
if (otherCount > 0 || allFiles.size() != totalFiles) {
    Map<String, Long> statusCount = allFiles.stream()
            .collect(Collectors.groupingBy(
                    f -> f.getStatus() != null ? f.getStatus() : "NULL",
                    Collectors.counting()));
    log.warn("批次 {} 存在异常状态，文件状态分布: {}", batchId, statusCount);
}

// 改进最终状态判断逻辑
long processedCount = successCount + failedCount;

if (processedCount == 0) {
    batchProcessManager.updateBatchStatus(batchId, "FAILED",
            String.format("批次处理异常，无文件状态更新。总文件: %d, 实际文件: %d", totalFiles, allFiles.size()));
} else if (failedCount == 0 && successCount == totalFiles) {
    batchProcessManager.updateBatchStatus(batchId, "SUCCESS", "所有文件处理成功");
} else if (successCount > 0 && failedCount > 0) {
    batchProcessManager.updateBatchStatus(batchId, "PARTIAL_SUCCESS",
            String.format("部分文件处理成功，成功: %d, 失败: %d", successCount, failedCount));
} else if (successCount == 0 && failedCount > 0) {
    batchProcessManager.updateBatchStatus(batchId, "FAILED",
            String.format("所有文件处理失败，失败: %d", failedCount));
}

// 线程安全的公钥内容获取方法
private String getPublicKeyContent() {
    // 第一次检查：快速路径，无锁检查缓存
    if (cachedPublicKeyContent != null) {
        return cachedPublicKeyContent;
    }

    // 使用同步块确保只有一个线程去加载公钥
    synchronized (publicKeyLock) {
        // 第二次检查：在锁内再次检查缓存
        if (cachedPublicKeyContent != null) {
            return cachedPublicKeyContent;
        }

        try {
            // 首先尝试从classpath加载
            publicKeyContent = ResourceUtil.readUtf8Str(publicKey);
        } catch (Exception e) {
            // 如果失败，尝试从当前线程的类加载器加载
            ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
            try (InputStream inputStream = contextClassLoader.getResourceAsStream(publicKey)) {
                if (inputStream != null) {
                    publicKeyContent = IoUtil.readUtf8(inputStream);
                } else {
                    throw new RuntimeException("无法找到公钥文件: " + publicKey);
                }
            }
        }

        // 缓存公钥内容
        cachedPublicKeyContent = publicKeyContent;
        return cachedPublicKeyContent;
    }
}

// 应用启动时预加载公钥
@EventListener(ApplicationReadyEvent.class)
public void preloadPublicKey() {
    try {
        log.info("应用启动完成，开始预加载公钥文件...");
        getPublicKeyContent(); // 触发公钥加载和缓存
        log.info("公钥文件预加载完成");
    } catch (Exception e) {
        log.error("预加载公钥文件失败，将在运行时重试: {}", e.getMessage());
    }
}

// 添加全局取消标志
const batchProcessingCancelled = ref(false);

// 在分批处理循环中检查取消状态
for (let i = 0; i < totalBatches.value; i++) {
  // 处理前检查是否被取消
  if (batchProcessingCancelled.value) {
    console.log('批次处理已被用户取消，停止后续批次');
    ElMessage.info('批次处理已取消，停止后续批次');
    break;
  }

  await processBatch(i);

  // 处理后再次检查是否被取消
  if (batchProcessingCancelled.value) {
    console.log('批次处理已被用户取消，停止后续批次');
    ElMessage.info('批次处理已取消，停止后续批次');
    break;
  }
}

// 在取消方法中设置标志
const cancelCurrentBatch = async () => {
  const result = await cancelBatchApi(currentBatch.value.batchId);
  if (result.code === 200) {
    batchProcessingCancelled.value = true; // 停止后续批次处理
    ElMessage.success('当前批次已取消');
  }
};