使用GORM查询用户时，如何排除关联Client中的assignee_user字段

方法一：在GORM预加载时排除关联字段并优化JSON序列化 #

先修正GORM预加载逻辑，同时调整结构体定义避免空字段被序列化：

1. 修改Client结构体的AssigneeUser字段为指针类型，添加omitempty标签：

// Client.go
type Client struct {
    helpers.Model
    Name           string  `gorm:"size:255; not null" json:"name"`
    LastName       string  `gorm:"size:255; not null" json:"lastname"`
    Phone          string  `gorm:"size:255; not null" json:"phone"`
    Address        string  `gorm:"size:255; not null" json:"address"`
    AmountApproved float64 `gorm:"size:255; not null" json:"amount_approved"`
    Status         int     `gorm:"size:1; not null; default:0" json:"status"`

    AssigneeUserID uint  `gorm:"not null" json:"assignee_user_id"`
    AssigneeUser   *User `gorm:"foreignKey:AssigneeUserID" json:"assignee_user,omitempty"` // 改为指针+omitempty
}

2. 调整查询逻辑，在Preload中通过回调排除AssigneeUser字段：

// Service
func GetUser(userId string) models.User {
    var user models.User

    database.DB.Preload("Clients", func(db *gorm.DB) *gorm.DB {
        return db.Omit("AssigneeUser")
    }).First(&user, userId)

    return user
}

此时GORM不会查询AssigneeUser，该字段会是nil，配合omitempty标签后JSON序列化时会自动忽略这个字段。

方法二：使用DTO（数据传输对象）分离模型与响应（推荐） #

这种方式彻底隔离数据库模型和API响应结构，还能避免泄露敏感字段（比如用户的Password）：

1. 定义专用的响应结构体：

// responses.go
import "time"

type UserResponse struct {
    ID            uint             `json:"id"`
    CreatedAt     time.Time        `json:"createdAt"`
    UpdatedAt     time.Time        `json:"updatedAt"`
    Name          string           `json:"name"`
    LastName      string           `json:"lastname"`
    Username      string           `json:"username"`
    Email         string           `json:"email"`
    Phone         string           `json:"phone"`
    Status        int              `json:"status"`
    Clients       []ClientResponse `json:"clients"`
    ClientsCount  int              `json:"clients_count"`
}

type ClientResponse struct {
    ID             uint      `json:"id"`
    CreatedAt      time.Time `json:"createdAt"`
    UpdatedAt      time.Time `json:"updatedAt"`
    Name           string    `json:"name"`
    LastName       string    `json:"lastname"`
    Phone          string    `json:"phone"`
    Address        string    `json:"address"`
    AmountApproved float64   `json:"amount_approved"`
    Status         int       `json:"status"`
    AssigneeUserID uint      `json:"assignee_user_id"`
    // 此处不包含AssigneeUser字段
}

2. 修改查询逻辑，将数据库模型转换为响应结构体：

// Service
func GetUser(userId string) UserResponse {
    var user models.User
    database.DB.Preload("Clients").First(&user, userId)

    // 转换客户列表
    clientResponses := make([]ClientResponse, len(user.Clients))
    for i, client := range user.Clients {
        clientResponses[i] = ClientResponse{
            ID:             client.ID,
            CreatedAt:      client.CreatedAt,
            UpdatedAt:      client.UpdatedAt,
            Name:           client.Name,
            LastName:       client.LastName,
            Phone:          client.Phone,
            Address:        client.Address,
            AmountApproved: client.AmountApproved,
            Status:         client.Status,
            AssigneeUserID: client.AssigneeUserID,
        }
    }

    // 转换用户信息
    return UserResponse{
        ID:            user.ID,
        CreatedAt:     user.CreatedAt,
        UpdatedAt:     user.UpdatedAt,
        Name:          user.Name,
        LastName:      user.LastName,
        Username:      user.Username,
        Email:         user.Email,
        Phone:         user.Phone,
        Status:        user.Status,
        Clients:       clientResponses,
        ClientsCount:  user.ClientsCount,
    }
}

这种方案不仅解决了assignee_user字段的问题，还能严格控制API返回的字段内容，是更规范的后端开发实践。

内容的提问来源于stack exchange，提问作者Mario Campbell