Go实现流程处理代码

1. 背景

需要根据请求中提供的 Vendor 来进行一些列操作，操作流程如下

1. 创建对应供应商的客户端
2. 创建账号
3. 创建分区
4. 绑定账号和分区

2. 代码说明

1. 工厂模式：
   • CloudClientFactory 用于根据云厂商名称生成对应的客户端实例。
2. 责任链模式：
   • 每个处理器（如 AccountProcessor, PartitionProcessor, BindingProcessor）负责特定的操作。
   • 通过 SetNext 方法将多个处理器串联起来，形成责任链。
3. 状态检查：
   • 在每个处理器中检查资源的状态（如账号是否存在、分区是否存在），动态决定是否执行操作。
4. 可扩展性：
   • 如果需要添加新的逻辑处理，只需创建新的处理器，并插入到责任链中即可。

package main

import (
	"fmt"
)

// Resource 定义资源信息
// 包含云厂商、资源类型、账号是否存在、分区是否存在等状态。
type Resource struct {
	Vendor          string
	ResourceType    string
	AccountExists   bool
	PartitionExists bool
}

// CloudClient 定义云平台客户端接口
type CloudClient interface {
	CreateAccount() error
	CreatePartition() error
	BindAccountAndPartition() error
}

// AWSClient AWS 的客户端实现
type AWSClient struct{}

func (a *AWSClient) CreateAccount() error {
	fmt.Println("AWS: 创建账号")
	return nil
}

func (a *AWSClient) CreatePartition() error {
	fmt.Println("AWS: 创建分区")
	return nil
}

func (a *AWSClient) BindAccountAndPartition() error {
	fmt.Println("AWS: 绑定账号和分区")
	return nil
}

// AliyunClient 阿里云的客户端实现
type AliyunClient struct{}

func (a *AliyunClient) CreateAccount() error {
	fmt.Println("阿里云: 创建账号")
	return nil
}

func (a *AliyunClient) CreatePartition() error {
	fmt.Println("阿里云: 创建分区")
	return nil
}

func (a *AliyunClient) BindAccountAndPartition() error {
	fmt.Println("阿里云: 绑定账号和分区")
	return nil
}

// CloudClientFactory 云平台客户端工厂
type CloudClientFactory struct{}

func (f *CloudClientFactory) GetClient(vendor string) CloudClient {
	switch vendor {
	case "AWS":
		return &AWSClient{}
	case "Aliyun":
		return &AliyunClient{}
	default:
		return nil
	}
}

// Processor 定义处理器接口，用于责任链模式
type Processor interface {
	Process(resource *Resource, client CloudClient) error
	SetNext(next Processor)
}

// BaseProcessor 基础处理器，包含责任链的基本实现
type BaseProcessor struct {
	next Processor
}

func (b *BaseProcessor) SetNext(next Processor) {
	b.next = next
}

func (b *BaseProcessor) Process(resource *Resource, client CloudClient) error {
	if b.next != nil {
		return b.next.Process(resource, client)
	}
	return nil
}

// AccountProcessor 处理账号创建的处理器
type AccountProcessor struct {
	BaseProcessor
}

func (a *AccountProcessor) Process(resource *Resource, client CloudClient) error {
	if !resource.AccountExists {
		fmt.Println("账号不存在，开始创建账号...")
		if err := client.CreateAccount(); err != nil {
			return err
		}
		resource.AccountExists = true
	} else {
		fmt.Println("账号已存在，跳过创建账号")
	}
	return a.BaseProcessor.Process(resource, client)
}

// PartitionProcessor 处理分区创建的处理器
type PartitionProcessor struct {
	BaseProcessor
}

func (p *PartitionProcessor) Process(resource *Resource, client CloudClient) error {
	if !resource.PartitionExists {
		fmt.Println("分区不存在，开始创建分区...")
		if err := client.CreatePartition(); err != nil {
			return err
		}
		resource.PartitionExists = true
	} else {
		fmt.Println("分区已存在，跳过创建分区")
	}
	return p.BaseProcessor.Process(resource, client)
}

// BindingProcessor 处理绑定账号和分区的处理器
type BindingProcessor struct {
	BaseProcessor
}

func (b *BindingProcessor) Process(resource *Resource, client CloudClient) error {
	fmt.Println("开始绑定账号和分区...")
	if err := client.BindAccountAndPartition(); err != nil {
		return err
	}
	return b.BaseProcessor.Process(resource, client)
}

func main() {
	// 创建资源信息
	resource := &Resource{
		Vendor:          "AWS",
		ResourceType:    "Compute",
		AccountExists:   false,
		PartitionExists: false,
	}

	// 使用工厂模式获取对应云厂商的客户端
	factory := &CloudClientFactory{}
	client := factory.GetClient(resource.Vendor)
	if client == nil {
		fmt.Println("不支持的云厂商")
		return
	}

	// 构建责任链
	accountProcessor := &AccountProcessor{}
	partitionProcessor := &PartitionProcessor{}
	bindingProcessor := &BindingProcessor{}

	accountProcessor.SetNext(partitionProcessor)
	partitionProcessor.SetNext(bindingProcessor)

	// 执行责任链
	if err := accountProcessor.Process(resource, client); err != nil {
		fmt.Printf("处理失败: %v\n", err)
	} else {
		fmt.Println("处理完成！")
	}
}