重构minio工具类 配置文件区分生产环境和开发环境

‘liusuyi’

2023-08-23 3dadd51018b621bbb5b3abcde94df6d8fa9fbf6b

重构minio工具类
配置文件区分生产环境和开发环境

 src/main/java/com/ard/alarm/apponekey/controller/ArdAlarmApponekeyController.java

@@ -1,12 +1,12 @@
package com.ard.alarm.apponekey.controller;

import com.ard.utils.hiksdk.util.minio.MinioUtils;
import com.ard.utils.http.AjaxResult;
import org.springframework.beans.factory.annotation.Autowired;
import com.ard.utils.minio.MinioUtils;
import org.springframework.web.bind.annotation.*;
import com.ard.alarm.apponekey.domain.ArdAlarmApponekey;
import com.ard.alarm.apponekey.service.IArdAlarmApponekeyService;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;


/**
@@ -18,16 +18,16 @@
@RestController
@RequestMapping("/alarm/apponekey")
public class ArdAlarmApponekeyController {
    @Autowired
    @Resource
    private IArdAlarmApponekeyService ardAlarmApponekeyService;


    @Resource
    private MinioUtils minioUtil;
    /**
     * æ–°å¢žapp一键报警
     */
    @PostMapping
    public AjaxResult add(String userId,String name, Double longitude,Double latitude,Double altitude,MultipartFile file) {
        String url = MinioUtils.putObjectAndGetUrl("record", file);
        String url = minioUtil.putObjectAndGetUrl("record", file);
        ArdAlarmApponekey ardAlarmApponekey =new ArdAlarmApponekey();
        ardAlarmApponekey.setUserId(userId);
        ardAlarmApponekey.setName(name);

 src/main/java/com/ard/config/MinioClientSingleton.java

ÎļþÒÑɾ³ý

 src/main/java/com/ard/utils/hiksdk/service/impl/FMSGCallBack.java

@@ -6,17 +6,16 @@
import com.ard.alarm.camera.service.IArdCamerasService;
import com.ard.alarm.external.domain.ArdEquipExternal;
import com.ard.alarm.external.service.IArdEquipExternalService;
import com.ard.config.MinioClientSingleton;
import com.ard.utils.minio.MinioUtils;
import com.ard.utils.other.ByteUtils;
import com.ard.utils.hiksdk.common.GlobalVariable;
import com.ard.utils.hiksdk.domain.AccessControlHostEventInfo;
import com.ard.utils.hiksdk.domain.CameraEventInfo;
import com.ard.utils.hiksdk.domain.ExternalAlarmEventInfo;
import com.ard.utils.hiksdk.util.hikSdkUtil.HCNetSDK;
import com.ard.utils.hiksdk.util.minio.MinioUtils;
import com.ard.utils.other.DateUtils;
import com.ard.utils.other.SpringTool;
import com.ard.utils.mqtt.MqttConsumer;
import com.ard.utils.spring.SpringUtils;
import com.ard.utils.uuid.IdUtils;
import com.sun.jna.Pointer;
import lombok.extern.slf4j.Slf4j;
@@ -61,7 +60,7 @@
                ArdCameras ardCameras = new ArdCameras();
                ardCameras.setIp(sDeviceIP);
                ardCameras.setPort(wLinkPort);
                IArdCamerasService ardCamerasService = SpringTool.getApplicationContext().getBean(IArdCamerasService.class);
                IArdCamerasService ardCamerasService = SpringUtils.getBean(IArdCamerasService.class);
                ArdCameras camera = ardCamerasService.selectArdCamerasList(ardCameras).get(0);
                HCNetSDK.NET_DVR_ALARMINFO_V30 netDvrAlarminfoV30 = new HCNetSDK.NET_DVR_ALARMINFO_V30();
                netDvrAlarminfoV30.write();
@@ -95,7 +94,7 @@
                ardCameras = new ArdCameras();
                ardCameras.setIp(sDeviceIP);
                ardCameras.setPort(wLinkPort);
                ardCamerasService = SpringTool.getApplicationContext().getBean(IArdCamerasService.class);
                ardCamerasService = SpringUtils.getBean(IArdCamerasService.class);
                ArdCameras ardCamera = ardCamerasService.selectArdCamerasList(ardCameras).get(0);

                HCNetSDK.NET_VCA_RULE_ALARM strVcaAlarm = new HCNetSDK.NET_VCA_RULE_ALARM();
@@ -190,7 +189,7 @@
                ArdEquipExternal ardEquipExternal = new ArdEquipExternal();
                ardEquipExternal.setIp(sDeviceIP);
                ardEquipExternal.setPort(wLinkPort);
                IArdEquipExternalService ardEquipExternalService = SpringTool.getApplicationContext().getBean(IArdEquipExternalService.class);
                IArdEquipExternalService ardEquipExternalService = SpringUtils.getBean(IArdEquipExternalService.class);
                ardEquipExternal = ardEquipExternalService.selectArdEquipExternal(ardEquipExternal);


@@ -276,7 +275,7 @@
                ArdEquipExternal accessControlHost = new ArdEquipExternal();
                accessControlHost.setIp(sDeviceIP);
                accessControlHost.setPort(wLinkPort);
                ardEquipExternalService = SpringTool.getApplicationContext().getBean(IArdEquipExternalService.class);
                ardEquipExternalService = SpringUtils.getBean(IArdEquipExternalService.class);
                accessControlHost = ardEquipExternalService.selectArdEquipExternal(accessControlHost);

                HCNetSDK.NET_DVR_ACS_ALARM_INFO strACSInfo = new HCNetSDK.NET_DVR_ACS_ALARM_INFO();
@@ -322,9 +321,10 @@
                        InputStream input = new ByteArrayInputStream(bytes);
                        String bucketName = "pic";
                        String objectName = "alarm/" + IdUtils.simpleUUID() + ".jpeg";
                        boolean uploadObject = MinioUtils.uploadObject(bucketName, objectName, input, "image/JPEG");
                        MinioUtils minioUtil = SpringUtils.getBean(MinioUtils.class);
                        boolean uploadObject = minioUtil.uploadObject(bucketName, objectName, input,input.available(), "image/JPEG");
                        if (uploadObject) {
                            url = MinioClientSingleton.domainUrl + "/" + bucketName + "/" + objectName;
                            url = minioUtil.getBucketObjectUrl(bucketName, objectName);
                            //log.debug("上传文件成功!" + url);
                        }
                    } catch (Exception e) {

 src/main/java/com/ard/utils/hiksdk/service/impl/HikClientUtil.java

@@ -3,12 +3,12 @@
import com.ard.alarm.camera.domain.ArdCameras;
import com.ard.alarm.camera.domain.CameraCmd;
import com.ard.alarm.external.domain.ArdEquipExternal;
import com.ard.config.MinioClientSingleton;
import com.ard.utils.minio.MinioUtils;
import com.ard.utils.other.ByteUtils;
import com.ard.utils.hiksdk.common.GlobalVariable;
import com.ard.utils.hiksdk.domain.DeviceInfo;
import com.ard.utils.hiksdk.util.hikSdkUtil.HCNetSDK;
import com.ard.utils.hiksdk.util.minio.MinioUtils;
import com.ard.utils.spring.SpringUtils;
import com.sun.jna.Native;
import com.sun.jna.Platform;
import com.sun.jna.Pointer;
@@ -434,11 +434,10 @@
            InputStream input = new ByteArrayInputStream(array);
            String url = "";
            try {
                boolean b = MinioUtils.uploadObject(cmd.getBucketName(), cmd.getObjectName(), input, ContentType);
                MinioUtils minioUtil = SpringUtils.getBean(MinioUtils.class);
                boolean b = minioUtil.uploadObject(cmd.getBucketName(), cmd.getObjectName(), input,input.available(), ContentType);
                if (b) {
                    // url = MinioUtils.getBucketObjectUrl(cmd.getBucketName(), cmd.getObjectName());
                    // url = url.indexOf('?') != -1 ? url.substring(0, url.indexOf('?')) : url;
                    url = MinioClientSingleton.domainUrl + "/" + cmd.getBucketName() + "/" + cmd.getObjectName();
                    url = minioUtil.getBucketObjectUrl(cmd.getBucketName(), cmd.getObjectName());
                   // log.debug("上传文件成功!" + url);
                }
            } catch (Exception ex) {

 src/main/java/com/ard/utils/hiksdk/util/minio/MinioUtils.java

ÎļþÒÑɾ³ý

 src/main/java/com/ard/utils/minio/MinioConfig.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,33 @@
package com.ard.utils.minio;

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("${spring.minio.endpoint}")
    private  String endpoint;
    @Value("${spring.minio.accessKey}")
    private  String accessKey;
    @Value("${spring.minio.secretKey}")
    private  String secretKey;

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


 src/main/java/com/ard/utils/minio/MinioUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,592 @@
package com.ard.utils.minio;

import com.ard.utils.other.StringUtils;
import com.ard.utils.uuid.IdUtils;
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.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @Description: Minio客户端工具类
 * @ClassName: MinioUtils
 * @Author: åˆ˜è‹ä¹‰
 * @Date: 2023å¹´05月18日9:34
 * @Version: 1.0
 **/
@SuppressWarnings("ALL")
@Slf4j(topic = "minio")
@Component
public class MinioUtils {

    @Resource
    MinioClient minioClient;

    /**
     * åˆ¤æ–­æ¡¶æ˜¯å¦å­˜åœ¨
     */
    public boolean exitsBucket(String bucketName) {
        boolean found = false;
        try {
            if (StringUtils.isEmpty(bucketName)) {
                return false;
            }
            BucketExistsArgs bucketExistsArgs = BucketExistsArgs.builder().bucket(bucketName).build();
            found = minioClient.bucketExists(bucketExistsArgs);

        } catch (Exception ex) {
            log.error("minio判断桶存在异常：", ex.getMessage());
        }
        return found;
    }

    /**
     * åˆ›å»ºæ¡¶,并设置桶策略为公共
     */
    public boolean createBucket(String bucketName) {
        try {
            if (StringUtils.isEmpty(bucketName)) {
                return false;
            }
            /*创建桶*/
            MakeBucketArgs makeBucketArgs = MakeBucketArgs.builder().bucket(bucketName).build();
            minioClient.makeBucket(makeBucketArgs);
            /*设置策略*/
            String sb = "{\"Version\":\"2012-10-17\"," +
                    "\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":" +
                    "{\"AWS\":[\"*\"]},\"Action\":[\"s3:ListBucket\",\"s3:ListBucketMultipartUploads\"," +
                    "\"s3:GetBucketLocation\"],\"Resource\":[\"arn:aws:s3:::" + bucketName +
                    "\"]},{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:PutObject\",\"s3:AbortMultipartUpload\",\"s3:DeleteObject\",\"s3:GetObject\",\"s3:ListMultipartUploadParts\"],\"Resource\":[\"arn:aws:s3:::" +
                    bucketName + "/*\"]}]}";
            SetBucketPolicyArgs setBucketPolicyArgs = SetBucketPolicyArgs.builder()
                    .bucket(bucketName)
                    .config(sb)
                    .build();
            /*设置通知mqtt*/
            //设置mqtt主题
            NotificationConfiguration config = new NotificationConfiguration();
            List<QueueConfiguration> queueConfigurations = new ArrayList<>();
            QueueConfiguration queueConfiguration = new QueueConfiguration();
            queueConfiguration.setQueue("arn:minio:sqs::_:mqtt");

            //设置事件
            List<EventType> events = new ArrayList<>();
            events.add(EventType.OBJECT_REMOVED_ANY);
            events.add(EventType.OBJECT_CREATED_ANY);
            queueConfiguration.setEvents(events);

            queueConfigurations.add(queueConfiguration);
            config.setQueueConfigurationList(queueConfigurations);
            SetBucketNotificationArgs setBucketNotificationArgs = SetBucketNotificationArgs.builder()
                    .bucket(bucketName)
                    .config(config).build();
            minioClient.setBucketPolicy(setBucketPolicyArgs);
            minioClient.setBucketNotification(setBucketNotificationArgs);

            return true;
        } catch (Exception ex) {
            log.error("minio创建桶异常：", ex.getMessage());
            return false;
        }
    }

    /**
     * åˆ é™¤ä¸€ä¸ªæ¡¶
     *
     * @param bucket æ¡¶åç§°
     */
    public boolean removeBucket(String bucket) {
        try {
            boolean found = exitsBucket(bucket);
            if (found) {
                Iterable<Result<Item>> myObjects = minioClient.listObjects(ListObjectsArgs.builder().bucket(bucket).build());
                for (Result<Item> result : myObjects) {
                    Item item = result.get();
                    //有对象文件，则删除失败
                    if (item.size() > 0) {
                        return false;
                    }
                }
                // åˆ é™¤`bucketName`存储桶，注意，只有存储桶为空时才能删除成功。
                minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucket).build());
                found = exitsBucket(bucket);
                return !found;
            }
        } catch (Exception ex) {
            log.error("删除桶异常：" + ex.getMessage());
        }
        return false;
    }

    /**
     * æŸ¥è¯¢æ‰€æœ‰æ¡¶æ–‡ä»¶
     *
     * @return
     */
    public List<Bucket> getListBuckets() {
        try {
            return minioClient.listBuckets();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Collections.emptyList();
    }

    /**
     * ç”Ÿæˆä¸€ä¸ªGET请求的带有失效时间的分享链接。
     * å¤±æ•ˆæ—¶é—´é»˜è®¤æ˜¯7天。
     *
     * @param bucketName å­˜å‚¨æ¡¶åç§°
     * @param objectName å­˜å‚¨æ¡¶é‡Œçš„对象名称
     * @param expires    å¤±æ•ˆæ—¶é—´ï¼ˆä»¥ç§’为单位），默认是7天，不得大于七天
     * @return
     */
    public String getObjectWithExpired(String bucketName, String objectName, Integer expires, TimeUnit timeUnit) {
        String url = "";
        if (exitsBucket(bucketName)) {
            try {
                GetPresignedObjectUrlArgs getPresignedObjectUrlArgs = GetPresignedObjectUrlArgs.builder()
                        .method(Method.GET)
                        .bucket(bucketName)
                        .object(objectName)
                        .expiry(expires, timeUnit)
                        .build();
                url = minioClient.getPresignedObjectUrl(getPresignedObjectUrlArgs);
            } catch (Exception ex) {
                log.error("minio生成失效url异常", ex.getMessage());
            }
        } else {
            createBucket(bucketName);
        }
        return url;
    }

    /**
     * @描述 ä¸Šä¼ MultipartFile文件返回url
     * @参数 [bucketName, file]
     * @返回值 java.lang.String
     * @创建人 åˆ˜è‹ä¹‰
     * @创建时间 2023/5/18 12:16
     * @修改人和其它信息
     */
    public String putObjectAndGetUrl(String bucketName, MultipartFile file) {
        if (!exitsBucket(bucketName)) {
            createBucket(bucketName);
        }
        //判断文件是否为空
        if (null == file || 0 == file.getSize()) {
            log.error("上传minio文件服务器错误，上传文件为空");
        }
        boolean exsit = exitsBucket(bucketName);
        if (!exsit) {
            boolean bucket = createBucket(bucketName);
            if (bucket) {
                log.info(bucketName + "-桶不存在,成功创建桶");
            }
        }
        //文件名
        String originalFilename = file.getOriginalFilename();
        //新的文件名
        String fileName = IdUtils.fastSimpleUUID() + "_" + originalFilename;
        try {
            InputStream inputStream = file.getInputStream();
            /*上传对象*/
            PutObjectArgs putObjectArgs = PutObjectArgs
                    .builder()
                    .bucket(bucketName)
                    .object(fileName)
                    .stream(inputStream, file.getSize(), -1)
                    .contentType(file.getContentType())
                    .build();
            minioClient.putObject(putObjectArgs);
            inputStream.close();
            /*获取url*/
            GetPresignedObjectUrlArgs getPresignedObjectUrlArgs = GetPresignedObjectUrlArgs
                    .builder()
                    .bucket(bucketName)
                    .object(fileName)
                    .method(Method.GET)
                    .build();
            String presignedObjectUrl = minioClient.getPresignedObjectUrl(getPresignedObjectUrlArgs);
            String ObjectUrl = presignedObjectUrl.substring(0, presignedObjectUrl.indexOf("?"));
            return ObjectUrl;
        } catch (Exception ex) {
            log.error("上传对象返回url异常：" + ex.getMessage());
        }
        return "";
    }

    /**
     * @描述 ä¸Šä¼ MultipartFile文件返回url
     * @参数 [bucketName, file]
     * @返回值 java.lang.String
     * @创建人 åˆ˜è‹ä¹‰
     * @创建时间 2023/5/18 12:16
     * @修改人和其它信息
     */
    public String putObjectAndGetUrl(String bucketName, String folder, MultipartFile file) {
        if (!exitsBucket(bucketName)) {
            createBucket(bucketName);
        }
        //判断文件是否为空
        if (null == file || 0 == file.getSize()) {
            log.error("上传minio文件服务器错误，上传文件为空");
        }
        boolean exsit = exitsBucket(bucketName);
        if (!exsit) {
            boolean bucket = createBucket(bucketName);
            if (bucket) {
                log.info(bucketName + "-桶不存在,成功创建桶");
            }
        }
        //文件名
        String originalFilename = file.getOriginalFilename();
        //新的文件名
        String fileName = folder + "/" + IdUtils.fastSimpleUUID() + "_" + originalFilename;
        try {
            InputStream inputStream = file.getInputStream();
            /*上传对象*/
            PutObjectArgs putObjectArgs = PutObjectArgs
                    .builder()
                    .bucket(bucketName)
                    .object(fileName)
                    .stream(inputStream, file.getSize(), -1)
                    .contentType(file.getContentType())
                    .build();
            minioClient.putObject(putObjectArgs);
            inputStream.close();
            /*获取url*/
            GetPresignedObjectUrlArgs getPresignedObjectUrlArgs = GetPresignedObjectUrlArgs
                    .builder()
                    .bucket(bucketName)
                    .object(fileName)
                    .method(Method.GET)
                    .build();
            String presignedObjectUrl = minioClient.getPresignedObjectUrl(getPresignedObjectUrlArgs);
            String ObjectUrl = presignedObjectUrl.substring(0, presignedObjectUrl.indexOf("?"));
            return ObjectUrl;
        } catch (Exception ex) {
            log.error("上传对象返回url异常：" + ex.getMessage());
        }
        return "";
    }

    /**
     * åˆ é™¤æ–‡ä»¶
     *
     * @param bucket     æ¡¶åç§°
     * @param objectName å¯¹è±¡åç§°
     * @return boolean
     */
    public boolean removeObject(String bucket, String objectName) {
        try {
            boolean exsit = exitsBucket(bucket);
            if (exsit) {
                RemoveObjectArgs removeObjectArgs = RemoveObjectArgs.builder().bucket(bucket).object(objectName).build();
                minioClient.removeObject(removeObjectArgs);
                return true;
            }
        } catch (Exception e) {
            log.error("removeObject", e);
        }
        return false;
    }

    /**
     * æ‰¹é‡åˆ é™¤æ–‡ä»¶
     *
     * @param objectNames å¯¹è±¡åç§°
     * @return boolean
     */
    public boolean removeObjects(String bucket, List<String> objectNames) {
        if (exitsBucket(bucket)) {
            try {
                List<DeleteObject> objects = new LinkedList<>();
                for (String str : objectNames) {
                    objects.add(new DeleteObject(str));
                }
                RemoveObjectsArgs removeObjectsArgs = RemoveObjectsArgs.builder().bucket(bucket).objects(objects).build();
                Iterable<Result<DeleteError>> results = minioClient.removeObjects(removeObjectsArgs);
                /*删除完遍历结果，否则删不掉*/
                for (Result<DeleteError> result : results) {
                    DeleteError error = result.get();
                    log.error("Error in deleting object " + error.objectName() + "; " + error.message());
                }

                return true;
            } catch (Exception ex) {
                log.error("minio批量删除文件异常", ex.getMessage());
            }
        }
        return false;
    }

    /**
     * èŽ·å–单个桶中的所有文件对象名称
     *
     * @param bucket æ¡¶åç§°
     * @return {@link List}<{@link String}>
     */
    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 = 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());
                }
                return listObjetcName;
            } catch (Exception ex) {
                log.error("minio获取桶下对象异常：" + ex.getMessage());
            }
        }
        return null;
    }

    /**
     * èŽ·å–某个桶下某个对象的URL
     *
     * @param bucket     æ¡¶åç§°
     * @param objectName å¯¹è±¡å (文件夹名 + æ–‡ä»¶å)
     * @return
     */
    public String getBucketObjectUrl(String bucketName, String objectName) {
        try {
            if (!exitsBucket(bucketName)) {
                return "";
            }
            GetPresignedObjectUrlArgs getPresignedObjectUrlArgs = GetPresignedObjectUrlArgs
                    .builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .method(Method.GET)
                    .build();
            String presignedObjectUrl = minioClient.getPresignedObjectUrl(getPresignedObjectUrlArgs);
            String ObjectUrl = presignedObjectUrl.substring(0, presignedObjectUrl.indexOf("?"));
            return ObjectUrl;
        } catch (Exception ex) {
            log.error("minio获取对象URL异常" + ex.getMessage());
        }
        return "";
    }

    /**
     * ä¸Šä¼ å¯¹è±¡-stream
     *
     * @param bucketName  bucket名称
     * @param objectName  â½‚件名称
     * @param stream      â½‚件流
     * @param size        â¼¤â¼©
     * @param contextType ç±»åž‹ Image/jpeg æµè§ˆå™¨å¯ä»¥ç›´æŽ¥æ‰“开，否则下载
     */
    public boolean uploadObject(String bucketName, String objectName, InputStream stream, long size, String contextType) {
        try {
            if (!exitsBucket(bucketName)) {
                createBucket(bucketName);
            }
            PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .stream(stream, size, -1)
                    .contentType(contextType)
                    .build();
            ObjectWriteResponse objectWriteResponse = minioClient.putObject(putObjectArgs);
            return true;
        } catch (Exception ex) {
            log.error("minio上传文件(通过stream)异常" + ex.getMessage());
            return false;
        }
    }

    /**
     * ä¸Šä¼ å¯¹è±¡-File
     *
     * @param bucketName  bucket名称
     * @param objectName  â½‚件名称
     * @param file        â½‚件
     * @param contextType ç±»åž‹ Image/jpeg æµè§ˆå™¨å¯ä»¥ç›´æŽ¥æ‰“开，否则下载
     */
    public boolean uploadObject(String bucketName, String objectName, File file, String contextType) {
        try {
            if (!exitsBucket(bucketName)) {
                createBucket(bucketName);
            }
            FileInputStream fileInputStream = new FileInputStream(file);
            PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .stream(fileInputStream, file.length(), -1)
                    .contentType(contextType)
                    .build();
            ObjectWriteResponse objectWriteResponse = minioClient.putObject(putObjectArgs);
            return true;
        } catch (Exception ex) {
            log.error("minio上传文件(通过File)异常" + ex.getMessage());
            return false;
        }
    }

    /**
     * ä¸Šä¼ å¯¹è±¡-MultipartFile
     *
     * @param bucketName    bucket名称
     * @param objectName    â½‚件名称
     * @param MultipartFile â½‚件
     * @param contextType   ç±»åž‹ Image/jpeg æµè§ˆå™¨å¯ä»¥ç›´æŽ¥æ‰“开，否则下载
     */
    public boolean uploadObject(String bucketName, String objectName, MultipartFile multipartFile, String contextType) {
        try {
            if (!exitsBucket(bucketName)) {
                createBucket(bucketName);
            }
            InputStream inputStream = multipartFile.getInputStream();
            PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .stream(inputStream, multipartFile.getSize(), -1)
                    .contentType(contextType)
                    .build();
            ObjectWriteResponse objectWriteResponse = minioClient.putObject(putObjectArgs);
            return true;
        } catch (Exception ex) {
            log.error("minio上传文件(通过File)异常" + ex.getMessage());
            return false;
        }
    }

    /**
     * ä¸Šä¼ å¯¹è±¡,用multipartFile名称作为对象名
     *
     * @param bucketName    bucket名称
     * @param objectName    â½‚件名称
     * @param MultipartFile â½‚件
     * @param contextType   ç±»åž‹ Image/jpeg æµè§ˆå™¨å¯ä»¥ç›´æŽ¥æ‰“开，否则下载
     */
    public boolean uploadObject(String bucketName, MultipartFile multipartFile, String contextType) {
        try {
            if (!exitsBucket(bucketName)) {
                createBucket(bucketName);
            }
            if (multipartFile == null) {
                log.error("上传文件为空");
                return false;
            }
            String objectName = multipartFile.getOriginalFilename();
            InputStream inputStream = multipartFile.getInputStream();
            PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .stream(inputStream, multipartFile.getSize(), -1)
                    .contentType(contextType)
                    .build();
            minioClient.putObject(putObjectArgs);
            return true;
        } catch (Exception ex) {
            log.error("minio上传文件(通过File)异常" + ex.getMessage());
            return false;
        }
    }

    /**
     * ä¸Šä¼ å¯¹è±¡-通过本地路径
     *
     * @param bulkName
     * @param objectName
     * @param localFilePathName
     * @return
     */
    public boolean uploadObject(String bucketName, String objectName, String localFilePathName, String contextType) {
        try {
            if (!exitsBucket(bucketName)) {
                createBucket(bucketName);
            }
            File file = new File(localFilePathName);
            if (!file.exists()) {
                log.debug("文件不存在");
                return false;
            }
            UploadObjectArgs uploadObjectArgs = UploadObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .filename(localFilePathName)
                    .contentType(contextType)
                    .build();
            ObjectWriteResponse objectWriteResponse = minioClient.uploadObject(uploadObjectArgs);
            return true;
        } catch (Exception e) {
            log.error("minio upload object file error " + e.getMessage());
            return false;
        }
    }

    /**
     * @描述 èŽ·å–桶中所有对象
     * @参数 [bucketName]
     * @返回值 java.lang.Iterable<io.minio.Result < io.minio.messages.Item>>
     * @创建人 åˆ˜è‹ä¹‰
     * @创建时间 2023/2/6 10:32
     * @修改人和其它信息
     */
    public Iterable<Result<Item>> getObjectsByBucket(String bucketName) {
        Iterable<Result<Item>> listObjects = minioClient.listObjects(ListObjectsArgs.builder()
                .bucket(bucketName)
                .recursive(true)
                .build());
        return listObjects;
    }

    /**
     * @描述 èŽ·å–桶中所有对象
     * @参数 [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;
    }
}

 src/main/java/com/ard/utils/mqtt/MqttConsumer.java

@@ -4,6 +4,7 @@
import org.apache.commons.lang3.StringUtils;
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.core.annotation.Order;
@@ -23,13 +24,29 @@
@Slf4j(topic = "mqtt")
@Order(1)
public class MqttConsumer implements ApplicationRunner {
    @Value("${spring.mqtt.enabled}")
    private Boolean MQTT_ENABLED;
    @Value("${spring.mqtt.topic}")
    private String MQTT_TOPIC;
    @Value("${spring.mqtt.host}")
    private String MQTT_HOST;
    @Value("${spring.mqtt.clientId}")
    private String MQTT_CLIENT_ID;
    @Value("${spring.mqtt.username}")
    private String MQTT_USER_NAME;
    @Value("${spring.mqtt.password}")
    private String MQTT_PASSWORD;
    @Value("${spring.mqtt.timeout}")
    private int MQTT_TIMEOUT;
    @Value("${spring.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();
        }
    }
@@ -43,7 +60,7 @@
            getClient();
            // 2 è®¾ç½®é…ç½®
            MqttConnectOptions options = getOptions();
            String[] topic = PropertiesUtil.MQTT_TOPIC.split(",");
            String[] topic = MQTT_TOPIC.split(",");
            // 3 æ¶ˆæ¯å‘布质量
            int[] qos = getQos(topic.length);
            // 4 æœ€åŽè®¾ç½®
@@ -59,7 +76,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) {
@@ -73,12 +90,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配置对象");

 src/main/java/com/ard/utils/mqtt/MqttConsumerCallback.java

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

 src/main/java/com/ard/utils/mqtt/PropertiesUtil.java

ÎļþÒÑɾ³ý

 src/main/java/com/ard/utils/other/SpringTool.java

ÎļþÒÑɾ³ý

 src/main/java/com/ard/utils/other/StringUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,577 @@
package com.ard.utils.other;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.springframework.util.AntPathMatcher;

/**
 * å­—符串工具类
 * 
 * @author ruoyi
 */
public class StringUtils extends org.apache.commons.lang3.StringUtils
{
    /** ç©ºå­—符串 */
    private static final String NULLSTR = "";

    /** ä¸‹åˆ’线 */
    private static final char SEPARATOR = '_';

    /**
     * èŽ·å–参数不为空值
     * 
     * @param value defaultValue è¦åˆ¤æ–­çš„value
     * @return value è¿”回值
     */
    public static <T> T nvl(T value, T defaultValue)
    {
        return value != null ? value : defaultValue;
    }

    /**
     * * åˆ¤æ–­ä¸€ä¸ªCollection是否为空， åŒ…含List，Set，Queue
     * 
     * @param coll è¦åˆ¤æ–­çš„Collection
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(Collection<?> coll)
    {
        return isNull(coll) || coll.isEmpty();
    }

    /**
     * * åˆ¤æ–­ä¸€ä¸ªCollection是否非空，包含List，Set，Queue
     * 
     * @param coll è¦åˆ¤æ–­çš„Collection
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Collection<?> coll)
    {
        return !isEmpty(coll);
    }

    /**
     * * åˆ¤æ–­ä¸€ä¸ªå¯¹è±¡æ•°ç»„是否为空
     * 
     * @param objects è¦åˆ¤æ–­çš„对象数组
     ** @return true：为空 false：非空
     */
    public static boolean isEmpty(Object[] objects)
    {
        return isNull(objects) || (objects.length == 0);
    }

    /**
     * * åˆ¤æ–­ä¸€ä¸ªå¯¹è±¡æ•°ç»„是否非空
     * 
     * @param objects è¦åˆ¤æ–­çš„对象数组
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Object[] objects)
    {
        return !isEmpty(objects);
    }

    /**
     * * åˆ¤æ–­ä¸€ä¸ªMap是否为空
     * 
     * @param map è¦åˆ¤æ–­çš„Map
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(Map<?, ?> map)
    {
        return isNull(map) || map.isEmpty();
    }

    /**
     * * åˆ¤æ–­ä¸€ä¸ªMap是否为空
     * 
     * @param map è¦åˆ¤æ–­çš„Map
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Map<?, ?> map)
    {
        return !isEmpty(map);
    }

    /**
     * * åˆ¤æ–­ä¸€ä¸ªå­—符串是否为空串
     * 
     * @param str String
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(String str)
    {
        return isNull(str) || NULLSTR.equals(str.trim());
    }

    /**
     * * åˆ¤æ–­ä¸€ä¸ªå­—符串是否为非空串
     * 
     * @param str String
     * @return true：非空串 false：空串
     */
    public static boolean isNotEmpty(String str)
    {
        return !isEmpty(str);
    }

    /**
     * * åˆ¤æ–­ä¸€ä¸ªå¯¹è±¡æ˜¯å¦ä¸ºç©º
     * 
     * @param object Object
     * @return true：为空 false：非空
     */
    public static boolean isNull(Object object)
    {
        return object == null;
    }

    /**
     * * åˆ¤æ–­ä¸€ä¸ªå¯¹è±¡æ˜¯å¦éžç©º
     * 
     * @param object Object
     * @return true：非空 false：空
     */
    public static boolean isNotNull(Object object)
    {
        return !isNull(object);
    }

    /**
     * * åˆ¤æ–­ä¸€ä¸ªå¯¹è±¡æ˜¯å¦æ˜¯æ•°ç»„类型（Java基本型别的数组）
     * 
     * @param object å¯¹è±¡
     * @return true：是数组 false：不是数组
     */
    public static boolean isArray(Object object)
    {
        return isNotNull(object) && object.getClass().isArray();
    }

    /**
     * åŽ»ç©ºæ ¼
     */
    public static String trim(String str)
    {
        return (str == null ? "" : str.trim());
    }

    /**
     * æˆªå–字符串
     * 
     * @param str å­—符串
     * @param start å¼€å§‹
     * @return ç»“æžœ
     */
    public static String substring(final String str, int start)
    {
        if (str == null)
        {
            return NULLSTR;
        }

        if (start < 0)
        {
            start = str.length() + start;
        }

        if (start < 0)
        {
            start = 0;
        }
        if (start > str.length())
        {
            return NULLSTR;
        }

        return str.substring(start);
    }

    /**
     * æˆªå–字符串
     * 
     * @param str å­—符串
     * @param start å¼€å§‹
     * @param end ç»“束
     * @return ç»“æžœ
     */
    public static String substring(final String str, int start, int end)
    {
        if (str == null)
        {
            return NULLSTR;
        }

        if (end < 0)
        {
            end = str.length() + end;
        }
        if (start < 0)
        {
            start = str.length() + start;
        }

        if (end > str.length())
        {
            end = str.length();
        }

        if (start > end)
        {
            return NULLSTR;
        }

        if (start < 0)
        {
            start = 0;
        }
        if (end < 0)
        {
            end = 0;
        }

        return str.substring(start, end);
    }




    /**
     * å­—符串转set
     * 
     * @param str å­—符串
     * @param sep åˆ†éš”符
     * @return set集合
     */
    public static final Set<String> str2Set(String str, String sep)
    {
        return new HashSet<String>(str2List(str, sep, true, false));
    }

    /**
     * å­—符串转list
     * 
     * @param str å­—符串
     * @param sep åˆ†éš”符
     * @param filterBlank è¿‡æ»¤çº¯ç©ºç™½
     * @param trim åŽ»æŽ‰é¦–尾空白
     * @return list集合
     */
    public static final List<String> str2List(String str, String sep, boolean filterBlank, boolean trim)
    {
        List<String> list = new ArrayList<String>();
        if (StringUtils.isEmpty(str))
        {
            return list;
        }

        // è¿‡æ»¤ç©ºç™½å­—符串
        if (filterBlank && StringUtils.isBlank(str))
        {
            return list;
        }
        String[] split = str.split(sep);
        for (String string : split)
        {
            if (filterBlank && StringUtils.isBlank(string))
            {
                continue;
            }
            if (trim)
            {
                string = string.trim();
            }
            list.add(string);
        }

        return list;
    }

    /**
     * åˆ¤æ–­ç»™å®šçš„set列表中是否包含数组array åˆ¤æ–­ç»™å®šçš„数组array中是否包含给定的元素value
     *
     *
     * @param array ç»™å®šçš„数组
     * @return boolean ç»“æžœ
     */
    public static boolean containsAny(Collection<String> collection, String... array)
    {
        if (isEmpty(collection) || isEmpty(array))
        {
            return false;
        }
        else
        {
            for (String str : array)
            {
                if (collection.contains(str))
                {
                    return true;
                }
            }
            return false;
        }
    }

    /**
     * æŸ¥æ‰¾æŒ‡å®šå­—符串是否包含指定字符串列表中的任意一个字符串同时串忽略大小写
     *
     * @param cs æŒ‡å®šå­—符串
     * @param searchCharSequences éœ€è¦æ£€æŸ¥çš„字符串数组
     * @return æ˜¯å¦åŒ…含任意一个字符串
     */
    public static boolean containsAnyIgnoreCase(CharSequence cs, CharSequence... searchCharSequences)
    {
        if (isEmpty(cs) || isEmpty(searchCharSequences))
        {
            return false;
        }
        for (CharSequence testStr : searchCharSequences)
        {
            if (containsIgnoreCase(cs, testStr))
            {
                return true;
            }
        }
        return false;
    }

    /**
     * é©¼å³°è½¬ä¸‹åˆ’线命名
     */
    public static String toUnderScoreCase(String str)
    {
        if (str == null)
        {
            return null;
        }
        StringBuilder sb = new StringBuilder();
        // å‰ç½®å­—符是否大写
        boolean preCharIsUpperCase = true;
        // å½“前字符是否大写
        boolean curreCharIsUpperCase = true;
        // ä¸‹ä¸€å­—符是否大写
        boolean nexteCharIsUpperCase = true;
        for (int i = 0; i < str.length(); i++)
        {
            char c = str.charAt(i);
            if (i > 0)
            {
                preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
            }
            else
            {
                preCharIsUpperCase = false;
            }

            curreCharIsUpperCase = Character.isUpperCase(c);

            if (i < (str.length() - 1))
            {
                nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
            }

            if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase)
            {
                sb.append(SEPARATOR);
            }
            else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase)
            {
                sb.append(SEPARATOR);
            }
            sb.append(Character.toLowerCase(c));
        }

        return sb.toString();
    }

    /**
     * æ˜¯å¦åŒ…含字符串
     * 
     * @param str éªŒè¯å­—符串
     * @param strs å­—符串组
     * @return åŒ…含返回true
     */
    public static boolean inStringIgnoreCase(String str, String... strs)
    {
        if (str != null && strs != null)
        {
            for (String s : strs)
            {
                if (str.equalsIgnoreCase(trim(s)))
                {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * å°†ä¸‹åˆ’线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 ä¾‹å¦‚：HELLO_WORLD->HelloWorld
     * 
     * @param name è½¬æ¢å‰çš„下划线大写方式命名的字符串
     * @return è½¬æ¢åŽçš„驼峰式命名的字符串
     */
    public static String convertToCamelCase(String name)
    {
        StringBuilder result = new StringBuilder();
        // å¿«é€Ÿæ£€æŸ¥
        if (name == null || name.isEmpty())
        {
            // æ²¡å¿…要转换
            return "";
        }
        else if (!name.contains("_"))
        {
            // ä¸å«ä¸‹åˆ’线，仅将首字母大写
            return name.substring(0, 1).toUpperCase() + name.substring(1);
        }
        // ç”¨ä¸‹åˆ’线将原始字符串分割
        String[] camels = name.split("_");
        for (String camel : camels)
        {
            // è·³è¿‡åŽŸå§‹å­—符串中开头、结尾的下换线或双重下划线
            if (camel.isEmpty())
            {
                continue;
            }
            // é¦–字母大写
            result.append(camel.substring(0, 1).toUpperCase());
            result.append(camel.substring(1).toLowerCase());
        }
        return result.toString();
    }

    /**
     * é©¼å³°å¼å‘½åæ³• ä¾‹å¦‚：user_name->userName
     */
    public static String toCamelCase(String s)
    {
        if (s == null)
        {
            return null;
        }
        s = s.toLowerCase();
        StringBuilder sb = new StringBuilder(s.length());
        boolean upperCase = false;
        for (int i = 0; i < s.length(); i++)
        {
            char c = s.charAt(i);

            if (c == SEPARATOR)
            {
                upperCase = true;
            }
            else if (upperCase)
            {
                sb.append(Character.toUpperCase(c));
                upperCase = false;
            }
            else
            {
                sb.append(c);
            }
        }
        return sb.toString();
    }

    /**
     * æŸ¥æ‰¾æŒ‡å®šå­—符串是否匹配指定字符串列表中的任意一个字符串
     * 
     * @param str æŒ‡å®šå­—符串
     * @param strs éœ€è¦æ£€æŸ¥çš„字符串数组
     * @return æ˜¯å¦åŒ¹é…
     */
    public static boolean matches(String str, List<String> strs)
    {
        if (isEmpty(str) || isEmpty(strs))
        {
            return false;
        }
        for (String pattern : strs)
        {
            if (isMatch(pattern, str))
            {
                return true;
            }
        }
        return false;
    }

    /**
     * åˆ¤æ–­url是否与规则配置: 
     * ? è¡¨ç¤ºå•ä¸ªå­—符; 
     * * è¡¨ç¤ºä¸€å±‚路径内的任意字符串，不可跨层级; 
     * ** è¡¨ç¤ºä»»æ„å±‚路径;
     * 
     * @param pattern åŒ¹é…è§„则
     * @param url éœ€è¦åŒ¹é…çš„url
     * @return
     */
    public static boolean isMatch(String pattern, String url)
    {
        AntPathMatcher matcher = new AntPathMatcher();
        return matcher.match(pattern, url);
    }

    @SuppressWarnings("unchecked")
    public static <T> T cast(Object obj)
    {
        return (T) obj;
    }

    /**
     * æ•°å­—左边补齐0，使之达到指定长度。注意，如果数字转换为字符串后，长度大于size，则只保留 æœ€åŽsize个字符。
     * 
     * @param num æ•°å­—对象
     * @param size å­—符串指定长度
     * @return è¿”回数字的字符串格式，该字符串为指定长度。
     */
    public static final String padl(final Number num, final int size)
    {
        return padl(num.toString(), size, '0');
    }

    /**
     * å­—符串左补齐。如果原始字符串s长度大于size，则只保留最后size个字符。
     * 
     * @param s åŽŸå§‹å­—符串
     * @param size å­—符串指定长度
     * @param c ç”¨äºŽè¡¥é½çš„字符
     * @return è¿”回指定长度的字符串，由原字符串左补齐或截取得到。
     */
    public static final String padl(final String s, final int size, final char c)
    {
        final StringBuilder sb = new StringBuilder(size);
        if (s != null)
        {
            final int len = s.length();
            if (s.length() <= size)
            {
                for (int i = size - len; i > 0; i--)
                {
                    sb.append(c);
                }
                sb.append(s);
            }
            else
            {
                return s.substring(len - size, len);
            }
        }
        else
        {
            for (int i = size; i > 0; i--)
            {
                sb.append(c);
            }
        }
        return sb.toString();
    }
}

 src/main/java/com/ard/utils/spring/SpringUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,158 @@
package com.ard.utils.spring;

import com.ard.utils.other.StringUtils;
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;

/**
 * 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);
    }
}

 src/main/java/com/ard/utils/udp/NettyUdpHandler.java

@@ -1,7 +1,7 @@
package com.ard.utils.udp;

import com.ard.alarm.tube.service.TubeAlarmService;
import com.ard.utils.other.SpringTool;
import com.ard.utils.spring.SpringUtils;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
@@ -20,7 +20,7 @@
            ByteBuf byteBuf = packet.content();
            String str = byteBuf.toString(Charset.forName("GBK"));
            log.info("udp收到数据: " + str);
            TubeAlarmService tubeAlarmService = (TubeAlarmService) SpringTool.getApplicationContext().getBean("tubeAlarmService");
            TubeAlarmService tubeAlarmService = SpringUtils.getBean(TubeAlarmService.class);
            tubeAlarmService.alarmHandler(str);
            String resStr = "ok";
            byte[] resBytes = resStr.getBytes(Charset.forName("GBK"));

 src/main/resources/application-dev.yml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,70 @@
# å¼€å‘环境
server:
  port: 8088
# spring配置
spring:
  servlet:
    multipart:
      enabled: true
      max-file-size: 30MB
      max-request-size: 30MB
  datasource:
      #  ä½¿ç”¨druid数据库连接池
    druid:
        #开启druid监控web
      stat-view-servlet:
        enabled: true
      driver-class-name: org.postgresql.Driver
      url: jdbc:postgresql://192.168.1.15:5432/ry-vue?stringtype=unspecified
      username: postgres
      password: postgres
      #最大连接数
      maxActive: 30
      #最小连接数
      minIdle: 5
      #获取连接的最大等待时间
      maxWait: 10000
      #解决mysql8小时的问题
      validation-query: SELECT 'X'
      #空闲连接的检查时间间隔
      timeBetweenEvictionRunsMillis: 60000
      #空闲连接最小空闲时间
      minEvictableIdleTimeMillis: 300000
  # netty配置
  netty:
    udp:
      port: 40000
      enabled: true
    tcp:
      enabled: true
  # mqtt配置
  mqtt:
    host: tcp://192.168.1.15:1883
    clientId: cc3
    username: admin
    password: xzx12345
    topic: tube
    timeout: 100
    keepalive: 60
    enabled: true
  # ç›—电接口地址
  stealelec:
    url: http://iot.zhdk.net:8090/Warning/GetWarning?userName=cy4oil
  # minio配置
  minio:
    endpoint: http://192.168.1.15:9001
    accessKey: admin
    secretKey: xzx12345
# mybatis配置
mybatis:
  typeAliasesPackage: com.ard.alarm.**.domain
  mapperLocations: classpath:/mapper/*.xml
# æ—¥å¿—等级配置
logging:
  level:
    hikSdk: debug
    mqtt: info
    netty: info
    external: info
    camera: info
    tube: info

 src/main/resources/application-prod.yml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,67 @@
#生产环境
spring:
  servlet:
    multipart:
      enabled: true
      max-file-size: 30MB
      max-request-size: 30MB
  datasource:
      #  ä½¿ç”¨druid数据库连接池
    druid:
        #开启druid监控web
      stat-view-servlet:
        enabled: true
      driver-class-name: org.postgresql.Driver
      url: jdbc:postgresql://112.98.126.2:35432/ry-vue?stringtype=unspecified
      username: postgres
      password: Yykj.2017
      #最大连接数
      maxActive: 30
      #最小连接数
      minIdle: 5
      #获取连接的最大等待时间
      maxWait: 10000
      #解决mysql8小时的问题
      validation-query: SELECT 'X'
      #空闲连接的检查时间间隔
      timeBetweenEvictionRunsMillis: 60000
      #空闲连接最小空闲时间
      minEvictableIdleTimeMillis: 300000
  # netty配置
  netty:
    udp:
      port: 40000
      enabled: true
    tcp:
      enabled: true
  # minio配置
  minio:
    endpoint: http://127.0.0.1:9001
    accessKey: admin
    secretKey: xzx12345
  # mqtt配置
  mqtt:
    host: tcp://192.168.1.15:1883
    clientId: cc3
    username: admin
    password: xzx12345
    topic: tube
    timeout: 100
    keepalive: 60
    enabled: true
  stealelec:
    url: http://iot.zhdk.net:8090/Warning/GetWarning?userName=cy4oil
mybatis:
  typeAliasesPackage: com.ard.alarm.**.domain
  mapperLocations: classpath:/mapper/*.xml

server:
  port: 8088
logging:
  level:
    hikSdk: debug
    mqtt: info
    netty: info
    external: info
    camera: info
    tube: info

 src/main/resources/application.yml

@@ -1,61 +1,4 @@
spring:
  servlet:
    multipart:
      enabled: true
      max-file-size: 30MB
      max-request-size: 30MB
  datasource:
      #  ä½¿ç”¨druid数据库连接池
    druid:
        #开启druid监控web
      stat-view-servlet:
        enabled: true
      driver-class-name: org.postgresql.Driver
          #    url: jdbc:postgresql://111.40.46.199:15432/ry-vue?stringtype=unspecified
          #    username: postgres
          #    password: Yykj.2021
      url: jdbc:postgresql://192.168.1.15:5432/ry-vue?stringtype=unspecified
      username: postgres
      password: postgres
      #最大连接数
      maxActive: 30
      #最小连接数
      minIdle: 5
      #获取连接的最大等待时间
      maxWait: 10000
      #解决mysql8小时的问题
      validation-query: SELECT 'X'
      #空闲连接的检查时间间隔
      timeBetweenEvictionRunsMillis: 60000
      #空闲连接最小空闲时间
      minEvictableIdleTimeMillis: 300000
  netty:
    udp:
      port: 40000
      enabled: true
    tcp:
      enabled: true
  mqtt:
    host: tcp://192.168.1.15:1883
    clientId: cc3
    username: admin
    password: xzx12345
    topic: tube
    timeout: 100
    keepalive: 60
    enabled: true
  stealelec:
    url: http://iot.zhdk.net:8090/Warning/GetWarning?userName=cy4oil
mybatis:
  typeAliasesPackage: com.ard.alarm.**.domain
  mapperLocations: classpath:/mapper/*.xml
# minio配置
minio:
  endpoint: http://192.168.1.15:9001
  accessKey: admin
  secretKey: xzx12345
server:
  port: 8088
logging:
  level:
    com.ard.utils.hiksdk.service.impl.FMSGCallBack: debug
  profiles:
    active: prod