Golang AWS SDK V2分页功能实现指南

以下是针对你问题的解决方案：

1. 分页器返回所有队列的问题

AWS SQS的ListQueues API默认每页最多返回1000个队列，但分页器会自动处理所有页面。你的代码看起来应该能获取所有队列。问题可能在于：

• 确认你确实有超过1000个队列
• 检查是否有权限问题
• 确认队列名称前缀过滤是否正确

改进后的代码：

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/sqs"
    "github.com/aws/aws-sdk-go-v2/service/sqs/types"
)

func listAllQueues(prefix string) ([]string, error) {
    cfg, err := config.LoadDefaultConfig(context.TODO(),
        config.WithRegion("us-east-1"),
    )
    if err != nil {
        return nil, fmt.Errorf("failed to load config: %w", err)
    }

    client := sqs.NewFromConfig(cfg)

    params := &sqs.ListQueuesInput{}
    if prefix != "" {
        params.QueueNamePrefix = aws.String(prefix)
    }

    var allQueueUrls []string
    paginator := sqs.NewListQueuesPaginator(client, params)
    
    pageCount := 0
    for paginator.HasMorePages() {
        pageCount++
        output, err := paginator.NextPage(context.TODO())
        if err != nil {
            return nil, fmt.Errorf("failed to get page %d: %w", pageCount, err)
        }
        
        for _, url := range output.QueueUrls {
            allQueueUrls = append(allQueueUrls, url)
        }
        
        fmt.Printf("Page %d: Found %d queues\n", pageCount, len(output.QueueUrls))
    }
    
    fmt.Printf("Total pages: %d, Total queues: %d\n", pageCount, len(allQueueUrls))
    return allQueueUrls, nil
}

func main() {
    queues, err := listAllQueues("")
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("Found %d total queues\n", len(queues))
    
    // 显示前10个队列URL
    for i, url := range queues {
        if i >= 10 {
            break
        }
        fmt.Printf("Queue %d: %s\n", i+1, url)
    }
}

2. 返回队列URL给其他模块

以下是返回队列URL的完整实现：

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/sqs"
)

// SQSManager 管理SQS操作
type SQSManager struct {
    client *sqs.Client
}

// NewSQSManager 创建新的SQS管理器
func NewSQSManager(region string) (*SQSManager, error) {
    cfg, err := config.LoadDefaultConfig(context.TODO(),
        config.WithRegion(region),
    )
    if err != nil {
        return nil, fmt.Errorf("failed to load config: %w", err)
    }
    
    return &SQSManager{
        client: sqs.NewFromConfig(cfg),
    }, nil
}

// ListAllQueueURLs 返回所有队列URL
func (m *SQSManager) ListAllQueueURLs(prefix string) ([]string, error) {
    params := &sqs.ListQueuesInput{}
    if prefix != "" {
        params.QueueNamePrefix = aws.String(prefix)
    }

    var allQueueUrls []string
    paginator := sqs.NewListQueuesPaginator(m.client, params)
    
    for paginator.HasMorePages() {
        output, err := paginator.NextPage(context.TODO())
        if err != nil {
            return nil, fmt.Errorf("failed to get next page: %w", err)
        }
        
        allQueueUrls = append(allQueueUrls, output.QueueUrls...)
    }
    
    return allQueueUrls, nil
}

// ListQueueURLsWithLimit 返回队列URL（带限制）
func (m *SQSManager) ListQueueURLsWithLimit(prefix string, maxResults int32) ([]string, error) {
    params := &sqs.ListQueuesInput{
        MaxResults: aws.Int32(maxResults),
    }
    
    if prefix != "" {
        params.QueueNamePrefix = aws.String(prefix)
    }

    output, err := m.client.ListQueues(context.TODO(), params)
    if err != nil {
        return nil, fmt.Errorf("failed to list queues: %w", err)
    }
    
    return output.QueueUrls, nil
}

// 使用示例
func main() {
    // 初始化SQS管理器
    manager, err := NewSQSManager("us-east-1")
    if err != nil {
        log.Fatal(err)
    }
    
    // 方法1：获取所有队列URL
    allQueues, err := manager.ListAllQueueURLs("")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Found %d total queues\n", len(allQueues))
    
    // 方法2：获取前100个队列URL
    limitedQueues, err := manager.ListQueueURLsWithLimit("", 100)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Found %d queues (limited)\n", len(limitedQueues))
    
    // 在其他模块中使用
    processQueues(allQueues)
}

// 其他模块处理队列URL
func processQueues(queueUrls []string) {
    fmt.Println("Processing queues in another module:")
    for i, url := range queueUrls {
        fmt.Printf("Queue %d: %s\n", i+1, url)
        // 这里可以添加你的业务逻辑
    }
}

3. 错误处理改进版本

package main

import (
    "context"
    "errors"
    "fmt"
    "log"

    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/sqs"
)

// GetQueueURLs 获取队列URL的主函数
func GetQueueURLs(ctx context.Context, region, prefix string) ([]string, error) {
    if region == "" {
        return nil, errors.New("region is required")
    }
    
    cfg, err := config.LoadDefaultConfig(ctx, config.WithRegion(region))
    if err != nil {
        return nil, fmt.Errorf("configuration error: %w", err)
    }
    
    client := sqs.NewFromConfig(cfg)
    return fetchAllQueueURLs(ctx, client, prefix)
}

// fetchAllQueueURLs 内部函数，处理分页逻辑
func fetchAllQueueURLs(ctx context.Context, client *sqs.Client, prefix string) ([]string, error) {
    input := &sqs.ListQueuesInput{}
    if prefix != "" {
        input.QueueNamePrefix = aws.String(prefix)
    }
    
    var results []string
    paginator := sqs.NewListQueuesPaginator(client, input)
    
    for paginator.HasMorePages() {
        page, err := paginator.NextPage(ctx)
        if err != nil {
            return nil, fmt.Errorf("pagination error: %w", err)
        }
        
        results = append(results, page.QueueUrls...)
    }
    
    return results, nil
}

func main() {
    ctx := context.Background()
    
    // 调用函数获取队列URL
    queueURLs, err := GetQueueURLs(ctx, "us-east-1", "")
    if err != nil {
        log.Fatalf("Error getting queue URLs: %v", err)
    }
    
    fmt.Printf("Successfully retrieved %d queue URLs\n", len(queueURLs))
    
    // 使用队列URL
    for _, url := range queueURLs {
        fmt.Println(url)
    }
}

关键点：

1. 分页器会自动处理所有页面，确保循环直到HasMorePages()返回false
2. 使用切片收集所有结果：allQueueUrls = append(allQueueUrls, output.QueueUrls...)
3. 将功能封装在结构体或函数中，便于其他模块调用
4. 使用...操作符展开切片，正确收集所有队列URL