Golang中如何为导入的类型实现自定义序列化/反序列化方法

你可以在 database 包中定义另一个 ToolType：

package database

import (
    "world"
)

type ToolType world.ToolType

func (toolType ToolType) MarshalDynamoDBAttributeValue(av *dynamodb.AttributeValue) error {
   txt, err := world.ToolType(toolType).MarshalText()
   if err != nil {
      return err
   }
   av.S = aws.String(txt)
   return nil
}

func (toolType *ToolType) UnmarshalDynamoDBAttributeValue(av *dynamodb.AttributeValue) error {
    return ((*world.ToolType)(toolType)).UnmarshalText([]byte(*av.S))
}

然后由 server 来处理 world.ToolType 和 database.ToolType 之间的转换。

编辑： 对 UnmarshalText 的调用有误。

在Go中，为导入的类型实现自定义序列化/反序列化方法，可以通过以下几种方式解决：

方法1：使用包装类型（推荐）

在database包中创建包装类型，实现DynamoDB的编组器：

// database/tool_type.go
package database

import (
    "github.com/aws/aws-sdk-go/service/dynamodb"
    "github.com/aws/aws-sdk-go/aws"
    "world"
)

type ToolTypeWrapper struct {
    world.ToolType
}

func (w ToolTypeWrapper) MarshalDynamoDBAttributeValue(av *dynamodb.AttributeValue) error {
    txt, err := w.ToolType.MarshalText()
    if err != nil {
        return err
    }
    av.S = aws.String(string(txt))
    return nil
}

func (w *ToolTypeWrapper) UnmarshalDynamoDBAttributeValue(av *dynamodb.AttributeValue) error {
    if av.S == nil {
        return errors.New("nil string attribute")
    }
    return w.ToolType.UnmarshalText([]byte(*av.S))
}

// 使用示例
func SaveTool(tool world.ToolType) error {
    wrapper := ToolTypeWrapper{tool}
    // 使用wrapper进行DynamoDB操作
}

方法2：使用自定义编组器函数

创建独立的编组器函数，而不是方法：

// database/marshal.go
package database

import (
    "github.com/aws/aws-sdk-go/service/dynamodb"
    "github.com/aws/aws-sdk-go/aws"
    "world"
)

func MarshalToolTypeToDynamoDB(tool world.ToolType) (*dynamodb.AttributeValue, error) {
    txt, err := tool.MarshalText()
    if err != nil {
        return nil, err
    }
    return &dynamodb.AttributeValue{
        S: aws.String(string(txt)),
    }, nil
}

func UnmarshalToolTypeFromDynamoDB(av *dynamodb.AttributeValue) (world.ToolType, error) {
    if av.S == nil {
        return 0, errors.New("nil string attribute")
    }
    
    var tool world.ToolType
    err := tool.UnmarshalText([]byte(*av.S))
    return tool, err
}

方法3：使用接口适配器

创建适配器接口来处理不同类型的编组：

// database/dynamodb_adapter.go
package database

import (
    "github.com/aws/aws-sdk-go/service/dynamodb"
    "world"
)

type DynamoDBMarshaler interface {
    MarshalDynamoDB() (*dynamodb.AttributeValue, error)
    UnmarshalDynamoDB(*dynamodb.AttributeValue) error
}

type ToolTypeAdapter struct {
    Value world.ToolType
}

func (a ToolTypeAdapter) MarshalDynamoDB() (*dynamodb.AttributeValue, error) {
    txt, err := a.Value.MarshalText()
    if err != nil {
        return nil, err
    }
    return &dynamodb.AttributeValue{
        S: aws.String(string(txt)),
    }, nil
}

func (a *ToolTypeAdapter) UnmarshalDynamoDB(av *dynamodb.AttributeValue) error {
    if av.S == nil {
        return errors.New("nil string attribute")
    }
    return a.Value.UnmarshalText([]byte(*av.S))
}

方法4：使用结构体标签和自定义编组器（DynamoDB特定）

利用DynamoDB SDK的dynamodbav标签和自定义编组器：

// database/models.go
package database

import (
    "github.com/aws/aws-sdk-go/service/dynamodb"
    "github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute"
    "world"
)

type ToolRecord struct {
    ToolType string `dynamodbav:"tool_type"`
}

func SaveToolToDynamoDB(tool world.ToolType) error {
    txt, err := tool.MarshalText()
    if err != nil {
        return err
    }
    
    record := ToolRecord{
        ToolType: string(txt),
    }
    
    av, err := dynamodbattribute.MarshalMap(record)
    if err != nil {
        return err
    }
    
    // 使用av进行DynamoDB操作
    return nil
}

func LoadToolFromDynamoDB() (world.ToolType, error) {
    // 从DynamoDB获取数据
    var record ToolRecord
    err := dynamodbattribute.UnmarshalMap(dynamoResult.Item, &record)
    if err != nil {
        return 0, err
    }
    
    var tool world.ToolType
    err = tool.UnmarshalText([]byte(record.ToolType))
    return tool, err
}

方法5：使用泛型包装器（Go 1.18+）

如果使用Go 1.18或更高版本，可以使用泛型：

// database/generic_wrapper.go
package database

import (
    "github.com/aws/aws-sdk-go/service/dynamodb"
    "github.com/aws/aws-sdk-go/aws"
)

type TextMarshaler interface {
    MarshalText() ([]byte, error)
    UnmarshalText([]byte) error
}

type DynamoDBWrapper[T TextMarshaler] struct {
    Value T
}

func (w DynamoDBWrapper[T]) MarshalDynamoDBAttributeValue(av *dynamodb.AttributeValue) error {
    txt, err := w.Value.MarshalText()
    if err != nil {
        return err
    }
    av.S = aws.String(string(txt))
    return nil
}

func (w *DynamoDBWrapper[T]) UnmarshalDynamoDBAttributeValue(av *dynamodb.AttributeValue) error {
    if av.S == nil {
        return errors.New("nil string attribute")
    }
    return w.Value.UnmarshalText([]byte(*av.S))
}

// 使用示例
func SaveToolGeneric(tool world.ToolType) error {
    wrapper := DynamoDBWrapper[world.ToolType]{Value: tool}
    // 使用wrapper进行DynamoDB操作
}

这些方法都能在database包内实现DynamoDB编组器，同时保持world包的纯净，避免引入DynamoDB依赖到client包中。方法1（包装类型）是最直接和兼容性最好的解决方案。