阿里云oss存储

WuWuII

已于 2025-03-06 11:45:23 修改

阅读量558

点赞数 5

分类专栏： java 文章标签：阿里云oss 文件存储

于 2024-06-27 15:31:33 首次发布

本文链接：https://blog.youkuaiyun.com/a3562323/article/details/139904782

版权

java 专栏收录该内容

62 篇文章

订阅专栏

文章目录

准备阿里云的OSS
java使用oss
封装工具类
Oss访问文件
- 如何保证指定时间段内可以访问私有权限的图片文件？
其它

准备阿里云的OSS

控制台

访问阿里云官网，登录以后，右上角有个控制台
在这里插入图片描述
点击左上角，然后搜索oss

因为我没有开通过，所以提示开通

点击开通

创建bucket

在这里插入图片描述
填写bucket名称和选择读写权限为公共读，然后完成创建

然后bucket列表中，就有刚才创建的bucket了

点击列表中的bucket名称，然后点击概览，看到一些基础信息，其中有个Endpoint，上传文件会用到

获取AccessKey

鼠标移到右上角头像处，有个AccessKey管理，点击来获取AccessKey，

在这里插入图片描述
选择继续使用

然后点击创建AccessKey，再验证手机验证码，就成功创建，需要注意的是，获取到AccessKey以后，要保存好，关闭这个窗口就看不到了

java使用oss

左边最下面有个sdk下载
在这里插入图片描述
java后面有个小图标，点一下

文档中心打开

导入依赖

左边找到java-安装，我是maven项目，选择导入pom依赖，，它有说明，java9以上要引入下面那部分，具体看你版本，我是9以上，两部分依赖都要
在这里插入图片描述

        <!--oss依赖-->
        <dependency>
            <groupId>com.aliyun.oss</groupId>
            <artifactId>aliyun-sdk-oss</artifactId>
            <version>3.17.4</version>
        </dependency>
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>2.3.1</version>
        </dependency>
        <dependency>
            <groupId>javax.activation</groupId>
            <artifactId>activation</artifactId>
            <version>1.1.1</version>
        </dependency>
        <!-- no more than 2.3.3-->
        <dependency>
            <groupId>org.glassfish.jaxb</groupId>
            <artifactId>jaxb-runtime</artifactId>
            <version>2.3.3</version>
        </dependency>

官网demo

依赖有了，现在要做的就是上传文件的测试demo了，找到测试demo，粘到项目代码中
在这里插入图片描述

修改参数

粘贴过来以后，把一些关键参数换成我们实际的数值
demo需要修改的参数说明
在这里插入图片描述

运行demo代码

package com.wzw.alioss;

import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.common.auth.CredentialsProviderFactory;
import com.aliyun.oss.common.auth.EnvironmentVariableCredentialsProvider;
import com.aliyun.oss.model.PutObjectRequest;
import com.aliyun.oss.model.PutObjectResult;

import java.io.ByteArrayInputStream;
import java.io.FileInputStream;

public class DemoTest {
    public static void main(String[] args) throws Exception {
        // Endpoint以华东1（杭州）为例，其它Region请按实际情况填写。
        String endpoint = "https://oss-cn-beijing.aliyuncs.com";
        // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
        //EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        String ACCESS_KEY_ID = "LTAI5tRHMRGaK14mSm1LNRkB";
        String ACCESS_KEY_SECRET = "mrniIO007QfxpdsMzW0CDROcPjoTfg";
        // 填写Bucket名称，例如examplebucket。
        String bucketName = "ali-bucket-space";
        // 填写Object完整路径，完整路径中不能包含Bucket名称，例如exampledir/exampleobject.txt。
        String objectName = "dog.jpg";

        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, ACCESS_KEY_ID,ACCESS_KEY_SECRET);

        try {

            // 创建PutObjectRequest对象。
            PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, objectName, new FileInputStream("C:\\Users\\w4523\\Desktop\\dogjpg.jpg"));

            // 如果需要上传时设置存储类型和访问权限，请参考以下示例代码。
            // ObjectMetadata metadata = new ObjectMetadata();
            // metadata.setHeader(OSSHeaders.OSS_STORAGE_CLASS, StorageClass.Standard.toString());
            // metadata.setObjectAcl(CannedAccessControlList.Private);
            // putObjectRequest.setMetadata(metadata);

            // 上传字符串。
            PutObjectResult result = ossClient.putObject(putObjectRequest);
        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
    }

}

运行，上传成功
在这里插入图片描述

封装工具类

上面参数说明已经看到了，其实很多东西都是固定的，只有一些值需要传入就可以了，现在封装成一个工具类，只传入我们要上传的文件对象就可以了

package com.wzw.alioss.com.wzw.alioss.util;

import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.model.PutObjectRequest;
import com.aliyun.oss.model.PutObjectResult;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.io.InputStream;

public class AliOssUtil {

    //地域节点
    private static final String endpoint="https://oss-cn-beijing.aliyuncs.com";
    //ACCESS_KEY_ID
    private static final String ACCESS_KEY_ID="LTAI5tRHMRGaK14mSm1LNRkB";
    //ACCESS_KEY_SECRET
    private static final String ACCESS_KEY_SECRET="mrniIO007QfxpdsMzW0CDROcPjoTfg";
    //bucket名称
    private static final String bucketName="ali-bucket-space";


    /**
     * 上传文件到OSS
     * @param objectName
     * @param inputStream
     * @return
     * @throws Exception
     */
    public static String uploadFile(String objectName, InputStream inputStream) throws Exception {

        //文件存储的地址
        String url="";

        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, ACCESS_KEY_ID,ACCESS_KEY_SECRET);

        try {

            // 创建PutObjectRequest对象。
            PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, objectName, inputStream);

            // 如果需要上传时设置存储类型和访问权限，请参考以下示例代码。
            // ObjectMetadata metadata = new ObjectMetadata();
            // metadata.setHeader(OSSHeaders.OSS_STORAGE_CLASS, StorageClass.Standard.toString());
            // metadata.setObjectAcl(CannedAccessControlList.Private);
            // putObjectRequest.setMetadata(metadata);

            // 上传字符串。
            PutObjectResult result = ossClient.putObject(putObjectRequest);
            /**
             * 示例中上传的文件地址：https://ali-bucket-space.oss-cn-beijing.aliyuncs.com/dog.jpg
             * 根据这个地址url可以观察到，它是https://+bucketName+区域节点+objectName
             */
            url="https://"+bucketName+"."+endpoint.substring(endpoint.lastIndexOf("/")+1)+"/"+objectName;
        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
        return url;
    }
}

controller调用

package com.wzw.alioss.com.wzw.alioss.controller;

import com.wzw.alioss.com.wzw.alioss.util.AliOssUtil;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.UUID;

@RestController
public class AliOssController {

    /**
     * 上传文件到OSS
     * @param file
     * @return
     * @throws IOException
     */
    @PostMapping("/upload")
    public String uploadFile(MultipartFile file) throws Exception {
        String fileName=file.getOriginalFilename();
        String url = AliOssUtil.uploadFile(UUID.randomUUID()+fileName.substring(fileName.lastIndexOf(".")), file.getInputStream());
        return url;
    }
}

发送postman请求，看到结果也返回了url
在这里插入图片描述
查看bucket，上传成功

整个示例代码：https://gitee.com/w452339689/alioss_test

Oss访问文件

如果是公开的，直接访问固定的url就行，如果是私有的，需要授权

如何保证指定时间段内可以访问私有权限的图片文件？

访问私有云文件url提示如下
在这里插入图片描述
私有云访问也是需要认证的，可以通过文件名授权一个临时的url，在指定的时间内可以访问。

官方文档：https://help.aliyun.com/zh/oss/user-guide/how-to-access-a-private-image-object-within-a-specific-period-of-time?spm=a2c4g.11186623.0.i20
在这里插入图片描述

成功获取，查看能不能访问到，完成
在这里插入图片描述
封装工具类

    /**
     * 阿里云oss生成临时访问路径
     * @param objectName 文件名631ffc15-83d8-478f-95e5-5a8a96afa7d4.png
     */
    public static String getOssUrl(String objectName) {

        String fileUrl="";

        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, ACCESS_KEY_ID,ACCESS_KEY_SECRET);

        try {
            // 设置签名URL过期时间为1天，单位为秒，
            Date expiration = new Date(new Date().getTime() + 3600 * 1000);
            // 生成以GET方法访问的签名URL，在签名URL有效期内访客可以直接通过浏览器访问相关内容。
            URL url = ossClient.generatePresignedUrl(bucketName, objectName, expiration);
            System.out.println(url.toString());
            if(Optional.ofNullable(url).isPresent()) {
                return fileUrl=url.toString();
            }
        } catch (OSSException oe) {
            log.error("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            log.error("Error Message:" + oe.getErrorMessage());
            log.error("Error Code:" + oe.getErrorCode());
            log.error("Request ID:" + oe.getRequestId());
            log.error("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            log.error("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            log.error("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
        return fileUrl;
    }

可能遇到一个问题，访问临时url，提示如下，看信息应该是时间不对，我之前设置的是30天，调整成1天就好了。
在这里插入图片描述

其它

oss客户端，不用登陆网页就能查看存储的文件

网页没权限，想看存储了哪些文件，只要你代码能存文件，肯定就有秘钥，使用秘钥登陆客户端就可以
在这里插入图片描述

浏览器访问图片URL，怎么预览图片

OSS默认的是强制下载，需要绑定自定义域名，才能在浏览器中预览文件。
在这里插入图片描述

更多工具类

package com.kd.common.utils;

import com.alibaba.fastjson2.JSON;
import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.model.*;
import com.kd.common.data.sms.OssRequest;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

@Slf4j
@Component
@ConfigurationProperties(prefix = "aliyun.oss")
@Data
public class AliOssUtil {

    private String endpoint;

    private String accessKeyId;

    private String accessKeySecret;

    private String bucketName;


    private OSS ossClient;


    @PostConstruct
    public void init() {
        this.ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        log.info("OSSClient 初始化成功");
    }

    @PreDestroy
    public void destroy() {
        if (ossClient != null) {
            ossClient.shutdown();
            log.info("OSSClient 关闭成功");
        }
    }

    /**
     * 删除目录
     * @param dirName
     * @param prefix 是否按照前缀删除目录
     * @return
     */
    public boolean rmdir(String dirName,boolean prefix){

        try {
            if(!prefix){
                if(!dirName.endsWith("/")){
                    dirName +="/";
                }
            }
            List<String> keysToDelete = new ArrayList<>();
            ListObjectsRequest listObjectsRequest = new ListObjectsRequest(bucketName)
                    .withPrefix(dirName);
            ObjectListing objectListing;
            do {
                objectListing = ossClient.listObjects(listObjectsRequest);
                for (OSSObjectSummary objectSummary : objectListing.getObjectSummaries()) {
                    keysToDelete.add(objectSummary.getKey());
                }
                listObjectsRequest.setMarker(objectListing.getNextMarker());
            } while (objectListing.isTruncated());

            // 2. 删除这些对象
            if (!keysToDelete.isEmpty()) {
                DeleteObjectsRequest deleteObjectsRequest = new DeleteObjectsRequest(bucketName);
                deleteObjectsRequest.setKeys(keysToDelete);
                ossClient.deleteObjects(deleteObjectsRequest);
                System.out.println("目录及其内容已删除");
            } else {
                System.out.println("目录为空，无需删除");
            }
            return true;
        } catch (OSSException | ClientException e) {
            log.error("删除目录失败: {}, 错误信息: {}", dirName, e.getMessage());
            return false;
        }
    }

    /**
     * 创建目录
     * @param dirName
     * @return
     */
    public boolean mkdir(String dirName){
        try {
            if(!dirName.endsWith("/")){
                dirName +="/";
            }
            ossClient.putObject(bucketName, dirName, new ByteArrayInputStream("".getBytes()));
            return true;
        } catch (OSSException | ClientException e) {
            log.error("创建文件夹失败: {}, 错误信息: {}", dirName, e.getMessage());
            return false;
        }
    }

    /**
     * 文件重命名
     * @param oldName
     * @param newName
     * @return
     */
    public boolean renameFile(String oldName, String newName) {
        try {
            OssRequest request=new OssRequest();
            request.setNewFile(newName);
            request.setSourceFile(oldName);
            copyFile(request);
            ossClient.deleteObject(bucketName, oldName);
            return true;
        } catch (OSSException | ClientException e) {
            log.error("文件重命名失败: {}, 错误信息: {}", oldName, e.getMessage());
            return false;
        }
    }

    /**
     * 判断文件是否存在
     * @param objectName    完整路径
     * @return
     */
    public boolean doesObjectExist(String objectName) {
        try {
            return ossClient.doesObjectExist(bucketName, objectName);
        } catch (OSSException | ClientException e) {
            return false;
        }
    }

    /**
     * 拷贝文件
     * @param request 文件拷贝参数
     */
    public void copyFile(OssRequest request) {

        CopyObjectRequest copyObjectRequest = new CopyObjectRequest(bucketName, request.getSourceFile(), StringUtils.isBlank(request.getNewBucketName())? bucketName : request.getNewBucketName(), StringUtils.isBlank(request.getNewFile())? getCopyFileName(request.getSourceFile()) : request.getNewFile());

        try {
            CopyObjectResult result = ossClient.copyObject(copyObjectRequest);
            log.info("文件拷贝成功: {}", result.getResponse().getStatusCode());
        } catch (OSSException | ClientException e) {
            log.error("文件拷贝失败: {}, 错误信息: {}", request.getSourceFile(), e.getMessage());
        }

    }

    /**
     * 删除单个文件
     * @param objectName OSS 文件绝对路径
     */
    public boolean deleteFile(String objectName) {
        try {
            ossClient.deleteObject(bucketName, objectName);
            log.info("文件删除成功: {}", objectName);
            return true;
        } catch (OSSException | ClientException e) {
            log.error("文件删除失败: {}, 错误信息: {}", objectName, e.getMessage());
            return false;
        }
    }

    /**
     * 批量删除多个文件
     * @param objectNames 要删除的文件列表
     * @return 删除失败的文件列表（如果为空，说明全部删除成功）
     */
    public List<String> deleteFiles(List<String> objectNames) {
        try {
            DeleteObjectsRequest deleteObjectsRequest = new DeleteObjectsRequest(bucketName)
                    .withKeys(objectNames)
                    .withQuiet(false);

            DeleteObjectsResult deleteObjectsResult = ossClient.deleteObjects(deleteObjectsRequest);

            List<String> failedDeletes = objectNames.stream()
                    .filter(name -> !deleteObjectsResult.getDeletedObjects().contains(name))
                    .collect(Collectors.toList());

            if (failedDeletes.isEmpty()) {
                log.info("批量删除成功: {}", objectNames);
            } else {
                log.warn("部分文件删除失败: {}", failedDeletes);
            }
            return failedDeletes;
        } catch (OSSException | ClientException e) {
            log.error("批量删除失败, 错误信息: {}", e.getMessage());
            return objectNames;
        }
    }

    /**
     * 上传文件到OSS
     * @param objectName
     * @param inputStream
     * @return  文件访问地址
     * @throws Exception
     */
    public String uploadFile(String objectName, InputStream inputStream){

        try {

            ObjectMetadata metadata = new ObjectMetadata();
            metadata.setContentType(getContentType(objectName));

            // 创建PutObjectRequest对象。
            PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, objectName, inputStream, metadata);

            // 上传字符串。
            PutObjectResult result = ossClient.putObject(putObjectRequest);

            return "https://"+bucketName+"."+endpoint.substring(endpoint.lastIndexOf("/")+1)+"/"+objectName;
        } catch (RuntimeException oe) {
            log.error("上传失败：{}", JSON.toJSONString(oe));
            throw new RuntimeException("上传失败");
        }finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
    }



    /**
     * 根据文件后缀获取 Content-Type
     */
    private String getContentType(String fileName) {
        if (fileName.endsWith(".png")) return "image/png";
        if (fileName.endsWith(".jpg") || fileName.endsWith(".jpeg")) return "image/jpeg";
        if (fileName.endsWith(".pdf")) return "application/pdf";
        if (fileName.endsWith(".txt")) return "text/plain";
        if (fileName.endsWith(".mp4")) return "video/mp4";
        return "application/octet-stream"; // 默认二进制流
    }

    /**
     * 获取拷贝文件名
     * @param fileName
     * @return
     */
    private String getCopyFileName(String fileName){
        return FilenameUtils.removeExtension(fileName)+"_copy."+FilenameUtils.getExtension(fileName);
    }

}