1、Golang 获取系统环境变量
Golang 要获取系统的环境变量需要导入"os"包，通过os包中的Getenv方法来获取。
| 1 2 3 |
func Getenv（key string） string {
}
|
示例代码：
| 1 2 3 4 5 6 7 8 9 10 |
package main
import (
"fmt"
"os"
)
func main() {
fmt.Println(os.Getenv("GOPATH"))
}
|
2、通过godotenv库配置环境变量
2.1 简介
微服务应用提倡将配置存储在环境变量中。任何从开发环境切换到生产环境时需要修改的东西都从代码抽取到环境变量里。但是在实际开发中，如果同一台机器运行多个项目，设置环境变量容易冲突，不实用。godotenv库从.env文件中读取配置， 然后存储到程序的环境变量中。在代码中可以使用读取非常方便。godotenv源于一个 Ruby 的开源项目dotenv。
2.2 快速使用
第三方库需要先安装：
| 1 |
go get github.com/joho/godotenv
|
后使用：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package main
import (
"fmt"
"log"
"os"
"github.com/joho/godotenv"
)
func main() {
err := godotenv.Load()
if err != nil {
log.Fatal(err)
}
fmt.Println("name: ", os.Getenv("name"))
fmt.Println("age: ", os.Getenv("age"))
}
|
然后在可执行程序相同目录下，添加一个.env文件：
运行程序，输出：
可见，使用非常方便。默认情况下，godotenv读取项目根目录下的.env文件，文件中使用key = value的格式，每行一个键值对。调用godotenv.Load()即可加载，可直接调用os.Getenv("key")读取。
2.3 高级特性
自动加载
如果连Load方法都不想自己调用,可以导入github.com/joho/godotenv/autoload，配置会自动读取：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 |
package main
import (
"fmt"
"os"
_ "github.com/joho/godotenv/autoload"
)
func main() {
fmt.Println("name: ", os.Getenv("name"))
fmt.Println("age: ", os.Getenv("age"))
}
|
注意，由于代码中没有显式用到godotenv库，需要使用空导入，即导入时包名前添加一个_。
看autoload包的源码，其实就是库帮你调用了Load方法：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
// src/github.com/joho/godotenv/autoload/autoload.go
package autoload
/*
You can just read the .env file on import just by doing
import _ "github.com/joho/godotenv/autoload"
And bob's your mother's brother
*/
import"github.com/joho/godotenv"
func init() {
godotenv.Load()
}
|
加载自定义文件
默认情况下，加载的是项目根目录下的.env文件。当然我们可以加载任意名称的文件，文件也不必以.env为后缀：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
package main
import (
"fmt"
"log"
"os"
"github.com/joho/godotenv"
)
func main() {
err := godotenv.Load("common", "dev.env", "production.env")
if err != nil {
log.Fatal(err)
}
fmt.Println("name: ", os.Getenv("name"))
fmt.Println("version: ", os.Getenv("version"))
fmt.Println("database: ", os.Getenv("database"))
}
|
common文件内容：
| 1 2 |
name = awesome web
version = 0.0.1
|
dev.env文件内容：
production.env文件内容：
运行结果：
| 1 2 3 |
name: awesome web
version: 0.0.1
database: sqlite
|
注意：Load接收多个文件名作为参数，如果不传入文件名，默认读取.env文件的内容。如果多个文件中存在同一个键，那么先出现的优先，后出现的不生效。所以，上面输出的database是sqlite。
注释
.env文件中可以添加注释，注释以#开始，直到该行结束。
| 1 2 3 4 |
# app name
name = awesome web
# current version
version = 0.0.1
|
YAML
.env文件还可以使用 YAML 格式：
| 1 2 |
name: awesome web
version: 0.0.1
|
不存入环境变量（重要）
godotenv允许不将.env文件内容存入环境变量，使用godotenv.Read()返回一个map[string]string，可直接使用：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package main
import (
"fmt"
"log"
"github.com/joho/godotenv"
)
func main() {
var myEnv map[string]string
myEnv, err := godotenv.Read()
if err != nil {
log.Fatal(err)
}
fmt.Println("name: ", myEnv["name"])
fmt.Println("version: ", myEnv["version"])
}
|
输出：
| 1 2 |
name: awesome web
version: 0.0.1
|
直接操作map，简单直接！
数据源
除了读取文件，还可以从string、io.Reader中读取配置：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
package main
import (
"fmt"
"log"
"github.com/joho/godotenv"
)
func main() {
content := `
name: awesome web
version: 0.0.1
`
myEnv, err := godotenv.Unmarshal(content)
if err != nil {
log.Fatal(err)
}
fmt.Println("name: ", myEnv["name"])
fmt.Println("version: ", myEnv["version"])
}
|
输出：
| 1 2 |
name: awesome web
version: 0.0.1
|
只要实现了io.Reader接口，就能作为数据源。可以从文件（os.File），网络（net.Conn），bytes.Buffer等多种来源读取：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
package main
import (
"bytes"
"fmt"
"log"
"os"
"github.com/joho/godotenv"
)
func main() {
file, _ := os.OpenFile(".env", os.O_RDONLY, 0666)
myEnv, err := godotenv.Parse(file)
if err != nil {
log.Fatal(err)
}
fmt.Println("name: ", myEnv["name"])
fmt.Println("version: ", myEnv["version"])
buf := &bytes.Buffer{}
buf.WriteString("name: awesome web @buffer")
buf.Write([]byte{'\n'})
buf.WriteString("version: 0.0.1")
myEnv, err = godotenv.Parse(buf)
if err != nil {
log.Fatal(err)
}
fmt.Println("name: ", myEnv["name"])
fmt.Println("version: ", myEnv["version"])
}
|
输出：
| 1 2 3 4 |
name: awesome web
version: 0.0.1
name: awesome web @buffer
version: 0.0.1
|
注意，从字符串读取和从io.Reader读取使用的方法是不同的。前者为Unmarshal，后者是Parse。
生成.env文件
可以通过程序生成一个.env文件的内容，可以直接写入到文件中：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
package main
import (
"bytes"
"log"
"github.com/joho/godotenv"
)
func main() {
buf := &bytes.Buffer{}
buf.WriteString("name = awesome web")
buf.WriteByte('\n')
buf.WriteString("version = 0.0.1")
env, err := godotenv.Parse(buf)
if err != nil {
log.Fatal(err)
}
err = godotenv.Write(env, "./.env")
if err != nil {
log.Fatal(err)
}
}
|
查看生成的.env文件：
| 1 2 |
name="awesome web"
version="0.0.1"
|
还可以返回一个字符串：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
package main
import (
"bytes"
"fmt"
"log"
"github.com/joho/godotenv"
)
func main() {
buf := &bytes.Buffer{}
buf.WriteString("name = awesome web")
buf.WriteByte('\n')
buf.WriteString("version = 0.0.1")
env, err := godotenv.Parse(buf)
if err != nil {
log.Fatal(err)
}
content, err := godotenv.Marshal(env)
if err != nil {
log.Fatal(err)
}
fmt.Println(content)
}
|
输出：
| 1 2 |
name="awesome web"
version="0.0.1"
|
命令行模式
godotenv还提供了一个命令行的模式：
| 1 |
godotenv -f ./.env command args
|
前面在go get安装godotenv时，godotenv就已经安装在$GOPATH/bin目录下了，我习惯把$GOPATH/bin加入系统PATH，所以godotenv命令可以直接使用。
命令行模式就是读取指定文件（如果不通过-f指定，则使用.env文件），设置环境变量，然后运行后面的程序。
我们简单写一个程序验证一下：
| 1 2 3 4 5 6 7 8 9 10 11 |
package main
import (
"fmt"
"os"
)
func main() {
fmt.Println(os.Getenv("name"))
fmt.Println(os.Getenv("version"))
}
|
使用godotenv运行一下：
| 1 |
godotenv -f ./.env go run main.go
|
输出：
多个环境
实践中，一般会根据APP_ENV环境变量的值加载不同的文件：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
package main
import (
"fmt"
"log"
"os"
"github.com/joho/godotenv"
)
func main() {
env := os.Getenv("GODAILYLIB_ENV")
if env == "" {
env = "development"
}
err := godotenv.Load(".env." + env)
if err != nil {
log.Fatal(err)
}
err = godotenv.Load()
if err != nil {
log.Fatal(err)
}
fmt.Println("name: ", os.Getenv("name"))
fmt.Println("version: ", os.Getenv("version"))
fmt.Println("database: ", os.Getenv("database"))
}
|
我们先读取环境变量GODAILYLIB_ENV，然后读取对应的.env. + env，最后读取默认的.env文件。
前面也提到过，先读取到的优先。我们可以在默认的.env文件中配置基础信息和一些默认的值， 如果在开发/测试/生产环境需要修改，那么在对应的.env.development/.env.test/.env.production文件中再配置一次即可。
.env文件内容：
| 1 2 3 |
name = awesome web
version = 0.0.1
database = file
|
.env.development文件内容：
.env.production文件内容：
运行程序：
| 1 2 3 4 5 6 7 8 9 10 11 |
# 默认是开发环境
$ go run main.go
name: awesome web
version: 0.0.1
database: sqlite3
# 设置为生产环境
$ GODAILYLIB_ENV=production go run main.go
name: awesome web
version: 0.0.1
database: mysql
|
2.4 一点源码
godotenv读取文件内容，为什么可以使用os.Getenv访问：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
// src/github.com/joho/godotenv/godotenv.go
func loadFile(filename string, overload bool) error {
envMap, err := readFile(filename)
if err != nil {
return err
}
currentEnv := map[string]bool{}
rawEnv := os.Environ()
for _, rawEnvLine := range rawEnv {
key := strings.Split(rawEnvLine, "=")[0]
currentEnv[key] = true
}
for key, value := range envMap {
if !currentEnv[key] || overload {
os.Setenv(key, value)
}
}
returnnil
}
|
因为godotenv调用os.Setenv将键值对设置到环境变量中了。
