spring boot 整合log4j并输出日志文件

最新推荐文章于 2024-04-16 07:00:58 发布
最新推荐文章于 2024-04-16 07:00:58 发布
阅读量358 收藏
点赞数
分类专栏： spring boot log4j 文章标签： 微服务 spring boot log4j 日志整合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42037525/article/details/102497950
版权

第一步：spring boot默认的日志框架是logback，首先去除Logback的jar包，并引入Log4j2的jar。我在网上找到一些资料说排除spring-boot-starter或者spring-boot-starter-web下的日志框架即可，我建议两个都排除。

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <!--排除spring boot自带的日志框架-->
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <!--排除spring boot自带的日志框架-->
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--引入log4j依赖包-->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j</artifactId>
            <version>1.2.5.RELEASE</version>
        </dependency>

第二步：创建ColoredPatternLayout类，若log4.properties文件中没有使用则不需要创建

import org.apache.log4j.Level;
import org.apache.log4j.PatternLayout;
import org.apache.log4j.spi.LoggingEvent;

import java.util.StringTokenizer;

/**
 * 描述: 颜色
 *
 * @outhor Administrator
 * @create 2018-11-07 17:45
 */


public class ColoredPatternLayout extends PatternLayout {
  private static final String CONFIGURATION_SEPARATOR="/";

  private static final String PREFIX = "\u001b[";
  private static final String SUFFIX = "m";
  private static final char SEPARATOR = ';';
  private static final String END_COLOR = PREFIX + SUFFIX;

  private static final String ATTR_NORMAL = "0";
  private static final String ATTR_BRIGHT = "1";
  private static final String ATTR_DIM = "2";
  private static final String ATTR_UNDERLINE = "3";
  private static final String ATTR_BLINK = "5";
  private static final String ATTR_REVERSE = "7";
  private static final String ATTR_HIDDEN = "8";

  private static final String FG_BLACK = "30";
  private static final String FG_RED = "31";
  private static final String FG_GREEN = "32";
  private static final String FG_YELLOW = "33";
  private static final String FG_BLUE = "34";
  private static final String FG_MAGENTA = "35";
  private static final String FG_CYAN = "36";
  private static final String FG_WHITE = "37";

  private static final String BG_BLACK = "40";
  private static final String BG_RED = "41";
  private static final String BG_GREEN = "42";
  private static final String BG_YELLOW = "44";
  private static final String BG_BLUE = "44";
  private static final String BG_MAGENTA = "45";
  private static final String BG_CYAN = "46";
  private static final String BG_WHITE = "47";

  private String fatalErrorColor
      = PREFIX + ATTR_DIM + SEPARATOR + FG_RED + SUFFIX;
  private String errorColor
      = PREFIX + ATTR_DIM + SEPARATOR + FG_RED + SUFFIX;
  private String warnColor
      = PREFIX + ATTR_DIM + SEPARATOR + FG_MAGENTA + SUFFIX;
  private String infoColor
      = PREFIX + ATTR_DIM + SEPARATOR + FG_GREEN + SUFFIX;
  private String debugColor
      = PREFIX + ATTR_DIM + SEPARATOR + FG_WHITE + SUFFIX;

  public ColoredPatternLayout(){
    super();
  }
  public ColoredPatternLayout(String pattern){
    super(pattern);
  }

  public String format(LoggingEvent event){
    if( event.getLevel().equals(Level.FATAL)){
      return fatalErrorColor+super.format(event)+END_COLOR;
    }else if( event.getLevel().equals(Level.ERROR)){
      return errorColor+super.format(event)+END_COLOR;
    }if( event.getLevel().equals(Level.WARN)){
      return warnColor+super.format(event)+END_COLOR;
    }if( event.getLevel().equals(Level.INFO)){
      return infoColor+super.format(event)+END_COLOR;
    }if( event.getLevel().equals(Level.DEBUG)){
      return debugColor+super.format(event)+END_COLOR;
    }else{
      throw new RuntimeException("Unsupported Level "+event.toString());
    }
  }

  private String makeFgString(String fgColorName){
    if(fgColorName.toLowerCase().equals("black")){
      return FG_BLACK;
    }else if(fgColorName.toLowerCase().equals("red")){
      return FG_RED;
    }else if(fgColorName.toLowerCase().equals("green")){
      return FG_GREEN;
    }else if(fgColorName.toLowerCase().equals("yellow")){
      return FG_YELLOW;
    }else if(fgColorName.toLowerCase().equals("blue")){
      return FG_BLUE;
    }else if(fgColorName.toLowerCase().equals("magenta")){
      return FG_MAGENTA;
    }else if(fgColorName.toLowerCase().equals("cyan")){
      return FG_CYAN;
    }else if(fgColorName.toLowerCase().equals("white")){
      return FG_WHITE;
    }
    System.out.println("log4j: ColoredPatternLayout Unsupported FgColor "+fgColorName);
    return "-1";
  }
  private String makeBgString(String bgColorName){
    //System.out.println("bg "+bgColorName);
    if(bgColorName.toLowerCase().equals("black")){
      return BG_BLACK;
    }else if(bgColorName.toLowerCase().equals("red")){
      return BG_RED;
    }else if(bgColorName.toLowerCase().equals("green")){
      return BG_GREEN;
    }else if(bgColorName.toLowerCase().equals("yellow")){
      return BG_YELLOW;
    }else if(bgColorName.toLowerCase().equals("blue")){
      return BG_BLUE;
    }else if(bgColorName.toLowerCase().equals("magenta")){
      return BG_MAGENTA;
    }else if(bgColorName.toLowerCase().equals("cyan")){
      return BG_CYAN;
    }else if(bgColorName.toLowerCase().equals("white")){
      return BG_WHITE;
    }
    System.out.println("log4j: ColoredPatternLayout Unsupported BgColor "+bgColorName);
    return "-1";
  }


  private String makeAttributeString(String attributeName){
    //System.out.println("attribute "+attributeName);
    if(attributeName.toLowerCase().equals("normal")){
      return ATTR_NORMAL;
    }else if(attributeName.toLowerCase().equals("bright")){
      return ATTR_BRIGHT;
    }else if(attributeName.toLowerCase().equals("dim")){
      return ATTR_DIM;
    }else if(attributeName.toLowerCase().equals("underline")){
      return ATTR_UNDERLINE;
    }else if(attributeName.toLowerCase().equals("blink")){
      return ATTR_BLINK;
    }else if(attributeName.toLowerCase().equals("reverse")){
      return ATTR_REVERSE;
    }else if(attributeName.toLowerCase().equals("hidden")){
      return ATTR_HIDDEN;
    }
    System.out.println("log4j: ColoredPatternLayout Unsupported Attribute "+attributeName);

    return "-1";
  }

  private String makeColorString(String colorName){
    //System.out.println(colorName);
    StringTokenizer tokenizer=new StringTokenizer(colorName,
        CONFIGURATION_SEPARATOR);
    String fgColor=FG_WHITE;
    String bgColor=BG_BLACK;
    String attr=ATTR_NORMAL;
    if(!tokenizer.hasMoreTokens()){
      return PREFIX + ATTR_NORMAL + SEPARATOR + FG_WHITE + SUFFIX;
    }
    if(tokenizer.hasMoreTokens()){
      fgColor=makeFgString(tokenizer.nextToken());
    }
    if(tokenizer.hasMoreTokens()){
      bgColor=makeBgString(tokenizer.nextToken());
    }
    if(tokenizer.hasMoreTokens()){
      attr=makeAttributeString(tokenizer.nextToken());
    }
    //return PREFIX + ATTR_DIM + SEPARATOR + FG_WHITE + SUFFIX;
    return PREFIX + attr
        + SEPARATOR + fgColor
        + SEPARATOR + bgColor
        +SUFFIX;
  }

  public String getFatalErrorColor(){
    return fatalErrorColor;
  }
  public void setFatalErrorColor(String colorName){
    fatalErrorColor=makeColorString(colorName);
  }

  public String getErrorColor(){
    return errorColor;
  }
  public void setErrorColor(String colorName){
    //System.out.println(colorName);
    errorColor=makeColorString(colorName);
  }

  public String getWarnColor(){
    return warnColor;
  }
  public void setWarnColor(String colorName){
    warnColor=makeColorString(colorName);
  }

  public String getInfoColor(){
    return infoColor;
  }
  public void setInfoColor(String colorName){
    infoColor=makeColorString(colorName);
  }

  public String getDebugColor(){
    return debugColor;
  }
  public void setDebugColor(String colorName){
    debugColor=makeColorString(colorName);
  }


}

第三步：创建log4.properties文件

log4j.debug=true
log4j.rootLogger=INFO,console,debug,error,warn
log4j.logger.com.alibaba.druid.filter.logging.Log4j2Filter=DEBUG
#log4j.logger.com.alibaba.druid=DEBUG
#log4j.logger.com.atomikos=ERROR
log4j.appender.console=org.apache.log4j.ConsoleAppender
## console面板自定义打印颜色配置，也可以使用默认的org.apache.log4j.PatternLayout
## 配置自己的面板输出颜色类ColoredPatternLayout
log4j.appender.console.layout=*.ColoredPatternLayout
log4j.appender.console.layout.ConversionPattern=[%p-%d{HH\:mm\:ss}]%c{1}.(%L) - %m%n
log4j.appender.console.Threshold=DEBUG
## 输出到日志文件 ###
log4j.appender.debug = org.apache.log4j.DailyRollingFileAppender
log4j.appender.debug.File = debug.log
log4j.appender.debug.DatePattern='.'yyyy-MM-dd'.log'
log4j.appender.debug.Append = true
log4j.appender.debug.Threshold = DEBUG
log4j.appender.debug.layout = org.apache.log4j.PatternLayout
log4j.appender.debug.layout.ConversionPattern = %-d{HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n
## 保存异常信息到单独文件 ###
log4j.appender.error = org.apache.log4j.DailyRollingFileAppender
log4j.appender.error.File = error.log
log4j.appender.error.DatePattern='.'yyyy-MM-dd'.log'
log4j.appender.error.Append = true
log4j.appender.error.Threshold = ERROR
log4j.appender.error.layout = org.apache.log4j.PatternLayout
log4j.appender.error.layout.ConversionPattern = %-d{ HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n
## 保存异常信息到单独文件 ###
log4j.appender.warn = org.apache.log4j.DailyRollingFileAppender
log4j.appender.warn.File = warn.log
log4j.appender.warn.DatePattern='.'yyyy-MM-dd'.log'
log4j.appender.warn.Append = true
log4j.appender.warn.Threshold = WARN
log4j.appender.warn.layout = org.apache.log4j.PatternLayout
log4j.appender.warn.layout.ConversionPattern = %-d{HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

第四步：创建mybatis-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!-- 在这个文件放置一些全局性的配置
    <typeAliases>
        <typeAlias type="实体类" alias="别名"/>
    </typeAliases> -->

    <settings>
        <setting name="cacheEnabled" value="false" />
        <!-- 打印查询语句 -->
        <!--<setting name="logImpl" value="STDOUT_LOGGING" />-->
        <!-- 设置超时时间，它决定驱动等待一个数据库响应的时间  -->

        <!--  设置缓存和延迟加载等等重要的运行时的行为方式
         <setting name="defaultStatementTimeout" value="25000"/>
         &lt;!&ndash; 这个配置使全局的映射器启用或禁用缓存  &ndash;&gt;
         <setting name="cacheEnabled" value="true" />
         <setting name="lazyLoadingEnabled" value="true"/>
         <setting name="useColumnLabel" value="true" />
         <setting name="mapUnderscoreToCamelCase" value="true" />-->
    </settings>
    <!-- 以下内容不再需要手动配置  已经自动映射 -->


    <!--配置sql拦截器-->
    <plugins>
        <plugin interceptor="shop.guangzhou.yunwuyou.config.SqlStatementInterceptor"/>
    </plugins>
    <!--<plugins>
      <plugin interceptor="cn.chenlilin.blog.filter.SqlStatementInterceptor" />
    </plugins>-->

</configuration>

第五步：添加全局异常拦截器GlobalExceptionHandler

import org.apache.commons.io.output.ByteArrayOutputStream;
import org.apache.tomcat.util.http.fileupload.FileUploadBase;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.multipart.MaxUploadSizeExceededException;
import org.springframework.web.multipart.MultipartException;
import shop.guangzhou.yunwuyou.utils.Msg;

import java.io.PrintStream;


/**
 * Created by Administrator on 2020/11/13.
 */
@RestControllerAdvice
@Component
public class GlobalExceptionHandler {

    static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public Msg globalExceptionHandle(Exception e) {
        logger.error("===========全局统一异常处理============");
        logger.error(getExceptionInfo(e));
        return Msg.fail(500, "error", "系统错误");
    }

    private static String getExceptionInfo(Exception ex) {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        PrintStream printStream = new PrintStream(out);
        ex.printStackTrace(printStream);
        String rs = new String(out.toByteArray());
        try {
            printStream.close();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return rs;
    }

}

第四步：配置application.yml文件，在最下面加入如下配置即可

# MyBatis配置`
mybatis:
  config-location: classpath:mybatis-config.xml
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: shop.guangzhou.yunwuyou.pojo
logging:
  config: classpath:log4j.properties
  path: classpath:log/

配置完成后运行项目结果如下，到此便整合完成

 

你的微笑，乱了夏天
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot整合与使用log4j2日志框架【详解版】
无边热爱，来日方长
06-04 3590
Springboot整合与使用log4j2日志框架【详解版】
学习SpringBoot使用slf4j日志并输出到文件中
weixin_46010242的博客
03-11 6029
的文件名作为你的日志配置（如logback-spring.xml，而不是logback.xml），命名为logback-spring.xml的日志配置文件，spring boot可以为它添加一些spring boot特有的配置项（下面会提到）。slf4j(Simple logging Facade for Java) 简单日志门面，日志系统的实现进行了具体的抽象化，只提供了统一的日志使用接口，没有任何日志实现，只有一个jar包（slf4j-api.jar）。log4j和logback是具体的日志框架。
Log4j2同步日志，混合日志和异步日志配置详解
最新发布
2401_84049001的博客
04-16 1236
开发环境使用测试，生产环境使用混合同步和异步日志Log4j-2.9及更高版本在类路径上需要disruptor-3.3.4.jar或更高版本。在Log4j-2.9之前，需要disruptor-3.0.0.jar或更高版本。无需将系统属性“Log4jContextSelector”设置为任何值。可以在配置中组合同步和异步记录器。这为您提供了更大的灵活性，但代价是性能略有下降（与使所有记录器异步相比）。使用或配置元素指定需要异步的记录器。配置只能包含一个根记录器（或。
20Springboot整合日志过程
qq_41946216的博客
03-24 2562
1、日志级别介绍 日志级别从高到低：error，warn，info，debug、trace error：抛出异常或者连接不上数据库等，需要人为接入和修复的 warn：不常用，只是警告 info：在未来进行定位和排查问题使用，例如用户请求和返回 debug：用于自身在开发过程中调试使用，例如打印某方法执行的时间，这些信息不需要以info级别记录。 trace；一般用于框架开发，不常用。 2、引入log4j2依赖 引入log4j2依赖，无需指定版本，因......
springboot整合log4j
qq_44981598的博客
09-07 898
4. 日志的级别可以再配置文件配置。一般开发环境打DEBUG。
springboot+log4j日志配置
hauchun的博客
11-04 6707
日志是每个项目中必不可少的配置，主要用来运行情况和定位问题 以下为自己亲自测试的,如果大家有更好的方式，欢迎在下方留言！ 步骤： 1.引入jar包 2.配置日志打印详细 1.引入jar包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId&g..
Spring Boot 入门之整合 log4jdbc 篇
01-07
logback日志的yml文件 logging: level: root: info org.springframework: info com.beijin.limengya.mobile.dao: ERROR com.beijin: debug #com.beijin: ERROR com.netflix: ERROR com.zaxxer: ERROR ...
springmvc5+hibernate5+junit4+log4j2整合实例
12-08
在本整合实例中，我们将探讨如何将Spring MVC 5、Hibernate 5、JUnit 4 和 Log4j2 集成在一起，以构建一个高效、可测试和日志记录完善的Java Web应用程序。以下是对这些技术及其整合过程的详细说明： **Spring MVC ...
spring-boot-log4j2-example
02-07
本篇将详细介绍如何在Spring Boot项目中整合Log4j2，以实现高效、灵活的日志管理。 首先，我们创建一个名为"spring-boot-log4j2-example"的项目，这通常是一个Maven或Gradle工程。Spring Boot项目的基础结构包括`...
SpringBoot2.X整合Mybatis代码示例2-使用配置文件方式+Log4j
09-17
1. **引入Log4j配置**：在项目的`src/main/resources`目录下创建`log4j2.xml`或`log4j2.json`文件，用于定义日志级别、输出位置、格式等。 ```xml [%t] %-5level %logger{36} - %msg%n"/> ...
Spring boot+Mybatis+log4j项目实例
03-14
Spring Boot简化了Spring应用程序的初始设置和配置，Mybatis作为轻量级的持久层框架提供了灵活的SQL操作，而Log4j则是广泛使用的日志记录工具，用于追踪应用中的各种事件。 首先，Spring Boot以其“开箱即用”的...
log4j2.component.properties
12-13
log4j2.component.properties
spring boot整合slf4j 、 log4j2指南，实现日志打印到文档
it1993的博客
03-02 1309
一. 新建spring boot项目 选择这3个选项，同时引入junit测试jar包，具体操作见下图 <!-- springboot test --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-...
SpringBoot + Log4j 每天输出一个日志文件(分级别的)
az44yao的专栏
05-21 1643
一、日志文件的作用 将系统日志持久化到文件保存起来，当程序方便发生问题的时候，能够快速、准确的定位到问题的所在。 现在有很多日志处理方式他们都是什么关系SLF4J和Logback和Log4j和Logging的区别与联系 SLF4J详情 logger打印日志(如何打印对象内容) log4j.jar log4j.properties 配置与使用 下面我们用SpringBoot + Log4j 每天输出一个日志文件(分级别的) 系统运行时间久了，日志文件也自然多了，出现问题自然也不好找。所以可以通过.
log4j2 日志的 log4j2.component.properties 文件内容
YKenan的博客
03-22 5607
log4j2 日志的 log4j2.component.properties 文件内容 此文件会随着时间不断更新 log4j2.loggerContextFactory=org.apache.logging.log4j.core.impl.Log4jContextFactory log4j.configurationFile=log4j/log4j2.xml ...
Log4j2漏洞修复
derstsea的专栏
12-14 1万+
一、漏洞说明 Apache Log4j2是一个基于Java的日志记录工具。由于Apache Log4j2某些功能存在递归解析功能，攻击者可直接构造恶意请求，触发远程代码执行漏洞。漏洞利用无需特殊配置，经阿里云安全团队验证，Apache Struts2、Apache Solr、Apache Druid、Apache Flink等均受影响。 漏洞适用版本为 2.0 <= Apache log4j2 <= 2.14.1，只需检测Java应用是否引入 log4j-api , log4j-core 两个j
Mybatis 日志(Log4j2)
Mointor
09-26 1048
本篇主要介绍Mybatis配置Log4j2日志系统进行日志的打印，同时也介绍了Log4j2日志系统配置文件的配置与引入方式
spring、springboot集成 log4j日志、log4j2日志以及slf4j
qq_45812181的博客
03-27 2509
1、查看pringboot自带的日志框架 新建一个springboot 工程，查看依赖树 通过查看依赖树可以发现，springboot自带被loggong管理的log4j 、logback等日志相关的依赖。为了不影响测试结果，手动排除掉龙宫依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-
后台学习一---spring+maven+mybatis+mysql+junit整合
热门推荐
lxfHaHaHa的博客
02-25 1万+
1.工具/原料• apache-tomcat-7.0.63 http://download.csdn.net/detail/lxfhahaha/9778163 • apache-maven-3.3.3 http://download.csdn.net/detail/lxfhahaha/9778158 • MySQL Server 5.0 http://download.csdn.ne
[课堂课件讲解]Java微服务实践-Spring Boot 日志.pptx
08-27
本资源是一份关于Java微服务实践，特别是Spring Boot日志使用的课堂课件，涵盖了日志框架的统一、设计模式以及Spring Boot的日志整合等内容。其中重点介绍了Log4j，包括其历史背景、整体架构以及关键组件。 在Java...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值