提交

‘liusuyi’

2023-05-31 773c502d0b2f2732f858946a32f41bf13e1bcdff

提交

 .gitignore

@@ -1,6 +1,6 @@
/ardLog/logs/
/ardLog/

/ruoyi-ui
######################################################################
# Build Tools


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

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,76 @@
package com.ruoyi.device.hiksdk.config;

import io.minio.MinioClient;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.YamlPropertiesFactoryBean;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.Properties;

/**
 * @Description:
 * @ClassName: MinioClientSingleton
 * @Author: åˆ˜è‹ä¹‰
 * @Date: 2023å¹´05月18日9:32
 * @Version: 1.0
 **/

@Slf4j(topic = "minio")
@Data
@Component
public class MinioClientSingleton {

    private static String domainUrl;
    private static String accessKey;
    private static String secretKey;

    private volatile static MinioClient minioClient;

    static {
        domainUrl = getYmlNew("minio.endpoint");
        accessKey = getYmlNew("minio.accessKey");
        secretKey = getYmlNew("minio.secretKey");
        log.info("minio信息：" + domainUrl + "(" + accessKey + "/" + secretKey + ")");
    }

    /**
     * èŽ·å–minio客户端实例
     *
     * @return {@link MinioClient}
     */
    public static MinioClient getMinioClient() {
        if (minioClient == null) {
            synchronized (MinioClientSingleton.class) {
                if (minioClient == null) {
                    minioClient = MinioClient.builder()
                            .endpoint(domainUrl)
                            .credentials(accessKey, secretKey)
                            .build();
                }
            }
        }
        return minioClient;
    }

    /*yml配置信息获取*/
    public static String getYmlNew(String key) {
        Resource resource = new ClassPathResource("application.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/device/hiksdk/config/MinioConfig.java

ÎļþÒÑɾ³ý

 ard-work/src/main/java/com/ruoyi/device/hiksdk/util/minio/MinioUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,473 @@
package com.ruoyi.device.hiksdk.util.minio;

import com.ruoyi.device.hiksdk.config.MinioClientSingleton;
import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.Bucket;
import io.minio.messages.DeleteError;
import io.minio.messages.DeleteObject;
import io.minio.messages.Item;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.multipart.MultipartFile;
import java.io.*;
import java.util.*;
import java.util.concurrent.TimeUnit;

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

    /**
     * åˆ¤æ–­æ¡¶æ˜¯å¦å­˜åœ¨
     */
    public static boolean exitsBucket(String bucketName) {
        boolean found = false;
        try {
            BucketExistsArgs bucketExistsArgs = BucketExistsArgs.builder().bucket(bucketName).build();
            found = MinioClientSingleton.getMinioClient().bucketExists(bucketExistsArgs);
        } catch (Exception ex) {
            log.error("minio判断桶存在异常：", ex.getMessage());
        }
        return found;
    }

    /**
     * åˆ›å»ºæ¡¶,并设置桶策略为公共
     */
    public static boolean createBucket(String bucketName) {
        try {
            /*创建桶*/
            MakeBucketArgs makeBucketArgs = MakeBucketArgs.builder().bucket(bucketName).build();
            MinioClientSingleton.getMinioClient().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();
            MinioClientSingleton.getMinioClient().setBucketPolicy(setBucketPolicyArgs);
            return true;
        } catch (Exception ex) {
            log.error("minio创建桶异常：", ex.getMessage());
            return false;
        }
    }

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

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

    /**
     * ç”Ÿæˆä¸€ä¸ªGET请求的带有失效时间的分享链接。
     * å¤±æ•ˆæ—¶é—´é»˜è®¤æ˜¯7天。
     *
     * @param bucketName å­˜å‚¨æ¡¶åç§°
     * @param objectName å­˜å‚¨æ¡¶é‡Œçš„对象名称
     * @param expires    å¤±æ•ˆæ—¶é—´ï¼ˆä»¥ç§’为单位），默认是7天，不得大于七天
     * @return
     */
    public static 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 = MinioClientSingleton.getMinioClient().getPresignedObjectUrl(getPresignedObjectUrlArgs);
            } catch (Exception ex) {
                log.error("minio生成失效url异常", ex.getMessage());
            }
        }
        return url;
    }

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

    /**
     * åˆ é™¤æ–‡ä»¶
     *
     * @param bucket     æ¡¶åç§°
     * @param objectName å¯¹è±¡åç§°
     * @return boolean
     */
    public static 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);
                return true;
            }
        } catch (Exception e) {
            log.error("removeObject", e);
        }
        return false;
    }

    /**
     * æ‰¹é‡åˆ é™¤æ–‡ä»¶
     *
     * @param objectNames å¯¹è±¡åç§°
     * @return boolean
     */
    public static 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 = MinioClientSingleton.getMinioClient().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 static 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);
                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 static String getBucketObjectUrl(String bucketName, String objectName) {
        try {
            if (!exitsBucket(bucketName)) {
                return "";
            }
            GetPresignedObjectUrlArgs getPresignedObjectUrlArgs = GetPresignedObjectUrlArgs
                    .builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .build();
            return MinioClientSingleton.getMinioClient().getPresignedObjectUrl(getPresignedObjectUrlArgs);
        } 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 static boolean uploadObject(String bucketName, String objectName, InputStream stream, long size, String contextType) {
        try {
            PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .stream(stream, size, -1)
                    .contentType(contextType)
                    .build();
            ObjectWriteResponse objectWriteResponse = MinioClientSingleton.getMinioClient().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 static boolean uploadObject(String bucketName, String objectName, File file, String contextType) {
        try {
            FileInputStream fileInputStream = new FileInputStream(file);
            PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .stream(fileInputStream, file.length(), -1)
                    .contentType(contextType)
                    .build();
            ObjectWriteResponse objectWriteResponse = MinioClientSingleton.getMinioClient().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 static boolean uploadObject(String bucketName, String objectName, MultipartFile multipartFile, String contextType) {
        try {
            if (bucketName.isEmpty()) {
                log.error("bucket名称为空");
                return false;
            }
            if (objectName.isEmpty()) {
                log.error("对象名称为空");
                return false;
            }
            InputStream inputStream = multipartFile.getInputStream();
            PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .stream(inputStream, multipartFile.getSize(), -1)
                    .contentType(contextType)
                    .build();
            ObjectWriteResponse objectWriteResponse = MinioClientSingleton.getMinioClient().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 static boolean uploadObject(String bucketName, MultipartFile multipartFile, String contextType) {
        try {
            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();
            MinioClientSingleton.getMinioClient().putObject(putObjectArgs);
            return true;
        } catch (Exception ex) {
            log.error("minio上传文件(通过File)异常" + ex.getMessage());
            return false;
        }
    }

    /**
     * ä¸Šä¼ å¯¹è±¡-通过本地路径
     *
     * @param bulkName
     * @param objectName
     * @param localFilePathName
     * @return
     */
    public static boolean uploadObject(String bulkName, String objectName, String localFilePathName, String contextType) {
        try {
            if (!exitsBucket(bulkName)) {
                log.debug(bulkName + "不存在");
                return false;
            }
            File file = new File(localFilePathName);
            if (!file.exists()) {
                log.debug("文件不存在");
                return false;
            }
            UploadObjectArgs uploadObjectArgs = UploadObjectArgs.builder()
                    .bucket(bulkName)
                    .object(objectName)
                    .filename(localFilePathName)
                    .contentType(contextType)
                    .build();
            ObjectWriteResponse objectWriteResponse = MinioClientSingleton.getMinioClient().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 static Iterable<Result<Item>> getObjectsByBucket(String bucketName)  {
        Iterable<Result<Item>> listObjects = MinioClientSingleton.getMinioClient().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;
    }
}

 ard-work/src/main/java/com/ruoyi/device/hiksdk/util/minioUtil/MinioUtil.java

ÎļþÒÑɾ³ý

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

@@ -1,11 +1,11 @@
package com.ruoyi.quartz.task;

import com.ruoyi.device.hiksdk.util.minioUtil.MinioUtil;
import com.ruoyi.device.hiksdk.util.minio.MinioUtils;
import io.minio.Result;
import io.minio.messages.Item;
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,8 +21,6 @@
@Component("MinioTask")
@Slf4j(topic = "minio")
public class MinioTask {
    @Resource
    MinioUtil minioUtil;

    public void delHistoryTask(Integer saveDays) {
        log.info("执行历史数据删除");
@@ -32,7 +30,7 @@
            buckets.add("pic");
            buckets.add("record");
            for (String name:buckets) {
                Iterable<Result<Item>> listObjectsPic = minioUtil.getObjectsByBucket(name);
                Iterable<Result<Item>> listObjectsPic = MinioUtils.getObjectsByBucket(name);
                for (Result<Item> result : listObjectsPic) {
                    Item item = result.get();
                    log.info(item.objectName() + "创建时间：" + item.lastModified());
@@ -52,7 +50,7 @@

                    if (objectTime.compareTo(nowTime) < 0) {
                        log.info("objectTime æ—¶é—´åœ¨ nowTime ä¹‹å‰");
                        boolean b = minioUtil.deleteObject(name, item.objectName());
                        boolean b = MinioUtils.removeObject(name, item.objectName());
                        if(b)
                        {
                            log.info("删除过期数据："+ item.objectName()+"---"+item.lastModified());