🌟 데이터 직렬화, 왜 필요한 걸까?

안녕! 오늘은 Go언어에서 정말 중요한 주제를 다뤄볼 거야. 바로 JSON과 XML 처리, 그리고 데이터 직렬화에 대한 이야기야. 😊

먼저 데이터 직렬화(Serialization)가 뭔지부터 알아볼까? 쉽게 말하면, 프로그램 안에서 사용하는 복잡한 데이터 구조를 다른 시스템이나 네트워크를 통해 전송할 수 있는 형태로 변환하는 과정이야. 마치 택배를 보낼 때 물건을 박스에 포장하는 것과 비슷하지!

반대로 역직렬화(Deserialization)는 받은 데이터를 다시 프로그램에서 사용할 수 있는 형태로 풀어내는 거야. 택배 박스를 열어서 물건을 꺼내는 것처럼 말이야. 📦

📚 Go의 encoding 패키지 패밀리

Go 언어는 데이터 직렬화를 위해 정말 훌륭한 표준 라이브러리를 제공하고 있어. encoding 패키지 아래에 여러 하위 패키지들이 있는데, 오늘 우리가 집중적으로 볼 건 다음 두 가지야:

• encoding/json - JSON 데이터 처리
• encoding/xml - XML 데이터 처리

이 외에도 encoding/csv, encoding/base64, encoding/hex 등 다양한 패키지들이 있지만, 실무에서 가장 많이 사용하는 건 단연 JSON과 XML이야! 🎯

🎨 JSON 처리의 기본 - Marshal과 Unmarshal

JSON 처리의 핵심은 두 가지 함수야. Marshal과 Unmarshal! 이름이 좀 어렵게 느껴질 수 있는데, 쉽게 생각하면 돼:

• Marshal: Go 데이터 → JSON 문자열 (직렬화)
• Unmarshal: JSON 문자열 → Go 데이터 (역직렬화)

자, 이제 실제 코드로 살펴볼까? 😊

package main

import (
    "encoding/json"
    "fmt"
    "log"
)

// 사용자 정보를 담을 구조체
type User struct {
    Name    string `json:"name"`
    Age     int    `json:"age"`
    Email   string `json:"email"`
    IsAdmin bool   `json:"is_admin"`
}

func main() {
    // 1. Marshal 예제 - 구조체를 JSON으로 변환
    user := User{
        Name:    "김철수",
        Age:     28,
        Email:   "chulsoo@example.com",
        IsAdmin: false,
    }
    
    // JSON으로 변환 (직렬화)
    jsonData, err := json.Marshal(user)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Println("JSON 데이터:", string(jsonData))
    // 출력: {"name":"김철수","age":28,"email":"chulsoo@example.com","is_admin":false}
    
    // 2. Unmarshal 예제 - JSON을 구조체로 변환
    jsonString := `{"name":"이영희","age":25,"email":"younghee@example.com","is_admin":true}`
    
    var newUser User
    err = json.Unmarshal([]byte(jsonString), &newUser)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("이름: %s, 나이: %d, 관리자: %v\n", 
        newUser.Name, newUser.Age, newUser.IsAdmin)
    // 출력: 이름: 이영희, 나이: 25, 관리자: true
}

🎯 JSON 태그 옵션 완전 정복

구조체 태그에는 다양한 옵션을 줄 수 있어. 이걸 잘 활용하면 정말 강력한 JSON 처리가 가능해! 하나씩 살펴보자. 💪

type Product struct {
    // 기본 매핑
    ID          int     `json:"id"`
    
    // omitempty: 값이 비어있으면 JSON에서 제외
    Name        string  `json:"name,omitempty"`
    
    // -: JSON 변환 시 완전히 무시
    InternalCode string `json:"-"`
    
    // string: 숫자를 문자열로 변환
    Price       int     `json:"price,string"`
    
    // 태그 없음: 필드명 그대로 사용
    Category    string
}

각 옵션을 실제로 사용해보면 이렇게 동작해:

func main() {
    product := Product{
        ID:           1,
        Name:         "", // 비어있음
        InternalCode: "SECRET-123",
        Price:        15000,
        Category:     "Electronics",
    }
    
    jsonData, _ := json.Marshal(product)
    fmt.Println(string(jsonData))
    // 출력: {"id":1,"price":"15000","Category":"Electronics"}
    // name은 omitempty로 제외됨
    // InternalCode는 - 옵션으로 제외됨
    // price는 문자열로 변환됨
}

🌈 중첩 구조체와 복잡한 JSON 다루기

실제 프로젝트에서는 단순한 구조체보다 복잡하게 중첩된 데이터를 다루는 경우가 많아. 이럴 때도 Go는 정말 우아하게 처리할 수 있어! 🎨

type Address struct {
    Street  string `json:"street"`
    City    string `json:"city"`
    ZipCode string `json:"zip_code"`
}

type Company struct {
    Name    string  `json:"name"`
    Address Address `json:"address"`
}

type Employee struct {
    ID       int      `json:"id"`
    Name     string   `json:"name"`
    Company  Company  `json:"company"`
    Skills   []string `json:"skills"`
    Metadata map[string]interface{} `json:"metadata,omitempty"`
}

func main() {
    employee := Employee{
        ID:   101,
        Name: "박지성",
        Company: Company{
            Name: "테크스타트업",
            Address: Address{
                Street:  "테헤란로 123",
                City:    "서울",
                ZipCode: "06234",
            },
        },
        Skills: []string{"Go", "Python", "JavaScript"},
        Metadata: map[string]interface{}{
            "hire_date": "2023-01-15",
            "level":     "Senior",
            "remote":    true,
        },
    }
    
    // 예쁘게 출력하기 위해 MarshalIndent 사용
    jsonData, err := json.MarshalIndent(employee, "", "  ")
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Println(string(jsonData))
}

위 코드를 실행하면 이렇게 예쁘게 포맷된 JSON이 출력돼:

{
  "id": 101,
  "name": "박지성",
  "company": {
    "name": "테크스타트업",
    "address": {
      "street": "테헤란로 123",
      "city": "서울",
      "zip_code": "06234"
    }
  },
  "skills": [
    "Go",
    "Python",
    "JavaScript"
  ],
  "metadata": {
    "hire_date": "2023-01-15",
    "level": "Senior",
    "remote": true
  }
}

🔍 동적 JSON 처리 - interface{}의 활용

때로는 JSON 구조를 미리 알 수 없는 경우가 있어. API 응답이 매번 다르거나, 설정 파일이 유연한 구조를 가질 때 말이야. 이럴 때는 interface{}를 활용하면 돼! 🎭

func main() {
    // 구조를 모르는 JSON 데이터
    jsonString := `{
        "status": "success",
        "data": {
            "users": [
                {"name": "Alice", "age": 30},
                {"name": "Bob", "age": 25}
            ],
            "total": 2
        },
        "timestamp": 1234567890
    }`
    
    // interface{}로 받기
    var result map[string]interface{}
    err := json.Unmarshal([]byte(jsonString), &result)
    if err != nil {
        log.Fatal(err)
    }
    
    // 타입 단언(Type Assertion)으로 접근
    status := result["status"].(string)
    fmt.Println("상태:", status)
    
    data := result["data"].(map[string]interface{})
    total := data["total"].(float64) // JSON 숫자는 float64로 변환됨!
    fmt.Println("총 개수:", int(total))
    
    users := data["users"].([]interface{})
    for _, u := range users {
        user := u.(map[string]interface{})
        name := user["name"].(string)
        age := user["age"].(float64)
        fmt.Printf("이름: %s, 나이: %.0f\n", name, age)
    }
}

🎪 커스텀 JSON 마샬링 - MarshalJSON 인터페이스

때로는 기본 JSON 변환 방식이 마음에 들지 않을 수 있어. 예를 들어 날짜를 특정 포맷으로 출력하고 싶다거나, 민감한 정보를 마스킹하고 싶을 때 말이야. 이럴 때는 json.Marshaler 인터페이스를 구현하면 돼! 🎨

import (
    "encoding/json"
    "fmt"
    "time"
)

type CustomDate struct {
    time.Time
}

// MarshalJSON 메서드 구현
func (cd CustomDate) MarshalJSON() ([]byte, error) {
    // 원하는 포맷으로 날짜 변환
    formatted := cd.Format("2006년 01월 02일")
    return json.Marshal(formatted)
}

// UnmarshalJSON 메서드 구현
func (cd *CustomDate) UnmarshalJSON(data []byte) error {
    var dateStr string
    if err := json.Unmarshal(data, &dateStr); err != nil {
        return err
    }
    
    parsed, err := time.Parse("2006년 01월 02일", dateStr)
    if err != nil {
        return err
    }
    
    cd.Time = parsed
    return nil
}

type Event struct {
    Name string     `json:"name"`
    Date CustomDate `json:"date"`
}

func main() {
    event := Event{
        Name: "Go 컨퍼런스",
        Date: CustomDate{time.Now()},
    }
    
    jsonData, _ := json.MarshalIndent(event, "", "  ")
    fmt.Println(string(jsonData))
    // 출력: {"name":"Go 컨퍼런스","date":"2024년 01월 15일"}
}

또 다른 실용적인 예제로 비밀번호 마스킹을 해볼까? 🔐

type SecureUser struct {
    Username string `json:"username"`
    Password string `json:"-"` // 기본적으로 제외
    Email    string `json:"email"`
}

// MarshalJSON으로 비밀번호를 마스킹
func (su SecureUser) MarshalJSON() ([]byte, error) {
    type Alias SecureUser // 무한 재귀 방지
    return json.Marshal(&struct {
        *Alias
        Password string `json:"password"`
    }{
        Alias:    (*Alias)(&su),
        Password: "****", // 마스킹된 값
    })
}

func main() {
    user := SecureUser{
        Username: "gopher",
        Password: "super-secret-123",
        Email:    "gopher@example.com",
    }
    
    jsonData, _ := json.MarshalIndent(user, "", "  ")
    fmt.Println(string(jsonData))
    // 출력: {"username":"gopher","email":"gopher@example.com","password":"****"}
}

📝 JSON Encoder와 Decoder - 스트림 처리

지금까지 본 Marshal과 Unmarshal은 메모리에 있는 데이터를 한 번에 처리하는 방식이야. 하지만 큰 파일을 읽거나, 네트워크 스트림을 처리할 때는 Encoder와 Decoder를 사용하는 게 더 효율적이야! 🚀

import (
    "encoding/json"
    "os"
)

type LogEntry struct {
    Timestamp string `json:"timestamp"`
    Level     string `json:"level"`
    Message   string `json:"message"`
}

func writeLogsToFile() error {
    file, err := os.Create("logs.json")
    if err != nil {
        return err
    }
    defer file.Close()
    
    // Encoder 생성 - 파일에 직접 쓰기
    encoder := json.NewEncoder(file)
    encoder.SetIndent("", "  ") // 예쁘게 포맷
    
    logs := []LogEntry{
        {Timestamp: "2024-01-15 10:00:00", Level: "INFO", Message: "서버 시작"},
        {Timestamp: "2024-01-15 10:05:00", Level: "WARN", Message: "메모리 사용량 높음"},
        {Timestamp: "2024-01-15 10:10:00", Level: "ERROR", Message: "데이터베이스 연결 실패"},
    }
    
    // 각 로그를 순차적으로 인코딩
    for _, log := range logs {
        if err := encoder.Encode(log); err != nil {
            return err
        }
    }
    
    return nil
}

func readLogsFromFile() error {
    file, err := os.Open("logs.json")
    if err != nil {
        return err
    }
    defer file.Close()
    
    // Decoder 생성 - 파일에서 직접 읽기
    decoder := json.NewDecoder(file)
    
    // 스트림에서 하나씩 디코딩
    for decoder.More() {
        var log LogEntry
        if err := decoder.Decode(&log); err != nil {
            return err
        }
        fmt.Printf("[%s] %s: %s\n", log.Level, log.Timestamp, log.Message)
    }
    
    return nil
}

🎪 XML 처리 - JSON의 형제

자, 이제 XML을 살펴볼 차례야! XML은 JSON보다 좀 더 복잡하고 장황하지만, 여전히 많은 곳에서 사용되고 있어. 특히 레거시 시스템이나 SOAP API, 설정 파일 등에서 말이야. 📜

Go의 encoding/xml 패키지는 JSON 패키지와 매우 유사한 인터페이스를 제공해서 배우기 쉬워!

import (
    "encoding/xml"
    "fmt"
)

// XML 구조체 정의
type Book struct {
    XMLName xml.Name `xml:"book"` // 루트 엘리먼트 이름
    Title   string   `xml:"title"`
    Author  string   `xml:"author"`
    Year    int      `xml:"year"`
    ISBN    string   `xml:"isbn,attr"` // 속성으로 표현
    Pages   int      `xml:"pages,omitempty"`
}

type Library struct {
    XMLName xml.Name `xml:"library"`
    Name    string   `xml:"name,attr"`
    Books   []Book   `xml:"book"`
}

func main() {
    library := Library{
        Name: "중앙도서관",
        Books: []Book{
            {
                Title:  "Go 프로그래밍",
                Author: "김고퍼",
                Year:   2024,
                ISBN:   "978-1234567890",
                Pages:  450,
            },
            {
                Title:  "클린 코드",
                Author: "로버트 마틴",
                Year:   2008,
                ISBN:   "978-0132350884",
                Pages:  464,
            },
        },
    }
    
    // XML로 마샬링
    xmlData, err := xml.MarshalIndent(library, "", "  ")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    
    // XML 선언 추가
    output := xml.Header + string(xmlData)
    fmt.Println(output)
}

위 코드의 출력 결과는 이렇게 나와:

<?xml version="1.0" encoding="UTF-8"?>
<library name="중앙도서관">
  <book isbn="978-1234567890">
    <title>Go 프로그래밍</title>
    <author>김고퍼</author>
    <year>2024</year>
    <pages>450</pages>
  </book>
  <book isbn="978-0132350884">
    <title>클린 코드</title>
    <author>로버트 마틴</author>
    <year>2008</year>
    <pages>464</pages>
  </book>
</library>

🏷️ XML 태그 옵션 완전 가이드

XML 태그도 JSON처럼 다양한 옵션을 제공해. 하나씩 알아보자! 🎨

실제 예제로 이 옵션들을 활용해보자:

type Article struct {
    XMLName xml.Name `xml:"article"`
    ID      string   `xml:"id,attr"`
    Lang    string   `xml:"lang,attr,omitempty"`
    Title   string   `xml:"title"`
    Content string   `xml:"content,cdata"` // HTML 포함 가능
    Author  Author   `xml:"author"`
    Tags    []string `xml:"tags>tag"` // 중첩 구조
}

type Author struct {
    Name  string `xml:"name"`
    Email string `xml:"email,omitempty"`
}

func main() {
    article := Article{
        ID:    "article-001",
        Lang:  "ko",
        Title: "Go와 XML",
        Content: "<p>이것은 <strong>HTML</strong> 내용입니다.</p>",
        Author: Author{
            Name:  "김개발",
            Email: "dev@example.com",
        },
        Tags: []string{"Go", "XML", "프로그래밍"},
    }
    
    xmlData, _ := xml.MarshalIndent(article, "", "  ")
    fmt.Println(xml.Header + string(xmlData))
}

🎯 XML 네임스페이스 처리

XML의 강력한 기능 중 하나가 네임스페이스야. 여러 XML 스키마를 혼합해서 사용할 때 이름 충돌을 방지할 수 있지. Go에서도 이걸 지원해! 🌐

type RSS struct {
    XMLName xml.Name `xml:"rss"`
    Version string   `xml:"version,attr"`
    Channel Channel  `xml:"channel"`
    
    // 네임스페이스 선언
    XMLNS   string `xml:"xmlns:atom,attr"`
    Content string `xml:"xmlns:content,attr"`
}

type Channel struct {
    Title       string `xml:"title"`
    Link        string `xml:"link"`
    Description string `xml:"description"`
    Items       []Item `xml:"item"`
    
    // atom 네임스페이스 사용
    AtomLink AtomLink `xml:"atom:link"`
}

type AtomLink struct {
    Href string `xml:"href,attr"`
    Rel  string `xml:"rel,attr"`
    Type string `xml:"type,attr"`
}

type Item struct {
    Title       string `xml:"title"`
    Link        string `xml:"link"`
    Description string `xml:"description"`
    PubDate     string `xml:"pubDate"`
    
    // content 네임스페이스 사용
    ContentEncoded string `xml:"content:encoded"`
}

func main() {
    rss := RSS{
        Version: "2.0",
        XMLNS:   "http://www.w3.org/2005/Atom",
        Content: "http://purl.org/rss/1.0/modules/content/",
        Channel: Channel{
            Title:       "Go 프로그래밍 블로그",
            Link:        "https://example.com",
            Description: "Go 언어에 대한 모든 것",
            AtomLink: AtomLink{
                Href: "https://example.com/feed",
                Rel:  "self",
                Type: "application/rss+xml",
            },
            Items: []Item{
                {
                    Title:          "Go 1.22 출시",
                    Link:           "https://example.com/go-1.22",
                    Description:    "새로운 기능 소개",
                    PubDate:        "Mon, 15 Jan 2024 10:00:00 GMT",
                    ContentEncoded: "<p>상세한 HTML 내용...</p>",
                },
            },
        },
    }
    
    xmlData, _ := xml.MarshalIndent(rss, "", "  ")
    fmt.Println(xml.Header + string(xmlData))
}

🔄 JSON과 XML 상호 변환

실무에서는 JSON과 XML을 서로 변환해야 하는 경우가 많아. 예를 들어 레거시 시스템은 XML을 사용하는데, 모던 프론트엔드는 JSON을 선호하는 경우 말이야. 이럴 때 어떻게 할까? 🔄

import (
    "encoding/json"
    "encoding/xml"
    "fmt"
)

// 공통 데이터 구조
type Product struct {
    ID          int     `json:"id" xml:"id,attr"`
    Name        string  `json:"name" xml:"name"`
    Price       float64 `json:"price" xml:"price"`
    Category    string  `json:"category" xml:"category"`
    InStock     bool    `json:"in_stock" xml:"in_stock"`
    Description string  `json:"description,omitempty" xml:"description,omitempty"`
}

// JSON을 XML로 변환
func jsonToXML(jsonData []byte) ([]byte, error) {
    var product Product
    
    // JSON 파싱
    if err := json.Unmarshal(jsonData, &product); err != nil {
        return nil, err
    }
    
    // XML로 변환
    xmlData, err := xml.MarshalIndent(product, "", "  ")
    if err != nil {
        return nil, err
    }
    
    return append([]byte(xml.Header), xmlData...), nil
}

// XML을 JSON으로 변환
func xmlToJSON(xmlData []byte) ([]byte, error) {
    var product Product
    
    // XML 파싱
    if err := xml.Unmarshal(xmlData, &product); err != nil {
        return nil, err
    }
    
    // JSON으로 변환
    jsonData, err := json.MarshalIndent(product, "", "  ")
    if err != nil {
        return nil, err
    }
    
    return jsonData, nil
}

func main() {
    // JSON 데이터
    jsonStr := `{
        "id": 101,
        "name": "Go 프로그래밍 책",
        "price": 35000,
        "category": "도서",
        "in_stock": true,
        "description": "Go 언어 완벽 가이드"
    }`
    
    // JSON → XML
    xmlData, err := jsonToXML([]byte(jsonStr))
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    
    fmt.Println("=== XML 출력 ===")
    fmt.Println(string(xmlData))
    
    // XML → JSON
    jsonData, err := xmlToJSON(xmlData)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    
    fmt.Println("\n=== JSON 출력 ===")
    fmt.Println(string(jsonData))
}

⚡ 성능 최적화 팁

데이터 직렬화는 성능에 민감한 작업이야. 특히 대용량 데이터를 처리하거나 높은 처리량이 필요한 서비스에서는 최적화가 정말 중요해! 몇 가지 실용적인 팁을 알려줄게. 🚀

import (
    "bytes"
    "encoding/json"
    "sync"
)

// 버퍼 풀로 메모리 재사용
var bufferPool = sync.Pool{
    New: func() interface{} {
        return new(bytes.Buffer)
    },
}

// 최적화된 JSON 마샬링
func optimizedMarshal(v interface{}) ([]byte, error) {
    buf := bufferPool.Get().(*bytes.Buffer)
    buf.Reset()
    defer bufferPool.Put(buf)
    
    encoder := json.NewEncoder(buf)
    if err := encoder.Encode(v); err != nil {
        return nil, err
    }
    
    // 마지막 개행 문자 제거
    result := buf.Bytes()
    if len(result) > 0 && result[len(result)-1] == '\n' {
        result = result[:len(result)-1]
    }
    
    return result, nil
}

// 병렬 처리 예제
func processMultipleFiles(filenames []string) error {
    var wg sync.WaitGroup
    errChan := make(chan error, len(filenames))
    
    for _, filename := range filenames {
        wg.Add(1)
        go func(fname string) {
            defer wg.Done()
            
            // 파일 처리 로직
            if err := processFile(fname); err != nil {
                errChan <- err
            }
        }(filename)
    }
    
    wg.Wait()
    close(errChan)
    
    // 에러 체크
    for err := range errChan {
        if err != nil {
            return err
        }
    }
    
    return nil
}

func processFile(filename string) error {
    // 파일 처리 구현
    return nil
}

🎯 실전 예제: RESTful API 클라이언트

이제 배운 내용을 종합해서 실제 RESTful API 클라이언트를 만들어보자! 이건 정말 실무에서 자주 사용하는 패턴이야. 😊

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
)

// API 응답 구조체
type APIResponse struct {
    Success bool        `json:"success"`
    Data    interface{} `json:"data,omitempty"`
    Error   string      `json:"error,omitempty"`
    Meta    Meta        `json:"meta"`
}

type Meta struct {
    Timestamp time.Time `json:"timestamp"`
    Version   string    `json:"version"`
}

// 사용자 데이터
type User struct {
    ID        int       `json:"id,omitempty"`
    Username  string    `json:"username"`
    Email     string    `json:"email"`
    CreatedAt time.Time `json:"created_at,omitempty"`
}

// API 클라이언트
type APIClient struct {
    BaseURL    string
    HTTPClient *http.Client
}

func NewAPIClient(baseURL string) *APIClient {
    return &APIClient{
        BaseURL: baseURL,
        HTTPClient: &http.Client{
            Timeout: 10 * time.Second,
        },
    }
}

// GET 요청
func (c *APIClient) GetUser(userID int) (*User, error) {
    url := fmt.Sprintf("%s/users/%d", c.BaseURL, userID)
    
    resp, err := c.HTTPClient.Get(url)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("API error: status %d", resp.StatusCode)
    }
    
    var apiResp APIResponse
    if err := json.NewDecoder(resp.Body).Decode(&apiResp); err != nil {
        return nil, err
    }
    
    if !apiResp.Success {
        return nil, fmt.Errorf("API error: %s", apiResp.Error)
    }
    
    // interface{}를 User로 변환
    userData, _ := json.Marshal(apiResp.Data)
    var user User
    if err := json.Unmarshal(userData, &user); err != nil {
        return nil, err
    }
    
    return &user, nil
}

// POST 요청
func (c *APIClient) CreateUser(user *User) (*User, error) {
    url := fmt.Sprintf("%s/users", c.BaseURL)
    
    // 요청 바디 생성
    jsonData, err := json.Marshal(user)
    if err != nil {
        return nil, err
    }
    
    resp, err := c.HTTPClient.Post(url, "application/json", bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != http.StatusCreated {
        body, _ := io.ReadAll(resp.Body)
        return nil, fmt.Errorf("API error: status %d, body: %s", resp.StatusCode, string(body))
    }
    
    var apiResp APIResponse
    if err := json.NewDecoder(resp.Body).Decode(&apiResp); err != nil {
        return nil, err
    }
    
    userData, _ := json.Marshal(apiResp.Data)
    var createdUser User
    if err := json.Unmarshal(userData, &createdUser); err != nil {
        return nil, err
    }
    
    return &createdUser, nil
}

// PUT 요청
func (c *APIClient) UpdateUser(userID int, user *User) (*User, error) {
    url := fmt.Sprintf("%s/users/%d", c.BaseURL, userID)
    
    jsonData, err := json.Marshal(user)
    if err != nil {
        return nil, err
    }
    
    req, err := http.NewRequest(http.MethodPut, url, bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, err
    }
    req.Header.Set("Content-Type", "application/json")
    
    resp, err := c.HTTPClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    var apiResp APIResponse
    if err := json.NewDecoder(resp.Body).Decode(&apiResp); err != nil {
        return nil, err
    }
    
    userData, _ := json.Marshal(apiResp.Data)
    var updatedUser User
    if err := json.Unmarshal(userData, &updatedUser); err != nil {
        return nil, err
    }
    
    return &updatedUser, nil
}

// DELETE 요청
func (c *APIClient) DeleteUser(userID int) error {
    url := fmt.Sprintf("%s/users/%d", c.BaseURL, userID)
    
    req, err := http.NewRequest(http.MethodDelete, url, nil)
    if err != nil {
        return err
    }
    
    resp, err := c.HTTPClient.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent {
        return fmt.Errorf("API error: status %d", resp.StatusCode)
    }
    
    return nil
}

func main() {
    client := NewAPIClient("https://api.example.com")
    
    // 사용자 생성
    newUser := &User{
        Username: "gopher",
        Email:    "gopher@example.com",
    }
    
    createdUser, err := client.CreateUser(newUser)
    if err != nil {
        fmt.Println("Error creating user:", err)
        return
    }
    
    fmt.Printf("Created user: %+v\n", createdUser)
    
    // 사용자 조회
    user, err := client.GetUser(createdUser.ID)
    if err != nil {
        fmt.Println("Error getting user:", err)
        return
    }
    
    fmt.Printf("Retrieved user: %+v\n", user)
    
    // 사용자 업데이트
    user.Email = "newemail@example.com"
    updatedUser, err := client.UpdateUser(user.ID, user)
    if err != nil {
        fmt.Println("Error updating user:", err)
        return
    }
    
    fmt.Printf("Updated user: %+v\n", updatedUser)
    
    // 사용자 삭제
    if err := client.DeleteUser(user.ID); err != nil {
        fmt.Println("Error deleting user:", err)
        return
    }
    
    fmt.Println("User deleted successfully")
}

🎨 고급 기법: 제네릭을 활용한 범용 직렬화

Go 1.18부터 제네릭이 도입되면서 더 유연한 코드를 작성할 수 있게 됐어! 직렬화 코드에도 제네릭을 활용해보자. 🚀

import (
    "encoding/json"
    "encoding/xml"
    "fmt"
    "io"
)

// 제네릭 직렬화 인터페이스
type Serializer[T any] interface {
    Marshal(v T) ([]byte, error)
    Unmarshal(data []byte, v *T) error
}

// JSON 직렬화기
type JSONSerializer[T any] struct{}

func (s JSONSerializer[T]) Marshal(v T) ([]byte, error) {
    return json.Marshal(v)
}

func (s JSONSerializer[T]) Unmarshal(data []byte, v *T) error {
    return json.Unmarshal(data, v)
}

// XML 직렬화기
type XMLSerializer[T any] struct{}

func (s XMLSerializer[T]) Marshal(v T) ([]byte, error) {
    return xml.Marshal(v)
}

func (s XMLSerializer[T]) Unmarshal(data []byte, v *T) error {
    return xml.Unmarshal(data, v)
}

// 범용 저장/로드 함수
func Save[T any](filename string, data T, serializer Serializer[T]) error {
    bytes, err := serializer.Marshal(data)
    if err != nil {
        return err
    }
    
    // 파일 저장 로직 (간략화)
    fmt.Printf("Saving to %s: %s\n", filename, string(bytes))
    return nil
}

func Load[T any](filename string, serializer Serializer[T]) (T, error) {
    var result T
    
    // 파일 읽기 로직 (간략화)
    data := []byte(`{"name":"test","value":123}`)
    
    if err := serializer.Unmarshal(data, &result); err != nil {
        return result, err
    }
    
    return result, nil
}

// 사용 예제
type Config struct {
    Name  string `json:"name" xml:"name"`
    Value int    `json:"value" xml:"value"`
}

func main() {
    config := Config{Name: "MyApp", Value: 123}
    
    // JSON으로 저장
    jsonSer := JSONSerializer[Config]{}
    if err := Save("config.json", config, jsonSer); err != nil {
        fmt.Println("Error:", err)
    }
    
    // XML로 저장
    xmlSer := XMLSerializer[Config]{}
    if err := Save("config.xml", config, xmlSer); err != nil {
        fmt.Println("Error:", err)
    }
    
    // JSON에서 로드
    loadedConfig, err := Load("config.json", jsonSer)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Printf("Loaded: %+v\n", loadedConfig)
    }
}

🛡️ 보안 고려사항

데이터 직렬화를 다룰 때는 보안도 정말 중요해! 특히 외부에서 받은 데이터를 역직렬화할 때는 더욱 조심해야 해. 몇 가지 중요한 보안 팁을 알려줄게. 🔒

import (
    "encoding/json"
    "errors"
    "fmt"
    "io"
    "strings"
)

// 안전한 역직렬화 함수
func SafeUnmarshal(data []byte, v interface{}, maxSize int) error {
    // 1. 크기 검증
    if len(data) > maxSize {
        return fmt.Errorf("data too large: %d bytes (max: %d)", len(data), maxSize)
    }
    
    // 2. 기본 JSON 유효성 검사
    if !json.Valid(data) {
        return errors.New("invalid JSON")
    }
    
    // 3. 역직렬화
    if err := json.Unmarshal(data, v); err != nil {
        return fmt.Errorf("unmarshal error: %w", err)
    }
    
    return nil
}

// 제한된 Reader로 DoS 방어
type LimitedReader struct {
    R io.Reader
    N int64
}

func (l *LimitedReader) Read(p []byte) (n int, err error) {
    if l.N <= 0 {
        return 0, errors.New("read limit exceeded")
    }
    if int64(len(p)) > l.N {
        p = p[0:l.N]
    }
    n, err = l.R.Read(p)
    l.N -= int64(n)
    return
}

// 안전한 Decoder
func SafeDecode(r io.Reader, v interface{}, maxBytes int64) error {
    limitedReader := &LimitedReader{R: r, N: maxBytes}
    decoder := json.NewDecoder(limitedReader)
    
    // 중첩 깊이 제한 (Go 1.10+)
    decoder.DisallowUnknownFields() // 예상치 못한 필드 거부
    
    if err := decoder.Decode(v); err != nil {
        return fmt.Errorf("decode error: %w", err)
    }
    
    return nil
}

// 민감 정보 마스킹
type SecureConfig struct {
    AppName    string `json:"app_name"`
    APIKey     string `json:"-"` // 직렬화에서 제외
    DBPassword string `json:"-"` // 직렬화에서 제외
    PublicURL  string `json:"public_url"`
}

// 로깅용 안전한 문자열 변환
func (sc SecureConfig) SafeString() string {
    return fmt.Sprintf("SecureConfig{AppName: %s, PublicURL: %s, APIKey: [REDACTED], DBPassword: [REDACTED]}", 
        sc.AppName, sc.PublicURL)
}

// 입력 검증 예제
type ValidatedUser struct {
    Username string `json:"username"`
    Email    string `json:"email"`
    Age      int    `json:"age"`
}

func (u *ValidatedUser) Validate() error {
    if len(u.Username) < 3 || len(u.Username) > 20 {
        return errors.New("username must be 3-20 characters")
    }
    
    if !strings.Contains(u.Email, "@") {
        return errors.New("invalid email format")
    }
    
    if u.Age < 0 || u.Age > 150 {
        return errors.New("invalid age")
    }
    
    return nil
}

func main() {
    // 안전한 역직렬화 예제
    jsonData := []byte(`{"username":"gopher","email":"gopher@example.com","age":5}`)
    
    var user ValidatedUser
    if err := SafeUnmarshal(jsonData, &user, 1024); err != nil {
        fmt.Println("Unmarshal error:", err)
        return
    }
    
    // 검증
    if err := user.Validate(); err != nil {
        fmt.Println("Validation error:", err)
        return
    }
    
    fmt.Printf("Valid user: %+v\n", user)
}

📊 벤치마킹과 성능 측정

성능 최적화를 하려면 먼저 측정부터 해야 해! Go는 훌륭한 벤치마킹 도구를 제공하고 있어. 실제로 JSON과 XML의 성능을 비교해보자. 📈

package main

import (
    "encoding/json"
    "encoding/xml"
    "testing"
)

type BenchData struct {
    ID          int      `json:"id" xml:"id"`
    Name        string   `json:"name" xml:"name"`
    Description string   `json:"description" xml:"description"`
    Tags        []string `json:"tags" xml:"tags>tag"`
    Active      bool     `json:"active" xml:"active"`
}

var testData = BenchData{
    ID:          12345,
    Name:        "Test Product",
    Description: "This is a test product with some description",
    Tags:        []string{"tag1", "tag2", "tag3", "tag4", "tag5"},
    Active:      true,
}

// JSON Marshal 벤치마크
func BenchmarkJSONMarshal(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _, err := json.Marshal(testData)
        if err != nil {
            b.Fatal(err)
        }
    }
}

// JSON Unmarshal 벤치마크
func BenchmarkJSONUnmarshal(b *testing.B) {
    data, _ := json.Marshal(testData)
    b.ResetTimer()
    
    for i := 0; i < b.N; i++ {
        var result BenchData
        err := json.Unmarshal(data, &result)
        if err != nil {
            b.Fatal(err)
        }
    }
}

// XML Marshal 벤치마크
func BenchmarkXMLMarshal(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _, err := xml.Marshal(testData)
        if err != nil {
            b.Fatal(err)
        }
    }
}

// XML Unmarshal 벤치마크
func BenchmarkXMLUnmarshal(b *testing.B) {
    data, _ := xml.Marshal(testData)
    b.ResetTimer()
    
    for i := 0; i < b.N; i++ {
        var result BenchData
        err := xml.Unmarshal(data, &result)
        if err != nil {
            b.Fatal(err)
        }
    }
}

// 메모리 할당 측정
func BenchmarkJSONMarshalAllocs(b *testing.B) {
    b.ReportAllocs()
    
    for i := 0; i < b.N; i++ {
        _, err := json.Marshal(testData)
        if err != nil {
            b.Fatal(err)
        }
    }
}

벤치마크를 실행하려면 터미널에서 이렇게 입력해:

# 기본 벤치마크 실행
go test -bench=.

# 메모리 할당 정보 포함
go test -bench=. -benchmem

# 특정 벤치마크만 실행
go test -bench=BenchmarkJSON

# CPU 프로파일 생성
go test -bench=. -cpuprofile=cpu.prof

# 메모리 프로파일 생성
go test -bench=. -memprofile=mem.prof

🎯 실전 프로젝트: 설정 파일 관리자

이제 배운 내용을 모두 활용해서 실용적인 설정 파일 관리자를 만들어보자! JSON과 XML을 모두 지원하고, 환경별로 다른 설정을 로드할 수 있는 시스템이야. 🛠️

package main

import (
    "encoding/json"
    "encoding/xml"
    "fmt"
    "os"
    "path/filepath"
    "strings"
)

// 설정 구조체
type AppConfig struct {
    XMLName xml.Name `xml:"config" json:"-"`
    
    App struct {
        Name        string `json:"name" xml:"name"`
        Version     string `json:"version" xml:"version"`
        Environment string `json:"environment" xml:"environment"`
        Debug       bool   `json:"debug" xml:"debug"`
    } `json:"app" xml:"app"`
    
    Server struct {
        Host string `json:"host" xml:"host"`
        Port int    `json:"port" xml:"port"`
        TLS  bool   `json:"tls" xml:"tls"`
    } `json:"server" xml:"server"`
    
    Database struct {
        Driver   string `json:"driver" xml:"driver"`
        Host     string `json:"host" xml:"host"`
        Port     int    `json:"port" xml:"port"`
        Name     string `json:"name" xml:"name"`
        Username string `json:"username" xml:"username"`
        Password string `json:"-" xml:"-"` // 보안상 직렬화 제외
        MaxConns int    `json:"max_connections" xml:"max_connections"`
    } `json:"database" xml:"database"`
    
    Logging struct {
        Level  string `json:"level" xml:"level"`
        Format string `json:"format" xml:"format"`
        Output string `json:"output" xml:"output"`
    } `json:"logging" xml:"logging"`
}

// 설정 관리자
type ConfigManager struct {
    config      *AppConfig
    configPath  string
    environment string
}

func NewConfigManager(environment string) *ConfigManager {
    return &ConfigManager{
        environment: environment,
    }
}

// 설정 파일 로드
func (cm *ConfigManager) Load(basePath string) error {
    // 환경별 설정 파일 경로 결정
    // 예: config.json, config.dev.json, config.prod.json
    paths := []string{
        filepath.Join(basePath, fmt.Sprintf("config.%s.json", cm.environment)),
        filepath.Join(basePath, "config.json"),
        filepath.Join(basePath, fmt.Sprintf("config.%s.xml", cm.environment)),
        filepath.Join(basePath, "config.xml"),
    }
    
    for _, path := range paths {
        if _, err := os.Stat(path); err == nil {
            cm.configPath = path
            return cm.loadFromFile(path)
        }
    }
    
    return fmt.Errorf("no config file found in %s", basePath)
}

func (cm *ConfigManager) loadFromFile(path string) error {
    data, err := os.ReadFile(path)
    if err != nil {
        return fmt.Errorf("failed to read config file: %w", err)
    }
    
    cm.config = &AppConfig{}
    
    // 파일 확장자로 포맷 판단
    ext := strings.ToLower(filepath.Ext(path))
    switch ext {
    case ".json":
        if err := json.Unmarshal(data, cm.config); err != nil {
            return fmt.Errorf("failed to parse JSON config: %w", err)
        }
    case ".xml":
        if err := xml.Unmarshal(data, cm.config); err != nil {
            return fmt.Errorf("failed to parse XML config: %w", err)
        }
    default:
        return fmt.Errorf("unsupported config format: %s", ext)
    }
    
    // 환경 변수로 오버라이드
    cm.applyEnvironmentOverrides()
    
    // 검증
    if err := cm.validate(); err != nil {
        return fmt.Errorf("config validation failed: %w", err)
    }
    
    return nil
}

// 환경 변수로 설정 오버라이드
func (cm *ConfigManager) applyEnvironmentOverrides() {
    if port := os.Getenv("SERVER_PORT"); port != "" {
        fmt.Sscanf(port, "%d", &cm.config.Server.Port)
    }
    
    if dbHost := os.Getenv("DB_HOST"); dbHost != "" {
        cm.config.Database.Host = dbHost
    }
    
    if dbPass := os.Getenv("DB_PASSWORD"); dbPass != "" {
        cm.config.Database.Password = dbPass
    }
    
    if debug := os.Getenv("DEBUG"); debug == "true" {
        cm.config.App.Debug = true
    }
}

// 설정 검증
func (cm *ConfigManager) validate() error {
    if cm.config.App.Name == "" {
        return fmt.Errorf("app name is required")
    }
    
    if cm.config.Server.Port < 1 || cm.config.Server.Port > 65535 {
        return fmt.Errorf("invalid server port: %d", cm.config.Server.Port)
    }
    
    if cm.config.Database.MaxConns < 1 {
        return fmt.Errorf("database max connections must be at least 1")
    }
    
    validLogLevels := map[string]bool{
        "debug": true, "info": true, "warn": true, "error": true,
    }
    if !validLogLevels[strings.ToLower(cm.config.Logging.Level)] {
        return fmt.Errorf("invalid log level: %s", cm.config.Logging.Level)
    }
    
    return nil
}

// 설정 저장
func (cm *ConfigManager) Save(path string, format string) error {
    var data []byte
    var err error
    
    switch strings.ToLower(format) {
    case "json":
        data, err = json.MarshalIndent(cm.config, "", "  ")
    case "xml":
        data, err = xml.MarshalIndent(cm.config, "", "  ")
        if err == nil {
            data = append([]byte(xml.Header), data...)
        }
    default:
        return fmt.Errorf("unsupported format: %s", format)
    }
    
    if err != nil {
        return fmt.Errorf("failed to marshal config: %w", err)
    }
    
    if err := os.WriteFile(path, data, 0644); err != nil {
        return fmt.Errorf("failed to write config file: %w", err)
    }
    
    return nil
}

// Getter 메서드들
func (cm *ConfigManager) Get() *AppConfig {
    return cm.config
}

func (cm *ConfigManager) GetServerAddress() string {
    protocol := "http"
    if cm.config.Server.TLS {
        protocol = "https"
    }
    return fmt.Sprintf("%s://%s:%d", protocol, cm.config.Server.Host, cm.config.Server.Port)
}

func (cm *ConfigManager) GetDatabaseDSN() string {
    return fmt.Sprintf("%s://%s:%s@%s:%d/%s",
        cm.config.Database.Driver,
        cm.config.Database.Username,
        cm.config.Database.Password,
        cm.config.Database.Host,
        cm.config.Database.Port,
        cm.config.Database.Name,
    )
}

// 설정 정보 출력 (민감 정보 제외)
func (cm *ConfigManager) Print() {
    fmt.Println("=== Application Configuration ===")
    fmt.Printf("App: %s v%s (%s)\n", 
        cm.config.App.Name, 
        cm.config.App.Version, 
        cm.config.App.Environment)
    fmt.Printf("Server: %s\n", cm.GetServerAddress())
    fmt.Printf("Database: %s@%s:%d/%s\n",
        cm.config.Database.Driver,
        cm.config.Database.Host,
        cm.config.Database.Port,
        cm.config.Database.Name)
    fmt.Printf("Logging: %s (%s)\n", 
        cm.config.Logging.Level, 
        cm.config.Logging.Format)
    fmt.Println("================================")
}

func main() {
    // 환경 결정 (기본값: development)
    env := os.Getenv("APP_ENV")
    if env == "" {
        env = "development"
    }
    
    // 설정 관리자 생성
    configMgr := NewConfigManager(env)
    
    // 설정 로드
    if err := configMgr.Load("./config"); err != nil {
        fmt.Println("Error loading config:", err)
        
        // 기본 설정 생성
        fmt.Println("Creating default configuration...")
        configMgr.config = createDefaultConfig(env)
        
        // JSON으로 저장
        if err := configMgr.Save("./config/config.json", "json"); err != nil {
            fmt.Println("Error saving config:", err)
            return
        }
        fmt.Println("Default config saved to ./config/config.json")
    }
    
    // 설정 정보 출력
    configMgr.Print()
    
    // 설정 사용 예제
    config := configMgr.Get()
    if config.App.Debug {
        fmt.Println("\n[DEBUG MODE ENABLED]")
        fmt.Printf("Database DSN: %s\n", configMgr.GetDatabaseDSN())
    }
}

// 기본 설정 생성
func createDefaultConfig(env string) *AppConfig {
    config := &AppConfig{}
    
    config.App.Name = "MyApp"
    config.App.Version = "1.0.0"
    config.App.Environment = env
    config.App.Debug = (env == "development")
    
    config.Server.Host = "localhost"
    config.Server.Port = 8080
    config.Server.TLS = false
    
    config.Database.Driver = "postgres"
    config.Database.Host = "localhost"
    config.Database.Port = 5432
    config.Database.Name = "myapp"
    config.Database.Username = "user"
    config.Database.Password = ""
    config.Database.MaxConns = 10
    
    config.Logging.Level = "info"
    config.Logging.Format = "json"
    config.Logging.Output = "stdout"
    
    return config
}

🌐 실전 예제: 다국어 지원 시스템

JSON을 활용한 또 다른 실용적인 예제로 다국어 지원 시스템을 만들어보자! 이건 글로벌 서비스를 만들 때 정말 필수적이야. 🌍

package main

import (
    "encoding/json"
    "fmt"
    "os"
    "path/filepath"
    "strings"
)

// 번역 데이터 구조
type Translation map[string]interface{}

// 다국어 관리자
type I18nManager struct {
    defaultLang  string
    currentLang  string
    translations map[string]Translation
    fallback     Translation
}

func NewI18nManager(defaultLang string) *I18nManager {
    return &I18nManager{
        defaultLang:  defaultLang,
        currentLang:  defaultLang,
        translations: make(map[string]Translation),
    }
}

// 언어 파일 로드
func (i18n *I18nManager) LoadLanguage(lang string, path string) error {
    data, err := os.ReadFile(path)
    if err != nil {
        return fmt.Errorf("failed to read language file: %w", err)
    }
    
    var translation Translation
    if err := json.Unmarshal(data, &translation); err != nil {
        return fmt.Errorf("failed to parse language file: %w", err)
    }
    
    i18n.translations[lang] = translation
    
    // 기본 언어면 fallback으로 설정
    if lang == i18n.defaultLang {
        i18n.fallback = translation
    }
    
    return nil
}

// 디렉토리에서 모든 언어 파일 로드
func (i18n *I18nManager) LoadDirectory(dir string) error {
    files, err := filepath.Glob(filepath.Join(dir, "*.json"))
    if err != nil {
        return err
    }
    
    for _, file := range files {
        // 파일명에서 언어 코드 추출 (예: en.json -> en)
        lang := strings.TrimSuffix(filepath.Base(file), ".json")
        
        if err := i18n.LoadLanguage(lang, file); err != nil {
            fmt.Printf("Warning: failed to load %s: %v\n", file, err)
            continue
        }
        
        fmt.Printf("Loaded language: %s\n", lang)
    }
    
    if len(i18n.translations) == 0 {
        return fmt.Errorf("no language files loaded")
    }
    
    return nil
}

// 현재 언어 설정
func (i18n *I18nManager) SetLanguage(lang string) error {
    if _, exists := i18n.translations[lang]; !exists {
        return fmt.Errorf("language not loaded: %s", lang)
    }
    
    i18n.currentLang = lang
    return nil
}

// 번역 가져오기 (중첩 키 지원)
func (i18n *I18nManager) Get(key string, args ...interface{}) string {
    // 현재 언어에서 찾기
    if value := i18n.getValue(i18n.translations[i18n.currentLang], key); value != "" {
        return i18n.format(value, args...)
    }
    
    // fallback 언어에서 찾기
    if value := i18n.getValue(i18n.fallback, key); value != "" {
        return i18n.format(value, args...)
    }
    
    // 못 찾으면 키 자체 반환
    return key
}

// 중첩된 키에서 값 가져오기 (예: "user.profile.name")
func (i18n *I18nManager) getValue(translation Translation, key string) string {
    parts := strings.Split(key, ".")
    var current interface{} = translation
    
    for _, part := range parts {
        switch v := current.(type) {
        case map[string]interface{}:
            current = v[part]
        case Translation:
            current = v[part]
        default:
            return ""
        }
        
        if current == nil {
            return ""
        }
    }
    
    if str, ok := current.(string); ok {
        return str
    }
    
    return ""
}

// 포맷팅 (간단한 플레이스홀더 치환)
func (i18n *I18nManager) format(template string, args ...interface{}) string {
    result := template
    for i, arg := range args {
        placeholder := fmt.Sprintf("{%d}", i)
        result = strings.ReplaceAll(result, placeholder, fmt.Sprint(arg))
    }
    return result
}

// 복수형 처리
func (i18n *I18nManager) Plural(key string, count int, args ...interface{}) string {
    var pluralKey string
    
    if count == 1 {
        pluralKey = key + ".one"
    } else {
        pluralKey = key + ".other"
    }
    
    allArgs := append([]interface{}{count}, args...)
    return i18n.Get(pluralKey, allArgs...)
}

// 사용 가능한 언어 목록
func (i18n *I18nManager) AvailableLanguages() []string {
    langs := make([]string, 0, len(i18n.translations))
    for lang := range i18n.translations {
        langs = append(langs, lang)
    }
    return langs
}

// 현재 언어
func (i18n *I18nManager) CurrentLanguage() string {
    return i18n.currentLang
}

func main() {
    // 다국어 관리자 생성
    i18n := NewI18nManager("ko")
    
    // 언어 파일들 로드
    if err := i18n.LoadDirectory("./locales"); err != nil {
        fmt.Println("Error loading languages:", err)
        
        // 테스트용 언어 데이터 생성
        createSampleLanguageFiles()
        
        // 다시 로드
        if err := i18n.LoadDirectory("./locales"); err != nil {
            fmt.Println("Error:", err)
            return
        }
    }
    
    fmt.Println("Available languages:", i18n.AvailableLanguages())
    fmt.Println()
    
    // 한국어로 출력
    i18n.SetLanguage("ko")
    fmt.Println("=== 한국어 ===")
    fmt.Println(i18n.Get("welcome"))
    fmt.Println(i18n.Get("greeting", "김철수"))
    fmt.Println(i18n.Get("user.profile.name"))
    fmt.Println(i18n.Plural("items", 1))
    fmt.Println(i18n.Plural("items", 5))
    fmt.Println()
    
    // 영어로 출력
    i18n.SetLanguage("en")
    fmt.Println("=== English ===")
    fmt.Println(i18n.Get("welcome"))
    fmt.Println(i18n.Get("greeting", "John"))
    fmt.Println(i18n.Get("user.profile.name"))
    fmt.Println(i18n.Plural("items", 1))
    fmt.Println(i18n.Plural("items", 5))
    fmt.Println()
    
    // 일본어로 출력
    i18n.SetLanguage("ja")
    fmt.Println("=== 日本語 ===")
    fmt.Println(i18n.Get("welcome"))
    fmt.Println(i18n.Get("greeting", "田中"))
    fmt.Println(i18n.Get("user.profile.name"))
    fmt.Println(i18n.Plural("items", 1))
    fmt.Println(i18n.Plural("items", 5))
}

// 샘플 언어 파일 생성
func createSampleLanguageFiles() {
    os.MkdirAll("./locales", 0755)
    
    // 한국어
    ko := map[string]interface{}{
        "welcome": "재능넷에 오신 것을 환영합니다!",
        "greeting": "안녕하세요, {0}님!",
        "user": map[string]interface{}{
            "profile": map[string]interface{}{
                "name": "이름",
                "email": "이메일",
                "phone": "전화번호",
            },
        },
        "items": map[string]interface{}{
            "one": "{0}개의 항목",
            "other": "{0}개의 항목들",
        },
    }
    
    // 영어
    en := map[string]interface{}{
        "welcome": "Welcome to JaeNung.net!",
        "greeting": "Hello, {0}!",
        "user": map[string]interface{}{
            "profile": map[string]interface{}{
                "name": "Name",
                "email": "Email",
                "phone": "Phone",
            },
        },
        "items": map[string]interface{}{
            "one": "{0} item",
            "other": "{0} items",
        },
    }
    
    // 일본어
    ja := map[string]interface{}{
        "welcome": "才能ネットへようこそ!",
        "greeting": "こんにちは、{0}さん!",
        "user": map[string]interface{}{
            "profile": map[string]interface{}{
                "name": "名前",
                "email": "メール",
                "phone": "電話",
            },
        },
        "items": map[string]interface{}{
            "one": "{0}個のアイテム",
            "other": "{0}個のアイテム",
        },
    }
    
    // 파일로 저장
    saveLanguageFile("./locales/ko.json", ko)
    saveLanguageFile("./locales/en.json", en)
    saveLanguageFile("./locales/ja.json", ja)
    
    fmt.Println("Sample language files created in ./locales/")
}

func saveLanguageFile(path string, data interface{}) {
    jsonData, _ := json.MarshalIndent(data, "", "  ")
    os.WriteFile(path, jsonData, 0644)
}

🔧 디버깅과 문제 해결

JSON과 XML 처리 중에 문제가 생기면 어떻게 해결할까? 자주 발생하는 문제들과 해결 방법을 알아보자! 🔍

import (
    "encoding/json"
    "fmt"
    "strings"
)

// 디버깅 헬퍼 함수들

// JSON 유효성 검사
func ValidateJSON(data []byte) error {
    if !json.Valid(data) {
        // 어디가 잘못됐는지 찾기
        var v interface{}
        err := json.Unmarshal(data, &v)
        return fmt.Errorf("invalid JSON: %w", err)
    }
    return nil
}

// JSON 예쁘게 출력
func PrettyPrintJSON(data []byte) {
    var obj interface{}
    if err := json.Unmarshal(data, &obj); err != nil {
        fmt.Println("Error:", err)
        return
    }
    
    pretty, err := json.MarshalIndent(obj, "", "  ")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    
    fmt.Println(string(pretty))
}

// 구조체와 JSON 비교 (디버깅용)
func CompareStructAndJSON(v interface{}, jsonData []byte) {
    // 구조체를 JSON으로
    structJSON, _ := json.MarshalIndent(v, "", "  ")
    
    // 입력 JSON 정리
    var obj interface{}
    json.Unmarshal(jsonData, &obj)
    inputJSON, _ := json.MarshalIndent(obj, "", "  ")
    
    fmt.Println("=== Struct as JSON ===")
    fmt.Println(string(structJSON))
    fmt.Println("\n=== Input JSON ===")
    fmt.Println(string(inputJSON))
    
    // 차이점 찾기 (간단한 버전)
    structLines := strings.Split(string(structJSON), "\n")
    inputLines := strings.Split(string(inputJSON), "\n")
    
    fmt.Println("\n=== Differences ===")
    maxLen := len(structLines)
    if len(inputLines) > maxLen {
        maxLen = len(inputLines)
    }
    
    for i := 0; i < maxLen; i++ {
        var structLine, inputLine string
        if i < len(structLines) {
            structLine = structLines[i]
        }
        if i < len(inputLines) {
            inputLine = inputLines[i]
        }
        
        if structLine != inputLine {
            fmt.Printf("Line %d differs:\n", i+1)
            fmt.Printf("  Struct: %s\n", structLine)
            fmt.Printf("  Input:  %s\n", inputLine)
        }
    }
}

// 타입 불일치 찾기
func FindTypeMismatches(jsonData []byte, targetType interface{}) []string {
    var mismatches []string
    
    // JSON을 map으로 파싱
    var jsonMap map[string]interface{}
    if err := json.Unmarshal(jsonData, &jsonMap); err != nil {
        return []string{fmt.Sprintf("Failed to parse JSON: %v", err)}
    }
    
    // 구조체 정보 가져오기 (리플렉션 사용)
    // 실제 구현은 reflect 패키지 필요
    
    return mismatches
}

// 안전한 역직렬화 (상세한 에러 정보)
func SafeUnmarshalWithDetails(data []byte, v interface{}) error {
    // 1. JSON 유효성 검사
    if err := ValidateJSON(data); err != nil {
        return fmt.Errorf("validation failed: %w", err)
    }
    
    // 2. 역직렬화 시도
    if err := json.Unmarshal(data, v); err != nil {
        // 에러 타입별 상세 정보
        switch e := err.(type) {
        case *json.UnmarshalTypeError:
            return fmt.Errorf(
                "type mismatch at field '%s': expected %s but got %s (offset %d)",
                e.Field, e.Type, e.Value, e.Offset,
            )
        case *json.SyntaxError:
            return fmt.Errorf(
                "syntax error at offset %d: %v",
                e.Offset, e,
            )
        default:
            return fmt.Errorf("unmarshal error: %w", err)
        }
    }
    
    return nil
}

func main() {
    // 문제가 있는 JSON
    badJSON := []byte(`{
        "name": "Test",
        "age": "not a number",
        "active": true
    }`)
    
    type User struct {
        Name   string `json:"name"`
        Age    int    `json:"age"`
        Active bool   `json:"active"`
    }
    
    var user User
    
    // 상세한 에러 정보와 함께 역직렬화
    if err := SafeUnmarshalWithDetails(badJSON, &user); err != nil {
        fmt.Println("Error:", err)
        // 출력: type mismatch at field 'age': expected int but got string
    }
    
    // JSON 비교
    goodJSON := []byte(`{"name":"Test","age":25,"active":true}`)
    json.Unmarshal(goodJSON, &user)
    CompareStructAndJSON(user, badJSON)
}

🎯 마무리하며

와! 정말 긴 여정이었지? 😊 우리는 Go 언어에서 JSON과 XML을 처리하는 방법을 정말 깊이 있게 다뤄봤어. Marshal과 Unmarshal의 기본부터 시작해서, 커스텀 직렬화, 성능 최적화, 실전 프로젝트까지 정말 많은 내용을 배웠어!

이제 너는 다음과 같은 것들을 할 수 있게 됐어:

✅ JSON과 XML 데이터를 자유자재로 다루기
✅ 구조체 태그를 활용한 유연한 매핑
✅ 커스텀 마샬링으로 특별한 요구사항 처리
✅ 성능을 고려한 효율적인 코드 작성
✅ 실전 프로젝트에 바로 적용 가능한 패턴 활용
✅ 보안을 고려한 안전한 데이터 처리

데이터 직렬화는 현대 프로그래밍에서 정말 중요한 기술이야. API 통신, 설정 파일 관리, 데이터 저장 등 거의 모든 곳에서 사용되거든. Go의 encoding 패키지는 이런 작업을 정말 쉽고 효율적으로 만들어줘!

재능넷 같은 플랫폼에서 다양한 프로젝트를 진행하다 보면, 오늘 배운 내용들이 정말 유용하게 쓰일 거야. 외부 API 연동, 데이터 교환, 설정 관리 등 실무에서 바로 활용할 수 있는 기술들이니까! 💪

계속 연습하고, 실제 프로젝트에 적용해보면서 경험을 쌓아가길 바라! 궁금한 점이 있으면 언제든지 Go 커뮤니티나 재능넷의 지식인의 숲에서 질문하고 답을 찾아봐. 함께 성장하는 개발자가 되자! 🚀

Happy Coding! 즐거운 Go 프로그래밍 되길! 🎉