Go实战项目【三】日志系统和编写路由文件

日志服务

在服务端开发中，日志系统必不可少的，能帮助我们更快的找到问题和运行记录，接下来就简单的做个日志文件系统。
日志是以文件的形式存放在项目的目录中，所以需要使用Go对文件操作,封装一下

pkg/file/file.go

package file

import (
    "io/ioutil"
    "mime/multipart"    //它主要实现了 MIME 的 multipart 解析，主要适用于 HTTP 和常见浏览器生成的 multipart 主体
    "os"
    "path"
)

//获取文件大小
func GetSize(f multipart.File)(int , error)  {
    content,err := ioutil.ReadAll(f)

    return len(content),err
}

//获取文件后缀
func GetExt(filename string) string {
    return path.Ext(filename)
}

//检查文件是否存在
/*
   如果返回的错误为nil,说明文件或文件夹存在
   如果返回的错误类型使用os.IsNotExist()判断为true,说明文件或文件夹不存在
   如果返回的错误为其它类型,则不确定是否在存在
*/
func CheckExist(src string)bool  {
    _, err := os.Stat(src)
    if err == nil {
        return true
    }
    if os.IsNotExist(err) {
        return false
    }
    return false
}

//检查文件权限
func CheckPermission(src string)bool  {
    _,err := os.Stat(src)
    return os.IsPermission(err)
}

//新建文件夹
func MKDir(src string)error  {
    err := os.MkdirAll(src,os.ModePerm)
    return err
}

//如果不存在则新建文件夹
func IsNotExistMkDir(src string)error  {
    if exist := CheckExist(src); exist == false {
        if err := MKDir(src);err !=nil  {
            return err
        }
    }
    return nil
}

/*
   调用文件，支持传入文件名称、指定的模式调用文件、文件权限，返回的文件的方法可以用于I/O。如果出现错误，则为*PathError
   const (
       // Exactly one of O_RDONLY, O_WRONLY, or O_RDWR must be specified.
       O_RDONLY int = syscall.O_RDONLY // 以只读模式打开文件
       O_WRONLY int = syscall.O_WRONLY // 以只写模式打开文件
       O_RDWR   int = syscall.O_RDWR   // 以读写模式打开文件
       // The remaining values may be or'ed in to control behavior.
       O_APPEND int = syscall.O_APPEND // 在写入时将数据追加到文件中
       O_CREATE int = syscall.O_CREAT  // 如果不存在，则创建一个新文件
       O_EXCL   int = syscall.O_EXCL   // 使用O_CREATE时，文件必须不存在
       O_SYNC   int = syscall.O_SYNC   // 同步IO
       O_TRUNC  int = syscall.O_TRUNC  // 如果可以，打开时
   )
*/
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,err
}

这个文件把大部分文件操作的方法封装了。注释中也有讲解。而且以后再有对文件进行操作（比如用户上传/更改头像，上传文件）也都可以使用这些方法进行操作。

然后进行对log的日志文件进行操作
pkg/logging/file.go

package logging

import (
    "api/pkg/file"
    "api/pkg/setting"
    "fmt"
    "os"
    "time"
)

//获取日志文件路径
func getLogFilePath() string {
    return fmt.Sprintf("%s%s", setting.AppSetting.RuntimeRootPath, setting.AppSetting.LogSavePath)
}

//获取日志文件的名称
func getLogFileName() string {
    return fmt.Sprintf("%s%s.%s",
        setting.AppSetting.LogSaveName,
        time.Now().Format(setting.AppSetting.TimeFormat),
        setting.AppSetting.LogFileExt,
    )
}

//打开日志文件
func openLogFile(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 := file.CheckPermission(src)   //检查文件权限
    if perm == true {
        return nil, fmt.Errorf("file.CheckPermission Permission denied src: %s", src)
    }

    err = file.IsNotExistMkDir(src)     //如果不存在则新建文件夹
    if err != nil {
        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
}

日志的文件操作，将会以log+日期.log为命名文件。日志文件夹保存的路径在是根据配置文件设置的，路径为runtime/logs/下

最后对打印日志的格式进行封装
pkg/logging/log.go

package logging

import (
    "fmt"
    "log"
    "os"
    "path/filepath"
    "runtime"
)

type Level int

var (
    F * os.File             //文件

    DefaultPrefix = ""      //默认的前缀
    DefaultCallDepth = 2    //调用深度

    logger *log.Logger      //打印
    logPrefix = ""          //打印前缀
    levelFlags = []string{"DEBUG", "INFO", "WARN", "ERROR", "FATAL"}    //调试，信息，警告，错误，崩溃
)

const (
    DEBUG Level = iota
    INFO
    WARNING
    ERROR
    FATAL
)

func SetUp()  {

    var err error
    filePath := getLogFilePath()        //获取日志文件路径
    fileName := getLogFileName()        //获取日志文件名称
    F, err = openLogFile(fileName, filePath)    //打开日志文件
    if err != nil {
        log.Fatalln(err)
    }

    /*
       log.New创建一个新的日志记录器。out定义要写入日志数据的IO句柄。prefix定义每个生成的日志行的开头。flag定义了日志记录属性
       log.LstdFlags：日志记录的格式属性之一，其余的选项如下
       const (
         Ldate         = 1 << iota     // the date in the local time zone: 2009/01/23
         Ltime                         // the time in the local time zone: 01:23:23
         Lmicroseconds                 // microsecond resolution: 01:23:23.123123.  assumes Ltime.
         Llongfile                     // full file name and line number: /a/b/c/d.go:23
         Lshortfile                    // final file name element and line number: d.go:23. overrides Llongfile
         LUTC                          // if Ldate or Ltime is set, use UTC rather than the local time zone
         LstdFlags     = Ldate | Ltime // initial values for the standard logger
       )
    */
    logger = log.New(F, DefaultPrefix, log.LstdFlags)
}

//设置前缀
func setPrefix(level Level)  {
    _,file,line,ok := runtime.Caller(DefaultCallDepth)
    if ok {
        logPrefix = fmt.Sprintf("[%s][%s:%d]", levelFlags[level], filepath.Base(file), line)
    }else {
        logPrefix = fmt.Sprintf("[%s]", levelFlags[level])
    }

    logger.SetPrefix(logPrefix)
}

func Debug(v ...interface{})  {
    setPrefix(DEBUG)
    logger.Println(v)
}

func Info(v ...interface{}) {
    setPrefix(INFO)
    logger.Println(v)
}

func Warn(v ...interface{}) {
    setPrefix(WARNING)
    logger.Println(v)
}

func Error(v ...interface{}) {
    setPrefix(ERROR)
    logger.Println(v)
}

func Fatal(v ...interface{}) {
    setPrefix(FATAL)
    logger.Fatalln(v)
}

日志打印有5个级别，调试，信息，警告，错误，崩溃。可以根据不同环境下的信息进行调用不同的级别。
在main.go文件中初始化

...
setting.SetUp() //初始化配置文件
logging.SetUp()     //设置日志文件
...

路由文件

用Gin框架启动服务没问题后，进行路由文件的编写。
创建routers/routers.go文件，在这个文件中创建初始化路由的方法
routers/routers.go

package routers

import (
    "api/pkg/e"
    "api/pkg/setting"
    "github.com/gin-gonic/gin"
)

/*
    初始化路由
*/
func InitRouter() *gin.Engine {
    r := gin.New()        //创建gin框架路由实例
    r.Use(gin.Logger())   //使用gin框架中的打印中间件
    r.Use(gin.Recovery()) //使用gin框架中的恢复中间件，可以从任何恐慌中恢复，如果有，则写入500

    gin.SetMode(setting.ServerSetting.RunMode) //设置运行模式，debug或release,如果放在gin.New或者gin.Default之后，还是会打印一些信息的。放之前则不会

    apiv1 := r.Group("/api/v1") //路由分组，apiv1代表v1版本的路由组
    {
        apiv1.GET("version",v1.GetAppVersionTest)   //app版本升级
    }

    return r
}

创建routers/v1/app_version.go

package v1

import (
    "api/pkg/e"
    "github.com/gin-gonic/gin"
)

//app更新接口
func GetAppVersionTest(c *gin.Context)  {

    c.JSON(e.SUCCESS,gin.H{
        "Code":e.SUCCESS,
        "Msg":e.GetMsg(e.SUCCESS),
        "Data":"返回数据成功",
    })
}

同样的，也必须把main方法中的初始化路由修改下
main.go

...
func main() {
    log.Println("Hello, api 正在启动中...")
    setting.SetUp() //初始化配置文件

    router := routers.InitRouter()  //初始化路由

    s := &http.Server{
        Addr:fmt.Sprintf(":%d", setting.ServerSetting.HttpPort),        //设置端口号
        Handler:router,                                         //http句柄，实质为ServeHTTP，用于处理程序响应HTTP请求
        ReadTimeout:setting.ServerSetting.ReadTimeout,          //允许读取的最大时间
        WriteTimeout:setting.ServerSetting.WriteTimeout,        //允许写入的最大时间
        MaxHeaderBytes: 1 << 20,                                //请求头的最大字节数
    }

    /*
       使用 http.Server - Shutdown() 优雅的关闭http服务
    */
    go func() {
        if err := s.ListenAndServe(); err != nil{
            log.Printf("Listen: %s\n", err)
        }
    }()

    quit := make(chan os.Signal)
    signal.Notify(quit,os.Interrupt)
    <- quit

    log.Println("Shutdown Server ...")
    ctx, cancel := context.WithTimeout(context.Background(), 5 * time.Second)
    defer cancel()
    if err := s.Shutdown(ctx); err != nil {
        log.Fatal("Server Shutdown:", err)
    }

    log.Println("程序服务关闭退出")
}

可以看到对路由分组以后，现在接口的url是http://127.0.0.1:9999/api/v1/version
重新进行go run后，浏览器查看是否返回数据

以后的路由代码都会在routers/v1目录下编写，比如app_version.go文件就是有关app升级相关的代码，这里就把路由服务分解开来了。

点关注，不迷路