对象存储OSS

阿里云对象存储OSS（Object Storage Service）是一款海量、安全、低成本、高可靠的云存储服务，提供99.9999999999%(12个9)的数据持久性，99.995%的数据可用性。多种存储类型供选择，全面优化存储成本

产品优势

1.更安全

完善的权限控制与多种加密算法的支持，满足企业数据安全与合规要求

2.更可靠

OSS的多重冗余架构设计，为数据持久存储提供更可靠的保障

3.更稳定

提供高达99.995%的可用性SLA承诺，为客户提供高可用的存储服务

4.更智能

提供数据的生命周期管理与数据的智能处理能力，有效满足企业需求

产品功能

1.数据迁移

支持PB级的在线、离线迁移方案，完成中国互联网首个单客户百PB级数据的迁移上云案例，提供更安全、更快速的海量数据迁移上云方案

2.数据处理

支持图片、文档、视频、CSV等数据的常用处理和分析能力，提供更智能的对象存储

3.数据管理

支持生命周期、镜像回源、更丰富的数据上传与下载方式、事件通知、回调等功能，提供更简单易用、更便于管理的对象存储

4.容灾备份

通过数据跨区域复制以及同城冗余、版本控制等技术，保障数据的高可靠性，防止数据被误删或误覆盖导致的业务损失

5.安全合规

OSS提供多种保证数据安全与合规的技术，包括防盗链、数据存储加密和数据的合规保留策略（WORM）设置等

应用场景

1.数据迁移

阿里云提供了多种数据迁移方式与存储类型，让数据能够快速、安全地迁移至对象存储OSS。与此同时，还提供丰富多样的数据存储类型以及数据管理功能，帮助客户降低存储成本，提高运维效率

2.数据湖

阿里云对象存储OSS打造了云原生的企业级数据湖，作为统一的存储池，不仅可对接多种数据输入方式，还可以存储任意规模的结构化、半结构化、非结构化数据

3.企业数据存储和管理

阿里云对象存储OSS提供多种数据存储类型，包括标准型、低频访问型、归档型以及冷归档型，并结合OSS生命周期管理能力，根据数据的冷热程度进行数据智能分层，提供最具性价比的对象存储服务

4.数据处理

阿里云对象存储OSS提供多种数据处理能力 ，如图片处理、视频截帧、文档预览、图片场景识别、人脸识别、Select查询等，通过简单的 RESTful 接口，可以在任何时间、任何地点、任何互联网设备上对存储在OSS中的数据进行分析处理

5.容灾与备份

阿里云对象存储OSS不仅提供多种冗余能力的存储类型（如同城冗余与本地冗余），同时在数据的跨区域容灾、防止数据误删除等场景下也提供了丰富的产品能力

环境准备

开通对象存储OSS服务

产品地址：https://www.aliyun.com/product/oss

创建Bucket

按需求选择相关配置参数

创建RAM子用户

地址：https://ram.console.aliyun.com/users/new

根据实际需求添加权限

Spring Boot集成阿里云对象存储OSS

开发文档参考：https://help.aliyun.com/document_detail/195870.html

引入依赖

<dependency>
    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-sdk-oss</artifactId>
    <version>3.15.0</version>
</dependency>

配置application.properties

# oss配置
oss.accessKeyId=
oss.accessKeySecret=
oss.endpoint=http://oss-cn-chengdu.aliyuncs.com
oss.domain=http://cj-upload.oss-cn-chengdu.aliyuncs.com/
oss.bucket=cj-upload

参数配置对象

创建Oss参数配置对象，读取配置文件信息，封装到该对象

@Component
//@PropertySource("classpath:application.properties")
public class Oss implements InitializingBean {
    @Value("${oss.accessKeyId}")
    private String accessKeyId;
    @Value("${oss.accessKeySecret}")
    private String accessKeySecret;

    @Value("${oss.endpoint}")
    private String endpoint;
    @Value("${oss.bucket}")
    private String bucket;

    @Value("${oss.domain}")
    private String ossDomain;

    public static String ACCESSKEY_ID;
    public static String ACCESSKEY_SECRET;
    public static String ENDPOINT;
    public static String BUCKET;
    public static String OSSDOMAIN;

    @Override
    public void afterPropertiesSet() {
        ACCESSKEY_ID = accessKeyId;
        ACCESSKEY_SECRET = accessKeySecret;
        ENDPOINT = endpoint;
        BUCKET = bucket;
        OSSDOMAIN = ossDomain;
    }
}

初始化

OSSClient是OSS的Java客户端，用于管理存储空间和文件等OSS资源。使用Java SDK发起OSS请求，需要初始化一个OSSClient实例，并根据需要修改ClientConfiguration的默认配置项

public class AliyunOSSUtils {

    /**
     * 初始化
     * @return
     */
    public static OSS initOSS() {
        // Endpoint以杭州为例，其它Region请按实际情况填写。
        String endpoint = Oss.ENDPOINT;
        // 阿里云主账号AccessKey拥有所有API的访问权限，风险很高。强烈建议您创建并使用RAM账号进行API访问或日常运维，请登录RAM控制台创建RAM账号。
        String accessKeyId = Oss.ACCESSKEY_ID;
        String accessKeySecret = Oss.ACCESSKEY_SECRET;

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

        return ossClient;
    }
}

简单上传

在OSS中，操作的基本数据单元是文件（Object）。OSS Java SDK提供以下几种文件上传方式：

简单上传：包括流式上传和文件上传。最大不能超过5GB。
表单上传：最大不能超过5GB。
追加上传：最大不能超过5GB。
断点续传上传：支持并发、断点续传、自定义分片大小。大文件上传推荐使用断点续传。最大不能超过48.8TB。
分片上传：当文件较大时，可以使用分片上传，最大不能超过48.8TB。

    /**
     * 简单上传-上传文件流
     */
    public static PutObjectResult uploadFile(String filePath, String newFielPath) {
        //指定存储空间（bucketName）
        String bucketName = Oss.BUCKET;
        //初始化
        OSS ossClient = AliyunOSSUtils.initOSS();

        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(filePath);
            //上传文件到指定的存储空间（bucketName）并将其保存为指定的文件名称(user.png)
            PutObjectResult putObjectResult = ossClient.putObject(bucketName, newFielPath, fileInputStream);
            return putObjectResult;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (ossClient != null) {
                // 关闭OSSClient
                ossClient.shutdown();
            }
        }
        return null;
    }

@Test
public  void uploadFile(){
   AliyunOSSUtils.uploadFile("D:\\user\\test.png", LocalDate.now()+"/user.png");
}

下载文件

OSS Java SDK提供丰富的文件下载方式：流式下载、下载到本地文件、范围下载、断点续传下载、限定条件下载

    /**
     * 下载到本地文件
     */
    public static ObjectMetadata downloadFile(String filePath) {
        //指定存储空间（bucketName）
        String bucketName = Oss.BUCKET;
        //初始化
        OSS ossClient = AliyunOSSUtils.initOSS();
        try {
            // 下载Object到本地文件，并保存到指定的本地路径中。如果指定的本地文件存在会覆盖，不存在则新建。
            // 如果未指定本地路径，则下载后的文件默认保存到示例程序所属项目对应本地路径中。
            ObjectMetadata objectMetadata = ossClient.getObject(new GetObjectRequest(bucketName, filePath), new File("D:\\user.jpg"));
            return objectMetadata;
        } catch (ClientException e) {
            e.printStackTrace();
        } finally {
            if (ossClient != null) {
                // 关闭OSSClient
                ossClient.shutdown();
            }
        }
        return null;
    }

    @Test
    public  void downloadFile(){
        AliyunOSSUtils.downloadFile("2022-09-18/user.png");
    }

追加上传

准备test.txt文件

1.hello
2.world
3.ok

准备test2.txt文件

4.hello

5.world

6.ok

/**
     * 追加长传文件
     */
    public static AppendObjectResult appendUpload(String filePath, File file, long position) {
        // 创建ossClient实例
        OSS ossClient = AliyunOSSUtils.initOSS();
        try {
            ObjectMetadata meta = new ObjectMetadata();
            // 指定上传的内容类型
            meta.setContentType("text/plain");
            // 通过AppendObjectRequest设置多个参数。
            AppendObjectRequest appendObjectRequest = new AppendObjectRequest(Oss.BUCKET, filePath, file, meta);

            // 通过AppendObjectRequest设置单个参数。
            // 设置存储空间名称。
            //appendObjectRequest.setBucketName("<yourBucketName>");
            // 设置文件名称。
            //appendObjectRequest.setKey("<yourObjectName>");
            // 设置待追加的内容。有两种可选类型：InputStream类型和File类型。这里为InputStream类型。
            //appendObjectRequest.setInputStream(new ByteArrayInputStream(content1.getBytes()));
            // 设置待追加的内容。有两种可选类型：InputStream类型和File类型。这里为File类型。
            //appendObjectRequest.setFile(new File("<yourLocalFile>"));
            // 指定文件的元信息，第一次追加时有效。
            //appendObjectRequest.setMetadata(meta);

            // 设置文件的追加位置
            appendObjectRequest.setPosition(position);
            AppendObjectResult appendObjectResult = ossClient.appendObject(appendObjectRequest);
            return appendObjectResult;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (ossClient != null) {
                // 关闭OSSClient
                ossClient.shutdown();
            }
        }
        return null;
    }

    @Test
    public void appendUpload() throws IOException {
        File file1=new File("D:\\test1.txt");
        File file2=new File("D:\\test2.txt");
        FileInputStream fileInputStream = new FileInputStream(file1);
        AppendObjectResult appendObjectResult = AliyunOSSUtils.appendUpload(LocalDate.now() + "/test.txt", file1, 0);
        Long nextPosition = appendObjectResult.getNextPosition();
        AliyunOSSUtils.appendUpload(LocalDate.now() + "/test.txt", file2, nextPosition);
    }

访问https://oss.console.aliyun.com/bucket/，下载文件查看

断点续传

    /**
     * 断点续传
     */
    public static UploadFileResult breakpointSequel(String filePath, String localFilePath) {
        // 创建ossClient实例
        OSS ossClient = AliyunOSSUtils.initOSS();
        try {
            ObjectMetadata meta = new ObjectMetadata();
            // 指定上传的内容类型。
            meta.setContentType("text/plain");
            // 文件上传时设置访问权限ACL。
            // meta.setObjectAcl(CannedAccessControlList.Private);

            // 通过UploadFileRequest设置多个参数。
            // 依次填写Bucket名称（例如examplebucket）以及Object完整路径（例如exampledir/exampleobject.txt），Object完整路径中不能包含Bucket名称。
            UploadFileRequest uploadFileRequest = new UploadFileRequest(Oss.BUCKET, filePath);

            // 通过UploadFileRequest设置单个参数。
            // 填写本地文件的完整路径，例如D:\\localpath\\examplefile.txt。如果未指定本地路径，则默认从示例程序所属项目对应本地路径中上传文件。
            uploadFileRequest.setUploadFile(localFilePath);
            // 指定上传并发线程数，默认值为1。
            uploadFileRequest.setTaskNum(2);
            // 指定上传的分片大小，单位为字节，取值范围为100 KB~5 GB。默认值为100 KB。
//            uploadFileRequest.setPartSize(1 * 1024 * 1024);
            // 开启断点续传，默认关闭。
            uploadFileRequest.setEnableCheckpoint(true);
            // 记录本地分片上传结果的文件。上传过程中的进度信息会保存在该文件中，如果某一分片上传失败，再次上传时会根据文件中记录的点继续上传。上传完成后，该文件会被删除。
            // 如果未设置该值，默认与待上传的本地文件同路径，名称为${uploadFile}.ucp。
//            uploadFileRequest.setCheckpointFile("yourCheckpointFile");
            // 文件的元数据。
            uploadFileRequest.setObjectMetadata(meta);
            // 设置上传回调，参数为Callback类型。
            //uploadFileRequest.setCallback("yourCallbackEvent");

            // 断点续传上传。
            UploadFileResult uploadFileResult = ossClient.uploadFile(uploadFileRequest);
            return uploadFileResult;
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            // 关闭OSSClient。
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
        return null;
    }

   @Test
    public void breakpointSequel() {
        AliyunOSSUtils.breakpointSequel(LocalDate.now() + "/test.mp4","D:\\test.mp4");
    }

在测试上传过程中，中断上传，返回本地路径查看，发现生成后缀.ucp的进度信息记录文件

分片上传

/**
     * 分片上传
     */
    public static CompleteMultipartUploadResult partialUpload(String objectName, String localFilePath) {
        // 创建ossClient实例
        OSS ossClient = AliyunOSSUtils.initOSS();
        try {
            // 创建InitiateMultipartUploadRequest对象。
            InitiateMultipartUploadRequest request = new InitiateMultipartUploadRequest(Oss.BUCKET, objectName);

            // 如果需要在初始化分片时设置请求头，请参考以下示例代码。
            // ObjectMetadata metadata = new ObjectMetadata();
            // metadata.setHeader(OSSHeaders.OSS_STORAGE_CLASS, StorageClass.Standard.toString());
            // 指定该Object的网页缓存行为。
            // metadata.setCacheControl("no-cache");
            // 指定该Object被下载时的名称。
            // metadata.setContentDisposition("attachment;filename=oss_MultipartUpload.txt");
            // 指定该Object的内容编码格式。
            // metadata.setContentEncoding(OSSConstants.DEFAULT_CHARSET_NAME);
            // 指定初始化分片上传时是否覆盖同名Object。此处设置为true，表示禁止覆盖同名Object。
            // metadata.setHeader("x-oss-forbid-overwrite", "true");
            // 指定上传该Object的每个part时使用的服务器端加密方式。
            // metadata.setHeader(OSSHeaders.OSS_SERVER_SIDE_ENCRYPTION, ObjectMetadata.KMS_SERVER_SIDE_ENCRYPTION);
            // 指定Object的加密算法。如果未指定此选项，表明Object使用AES256加密算法。
            // metadata.setHeader(OSSHeaders.OSS_SERVER_SIDE_DATA_ENCRYPTION, ObjectMetadata.KMS_SERVER_SIDE_ENCRYPTION);
            // 指定KMS托管的用户主密钥。
            // metadata.setHeader(OSSHeaders.OSS_SERVER_SIDE_ENCRYPTION_KEY_ID, "9468da86-3509-4f8d-a61e-6eab1eac****");
            // 指定Object的存储类型。
            // metadata.setHeader(OSSHeaders.OSS_STORAGE_CLASS, StorageClass.Standard);
            // 指定Object的对象标签，可同时设置多个标签。
            // metadata.setHeader(OSSHeaders.OSS_TAGGING, "a:1");
            // request.setObjectMetadata(metadata);

            // 初始化分片。
            InitiateMultipartUploadResult upresult = ossClient.initiateMultipartUpload(request);
            // 返回uploadId，它是分片上传事件的唯一标识。您可以根据该uploadId发起相关的操作，例如取消分片上传、查询分片上传等。
            String uploadId = upresult.getUploadId();

            // partETags是PartETag的集合。PartETag由分片的ETag和分片号组成。
            List<PartETag> partETags = new ArrayList<PartETag>();
            // 每个分片的大小，用于计算文件有多少个分片。单位为字节。
            final long partSize = 1 * 1024 * 1024L;   //1 MB。

            // 填写本地文件的完整路径。如果未指定本地路径，则默认从示例程序所属项目对应本地路径中上传文件。
            final File sampleFile = new File(localFilePath);
            long fileLength = sampleFile.length();
            int partCount = (int) (fileLength / partSize);
            if (fileLength % partSize != 0) {
                partCount++;
            }
            // 遍历分片上传。
            for (int i = 0; i < partCount; i++) {
                log.info("开始上传分片：{}", (i + 1));
                long startPos = i * partSize;
                long curPartSize = (i + 1 == partCount) ? (fileLength - startPos) : partSize;
                InputStream instream = new FileInputStream(sampleFile);
                // 跳过已经上传的分片。
                instream.skip(startPos);
                UploadPartRequest uploadPartRequest = new UploadPartRequest();
                uploadPartRequest.setBucketName(Oss.BUCKET);
                uploadPartRequest.setKey(objectName);
                uploadPartRequest.setUploadId(uploadId);
                uploadPartRequest.setInputStream(instream);
                // 设置分片大小。除了最后一个分片没有大小限制，其他的分片最小为100 KB。
                uploadPartRequest.setPartSize(curPartSize);
                // 设置分片号。每一个上传的分片都有一个分片号，取值范围是1~10000，如果超出此范围，OSS将返回InvalidArgument错误码。
                uploadPartRequest.setPartNumber(i + 1);
                // 每个分片不需要按顺序上传，甚至可以在不同客户端上传，OSS会按照分片号排序组成完整的文件。
                UploadPartResult uploadPartResult = ossClient.uploadPart(uploadPartRequest);
                // 每次上传分片之后，OSS的返回结果包含PartETag。PartETag将被保存在partETags中。
                partETags.add(uploadPartResult.getPartETag());
            }


            // 创建CompleteMultipartUploadRequest对象。
            // 在执行完成分片上传操作时，需要提供所有有效的partETags。OSS收到提交的partETags后，会逐一验证每个分片的有效性。当所有的数据分片验证通过后，OSS将把这些分片组合成一个完整的文件。
            CompleteMultipartUploadRequest completeMultipartUploadRequest = new CompleteMultipartUploadRequest(Oss.BUCKET, objectName, uploadId, partETags);

            // 如果需要在完成分片上传的同时设置文件访问权限，请参考以下示例代码。
            // completeMultipartUploadRequest.setObjectACL(CannedAccessControlList.Private);
            // 指定是否列举当前UploadId已上传的所有Part。如果通过服务端List分片数据来合并完整文件时，以上CompleteMultipartUploadRequest中的partETags可为null。
            // Map<String, String> headers = new HashMap<String, String>();
            // 如果指定了x-oss-complete-all:yes，则OSS会列举当前UploadId已上传的所有Part，然后按照PartNumber的序号排序并执行CompleteMultipartUpload操作。
            // 如果指定了x-oss-complete-all:yes，则不允许继续指定body，否则报错。
            // headers.put("x-oss-complete-all","yes");
            // completeMultipartUploadRequest.setHeaders(headers);

            // 完成分片上传。
            CompleteMultipartUploadResult completeMultipartUploadResult = ossClient.completeMultipartUpload(completeMultipartUploadRequest);
            System.out.println(completeMultipartUploadResult.getETag());
            return completeMultipartUploadResult;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
        return null;
    }

    @Test
    public void partialUpload() {
        AliyunOSSUtils.partialUpload(LocalDate.now() + "/test.mp4","D:\\test.mp4");
    }

INFO 39640 --- [           main] com.example.demo.utils.AliyunOSSUtils    : 开始上传分片：1
INFO 39640 --- [           main] com.example.demo.utils.AliyunOSSUtils    : 开始上传分片：2
INFO 39640 --- [           main] com.example.demo.utils.AliyunOSSUtils    : 开始上传分片：3
67483CC314CF06A4879847F60C0059DA-3

文件管理

1.判断文件是否存在

// 判断文件是否存在。doesObjectExist还有一个参数isOnlyInOSS，如果为true则忽略302重定向或镜像；如果
为false，则考虑302重定向或镜像。
boolean found = ossClient.doesObjectExist("<yourBucketName>", "<yourObjectName>");

2.管理文件访问权限

文件的访问权限优先级高于存储空间的访问权限。文件的访问权限有以下四种

设置文件访问权限

// 设置文件的访问权限为公共读。
ossClient.setObjectAcl("<yourBucketName>", "<yourObjectName>", CannedAccessControlList.PublicRead);

获取文件访问权限

// 获取文件的访问权限。
ObjectAcl objectAcl = ossClient.getObjectAcl("<yourBucketName>", "<yourObjectName>");
System.out.println(objectAcl.getPermission().toString());

3.删除文件

删除单个文件

// 删除文件。如需删除文件夹，请将ObjectName设置为对应的文件夹名称。如果文件夹非空，则需要将文件夹下的所有object删除后才能删除该文件夹。
ossClient.deleteObject(bucketName, objectName);

删除多个文件

每次最多删除1000个文件。有两种返回模式：

详细（verbose）模式：返回删除成功的文件列表。默认为详细模式。

简单（quiet）模式：返回删除失败的文件列表。

DeleteObjectsRequest的参数如下：

// 删除文件。key等同于ObjectName，表示删除OSS文件时需要指定包含文件后缀在内的完整路径，例如abc/efg/123.jpg。
List<String> keys = new ArrayList<String>();
keys.add("key0");
keys.add("key1");
keys.add("key2");

DeleteObjectsResult deleteObjectsResult = ossClient.deleteObjects(new DeleteObjectsRequest(bucketName).withKeys(keys));
List<String> deletedObjects = deleteObjectsResult.getDeletedObjects();

完整AliyunOSSUtils

import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.model.*;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class AliyunOSSUtils {

    /**
     * 初始化
     *
     * @return
     */
    public static OSS initOSS() {
        // Endpoint以杭州为例，其它Region请按实际情况填写。
        String endpoint = Oss.ENDPOINT;
        // 阿里云主账号AccessKey拥有所有API的访问权限，风险很高。强烈建议您创建并使用RAM账号进行API访问或日常运维，请登录RAM控制台创建RAM账号。
        String accessKeyId = Oss.ACCESSKEY_ID;
        String accessKeySecret = Oss.ACCESSKEY_SECRET;

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

        return ossClient;
    }


    /**
     * 文件上传
     *
     * @param filePath
     * @param newFielPath
     * @return
     */
    public static PutObjectResult uploadFile(String filePath, String newFielPath) {
        //指定存储空间（bucketName）
        String bucketName = Oss.BUCKET;
        //初始化
        OSS ossClient = AliyunOSSUtils.initOSS();

        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(filePath);
            //上传文件到指定的存储空间（bucketName）并将其保存为指定的文件名称(user.png)
            PutObjectResult putObjectResult = ossClient.putObject(bucketName, newFielPath, fileInputStream);
            return putObjectResult;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (ossClient != null) {
                // 关闭OSSClient
                ossClient.shutdown();
            }
        }
        return null;
    }


    /**
     * 下载到本地文件
     */
    public static ObjectMetadata downloadFile(String filePath) {
        //指定存储空间（bucketName）
        String bucketName = Oss.BUCKET;
        //初始化
        OSS ossClient = AliyunOSSUtils.initOSS();
        try {
            // 下载Object到本地文件，并保存到指定的本地路径中。如果指定的本地文件存在会覆盖，不存在则新建。
            // 如果未指定本地路径，则下载后的文件默认保存到示例程序所属项目对应本地路径中。
            ObjectMetadata objectMetadata = ossClient.getObject(new GetObjectRequest(bucketName, filePath), new File("D:\\user.jpg"));
            return objectMetadata;
        } catch (ClientException e) {
            e.printStackTrace();
        } finally {
            if (ossClient != null) {
                // 关闭OSSClient
                ossClient.shutdown();
            }
        }
        return null;
    }

    /**
     * 追加长传文件
     */
    public static AppendObjectResult appendUpload(String filePath, File file, long position) {
        // 创建ossClient实例
        OSS ossClient = AliyunOSSUtils.initOSS();
        try {
            ObjectMetadata meta = new ObjectMetadata();
            // 指定上传的内容类型
            meta.setContentType("text/plain");
            // 通过AppendObjectRequest设置多个参数。
            AppendObjectRequest appendObjectRequest = new AppendObjectRequest(Oss.BUCKET, filePath, file, meta);

            // 通过AppendObjectRequest设置单个参数。
            // 设置存储空间名称。
            //appendObjectRequest.setBucketName("<yourBucketName>");
            // 设置文件名称。
            //appendObjectRequest.setKey("<yourObjectName>");
            // 设置待追加的内容。有两种可选类型：InputStream类型和File类型。这里为InputStream类型。
            //appendObjectRequest.setInputStream(new ByteArrayInputStream(content1.getBytes()));
            // 设置待追加的内容。有两种可选类型：InputStream类型和File类型。这里为File类型。
            //appendObjectRequest.setFile(new File("<yourLocalFile>"));
            // 指定文件的元信息，第一次追加时有效。
            //appendObjectRequest.setMetadata(meta);

            // 设置文件的追加位置
            appendObjectRequest.setPosition(position);
            AppendObjectResult appendObjectResult = ossClient.appendObject(appendObjectRequest);
            return appendObjectResult;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (ossClient != null) {
                // 关闭OSSClient
                ossClient.shutdown();
            }
        }
        return null;
    }

}