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

本文涉及的产品
日志服务 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的矿方说明中,给出了两种类型的日志记录器——LoggerSugared 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)

而这里我们所要配置的就是corezapcore.Core需要三个配置:

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

接下来我们尝试将日志打印在test.log中,并且用Jsontext两种格式来打印到文件中:

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
}
相关实践学习
通过日志服务实现云资源OSS的安全审计
本实验介绍如何通过日志服务实现云资源OSS的安全审计。
相关文章
|
6月前
|
JavaScript 前端开发 Java
通义灵码 Rules 库合集来了,覆盖Java、TypeScript、Python、Go、JavaScript 等
通义灵码新上的外挂 Project Rules 获得了开发者的一致好评:最小成本适配我的开发风格、相当把团队经验沉淀下来,是个很好功能……
1170 103
|
3月前
|
监控 Java 编译器
限流、控并发、减GC!一文搞懂Go项目资源优化的正确姿势
本章介绍Go语言项目在构建与部署阶段的性能调优和资源控制策略,涵盖编译优化、程序性能提升、并发与系统资源管理、容器化部署及自动化测试等内容,助力开发者打造高效稳定的生产级应用。
|
3月前
|
测试技术 Go 开发工具
Go语言项目工程化 — 常见开发工具与 CI/CD 支持
Go语言项目工程化实践中的开发工具与CI/CD支持,涵盖格式化、静态检查、依赖管理、构建打包、自动化测试及部署策略。内容包括常用工具如gofmt、go vet、golangci-lint、Docker、GitHub Actions等,并提供实战建议与总结,提升团队协作效率与项目质量。
|
3月前
|
NoSQL 中间件 Go
Go语言项目工程化 — 项目结构与模块划分
本章讲解Go语言项目工程化中的结构设计与模块划分,涵盖单体及分层架构方案,指导如何按功能组织代码,提升项目的可维护性、扩展性,适用于不同规模的开发场景。
|
3月前
|
JSON 安全 Go
Go语言项目工程化 —— 日志、配置、错误处理规范
本章详解Go语言项目工程化核心规范,涵盖日志、配置与错误处理三大关键领域。在日志方面,强调其在问题排查、性能优化和安全审计中的作用,推荐使用高性能结构化日志库zap,并介绍日志级别与结构化输出的最佳实践。配置管理部分讨论了配置分离的必要性,对比多种配置格式如JSON、YAML及环境变量,并提供viper库实现多环境配置的示例。错误处理部分阐述Go语言显式返回error的设计哲学,讲解标准处理方式、自定义错误类型、错误封装与堆栈追踪技巧,并提出按调用层级进行错误处理的建议。最后,总结各模块的工程化最佳实践,助力构建可维护、可观测且健壮的Go应用。
|
5月前
|
Java 关系型数据库 MySQL
在Linux平台上进行JDK、Tomcat、MySQL的安装并部署后端项目
现在,你可以通过访问http://Your_IP:Tomcat_Port/Your_Project访问你的项目了。如果一切顺利,你将看到那绚烂的胜利之光照耀在你的项目之上!
305 41
|
7月前
|
JSON 自然语言处理 前端开发
【01】对APP进行语言包功能开发-APP自动识别地区ip后分配对应的语言功能复杂吗?-成熟app项目语言包功能定制开发-前端以uniapp-基于vue.js后端以laravel基于php为例项目实战-优雅草卓伊凡
【01】对APP进行语言包功能开发-APP自动识别地区ip后分配对应的语言功能复杂吗?-成熟app项目语言包功能定制开发-前端以uniapp-基于vue.js后端以laravel基于php为例项目实战-优雅草卓伊凡
318 72
【01】对APP进行语言包功能开发-APP自动识别地区ip后分配对应的语言功能复杂吗?-成熟app项目语言包功能定制开发-前端以uniapp-基于vue.js后端以laravel基于php为例项目实战-优雅草卓伊凡
|
6月前
|
人工智能 小程序 NoSQL
【一步步开发AI运动小程序】二十一、如何将AI运动项目配置持久化到后端?
本文介绍基于云智「Ai运动识别引擎」的运动配置持久化方案,旨在优化小程序或Uni APP中AI运动识别能力。通过将运动检测参数(如`Key`、`Name`、`TickMode`、`rules`或`samples`)持久化到后端,可避免因频繁调整运动参数而重新发布应用,提升用户体验。持久化数据结构支持规则和姿态样本存储,适用于关系数据库、文件或文档数据库(如MongoDB)。此外,云智还提供运动自动适配工具及「AI乐运动」产品,助力快速实现AI体育、全民健身等场景。
|
7月前
|
Go 开发者
go-carbon v2.6.0 重大版本更新,轻量级、语义化、对开发者友好的 golang 时间处理库
carbon 是一个轻量级、语义化、对开发者友好的 Golang 时间处理库,提供了对时间穿越、时间差值、时间极值、时间判断、星座、星座、农历、儒略日 / 简化儒略日、波斯历 / 伊朗历的支持
123 3
|
8月前
|
网络协议 Linux Go
用 Go 基于 epoll 实现一个最小化的IO库
Go 语言社区中存在多个异步网络框架,如 evio、nbio、gnet 和 netpoll 等。这些框架旨在解决标准库 netpoll 的低效问题,如一个连接占用一个 goroutine 导致的资源浪费。easyio 是一个最小化的 IO 框架,核心代码不超过 500 行,仅实现 Linux 下的 epoll 和 TCP 协议。它通过 Worker Pool、Buffer 等优化提高了性能,并提供了简单的事件处理机制。
101 0

热门文章

最新文章