文件管理

    BOS GO SDK提供了丰富的文件上传接口，可以通过以下方式上传文件：

    • 简单上传
    • 追加上传
    • 抓取上传
    • 分块上传

    BOS在简单上传的场景中，支持以指定文件形式、以数据流方式、以二进制串方式、以字符串方式执行Object上传，请参考如下代码：

    Object以文件的形式上传到BOS中，上述简单上传的接口支持不超过5GB的Object上传。在请求处理成功后，BOS会在Header中返回Object的ETag作为文件标识。

    设置文件元信息

    文件元信息(Object Meta)，是对用户在向BOS上传文件时，同时对文件进行的属性描述，主要分为分为两种：设置HTTP标准属性（HTTP Headers）和用户自定义的元信息。

    设定Object的Http Header

    BOS GO SDK本质上是调用后台的HTTP接口，因此用户可以在上传文件时自定义Object的Http Header。常用的http header说明如下：

    参考代码如下：

    3. args := new(api.PutObjectArgs)
    5. // 设置上传内容的MIME类型
    6. args.ContentType = "text/javascript"
    8. // 设置上传内容的长度
    9. args.ContentLength = 1024
    11. // 设置缓存过期时间
    12. args.Expires = "Mon, 19 Mar 2018 11:55:32 GMT"
    14. // 设置缓存行为
    15. args.CacheControl = "max-age=3600"
    17. etag, err := bosClient.PutObject(bucketName, objectName, bodyStream, args)

    用户自定义元信息

    BOS支持用户自定义元数据来对Object进行描述。如下代码所示：

    1. // import "github.com/baidubce/bce-sdk-go/services/bos/api"
    3. args := new(api.PutObjectArgs)
    5. // 设置用户自定义元数据
    6. args.UserMeta = map[string]string{
    7.     "name1": "my-metadata1",
    8.     "name2": "my-metadata2",
    9. }
    11. etag, err := bosClient.PutObject(bucketName, objectName, bodyStream, args)
    提示： - 在上面代码中，用户自定义了一个名字为“name1”和“name2”，值分别为“my-metadata1”和“my-metadata2”的元数据 - 当用户下载此Object的时候，此元数据也可以一并得到 - 一个Object可以有多个类似的参数，但所有的User Meta总大小不能超过2KB

    上传Object时设置存储类型

    BOS支持标准存储、低频存储和冷存储，上传Object并存储为低频存储类型通过指定StorageClass实现，三种存储类型对应的参数如下：

    以低频存储为例，代码如下：

    1. // import "github.com/baidubce/bce-sdk-go/services/bos/api"
    3. args := new(api.PutObjectArgs)
    4. args.StorageClass = api.STORAGE_CLASS_STANDARD_IA
    5. etag, err := bosClient.PutObject(bucketName, objectName, bodyStream, args)

    追加上传

    上文介绍的简单上传方式，创建的Object都是Normal类型，用户不可再进行追加写，这在日志、视频监控、视频直播等数据复写较频繁的场景中使用不方便。

    正因如此，百度云BOS特别支持了AppendObject，即以追加写的方式上传文件。通过AppendObject操作创建的Object类型为Appendable Object，可以对该Object追加数据。AppendObject大小限制为0~5G。当您的网络情况较差时，推荐使用AppendObject的方式进行上传，每次追加较小数据（如256kb）。

    通过AppendObject方式上传示例代码如下：

    1. // import "github.com/baidubce/bce-sdk-go/services/bos/api"
    3. args := new(api.AppendObjectArgs)
    5. // 1. 原始接口上传，设置为低频存储，设置追加的偏移位置
    6. args.StorageClass = api.STORAGE_CLASS_STANDARD_IA
    7. args.Offset = 1024
    8. res, err := bosClient.AppendObject(bucketName, objectName, bodyStream, args)
    10. // 2. 封装的简单接口，仅支持设置offset
    11. res, err := bosClient.SimpleAppendObject(bucketName, objectName, bodyStream, offset)
    13. // 3. 封装的从字符串上传接口，仅支持设置offset
    14. res, err := bosClient.SimpleAppendObjectFromString(bucketName, objectName, "abc", offset)
    16. // 4. 封装的从给出的文件名上传文件的接口，仅支持设置offset
    17. res, err := bosClient.SimpleAppendObjectFromFile(bucketName, objectName, "<path-to-local-file>", offset)
    19. fmt.Println(res.ETag)             // 打印ETag
    20. fmt.Println(res.ContentMD5)       // 打印ContentMD5
    21. fmt.Println(res.NextAppendOffset) // 打印NextAppendOffset

    抓取上传

    BOS支持用户提供的url自动抓取相关内容并保存为指定Bucket的指定名称的Object。

    1. // import "github.com/baidubce/bce-sdk-go/services/bos/api"
    3. args := new(api.FetchObjectArgs)
    5. // 1. 原始接口抓取，设置为异步抓取模式
    6. args.FetchMode = api.FETCH_MODE_ASYNC
    7. res, err := bosClient.FetchObject(bucket, object, url, args)
    9. // 2. 基本抓取接口，默认为同步抓取模式
    10. res, err := bosClient.BasicFetchObject(bucket, object, url)
    12. // 3. 易用接口，直接指定可选参数
    13. res, err := bosClient.SimpleFetchObject(bucket, object, url,
    14.     api.FETCH_MODE_ASYNC, api.STORAGE_CLASS_STANDARD_IA)
    16. fmt.Println(res.ETag) // 打印ETag

    分块上传

    除了通过简单上传及追加上传方式将文上传件到BOS以外，BOS还提供了另外一种上传模式 —— Multipart Upload。用户可以在如下的应用场景内（但不仅限于此），使用Multipart Upload上传模式，如：

    • 需要支持断点上传。
    • 上传超过5GB大小的文件。
    • 网络条件较差，和BOS的服务器之间的连接经常断开。
    • 需要流式地上传文件。

    • 上传文件之前，无法确定上传文件的大小。
      BOS GO SDK提供了分块操作的控制参数：

    • MultipartSize：每个分块的大小，默认为10MB，最小不得低于5MB

    • MaxParallel：分块操作的并发数，默认为10
      下面的示例代码设置了分块的大小为20MB，并发数为100：
    1. // import "github.com/baidubce/bce-sdk-go/services/bos"
    3. client := bos.NewClient(<your-ak>, <your-sk>, <endpoint>)
    4. client.MultipartSize = 20 * (1 << 10)
    5. client.MaxParallel = 100

    除了上述参数外，还会对设置的每个分块数进行1MB对齐，同时限制是最大分块数目不得超过10000，如果分块较小导致分块数超过这个上限会自动调整分块大小。

    下面将一步步介绍Multipart Upload的实现。假设有一个文件，本地路径为 /path/to/file.zip，由于文件比较大，将其分块传输到BOS中。

    初始化Multipart Upload

    使用BasicInitiateMultipartUpload方法来初始化一个基本的分块上传事件：

    1. res, err := bosClient.BasicInitiateMultipartUpload(bucketName, objectKey)
    2. fmt.Println(res.UploadId) // 打印初始化分块上传后获取的UploadId

    返回结果中含有 UploadId ，它是区分分块上传事件的唯一标识，在后面的操作中，我们将用到它。

    上传低频存储类型Object的初始化

    BOS GO SDK提供的InitiateMultipartUpload接口可以设置其他分块上传的相关参数，下面的代码初始化了低频存储的一个分块上传事件：

    1. // import "github.com/baidubce/bce-sdk-go/services/bos/api"
    3. args := new(api.InitiateMultipartUploadArgs)
    4. args.StorageClass = api.STORAGE_CLASS_STANDARD_IA
    5. res, err := bosClient.InitiateMultipartUpload(bucketName, objectKey, contentType, args)
    6. fmt.Println(res.UploadId) // 打印初始化分块上传后获取的UploadId

    上传冷存储类型Object的初始化

    初始化低频存储的一个分块上传事件：

    1. // import "github.com/baidubce/bce-sdk-go/services/bos/api"
    3. args := new(api.InitiateMultipartUploadArgs)
    4. args.StorageClass = api.STORAGE_CLASS_COLD
    5. res, err := bosClient.InitiateMultipartUpload(bucketName, objectKey, contentType, args)
    6. fmt.Println(res.UploadId) // 打印初始化分块上传后获取的UploadId

    上传分块

    1. // import "github.com/baidubce/bce-sdk-go/bce"
    2. // import "github.com/baidubce/bce-sdk-go/services/bos"
    3. // import "github.com/baidubce/bce-sdk-go/services/bos/api"
    5. file, _ := os.Open("/path/to/file.zip")
    7. // 分块大小按MULTIPART_ALIGN=1MB对齐
    8. partSize := (bosClient.MultipartSize +
    9.     bos.MULTIPART_ALIGN - 1) / bos.MULTIPART_ALIGN * bos.MULTIPART_ALIGN
    11. // 获取文件大小，并计算分块数目，最大分块数MAX_PART_NUMBER=10000
    12. fileInfo, _ := file.Stat()
    13. fileSize := fileInfo.Size()
    14. partNum := (fileSize + partSize - 1) / partSize
    15. if partNum > bos.MAX_PART_NUMBER { // 超过最大分块数，需调整分块大小
    16.     partSize = (fileSize + bos.MAX_PART_NUMBER + 1) / bos.MAX_PART_NUMBER
    17.     partSize = (partSize + bos.MULTIPART_ALIGN - 1) / bos.MULTIPART_ALIGN * bos.MULTIPART_ALIGN
    18.     partNum = (fileSize + partSize - 1) / partSize
    19. }
    21. // 创建保存每个分块上传后的ETag和PartNumber信息的列表
    22. partEtags := make([]api.UploadInfoType)
    24. // 逐个分块上传
    25. for i := int64(1); i <= partNum; i++  {
    26.     // 计算偏移offset和本次上传的大小uploadSize
    27.     uploadSize := partSize
    28.     offset := partSize * (i - 1)
    29.     if left < partSize {
    30.         uploadSize = left
    31.     }
    33.     // 创建指定偏移、指定大小的文件流
    34.     partBody, _ := bce.NewBodyFromSectionFile(file, offset, uploadSize)
    36.     // 上传当前分块
    37.     etag, err := bosClient.BasicUploadPart(bucketName, objectKey, uploadId, int(i), partBody)
    39.     // 保存当前分块上传成功后返回的序号和ETag
    40.     partEtags = append(partEtags, api.UploadInfoType{int(partNum), etag})
    41. }

    上面代码的核心是调用 BasicUploadPart 方法来上传每一个分块，但是要注意以下几点：

    • BasicUploadPart 方法要求除最后一个Part以外，其他的Part大小都要大于等于5MB。但是该接口并不会立即校验上传Part的大小；只有当Complete Multipart Upload的时候才会校验。
    • 为了保证数据在网络传输过程中不出现错误，建议您在BasicUploadPart后，使用每个分块BOS返回的Content-MD5值分别验证已上传分块数据的正确性。当所有分块数据合成一个Object后，不再含MD5值。
    • Part号码的范围是1~10000。如果超出这个范围，BOS将返回InvalidArgument的错误码。
    • 每次上传Part之后，BOS的返回结果会包含一个 PartETag对象，它是上传块的ETag与块编号（PartNumber）的组合，在后续完成分块上传的步骤中会用到它，因此需要将其保存起来。一般来讲这些PartETag 对象将被保存到List中。
      完成分块上传

    如下代码所示，完成分块上传：

    1. // import "github.com/baidubce/bce-sdk-go/services/bos/api"
    3. completeArgs := &api.CompleteMultipartUploadArgs{partEtags}
    4. res, _ := bosClient.CompleteMultipartUploadFromStruct(
    5.     bucketName, objectKey, uploadId, completeArgs, nil)
    7. // 输出结果对象的内容
    8. fmt.Println(res.Location)
    9. fmt.Println(res.Bucket)
    10. fmt.Println(res.Key)
    11. fmt.Println(res.ETag)

    上面代码中的 partETags是第二部中保存的partETag的列表，BOS收到用户提交的Part列表后，会逐一验证每个数据Part的有效性。当所有的数据Part验证通过后，BOS将把这些数据part组合成一个完整的Object。

    取消分块上传

    用户可以使用abortMultipartUpload方法取消分块上传。

    1. bosClient.AbortMultipartUpload(bucketName, objectKey, uploadId)

    获取未完成的分块上传

    用户可以使用 方法获取Bucket内未完成的分块上传事件。

    1. // 列出给定bucket下所有未完成的分块信息
    2. res, err := BasicListMultipartUploads(bucketName)
    4. // 输出返回结果状态信息
    5. fmt.Println(res.Bucket)
    6. fmt.Println(res.Delimiter)
    7. fmt.Println(res.Prefix)
    8. fmt.Println(res.IsTruncated)
    9. fmt.Println(res.KeyMarker)
    10. fmt.Println(res.NextKeyMarker)
    11. fmt.Println(res.MaxUploads)
    13. // 遍历所有未完成分块信息列表
    14. for _, multipartUpload := range res.Uploads {
    15.     fmt.Println("Key:", multipartUpload.Key, ", UploadId:", multipartUpload.UploadId)
    16. }
    注意： - 默认情况下，如果Bucket中的分块上传事件的数目大于1000，则只会返回1000个Object，并且返回结果中IsTruncated的值为True，同时返回NextKeyMarker作为下次读取的起点。 - 若想返回更多分块上传事件的数目，可以使用KeyMarker参数分次读取。

    获取所有已上传的块信息

    用户可以使用 ListParts 方法获取某个上传事件中所有已上传的块。

    上述示例是使用API依次实现，没有并发执行，如果需要加快速度需要用户实现并发上传的部分。为了方便用户使用，BOS Client特封装了分块上传的并发接口UploadSuperFile：

    • 接口：UploadSuperFile(bucket, object, fileName, storageClass string) error
    • 参数:
      • bucket: 上传对象的bucket的名称
      • object: 上传对象的名称
      • fileName: 本地文件名称
      • storageClass: 上传对象的存储类型，默认标准存储
    • 返回值:
      • error: 上传过程中的错误，成功则为空
        用户只需给出bucket、object、filename即可并发的进行分块上传，同时也可指定上传对象的storageClass。

    下载文件

    BOS GO SDK提供了丰富的文件下载接口，用户可以通过以下方式从BOS中下载文件：

    • 简单流式下载
    • 下载到本地文件
    • 范围下载

    简单流式下载

    用户可以通过如下代码将Object读取到一个流中：

    1. // 提供Bucket和Object，直接获取一个对象
    2. res, err := bosClient.BasicGetObject(bucketName, objectName)
    4. // 获取ObjectMeta
    5. meta := res.ObjectMeta
    7. // 获取Object的读取流（io.ReadCloser）
    8. stream := res.Body
    10. // 确保关闭Object读取流
    11. defer stream.Close()
    13. // 调用stream对象的Read方法处理Object
    14. ...
    注意： - 上述接口的返回结果对象中包含了Object的各种信息，包含Object所在的Bucket、Object的名称、MetaData以及一个读取流。 - 可通过结果对象的ObjectMeta字段获取对象的元数据，它包含了Object上传时定义的ETag，Http Header以及自定义的元数据。 - 可通过结果对象的Body字段获取返回Object的读取流，通过操作读取流将Object的内容读取到文件或者内存中或进行其他操作。

    下载到本地文件

    用户可以通过如下代码直接将Object下载到指定文件：

    1. err := bosClient.BasicGetObjectToFile(bucketName, objectName, "path-to-local-file")

    为了实现更多的功能，可以指定下载范围、返回header来实现更精细化地获取Object。如果指定的下载范围是0 - 100，则返回第0到第100个字节的数据，包括第100个，共101字节的数据，即[0, 100]。

    1. // 指定范围起始位置和返回header
    2. responseHeaders := map[string]string{"ContentType": "image/gif"}
    3. rangeStart = 1024
    4. rangeEnd = 2048
    5. res, err := bosClient.GetObject(bucketName, objectName, responseHeaders, rangeStart, rangeEnd)
    7. // 只指定起始位置start
    8. res, err := bosClient.GetObject(bucketName, objectName, responseHeaders, rangeStart)
    10. // 不指定range
    11. res, err := bosClient.GetObject(bucketName, objectName, responseHeaders)
    13. // 不指定返回可选头部
    14. res, err := bosClient.GetObject(bucketName, objectName, nil)

    基于范围下载接口，用户可以据此实现文件的分段下载和断点续传。为了方便用户使用，BOS GO SDK封装了并发下载的接口DownloadSuperFile：

    • 接口：DownloadSuperFile(bucket, object, fileName string) error
    • 参数:
      • bucket: 下载对象所在bucket的名称
      • object: 下载对象的名称
      • fileName: 该对象保存到本地的文件名称
    • 返回值:
      • error: 下载过程中的错误，成功则为空
        该接口利用并发控制参数执行并发范围下载，直接下载到用户指定的文件中。

    其他使用方法

    获取Object的存储类型

    Object的storage class属性分为STANDARD(标准存储)、STANDARD_IA(低频存储)和COLD(冷存储)，通过如下代码可以实现：

    1. res, err := bosClient.GetObjectMeta(bucketName, objectName)
    2. fmt.Println(res.StorageClass)

    只获取Object Metadata

    通过GetObjectMeta方法可以只获取Object Metadata而不获取Object的实体。如下代码所示：

    1. res, err := bosClient.GetObjectMeta(bucketName, objectName)
    2. fmt.Printf("Metadata: %+v\n", res)

    获取文件下载URL

    用户可以通过如下代码获取指定Object的URL：

    1. // 1. 原始接口，可设置bucket、object名称，过期时间、请求方法、请求头和请求参数
    2. url := bosClient.GeneratePresignedUrl(bucketName, objectName,
    3.         expirationInSeconds, method, headers, params)
    5. // 2. 基本接口，默认为`GET`方法，仅需设置过期时间
    6. url := bosClient.BasicGeneratePresignedUrl(bucketName, objectName, expirationInSeconds)
    说明： - 用户在调用该函数前，需要手动设置endpoint为所属区域域名。百度云目前开放了多区域支持，请参考区域选择说明。目前支持“华北-北京”、“华南-广州”和“华东-苏州”三个区域。北京区域：，广州区域：http://gz.bcebos.com，苏州区域：。 - expirationInSeconds为指定的URL有效时长，时间从当前时间算起，为可选参数，不配置时系统默认值为1800秒。如果要设置为永久不失效的时间，可以将expirationInSeconds参数设置为-1，不可设置为其他负数。 - 如果预期获取的文件时公共可读的，则对应URL链接可通过简单规则快速拼接获取: http://{$bucketName}.{$region}.bcebos.com/{$objectName}。

    BOS GO SDK支持用户通过以下两种方式列举出object：

    • 简单列举
    • 通过参数复杂列举
      除此之外，用户还可在列出文件的同时模拟文件夹。

    简单列举

    当用户希望简单快速列举出所需的文件时，可通过ListObjects方法返回ListObjectsResult对象，ListObjectsResult对象包含了此次请求的返回结果。用户可以从ListObjectsResult对象的Contents字段获取Object的所有描述信息。

    1. listObjectResult, err := bosClient.ListObjects(bucketName, nil)
    3. // 打印当前ListObjects请求的状态结果
    4. fmt.Println("Name:", listObjectResult.Name)
    5. fmt.Println("Prefix:", listObjectResult.Prefix)
    6. fmt.Println("Delimiter:", listObjectResult.Delimiter)
    7. fmt.Println("Marker:", listObjectResult.Marker)
    8. fmt.Println("NextMarker:", listObjectResult.NextMarker)
    9. fmt.Println("MaxKeys:", listObjectResult.MaxKeys)
    10. fmt.Println("IsTruncated:", listObjectResult.IsTruncated)
    12. // 打印Contents字段的具体结果
    13. for _, obj := range listObjectResult.Contents {
    14.     fmt.Println("Key:", obj.Key, ", ETag:", obj.ETag, ", Size:", obj.Size,
    15.         ", LastModified:", obj.LastModified, ", StorageClass:", obj.StorageClass)
    16. }

    通过参数复杂列举

    除上述简单列举外，用户还可通过设置ListObjectsArgs参数实现各种灵活的查询功能。ListObjectsArgs可设置的参数如下：

    注意： - 如果有Object以Prefix命名，当仅使用Prefix查询时，返回的所有Key中仍会包含以Prefix命名的Object，详见。 - 如果有Object以Prefix命名，当使用Prefix和Delimiter组合查询时，返回的所有Key中会有Null，Key的名字不包含Prefix前缀，详见查看目录下的文件和子目录。

    下面我们分别以几个案例说明通过参数列举的方法：

    1. // import "github.com/baidubce/bce-sdk-go/services/bos/api"
    3. args := new(api.ListObjectsArgs)
    5. // 指定最大返回参数为500
    6. args.MaxKeys = 500
    8. // 指定满足特定前缀
    9. args.Prefix = "my-prefix/"
    11. // 指定分隔符，实现类似文件夹的功能
    12. args.Delimiter = "/"
    14. // 设置特定Object之后的排序结果
    15. args.Marker = "bucket/object-0"
    17. listObjectResult, err := bosClient.ListObjects(bucketName, args)

    模拟文件夹功能

    在BOS的存储结果中是没有文件夹这个概念的，所有元素都是以Object来存储，但BOS的用户在使用数据时往往需要以文件夹来管理文件。因此，BOS提供了创建模拟文件夹的能力，其本质上来说是创建了一个size为0的Object。对于这个Object可以上传下载，只是控制台会对以“/”结尾的Object以文件夹的方式展示。

    用户可以通过Delimiter和Prefix参数的配合模拟出文件夹功能。Delimiter和Prefix的组合效果是这样的：

    如果把Prefix设为某个文件夹名，就可以罗列以此Prefix开头的文件，即该文件夹下递归的所有的文件和子文件夹（目录）。文件名在Contents中显示。如果再把 Delimiter 设置为“/”时，返回值就只罗列该文件夹下的文件和子文件夹（目录），该文件夹下的子文件名（目录）返回在CommonPrefixes 部分，子文件夹下递归的文件和文件夹不被显示。

    如下是几个应用方式：

    列出Bucket内所有文件

    当用户需要获取Bucket下的所有文件时，可以参考如下代码：

    1. // import "github.com/baidubce/bce-sdk-go/services/bos/api"
    3. args := new(api.ListObjectsArgs)
    4. args.Delimiter = "/"
    5. listObjectResult, err := bosClient.ListObjects(bucketName, args)

    可以通过设置 Prefix 参数来获取某个目录下所有的文件：

    1. // import "github.com/baidubce/bce-sdk-go/services/bos/api"
    3. args := new(api.ListObjectsArgs)
    4. args.Prefix = "fun/"
    5. listObjectResult, err := bosClient.ListObjects(bucketName, args)
    6. fmt.Println("Objects:")
    7. for _, obj := range listObjectResult.Contents {
    8.     fmt.Println(obj.Key)
    9. }

    输出：

    1. Objects:
    2. fun/
    3. fun/movie/001.avi
    4. fun/movie/007.avi
    5. fun/test.jpg

    查看目录下的文件和子目录

    在 Prefix 和 Delimiter 结合的情况下，可以列出目录下的文件和子目录：

    1. // import "github.com/baidubce/bce-sdk-go/services/bos/api"
    3. args.Delimiter = "/"
    4. args.Prefix = "fun/"
    5. listObjectResult, err := bosClient.ListObjects(bucketName, args)
    7. // 遍历所有的Objects（当前目录和直接子文件）
    8. fmt.Println("Objects:")
    9. for _, obj := range listObjectResult.Contents {
    10.     fmt.Println(obj.Key)
    11. }
    13. // 遍历所有的CommonPrefix（子目录）
    14. fmt.Println("CommonPrefixs:")
    15. for _, obj := range listObjectResult.CommonPrefixes {
    16.     fmt.Println(obj.Prefix)
    17. }

    输出： Objects: fun/ fun/test.jpg

    1. CommonPrefixs:
    2. fun/movie/

    返回的结果中，ObjectSummaries 的列表中给出的是fun目录下的文件。而CommonPrefixs的列表中给出的是fun目录下的所有子文件夹。可以看出fun/movie/001.avi ，fun/movie/007.avi两个文件并没有被列出来，因为它们属于 文件夹下的 movie 目录。

    列举Bucket中object的存储属性

    当用户完成上传后，如果需要查看指定Bucket中的全部Object的storage class属性，可以通过如下代码实现：

    权限控制

    目前BOS支持两种方式设置ACL。第一种是使用Canned Acl，在PutObjectAcl的时候，通过头域的"x-bce-acl"或者"x-bce-grant-permission"来设置对象的访问权限，当前可设置的权限包括private和public-read，两种类型的header不可以同时在一个请求中出现。第二种方式是上传一个ACL文件。详细信息请参考设置Object权限控制

    设置Canned ACL

    Canned ACL是预定义的访问权限，用户可选择对某个对象进行设置，支持三种接口：

    1. // 1. 使用x-bce-acl Header设置
    2. err := bosClient.PutObjectAclFromCanned(bucket, object, cannedAcl) //cannedAcl可取值为：private、public-read
    4. // 2. 使用x-bce-grant-{permission} Header设置
    5. err1 := bosClient.PutObjectAclGrantRead(bucket, object, userId) 
    6. err2 := bosClient.PutObjectAclGrantFullControl(bucket, object, userId)
    7. // userId为授权的用户，支持可变参数，传入多个用户ID

    设置自定义ACL

    用户可参考如下代码设置Bucket内的对象的自定义访问权限，支持四种不同参数：

    1. // import "github.com/baidubce/bce-sdk-go/bce"
    2. // import "github.com/baidubce/bce-sdk-go/services/bos/api"
    4. // 1. 直接上传ACL文件流
    5. aclBodyStream := bce.NewBodyFromFile("<path-to-acl-file>")
    6. err := bosClient.PutObjectAcl(bucket, object, aclBodyStream)
    8. // 2. 直接使用ACL json字符串
    9. aclString := `{
    10.     "accessControlList":[
    11.         {
    12.             "grantee":[{
    13.                 "id":"e13b12d0131b4c8bae959df4969387b8" //指定用户ID
    14.             }],
    15.             "permission":["FULL_CONTROL"] //指定用户权限
    16.         }
    17.     ]
    18. }`
    19. err := bosClient.PutObjectAclFromString(bucket, object, aclString)
    21. // 3. 使用ACL文件
    22. err := bosClient.PutObjectAclFromFile(bucket, object, "<acl-file-name>")
    24. // 4. 使用ACL struct对象设置
    25. grantUser1 := api.GranteeType{"<user-id-1>"}
    26. grantUser2 := api.GranteeType{"<user-id-2>"}
    27. grant1 := api.GrantType{
    28.     Grantee: []api.GranteeType{grantUser1},
    29.     Permission: []string{"FULL_CONTROL"}
    30. }
    31. grant2 := api.GrantType{
    32.     Grantee: []api.GranteeType{granteUser2},
    33.     Permission: []string{"READ"}
    34. }
    35. grantArr := make([]api.GranteType)
    36. grantArr = append(grantArr, grant1)
    37. grantArr = append(grantArr, grant2)
    38. args := &api.PutObjectAclArgs{grantArr}
    39. err := bosClient.PutObjectAclFromStruct(bucketName, object, args)

    获取对象的访问权限

    如下代码可获取一个对象的访问权限：

    1. result, err := bosClient.GetObjectAcl(bucketName, object)

    返回结果对象的字段包含了访问权限的详细内容，具体定义如下：

    1. type GetObjectAclResult struct {
    2.     AccessControlList []struct{
    3.         Grantee []struct{
    4.             Id string
    5.         }
    6.         Permission []string
    7.     }
    8. }

    删除对象的访问权限

    对设置过访问权限的对象，可以调用此接口进行删除：

    1. err := bosClient.DeleteObjectAcl(bucketName, object)

    删除文件

    删除单个文件

    可参考如下代码删除了一个Object:

    1. // 指定要删除Object名称和所在的Bucket名称
    2. err := bosClient.DeleteObject(bucketName, objectName)

    删除多个文件

    用户也可通过一次调用删除同一个Bucket下的多个文件，有如下参数：

    具体示例如下：

    1. // import "github.com/baidubce/bce-sdk-go/services/bos/api"
    3. // 1. 原始接口，提供多个Object的List Stream
    4. res, err := bosClient.DeleteMultipleObjects(bucket, objectListStream)
    6. // 2. 提供json字符串删除
    7. objectList := `{
    8.     "objects":[
    9.         {"key": "aaa"},
    10.         {"key": "bbb"}
    11.     ]
    12. }`
    13. res, err := bosClient.DeleteMultipleObjectsFromString(bucket, objectList)
    15. // 3. 提供删除Object的List对象
    16. deleteObjectList := make([]api.DeleteObjectArgs, 0)
    17. deleteObjectList = append(deleteObjectList, api.DeleteObjectArgs{"aaa"})
    18. deleteObjectList = append(deleteObjectList, api.DeleteObjectArgs{"bbb"})
    19. multiDeleteObj := &api.DeleteMultipleObjectsArgs{deleteObjectList}
    20. res, err := bosClient.DeleteMultipleObjectsFromStruct(bucket, multiDeleteObj)
    22. // 4. 直接提供待删除Object的名称列表
    23. deleteObjects := []string{"aaa", "bbb"}
    24. res, err := bosClient.DeleteMultipleObjectsFromKeyList(bucket, deleteObjects)
    说明： 一次删除多个Object的时候，返回的结果里包含了未删除成功的Object名称列表。删除部分对象成功时res里包含了未删除成功的名称列表。删除部分对象成功时err为nil且res不为nil，判断全部删除成功：err为io.EOF且res为nil。

    用户可通过如下操作查看某文件是否存在：

    1. // import "github.com/baidubce/bce-sdk-go/bce"
    3. _, err := bosClient.GetObjectMeta(bucketName, objectName)
    4. if realErr, ok := err.(*bce.BceServiceError); ok {
    5.     if realErr.StatusCode == 404 {
    6.         fmt.Println("object not exists")
    7.     }
    8. }
    9. fmt.Println("object exists")

    获取及更新文件元信息

    文件元信息(Object Metadata)，是对用户上传BOS的文件的属性描述，分为两种：HTTP标准属性（HTTP Headers）和User Meta（用户自定义元信息）。

    获取文件元信息

    用户通过GetObjectMeta方法可以只获取Object Metadata而不获取Object的实体。如下代码所示：

    1. res, err := bosClient.GetObjectMeta(bucketName, objectName)
    2. fmt.Printf("Metadata: %+v\n", res)

    修改文件元信息

    BOS修改Object的Metadata通过拷贝Object实现。即拷贝Object的时候，把目的Bucket设置为源Bucket，目的Object设置为源Object，并设置新的Metadata，通过拷贝自身实现修改Metadata的目的。如果不设置新的Metadata，则报错。这种方式下必须使用拷贝模式为“replace”（默认情况为“copy”）。示例如下：

    1. // import "github.com/baidubce/bce-sdk-go/bce"
    3. args := new(api.CopyObjectArgs)
    5. // 必须设置拷贝模式为"replace"，默认为"copy"是不能执行Metadata修改的
    6. args.MetadataDirective="replace"
    8. // 设置Metadata参数值，具体字段请参考官网说明
    9. args.LastModified = "Wed, 29 Nov 2017 13:18:08 GMT"
    10. args.ContentType = "text/json"
    12. // 使用CopyObject接口修改Metadata，源对象和目的对象相同
    13. res, err := bosClient.CopyObject(bucket, object, bucket, object, args)

    拷贝文件

    拷贝一个文件

    用户可以通过CopyObject方法拷贝一个Object，如下代码所示：

    1. // 1. 原始接口，可设置拷贝参数
    2. res, err := bosClient.CopyObject(bucketName, objectName, srcBucket, srcObject, nil)
    4. // 2. 忽略拷贝参数，使用默认
    5. res, err := bosClient.BasicCopyObject(bucketName, objectName, srcBucket, srcObject)
    7. fmt.Println("ETag:", res.ETag, "LastModified:", res.LastModified)

    上述接口返回的结果对象中包含了新Object的ETag和修改时间LastModified。

    1. // import "github.com/baidubce/bce-sdk-go/services/bos/api"
    3. args := new(api.CopyObjectArgs)
    5. // 设置用户自定义Metadata
    6. args.UserMeta = map[string]string{"<user-meta-key>": "<user-meta-value>"}
    8. res, err := bosClient.CopyObject(bucketName, objectName, srcBucket, srcObject, args)
    9. fmt.Println("ETag:", res.ETag, "LastModified:", res.LastModified)

    设置Object的Copy属性

    用户在执行拷贝的过程中，可以对源Object的Etag或修改状态进行判断，根据判断结果决定是否执行拷贝。详细的参数解释如下：

    对应的示例代码：

    1. // import "github.com/baidubce/bce-sdk-go/services/bos/api"
    3. args := new(api.CopyObjectArgs)
    5. // 设置用户自定义Metadata
    6. args.UserMeta = map[string]string{"<user-meta-key>": "<user-meta-value>"}
    8. // 设置copy-source-if-match
    9. args.IfMatch = "111111111183bf192b57a4afc76fa632"
    11. // 设置copy-source-if-none-match
    12. args.IfNoneMatch = "111111111183bf192b57a4afc76fa632"
    14. // 设置copy-source-if-modified-since
    15. args.IfModifiedSince = "Fri, 16 Mar 2018 17:07:21 GMT"
    17. // 设置copy-source-if-unmodified-since
    18. args.IfUnmodifiedSince = "Fri, 16 Mar 2018 17:07:21 GMT"
    20. fmt.Println("ETag:", res.ETag, "LastModified:", res.LastModified)

    同步Copy功能

    当前BOS的CopyObject接口是通过同步方式实现的。同步方式下，BOS端会等待Copy实际完成才返回成功。同步Copy能帮助用户更准确的判断Copy状态，但用户感知的复制时间会变长，且复制时间和文件大小成正比。

    同步Copy方式更符合业界常规，提升了与其它平台的兼容性。同步Copy方式还简化了BOS服务端的业务逻辑，提高了服务效率。