beego配置和环境隔离

beego配置和环境隔离

01、默认解析app.conf

1: Beego 默认会解析当前应用下的 conf/app.conf 文件，后面就可以通过config包名直接使用：

配置文件的内容是：

appname = ksd-social-api
httpport = 8080
runmode = dev
autorender = false
copyrequestbody = true
EnableDocs = true
sqlconn =

在 beego中有一个对应的config对象模块转来解析你默认加载的配置。方便你后续在其他的go文件中使用。比如: 获取的方式有两种

• 使用config方的方式

import (
    "github.com/beego/beego/v2/core/config"
    "github.com/beego/beego/v2/core/logs"
)
​
func main() {
    // 1: 获取配置文件的信息
    appname, _ := config.String("appname")
    runmode, _ := config.String("runmode")
    global.SugarLog.Infof("当前项目的工程名是：%s，环境运行模式是：%s", appname, runmode)
}

• 使用Bconfig代码的方式

 beego.BConfig.RunMode
 beego.BConfig.CopyRequestBody

02、第一种方案：使用文件自身的环境隔离

在开发中我们环境的隔离是非常重要，因为在实际企业中一般开发环境，测试环境，和生产环境是不一样配置信息。所以我们在开发中如果高校隔离环境配置，是很多框架都会去想办法支持的实现一个方向。beego配置机制已经实现了环境隔离。如下：

隔离的方式是通过一个：runmode的配置来决定你选择什么样子的环境来处理你的配置信息：

1: 在conf/app.conf

appname = ksd-social-api
autorender = false
copyrequestbody = true
EnableDocs = true
sqlconn =
# 如果这里指向是dev。那么httpport端口就是：8080
runmode = dev
​
# 开发环境
[dev]
httpport = 8080
# 测试环境
[test]
httpport = 8088
# 生产环境
[prod]
httpport = 8888

2： 获取配置环境

main.go

// 获取当前的开发环境
fmt.Println(beego.BConfig.RunMode)
fmt.Println(config.String("runmode"))
​

然后修改配置文件中runmode=dev 那么久会使用8080来进行初始化web端口，如果是test就会是：8088 ，如果是prod就是：8888

3: 环境的配置如何获取

// 1: 获取配置文件的信息
runmode, _ := config.String("runmode")
copyrequestbody, _ := config.Bool("copyrequestbody")
httpport, _ := config.Int64(runmode + "::httpport")
fmt.Println(runmode, copyrequestbody, httpport)

httpport, _ := config.Int64(runmode + "::httpport") 这行代码要注意，因为httpport已经是放入到环境隔离配置中，你必须要指定获取那个环境下的配置信息，才可以拿到具体哪个环节下的配置信息。格式：环境::环境下面属性名 比如：

httpport, _ := config.Int64(runmode + "::httpport")

4：工具类的封装

package main
​
import (
    "fmt"
    beego "github.com/beego/beego/v2/server/web"
    "ksd-social-api/global"
    initilization "ksd-social-api/initlization"
    _ "ksd-social-api/routers"
    "ksd-social-api/utils"
)
​
func main() {
    // 记录环境信息
    global.Env = beego.BConfig.RunMode
    // 设定环境的日志级别，默认是prod环境下的error级别，意思就是：只有程序报错了才会进行日志写入到文件和控制台中。
    loggerLevel := "error"
    // 如果项目不使用swagger，这里确实可以删除，但是如果使用了最好保留。这个代码的意思，在dev开发环境使用文档方便调试和运行
    // 如果是其它dev以外的环境，不提供swagger文档给外界访问
    if global.Env == "dev" {
        beego.BConfig.WebConfig.DirectoryIndex = true
        beego.BConfig.WebConfig.StaticDir["/swagger"] = "swagger"
        // 如果是开发环境，我们要方便调试我们代码。所以建议使用debug或者info都可以
        loggerLevel = "info"
    }
    
    // 初始化zap日志
    initilization.InitLogger(loggerLevel)
    // 初始化redis
    initilization.InitRedis()
    // 1: 获取配置文件的信息
    runmode := utils.ParseConfig("runmode")
    copyrequestbody := utils.ParseConfig("copyrequestbody")---------------------------
    httpport := utils.ParseEnvConfig("httpport") ----------------------------------
    fmt.Println(runmode, copyrequestbody, httpport)
​
    // 在开发环境可以使用打印把定义和初始化成功的路由全部打印出来，方便你查询和确认你定义的路由是否生效
    if global.Env == "dev" {
        tree := beego.PrintTree()
        methods := tree["Data"].(beego.M)
        for k, v := range methods {
            fmt.Printf("%s => %v\n", k, v)
        }
    }
​
    // beego框架的运行和启动
    beego.Run()
}
​

utils如下：

package utils
​
import (
    "github.com/beego/beego/v2/core/config"
    "ksd-social-api/global"
)
​
func ParseConfig(key string) string {
    s, _ := config.String(key)
    return s
}
​
func ParseEnvConfig(key string) string {
    s, _ := config.String(global.Env + "::" + key)
    return s
}
​

03、第二种方式：自定义配置文件+环境隔离

在开发有时候我们默认app.conf文件配置的信息会随时业务增加而变得复杂和臃肿。你可以自己定义一个业务的配置专门来配置业务的配置信息，比如：

1: 分别定义三个配置文件

在conf/app-dev.conf

redis.port=6379

在conf/app-test.conf

redis.port=6380

在conf/app-prod.conf

redis.port=6381

2: 然后在initlization中定义 init_config.go 如下：

package initilization
​
import (
    "github.com/beego/beego/v2/core/config"
    "github.com/beego/beego/v2/core/logs"
    "ksd-social-api/global"
)
​
func InitMyConfig() {
    // 定义一个新的解析自定义配置的对象 cfg，自定义的文件名是：app-xxx.conf
    cfg, err := config.NewConfig("ini", "conf/app-"+global.Env+".conf")-------------------
    if err != nil {
        logs.Error(err)
    }
    // 这里就把自定义对象使用一个全局对象进行接管，方便后续进行获取和操作
    global.Config = cfg------------------------------------------
}
​

3: 初始化

在main.go中初始化自定义配置文件信息

package main
​
import (
    "fmt"
    beego "github.com/beego/beego/v2/server/web"
    "ksd-social-api/global"
    initilization "ksd-social-api/initlization"
    _ "ksd-social-api/routers"
)
​
func main() {
    //1：记录环境信息
    global.Env = beego.BConfig.RunMode
    //2：解析自定义的配置文件
    initilization.InitMyConfig()--------------------------------------------------------
    fmt.Println(global.Config.String("redis.port"))-----------------------------------------
    //3: beego框架的运行和启动
    beego.Run()
}
​

这样的做法其实就一种跟踪环境变量来获取最定义配置，来进行加载，这样的方式就全部都是平级关系，这样就避免取值过程中还要跟随环境的名字才能取到的问题。

fmt.Println(global.Config.String("redis.port"))

04、yaml解析

import (
    "github.com/beego/beego/v2/core/config"
    // never forget this
    _ "github.com/beego/beego/v2/core/config/yaml"
    "github.com/beego/beego/v2/core/logs"
)
​
var (
    ConfigFile = "./app.yaml"
)
​
func main() {
    cfg err := config.NewConfig("yaml", ConfigFile)
    if err != nil {
        logs.Critical("An error occurred:", err)
        panic(err)
    }
​
    selection, _ := cfg.getSelection("redis")
    logs.Info("load config name is", selection["port"])
}

05、代码修改配置

// 代码修改配置 与 config.Bool("EnableGzip")无关
beego.BConfig.EnableGzip = false
EnableGzip, _ := config.Bool("EnableGzip")
fmt.Println(beego.BConfig.EnableGzip)
fmt.Println(EnableGzip)

如果使用beego.BConfig.xxxx配置项，你又使用配置文件来进行配置，代码中使用beego.BConfig.`的优先级高于配置文件。同时告诉你一个问题配置文件中的属性都是来自：Config这个包下面结构体，不区分大小写：

AppName:             "beego",
RunMode:             PROD,
RouterCaseSensitive: true,
ServerName:          "beegoServer:" + beego.VERSION,
RecoverPanic:        true,
​
CopyRequestBody:    false,
EnableGzip:         false,
MaxMemory:          1 << 26, // 64MB
MaxUploadSize:      1 << 30, // 1GB
EnableErrorsShow:   true,
EnableErrorsRender: true,
Listen: Listen{
    Graceful:      false,
    ServerTimeOut: 0,
    ListenTCP4:    false,
    EnableHTTP:    true,
    AutoTLS:       false,
    Domains:       []string{},
    TLSCacheDir:   ".",
    HTTPAddr:      "",
    HTTPPort:      8080,
    EnableHTTPS:   false,
    HTTPSAddr:     "",
    HTTPSPort:     10443,
    HTTPSCertFile: "",
    HTTPSKeyFile:  "",
    EnableAdmin:   false,
    AdminAddr:     "",
    AdminPort:     8088,
    EnableFcgi:    false,
    EnableStdIo:   false,
    ClientAuth:    int(tls.RequireAndVerifyClientCert),
},
WebConfig: WebConfig{
    AutoRender:             true,
    EnableDocs:             false,
    FlashName:              "BEEGO_FLASH",
    FlashSeparator:         "BEEGOFLASH",
    DirectoryIndex:         false,
    StaticDir:              map[string]string{"/static": "static"},
    StaticExtensionsToGzip: []string{".css", ".js"},
    StaticCacheFileSize:    1024 * 100,
    StaticCacheFileNum:     1000,
    TemplateLeft:           "{{",
    TemplateRight:          "}}",
    ViewsPath:              "views",
    CommentRouterPath:      "controllers",
    EnableXSRF:             false,
    XSRFKey:                "beegoxsrf",
    XSRFExpire:             0,
    Session: SessionConfig{
        SessionOn:                    false,
        SessionProvider:              "memory",
        SessionName:                  "beegosessionID",
        SessionGCMaxLifetime:         3600,
        SessionProviderConfig:        "",
        SessionDisableHTTPOnly:       false,
        SessionCookieLifeTime:        0, // set cookie default is the browser life
        SessionAutoSetCookie:         true,
        SessionDomain:                "",
        SessionEnableSidInHTTPHeader: false, // enable store/get the sessionId into/from http headers
        SessionNameInHTTPHeader:      "Beegosessionid",
        SessionEnableSidInURLQuery:   false, // enable get the sessionId from Url Query params
        SessionCookieSameSite:        http.SameSiteDefaultMode,
    },
},
Log: LogConfig{
    AccessLogs:       false,
    EnableStaticLogs: false,
    AccessLogsFormat: "APACHE_FORMAT",
    FileLineNum:      true,
    Outputs:          map[string]string{"console": ""},
},

通过一系列测试：配置文件中的key是不区分大小写的。

参考：

在beego程序中读取app.conf中的配置内容可以使用：
beego.AppConfig.String("appname")
​
app.conf系统配置内容
AppName
应用名称，默认是 beego。通过 bee new 创建的是创建的项目名。
beego.BConfig.AppName = "beego"
​
RunMode
应用的运行模式，可选值为 prod, dev 或者 test. 默认是 dev, 为开发模式，在开发模式下出错会提示友好的出错页面，如前面错误描述中所述。
beego.BConfig.RunMode = "dev"
​
RouterCaseSensitive
是否路由忽略大小写匹配，默认是 true，区分大小写
beego.BConfig.RouterCaseSensitive = true
​
ServerName
beego 服务器默认在请求的时候输出 server 为 beego。
beego.BConfig.ServerName = "beego"
​
RecoverPanic
是否异常恢复，默认值为 true，即当应用出现异常的情况，通过 recover 恢复回来，而不会导致应用异常退出。
beego.BConfig.RecoverPanic = true
​
CopyRequestBody
是否允许在 HTTP 请求时，返回原始请求体数据字节，默认为 true （GET or HEAD or 上传文件请求除外）。
beego.BConfig.CopyRequestBody = false
​
EnableGzip
是否开启 gzip 支持，默认为 false 不支持 gzip，一旦开启了 gzip，那么在模板输出的内容会进行 gzip 或者 zlib 压缩，根据用户的 Accept-Encoding 来判断。
beego.BConfig.EnableGzip = false
Gzip允许用户自定义压缩级别、压缩长度阈值和针对请求类型压缩:
1.压缩级别, gzipCompressLevel = 9,取值为 1~9,如果不设置为 1(最快压缩)
2.压缩长度阈值, gzipMinLength = 256,当原始内容长度大于此阈值时才开启压缩,默认为 20B(ngnix默认长度)
3.请求类型, includedMethods = get;post,针对哪些请求类型进行压缩,默认只针对 GET 请求压缩
​
MaxMemory
文件上传默认内存缓存大小，默认值是 1 << 26(64M)。
beego.BConfig.MaxMemory = 1 << 26
​
EnableErrorsShow
是否显示系统错误信息，默认为 true。
beego.BConfig.EnableErrorsShow = true
​
EnableErrorsRender
是否将错误信息进行渲染，默认值为 true，即出错会提示友好的出错页面，对于 API 类型的应用可能需要将该选项设置为 false 以阻止在 dev 模式下不必要的模板渲染信息返回。
​
app.conf web配置部分
AutoRender
是否模板自动渲染，默认值为 true，对于 API 类型的应用，应用需要把该选项设置为 false，不需要渲染模板。
beego.BConfig.WebConfig.AutoRender = true
​
EnableDocs
是否开启文档内置功能，默认是 false
beego.BConfig.WebConfig.EnableDocs = true
​
FlashName
Flash 数据设置时 Cookie 的名称，默认是 BEEGO_FLASH
beego.BConfig.WebConfig.FlashName = "BEEGO_FLASH"
​
FlashSeperator
Flash 数据的分隔符，默认是 BEEGOFLASH
beego.BConfig.WebConfig.FlashSeperator = "BEEGOFLASH"
​
DirectoryIndex
是否开启静态目录的列表显示，默认不显示目录，返回 403 错误。
beego.BConfig.WebConfig.DirectoryIndex = false
​
StaticDir
静态文件目录设置，默认是static
可配置单个或多个目录:
单个目录, StaticDir = download. 相当于 beego.SetStaticPath("/download","download")
多个目录, StaticDir = download:down download2:down2. 相当于 beego.SetStaticPath("/download","down") 和
​
beego.SetStaticPath("/download2","down2") beego.BConfig.WebConfig.StaticDir
​
StaticExtensionsToGzip
允许哪些后缀名的静态文件进行 gzip 压缩，默认支持 .css 和 .js
beego.BConfig.WebConfig.StaticExtensionsToGzip = []string{".css", ".js"}
等价 config 文件中
StaticExtensionsToGzip = .css, .js
​
TemplateLeft
模板左标签，默认值是{{。
beego.BConfig.WebConfig.TemplateLeft="{{"
​
TemplateRight
模板右标签，默认值是}}。
beego.BConfig.WebConfig.TemplateRight="}}"
​
ViewsPath
模板路径，默认值是 views。
beego.BConfig.WebConfig.ViewsPath="views"
​
EnableXSRF
是否开启 XSRF，默认为 false，不开启。
beego.BConfig.WebConfig.EnableXSRF = false
​
XSRFKEY
XSRF 的 key 信息，默认值是 beegoxsrf。 EnableXSRF＝true 才有效
beego.BConfig.WebConfig.XSRFKEY = "beegoxsrf"
​
XSRFExpire
XSRF 过期时间，默认值是 0，不过期。
beego.BConfig.WebConfig.XSRFExpire = 0
​
监听配置
Graceful
是否开启热升级，默认是 false，关闭热升级。
beego.BConfig.Listen.Graceful=false
​
ServerTimeOut
设置 HTTP 的超时时间，默认是 0，不超时。
beego.BConfig.Listen.ServerTimeOut=0
​
ListenTCP4
监听本地网络地址类型，默认为 "tcp4"，该值可以是 "tcp", "tcp4", "tcp6", "unix" or "unixpacket" 之一。
beego.BConfig.Listen.ListenTCP4 = "tcp4"
​
EnableHTTP
是否启用 HTTP 监听，默认是 true。
beego.BConfig.Listen.EnableHTTP = true
​
HTTPAddr
应用监听地址，默认为空，监听所有的网卡 IP。
beego.BConfig.Listen.HTTPAddr = ""
​
HTTPPort
应用监听端口，默认为 8080
beego.BConfig.Listen.HTTPPort = 8080
​
EnableHTTPS
是否启用 HTTPS，默认是 false 关闭。当需要启用时，先设置 EnableHTTPS = true，并设置 HTTPSCertFile 和 HTTPSKeyFile
beego.BConfig.Listen.EnableHTTPS = false
​
HTTPSAddr
应用监听地址，默认为空，监听所有的网卡 IP。
beego.BConfig.Listen.HTTPSAddr = ""
​
HTTPSPort
应用监听端口，默认为 10443
beego.BConfig.Listen.HTTPSPort = 10443
​
HTTPSCertFile
开启 HTTPS 后，ssl 证书路径，默认为空。
beego.BConfig.Listen.HTTPSCertFile = "conf/ssl.crt"
​
HTTPSKeyFile
开启 HTTPS 之后，SSL 证书 keyfile 的路径。
beego.BConfig.Listen.HTTPSKeyFile = "conf/ssl.key"
​
EnableAdmin
是否开启进程内监控模块，默认 false 关闭。
beego.BConfig.Listen.EnableAdmin = false
​
AdminAddr
监控程序监听的地址，默认值是 localhost 。
beego.BConfig.Listen.AdminAddr = "localhost"
​
AdminPort
监控程序监听的地址，默认值是 8088 。
beego.BConfig.Listen.AdminPort = 8088
​
EnableFcgi
是否启用 fastcgi ， 默认是 false。
beego.BConfig.Listen.EnableFcgi = false
​
EnableStdIo
通过fastcgi 标准I/O，启用 fastcgi 后才生效，默认 false。
beego.BConfig.Listen.EnableStdIo = false
​
Session配置
SessionOn
session 是否开启，默认是 false。
beego.BConfig.WebConfig.Session.SessionOn = false
​
SessionProvider
session 的引擎，默认是 memory，详细参见 session 模块。
beego.BConfig.WebConfig.Session.SessionProvider = ""
​
SessionName
存在客户端的 cookie 名称，默认值是 beegosessionID。
beego.BConfig.WebConfig.Session.SessionName = "beegosessionID"
​
SessionGCMaxLifetime
session 过期时间，默认值是 3600 秒。
beego.BConfig.WebConfig.Session.SessionGCMaxLifetime = 3600
​
SessionProviderConfig
配置信息，根据不同的引擎设置不同的配置信息，详细的配置请看下面的引擎设置，详细参见 session 模块
​
SessionCookieLifeTime
session 默认存在客户端的 cookie 的时间，默认值是 3600 秒。
beego.BConfig.WebConfig.Session.SessionCookieLifeTime = 3600
​
SessionAutoSetCookie
是否开启SetCookie, 默认值 true 开启。
beego.BConfig.WebConfig.Session.SessionAutoSetCookie = true
​
SessionDomain
session cookie 存储域名, 默认空。
beego.BConfig.WebConfig.Session.SessionDomain = ""
​
Log配置
AccessLogs
是否输出日志到 Log，默认在 prod 模式下不会输出日志，默认为 false 不输出日志。此参数不支持配置文件配置。
beego.BConfig.Log.AccessLogs = false
​
FileLineNum
是否在日志里面显示文件名和输出日志行号，默认 true。此参数不支持配置文件配置。
beego.BConfig.Log.FileLineNum = true
​
Outputs
日志输出配置，参考 logs 模块，console file 等配置，此参数不支持配置文件配置。
beego.BConfig.Log.Outputs = map[string]string{"console": ""}
或者
beego.BConfig.Log.Outputs["console"] = ""

小结

beego系统三种获取配置文件信息的方式

• config.string
• beego.BConfig.xxxx
• beego.AppConfig.String

获取系统配置的信息

• config.string (获取app.conf定义的配置信息或者在app.conf环境隔离的属性）
• beego.BConfig.xxxx (都是用于获取app.conf定义的配置信息)

获取自定义的配置信息

• beego.AppConfig.string("key") 获取自定义部分的信息，里面已经把环境的问题处理掉了。
• config.string 来获取就必须指定环境来找到环境隔离下面的属性值。