热门标签
热门文章
- 1STM32最小系统核心板(STM32F103C8T6)实现流水灯_stm32f103c8t6最小系统板 hal led
- 2JAVA代码审计-XSS漏洞分析_java检验数据是否存在xss代码
- 3Linux Jellyfin 硬解4K HEVC HDR报错，“该客户端与媒体不兼容，服务器未发送兼容的媒体格式”_该客户端与媒体不兼容,服务器未发送兼容的媒体格式。
- 4Rust 101_5fn.buzz
- 5phpMyAdmin无法登录MySQL服务器_phpmyadmin无法登录 mysql 服务器
- 6chatgpt赋能python：[Python全选代码：实现高效快速的开发工作]
- 7过年了，尽情地享受《幻兽帕鲁》吧！
- 815个node.js经典面试题和答案_node jwt面试题
- 92022必会的vue高频面试题（附答案）_vue高级面试题
- 10用python把数据导入neo4j中，建立一个简单的知识图谱_python写入neo4j知识图谱
当前位置: article > 正文
使用腾讯云go sdk 查询对象存储中最新文件
作者：你好赵伟 | 2024-03-03 14:09:21
赞
踩
使用腾讯云go sdk 查询对象存储中最新文件
背景：
腾讯云账号下，有很多对象存储COS桶：
我现在想确认某一个对象存储桶的活跃程度，简单的来说。我想知道这个桶里面最后上传的一个文件是什么，以及它的上传时间戳。
本文将介绍如何使用腾讯云对象存储（COS）的 Go 语言 SDK 查询指定存储桶中的最新文件信息，包括文件路径和上传时间。本教程假设读者已经具备基本的 Go 语言编程知识，并且对腾讯云 COS 有一定的了解。
使用腾讯云go sdk 查询对象存储中最新文件
前置条件
- 您需要拥有一个腾讯云账号，并创建了至少一个COS存储桶。
- 了解Go语言和基本的并发编程知识。
- 确保您已安装Go运行时环境。
安装腾讯云COS Go SDK
在开始之前，先确保您的开发环境已安装了腾讯云COS的Go SDK。如果尚未安装，可以使用以下Go命令安装：
mkdir xxxx
go mod int xxxx
go get github.com/tencentyun/cos-go-sdk-v5
- 1
- 2
- 3
我们这里的操作是属于List Object 参照：GetBucket
第一版代码：
使用chatgpt生成第一版代码：
main.go
package main import ( "context" "fmt" "net/http" "net/url" "sort" "time" "github.com/tencentyun/cos-go-sdk-v5" ) // 请替换下面的假设值为实际的 SecretId、SecretKey、BucketName 和 Region。 const ( SecretId = "xxxxxx" SecretKey = "xxxx" BucketName = "xxxxxx" // 例如 "example-1250000000" BucketRegion = "ap-shanghai" // 例如 "ap-guangzhou" ) func main() { u, _ := url.Parse(fmt.Sprintf("https://%s.cos.%s.myqcloud.com", BucketName, BucketRegion)) b := &cos.BaseURL{BucketURL: u} client := cos.NewClient(b, &http.Client{ Transport: &cos.AuthorizationTransport{ SecretID: SecretId, SecretKey: SecretKey, }, }) c := context.Background() opt := &cos.BucketGetOptions{ MaxKeys: 1000, // 修改这个值以获取更多或更少的对象 } v, _, err := client.Bucket.Get(c, opt) if err != nil { panic(err) } // 对结果进行排序，找到最后更新的对象 if len(v.Contents) > 0 { sort.Slice(v.Contents, func(i, j int) bool { ti, _ := time.Parse(time.RFC3339, v.Contents[i].LastModified) tj, _ := time.Parse(time.RFC3339, v.Contents[j].LastModified) return ti.After(tj) }) lastUpdatedObj := v.Contents[0] fmt.Printf("最新上传文件路径: %s\n", lastUpdatedObj.Key) fmt.Printf("最新上传时间: %s\n", lastUpdatedObj.LastModified) } else { fmt.Println("桶中没有文件。") } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
运行main.go
go run main.go
- 1
运行后也许感觉是正确的，毕竟没有报错。但是这里是有问题的，为什么呢？因为我本身不知道最后一个文件是什么，我手动上传了一个文件，最后一个文件应该是输出：go1.22.0.linux-amd64.tar.gz！
什么原因呢？问题应该是在这里：
c := context.Background()
opt := &cos.BucketGetOptions{
MaxKeys: 1000, // 修改这个值以获取更多或更少的对象
}
- 1
- 2
- 3
- 4
marker标记参数没有设置
继续修改完善main.go代码：
package main import ( "context" "fmt" "net/http" "net/url" "sort" "time" "github.com/tencentyun/cos-go-sdk-v5" ) // 请替换以下的假设值为实际的 SecretId、SecretKey、BucketName 和 Region。 const ( SecretId = "xxxxxx" SecretKey = "xxxx" BucketName = "xxxxxx" // 例如 "example-1250000000" BucketRegion = "ap-shanghai" // 例如 "ap-guangzhou" ) func main() { u, _ := url.Parse(fmt.Sprintf("https://%s.cos.%s.myqcloud.com", BucketName, BucketRegion)) b := &cos.BaseURL{BucketURL: u} client := cos.NewClient(b, &http.Client{ Transport: &cos.AuthorizationTransport{ SecretID: SecretId, SecretKey: SecretKey, }, }) c := context.Background() var lastUpdatedObj *cos.Object isTruncated := true nextMarker := "" for isTruncated { opt := &cos.BucketGetOptions{ Marker: nextMarker, MaxKeys: 1000, // 单次请求返回的最大对象数 } v, _, err := client.Bucket.Get(c, opt) if err != nil { panic(err) } for _, object := range v.Contents { if lastUpdatedObj == nil || object.LastModified > lastUpdatedObj.LastModified { lastUpdatedObj = &object } } // 更新下一个标记和是否截断的标志 isTruncated = v.IsTruncated nextMarker = v.NextMarker } // 检查是否有对象被找到 if lastUpdatedObj != nil { fmt.Printf("最新上传文件路径: %s\n", lastUpdatedObj.Key) fmt.Printf("最新上传时间: %s\n", lastUpdatedObj.LastModified) } else { fmt.Println("桶中没有文件。") } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
运行修改后的main.go文件：
go run main.go
- 1
输出go1.22.0.linux-amd64.tar.gz这个起码是正确的！
拆分代码
想继续拆分一下，将客户端的创建和查找逻辑拆分到两个独立的函数createCOSClient getLastUpdatedFileInfo，然后main函数中调用：
package main import ( "context" "fmt" "github.com/tencentyun/cos-go-sdk-v5" "net/http" "net/url" "sort" "time" ) // 请替换下面的假设值为实际的 SecretId、SecretKey、BucketName 和 Region。 const ( SecretId = "xxxxxx" SecretKey = "xxx" BucketName = "xxxxx" // 例如 "example-1250000000" BucketRegion = "ap-shanghai" // 例如 "ap-guangzhou" ) // 创建 COS 客户端 func createCOSClient(secretId, secretKey, bucketName, bucketRegion string) *cos.Client { u, _ := url.Parse(fmt.Sprintf("https://%s.cos.%s.myqcloud.com", bucketName, bucketRegion)) b := &cos.BaseURL{BucketURL: u} client := cos.NewClient(b, &http.Client{ Transport: &cos.AuthorizationTransport{ SecretID: secretId, SecretKey: secretKey, }, }) return client } func getLastUpdatedFileInfo(client *cos.Client) (key, lastModifiedTime string, err error) { c := context.Background() // 初始化一个空字符串，表示从桶的开头获取文件列表 nextMarker := "" var allContents []cos.Object for { opt := &cos.BucketGetOptions{ MaxKeys: 1000, Marker: nextMarker, } v, _, err := client.Bucket.Get(c, opt) if err != nil { return "", "", err } allContents = append(allContents, v.Contents...) // 如果没有更多的文件，则停止循环 if !v.IsTruncated { break } // 更新 nextMarker 为下一页的开始位置 nextMarker = v.NextMarker } // 对所有结果进行排序以找到最新更新的对象 if len(allContents) > 0 { sort.Slice(allContents, func(i, j int) bool { ti, errTi := time.Parse(time.RFC3339, allContents[i].LastModified) tj, errTj := time.Parse(time.RFC3339, allContents[j].LastModified) if errTi != nil || errTj != nil { fmt.Printf("Error parsing time: %v, %v", errTi, errTj) return false } return ti.After(tj) }) lastUpdatedObj := allContents[0] return lastUpdatedObj.Key, lastUpdatedObj.LastModified, nil } else { return "", "", fmt.Errorf("桶中没有文件") } } func main() { client := createCOSClient(SecretId, SecretKey, BucketName, BucketRegion) key, lastModifiedTime, err := getLastUpdatedFileInfo(client) if err != nil { fmt.Printf("\n查询失败: %v\n", err) return } fmt.Printf("\n最后更新的文件:\n") fmt.Printf("文件路径: %s\n", key) fmt.Printf("最后修改时间: %s\n", lastModifiedTime) }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
运行main.go
go run main.go
- 1
注：为了验证代码有效性，我这里后面又加了一个新的文件：zaZTYa1i2x.txt
加个进度条
上面的代码已经可以正常满足需求了，但是我新加一个进度条，显示查询了多少文件了。也能大概知道一个进度的状况，继续修改一下main.go
package main import ( "context" "fmt" "github.com/tencentyun/cos-go-sdk-v5" "net/http" "net/url" "sort" "time" ) // 请替换下面的假设值为实际的 SecretId、SecretKey、BucketName 和 Region。 const ( SecretId = "xxxx" SecretKey = "xxxxx" BucketName = "xxxxx" // 例如 "example-1250000000" BucketRegion = "ap-shanghai" // 例如 "ap-guangzhou" ) // 创建 COS 客户端 func createCOSClient(secretId, secretKey, bucketName, bucketRegion string) *cos.Client { u, _ := url.Parse(fmt.Sprintf("https://%s.cos.%s.myqcloud.com", bucketName, bucketRegion)) b := &cos.BaseURL{BucketURL: u} client := cos.NewClient(b, &http.Client{ Transport: &cos.AuthorizationTransport{ SecretID: secretId, SecretKey: secretKey, }, }) return client } func getLastUpdatedFileInfo(client *cos.Client) (key, lastModifiedTime string, err error) { c := context.Background() nextMarker := "" var allContents []cos.Object var retrievedCount int fmt.Println("开始检索文件列表...") for { opt := &cos.BucketGetOptions{ MaxKeys: 10000, Marker: nextMarker, } v, _, err := client.Bucket.Get(c, opt) if err != nil { return "", "", err } retrievedCount += len(v.Contents) fmt.Printf("已检索 %d 个文件...\r", retrievedCount) // 输出进度信息 '\r' 会覆盖当前行，这样我们就可以在同一行更新进度 allContents = append(allContents, v.Contents...) if !v.IsTruncated { break } nextMarker = v.NextMarker } fmt.Println("\n文件列表检索完成。") if len(allContents) > 0 { sort.Slice(allContents, func(i, j int) bool { ti, errTi := time.Parse(time.RFC3339, allContents[i].LastModified) tj, errTj := time.Parse(time.RFC3339, allContents[j].LastModified) if errTi != nil || errTj != nil { fmt.Printf("Error parsing time: %v, %v", errTi, errTj) return false } return ti.After(tj) }) lastUpdatedObj := allContents[0] return lastUpdatedObj.Key, lastUpdatedObj.LastModified, nil } else { return "", "", fmt.Errorf("桶中没有文件") } } func main() { client := createCOSClient(SecretId, SecretKey, BucketName, BucketRegion) key, lastModifiedTime, err := getLastUpdatedFileInfo(client) if err != nil { fmt.Printf("\n查询失败: %v\n", err) return } fmt.Printf("\n最后更新的文件:\n") fmt.Printf("文件路径: %s\n", key) fmt.Printf("最后修改时间: %s\n", lastModifiedTime) }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
运行main.go
go run main.go
- 1
继续完善
继续完善一下代码：我需要把MaxKeys 提取出来，增加一下输出程序的运行时间，并把输出文件的时间戳调整为东八区时间：
package main import ( "context" "fmt" "github.com/tencentyun/cos-go-sdk-v5" "net/http" "net/url" "sort" "time" ) const ( SecretId = "xxxx" SecretKey = "xxxxx" BucketName = "xxxxx" BucketRegion = "ap-shanghai" MaxKeys = 1000 // 设置最大检索数量的常量 ) var cstZone = time.FixedZone("CST", 8*3600) // 东八区时区 func createCOSClient(secretId, secretKey, bucketName, bucketRegion string) *cos.Client { u, _ := url.Parse(fmt.Sprintf("https://%s.cos.%s.myqcloud.com", bucketName, bucketRegion)) b := &cos.BaseURL{BucketURL: u} client := cos.NewClient(b, &http.Client{ Transport: &cos.AuthorizationTransport{ SecretID: secretId, SecretKey: secretKey, }, }) return client } func getLastUpdatedFileInfo(client *cos.Client) (key, lastModifiedTime string, err error) { c := context.Background() nextMarker := "" var allContents []cos.Object var retrievedCount int fmt.Println("开始检索文件列表...") for { opt := &cos.BucketGetOptions{ MaxKeys: MaxKeys, // 使用常量 MaxKeys Marker: nextMarker, } v, _, err := client.Bucket.Get(c, opt) if err != nil { return "", "", err } retrievedCount += len(v.Contents) fmt.Printf("已检索 %d 个文件...\r", retrievedCount) allContents = append(allContents, v.Contents...) if !v.IsTruncated { break } nextMarker = v.NextMarker } fmt.Println("\n文件列表检索完成。") if len(allContents) > 0 { sort.Slice(allContents, func(i, j int) bool { ti, errTi := time.Parse(time.RFC3339, allContents[i].LastModified) tj, errTj := time.Parse(time.RFC3339, allContents[j].LastModified) if errTi != nil || errTj != nil { fmt.Printf("Error parsing time: %v, %v", errTi, errTj) return false } return ti.After(tj) }) lastUpdatedObj := allContents[0] // 将文件的 LastModified 时间字符串转换为 time.Time t, err := time.Parse(time.RFC3339, lastUpdatedObj.LastModified) if err != nil { return "", "", fmt.Errorf("无法解析最后修改时间: %v", err) } // 转换为东八区时间 cstTime := t.In(cstZone).Format(time.RFC3339) return lastUpdatedObj.Key, cstTime, nil } else { return "", "", fmt.Errorf("桶中没有文件") } } func main() { start := time.Now() // 程序开始时间 client := createCOSClient(SecretId, SecretKey, BucketName, BucketRegion) key, lastModifiedTime, err := getLastUpdatedFileInfo(client) if err != nil { fmt.Printf("\n查询失败: %v\n", err) return } fmt.Printf("\n最后更新的文件:\n") fmt.Printf("文件路径: %s\n", key) fmt.Printf("最后修改时间: %s\n", lastModifiedTime) elapsed := time.Since(start) // 程序执行时间 fmt.Printf("\n程序运行时间: %s\n", elapsed) }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
运行修改后的main.go文件：
go run main.go
- 1
继续发散
继续发散一下，我需要输出最后上传的10个文件
package main import ( "context" "fmt" "github.com/tencentyun/cos-go-sdk-v5" "net/http" "net/url" "sort" "time" ) // 请替换下面的假设值为实际的 SecretId、SecretKey、BucketName 和 Region。 const ( SecretId = "AKID7Mhwz45A9zqcCf4s07A7FIKKTlAiEf7M" SecretKey = "KXbXL0unr2EaBsicYejj1GkEjO2jWOAg" BucketName = "layabox-10028350" // 例如 "example-1250000000" BucketRegion = "ap-shanghai" // 例如 "ap-guangzhou" MaxKeys = 1000 // 设置最大检索数量的常量 NumberOfFiles = 10 // 需要获取的最后更新的文件数量 ) var cstZone = time.FixedZone("CST", 8*3600) // 东八区时区 func createCOSClient(secretId, secretKey, bucketName, bucketRegion string) *cos.Client { u, _ := url.Parse(fmt.Sprintf("https://%s.cos.%s.myqcloud.com", bucketName, bucketRegion)) b := &cos.BaseURL{BucketURL: u} client := cos.NewClient(b, &http.Client{ Transport: &cos.AuthorizationTransport{ SecretID: secretId, SecretKey: secretKey, }, }) return client } func getLastUpdatedFileInfo(client *cos.Client, numberOfFiles int) ([]cos.Object, error) { c := context.Background() nextMarker := "" var allContents []cos.Object var retrievedCount int fmt.Println("开始检索文件列表...") for { opt := &cos.BucketGetOptions{ MaxKeys: MaxKeys, // 使用常量 MaxKeys Marker: nextMarker, } v, _, err := client.Bucket.Get(c, opt) if err != nil { return nil, err } retrievedCount += len(v.Contents) fmt.Printf("已检索 %d 个文件...\r", retrievedCount) allContents = append(allContents, v.Contents...) if !v.IsTruncated { break } nextMarker = v.NextMarker } fmt.Println("\n文件列表检索完成。") fmt.Printf("\n桶中总文件数: %d\n", len(allContents)) if len(allContents) > 0 { sort.Slice(allContents, func(i, j int) bool { ti, errTi := time.Parse(time.RFC3339, allContents[i].LastModified) tj, errTj := time.Parse(time.RFC3339, allContents[j].LastModified) if errTi != nil || errTj != nil { fmt.Printf("Error parsing time: %v, %v", errTi, errTj) return false } return ti.After(tj) }) // 截取切片以获取最后更新的numberOfFiles个文件 if len(allContents) > numberOfFiles { allContents = allContents[:numberOfFiles] } // 返回最后更新的numberOfFiles个文件 return allContents, nil } else { return nil, fmt.Errorf("桶中没有文件") } } func main() { start := time.Now() // 程序开始时间 client := createCOSClient(SecretId, SecretKey, BucketName, BucketRegion) files, err := getLastUpdatedFileInfo(client, NumberOfFiles) if err != nil { fmt.Printf("\n查询失败: %v\n", err) return } fmt.Printf("\n最后更新的%d个文件:\n", NumberOfFiles) for _, file := range files { t, err := time.Parse(time.RFC3339, file.LastModified) if err != nil { fmt.Printf("无法解析文件 %s 的最后修改时间: %v\n", file.Key, err) continue } cstTime := t.In(cstZone).Format(time.RFC3339) fmt.Printf("文件路径: %s\n", file.Key) fmt.Printf("最后修改时间: %s\n", cstTime) } elapsed := time.Since(start) // 程序执行时间 fmt.Printf("\n程序运行时间: %s\n", elapsed) }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
其实也想过协程或者其他方式？但是奈何max-keys 最大是1000测试了一下没有太大的提升放弃了…
总结
在这篇博客中，我们学习了如何使用腾讯云 COS Go SDK 查询存储桶中最新的文件信息。这包括如何创建COS客户端，如何逐页检索对象列表，并如何对结果排序以找到最后更新的对象。我们还展示了如何优化用户体验，通过实时进度更新和检索多个文件来改进程序。
希望本文能帮助你在使用腾讯云 COS 时实现更高效的数据管理。
本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/184850
推荐阅读
相关标签
