|
|
package confm
|
|
|
|
|
|
import (
|
|
|
"errors"
|
|
|
"gopkg.in/yaml.v3"
|
|
|
"log"
|
|
|
"os"
|
|
|
"strconv"
|
|
|
"strings"
|
|
|
)
|
|
|
|
|
|
//变量
|
|
|
//实例池
|
|
|
var pool = map[string]*config{}
|
|
|
|
|
|
//默认选项值
|
|
|
var optionDefault = Option{
|
|
|
Path: "./configs/",
|
|
|
Ext: ".yml",
|
|
|
Sep: ".",
|
|
|
}
|
|
|
|
|
|
//类型
|
|
|
//配置内容
|
|
|
type contents = map[string]map[string]interface{}
|
|
|
type config struct {
|
|
|
option Option
|
|
|
//配置文件内容解码缓存
|
|
|
contents
|
|
|
}
|
|
|
type Option struct {
|
|
|
Name string
|
|
|
|
|
|
Path string
|
|
|
Ext string
|
|
|
Sep string
|
|
|
}
|
|
|
|
|
|
// New 创建对象
|
|
|
func New(option ...Option) *config {
|
|
|
verifiedOption := optionVerify(option...)
|
|
|
return create(verifiedOption)
|
|
|
}
|
|
|
|
|
|
// Get 存在直接返回，否则创建、存储再返回
|
|
|
func Get(option ...Option) *config {
|
|
|
verifiedOption := optionVerify(option...)
|
|
|
if !Has(verifiedOption.Name) {
|
|
|
pool[verifiedOption.Name] = create(verifiedOption)
|
|
|
}
|
|
|
return pool[verifiedOption.Name]
|
|
|
}
|
|
|
|
|
|
// Has 存在返回 true，否则返回 false
|
|
|
func Has(name string) bool {
|
|
|
_, has := pool[name]
|
|
|
return has
|
|
|
}
|
|
|
|
|
|
func create(option Option) *config {
|
|
|
return &config{
|
|
|
option: option,
|
|
|
contents: contents{},
|
|
|
}
|
|
|
}
|
|
|
func optionVerify(option ...Option) Option {
|
|
|
opt := optionDefault
|
|
|
if len(option) > 0 {
|
|
|
opt.Name = option[0].Name
|
|
|
if option[0].Path != "" {
|
|
|
opt.Path = option[0].Path
|
|
|
}
|
|
|
if option[0].Ext != "" {
|
|
|
opt.Ext = option[0].Ext
|
|
|
if !strings.HasPrefix(opt.Ext, ".") {
|
|
|
opt.Ext = "." + opt.Ext
|
|
|
}
|
|
|
}
|
|
|
if option[0].Sep != "" {
|
|
|
opt.Sep = option[0].Sep
|
|
|
}
|
|
|
}
|
|
|
return opt
|
|
|
}
|
|
|
|
|
|
//可导出包方法
|
|
|
|
|
|
// Bool Getter|Setter
|
|
|
func (c config) Bool(key string) bool {
|
|
|
valueIf, err := c.value(key)
|
|
|
if err != nil {
|
|
|
return false
|
|
|
}
|
|
|
value, ok := valueIf.(bool)
|
|
|
if !ok {
|
|
|
return false
|
|
|
}
|
|
|
return value
|
|
|
}
|
|
|
|
|
|
func (c config) String(key string) string {
|
|
|
valueIf, err := c.value(key)
|
|
|
if err != nil {
|
|
|
return ""
|
|
|
}
|
|
|
return assertString(valueIf)
|
|
|
}
|
|
|
|
|
|
func (c config) Int(key string) int {
|
|
|
valueIf, err := c.value(key)
|
|
|
if err != nil {
|
|
|
log.Println(err)
|
|
|
return 0
|
|
|
}
|
|
|
value, ok := valueIf.(int)
|
|
|
if !ok {
|
|
|
return 0
|
|
|
}
|
|
|
return value
|
|
|
}
|
|
|
|
|
|
func (c config) Uint(key string) uint {
|
|
|
valueIf, err := c.value(key)
|
|
|
if err != nil {
|
|
|
log.Println(err)
|
|
|
return 0
|
|
|
}
|
|
|
value, ok := valueIf.(uint)
|
|
|
if !ok {
|
|
|
return 0
|
|
|
}
|
|
|
return value
|
|
|
}
|
|
|
|
|
|
func (c config) Float64(key string) float64 {
|
|
|
valueIf, err := c.value(key)
|
|
|
if err != nil {
|
|
|
return 0
|
|
|
}
|
|
|
return assertFloat64(valueIf)
|
|
|
}
|
|
|
|
|
|
func (c config) Float32(key string) float32 {
|
|
|
valueIf, err := c.value(key)
|
|
|
if err != nil {
|
|
|
return 0
|
|
|
}
|
|
|
return assertFloat32(valueIf)
|
|
|
}
|
|
|
|
|
|
func (c config) BoolSlice(key string) []bool {
|
|
|
valueIf, err := c.value(key)
|
|
|
if err != nil {
|
|
|
return []bool{}
|
|
|
}
|
|
|
//
|
|
|
sli, ok := valueIf.([]interface{})
|
|
|
if !ok {
|
|
|
return []bool{}
|
|
|
}
|
|
|
value := make([]bool, len(sli))
|
|
|
for i, vi := range sli {
|
|
|
v, ok := vi.(bool)
|
|
|
if ok {
|
|
|
value[i] = v
|
|
|
}
|
|
|
}
|
|
|
return value
|
|
|
}
|
|
|
|
|
|
func (c config) IntSlice(key string) []int {
|
|
|
valueIf, err := c.value(key)
|
|
|
if err != nil {
|
|
|
return []int{}
|
|
|
}
|
|
|
//
|
|
|
sli, ok := valueIf.([]interface{})
|
|
|
if !ok {
|
|
|
return []int{}
|
|
|
}
|
|
|
value := make([]int, len(sli))
|
|
|
for i, vi := range sli {
|
|
|
v, ok := vi.(int)
|
|
|
if ok {
|
|
|
value[i] = v
|
|
|
}
|
|
|
}
|
|
|
return value
|
|
|
}
|
|
|
|
|
|
func (c config) StringSlice(key string) []string {
|
|
|
valueIf, err := c.value(key)
|
|
|
if err != nil {
|
|
|
return []string{}
|
|
|
}
|
|
|
//
|
|
|
sli, ok := valueIf.([]interface{})
|
|
|
if !ok {
|
|
|
return []string{}
|
|
|
}
|
|
|
value := make([]string, len(sli))
|
|
|
for i, vi := range sli {
|
|
|
value[i] = assertString(vi)
|
|
|
}
|
|
|
return value
|
|
|
}
|
|
|
|
|
|
func (c config) Float64Slice(key string) []float64 {
|
|
|
valueIf, err := c.value(key)
|
|
|
if err != nil {
|
|
|
return []float64{}
|
|
|
}
|
|
|
//
|
|
|
sli, ok := valueIf.([]interface{})
|
|
|
if !ok {
|
|
|
return []float64{}
|
|
|
}
|
|
|
value := make([]float64, len(sli))
|
|
|
for i, vi := range sli {
|
|
|
value[i] = assertFloat64(vi)
|
|
|
}
|
|
|
return value
|
|
|
}
|
|
|
|
|
|
func (c config) Float32Slice(key string) []float32 {
|
|
|
valueIf, err := c.value(key)
|
|
|
if err != nil {
|
|
|
return []float32{}
|
|
|
}
|
|
|
//
|
|
|
sli, ok := valueIf.([]interface{})
|
|
|
if !ok {
|
|
|
return []float32{}
|
|
|
}
|
|
|
|
|
|
value := make([]float32, len(sli))
|
|
|
for i, vi := range sli {
|
|
|
value[i] = assertFloat32(vi)
|
|
|
}
|
|
|
return value
|
|
|
}
|
|
|
|
|
|
func (c config) BoolMap(key string) map[string]bool {
|
|
|
valueIf, err := c.value(key)
|
|
|
if err != nil {
|
|
|
return map[string]bool{}
|
|
|
}
|
|
|
//
|
|
|
mp, ok := valueIf.(map[string]interface{})
|
|
|
if !ok {
|
|
|
return map[string]bool{}
|
|
|
}
|
|
|
value := map[string]bool{}
|
|
|
for k, vk := range mp {
|
|
|
value[k] = false
|
|
|
v, ok := vk.(bool)
|
|
|
if ok {
|
|
|
value[k] = v
|
|
|
}
|
|
|
}
|
|
|
return value
|
|
|
}
|
|
|
|
|
|
func (c config) IntMap(key string) map[string]int {
|
|
|
valueIf, err := c.value(key)
|
|
|
if err != nil {
|
|
|
return map[string]int{}
|
|
|
}
|
|
|
//
|
|
|
mp, ok := valueIf.(map[string]interface{})
|
|
|
if !ok {
|
|
|
return map[string]int{}
|
|
|
}
|
|
|
value := map[string]int{}
|
|
|
for k, vk := range mp {
|
|
|
value[k] = 0
|
|
|
v, ok := vk.(int)
|
|
|
if ok {
|
|
|
value[k] = v
|
|
|
}
|
|
|
}
|
|
|
return value
|
|
|
}
|
|
|
|
|
|
func (c config) Float64Map(key string) map[string]float64 {
|
|
|
valueIf, err := c.value(key)
|
|
|
if err != nil {
|
|
|
return map[string]float64{}
|
|
|
}
|
|
|
//
|
|
|
mp, ok := valueIf.(map[string]interface{})
|
|
|
if !ok {
|
|
|
return map[string]float64{}
|
|
|
}
|
|
|
|
|
|
value := map[string]float64{}
|
|
|
for k, vk := range mp {
|
|
|
value[k] = assertFloat64(vk)
|
|
|
}
|
|
|
return value
|
|
|
}
|
|
|
|
|
|
func (c config) Float32Map(key string) map[string]float32 {
|
|
|
valueIf, err := c.value(key)
|
|
|
if err != nil {
|
|
|
return map[string]float32{}
|
|
|
}
|
|
|
//
|
|
|
mp, ok := valueIf.(map[string]interface{})
|
|
|
if !ok {
|
|
|
return map[string]float32{}
|
|
|
}
|
|
|
|
|
|
value := map[string]float32{}
|
|
|
for k, vk := range mp {
|
|
|
value[k] = assertFloat32(vk)
|
|
|
}
|
|
|
return value
|
|
|
}
|
|
|
|
|
|
func (c config) StringMap(key string) map[string]string {
|
|
|
valueIf, err := c.value(key)
|
|
|
if err != nil {
|
|
|
return map[string]string{}
|
|
|
}
|
|
|
//
|
|
|
mp, ok := valueIf.(map[string]interface{})
|
|
|
if !ok {
|
|
|
return map[string]string{}
|
|
|
}
|
|
|
value := map[string]string{}
|
|
|
for k, vk := range mp {
|
|
|
value[k] = assertString(vk)
|
|
|
}
|
|
|
return value
|
|
|
}
|
|
|
|
|
|
//非导出方法
|
|
|
|
|
|
//利用 key 获取 值
|
|
|
func (c config) value(key string) (interface{}, error) {
|
|
|
filename, keys := c.parseKey(key)
|
|
|
if data, exists := c.contents[filename]; !exists {
|
|
|
var (
|
|
|
content = []byte{}
|
|
|
err error
|
|
|
)
|
|
|
if content, err = c.getContent(filename); err != nil {
|
|
|
log.Println(err)
|
|
|
return nil, err
|
|
|
}
|
|
|
if err = yaml.Unmarshal(content, &data); err != nil {
|
|
|
log.Println(err)
|
|
|
return nil, err
|
|
|
}
|
|
|
c.contents[filename] = data
|
|
|
}
|
|
|
|
|
|
//解析
|
|
|
for i, l, currLevel := 0, len(keys), c.contents[filename]; i < l; i++ {
|
|
|
//最后一级 key
|
|
|
if i == l-1 {
|
|
|
if value, exists := currLevel[keys[i]]; exists {
|
|
|
return value, nil
|
|
|
} else {
|
|
|
return nil, errors.New("key is not exists")
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//不是最后一级，继续解析
|
|
|
var exists bool
|
|
|
currLevel, exists = currLevel[keys[i]].(map[string]interface{})
|
|
|
if !exists {
|
|
|
return nil, errors.New("key is not exists")
|
|
|
}
|
|
|
}
|
|
|
return nil, nil
|
|
|
}
|
|
|
|
|
|
//解析 key
|
|
|
func (c config) parseKey(key string) (string, []string) {
|
|
|
strs := strings.Split(key, c.option.Sep)
|
|
|
if len(strs) == 1 {
|
|
|
strs = append([]string{"app"}, strs...)
|
|
|
}
|
|
|
return strs[0], strs[1:]
|
|
|
}
|
|
|
|
|
|
//读取配置文件
|
|
|
func (c config) getContent(filename string) ([]byte, error) {
|
|
|
return os.ReadFile(c.option.Path + filename + c.option.Ext)
|
|
|
}
|
|
|
|
|
|
//断言 Interface{} to string
|
|
|
func assertString(valueIf interface{}) (value string) {
|
|
|
switch v := valueIf.(type) {
|
|
|
case string:
|
|
|
value = v
|
|
|
case int:
|
|
|
value = strconv.FormatInt(int64(v), 10) //string(v)
|
|
|
case float64:
|
|
|
value = strconv.FormatFloat(v, 'f', -1, 64)
|
|
|
case float32:
|
|
|
value = strconv.FormatFloat(float64(v), 'f', -1, 64)
|
|
|
case bool:
|
|
|
value = strconv.FormatBool(v)
|
|
|
}
|
|
|
return
|
|
|
}
|
|
|
|
|
|
//断言 Interface{} to float32
|
|
|
func assertFloat32(valueIf interface{}) (value float32) {
|
|
|
switch v := valueIf.(type) {
|
|
|
case float64:
|
|
|
value = float32(v)
|
|
|
case float32:
|
|
|
value = v
|
|
|
case int:
|
|
|
value = float32(v)
|
|
|
}
|
|
|
return
|
|
|
}
|
|
|
|
|
|
//断言 Interface{} to float64
|
|
|
func assertFloat64(valueIf interface{}) (value float64) {
|
|
|
switch v := valueIf.(type) {
|
|
|
case float64:
|
|
|
value = v
|
|
|
case float32:
|
|
|
value = float64(v)
|
|
|
case int:
|
|
|
value = float64(v)
|
|
|
}
|
|
|
return
|
|
|
}
|
