关于map引用的小问题

问题

前几天我们的一个管理系统系统配置页面，刷新一次，其中有一个配置项就变化一次，简单看了下请求，发现每次请求api返回的数据不一致。于是经过一番排查发现是由于map引用的问题导致的。

代码如下：

1. export.go文件

package preference

import (
    "log"
)

var GeneralSetting general

func NewGeneral() *general {
    return &GeneralSetting
}

func LoadAll() {
    logs.Info("开始加载通用配置...")
    // general
    if err := GeneralSetting.Restore(); err != nil {
        log.Fatal("加载通用配置失败, 错误: ", err.Error())
    }
    logs.Info("配置加载完毕.")
}

2. general.go

package preference

import (
    "encoding/json"
    "time"
)

type PasswordStrengthLevel byte

type (
    general struct {

        PasswordExpire time.Duration
    
        PasswordStrengthLevel PasswordStrengthLevel

        ArchiveInterval map[SecurityClassification]time.Duration
        
        ArchiveNotifyPrinterUserBefore time.Duration

        HelperRFIDReaderIPAddress string
    }

    // 跟上面的结构一毛一样
    generalJSON struct {
        PasswordExpire                 time.Duration                            `json:"passwordExpire"`
        PasswordStrengthLevel          PasswordStrengthLevel                    `json:"passwordStrengthLevel"`
        ArchiveInterval                map[SecurityClassification]time.Duration `json:"archiveInterval"`
        ArchiveNotifyPrinterUserBefore time.Duration                            `json:"archiveNotifyPrinterUserBefore"`
        HelperRFIDReaderIPAddress      string                                   `json:"helperRfidReaderIpAddress"`
    }
)

func (g general) MarshalJSON() ([]byte, error) {
    result := generalJSON{
        PasswordExpire:              g.PasswordExpire / time.Second,
        PasswordStrengthLevel:       g.PasswordStrengthLevel,
        ArchiveInterval:                g.ArchiveInterval,
        ArchiveNotifyPrinterUserBefore: g.ArchiveNotifyPrinterUserBefore / time.Second,
        HelperRFIDReaderIPAddress:      g.HelperRFIDReaderIPAddress,
    }

    for key := range result.ArchiveInterval {
        result.ArchiveInterval[key] = result.ArchiveInterval[key] / time.Second
    }
    return json.Marshal(&result)
}

func (g *general) Restore() (err error) {
    if err = Load(g); err != nil {
        return err
    }
    return nil
}

篇幅有限，我只贴了部分代码，其中关于general结构体中的配置，我们在服务运行的时候会加载配置项到GeneralSetting这个变量中（常驻内存），那么根据上面的问题可以得知GeneralSetting这个变量的内容发生变化了。返回给前端童鞋数据的时候会json序列化，这里我们实现了json序列化的的方法，MarshalJSON方法是一个值接收者，而不是指针，那么根据go方法集规则，当接收者是一个值类型接收者时，那么指针和值都可以调用该方法，区别就是用值去调用该方法时，对接收者的改变不会影响调用者。
而在这里，虽然接收者是值，但是结构体里有一个map类型的数据ArchiveInterval，而map在传递的过程中是引用传递，也就是说，用值调用该方法的时候会产生一份值的拷贝，其中的map拷贝的也只是一个指针，而指向底层的hash桶是同一个，所以当对map中的数据进行修改的时候，调用者里面的map值也会改变。
改动后的代码如下：

func (g general) MarshalJSON() ([]byte, error) {
    result := generalJSON{
        PasswordExpire:              g.PasswordExpire / time.Second,
        PasswordStrengthLevel:       g.PasswordStrengthLevel,
        ArchiveNotifyPrinterUserBefore: g.ArchiveNotifyPrinterUserBefore / time.Second,
        HelperRFIDReaderIPAddress:      g.HelperRFIDReaderIPAddress,
    }

    archiveInterval := make(map[SecurityClassification]time.Duration, len(g.ArchiveInterval))
    for key := range g.ArchiveInterval {
        archiveInterval[key] = g.ArchiveInterval[key] / time.Second
    }
    result.ArchiveInterval = archiveInterval
    return json.Marshal(&result)
}

下面是一个测试用例:

package main

import "fmt"

var personSetting person

type hobby map[string]string

type person struct {
    name  string `json:"name"`
    age   int    `json:"age"`
    hobby hobby  `json:"hobby"`
}

func (p person) Default() {
    result := person{
        name:  p.name,
        age:   p.age,
        hobby: p.hobby,
    }
    result.hobby["a"] = "f"
    //hobby := make(hobby, len(p.hobby));
    //hobby["c"] = "f"
    //result.hobby = hobby
}

func main() {
    personSetting = person{
        name: "初九",
        age:  19,
        hobby: map[string]string{
            "a": "b",
            "c": "d",
        },
    }
    fmt.Print("before:", personSetting)
    personSetting.Default()
    fmt.Print("after:", personSetting)
}
``