使用golang读取ini的配置文件，配置文件包含多个服务器信息，服务器信息可以动态添加，每个服务器中包含服务器的ID、访问地址、用户名、密码、启动的服务，启动的服务可以存在多个，每个服务必须包含启动的ID以及其他的参数，提供读取和写入配置文件的方法

### 回答1：
在 Go 语言中，你可以使用第三方库来读写 INI 配置文件。其中有一个很流行的库就是 "gcfg"。

使用这个库，你可以定义一个结构体来表示你的配置文件，然后使用 gcfg 库的函数来读写这个结构体。

例如，你可以定义一个名为 "Server" 的结构体来表示每个服务器的信息，其中包含服务器的 ID、访问地址、用户名、密码、启动的服务等字段。然后，你可以定义一个名为 "Config" 的结构体来表示整个配置文件，其中包含一个名为 "Servers" 的字段，类型是 []Server。

接着，你可以使用 gcfg 库的 ReadFile() 函数来读取配置文件，并将读取到的信息填充到 Config 结构体中。例如：

var config Config
err := gcfg.ReadFileInto(&config, "config.ini")
if err != nil {
    // 处理错误
}

当然，你也可以使用 gcfg 库的 WriteFile() 函数来将 Config 结构体写入到配置文件中。例如：

err := gcfg.WriteFile(&config, "config.ini")
if err != nil {
    // 处理错误
}

希望这能帮到你！

### 回答2：
在Golang中，可以使用github.com/go-ini/ini包来读取和写入ini配置文件。

首先，我们需要创建一个结构体来表示服务器信息：

type Server struct {
    ID           int
    Address      string
    Username     string
    Password     string
    StartedApps  []App
}

type App struct {
    ID       int
    Params   map[string]string
}

接下来，我们创建一个函数来读取配置文件：

func ReadConfigFile(filename string) ([]Server, error) {
    cfg, err := ini.Load(filename)
    if err != nil {
        return nil, err
    }

    servers := make([]Server, 0)

    // 读取每个服务器的信息
    for _, section := range cfg.Sections() {
        if section.Name() == "DEFAULT" { // 跳过默认的section
            continue
        }

        // 读取服务器信息
        server := Server{
            ID:       section.Key("id").MustInt(),
            Address:  section.Key("address").MustString(),
            Username: section.Key("username").MustString(),
            Password: section.Key("password").MustString(),
        }

        // 读取该服务器启动的服务
        for _, key := range section.Keys() {
            if strings.HasPrefix(key.Name(), "app.") {
                parts := strings.Split(key.Name(), ".")
                appID, _ := strconv.Atoi(parts[1])
                app := App{
                    ID:     appID,
                    Params: make(map[string]string),
                }
                app.Params["params"] = key.String() // 以键值对的方式保存其他参数
                server.StartedApps = append(server.StartedApps, app)
            }
        }

        servers = append(servers, server)
    }

    return servers, nil
}

然后，我们可以创建一个函数来写入配置文件：

func WriteConfigFile(filename string, servers []Server) error {
    cfg := ini.Empty()

    for _, server := range servers {
        section, err := cfg.NewSection(fmt.Sprintf("server%d", server.ID))
        if err != nil {
            return err
        }

        section.NewKey("id", strconv.Itoa(server.ID))
        section.NewKey("address", server.Address)
        section.NewKey("username", server.Username)
        section.NewKey("password", server.Password)

        for _, app := range server.StartedApps {
            section.NewKey(fmt.Sprintf("app.%d", app.ID), app.Params["params"])
        }
    }

    return cfg.SaveTo(filename)
}

这样，我们就可以使用上述函数来读取和写入包含多个服务器信息的ini配置文件了。

### 回答3：
可以使用golang的`ini`包来读取和写入配置文件。

首先，我们需要安装`ini`包。可以使用以下命令进行安装：

go get github.com/go-ini/ini

接下来，我们创建一个`Config`结构体来表示服务器信息和服务信息：

type Server struct {
    ID       int
    Address  string
    Username string
    Password string
    Services []Service
}

type Service struct {
    ID      int
    Params  map[string]string
}

然后，我们可以编写`LoadConfig`函数来读取配置文件：

func LoadConfig(filePath string) (map[int]Server, error) {
    cfg, err := ini.Load(filePath)
    if err != nil {
        return nil, err
    }

    servers := make(map[int]Server)

    for _, section := range cfg.Sections() {
        if section.Name() != "DEFAULT" {
            serverID, _ := section.Key("ID").Int()
            address := section.Key("Address").String()
            username := section.Key("Username").String()
            password := section.Key("Password").String()

            server := Server{
                ID:       serverID,
                Address:  address,
                Username: username,
                Password: password,
            }

            for _, key := range section.Keys() {
                if key.Name() != "ID" && key.Name() != "Address" && key.Name() != "Username" && key.Name() != "Password" {
                    serviceID := key.MustInt()
                    params := make(map[string]string)

                    for _, subKey := range section.Key(key.Name()).SubKeys() {
                        paramName := subKey.Name()
                        paramValue := subKey.Value()

                        params[paramName] = paramValue
                    }

                    service := Service{
                        ID:      serviceID,
                        Params:  params,
                    }

                    server.Services = append(server.Services, service)
                }
            }

            servers[serverID] = server
        }
    }

    return servers, nil
}

最后，我们可以编写`SaveConfig`函数来写入配置文件：

func SaveConfig(filePath string, servers map[int]Server) error {
    cfg := ini.Empty()

    for _, server := range servers {
        section := cfg.Section("")

        section.NewKey("ID", strconv.Itoa(server.ID))
        section.NewKey("Address", server.Address)
        section.NewKey("Username", server.Username)
        section.NewKey("Password", server.Password)

        for _, service := range server.Services {
            serviceSection := section

            serviceSection.NewKey(strconv.Itoa(service.ID), "")

            for paramName, paramValue := range service.Params {
                serviceSection.NewKey(paramName, paramValue)
            }
        }
    }

    err := cfg.SaveTo(filePath)
    if err != nil {
        return err
    }

    return nil
}