Golang中如何设置和使用JSON输入文件中的动态变量如{{START_DATE}}

在Golang中处理JSON文件中的动态变量（如{{START_DATE}}），可以通过模板解析和变量替换来实现。以下是具体实现方案：

1. 定义全局参数结构体

type GlobalParams struct {
    StartDate string `json:"START_DATE"`
    EndDate   string `json:"END_DATE"`
    // 添加其他动态参数
}

// 初始化全局参数
var globalParams = GlobalParams{
    StartDate: "2024-01-01",
    EndDate:   "2024-12-31",
}

2. 使用模板引擎替换动态变量

import (
    "bytes"
    "encoding/json"
    "fmt"
    "strings"
    "text/template"
)

func ReplaceDynamicVars(jsonStr string, params GlobalParams) (string, error) {
    // 创建模板
    tmpl, err := template.New("jsonTemplate").Parse(jsonStr)
    if err != nil {
        return "", fmt.Errorf("模板解析失败: %v", err)
    }
    
    // 执行模板替换
    var buf bytes.Buffer
    err = tmpl.Execute(&buf, params)
    if err != nil {
        return "", fmt.Errorf("模板执行失败: %v", err)
    }
    
    return buf.String(), nil
}

3. 完整示例代码

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "log"
    "text/template"
)

type GlobalParams struct {
    StartDate string `json:"START_DATE"`
    EndDate   string `json:"END_DATE"`
    UserName  string `json:"USER_NAME"`
}

type TimeRange struct {
    GTE string `json:"gte"`
    LTE string `json:"lte"`
}

type Config struct {
    Time TimeRange `json:"Time"`
}

func main() {
    // 定义全局参数
    params := GlobalParams{
        StartDate: "2024-01-01T00:00:00Z",
        EndDate:   "2024-12-31T23:59:59Z",
        UserName:  "john_doe",
    }
    
    // JSON模板字符串（包含动态变量）
    jsonTemplate := `{
        "Time": {
            "gte": "{{.StartDate}}",
            "lte": "{{.EndDate}}"
        },
        "User": "{{.UserName}}"
    }`
    
    // 替换动态变量
    result, err := replaceTemplateVars(jsonTemplate, params)
    if err != nil {
        log.Fatal(err)
    }
    
    // 解析为结构体
    var config Config
    err = json.Unmarshal([]byte(result), &config)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("处理后的JSON: %s\n", result)
    fmt.Printf("开始时间: %s\n", config.Time.GTE)
    fmt.Printf("结束时间: %s\n", config.Time.LTE)
}

func replaceTemplateVars(templateStr string, params GlobalParams) (string, error) {
    tmpl, err := template.New("config").Parse(templateStr)
    if err != nil {
        return "", err
    }
    
    var buf bytes.Buffer
    err = tmpl.Execute(&buf, params)
    if err != nil {
        return "", err
    }
    
    return buf.String(), nil
}

4. 从文件读取并处理

func ProcessJSONFile(templateFile string, params GlobalParams) ([]byte, error) {
    // 读取模板文件
    content, err := os.ReadFile(templateFile)
    if err != nil {
        return nil, err
    }
    
    // 替换变量
    result, err := replaceTemplateVars(string(content), params)
    if err != nil {
        return nil, err
    }
    
    // 验证JSON格式
    var js map[string]interface{}
    if err := json.Unmarshal([]byte(result), &js); err != nil {
        return nil, fmt.Errorf("无效的JSON: %v", err)
    }
    
    return []byte(result), nil
}

5. 使用自定义分隔符（如果需要{{}}格式）

func ReplaceWithCustomDelimiters(jsonStr string, params map[string]string) string {
    result := jsonStr
    for key, value := range params {
        placeholder := "{{" + key + "}}"
        result = strings.ReplaceAll(result, placeholder, value)
    }
    return result
}

// 使用示例
paramsMap := map[string]string{
    "START_DATE": "2024-01-01",
    "END_DATE":   "2024-12-31",
}

jsonInput := `{"Time": {"gte": "{{START_DATE}}", "lte": "{{END_DATE}}"}}`
finalJSON := ReplaceWithCustomDelimiters(jsonInput, paramsMap)

6. 支持嵌套结构的完整示例

type QueryParams struct {
    TimeRange struct {
        Start string `json:"start"`
        End   string `json:"end"`
    } `json:"time_range"`
    Filters map[string]interface{} `json:"filters"`
}

func GenerateDynamicJSON(params GlobalParams) ([]byte, error) {
    // 构建包含动态变量的数据结构
    query := map[string]interface{}{
        "time_range": map[string]string{
            "start": params.StartDate,
            "end":   params.EndDate,
        },
        "filters": map[string]interface{}{
            "status":    "active",
            "user":      params.UserName,
            "timestamp": fmt.Sprintf("{{.StartDate}} to {{.EndDate}}"),
        },
    }
    
    // 转换为JSON
    jsonData, err := json.MarshalIndent(query, "", "  ")
    if err != nil {
        return nil, err
    }
    
    // 替换剩余的模板变量
    jsonStr := string(jsonData)
    tmpl, err := template.New("query").Parse(jsonStr)
    if err != nil {
        return nil, err
    }
    
    var buf bytes.Buffer
    err = tmpl.Execute(&buf, params)
    
    return buf.Bytes(), err
}

这种方法允许你在JSON文件中使用动态变量，并在运行时替换为实际值。模板引擎会自动处理所有{{.FieldName}}格式的变量，将其替换为结构体中对应的值。