mySpace项目遇到的问题

我的耳机没电了2025-04-28 16:38

声明式事务：

在实现下载进度展示的时候发现：原先的代码需要等待所有的操作完成后才会将数据持久化到数据库中，这样子导致前端无法查询下载进度

ini 复制代码 
   @Override
   @Transactional
   public BaseResponse<DownloadTaskAddVO> initDownloadTask(DownloadTaskAddRequest downloadTaskAddRequest, HttpServletRequest request) {
       String userId = downloadTaskAddRequest.getUserId();
       String targetId = downloadTaskAddRequest.getTargetId();
       String type = downloadTaskAddRequest.getType();
       // String zipTaskId = downloadTaskAddRequest.getZipTaskId();
       // 鉴权
       String loginUserId = userService.getLoginUser(request).getId().toString();
       if (!loginUserId.equals(userId)) {
           throw new BusinessException(ErrorCode.NO_AUTH_ERROR, "你无权操作");
       }
       // 判断一下要下载的文件或是文件夹是否是存在的
       File file = fileService.getById(targetId);
       if (file == null) {
           throw new BusinessException(ErrorCode.PARAMS_ERROR, "要下载的文件或文件夹不存在");
       }
       Downloadtask downloadtask = new Downloadtask();
       downloadtask.setUserId(userId);
       downloadtask.setTargetId(targetId);
       downloadtask.setType(type);
       downloadtask.setExpireTime(LocalDateTime.now().plusDays(7));
       if (!this.save(downloadtask)) {
           throw new BusinessException(ErrorCode.OPERATION_ERROR, "数据插入失败");
       }
       // 计算要下载的文件(夹)总字节大小
       long totalSize = file.getSize();
       // 判断是否是文件夹
       if (file.getIsFolder() == 1) {
           totalSize = 0;
           // 初始化一下压缩任务
           String taskId = ziptaskService.initTask(loginUserId, targetId);
           LambdaUpdateWrapper<Downloadtask> updateWrapper =
                   new LambdaUpdateWrapper<Downloadtask>()
                           .eq(Downloadtask::getTaskId, downloadtask.getTaskId())
                           .set(Downloadtask::getZipTaskId, taskId);
           if (!this.update(updateWrapper)) {
               throw new BusinessException(ErrorCode.OPERATION_ERROR, "zipTaskId记录失败");
           }
           // 对文件夹进行压缩
           GetFolderZipResult data = fileService.getFolderZipById(downloadtask.getTaskId(), targetId, request).getData();
           if (!data.isCompleted()) {
               throw new BusinessException(ErrorCode.SYSTEM_ERROR, "ZIP 文件尚未生成完成");
           }
           String url = data.getUrl();
           // 完善一下压缩任务
           boolean update = ziptaskService.updateField(taskId, url);
           if (!update) {
               throw new BusinessException(ErrorCode.OPERATION_ERROR, "下载任务完善失败");
           }
           String key = FilePathUtil.parseStoragePath(url);
           COSClient cosClient = cosClientConfig.cosClient();
           COSObject object = cosClient.getObject(cosClientConfig.getBucket(), key);
           long fileSizeInBytes = object.getObjectMetadata().getContentLength();
           totalSize = fileSizeInBytes;
       }
       LambdaUpdateWrapper<Downloadtask> updateWrapper = new LambdaUpdateWrapper<Downloadtask>()
               .eq(Downloadtask::getTaskId, downloadtask.getTaskId())
               .set(Downloadtask::getTotalSize, totalSize);
       if (!this.update(updateWrapper)) {
           throw new BusinessException(ErrorCode.OPERATION_ERROR, "文件大小更新失败");
       }
       // 大于10M，提前初始化逻辑分片
       if (totalSize >= 10 * 1024 * 1024) {
           List<Downloadchunk> chunks = new ArrayList<>();

           // 计算分片数量（向上取整）
           long totalChunks = (totalSize + CHUNK_SIZE - 1) / CHUNK_SIZE;

           // 生成分片记录
           for (int i = 0; i < totalChunks; i++) {
               long startOffset = i * CHUNK_SIZE;
               long endOffset = Math.min(startOffset + CHUNK_SIZE, totalSize) - 1;
               long actualChunkSize = endOffset - startOffset + 1;

               Downloadchunk chunk = new Downloadchunk();
               chunk.setTaskId(downloadtask.getTaskId());
               // chunk.setChunkNumber(i + 1); // 序号从1开始
               chunk.setChunkNumber(i); // 序号从0开始
               chunk.setChunkSize(actualChunkSize);
               chunk.setStartOffset(startOffset);
               chunk.setEndOffset(endOffset);
               chunk.setResourceType(file.getIsFolder() == 1 ? "folder" : "file");
               chunk.setStatus("pending");
               chunks.add(chunk);
           }
           // 批量保存分片记录
           if (!chunks.isEmpty() && !downloadchunkService.saveBatch(chunks)) {
               throw new BusinessException(ErrorCode.OPERATION_ERROR, "分片初始化失败");
           }
       }
       // 封装返回类型
       DownloadTaskAddVO downloadTaskAddVO = new DownloadTaskAddVO();
       downloadTaskAddVO.setDownloadTaskId(downloadtask.getTaskId());
       downloadTaskAddVO.setTotalSize(totalSize);
       return ResultUtils.success(downloadTaskAddVO);
   }

一开始以为是插入顺序的问题导致要整个流程执行完才会将数据持久化到数据库中，然后询问ai，发现给出的代码其实还是一样的，还是会导致开头的问题

scss 复制代码 
@Override
@Transactional
public BaseResponse<DownloadTaskAddVO> initDownloadTask(DownloadTaskAddRequest downloadTaskAddRequest, HttpServletRequest request) {
    String userId = downloadTaskAddRequest.getUserId();
    String targetId = downloadTaskAddRequest.getTargetId();
    String type = downloadTaskAddRequest.getType();

    // 鉴权
    String loginUserId = userService.getLoginUser(request).getId().toString();
    if (!loginUserId.equals(userId)) {
        throw new BusinessException(ErrorCode.NO_AUTH_ERROR, "无权操作");
    }

    // 校验目标文件存在性
    File file = fileService.getById(targetId);
    if (file == null) {
        throw new BusinessException(ErrorCode.PARAMS_ERROR, "下载目标不存在");
    }

    // --- 核心修改点：立即初始化下载任务并保存 ---
    Downloadtask downloadtask = new Downloadtask();
    downloadtask.setUserId(userId);
    downloadtask.setTargetId(targetId);
    downloadtask.setType(type);
    downloadtask.setExpireTime(LocalDateTime.now().plusDays(7));
    if (!this.save(downloadtask)) {
        throw new BusinessException(ErrorCode.OPERATION_ERROR, "任务创建失败");
    }

    // --- 后续步骤：基于已创建的下载任务进行处理 ---
    try {
        long totalSize = file.getSize();
        String zipTaskId = null;

        // 处理文件夹类型
        if (file.getIsFolder() == 1) {
            // 初始化压缩任务
            zipTaskId = ziptaskService.initTask(loginUserId, targetId);
            // 绑定压缩任务ID到下载任务
            downloadtask.setZipTaskId(zipTaskId);
            if (!this.updateById(downloadtask)) {
                throw new BusinessException(ErrorCode.OPERATION_ERROR, "任务更新失败");
            }

            // 生成ZIP并获取实际大小
            GetFolderZipResult zipResult = fileService.getFolderZipById(downloadtask.getTaskId(), targetId, request).getData();
            if (!zipResult.isCompleted()) {
                throw new BusinessException(ErrorCode.SYSTEM_ERROR, "ZIP未就绪");
            }
            String url = zipResult.getUrl();
            ziptaskService.updateField(zipTaskId, url); // 更新压缩任务URL

            // 从COS获取ZIP文件大小
            String cosKey = FilePathUtil.parseStoragePath(url);
            COSObject cosObject = cosClientConfig.cosClient().getObject(cosClientConfig.getBucket(), cosKey);
            totalSize = cosObject.getObjectMetadata().getContentLength();
        }

        // 更新任务总大小
        downloadtask.setTotalSize(totalSize);
        if (!this.updateById(downloadtask)) {
            throw new BusinessException(ErrorCode.OPERATION_ERROR, "大小更新失败");
        }

        // 大文件分片预处理
        if (totalSize >= 10 * 1024 * 1024) {
            initializeChunks(downloadtask.getTaskId(), totalSize, file.getIsFolder() == 1);
        }

        // 构造响应
        DownloadTaskAddVO vo = new DownloadTaskAddVO();
        vo.setDownloadTaskId(downloadtask.getTaskId());
        vo.setTotalSize(totalSize);
        return ResultUtils.success(vo);

    } catch (Exception e) {
        // 异常时清理任务（可选）
        this.removeById(downloadtask.getTaskId());
        throw e;
    }
}

// 分片初始化逻辑封装
private void initializeChunks(String taskId, long totalSize, boolean isFolder) {
    List<Downloadchunk> chunks = new ArrayList<>();
    long chunkCount = (totalSize + CHUNK_SIZE - 1) / CHUNK_SIZE;

    for (int i = 0; i < chunkCount; i++) {
        long start = i * CHUNK_SIZE;
        long end = Math.min(start + CHUNK_SIZE, totalSize) - 1;

        Downloadchunk chunk = new Downloadchunk();
        chunk.setTaskId(taskId);
        chunk.setChunkNumber(i);
        chunk.setStartOffset(start);
        chunk.setEndOffset(end);
        chunk.setChunkSize(end - start + 1);
        chunk.setResourceType(isFolder ? "folder" : "file");
        chunk.setStatus("pending");
        chunks.add(chunk);
    }

    if (!chunks.isEmpty() && !downloadchunkService.saveBatch(chunks)) {
        throw new BusinessException(ErrorCode.OPERATION_ERROR, "分片初始化失败");
    }
}

发现这个代码其实和原来的代码的执行流程其实基本是差不多，都是先将下载任务先保存到数据库中

但是执行发现其实虽然执行的过程中会有相应执行的sql产生，但是其实并没有真正的将数据持久化到数据库中

最后一番排查之后发现其实是声明式事务搞的鬼

把它注销掉之后就会发现能够提前将数据持久化到数据库中了

虽然但是能达到我们的目的，但是听起来就很离谱，怎么可能通过这么不聪明的方法来实现这个目的

所以还要另寻他法

这里先回顾一下声明式事务：

SpringAop 的声明式事务：

  • 开始 ：当 initDownloadTask 方法被调用时，Spring 会开启一个事务。
  • 执行 ：所有数据库操作（如 this.save(downloadtask)）会生成 SQL 语句并缓存在事务上下文中，但不会立即写入数据库。
  • 提交/回滚：
    • 如果方法正常执行完成，事务提交，所有 SQL 一次性写入数据库。
    • 如果方法抛出异常，事务回滚，所有 SQL 被丢弃，数据库保持原状。

也就是说这里的 this.save(downloadtask) 不会真正写入数据库

那么肯定有人要问了，我不想自己手动编写事务，那么能不能直接将这两步拆分两个方法，然后把 his.save(downloadtask) 下面的逻辑拆成另外一个方法，然后在这个方法中直接去调用另外一个方法，然后在另外一个方法去加事务，这个方法不加事务

首先回答一下，这个肯定是可以的，但是有一个前提就是这两个方法必须写在两个类中

由于 Spring 的 AOP 代理机制是基于 类级别 的动态代理，自调用（同一类中方法A调用方法B）不会触发事务。

例如：

typescript 复制代码 
@Service
public class MyService {
    // 方法A：无事务注解
    public void methodA() {
        methodB(); // 调用有事务注解的方法B
    }

    // 方法B：有事务注解
    @Transactional
    public void methodB() {
        // 数据库操作...
    }
}
typescript 复制代码 
@Service
public class ServiceA {
    @Autowired
    private ServiceB serviceB;

    // 方法A：无事务注解
    public void methodA() {
        serviceB.methodB(); // 调用另一个Service的事务方法
    }
}

@Service
public class ServiceB {
    // 方法B：有事务注解
    @Transactional
    public void methodB() {
        // 数据库操作...
    }
}

那如果要确保同一个类中还是事务生效的话：通过代理对象调用，而不是自己调用：（不太推荐）

typescript 复制代码 
@Service
public class MyService {
    @Autowired
    private MyService selfProxy; // 通过代理对象调用方法B

    public void methodA() {
        selfProxy.methodB(); // 通过代理调用，触发事务
    }

    @Transactional
    public void methodB() {
        // 数据库操作...
    }
}

那么我们可以怎么做呢？

其实也很好做，首先我们再创建一个新的类，然后将提前持久化的代码放在这个类中，然后进行当注册一个事务同步器来监听主事务的回滚操作

ini 复制代码 
@Override
    @Transactional
    public BaseResponse<DownloadTaskAddVO> initDownloadTask(DownloadTaskAddRequest downloadTaskAddRequest, HttpServletRequest request) {
        String userId = downloadTaskAddRequest.getUserId();
        String targetId = downloadTaskAddRequest.getTargetId();
        String type = downloadTaskAddRequest.getType();
        // String zipTaskId = downloadTaskAddRequest.getZipTaskId();
        // 鉴权
        String loginUserId = userService.getLoginUser(request).getId().toString();
        if (!loginUserId.equals(userId)) {
            throw new BusinessException(ErrorCode.NO_AUTH_ERROR, "你无权操作");
        }
        // 判断一下要下载的文件或是文件夹是否是存在的
        File file = fileService.getById(targetId);
        if (file == null) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "要下载的文件或文件夹不存在");
        }
        Downloadtask downloadtask = new Downloadtask();
        downloadtask.setUserId(userId);
        downloadtask.setTargetId(targetId);
        downloadtask.setType(type);
        downloadtask.setExpireTime(LocalDateTime.now().plusDays(7));
        System.out.println("执行到这里了1");
        // 强制保存数据
        independentService.saveDownloadTask(downloadtask);
        // 注册事务同步器，监听主事务的回滚事件
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
            @Override
            public void afterCompletion(int status) {
                if (status == TransactionSynchronization.STATUS_ROLLED_BACK) {
                    // 主事务回滚，触发删除操作
                    independentService.deleteDownloadTaskInNewTransaction(downloadtask.getTaskId());
                }
            }
        });
        // 计算要下载的文件(夹)总字节大小
        long totalSize = file.getSize();
        // 判断是否是文件夹
        if (file.getIsFolder() == 1) {
            totalSize = 0;
            // 初始化一下压缩任务
            String taskId = ziptaskService.initTask(loginUserId, targetId);
            LambdaUpdateWrapper<Downloadtask> updateWrapper =
                    new LambdaUpdateWrapper<Downloadtask>()
                            .eq(Downloadtask::getTaskId, downloadtask.getTaskId())
                            .set(Downloadtask::getZipTaskId, taskId);
            if (!this.update(updateWrapper)) {
                throw new BusinessException(ErrorCode.OPERATION_ERROR, "zipTaskId记录失败");
            }
            // 对文件夹进行压缩
            long start = System.currentTimeMillis();
            GetFolderZipResult data = fileService.getFolderZipById(downloadtask.getTaskId(), targetId, request).getData();
            long end = System.currentTimeMillis();
            System.out.println("执行压缩文件消耗的时间是：" + (end - start));
            if (!data.isCompleted()) {
                throw new BusinessException(ErrorCode.SYSTEM_ERROR, "ZIP 文件尚未生成完成");
            }
            String url = data.getUrl();
            // 完善一下压缩任务
            boolean update = ziptaskService.updateField(taskId, url);
            if (!update) {
                throw new BusinessException(ErrorCode.OPERATION_ERROR, "下载任务完善失败");
            }
            String key = FilePathUtil.parseStoragePath(url);
            COSClient cosClient = cosClientConfig.cosClient();
            COSObject object = cosClient.getObject(cosClientConfig.getBucket(), key);
            long fileSizeInBytes = object.getObjectMetadata().getContentLength();
            totalSize = fileSizeInBytes;
        }
        LambdaUpdateWrapper<Downloadtask> updateWrapper = new LambdaUpdateWrapper<Downloadtask>()
                .eq(Downloadtask::getTaskId, downloadtask.getTaskId())
                .set(Downloadtask::getTotalSize, totalSize);
        if (!this.update(updateWrapper)) {
            throw new BusinessException(ErrorCode.OPERATION_ERROR, "文件大小更新失败");
        }
        // 大于10M，提前初始化逻辑分片
        if (totalSize >= 10 * 1024 * 1024) {
            List<Downloadchunk> chunks = new ArrayList<>();

            // 计算分片数量（向上取整）
            long totalChunks = (totalSize + CHUNK_SIZE - 1) / CHUNK_SIZE;

            // 生成分片记录
            for (int i = 0; i < totalChunks; i++) {
                long startOffset = i * CHUNK_SIZE;
                long endOffset = Math.min(startOffset + CHUNK_SIZE, totalSize) - 1;
                long actualChunkSize = endOffset - startOffset + 1;

                Downloadchunk chunk = new Downloadchunk();
                chunk.setTaskId(downloadtask.getTaskId());
                chunk.setChunkNumber(i); // 序号从0开始
                chunk.setChunkSize(actualChunkSize);
                chunk.setStartOffset(startOffset);
                chunk.setEndOffset(endOffset);
                chunk.setResourceType(file.getIsFolder() == 1 ? "folder" : "file");
                chunk.setStatus("pending");
                chunks.add(chunk);
            }
            // 批量保存分片记录
            if (!chunks.isEmpty() && !downloadchunkService.saveBatch(chunks)) {
                throw new BusinessException(ErrorCode.OPERATION_ERROR, "分片初始化失败");
            }
        }
        // 封装返回类型
        DownloadTaskAddVO downloadTaskAddVO = new DownloadTaskAddVO();
        downloadTaskAddVO.setDownloadTaskId(downloadtask.getTaskId());
        downloadTaskAddVO.setTotalSize(totalSize);
        return ResultUtils.success(downloadTaskAddVO);
    }
typescript 复制代码 
@Service
public class IndependentServiceImpl implements IndependentService {

    @Resource
    private DownloadtaskService downloadtaskService;

    /**
     * 将数据持久化到数据库中
     * @param downloadtask
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW) // 开启新事务
    public void saveDownloadTask(Downloadtask downloadtask) {
        System.out.println("执行到这里了2");
        if (!downloadtaskService.save(downloadtask)) {
            throw new BusinessException(ErrorCode.OPERATION_ERROR, "数据插入失败");
        }
    }

    /**
     * 开启新线程删除事务
     * @param taskId
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void deleteDownloadTaskInNewTransaction(String taskId) {
        downloadtaskService.removeById(taskId);
    }
}

不过要注意循环依赖问题，可以通过 @Lazy 注解开启spring的三级缓存进行处理

除了上面的这种操作之后也可以通过手动补偿机制或是嵌套事务解决，这里就大家自己研究，方法肯定还是有很多的，结合自己的项目挑选合适的就行。

相关推荐
Rabbb40 分钟前
C# JSON属性排序、比较 Newtonsoft.Json
后端
蓝易云41 分钟前
在Linux、CentOS7中设置shell脚本开机自启动服务
前端·后端·centos
一千柯橘1 小时前
Nestjs 解决 request entity too large
javascript·后端
userkang1 小时前
消失的前后端，崛起的智能体
前端·人工智能·后端·ai·硬件工程
慧一居士2 小时前
Kafka HA集群配置搭建与SpringBoot使用示例总结
spring boot·后端·kafka
@_猿来如此2 小时前
Django 实现电影推荐系统：从搭建到功能完善（附源码）
数据库·后端·python·django
言之。2 小时前
【Go语言】ORM（对象关系映射）库
开发语言·后端·golang
极客智谷3 小时前
深入理解Java线程池：从原理到实战的完整指南
java·后端
陈随易3 小时前
长跑8年，Node.js框架Koa v3.0终发布
前端·后端·程序员
热门推荐
01西电B测-计算机网络综合实验(含验收问题)02KGG转MP3工具|非KGM文件|解密音频03从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑04Coze扣子平台完整体验和实践（附国内和国际版对比）05yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记06我决定放弃搞 Java 了07YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU08YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】09DeepSeek各版本说明与优缺点分析10yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）