Go學(xué)習(xí)筆記之Zap日志的使用
Log包
Go語言提供的默認(rèn)日志包：https://golang.org/pkg/log/
基本用法
log包定義了Logger類型，該類型提供了一些格式化輸出的方法。
type Logger struct {
mu sync.Mutex // ensures atomic writes; protects the following fields
prefix string // prefix on each line to identify the logger (but see Lmsgprefix)
flag int // properties
out io.Writer // destination for output
buf []byte // for accumulating text to write
}mu屬性主要是為了確保原子操作，prefix設(shè)置每一行的前綴，flag設(shè)置輸出的各種屬性，比如時間、行號、文件路徑等。out輸出的方向，用于把日志存儲文件。
本包也提供了一個預(yù)定義的“標(biāo)準(zhǔn)”logger，可以通過調(diào)用函數(shù)Print系列(Print|Printf|Println）、Fatal系列（Fatal|Fatalf|Fatalln）、和Panic系列（Panic|Panicf|Panicln）來使用，比自行創(chuàng)建一個logger對象更容易使用。
例如，我們可以像下面的代碼一樣直接通過log包來調(diào)用上面提到的方法，默認(rèn)它們會將日志信息打印到終端界面：
log.Println("這是一條優(yōu)雅的日志。")
v := "優(yōu)雅的"
log.Printf("這是一個%s日志\n", v)
//fatal系列函數(shù)會在寫入日志信息后調(diào)用os.Exit(1)
log.Fatalln("這是一天會觸發(fā)fatal的日志")
//Panic系列函數(shù)會在寫入日志信息后panic
log.Panicln("這是一個會觸發(fā)panic的日志。") //執(zhí)行后會自動觸發(fā)一個異常flag屬性
默認(rèn)情況下的logger只會提供日志的時間信息，但是很多情況下我們希望得到更多信息，比如記錄該日志的文件名和行號等。log標(biāo)準(zhǔn)庫中為我們提供了定制這些設(shè)置的方法。
log標(biāo)準(zhǔn)庫中的Flags函數(shù)會返回標(biāo)準(zhǔn)logger的輸出配置，而SetFlags函數(shù)用來設(shè)置標(biāo)準(zhǔn)logger的輸出配置。下面是flag屬性對應(yīng)的常量
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
Lmsgprefix // move the "prefix" from the beginning of the line to before the message
LstdFlags = Ldate | Ltime // initial values for the standard logger
)設(shè)置輸出屬性的代碼如下：
func main() {
log.SetFlags(log.Llongfile | log.Lmicroseconds | log.Ldate)
log.Println("這是一條優(yōu)雅的日志。")
}編譯輸出：
2020/07/14 22:51:06.079594 D:/xxx/test_log.go:24: 這是一條優(yōu)雅的日志。
prefix屬性
log標(biāo)準(zhǔn)庫中還提供了關(guān)于日志信息前綴的兩個方法：其中Prefix函數(shù)用來查看標(biāo)準(zhǔn)logger的輸出前綴，SetPrefix函數(shù)用來設(shè)置輸出前綴。
func Prefix() string func SetPrefix(prefix string)
設(shè)置日志輸出前綴的代碼如下：
func main() {
log.SetPrefix("[PS]")
log.Println("這是一條很普通的日志。")
}編譯輸出：
[PS]2020/07/14 22:56:15.652555 D:/xxx/test_log.go:26: 這是一個普通的日志
out屬性
out屬性是一個io.Writer輸出流，使用它可以把日志輸出為文件。
需要用的方法為：設(shè)置標(biāo)準(zhǔn)logger的輸出目的地，默認(rèn)是標(biāo)準(zhǔn)錯誤輸出。
func SetOutput(w io.Writer)
例如，下面的代碼會把日志輸出到同目錄下的xx.log文件中。
func main() {
logFile, err := os.OpenFile("./xx.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
if err != nil {
fmt.Println("open log file failed, err:", err)
return
}
log.SetOutput(logFile)
log.SetFlags(log.Llongfile | log.Lmicroseconds | log.Ldate)
log.Println("這是一條很普通的日志。")
log.SetPrefix("[PS]")
log.Println("這是一條很普通的日志。")
}如果你要使用標(biāo)準(zhǔn)的logger，我們通常會把上面的配置操作寫到init函數(shù)中。
func init() {
logFile, err := os.OpenFile("./xx.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
if err != nil {
fmt.Println("open log file failed, err:", err)
return
}
log.SetOutput(logFile)
log.SetFlags(log.Llongfile | log.Lmicroseconds | log.Ldate)
}創(chuàng)建新的Logger
log標(biāo)準(zhǔn)庫中還提供了一個創(chuàng)建新logger對象的構(gòu)造函數(shù) New，支持我們創(chuàng)建自己的logger示例。New函數(shù)的簽名如下：
func New(out io.Writer, prefix string, flag int) *Logger
New創(chuàng)建一個Logger對象。其中，參數(shù)out設(shè)置日志信息寫入的目的地。參數(shù)prefix會添加到生成的每一條日志前面。參數(shù)flag定義日志的屬性（時間、文件等等）。
舉個例子：
func main() {
logger := log.New(os.Stdout, "<PS>", log.Lshortfile|log.Ldate|log.Ltime)
logger.Println("這是自定義的logger記錄的日志。")
}編譯輸出：
<PS>2020/07/14 23:02:59 test_log.go:43: 這是自定義的logger記錄的日志
自定義Go Logger
可以設(shè)置任何io.Writer作為日志記錄輸出并向其發(fā)送要寫入的日志
設(shè)置
func SetupLogger() {
logFileLocation, _ := os.OpenFile("./test.log", os.O_CREATE|os.O_APPEND|os.O_RDWR, 0744)
log.SetOutput(logFileLocation)
}使用
func test(){
log.Printf("Test log: %s %s", "Hello", "World")
}運行
func main() {
SetupLogger()
test()
}Zap
Zap是非?？斓?、結(jié)構(gòu)化的，分日志級別的Go日志庫。
安裝
go get -u go.uber.org/zap
配置Zap Logger
Zap提供了兩種類型的日志記錄器—Sugared Logger和Logger。
- Logger更快，但只支持強(qiáng)類型的結(jié)構(gòu)化日志記錄。
- Sugared Logger支持結(jié)構(gòu)化和printf風(fēng)格的日志記錄。
Logger
- 通過調(diào)用
zap.NewProduction()/zap.NewDevelopment()或者zap.Example()創(chuàng)建一個Logger。 Example和Production使用的是json格式輸出，Development使用行的形式輸出Development從警告級別(Warn)向上打印到堆棧中來跟蹤，ProductionError , Dpanic 級別的記錄，會在堆棧中跟蹤文件， Warn 不會- 通過Logger調(diào)用Info/Error等。
- 默認(rèn)情況下日志都會打印到應(yīng)用程序的console界面。
var logger *zap.Logger
func main() {
InitLogger()
defer logger.Sync()
simpleHttpGet("www.google.com")
simpleHttpGet("http://www.google.com")
}
func InitLogger() {
logger, _ = zap.NewProduction()
}
func simpleHttpGet(url string) {
resp, err := http.Get(url)
if err != nil {
logger.Error(
"Error fetching url..",
zap.String("url", url),
zap.Error(err))
} else {
logger.Info("Success..",
zap.String("statusCode", resp.Status),
zap.String("url", url))
resp.Body.Close()
}
}在上面的代碼中，我們首先創(chuàng)建了一個Logger，然后使用Info/ Error等Logger方法記錄消息。
日志記錄器方法的語法是這樣的：
func (log *Logger) MethodXXX(msg string, fields ...Field)
其中MethodXXX是一個可變參數(shù)函數(shù)，可以是Info / Error/ Debug / Panic等。每個方法都接受一個消息字符串和任意數(shù)量的zapcore.Field場參數(shù)。
每個zapcore.Field其實就是一組鍵值對參數(shù)。
我們執(zhí)行上面的代碼會得到如下輸出結(jié)果：
{"level":"error","ts":1572159218.912792,"caller":"zap_demo/temp.go:25","msg":"Error fetching url..","url":"www.sogo.com","error":"Get www.sogo.com: unsupported protocol scheme \"\"","stacktrace":"main.simpleHttpGet\n\t/Users/itxiaoma/zap_demo/temp.go:25\nmain.main\n\t/Users/itxiaoma/zap_demo/temp.go:14\nruntime.main\n\t/usr/local/go/src/runtime/proc.go:203"}
{"level":"info","ts":1572159219.1227388,"caller":"zap_demo/temp.go:30","msg":"Success..","statusCode":"200 OK","url":"http://www.sogo.com"}
Sugared Logger
slogger := logger.Sugar()
suger logger基于 printf 分割的反射類型檢測，提供更簡單的語法來添加混合類型的標(biāo)簽。
var sugarLogger *zap.SugaredLogger
func main() {
InitLogger()
defer sugarLogger.Sync()
simpleHttpGet("www.google.com")
simpleHttpGet("http://www.google.com")
}
func InitLogger() {
logger, _ := zap.NewProduction()
sugarLogger = logger.Sugar()
}
func simpleHttpGet(url string) {
sugarLogger.Debugf("Trying to hit GET request for %s", url)
resp, err := http.Get(url)
if err != nil {
sugarLogger.Errorf("Error fetching URL %s : Error = %s", url, err)
} else {
sugarLogger.Infof("Success! statusCode = %s for URL %s", resp.Status, url)
resp.Body.Close()
}
}執(zhí)行結(jié)果：
{"level":"error","ts":1572159149.923002,"caller":"logic/temp2.go:27","msg":"Error fetching URL www.sogo.com : Error = Get www.sogo.com: unsupported protocol scheme \"\"","stacktrace":"main.simpleHttpGet\n\t/Users/itxiaoma/zap_demo/logic/temp2.go:27\nmain.main\n\t/Users/itxiaoma/zap_demo/logic/temp2.go:14\nruntime.main\n\t/usr/local/go/src/runtime/proc.go:203"}
{"level":"info","ts":1572159150.192585,"caller":"logic/temp2.go:29","msg":"Success! statusCode = 200 OK for URL http://www.sogo.com"}
定制logger
1. 日志寫入文件
使用zap.New(…)方法來手動傳遞所有配置，而不是使用像zap.NewProduction()這樣的預(yù)置方法來創(chuàng)建logger。
func New(core zapcore.Core, options ...Option) *Logger
Encoder:編碼器(如何寫入日志)。我們將使用開箱即用的NewJSONEncoder()，并使用預(yù)先設(shè)置的ProductionEncoderConfig()。
zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())
WriterSyncer ：指定日志將寫到哪里去。我們使用zapcore.AddSync()函數(shù)并且將打開的文件句柄傳進(jìn)去。
file, _ := os.Create("./test.log")
writeSyncer := zapcore.AddSync(file)Log Level：哪種級別的日志將被寫入。
func InitLogger() {
writeSyncer := getLogWriter()
encoder := getEncoder()
core := zapcore.NewCore(encoder, writeSyncer, zapcore.DebugLevel)
logger := zap.New(core)
sugarLogger = logger.Sugar()
}
func getEncoder() zapcore.Encoder {
return zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())
}
func getLogWriter() zapcore.WriteSyncer {
file, _ := os.Create("./test.log")
return zapcore.AddSync(file)
}當(dāng)使用這些修改過的logger配置調(diào)用上述部分的main()函數(shù)時，以下輸出將打印在文件——test.log中。
{"level":"debug","ts":1572160754.994731,"msg":"Trying to hit GET request for www.sogo.com"}
{"level":"error","ts":1572160754.994982,"msg":"Error fetching URL www.sogo.com : Error = Get www.sogo.com: unsupported protocol scheme \"\""}
{"level":"debug","ts":1572160754.994996,"msg":"Trying to hit GET request for http://www.sogo.com"}
{"level":"info","ts":1572160757.3755069,"msg":"Success! statusCode = 200 OK for URL http://www.sogo.com"}
2.將JSON Encoder更改為普通的Log Encoder
將NewJSONEncoder()更改為NewConsoleEncoder()。
return zapcore.NewConsoleEncoder(zap.NewProductionEncoderConfig())
當(dāng)使用這些修改過的logger配置調(diào)用上述部分的main()函數(shù)時，以下輸出將打印在文件——test.log中。
1.572161051846623e+09 debug Trying to hit GET request for www.sogo.com
1.572161051846828e+09 error Error fetching URL www.sogo.com : Error = Get www.sogo.com: unsupported protocol scheme ""
1.5721610518468401e+09 debug Trying to hit GET request for http://www.sogo.com
1.572161052068744e+09 info Success! statusCode = 200 OK for URL http://www.sogo.com
3. 更改時間編碼并添加調(diào)用者詳細(xì)信息
修改時間編碼器：
func getEncoder() zapcore.Encoder {
encoderConfig := zap.NewProductionEncoderConfig()
encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
return zapcore.NewConsoleEncoder(encoderConfig)
}添加調(diào)用方信息：在zap.New(..)函數(shù)中添加一個Option。
logger := zap.New(core, zap.AddCaller())
最終結(jié)果：
2019-10-27T15:33:29.855+0800 DEBUG logic/temp2.go:47 Trying to hit GET request for www.sogo.com
2019-10-27T15:33:29.855+0800 ERROR logic/temp2.go:50 Error fetching URL www.sogo.com : Error = Get www.sogo.com: unsupported protocol scheme ""
2019-10-27T15:33:29.856+0800 DEBUG logic/temp2.go:47 Trying to hit GET request for http://www.sogo.com
2019-10-27T15:33:30.125+0800 INFO logic/temp2.go:52 Success! statusCode = 200 OK for URL http://www.sogo.com
Lumberjack 日志切割
安裝
go get -u github.com/natefinch/lumberjack
使用
func getLogWriter() zapcore.WriteSyncer {
lumberJackLogger := &lumberjack.Logger{
Filename: "./test.log",
MaxSize: 10,
MaxBackups: 5,
MaxAge: 30,
Compress: false,
}
return zapcore.AddSync(lumberJackLogger)
}Lumberjack Logger采用以下屬性作為輸入:
- Filename: 日志文件的位置
- MaxSize：在進(jìn)行切割之前，日志文件的最大大?。ㄒ訫B為單位）
- MaxBackups：保留舊文件的最大個數(shù)
- MaxAges：保留舊文件的最大天數(shù)
- Compress：是否壓縮/歸檔舊文件
Zap接收Gin默認(rèn)日志
我們在使用gin.Default()的同時是用到了gin框架內(nèi)的兩個默認(rèn)中間件Logger()和Recovery()。
Logger()是把gin框架本身的日志輸出到標(biāo)準(zhǔn)輸出（我們本地開發(fā)調(diào)試時在終端輸出的那些日志就是它的功勞）Recovery()是在程序出現(xiàn)panic的時候恢復(fù)現(xiàn)場并寫入500響應(yīng)的。
基于zap的中間件
替換gin.Default()
r := gin.New() r.Use(GinLogger(), GinRecovery())
中間件：
// GinLogger 接收gin框架默認(rèn)的日志
func GinLogger(logger *zap.Logger) gin.HandlerFunc {
return func(c *gin.Context) {
start := time.Now()
path := c.Request.URL.Path
query := c.Request.URL.RawQuery
c.Next()
cost := time.Since(start)
logger.Info(path,
zap.Int("status", c.Writer.Status()),
zap.String("method", c.Request.Method),
zap.String("path", path),
zap.String("query", query),
zap.String("ip", c.ClientIP()),
zap.String("user-agent", c.Request.UserAgent()),
zap.String("errors", c.Errors.ByType(gin.ErrorTypePrivate).String()),
zap.Duration("cost", cost),
)
}
}
// GinRecovery recover掉項目可能出現(xiàn)的panic
func GinRecovery(logger *zap.Logger, stack bool) gin.HandlerFunc {
return func(c *gin.Context) {
defer func() {
if err := recover(); err != nil {
// Check for a broken connection, as it is not really a
// condition that warrants a panic stack trace.
var brokenPipe bool
if ne, ok := err.(*net.OpError); ok {
if se, ok := ne.Err.(*os.SyscallError); ok {
if strings.Contains(strings.ToLower(se.Error()), "broken pipe") || strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") {
brokenPipe = true
}
}
}
httpRequest, _ := httputil.DumpRequest(c.Request, false)
if brokenPipe {
logger.Error(c.Request.URL.Path,
zap.Any("error", err),
zap.String("request", string(httpRequest)),
)
// If the connection is dead, we can't write a status to it.
c.Error(err.(error)) // nolint: errcheck
c.Abort()
return
}
if stack {
logger.Error("[Recovery from panic]",
zap.Any("error", err),
zap.String("request", string(httpRequest)),
zap.String("stack", string(debug.Stack())),
)
} else {
logger.Error("[Recovery from panic]",
zap.Any("error", err),
zap.String("request", string(httpRequest)),
)
}
c.AbortWithStatus(http.StatusInternalServerError)
}
}()
c.Next()
}
}如果不想自己實現(xiàn)，可以使用github上有別人封裝好的https://github.com/gin-contrib/zap。
這樣我們就可以在gin框架中使用我們上面定義好的兩個中間件來代替gin框架默認(rèn)的Logger()和Recovery()了。
在gin項目中使用zap
最后我們再加入我們項目中常用的日志切割，完整版的logger.go代碼如下：
package logger
import (
"gin_zap_demo/config"
"net"
"net/http"
"net/http/httputil"
"os"
"runtime/debug"
"strings"
"time"
"github.com/gin-gonic/gin"
"github.com/natefinch/lumberjack"
"go.uber.org/zap"
"go.uber.org/zap/zapcore"
)
var lg *zap.Logger
// InitLogger 初始化Logger
func InitLogger(cfg *config.LogConfig) (err error) {
writeSyncer := getLogWriter(cfg.Filename, cfg.MaxSize, cfg.MaxBackups, cfg.MaxAge)
encoder := getEncoder()
var l = new(zapcore.Level)
err = l.UnmarshalText([]byte(cfg.Level))
if err != nil {
return
}
core := zapcore.NewCore(encoder, writeSyncer, l)
lg = zap.New(core, zap.AddCaller())
zap.ReplaceGlobals(lg) // 替換zap包中全局的logger實例，后續(xù)在其他包中只需使用zap.L()調(diào)用即可
return
}
func getEncoder() zapcore.Encoder {
encoderConfig := zap.NewProductionEncoderConfig()
encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
encoderConfig.TimeKey = "time"
encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
encoderConfig.EncodeDuration = zapcore.SecondsDurationEncoder
encoderConfig.EncodeCaller = zapcore.ShortCallerEncoder
return zapcore.NewJSONEncoder(encoderConfig)
}
func getLogWriter(filename string, maxSize, maxBackup, maxAge int) zapcore.WriteSyncer {
lumberJackLogger := &lumberjack.Logger{
Filename: filename,
MaxSize: maxSize,
MaxBackups: maxBackup,
MaxAge: maxAge,
}
return zapcore.AddSync(lumberJackLogger)
}
// GinLogger 接收gin框架默認(rèn)的日志
func GinLogger() gin.HandlerFunc {
return func(c *gin.Context) {
start := time.Now()
path := c.Request.URL.Path
query := c.Request.URL.RawQuery
c.Next()
cost := time.Since(start)
lg.Info(path,
zap.Int("status", c.Writer.Status()),
zap.String("method", c.Request.Method),
zap.String("path", path),
zap.String("query", query),
zap.String("ip", c.ClientIP()),
zap.String("user-agent", c.Request.UserAgent()),
zap.String("errors", c.Errors.ByType(gin.ErrorTypePrivate).String()),
zap.Duration("cost", cost),
)
}
}
// GinRecovery recover掉項目可能出現(xiàn)的panic，并使用zap記錄相關(guān)日志
func GinRecovery(stack bool) gin.HandlerFunc {
return func(c *gin.Context) {
defer func() {
if err := recover(); err != nil {
// Check for a broken connection, as it is not really a
// condition that warrants a panic stack trace.
var brokenPipe bool
if ne, ok := err.(*net.OpError); ok {
if se, ok := ne.Err.(*os.SyscallError); ok {
if strings.Contains(strings.ToLower(se.Error()), "broken pipe") || strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") {
brokenPipe = true
}
}
}
httpRequest, _ := httputil.DumpRequest(c.Request, false)
if brokenPipe {
lg.Error(c.Request.URL.Path,
zap.Any("error", err),
zap.String("request", string(httpRequest)),
)
// If the connection is dead, we can't write a status to it.
c.Error(err.(error)) // nolint: errcheck
c.Abort()
return
}
if stack {
lg.Error("[Recovery from panic]",
zap.Any("error", err),
zap.String("request", string(httpRequest)),
zap.String("stack", string(debug.Stack())),
)
} else {
lg.Error("[Recovery from panic]",
zap.Any("error", err),
zap.String("request", string(httpRequest)),
)
}
c.AbortWithStatus(http.StatusInternalServerError)
}
}()
c.Next()
}
}然后定義日志相關(guān)配置：
type LogConfig struct {
Level string `json:"level"`
Filename string `json:"filename"`
MaxSize int `json:"maxsize"`
MaxAge int `json:"max_age"`
MaxBackups int `json:"max_backups"`
}在項目中先從配置文件加載配置信息，再調(diào)用logger.InitLogger(config.Conf.LogConfig)即可完成logger實例的初識化。其中，通過r.Use(logger.GinLogger(), logger.GinRecovery(true))注冊我們的中間件來使用zap接收gin框架自身的日志，在項目中需要的地方通過使用zap.L().Xxx()方法來記錄自定義日志信息。
package main
import (
"fmt"
"gin_zap_demo/config"
"gin_zap_demo/logger"
"net/http"
"os"
"go.uber.org/zap"
"github.com/gin-gonic/gin"
)
func main() {
// load config from config.json
if len(os.Args) < 1 {
return
}
if err := config.Init(os.Args[1]); err != nil {
panic(err)
}
// init logger
if err := logger.InitLogger(config.Conf.LogConfig); err != nil {
fmt.Printf("init logger failed, err:%v\n", err)
return
}
gin.SetMode(config.Conf.Mode)
r := gin.Default()
// 注冊zap相關(guān)中間件
r.Use(logger.GinLogger(), logger.GinRecovery(true))
r.GET("/hello", func(c *gin.Context) {
// 假設(shè)你有一些數(shù)據(jù)需要記錄到日志中
var (
name = "itxiaoma"
age = 18
)
// 記錄日志并使用zap.Xxx(key, val)記錄相關(guān)字段
zap.L().Debug("this is hello func", zap.String("user", name), zap.Int("age", age))
c.String(http.StatusOK, "hello itxiaoma!")
})
addr := fmt.Sprintf(":%v", config.Conf.Port)
r.Run(addr)
}到此這篇關(guān)于Go學(xué)習(xí)筆記之Zap日志的使用的文章就介紹到這了,更多相關(guān)Go Zap日志內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
這篇文章要介紹的是Go語言并發(fā)編程 sync.Once，sync.Once用于保證某個動作只被執(zhí)行一次，可用于單例模式中，下面文章我們來介紹一下它的使用方法,需要的朋友可以參考一下2021-10-10
這篇文章主要介紹了Golang中的path/filepath包用法，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-12-12
go module是go官方自帶的go依賴管理庫,在1.13版本正式推薦使用,這篇文章主要介紹了Go Module常用命令及如何使用Go Module,需要的朋友可以參考下2024-02-02
這篇文章主要介紹了gin安裝及初始化，修改啟動端口，get/post?請求參數(shù)，模型綁定shouldbind,自定義驗證器/表單驗證，等操作步驟，有需要的朋友可以借鑒參考下2022-04-04
這篇文章主要為大家整理了Go語言中的time庫，包括時間、日期和時區(qū)等相關(guān)概念及使用方法，希望通過掌握這些知識，大家可以更好地處理時間、日期和時區(qū)相關(guān)的問題2023-08-08
這篇文章主要介紹了Go語言庫系列之flag的具體使用,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-04-04
這篇文章主要介紹了golang如何使用sarama訪問kafka，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2018-12-12
這篇文章主要介紹了Go語言線程安全之互斥鎖與讀寫鎖,互斥鎖是為了并發(fā)的安全,在多個goroutine共同工作的時候,對于共享的數(shù)據(jù)十分不安全,而讀寫鎖效率革命，使用鎖的時候，安全與效率往往需要互相轉(zhuǎn)換，下文詳細(xì)內(nèi)容，需要的小伙伴可以參考一下2022-02-02
這篇文章主要介紹了Golang 高并發(fā)問題的解決方案，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2021-05-05
基于時間的一次性密碼 TOTP 是 OTP 的一種實現(xiàn)方式,這種方法的優(yōu)點是不依賴網(wǎng)絡(luò),因此即使在沒有網(wǎng)絡(luò)的情況下,用戶也可以生成密碼,下面我們就來看看如何使用golang實現(xiàn)一次性密碼TOTP吧2023-11-11