配置文件的读取与解析 config.json

没有配置则读取默认配置

结构体读取，初学者demo，有啥问题可以留言交流

package main

import (
    "encoding/json"
    "errors"
    "fmt"
    "io/ioutil"
    "os"
    "reflect"
    "strconv"
)

type ConfigStruct struct {
    A string `json:"A" default:"a"`
    B int    `json:"B" default:"1"`
    G struct {
        AA string `json:"AA" default:"aa"`
        BB int    `json:"BB" default:"22"`
        GG struct {
            AAA string `json:"AAA" default:"aaa"`
            BBB int    `json:"BBB" default:"333"`
            // ...struct
        }
    }
}

type ConfigInterface interface {
    // 恢复默认值
    ReDefault(config *interface{}) error
    // 读取配置文件
    ReadFile() error
    // 写入配置文件
    WriteFile() error
}

// 配置
var Config ConfigStruct

// 配置文件名
var configFile string = "config.json"

// 默认值标签名
var tagDefaultName string = "default"

// 恢复默认值
func (Config *ConfigStruct) ReDefault(config interface{}) error {
    t, v := reflect.TypeOf(config), reflect.ValueOf(config)
    tE, vE := t.Elem(), v.Elem()
    if t.Kind() != reflect.Ptr || v.Kind() != reflect.Ptr {
        return errors.New("参数必须是指针")
    }
    if tE.Kind() != reflect.Struct || vE.Kind() != reflect.Struct {
        return errors.New("参数元素必须是结构体")
    }
    for i := 0; i < tE.NumField(); i++ {
        tEf, vEf := tE.Field(i), vE.Field(i)
        tagV := tEf.Tag.Get(tagDefaultName)
        switch vEf.Kind() {
        case reflect.Struct:
            if err := Config.ReDefault(vEf.Addr().Interface()); err != nil {
                return err
            }
        case reflect.String:
            if len(tagV) > 0 {
                vEf.SetString(tagV)
            }
        case reflect.Int:
            if len(tagV) > 0 {
                number, err := strconv.ParseInt(tagV, 0, 64)
                if err == nil {
                    vEf.SetInt(number)
                } else {
                    return err
                }
            }
        default:
            return errors.New("不能处理类型 " + vEf.Kind().String())
        }
    }
    return nil
}

// 读取配置文件
func (Config *ConfigStruct) ReadFile() error {
    configFile, err := ioutil.ReadFile(configFile)
    if err != nil {
        return err
    }
    if err2 := json.Unmarshal(configFile, Config); err2 != nil {
        return err
    }
    return nil
}

// 写入配置文件
func (Config *ConfigStruct) WriteFile() error {
    jsonStr, err := json.MarshalIndent(Config, "", "\t")
    if err != nil {
        return err
    }
    if err := ioutil.WriteFile(configFile, jsonStr, os.ModePerm); err != nil {
        return err
    }
    return nil
}

func init() {
    if err := Config.ReadFile(); err == nil {
        fmt.Println("读取配置文件成功")
    } else {
        fmt.Println("读取配置文件失败", err)
        if err := Config.ReDefault(&Config); err == nil {
            fmt.Println("恢复默认参数成功")
            if err := Config.WriteFile(); err == nil {
                fmt.Println("生成配置文件成功")
            } else {
                fmt.Println("生成配置文件失败", err)
            }
        } else {
            fmt.Println("恢复默认参数失败", err)
        }
    }
}

func main() {
    jsonStr, _ := json.Marshal(Config)
    fmt.Printf("%s \n", jsonStr)
}