Spring Boot 分片上傳、斷點續傳、大文件上傳、秒傳，應有盡有，建議收藏！！

来源:https://www.cnblogs.com/javastack/archive/2023/03/13/17210719.html
-Advertisement-
Play Games

文件上傳是一個老生常談的話題了，在文件相對比較小的情況下，可以直接把文件轉化為位元組流上傳到伺服器，但在文件比較大的情況下，用普通的方式進行上傳，這可不是一個好的辦法，畢竟很少有人會忍受，當文件上傳到一半中斷後，繼續上傳卻只能重頭開始上傳，這種讓人不爽的體驗。那有沒有比較好的上傳體驗呢，答案有的，就是 ...


文件上傳是一個老生常談的話題了，在文件相對比較小的情況下，可以直接把文件轉化為位元組流上傳到伺服器，但在文件比較大的情況下，用普通的方式進行上傳，這可不是一個好的辦法，畢竟很少有人會忍受，當文件上傳到一半中斷後，繼續上傳卻只能重頭開始上傳，這種讓人不爽的體驗。那有沒有比較好的上傳體驗呢，答案有的，就是下邊要介紹的幾種上傳方式。

1、分片上傳

1.1 什麼是分片上傳

分片上傳，就是將所要上傳的文件，按照一定的大小，將整個文件分隔成多個數據塊（我們稱之為Part）來進行分別上傳，上傳完之後再由服務端對所有上傳的文件進行彙總整合成原始的文件。

1.2 分片上傳的場景

  • 大文件上傳
  • 網路環境環境不好，存在需要重傳風險的場景

2斷點續傳

2.1 什麼是斷點續傳

斷點續傳是在下載或上傳時，將下載或上傳任務（一個文件或一個壓縮包）人為的劃分為幾個部分，每一個部分採用一個線程進行上傳或下載，如果碰到網路故障，可以從已經上傳或下載的部分開始繼續上傳或者下載未完成的部分，而沒有必要從頭開始上傳或者下載。

本文的斷點續傳主要是針對斷點上傳場景。

2.2 應用場景

斷點續傳可以看成是分片上傳的一個衍生，因此可以使用分片上傳的場景，都可以使用斷點續傳。

2.3 實現斷點續傳的核心邏輯

在分片上傳的過程中，如果因為系統崩潰或者網路中斷等異常因素導致上傳中斷，這時候客戶端需要記錄上傳的進度。在之後支持再次上傳時，可以繼續從上次上傳中斷的地方進行繼續上傳。

為了避免客戶端在上傳之後的進度數據被刪除而導致重新開始從頭上傳的問題，服務端也可以提供相應的介面便於客戶端對已經上傳的分片數據進行查詢，從而使客戶端知道已經上傳的分片數據，從而從下一個分片數據開始繼續上傳。

整體的過程如下：

  1. 前端將文件安裝百分比進行計算,每次上傳文件的百分之一(文件分片),給文件分片做上序號
  2. 後端將前端每次上傳的文件,放入到緩存目錄
  3. 等待前端將全部的文件內容都上傳完畢後,發送一個合併請求
  4. 後端使用RandomAccessFile進多線程讀取所有的分片文件,一個線程一個分片
  5. 後端每個線程按照序號將分片的文件寫入到目標文件中
  6. 在上傳文件的過程中發生斷網了或者手動暫停了,下次上傳的時候發送續傳請求,讓後端刪除最後一個分片
  7. 前端重新發送上次的文件分片

2.4 實現流程步驟

方案一，常規步驟

  • 將需要上傳的文件按照一定的分割規則，分割成相同大小的數據塊；
  • 初始化一個分片上傳任務，返回本次分片上傳唯一標識；
  • 按照一定的策略（串列或並行）發送各個分片數據塊；
  • 發送完成後，服務端根據判斷數據上傳是否完整，如果完整，則進行數據塊合成得到原始文件。

方案二、本文實現的步驟

  • 前端（客戶端）需要根據固定大小對文件進行分片，請求後端（服務端）時要帶上分片序號和大小。
  • 服務端創建conf文件用來記錄分塊位置，conf文件長度為總分片數，每上傳一個分塊即向conf文件中寫入一個127，那麼沒上傳的位置就是預設的0,已上傳的就是Byte.MAX_VALUE 127（這步是實現斷點續傳和秒傳的核心步驟）
  • 伺服器按照請求數據中給的分片序號和每片分塊大小（分片大小是固定且一樣的）算出開始位置，與讀取到的文件片段數據，寫入文件。

整體的實現流程如下：

3、分片上傳/斷點上傳代碼實現

3.1 前端實現

前端的File對象是特殊類型的Blob，且可以用在任意的Blob類型的上下文中。

就是說能夠處理Blob對象的方法也能處理File對象。在Blob的方法里有有一個Slice方法可以幫完成切片。

推薦一個開源免費的 Spring Boot 最全教程：

https://github.com/javastacks/spring-boot-best-practice

核心代碼：

fileMD5 (files) {
  // 計算文件md5
  return new  Promise((resolve,reject) => {
    const fileReader = new FileReader();
    const piece = Math.ceil(files.size / this.pieceSize);
    const nextPiece = () => {
      let start = currentPieces * this.pieceSize;
      let end = start * this.pieceSize >= files.size ? files.size : start + this.pieceSize;
      fileReader.readAsArrayBuffer(files.slice(start,end));
    };

    let currentPieces = 0;
    fileReader.onload = (event) => {
      let e = window.event || event;
      this.spark.append(e.target.result);
      currentPieces++
      if (currentPieces < piece) {
        nextPiece()
      } else {
        resolve({fileName: files.name, fileMd5: this.spark.end()})
      }
    }
    // fileReader.onerror = (err => { reject(err) })
    nextPiece()
  })
}

當然如果我們是vue項目的話還有更好的選擇，我們可以使用一些開源的框架，本文推薦使用vue-simple-uploader 實現文件分片上傳、斷點續傳及秒傳。

當然我們也可以採用百度提供的webuploader的插件，進行分片。

操作方式也特別簡單，直接按照官方文檔給出的操作進行即可。

3.2 後端寫入文件

後端用兩種方式實現文件寫入：

  • RandomAccessFile
  • MappedByteBuffer

在向下學習之前，我們先簡單瞭解一下這兩個類的使用

RandomAccessFile

Java除了File類之外，還提供了專門處理文件的類，即RandomAccessFile（隨機訪問文件）類。

該類是Java語言中功能最為豐富的文件訪問類，它提供了眾多的文件訪問方法。RandomAccessFile類支持“隨機訪問”方式，這裡“隨機”是指可以跳轉到文件的任意位置處讀寫數據。在訪問一個文件的時候，不必把文件從頭讀到尾，而是希望像訪問一個資料庫一樣“隨心所欲”地訪問一個文件的某個部分，這時使用RandomAccessFile類就是最佳選擇。

RandomAccessFile對象類有個位置指示器，指向當前讀寫處的位置，當前讀寫n個位元組後，文件指示器將指向這n個位元組後面的下一個位元組處。

剛打開文件時，文件指示器指向文件的開頭處，可以移動文件指示器到新的位置，隨後的讀寫操作將從新的位置開始。

RandomAccessFile類在數據等長記錄格式文件的隨機（相對順序而言）讀取時有很大的優勢，但該類僅限於操作文件，不能訪問其他的I/O設備，如網路、記憶體映像等。

RandomAccessFile類的構造方法如下所示：

//創建隨機存儲文件流，文件屬性由參數File對象指定
RandomAccessFile(File file , String mode)

//創建隨機存儲文件流，文件名由參數name指定
RandomAccessFile(String name , String mode)

這兩個構造方法均涉及到一個String類型的參數mode，它決定隨機存儲文件流的操作模式，其中mode值及對應的含義如下：

  • “r”：以只讀的方式打開，調用該對象的任何write（寫）方法都會導致IOException異常
  • “rw”：以讀、寫方式打開，支持文件的讀取或寫入。若文件不存在，則創建之。
  • “rws”：以讀、寫方式打開，與“rw”不同的是，還要對文件內容的每次更新都同步更新到潛在的存儲設備中去。這裡的“s”表示synchronous（同步）的意思
  • “rwd”：以讀、寫方式打開，與“rw”不同的是，還要對文件內容的每次更新都同步更新到潛在的存儲設備中去。使用“rwd”模式僅要求將文件的內容更新到存儲設備中，而使用“rws”模式除了更新文件的內容，還要更新文件的元數據（metadata），因此至少要求1次低級別的I/O操作
import java.io.RandomAccessFile;
import java.nio.charset.StandardCharsets;
public class RandomFileTest {
    private static final String filePath = "C:\\Users\\NineSun\\Desktop\\employee.txt";

    public static void main(String[] args) throws Exception {
        Employee e1 = new Employee("zhangsan", 23);
        Employee e2 = new Employee("lisi", 24);
        Employee e3 = new Employee("wangwu", 25);
        RandomAccessFile ra = new RandomAccessFile(filePath, "rw");
        ra.write(e1.name.getBytes(StandardCharsets.UTF_8));//防止寫入文件亂碼
        ra.writeInt(e1.age);
        ra.write(e2.name.getBytes());
        ra.writeInt(e2.age);
        ra.write(e3.name.getBytes());
        ra.writeInt(e3.age);
        ra.close();
        RandomAccessFile raf = new RandomAccessFile(filePath, "r");
        int len = 8;
        raf.skipBytes(12);//跳過第一個員工的信息，其姓名8位元組，年齡4位元組
        System.out.println("第二個員工信息：");
        String str = "";
        for (int i = 0; i < len; i++) {
            str = str + (char) raf.readByte();
        }
        System.out.println("name:" + str);
        System.out.println("age:" + raf.readInt());
        System.out.println("第一個員工信息：");
        raf.seek(0);//將文件指針移動到文件開始位置
        str = "";
        for (int i = 0; i < len; i++) {
            str = str + (char) raf.readByte();
        }
        System.out.println("name:" + str);
        System.out.println("age:" + raf.readInt());
        System.out.println("第三個員工信息：");
        raf.skipBytes(12);//跳過第二個員工的信息
        str = "";
        for (int i = 0; i < len; i++) {
            str = str + (char) raf.readByte();
        }
        System.out.println("name:" + str);
        System.out.println("age:" + raf.readInt());
        raf.close();
    }
}

class Employee {
    String name;
    int age;
    final static int LEN = 8;

    public Employee(String name, int age) {
        if (name.length() > LEN) {
            name = name.substring(0, 8);
        } else {
            while (name.length() < LEN) {
                name = name + "\u0000";
            }
            this.name = name;
            this.age = age;
        }
    }
}

MappedByteBuffer

java io操作中通常採用BufferedReader，BufferedInputStream等帶緩衝的IO類處理大文件，不過java nio中引入了一種基於MappedByteBuffer操作大文件的方式，其讀寫性能極高

3.3 進行寫入操作的核心代碼

為了節約文章篇幅，下麵我只展示核心代碼，完整代碼可以在文末進行下載

RandomAccessFile實現方式

@UploadMode(mode = UploadModeEnum.RANDOM_ACCESS)
@Slf4j
public class RandomAccessUploadStrategy extends SliceUploadTemplate {

  @Autowired
  private FilePathUtil filePathUtil;

  @Value("${upload.chunkSize}")
  private long defaultChunkSize;

  @Override
  public boolean upload(FileUploadRequestDTO param) {
    RandomAccessFile accessTmpFile = null;
    try {
      String uploadDirPath = filePathUtil.getPath(param);
      File tmpFile = super.createTmpFile(param);
      accessTmpFile = new RandomAccessFile(tmpFile, "rw");
      //這個必須與前端設定的值一致
      long chunkSize = Objects.isNull(param.getChunkSize()) ? defaultChunkSize * 1024 * 1024
          : param.getChunkSize();
      long offset = chunkSize * param.getChunk();
      //定位到該分片的偏移量
      accessTmpFile.seek(offset);
      //寫入該分片數據
      accessTmpFile.write(param.getFile().getBytes());
      boolean isOk = super.checkAndSetUploadProgress(param, uploadDirPath);
      return isOk;
    } catch (IOException e) {
      log.error(e.getMessage(), e);
    } finally {
      FileUtil.close(accessTmpFile);
    }
    return false;
  }
}

MappedByteBuffer實現方式

@UploadMode(mode = UploadModeEnum.MAPPED_BYTEBUFFER)
@Slf4j
public class MappedByteBufferUploadStrategy extends SliceUploadTemplate {

  @Autowired
  private FilePathUtil filePathUtil;

  @Value("${upload.chunkSize}")
  private long defaultChunkSize;

  @Override
  public boolean upload(FileUploadRequestDTO param) {

    RandomAccessFile tempRaf = null;
    FileChannel fileChannel = null;
    MappedByteBuffer mappedByteBuffer = null;
    try {
      String uploadDirPath = filePathUtil.getPath(param);
      File tmpFile = super.createTmpFile(param);
      tempRaf = new RandomAccessFile(tmpFile, "rw");
      fileChannel = tempRaf.getChannel();

      long chunkSize = Objects.isNull(param.getChunkSize()) ? defaultChunkSize * 1024 * 1024
          : param.getChunkSize();
      //寫入該分片數據
      long offset = chunkSize * param.getChunk();
      byte[] fileData = param.getFile().getBytes();
      mappedByteBuffer = fileChannel
          .map(FileChannel.MapMode.READ_WRITE, offset, fileData.length);
      mappedByteBuffer.put(fileData);
      boolean isOk = super.checkAndSetUploadProgress(param, uploadDirPath);
      return isOk;
    } catch (IOException e) {
      log.error(e.getMessage(), e);
    } finally {
      FileUtil.freedMappedByteBuffer(mappedByteBuffer);
      FileUtil.close(fileChannel);
      FileUtil.close(tempRaf);

    }

    return false;
  }
}

文件操作核心模板類代碼

@Slf4j
public abstract class SliceUploadTemplate implements SliceUploadStrategy {

  public abstract boolean upload(FileUploadRequestDTO param);

  protected File createTmpFile(FileUploadRequestDTO param) {

    FilePathUtil filePathUtil = SpringContextHolder.getBean(FilePathUtil.class);
    param.setPath(FileUtil.withoutHeadAndTailDiagonal(param.getPath()));
    String fileName = param.getFile().getOriginalFilename();
    String uploadDirPath = filePathUtil.getPath(param);
    String tempFileName = fileName + "_tmp";
    File tmpDir = new File(uploadDirPath);
    File tmpFile = new File(uploadDirPath, tempFileName);
    if (!tmpDir.exists()) {
      tmpDir.mkdirs();
    }
    return tmpFile;
  }

  @Override
  public FileUploadDTO sliceUpload(FileUploadRequestDTO param) {

    boolean isOk = this.upload(param);
    if (isOk) {
      File tmpFile = this.createTmpFile(param);
      FileUploadDTO fileUploadDTO = this.saveAndFileUploadDTO(param.getFile().getOriginalFilename(), tmpFile);
      return fileUploadDTO;
    }
    String md5 = FileMD5Util.getFileMD5(param.getFile());

    Map<Integer, String> map = new HashMap<>();
    map.put(param.getChunk(), md5);
    return FileUploadDTO.builder().chunkMd5Info(map).build();
  }

  /**
   * 檢查並修改文件上傳進度
   */
  public boolean checkAndSetUploadProgress(FileUploadRequestDTO param, String uploadDirPath) {

    String fileName = param.getFile().getOriginalFilename();
    File confFile = new File(uploadDirPath, fileName + ".conf");
    byte isComplete = 0;
    RandomAccessFile accessConfFile = null;
    try {
      accessConfFile = new RandomAccessFile(confFile, "rw");
      //把該分段標記為 true 表示完成
      System.out.println("set part " + param.getChunk() + " complete");
      //創建conf文件文件長度為總分片數，每上傳一個分塊即向conf文件中寫入一個127，那麼沒上傳的位置就是預設0,已上傳的就是Byte.MAX_VALUE 127
      accessConfFile.setLength(param.getChunks());
      accessConfFile.seek(param.getChunk());
      accessConfFile.write(Byte.MAX_VALUE);

      //completeList 檢查是否全部完成,如果數組裡是否全部都是127(全部分片都成功上傳)
      byte[] completeList = FileUtils.readFileToByteArray(confFile);
      isComplete = Byte.MAX_VALUE;
      for (int i = 0; i < completeList.length && isComplete == Byte.MAX_VALUE; i++) {
        //與運算, 如果有部分沒有完成則 isComplete 不是 Byte.MAX_VALUE
        isComplete = (byte) (isComplete & completeList[i]);
        System.out.println("check part " + i + " complete?:" + completeList[i]);
      }

    } catch (IOException e) {
      log.error(e.getMessage(), e);
    } finally {
      FileUtil.close(accessConfFile);
    }
    boolean isOk = setUploadProgress2Redis(param, uploadDirPath, fileName, confFile, isComplete);
    return isOk;
  }

  /**
   * 把上傳進度信息存進redis
   */
  private boolean setUploadProgress2Redis(FileUploadRequestDTO param, String uploadDirPath,
      String fileName, File confFile, byte isComplete) {

    RedisUtil redisUtil = SpringContextHolder.getBean(RedisUtil.class);
    if (isComplete == Byte.MAX_VALUE) {
      redisUtil.hset(FileConstant.FILE_UPLOAD_STATUS, param.getMd5(), "true");
      redisUtil.del(FileConstant.FILE_MD5_KEY + param.getMd5());
      confFile.delete();
      return true;
    } else {
      if (!redisUtil.hHasKey(FileConstant.FILE_UPLOAD_STATUS, param.getMd5())) {
        redisUtil.hset(FileConstant.FILE_UPLOAD_STATUS, param.getMd5(), "false");
        redisUtil.set(FileConstant.FILE_MD5_KEY + param.getMd5(),
            uploadDirPath + FileConstant.FILE_SEPARATORCHAR + fileName + ".conf");
      }

      return false;
    }
  }

  /**
   * 保存文件操作
   */
  public FileUploadDTO saveAndFileUploadDTO(String fileName, File tmpFile) {

    FileUploadDTO fileUploadDTO = null;

    try {

      fileUploadDTO = renameFile(tmpFile, fileName);
      if (fileUploadDTO.isUploadComplete()) {
        System.out
            .println("upload complete !!" + fileUploadDTO.isUploadComplete() + " name=" + fileName);
        //TODO 保存文件信息到資料庫

      }

    } catch (Exception e) {
      log.error(e.getMessage(), e);
    } finally {

    }
    return fileUploadDTO;
  }

  /**
   * 文件重命名
   *
   * @param toBeRenamed 將要修改名字的文件
   * @param toFileNewName 新的名字
   */
  private FileUploadDTO renameFile(File toBeRenamed, String toFileNewName) {
    //檢查要重命名的文件是否存在，是否是文件
    FileUploadDTO fileUploadDTO = new FileUploadDTO();
    if (!toBeRenamed.exists() || toBeRenamed.isDirectory()) {
      log.info("File does not exist: {}", toBeRenamed.getName());
      fileUploadDTO.setUploadComplete(false);
      return fileUploadDTO;
    }
    String ext = FileUtil.getExtension(toFileNewName);
    String p = toBeRenamed.getParent();
    String filePath = p + FileConstant.FILE_SEPARATORCHAR + toFileNewName;
    File newFile = new File(filePath);
    //修改文件名
    boolean uploadFlag = toBeRenamed.renameTo(newFile);

    fileUploadDTO.setMtime(DateUtil.getCurrentTimeStamp());
    fileUploadDTO.setUploadComplete(uploadFlag);
    fileUploadDTO.setPath(filePath);
    fileUploadDTO.setSize(newFile.length());
    fileUploadDTO.setFileExt(ext);
    fileUploadDTO.setFileId(toFileNewName);

    return fileUploadDTO;
  }

}

上傳介面

@PostMapping(value = "/upload")
@ResponseBody
public Result<FileUploadDTO> upload(FileUploadRequestDTO fileUploadRequestDTO) throws IOException {

    boolean isMultipart = ServletFileUpload.isMultipartContent(request);
    FileUploadDTO fileUploadDTO = null;
    if (isMultipart) {

      StopWatch stopWatch = new StopWatch();
      stopWatch.start("upload");
      if (fileUploadRequestDTO.getChunk() != null && fileUploadRequestDTO.getChunks() > 0) {
        fileUploadDTO = fileService.sliceUpload(fileUploadRequestDTO);
      } else {
        fileUploadDTO = fileService.upload(fileUploadRequestDTO);
      }
      stopWatch.stop();
      log.info("{}",stopWatch.prettyPrint());

      return new Result<FileUploadDTO>().setData(fileUploadDTO);
    }

    throw new BizException("上傳失敗", 406);
}

4、秒傳

4.1 什麼是秒傳

通俗的說，你把要上傳的東西上傳，伺服器會先做MD5校驗，如果伺服器上有一樣的東西，它就直接給你個新地址，其實你下載的都是伺服器上的同一個文件，想要不秒傳，其實只要讓MD5改變，就是對文件本身做一下修改（改名字不行），例如一個文本文件，你多加幾個字，MD5就變了，就不會秒傳了。

4.2 實現的秒傳核心邏輯

利用redis的set方法存放文件上傳狀態，其中key為文件上傳的md5，value為是否上傳完成的標誌位，當標誌位true為上傳已經完成，此時如果有相同文件上傳，則進入秒傳邏輯。

如果標誌位為false，則說明還沒上傳完成，此時需要在調用set的方法，保存塊號文件記錄的路徑，其中，key為上傳文件md5加一個固定首碼，value為塊號文件記錄路徑

4.3 核心代碼

private boolean setUploadProgress2Redis(FileUploadRequestDTO param, String uploadDirPath,
      String fileName, File confFile, byte isComplete) {

    RedisUtil redisUtil = SpringContextHolder.getBean(RedisUtil.class);
    if (isComplete == Byte.MAX_VALUE) {
      redisUtil.hset(FileConstant.FILE_UPLOAD_STATUS, param.getMd5(), "true");
      redisUtil.del(FileConstant.FILE_MD5_KEY + param.getMd5());
      confFile.delete();
      return true;
    } else {
      if (!redisUtil.hHasKey(FileConstant.FILE_UPLOAD_STATUS, param.getMd5())) {
        redisUtil.hset(FileConstant.FILE_UPLOAD_STATUS, param.getMd5(), "false");
        redisUtil.set(FileConstant.FILE_MD5_KEY + param.getMd5(),
            uploadDirPath + FileConstant.FILE_SEPARATORCHAR + fileName + ".conf");
      }

      return false;
    }
}

5、總結

在實現分片上傳的過程，需要前端和後端配合，比如前後端的上傳塊號的文件大小，前後端必須得要一致，否則上傳就會有問題。

其次文件相關操作正常都是要搭建一個文件伺服器的，比如使用fastdfs、hdfs等。

版權聲明：本文為CSDN博主「ZNineSun」的原創文章，遵循CC 4.0 BY-SA版權協議，轉載請附上原文出處鏈接及本聲明。原文鏈接：https://blog.csdn.net/zhiyikeji/article/details/128242775

近期熱文推薦：

1.1,000+ 道 Java面試題及答案整理(2022最新版)

2.勁爆！Java 協程要來了。。。

3.Spring Boot 2.x 教程，太全了！

4.別再寫滿屏的爆爆爆炸類了，試試裝飾器模式，這才是優雅的方式！！

5.《Java開發手冊（嵩山版）》最新發佈，速速下載！

覺得不錯，別忘了隨手點贊+轉發哦！


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 過濾器和攔截器總結
    1.總結內容參考：https://blog.csdn.net/dhklsl/article/details/127533485 2.下麵是本人工作項目中實戰到的案例（具體業務的實體沒必要關註） 2.1.攔截器使用 點擊查看代碼 import java.lang.invoke.MethodHandle ...
  • IDEA： 如何導入項目模塊 以及 將 Java程式打包 JAR 詳細步驟
    IDEA： 如何導入項目模塊 以及 將 Java程式打包 JAR 詳細步驟 、 @ IDEA 導入項目模塊 Module 一. 創建一個空項目 想要導入模塊 Module ，我們需要先創建一個項目，因為 Module模塊在 IDEA 中是存在於項目下的。 這裡我們先創建一個空項目，當然已經有項目了， ...
  • 桌面文件又多又亂？教你用Python一鍵清理，只需20行代碼輕鬆實現！
    我這個人比較懶，總是喜歡把收到的重要文件，或者比較緊急的文件放到桌面，久而久之，桌面或者文件夾越來越亂 。 不知道大家是不是像我一樣的 我滴媽呀，看著就很崩潰！ 之所以放在桌面上，主要是為了下次使用的時候好找 但是，其實，結果…並沒有 結果，我的馬馬~~ 反而更難找了 也不知道越亂越好找這句話是誰第 ...
  • 面試官：如何在千萬級數據中查詢 10W 的數據，都有什麼方案？
    作者：變速風聲 鏈接：https://juejin.cn/post/7104090532015505416 前言 在開發中遇到一個業務訴求，需要在千萬量級的底池數據中篩選出不超過 10W 的數據，並根據配置的權重規則進行排序、打散（如同一個類目下的商品數據不能連續出現 3 次）。 下麵對該業務訴求的 ...
  • 驅動開發：配置Visual Studio驅動開發環境
    在正式開始驅動開發之前，需要自行搭建驅動開發的必要環境，首先我們需要安裝`Visual Studio 2013`這款功能強大的程式開發工具，在課件內請雙擊`ISO`文件並運行內部的`vs_ultimate.exe`安裝包，`Visual Studio`的安裝非常的簡單，您只需要按照提示全部選擇預設參... ...
  • C++語言線上代碼運行編譯工具推薦
    C++語言線上運行編譯,是一款可線上編程編輯器,在編輯器上輸入C++語言代碼,點擊運行,可線上編譯運行C++語言,C++語言代碼線上運行調試,C++語言線上編譯,可快速線上測試您的C++語言代碼,線上編譯C++語言代碼發現是否存在錯誤,如果代碼測試通過，將會輸出編譯後的結果。 該線上工具由IT寶庫提 ...
  • Python3程式捕獲Ctrl+C終止信號
    當我們準備去殺死一個進程時，從程式設計的本身來考慮，我們應當要設計一定的保護方案來確保程式被非正常終止時，相應的計算結果也能夠被很好的保存下來。在Python中可以使用signal.signal函數來實現這樣的功能，但是如果要實現數據的保存功能，需要結合一個實際的類來實現。 ...
  • HDF格式遙感影像批量轉為TIFF格式：ArcPy實現
    本文介紹基於Python中ArcPy模塊，實現大量HDF格式柵格圖像文件批量轉換為TIFF格式的方法。 首先，來看看我們想要實現的需求。 在一個名為HDF的文件夾下，有五個子文件夾；每一個子文件夾中，都存儲了大量的.hdf格式的柵格遙感影像數據。 我們在其中任選一個子文件夾，來看看其中所含的文件。 ...
一周排行
    -Advertisement-
    Play Games
  • GoF之工廠模式
    GoF之工廠模式 @目錄GoF之工廠模式每博一文案1. 簡單說明“23種設計模式”1.2 介紹工廠模式的三種形態1.3 簡單工廠模式（靜態工廠模式）1.3.1 簡單工廠模式的優缺點:1.4 工廠方法模式1.4.1 工廠方法模式的優缺點:1.5 抽象工廠模式1.6 抽象工廠模式的優缺點：2. 總結:3 ...
  • dotnet C# 簡單的追加文件夾到 ZipArchive 壓縮文件的方法
    新改進提供的Taurus Rpc 功能，可以簡化微服務間的調用，同時可以不用再手動輸出模塊名稱，或調用路徑，包括負載均衡，這一切，由框架實現並提供了。新的Taurus Rpc 功能，將使得服務間的調用，更加輕鬆、簡約、高效。 ...
  • Elasticsearch 系列（六）- ES數據同步和ES集群
    本章將和大家分享ES的數據同步方案和ES集群相關知識。廢話不多說，下麵我們直接進入主題。 一、ES數據同步 1、數據同步問題 Elasticsearch中的酒店數據來自於mysql資料庫，因此mysql數據發生改變時，Elasticsearch也必須跟著改變，這個就是Elasticsearch與my ...
  • 自動化測試數據生成：Asp.Net Core單元測試利器AutoFixture詳解
    引言 在我們之前的文章中介紹過使用Bogus生成模擬測試數據，今天來講解一下功能更加強大自動生成測試數據的工具的庫"AutoFixture"。 什麼是AutoFixture? AutoFixture 是一個針對 .NET 的開源庫，旨在最大程度地減少單元測試中的“安排（Arrange）”階段，以提高 ...
  • .NET Emit 入門教程：第七部分：實戰項目1：將 DbDataReader 轉實體
    經過前面幾個部分學習，相信學過的同學已經能夠掌握 .NET Emit 這種中間語言，並能使得它來編寫一些應用，以提高程式的性能。隨著 IL 指令篇的結束，本系列也已經接近尾聲，在這接近結束的最後，會提供幾個可供直接使用的示例，以供大伙分析或使用在項目中。 ...
  • Windows下綁定線程到指定的CPU核心
    當從不同來源導入Excel數據時，可能存在重覆的記錄。為了確保數據的準確性，通常需要刪除這些重覆的行。手動查找並刪除可能會非常耗費時間，而通過編程腳本則可以實現在短時間內處理大量數據。本文將提供一個使用C# 快速查找並刪除Excel重覆項的免費解決方案。 以下是實現步驟： 1. 首先安裝免費.NET ...
  • mORMot 1.18 第07章 簡單的讀寫操作
    C++ 異常處理 C++ 異常處理機制允許程式在運行時處理錯誤或意外情況。它提供了捕獲和處理錯誤的一種結構化方式，使程式更加健壯和可靠。 異常處理的基本概念： 異常: 程式在運行時發生的錯誤或意外情況。 拋出異常: 使用 throw 關鍵字將異常傳遞給調用堆棧。 捕獲異常: 使用 try-catch ...
  • mORMot 1.18 第06章 概念
    優秀且經驗豐富的Java開發人員的特征之一是對API的廣泛瞭解，包括JDK和第三方庫。 我花了很多時間來學習API，尤其是在閱讀了Effective Java 3rd Edition之後 ，Joshua Bloch建議在Java 3rd Edition中使用現有的API進行開發，而不是為常見的東西編 ...
  • php 開發規範
    框架 · 使用laravel框架，原因：tp的框架路由和orm沒有laravel好用 · 使用強制路由，方便介面多時，分多版本，分文件夾等操作 介面 · 介面開發註意欄位類型，欄位是int，查詢成功失敗都要返回int（對接java等強類型語言方便） · 查詢介面用GET、其他用POST 代碼 · 所 ...
  • 2024 年 4 月 28 日 周日 晴 熱（1253 字）
    正文 下午找企業的人去鎮上做貸後。 車上聽同事跟那個司機對罵，火星子都快出來了。司機跟那同事更熟一些，連我在內一共就三個人，同事那一手指桑罵槐給我都聽愣了。司機也是老社會人了，馬上聽出來了，為那個無辜的企業經辦人辯護，實際上是為自己辯護。 “這個事情你不能怪企業。”“但他們總不能讓銀行的人全權負責， ...
所有分類