Java实现Excel高性能异步导出的完整方案详解

一、方案概述

Excel高性能异步导出是解决大数据量导出时系统响应慢、内存溢出和用户体验差的关键技术方案。本方案通过异步处理机制、内存优化策略和流式写入技术，实现大数据量Excel文件的高效导出，同时保证系统的稳定性和用户体验。

二、核心挑战与解决思路

1. 主要挑战

内存溢出风险：传统POI方式一次性加载所有数据到内存
响应时间长：大数据量处理导致用户等待时间过长
服务器压力：高并发导出请求影响系统整体性能
用户体验差：同步导出过程用户无法获知进度

2. 解决思路

异步处理：将导出任务放入后台线程执行，立即返回任务ID
流式写入：采用SXSSFWorkbook等流式API，避免内存中保存全部数据
分页查询：从数据库分批获取数据，减少单次内存占用
进度跟踪：实时记录导出进度，支持进度查询
文件存储：导出文件临时存储，完成后提供下载链接

三、技术架构设计

1. 整体架构

┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│   客户端    │───▶│  导出控制器  │───▶│ 任务管理服务 │───▶│ 数据处理服务 │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘
       ▲                   ▲                   ▲                   ▲
       │                   │                   │                   │
       ▼                   ▼                   ▼                   ▼
┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│ 进度查询接口 │◀───│ 任务状态存储 │◀───│ 异步任务线程 │◀───│ 文件存储服务 │
└─────────────┘    ┌─────────────┐    └─────────────┘    └─────────────┘
                     │ 通知服务    │
                     └─────────────┘

2. 技术栈选型

核心框架：Spring Boot + Spring MVC
异步处理：Spring Async / 线程池 / 消息队列(RabbitMQ/Kafka)
Excel处理：Apache POI SXSSFWorkbook / EasyExcel
任务管理：Redis / 数据库 / Zookeeper
文件存储：本地文件系统 / OSS / 分布式文件系统
进度跟踪：Redis Counter / 数据库状态表

四、详细实现方案

1. 异步任务管理实现

任务实体设计

@Entity
@Table(name = "export_task")
public class ExportTask {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String taskId; // 唯一任务ID
    private String taskName; // 任务名称
    private String userId; // 用户ID
    private String status; // 状态: PENDING, PROCESSING, COMPLETED, FAILED
    private Integer totalRecords; // 总记录数
    private Integer processedRecords; // 已处理记录数
    private String filePath; // 文件存储路径
    private String fileName; // 文件名称
    private Date createTime;
    private Date updateTime;
    private String errorMsg; // 错误信息
    
    // getters and setters
}

任务状态枚举

public enum ExportTaskStatus {
    PENDING("待处理"),
    PROCESSING("处理中"),
    COMPLETED("已完成"),
    FAILED("失败");
    
    private String desc;
    
    ExportTaskStatus(String desc) {
        this.desc = desc;
    }
}

任务管理服务

@Service
public class ExportTaskService {
    
    @Autowired
    private ExportTaskRepository taskRepository;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    /**
     * 创建导出任务
     */
    public ExportTask createTask(String taskName, String userId) {
        ExportTask task = new ExportTask();
        task.setTaskId(generateTaskId());
        task.setTaskName(taskName);
        task.setUserId(userId);
        task.setStatus(ExportTaskStatus.PENDING.name());
        task.setCreateTime(new Date());
        task.setUpdateTime(new Date());
        
        return taskRepository.save(task);
    }
    
    /**
     * 更新任务状态
     */
    public void updateTaskStatus(String taskId, ExportTaskStatus status, 
                               Integer processedRecords, String errorMsg) {
        ExportTask task = taskRepository.findByTaskId(taskId);
        if (task != null) {
            task.setStatus(status.name());
            task.setProcessedRecords(processedRecords != null ? processedRecords : task.getProcessedRecords());
            task.setErrorMsg(errorMsg);
            task.setUpdateTime(new Date());
            taskRepository.save(task);
            
            // 同时更新Redis缓存，用于快速查询
            redisTemplate.opsForHash().put("export:task:" + taskId, "status", status.name());
            redisTemplate.opsForHash().put("export:task:" + taskId, "processedRecords", 
                                          processedRecords != null ? processedRecords.toString() : "0");
        }
    }
    
    /**
     * 获取任务进度
     */
    public Map<String, Object> getTaskProgress(String taskId) {
        ExportTask task = taskRepository.findByTaskId(taskId);
        Map<String, Object> progress = new HashMap<>();
        
        if (task != null) {
            progress.put("taskId", task.getTaskId());
            progress.put("status", task.getStatus());
            progress.put("totalRecords", task.getTotalRecords());
            progress.put("processedRecords", task.getProcessedRecords());
            progress.put("progress", task.getTotalRecords() > 0 ? 
                        (task.getProcessedRecords() * 100.0 / task.getTotalRecords()) : 0);
            progress.put("fileName", task.getFileName());
            progress.put("filePath", task.getFilePath());
            progress.put("createTime", task.getCreateTime());
            progress.put("updateTime", task.getUpdateTime());
        }
        
        return progress;
    }
    
    private String generateTaskId() {
        return UUID.randomUUID().toString().replace("-", "");
    }
}

2. 异步导出控制器

@RestController
@RequestMapping("/api/export")
public class ExportController {
    
    @Autowired
    private ExportTaskService taskService;
    
    @Autowired
    private ExcelExportService excelExportService;
    
    /**
     * 发起异步导出请求
     */
    @PostMapping("/async")
    public ResponseEntity<Map<String, Object>> startAsyncExport(
            @RequestBody ExportRequest request,
            HttpServletRequest httpRequest) {
        
        // 1. 创建导出任务
        String userId = getCurrentUserId(httpRequest); // 获取当前用户ID
        ExportTask task = taskService.createTask(request.getTaskName(), userId);
        
        // 2. 提交异步导出任务
        CompletableFuture.runAsync(() -> {
            try {
                excelExportService.exportToExcelAsync(request, task.getTaskId());
            } catch (Exception e) {
                taskService.updateTaskStatus(task.getTaskId(), 
                                           ExportTaskStatus.FAILED, 
                                           null, e.getMessage());
            }
        }, getExportExecutor()); // 使用专用线程池
        
        // 3. 返回任务ID，客户端可轮询进度
        Map<String, Object> response = new HashMap<>();
        response.put("taskId", task.getTaskId());
        response.put("message", "导出任务已提交，正在处理中");
        response.put("statusUrl", "/api/export/progress/" + task.getTaskId());
        
        return ResponseEntity.accepted().body(response);
    }
    
    /**
     * 查询导出进度
     */
    @GetMapping("/progress/{taskId}")
    public ResponseEntity<Map<String, Object>> getExportProgress(@PathVariable String taskId) {
        Map<String, Object> progress = taskService.getTaskProgress(taskId);
        return ResponseEntity.ok(progress);
    }
    
    /**
     * 下载导出的Excel文件
     */
    @GetMapping("/download/{taskId}")
    public ResponseEntity<Resource> downloadExcel(@PathVariable String taskId,
                                                 HttpServletRequest request) {
        // 1. 验证任务状态
        ExportTask task = taskService.getTaskByTaskId(taskId);
        if (task == null || !ExportTaskStatus.COMPLETED.name().equals(task.getStatus())) {
            throw new RuntimeException("导出任务未完成或不存在");
        }
        
        // 2. 加载文件资源
        Path filePath = Paths.get(task.getFilePath());
        Resource resource = new FileSystemResource(filePath);
        
        // 3. 构建响应头
        String contentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
        String fileName = URLEncoder.encode(task.getFileName(), StandardCharsets.UTF_8).replaceAll("\\+", "%20");
        
        return ResponseEntity.ok()
                .contentType(MediaType.parseMediaType(contentType))
                .header(HttpHeaders.CONTENT_DISPOSITION, 
                       "attachment; filename=\"" + fileName + "\"")
                .body(resource);
    }
    
    private Executor getExportExecutor() {
        // 配置专用导出线程池
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5); // 核心线程数
        executor.setMaxPoolSize(10); // 最大线程数
        executor.setQueueCapacity(50); // 队列容量
        executor.setThreadNamePrefix("excel-export-");
        executor.initialize();
        return executor;
    }
}

3. 高性能Excel导出服务（基于EasyExcel）

EasyExcel导出实现（推荐）

@Service
public class ExcelExportService {
    
    @Autowired
    private ExportTaskService taskService;
    
    @Autowired
    private DataQueryService dataQueryService;
    
    private static final int BATCH_SIZE = 1000; // 每批查询数据量
    
    /**
     * 异步导出Excel（基于EasyExcel）
     */
    public void exportToExcelAsync(ExportRequest request, String taskId) {
        try {
            // 1. 更新任务状态为处理中
            taskService.updateTaskStatus(taskId, ExportTaskStatus.PROCESSING, 0, null);
            
            // 2. 准备导出参数
            String fileName = buildFileName(request);
            String tempDir = System.getProperty("java.io.tmpdir");
            String filePath = tempDir + File.separator + fileName;
            
            // 3. 创建ExcelWriter，使用SXSSF模式（流式写入）
            try (ExcelWriter excelWriter = EasyExcel.write(filePath, request.getDataClass())
                    .registerWriteHandler(new LongestMatchColumnWidthStyleStrategy()) // 自适应列宽
                    .inMemory(false) // 开启磁盘缓存，避免OOM
                    .build()) {
                
                WriteSheet writeSheet = EasyExcel.writerSheet(request.getSheetName())
                        .head(request.getDataClass())
                        .build();
                
                // 4. 分页查询并写入数据
                int totalRecords = dataQueryService.getTotalCount(request);
                taskService.updateTaskStatus(taskId, ExportTaskStatus.PROCESSING, 0, null);
                taskService.updateTaskTotal(taskId, totalRecords);
                
                int pageSize = BATCH_SIZE;
                int pageNum = 1;
                int processedRecords = 0;
                
                while (true) {
                    // 分页查询数据
                    List<?> dataList = dataQueryService.queryByPage(request, pageNum, pageSize);
                    if (CollectionUtils.isEmpty(dataList)) {
                        break;
                    }
                    
                    // 写入当前批次数据
                    excelWriter.write(dataList, writeSheet);
                    processedRecords += dataList.size();
                    
                    // 更新进度
                    taskService.updateTaskStatus(taskId, ExportTaskStatus.PROCESSING, 
                                               processedRecords, null);
                    
                    // 判断是否完成
                    if (dataList.size() < pageSize) {
                        break;
                    }
                    
                    pageNum++;
                    
                    // 可选：添加适当延时，避免过度消耗资源
                    if (pageNum % 10 == 0) {
                        Thread.sleep(10);
                    }
                }
                
                // 5. 完成导出
                taskService.updateTaskStatus(taskId, ExportTaskStatus.COMPLETED, 
                                           processedRecords, null);
                
            } catch (Exception e) {
                taskService.updateTaskStatus(taskId, ExportTaskStatus.FAILED, 
                                           processedRecords, e.getMessage());
                throw e;
            }
            
            // 6. 更新文件路径信息
            taskService.updateTaskFilePath(taskId, filePath, fileName);
            
        } catch (Exception e) {
            taskService.updateTaskStatus(taskId, ExportTaskStatus.FAILED, 0, e.getMessage());
            throw new RuntimeException("导出失败: " + e.getMessage(), e);
        }
    }
    
    /**
     * 异步导出Excel（基于POI SXSSF，备选方案）
     */
    public void exportToExcelWithPoiAsync(ExportRequest request, String taskId) {
        try {
            taskService.updateTaskStatus(taskId, ExportTaskStatus.PROCESSING, 0, null);
            
            String fileName = buildFileName(request);
            String tempDir = System.getProperty("java.io.tmpdir");
            String filePath = tempDir + File.separator + fileName;
            
            // 使用SXSSFWorkbook，设置内存中保留的行数（如100行）
            try (SXSSFWorkbook workbook = new SXSSFWorkbook(100)) {
                Sheet sheet = workbook.createSheet(request.getSheetName());
                
                // 创建表头
                createHeaderRow(sheet, request);
                
                int totalRecords = dataQueryService.getTotalCount(request);
                taskService.updateTaskTotal(taskId, totalRecords);
                
                int pageSize = BATCH_SIZE;
                int pageNum = 1;
                int processedRecords = 0;
                int rowNum = 1; // 从第2行开始（第1行是表头）
                
                while (true) {
                    List<?> dataList = dataQueryService.queryByPage(request, pageNum, pageSize);
                    if (CollectionUtils.isEmpty(dataList)) {
                        break;
                    }
                    
                    for (Object data : dataList) {
                        Row row = sheet.createRow(rowNum++);
                        fillDataRow(row, data, request);
                        processedRecords++;
                        
                        // 定期更新进度
                        if (processedRecords % 100 == 0) {
                            taskService.updateTaskStatus(taskId, ExportTaskStatus.PROCESSING, 
                                                       processedRecords, null);
                        }
                    }
                    
                    if (dataList.size() < pageSize) {
                        break;
                    }
                    pageNum++;
                }
                
                // 写入文件
                try (FileOutputStream out = new FileOutputStream(filePath)) {
                    workbook.write(out);
                }
                
                taskService.updateTaskStatus(taskId, ExportTaskStatus.COMPLETED, 
                                           processedRecords, null);
                taskService.updateTaskFilePath(taskId, filePath, fileName);
                
            } catch (Exception e) {
                taskService.updateTaskStatus(taskId, ExportTaskStatus.FAILED, 
                                           processedRecords, e.getMessage());
                throw e;
            }
            
        } catch (Exception e) {
            taskService.updateTaskStatus(taskId, ExportTaskStatus.FAILED, 0, e.getMessage());
            throw new RuntimeException("导出失败: " + e.getMessage(), e);
        }
    }
    
    // 辅助方法：创建表头、填充数据行等
    private void createHeaderRow(Sheet sheet, ExportRequest request) { /* ... */ }
    private void fillDataRow(Row row, Object data, ExportRequest request) { /* ... */ }
    private String buildFileName(ExportRequest request) { /* ... */ }
}

4. 数据查询服务

@Service
public class DataQueryService {
    
    @Autowired
    private JdbcTemplate jdbcTemplate;
    // 或使用MyBatis、JPA等
    
    /**
     * 获取总记录数
     */
    public int getTotalCount(ExportRequest request) {
        String countSql = buildCountSql(request);
        return jdbcTemplate.queryForObject(countSql, Integer.class, request.getParams());
    }
    
    /**
     * 分页查询数据
     */
    public List<?> queryByPage(ExportRequest request, int pageNum, int pageSize) {
        String dataSql = buildDataSql(request);
        int offset = (pageNum - 1) * pageSize;
        
        // 根据不同数据库构建分页SQL
        String pagedSql = buildPagedSql(dataSql, offset, pageSize);
        
        return jdbcTemplate.query(pagedSql, request.getRowMapper(), 
                                appendPaginationParams(request.getParams(), offset, pageSize));
    }
    
    private String buildPagedSql(String sql, int offset, int pageSize) {
        // MySQL分页
        return sql + " LIMIT " + offset + ", " + pageSize;
        
        // Oracle分页示例
        // return "SELECT * FROM (SELECT a.*, ROWNUM rn FROM (" + sql + ") a WHERE ROWNUM <= " + 
        //        (offset + pageSize) + ") WHERE rn > " + offset;
    }
}

5. 导出请求与响应对象

@Data
public class ExportRequest {
    private String taskName;
    private String sheetName;
    private Class<?> dataClass; // Excel数据对应的Java类
    private Map<String, Object> params; // 查询参数
    private RowMapper<?> rowMapper; // MyBatis行映射器（可选）
    // 其他导出配置参数
    private boolean includeHeader = true;
    private String dateFormat = "yyyy-MM-dd";
    // 可根据具体业务需求扩展
}

@Data
public class ExportResponse {
    private String taskId;
    private String downloadUrl;
    private String statusUrl;
    private String message;
}

五、高级优化策略

1. 内存优化配置

EasyExcel内存优化

// 开启磁盘缓存，避免OOM
EasyExcel.write(filePath, clazz)
    .inMemory(false) // 默认false，使用磁盘缓存
    .withTemplate(templateInputStream) // 可选：使用模板
    .registerWriteHandler(new LongestMatchColumnWidthStyleStrategy()) // 自适应列宽
    .registerWriteHandler(new HorizontalCellStyleStrategy(headStyle, contentStyle)) // 样式策略
    .build();

POI SXSSF配置优化

// 设置内存中保留的行数（如100行），超出部分写入临时文件
SXSSFWorkbook workbook = new SXSSFWorkbook(100);

// 可选：设置临时文件目录
// System.setProperty("org.apache.poi.util.POITempFile.tempdir", "/path/to/temp/dir");

// 处理完成后，清理临时文件
workbook.dispose();

2. 并发与线程池优化

@Configuration
public class ExportThreadPoolConfig {
    
    @Bean("exportTaskExecutor")
    public Executor exportTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 根据服务器配置调整参数
        executor.setCorePoolSize(5);      // 核心线程数
        executor.setMaxPoolSize(20);      // 最大线程数
        executor.setQueueCapacity(100);   // 队列容量
        executor.setKeepAliveSeconds(60); // 空闲线程存活时间
        executor.setThreadNamePrefix("export-task-");
        
        // 拒绝策略：调用者运行策略，避免任务丢失
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        
        executor.initialize();
        return executor;
    }
    
    @Bean("highPriorityExportExecutor")
    public Executor highPriorityExportExecutor() {
        // 高优先级导出任务线程池
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(5);
        executor.setQueueCapacity(20);
        executor.setThreadNamePrefix("high-prio-export-");
        executor.initialize();
        return executor;
    }
}

3. 分布式环境下的任务管理

基于Redis的任务状态存储

@Service
public class RedisExportTaskService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    private static final String TASK_KEY_PREFIX = "export:task:";
    private static final String TASK_PROGRESS_KEY = "progress";
    private static final String TASK_STATUS_KEY = "status";
    private static final String TASK_TOTAL_KEY = "total";
    private static final String TASK_PROCESSED_KEY = "processed";
    private static final String TASK_FILE_PATH_KEY = "filePath";
    private static final String TASK_FILE_NAME_KEY = "fileName";
    
    public void createTask(String taskId, String taskName, String userId) {
        String key = TASK_KEY_PREFIX + taskId;
        Map<String, Object> taskData = new HashMap<>();
        taskData.put("taskId", taskId);
        taskData.put("taskName", taskName);
        taskData.put("userId", userId);
        taskData.put("status", ExportTaskStatus.PENDING.name());
        taskData.put("createTime", new Date());
        
        redisTemplate.opsForHash().putAll(key, taskData);
        redisTemplate.expire(key, 24, TimeUnit.HOURS); // 设置过期时间
    }
    
    public void updateProgress(String taskId, int processed, int total) {
        String key = TASK_KEY_PREFIX + taskId;
        redisTemplate.opsForHash().put(key, TASK_PROCESSED_KEY, processed);
        redisTemplate.opsForHash().put(key, TASK_TOTAL_KEY, total);
        
        double progress = total > 0 ? (processed * 100.0 / total) : 0;
        redisTemplate.opsForHash().put(key, TASK_PROGRESS_KEY, progress);
    }
    
    public void updateStatus(String taskId, ExportTaskStatus status) {
        String key = TASK_KEY_PREFIX + taskId;
        redisTemplate.opsForHash().put(key, TASK_STATUS_KEY, status.name());
    }
    
    public Map<String, Object> getTaskInfo(String taskId) {
        String key = TASK_KEY_PREFIX + taskId;
        return redisTemplate.opsForHash().entries(key);
    }
}

4. 断点续传与失败重试

@Service
public class ResilientExportService {
    
    @Autowired
    private ExportTaskService taskService;
    
    @Retryable(value = {Exception.class}, maxAttempts = 3, backoff = @Backoff(delay = 1000))
    public void exportWithRetry(ExportRequest request, String taskId) {
        try {
            excelExportService.exportToExcelAsync(request, taskId);
        } catch (Exception e) {
            // 记录失败信息
            taskService.updateTaskStatus(taskId, ExportTaskStatus.FAILED, 
                                       getProcessedCount(taskId), e.getMessage());
            throw e;
        }
    }
    
    @Recover
    public void recoverExport(Exception e, ExportRequest request, String taskId) {
        taskService.updateTaskStatus(taskId, ExportTaskStatus.FAILED, 
                                   getProcessedCount(taskId), 
                                   "导出失败，重试后仍然错误: " + e.getMessage());
    }
    
    // 支持断点续传的导出
    public void resumeExport(String taskId) {
        ExportTask task = taskService.getTaskByTaskId(taskId);
        if (task != null && ExportTaskStatus.FAILED.name().equals(task.getStatus())) {
            // 重新提交导出任务，从上次失败的位置继续
            ExportRequest request = buildRequestFromTask(task);
            exportWithRetry(request, taskId);
        }
    }
}

六、前端集成与用户体验

1. 前端调用示例（Vue.js/React）

// 发起导出请求
async function startExport(exportConfig) {
  try {
    const response = await axios.post('/api/export/async', {
      taskName: '数据导出',
      sheetName: 'Sheet1',
      // 其他导出参数
      ...exportConfig
    });
    
    const { taskId, statusUrl } = response.data;
    
    // 轮询进度
    pollExportProgress(taskId, statusUrl);
    
  } catch (error) {
    console.error('导出请求失败:', error);
    message.error('导出请求失败');
  }
}

// 轮询导出进度
function pollExportProgress(taskId, statusUrl) {
  const progressInterval = setInterval(async () => {
    try {
      const response = await axios.get(`/api/export/progress/${taskId}`);
      const progress = response.data;
      
      // 更新UI进度
      updateProgressUI(progress);
      
      // 判断是否完成
      if (progress.status === 'COMPLETED') {
        clearInterval(progressInterval);
        message.success('导出完成，开始下载');
        // 触发下载
        startDownload(taskId);
      } else if (progress.status === 'FAILED') {
        clearInterval(progressInterval);
        message.error(`导出失败: ${progress.errorMsg || '未知错误'}`);
      }
      
    } catch (error) {
      clearInterval(progressInterval);
      message.error('获取导出进度失败');
    }
  }, 2000); // 每2秒轮询一次
  
  // 可选：设置轮询超时
  setTimeout(() => {
    clearInterval(progressInterval);
    message.warning('导出进度查询超时，请稍后手动查询');
  }, 300000); // 5分钟超时
}

// 下载导出文件
function startDownload(taskId) {
  window.location.href = `/api/export/download/${taskId}`;
}

2. 用户体验优化

即时反馈：提交导出请求后立即显示”导出已提交”提示
进度可视化：实时显示进度条和百分比
状态通知：通过WebSocket或轮询提供实时状态更新
错误处理：友好的错误提示和重试机制
下载管理：导出完成后提供明显的下载按钮
历史记录：保存用户的导出历史，支持重新下载

七、部署与运维考虑

1. 文件存储策略

@Service
public class FileStorageService {
    
    // 本地文件系统存储
    @Value("${export.file.storage.local.path:/tmp/export_files}")
    private String localStoragePath;
    
    // OSS存储配置
    @Value("${export.file.storage.oss.enabled:false}")
    private boolean ossEnabled;
    
    @Value("${export.file.storage.oss.endpoint:}")
    private String ossEndpoint;
    
    @Value("${export.file.storage.oss.bucketName:}")
    private String ossBucketName;
    
    @Value("${export.file.storage.oss.accessKey:}")
    private String ossAccessKey;
    
    @Value("${export.file.storage.oss.secretKey:}")
    private String ossSecretKey;
    
    /**
     * 存储导出文件
     */
    public String storeExportFile(String taskId, String fileName, byte[] fileData) throws IOException {
        if (ossEnabled) {
            return storeToOSS(taskId, fileName, fileData);
        } else {
            return storeToLocal(taskId, fileName, fileData);
        }
    }
    
    private String storeToLocal(String taskId, String fileName, byte[] fileData) throws IOException {
        String dirPath = localStoragePath + File.separator + LocalDate.now().format(DateTimeFormatter.ISO_DATE);
        File dir = new File(dirPath);
        if (!dir.exists()) {
            dir.mkdirs();
        }
        
        String filePath = dirPath + File.separator + taskId + "_" + fileName;
        Path path = Paths.get(filePath);
        Files.write(path, fileData);
        
        return filePath;
    }
    
    private String storeToOSS(String taskId, String fileName, byte[] fileData) {
        // 实现OSS存储逻辑
        // 使用阿里云OSS SDK或其他云存储SDK
        // 返回文件的访问URL
        return "oss://bucket/" + taskId + "_" + fileName;
    }
    
    /**
     * 获取文件访问URL
     */
    public String getFileAccessUrl(String filePath) {
        if (ossEnabled) {
            return generateOSSUrl(filePath);
        } else {
            return generateLocalUrl(filePath);
        }
    }
}

2. 定时清理任务

@Component
public class ExportCleanupTask {
    
    @Autowired
    private ExportTaskRepository taskRepository;
    
    @Autowired
    private FileStorageService fileStorageService;
    
    // 每天凌晨执行一次，清理超过7天的导出文件和任务记录
    @Scheduled(cron = "0 0 3 * * ?")
    public void cleanupOldExports() {
        // 清理7天前的完成任务
        LocalDateTime threshold = LocalDateTime.now().minusDays(7);
        List<ExportTask> oldTasks = taskRepository.findByStatusAndCreateTimeBefore(
            ExportTaskStatus.COMPLETED.name(), 
            Date.from(threshold.atZone(ZoneId.systemDefault()).toInstant())
        );
        
        for (ExportTask task : oldTasks) {
            try {
                // 删除物理文件
                if (task.getFilePath() != null) {
                    Path path = Paths.get(task.getFilePath());
                    if (Files.exists(path)) {
                        Files.deleteIfExists(path);
                    }
                }
                
                // 删除数据库记录
                taskRepository.delete(task);
                
            } catch (Exception e) {
                // 记录清理失败日志
                log.error("清理导出文件失败，任务ID: {}", task.getTaskId(), e);
            }
        }
    }
}