DurkBlue博客

springBoot实现Redis分布式加锁功能

Wed, 08 Apr 2026 12:11:29 +0800

在Spring Boot中实现Redis分布式锁，你可以使用Redisson客户端，它提供了一个高级的Redis客户端，支持分布式锁的实现。以下是如何使用Redisson在Spring Boot应用中实现Redis分布式锁的步骤

在mavan中添加依赖

org.redissonredisson3.16.6

2. 配置RedissonClient

在Spring Boot的application.yml或application.properties中配置Redis连接信息

spring:
  redis:
    host: localhost
    port: 6379
    password: yourpassword  # 如果你的Redis设置了密码

然后，创建一个配置类来配置RedissonClient：

com.tehn.configorg.redisson.Redissonorg.redisson.api.RedissonClientorg.redisson.config.Configorg.springframework.beans.factory.annotation.org.springframework.context.annotation.org.springframework.context.annotation.RedissonConfig {
    ()
    String ()
    Integer ()
    String (destroyMethod=)
    RedissonClient () {
        Config config = Config()config.useSingleServer()
                .setAddress(+ + + )
                .setPassword()Redisson.(config)}
}

3. 使用RedissonClient实现分布式锁

在你的服务类中，注入RedissonClient并使用它来获取锁：

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
@Service
public class DistributedLockService {
    @Autowired
    private RedissonClient redissonClient;
    private static final String LOCK_KEY = "myLock"; // 锁的key，可根据需要修改
    private static final int LOCK_EXPIRE = 10; // 锁过期时间，单位秒，可根据需要修改
    private static final int LOCK_WAIT_TIME = 5; // 尝试获取锁的最大等待时间，单位秒，可根据需要修改
    private static final TimeUnit TIME_UNIT = TimeUnit.SECONDS; // 时间单位，可根据需要修改（秒）
    
    public void performTask() {
        RLock lock = redissonClient.getLock(LOCK_KEY);
        boolean hasLock = false; // 标记是否成功获取到锁，用于异常处理时释放锁
        try {
            hasLock = lock.tryLock(LOCK_WAIT_TIME, LOCK_EXPIRE, TIME_UNIT); // 尝试获取锁，如果获取失败则等待一段时间再尝试获取，直到获取或超时。
            if (hasLock) {
                // 执行业务逻辑...
                System.out.println("Task performed");
            } else {
                System.out.println("Could not acquire lock, task not performed");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 重置中断状态，以便其他线程可以捕获到中断信号。
        } finally {
            if (hasLock) { // 如果成功获取到锁，则在finally块中释放锁。
                lock.unlock(); // 释放锁。注意：只有在成功获取到锁的情况下才释放锁。如果tryLock失败，则无需释放锁。
            } else {
                // 如果在try块中没有成功获取到锁（即hasLock为false），则在finally块中不需要释放锁。因为根本没有获取到锁。但是，为了避免潜在的死锁问题，可以在此处添加日志记录或其他调试信息。
                // 例如：System.out.println("Skipped unlocking as lock was not acquired");。这样做可以帮助开发者在调试时更容易地识别问题所在。但在实际应用中，通常不需要这样做，
                //因为只有在成功获取到锁的情况下才需要释放锁。这里的注释主要是为了解释为什么在某些情况下不需要释放锁。实际上，在正常情况下，只有在成功获取到锁的情况下才会进入finally块并执行unlock操作。如果tryLock失败，则不会执行
             }
        }

nginx 将访问/fljc/public/下的所有除了css和js文件和图片资源之外路由自动重写/fljc/public/index.php/下所有响应路径

Wed, 25 Mar 2026 16:56:16 +0800

要实现当访问 Nginx 服务器上的 /fljc/public/ 目录时，自动重写路由（即除了 CSS、JS 文件和图片资源之外的重定向），你可以使用 Nginx 的 try_files 指令和 location 块来配置。这种方法可以确保除了特定类型的文件外，其他请求都会被重定向到一个特定的处理程序或URL。

以下是一个配置示例，假设你想要将所有非CSS、JS和图片的请求重定向到你的应用的主入口文件（例如 index.php）：

server {
    listen 80;
    server_name yourdomain.com;
    root /path/to/fljc/public;
    index index.php index.html index.htm;
   # 是这两个开始
location /fljc/public/ {
        rewrite ^/fljc/public/(.*)$ /fljc/public/index.php/$1 last;
    }
location ~ \.(jpg|jpeg|png|gif|ico|css|js)$ {
        try_files $uri =404;
        expires 30d;
    }
  # 是这两个结束
    location ~ \.php$ {
        include fastcgi_params;
        fastcgi_pass unix:/var/run/php/php7.4-fpm.sock; # 根据你的PHP版本和配置调整
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    }
}

解释：

‌根目录配置‌：root /path/to/fljc/public; 指定了 Nginx 的根目录。
‌主位置块‌ (location /fljc/public)：

rewrite ^/fljc/public/(.*)$ /fljc/public/index.php/$1 last; 将所有非静态文件的请求重写到 index.php，并通过 $1 捕获原始URI。last 指令告诉 Nginx 使用新的 URI 重新执行请求。

‌静态文件处理‌：

location ~ \.(jpg|jpeg|png|gif|ico|css|js)$ 匹配图片、CSS 和 JS 文件，并设置它们过期时间为30天。如果文件不存在，返回404。

‌PHP 处理‌：

location ~ \.php$ 用于处理 PHP 文件，通过 fastcgi_pass 指令将请求传递给 FastCGI 服务器（如 PHP-FPM）。

通过这种方式，所有对 /fljc/public/ 的请求（除了 CSS、JS 和图片文件）都会被重定向到 index.php，从而实现你的需求。确保根据你的实际目录结构和 PHP-FPM 配置调整路径和参数。

浅谈以下如何实现超大文件断点续传功能

Sat, 21 Mar 2026 22:20:52 +0800

断点续传就是下载文件时，不必重头开始下载，而是从指定的位置继续下载，这样的功能就叫做断点续传。断点续传的理解可以分为两部分：一部分是断点，一部分是续传。断点的由来是在下载过程中，将一个下载文件分成了多个部分，同时进行多个部分一起的下载，当某个时间点，任务被暂停了，此时下载暂停的位置就是断点了。续传就是当一个未完成的下载任务再次开始时，会从上次的断点继续传送。

以前文件无法分割，但随着html5新特性的引入，类似普通字符串、数组的分割，我们可以可以使用slice方法来分割文件。所以断点续传的最基本实现也就是：前端通过FileList对象获取到相应的文件，按照指定的分割方式将大文件分段，然后一段一段地传给后端，后端再按顺序一段段将文件进行拼接。

而我们需要对FileList对象进行修改再提交，在之前的文章中知晓了这种提交的一些注意点，因为FileList对象不能直接更改，所以不能直接通过表单的.submit()方法上传提交，需要结合FormData对象生成一个新的数据，通过Ajax进行上传操作。

设计思路

1. 分片上传（Chunk Upload）

核心思想：将一个大文件（比如1GB）切割成多个固定大小的小分片（比如10MB/片），分别上传，服务端接收所有分片后再合并成完整文件。

解决问题：避免单次上传大文件时网络中断导致全部重传、请求超时、服务器内存溢出等问题。

2. 断点续传（Resumable Upload）

核心思想：上传前先校验文件的唯一标识（如MD5/文件大小+修改时间），服务端查询该文件已上传的分片，只上传未完成的分片。

关键依赖：需要一个“分片记录器”（数据库/缓存），记录每个文件的分片上传状态（已上传分片索引、总分片数、文件唯一标识等）。

3. 多文件上传

本质是对单文件上传逻辑的复用，前端传递文件列表，后端循环处理每个文件的分片/断点续传逻辑即可。

整体实现流程

整个流程分为前端预处理和后端核心逻辑两部分，以下是标准化的实现步骤：

步骤1：文件唯一标识生成（前端+后端）

为了区分不同文件、校验分片归属，首先生成文件的唯一标识（推荐MD5）：

前端：读取文件内容，计算文件的MD5（可使用SparkMD5等库），同时指定分片大小（如10MB），计算总分片数。

后端：接收MD5后，可作为文件的唯一ID，用于查询分片上传状态。

步骤2：断点续传校验（前端请求，后端响应）

前端上传前先请求后端：“文件MD5为某某的文件，哪些分片已经上传完成”

后端：查询分片记录（数据库/缓存），返回已上传的分片索引列表。

前端：根据返回结果，只上传未完成的分片（实现断点续传）。

步骤3：分片上传（核心）

前端将文件切割成分片，逐个/并发上传分片，每个分片携带：

1.文件MD5（文件唯一标识）

2.分片索引（第几个分片，从0开始）

3.总分片数

4.分片内容

后端接收分片后，保存到临时目录，并更新分片上传状态。

步骤4：合并分片（所有分片上传完成后）

前端确认所有分片上传完成后，请求后端合并分片：

后端：按分片索引顺序读取所有临时分片文件，写入最终文件路径，删除临时分片，更新文件上传状态为“完成”。

基于这个思路，以下博主分享代码

html部分

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
<script src="http://localhost/jquery-4.0.0.min.js"></script>
<!-- 使用SparkMD5库来获取文件的MD5哈希值 -->
<script src="https://cdnjs.cloudflare.com/ajax/libs/spark-md5/3.0.2/spark-md5.min.js"></script>
</head>
<body>
<h1>html5大文件断点切割上传</h1>
<input type="file" id="fileInput" />
<button onclick="calculateMD5()">上传文件</button>
<div id="progress">0%</div>
<script>
function calculateMD5() {
   const fileInput = document.getElementById('fileInput');
    const file = fileInput.files[0];
    if (!file) {
        alert('请选择一个文件');
        return;
    }
    const reader = new FileReader();
    const spark = new SparkMD5.ArrayBuffer();
    let fileLoaded = false;
      reader.onload = function(e) {
        // 文件加载成功
        fileLoaded = true;
       spark.append(e.target.result); // 读取文件完成之后放进内存缓冲区
        const hash = spark.end(); // 获取hash文件哈希值
        console.log(hash,"曲中")
        uploadFile(file, hash);
                
    }
    reader.onerror = function() {
        console.log('Spark读取文件中出现意外错误');
    };
    reader.readAsArrayBuffer(file);
 }
function uploadFile(file, fileMD5) {
    
    
    const CHUNK_SIZE = 1024 * 1024 * 5; // 5MB 每个分片大小
    const totalChunks = Math.ceil(file.size / CHUNK_SIZE);
    checkFile(fileMD5, totalChunks);
    /**
     * offset  在那个分片索引标识开始上传
     * fileMD5  文件唯一标识
     * currentChunk 当前已经上传的分片数量
     * uploadedBytes 当前已完成上传的文件大小
     * */
    function uploadChunk(fileMD5, currentChunk) {
        offset = currentChunk * CHUNK_SIZE;
        let uploadedBytes = offset;
        const blob = file.slice(offset, offset + CHUNK_SIZE);
        const formData = new FormData();
        formData.append('chunkFile', blob);
        formData.append('chunkIndex', currentChunk);
        formData.append('totalChunks', totalChunks);
        formData.append('fileName', file.name);
        formData.append('fileSize', file.size);
        formData.append('chunkSize', CHUNK_SIZE);
        formData.append('fileMd5', fileMD5);
        $.ajax({
         url: 'http://localhost:60000/upload/chunk', 
            type: 'POST',
            data: formData,
            processData: false, 
            contentType: false, 
            xhr: function() { // Custom XMLHttpRequest to handle progress updates
                var xhr = new XMLHttpRequest(); // XMLHttpRequest object to monitor progress events
                xhr.upload.addEventListener("progress", function(evt) {
                    if (evt.lengthComputable) {
                        var percentComplete = Math.round((evt.loaded / evt.total) * 100);
                        uploadedBytes += evt.loaded; // Update uploaded bytes counter
                        $('#progress').text(percentComplete + '%'); // Update progress bar or text display on client side if needed
                    }
                }, false);
                return xhr; // Return the XHR object for jQuery to use it for the request
            },
            success: function(data) { // On successful upload of this chunk, upload the next one (recursive call)
            if (data.code == 200) {
                currentChunk++;
                if (currentChunk < totalChunks) {
                    uploadChunk(fileMD5, currentChunk); // 继续上传下一个分片
                } else {
                        // 所有分片上传完毕，发起文件合并请求
                    mergeFile(fileMD5);
                }
            } else {
                alert(data.msg);
            }
            }
        });
        
    }
    // 在执行上传该文件时,向后端提交检查该文件有没有中断上传的记录，如果有，则从上传失败的分片索引处开始继续上传
    function checkFile(fileMD5, chunksTotalNum){
        const formData = new FormData();
        formData.append('fileMd5', fileMD5);
        $.ajax({
            url: 'http://localhost:60000/upload/check', 
            type: 'POST',
            data: formData,
            processData: false, 
            contentType: false, 
            success: function(data) {
                
                if (data.code == 200) {
                    let arr = data.data;
                    if(arr.finishChunk.length == 0) uploadChunk(fileMD5, 0);
                    else if(chunksTotalNum <= arr.finishChunk.length){
                        if(arr.isMerge == 0) mergeFile(fileMD5);
                        else return alert('文件早已上传')
                    }
                    else{
                        // 继续上传未尽的分片
                        uploadChunk(fileMD5, arr.finishChunk[arr.finishChunk.length - 1]); // 继续上传下一个分片
                    }
                } else {
                    alert(data.msg);
                }
            }
        });
    }
    // 在分片上传全部完成后，向后端提交合并请求
    function mergeFile(fileMD5){
        const formData = new FormData();
        formData.append('fileMd5', fileMD5);
        $.ajax({
            url: 'http://localhost:60000/upload/merge', 
            type: 'POST',
            data: formData,
            processData: false, 
            contentType: false, 
            success: function(data) { // On successful upload of this chunk, upload the next one (recursive call)
                if (data.code == 200) {
                    alert('文件上传完成');
                } else {
                    alert('文件上传失败');
                }
            }
        });
    }
}
</script>
</body>
</html>

后端部分(采用了springBoot+Mysql)

数据表

CREATE TABLE `file_upload_record` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `file_md5` varchar(64) NOT NULL COMMENT '文件唯一标识（MD5）',
  `file_name` varchar(255) NOT NULL COMMENT '文件名',
  `file_size` bigint(20) NOT NULL COMMENT '文件总大小（字节）',
  `chunk_size` bigint(20) NOT NULL COMMENT '分片大小（字节）',
  `total_chunks` int(11) NOT NULL COMMENT '总分片数',
  `uploaded_chunks` varchar(1000) DEFAULT '' COMMENT '已上传分片索引（逗号分隔，如0,1,2）',
  `file_path` varchar(500) DEFAULT NULL COMMENT '最终文件保存路径',
  `status` tinyint(4) NOT NULL DEFAULT '0' COMMENT '0-未完成 1-已完成',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_file_md5` (`file_md5`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='文件上传记录表';

// maven依赖

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   <exclusions>
      <exclusion>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-logging</artifactId>
      </exclusion>
   </exclusions>
</dependency>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter</artifactId>
   <exclusions>
      <exclusion>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-logging</artifactId>
      </exclusion>
   </exclusions>
</dependency>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

<!-- mysql驱动包 -->
<dependency>
   <groupId>com.mysql</groupId>
   <artifactId>mysql-connector-j</artifactId>
   <scope>runtime</scope>
</dependency>
<!-- mybatis的相关依赖 -->
<dependency>
   <groupId>org.mybatis.spring.boot</groupId>
   <artifactId>mybatis-spring-boot-starter</artifactId>
   <version>2.3.1</version>
</dependency>
<!-- 日志输出依赖包 -->
<dependency>
   <groupId>org.slf4j</groupId>
   <artifactId>slf4j-api</artifactId>
   <version>1.7.21</version>
</dependency>
<dependency>
   <groupId>org.slf4j</groupId>
   <artifactId>slf4j-log4j12</artifactId>
   <version>1.7.21</version>
</dependency>
<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-collections4</artifactId>
   <version>4.4</version>
</dependency>

<!-- myBatis-plus -->
<dependency>
   <groupId>com.baomidou</groupId>
   <artifactId>mybatis-plus-boot-starter</artifactId>
   <version>3.5.3.1</version>
</dependency>
<!-- 文件操作工具 -->
<dependency>
   <groupId>commons-io</groupId>
   <artifactId>commons-io</artifactId>
   <version>2.15.0</version>
</dependency>
<!-- 校验MD5 -->
<dependency>
   <groupId>commons-codec</groupId>
   <artifactId>commons-codec</artifactId>
   <version>1.15</version>
</dependency>

// 实体类

package com.durkblue.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

import java.util.Date;

@TableName("file_upload_record")
public class FileUploadRecord {
    @TableId(type = IdType.AUTO)
    private Long id;
    // 文件MD5
    @TableField("file_md5")
    private String fileMd5;
    // 文件名
    @TableField("file_name")
    private String fileName;
    // 文件总大小（字节）
    @TableField("file_size")
    private Long fileSize;
    // 分片大小（字节）
    @TableField("chunk_size")
    private Long chunkSize;
    // 总分片数
    @TableField("total_chunks")
    private Integer totalChunks;
    // 已上传分片索引（逗号分隔）
    @TableField("uploaded_chunks")
    private String uploadedChunks;
    // 最终文件路径
    @TableField("file_path")
    private String filePath;
    // 上传状态：0-未完成 1-已完成
    @TableField("status")
    private Integer status;
    @TableField("create_time")
    // 记录时间
    private Date createTime;
    @TableField("update_time")
    // 上传时间
    private Date updateTime;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getFileMd5() {
        return fileMd5;
    }

    public void setFileMd5(String fileMd5) {
        this.fileMd5 = fileMd5;
    }

    public String getFileName() {
        return fileName;
    }

    public void setFileName(String fileName) {
        this.fileName = fileName;
    }

    public Long getFileSize() {
        return fileSize;
    }

    public void setFileSize(Long fileSize) {
        this.fileSize = fileSize;
    }

    public Long getChunkSize() {
        return chunkSize;
    }

    public void setChunkSize(Long chunkSize) {
        this.chunkSize = chunkSize;
    }

    public Integer getTotalChunks() {
        return totalChunks;
    }

    public void setTotalChunks(Integer totalChunks) {
        this.totalChunks = totalChunks;
    }

    public String getUploadedChunks() {
        return uploadedChunks;
    }

    public void setUploadedChunks(String uploadedChunks) {
        this.uploadedChunks = uploadedChunks;
    }

    public String getFilePath() {
        return filePath;
    }

    public void setFilePath(String filePath) {
        this.filePath = filePath;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }
}

// mapper层

package com.durkblue.mapper;


import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.durkblue.domain.FileUploadRecord;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface FileUploadRecordMapper extends BaseMapper<FileUploadRecord> {
}

// service层接口

package com.durkblue.service;

import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.Map;
import java.util.Set;

public interface IFileUploadService {
    /**
     * 断点续传校验，返回已上传的分片索引
     *
     * @param fileMd5 文件分片标识
     * @return 分片索引
     */
    Map<String, Object> checkUploadedChunks(String fileMd5);

    /**
     * 上传总文件当中单个分片
     * @param fileMd5  总文件唯一标识
     * @param fileName 总文件名称
     * @param fileSize 总文件大小
     * @param chunkSize 分片文件大小
     * @param chunkIndex 分片索引
     * @param totalChunks 总分片数
     * @param chunkFile 分片文件
     * @return 是否上传该分片成功
     * @throws IOException 异常
     */
    boolean uploadChunk(String fileMd5, String fileName, Long fileSize, Long chunkSize,
                        Integer chunkIndex, Integer totalChunks, MultipartFile chunkFile) throws IOException;

    /**
     * 合并所有文件分片
     * @param fileMd5 总文件唯一标识
     * @return 是否合并成功
     * @throws IOException 异常
     */
    boolean mergeChunks(String fileMd5) throws IOException;


}

// service层实现类

package com.durkblue.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.durkblue.domain.FileUploadRecord;
import com.durkblue.mapper.FileUploadRecordMapper;
import com.durkblue.service.IFileUploadService;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.io.FileUtils;
import org.apache.ibatis.util.MapUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class FileUploadServiceImpl implements IFileUploadService {
    // 当分片上传全部完成后最终文件存储目录
    private final String finalPath = "D:\\file\\upload\\";

    // 临时文件分片存储目录
    private String tempPath = "D:\\file\\tmp\\";
    @Autowired
    private FileUploadRecordMapper fileUploadRecordMapper;

    @Override
    public Map<String, Object> checkUploadedChunks(String fileMd5) {
        Map<String, Object> dataMap = new HashMap<>();
        LambdaQueryWrapper<FileUploadRecord> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(FileUploadRecord::getFileMd5, fileMd5);
        FileUploadRecord record = fileUploadRecordMapper.selectOne(queryWrapper);

        // 无记录：返回空集合（所有分片都未上传）
        if (Objects.isNull(record)) {
            dataMap.put("finishChunk", new HashSet<>());// 当前已经上传的分片索引
            dataMap.put("isMerge", 0);// 当前文件是否需要文件合并操作0=否1=是
        }else{
            // 已完成：返回所有分片索引（前端无需再上传）
            if (record.getStatus() == 1) {
                Set<Integer> allChunks = new HashSet<>();
                for (int i = 0; i < record.getTotalChunks(); i++) {
                    allChunks.add(i);
                }
                dataMap.put("finishChunk", allChunks);
                dataMap.put("isMerge", record.getStatus());
            }
            else{
                // 未完成：解析已上传分片索引
                String uploadedChunks = record.getUploadedChunks();
                if (uploadedChunks == null || uploadedChunks.isEmpty()) {
                    dataMap.put("finishChunk", new HashSet<>());
                    dataMap.put("isMerge", record.getStatus());
                }else{
                    Set<Integer> chunkSet = Arrays.stream(uploadedChunks.split(","))
                            .map(Integer::parseInt)
                            .collect(Collectors.toSet());
                    dataMap.put("finishChunk", chunkSet);
                    dataMap.put("isMerge", record.getStatus());
                }
            }

        }
        return dataMap;
    }

    @Override
    public boolean uploadChunk(String fileMd5, String fileName, Long fileSize, Long chunkSize, Integer chunkIndex, Integer totalChunks, MultipartFile chunkFile) throws IOException {
        // 1. 校验分片文件
        if (chunkFile.isEmpty()) {
            throw new RuntimeException("分片文件为空");
        }

        // 2. 创建临时目录（按文件MD5分目录，避免分片冲突）
        File tempDir = new File(tempPath + File.separator + fileMd5);
        if (!tempDir.exists()) {
            FileUtils.forceMkdir(tempDir);
        }

        // 3. 保存分片文件（命名规则：fileMd5 + "_" + chunkIndex）
        File chunkFileObj = new File(tempDir, fileMd5 + "_" + chunkIndex);
        FileUtils.copyInputStreamToFile(chunkFile.getInputStream(), chunkFileObj);

        // 4. 更新分片上传记录
        LambdaQueryWrapper<FileUploadRecord> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(FileUploadRecord::getFileMd5, fileMd5);
        FileUploadRecord record = fileUploadRecordMapper.selectOne(queryWrapper);

        if (Objects.isNull(record)) {
            // 首次上传：新增记录
            record = new FileUploadRecord();
            record.setFileMd5(fileMd5);
            record.setFileName(fileName);
            record.setFileSize(fileSize);
            record.setChunkSize(chunkSize);
            record.setTotalChunks(totalChunks);
            record.setUploadedChunks(chunkIndex.toString());
            record.setStatus(0);
            fileUploadRecordMapper.insert(record);
        } else {
            // 非首次上传：追加分片索引
            Map<String, Object> uploadMap = checkUploadedChunks(fileMd5);
            Set<Integer> uploadedSet = (Set<Integer>) MapUtils.getObject(uploadMap, "finishChunk");
            uploadedSet.add(chunkIndex);
            String newUploadedChunks = uploadedSet.stream()
                    .sorted()
                    .map(String::valueOf)
                    .collect(Collectors.joining(","));
            record.setUploadedChunks(newUploadedChunks);

            fileUploadRecordMapper.updateById(record);
            // 判断是否最后一个分片上传
            if(uploadedSet.size() == record.getTotalChunks()){
                // 最后一个分片上传，执行文件合并
                mergeChunks(fileMd5);
            }
        }

        return true;
    }

    @Override
    public boolean mergeChunks(String fileMd5) throws IOException {
        // 1. 查询文件记录
        LambdaQueryWrapper<FileUploadRecord> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(FileUploadRecord::getFileMd5, fileMd5);
        FileUploadRecord record = fileUploadRecordMapper.selectOne(queryWrapper);
        if (record == null || record.getStatus() == 1) {
            return true; // 无记录或已合并，直接返回成功
        }

        // 2. 校验所有分片是否上传完成
        Map<String, Object> uploadMap = checkUploadedChunks(fileMd5);
        Set<Integer> uploadedChunks = (Set<Integer>) MapUtils.getObject(uploadMap, "finishChunk");
        if (uploadedChunks.size() != record.getTotalChunks()) {
            throw new RuntimeException("分片未全部上传，无法合并");
        }

        // 3. 创建最终文件目录
        File finalDir = new File(finalPath);
        if (!finalDir.exists()) {
            FileUtils.forceMkdir(finalDir);
        }

        // 4. 合并分片到最终文件
        File finalFile = new File(finalDir, record.getFileName());
        try (FileOutputStream fos = new FileOutputStream(finalFile, true);
             BufferedOutputStream bos = new BufferedOutputStream(fos)) {
            // 按分片索引顺序读取并写入
            for (int i = 0; i < record.getTotalChunks(); i++) {
                File chunkFile = new File(tempPath + File.separator + fileMd5, fileMd5 + "_" + i);
                if (!chunkFile.exists()) {
                    throw new RuntimeException("分片" + i + "不存在");
                }
                // 写入分片内容
                FileUtils.copyFile(chunkFile, bos);
                // 删除临时分片文件
                FileUtils.delete(chunkFile);
            }
        }

        // 5. 更新记录：标记为已完成，保存最终文件路径
        record.setFilePath(finalFile.getAbsolutePath());
        record.setStatus(1);
        fileUploadRecordMapper.updateById(record);

        // 6. 删除临时目录
        File tempDir = new File(tempPath + File.separator + fileMd5);
        FileUtils.deleteDirectory(tempDir);

        return true;
    }
}

// 工具类

com.durkblue.utiljava.util.HashMapjava.util.ObjectsAjaxResult HashMap<StringObject> {
    = String = String = String = String = ()
    {
    }

    (codeString msg)
    {
        .put(code).put(msg)}

    (Object dataInteger total){
        .put(data).put(total).put().put()}
    (codeString msgObject data)
    {
        .put(code).put(msg)(!Objects.(data))
        {
            .put(data)}
    }

    AjaxResult ()
    {
        AjaxResult.()}

    AjaxResult (Object data)
    {
        AjaxResult.(data)}

    AjaxResult (String msg)
    {
        AjaxResult.(msg)}

    AjaxResult (String msgObject data)
    {
        AjaxResult(msgdata)}



    AjaxResult ()
    {
        AjaxResult.()}

    AjaxResult (String msg)
    {
        AjaxResult.(msg)}

    AjaxResult (String msgObject data)
    {
        AjaxResult(msgdata)}

    AjaxResult (codeString msg)
    {
        AjaxResult(codemsg)}



}

// controller层

package com.durkblue.controller;


import com.durkblue.service.IFileUploadService;
import com.durkblue.util.AjaxResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.Map;
import java.util.Set;

@RestController
@RequestMapping("/upload")
public class FileUploadController {
    @Autowired
    private IFileUploadService fileUploadService;

    /**
     * 断点续传校验接口
     */
    @PostMapping("/check")
    public AjaxResult checkUpload(String fileMd5) {
        Map<String, Object> uploadedChunks = fileUploadService.checkUploadedChunks(fileMd5);
        return AjaxResult.success(uploadedChunks);
    }

    /**
     * 分片上传接口（单文件分片）
     */
    @PostMapping("/chunk")
    public AjaxResult uploadChunk(String fileMd5, String fileName, Long fileSize, Long chunkSize, Integer chunkIndex,
                                  Integer totalChunks, MultipartFile chunkFile) {
        try {
            fileUploadService.uploadChunk(fileMd5, fileName, fileSize,
                    chunkSize, chunkIndex, totalChunks, chunkFile);
            return AjaxResult.success("分片上传成功");
        } catch (IOException e) {
            return AjaxResult.error("分片上传失败：" + e.getMessage());
        }
    }
    /**
     * 分片合并接口
     */
    @PostMapping("/merge")
    public AjaxResult mergeChunks(String fileMd5) {
        try {
            fileUploadService.mergeChunks(fileMd5);
            return AjaxResult.success("文件合并成功");
        } catch (IOException e) {
            return AjaxResult.error("文件合并失败：" + e.getMessage());
        }
    }

}

// 解决跨域问题

package com.durkblue.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/upload/**") // 调整为你的映射路径
                .allowedOrigins("http://localhost") // 替换为你的前端应用的 URL
                .allowedMethods("POST", "GET", "PUT", "DELETE") // 根据需要添加更多方法
                .allowCredentials(true)
                .maxAge(3600);
    }

}

// springboot配置文件

:
  :
    : file-resume-from-breakpoint
  :
    : jdbc:mysql://localhost:3306/ruoyi-wvp?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
    : ....: root
    : root
    :
      : : : : : : :
    :
      : 50MB
      : 100MB
:
  : classpath:/mapping/*Mapper.xml
  : com.durkblue.domain
  :
    : :
  :

ZLMediaKit在linux X86_64上的部署与启动

Mon, 09 Mar 2026 14:41:21 +0800

步骤1：安装yasm

wget http://www.tortall.net/projects/yasm/releases/yasm-1.3.0.tar.gz

tar -zxvf yasm-1.3.0.tar.gz

cd yasm-1.3.0

./configure

make && make install

#查看是否安装成功

yasm --version

步骤2：安装gcc

# 首先查看是否已经安装gcc,如果安装且版本>=4.8跳过此步骤

gcc -v

# 安装gcc

yum isntall gcc

yum -y install gcc-c++

步骤3：安装ffmpeg

wget http://www.ffmpeg.org/releases/ffmpeg-3.1.tar.gz

tar -zxvf ffmpeg-3.1.tar.gz

cd ffmpeg-3.1

./configure --prefix=/usr/local/ffmpeg

make && make install

vim /etc/profile

#在最后PATH添加环境变量：

export PATH=$PATH:/usr/local/ffmpeg/bin

#更新环境

source /etc/profile

#查看ffmpeg版本

ffmpeg -version

步骤4：安装cmake

#获取CMake源码包

wget https://github.com/Kitware/CMake/releases/download/v3.20.5/cmake-3.20.5.tar.gz

#解压CMake源码包

tar -zxvf cmake-3.20.5.tar.gz

#编译安装

cd cmake-3.20.5

./bootstrap && make -j4 && make install

#配置环境变量

vim /etc/profile

#文件末尾加上配置

export CMAKE_HOME=/opt/cmake/cmake-3.20.5/bin

export PATH=$CMAKE_HOME:$PATH

#刷新配置

source /etc/profile

cmake --version

步骤5：安装openssl

# 服务器安装好后一版自带openssl，但是自带的openssl可能版本和zlmediakit所需的版本不匹配，此处推荐安装openssl 1.1.1K

#查看openssl版本

openssl version -a

#安装openssl

wget https://www.openssl.org/source/openssl-1.1.1k.tar.gz

tar -xvzf openssl-1.1.1k.tar.gz

yum install -y zlib zlib-devel perl-CPAN

cd openssl-1.1.1k

./config shared --openssldir=/usr/local/openssl --prefix=/usr/local/openssl

make && make install

echo "/usr/local/lib64/" >> /etc/ld.so.conf

echo "/usr/local/openssl/lib" >> /etc/ld.so.conf

ldconfig

ln -s /usr/local/openssl/bin/openssl /usr/local/bin/openssl # 替换系统openssl，非必须

openssl version -a

步骤6：安装libsrtp

wget https://codeload.github.com/cisco/libsrtp/tar.gz/refs/tags/v2.3.0

tar -xvzf libsrtp-2.3.0.tar.gz

cd libsrtp-2.3.0

./configure --enable-openssl --with-openssl-dir=/usr/local/openssl

make -j8 && make install

步骤7：下载zlm源码

#如果没安装git 那么安装

yum install -y git

#国内用户推荐从同步镜像网站gitee下载

git clone --depth 1 https://gitee.com/xia-chu/ZLMediaKit

cd ZLMediaKit

#千万不要忘记执行这句命令

git submodule update --init

#编译

mkdir build

cd build

cmake .. -DENABLE_WEBRTC=true -DOPENSSL_ROOT_DIR=/usr/local/openssl -DOPENSSL_LIBRARIES=/usr/local/openssl/lib

cmake --build . --target MediaServer

# 最终输出

[ 96%] Built target test_rtcp_fci

[ 96%] Building CXX object tests/CMakeFiles/test_rtp.dir/test_rtp.cpp.o

[ 97%] Linking CXX executable ../../release/linux/Debug/test_rtp

[ 97%] Built target test_rtp

[ 97%] Building CXX object tests/CMakeFiles/test_wsServer.dir/test_wsServer.cpp.o

[ 97%] Linking CXX executable ../../release/linux/Debug/test_wsServer

[ 97%] Built target test_wsServer

[ 97%] Building CXX object tests/CMakeFiles/test_server.dir/test_server.cpp.o

[ 97%] Linking CXX executable ../../release/linux/Debug/test_server

[ 97%] Built target test_server

[ 98%] Built target jsoncpp

[ 98%] Linking CXX executable ../../release/linux/Debug/MediaServer

[100%] Built target MediaServer

步骤8:配置文件

配置http端口和https端口,并接触ip限制白名单

步骤8：运行

MediaServer -c /data/durkblue/ZLMediaKit/conf/config.ini # /data/durkblue/ZLMediaKit/conf/config.ini为MediaServer配置文件目录

步骤9：查看是否启动成功

ps -ef | grep MediaServer

常用命令

#热加载配置文件

killall -1 MediaServer

#关闭MediaServer

killall -2 MediaServer

访问链接

#ip:ZLMediaKit配置文件中http的port端口

http://ip:端口/webrtc/

记录离线方式实现docker版本的升级 docker-compose升级版本

Tue, 10 Feb 2026 12:44:25 +0800

一、docker版本的升级

在 AArch64 架构（如使用 ARM64 处理器，如 Raspberry Pi 4 或其他基于 ARM 的服务器）上离线升级 Docker 版本到 25.0 可能需要一些额外的步骤，因为通常 Docker 官方仓库不提供离线安装包。同样适用于cpu芯片架构为X86_64(只需要下载docker的X86平台安装包)

步骤 1: 确认当前 Docker 版本

首先，确认你的系统上当前安装的 Docker 版本。可以通过运行以下命令来查看：

docker --version

步骤 2: 下载 Docker 安装包

由于你需要在离线环境中操作，你需要手动下载 Docker 的安装包。你可以从 Docker 的官方网站或其他可信来源下载适用于 AArch64 的 Docker 版本。例如，访问 Docker 官方下载页面并找到适合你的 Docker 版本（在这个例子中是 25.0）。

步骤 3: 传输安装包到目标设备

将下载的 Docker 安装包传输到你的 AArch64 设备上。你可以使用 scp, rsync, 或者任何其他文件传输工具来完成这个任务

步骤 4: 解压并替换二进制文件

4.1登录到服务器。

4.2解压下载的安装包：

tar -xvf docker-25.0.0.tgz

4.3 将解压后的二进制文件移动到 /usr/bin 或者 Docker 推荐的目录中（例如 /usr/local/bin）：

sudo mv docker/* /usr/bin/  # 将当前终端命令下的路径下的docker文件夹下的所有文件包括文件夹移动到/usr/bin目录下

步骤 5: 更新 Docker 服务配置（可选）

如果需要更新 Docker 的配置文件（如 daemon.json），确保这些配置文件位于 /etc/docker 目录下，并根据需要更新它们。

步骤 6: 重启 Docker 服务

重新启动 Docker 服务以确保新版本的 Docker 正在运行：

systemctl restart docker

或者，如果你使用的是较旧的系统，可能需要使用：

service docker restart

步骤 7: 验证 Docker 版本

最后，验证 Docker 是否成功更新到新版本：

docker --version

二、docker-compose版本升级

要在基于 ARM64 架构（如 AArch64）的系统中离线升级 docker-compose 版本到 2.26.1，你可以按照以下步骤操作。这个过程涉及到下载 docker-compose 的二进制文件并手动安装，因为直接在线安装通常是通过 pip 安装，这在离线环境中不适用。

首先，你需要从 Docker 的官方网站或者其他可信源下载 docker-compose 的二进制文件。对于 AArch64 架构，你可以访问 Docker 的 GitHub Releases 页面或者直接从 Docker Hub 获取预编译的二进制文件。

1.访问 Docker Compose GitHub Releases。

2.找到版本 2.26.1 的发布页面。

3.下载适用于 Linux 的 ARM64 架构的二进制文件。通常文件名类似于 docker-compose-linux-aarch64。

步骤 2: 安装 docker-compose

下载完成后，你需要将下载的二进制文件移动到系统的 PATH 中，以便可以从任何位置运行它。

1.使用 scp 或其他文件传输工具将下载的二进制文件传输到你的 AArch64 系统。

2.使用 SSH 登录到你的系统。

3.将二进制文件移动到 /usr/bin 或你喜欢的任何目录，并将其重命名为 docker-compose（没有版本号）：

mv docker-compose-linux-aarch64 /usr/local/bin/docker-compose

4.给docker-compose加执行命令权限

chmod +x /usr/bin/docker-compose

5.确认 docker-compose 是否正确安装：

docker-compose --version

如果有输出新的版本则表明成功

在js里引用地图发现 is invoked via document.write. The network request for this script MAY be blocked by the

Mon, 09 Feb 2026 09:52:49 +0800

在页面中引用高德地图后发现页面出现黄色警告

api?v=2.0&ak=dm65KD93tW9zmcZys9YvKIUj:1 A parser-blocking, cross site (i.e. different eTLD+1) script, http://api.map.baidu.com/getscript?v=2.0&ak=YvKIUj&services=&t=20190123111209, is invoked via document.write. The network request for this script MAY be blocked by the browser in this or a future page load due to poor network connectivity. If blocked in this page load, it will be confirmed in a subsequent console message. See https://www.chromestatus.com/feature/5718547946799104 for more details.

造成这个警告的原因是：

1.在弱的网络连接环境下，比如2G网络，在页面上使用document.write()来动态插入外部的脚本会阻塞页面的解析，延迟页面的显示，甚至加载脚本失败，最终导致页面不能正确显示。

2.为了提高用户的体验，Chrome对于由document.write()动态插入的<script>会做检查，当满足下面所有的条件下，Chrome不会执行加载。

a.用户处在弱网络连接的环境下，特别是2G网络

b.document.write()在主页面里，对于那些嵌入在iframe里的页面没有影响。

c.在document.write()插入的脚本是阻碍解析的（parser-blocking）。如果插入的<script>标签加了async 或着defer属性，脚本会异步加载，不影响解析，所以也是能被执行的

d.加载的脚本和站点不是同一个域名

e.脚本没有在浏览器的缓存里

f.页面不是重新加载

从Chrome 53开始，对于满足2-5条件的代码，在控制台会输出上述警告.
解决途径

改变地图js的引用方法

改成

记录phpStudy环境软件数据库管理器phpMyAdmin4.8.5 更改为远程数据库地址连接

Thu, 29 Jan 2026 11:17:13 +0800

phpMyAdmin4.8.5 是基于php环境搭建的mysql数据库图形化管理器数据库地址默认为localhost连接现在有个需求就是默认的数据库地址连接localhost更改为172.21.89远程地址连接应该如何进行呢

phpMyAdmin4.8.5文件下载phpMyAdmin4.8.5.rar

phpMyAdmin4.8.5.rar

修改libraries文件夹下的config.default.php文件

1、查找$cfg['PmaAbsoluteUri'] ，将其值设置为你本地的phpmyadmin路径，例如http://127.21.8.9/admin/

2、查找cfg[′Servers′][i]['host'] ，将其值设置为你mysql数据库地址，例如172.21.8.9

3、查找cfg[′Servers′][i]['user'] ，将其值设置为你mysql数据库用户名，例如abcd

4、查找cfg[′Servers′][i]['password'] ，将其值设置为你mysql数据库密码，例如abcd

三、通过你本地的phpmyadmin路径（同第二步设置的路径），通过你的mysql数据库用户名密码即可访问远程数据库。

记录使用MinIO作为文件分布式存储服务的使用方法

Wed, 07 Jan 2026 12:18:30 +0800

MinIO 是一种高性能、S3 兼容的对象存储。它是为大规模 AI/ML、数据湖和数据库工作负载。它是软件定义的并在任何云或本地基础设施上运行。 MinIO 具有双重许可根据开源 GNU AGPL v3 和商业企业许可证

一、下载MinIO依赖

<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>7.1.0</version>
</dependency>

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

二、MinIO工具类

package com.sl.util;


import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import io.minio.*;

import io.minio.http.Method;
import io.minio.messages.Item;
import lombok.SneakyThrows;
import org.apache.http.client.utils.URIBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.io.ByteArrayInputStream;
import java.io.InputStream;

/**
 * minio操作类
 */
@Component
public class MinioUtils {

    @Value("${minio.buccketName}")
    private String buccketName;
    @Autowired
    private MinioClient client;


    /**
     * 创建桶
     *
     * @param bucketName 桶名称
     */
    @SneakyThrows
    public void createBucket(String bucketName) {
        boolean found =
                client.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        if (!found) {
            client.makeBucket(
                    MakeBucketArgs.builder()
                            .bucket(bucketName)
                            .region("cn-beijing")
                            .build());
        }
    }

    /**
     * 删除桶
     *
     * @param bucketName 桶名称
     */
    @SneakyThrows
    public void removeBucket(String bucketName) {
        client.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    }

    /**
     * 获取文件信息
     *
     * @param bucketName 桶名称
     * @param objectName 文件名称
     * @return
     */
    @SneakyThrows
    public ObjectStat getObjectInfo(String bucketName, String objectName) {
        return client.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
    }

    /**
     * 上传文件
     *
     * @param bucketName 桶名称
     * @param objectName 文件名
     * @param stream     流
     * @param fileSize   文件大小
     * @param type       文件类型
     * @throws Exception
     */
    public void putObject(String bucketName, String objectName, InputStream stream, Long fileSize, String type) throws Exception {
        client.putObject(
                PutObjectArgs.builder().bucket(bucketName).object(objectName).stream(
                        stream, fileSize, -1)
                        .contentType(type)
                        .build());
    }

    /**
     * 判断文件夹是否存在
     *
     * @param bucketName 桶名称
     * @param prefix     文件夹名字
     * @return
     */
    @SneakyThrows
    public Boolean folderExists(String bucketName, String prefix) {
        Iterable<Result<Item>> results = client.listObjects(ListObjectsArgs.builder().bucket(bucketName)
                .prefix(prefix).recursive(false).build());
        for (Result<Item> result:results){
            Item item = result.get();
            if (item.isDir()){
                return true;
            }
        }
        return false;
    }

    /**
     * 创建文件夹
     * @param bucketName 桶名称
     * @param path 路径
     */
    @SneakyThrows
    public void createFolder(String bucketName,String path) {
        client.putObject(PutObjectArgs.builder().bucket(bucketName).object(path)
                .stream(new ByteArrayInputStream(new byte[]{}),0,-1).build());
    }

    /**
     * 获取文件在minio在服务器上的外链
     * @param bucketName 桶名称
     * @param objectName 文件名
     * @return
     */
    @SneakyThrows
    public String getObjectUrl(String bucketName,String objectName){
        return client.getPresignedObjectUrl(
                     GetPresignedObjectUrlArgs.builder()
                           .method(Method.GET)
                          .bucket(bucketName)
                          .object(objectName)
                          .build());
    }

    /**
     * 获取minio永不失效的外链
     * @param fileName 文件名称
     * @param bucketName 桶名称
     * @return 外链接
     */
    public String getPreviewUrl(String fileName, String bucketName) {
        if (StringUtils.isNotBlank(fileName)) {
            String bucket = bucketName == null ? this.buccketName : bucketName;
            try {
                client.statObject(StatObjectArgs.builder().bucket(bucket).object(fileName).build());
                String url = client.getPresignedObjectUrl(
                        GetPresignedObjectUrlArgs.builder()
                                .method(Method.GET)
                                .bucket(bucket)
                                .object(fileName)
                                .build());
                URIBuilder uriBuilder = new URIBuilder(url);
                uriBuilder.removeQuery();
                return uriBuilder.build().toString();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 获取minio永久外链
     * @param fileName 文件名称
     * @param bucketName 桶名称
     * @return 外链接
     */
    public String getPermanentUrl(String fileName, String bucketName) {
        if (StringUtils.isNotBlank(fileName)) {
            String bucket = bucketName == null ? this.buccketName : bucketName;
            try {
                // 检查对象是否存在
                client.statObject(StatObjectArgs.builder().bucket(bucket).object(fileName).build());

                // 返回永久链接
                return client.getObjectUrl(bucket, fileName);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 根据key删除服务器上的文件
     */
    public boolean deleteFileByUrl(String bucketName,String fileName,String folder) {
        try {
            client.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(folder + fileName).build());
            System.out.println(("删除" + bucketName + "下的文件" + folder + fileName + "成功"));
            return true;
        } catch (Exception e) {
            System.out.println(("删除文件失败:{}"+ e.getMessage()));
            e.printStackTrace();
            return false;
        }
    }

}

把tehn存储桶权限由private更改为custom的配置文件如下：

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "AWS": [
                    "*"
                ]
            },
            "Action": [
                "s3:GetBucketLocation",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::tehn"
            ]
        },
        {
            "Effect": "Allow",
            "Principal": {
                "AWS": [
                    "*"
                ]
            },
            "Action": [
                "s3:GetObject"
            ],
            "Resource": [
                "arn:aws:s3:::tehn/*"
            ]
        }
    ]
}

麒麟系统安装docker时发现yum install-y yum-utils报错 No match for argument：Unable to find a match

Tue, 16 Dec 2025 17:00:40 +0800

安装docker 遇到yum install -y yum-utils报错，No match for argument：Unable to find a match

下载可用的.repo文件

wget -O /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-vault-8.5.2111.repo

#注 wget -O … （此处为大写的英文字母O）

输入带版本的安装命令就可以了

sudo yum install -y --releasever=8 yum-utils

JAR包在linux系统中后台进行常驻并开机自启动 jar包自启jar包后台启动jar自启动jar后台启动

Wed, 10 Dec 2025 16:59:32 +0800

Linux系统配置开机自动启动Java项目

在我们写完项目后，项目后端要部署到服务器上。如遇到服务器出现故障导致重启，项目还需要手动进行启动，才不会影响项目的正常运行。

1、准备工作

Linux中Java的路径
项目jar包绝对路径
项目外置配置文件（没有可不准备）

2、创建自启脚本jar_auto.sh

在/etc/rc.d/init.d目录下创建jar_auto.sh文件可使用vi命令或touch命令创建jar_auto.sh，文件名称可自定义

# 改变目录
cd /etc/rc.d/init.d
# 创建文件
vi jar_auto.sh
# 或 touch jar_auto.sh

创建好后编写自定义启动脚本内容

#!/bin/bash

# 表示延迟30秒启动
sleep 10
# 配置jar包启动的路径 日志生成路径  nohup表示静默启动
# 两种启动jar包命令的写法，one.使用java的绝对路径的命令，two.使用已配置好的全局java命令（根据自己喜好二选一即可）
# one.使用java的绝对路径的命令
nohup java -Djava.awt.headless=true -Duser.timezone=Asia/Shanghai -Xmx1024M -Xms256M -jar /home/durkblue/jar/atomo/atmospheric-electric-meter-0.0.1-SNAPSHOT.jar &
nohup java -Djava.awt.headless=true -Duser.timezone=Asia/Shanghai -Xmx1024M -Xms256M -jar /home/durkblue/jar/devicePro/devicePro-1.1.0.jar &
nohup java -Djava.awt.headless=true -Duser.timezone=Asia/Shanghai -Xmx1024M -Xms256M -jar /home/durkblue/jar/netty/nettydamo-0.0.1-SNAPSHOT.jar &
nohup java -Djava.awt.headless=true -Duser.timezone=Asia/Shanghai -Xmx1024M -Xms256M -jar /home/durkblue/jar/onenet/onenet-device-gateway-0.0.1-SNAPSHOT.jar &
# two.使用已配置好的全局java命令
#nohup java -mx256M -Diname=buss-admin -Xrs -jar /home/application/bussManager/lib/buss-admin.jar --spring.config.location=/home/application/bussManager/conf/application.yml > /home/application/bussManager/logs/buss-admin.log&
# 如果有多个jar需要启动，可以继续按照one或two配置。如下：
#nohup java -jar /home/application/bussManager/jar/one.jar > /home/application/bussManager/logs/one.log&
#nohup java -jar /home/application/bussManager/jar/two.jar >/home/application/bussManager/logs/two.log&

如果有需要延时启动，可以使用sleep + 数字（标识延迟多少秒启动）进行设置

3、为脚本文件赋予执行权限

使用**chmod +x** 命令标识将该文件设置为可执行文件

chmod +x /etc/rc.d/init.d/jar_auto.sh      #赋予执行权限

4、为jar脚本赋予开机自启权限

编辑/etc/rc.d目录下的rc.local文件，将jar启动脚本加入该文件中即可。

vim /etc/rc.d/rc.local

rc.local文件中加入jar启动脚本文件绝对路径，如下：

# rc.local文件
/etc/rc.d/init.d/jar_auto.sh

5、赋予/etc/rc.d/rc.local文件执行权限

将jar脚本文件目录添加到rc.local文件后，需要为文件重新赋予执行权限，执行**chmod -x**命令

chmod +x /etc/rc.d/rc.local

6、使用reboot命令重启Linux系统，使用ps -ef | grep buss-admin 命令查看是否启动成功！

# 重启系统
reboot
# 启动完成后查看jar包是否已启动
ps -ef | grep buss-admin

DurkBlue博客

springBoot实现Redis分布式加锁功能

2. 配置RedissonClient

3. 使用RedissonClient实现分布式锁

nginx 将访问/fljc/public/下的所有除了css和js文件和图片资源之外 路由自动重写/fljc/public/index.php/下所有响应路径

解释：

浅谈以下如何实现超大文件断点续传功能

ZLMediaKit在linux X86_64上的部署与启动

记录离线方式实现docker版本的升级 docker-compose升级版本

步骤 2: 安装 docker-compose

在js里引用地图发现 is invoked via document.write. The network request for this script MAY be blocked by the

记录phpStudy环境软件数据库管理器phpMyAdmin4.8.5 更改为远程数据库地址连接

记录使用MinIO作为文件分布式存储服务的使用方法

麒麟系统安装docker时发现yum install-y yum-utils报错 No match for argument：Unable to find a match

JAR包在linux系统中后台进行常驻并开机自启动 jar包自启jar包后台启动jar自启动jar后台启动

Linux系统配置开机自动启动Java项目

1、准备工作

2、创建自启脚本jar_auto.sh

3、为脚本文件赋予执行权限

4、为jar脚本赋予开机自启权限

5、赋予/etc/rc.d/rc.local文件执行权限

nginx 将访问/fljc/public/下的所有除了css和js文件和图片资源之外路由自动重写/fljc/public/index.php/下所有响应路径