Gin框架学习笔记(六)——gin中的日志使用

本文涉及的产品
日志服务 SLS,月写入数据量 50GB 1个月
简介: Gin框架学习笔记(六)——gin中的日志使用

gin内置日志组件的使用

前言

在之前我们要使用Gin框架定义路由的时候我们一般会使用Default方法来实现,我们来看一下他的实现:

func Default(opts ...OptionFunc) *Engine {
  debugPrintWARNINGDefault()
  engine := New()
  engine.Use(Logger(), Recovery())
  return engine.With(opts...)
}

我们可以看到它注册了两个中间件Logger()Recovery(),而Logger就是我们今天的主角:gin框架自带的日志组件。

输出日志到文件中

package main
import (
  "fmt"
  "github.com/gin-gonic/gin"
  "io"
  "os"
)
func main() {
  file, err := os.Create("ginlog")
  if err != nil {
    fmt.Println("Create file error! err:", err)
  }
  gin.DefaultWriter = io.MultiWriter(file)
  r := gin.Default()
  r.GET("/", func(c *gin.Context) {
    c.JSON(200, gin.H{
      "message": "Hello World!",
    })
  })
  r.Run()
}

运行上面代码我们会发现,控制台不再会有相关日志的输出,而是打印到了ginlog文件中:

[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.
[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
 - using env: export GIN_MODE=release
 - using code:  gin.SetMode(gin.ReleaseMode)
[GIN-debug] GET    /                         --> main.main.func1 (3 handlers)
[GIN-debug] [WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.
Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.
[GIN-debug] Environment variable PORT is undefined. Using port :8080 by default
[GIN-debug] Listening and serving HTTP on :8080

当然我们也可以选择既在控制台输出也在文件内输出:

package main
import (
  "fmt"
  "github.com/gin-gonic/gin"
  "io"
  "os"
)
func main() {
  file, err := os.Create("ginlog")
  if err != nil {
    fmt.Println("Create file error! err:", err)
  }
  gin.DefaultWriter = io.MultiWriter(file, os.Stdout)
  r := gin.Default()
  r.GET("/", func(c *gin.Context) {
    c.JSON(200, gin.H{
      "message": "Hello World!",
    })
  })
  r.Run()
}

我们可以看到无论是日志文件ginlog和控制台,都实现了对日志的打印

定义日志中的路由格式

当我们运行Gin框架的时候,它会自动打印当前所有被定义的路由,比如下面这样的格式:

[GIN-debug] GET    /                         --> main.main.func1 (3 handlers)

而在Gin框架中它允许我们去自己定义路由的输出格式,我们可以自己去定义我们的路由格式:

func _Router_print_init() {
  gin.DebugPrintRouteFunc = func(httpMethod, absolutePath, handlerName string,
    nuHandlers int) {
    fmt.Printf("[三玖]: %v  %v   %v   %v  \n",
      httpMethod, absolutePath, handlerName, nuHandlers)
  }
}

输出的路由格式是这样的:

[三玖]: GET  /   main.main.func1   3

生产模式与开发模式

在我们程序其实是有两种模式的:

  • debug:开发模式
  • release:生产模式

如果我们希望控制台不在显示日志,可以将模式切换到release模式:

gin.SetMode(gin.ReleaseMode)
  r := gin.Default()

我们可以看到控制台已不再输出日志信息了。

第三方包logrus日志包的使用

logrus包的安装与基本使用

logrus包的安装

logrus的安装很简单,只需要终端输入以下命令即可:

go get github.com/sirupsen/logrus

logrus包的基本使用

logrus常用方法:
logrus.Debug("debug")
  logrus.Info("info")
  logrus.Warn("warn")
  logrus.Error("error")
  logrus.Println("println")

当我们运行该代码的时候会发现打印结果只有四行:

这主要是因为logrus默认的打印等级是info,在这个等级之下的不会打印,在我们生产环境下一般会要求不打印Warn以下的日志,我们可以对打印等级进行调整:

logrus.SetLevel(logrus.WarnLevel)

再次运行上面的代码,运行结果就会有所不同:

我们还可以查看当前的打印等级:

fmt.Println(logrus.GetLevel())

设置特定字段

如果我们希望某条日志记录的打印中添加某一条特定的字段,我们可以使用WithField方法:

log1 := logrus.WithField("key1", "value1")
log1.Info("hello world")

通常,在一个应用中、或者应用的一部分中,都有一些固定的Field。比如我们在处理用户http请求时,上下文中,所有的日志都会有request_id和user_ip为了避免每次记录日志都要使用log.WithFields(log.Fields{“request_id”: request_id, “user_ip”: user_ip}),我们可以创建一个logrus.Entry实例,为这个实例设置默认Fields,在上下文中使用这个logrus.Entry实例记录日志即可,这里我写了一个demo,仅做参考:

package main
import (
  "github.com/sirupsen/logrus"
)
type DefaultLogger struct {
  *logrus.Entry
  defaultFields logrus.Fields
}
func NewDefaultLogger() *DefaultLogger {
  logger := logrus.New()
  entry := logrus.NewEntry(logger)
  return &DefaultLogger{
    Entry:         entry,
    defaultFields: logrus.Fields{},
  }
}
func (l *DefaultLogger) WithFields(fields logrus.Fields) *logrus.Entry {
  allFields := make(logrus.Fields, len(fields))
  for k, v := range fields {
    allFields[k] = v
  }
  return l.Entry.WithFields(allFields)
}
func (l *DefaultLogger) WithDefaultField() {
  l.Entry = l.Entry.WithFields(l.defaultFields)
}
func (l *DefaultLogger) Info(msg string) {
  l.WithDefaultField()
  l.Entry.Info(msg)
}
func (l *DefaultLogger) AddDefaultField(key string, value interface{}) {
  l.defaultFields[key] = value
}
func main() {
  defaultLogger := NewDefaultLogger()
  defaultLogger.AddDefaultField("request_id", "123")
  defaultLogger.AddDefaultField("user_ip", "127.0.0.1")
  // 使用默认字段记录日志
  defaultLogger.Info("This is a log message with default fields")
  // 添加额外字段记录日志
  defaultLogger.WithFields(logrus.Fields{
    "additional_field": "abc",
  }).Info("This is a log message with additional field")
}

输出结果为:

设置显示样式

虽然日志的打印默认是txt格式的,但是我们也可以将格式修改为json格式的:

logrus.SetFormatter(&logrus.TextFormatter{})
• 1

将日志输入到文件

package main
import (
  "github.com/sirupsen/logrus"
  "os"
)
func main() {
  file, err := os.OpenFile("./logrus.log", os.O_CREATE|os.O_WRONLY, 0666)
  if err != nil {
    panic(err)
  }
  logrus.SetOutput(file)
  logrus.Error("error")
}

我们还可以让控制台和日志文件一起输出:

package main
import (
  "github.com/sirupsen/logrus"
  "golang.org/x/sys/windows"
  "io"
  "os"
)
func main() {
  file, err := os.OpenFile("./logrus.log", os.O_CREATE|os.O_WRONLY|windows.O_APPEND, 0666)
  if err != nil {
    panic(err)
  }
  writers := []io.Writer{
    file,
    os.Stdout,
  }
  lod := io.MultiWriter(writers...)
  logrus.SetOutput(lod)
  logrus.Error("error")
  logrus.Info("info")
}

显示行号

logrus.SetReportCaller(true)

logus的Hook机制

在使用logrus这一第三方包的时候,我们可以基于Hook机制来为logrus添加一些拓展功能。

首先我们先定义Hook结构体:

type Hook struct {
  Levels() []logrus.Level  // 返回日志级别
  Fire(entry *logrus.Entry) error  // 日志处理
}

我们Hook结构体中一般会有两个成员:

  • Levels:Hook机制起作用的日志级别
  • Fire:对应的日志处理方式

这里我们举一个例子,如果我们希望将所有Error级别的日志单独拎出来,我们可以基于Hook机制来实现:

package main
import (
  "fmt"
  "github.com/sirupsen/logrus"
  "os"
)
type Hook struct {
  Writer *os.File
}
func (MyHook *Hook) Fire(entry *logrus.Entry) error {
  line, err := entry.String()
  if err != nil {
    fmt.Fprintf(os.Stderr, "Failed to write to log, %v\n", err)
  }
  MyHook.Writer.Write([]byte(line))
  return nil
}
func (MyHook *Hook) Levels() []logrus.Level {
  return []logrus.Level{
    logrus.ErrorLevel,
  }
}
func main() {
  logrus.SetFormatter(&logrus.TextFormatter{ForceColors: true, TimestampFormat: "2006-01-02 15:04:05", FullTimestamp: true})
  logrus.SetReportCaller(true)
  file, _ := os.OpenFile("./error.log", os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0666)
  hook := &Hook{Writer: file}
  logrus.AddHook(hook)
  logrus.Error("error")
}

日志分割

按时间分割

  • Write写法
package main
import (
  "fmt"
  "github.com/sirupsen/logrus"
  "io"
  "os"
  "path/filepath"
  "strings"
  "time"
)
type LogFormatter struct{}
// Format 格式详情
func (s *LogFormatter) Format(entry *logrus.Entry) ([]byte, error) {
  timestamp := time.Now().Local().Format("2006-01-02 15:04:05")
  var file string
  var len int
  if entry.Caller != nil {
    file = filepath.Base(entry.Caller.File)
    len = entry.Caller.Line
  }
  //fmt.Println(entry.Data)
  msg := fmt.Sprintf("[%s] %s [%s:%d] %s\n", strings.ToUpper(entry.Level.String()), timestamp, file, len, entry.Message)
  return []byte(msg), nil
}
type LogWriter struct {
  Writer   *os.File
  logPath  string
  fileDate string //判断是否需要切换日志文件
  fileName string //日志文件名
}
func (writer *LogWriter) Write(p []byte) (n int, err error) {
  if writer == nil {
    logrus.Error("writer is nil")
    return 0, nil
  }
  if writer.Writer == nil {
    logrus.Error("writer.Writer is nil")
    return 0, nil
  }
  timer := time.Now().Format("2006-01-02 04:12")
  //需要切换日志文件
  if writer.fileDate != timer {
    writer.fileDate = timer
    writer.Writer.Close()
    err = os.MkdirAll(writer.logPath, os.ModePerm)
    if err != nil {
      logrus.Error(err)
      return 0, nil
    }
    filename := fmt.Sprintf("%s/%s.log", writer.logPath, writer.fileDate)
    writer.Writer, err = os.OpenFile(filename, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0666)
    if err != nil {
      logrus.Error(err)
      return 0, nil
    }
  }
  return writer.Writer.Write(p)
}
func Initing(logPath string, fileName string) {
  fileDate := time.Now().Format("20060102")
  filepath := fmt.Sprintf("%s/%s", logPath, fileDate)
  err := os.MkdirAll(filepath, os.ModePerm)
  if err != nil {
    logrus.Error(err)
    return
  }
  filename := fmt.Sprintf("%s/%s.log", filepath, fileName)
  writer, err := os.OpenFile(filename, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0666)
  if err != nil {
    logrus.Error(err)
    return
  }
  Logwriter := LogWriter{logPath: logPath, fileDate: fileDate, fileName: fileName, Writer: writer}
  logrus.SetOutput(os.Stdout)
  writers := []io.Writer{
    Logwriter.Writer,
    os.Stdout,
  }
  multiWriter := io.MultiWriter(writers...)
  logrus.SetOutput(multiWriter)
  logrus.SetReportCaller(true)
  logrus.SetFormatter(new(LogFormatter))
}
func main() {
  Initing("./", "fengxu")
  logrus.Warn("fengxu")
  logrus.Error("fengxu")
  logrus.Info("fengxu")
}
  • Hook写法
package main
import (
  "fmt"
  "github.com/sirupsen/logrus"
  "os"
  "time"
)
type Hook struct {
  writer   *os.File
  logPath  string
  fileName string
  fileDate string
}
func (MyHook *Hook) Levels() []logrus.Level {
  return logrus.AllLevels
}
func (MyHook *Hook) Fire(entry *logrus.Entry) error {
  timer := time.Now().Format("2006-01-02")
  line, _ := entry.String()
  //需要切换日志文件
  if MyHook.fileDate != timer {
    MyHook.fileDate = timer
    MyHook.writer.Close()
    filepath := fmt.Sprintf("%s/%s", MyHook.logPath, MyHook.fileDate)
    err := os.MkdirAll(filepath, os.ModePerm)
    if err != nil {
      logrus.Error(err)
      return err
    }
    filename := fmt.Sprintf("%s/%s.log", filepath, MyHook.fileName)
    MyHook.writer, _ = os.OpenFile(filename, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0666)
  }
  MyHook.writer.Write([]byte(line))
  return nil
}
func InitFile(logPath string, fileName string) {
  timer := time.Now().Format("2006-01-02")
  filepath := fmt.Sprintf("%s/%s", logPath, timer)
  err := os.MkdirAll(filepath, os.ModePerm)
  if err != nil {
    logrus.Error(err)
    return
  }
  filename := fmt.Sprintf("%s/%s.log", filepath, fileName)
  writer, err := os.OpenFile(filename, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0666)
  if err != nil {
    logrus.Error(err)
    return
  }
  logrus.AddHook(&Hook{
    writer:   writer,
    logPath:  logPath,
    fileName: fileName,
    fileDate: timer,
  })
}
func main() {
  InitFile("./log", "fengxu")
  logrus.Error("test")
}

按日志等级分割

package main
import (
  "fmt"
  "github.com/sirupsen/logrus"
  "os"
)
const (
  alllog   = "all"
  errorlog = "error"
  warnlog  = "warn"
)
type Hook struct {
  allLevel   *os.File
  errorLevel *os.File
  warnLevel  *os.File
}
func (MyHook *Hook) Levels() []logrus.Level {
  return logrus.AllLevels
}
func (MyHook *Hook) Fire(entry *logrus.Entry) error {
  line, _ := entry.String()
  switch entry.Level {
  case logrus.ErrorLevel:
    MyHook.errorLevel.Write([]byte(line))
  case logrus.WarnLevel:
    MyHook.warnLevel.Write([]byte(line))
  }
  MyHook.allLevel.Write([]byte(line))
  return nil
}
func InitLevel(logPath string) {
  err := os.MkdirAll(logPath, os.ModePerm)
  if err != nil {
    logrus.Error("创建目录失败")
    return
  }
  allFile, err := os.OpenFile((fmt.Sprintf("%s/%s", logPath, alllog)), os.O_CREATE|os.O_APPEND|os.O_RDWR, 0600)
  errFile, err := os.OpenFile((fmt.Sprintf("%s/%s", logPath, errorlog)), os.O_CREATE|os.O_APPEND|os.O_RDWR, 0600)
  warnFile, err := os.OpenFile((fmt.Sprintf("%s/%s", logPath, warnlog)), os.O_CREATE|os.O_APPEND|os.O_RDWR, 0600)
  logrus.AddHook(&Hook{allLevel: allFile, errorLevel: errFile, warnLevel: warnFile})
}
func main() {
  InitLevel("./log")
  logrus.SetReportCaller(true)
  logrus.Errorln("你好")
  logrus.Errorln("err")
  logrus.Warnln("warn")
  logrus.Infof("info")
  logrus.Println("print")
}

gin集成logrus

  • main函数(main.go)
package main
import (
  "gin/Logger/gin/gin_logrus/log"
  "gin/Logger/gin/gin_logrus/middleware"
  "github.com/gin-gonic/gin"
)
func main() {
  log.InitFile("./log", "fengxu")
  r := gin.New()
  r.Use(middleware.Logmiddleware())
  r.GET("/", func(c *gin.Context) {
    c.JSON(200, gin.H{
      "message": "pong",
    })
  })
  r.Run(":8080")
}
  • log.go
package log
import (
  "bytes"
  "fmt"
  "github.com/sirupsen/logrus"
  "os"
  "time"
)
type Hook struct {
  writer   *os.File
  logPath  string
  fileName string
  fileDate string
}
func (MyHook *Hook) Levels() []logrus.Level {
  return logrus.AllLevels
}
func (MyHook *Hook) Fire(entry *logrus.Entry) error {
  timer := time.Now().Format("2006-01-02")
  line, _ := entry.String()
  //需要切换日志文件
  if MyHook.fileDate != timer {
    MyHook.fileDate = timer
    MyHook.writer.Close()
    filepath := fmt.Sprintf("%s/%s", MyHook.logPath, MyHook.fileDate)
    err := os.MkdirAll(filepath, os.ModePerm)
    if err != nil {
      logrus.Error(err)
      return err
    }
    filename := fmt.Sprintf("%s/%s.log", filepath, MyHook.fileName)
    MyHook.writer, _ = os.OpenFile(filename, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0666)
  }
  MyHook.writer.Write([]byte(line))
  return nil
}
type LogFormat struct {
}
func (l *LogFormat) Format(entry *logrus.Entry) ([]byte, error) {
  var buff *bytes.Buffer
  if entry.Buffer != nil {
    buff = entry.Buffer
  } else {
    buff = &bytes.Buffer{}
  }
  _, _ = fmt.Fprintf(buff, "%s\n", entry.Message) //这里可以自己去设置输出格式
  return buff.Bytes(), nil
}
func InitFile(logPath string, fileName string) {
  logrus.SetFormatter(&LogFormat{})
  timer := time.Now().Format("2006-01-02")
  filepath := fmt.Sprintf("%s/%s", logPath, timer)
  err := os.MkdirAll(filepath, os.ModePerm)
  if err != nil {
    logrus.Error(err)
    return
  }
  filename := fmt.Sprintf("%s/%s.log", filepath, fileName)
  writer, err := os.OpenFile(filename, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0666)
  if err != nil {
    logrus.Error(err)
    return
  }
  logrus.AddHook(&Hook{
    writer:   writer,
    logPath:  logPath,
    fileName: fileName,
    fileDate: timer,
  })
}
  • 中间件(lmiddleware.go)
package middleware
import (
  "github.com/gin-gonic/gin"
  "github.com/sirupsen/logrus"
  "time"
)
const ( //自定义状态码和方法的显示颜色
  status200 = 42
  status404 = 43
  status500 = 41
  methodGET = 44
)
func Logmiddleware() gin.HandlerFunc {
  return func(c *gin.Context) {
    start := time.Now()
    path := c.Request.URL.Path
    raw := c.Request.URL.RawQuery
    if raw != "" {
      path = path + "?" + raw
    }
    c.Next() //执行其他中间件
    //end := time.Now()
    //timesub := end.Sub(start)  //响应所需时间
    //ClientIp := c.ClientIP()  //客户端ip
    statuscode := c.Writer.Status()
    //var statusColor string  
    //switch c.Writer.Status() {
    //case 200:
    //  statusColor = fmt.Sprintf("\033[%dm%d\033[0m", status200, statuscode)
    //case 404:
    //  statusColor = fmt.Sprintf("\033[%dm%d\033[0m", status404, statuscode)
    //default:
    //  statusColor = fmt.Sprintf("\033[%dm%d\033[0m", status500, statuscode)
    //}
    //
    //var methodColor string
    //switch c.Request.Method {
    //case "GET":
    //  methodColor = fmt.Sprintf("\033[%dm%s\033[0m", methodGET, c.Request.Method)
    //}
    logrus.Infof("[GIN] %s  |%d  |%s  |%s",
      start.Format("2006-01-02 15:04:06"),
      statuscode,
      c.Request.Method,
      path,
    )
  }
}

项目结构:

结语

至此我们对Gin框架的简单学习就到此为止了,更多的学习大家可以前去查看Gin框架官方文档:

Gin框架官方文档

后面就要开始对Gorm的学习了,下篇见!

相关实践学习
日志服务之数据清洗与入湖
本教程介绍如何使用日志服务接入NGINX模拟数据,通过数据加工对数据进行清洗并归档至OSS中进行存储。
相关文章
|
4天前
|
XML Java 测试技术
《手把手教你》系列基础篇(九十一)-java+ selenium自动化测试-框架设计基础-Logback实现日志输出-下篇(详解教程)
【7月更文挑战第9天】在Java项目中,使用Logback配置可以实现日志按照不同包名输出到不同的文件,并且根据日志级别分开记录。
20 4
|
4天前
|
XML Java 测试技术
《手把手教你》系列基础篇(九十)-java+ selenium自动化测试-框架设计基础-Logback实现日志输出-中篇(详解教程)
【7月更文挑战第8天】这篇教程介绍了如何使用Logback将Java应用的日志输出到文件中。首先,通过创建`logback.xml`配置文件,设置`FileAppender`来指定日志文件路径和格式。然后,提供了一个`RollingFileAppender`的例子,用于每日生成新的日志文件并保留一定天数的历史记录。文中包含配置文件的XML代码示例,并展示了控制台输出和生成的日志文件内容。教程最后提到了一些可能遇到的问题及解决建议。
15 0
《手把手教你》系列基础篇(九十)-java+ selenium自动化测试-框架设计基础-Logback实现日志输出-中篇(详解教程)
|
9天前
|
XML 测试技术 数据格式
《手把手教你》系列基础篇(八十五)-java+ selenium自动化测试-框架设计基础-TestNG自定义日志-下篇(详解教程)
【7月更文挑战第3天】TestNG教程展示了如何自定义日志记录。首先创建一个名为`TestLog`的测试类,包含3个测试方法,其中一个故意失败以展示日志。使用`Assert.assertTrue`和`Reporter.log`来记录信息。接着创建`CustomReporter`类,继承`TestListenerAdapter`,覆盖`onTestFailure`, `onTestSkipped`, 和 `onTestSuccess`,在这些方法中自定义日志输出。
27 6
|
5天前
|
Java 关系型数据库 测试技术
《手把手教你》系列基础篇(八十九)-java+ selenium自动化测试-框架设计基础-Logback实现日志输出-上篇(详解教程)
【7月更文挑战第7天】Apache Log4j2的安全漏洞促使考虑使用logback作为替代的日志框架。Logback由log4j创始人设计,提供更好的性能,更低的内存使用,并且能够自动重载配置文件。它分为logback-core、logback-classic(实现了SLF4J API)和logback-access(用于Servlet容器集成)三个模块。配置涉及Logger、Appender(定义日志输出目的地)和Layout(格式化日志)。
15 1
|
8天前
|
Java 测试技术 Apache
《手把手教你》系列基础篇(八十六)-java+ selenium自动化测试-框架设计基础-Log4j实现日志输出(详解教程)
【7月更文挑战第4天】Apache Log4j 是一个广泛使用的 Java 日志框架,它允许开发者控制日志信息的输出目的地、格式和级别。Log4j 包含三个主要组件:Loggers(记录器)负责生成日志信息,Appenders(输出源)确定日志输出的位置(如控制台、文件、数据库等),而 Layouts(布局)则控制日志信息的格式。通过配置 Log4j,可以灵活地定制日志记录行为。
25 4
|
16天前
|
监控 Java API
Java日志框架的纷争演进与传奇故事
Java日志框架的纷争演进与传奇故事
|
6天前
|
XML Java 测试技术
《手把手教你》系列基础篇(八十八)-java+ selenium自动化测试-框架设计基础-Log4j 2实现日志输出-下篇(详解教程)
【7月更文挑战第6天】本文介绍了如何使用Log4j2将日志输出到文件中,重点在于配置文件的结构和作用。配置文件包含两个主要部分:`appenders`和`loggers`。`appenders`定义了日志输出的目标,如控制台(Console)或其他文件,如RollingFile,设置输出格式和策略。`loggers`定义了日志记录器,通过`name`属性关联到特定的类或包,并通过`appender-ref`引用`appenders`来指定输出位置。`additivity`属性控制是否继承父logger的配置。
15 0
|
7天前
|
XML Java 测试技术
《手把手教你》系列基础篇(八十七)-java+ selenium自动化测试-框架设计基础-Log4j 2实现日志输出-上篇(详解教程)
【7月更文挑战第5天】Apache Log4j 2是一个日志框架,它是Log4j的升级版,提供了显著的性能提升,借鉴并改进了Logback的功能,同时修复了Logback架构中的问题。Log4j2的特点包括API与实现的分离,支持SLF4J,自动重新加载配置,以及高级过滤选项。它还引入了基于lambda表达式的延迟评估,低延迟的异步记录器和无垃圾模式。配置文件通常使用XML,但也可以是JSON或YAML,其中定义了日志级别、输出目的地(Appender)和布局(Layout)。
16 0
|
10天前
|
Java 测试技术 Android开发
《手把手教你》系列基础篇(八十四)-java+ selenium自动化测试-框架设计基础-TestNG日志-上篇(详解教程
【7月更文挑战第2天】TestNG是一个用于自动化测试的Java框架,提供日志记录功能。日志有两种模式:底层级详细记录每个步骤,高层级仅记录关键事件。示例代码展示了如何在测试方法中使用`Reporter.log()`记录信息,这些信息会显示在TestNG HTML报告中。文章还提及了日志显示时可能出现的编码问题及解决办法。
17 0
|
15天前
|
Java Spring 容器
Spring5系列学习文章分享---第六篇(框架新功能系列+整合日志+ @Nullable注解 + JUnit5整合)
Spring5系列学习文章分享---第六篇(框架新功能系列+整合日志+ @Nullable注解 + JUnit5整合)
12 0