[FIX]优化配置读取

main.go

@@ -2,21 +2,39 @@ package main
 
 import (
 	"fmt"
+	"github.com/gin-gonic/gin"
+	"github.com/go-pripro/shop/models"
+	"github.com/go-pripro/shop/pkg/logging"
 	"github.com/go-pripro/shop/pkg/setting"
 	"github.com/go-pripro/shop/routers"
+	"log"
 	"net/http"
 )
 
-func main()  {
+func init()  {
-	router := routers.InitRouter()
+	setting.Setup()
+	models.Setup()
+	logging.Setup()
+}
+
+func main() {
+	gin.SetMode(setting.ServerSetting.RunMode)
+
+	routersInit := routers.InitRouter()
+	readTimeout := setting.ServerSetting.ReadTimeout
+	writeTimeout := setting.ServerSetting.WriteTimeout
+	endPoint := fmt.Sprintf(":%d", setting.ServerSetting.HttpPort)
+	maxHeaderBytes := 1 << 20
 
 	s := &http.Server{
-		Addr: fmt.Sprintf(":%d", setting.HTTPPort),
+		Addr:           endPoint,
-		Handler:  router,
+		Handler:        routersInit,
-		ReadTimeout: setting.ReadTimeout,
+		ReadTimeout:    readTimeout,
-		WriteTimeout: setting.WriteTimeout,
+		WriteTimeout:   writeTimeout,
-		MaxHeaderBytes:  1 << 20,
+		MaxHeaderBytes: maxHeaderBytes,
 	}
 
+	log.Printf("[info] start http server listening %s", endPoint)
+
 	s.ListenAndServe()
-}
+}

models/models.go

@@ -18,38 +18,22 @@ type Model struct {
 	DeleteOn   int `json:"deleted_on"`
 }
 
-func init() {
+func Setup() {
-	var (
+	var err error
-		err                                                     error
-		dbType, dbName, user, password, host, port, tablePrefix string
-	)
 
-	sec, err := setting.Cfg.GetSection("database")
+	db, err = gorm.Open(setting.DatabaseSetting.Type, fmt.Sprintf("host=%s user=%s dbname=%s port=%s sslmode=disable password=%s",
-	if err != nil {
+		setting.DatabaseSetting.Host,
-		log.Fatal(2, "Fail to get section 'database': %v", err)
+		setting.DatabaseSetting.User,
-	}
+		setting.DatabaseSetting.Name,
-
+		setting.DatabaseSetting.Port,
-	dbType = sec.Key("Type").String()
+		setting.DatabaseSetting.Password))
-	dbName = sec.Key("Name").String()
-	user = sec.Key("User").String()
-	password = sec.Key("Password").String()
-	host = sec.Key("Host").String()
-	port = sec.Key("Port").String()
-	tablePrefix = sec.Key("TablePrefix").String()
-
-	db, err = gorm.Open(dbType, fmt.Sprintf("host=%s user=%s dbname=%s port=%s sslmode=disable password=%s",
-		host,
-		user,
-		dbName,
-		port,
-		password))
 
 	if err != nil {
-		log.Println(err)
+		log.Fatalf("models.Setup err: %v", err)
 	}
 
 	gorm.DefaultTableNameHandler = func(db *gorm.DB, defaultTableName string) string {
-		return tablePrefix + defaultTableName
+		return setting.DatabaseSetting.TablePrefix + defaultTableName
 	}
 
 	db.AutoMigrate(&Employee{})

pkg/file/file.go

@@ -0,0 +1,92 @@
+package file
+
+import (
+	"fmt"
+	"io/ioutil"
+	"mime/multipart"
+	"os"
+	"path"
+)
+
+// GetSize get the file size 获取文件大小
+func GetSize(f multipart.File) (int, error) {
+	content, err := ioutil.ReadAll(f)
+
+	return len(content), err
+}
+
+// GetExt get the file ext 获取文件后缀
+func GetExt(fileName string) string {
+	return path.Ext(fileName)
+}
+
+// CheckNotExist check if the file exists 检查文件是否存在
+func CheckNotExist(src string) bool {
+	_, err := os.Stat(src)
+
+	return os.IsNotExist(err)
+}
+
+// CheckPermission check if the file has permission 检查文件权限
+func CheckPermission(src string) bool {
+	_, err := os.Stat(src)
+
+	return os.IsPermission(err)
+}
+
+// IsNotExistMkDir create a directory if it does not exist 如果不存在则新建文件夹
+func IsNotExistMkDir(src string) error {
+	if notExist := CheckNotExist(src); notExist == true {
+		if err := MkDir(src); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// MkDir create a directory 新建文件夹
+func MkDir(src string) error {
+	err := os.MkdirAll(src, os.ModePerm)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Open a file according to a specific mode 打开文件
+func Open(name string, flag int, perm os.FileMode) (*os.File, error) {
+	f, err := os.OpenFile(name, flag, perm)
+	if err != nil {
+		return nil, err
+	}
+
+	return f, nil
+}
+
+// MustOpen maximize trying to open the file
+func MustOpen(fileName, filePath string) (*os.File, error) {
+	dir, err := os.Getwd()
+	if err != nil {
+		return nil, fmt.Errorf("os.Getwd err: %v", err)
+	}
+
+	src := dir + "/" + filePath
+	perm := CheckPermission(src)
+	if perm == true {
+		return nil, fmt.Errorf("file.CheckPermission Permission denied src: %s", src)
+	}
+
+	err = IsNotExistMkDir(src)
+	if err != nil {
+		return nil, fmt.Errorf("file.IsNotExistMkDir src: %s, err: %v", src, err)
+	}
+
+	f, err := Open(src+fileName, os.O_APPEND|os.O_CREATE|os.O_RDWR, 0644)
+	if err != nil {
+		return nil, fmt.Errorf("Fail to OpenFile :%v", err)
+	}
+
+	return f, nil
+}

pkg/logging/file.go

@@ -2,43 +2,41 @@ package logging
 
 import (
 	"fmt"
-	"log"
+	"github.com/go-pripro/shop/pkg/file"
+	"github.com/go-pripro/shop/pkg/setting"
 	"os"
 	"time"
 )
 
-var (
-	LogSavePath = "runtime/logs/"
-	LogSaveName = "log"
-	LogFileExt = "log"
-	TimeFormat = "20060102"
-)
 func getLogFilePath() string {
-	return fmt.Sprintf("%s", LogSavePath)
+	return fmt.Sprintf("%s%s", setting.AppSetting.RuntimeRootPath, setting.AppSetting.LogSavePath)
 }
-func getLogFileFullPath() string {
+
-	prefixPath := getLogFilePath()
+func getLogFileName() string {
-	suffixPath := fmt.Sprintf("%s%s.%s", LogSaveName, time.Now().Format(TimeFormat), LogFileExt)
+	return fmt.Sprintf("%s%s.%s",
-	return fmt.Sprintf("%s%s", prefixPath, suffixPath)
+			setting.AppSetting.LogSavename,
+			time.Now().Format(setting.AppSetting.TimeFormat),
+			setting.AppSetting.LogFileExt,
+	)
 }
-func openLogFile(filePath string) *os.File {
+
-	_, err := os.Stat(filePath)
+func openLogFile(fileName, filePath string) (*os.File, error) {
-	switch {
+	dir, err := os.Getwd()
-	case os.IsNotExist(err):
-		mkDir()
-	case os.IsPermission(err):
-		log.Fatalf("Permission :%v", err)
-	}
-	handle, err := os.OpenFile(filePath, os.O_APPEND | os.O_CREATE | os.O_WRONLY, 0644)
 	if err != nil {
-		log.Fatalf("Fail to OpenFile :%v", err)
+		return nil, fmt.Errorf("os.Getwd err: %v", err)
 	}
-	return handle
+	src := dir + "/" + filePath
-}
+	perm := file.CheckPermission(src)
-func mkDir() {
+	if perm == true {
-	dir, _ := os.Getwd()
+		return nil, fmt.Errorf("file.CheckPermission Permission denied src: %s", src)
-	err := os.MkdirAll(dir + "/" + getLogFilePath(), os.ModePerm)
+	}
+	err = file.IsNotExistMkDir(src)
 	if err != nil {
-		panic(err)
+		return nil, fmt.Errorf("file.IsNotExistMkDir src: %s, err: %v", src, err)
 	}
+	f, err := file.Open(src + fileName, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		return nil, fmt.Errorf("Fail to OpenFile :%v", err)
+	}
+	return f, nil
 }

pkg/logging/log.go

@@ -27,9 +27,16 @@ const (
 	FATAL
 )
 
-func init() {
+func Setup() {
-	filePath := getLogFileFullPath()
+	var err error
-	F = openLogFile(filePath)
+
+	filePath := getLogFilePath()
+	fileName := getLogFileName()
+	F, err = openLogFile(fileName, filePath)
+	if err != nil {
+		log.Fatalf("logging.Setup err: %v", err)
+	}
+
 	logger = log.New(F, DefaultPrefix, log.LstdFlags)
 }
 func Debug(v ...interface{}) {

pkg/setting/setting.go

@@ -6,50 +6,66 @@ import (
 	"time"
 )
 
-var Cfg *ini.File
+type App struct {
-var (
+	JwtSecret       string
+	PageSize        int
+	RuntimeRootPath string
+
+	ImagePrefixUrl string
+	ImageSavePath  string
+	ImageMaxSize   int
+	ImageAllowExts []string
+
+	LogSavePath string
+	LogSavename string
+	LogFileExt  string
+	TimeFormat  string
+}
+
+var AppSetting = &App{}
+
+type Server struct {
 	RunMode      string
-	HTTPPort     int
+	HttpPort     int
 	ReadTimeout  time.Duration
 	WriteTimeout time.Duration
-	PageSize     int
+}
-	JwtSecret    string
-)
 
-func init() {
+var ServerSetting = &Server{}
-	var err error
+
-	Cfg, err = ini.Load("conf/app.ini")
+type Database struct {
+	Type        string
+	User        string
+	Password    string
+	Host        string
+	Port        string
+	Name        string
+	TablePrefix string
+}
+
+var DatabaseSetting = &Database{}
+
+func Setup() {
+	Cfg, err := ini.Load("conf/app.ini")
 	if err != nil {
 		log.Fatalf("Fail to parse 'conf/app.ini': %v", err)
 	}
 
-	LoadBase()
+	err = Cfg.Section("app").MapTo(AppSetting)
-	LoadServer()
-	LoadApp()
-}
-
-func LoadBase() {
-	//RunMode = Cfg.Section("server").Key("RUN_MODE").MustString("debug")
-}
-
-func LoadServer() {
-	sec, err := Cfg.GetSection("server")
 	if err != nil {
-		log.Fatalf("Fail to get section 'sever' : %v", err)
+		log.Fatalf("Cfg.MapTo AppSetting err: %v", err)
 	}
 
-	RunMode = sec.Key("RunMode").MustString("debug")
+	err = Cfg.Section("server").MapTo(ServerSetting)
-	HTTPPort = sec.Key("HttpPort").MustInt(8000)
-	ReadTimeout = time.Duration(sec.Key("ReadTimeout").MustUint(60)) * time.Second
-	WriteTimeout = time.Duration(sec.Key("WriteTimeout").MustInt(60)) * time.Second
-}
-
-func LoadApp() {
-	sec, err := Cfg.GetSection("app")
 	if err != nil {
-		log.Fatalf("Fail to get section 'app':%v", err)
+		log.Fatalf("Cfg.MapTo ServerSetting err: %v", err)
 	}
 
-	JwtSecret = sec.Key("JwtSecret").MustString("!@#!@#!@#!@@#!@#")
+	ServerSetting.ReadTimeout *= time.Second
-	PageSize = sec.Key("WriteTimeout").MustInt(10)
+	ServerSetting.WriteTimeout *= time.Second
+
+	err = Cfg.Section("database").MapTo(DatabaseSetting)
+	if err != nil {
+		log.Fatalf("Cfg.MapTo DatabaseSetting err: %v", err)
+	}
 }

pkg/util/jwt.go

@@ -6,7 +6,7 @@ import (
 	"time"
 )
 
-var jwtSecret = []byte(setting.JwtSecret)
+var jwtSecret = []byte(setting.AppSetting.JwtSecret)
 
 type Claims struct {
 	Username string `json:"username"`

pkg/util/pagenation.go

@@ -10,7 +10,7 @@ func GetPage(c *gin.Context) int {
 	result := 0
 	page, _ := com.StrTo(c.Query("page")).Int()
 	if page > 0 {
-		result = (page - 1) * setting.PageSize
+		result = (page - 1) * setting.AppSetting.PageSize
 	}
 
 	return result

routers/admin/v1/employee.go

@@ -75,7 +75,7 @@ func GetEmployees(c *gin.Context) {
 
 	if ! valid.HasErrors() {
 		code = e.SUCCESS
-		data["lists"] = models.GetEmployees(util.GetPage(c), setting.PageSize, maps)
+		data["lists"] = models.GetEmployees(util.GetPage(c), setting.AppSetting.PageSize, maps)
 		data["total"] = models.GetEmployeeTotal(maps)
 	} else {
 		for _, err := range valid.Errors {

routers/router.go

@@ -15,7 +15,7 @@ func InitRouter() *gin.Engine {
 
 	r.Use(gin.Recovery())
 
-	gin.SetMode(setting.RunMode)
+	gin.SetMode(setting.ServerSetting.RunMode)
 
 	r.GET("/ping", func(c *gin.Context) {
 		c.JSON(200, gin.H{