Spring Boot 分片上传、断点续传、大文件上传、秒传，应有尽有

文件上传是一个老生常谈的话题了，在文件相对比较小的情况下，可以直接把文件转化为字节流上传到服务器，但在文件比较大的情况下，用普通的方式进行上传，这可不是一个好的办法，毕竟很少有人会忍受，当文件上传到一半中断后，继续上传却只能重头开始上传，这种让人不爽的体验。那有没有比较好的上传体验呢，答案有的，就是下边要介绍的几种上传方式。

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方法可以帮完成切片。

核心代码：

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 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 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().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等。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/698276.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

《Brave New Words 》5.1 传递真相：偏见和虚假信息现状

《Brave New Words 》5.1 传递真相：偏见和虚假信息现状

Part V: Keeping Kids Safe 第五部分&#xff1a;确保孩子安全 Never travel faster than your guardian angel can fly. —Mother Teresa 永远不要比你的守护天使飞得更快。 ——特蕾莎修女 Distrust and caution are the parents of security. —Benjamin Franklin 不信任和谨…
阅读更多...
使用 actor-critic 方法来控制 CartPole-V0 游戏

使用 actor-critic 方法来控制 CartPole-V0 游戏

CartPole 介绍 在一个光滑的轨道上有个推车&#xff0c;杆子垂直微置在推车上&#xff0c;随时有倒的风险。系统每次对推车施加向左或者向右的力&#xff0c;但我们的目标是让杆子保持直立。杆子保持直立的每个时间单位都会获得 1 的奖励。但是当杆子与垂直方向成 15 度以上的…
阅读更多...
Java开发基础技能简介

Java开发基础技能简介

一、Java版本 JavaSE&#xff1a;标准版 JavaEE&#xff1a;企业版 二、IDEA工程中的模块 1.打开工程所在文件夹 鼠标右键点模块——open in——explorer 2.修改模块名 鼠标右键点模块——refactor-rename-rename module and directory 3.导出模块 ctrl c&#xff0c;…
阅读更多...
LLM系列：KVCache及优化方法

LLM系列：KVCache及优化方法

前言 Transformer encode-base模型&#xff0c;推理和训练过程高度统一&#xff08;差异仅仅是否存在反向&#xff09;&#xff0c;而decoder-base模型&#xff08;如GPT、LLama2&#xff09;&#xff0c;推理与训练差异性比较大&#xff1a; 自回归推理全量prompt增量tokenK…
阅读更多...
公司电脑文件防泄密软件系统——天锐绿盾 | 透明加密、防泄密系统

公司电脑文件防泄密软件系统——天锐绿盾 | 透明加密、防泄密系统

天锐绿盾是一款专业的企业信息安全防护软件&#xff0c;旨在防止公司内部文件的泄露。它提供了多种功能来保护敏感数据&#xff0c;确保企业信息的安全。 PC地址&#xff1a; https://isite.baidu.com/site/wjz012xr/2eae091d-1b97-4276-90bc-6757c5dfedee 以下是天锐绿盾的主…
阅读更多...
[Java基础揉碎]网络相关概念

[Java基础揉碎]网络相关概念

目录 网络通信 网络 ip地址 ​编辑 域名 ​编辑 网络协议 TCP和UDP 网络编程比较重要的的InetAddress类 Socket ​编辑 tcp字节流编程 案例一 案例二​编辑 案例三 网络上传文件 ​编辑​编辑 ​编辑 netstat tcp网络通信客户端也是通过端口和服务端进行通讯的…
阅读更多...
输入失调电流是什么？

输入失调电流是什么？

输入失调电流与输入补偿电流概念一样&#xff08;input offset current&#xff09;&#xff1a;同相减去反相输入端偏置电流的差值。这是由生产工艺导致同相与反相端的电流大小方向都会有所不同。 第一种情况&#xff1a;同相输入端减去反相输入端 第一种情况&#xff1a;同相…
阅读更多...
Elasticsearch 为时间序列数据带来存储优势

Elasticsearch 为时间序列数据带来存储优势

作者&#xff1a;来自 Elastic Martijn Van Groningen, Kostas Krikellas 背景 Elasticsearch 最近投资了对存储和查询时间序列数据的更好支持。存储效率一直是关注的主要领域&#xff0c;许多项目取得了巨大的成功&#xff0c;与将数据保存在标准索引中相比&#xff0c;可以节…
阅读更多...
耐用充电宝有哪些？优质充电宝到底选哪个？良心推荐！

耐用充电宝有哪些？优质充电宝到底选哪个？良心推荐！

在电量即生产力的现今时代&#xff0c;如何为移动设备寻找一位最佳的伴侣呢&#xff1f;一款耐用、优质的充电宝无疑是你的不二之选。今天我们将带您揭开市场隐藏的一面&#xff0c;揭示哪些充电宝品牌真正代表了耐用与品质的标杆。让我们一起深入了解并选购最适合自己的充电宝…
阅读更多...
MFC绘图

MFC绘图

文章目录 消息组成消息的作用获取消息翻译消息常见消息WM_DESTROYWM_SYSCOMMAND 消息循环的阻塞发送消息字符串资源加速键资源GDI绘图对象-画笔位图绘制文本绘制字体模式对话框动态库特点线程创建线程 互斥事件信号量 消息组成 窗口句柄消息ID消息的两个参数消息产生的时间消息…
阅读更多...
PGConf.dev 2024 ｜@PGer 你的问题已出海，来看看 Tom Lane 如何回复？

PGConf.dev 2024 ｜@PGer 你的问题已出海，来看看 Tom Lane 如何回复？

2024 PostgreSQL 开发大会&#xff08;pgconf.dev&#xff09;于5月8日在温哥华召开。瀚高IvorySQL发起留言互动活动——#PGConf.dev 2024数据世界因你不同#&#xff0c;已将部分用户想问的问题传递到PGConf.dev现场。 与会的大佬们对每一个问题都给予了认真的回复和解答。来看…
阅读更多...
ABB机器人修改IO信号的具体方法介绍

ABB机器人修改IO信号的具体方法介绍

ABB机器人修改IO信号的具体方法介绍 具体步骤可从参考以下内容： 导出IO配置文件 打开【控制面板】-【配置】-【I/O System】-【文件】-【‘EIO’另存为】，就可以保存IO配置文件【EIO.cfg】用RobotStudio软件打开EIO.cfg文件在软件界面，鼠标右击，选择【I/O信号数据编辑器】选…
阅读更多...
Flutter 实现dispose探测控件

Flutter 实现dispose探测控件

文章目录 前言一、什么是dispose探测控件&#xff1f;1、通常情况2、使用dispose探测控件 二、如何实现1、继承StatefulWidget2、定义dipose回调3、定义child4、重载Dispose方法5、build child 三、完整代码四、使用示例1、基本用法2、设置定义数据 总结 前言 开发flutter一般…
阅读更多...
单片机多个中断源时的设计思路，（51为例）工作寄存器R0-R7

单片机多个中断源时的设计思路，（51为例）工作寄存器R0-R7

51单片机中四组工作寄存器&#xff08;R0-R7&#xff09; 参考 可以看出每个工作寄存器区有8个字节即为R0-R7&#xff0c;当不指定使用哪个工作寄存器区的时候默认0区。其他工作区作为普通的RAM使用。特殊功能寄存器中有可以位寻址和不能位寻址的区域 下面文字引用 通过修改…
阅读更多...
晶泰科技即将登陆港交所：三年亏近55亿，二级市场信心待考

晶泰科技即将登陆港交所：三年亏近55亿，二级市场信心待考

《港湾商业观察》黄懿 有着“AI制药”之称的深圳晶泰科技有限公司&#xff08;以下简称&#xff0c;晶泰科技&#xff1b;02228.HK&#xff09;即将登陆港交所。 据日前消息&#xff0c;晶泰科技于2024年6月4日至6月7日招股&#xff0c;拟全球发售股份1.87373亿股&#xff0c…
阅读更多...
ES8.13 _bulk报错Malformed content, found extra data after parsing: START_OBJECT解决

ES8.13 _bulk报错Malformed content, found extra data after parsing: START_OBJECT解决

在使用elaticsearch8.13.0使用批量创建索引时&#xff0c;根据谷粒中说的es7.9方法去批量操作请求&#xff1a; http://127.0.0.1:9200/shop/_doc/_bulk 注意1&#xff1a;设置header为Content-Type:application/x-ndjson,否则请求报错&#xff1a; {"error": &qu…
阅读更多...
LeetCode | 2022.将一维数组转变为二维数组

LeetCode | 2022.将一维数组转变为二维数组

这道题思路比较简单&#xff0c;比较容易想到的是先判断m和n构成的二维数组在形式上是否可以由原来的数组转变而成&#xff0c;若不可以返回空数组&#xff0c;若可以直接用一个二重循环遍历一遍即可&#xff0c;时间复杂度 O ( n 2 ) O(n^2) O(n2) class Solution(object):de…
阅读更多...
史上最全，呕心沥血总结oracle推进SCN方法（六）

史上最全，呕心沥血总结oracle推进SCN方法（六）

作者介绍&#xff1a;老苏&#xff0c;10余年DBA工作运维经验&#xff0c;擅长Oracle、MySQL、PG数据库运维&#xff08;如安装迁移&#xff0c;性能优化、故障应急处理等&#xff09; 公众号&#xff1a;老苏畅谈运维 欢迎关注本人公众号&#xff0c;更多精彩与您分享。前面介…
阅读更多...
tmux 移植到ARM板端运行环境搭建

tmux 移植到ARM板端运行环境搭建

tmux源码下载&#xff1a; Home tmux/tmux Wiki GitHub 依赖的库代码下载&#xff1a; libevent&#xff1a; ncurses: 第一步&#xff1a;将以上三个代码解压放在同一个目录下&#xff0c;逐个编译 1. cd ./libevent-2.1.12-stable ./configure --host"arm-nextvp…
阅读更多...
北斗位置服务管理平台

北斗位置服务管理平台

平台简介 一直想做一款后台管理系统&#xff0c;同时可以管理人&#xff0c;车&#xff0c;物品&#xff0c;猫&#xff0c;狗&#xff0c;牛羊等一切可以移动的室外事物进行集中化管理&#xff0c;最初的需求聚焦——谁在哪儿&#xff01; 系统框架是基于当前最常用的RuoYi框架…
阅读更多...
最新文章

Copyright @ 2022~2023