当然，想必您已经猜到了，在对一些复杂类型（如 struct）的转换时， gconv 模块内部其实使用了反射的特性来实现的。这虽然为开发者提供了极大的便捷，但是这确实是以性能损耗为代价的。其实在对于 struct 转换时，如果开发者已经 明确转换规则，并且对于其中的性能损耗比较在意，那么可以对特定的 struct 实现 UnmarshalValue 接口来实现 自定义转换。当使用 gconv 模块对该 struct 进行转换时，无论该 struct 是直接作为转换对象或者作为转换对象的属性， gconv 都将会自动识别其实现的 UnmarshalValue 接口并直接调用该接口实现类型转换，而不会使用反射特性来实现转换。

类型转换-UnmarshalValue - 图1提示

标准库的常用反序列化接口，如 UnmarshalText(text []byte) error 其实也是支持的哟，使用方式同 UnmarshalValue，只是参数不同。

接口定义

  1. // apiUnmarshalValue is the interface for custom defined types customizing value assignment.
  2. // Note that only pointer can implement interface apiUnmarshalValue.
  3. type apiUnmarshalValue interface {
  4.     UnmarshalValue(interface{}) error
  5. }

可以看到，自定义的类型可以通过定义 UnmarshalValue 方法来实现自定义的类型转换。这里的输入参数为 interface{} 类型，开发者可以在实际使用场景中通过 类型断言 或者其他方式进行类型转换。

类型转换-UnmarshalValue - 图2注意

需要特别注意，由于 UnmarshalValue 类型转换会修改当前对象的属性值，因此需要保证该接口实现的接受者( Receiver)是指针类型。

正确的接口实现定义示例（使用指针接受）：

  1. func (c *Receiver) UnmarshalValue(interface{}) error

错误的 接口实现定义示例（使用了值传递）：

  1. func (c Receiver) UnmarshalValue(interface{}) error

使用示例

1、自定义数据表查询结果 struct 转换

数据表结构：

  1. CREATE TABLE `user` (
  2.    id bigint unsigned NOT NULL AUTO_INCREMENT,
  3.    passport varchar(45),
  4.    password char(32) NOT NULL,
  5.    nickname varchar(45) NOT NULL,
  6.    create_time timestamp NOT NULL,
  7.    PRIMARY KEY (id)
  8. ) ;

示例代码：

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/v2/container/garray"
  6.     "github.com/gogf/gf/v2/database/gdb"
  7.     "github.com/gogf/gf/v2/errors/gerror"
  8.     "github.com/gogf/gf/v2/frame/g"
  9.     "github.com/gogf/gf/v2/os/gtime"
  10.     "reflect"
  11. )
  13. type User struct {
  14.     Id         int
  15.     Passport   string
  16.     Password   string
  17.     Nickname   string
  18.     CreateTime *gtime.Time
  19. }
  21. // 实现UnmarshalValue接口，用于自定义结构体转换
  22. func (user *User) UnmarshalValue(value interface{}) error {
  23.     if record, ok := value.(gdb.Record); ok {
  24.         *user = User{
  25.             Id:         record["id"].Int(),
  26.             Passport:   record["passport"].String(),
  27.             Password:   "",
  28.             Nickname:   record["nickname"].String(),
  29.             CreateTime: record["create_time"].GTime(),
  30.         }
  31.         return nil
  32.     }
  33.     return gerror.Newf(`unsupported value type for UnmarshalValue: %v`, reflect.TypeOf(value))
  34. }
  36. func main() {
  37.     var (
  38.         err   error
  39.         users []*User
  40.     )
  41.     array := garray.New(true)
  42.     for i := 1; i <= 10; i++ {
  43.         array.Append(g.Map{
  44.             "id":          i,
  45.             "passport":    fmt.Sprintf(`user_%d`, i),
  46.             "password":    fmt.Sprintf(`pass_%d`, i),
  47.             "nickname":    fmt.Sprintf(`name_%d`, i),
  48.             "create_time": gtime.NewFromStr("2018-10-24 10:00:00").String(),
  49.         })
  50.     }
  51.     // 写入数据
  52.     _, err = g.Model("user").Data(array).Insert()
  53.     if err != nil {
  54.         panic(err)
  55.     }
  56.     // 查询数据
  57.     err = g.Model("user").Order("id asc").Scan(&users)
  58.     if err != nil {
  59.         panic(err)
  60.     }
  61.     g.Dump(users)
  62. }

执行后，终端输出：

  1. [
  2.     {
  3.         Id:         1,
  4.         Passport:   "user_1",
  5.         Password:   "",
  6.         Nickname:   "name_1",
  7.         CreateTime: "2018-10-24 10:00:00",
  8.     },
  9.     {
  10.         Id:         2,
  11.         Passport:   "user_2",
  12.         Password:   "",
  13.         Nickname:   "name_2",
  14.         CreateTime: "2018-10-24 10:00:00",
  15.     },
  16.     {
  17.         Id:         3,
  18.         Passport:   "user_3",
  19.         Password:   "",
  20.         Nickname:   "name_3",
  21.         CreateTime: "2018-10-24 10:00:00",
  22.     },
  23.     {
  24.         Id:         4,
  25.         Passport:   "user_4",
  26.         Password:   "",
  27.         Nickname:   "name_4",
  28.         CreateTime: "2018-10-24 10:00:00",
  29.     },
  30.     {
  31.         Id:         5,
  32.         Passport:   "user_5",
  33.         Password:   "",
  34.         Nickname:   "name_5",
  35.         CreateTime: "2018-10-24 10:00:00",
  36.     },
  37.     {
  38.         Id:         6,
  39.         Passport:   "user_6",
  40.         Password:   "",
  41.         Nickname:   "name_6",
  42.         CreateTime: "2018-10-24 10:00:00",
  43.     },
  44.     {
  45.         Id:         7,
  46.         Passport:   "user_7",
  47.         Password:   "",
  48.         Nickname:   "name_7",
  49.         CreateTime: "2018-10-24 10:00:00",
  50.     },
  51.     {
  52.         Id:         8,
  53.         Passport:   "user_8",
  54.         Password:   "",
  55.         Nickname:   "name_8",
  56.         CreateTime: "2018-10-24 10:00:00",
  57.     },
  58.     {
  59.         Id:         9,
  60.         Passport:   "user_9",
  61.         Password:   "",
  62.         Nickname:   "name_9",
  63.         CreateTime: "2018-10-24 10:00:00",
  64.     },
  65.     {
  66.         Id:         10,
  67.         Passport:   "user_10",
  68.         Password:   "",
  69.         Nickname:   "name_10",
  70.         CreateTime: "2018-10-24 10:00:00",
  71.     },
  72. ]

类型转换-UnmarshalValue - 图3提示

可以看到自定义的 UnmarshalValue 类型转换方法中没有使用到反射特性，因此转换的性能会得到极大的提升。小伙伴们可以尝试着增加写入的数据量（例如 100W），同时对比一下去掉 UnmarshalValue 后的类型转换所开销的时间。

2、自定义二进制TCP数据解包

一个TCP通信的数据包解包示例。

  1. package main
  3. import (
  4.     "errors"
  5.     "fmt"
  6.     "github.com/gogf/gf/v2/crypto/gcrc32"
  7.     "github.com/gogf/gf/v2/encoding/gbinary"
  8.     "github.com/gogf/gf/v2/util/gconv"
  9. )
  11. type Pkg struct {
  12.     Length uint16 // Total length.
  13.     Crc32  uint32 // CRC32.
  14.     Data   []byte
  15. }
  17. // NewPkg creates and returns a package with given data.
  18. func NewPkg(data []byte) *Pkg {
  19.     return &Pkg{
  20.         Length: uint16(len(data) + 6),
  21.         Crc32:  gcrc32.Encrypt(data),
  22.         Data:   data,
  23.     }
  24. }
  26. // Marshal encodes the protocol struct to bytes.
  27. func (p *Pkg) Marshal() []byte {
  28.     b := make([]byte, 6+len(p.Data))
  29.     copy(b, gbinary.EncodeUint16(p.Length))
  30.     copy(b[2:], gbinary.EncodeUint32(p.Crc32))
  31.     copy(b[6:], p.Data)
  32.     return b
  33. }
  35. // UnmarshalValue decodes bytes to protocol struct.
  36. func (p *Pkg) UnmarshalValue(v interface{}) error {
  37.     b := gconv.Bytes(v)
  38.     if len(b) < 6 {
  39.         return errors.New("invalid package length")
  40.     }
  41.     p.Length = gbinary.DecodeToUint16(b[:2])
  42.     if len(b) < int(p.Length) {
  43.         return errors.New("invalid data length")
  44.     }
  45.     p.Crc32 = gbinary.DecodeToUint32(b[2:6])
  46.     p.Data = b[6:]
  47.     if gcrc32.Encrypt(p.Data) != p.Crc32 {
  48.         return errors.New("crc32 validation failed")
  49.     }
  50.     return nil
  51. }
  53. func main() {
  54.     var p1, p2 *Pkg
  56.     // Create a demo pkg as p1.
  57.     p1 = NewPkg([]byte("123"))
  58.     fmt.Println(p1)
  60.     // Convert bytes from p1 to p2 using gconv.Struct.
  61.     err := gconv.Struct(p1.Marshal(), &p2)
  62.     if err != nil {
  63.         panic(err)
  64.     }
  65.     fmt.Println(p2)
  66. }

执行后，终端输出：

  1. &{9 2286445522 [49 50 51]}
  2. &{9 2286445522 [49 50 51]}