重构minio和mqtt配置信息获取 重构minio工具类 区分生产环境和开发环境配置信息

‘liusuyi’

2023-08-23 aea81128444acb8ca9a90bc7ef04758bf2cd284d

重构minio和mqtt配置信息获取
重构minio工具类
区分生产环境和开发环境配置信息

 ard-work/src/main/java/com/ruoyi/app/position/controller/ArdAppPositionController.java

@@ -46,7 +46,8 @@
    private IArdAppPositionService ardAppPositionService;
    @Autowired
    private ISysUserService sysUserService;

    @Autowired
    private MinioUtils minioUtil;

    /**
     * 查询app位置列表
@@ -200,7 +201,7 @@
    @ApiOperation("上传文件")
    public AjaxResult uploadFile(MultipartFile file,String type)
    {
        String url = MinioUtils.putObjectAndGetUrl("app",type, file);
        String url = minioUtil.putObjectAndGetUrl("app",type, file);
        return AjaxResult.success(url);
    }
}

 ard-work/src/main/java/com/ruoyi/device/camera/service/impl/ArdCamerasServiceImpl.java

@@ -120,20 +120,7 @@
        ardCameras.setCreateTime(DateUtils.getNowDate());
        ardCameras.setUserId(SecurityUtils.getUserId());
        redisCache.setCacheObject(getCacheKey(ardCameras.getId()), ardCameras);
        int i = ardCamerasMapper.insertArdCameras(ardCameras);
        if (i > 0) {
//            //删除当前相机的所有通道
//            ardChannelMapper.deleteArdChannelByDeviceId(ardCameras.getId());
//            //获取相机通道
//            List<ArdChannel> ipChannelList = hikClientService.getCameraChannelList(ardCameras);
//            if (ipChannelList.size() > 0) {
//                for (ArdChannel channel : ipChannelList) {
//                    channel.setId(IdUtils.simpleUUID());
//                    ardChannelMapper.insertArdChannel(channel);
//                }
//            }
        }
        return i;
        return ardCamerasMapper.insertArdCameras(ardCameras);
    }

    /**

 ard-work/src/main/java/com/ruoyi/device/hiksdk/config/MinioClientSingleton.java

文件已删除

 ard-work/src/main/java/com/ruoyi/device/hiksdk/service/impl/HikClientServiceImpl.java

@@ -1,16 +1,13 @@
package com.ruoyi.device.hiksdk.service.impl;

import com.alibaba.fastjson2.JSONObject;
import com.ruoyi.common.annotation.SdkOperate;
import com.ruoyi.common.utils.file.FileUtils;
import com.ruoyi.common.utils.uuid.IdUtils;
import com.ruoyi.device.camera.domain.CameraCmd;
import com.ruoyi.device.camera.service.IArdCamerasService;
import com.ruoyi.device.channel.domain.ArdChannel;
import com.ruoyi.device.channel.service.IArdChannelService;
import com.ruoyi.device.hiksdk.common.GlobalVariable;
import com.ruoyi.device.camera.domain.ArdCameras;
import com.ruoyi.device.hiksdk.config.MinioClientSingleton;
import com.ruoyi.device.hiksdk.util.hikSdkUtil.GisUtil;
import com.ruoyi.device.hiksdk.util.hikSdkUtil.HCNetSDK;
import com.ruoyi.device.hiksdk.service.IHikClientService;
@@ -22,7 +19,7 @@
import com.sun.jna.Pointer;
import com.sun.jna.ptr.IntByReference;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.util.Base64;
@@ -33,7 +30,6 @@
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

import static com.ruoyi.device.hiksdk.util.hikSdkUtil.HCNetSDK.*;

@@ -48,8 +44,12 @@
@Service
public class HikClientServiceImpl implements IHikClientService {

    @Value("${minio.endpoint}")
    private static String endpoint;
    @Resource
    IArdCamerasService ardCamerasService;
    private IArdCamerasService ardCamerasService;
    @Resource
    private MinioUtils minioUtil;

    private static HCNetSDK hCNetSDK;

@@ -1155,9 +1155,9 @@
            InputStream input = new ByteArrayInputStream(array);
            String url = "";
            try {
                boolean b = MinioUtils.uploadObject(BucketName, ObjectName, input, input.available(), ContentType);
                boolean b = minioUtil.uploadObject(BucketName, ObjectName, input, input.available(), ContentType);
                if (b) {
                    url = MinioUtils.getBucketObjectUrl(BucketName, ObjectName);
                    url = minioUtil.getBucketObjectUrl(BucketName, ObjectName);
                    log.debug("上传文件成功!" + url);
                }
            } catch (IOException ex) {
@@ -1341,9 +1341,9 @@
            FileInputStream stream = new FileInputStream(path);
            String time = new SimpleDateFormat("yyyyMMdd").format(new Date());
            String recordName = cameraId + "/" + time + "/" + ObjectName + ".mp4";
            boolean b = MinioUtils.uploadObject(BucketName, recordName, stream, stream.available(), ContentType);
            boolean b = minioUtil.uploadObject(BucketName, recordName, stream, stream.available(), ContentType);
            if (b) {
                url = MinioClientSingleton.domainUrl + "/" + BucketName + "/" + recordName;
                url = endpoint + "/" + BucketName + "/" + recordName;
                log.debug("上传文件成功!" + url);
            }
            return url;

 ard-work/src/main/java/com/ruoyi/media/service/impl/WebrtcService.java

@@ -47,8 +47,8 @@
                // 启动后台进程
                CmdUtils.commandStart(processName, cmd, null);
                // 启动cmd窗口
//            String[] command = {"cmd", "/c", "start", exePath, "-H127.0.0.1:8000", "-o"};
//            CmdUtils.commandStart(command);
//                String[] command = {"cmd", "/c", "start", exePath, "-H127.0.0.1:8000", "-o"};
//                CmdUtils.commandStart(command);
            }
        }
    }

 ard-work/src/main/java/com/ruoyi/storage/minio/utils/MinioConfig.java

对比新文件
@@ -0,0 +1,75 @@
package com.ruoyi.storage.minio.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

/**
 * @Description:
 * @ClassName: MinioClientSingleton
 * @Author: 刘苏义
 * @Date: 2023年05月18日9:32
 * @Version: 1.0
 **/
@Slf4j(topic = "minio")
@Component
public class MinioConfig {
    @Value("${minio.endpoint}")
    private  String endpoint;
    @Value("${minio.accessKey}")
    private  String accessKey;
    @Value("${minio.secretKey}")
    private  String secretKey;

//    private volatile static MinioClient minioClient;

    @Bean
    public io.minio.MinioClient getMinioClient() {
        return io.minio.MinioClient.builder()
                .endpoint(endpoint)
                .credentials(accessKey, secretKey)
                .build();
    }

//    /**
//     * 获取minio客户端实例
//     *
//     * @return {@link MinioClient}
//     */
//    public static MinioClient getMinioClient() {
//        if (minioClient == null) {
//            synchronized (MinioClientSingleton.class) {
//                if (minioClient == null) {
//                    minioClient = MinioClient.builder()
//                            .endpoint(endpoint)
//                            .credentials(accessKey, secretKey)
//                            .build();
//                }
//            }
//        }
//        return minioClient;
//    }
    //    static {
//        domainUrl = getYmlNew("minio.endpoint");
//        accessKey = getYmlNew("minio.accessKey");
//        secretKey = getYmlNew("minio.secretKey");
//        log.debug("minio信息：" + domainUrl + "(" + accessKey + "/" + secretKey + ")");
//    }
    /*yml配置信息获取*/
//    public static String getYmlNew(String key) {
//        Resource resource = new ClassPathResource("application-prod.yml");
//        Properties properties = null;
//        try {
//            YamlPropertiesFactoryBean yamlFactory = new YamlPropertiesFactoryBean();
//            yamlFactory.setResources(resource);
//            properties = yamlFactory.getObject();
//        } catch (Exception e) {
//            e.printStackTrace();
//            return null;
//        }
//        return properties.get(key).toString();
//    }

}


 ard-work/src/main/java/com/ruoyi/storage/minio/utils/MinioUtils.java

@@ -2,13 +2,14 @@

import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.uuid.IdUtils;
import com.ruoyi.device.hiksdk.config.MinioClientSingleton;
import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.io.*;
import java.util.*;
import java.util.concurrent.TimeUnit;
@@ -22,19 +23,23 @@
 **/
@SuppressWarnings("ALL")
@Slf4j(topic = "minio")
@Component
public class MinioUtils {

    @Resource
    MinioClient minioClient;

    /**
     * 判断桶是否存在
     */
    public static boolean exitsBucket(String bucketName) {
    public boolean exitsBucket(String bucketName) {
        boolean found = false;
        try {
            if (StringUtils.isEmpty(bucketName)) {
                return false;
            }
            BucketExistsArgs bucketExistsArgs = BucketExistsArgs.builder().bucket(bucketName).build();
            found = MinioClientSingleton.getMinioClient().bucketExists(bucketExistsArgs);
            found = minioClient.bucketExists(bucketExistsArgs);

        } catch (Exception ex) {
            log.error("minio判断桶存在异常：", ex.getMessage());
@@ -45,14 +50,14 @@
    /**
     * 创建桶,并设置桶策略为公共
     */
    public static boolean createBucket(String bucketName) {
    public boolean createBucket(String bucketName) {
        try {
            if (StringUtils.isEmpty(bucketName)) {
                return false;
            }
            /*创建桶*/
            MakeBucketArgs makeBucketArgs = MakeBucketArgs.builder().bucket(bucketName).build();
            MinioClientSingleton.getMinioClient().makeBucket(makeBucketArgs);
            minioClient.makeBucket(makeBucketArgs);
            /*设置策略*/
            String sb = "{\"Version\":\"2012-10-17\"," +
                    "\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":" +
@@ -72,7 +77,7 @@
            queueConfiguration.setQueue("arn:minio:sqs::_:mqtt");

            //设置事件
            List<EventType> events=new ArrayList<>();
            List<EventType> events = new ArrayList<>();
            events.add(EventType.OBJECT_REMOVED_ANY);
            events.add(EventType.OBJECT_CREATED_ANY);
            queueConfiguration.setEvents(events);
@@ -82,8 +87,8 @@
            SetBucketNotificationArgs setBucketNotificationArgs = SetBucketNotificationArgs.builder()
                    .bucket(bucketName)
                    .config(config).build();
            MinioClientSingleton.getMinioClient().setBucketPolicy(setBucketPolicyArgs);
            MinioClientSingleton.getMinioClient().setBucketNotification(setBucketNotificationArgs);
            minioClient.setBucketPolicy(setBucketPolicyArgs);
            minioClient.setBucketNotification(setBucketNotificationArgs);

            return true;
        } catch (Exception ex) {
@@ -97,11 +102,11 @@
     *
     * @param bucket 桶名称
     */
    public static boolean removeBucket(String bucket) {
    public boolean removeBucket(String bucket) {
        try {
            boolean found = exitsBucket(bucket);
            if (found) {
                Iterable<Result<Item>> myObjects = MinioClientSingleton.getMinioClient().listObjects(ListObjectsArgs.builder().bucket(bucket).build());
                Iterable<Result<Item>> myObjects = minioClient.listObjects(ListObjectsArgs.builder().bucket(bucket).build());
                for (Result<Item> result : myObjects) {
                    Item item = result.get();
                    //有对象文件，则删除失败
@@ -110,7 +115,7 @@
                    }
                }
                // 删除`bucketName`存储桶，注意，只有存储桶为空时才能删除成功。
                MinioClientSingleton.getMinioClient().removeBucket(RemoveBucketArgs.builder().bucket(bucket).build());
                minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucket).build());
                found = exitsBucket(bucket);
                return !found;
            }
@@ -125,9 +130,9 @@
     *
     * @return
     */
    public static List<Bucket> getListBuckets() {
    public List<Bucket> getListBuckets() {
        try {
            return MinioClientSingleton.getMinioClient().listBuckets();
            return minioClient.listBuckets();
        } catch (Exception e) {
            e.printStackTrace();
        }
@@ -143,7 +148,7 @@
     * @param expires    失效时间（以秒为单位），默认是7天，不得大于七天
     * @return
     */
    public static String getObjectWithExpired(String bucketName, String objectName, Integer expires, TimeUnit timeUnit) {
    public String getObjectWithExpired(String bucketName, String objectName, Integer expires, TimeUnit timeUnit) {
        String url = "";
        if (exitsBucket(bucketName)) {
            try {
@@ -153,7 +158,7 @@
                        .object(objectName)
                        .expiry(expires, timeUnit)
                        .build();
                url = MinioClientSingleton.getMinioClient().getPresignedObjectUrl(getPresignedObjectUrlArgs);
                url = minioClient.getPresignedObjectUrl(getPresignedObjectUrlArgs);
            } catch (Exception ex) {
                log.error("minio生成失效url异常", ex.getMessage());
            }
@@ -171,7 +176,7 @@
     * @创建时间 2023/5/18 12:16
     * @修改人和其它信息
     */
    public static String putObjectAndGetUrl(String bucketName, MultipartFile file) {
    public String putObjectAndGetUrl(String bucketName, MultipartFile file) {
        if (!exitsBucket(bucketName)) {
            createBucket(bucketName);
        }
@@ -200,7 +205,7 @@
                    .stream(inputStream, file.getSize(), -1)
                    .contentType(file.getContentType())
                    .build();
            MinioClientSingleton.getMinioClient().putObject(putObjectArgs);
            minioClient.putObject(putObjectArgs);
            inputStream.close();
            /*获取url*/
            GetPresignedObjectUrlArgs getPresignedObjectUrlArgs = GetPresignedObjectUrlArgs
@@ -209,7 +214,7 @@
                    .object(fileName)
                    .method(Method.GET)
                    .build();
            String presignedObjectUrl = MinioClientSingleton.getMinioClient().getPresignedObjectUrl(getPresignedObjectUrlArgs);
            String presignedObjectUrl = minioClient.getPresignedObjectUrl(getPresignedObjectUrlArgs);
            String ObjectUrl = presignedObjectUrl.substring(0, presignedObjectUrl.indexOf("?"));
            return ObjectUrl;
        } catch (Exception ex) {
@@ -226,7 +231,7 @@
     * @创建时间 2023/5/18 12:16
     * @修改人和其它信息
     */
    public static String putObjectAndGetUrl(String bucketName, String folder, MultipartFile file) {
    public String putObjectAndGetUrl(String bucketName, String folder, MultipartFile file) {
        if (!exitsBucket(bucketName)) {
            createBucket(bucketName);
        }
@@ -255,7 +260,7 @@
                    .stream(inputStream, file.getSize(), -1)
                    .contentType(file.getContentType())
                    .build();
            MinioClientSingleton.getMinioClient().putObject(putObjectArgs);
            minioClient.putObject(putObjectArgs);
            inputStream.close();
            /*获取url*/
            GetPresignedObjectUrlArgs getPresignedObjectUrlArgs = GetPresignedObjectUrlArgs
@@ -264,7 +269,7 @@
                    .object(fileName)
                    .method(Method.GET)
                    .build();
            String presignedObjectUrl = MinioClientSingleton.getMinioClient().getPresignedObjectUrl(getPresignedObjectUrlArgs);
            String presignedObjectUrl = minioClient.getPresignedObjectUrl(getPresignedObjectUrlArgs);
            String ObjectUrl = presignedObjectUrl.substring(0, presignedObjectUrl.indexOf("?"));
            return ObjectUrl;
        } catch (Exception ex) {
@@ -280,12 +285,12 @@
     * @param objectName 对象名称
     * @return boolean
     */
    public static boolean removeObject(String bucket, String objectName) {
    public boolean removeObject(String bucket, String objectName) {
        try {
            boolean exsit = exitsBucket(bucket);
            if (exsit) {
                RemoveObjectArgs removeObjectArgs = RemoveObjectArgs.builder().bucket(bucket).object(objectName).build();
                MinioClientSingleton.getMinioClient().removeObject(removeObjectArgs);
                minioClient.removeObject(removeObjectArgs);
                return true;
            }
        } catch (Exception e) {
@@ -300,7 +305,7 @@
     * @param objectNames 对象名称
     * @return boolean
     */
    public static boolean removeObjects(String bucket, List<String> objectNames) {
    public boolean removeObjects(String bucket, List<String> objectNames) {
        if (exitsBucket(bucket)) {
            try {
                List<DeleteObject> objects = new LinkedList<>();
@@ -308,7 +313,7 @@
                    objects.add(new DeleteObject(str));
                }
                RemoveObjectsArgs removeObjectsArgs = RemoveObjectsArgs.builder().bucket(bucket).objects(objects).build();
                Iterable<Result<DeleteError>> results = MinioClientSingleton.getMinioClient().removeObjects(removeObjectsArgs);
                Iterable<Result<DeleteError>> results = minioClient.removeObjects(removeObjectsArgs);
                /*删除完遍历结果，否则删不掉*/
                for (Result<DeleteError> result : results) {
                    DeleteError error = result.get();
@@ -329,13 +334,37 @@
     * @param bucket 桶名称
     * @return {@link List}<{@link String}>
     */
    public static List<String> getBucketObjectName(String bucket) {
    public List<String> getBucketObjectName(String bucket) {
        boolean exsit = exitsBucket(bucket);
        if (exsit) {
            List<String> listObjetcName = new ArrayList<>();
            try {
                ListObjectsArgs listObjectsArgs = ListObjectsArgs.builder().bucket(bucket).build();
                Iterable<Result<Item>> myObjects = MinioClientSingleton.getMinioClient().listObjects(listObjectsArgs);
                Iterable<Result<Item>> myObjects = minioClient.listObjects(listObjectsArgs);
                for (Result<Item> result : myObjects) {
                    Item item = result.get();
                    listObjetcName.add(item.objectName());
                }
                return listObjetcName;
            } catch (Exception ex) {
                log.error("minio获取桶下对象异常：" + ex.getMessage());
            }
        }
        return null;
    }

    /**
     * 获取单个桶中的所有文件对象名称
     * @param [bucket,prefix]
     * @return {@link List}<{@link String}>
     */
    public List<String> getBucketObjectName(String bucket, String prefix) {
        boolean exsit = exitsBucket(bucket);
        if (exsit) {
            List<String> listObjetcName = new ArrayList<>();
            try {
                ListObjectsArgs listObjectsArgs = ListObjectsArgs.builder().prefix(prefix).bucket(bucket).build();
                Iterable<Result<Item>> myObjects = minioClient.listObjects(listObjectsArgs);
                for (Result<Item> result : myObjects) {
                    Item item = result.get();
                    listObjetcName.add(item.objectName());
@@ -355,7 +384,7 @@
     * @param objectName 对象名 (文件夹名 + 文件名)
     * @return
     */
    public static String getBucketObjectUrl(String bucketName, String objectName) {
    public String getBucketObjectUrl(String bucketName, String objectName) {
        try {
            if (!exitsBucket(bucketName)) {
                return "";
@@ -366,7 +395,9 @@
                    .object(objectName)
                    .method(Method.GET)
                    .build();
            return MinioClientSingleton.getMinioClient().getPresignedObjectUrl(getPresignedObjectUrlArgs);
            String presignedObjectUrl = minioClient.getPresignedObjectUrl(getPresignedObjectUrlArgs);
            String ObjectUrl = presignedObjectUrl.substring(0, presignedObjectUrl.indexOf("?"));
            return ObjectUrl;
        } catch (Exception ex) {
            log.error("minio获取对象URL异常" + ex.getMessage());
        }
@@ -382,7 +413,7 @@
     * @param size        ⼤⼩
     * @param contextType 类型 Image/jpeg 浏览器可以直接打开，否则下载
     */
    public static boolean uploadObject(String bucketName, String objectName, InputStream stream, long size, String contextType) {
    public boolean uploadObject(String bucketName, String objectName, InputStream stream, long size, String contextType) {
        try {
            if (!exitsBucket(bucketName)) {
                createBucket(bucketName);
@@ -393,7 +424,7 @@
                    .stream(stream, size, -1)
                    .contentType(contextType)
                    .build();
            ObjectWriteResponse objectWriteResponse = MinioClientSingleton.getMinioClient().putObject(putObjectArgs);
            ObjectWriteResponse objectWriteResponse = minioClient.putObject(putObjectArgs);
            return true;
        } catch (Exception ex) {
            log.error("minio上传文件(通过stream)异常" + ex.getMessage());
@@ -409,7 +440,7 @@
     * @param file        ⽂件
     * @param contextType 类型 Image/jpeg 浏览器可以直接打开，否则下载
     */
    public static boolean uploadObject(String bucketName, String objectName, File file, String contextType) {
    public boolean uploadObject(String bucketName, String objectName, File file, String contextType) {
        try {
            if (!exitsBucket(bucketName)) {
                createBucket(bucketName);
@@ -421,7 +452,7 @@
                    .stream(fileInputStream, file.length(), -1)
                    .contentType(contextType)
                    .build();
            ObjectWriteResponse objectWriteResponse = MinioClientSingleton.getMinioClient().putObject(putObjectArgs);
            ObjectWriteResponse objectWriteResponse = minioClient.putObject(putObjectArgs);
            return true;
        } catch (Exception ex) {
            log.error("minio上传文件(通过File)异常" + ex.getMessage());
@@ -437,7 +468,7 @@
     * @param MultipartFile ⽂件
     * @param contextType   类型 Image/jpeg 浏览器可以直接打开，否则下载
     */
    public static boolean uploadObject(String bucketName, String objectName, MultipartFile multipartFile, String contextType) {
    public boolean uploadObject(String bucketName, String objectName, MultipartFile multipartFile, String contextType) {
        try {
            if (!exitsBucket(bucketName)) {
                createBucket(bucketName);
@@ -449,7 +480,7 @@
                    .stream(inputStream, multipartFile.getSize(), -1)
                    .contentType(contextType)
                    .build();
            ObjectWriteResponse objectWriteResponse = MinioClientSingleton.getMinioClient().putObject(putObjectArgs);
            ObjectWriteResponse objectWriteResponse = minioClient.putObject(putObjectArgs);
            return true;
        } catch (Exception ex) {
            log.error("minio上传文件(通过File)异常" + ex.getMessage());
@@ -465,7 +496,7 @@
     * @param MultipartFile ⽂件
     * @param contextType   类型 Image/jpeg 浏览器可以直接打开，否则下载
     */
    public static boolean uploadObject(String bucketName, MultipartFile multipartFile, String contextType) {
    public boolean uploadObject(String bucketName, MultipartFile multipartFile, String contextType) {
        try {
            if (!exitsBucket(bucketName)) {
                createBucket(bucketName);
@@ -482,7 +513,7 @@
                    .stream(inputStream, multipartFile.getSize(), -1)
                    .contentType(contextType)
                    .build();
            MinioClientSingleton.getMinioClient().putObject(putObjectArgs);
            minioClient.putObject(putObjectArgs);
            return true;
        } catch (Exception ex) {
            log.error("minio上传文件(通过File)异常" + ex.getMessage());
@@ -498,7 +529,7 @@
     * @param localFilePathName
     * @return
     */
    public static boolean uploadObject(String bucketName, String objectName, String localFilePathName, String contextType) {
    public boolean uploadObject(String bucketName, String objectName, String localFilePathName, String contextType) {
        try {
            if (!exitsBucket(bucketName)) {
                createBucket(bucketName);
@@ -514,7 +545,7 @@
                    .filename(localFilePathName)
                    .contentType(contextType)
                    .build();
            ObjectWriteResponse objectWriteResponse = MinioClientSingleton.getMinioClient().uploadObject(uploadObjectArgs);
            ObjectWriteResponse objectWriteResponse = minioClient.uploadObject(uploadObjectArgs);
            return true;
        } catch (Exception e) {
            log.error("minio upload object file error " + e.getMessage());
@@ -530,42 +561,28 @@
     * @创建时间 2023/2/6 10:32
     * @修改人和其它信息
     */
    public static Iterable<Result<Item>> getObjectsByBucket(String bucketName) {
        Iterable<Result<Item>> listObjects = MinioClientSingleton.getMinioClient().listObjects(ListObjectsArgs.builder()
    public Iterable<Result<Item>> getObjectsByBucket(String bucketName) {
        Iterable<Result<Item>> listObjects = minioClient.listObjects(ListObjectsArgs.builder()
                .bucket(bucketName)
                .recursive(true)
                .build());
        return listObjects;
    }

    public static void main(String[] args) {
        //        /*删除桶*/
        //        boolean b = removeBucket("lsy");
        //        log.info(String.valueOf(b));
        //        /*创建桶*/
        //        boolean lsy = createBucket("lsy");
        //        log.info(String.valueOf(lsy));
        //        /*判断桶是否存在*/
        //        boolean pic = exitsBucket("lsy");
        //        log.info(String.valueOf(pic));
        /*查询所有桶*/
        //        List<Bucket> listBuckets = getListBuckets();
        //        for (Bucket bucket : listBuckets) {
        //            log.info(bucket.name());
        //        }
        String bucket = "lsy";
        String filename = UUID.randomUUID().toString().replace("-", "") + "pic.jpeg";
        String fileFullPath = "C:\\Users\\Administrator\\Desktop\\微信截图_20230518102605.png";
        //        uploadObject(bucket, filename, fileFullPath, "Image/jpeg");
        //        String url = getObjectWithExpired(bucket, filename, 10, SECONDS);
        //        System.out.println(url);
        boolean b = removeBucket(bucket);
        System.out.println(b);
        //        boolean b = uploadObjectBylocalPath(bucket, filename, fileFullPath);
        //        System.out.println(b);
        //String url = getObjectWithExpired(bucket, filename, 10000);
        //
        //String url = getBucketObject(bucket, filename);
        //      System.out.println(url); package com.example.minio;
    /**
     * @描述 获取桶中所有对象
     * @参数 [bucketName,prefix]
     * @返回值 java.lang.Iterable<io.minio.Result < io.minio.messages.Item>>
     * @创建人 刘苏义
     * @创建时间 2023/2/6 10:32
     * @修改人和其它信息
     */
    public Iterable<Result<Item>> getObjectsByBucket(String bucketName, String prefix) {
        Iterable<Result<Item>> listObjects = minioClient.listObjects(ListObjectsArgs.builder()
                .bucket(bucketName)
                .prefix(prefix)
                .recursive(true)
                .build());
        return listObjects;
    }
}

 ard-work/src/main/java/com/ruoyi/sy/service/impl/ArdSyCarServiceImpl.java

@@ -1,6 +1,5 @@
package com.ruoyi.sy.service.impl;

import java.awt.geom.Point2D;
import java.io.IOException;
import java.io.InputStream;
import java.text.ParseException;
@@ -24,7 +23,7 @@
import com.ruoyi.sy.mapper.ArdSyCarDayMapper;
import com.ruoyi.utils.tools.GisTool;
import com.ruoyi.utils.websocket.util.WebSocketUtils;
import com.ruoyi.device.hiksdk.config.MinioClientSingleton;
import com.ruoyi.storage.minio.utils.MinioConfig;
import com.ruoyi.storage.minio.utils.MinioUtils;
import com.ruoyi.sy.domain.ArdSyUser;
import com.ruoyi.sy.gps31.PositionContainer;
@@ -83,7 +82,8 @@
    RedisCache redisCache;
    @Resource
    private ArdSyCarDayMapper ardSyCarDayMapper;

    @Resource
    private MinioUtils minioUtil;
    private Map<Integer, Map<String, String>> logInMap = new HashMap();

    private Map<String, Timer> userCarTimerMap = new HashMap();
@@ -147,7 +147,7 @@
                objectNames.add(ardSyCar.getCarPicture().split("/sycar/")[1]);
            }
        }
        MinioUtils.removeObjects("sycar", objectNames);
        minioUtil.removeObjects("sycar", objectNames);
        return ardSyCarMapper.deleteArdSyCarByIds(ids);
    }

@@ -264,12 +264,12 @@

    @Override
    public List<Map<String, String>> getAllCarModel() {
        boolean exsit = MinioUtils.exitsBucket("sycar");
        boolean exsit = minioUtil.exitsBucket("sycar");
        if (exsit) {
            List<Map<String, String>> listObjetcName = new ArrayList<>();
            try {
                ListObjectsArgs listObjectsArgs = ListObjectsArgs.builder().prefix("carmodel/").bucket("sycar").build();
                Iterable<Result<Item>> myObjects = MinioClientSingleton.getMinioClient().listObjects(listObjectsArgs);
               // ListObjectsArgs listObjectsArgs = ListObjectsArgs.builder().prefix("carmodel/").bucket("sycar").build();
                Iterable<Result<Item>> myObjects = minioUtil.getObjectsByBucket("sycar","carmodel");
                for (Result<Item> result : myObjects) {
                    Item item = result.get();
                    Map<String, String> map = new HashMap();
@@ -332,16 +332,16 @@
            if (ardSyCarr.getCarPicture() != null || !ardSyCarr.getCarPicture().equals("")) {
                String objectName = ardSyCarr.getCarPicture().split("/sycar/")[1];
                objectNames.add(objectName);
                MinioUtils.removeObjects("sycar", objectNames);
                minioUtil.removeObjects("sycar", objectNames);
            }
        }
        //判断文件是否为空
        if (null == carPicture || 0 == carPicture.getSize()) {
            return "";
        }
        boolean exsit = MinioUtils.exitsBucket("sycar");
        boolean exsit = minioUtil.exitsBucket("sycar");
        if (!exsit) {
            boolean bucket = MinioUtils.createBucket("sycar");
            boolean bucket = minioUtil.createBucket("sycar");
        }
        //文件名
        String originalFilename = carPicture.getOriginalFilename();
@@ -350,14 +350,15 @@
        try {
            InputStream inputStream = carPicture.getInputStream();
            /*上传对象*/
            PutObjectArgs putObjectArgs = PutObjectArgs
                    .builder()
                    .bucket("sycar")
                    .object(fileName)
                    .stream(inputStream, carPicture.getSize(), -1)
                    .contentType(carPicture.getContentType())
                    .build();
            MinioClientSingleton.getMinioClient().putObject(putObjectArgs);
//            PutObjectArgs putObjectArgs = PutObjectArgs
//                    .builder()
//                    .bucket("sycar")
//                    .object(fileName)
//                    .stream(inputStream, carPicture.getSize(), -1)
//                    .contentType(carPicture.getContentType())
//                    .build();
//            MinioConfig.getMinioClient().putObject(putObjectArgs);
            minioUtil.uploadObject("sycar",fileName,inputStream,carPicture.getSize(),carPicture.getContentType());
            inputStream.close();
            /*获取url*/
            GetPresignedObjectUrlArgs getPresignedObjectUrlArgs = GetPresignedObjectUrlArgs
@@ -366,8 +367,8 @@
                    .object(fileName)
                    .method(Method.GET)
                    .build();
            String presignedObjectUrl = MinioClientSingleton.getMinioClient().getPresignedObjectUrl(getPresignedObjectUrlArgs);
            String ObjectUrl = presignedObjectUrl.substring(0, presignedObjectUrl.indexOf("?"));
            //String presignedObjectUrl = MinioConfig.getMinioClient().getPresignedObjectUrl(getPresignedObjectUrlArgs);
            String ObjectUrl = minioUtil.getBucketObjectUrl("sycar", fileName);
            if (id != null && !id.equals("")) {//id为非必要
                ArdSyCar ardSyCar = new ArdSyCar();
                ardSyCar.setId(id);

 ard-work/src/main/java/com/ruoyi/test/ReadAccessDatabase.java

@@ -8,32 +8,23 @@
 * @Version: 1.0
 **/

import com.ruoyi.app.position.domain.ArdAppPosition;
import com.ruoyi.utils.websocket.util.WebSocketUtils;
import lombok.extern.slf4j.Slf4j;

import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.sql.*;
import java.util.*;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
@Slf4j
public class ReadAccessDatabase {

    public static void main(String[] args) {
//        // 多个数据库文件路径
//        String[] dbPaths = {
//                "D:\\mdb\\道路中心线.mdb",
//                "D:\\mdb\\防风林-灌木.mdb",
//                // 添加更多的数据库文件路径
//        };
//
//        // 遍历每个数据库文件
//        for (String dbPath : dbPaths) {
//            readDataFromAccessDatabase(dbPath);
//        }
        // 多个数据库文件路径
        String[] dbPaths = {
                "D:\\Workspaces\\ard\\安瑞达工作资料\\mdb\\道路中心线.mdb"
//                "D:\\Workspaces\\ard\\安瑞达工作资料\\mdb\\防风林-灌木.mdb",
                // 添加更多的数据库文件路径
        };

        // 遍历每个数据库文件
        for (String dbPath : dbPaths) {
            readDataFromAccessDatabase(dbPath);
        }
    }

    public static void readDataFromAccessDatabase(String dbPath) {
@@ -54,16 +45,16 @@
                if (!tableName.equals("道路中心线")) {
                    continue;
                }
                System.out.println("表名: " + tableName);
                log.info("表名: " + tableName);

                // 获取表的字段元数据
 //               ResultSet column = metaData.getColumns(null, null, tableName, null);
                ResultSet column = metaData.getColumns(null, null, tableName, null);
                // 遍历字段
//                while (column.next()) {
//                    String columnName = column.getString("COLUMN_NAME");
//                    System.out.println("字段名: " + columnName);
//                }
//                column.close();
                while (column.next()) {
                    String columnName = column.getString("COLUMN_NAME");
                    log.info("字段名: " + columnName);
                }
                column.close();
                // 执行查询操作
                String sql = "SELECT * FROM " + tableName; // 替换为你要查询的表名
                Statement statement = connection.createStatement();
@@ -72,12 +63,12 @@
                while (resultSet.next()) {
                    // 读取每一行数据
                    String id = resultSet.getString(1); // 根据表中的列名获取数据
                    String name = resultSet.getString("编号");

                    String no = resultSet.getString("编号");
                    String name = resultSet.getString("道路名称");
                    // 可以根据具体的表结构继续获取其他字段的数据

                    // 在这里处理获取到的数据，例如输出到控制台或保存到集合中
                    System.out.println("ID: " + id + ", Name: " + name);
                    log.info("ID: " + id + ", No: " + no+ ", Name: " + name);
                }
                // 关闭连接
                resultSet.close();
@@ -89,5 +80,7 @@
            e.printStackTrace();
        }
    }


}


 ard-work/src/main/java/com/ruoyi/utils/mqtt/MqttConsumer.java

@@ -3,6 +3,7 @@
import lombok.extern.slf4j.Slf4j;
import org.eclipse.paho.client.mqttv3.*;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;
@@ -18,12 +19,30 @@
@Slf4j(topic = "mqtt")
public class MqttConsumer implements ApplicationRunner {

    @Value("${mqtt.enabled}")
    private Boolean MQTT_ENABLED;
    @Value("${mqtt.topic}")
    private String MQTT_TOPIC;
    @Value("${mqtt.host}")
    private String MQTT_HOST;
    @Value("${mqtt.clientId}")
    private String MQTT_CLIENT_ID;
    @Value("${mqtt.username}")
    private String MQTT_USER_NAME;
    @Value("${mqtt.password}")
    private String MQTT_PASSWORD;
    @Value("${mqtt.timeout}")
    private int MQTT_TIMEOUT;
    @Value("${mqtt.keepalive}")
    private int MQTT_KEEP_ALIVE;

    private static MqttClient client;


    @Override
    public void run(ApplicationArguments args) {
        log.debug("初始化并启动mqtt......");
        if(PropertiesUtil.MQTT_ENABLED)
        if(MQTT_ENABLED)
        {
            this.connect();
        }
@@ -38,7 +57,7 @@
            getClient();
            // 2 设置配置
            MqttConnectOptions options = getOptions();
            String[] topic = PropertiesUtil.MQTT_TOPIC.split(",");
            String[] topic = MQTT_TOPIC.split(",");
            // 3 消息发布质量
            int[] qos = getQos(topic.length);
            // 4 最后设置
@@ -54,7 +73,7 @@
    public void getClient() {
        try {
            if (null == client) {
                client = new MqttClient(PropertiesUtil.MQTT_HOST, PropertiesUtil.MQTT_CLIENT_ID, new MemoryPersistence());
                client = new MqttClient(MQTT_HOST, MQTT_CLIENT_ID, new MemoryPersistence());
            }
            log.debug("--创建mqtt客户端");
        } catch (Exception e) {
@@ -68,12 +87,12 @@
    public MqttConnectOptions getOptions() {
        MqttConnectOptions options = new MqttConnectOptions();
        //设置用户名密码
        options.setUserName(PropertiesUtil.MQTT_USER_NAME);
        options.setPassword(PropertiesUtil.MQTT_PASSWORD.toCharArray());
        options.setUserName(MQTT_USER_NAME);
        options.setPassword(MQTT_PASSWORD.toCharArray());
        // 设置超时时间
        options.setConnectionTimeout(PropertiesUtil.MQTT_TIMEOUT);
        options.setConnectionTimeout(MQTT_TIMEOUT);
        // 设置会话心跳时间
        options.setKeepAliveInterval(PropertiesUtil.MQTT_KEEP_ALIVE);
        options.setKeepAliveInterval(MQTT_KEEP_ALIVE);
        // 是否清除session
        options.setCleanSession(true);
        log.debug("--生成mqtt配置对象");

 ard-work/src/main/java/com/ruoyi/utils/mqtt/MqttConsumerCallback.java

@@ -92,10 +92,10 @@
            if (null != topic && null != qos) {
                if (client.isConnected()) {
                    client.subscribe(topic, qos);
                    log.info("mqtt连接成功，客户端ID：" + PropertiesUtil.MQTT_CLIENT_ID);
                    log.info("mqtt连接成功" );
                    log.info("--订阅主题:：" + Arrays.toString(topic));
                } else {
                    log.info("mqtt连接失败，客户端ID：" + PropertiesUtil.MQTT_CLIENT_ID);
                    log.info("mqtt连接失败");
                }
            }
        } catch (Exception e) {

 ard-work/src/main/java/com/ruoyi/utils/mqtt/PropertiesUtil.java

文件已删除

 ard-work/src/main/java/com/ruoyi/utils/spring/SpringUtils.java

对比新文件
@@ -0,0 +1,158 @@
package com.ruoyi.utils.spring;

import org.springframework.aop.framework.AopContext;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import com.ruoyi.common.utils.StringUtils;

/**
 * spring工具类 方便在非spring管理环境中获取bean
 * 
 * @author ruoyi
 */
@Component
public final class SpringUtils implements BeanFactoryPostProcessor, ApplicationContextAware 
{
    /** Spring应用上下文环境 */
    private static ConfigurableListableBeanFactory beanFactory;

    private static ApplicationContext applicationContext;

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException 
    {
        SpringUtils.beanFactory = beanFactory;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException 
    {
        SpringUtils.applicationContext = applicationContext;
    }

    /**
     * 获取对象
     *
     * @param name
     * @return Object 一个以所给名字注册的bean的实例
     * @throws BeansException
     *
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) throws BeansException
    {
        return (T) beanFactory.getBean(name);
    }

    /**
     * 获取类型为requiredType的对象
     *
     * @param clz
     * @return
     * @throws BeansException
     *
     */
    public static <T> T getBean(Class<T> clz) throws BeansException
    {
        T result = (T) beanFactory.getBean(clz);
        return result;
    }

    /**
     * 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
     *
     * @param name
     * @return boolean
     */
    public static boolean containsBean(String name)
    {
        return beanFactory.containsBean(name);
    }

    /**
     * 判断以给定名字注册的bean定义是一个singleton还是一个prototype。 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
     *
     * @param name
     * @return boolean
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.isSingleton(name);
    }

    /**
     * @param name
     * @return Class 注册对象的类型
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static Class<?> getType(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.getType(name);
    }

    /**
     * 如果给定的bean名字在bean定义中有别名，则返回这些别名
     *
     * @param name
     * @return
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static String[] getAliases(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.getAliases(name);
    }

    /**
     * 获取aop代理对象
     * 
     * @param invoker
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T getAopProxy(T invoker)
    {
        return (T) AopContext.currentProxy();
    }

    /**
     * 获取当前的环境配置，无配置返回null
     *
     * @return 当前的环境配置
     */
    public static String[] getActiveProfiles()
    {
        return applicationContext.getEnvironment().getActiveProfiles();
    }

    /**
     * 获取当前的环境配置，当有多个环境配置时，只获取第一个
     *
     * @return 当前的环境配置
     */
    public static String getActiveProfile()
    {
        final String[] activeProfiles = getActiveProfiles();
        return StringUtils.isNotEmpty(activeProfiles) ? activeProfiles[0] : null;
    }

    /**
     * 获取配置文件中的值
     *
     * @param key 配置文件的key
     * @return 当前的配置文件的值
     *
     */
    public static String getRequiredProperty(String key)
    {
        return applicationContext.getEnvironment().getRequiredProperty(key);
    }
}

 ard-work/src/main/resources/templates/test.html

@@ -162,7 +162,7 @@
            }
        })

        opt = {"username": "liusuyi", "password": "5959932"};
        opt = {"username": "admin", "password": "admin123"};
        $.ajax({
            headers: {
                'Accept': 'application/json',

 ruoyi-admin/src/main/resources/application-ard.yml

文件已删除

 ruoyi-admin/src/main/resources/application-dev-druid.yml

对比新文件
@@ -0,0 +1,58 @@
# 数据源配置
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      # 主库数据源
      master:
        driverClassName: org.postgresql.Driver
        url: jdbc:postgresql://192.168.1.15:5432/ry-vue?stringtype=unspecified
        username: postgres
        password: postgres
        # 从库数据源
      slave:
      # 从数据源开关/默认关闭
      # enabled: true
      # driverClassName: org.postgresql.Driver
      # url: jdbc:postgresql://112.98.126.2:35432/ard732
      # username: postgres
      # password: Yykj.2017
      # 初始连接数
      initialSize: 5
      # 最小连接池数量
      minIdle: 10
      # 最大连接池数量
      maxActive: 20
      # 配置获取连接等待超时的时间
      maxWait: 60000
      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      timeBetweenEvictionRunsMillis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      minEvictableIdleTimeMillis: 300000
      # 配置一个连接在池中最大生存的时间，单位是毫秒
      maxEvictableIdleTimeMillis: 900000
      # 配置检测连接是否有效
      validationQuery: SELECT 1
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      webStatFilter:
        enabled: true
      statViewServlet:
        enabled: true
        # 设置白名单，不填则允许所有访问
        allow:
        url-pattern: /druid/*
        # 控制台管理用户名和密码
        login-username: ruoyi
        login-password: 123456
      filter:
        stat:
          enabled: true
          # 慢SQL记录
          log-slow-sql: true
          slow-sql-millis: 3000
          merge-sql: true
        wall:
          config:
            multi-statement-allow: true

 ruoyi-admin/src/main/resources/application-dev.yml

对比新文件
@@ -0,0 +1,101 @@
# 开发环境配置
server:
  # 服务器的HTTP端口，默认为8080
  port: 8080
  servlet:
    # 应用的访问路径
    context-path: /
  tomcat:
    # tomcat的URI编码
    uri-encoding: UTF-8
    # 连接数满后的排队数，默认为100
    accept-count: 1000
    threads:
      # tomcat最大线程数，默认为200
      max: 800
      # Tomcat启动初始化的线程数，默认值10
      min-spare: 100
# Spring配置
spring:
  # redis 配置
  redis:
    # 地址
    host: 127.0.0.1
    # 端口，默认为6379
    port: 6379
    # 数据库索引
    database: 0
    # 密码
    password:
    # 连接超时时间
    timeout: 10s
    lettuce:
      pool:
        # 连接池中的最小空闲连接
        min-idle: 0
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池的最大数据库连接数
        max-active: 8
        # #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1ms
# 日志配置
logging:
  level:
    authorize: info
    minio: info
    hikSdk: info
    stealAlarm: info
    websocket: info
    patrolInspectionTask: info
    mqtt: info
    guideQueue: info
    rongCloud: info
    cmd: info
    uav: info
    sy: info


# webrtc-streamer配置
webrtc:
  enabled: true
  host: 127.0.0.1:8000
# minio配置
minio:
  enabled: false
  endpoint: http://192.168.1.15:9001
  accessKey: admin
  secretKey: xzx12345
  path: G:/DATA
# forest配置
forest:
  backend: okhttp3             # 后端HTTP框架（默认为 okhttp3）
  max-connections: 1000        # 连接池最大连接数（默认为 500）
  max-route-connections: 500   # 每个路由的最大连接数（默认为 500）
  max-request-queue-size: 100  # [自v1.5.22版本起可用] 最大请求等待队列大小
  max-async-thread-size: 300   # [自v1.5.21版本起可用] 最大异步线程数
  max-async-queue-size: 16     # [自v1.5.22版本起可用] 最大异步线程池队列大小
  timeout: 3000                # [已不推荐使用] 请求超时时间，单位为毫秒（默认为 3000）
  connect-timeout: 3000        # 连接超时时间，单位为毫秒（默认为 timeout）
  read-timeout: 3000           # 数据读取超时时间，单位为毫秒（默认为 timeout）
  max-retry-count: 0           # 请求失败后重试次数（默认为 0 次不重试）
  ssl-protocol: TLS            # 单向验证的HTTPS的默认TLS协议（默认为 TLS）
  log-enabled: true            # 打开或关闭日志（默认为 true）
  log-request: true            # 打开/关闭Forest请求日志（默认为 true）
  log-response-status: true    # 打开/关闭Forest响应状态日志（默认为 true）
  log-response-content: true   # 打开/关闭Forest响应内容日志（默认为 false）
  async-mode: platform         # [自v1.5.27版本起可用] 异步模式（默认为 platform）
#流媒体转码服务器
mediamtx:
  enabled: true
  host: 127.0.0.1
#mqtt
mqtt:
  host: tcp://192.168.1.15:1883
  clientId: m227
  username: admin
  password: xzx12345
  topic: minioEvent
  timeout: 100
  keepalive: 60
  enabled: true

 ruoyi-admin/src/main/resources/application-druid.yml

文件已删除

 ruoyi-admin/src/main/resources/application-prod-druid.yml

对比新文件
@@ -0,0 +1,58 @@
# 数据源配置
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      # 主库数据源
      master:
        driverClassName: org.postgresql.Driver
        url: jdbc:postgresql://112.98.126.2:35432/ry-vue?stringtype=unspecified
        username: postgres
        password: Yykj.2017
        # 从库数据源
      slave:
      # 从数据源开关/默认关闭
      # enabled: true
      # driverClassName: org.postgresql.Driver
      # url: jdbc:postgresql://112.98.126.2:35432/ard732
      # username: postgres
      # password: Yykj.2017
      # 初始连接数
      initialSize: 5
      # 最小连接池数量
      minIdle: 10
      # 最大连接池数量
      maxActive: 20
      # 配置获取连接等待超时的时间
      maxWait: 60000
      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      timeBetweenEvictionRunsMillis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      minEvictableIdleTimeMillis: 300000
      # 配置一个连接在池中最大生存的时间，单位是毫秒
      maxEvictableIdleTimeMillis: 900000
      # 配置检测连接是否有效
      validationQuery: SELECT 1
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      webStatFilter:
        enabled: true
      statViewServlet:
        enabled: true
        # 设置白名单，不填则允许所有访问
        allow:
        url-pattern: /druid/*
        # 控制台管理用户名和密码
        login-username: ruoyi
        login-password: 123456
      filter:
        stat:
          enabled: true
          # 慢SQL记录
          log-slow-sql: true
          slow-sql-millis: 3000
          merge-sql: true
        wall:
          config:
            multi-statement-allow: true

 ruoyi-admin/src/main/resources/application-prod.yml

对比新文件
@@ -0,0 +1,101 @@
# 生产环境配置
server:
  # 服务器的HTTP端口，默认为8080
  port: 8080
  servlet:
    # 应用的访问路径
    context-path: /
  tomcat:
    # tomcat的URI编码
    uri-encoding: UTF-8
    # 连接数满后的排队数，默认为100
    accept-count: 1000
    threads:
      # tomcat最大线程数，默认为200
      max: 800
      # Tomcat启动初始化的线程数，默认值10
      min-spare: 100
# Spring配置
spring:
  # redis 配置
  redis:
    # 地址
    host: 192.168.5.229
    # 端口，默认为6379
    port: 6379
    # 数据库索引
    database: 0
    # 密码
    password:
    # 连接超时时间
    timeout: 10s
    lettuce:
      pool:
        # 连接池中的最小空闲连接
        min-idle: 0
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池的最大数据库连接数
        max-active: 8
        # #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1ms
# 日志配置
logging:
  level:
    authorize: info
    minio: info
    hikSdk: info
    stealAlarm: info
    websocket: info
    patrolInspectionTask: info
    mqtt: info
    guideQueue: info
    rongCloud: info
    cmd: info
    uav: info
    sy: info

# webrtc-streamer配置
webrtc:
  enabled: false
  host: 192.168.5.229:8000

# minio配置
minio:
  enabled: false
  endpoint: http://192.168.5.229:9001
  accessKey: admin
  secretKey: xzx12345
  path: F:/DATA
# forest配置
forest:
  backend: okhttp3             # 后端HTTP框架（默认为 okhttp3）
  max-connections: 1000        # 连接池最大连接数（默认为 500）
  max-route-connections: 500   # 每个路由的最大连接数（默认为 500）
  max-request-queue-size: 100  # [自v1.5.22版本起可用] 最大请求等待队列大小
  max-async-thread-size: 300   # [自v1.5.21版本起可用] 最大异步线程数
  max-async-queue-size: 16     # [自v1.5.22版本起可用] 最大异步线程池队列大小
  timeout: 3000                # [已不推荐使用] 请求超时时间，单位为毫秒（默认为 3000）
  connect-timeout: 3000        # 连接超时时间，单位为毫秒（默认为 timeout）
  read-timeout: 3000           # 数据读取超时时间，单位为毫秒（默认为 timeout）
  max-retry-count: 0           # 请求失败后重试次数（默认为 0 次不重试）
  ssl-protocol: TLS            # 单向验证的HTTPS的默认TLS协议（默认为 TLS）
  log-enabled: true            # 打开或关闭日志（默认为 true）
  log-request: true            # 打开/关闭Forest请求日志（默认为 true）
  log-response-status: true    # 打开/关闭Forest响应状态日志（默认为 true）
  log-response-content: true   # 打开/关闭Forest响应内容日志（默认为 false）
  async-mode: platform         # [自v1.5.27版本起可用] 异步模式（默认为 platform）
#流媒体转码服务器
mediamtx:
  enabled: true
  host: 192.168.5.229
#mqtt
mqtt:
  host: tcp://192.168.5.229:1883
  clientId: server229
  username: admin
  password: xzx12345
  topic: minioEvent,apponekey,camera,external
  timeout: 100
  keepalive: 60
  enabled: true

 ruoyi-admin/src/main/resources/application.yml

@@ -11,36 +11,9 @@
  # 文件路径 示例（ Windows配置D:/ard/uploadPath，Linux配置 /home/ard/uploadPath）
  profile: D:/ard/uploadPath
  # 获取ip地址开关
  addressEnabled: false
  addressEnabled: true
  # 验证码类型 math 数组计算 char 字符验证
  captchaType: char

# 开发环境配置
server:
  # 服务器的HTTP端口，默认为8080
  port: 8080
  servlet:
    # 应用的访问路径
    context-path: /
  tomcat:
    # tomcat的URI编码
    uri-encoding: UTF-8
    # 连接数满后的排队数，默认为100
    accept-count: 1000
    threads:
      # tomcat最大线程数，默认为200
      max: 800
      # Tomcat启动初始化的线程数，默认值10
      min-spare: 100

# 日志配置
logging:
  level:
    com.ruoyi.utils.tube: debug
    com.ruoyi.inspect: info
    org.springframework: warn
    com.example.mapper: debug

# 用户配置
user:
  password:
@@ -48,60 +21,14 @@
    maxRetryCount: 5
    # 密码锁定时间（默认10分钟）
    lockTime: 10

# Spring配置
spring:
  # 资源信息
  messages:
    # 国际化资源文件路径
    basename: i18n/messages
  profiles: 
    active: druid,ard
  # 文件上传
  servlet:
     multipart:
       # 单个文件大小
       max-file-size:  10MB
       # 设置总上传的文件大小
       max-request-size:  20MB
  # 服务模块
  devtools:
    restart:
      # 热部署开关
      enabled: false
  # redis 配置
  redis:
    # 地址
    host: 192.168.1.15
    # 端口，默认为6379
    port: 6379
    # 数据库索引
    database: 0
    # 密码
    password:
    # 连接超时时间
    timeout: 10s
    lettuce:
      pool:
        # 连接池中的最小空闲连接
        min-idle: 0
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池的最大数据库连接数
        max-active: 8
        # #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1ms
  thymeleaf:
    cache: false
# token配置
token:
    # 令牌自定义标识
    header: Authorization
    # 令牌密钥
    secret: abcdefghijklmnopqrstuvwxyz
    # 令牌有效期（默认30分钟）
    expireTime: 30
  
  # 令牌自定义标识
  header: Authorization
  # 令牌密钥
  secret: abcdefghijklmnopqrstuvwxyz
  # 令牌有效期（默认30分钟）
  expireTime: 30
# MyBatis配置
#mybatis:
#    # 搜索指定包别名
@@ -114,6 +41,10 @@
  type-Aliases-Package: com.ruoyi.**.domain
  mapper-Locations: classpath*:mapper/**/*Mapper.xml
  config-Location: classpath:mybatis/mybatis-config.xml
  global-config:
    banner: off # 关闭mybatisplus启动图标
    db-config: #主键不用MyBatis plus的雪花算法,用数据库的主键自增
      id-type: auto
#  configuration:
#    # 是否开启自动驼峰命名规则映射:从数据库列名到Java属性驼峰命名的类似映射
#    map-underscore-to-camel-case: true
@@ -121,30 +52,54 @@
#    call-setters-on-nulls: true
#    # 这个配置会将执行的sql打印出来，在开发或测试的时候可以用
#    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl


# PageHelper分页插件
pagehelper: 
pagehelper:
  helperDialect: postgresql
  supportMethodsArguments: true
  params: count=countSql 

  params: count=countSql
# Swagger配置
swagger:
  # 是否开启swagger
  enabled: true
  # 请求前缀
  pathMapping: /

# knife4j增强功能
knife4j:
  enable: true

# 防止XSS攻击
xss: 
xss:
  # 过滤开关
  enabled: true
  # 排除链接（多个用逗号分隔）
  excludes: /system/notice
  # 匹配链接
  urlPatterns: /system/*,/monitor/*,/tool/*
#异步线程池配置
ThreadPoolTask:
  corePoolSize: 20
  maxPoolSize: 40
  keepAliveSeconds: 300
  queueCapacity: 50
# Spring配置
spring:
  # 资源信息
  messages:
    # 国际化资源文件路径
    basename: i18n/messages
  # 文件上传
  servlet:
    multipart:
      # 单个文件大小
      max-file-size: 10MB
      # 设置总上传的文件大小
      max-request-size: 20MB
  # 服务模块
  devtools:
    restart:
      # 热部署开关
      enabled: false
  thymeleaf:
    cache: false
  profiles:
    active: dev-druid,dev


 ruoyi-quartz/src/main/java/com/ruoyi/quartz/task/MinioTask.java

@@ -6,6 +6,7 @@
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
@@ -21,6 +22,8 @@
@Component("MinioTask")
@Slf4j(topic = "minio")
public class MinioTask {
    @Resource
    MinioUtils minioUtil;

    public void delHistoryTask(Integer saveDays) {
        log.debug("执行历史数据删除");
@@ -30,7 +33,7 @@
            buckets.add("pic");
            buckets.add("record");
            for (String name : buckets) {
                Iterable<Result<Item>> listObjectsPic = MinioUtils.getObjectsByBucket(name);
                Iterable<Result<Item>> listObjectsPic = minioUtil.getObjectsByBucket(name);
                for (Result<Item> result : listObjectsPic) {
                    Item item = result.get();
                    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").withZone(ZoneId.of("Asia/Shanghai"));
@@ -48,7 +51,7 @@
                        log.debug("objectTime : " + objectTime);
                        log.debug("expireTime : " + expireTime);
                        log.debug("objectTime 时间在 expireTime 之前,执行删除");
                        boolean b = MinioUtils.removeObject(name, item.objectName());
                        boolean b = minioUtil.removeObject(name, item.objectName());
                        if (b) {
                            log.debug("成功删除过期数据：" + item.objectName() + "---" + item.lastModified());
                        }