xorm框架通过`engine.registertype()`方法注册自定义数据类型,调用时需传入自定义类型的实例和对应的sql驱动类型名称。执行该方法后,xorm在映射结构体字段时会自动识别该类型并应用指定的转换逻辑,从而支持如json、uuid等非标准数据库类型的持久化操作。

如何注册一个支持JSON序列化的自定义类型
注册JSON类型需要定义一个实现`sql.Scanner`和`driver.Valuer`接口的结构体,并通过`RegisterType`将其绑定到`database/sql`的`json.RawMessage`或类似类型上。这样在查询和插入时,XORM会委托给这些接口方法进行数据转换。

package main
import (
"database/sql/driver"
"database/sql"
"encoding/json"
"fmt"
"log"
"github.com/xormplus/xorm"
_ "github.com/go-sql-driver/mysql"
)
type JSONMap map[string]interface{}
func (j JSONMap) Value() (driver.Value, error) {
return json.Marshal(j)
}
func (j *JSONMap) Scan(value interface{}) error {
bytes, ok := value.([]byte)
if !ok {
return fmt.Errorf("type assertion failed")
}
return json.Unmarshal(bytes, j)
}
func main() {
engine, err := xorm.NewEngine("mysql", "user:pass@tcp(127.0.0.1:3306)/dbname")
if err != nil {
log.Fatal(err)
}
// 注册自定义类型:将 JSONMap 映射为 MySQL 的 TEXT 类型
engine.RegisterType(JSONMap{}, "text")
type User struct {
ID int64
Data JSONMap `xorm:"varchar(500)"`
}
err = engine.Sync2(new(User))
if err != nil {
log.Fatal(err)
}
user := User{
Data: JSONMap{"name": "Alice", "age": 30},
}
_, err = engine.Insert(&user)
if err != nil {
log.Fatal(err)
}
var result User
has, err := engine.ID(1).Get(&result)
if err != nil || !has {
log.Fatal(err)
}
fmt.Printf("Retrieved Data: %v\n", result.Data)
}
上述代码定义了`JSONMap`结构体,实现了必要的接口,并在主程序中完成注册。运行后,`Data`字段会被正确序列化为JSON字符串存入数据库,读取时自动反序列化回`JSONMap`对象。
如何处理UUID类型的存储与解析
处理UUID类型通常涉及将其转换为字符串格式进行存储。需要定义一个包含UUID值的结构体,实现`Value`方法返回字符串形式的UUID,以及`Scan`方法从数据库读取字符串并解析为UUID。注册时指定目标列类型为`char`或`varchar`。

package main
import (
"database/sql/driver"
"database/sql"
"fmt"
"log"
"strings"
"github.com/xormplus/xorm"
_ "github.com/go-sql-driver/mysql"
)
type UUID string
func (u UUID) Value() (driver.Value, error) {
return string(u), nil
}
func (u *UUID) Scan(value interface{}) error {
if value == nil {
*u = ""
return nil
}
s, ok := value.([]byte)
if !ok {
return fmt.Errorf("type assertion failed")
}
*u = UUID(strings.TrimSpace(string(s)))
return nil
}
func main() {
engine, err := xorm.NewEngine("mysql", "user:pass@tcp(127.0.0.1:3306)/dbname")
if err != nil {
log.Fatal(err)
}
// 注册 UUID 类型为 char(36)
engine.RegisterType(UUID{}, "char(36)")
type Product struct {
ID int64
Code UUID `xorm:"unique"`
Name string
}
err = engine.Sync2(new(Product))
if err != nil {
log.Fatal(err)
}
product := Product{
Code: UUID("550e8400-e29b-41d4-a716-446655440000"),
Name: "Widget",
}
_, err = engine.Insert(&product)
if err != nil {
log.Fatal(err)
}
var result Product
has, err := engine.Where("code = ?", "550e8400-e29b-41d4-a716-446655440000").Get(&result)
if err != nil || !has {
log.Fatal(err)
}
fmt.Printf("Retrieved Product Code: %s\n", result.Code)
}
此示例展示了UUID类型的完整注册流程。通过`RegisterType`将`UUID`绑定到`char(36)`,确保数据库能正确处理其长度和唯一性约束。插入和查询操作均能透明地处理字符串与UUID之间的转换。
注册类型后引擎内部是如何匹配结构体字段的
当XORM执行`Sync2`或`Insert/Get`等操作时,它会遍历结构体的字段。对于每个字段,如果其类型是之前通过`RegisterType`注册过的自定义类型,XORM会优先使用注册的映射关系,而不是默认的反射推断。具体而言,引擎会检查字段类型是否与已注册的类型实例相等,若匹配则应用对应的SQL类型和转换逻辑。


















