Golang处理非结构化数据的实用技巧

对于处理非结构化JSON数据，Go语言提供了几种灵活的方法。你可以使用map[string]interface{}或json.RawMessage来动态处理未知结构的JSON数据。

使用map[string]interface{}的示例

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

func handleFormData(w http.ResponseWriter, r *http.Request) {
    var data map[string]interface{}
    
    decoder := json.NewDecoder(r.Body)
    if err := decoder.Decode(&data); err != nil {
        http.Error(w, "Invalid JSON", http.StatusBadRequest)
        return
    }
    
    // 动态访问字段
    for key, value := range data {
        fmt.Printf("Key: %s, Value: %v, Type: %T\n", key, value, value)
    }
    
    // 类型断言处理特定字段
    if name, ok := data["name"].(string); ok {
        fmt.Println("Name:", name)
    }
    
    // 处理嵌套对象
    if address, ok := data["address"].(map[string]interface{}); ok {
        if city, ok := address["city"].(string); ok {
            fmt.Println("City:", city)
        }
    }
    
    w.WriteHeader(http.StatusOK)
    json.NewEncoder(w).Encode(map[string]string{"status": "success"})
}

func main() {
    http.HandleFunc("/submit", handleFormData)
    http.ListenAndServe(":8080", nil)
}

使用json.RawMessage延迟解析

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

type DynamicForm struct {
    FormName string          `json:"form_name"`
    Fields   json.RawMessage `json:"fields"`
    Metadata json.RawMessage `json:"metadata"`
}

func handleDynamicForm(w http.ResponseWriter, r *http.Request) {
    var form DynamicForm
    
    if err := json.NewDecoder(r.Body).Decode(&form); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    
    // 动态解析fields部分
    var fields map[string]interface{}
    if err := json.Unmarshal(form.Fields, &fields); err != nil {
        http.Error(w, "Invalid fields data", http.StatusBadRequest)
        return
    }
    
    // 根据模板动态处理字段
    processFields(fields)
    
    w.WriteHeader(http.StatusOK)
    json.NewEncoder(w).Encode(map[string]interface{}{
        "status": "processed",
        "field_count": len(fields),
    })
}

func processFields(fields map[string]interface{}) {
    for key, value := range fields {
        switch v := value.(type) {
        case string:
            fmt.Printf("String field %s: %s\n", key, v)
        case float64:
            fmt.Printf("Number field %s: %f\n", key, v)
        case bool:
            fmt.Printf("Boolean field %s: %v\n", key, v)
        case []interface{}:
            fmt.Printf("Array field %s with %d items\n", key, len(v))
        case map[string]interface{}:
            fmt.Printf("Object field %s\n", key)
        default:
            fmt.Printf("Unknown type for field %s: %T\n", key, v)
        }
    }
}

func main() {
    http.HandleFunc("/dynamic-form", handleDynamicForm)
    http.ListenAndServe(":8080", nil)
}

结合模板系统的动态处理

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "path/filepath"
)

type FormTemplate struct {
    TemplateName string                 `json:"template_name"`
    FieldConfigs map[string]FieldConfig `json:"field_configs"`
}

type FieldConfig struct {
    Type     string `json:"type"`
    Required bool   `json:"required"`
    Default  interface{} `json:"default,omitempty"`
}

func loadTemplates(dir string) (map[string]FormTemplate, error) {
    files, err := filepath.Glob(filepath.Join(dir, "*.json"))
    if err != nil {
        return nil, err
    }
    
    templates := make(map[string]FormTemplate)
    for _, file := range files {
        data, err := ioutil.ReadFile(file)
        if err != nil {
            return nil, err
        }
        
        var template FormTemplate
        if err := json.Unmarshal(data, &template); err != nil {
            return nil, err
        }
        
        templates[template.TemplateName] = template
    }
    
    return templates, nil
}

func validateFormData(template FormTemplate, formData map[string]interface{}) error {
    for fieldName, config := range template.FieldConfigs {
        value, exists := formData[fieldName]
        
        if config.Required && !exists {
            return fmt.Errorf("required field %s is missing", fieldName)
        }
        
        if !exists && config.Default != nil {
            formData[fieldName] = config.Default
        }
        
        // 类型检查
        if exists {
            switch config.Type {
            case "string":
                if _, ok := value.(string); !ok {
                    return fmt.Errorf("field %s should be string", fieldName)
                }
            case "number":
                if _, ok := value.(float64); !ok {
                    return fmt.Errorf("field %s should be number", fieldName)
                }
            case "boolean":
                if _, ok := value.(bool); !ok {
                    return fmt.Errorf("field %s should be boolean", fieldName)
                }
            }
        }
    }
    
    return nil
}

// 使用示例
func main() {
    templates, err := loadTemplates("./form_templates")
    if err != nil {
        panic(err)
    }
    
    // 模拟接收到的表单数据
    jsonData := `{"name": "John", "age": 30, "active": true}`
    var formData map[string]interface{}
    json.Unmarshal([]byte(jsonData), &formData)
    
    // 根据模板验证数据
    template := templates["user_form"]
    if err := validateFormData(template, formData); err != nil {
        fmt.Println("Validation error:", err)
    } else {
        fmt.Println("Form data is valid:", formData)
    }
}

这些方法允许你动态处理JSON数据而不需要预定义完整的结构体。map[string]interface{}适合完全未知的结构，而json.RawMessage适合部分已知的结构。结合模板系统，你可以在运行时根据模板定义验证和处理表单数据。