golang：编写一个简单的文件日志

柔光的暖阳◎ 2022-02-26 21:35 534阅读 0赞

在上一节中，我们解决了API’s可以任意访问的问题，那么我们现在还有一个问题。

就是我们的日志，都是输出到控制台上的，这显然对于一个项目来说是不合理的，因此我们这一节简单封装log库，使其支持简单的文件日志！

# 新建logging包 #

我们在`pkg`下新建`logging`目录，新建`file.go`和`log.go`文件，写入内容：

## 编写file文件 ##

1、file.go

package logging
    
    import (
    	"os"
    	"time"
    	"fmt"
    	"log"
    )
    
    var (
    	LogSavePath = "runtime/logs/"
    	LogSaveName = "log"
    	LogFileExt = "log"
    	TimeFormat = "20060102"
    )
    
    func getLogFilePath() string {
        
    	return fmt.Sprintf("%s", LogSavePath)
    }
    
    func getLogFileFullPath() string {
        
    	prefixPath := getLogFilePath()
    	suffixPath := fmt.Sprintf("%s%s.%s", LogSaveName, time.Now().Format(TimeFormat), LogFileExt)
    
    	return fmt.Sprintf("%s%s", prefixPath, suffixPath)
    }
    
    func openLogFile(filePath string) *os.File {
        
    	_, err := os.Stat(filePath)
    	switch {
        
    		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 handle
    }
    
    func mkDir() {
        
    	dir, _ := os.Getwd()
    	err := os.MkdirAll(dir + "/" + getLogFilePath(), os.ModePerm)
    	if err != nil {
        
    		panic(err)
    	}
    }

*  `os.Stat`：返回文件信息结构描述文件。如果出现错误，会返回`*PathError`

type PathError struct {
        
        Op   string
        Path string
        Err  error
    }

*  `os.IsNotExist`：能够接受`ErrNotExist`、`syscall`的一些错误，它会返回一个布尔值，能够得知文件不存在或目录不存在
 *  `os.IsPermission`：能够接受`ErrPermission`、`syscall`的一些错误，它会返回一个布尔值，能够得知权限是否满足
 *  `os.OpenFile`：调用文件，支持传入文件名称、指定的模式调用文件、文件权限，返回的文件的方法可以用于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  // 如果可以，打开时
    )

*  `os.Getwd`：返回与当前目录对应的根路径名
 *  `os.MkdirAll`：创建对应的目录以及所需的子目录，若成功则返回`nil`，否则返回`error`
 *  `os.ModePerm`：`const`定义`ModePerm FileMode = 0777`

## 编写log文件 ##

2、log.go

package logging
    
    import (
    	"log"
    	"os"
    	"runtime"
    	"path/filepath"
    	"fmt"
    )
    
    type Level int
    
    var (
    	F *os.File
    
    	DefaultPrefix = ""
    	DefaultCallerDepth = 2
    
    	logger *log.Logger
    	logPrefix = ""
    	levelFlags = []string{
        "DEBUG", "INFO", "WARN", "ERROR", "FATAL"}
    )
    
    const (
    	DEBUG Level = iota
    	INFO
    	WARNING
    	ERROR
    	FATAL
    )
    
    func init() {
        
    	filePath := getLogFileFullPath()
    	F = openLogFile(filePath)
    
    	logger = log.New(F, DefaultPrefix, log.LstdFlags)
    }
    
    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)
    }
    
    func setPrefix(level Level) {
        
    	_, file, line, ok := runtime.Caller(DefaultCallerDepth)
    	if ok {
        
    		logPrefix = fmt.Sprintf("[%s][%s:%d]", levelFlags[level], filepath.Base(file), line)
    	} else {
        
    		logPrefix = fmt.Sprintf("[%s]", levelFlags[level])
    	}
    	
    	logger.SetPrefix(logPrefix)
    }

\*`log.New`：创建一个新的日志记录器。`out`定义要写入日志数据的IO句柄。`prefix`定义每个生成的日志行的开头。`flag`定义了日志记录属性

func New(out io.Writer, prefix string, flag int) *Logger {
        
        return &Logger{
        out: out, prefix: prefix, flag: 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
    )

当前目录结构：

gin-blog/
    ├── conf
    │   └── app.ini
    ├── main.go
    ├── middleware
    │   └── jwt
    │       └── jwt.go
    ├── models
    │   ├── article.go
    │   ├── auth.go
    │   ├── models.go
    │   └── tag.go
    ├── pkg
    │   ├── e
    │   │   ├── code.go
    │   │   └── msg.go
    │   ├── logging
    │   │   ├── file.go
    │   │   └── log.go
    │   ├── setting
    │   │   └── setting.go
    │   └── util
    │       ├── jwt.go
    │       └── pagination.go
    ├── routers
    │   ├── api
    │   │   ├── auth.go
    │   │   └── v1
    │   │       ├── article.go
    │   │       └── tag.go
    │   └── router.go
    ├── runtime

我们自定义的`logging`包，已经基本完成了，接下来让它接入到我们的项目之中吧！

我们打开先前包含`log`包的代码，

*  打开`routers`目录下的`article.go`、`tag.go`、`auth.go`
 *  将`log`包的引用删除，修改引用我们自己的日志包为`gin-blog/pkg/logging`
 *  将原本的`log.Println(...)`改为`logging.Info(...)`

例如`auth.go`文件的修改内容：

package api
    
    import (
    	"net/http"
    
    	"github.com/gin-gonic/gin"
    	"github.com/astaxie/beego/validation"
    
    	"gin-blog/pkg/e"
    	"gin-blog/pkg/util"
    	"gin-blog/models"
    	"gin-blog/pkg/logging"
    )
    ...
    func GetAuth(c *gin.Context) {
        
    	...
    	code := e.INVALID_PARAMS
    	if ok {
        
    		...
    	} else {
        
    	    for _, err := range valid.Errors {
        
                    logging.Info(err.Key, err.Message)
                }
    	}
    
    	c.JSON(http.StatusOK, gin.H{
        
            "code" : code,
            "msg" : e.GetMsg(code),
            "data" : data,
        })
    }

# 验证功能 #

修改文件后，重启服务，我们来试试吧！

获取到`API`的`Token`后，我们故意传错误`URL`参数给接口，如：http://127.0.0.1:8000/api/v1/articles?tag\_id=0&state=9999999&token=eyJhbG…

然后我们到`$GOPATH/gin-blog/runtime/logs`查看日志：

$ tail -f log20180216.log 
    [INFO][article.go:79]2018/02/16 18:33:12 [state 状态只允许0或1]
    [INFO][article.go:79]2018/02/16 18:33:42 [state 状态只允许0或1]
    [INFO][article.go:79]2018/02/16 18:33:42 [tag_id 标签ID必须大于0]
    [INFO][article.go:79]2018/02/16 18:38:39 [state 状态只允许0或1]
    [INFO][article.go:79]2018/02/16 18:38:39 [tag_id 标签ID必须大于0]

日志结构一切正常，我们的记录模式都为`Info`，因此前缀是对的，并且我们是入参有问题，也把错误记录下来了，这样排错就很方便了！

至此，本节就完成了，这只是一个简单的扩展，实际上我们线上项目要使用的文件日志，是更复杂一些，开动你的大脑 举一反三吧！

# 参考 #

## 本系列示例代码 ##

*  [go-gin-example][]

[原文][Link 1]

[go-gin-example]: https://github.com/EDDYCJY/go-gin-example
[Link 1]: https://github.com/EDDYCJY/blog/blob/master/golang/gin/2018-02-16-Gin%E5%AE%9E%E8%B7%B5-%E8%BF%9E%E8%BD%BD%E5%85%AD-%E7%BC%96%E5%86%99%E4%B8%80%E4%B8%AA%E7%AE%80%E5%8D%95%E7%9A%84%E6%96%87%E4%BB%B6%E6%97%A5%E5%BF%97.md