Typora自动上传图片，springboot集成Minio做私有化图床

已于 2023-11-07 19:28:38 修改
阅读量179 收藏 1
点赞数
分类专栏： Other 文章标签： spring boot 后端 java
于 2023-11-07 19:26:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46951831/article/details/134274301
版权

Typora设置最简单的自动上传和手动上传图片并回显效果

在这里插入图片描述

在Typora里面设置一下插入图片时就能自动上传到Minio的服务器上了，这样同一个局域网的同学打开也能正常查看笔记内容了；

@echo off
set currentDate=%date:~0,4%-%date:~5,2%-%date:~8,2%
curl -X POST -F "folderName=%currentDate%" -F "file=@%~1" http://{IP}:{PORT}/minio/upload

bat文件里面的脚本说明：

1.通过curl访问服务接口：http://{IP}:{PORT}/minio/upload
2.传递参数：
	第一个参数为当前日期如：2023-11-07;作为minio服务上的目录
	第二个参数为需要上传的图片，即完整的图片路径

这样复制粘贴的图片就会按天自动归类到服务器上了如下面这样：

在这里插入图片描述

Minio部署这里就不讲了，就一个文件启动起来就行；

springboot集成Minio

依赖

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

核心实现类

package com.ygsoft.jt.teng.cp.minio.service;

import com.ygsoft.jt.teng.cp.minio.config.MinioConfig;
import com.ygsoft.jt.teng.cp.minio.constant.MinioConstant;
import com.ygsoft.jt.teng.cp.minio.entity.MultiPartUploadInfo;
import com.ygsoft.jt.teng.cp.minio.enums.PolicyType;
import com.ygsoft.jt.teng.cp.minio.service.client.ExtendMinioAsyncClient;
import com.ygsoft.jt.teng.cp.minio.utils.MinioUtil;
import io.minio.*;
import io.minio.errors.*;
import io.minio.http.Method;
import io.minio.messages.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.time.ZonedDateTime;
import java.util.*;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * @author hhong <br>
 * @version 1.0.0 2023/11/3 9:30 <br>
 * @since JDK 1.8.0
 */
@Service
public class MinioService {
    private static final Logger LOGGER = LoggerFactory.getLogger(MinioService.class);
    private final MinioConfig minioConfig;

    private final ExtendMinioAsyncClient minioAsyncClient;

    private final MinioClient minioClient;

    public MinioService(MinioConfig minioConfig, ExtendMinioAsyncClient minioAsyncClient, MinioClient minioClient) {
        this.minioConfig = minioConfig;
        this.minioAsyncClient = minioAsyncClient;
        this.minioClient = minioClient;
    }

    /**
     * 查看指定bucket是否存在
     *
     * @param bucketName bucket名称
     * @return
     */
    public boolean bucketExists(String bucketName) throws MinioException {
        try {
            return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        } catch (ErrorResponseException | IOException | InsufficientDataException
                 | InternalException | InvalidKeyException | InvalidResponseException
                 | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            throw new MinioException(e.getMessage());
        }
    }

    /**
     * 创建一个bucket
     *
     * @param bucketName bucket名称
     * @return
     */
    public boolean createBucket(String bucketName) throws MinioException {
        try {
            if (!bucketExists(bucketName)) {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            }
            return true;
        } catch (ErrorResponseException | IOException | InsufficientDataException
                 | InternalException | InvalidKeyException | InvalidResponseException
                 | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            throw new MinioException(e.getMessage());
        }
    }
    public void createFolder(String bucketName,String folderName) throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException, InvalidResponseException, XmlParserException, InternalException {
        minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(folderName + MinioConstant.URI_DELIMITER)
                        .stream(new ByteArrayInputStream(new byte[0]),0,-1)
                        .build()
        );
    }
    /**
     * 创建一个bucket，并指定访问策略
     *
     * @param bucketName bucket名称
     * @param policyType 访问策略
     * @return
     */
    public boolean createBucket(String bucketName, PolicyType policyType) throws MinioException {
        try {
            if (this.createBucket(bucketName)) {
                minioClient.setBucketPolicy(SetBucketPolicyArgs.builder().bucket(bucketName).config(PolicyType.getPolicy(policyType, bucketName)).build());
            }
            return true;
        } catch (ErrorResponseException | IOException | InsufficientDataException
                 | InternalException | InvalidKeyException | InvalidResponseException
                 | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            throw new MinioException(e.getMessage());
        }
    }

    /**
     * 创建一个bucket，并指定访问策略，默认三种不满足时，自定义可调用此方法
     *
     * @param bucketName bucket名称
     * @param policy     访问策略
     * @return
     */
    public boolean createBucket(String bucketName, String policy) throws MinioException {
        try {
            if (this.createBucket(bucketName)) {
                minioClient.setBucketPolicy(SetBucketPolicyArgs.builder().bucket(bucketName).config(policy).build());
            }
            return true;
        } catch (ErrorResponseException | IOException | InsufficientDataException
                 | InternalException | InvalidKeyException | InvalidResponseException
                 | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            throw new MinioException(e.getMessage());
        }
    }

    /**
     * 指定访问策略
     *
     * @param bucketName bucket名称
     * @param policyType 访问策略
     * @return
     */
    public boolean setBucketPolicy(String bucketName, PolicyType policyType) throws MinioException {
        try {
            if (!bucketExists(bucketName)) {
                throw new MinioException(bucketName + " bucket does not exist.");
            }
            minioClient.setBucketPolicy(SetBucketPolicyArgs.builder().bucket(bucketName).config(PolicyType.getPolicy(policyType, bucketName)).build());
            return true;
        } catch (ErrorResponseException | IOException | InsufficientDataException
                 | InternalException | InvalidKeyException | InvalidResponseException
                 | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            throw new MinioException(e.getMessage());
        }
    }

    /**
     * 指定访问策略，默认三种不满足时，自定义可调用此方法
     *
     * @param bucketName bucket名称
     * @param policy     访问策略
     * @return
     */
    public boolean setBucketPolicy(String bucketName, String policy) throws MinioException {
        try {
            if (!bucketExists(bucketName)) {
                throw new MinioException(bucketName + " bucket does not exist.");
            }
            minioClient.setBucketPolicy(SetBucketPolicyArgs.builder().bucket(bucketName).config(policy).build());
            return true;
        } catch (ErrorResponseException | IOException | InsufficientDataException
                 | InternalException | InvalidKeyException | InvalidResponseException
                 | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            throw new MinioException(e.getMessage());
        }
    }

    /**
     * 获得所有bucket
     *
     * @return
     */
    public List<Bucket> listBuckets() throws MinioException {
        try {
            return minioClient.listBuckets();
        } catch (ErrorResponseException | IOException | InsufficientDataException
                 | InternalException | InvalidKeyException | InvalidResponseException
                 | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            throw new MinioException(e.getMessage());
        }
    }

    /**
     * 获得指定bucket
     *
     * @param bucketName bucket名称
     * @return
     */
    public Optional<Bucket> getBucket(String bucketName) throws MinioException {
        return listBuckets().stream().filter(item -> item.name().equals(bucketName)).findFirst();
    }

    /**
     * 删除一个bucket
     *
     * @param bucketName bucket名称
     * @return
     */
    public boolean removeBucket(String bucketName) throws MinioException {
        try {
            if (bucketExists(bucketName)) {
                minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
            }
            return true;
        } catch (ErrorResponseException | IOException | InsufficientDataException
                 | InternalException | InvalidKeyException | InvalidResponseException
                 | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            throw new MinioException(e.getMessage());
        }
    }

    /**
     * 遍历默认 bucketName 下文件夹名称
     *
     * @return
     */
    public List<Item> listObjects() throws MinioException {
        return listObjects(getBucketName());
    }

    /**
     * 遍历指定 bucketName 下文件夹名称
     *
     * @param bucketName bucket名称
     * @return
     */
    public List<Item> listObjects(String bucketName) throws MinioException {
        return listObjects(bucketName, false);
    }

    /**
     * 遍历文件
     *
     * @param bucketName bucket名称
     * @param recursive  是否递归查询，是，则会返回文件全路径，否，则返回第一级文件夹
     * @return
     */
    public List<Item> listObjects(String bucketName, boolean recursive) throws MinioException {
        return listObjects(bucketName, null, recursive);
    }

    /**
     * 遍历文件
     *
     * @param bucketName bucket名称
     * @param prefix     前缀，包括路径
     * @param recursive  是否递归查询
     * @return
     */
    public List<Item> listObjects(String bucketName, String prefix, boolean recursive) throws MinioException {
        List<Item> objectList = new ArrayList<>();
        Iterable<Result<Item>> results = minioClient.listObjects(ListObjectsArgs.builder().bucket(bucketName).prefix(prefix).recursive(recursive).build());
        for (Result<Item> itemResult : results) {
            try {
                objectList.add(itemResult.get());
            } catch (ErrorResponseException | IOException | InsufficientDataException
                     | InternalException | InvalidKeyException | InvalidResponseException
                     | NoSuchAlgorithmException | XmlParserException | ServerException e) {
                throw new MinioException(e.getMessage());
            }
        }
        return objectList;
    }

    /**
     * 获得指定文件 文件流
     *
     * @param objectName
     * @return
     */
    public InputStream getObject(String objectName) throws MinioException {
        return getObject(getBucketName(), objectName);
    }

    /**
     * 获得指定文件 文件流
     *
     * @param bucketName
     * @param objectName
     * @return
     */
    public InputStream getObject(String bucketName, String objectName) throws MinioException {
        InputStream inputStream;
        try {
            inputStream = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(MinioUtil.getObjectName(objectName)).build());
        } catch (ErrorResponseException | IOException | InsufficientDataException
                 | InternalException | InvalidKeyException | InvalidResponseException
                 | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            throw new MinioException(e.getMessage());
        }
        return inputStream;
    }

    /**
     * 获得指定文件 文件流
     *
     * @param bucketName
     * @param objectName
     * @param versionId
     * @return
     */
    public InputStream getObject(String bucketName, String objectName, String versionId) throws MinioException {
        InputStream inputStream;
        try {
            inputStream = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(MinioUtil.getObjectName(objectName)).versionId(versionId).build());
        } catch (ErrorResponseException | IOException | InsufficientDataException
                 | InternalException | InvalidKeyException | InvalidResponseException
                 | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            throw new MinioException(e.getMessage());
        }
        return inputStream;
    }

    /**
     * 获得指定文件 文件流
     *
     * @param bucketName
     * @param objectName
     * @param length
     * @param offset
     * @return
     */
    public InputStream getObject(String bucketName, String objectName, long length, Long offset) throws MinioException {
        InputStream inputStream;
        try {
            inputStream = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(MinioUtil.getObjectName(objectName)).length(length).offset(offset).build());
        } catch (ErrorResponseException | IOException | InsufficientDataException
                 | InternalException | InvalidKeyException | InvalidResponseException
                 | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            throw new MinioException(e.getMessage());
        }
        return inputStream;
    }

    /**
     * 获得外链，过期时间默认7天
     *
     * @param objectName 文件
     * @return
     */
    public String getObjectUrl(String objectName) throws MinioException {
        return getObjectUrl(getBucketName(), objectName);
    }

    /**
     * 获得外链，过期时间默认7天
     *
     * @param bucketName bucket 名称
     * @param objectName 文件
     * @return
     */
    public String getObjectUrl(String bucketName, String objectName) throws MinioException {
        return getObjectUrl(bucketName, objectName, false);
    }

    /**
     * 获得外链，过期时间默认7天
     *
     * @param bucketName     bucket 名称
     * @param objectName     文件
     * @param replaceAddress 是否替换访问域名
     * @return
     */
    public String getObjectUrl(String bucketName, String objectName, boolean replaceAddress) throws MinioException {
        return getObjectUrl(bucketName, objectName, replaceAddress, GetPresignedObjectUrlArgs.DEFAULT_EXPIRY_TIME);
    }

    /**
     * 获得外链
     *
     * @param bucketName     bucket 名称
     * @param objectName     文件
     * @param replaceAddress 是否替换访问域名
     * @param expires        过期时间，单位秒
     * @return
     */
    public String getObjectUrl(String bucketName, String objectName, boolean replaceAddress, Integer expires) throws MinioException {
        try {
            String objectUrl;
            // expires 设置为-1时表示获取永久地址
            if (expires == -1) {
                objectUrl = minioConfig.getEndpoint()+MinioConstant.URI_DELIMITER+bucketName+MinioConstant.URI_DELIMITER+objectName;
            } else {
                objectUrl = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().bucket(bucketName).object(MinioUtil.getObjectName(objectName)).expiry(expires).method(Method.GET).build());
            }
            //String objectUrl = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().bucket(bucketName).object(MinioUtil.getObjectName(objectName)).expiry(expires).method(Method.GET).build());
            return replaceAddress && minioConfig.getAddress() != null ? objectUrl.replace(minioConfig.getEndpoint(), minioConfig.getAddress()) : objectUrl;
        } catch (ErrorResponseException | IOException | InsufficientDataException
                 | InternalException | InvalidKeyException | InvalidResponseException
                 | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            throw new MinioException(e.getMessage());
        }
    }

    /**
     * 上传文件
     *
     * @param objectName 文件名称
     * @param stream     文件流
     * @return
     */
    public ObjectWriteResponse putObject(String objectName, InputStream stream) throws MinioException {
        return putObject(getBucketName(), objectName, stream);
    }

    /**
     * 上传文件
     *
     * @param bucketName bucket名称
     * @param objectName 文件名称，如：2021/11/28/test.zip
     * @param stream     文件流
     * @return
     */
    public ObjectWriteResponse putObject(String bucketName, String objectName, InputStream stream) throws MinioException {
        return putObject(bucketName, objectName, null, stream);
    }

    /**
     * 上传文件
     *
     * @param bucketName  bucket名称
     * @param objectName  文件名称，如：2021/11/28/test.zip
     * @param contentType 文件类型
     * @param stream      文件流
     * @return
     */
    public ObjectWriteResponse putObject(String bucketName, String objectName, String contentType,
                                         InputStream stream) throws MinioException {
        try {
            return putObject(bucketName, objectName, contentType, stream, stream.available(), ObjectWriteArgs.MIN_MULTIPART_SIZE);
        } catch (IOException e) {
            throw new MinioException(e.getMessage());
        }
    }

    /**
     * 上传文件
     *
     * @param bucketName  bucket名称
     * @param objectName  文件名称，如：2021/11/28/test.zip
     * @param contentType 文件类型
     * @param stream      文件流
     * @param objectSize  文件大小
     * @return
     */
    public ObjectWriteResponse putObject(String bucketName, String objectName, String contentType,
                                         InputStream stream, long objectSize) throws MinioException {
        return putObject(bucketName, objectName, contentType, stream, objectSize, -1);
    }

    /**
     * 上传文件
     *
     * @param bucketName  bucket名称
     * @param objectName  文件名称，如：2021/11/28/test.zip
     * @param contentType 文件类型
     * @param stream      文件流
     * @param objectSize  文件大小
     * @param partSize    分片大小
     * @return
     */
    public ObjectWriteResponse putObject(String bucketName, String objectName, String contentType,
                                         InputStream stream, long objectSize, long partSize) throws MinioException {
        try {
            return minioClient.putObject(PutObjectArgs.builder()
                    .bucket(bucketName)
                    .object(MinioUtil.getObjectName(objectName))
                    .stream(stream, objectSize, partSize)
                    .contentType(MinioUtil.getContentType(contentType))
                    .build());
        } catch (ErrorResponseException | IOException | InsufficientDataException
                 | InternalException | InvalidKeyException | InvalidResponseException
                 | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            throw new MinioException(e.getMessage());
        }
    }

    /**
     * 单个删除
     *
     * @param objectName
     * @return
     */
    public boolean removeObject(String objectName) throws MinioException {
        return removeObject(getBucketName(), objectName);
    }

    /**
     * 单个删除
     *
     * @param bucketName
     * @param objectName
     * @return
     */
    public boolean removeObject(String bucketName, String objectName) throws MinioException {
        try {
            minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(MinioUtil.getObjectName(objectName)).build());
            return true;
        } catch (ErrorResponseException | IOException | InsufficientDataException
                 | InternalException | InvalidKeyException | InvalidResponseException
                 | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            throw new MinioException(e.getMessage());
        }
    }

    /**
     * 批量删除
     *
     * @param bucketName
     * @param objectNames
     * @return
     */
    public List<String> removeObjects(String bucketName, Collection<String> objectNames) throws MinioException {
        List<DeleteObject> objects = objectNames.stream().map(MinioUtil::getObjectName).map(DeleteObject::new).collect(Collectors.toList());
        Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(objects).build());
        List<String> errorDeleteObjects = new ArrayList<>();
        try {
            for (Result<DeleteError> result : results) {
                errorDeleteObjects.add(result.get().objectName());
                LOGGER.error(String.format("Error in deleting object %s:%s, code=%s, message=%s",
                        bucketName, result.get().objectName(), result.get().code(), result.get().message()));
            }
        } catch (ErrorResponseException | IOException | InsufficientDataException
                 | InternalException | InvalidKeyException | InvalidResponseException
                 | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            throw new MinioException(e.getMessage());
        }
        return errorDeleteObjects;
    }

    /**
     * 获取上传临时签名
     *
     * @param fileName
     * @return
     * @throws MinioException
     */
    public Map<String, String> getPresignedPostFormData(String fileName) throws MinioException {
        return getPresignedPostFormData(getBucketName(), fileName);
    }

    /**
     * 获取上传临时签名
     *
     * @param bucketName
     * @param fileName
     * @return
     * @throws MinioException
     */
    public Map<String, String> getPresignedPostFormData(String bucketName, String fileName) throws MinioException {
        return getPresignedPostFormData(bucketName, fileName, ZonedDateTime.now().plusMinutes(10));
    }

    /**
     * 获取上传临时签名
     *
     * @param bucketName
     * @param fileName
     * @param time       默认10分钟以内有效
     * @return
     * @throws MinioException
     */
    public Map<String, String> getPresignedPostFormData(String bucketName, String fileName, ZonedDateTime time) throws MinioException {
        return getPresignedPostFormData(bucketName, null, fileName, time);
    }

    /**
     * 获取上传临时签名
     *
     * @param bucketName
     * @param path       文件保存路径，如：test/file
     * @param fileName
     * @return
     * @throws MinioException
     */
    public Map<String, String> getPresignedPostFormData(String bucketName, String path, String fileName) throws MinioException {
        return getPresignedPostFormData(bucketName, path, fileName, ZonedDateTime.now().plusMinutes(10));
    }

    /**
     * 获取上传临时签名
     *
     * @param bucketName
     * @param path       文件保存路径，如：test/file
     * @param fileName
     * @param time
     * @return
     * @throws MinioException
     */
    public Map<String, String> getPresignedPostFormData(String bucketName, String path, String fileName, ZonedDateTime time) throws MinioException {
        PostPolicy postPolicy = new PostPolicy(bucketName, time);
        String key = MinioConstant.URI_DELIMITER + MinioUtil.getPath(path) + fileName;
        postPolicy.addEqualsCondition("key", key);
        try {
            Map<String, String> map = minioClient.getPresignedPostFormData(postPolicy);
            HashMap<String, String> map1 = new HashMap<>();
            map.forEach((k, v) -> map1.put(k.replace("-", ""), v));
            map1.put("key", key);
            map1.put("host", minioConfig.getEndpoint() + MinioConstant.URI_DELIMITER + bucketName);
            return map1;
        } catch (ErrorResponseException | IOException | InsufficientDataException
                 | InternalException | InvalidKeyException | InvalidResponseException
                 | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            throw new MinioException(e.getMessage());
        }
    }

    /**
     * 获取上传文件的url
     *
     * @param objectName
     * @return
     * @throws MinioException
     */
    public String getPresignedObjectPutUrl(String objectName) throws MinioException {
        return getPresignedObjectPutUrl(getBucketName(), objectName);
    }

    /**
     * 获取上传文件的url
     *
     * @param bucketName
     * @param objectName
     * @return
     * @throws MinioException
     */
    public String getPresignedObjectPutUrl(String bucketName, String objectName) throws MinioException {
        return getPresignedObjectPutUrl(bucketName, null, objectName);
    }

    /**
     * 获取上传文件的url
     *
     * @param bucketName
     * @param path
     * @param objectName
     * @return
     * @throws MinioException
     */
    public String getPresignedObjectPutUrl(String bucketName, String path, String objectName) throws MinioException {
        return getPresignedObjectPutUrl(bucketName, path, objectName, 5);
    }

    /**
     * 获取上传文件的url
     *
     * @param bucketName
     * @param path
     * @param objectName
     * @return
     * @throws MinioException
     */
    public String getPresignedObjectPutUrl(String bucketName, String path, String objectName, Integer time) throws MinioException {
        return getPresignedObjectPutUrl(bucketName, path, objectName, time, TimeUnit.MINUTES);
    }

    /**
     * 获取上传文件的url
     *
     * @param bucketName
     * @param path
     * @param objectName
     * @param time
     * @param timeUnit
     * @return
     * @throws MinioException
     */
    public String getPresignedObjectPutUrl(String bucketName, String path, String objectName, Integer time, TimeUnit timeUnit) throws MinioException {
        try {
            objectName = (StringUtils.hasText(path) ? MinioUtil.getPath(path) : "") + MinioUtil.getObjectName(objectName);
            return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                    .method(Method.PUT)
                    .bucket(bucketName)
                    .object(objectName)
                    .expiry(time, timeUnit).build());
        } catch (ErrorResponseException | IOException | InsufficientDataException
                 | InternalException | InvalidKeyException | InvalidResponseException
                 | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            throw new MinioException(e.getMessage());
        }
    }

    /**
     * 获得分片上传的地址信息
     *
     * @param objectName
     * @param partSize
     * @return
     * @throws MinioException
     */
    public MultiPartUploadInfo getPresignedMultipartUploadUrls(String objectName, Integer partSize) throws MinioException {
        return getPresignedMultipartUploadUrls(getBucketName(), objectName, partSize);
    }

    /**
     * 获得分片上传的地址信息
     *
     * @param objectName
     * @param partSize
     * @return
     * @throws MinioException
     */
    public MultiPartUploadInfo getPresignedMultipartUploadUrls(String objectName, Integer partSize, String contentType) throws MinioException {
        return getPresignedMultipartUploadUrls(getBucketName(), objectName, partSize, contentType);
    }

    /**
     * 获得分片上传的地址信息
     *
     * @param bucketName
     * @param objectName
     * @param partSize
     * @return
     * @throws MinioException
     */
    public MultiPartUploadInfo getPresignedMultipartUploadUrls(String bucketName, String objectName, Integer partSize) throws MinioException {
        return getPresignedMultipartUploadUrls(bucketName, null, objectName, partSize);
    }

    /**
     * 获得分片上传的地址信息
     *
     * @param bucketName
     * @param objectName
     * @param partSize
     * @param contentType
     * @return
     * @throws MinioException
     */
    public MultiPartUploadInfo getPresignedMultipartUploadUrls(String bucketName, String objectName, Integer partSize, String contentType) throws MinioException {
        return getPresignedMultipartUploadUrls(bucketName, null, objectName, partSize, contentType);
    }

    /**
     * 获得分片上传的地址信息
     *
     * @param bucketName
     * @param path
     * @param objectName
     * @param partSize
     * @return
     * @throws MinioException
     */
    public MultiPartUploadInfo getPresignedMultipartUploadUrls(String bucketName, String path, String objectName, Integer partSize) throws MinioException {
        return getPresignedMultipartUploadUrls(bucketName, path, objectName, partSize, null);
    }

    /**
     * 获得分片上传的地址信息
     *
     * @param bucketName
     * @param path
     * @param objectName
     * @param partSize
     * @param contentType
     * @return
     * @throws MinioException
     */
    public MultiPartUploadInfo getPresignedMultipartUploadUrls(String bucketName, String path, String objectName, Integer partSize, String contentType) throws MinioException {
        return getPresignedMultipartUploadUrls(bucketName, path, objectName, partSize, contentType, 10);
    }

    /**
     * 获得分片上传的地址信息
     *
     * @param bucketName
     * @param path
     * @param objectName
     * @param partSize
     * @param contentType
     * @param time
     * @return
     * @throws MinioException
     */
    public MultiPartUploadInfo getPresignedMultipartUploadUrls(String bucketName, String path, String objectName, Integer partSize, String contentType, Integer time) throws MinioException {
        return getPresignedMultipartUploadUrls(bucketName, path, objectName, partSize, contentType, time, TimeUnit.MINUTES);
    }

    /**
     * 获得分片上传的地址信息
     *
     * @param bucketName
     * @param path
     * @param objectName
     * @param partSize
     * @param contentType
     * @param time
     * @param timeUnit
     * @return
     * @throws MinioException
     */
    public MultiPartUploadInfo getPresignedMultipartUploadUrls(String bucketName, String path, String objectName, Integer partSize, String contentType, Integer time, TimeUnit timeUnit) throws MinioException {
        String uploadId = "";
        List<String> partUrlList = new ArrayList<>();
        try {
            objectName = (StringUtils.hasText(path) ? MinioUtil.getPath(path) : "") + MinioUtil.getObjectName(objectName);
            InitiateMultipartUploadResult uploadResponse = this.initMultiPartUpload(bucketName, objectName, contentType);
            uploadId = uploadResponse.uploadId();
            Map<String, String> paramsMap = new HashMap<>(2);
            paramsMap.put("uploadId", uploadId);
            for (int i = 1; i <= partSize; i++) {
                paramsMap.put("partNumber", String.valueOf(i));
                // 获取上传 url
                String uploadUrl = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                        // 注意此处指定请求方法为 PUT，前端需对应，否则会报 `SignatureDoesNotMatch` 错误
                        .method(Method.PUT)
                        .bucket(bucketName)
                        .object(objectName)
                        // 指定上传连接有效期
                        .expiry(time, timeUnit)
                        .extraQueryParams(paramsMap).build());
                partUrlList.add(uploadUrl);
            }
        } catch (IOException | InsufficientDataException | InternalException | InvalidKeyException |
                 NoSuchAlgorithmException | XmlParserException e) {
            throw new MinioException(e.getMessage());
        }

        return MultiPartUploadInfo.builder()
                .uploadId(uploadId)
                .fileName(objectName)
                .expiryTime(MinioUtil.getLocalDateTime(time, timeUnit))
                .uploadUrls(partUrlList)
                .build();
    }

    /**
     * 根据分片partNumber获取前端分片上传预签名urls
     *
     * @param uploadId    上传标识，同一个文件，需保证一样，通过 initMultiPartUpload 方法获取
     * @param objectName  文件名称，如：2021/11/28/test.zip
     * @param partNumbers 分片partNumber集合
     * @return
     */
    public MultiPartUploadInfo getPresignedMultipartUploadUrlsByPartNumbers(String uploadId, String objectName, List<Integer> partNumbers) throws MinioException {
        return getPresignedMultipartUploadUrlsByPartNumbers(uploadId, getBucketName(), objectName, partNumbers);
    }

    /**
     * 根据分片partNumber获取前端分片上传预签名urls
     *
     * @param uploadId    上传标识，同一个文件，需保证一样，通过 initMultiPartUpload 方法获取
     * @param bucketName  bucketName
     * @param objectName  文件名称，如：2021/11/28/test.zip
     * @param partNumbers 分片partNumber集合
     * @return
     */
    public MultiPartUploadInfo getPresignedMultipartUploadUrlsByPartNumbers(String uploadId, String bucketName, String objectName, List<Integer> partNumbers) throws MinioException {
        return getPresignedMultipartUploadUrlsByPartNumbers(uploadId, bucketName, null, objectName, partNumbers);
    }

    /**
     * 根据分片partNumber获取前端分片上传预签名urls
     *
     * @param uploadId    上传标识，同一个文件，需保证一样，通过 initMultiPartUpload 方法获取
     * @param bucketName  bucketName
     * @param objectName  文件名称，如：2021/11/28/test.zip
     * @param partNumbers 分片partNumber集合
     * @return
     */
    public MultiPartUploadInfo getPresignedMultipartUploadUrlsByPartNumbers(String uploadId, String bucketName, String path, String objectName, List<Integer> partNumbers) throws MinioException {
        return getPresignedMultipartUploadUrlsByPartNumbers(uploadId, bucketName, path, objectName, partNumbers, 10);
    }

    /**
     * 根据分片partNumber获取前端分片上传预签名urls
     *
     * @param uploadId    上传标识，同一个文件，需保证一样，通过 initMultiPartUpload 方法获取
     * @param bucketName  bucketName
     * @param objectName  文件名称，如：2021/11/28/test.zip
     * @param partNumbers 分片partNumber集合
     * @param time        过期时间，默认10分钟
     * @return
     */
    public MultiPartUploadInfo getPresignedMultipartUploadUrlsByPartNumbers(String uploadId, String bucketName, String path, String objectName, List<Integer> partNumbers, Integer time) throws MinioException {
        return getPresignedMultipartUploadUrlsByPartNumbers(uploadId, bucketName, path, objectName, partNumbers, time, TimeUnit.MINUTES);
    }

    /**
     * 根据分片partNumber获取前端分片上传预签名urls
     *
     * @param uploadId    上传标识，同一个文件，需保证一样，通过 initMultiPartUpload 方法获取
     * @param bucketName  bucketName
     * @param objectName  文件名称，如：2021/11/28/test.zip
     * @param partNumbers 分片partNumber集合
     * @param time        过期时间，默认10分钟
     * @param timeUnit    过期时间单位，默认分钟
     * @return
     */
    public MultiPartUploadInfo getPresignedMultipartUploadUrlsByPartNumbers(String uploadId, String bucketName, String path, String objectName, List<Integer> partNumbers, Integer time, TimeUnit timeUnit) throws MinioException {
        List<String> partUrlList = new ArrayList<>();
        try {
            objectName = (StringUtils.hasText(path) ? MinioUtil.getPath(path) : "") + MinioUtil.getObjectName(objectName);
            Map<String, String> paramsMap = new HashMap<>(2);
            paramsMap.put("uploadId", uploadId);
            for (Integer partNumber : partNumbers) {
                paramsMap.put("partNumber", String.valueOf(partNumber));
                // 获取上传 url
                String uploadUrl = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                        // 注意此处指定请求方法为 PUT，前端需对应，否则会报 `SignatureDoesNotMatch` 错误
                        .method(Method.PUT)
                        .bucket(bucketName)
                        .object(objectName)
                        // 指定上传连接有效期
                        .expiry(time, timeUnit)
                        .extraQueryParams(paramsMap).build());
                partUrlList.add(uploadUrl);
            }
        } catch (IOException | InsufficientDataException | InternalException | InvalidKeyException |
                 NoSuchAlgorithmException | XmlParserException e) {
            throw new MinioException(e.getMessage());
        }

        return MultiPartUploadInfo.builder()
                .uploadId(uploadId)
                .fileName(objectName)
                .expiryTime(MinioUtil.getLocalDateTime(time, timeUnit))
                .uploadUrls(partUrlList)
                .build();
    }

    /**
     * 初始化分片上传
     *
     * @param objectName 文件名称
     * @return
     * @throws MinioException
     */
    public InitiateMultipartUploadResult initMultiPartUpload(String objectName) throws MinioException {
        return initMultiPartUpload(getBucketName(), objectName);
    }

    /**
     * 初始化分片上传
     *
     * @param bucketName bucketName
     * @param objectName 文件名称
     * @return
     * @throws MinioException
     */
    public InitiateMultipartUploadResult initMultiPartUpload(String bucketName, String objectName) throws MinioException {
        return initMultiPartUpload(bucketName, null, objectName);
    }

    /**
     * 初始化分片上传
     *
     * @param bucketName bucketName
     * @param objectName 文件名称
     * @return
     * @throws MinioException
     */
    public InitiateMultipartUploadResult initMultiPartUpload(String bucketName, String path, String objectName) throws MinioException {
        return initMultiPartUpload(bucketName, path, objectName, "application/octet-stream");
    }

    /**
     * 初始化分片上传
     *
     * @param bucketName  bucketName
     * @param objectName  文件名称
     * @param contentType contentType
     * @return
     * @throws MinioException
     */
    public InitiateMultipartUploadResult initMultiPartUpload(String bucketName, String path, String objectName, String contentType) throws MinioException {
        try {
            objectName = (StringUtils.hasText(path) ? MinioUtil.getPath(path) : "") + MinioUtil.getObjectName(objectName);
            return minioAsyncClient.initMultiPartUpload(bucketName, null, objectName, MinioUtil.getHeader(contentType), null);
        } catch (IOException | InsufficientDataException | InternalException | InvalidKeyException |
                 NoSuchAlgorithmException | XmlParserException | ExecutionException | InterruptedException e) {
            throw new MinioException(e.getMessage());
        }
    }

    /**
     * 合并分片
     *
     * @param objectName
     * @param uploadId
     * @return
     * @throws MinioException
     */
    public String mergeMultiPartUpload(String objectName, String uploadId) throws MinioException {
        return mergeMultiPartUpload(getBucketName(), objectName, uploadId);
    }

    /**
     * 合并分片
     *
     * @param bucketName
     * @param objectName
     * @param uploadId
     * @return
     * @throws MinioException
     */
    public String mergeMultiPartUpload(String bucketName, String objectName, String uploadId) throws MinioException {
        return mergeMultiPartUpload(bucketName, objectName, uploadId, 1000);
    }


    /**
     * 合并分片
     *
     * @param bucketName
     * @param objectName
     * @param uploadId
     * @return
     * @throws MinioException
     */
    public String mergeMultiPartUpload(String bucketName, String objectName, String uploadId, Integer maxParts) throws MinioException {
        try {
            ListPartsResponse partsResponse = minioAsyncClient.listMultipart(bucketName, null, MinioUtil.getObjectName(objectName), maxParts, 0, uploadId, null, null);
            if (null == partsResponse) {
                throw new MinioException("分片列表为空");
            }
            List<Part> partList = partsResponse.result().partList();
            Part[] parts = new Part[partList.size()];
            partList.toArray(parts);
            ObjectWriteResponse writeResponse = minioAsyncClient.mergeMultipartUpload(bucketName, null, MinioUtil.getObjectName(objectName), uploadId, parts, null, null);
            if (null == writeResponse) {
                throw new MinioException("分片合并失败");
            }
            return getAddress(writeResponse.region());
        } catch (ErrorResponseException | IOException | InsufficientDataException | InternalException |
                 InvalidKeyException | InvalidResponseException | NoSuchAlgorithmException | XmlParserException |
                 ServerException | ExecutionException | InterruptedException e) {
            throw new MinioException(e.getMessage());
        }
    }

    /**
     * 获取已上传的分片列表
     *
     * @param objectName
     * @param uploadId
     * @return
     * @throws MinioException
     */
    public List<Integer> listUploadMultiPart(String objectName, String uploadId) throws MinioException {
        return listUploadMultiPart(getBucketName(), objectName, uploadId);
    }

    /**
     * 获取已上传的分片列表
     *
     * @param bucketName
     * @param objectName
     * @param uploadId
     * @return
     * @throws MinioException
     */
    public List<Integer> listUploadMultiPart(String bucketName, String objectName, String uploadId) throws MinioException {
        return listUploadMultiPart(bucketName, objectName, uploadId, 1000);
    }

    /**
     * 获取已上传的分片列表
     *
     * @param bucketName
     * @param objectName
     * @param uploadId
     * @param maxParts
     * @return
     * @throws MinioException
     */
    public List<Integer> listUploadMultiPart(String bucketName, String objectName, String uploadId, Integer maxParts) throws MinioException {
        ListPartsResponse partsResponse;
        try {
            partsResponse = minioAsyncClient.listMultipart(bucketName, null, MinioUtil.getObjectName(objectName), maxParts, 0, uploadId, null, null);
        } catch (NoSuchAlgorithmException | IOException | InvalidKeyException | ExecutionException |
                 InterruptedException e) {
            throw new MinioException(e.getMessage());
        }
        if (null == partsResponse) {
            return Collections.emptyList();
        }
        return partsResponse.result().partList().stream().map(Part::partNumber).collect(Collectors.toList());
    }

    /**
     * 获得 当前日期分割目录，如：2021/11/28
     *
     * @return
     */
    public String getDatePath() {
        return String.join(MinioConstant.URI_DELIMITER, MinioUtil.getDateFolder());
    }

    /**
     * 获得文件外链，永久外链，需要服务端设置指定bucket为全部可访问
     *
     * @param bucket    bucket名称
     * @param finalPath 路径及文件名，如 2021/11/20/test.zip
     * @return
     */
    public String gatewayUrl(String bucket, String finalPath) {
        finalPath = finalPath.startsWith(MinioConstant.URI_DELIMITER) ? finalPath.substring(finalPath.indexOf(MinioConstant.URI_DELIMITER) + 1) : finalPath;
        return getAddress(minioConfig.getEndpoint() + MinioConstant.URI_DELIMITER + bucket + MinioConstant.URI_DELIMITER + finalPath);
    }

    /**
     * 获得文件访问地址
     *
     * @return
     */
    public String getAddress(String url) {
        String address = "".equals(minioConfig.getAddress().trim()) ? minioConfig.getEndpoint() : minioConfig.getAddress();
        return url.replace(minioConfig.getEndpoint(), address);
    }

    /**
     * 默认BucketName
     *
     * @return
     */
    public String getBucketName() {
        if (!StringUtils.hasText(minioConfig.getBucketName())) {
            throw new RuntimeException("未配置默认 BucketName");
        }
        return minioConfig.getBucketName();
    }

}

Controller类

package com.ygsoft.jt.teng.cp.minio.controller;

import com.ygsoft.jt.teng.cp.minio.config.MinioConfig;
import com.ygsoft.jt.teng.cp.minio.constant.MinioConstant;
import com.ygsoft.jt.teng.cp.minio.enums.PolicyType;
import com.ygsoft.jt.teng.cp.minio.service.MinioService;
import io.minio.errors.MinioException;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

/**
 * @author hhong2 <br>
 * @version 1.0.0 2023/11/3 10:12 <br>
 * @since JDK 1.8.0
 */
@RestController
public class testController {
    @Resource
    private MinioService minioService;
    @Resource
    private MinioConfig minioConfig;
    @PostMapping("/minio/upload")
    public String upload(MultipartFile file, String folderName) throws IOException, MinioException, NoSuchAlgorithmException, InvalidKeyException {
        // 如果bucket不存在则创建一个当前配置的可读可写权限的bucket
        if (!minioService.bucketExists(minioConfig.getBucketName())){
            minioService.createBucket(minioConfig.getBucketName(), PolicyType.READ_WRITE);
        }
        // 创建目录
        minioService.createFolder(minioConfig.getBucketName(),folderName);
        // 上传图片
        minioService.putObject(minioConfig.getBucketName(),folderName+MinioConstant.URI_DELIMITER+file.getOriginalFilename(),file.getContentType(),file.getInputStream());
        // 返回图片下载地址
        return minioService.getObjectUrl(minioConfig.getBucketName(),folderName+MinioConstant.URI_DELIMITER+file.getOriginalFilename(),false,-1);
    }
}

这样不仅在typora里面可以实现私有化图床的效果，在中小型企业里面也可以完全自己搭一个图床来统一管理和备份了；封装了一个minioService的组件和完整流程的有需要的同学留言，我发压缩包；Typora自动上传图片，springboot集成Minio做私有化图床

HH287
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何Typora自动上传图片到minio图床
小邯韩的博客
05-19 319
验证配置是否正确，当然也能验证。
Typora实现图片自动上传(Windows为例)
chaim67的博客
11-30 1177
登录个人gitee仓库创建用于上传图片的git仓库建议勾选上初始化仓库或者设置模板, 会自动生成分支, 方便后续设置否则需要自行通过git同步来初始上传, 创建分支点击右上方个人头像, 点击设置按钮在左侧功能栏中点击私人令牌, 并在右上方点击生成新令牌填写令牌名称, 以及该令牌相关权限(后期可以修改)保留个人令牌。
Typora自定义上传图片到服务器图床(java实现)
csh1050449218的博客
01-18 965
Typora使用Custom Command自定义上传图片到图床，包含上传图片接口,上传到自己服务器中
生命在于折腾——PicGo+Minio+Typora图床搭建
易水哲的博客
04-12 2429
PicGo+Minio+Typora图床搭建
Linux 部署 MinIO 分布式对象存储 & 配置为 typora 图床
凉了的凉茶的博客
10-09 1455
MinIO 是一款高性能的对象存储系统，它可以用于大规模的 AI/ML、数据湖和数据库工作负载。它的 API 与Amazon S3 云存储服务完全兼容，可以在任何云或本地基础设施上运行。MinIO 是，也提供商业许可和支持。
通过Minio搭建私有化对象存储服务_开源PaaS Rainbond最佳实践
mark's technic world
03-14 935
Minio是建立在云原生的基础上；有分布式和共享存储等功能；旨在多租户环境中以可持续的方式进行扩展的对象存储服务。它最适合存储非结构化数据，如：照片、视频、日志文件、容器/虚拟机/映像等，单次存储对象的大小最大可达5TB。 实现架构单节点 根据存储是否为远端，可直接使用FS或NFS直接操作存储中的Object 调用S3接口，通过Minio使用FS或NFS来操作Object 多节点 多节点的...
私有化对象存储-minio
莫笑少年江湖梦，谁不年少梦江湖
11-03 379
MinIO是一款高性能、分布式的对象存储系统，它使用Go语言编写，并基于Apache License v2.0开源协议。MinIO的主要特点包括简单、可靠。它采用简单可靠的集群方案，摒弃复杂的大规模的集群调度管理，减少风险与性能瓶颈，聚焦产品的核心功能，打造高可用的集群、灵活的扩展能力以及超过的性能。MinIO支持云原生，能与Kubernetes、Docker、Swarm编排系统良好对接，实现灵活部署。部署简单，只有一个可执行文件，参数极少，一条命令即可启动一个MinIO系统。
springboot集成minio实现了分片上传功能源码+项目说明.zip
12-20
springboot集成minio实现了分片上传功能源码+项目说明.zip vue版本的：前端 后端 快速开始 后端 修改配置文件application.yml: minio: endpoint: accessKey: secretKey: bucketName: downloadUri: #配置...
springboot集成minio实现的文件服务组件(含Vue前端源码).zip
06-24
在本项目中，我们主要探讨的是如何利用SpringBoot框架与MinIO进行集成，构建一个功能完善的文件服务组件。MinIO是一款高性能的对象存储服务器，而SpringBoot则是Java领域中广泛使用的微服务开发框架，两者结合可以...
springboot集成minio完成自己的分布式文件系统
02-28
SpringBoot集成MinIO是构建分布式文件系统的常见方法，尤其对于Java开发者来说，这是一个高效且经济的解决方案。MinIO是一款开源的对象存储服务器，它兼容Amazon S3 API，可以提供高性能、高可用性和安全性。通过将...
minio 安装步骤以及springboot 如何集成minio
08-07
将MinIO集成到SpringBoot应用中，可以方便地管理和使用对象存储服务。下面我们将详细探讨MinIO的安装过程以及如何在SpringBoot应用中进行集成。 ### MinIO的安装步骤 1. **下载MinIO**: 首先，你需要从MinIO的官方...
Springboot通过MinIO进行文件操作代码
09-27
在Spring Boot应用中，MinIO是一个非常流行的对象存储服务，它可以用来进行文件的上传、下载、删除等操作。MinIO是高度兼容Amazon S3的对象存储服务器，提供了简单、快速、可扩展的数据存储解决方案。本教程将详细...
minio和阿里云oss哪个好？
MinIO
12-09 1177
阿里的OSS支持一系列具有不同级别的持久性、可用性和成本的存储类别，使其成为高度灵活的存储解决方案。在企业到了一定的规模，需要混合云、私有云、AI推理和数据隔离的情况下，MinIO可能会是更好的选择，能够保证更高的企业数据的自主性和安全性。因此，如果在公有云产品选择上可以选择阿里云OSS、腾讯云的COS、华为云的OBS和AWS的S3，都是全球非常优秀的对象存储产品。但是他们的S3的API借口都参考的是亚马逊的S3 标准，在MinIO 的S3兼容性上面比阿里云的兼容性更好一些。
对象存储MinIO的简介与部署
SRE成长记
01-08 2732
对象存储MinIO的简介与部署
【MinIO私有部署使用方法】
qq_38635320的博客
04-26 824
3、MinioOssBuilder类中返回MyMinioTemplate。5、文件回显需要签名，模版类里方法。使用跟天翼云OSS一样。2、在OssBuilder类中更换我们自定义的模版。注：MinIO也可创建公共和只读桶，按情况使用。1、自定义模版 MyMinioTemplate。4、使用示例–下载文件。
minio 私有化搭建oss
gwdgwd123的博客
02-07 377
用法和阿里云 OSS 差不多，因为他们都是亚马逊 S3(simple storage service) 规范的实现。我们用 docker 跑了一个 minio 的容器，然后分别在管理界面和用 npm 包的方式做了文件上传和下载。但是 OSS 是收费的，而且有些敏感数据不能传到云上，需要私有部署，这种就可以自己搭一个 OSS 服务。文件上传一般我们都是用 OSS 服务来存储，比如阿里云的 OSS。
基于minio,springboot部署图床
weixin_46684043的博客
01-27 478
技术栈:springboot,maven。
MinIO+NPS+DDNS+旧笔记本搭建私有图床
lunfangyu的博客
05-26 960
MinIO+NPS+DDNS+旧笔记本搭建私有图床 前言 ​ 一篇好的博文，是需要图文并茂的。以前最好用的免费图床应该是PicGo+gitee方式了。但今年，这种gitee已打击这种使用仓库作为图床做法，并且还做了防盗链处理。因此行不通了。所以现在要么使用付费OSS，要么只能另想他法了。之前，我写过typora+picgo实现本地自动转储图片base64这个文章，打算以这种base64的方式替代图床。开始使用还好，但后面便发现了局限性，当图片比较大时，转为base64后，编辑器就无法进行渲染显
@SpringBootApplication 注解及源码 详解
最新发布
weixin_68074170的博客
07-19 946
Configuration注解本质上是一个@Component注解，所以，被@Configuration注解标注的配置类本身也会被注册到IOC容器中。同时，@Configuration注解也会被@ComponentScan注解扫描到。当某个类被@Configuration注解标注时，说明这个类是配置类，可以在这个类中使用@Bean注解向IOC容器中注入Bean对象，也可以使用@Autowired、@Inject和@Resource等注解来注入所需的Bean对象。前面四个不用说，是定义一个注解所必须的。
springboot集成minio使用
08-20
springboot集成minio的使用步骤如下： 1. 配置文件桶权限：可以在配置文件中设置minio的桶权限，包括读、写、删除等操作。可以根据具体需求进行配置。 2. 引入minio客户端依赖：在项目的pom.xml文件中添加minio...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值