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{ // 错误：这个切片应该嵌套在 Data 结构体内部
    TranslatedText string
    SourceLanguage string // 错误：JSON键名为 "detectedSourceLanguage"
  }
}

type Translation struct{
    Data struct { // 对应JSON中的 "data" 对象
        Translations []struct { // 对应 "data" 对象中的 "translations" 数组
            TranslatedText string `json:"translatedText"` // 对应 "translatedText"
            DetectedSourceLanguage string `json:"detectedSourceLanguage"` // 对应 "detectedSourceLanguage"
        } `json:"translations"` // 对应 "translations" 键
    } `json:"data"` // 对应 "data" 键
}

package main

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

// 请替换为你的Google Translate API密钥
const API_KEY = "YOUR_GOOGLE_TRANSLATE_API_KEY"
const api = "https://translation.googleapis.com/language/translate/v2"

// 正确定义的Translation结构体，精确映射JSON响应
type Translation struct {
    Data struct {
        Translations []struct {
            TranslatedText         string `json:"translatedText"`
            DetectedSourceLanguage string `json:"detectedSourceLanguage"`
        } `json:"translations"`
    } `json:"data"`
}

type InputText struct {
    PlainText      string
    TargetLanguage string
    Values         url.Values
}

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")
    }

    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, 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, _ := ioutil.ReadAll(getResp.Body)
        return nil, fmt.Errorf("API request failed with status %d: %s", getResp.StatusCode, string(bodyBytes))
    }

    body, err := ioutil.ReadAll(getResp.Body)
    if err != nil {
        return nil, fmt.Errorf("failed to read response body: %w", err)
    }

    // 打印原始JSON体，用于调试
    fmt.Println("Raw JSON response:", string(body))

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

    return t, nil
}

func main() {
    // 请替换为你的API密钥
    if API_KEY == "YOUR_GOOGLE_TRANSLATE_API_KEY" {
        log.Fatal("Please replace 'YOUR_GOOGLE_TRANSLATE_API_KEY' with your actual Google Translate API key.")
    }

    input := &InputText{"My name is John, I was born in Nairobi and I am 31 years old", "ES", nil}
    translation, err := input.TranslateString()
    if err != nil {
        log.Fatalf("Translation failed: %v", err)
    }

    if translation != nil && len(translation.Data.Translations) > 0 {
        fmt.Println("Translated Text:", translation.Data.Translations[0].TranslatedText)
        fmt.Println("Detected Source Language:", translation.Data.Translations[0].DetectedSourceLanguage)
    } else {
        fmt.Println("No translation data received or an error occurred.")
    }
}