封裝包，首先需要先定義一些能夠描述日志方法的接口，基本的都是你的應用程序所需要的方法。比如，基本的日志接口基本的方法有 Info、Warn、 Error。然后就可以創(chuàng)建此接口的實現(xiàn)，將數(shù)據(jù)記錄到記錄庫中。定義了接口和實現(xiàn)，就可以創(chuàng)建一個 logger 封裝，并將相關的接口方法公開。

簡單包封裝

以下定義了五個方法：Info, Warn, Error 和 Fatal. 這些方法接口接收 2個參數(shù)，一個字符串和一個字段映射map.

type Logger interface {
	Debug(msg string, field map[string]interface{})
	Info(msg string, field map[string]interface{})
	Warn(msg string, field map[string]interface{})
	Error(msg string, field map[string]interface{})
	Fatal(msg string, field map[string]interface{})
}

接下來就是實現(xiàn)啦 Logger 方法，底層的實現(xiàn)主要是依賴使用 Logrus。首先需要創(chuàng)建一個 LLogger 結構體，該結構體包含 Logrus 實例。當然還需要一個 NewLLogger 方法來實例化一個 LLogger。

type LLogger struct {
	logger *logrus.Logger
	ctx    context.Context
}
func NewLLogger(ctx context.Context) *LLogger {
	logger := logrus.New()
	logger.Out = os.Stdout
	return &LLogger{logger: logger, ctx: ctx}
}
func (l *LLogger) Info(msg string, fields map[string]interface{}) {
	l.logger.WithFields(fields).Info(msg)
}
func (l *LLogger) Warn(msg string, fields map[string]interface{}) {
	l.logger.WithFields(fields).Warn(msg)
}
func (l *LLogger) Error(msg string, fields map[string]interface{}) {
	l.logger.WithFields(fields).Error(msg)
}
func (l *LLogger) Fatal(msg string, fields map[string]interface{}) {
	l.logger.WithFields(fields).Fatal(msg)
}

這樣一個簡單日志封裝就完成了，使用時就可以直接使用。

func main() {
	ctx := ... // context 信息
	lg := NewLLogger(ctx)
	fields := map[string]interface{}{
		"userId":    "xiaoxiong",
		"ipAddress": "127.0.0.1",
	}
	lg.Info("這是測試信息", fields)
}

多日志庫切換

當?shù)讓有枰褂玫氖遣煌娜罩編爝M行記錄日志時，那就需要封裝另外的日志，但是在實例化方法時可以增加一種日志類型參數(shù)，然后根據(jù)不同的類型實例化不同的日志。

比如使用了zap 包，那童養(yǎng)媳與奧實現(xiàn)接口的四個方法：Info, Warn, Error and Fatal.

type ZapLog struct {
	logger *zap.Logger
	ctx    context.Context
}
func NewZapLog(ctx context.Context) *ZapLog {
	logger, _ := zap.NewProduction()
	return &ZapLog{logger: logger, ctx: ctx}
}
func (l *ZapLog) Info(msg string, fields map[string]interface{}) {
	l.logger.Info(msg, zap.Any("args", fields))
}
func (l *ZapLog) Warn(msg string, fields map[string]interface{}) {
	l.logger.Warn(msg, zap.Any("args", fields))
}
func (l *ZapLog) Error(msg string, fields map[string]interface{}) {
	l.logger.Error(msg, zap.Any("args", fields))
}
func (l *ZapLog) Fatal(msg string, fields map[string]interface{}) {
	l.logger.Fatal(msg, zap.Any("args", fields))
}

定義其他日志庫的方法后就只需對這個兩個日志庫進行封裝，根據(jù)不同的類型初始化出不同的日志，然后使用日志時候就使用相應的包進行處理。

type LoggerWrapper struct {
	logger Logger
}
func NewLoggerWrapper(loggerType string, ctx context.Context) *LoggerWrapper {
	var logger Logger
	switch loggerType {
	case "logrus":
		logger = NewLLogger(ctx)
	case "zap":
		logger = NewZapLog(ctx)
	default:
		logger = NewLLogger(ctx)
	}
	return &LoggerWrapper{logger: logger}
}