SpringCloud+Vue实现大文件分片下载(支持开始、暂停、继续、取消)

于 2025-05-20 22:24:00 发布
阅读量614 收藏 5
点赞数 4
CC 4.0 BY-SA版权
分类专栏： 精选实践 文章标签： spring cloud vue.js spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/SJshenjian/article/details/148098983

1. 实现效果

http://localhost:8089/#/demo

开始下载
暂停

所有代码已提交至
https://github.com/SJshenjian/cloud.git与
https://github.com/SJshenjian/cloud-web.git中，欢迎star

2. 后端核心代码

@FeignClient(value = "download", contextId = "download")
@Component
@RequestMapping("/download")
public interface DownloadClient {

    @GetMapping("/download")
    @Operation(summary = "大文件下载", tags = "通用服务", security = {@SecurityRequirement(name = "token")})
    ResponseEntity<Object> downloadFile(@RequestHeader HttpHeaders headers, @RequestParam String fileId);
}

@RestController
public class DownloadController implements DownloadClient {

    private final DownloadService downloadService;

    public DownloadController(DownloadService downloadService) {
        this.downloadService = downloadService;
    }

    @Override
    public ResponseEntity<Object> downloadFile(@RequestHeader HttpHeaders headers, @RequestParam String fileId) {
        return downloadService.downloadFile(headers, fileId);
    }
}

public interface DownloadService {

    /**
     * 分片下载大文件
     *
     * @param headers
     * @param fileId
     * @return
     */
    ResponseEntity<Object> downloadFile(@RequestHeader HttpHeaders headers, @RequestParam String fileId);
}

@Slf4j
@Service
public class DownloadServiceImpl implements DownloadService {


    @Override
    public ResponseEntity<Object> downloadFile(HttpHeaders headers, String fileId) {
        Path filePath = Paths.get("/home/sfxs/files/" + fileId);
        File file = filePath.toFile();
        long fileLength = file.length();

        // 解析 Range 头
        List<HttpRange> ranges = headers.getRange();
        if (ranges.isEmpty()) {
            // 计算分片 MD5
            String fileMD5;
            try {
                fileMD5 = Md5Utils.calculateMD5(Files.readAllBytes(filePath));
            } catch (Exception e) {
                log.error("Failed to calculate MD5 for file {}", fileId, e);
                return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
            }
            return ResponseEntity.ok()
                    .header("Content-Disposition", "attachment; filename=" + file.getName())
                    .contentLength(fileLength)
                    .header("File-MD5", fileMD5) // 添加 MD5 响应头
                    .body(new FileSystemResource(file));
        }

        // 处理 Range 请求
        HttpRange range = ranges.get(0);
        long start = range.getRangeStart(fileLength);
        long end = range.getRangeEnd(fileLength);
        long rangeLength = end - start + 1;
        log.info("start: {}, end: {}", start, end);
        try (RandomAccessFile raf = new RandomAccessFile(file, "r");
             FileChannel channel = raf.getChannel()) {

            ByteBuffer buffer = ByteBuffer.allocate((int) rangeLength);
            channel.position(start);
            channel.read(buffer);
            buffer.flip();

            return ResponseEntity.status(HttpStatus.PARTIAL_CONTENT)
                    .header("Content-Range", "bytes " + start + "-" + end + "/" + fileLength)
                    .header("Accept-Ranges", "bytes")
                    .contentLength(rangeLength)
                    .body(buffer.array());
        } catch (Exception e) {
            log.error("Failed to process range request for file {}", fileId, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
        // 这种方式会导致原始文件大小为0
//        return ResponseEntity.status(HttpStatus.PARTIAL_CONTENT)
//                .header("Content-Range", "bytes " + start + "-" + end + "/" + fileLength)
//                .header("Accept-Ranges", "bytes")
//                .contentLength(rangeLength)
//                .body(new ResourceRegion(new FileSystemResource(file), start, rangeLength));
        // 计算当前分片的MD5， 排查用
//        byte[] chunkData;
//        try (RandomAccessFile raf = new RandomAccessFile(file, "r")) {
//            raf.seek(start);
//            chunkData = new byte[(int) rangeLength];
//            raf.read(chunkData);
//            bytesToHex(chunkData);
//            String md5 = DigestUtils.md5DigestAsHex(chunkData);
//            return ResponseEntity.status(HttpStatus.PARTIAL_CONTENT)
//                    .header("Content-Range", "bytes " + start + "-" + end + "/" + fileLength)
//                    .header("Accept-Ranges", "bytes")
//                    .header("File-MD5", md5)  // 添加MD5校验头
//                    .contentLength(rangeLength)
//                    .body(new ResourceRegion(new FileSystemResource(file), start, rangeLength));
//        } catch (FileNotFoundException e) {
//            throw new RuntimeException(e);
//        } catch (IOException e) {
//            throw new RuntimeException(e);
//        }
    }
}

3. 后端超时及自定义头配置

# application.yml
spring:
  cloud:
    openfeign:
      client:
        config:
          default:
            connectTimeout: 5000      # 5秒连接超时
            readTimeout: 30000         # 30秒读取超时
          download: # 下载服务专用配置
            connectTimeout: 30000   # 连接超时30秒
            readTimeout: 3600000   # 读取超时60分钟(1小时)

@Slf4j
@Component
public class AnonymousAuthenticationEntryPoint implements AuthenticationEntryPoint {

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException {
        // 允许跨域
        response.setHeader("Access-Control-Allow-Origin", "*");
        // 允许自定义请求头token(允许head跨域) 新增File-MD5
        response.setHeader("Access-Control-Allow-Headers", "Authorization, Role, Accept, Origin, X-Requested-With, Content-Type, Last-Modified, File-MD5");
        response.setHeader("Content-type", "application/json;charset=UTF-8");
        response.getWriter().print(JSON.toJSONString(ResponseVo.message(ResponseCode.UN_AUTHORIZED)));
    }
}

3. 统一返回放开

放开FileSystemResource与ResourceRegion的返回拦截

@RestControllerAdvice
@Slf4j
public class UnitedResponseAdvice implements ResponseBodyAdvice<Object> {

    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        return true;
    }

    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
        if (body != null && !(body instanceof ResponseVo) && !(body instanceof byte[]) && !(body instanceof FileSystemResource) && !(body instanceof ResourceRegion)) {
            // 放行Swagger相关
            if (body instanceof TreeMap && ((TreeMap)body).containsKey("oauth2RedirectUrl")) {
                return body;
            }
            // 解决string返回异常
            if (body instanceof String) {
                return JSON.toJSONString(ResponseVo.message(ResponseCode.SUCCESS.val(), ResponseCode.SUCCESS.des(), body));
            }
            return ResponseVo.message(ResponseCode.SUCCESS.val(), ResponseCode.SUCCESS.des(), body);
        }
        if (body == null) {
            return JSON.toJSONString(ResponseVo.message(ResponseCode.SUCCESS.val(), ResponseCode.SUCCESS.des(), ""));
        }
        return body;
    }
}

4. 前端Vue组件编写

<template>
  <div class="download-container">
    <el-button-group>
      <el-button
          @click="startDownload"
          :disabled="isDownloading"
          type="primary"
          icon="el-icon-download"
      >
        开始下载
      </el-button>
      <el-button
          @click="pauseDownload"
          :disabled="!isDownloading || isPaused"
          icon="el-icon-video-pause"
      >
        暂停
      </el-button>
      <el-button
          @click="resumeDownload"
          :disabled="!isPaused"
          icon="el-icon-caret-right"
      >
        继续
      </el-button>
      <el-button
          @click="cancelDownload"
          :disabled="!isDownloading"
          type="danger"
          icon="el-icon-close"
      >
        取消
      </el-button>
    </el-button-group>

    <el-progress
        :percentage="progressPercent"
        :status="progressStatus"
        :stroke-width="16"
        class="progress-bar"
    />
    <div class="download-info">
      <span v-if="speed">下载速度: {{ speed }} MB/s</span>
      <span>已下载: {{ formatFileSize(downloadedSize) }} / {{ formatFileSize(totalSize) }}</span>
    </div>
  </div>
</template>

<script>
import baseUrl from "../../util/baseUrl";
import store from "../../store";
import {md5} from "js-md5";

export default {
  name: "DownloadFile",
  props: {
    fileId: {
      type: String,
      required: true
    }
  },
  data() {
    return {
      chunkSize: 5 * 1024 * 1024, // 5MB 分片
      maxRetries: 3,
      isDownloading: false,
      isPaused: false,
      progressPercent: 0,
      progressStatus: '',
      speed: '',
      downloadedSize: 0,
      totalSize: 0,
      controller: null,
      retryCount: 0,
      chunks: [],
      downloadStartTime: null,
      fileName: '',
      serverFileMD5: '' // 存储服务器提供的文件 MD5
    }
  },
  computed: {
    fileUrl() {
      return `${baseUrl.apiUrl}/download/download?fileId=${this.fileId}`;
    },
    estimatedTime() {
      if (!this.speed || this.speed <= 0) return '--';
      const remaining = (this.totalSize - this.downloadedSize) / (this.speed * 1024 * 1024);
      return remaining > 3600
          ? `${Math.floor(remaining / 3600)}小时${Math.floor((remaining % 3600) / 60)}分钟`
          : `${Math.floor(remaining / 60)}分钟${Math.floor(remaining % 60)}秒`;
    }
  },
  methods: {
    formatFileSize(bytes) {
      if (bytes === 0) return '0 Bytes';
      const k = 1024;
      const sizes = ['Bytes', 'KB', 'MB', 'GB'];
      const i = Math.floor(Math.log(bytes) / Math.log(k));
      return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
    },

    async calculateMD5(data) {
      try {
        return md5(data); // Compute MD5 hash
      } catch (error) {
        console.error('MD5 error:', error);
        throw error;
      }
    },

    async startDownload() {
      if (this.isDownloading) return;

      try {
        this.resetState();
        this.isDownloading = true;
        this.downloadStartTime = Date.now();
        this.controller = new AbortController();

        // 获取文件元数据
        await this.fetchFileMetadata();

        // 恢复进度或开始新下载
        await this.downloadChunks();
      } catch (err) {
        this.handleError(err);
      }
    },

    async fetchFileMetadata() {
      const headRes = await fetch(this.fileUrl, {
        method: 'HEAD',
        headers: {
          Authorization: store.getters.token,
          'Cache-Control': 'no-cache'
        }
      });

      if (!headRes.ok) {
        throw new Error(`获取文件信息失败: ${headRes.statusText}`);
      }

      this.totalSize = parseInt(headRes.headers.get('Content-Length')) || 0;
      const contentDisposition = headRes.headers.get('Content-Disposition');
      this.fileName = contentDisposition
          ? contentDisposition.split('filename=')[1].replace(/"/g, '')
          : this.fileId;
      this.serverFileMD5 = headRes.headers.get('File-MD5') || ''; // 获取服务器提供的 MD5

      if (!this.serverFileMD5) {
        console.warn('服务器未提供文件 MD5，无法进行完整性验证');
      }

      // 恢复进度
      const savedProgress = localStorage.getItem(this.getStorageKey());
      if (savedProgress) {
        const progressData = JSON.parse(savedProgress);
        this.downloadedSize = progressData.downloaded;
        this.progressPercent = Math.round((this.downloadedSize / this.totalSize) * 100);
      }
    },

    getStorageKey() {
      return `download-${btoa(this.fileUrl)}`;
    },

    async downloadChunks() {
      while (this.downloadedSize < this.totalSize && !this.isPaused) {
        const start = this.downloadedSize;
        const end = Math.min(start + this.chunkSize - 1, this.totalSize - 1);

        try {
          const chunkBlob = await this.downloadChunk(start, end);
          const customBlob = {
            blob: chunkBlob,
            start: start,
            end: end
          };
          this.chunks.push(customBlob);
          this.retryCount = 0;
        } catch (err) {
          if (err.name === 'AbortError') return;
          if (this.retryCount++ < this.maxRetries) {
            await new Promise(resolve => setTimeout(resolve, 1000 * this.retryCount));
            continue;
          }
          throw err;
        }
      }

      if (this.downloadedSize >= this.totalSize) {
        await this.completeDownload();
      }
    },

    async downloadChunk(start, end) {
      const startTime = Date.now();
      // 禁用缓存
      const response = await fetch(this.fileUrl, {
        headers: {
          Range: `bytes=${start}-${end}`,
          Authorization: store.getters.token,
          'Cache-Control': 'no-cache'
        },
        signal: this.controller.signal // 添加时间戳参数以避免浏览器缓存
      });

      if (!response.ok) {
        throw new Error(`下载失败: ${response.statusText}`);
      }
      // 方法1：直接使用 arrayBuffer() 方法（最简单）
      const contentRange = response.headers.get('Content-Range');
      console.log('Content-Range:', contentRange);  // 确保它匹配你请求的范围
      const arrayBuffer = await response.arrayBuffer();
      // 排查用户端与服务端的MD5校验
      // const chunk_md5 = response.headers.get('File-MD5')
      // const real_md5 = await this.calculateMD5(arrayBuffer)
      // console.log(arrayBuffer)
      // if (chunk_md5 !== real_md5) {
      //   console.error("MD5不一致：", chunk_md5, real_md5)
      //   console.log("HEX" + utils.toHex(arrayBuffer))
      // } else {
      //   console.error("MD5一致：", chunk_md5, real_md5)
      //   console.log("HEX" + utils.toHex(arrayBuffer))
      // }

      // 更新进度
      this.updateProgress(start, arrayBuffer.byteLength, startTime);

      return arrayBuffer;
      // const reader = response.body.getReader();
      // let receivedLength = 0;
      // const chunks = [];
      //
      // while (true) {
      //   const { done, value } = await reader.read();
      //   if (done) break;
      //
      //   chunks.push(value);
      //   receivedLength += value.length;
      //
      //   // 更新进度
      //   this.updateProgress(start, receivedLength, startTime);
      // }
      // return chunks;
    },

    updateProgress(start, receivedLength, startTime) {
      this.downloadedSize = start + receivedLength;
      this.progressPercent = Math.round((this.downloadedSize / this.totalSize) * 100);

      // 计算下载速度
      const timeElapsed = (Date.now() - startTime) / 1000;
      this.speed = (receivedLength / 1024 / 1024 / timeElapsed).toFixed(2);

      // 保存进度
      localStorage.setItem(
          this.getStorageKey(),
          JSON.stringify({
            downloaded: this.downloadedSize,
            chunks: this.chunks.length
          })
      );
    },

    pauseDownload() {
      this.isPaused = true;
      this.controller.abort();
      this.progressStatus = 'warning';
      this.$message.warning('下载已暂停');
    },

    resumeDownload() {
      this.isPaused = false;
      this.progressStatus = '';
      this.controller = new AbortController();
      this.downloadChunks();
      this.$message.success('继续下载');
    },

    cancelDownload() {
      this.controller.abort();
      this.resetState();
      localStorage.removeItem(this.getStorageKey());
      this.$message.info('下载已取消');
    },

    async completeDownload() {
      try {
        this.progressStatus = 'success';
        await this.saveFile();
        this.$message.success('下载完成');
      } catch (err) {
        this.handleError(err);
      } finally {
        this.cleanup();
      }
    },

    async saveFile() {
      // 1. 排序分片
      const sortedChunks = this.chunks.sort((a, b) => a.start - b.start);
      const fullBlob = new Blob(sortedChunks.map(c => c.blob), { type: 'application/zip' });

      // 计算下载文件的 MD5
      let arrayBuffer;
      if (this.serverFileMD5) {
        arrayBuffer = await fullBlob.arrayBuffer();
        const downloadedMD5 = await this.calculateMD5(arrayBuffer);

        if (downloadedMD5 !== this.serverFileMD5) {
          this.progressStatus = 'exception';
          this.$message.error('文件校验失败：MD5 不匹配，文件可能已损坏');
          throw new Error('MD5 verification failed');
        }
      }

      // 检查 ZIP 文件头
      const uint8Array = new Uint8Array(arrayBuffer);
      const zipHeader = uint8Array.slice(0, 4);
      if (zipHeader[0] !== 80 || zipHeader[1] !== 75 || zipHeader[2] !== 3 || zipHeader[3] !== 4) {
        this.progressStatus = 'exception';
        this.$message.error('无效的 ZIP 文件：文件头错误');
        throw new Error('Invalid ZIP file header');
      }

      // 创建下载链接
      const url = URL.createObjectURL(fullBlob);
      const a = document.createElement('a');
      a.href = url;
      a.download = this.fileName;
      a.style.display = 'none';

      // 触发下载
      document.body.appendChild(a);
      a.click();

      // 延迟清理
      await new Promise(resolve => setTimeout(resolve, 100));
      document.body.removeChild(a);
      URL.revokeObjectURL(url);
    },

    resetState() {
      this.isDownloading = false;
      this.isPaused = false;
      this.progressPercent = 0;
      this.progressStatus = '';
      this.speed = '';
      this.downloadedSize = 0;
      this.retryCount = 0;
      this.chunks = [];
      this.controller = null;
      this.serverFileMD5 = '';
    },

    cleanup() {
      this.isDownloading = false;
      localStorage.removeItem(this.getStorageKey());
    },

    handleError(err) {
      console.error('下载错误:', err);
      this.progressStatus = 'exception';
      this.$message.error(`下载失败: ${err.message}`);
      this.cleanup();
    }
  },
  beforeUnmount() {
    if (this.controller) {
      this.controller.abort();
    }
  }
}
</script>

<style scoped>
.download-container {
  max-width: 800px;
  margin: 20px auto;
  padding: 20px;
  border: 1px solid #ebeef5;
  border-radius: 4px;
  background-color: #f5f7fa;
}

.el-button-group {
  margin-bottom: 15px;
}

.progress-bar {
  margin: 20px 0;
}

.download-info {
  display: flex;
  justify-content: space-between;
  margin-top: 10px;
  color: #606266;
  font-size: 14px;
}

.download-info span {
  padding: 0 5px;
}
</style>
带大家用 vue + springboot/springcloud +minio(可选) 实现文件分片上传和断点续传介绍，问题，原理及 前后端完整源码 (模式1:后台单点部署模式）
峡谷电光马仔的博客
02-15 2042
vue + springboot/springcloud +minio(可选) 实现文件分片上传和断点续传介绍，问题，原理及 前后端完整源码 (后台单点部署） 什么是http文件分片上传？为什么要分片上传？ 什么是http文件分片上传 为什么要分片上传？ 后台(springboot/springcloud)集群多节点部署下分片上传有什么问题以及如何改进 普通上传和分片上传的上传正常和重试原理 前后端完整代码
SpringBoot+vue 大文件分片下载
pscool的博客
08-05 2587
（Range请求交互过程可以参考这个里面的截图）// 文件总大小(需要请求后端获得)// 定义 存储所有的分片的数组。// 组合chunks到单个文件。这里面的代码实现，完全可以参考。// 文件总大小不足1个分片。'分片索引不可超过分片数量'// 分片下载大小 5MB。// 获取文件总大小。
Vue+SpringBoot实现文件的分片下载
Tz.的博客
06-18 2054
文件的分片下载顾名思义就是将文件分成一片一片，每次请求只下载一片，最后将文件进行整合下载，目的是为了防止文件大的情况,出现系统崩溃。SpringBoot后端实现文件的分片。
Vue、Springboot 大文件分片下载、多线程下载
dip_chao的博客
04-30 2630
解决大文件上传超时问题，使用Range支持，对文件进行分片下载。
vue 大文件切片下载
liuxi_happy的博客
10-20 1062
前提是你上传的时候也是切片上传，下载的时候后端给你返回的是一个文件id的数组，如果是你就可以用下面的方法。
springboot+vue实现超大文件分片极速上传与下载完整前后端源码
10-15
基于springboot与vue.js开发的前后端分离的超大文件分片上传下载系统，拥有简洁漂亮的界面，实现了G级别文件极速上传下载，断点续传以及秒传功能
Vue + ElementPlus + SpringBoot + Minio + AmazonS3 在Web端浏览器实现多线程分片上传解决方案，以及踩坑过程，未完善
qq_38050728的博客
11-26 619
现在网上大部分的分片上传存在的问题，基本都是复制粘贴的，没差，要不就是搞些收费的，我也懒得去花钱看，毕竟这个技术又不是那种独特唯一的，而且大部分没办法进行前后端联合的分片上传，要不就先把文件上出纳到服务端，然后分片上传进文件服务器，我参考整理了以下的文档链接，这个是可以进行分片上传的，且代码完整Minio分片上传、断点续传、分片下载、秒传、暂停（断点）下载（Java版-附源码地址）你们参考这里也是可以的，这个方案也是可行的，接下来给出的是我的处理方案。
阿里云oss文件分片、断点续传上传
m0_49106791的博客
08-18 6767
阿里云oss文件分片、断点续传上传 1、概述 把文件上传到阿里云oss上有两种上传方案： （1） 表单提交 （2）阿里云sdk 表单提交操作简单只需要向bucket所在地址发起post请求，并携带上签名，具体的可以由javaScript在前端生成，或者是由自己项目服务端生成，上传文件时需要先获取签名然后再携带上签名的参数向oss服务器上传文件。表单操作便捷，但有三大痛点，第一点是它不支持断点重传，第二它不支持分片上传，第三，它对批量上传不太友好，我曾经实践过，使用表单提交获取的签名只能使用一次，要想通过表单
【Spring Boot文件上传与下载】：高效资源管理，校园资料分享新篇章
本文全面探讨了Spring Boot框架下文件上传与下载的基础知识、实现、优化以及安全性和兼容性问题。首先，我们介绍了文件上传和下载的基本原理，包括HTTP协议中文件的传输机制、MIME类型解析以及流媒体技术。接着，...
Spring面试题2
最新发布
winks3的博客
02-21 397
IOC其实就是控制反转，依赖注入（DI）是SpringIOC的一种实现方式IOC（Inversion of Control）：IOC指将对象的创建和管理权交给Spring容器（如）统一控制。传统开发中，对象通过new主动创建依赖，而IoC模式下，容器负责对象的生命周期和依赖关系DI（Dependency Injection）：是IoC的具体实现方式，指容器在运行时动态将依赖对象注入到目标组件中依赖注入的两种实现方式。
前端大文件分片下载解决方案，没用你来砍我
ygxyvip的博客
10-14 6743
【真】超大文件下载，断点续传、进度展示
前端vue后端go实现大文件分片下载
Taboo
02-27 903
先获取文件大小，然后将文件切片传输给前端，前端再按顺序组合所有切片。
大文件分片下载(文件流形式)
qq_41069755的博客
02-25 1520
大文件分片下载(文件流的形式)
vue3+element 分片上传 分片下载功能实现
weixin_43485503的博客
03-17 5204
vue3+element 分片上传 分片下载功能实现
SpringBoot+vue文件上传&下载&预览&大文件分片上传&文件上传进度
pscool的博客
05-03 1万+
/ 上传完文件后, 将value置为空, 以避免下次选择同样的图片而不会触发input file的change事件。// (注意清空value后，将不能再从input file中获取file，而原先的file仍然能够使用)// 这种传参方式, 在axios的index.d.ts中可以看到。// 因为可能选择多个文件, 所以这里是个数组。// 可以有下面2种方式, 来上传文件。// 上传前, 可以预览该图片。
vue 批量大文件上传下载
Mr_Zang666的博客
03-25 995
核心原理： 该项目核心就是文件分块上传。前后端要高度配合，需要双方约定好一些数据，才能完成大文件分块，我们在项目中要重点解决的以下问题。 *如何分片； *如何合成一个文件； *中断了从哪个分片开始。 如何分，利用强大的js库，来减轻我们的工作，市场上已经能有关于大文件分块的轮子，虽然程序员的天性曾迫使我重新造轮子。但是因为时间的关系还有工作的关系，我只能罢休了。最后我选择了百...
Vue使用AWS s3进行大文件的分片上传、断点续传、下载（将文件上传进度显示）
热门推荐
qq_45634989的博客
10-14 1万+
Vue使用AWS s3进行大文件的分片上传、断点续传、下载（将文件上传进度显示）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

算法小生Đ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值