Golang Web服务与数据格式解析指南

在Golang Web服务中处理不同数据格式是常见需求。以下是针对你场景的专业实现方案：

1. 核心解决方案：使用DTO模式

你的方法基本正确，但可以优化转换逻辑。以下是改进的实现：

// 领域模型（数据库结构）
type Hotel struct {
    HotelID  string    `db:"hotel_id"`
    Name     string    `db:"name"`
    Address  string    `db:"address"`
    NbRooms  int32     `db:"nb_rooms"`
    Pictures []Picture `db:"-"`
    Rooms    []Room    `db:"-"`
}

// DTO结构体
type HotelListItemDTO struct {
    HotelID string `json:"hotel_id"`
    Name    string `json:"name"`
    Address string `json:"address"`
    NbRooms int32  `json:"nb_rooms"`
}

type HotelDetailDTO struct {
    HotelID  string         `json:"hotel_id"`
    Name     string         `json:"name"`
    Address  string         `json:"address"`
    NbRooms  int32          `json:"nb_rooms"`
    Pictures []PictureDTO   `json:"pictures"`
    Rooms    []RoomListItem `json:"rooms"`
}

// 转换方法
func (h *Hotel) ToListItemDTO() HotelListItemDTO {
    return HotelListItemDTO{
        HotelID: h.HotelID,
        Name:    h.Name,
        Address: h.Address,
        NbRooms: h.NbRooms,
    }
}

func (h *Hotel) ToDetailDTO() HotelDetailDTO {
    pictureDTOs := make([]PictureDTO, len(h.Pictures))
    for i, p := range h.Pictures {
        pictureDTOs[i] = p.ToDTO()
    }
    
    roomItems := make([]RoomListItem, len(h.Rooms))
    for i, r := range h.Rooms {
        roomItems[i] = r.ToListItem()
    }
    
    return HotelDetailDTO{
        HotelID:  h.HotelID,
        Name:     h.Name,
        Address:  h.Address,
        NbRooms:  h.NbRooms,
        Pictures: pictureDTOs,
        Rooms:    roomItems,
    }
}

2. 使用组合减少重复代码

// 基础结构体
type HotelBase struct {
    HotelID string `json:"hotel_id"`
    Name    string `json:"name"`
    Address string `json:"address"`
    NbRooms int32  `json:"nb_rooms"`
}

// 组合DTO
type HotelListItemDTO struct {
    HotelBase
}

type HotelDetailDTO struct {
    HotelBase
    Pictures []PictureDTO   `json:"pictures,omitempty"`
    Rooms    []RoomListItem `json:"rooms,omitempty"`
}

// 使用嵌入
type HotelSearchResult struct {
    HotelBase
    AvailableRooms int32   `json:"available_rooms"`
    MinPrice       float32 `json:"min_price"`
}

3. 使用函数式转换器

type HotelTransformer func(*Hotel) interface{}

var transformers = map[string]HotelTransformer{
    "list":   transformToList,
    "detail": transformToDetail,
    "search": transformToSearch,
}

func transformToList(h *Hotel) interface{} {
    return HotelListItemDTO{
        HotelID: h.HotelID,
        Name:    h.Name,
        Address: h.Address,
        NbRooms: h.NbRooms,
    }
}

func transformToDetail(h *Hotel) interface{} {
    return HotelDetailDTO{
        HotelID:  h.HotelID,
        Name:     h.Name,
        Address:  h.Address,
        NbRooms:  h.NbRooms,
        Pictures: transformPictures(h.Pictures),
        Rooms:    transformRooms(h.Rooms),
    }
}

// 在handler中使用
func GetHotels(w http.ResponseWriter, r *http.Request) {
    viewType := r.URL.Query().Get("view")
    transformer, exists := transformers[viewType]
    if !exists {
        transformer = transformers["list"]
    }
    
    hotels := fetchHotelsFromDB()
    result := make([]interface{}, len(hotels))
    for i, h := range hotels {
        result[i] = transformer(h)
    }
    
    json.NewEncoder(w).Encode(map[string]interface{}{
        "hotel_list": result,
    })
}

4. 使用结构体标签控制JSON输出

type HotelResponse struct {
    HotelID  string          `json:"hotel_id"`
    Name     string          `json:"name"`
    Address  string          `json:"address,omitempty"`  // 为空时不输出
    NbRooms  int32           `json:"nb_rooms"`
    Pictures []Picture       `json:"pictures,omitempty"`
    Rooms    []Room          `json:"rooms,omitempty"`
    
    // 使用自定义标签控制不同视图
    IncludePictures bool     `json:"-" query:"include_pictures"`
    IncludeRooms    bool     `json:"-" query:"include_rooms"`
}

// 自定义MarshalJSON
func (h HotelResponse) MarshalJSON() ([]byte, error) {
    type Alias HotelResponse
    aux := &struct {
        *Alias
        Pictures []Picture `json:"pictures,omitempty"`
        Rooms    []Room    `json:"rooms,omitempty"`
    }{
        Alias: (*Alias)(&h),
    }
    
    if h.IncludePictures {
        aux.Pictures = h.Pictures
    }
    if h.IncludeRooms {
        aux.Rooms = h.Rooms
    }
    
    return json.Marshal(aux)
}

5. 使用SQL查询优化

// 根据视图类型构建查询
func buildHotelQuery(viewType string) string {
    switch viewType {
    case "list":
        return `SELECT hotel_id, name, address, nb_rooms FROM hotels`
    case "detail":
        return `
            SELECT h.hotel_id, h.name, h.address, h.nb_rooms,
                   p.url, p.order, p.description,
                   r.room_nb, r.capacity, r.surface, r.price
            FROM hotels h
            LEFT JOIN pictures p ON h.hotel_id = p.hotel_id
            LEFT JOIN rooms r ON h.hotel_id = r.hotel_id
        `
    default:
        return `SELECT hotel_id, name FROM hotels`
    }
}

// 使用sqlx扫描到不同结构体
func fetchHotels(viewType string) (interface{}, error) {
    query := buildHotelQuery(viewType)
    
    switch viewType {
    case "list":
        var hotels []HotelListItemDTO
        err := db.Select(&hotels, query)
        return hotels, err
    case "detail":
        var hotels []HotelDetailDTO
        err := db.Select(&hotels, query)
        return hotels, err
    default:
        var hotels []HotelBase
        err := db.Select(&hotels, query)
        return hotels, err
    }
}

6. 使用代码生成工具

对于大量DTO，可以考虑使用代码生成：

// 使用go:generate指令
//go:generate dto-generator -type=Hotel -output=hotel_dto.go

// 生成的代码示例
type HotelListResponse struct {
    Hotels []HotelListItem `json:"hotels"`
    Total  int             `json:"total"`
    Page   int             `json:"page"`
}

type HotelSearchResponse struct {
    Hotels []HotelSearchItem `json:"hotels"`
    Filters map[string]interface{} `json:"filters"`
}

这些方案提供了可扩展的方式来处理不同UI视图的数据格式需求。DTO模式在Golang Web开发中是标准实践，结合结构体组合和转换器模式可以有效管理复杂度。