Golang中结构体的动态字段实现与应用

Golang中结构体的动态字段实现与应用 我想创建一个产品结构体，它包含一些键值对，这些键值对取决于每个产品。例如，对于手机，我们有这个属性：“screen-size”: “5” 等等；对于另一个产品，比如锅，我们有：“deep”: 4 等等。我必须在结构体中创建一个属性，其类型为 JSON，并将这个字段作为 JSON 保存到数据库中吗？

关于用户权限呢？我必须做同样的事情吗？

进一步解释： 我想建立一个电子商务网站。我们这里有一些产品，管理员可以将其添加到数据库中，客户可以查看和购买。每个产品除了产品名称、产品价格等之外，还有一些属性。我们有一个字段是属性，它包含每个产品的动态值。例如，对于手机，我们有一些属性（基于键值对）；对于厨房的锅，我们有一些其他属性（同样基于键值对）。现在我该如何实现这个。例如，我知道产品名称在产品结构体中是字符串类型，价格是浮点类型，但这个属性在 Go 和 Postgres 数据库中应该是什么类型？


更多关于Golang中结构体的动态字段实现与应用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

5 回复

你好，@mehrdaddolatkhah，也许这篇文章能帮到你：https://www.alexedwards.net/blog/using-postgresql-jsonb

更多关于Golang中结构体的动态字段实现与应用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


并且价格是浮点类型

抱歉没有评论其他部分，但请不要那样做。

谢谢。如果我想在结构体中实现一个 map 数组结构，它看起来会像这样：Property []map[string]string json:"property"。 那么我该如何在 API 中填充它，将其保存到 Postgres 数据库，然后再从 Postgres 中读取它呢？ 正如我所说，我们有不同的键和不同的值。

这里的最佳解决方案难道不是使用Map吗？

  • Map是一个无序的键值对集合。
  • Map 用于通过其关联的键来检索、更新或删除值。
  • 在Go中，一个 map 是对哈希表的引用，其中所有的键都是唯一的。
  • Map 类型写作 map[K]V，其中K和V分别是其键和值的类型。
  • 一个map有长度和容量，它们是可以修改的。
  • Maps 是Go内置的关联数据类型。

我写了一篇关于Map的完整文章，也许会有帮助。 我仍在全力学习GO，但我不确定这是否是您任务的最佳选择。根据我对您描述的理解，这似乎正是您要找的完美方案。

干杯。

Medium图标

GO: 理解 Map — 第1部分

这篇文章是关于如何在GO（Golang）中使用map的。

阅读时间：4分钟

在Go中实现动态字段的结构体，通常有以下几种方案：

方案1：使用map[string]interface{}类型

package main

import (
    "encoding/json"
    "fmt"
)

type Product struct {
    ID          int                    `json:"id"`
    Name        string                 `json:"name"`
    Price       float64                `json:"price"`
    Category    string                 `json:"category"`
    Attributes  map[string]interface{} `json:"attributes"`
}

func main() {
    // 手机产品示例
    phone := Product{
        ID:       1,
        Name:     "iPhone 15",
        Price:    999.99,
        Category: "electronics",
        Attributes: map[string]interface{}{
            "screen-size": "6.1",
            "ram":         "8GB",
            "storage":     "256GB",
            "battery":     3349,
        },
    }

    // 锅产品示例
    pot := Product{
        ID:       2,
        Name:     "不锈钢汤锅",
        Price:    49.99,
        Category: "kitchen",
        Attributes: map[string]interface{}{
            "diameter":  "24cm",
            "depth":     12,
            "material":  "stainless-steel",
            "capacity":  "5L",
        },
    }

    // 转换为JSON
    phoneJSON, _ := json.MarshalIndent(phone, "", "  ")
    fmt.Println("手机产品JSON:")
    fmt.Println(string(phoneJSON))

    potJSON, _ := json.MarshalIndent(pot, "", "  ")
    fmt.Println("\n锅产品JSON:")
    fmt.Println(string(potJSON))
}

方案2：使用JSONB字段（PostgreSQL + GORM）

package main

import (
    "encoding/json"
    "fmt"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
    "gorm.io/datatypes"
)

type Product struct {
    gorm.Model
    Name       string         `gorm:"type:varchar(100)"`
    Price      float64        `gorm:"type:decimal(10,2)"`
    CategoryID uint
    Attributes datatypes.JSON `gorm:"type:jsonb"`
}

func main() {
    dsn := "host=localhost user=gorm password=gorm dbname=gorm port=9920 sslmode=disable"
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("数据库连接失败")
    }

    // 自动迁移
    db.AutoMigrate(&Product{})

    // 创建手机产品
    phoneAttrs := map[string]interface{}{
        "screen_size": "6.1英寸",
        "processor":   "A16 Bionic",
        "camera":      "48MP",
        "weight":      171,
    }
    
    attrsJSON, _ := json.Marshal(phoneAttrs)
    phone := Product{
        Name:       "iPhone 15 Pro",
        Price:      1299.99,
        CategoryID: 1,
        Attributes: datatypes.JSON(attrsJSON),
    }

    // 保存到数据库
    db.Create(&phone)

    // 查询产品
    var product Product
    db.First(&product, 1)
    
    // 解析属性
    var attributes map[string]interface{}
    json.Unmarshal(product.Attributes, &attributes)
    fmt.Printf("产品属性: %v\n", attributes)
}

方案3：使用自定义类型和验证

package main

import (
    "encoding/json"
    "fmt"
)

type ProductAttributes map[string]AttributeValue

type AttributeValue struct {
    Value     interface{} `json:"value"`
    DataType  string      `json:"data_type"` // string, number, boolean
    Unit      string      `json:"unit,omitempty"`
}

type Product struct {
    ID         int               `json:"id"`
    Name       string            `json:"name"`
    Price      float64           `json:"price"`
    Category   string            `json:"category"`
    Attributes ProductAttributes `json:"attributes"`
}

func main() {
    product := Product{
        ID:       1,
        Name:     "智能手机",
        Price:    899.99,
        Category: "electronics",
        Attributes: ProductAttributes{
            "screen_size": AttributeValue{
                Value:    6.7,
                DataType: "number",
                Unit:     "英寸",
            },
            "water_resistant": AttributeValue{
                Value:    true,
                DataType: "boolean",
            },
            "color": AttributeValue{
                Value:    "黑色",
                DataType: "string",
            },
        },
    }

    jsonData, _ := json.MarshalIndent(product, "", "  ")
    fmt.Println(string(jsonData))
}

数据库表结构（PostgreSQL）

-- 产品表
CREATE TABLE products (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    price DECIMAL(10,2) NOT NULL,
    category_id INTEGER REFERENCES categories(id),
    attributes JSONB NOT NULL DEFAULT '{}',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- 或者使用文本类型存储JSON
CREATE TABLE products (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    price DECIMAL(10,2) NOT NULL,
    attributes TEXT NOT NULL DEFAULT '{}',
    CHECK (json_valid(attributes))
);

关于用户权限的实现

对于用户权限，可以采用类似的动态结构：

type User struct {
    ID       int                    `json:"id"`
    Username string                 `json:"username"`
    Email    string                 `json:"email"`
    Roles    []string               `json:"roles"`
    Permissions map[string]bool     `json:"permissions"` // 动态权限
}

// 或者使用JSON字段
type User struct {
    gorm.Model
    Username    string         `gorm:"uniqueIndex"`
    Profile     datatypes.JSON `gorm:"type:jsonb"` // 存储动态用户信息
    Settings    datatypes.JSON `gorm:"type:jsonb"` // 存储用户设置
}

查询示例

// 查询特定属性的产品
db.Where("attributes->>'screen_size' = ?", "6.1英寸").Find(&products)

// 查询包含某个键的产品
db.Where("attributes ? 'camera'").Find(&products)

// 查询属性值大于某个值的产品
db.Where("CAST(attributes->>'weight' AS INTEGER) > ?", 150).Find(&products)

这种设计允许灵活存储不同产品的动态属性，同时保持数据库查询能力。JSONB类型在PostgreSQL中支持索引和高效查询，适合电商产品的动态属性场景。

回到顶部