华为云对象存储（OBS）工具类

一、pom.xml依赖

<dependency>
	<groupId>com.huaweicloudgroupId>
	<artifactId>esdk-obs-java-bundleartifactId>
	<version>3.21.12version>
dependency>

二、配置文件

##华为OBS接入配置
huaweiobs:
  #OBS服务所在地址
  endPoint: https://xxx
  #存储桶名称
  bucketName: bucket-test
  #访问的key
  ak: xxx
  #访问的秘钥
  sk: xxx

三、配置类

package com.xxx.config;

import com.xxx.util.HuaWeiOBSUtil;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * HuaWeiOBS配置类
 *
 * @author hcs
 * @date 2023/6/1 9:41
 */
@Configuration
public class HuaWeiOBSConfig {

    @Value("${huaweiobs.bucketName:bucketNameCfg}")
    private String bucketName;
    @Value("${huaweiobs.ak:akCfg}")
    private String ak;
    @Value("${huaweiobs.sk:skCfg}")
    private String sk;
    @Value("${huaweiobs.endPoint:endPointCfg}")
    private String endPoint;

    @Bean
    public HuaWeiOBSUtil huaWeiOBSUtil() {
        return new HuaWeiOBSUtil(bucketName, ak, sk, endPoint);
    }
}

四、工具类

package com.xxx.util;

import com.obs.services.ObsClient;
import com.obs.services.model.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

/**
 * 华为云存储(OBS)-工具类
 *
 * @author hcs
 * @date 2023/6/20 17:03
 */
@Slf4j
public class HuaWeiOBSUtil {

    /**
     * 文件外链过期时间，7天
     */
    private static long expire = 7 * 24 * 60 * 60;

    /**
     * 文件外链访问端口
     */
    private static String port = ":443";

    private static String bucketName;
    private static String ak;
    private static String sk;
    private static String endPoint;

    /**
     * OBS操作客户端
     */
    private static ObsClient obsClient = null;

    private static final String SEPARATOR = "/";

    public HuaWeiOBSUtil(String bucketName, String ak, String sk, String endPoint) {
        HuaWeiOBSUtil.bucketName = bucketName;
        HuaWeiOBSUtil.ak = ak;
        HuaWeiOBSUtil.sk = sk;
        HuaWeiOBSUtil.endPoint = endPoint;
        createObsClientInstance();
    }

    public static String getBucketName() {
        return bucketName;
    }

    public static String getAk() {
        return ak;
    }

    public static String getSk() {
        return sk;
    }

    public static String getEndPoint() {
        return endPoint;
    }

    /**
     * 获取OBS操作客户端
     *
     * @return
     */
    private static void createObsClientInstance() {
        try {
            if (obsClient == null) {
                synchronized (ObsClient.class) {
                    if (obsClient == null) {
                        obsClient = new ObsClient(ak, sk, endPoint);
                    }
                }
            }
            createBucket(bucketName, endPoint);
        } catch (Exception e) {
            log.error("连接华为云存储服务器异常：" + e.getMessage(), e);
        }
    }

    /**
     * 获取上传文件的基础路径
     *
     * @return url
     */
    public static String getBasisUrl() {
        //实示例：http协议 + 存储桶名称 + . + endPoint + port + /
        return getHttpProtocol(endPoint) + "://" + bucketName + "." + endPoint.replace(getHttpProtocol(endPoint) + "://", "") + port + SEPARATOR;
    }

    /**
     * 获取上传文件的基础路径
     *
     * @param bucketName
     * @return
     */
    public static String getBasisUrl(String bucketName) {
        //实示例：http协议 + 存储桶名称 + . + endPoint + port + /
        return getHttpProtocol(endPoint) + "://" + bucketName + "." + endPoint.replace(getHttpProtocol(endPoint) + "://", "") + port + SEPARATOR;
    }

    /**
     * 获取区域
     *
     * @param endPoint
     * @return
     */
    public static String getRegion(String endPoint) {
        String substring = endPoint.substring(endPoint.indexOf(".") + 1);
        return substring.substring(0, substring.indexOf("."));
    }

    /**
     * 获取http协议
     *
     * @param endPoint
     * @return
     */
    public static String getHttpProtocol(String endPoint) {
        return endPoint.substring(0, endPoint.indexOf(":"));
    }

    /**
     * 创建存储桶
     *
     * @param bucketName
     * @return
     */
    public static void createBucket(String bucketName, String endPoint) {
        if (!headBucket(bucketName)) {
            CreateBucketRequest request = new CreateBucketRequest();
            // 设置存储桶名称
            request.setBucketName(bucketName);
            // 设置桶区域位置，从endPoint中截取，如果Location设置的区域与endPoint中的区域不是同一个，则创建会报错
            request.setLocation(getRegion(endPoint));
            // 创建桶成功
            obsClient.createBucket(request);
        }
    }

    /**
     * 删除存储桶
     *
     * @param bucketName
     * @return
     */
    public static HeaderResponse deleteBucket(String bucketName) {
        return obsClient.deleteBucket(bucketName);
    }

    /**
     * 判断存储桶是否存在
     *
     * @param bucketName
     * @return
     */
    public static boolean headBucket(String bucketName) {
        return obsClient.headBucket(bucketName);
    }

    /**
     * 上传字符
     *
     * @param bucketName
     * @param objectName
     * @param content
     * @return
     */
    public static PutObjectResult putObjectByStr(String bucketName, String objectName, String content) {
        if (StringUtils.isBlank(content)) {
            return null;
        }

        //重新构建objectName
        objectName = buildObjectName(objectName);

        return obsClient.putObject(bucketName, objectName, new ByteArrayInputStream(content.getBytes()));
    }

    /**
     * 上传输入流
     *
     * @param bucketName
     * @param objectName
     * @param inputStream
     * @return
     */
    public static PutObjectResult putObjectByInput(String bucketName, String objectName, InputStream inputStream) {
        //重新构建objectName
        objectName = buildObjectName(objectName);

        return obsClient.putObject(bucketName, objectName, inputStream);
    }

    /**
     * 上传文件输入流
     *
     * @param bucketName
     * @param objectName
     * @param fileInputStream
     * @return
     */
    public static PutObjectResult putObjectByFileInput(String bucketName, String objectName, FileInputStream fileInputStream) {
        //重新构建objectName
        objectName = buildObjectName(objectName);

        return obsClient.putObject(bucketName, objectName, fileInputStream);
    }

    /**
     * 通过MultipartFile，上传文件
     *
     * @param bucketName
     * @param objectName
     * @param media
     * @return
     */
    public static PutObjectResult putObjectByMultipartFile(String bucketName, String objectName, MultipartFile media) throws IOException {
        //重新构建objectName
        objectName = buildObjectName(objectName);

        return obsClient.putObject(bucketName, objectName, media.getInputStream());
    }

    /**
     * 上传本地文件
     *
     * @param bucketName
     * @param objectName
     * @param file
     * @return
     */
    public static PutObjectResult putObjectByFile(String bucketName, String objectName, File file) {
        //重新构建objectName
        objectName = buildObjectName(objectName);

        return obsClient.putObject(bucketName, objectName, file);
    }

    /**
     * 下载文件到本地
     *
     * @param bucketName
     * @param objectName
     * @param filePath
     * @return
     */
    public static boolean downloadObject(String bucketName, String objectName, String filePath) throws Exception {
        if (StringUtils.isBlank(filePath)) {
            return false;
        }
        //重新构建objectName
        objectName = buildObjectName(objectName);

        filePath = filePath.replace("\\", SEPARATOR);

        InputStream input = null;
        FileOutputStream fileOutputStream = null;
        try {
            // 获取对象
            ObsObject obsObject = obsClient.getObject(bucketName, objectName);
            // 读取对象内容
            input = obsObject.getObjectContent();

            if (input == null) {
                return false;
            }

            //获取文件夹路径
            if (filePath.contains(SEPARATOR)) {
                String dir = filePath.substring(0, filePath.lastIndexOf(SEPARATOR));
                File difFile = new File(dir);
                if (!difFile.exists()) {
                    //创建文件夹
                    boolean mkdirs = difFile.mkdirs();
                }
            }

            File file = new File(filePath);
            fileOutputStream = new FileOutputStream(file);

            byte[] b = new byte[1024];
            int len;
            while ((len = input.read(b)) != -1) {
                fileOutputStream.write(b, 0, len);
            }
            return true;
        } finally {
            if (fileOutputStream != null) {
                fileOutputStream.close();
            }
            if (input != null) {
                input.close();
            }
        }
    }

    /**
     * 获取文件内容
     *
     * @param bucketName
     * @param objectName
     * @return
     */
    public static String getObjectContent(String bucketName, String objectName) throws IOException {
        //重新构建objectName
        objectName = buildObjectName(objectName);

        InputStream input = null;
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        try {
            ObsObject obsObject = obsClient.getObject(bucketName, objectName);
            // 读取对象内容
            input = obsObject.getObjectContent();

            byte[] b = new byte[1024];
            int len;
            while ((len = input.read(b)) != -1) {
                bos.write(b, 0, len);
            }

            return new String(bos.toByteArray());
        } finally {
            bos.close();
            if (input != null) {
                input.close();
            }
        }
    }

    /**
     * 获取文件输入流
     *
     * @param bucketName
     * @param objectName
     * @return
     */
    public static InputStream getObject(String bucketName, String objectName) {
        //重新构建objectName
        objectName = buildObjectName(objectName);

        return obsClient.getObject(bucketName, objectName).getObjectContent();
    }

    /**
     * 指定数目和前缀列举
     *
     * @param bucketName
     * @param prefix
     * @param maxKeys
     * @return
     */
    public static List<ObsObject> listObjects(String bucketName, String prefix, Integer maxKeys) {
        prefix = prefix.startsWith("/") ? prefix.substring(1) : prefix;

        ListObjectsRequest request = new ListObjectsRequest(bucketName);
        // 设置列举的对象个数
        request.setMaxKeys(maxKeys);
        // 设置列举的对象需要带有指定前缀
        request.setPrefix(prefix);
        ObjectListing result = obsClient.listObjects(request);

        return result.getObjects();
    }

    /**
     * 列举指定前缀的全部对象
     *
     * @param bucketName
     * @param prefix
     * @return
     */
    public static List<ObsObject> listAllObjects(String bucketName, String prefix) {
        prefix = prefix.startsWith("/") ? prefix.substring(1) : prefix;

        List<ObsObject> list = new ArrayList<>();

        ListObjectsRequest request = new ListObjectsRequest(bucketName);
        // 设置列举的对象个数
        request.setMaxKeys(1000);
        // 设置列举的对象需要带有指定前缀
        request.setPrefix(prefix);

        ObjectListing result;
        do {
            result = obsClient.listObjects(request);
            request.setMarker(result.getNextMarker());

            list.addAll(result.getObjects());
        } while (result.isTruncated());

        return list;
    }

    /**
     * 删除单个对象
     *
     * @param bucketName
     * @param objectName
     * @return
     */
    public static DeleteObjectResult deleteObject(String bucketName, String objectName) {
        //重新构建objectName
        objectName = buildObjectName(objectName);

        return obsClient.deleteObject(bucketName, objectName);
    }

    /**
     * 复制对象
     *
     * @param sourceBucketName
     * @param sourceObjectName
     * @param destBucketName
     * @param destObjectName
     * @return
     */
    public static CopyObjectResult copyObject(String sourceBucketName, String sourceObjectName,
                                              String destBucketName, String destObjectName) {
        return obsClient.copyObject(sourceBucketName, sourceObjectName, destBucketName, destObjectName);
    }

    /**
     * 判断对象是否存在
     *
     * @param bucketName
     * @param objectName
     * @return
     */
    public static boolean doesObjectExist(String bucketName, String objectName) {
        //重新构建objectName
        objectName = buildObjectName(objectName);

        return obsClient.doesObjectExist(bucketName, objectName);
    }

    /**
     * 获取文件外链
     *
     * @param bucketName
     * @param objectName
     * @param expires    单位：秒(s)
     * @return
     */
    public static String getSignedUrl(String bucketName, String objectName, Long expires) {
        //重新构建objectName
        objectName = buildObjectName(objectName);

        TemporarySignatureRequest request = new TemporarySignatureRequest(HttpMethodEnum.GET, expires);
        request.setBucketName(bucketName);
        request.setObjectKey(objectName);
        TemporarySignatureResponse response = obsClient.createTemporarySignature(request);
        return response.getSignedUrl();
    }

    /**
     * 获取文件外链-url有效时间默认7天
     *
     * @param bucketName
     * @param objectName
     * @return
     */
    public static String getSignedUrl(String bucketName, String objectName) {
        return getSignedUrl(bucketName, objectName, expire);
    }

    /**
     * 重新构建objectName
     *
     * @param objectName
     */
    private static String buildObjectName(String objectName) {
        if (StringUtils.isBlank(objectName)) {
            return objectName;
        }
        //去除开头的/
        objectName = objectName.startsWith("/") ? objectName.substring(1) : objectName;
        //去除?后边的参数
        objectName = objectName.contains("?") ? objectName.substring(0, objectName.indexOf("?")) : objectName;

        return objectName;
    }

    /**
     * 传入文件访问外链，返回objectName
     *
     * @param url
     * @return
     */
    public static String getObjectNameByUrl(String url) {
        if (StringUtils.isBlank(url)) {
            return url;
        }

        if (url.contains(getBasisUrl())) {
            // 去除minio基础路径
            url = url.replace(getBasisUrl(), "");
            // 去除?后边的参数
            url = url.contains("?") ? url.substring(0, url.indexOf("?")) : url;
        }

        return url;
    }
}