Go语言中的方法机制与复杂JSON路径访问：替代.NET扩展方法的方案

package main

import "fmt"

// 定义一个基于string的命名类型MyString
type MyString string

// 为MyString类型添加一个方法Method
func (m MyString) Greet() {
    fmt.Printf("Hello from MyString: %s\n", m)
}

func main() {
    var s MyString = "Go Developer"
    s.Greet() // 调用自定义方法
    // 无法直接对原生string类型调用：
    // var rawStr string = "plain string"
    // rawStr.Greet() // 编译错误：rawStr.Greet undefined
}

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    jsonStr := `{
        "data": {
            "issued": "2023-10-26",
            "status": "active"
        },
        "user": {
            "name": "Alice"
        }
    }`

    var config map[string]interface{}
    err := json.Unmarshal([]byte(jsonStr), &config)
    if err != nil {
        fmt.Println("JSON解析错误:", err)
        return
    }

    // 访问 "data.issued"
    if dataMap, ok := config["data"].(map[string]interface{}); ok {
        if issued, ok := dataMap["issued"].(string); ok {
            fmt.Println("Issued Date:", issued) // 输出: Issued Date: 2023-10-26
        } else {
            fmt.Println("键 'issued' 不存在或类型不匹配")
        }
    } else {
        fmt.Println("键 'data' 不存在或类型不匹配")
    }
}

// JSONPathAccessor 是一个map[string]interface{}的别名，用于附加方法
type JSONPathAccessor map[string]interface{}

package main

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

// JSONPathAccessor 是一个map[string]interface{}的别名，用于附加方法
type JSONPathAccessor map[string]interface{}

// GetByPath 根据点分隔的路径字符串获取嵌套值
// path示例: "data.issued", "address.line1", "tickets[0].amnt"
func (j JSONPathAccessor) GetByPath(path string) (interface{}, error) {
    if j == nil {
        return nil, fmt.Errorf("json map is nil")
    }

    parts := strings.Split(path, ".")
    currentValue := interface{}(j) // 从根map开始

    for _, part := range parts {
        if part == "" {
            continue // 跳过空部分，例如路径以点开头或结尾
        }

        // 检查是否是数组索引访问，例如 "tickets[0]"
        if strings.Contains(part, "[") && strings.Contains(part, "]") {
            fieldName := part[:strings.Index(part, "[")]
            indexStr := part[strings.Index(part, "[")+1 : strings.Index(part, "]")]
            index := 0
            _, err := fmt.Sscanf(indexStr, "%d", &index)
            if err != nil {
                return nil, fmt.Errorf("invalid array index in path '%s': %w", part, err)
            }

            // 尝试从当前值中获取字段
            if currentMap, ok := currentValue.(map[string]interface{}); ok {
                if val, found := currentMap[fieldName]; found {
                    if currentSlice, ok := val.([]interface{}); ok {
                        if index >= 0 && index < len(currentSlice) {
                            currentValue = currentSlice[index]
                        } else {
                            return nil, fmt.Errorf("array index out of bounds: %s[%d]", fieldName, index)
                        }
                    } else {
                        return nil, fmt.Errorf("path segment '%s' is not an array", fieldName)
                    }
                } else {
                    return nil, fmt.Errorf("path segment '%s' not found in map", fieldName)
                }
            } else {
                return nil, fmt.Errorf("current value is not a map, cannot access field '%s'", fieldName)
            }
        } else {
            // 普通的map键访问
            if currentMap, ok := currentValue.(map[string]interface{}); ok {
                if val, found := currentMap[part]; found {
                    currentValue = val
                } else {
                    return nil, fmt.Errorf("path segment '%s' not found", part)
                }
            } else {
                return nil, fmt.Errorf("current value is not a map, cannot access segment '%s'", part)
            }
        }
    }
    return currentValue, nil
}

func main() {
    jsonStr := `{
        "_id" : 2001,
        "address" : {
            "line1" : "123 Main St",
            "line2" : "",
            "line3" : ""
        },
        "tickets" : [ 
            {
                "seq" : 2,
                "add" : [
                    { "seq" : "A", "amnt" : 50 },
                    { "seq" : "B", "amnt" : 60 }
                ]
            },
            {
                "seq" : 3,
                "add" : [
                    { "seq" : "C", "amnt" : 70 }
                ]
            }
        ]
    }`

    var rawConfig map[string]interface{}
    err := json.Unmarshal([]byte(jsonStr), &rawConfig)
    if err != nil {
        fmt.Println("JSON解析错误:", err)
        return
    }

    // 将原始map转换为自定义类型，以便调用其方法
    config := JSONPathAccessor(rawConfig)

    // 使用GetByPath方法访问数据
    val, err := config.GetByPath("address.line1")
    if err != nil {
        fmt.Println("获取 'address.line1' 错误:", err)
    } else {
        fmt.Println("Address Line 1:", val) // 输出: Address Line 1: 123 Main St
    }

    val, err = config.GetByPath("tickets[0].add[1].amnt")
    if err != nil {
        fmt.Println("获取 'tickets[0].add[1].amnt' 错误:", err)
    } else {
        fmt.Println("Ticket 0 Add 1 Amount:", val) // 输出: Ticket 0 Add 1 Amount: 60
    }

    val, err = config.GetByPath("non.existent.path")
    if err != nil {
        fmt.Println("获取 'non.existent.path' 错误:", err) // 输出错误信息
    } else {
        fmt.Println("Non Existent Path:", val)
    }

    val, err = config.GetByPath("tickets[5].seq") // 越界访问
    if err != nil {
        fmt.Println("获取 'tickets[5].seq' 错误:", err) // 输出错误信息
    } else {
        fmt.Println("Ticket 5 Seq:", val)
    }
}

type Document struct {
    ID      int                    `json:"_id"`
    Address AddressInfo            `json:"address"`
    Tickets []Ticket               `json:"tickets"`
    Metadata map[string]interface{} `json:"metadata"` // 动态部分
}

type AddressInfo struct {
    Line1 string `json:"line1"`
    Line2 string `json:"line2"`
    Line3 string `json:"line3"`
}

type Ticket struct {
    Seq int                      `json:"seq"`
    Add []TicketAddInfo          `json:"add"`
    // 其他动态字段可以放在这里
    ExtraData map[string]interface{} `json:"-"` // 忽略或单独处理
}

type TicketAddInfo struct {
    Seq  string  `json:"seq"`
    Amnt float64 `json:"amnt"`
}