Go语言中JSON反序列化常见陷阱与嵌套结构体设计

{
 "data": {
  "translations": [
   {
    "translatedText": "Mi nombre es John, nació en Nairobi y tengo 31 años de edad",
    "detectedSourceLanguage": "en"
   }
  ]
 }
}

type Translation struct {
  Data         string
  Translations []struct {
    TranslatedText string
    SourceLanguage string // 期望映射到 detectedSourceLanguage
  }
}

// ... (InputText struct and other setup omitted for brevity)

func (i *InputText) TranslateString() (*Translation, error) {
  // ... (HTTP request setup)

  getResp, err := http.Get(u)
  if err != nil {
    log.Fatal("error", err)
    return nil, err
  }
  defer getResp.Body.Close()

  body, err := io.ReadAll(getResp.Body) // 使用 io.ReadAll
  if err != nil {
    log.Fatal("error reading response body", err)
    return nil, err
  }

  // 打印 body 确认 JSON 返回正确
  fmt.Println("Raw JSON response:", string(body))

  t := new(Translation)
  err = json.Unmarshal(body, &t) // 反序列化
  if err != nil {
    log.Fatal("error unmarshalling JSON", err)
    return nil, err
  }

  return t, nil
}

func main() {
  // ...
  translation, _ := input.TranslateString()
  fmt.Println(translation) // 输出: &{[]}
}

type Translation struct {
  Data         string // 错误：JSON中 data 是一个对象，而不是字符串
  Translations []struct { // 错误：Translations 应该在 Data 对象内部
    TranslatedText string
    SourceLanguage string // 字段名与JSON键不匹配
  }
}

type Translation struct {
    Data struct { // Data 字段现在是一个匿名结构体，对应JSON中的 "data" 对象
        Translations []struct { // Translations 字段现在是 Data 结构体的成员
            TranslatedText         string `json:"translatedText"`         // 使用 json tag 明确映射
            DetectedSourceLanguage string `json:"detectedSourceLanguage"` // 使用 json tag 明确映射
        } `json:"translations"` // 使用 json tag 明确映射
    } `json:"data"` // 使用 json tag 明确映射
}

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "log"
    "net/http"
    "net/url"
)

// 定义API密钥和API端点 (实际项目中应从配置或环境变量中获取)
const (
    API_KEY = "YOUR_GOOGLE_TRANSLATE_API_KEY" // 替换为你的API密钥
    API_URL = "https://translation.googleapis.com/language/translate/v2"
)

// Translation 结构体，用于反序列化Google翻译API的响应
// 结构体定义精确匹配JSON的嵌套结构和字段名
type Translation struct {
    Data struct {
        Translations []struct {
            TranslatedText         string `json:"translatedText"`
            DetectedSourceLanguage string `json:"detectedSourceLanguage"`
        } `json:"translations"`
    } `json:"data"`
}

// InputText 结构体，用于封装翻译请求的输入
type InputText struct {
    PlainText      string
    TargetLanguage string
    Values         url.Values
}

// TranslateString 方法向Google翻译API发送请求并反序列化响应
func (i *InputText) TranslateString() (*Translation, error) {
    if len(i.PlainText) == 0 {
        return nil, fmt.Errorf("no text specified for translation")
    }
    if len(i.TargetLanguage) == 0 {
        return nil, fmt.Errorf("no target language specified")
    }
    if API_KEY == "YOUR_GOOGLE_TRANSLATE_API_KEY" || API_KEY == "" {
        return nil, fmt.Errorf("API_KEY is not set or is default. Please replace with your actual key")
    }

    i.Values = make(url.Values)
    var v = i.Values
    v.Set("target", i.TargetLanguage)
    v.Set("key", API_KEY)
    v.Set("q", i.PlainText)

    u := fmt.Sprintf("%s?%s", API_URL, v.Encode())

    getResp, err := http.Get(u)
    if err != nil {
        return nil, fmt.Errorf("http GET request failed: %w", err)
    }
    defer getResp.Body.Close()

    if getResp.StatusCode != http.StatusOK {
        bodyBytes, _ := io.ReadAll(getResp.Body)
        return nil, fmt.Errorf("API returned non-OK status: %d, response: %s", getResp.StatusCode, string(bodyBytes))
    }

    body, err := io.ReadAll(getResp.Body)
    if err != nil {
        return nil, fmt.Errorf("error reading response body: %w", err)
    }

    fmt.Println("--- Raw JSON Response ---")
    fmt.Println(string(body))
    fmt.Println("-------------------------")

    t := new(Translation)
    err = json.Unmarshal(body, &t)
    if err != nil {
        return nil, fmt.Errorf("error unmarshalling JSON: %w", err)
    }

    return t, nil
}

func main() {
    // 示例用法
    input := &InputText{
        PlainText:      "My name is John, I was born in Nairobi and I am 31 years old",
        TargetLanguage: "es", // Spanish
        Values:         nil,
    }

    translation, err := input.TranslateString()
    if err != nil {
        log.Fatalf("Translation failed: %v", err)
    }

    fmt.Println("\n--- Parsed Translation Result ---")
    if len(translation.Data.Translations) > 0 {
        fmt.Printf("Translated Text: %s\n", translation.Data.Translations[0].TranslatedText)
        fmt.Printf("Detected Source Language: %s\n", translation.Data.Translations[0].DetectedSourceLanguage)
    } else {
        fmt.Println("No translations found.")
    }
    fmt.Println("---------------------------------")
}

--- Raw JSON Response ---
{
 "data": {
  "translations": [
   {
    "translatedText": "Mi nombre es John, nací en Nairobi y tengo 31 años.",
    "detectedSourceLanguage": "en"
   }
  ]
 }
}
-------------------------

--- Parsed Translation Result ---
Translated Text: Mi nombre es John, nací en Nairobi y tengo 31 años.
Detected Source Language: en
---------------------------------