MINIO工具类记录

最新推荐文章于 2023-09-21 14:41:43 发布
最新推荐文章于 2023-09-21 14:41:43 发布
阅读量925 收藏 2
点赞数
分类专栏： 工具类 文章标签： java log4j
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ChenNuo_shuai/article/details/126499161
版权

文件管理客户端

package kl.gayxzc.csr.cilent;

import io.minio.GetObjectArgs;
import io.minio.GetObjectResponse;
import io.minio.GetPresignedObjectUrlArgs;
import io.minio.ListObjectsArgs;
import io.minio.MinioClient;
import io.minio.PutObjectArgs;
import io.minio.RemoveObjectArgs;
import io.minio.Result;
import io.minio.StatObjectArgs;
import io.minio.http.Method;
import io.minio.messages.Item;
import kl.gayxzc.csr.constant.CsrErrorCode;
import kl.gayxzc.csr.constant.MinioConstant;
import kl.gayxzc.csr.exception.MinioException;
import kl.gayxzc.csr.utils.DateUtils;
import kl.gayxzc.csr.utils.UUIDUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.logging.log4j.util.Strings;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.util.FastByteArrayOutputStream;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * minio-client
 * 文件管理客户端
 *
 * @author ldh
 */
@Slf4j
@Component("fileClient")
public class FileClient {

    private MinioClient minioClient;

    private BucketClient bucketClient;

    @Value("${csr.minio.file-server-type}")
    private String minioServerType;


    @Autowired
    public void setMinioClient(MinioClient minioClient) {
        this.minioClient = minioClient;
    }

    @Autowired
    public void setBucketClient(BucketClient bucketClient) {
        this.bucketClient = bucketClient;
    }

    /**
     * 上传文件到默认存储桶
     *
     * @param files 文件列表
     * @return 上传后的路径
     * @throws Exception 上传失败异常
     */
    public List<String> put(MultipartFile... files) {
        return put(null, files);
    }

    /**
     * 上传文件到指定存储桶
     *
     * @param path  上传后的路径
     * @param files 文件列表
     * @return 上传后的路径
     * @throws Exception 上传失败异常
     */
    public List<String> put(String path, MultipartFile... files) {
        if (files == null || files.length == 0) {
            return new ArrayList<>();
        }
        List<String> list = new LinkedList<>();
        for (MultipartFile file : files) {
            list.add(put(path, file));
        }
        return list;
    }

    /**
     * 下载默认存储桶中的文件
     *
     * @param fileName 文件名称
     * @param response 响应体
     * @throws Exception 下载失败异常
     */
    public void download(String fileName, HttpServletResponse response) {
        GetObjectArgs objectArgs = GetObjectArgs.builder().bucket(bucketClient.getDefaultBucket())
                .object(fileName).build();
        try (GetObjectResponse getObjectRes = minioClient.getObject(objectArgs)) {
            byte[] buf = new byte[1024];
            int len;
            try (FastByteArrayOutputStream os = new FastByteArrayOutputStream()) {
                while ((len = getObjectRes.read(buf)) != -1) {
                    os.write(buf, 0, len);
                }
                os.flush();
                byte[] bytes = os.toByteArray();
                response.setCharacterEncoding("utf-8");
                final String[] split = fileName.split(MinioConstant.DEFAULT_FILENAME_SEPARATOR);
                String orgFilename = split.length > 1 ? split[split.length - 1] : fileName;
                log.info("file original name is {}", orgFilename);
                response.addHeader("Content-Disposition", "attachment;fileName=" + URLEncoder.encode(orgFilename, "utf-8"));
                try (ServletOutputStream stream = response.getOutputStream()) {
                    stream.write(bytes);
                    stream.flush();
                }
            }
        } catch (Exception e) {
            log.error("file {} download fail", fileName, e);
            throw new MinioException(CsrErrorCode.DOWNLOAD_ERROR);
        }
    }


    /**
     * 下载指定存储桶中的文件
     *
     * @param fileName 文件名称
     * @param name     指定桶名称
     * @param response 响应体
     * @throws Exception 下载失败异常
     */
    public void download(String fileName, String name, HttpServletResponse response) {
        GetObjectArgs objectArgs = GetObjectArgs.builder().bucket(name)
                .object(fileName).build();
        try (GetObjectResponse getObjectRes = minioClient.getObject(objectArgs)) {
            byte[] buf = new byte[1024];
            int len;
            try (FastByteArrayOutputStream os = new FastByteArrayOutputStream()) {
                while ((len = getObjectRes.read(buf)) != -1) {
                    os.write(buf, 0, len);
                }
                os.flush();
                byte[] bytes = os.toByteArray();
                response.setCharacterEncoding("utf-8");
                final String[] split = fileName.split(MinioConstant.DEFAULT_FILENAME_SEPARATOR);
                String orgFilename = split.length > 1 ? split[split.length - 1] : fileName;
                log.info("file original name is {}", orgFilename);
                response.addHeader("Content-Disposition", "attachment;fileName=" + URLEncoder.encode(orgFilename, "utf-8"));
                try (ServletOutputStream stream = response.getOutputStream()) {
                    stream.write(bytes);
                    // 与框架冲突,保留框架层关闭 >> ResponseResult.success();
//                    stream.flush();
                }
            }
        } catch (Exception e) {
            log.error("file {} download fail", fileName, e);
            throw new MinioException(CsrErrorCode.DOWNLOAD_ERROR);
        }
    }

    /**
     * 预览图片
     *
     * @param fileName 文件名称
     * @return 预览地址
     */
    public String preview(String fileName) {
        // 查看文件地址
        final GetPresignedObjectUrlArgs build = GetPresignedObjectUrlArgs.builder()
                .bucket(bucketClient.getDefaultBucket())
                .object(fileName)
                .method(Method.GET)
                .build();
        try {
            return minioClient.getPresignedObjectUrl(build);
        } catch (Exception e) {
            log.error("file {} preview failed", fileName, e);
            throw new MinioException(CsrErrorCode.PREVIEW_ERROR);

        }
    }

    /**
     * 预览图片
     *
     * @param fileName   文件名称
     * @param bucketName 桶名称
     * @return 预览地址
     */
    public String preview(String fileName, String bucketName) {
        // 查看文件地址
        final GetPresignedObjectUrlArgs build = GetPresignedObjectUrlArgs.builder()
                .bucket((Strings.isBlank(bucketName)) ? bucketClient.getDefaultBucket() : bucketName)
                .object(fileName)
                .method(Method.GET)
                .build();
        try {
            return minioClient.getPresignedObjectUrl(build);
        } catch (Exception e) {
            log.error("file {} preview failed", fileName, e);
            throw new MinioException(CsrErrorCode.PREVIEW_ERROR);

        }
    }

    /**
     * 删除⽂件
     *
     * @param objectName ⽂件名称
     * @throws Exception 删除文件异常
     */
    public void removeObject(String objectName) {
        removeObject(bucketClient.getDefaultBucket(), objectName);
    }

    /**
     * 删除⽂件
     *
     * @param bucketName bucket名称
     * @param objectName ⽂件名称
     * @throws Exception 删除文件异常
     */
    public void removeObject(String bucketName, String objectName) {
        try {
            minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
        } catch (Exception e) {
            log.error("file {} remove failed", objectName, e);
            throw new MinioException(CsrErrorCode.REMOVE_ERROR);
        }
    }


    /**
     * 删除文件夹及文件
     *
     * @param bucketName bucket名称
     * @since tarzan LIU
     */
    public void deleteObject(String bucketName) {
        boolean flag = bucketClient.bucketExists(bucketName);
        if (flag) {
            try {
                // 递归列举某个bucket下的所有文件，然后循环删除
                log.info("递归列举{}下的所有文件循环删除", bucketName);
                Iterable<Result<Item>> iterable = minioClient.listObjects(ListObjectsArgs.builder()
                        .bucket(bucketName)
                        .recursive(true)
                        .build());
                for (Result<Item> itemResult : iterable) {
                    removeObject(bucketName, itemResult.get().objectName());
                }
            } catch (Exception e) {
                log.error("递归列举{}下的所有文件循环删除异常", bucketName, e);
            }
        }
    }

    /**
     * 上传单个文件
     *
     * @param file 文件
     * @return 文件路径
     * @throws Exception 上传失败异常
     */
    public String put(MultipartFile file) {
        return put(null, file);
    }

    /**
     * 上传单个文件至默认桶
     *
     * @param path 指定路径
     * @param file 文件
     * @return 文件最终路径
     * @throws Exception 文件上传失败异常
     */
    public String put(String path, MultipartFile file) {
        beforePutCheck(file);
        String originalFilename = file.getOriginalFilename();
        assert originalFilename != null;
        String objectName = buildObjectName(originalFilename, path);
        try {
            minioClient.putObject(buildPutObjectArgs(objectName, file));
            return objectName;
        } catch (Exception e) {
            log.error("file[{}] upload failed", originalFilename, e);
            throw new MinioException(CsrErrorCode.FILE_UPLOAD_FAILED_ERROR);
        }
    }

    /**
     * 上传单个文件至指定桶
     *
     * @param path       指定路径
     * @param file       文件
     * @param bucketName 桶名称
     * @return 文件最终路径
     * @throws Exception 文件上传失败异常
     */
    public String put(String path, MultipartFile file, String bucketName) {
        beforePutCheck(file);
        String originalFilename = file.getOriginalFilename();
        assert originalFilename != null;
//        String objectName = buildObjectName(originalFilename, path);
        try {
            minioClient.putObject(buildPutObjectArgs(path, file, bucketName));
            return path;
        } catch (Exception e) {
            log.error("file[{}] upload failed", originalFilename, e);
            throw new MinioException(CsrErrorCode.FILE_UPLOAD_FAILED_ERROR);
        }
    }

    /**
     * put 前校验
     *
     * @param file 文件
     * @throws Exception put异常
     */
    void beforePutCheck(MultipartFile file) {
        String originalFilename = file.getOriginalFilename();
        if (!StringUtils.hasText(originalFilename)) {
            log.error("file {} cannot have an empty name", originalFilename);
            throw new MinioException(CsrErrorCode.FILE_NAME_NO_NULL_ERROR);
        }
    }

    /**
     * 获取文件分隔符
     *
     * @return 文件分隔符
     */
    String getFileSeparator() {
        if (minioServerType.equals("WIN")) {
            return MinioConstant.FILE_SEPARATOR_WIN;
        } else if (minioServerType.equals("UNIX")) {
            return MinioConstant.FILE_SEPARATOR_UNIX;
        }
        return File.separator;
    }

    /**
     * 构建ObjectName
     *
     * @param originalFilename 文件原始名称
     * @param path             文件路径
     * @return ObjectName
     */
    String buildObjectName(String originalFilename, String path) {
        String filename = UUIDUtils.uuid() + MinioConstant.DEFAULT_FILENAME_SEPARATOR + originalFilename;

        String objectName = DateUtils.getNowDateStr(DateUtils.PATTERN_YYYYMMDD) + getFileSeparator() + filename;
        if (path != null) {
//           TODO 手写路径换 File.separator
            objectName = path + "/" + filename;
        }
        return objectName;
    }

    /**
     * 构建 PutObjectArgs
     *
     * @param objectName put对象名称
     * @param file       文件对象
     * @return PutObjectArgs
     * @throws Exception 输入输出流异常
     */
    PutObjectArgs buildPutObjectArgs(String objectName, MultipartFile file) throws Exception {
        return PutObjectArgs.builder()
                .bucket(bucketClient.getDefaultBucket())
                .object(objectName)
                .stream(file.getInputStream(), file.getSize(), -1)
                .contentType(file.getContentType())
                .build();
    }

    /**
     * 构建 PutObjectArgs
     *
     * @param objectName put对象名称
     * @param file       文件对象
     * @param bucketName 连接桶名称
     * @return PutObjectArgs
     * @throws Exception 输入输出流异常
     */
    PutObjectArgs buildPutObjectArgs(String objectName, MultipartFile file, String bucketName) throws Exception {
        return PutObjectArgs.builder()
                .bucket((Strings.isBlank(bucketName)) ? bucketClient.getDefaultBucket() : bucketName)
                .object(objectName)
                .stream(file.getInputStream(), file.getSize(), -1)
                .contentType(file.getContentType())
                .build();
    }

    /**
     * 判断默认存储桶文件是否存在
     *
     * @param objectName 文件名称, 如果要带文件夹请用 / 分割, 例如 /help/index.html
     * @return true存在, 反之
     */
    public Boolean checkFileIsExist(String objectName) {
        return this.checkFileIsExist(bucketClient.getDefaultBucket(), objectName);
    }

    /**
     * 判断默认存储桶文件夹是否存在
     *
     * @param folderName 文件夹名称
     * @return true存在, 反之
     */
    public Boolean checkFolderIsExist(String folderName) {
        return this.checkFolderIsExist(bucketClient.getDefaultBucket(), folderName);
    }

    /**
     * 判断文件是否存在
     *
     * @param bucketName 桶名称
     * @param objectName 文件名称, 如果要带文件夹请用 / 分割, 例如 /help/index.html
     * @return true存在, 反之
     */
    public Boolean checkFileIsExist(String bucketName, String objectName) {
        try {
            minioClient.statObject(
                    StatObjectArgs.builder().bucket(bucketName).object(objectName).build()
            );
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    /**
     * 判断文件夹是否存在
     *
     * @param bucketName 桶名称
     * @param folderName 文件夹名称
     * @return true存在, 反之
     */
    public Boolean checkFolderIsExist(String bucketName, String folderName) {
        try {
            Iterable<Result<Item>> results = minioClient.listObjects(
                    ListObjectsArgs
                            .builder()
                            .bucket(bucketName)
                            .prefix(folderName)
                            .recursive(false)
                            .build());
            for (Result<Item> result : results) {
                Item item = result.get();
                if (item.isDir() && folderName.equals(item.objectName())) {
                    return true;
                }
            }
        } catch (Exception e) {
            return false;
        }
        return true;
    }

}

存储桶管理客户端

package kl.gayxzc.csr.cilent;

import io.minio.BucketExistsArgs;
import io.minio.MakeBucketArgs;
import io.minio.MinioClient;
import io.minio.RemoveBucketArgs;
import io.minio.SetBucketPolicyArgs;
import io.minio.messages.Bucket;
import kl.gayxzc.csr.constant.CsrErrorCode;
import kl.gayxzc.csr.constant.MinioConstant;
import kl.gayxzc.csr.exception.MinioException;
import lombok.extern.slf4j.Slf4j;
import org.apache.logging.log4j.util.Strings;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.util.List;

/**
 * minio-client
 * 存储桶管理客户端
 *
 * @author ldh
 */
@Slf4j
@Component("bucketClient")
public class BucketClient {

    private MinioClient minioClient;

    private String defaultBucket;

    @Value("${csr.minio.bucket-name}")
    private String minioName;


    @Autowired
    public void setMinioClient(MinioClient minioClient) {
        this.minioClient = minioClient;
    }

    /**
     * 校验桶是否存在
     *
     * @param bucketName 桶名称
     * @return
     */
    public Boolean bucketExists(String bucketName) {
        try {
            return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        } catch (Exception e) {
            log.error("bucket {} cannot found", bucketName, e);
            throw new MinioException(CsrErrorCode.CHECK_ERROR);
        }
    }

    /**
     * 获取默认存储桶
     *
     * @return 默认存储桶
     * @throws Exception 获取失败
     */
    public String getDefaultBucket() {
        if (!StringUtils.hasText(defaultBucket)) {
            defaultBucket = minioName;
            if (!StringUtils.hasText(defaultBucket)) {
                log.error("default bucket cannot be empty");
                throw new MinioException(CsrErrorCode.MINIO_DEFAULT_ERROR);
            }
        }
        return defaultBucket;
    }

    /**
     * 设置默认存储桶
     *
     * @param name 存储桶名称
     * @throws Exception 设置失败异常
     */
    public void setDefaultBucket(String name) {
        if (bucketExists(name)) {
            this.defaultBucket = name;
            return;
        }
        this.defaultBucket = minioName;
        createBucket(this.defaultBucket);
        if (!StringUtils.hasText(defaultBucket)) {
            throw new MinioException(CsrErrorCode.MINIO_DEFAULT_ERROR);
        }
    }


    /**
     * 创建存储桶
     *
     * @param bucketName 存储桶名称
     * @throws Exception 存储桶异常
     */
    public void createBucket(String bucketName) {
        if (!bucketExists(bucketName)) {
            try {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            } catch (Exception e) {
                log.error("存储桶异常", e);
                throw new MinioException(CsrErrorCode.BUCKET_ERROR);
            }
        }
        log.warn("bucket {} has created", bucketName);
    }

    /**
     * 创建存储桶并赋予策略
     *
     * @param bucketName 存储桶名称
     * @param policy     权限
     * @throws Exception 存储桶异常
     */
    public void createBucket(String bucketName, String policy) {
        if (!bucketExists(bucketName)) {
            try {
//                创建桶
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
                if (Strings.isBlank(policy)) {
                    policy = MinioConstant.READ_WRITE;
                }
                if (Strings.isNotBlank(policy)) {
                    String strategy = this.consolidationStrategy(bucketName, policy);
                    minioClient.setBucketPolicy(SetBucketPolicyArgs.builder().bucket(bucketName).config(strategy).build());
                }
            } catch (Exception e) {
                log.error("存储桶异常", e);
                throw new MinioException(CsrErrorCode.BUCKET_ERROR);
            }
        }
        log.warn("bucket {} has created", bucketName);
    }

    /**
     * 拼接Minio对应桶策略
     *
     * @param policy 权限code
     * @return json 策略结构体
     */
    private String consolidationStrategy(String bucketName, String policy) {
        String jsonStrategy = Strings.EMPTY;
        if (MinioConstant.READ_ONLY.equals(policy)) {
            jsonStrategy = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:GetBucketLocation\",\"s3:ListBucket\"],\"Resource\":[\"arn:aws:s3:::" + bucketName + "\"]},{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:GetObject\"],\"Resource\":[\"arn:aws:s3:::" + bucketName + "/*\"]}]}";
        } else if (MinioConstant.WRITE_ONLY.equals(policy)) {
            jsonStrategy = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:GetBucketLocation\",\"s3:ListBucketMultipartUploads\"],\"Resource\":[\"arn:aws:s3:::" + bucketName + "\"]},{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:AbortMultipartUpload\",\"s3:DeleteObject\",\"s3:ListMultipartUploadParts\",\"s3:PutObject\"],\"Resource\":[\"arn:aws:s3:::" + bucketName + "/*\"]}]}";
        } else if (MinioConstant.READ_WRITE.equals(policy)) {
            jsonStrategy = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:GetBucketLocation\",\"s3:ListBucket\",\"s3:ListBucketMultipartUploads\"],\"Resource\":[\"arn:aws:s3:::" + bucketName + "\"]},{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:DeleteObject\",\"s3:GetObject\",\"s3:ListMultipartUploadParts\",\"s3:PutObject\",\"s3:AbortMultipartUpload\"],\"Resource\":[\"arn:aws:s3:::" + bucketName + "/*\"]}]}";
        } else {
            try {
                this.removeBucket(bucketName);
                log.info("桶策略枚举值不合法,桶{}已删除", bucketName);
                throw new MinioException(CsrErrorCode.POLICY_TYPE_ENUM_NOT_NULL);
            } catch (Exception e) {
                log.error("桶策略枚举值不合法", e);
            }
        }
        return jsonStrategy;
    }

    /**
     * 获取全部bucket
     *
     * @return 全部bucket信息
     * @throws Exception 获取全部bucket信息失败异常
     */
    public List<Bucket> getAllBuckets() {
        try {
            return minioClient.listBuckets();
        } catch (Exception e) {
            log.error("获取全部bucket信息失败异常", e);
            throw new MinioException(CsrErrorCode.FAILED_ALL_INFORMATION_ERROR);
        }
    }

    /**
     * 根据bucketName删除信息
     *
     * @param bucketName bucket名称
     * @throws Exception 删除bucket信息失败异常
     */
    public void removeBucket(String bucketName) {
        try {
            minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
        } catch (Exception e) {
            log.error("删除bucket信息失败异常", e);
            throw new MinioException(CsrErrorCode.REMOVE_BUCKET_ERROR);
        }

    }
}

常量定义

package kl.gayxzc.csr.constant;

/**
 * MINIO_常量定义
 */
public class MinioConstant {
    /**
     * 文件名称分隔符
     */
    public static final String DEFAULT_FILENAME_SEPARATOR = "@";

    /**
     * win
     */
    public static final String FILE_SEPARATOR_WIN = "\\";

    /**
     * unix
     */
    public static final String FILE_SEPARATOR_UNIX = "/";

    /**
     * bucket权限-只读 READ_ONLY
     */
    public static final String READ_ONLY = "READ_ONLY";
    /**
     * bucket权限-只写 WRITE_ONLY
     */
    public static final String WRITE_ONLY = "WRITE_ONLY";
    /**
     * bucket权限-读写 READ_WRITE
     */
    public static final String READ_WRITE = "READ_WRITE";

}

工具类定义

package kl.gayxzc.csr.utils;

import java.util.UUID;

/**
 * UUID工具类
 *
 * @author ldh
 */
public class UUIDUtils {
    /**
     * 随机获取uuid对象
     *
     * @return uuid对象
     */
    public static UUID randomUuid() {
        return UUID.randomUUID();
    }

    /**
     * 获取原生uuid字符串
     *
     * @return 原生uuid字符串
     */
    public static String orgUuid() {
        return randomUuid().toString();
    }

    /**
     * 获取 uuid
     *
     * @return uuid字符串
     */
    public static String uuid() {
        return orgUuid().replace("-", "");
    }
}


package kl.gayxzc.csr.utils;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

/**
 * 日期工具类
 *
 * @author ldh
 */
public class DateUtils {

    public static final String PATTERN_YYYYMMDD = "yyyyMMdd";

    public static final DateTimeFormatter DTF_PATTERN_YYYYMMDD = DateTimeFormatter.ofPattern(PATTERN_YYYYMMDD);

    public static final String PATTERN_YYYY_MM_DD = "yyyy-MM-dd";

    public static final DateTimeFormatter DTF_PATTERN_YYYY_MM_DD = DateTimeFormatter.ofPattern(PATTERN_YYYY_MM_DD);

    /**
     * /**
     * 获取当前日期
     *
     * @return 当前日期 <java.time.LocalDate>
     */
    public static LocalDate now() {
        return LocalDate.now();
    }

    /**
     * 获取当前日期字符串
     *
     * @return 时间
     */
    public static String getNowDateStr() {
        return now().format(DTF_PATTERN_YYYY_MM_DD);
    }

    /**
     * 获取当前日期字符串转Long
     *
     * @return 时间
     */
    public static Long getNowDateNumber() {
        return Long.valueOf(getNowDateStr());
    }

    /**
     * 获取当前日期字符串
     *
     * @param pattern 格式化
     * @return 时间
     */
    public static String getNowDateStr(String pattern) {
        return now().format(DateTimeFormatter.ofPattern(pattern));
    }
}
晨诺♪
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入比较 MinIO Java SDK 中的 getObject 和 statObject 方法
小子宝丁的博客
01-29 1312
MinIO是一款开源的对象存储服务器，为开发者提供了灵活的存储解决方案。在Java SDK中，`getObject` 和 `statObject` 是两个常用的方法，用于获取MinIO存储桶中对象的内容和元信息。本文将深入比较这两个方法，包括它们的操作含义、参数、返回值以及适用场景。
如何判断文件是否存在？
gaoxiaowei的专栏
09-02 717
  如何判断文件是否存在？#include #include bool FileExist(const char* FileName){    struct stat my_stat;    return (stat(FileName, &my_stat) == 0);}bool IsDirectory(const char* FileName){    struct stat my_stat
minio查询桶中文件,桶目录中文件
学海无涯,我用JAVA
02-10 1万+
文章再续,书接上文minio进阶分页查询说到了文件,可以实现分页查询,然后上次查询的是桶中的文件列表,这次遇到了需要数据隔离的文件,也就是需要在桶中再次建立文件夹;然后查询文件桶中的文件夹中的文件列表;由于需要实现此功能,查了很多文件,都没有找到合适的解答,又看了minio文档,也是没有找到合适的解释,试过了 ,最后只能一个个试终于算是解决了此次问题,做个记录,为后续方便;
SpringBoot 使用 Minio 进行文件存储
小毕超博客
07-24 2068
是在过去4年的时间内从0开始打造的一款软件，符合一切原生云计算的架构和构建过程，并且包含最新的云计算的全新的技术和概念。强有力的支持和驱动了很多世界500强的企业。此外，其部署的多样性和专业性提供了其他软件无法比拟的优势。存储桶类似于文件系统中的文件夹或目录，其中每个桶可以容纳任意数量的对象。、自由的创新和创造、自由的去修改、自由的再次发行新的版本和软件.确实,缩放器的来之不易的知识，为对象存储带来了简单的存储缩放模型，在。是全球领先的对象存储先锋，在标准硬件上，读/写速度上高达。...
Minio——docker
小白的博客
04-25 455
简介 MinIO 是在 Apache License v2.0 下发布的对象存储服务器。 它与 Amazon S3 云存储服务兼容。 它最适合存储非结构化数据，如照片，视频，日志文件，备份和容器/ VM 映像。 对象的大小可以从几 KB 到最大 5TB。 MinIO 服务器足够轻，可以与应用程序堆栈捆绑在一起，类似于 NodeJS，Redis 和 MySQL 一种高性能的分布式对象存储服务器，用于大型数据基础设施。它是机器学习和其他大数据工作负载下Hadoop HDFS 的理想 s3 兼容替代品 安装
使用MinIO文件存储系统【完成视频断点续传】业务逻辑
若有所执，必有所成，心之所向，必显光芒
05-21 2615
首先接收前端上传媒资文件所生成的md5和分块序号，通过文件的md5值和文件每一块的序号组成在minio中存储分块文件的位置，获取该位置的分块文件是否存在，如果存在返回true（说明该分块文件已经在此前完成过上传，无需再次上传），如果不存在返回false，说明该分块文件还未上传，重新上传这一块文件。当前端按照5M将文件切分好依次上传所有之后，会请求接口四（合并文件），后端接收原文件的md5值和上传文件的名称和分块总数，在业务层进行处理，controller层（控制层）controller层（控制层）
java连接minio工具类
09-21
MinIO is a software-defined high performance distributed object storage server. You can run MinIO on consumer or enterprise-grade hardware and a variety of operating ...本文是基于Java sdk 编写的工具类
官网下载Minio工具包
06-09
官网下载Minio工具包
java操作minio文件服务的通用工具类
08-19
java操作minio文件服务的通用工具类,可以实现使用指定方法就能控制文件的上传下载删除以及更多操作
C# .net core 最新版本minio帮助类
09-07
包含平台初始化，存储桶操作，文件上传下载，文件流上传下载
文件-AES-MD5-Upload-Minio工具类.zip
01-30
AESFileUtil MD5FileUtils FileUploadUtil FileUtil MinioUtils
java 客户端调用minio服务
u011250186的博客
12-21 4570
java 客户端调用minio服务
Minio下载文件
Anakki的博客
09-21 924
注意 ：controller层controller方法不需要返回值。从minio获取文件流，下载文件。
Minio工具类
weixin_43148691的博客
09-17 8184
引入Maven依赖 <dependency> <groupId>io.minio</groupId> <artifactId>minio</artifactId> <version>8.3.0</version> </dependency> 配置文件 ## ====================== ↓↓↓↓↓↓ MinIO文件服务器 ↓↓↓↓↓↓ =====================
minio操作,文件上传下载
CSDN__LiMing的博客
01-27 3010
minio操作工具类(其中,ip,端口,账号,密码在配置文件中配置) @Api(value = "minio操作") @Component public class UploadFileToMinio implements InitializingBean { @Value("${minio.endpoint}") private String endpoint;//minio ip @Value("${minio.port}") private int port;//m
项目中遇到的一些问题总结（六）
m0_51431003的博客
05-20 940
第二种机制是MySQL在可重复读隔离级别下使用的多版本并发控制（Multiversion Concurrency Control，MVCC）机制。该机制允许多个事务在不同的版本上并发读取和修改同一个数据行，以保证事务的隔离性，并发性和一致性。MVCC实现的核心思想是：对于每个事务，不直接读取数据库中的数据，而是创建一个“事务版本”，在事务版本集（Transaction Version Set）中记录该事务读取的所有数据行的版本号。
Minio文件服务使用API文档-Python
LeonTom的博客
09-27 1万+
文章目录1.安装包2.建立连接3.操作存储桶（文件夹）3.1创建桶3.2判断桶存在3.3删除桶4.操作文件对象4.1 下载文件4.1.1 获取文件数据4.1.2 直接下载到本地指定目录：4.2上传文件4.2.1以数据流格式上传4.2.2 以文件路径上传4.3删除文件4.4 删除多个文件5.问题：6.解决： 1.安装包 pip install minio 官方API文档链接：https://ww...
MinIO分布式储存简介以及整合SpringBoot
菠萝吹雪爱Java的博客
09-30 2082
Minio 是个基于 Golang 编写的开源对象存储套件，基于Apache License v2.0开源协议，虽然轻量，却拥有着不错的性能。它兼容亚马逊S3云存储服务接口。可以很简单的和其他应用结合使用，例如 NodeJS、Redis、MySQL等。
java操作minio最佳实践
热门推荐
shenjianzhuang的专栏
04-09 1万+
public class MinioUtil { private static String minio_url; private static String minio_name; private static String minio_pass; private static String minio_bucketName; /** * * @Title...
Java minio工具类
最新发布
10-20
Java minio工具类是基于Java sdk编写的工具类，用于操作MinIO对象存储服务器。它包含了上传文件、设置文件contentType类型、设置全局访问策略等方法。在使用Java minio工具类之前，需要在pom.xml中引入minio依赖，并在yml文件中配置MinIO服务所在地址、存储桶名称、访问的key和秘钥等信息。通过Java minio工具类，可以方便地对MinIO对象存储服务器进行操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值