AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

go语言后端开发学习(四) —— 在go项目中使用Zap日志库

2024-08-11 145
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 SLS，月写入数据量 50GB 1个月
简介： 本文详细介绍了如何在Go项目中集成并配置Zap日志库。首先通过`go get -u go.uber.org/zap`命令安装Zap，接着展示了`Logger`与`Sugared Logger`两种日志记录器的基本用法。随后深入探讨了Zap的高级配置，包括如何将日志输出至文件、调整时间格式、记录调用者信息以及日志分割等。最后，文章演示了如何在gin框架中集成Zap，通过自定义中间件实现了日志记录和异常恢复功能。通过这些步骤，读者可以掌握Zap在实际项目中的应用与定制方法

一.前言

在之前的文章中我们已经介绍过如何使用logrus包来作为我们在gin框架中使用的日志中间件，而今天我们要介绍的就是我们如何在go项目中如何集成Zap来作为日志中间件

二.Zap的安装与快速使用

和安装其他第三方包没什么区别，我们下载Zap包只需要执行以下命令

go get -u go.uber.org/zap

在Zap的矿方说明中,给出了两种类型的日志记录器——Logger与Sugared Logger,在不同场景下我们可以选择使用不同的日志记录器：

Logger：性能比较好，但是仅支持强类型输出的日志，适合在每一微秒和每一次内存分配都很重要的上下文中,使用Logger
Sugared Logger：它支持结构化和printf风格的日志记录。适合在性能很好但不是很关键的上下文中，使用SugaredLogger

接下来我将用两个简单的demo来展示一下我们如何使用这两种日志记录器：

//Logger
package main

import (
    "go.uber.org/zap"
    "net/http"
)

var logger *zap.Logger

func main() {
   
   
    InitLogger()
    defer logger.Sync() //等到全部日志写入，将缓冲区中的日志写入磁盘
    SimpleHttpGet("www.baidu.com") //这行代码会报错，仅做展示错误日志信息的打印
    SimpleHttpGet("https://www.kugou.com")
}

func InitLogger() {
   
   
    logger, _ = zap.NewProduction()
}

func SimpleHttpGet(url string) {
   
   
    re, err := http.Get(url)
    if err != nil {
   
   
        logger.Error("Error fetching url", zap.String("url", url), zap.Error(err))
    } else {
   
   
        logger.Info("Success fetching url", zap.String("statusCode", re.Status), zap.String("url", url))
    }
    re.Body.Close()
}

//SugarLogger
package main

import (
    "go.uber.org/zap"
    "net/http"
)

var sugarlogger *zap.SugaredLogger

func main() {
   
   
    InitLogger()
    defer sugarlogger.Sync() //等到全部日志写入，将缓冲区中的日志写入磁盘
    SimpleHttpGet("www.baidu.com")
    SimpleHttpGet("https://www.kugou.com")
}

func InitLogger() {
   
   
    logger, _ := zap.NewProduction() 
    sugarlogger = logger.Sugar()
}

func SimpleHttpGet(url string) {
   
   
    re, err := http.Get(url)
    if err != nil {
   
   
        sugarlogger.Error("Error fetching url", zap.String("url", url), zap.Error(err))
    } else {
   
   
        sugarlogger.Info("Success fetching url", zap.String("statusCode", re.Status), zap.String("url", url))
    }
    re.Body.Close()
}

三.Zap的配置

Zap的使用其实是比较简单的，但是如何去配置出一个适合我们自己项目的日志中间件其实也是比较困难，下面博主将一步步的实现的一个简单的日志中间件示例，下面开始吧!

1.让日志输入到文件中

在我们日常开发模式时,我们一般会将日志的错误信息打印在控制台上,这样可以方便我们去调试错误，但是在生产模式下,让错误信息打印在控制台上无疑是不大可能得了，我们一般会选择将日志信息录入到文件中，接下来让我们来尝试一下修改日志信息的输入路径。

为了修改日志信息的输出路径,我们这里就不会在通过NewProduction来自动创建logger对象了，而是我们自己通过New这一函数来手动传递配置了,在开始之前我们来看一下New这一函数：

func New(core zapcore.Core, options ...Option)

而这里我们所要配置的就是core，zapcore.Core需要三个配置：

  • Encoder:它决定了我们以何种形式写入日志，比如我们可以使用Json格式来作为我们书写日志的格式
  • WriteSyncer:它决定了我们要将日志写到什么地方去
  • LogLevel:它决定了哪些级别的日志会被写入到日志文件中去

接下来我们尝试将日志打印在test.log中，并且用Json和text两种格式来打印到文件中：

package main

import (
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
    "net/http"
    "os"
)

var sugarlogger *zap.SugaredLogger

func main() {
   
   
    InitLogger()
    defer sugarlogger.Sync() //等到全部日志写入，将缓冲区中的日志写入磁盘
    SimpleHttpGet("www.baidu.com")
    SimpleHttpGet("https://www.kugou.com")
}

func InitLogger() {
   
   
    encoder := InitEncoder()
    level := InitLevel()
    writer := InitWriter()
    core := zapcore.NewCore(encoder, writer, level)
    sugarlogger = zap.New(core).Sugar()
}

func InitEncoder() zapcore.Encoder {
   
   
    return zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())
}

func InitWriter() zapcore.WriteSyncer {
   
   
    file, _ := os.Create("G:\\bluebell\\src\\demo\\log\\test.log")
    return zapcore.AddSync(file)
}

func InitLevel() zapcore.Level {
   
   
    return zapcore.ErrorLevel
}
func SimpleHttpGet(url string) {
   
   
    re, err := http.Get(url)
    if err != nil {
   
   
        sugarlogger.Error("Error fetching url", zap.String("url", url), zap.Error(err))
    } else {
   
   
        sugarlogger.Info("Success fetching url", zap.String("statusCode", re.Status), zap.String("url", url))
    }
    re.Body.Close()
}

运行结果如下：
在这里插入图片描述
我们可以看到文件已经输入到json.log中了。

当然我们也可以使用正常的text格式

package main

import (
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
    "net/http"
    "os"
)

var sugarlogger *zap.SugaredLogger

func main() {
   
   
    InitLogger()
    defer sugarlogger.Sync() //等到全部日志写入，将缓冲区中的日志写入磁盘
    SimpleHttpGet("www.baidu.com")
    SimpleHttpGet("https://www.kugou.com")
}

func InitLogger() {
   
   
    encoder := InitEncoder()
    level := InitLevel()
    writer := InitWriter()
    core := zapcore.NewCore(encoder, writer, level)
    sugarlogger = zap.New(core).Sugar()
}

func InitEncoder() zapcore.Encoder {
   
   
    return zapcore.NewConsoleEncoder(zap.NewProductionEncoderConfig())
}

func InitWriter() zapcore.WriteSyncer {
   
   
    file, _ := os.Create("G:\\bluebell\\src\\demo\\log\\text.log")
    return zapcore.AddSync(file)
}

func InitLevel() zapcore.Level {
   
   
    return zapcore.ErrorLevel
}
func SimpleHttpGet(url string) {
   
   
    re, err := http.Get(url)
    if err != nil {
   
   
        sugarlogger.Error("Error fetching url", zap.String("url", url), zap.Error(err))
    } else {
   
   
        sugarlogger.Info("Success fetching url", zap.String("statusCode", re.Status), zap.String("url", url))
    }
    re.Body.Close()
}

运行结果：
在这里插入图片描述

2.修改时间编码,将调用函数信息记录在日志中

在上面日志输出中我们可以看到两个比较大的问题：

  • 时间是以非人类可读的方式展示,像1.7233697314262748e+09这样
  • 日志没有调用方的信息我们很难确定错误的位置

所以我们现在要做的就是以下修改：

  • 修改时间编码器
  • 让日志文件中存在调用者信息

首先是修改时间编码器:

func InitEncoder() zapcore.Encoder {
   
   
    encoderConfig := zap.NewProductionEncoderConfig()
    encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
    encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder //在日志文件中使用大写字母记录日志级别
    return zapcore.NewConsoleEncoder(encoderConfig)
}

运行结果如下：

2024-08-11T18:14:02.328+0800    INFO    Success fetching url{statusCode 15 0 403 Forbidden <nil>} {url 15 0 https://www.kugou.com <nil>}

最后我们添加将调用函数信息记录到日志中的功能，这里我们需要修改一下代码：

func InitLogger() {
   
   
    encoder := InitEncoder()
    level := InitLevel()
    writer := InitWriter()
    core := zapcore.NewCore(encoder, writer, level)
    sugarlogger = zap.New(core,zap.AddCaller()).Sugar()
}

这样我们就能看到调用信息了：

 2024-08-11T19:00:52.831+0800    INFO    main/main.go:47    Success fetching url{statusCode 15 0 403 Forbidden <nil>} {url 15 0 https://www.kugou.com <nil>}

拓展：AddCallerSkip
在日志记录过程中，我们通常希望在日志消息中包含准确的调用信息（即，记录日志的代码行）。例如，如果你在 main.go 文件的第 10 行调用了 logger.Info("Message")，你希望日志记录显示调用发生在 main.go:10。
但是，如果你将日志记录封装到另一个函数中，例如：

func logInfo(msg string) {
   
   
    logger.Info(msg)
}

这样返回的值就不是准确的日志记录问题了，因为日志记录的调用栈就会增加一层，因为实际上 logger.Info 是由logInfo 函数调用的。如果不调整调用栈深度，日志中可能会显示 logInfo 函数的调用位置，而不是实际的日志记录位置。

而AddCallerSkip 函数用于调整日志记录库中记录调用信息的调用栈深度。它可以让你指定跳过多少层调用栈，从而准确获取实际的日志记录位置。

所以我们最后的InitLogger函数是这样的：

func InitLogger() {
   
   
    encoder := InitEncoder()
    level := InitLevel()
    writer := InitWriter()
    core := zapcore.NewCore(encoder, writer, level)
    sugarlogger = zap.New(core, zap.AddCaller(),zap.AddCallerSkip(1)).Sugar()
}

3.如何将日志输出到多个位置或将特定级别日志输入到单独文件

  • 将日志输出到多个位置
    func InitWriter() zapcore.WriteSyncer {
     
     
  file, _ := os.Create("G:\\bluebell\\src\\demo\\log\\text.log")
  os := io.MultiWriter(os.Stdout, file)  //既输入到控制台也输入到日志文件中
  return zapcore.AddSync(os)
}
  • 将特定级别日志输入到单独文件(以error为例)
    func InitLogger() {
     
     
  encoder := InitEncoder()
  level := InitLevel()
  writer := InitWriter()
  c1 := zapcore.NewCore(encoder, writer, level) //记录全部日志
  errF, _ := os.Create("G:\\bluebell\\src\\demo\\log\\err.log")
  c2 := zapcore.NewCore(encoder, zapcore.AddSync(errF), zap.ErrorLevel) //记录错误日志
  core := zapcore.NewTee(c1, c2)                                        // tee将日志输出到多个目的地
  sugarlogger = zap.New(core, zap.AddCaller(), zap.AddCallerSkip(1)).Sugar()
}

以上完整代码如下：

package main

import (
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
    "io"
    "net/http"
    "os"
)

var sugarlogger *zap.SugaredLogger

func main() {
   
   
    InitLogger()
    defer sugarlogger.Sync() //等到全部日志写入，将缓冲区中的日志写入磁盘
    SimpleHttpGet("https://www.kugou.com")
    SimpleHttpGet("www.baidu.com")
}

func InitLogger() {
   
   
    encoder := InitEncoder()
    level := InitLevel()
    writer := InitWriter()
    c1 := zapcore.NewCore(encoder, writer, level) //记录全部日志
    errF, _ := os.Create("G:\\bluebell\\src\\demo\\log\\err.log")
    c2 := zapcore.NewCore(encoder, zapcore.AddSync(errF), zap.ErrorLevel) //记录错误日志
    core := zapcore.NewTee(c1, c2)                                        // tee将日志输出到多个目的地
    sugarlogger = zap.New(core, zap.AddCaller(), zap.AddCallerSkip(1)).Sugar()
}

func InitEncoder() zapcore.Encoder {
   
   
    encoderConfig := zap.NewProductionEncoderConfig()
    encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
    encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder //在日志文件中使用大写字母记录日志级别
    return zapcore.NewConsoleEncoder(encoderConfig)
}

func InitWriter() zapcore.WriteSyncer {
   
   
    file, _ := os.Create("G:\\bluebell\\src\\demo\\log\\text.log")
    os := io.MultiWriter(os.Stdout, file)
    return zapcore.AddSync(os)
}

func InitLevel() zapcore.Level {
   
   
    return zapcore.DebugLevel
}
func SimpleHttpGet(url string) {
   
   
    re, err := http.Get(url)
    if err != nil {
   
   
        sugarlogger.Error("Error fetching url", zap.String("url", url), zap.Error(err))
    } else {
   
   
        sugarlogger.Info("Success fetching url", zap.String("statusCode", re.Status), zap.String("url", url))
    }
    re.Body.Close()
}

四.Zap实现日志分割

日志切割可以使用Lumberjack这一第三方包，可以按照下面这个命令下载：

go get gopkg.in/natefinch/lumberjack.v2

最后我们来开一下怎么加入支持：

func InitWriter() zapcore.WriteSyncer {
   
   
    lumberjackLogger := &lumberjack.Logger{
   
   
        Filename:   "G:\\bluebell\\src\\demo\\log\\app.log", //日志文件路径
        MaxSize:    1,                                       //每个日志文件保存的最大尺寸 单位：MB
        MaxBackups: 5,                                       //最多保存多少个日志文件
        MaxAge:     30,                                      //日志文件最多保存多少天
        Compress:   false,                                   //是否压缩
    }
    return zapcore.AddSync(lumberjackLogger)
}

这样就实现了一个简单的日志分割了。

五.在gin框架中集成Zap日志库

在很早之前博主就写过gin.Default会调用Logger(), Recovery()这两个中间件，，所我们想在gin框架中集成Zap日志库只需要重写一下这两个中间件就可以了：

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)
        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掉项目可能出现的panic
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 {
   
   
                    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: err check
                    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()
    }
}

最后得到的就是我们的最终log文件代码：

package main

import (
    "github.com/gin-gonic/gin"
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
    "gopkg.in/natefinch/lumberjack.v2"
    "net"
    "net/http"
    "net/http/httputil"
    "os"
    "runtime/debug"
    "strings"
    "time"
)

var logger *zap.Logger

func main() {
   
   
    r := gin.New()
    r.Use(GinLogger(), GinRecovery(true))
}

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)
        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掉项目可能出现的panic
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 {
   
   
                    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: err check
                    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()
    }
}

func InitLogger() {
   
   
    encoder := InitEncoder()
    level := InitLevel()
    writer := InitWriter()
    c1 := zapcore.NewCore(encoder, writer, level) //记录全部日志
    errF, _ := os.Create("G:\\bluebell\\src\\demo\\log\\err.log")
    c2 := zapcore.NewCore(encoder, zapcore.AddSync(errF), zap.ErrorLevel) //记录错误日志
    core := zapcore.NewTee(c1, c2)                                        // tee将日志输出到多个目的地
    logger = zap.New(core, zap.AddCaller(), zap.AddCallerSkip(1))
}

func InitEncoder() zapcore.Encoder {
   
   
    encoderConfig := zap.NewProductionEncoderConfig()
    encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
    encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder //在日志文件中使用大写字母记录日志级别
    return zapcore.NewConsoleEncoder(encoderConfig)
}

func InitWriter() zapcore.WriteSyncer {
   
   
    lumberjackLogger := &lumberjack.Logger{
   
   
        Filename:   "G:\\bluebell\\src\\demo\\log\\app.log", //日志文件路径
        MaxSize:    1,                                       //每个日志文件保存的最大尺寸 单位：MB
        MaxBackups: 5,                                       //最多保存多少个日志文件
        MaxAge:     30,                                      //日志文件最多保存多少天
        Compress:   false,                                   //是否压缩
    }
    return zapcore.AddSync(lumberjackLogger)
}

func InitLevel() zapcore.Level {
   
   
    return zapcore.DebugLevel
}
文章标签：
日志服务
Go
中间件
数据格式
JSON
关键词：
Go语言开发
Go语言
后端开发
Go学习
语言日志服务
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
落雨便归尘
目录
相关文章
1603458909890196
|
4月前
|
缓存 弹性计算 API
用 Go 快速开发一个 RESTful API 服务
用 Go 快速开发一个 RESTful API 服务
1603458909890196
43 0
vohelon
|
28天前
|
Go 数据安全/隐私保护 开发者
Go语言开发
【10月更文挑战第26天】Go语言开发
vohelon
37 3
vohelon
|
29天前
|
Java 程序员 Go
Go语言的开发
【10月更文挑战第25天】Go语言的开发
vohelon
29 3
刘大猫.
|
28天前
|
JSON Java 数据库
SpringBoot项目使用AOP及自定义注解保存操作日志
SpringBoot项目使用AOP及自定义注解保存操作日志
刘大猫.
38 1
353iqifkhsbmw
|
2月前
|
Go
使用go语言将A助手加入项目中
使用go语言将A助手加入项目中
353iqifkhsbmw
24 2
1100237741946300
|
2月前
|
SQL 关系型数据库 MySQL
Go语言项目高效对接SQL数据库：实践技巧与方法
在Go语言项目中，与SQL数据库进行对接是一项基础且重要的任务
1100237741946300
78 11
java冯坚持
|
2月前
|
Arthas 监控 Java
JVM知识体系学习七：了解JVM常用命令行参数、GC日志详解、调优三大方面（JVM规划和预调优、优化JVM环境、JVM运行出现的各种问题）、Arthas
这篇文章全面介绍了JVM的命令行参数、GC日志分析以及性能调优的各个方面，包括监控工具使用和实际案例分析。
java冯坚持
51 3
武子康
|
2月前
|
存储 Prometheus NoSQL
大数据-44 Redis 慢查询日志 监视器 慢查询测试学习
大数据-44 Redis 慢查询日志 监视器 慢查询测试学习
武子康
26 3
dream_ready
|
2月前
|
数据采集 监控 Java
SpringBoot日志全方位超详细手把手教程，零基础可学习 日志如何配置及SLF4J的使用......
本文是关于SpringBoot日志的详细教程，涵盖日志的定义、用途、SLF4J框架的使用、日志级别、持久化、文件分割及格式配置等内容。
dream_ready
164 0
SpringBoot日志全方位超详细手把手教程，零基础可学习 日志如何配置及SLF4J的使用......
阿里云开发者
|
3月前
|
Kubernetes API Docker
跟着iLogtail学习容器运行时与K8s下日志采集方案
iLogtail 作为开源可观测数据采集器，对 Kubernetes 环境下日志采集有着非常好的支持，本文跟随 iLogtail 的脚步，了解容器运行时与 K8s 下日志数据采集原理。
阿里云开发者
101 7

热门文章

最新文章

  • 1
    基于类型系统的面向对象编程语言Go
  • 2
    Go——小白学习之接口
  • 3
    Go语言之反射
  • 4
    Go语言之函数详解
  • 5
    GO 之MAP的使用
  • 6
    【chatgpt】openai api 接口调用（go语言版）
  • 7
    GO语言练习：组合的用法
  • 8
    GO的定时器Timer 和定时任务cron
  • 9
    Go语言实现表达式求值器的秘密都在这里！
  • 10
    【defer】1.12版本中的defer｜Go主题月
  • 1
    【后端面经】【缓存】33｜缓存模式：缓存模式能不能解决缓存一致性问题？-03 Refresh Ahead + SingleFlight + 删除缓存 + 延迟双删
    129
  • 2
    【Uniapp 专栏】Uniapp 与后端接口对接的实战要点
    649
  • 3
    【后端面经】【缓存】33｜缓存模式：缓存模式能不能解决缓存一致性问题？-02 Write Through + Write Back
    87
  • 4
    nbcio-boot基于jeecg的flowable支持部门经理的单个或多实例支持（后端部分）
    97
  • 5
    ruoyi-nbcio-plus后端里mapstruct-plus和lombok的使用
    108
  • 6
    ruoyi-nbcio-plus后端升级遇到的编译错误问题
    92
  • 7
    vue的 blob文件下载文件时，后端自定义异常，并返回json错误提示信息，前端捕获信息并展示给用户
    240
  • 8
    新的centos7.9安装docker版本的jenkins2.436.1最新版本-后端项目发布（四）
    127
  • 9
    构建高效微服务架构：后端开发的新范式
    35
  • 10
    构建高效的微服务架构：后端开发的新范式
    31

    • 相关课程

    更多
  • 大数据知识图谱系列—基于ELK+Flink日志全观测最佳实践
  • Go语言核心编程 - 数据结构和算法
  • Go语言核心编程 - 基础语法、数组、切片、Map
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程
  • 场景实践-基于阿里云Quick BI 对MOOC网站日志分析
  • Go语言完全自学手册图文教程

    • 相关电子书

    更多
  • gohbase ：HBase go客户端
  • 机器学习在互联网后端技术中的应用
  • Go构建日请求千亿级微服务实践

    • 相关实验场景

    更多
  • 使用CloudLens管理SLS日志采集
  • 使用CloudLens采集PolarDB日志并进行审计分析
  • 使用CloudLens采集RDS日志并进行审计分析
  • 使用日志服务SLS进行OSS可观测分析
  • 语言入门-1：环境构建
  • 前端开发基础6：Node.js和LESS预编译工具
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月