日志，springboot日志整合，日志配置

已于 2025-02-11 08:58:31 修改
阅读量850 收藏 20
点赞数 8
文章标签： spring boot 后端 java
于 2025-02-11 08:57:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43827533/article/details/145563267
版权

日志门面

市面上的日志框架：Jboss-logging、logback、log4j、log4j2 等等

日志门面就是在日志框架和应用程序之间架设一个沟通的桥梁，对于应用程序来说，无论底层的日志框架如何变，都不需要有任何感知

日志门面可以理解为java中的一个interface（接口），而日志框架就是就是实现类

SLF4J（Simple Logging Facade for Java）

JUL（java.util.logging）

日志门面作用

  • ① 面向接口开发，不再依赖具体的实现类，减少代码的耦合；
  • ② 项目通过导入不同的日志实现类，可以灵活的切换日志框架；
  • ③ 统一API，方便开发者学习和使用；
  • ④ 统一配置便于项目日志的管理。

img

日志框架

1. Log4j:

是一个非常流行的开源日志框架，由Apache软件基金会开发和维护。

它提供了强大的日志记录功能，广泛应用于Java应用程序中。

Log4j的主要特点包括灵活的配置、高性能、丰富的功能和广泛的社区支持。 随着时间的推移，Log4j已经逐渐被

其后续版本Log4j2所取代。

2. Log4j2:

Log4j2是log4j的后续版本，它在性能、功能、灵活性和易用性方面都有了很大的提升。

Log4j2支持异步日志记录，可以极大地提高多线程环境下的日志性能。

Log4j2也支持通过配置文件进行灵活的配置，包括日志的输出目标、记录级别、输出格式等。

Log4j2也提供了对slf4j的桥接支持，因此可以作为slf4j的一个具体实现。

3. Logback:

Logback是log4j的创始人Ceki Gülcü开发的一个新的日志框架，它被视为log4j的继任者。

Logback在性能、内存使用和灵活性方面都优于log4j，并且它直接实现了slf4j的接口，因此可以作为slf4j的一个具

体实现。Logback本身包含了一套完整的日志解决方案，无需依赖其他库。

4. Jboss-logging

是一个用于Java应用程序的日志框架，主要用于Jboss生态系统。它提供了一个统一的日志API，可以与多种日志框架（如Log4j、Log4j 2、Logback、java.util.logging等）集成。Jboss-logging 的主要目标是提供一个抽象层，使得应用程序可以在不修改代码的情况下切换不同的日志框架。

SLF4J

1、简单介绍

简单日志门面(Simple Logging Facade For Java) SLF4J主要是为了给Java日志访问提供一套标准、规范的API框架，其主要意义在于提供接口，具体的实现可以交由其他日志框架，例如log4j和logback等。

对于一般的Java项目而言，日志框架会选择slf4j-api作为门面，配上具体的实现框架（log4j、logback等），中间使用桥接器完成桥接。

SLF4J，简单日志门面（Simple Logging Facade for Java），不是具体的日志解决方案，它只服务于各种各样的日志系统。

img

它允许最终用户在部署其应用时使用其所希望的日志系统。 实际上，SLF4J所提供的核心API是一些接口以及一个LoggerFactory的工厂类。在使用SLF4J的时候，不需要在代码中或配置文件中指定你打算使用哪个具体的日志系统。SLF4J提供了统一的记录日志的接口，只要按照其提供的方法记录即可，最终日志的格式、记录级别、输出方式等通过具体日志系统的配置来实现，因此可以在应用中灵活切换日志系统。

说白了，slf4j方便我们在不动代码的前提下随意切换我们的日志框架。在部署的时候，选择不同的日志系统包，就可自动转换到不同的日志系统上。

想象一下下面的场景：

有一个别人写的很棒的类库，里面使用的是jdk自带的java.util.logging.Logger这个日志系统，现在你有一个程序需要用到这个类库，并且你自己的程序现在是使用apache的org.apache.log4j.Logger这个日志系统。那么问题来了，如果你的程序导入了这个类库，那么必须支持这两种日志系统，这会很繁琐且不利于管理。但是使用Slf4j就可以屏蔽两者差异，并做到统一管理。

使用slf4j实现各种日志框架

怎么看springboot在哪里 springboot如何查看运行日志_怎么看springboot在哪里

日志整合

添加依赖
       <!-- jdbc -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <!-- druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.21</version>
        </dependency>

        <!-- log4j2 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
        </dependency>
引入log4j2-spring.xml日志配置
<?xml version="1.0" encoding="UTF-8"?>
<!--Configuration后面的status，这个用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，你会看到log4j2内部各种详细输出-->
<!--monitorInterval：Log4j能够自动检测修改配置 文件和重新配置本身，设置间隔秒数-->
<configuration status="INFO" monitorInterval="5">
    <!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
    <!--变量配置-->
    <Properties>
        <!-- 格式化输出：%date表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %msg：日志消息，%n是换行符-->
        <!-- %logger{36} 表示 Logger 名字最长36个字符 -->
        <property name="LOG_PATTERN" value="%date{HH:mm:ss.SSS} %X{PFTID} [%thread] %-5level %logger{36} - %msg%n" />
        <!-- 定义日志存储的路径 -->
        <property name="FILE_PATH" value="../log/vending_machine" />
        <property name="FILE_NAME" value="vending_machine.log" />
    </Properties>

    <!--https://logging.apache.org/log4j/2.x/manual/appenders.html-->
    <appenders>
      	 <!-- appenders标签定义了日志的输出目标（Appender），如控制台、文件等。 -->

        <console name="Console" target="SYSTEM_OUT">
            <!--输出日志的格式-->
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <!--ThresholdFilter 过滤器 控制台只输出level及其以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
        </console>

        <!--文件会打印出所有信息，这个log每次运行程序会自动清空，由append属性决定，适合临时测试用-->
        <File name="fileLog" fileName="${FILE_PATH}/temp.log" append="false">
            <PatternLayout pattern="${LOG_PATTERN}"/>
        </File>

        <!-- 这个会打印出所有的info及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileInfo" fileName="${FILE_PATH}/info.log" filePattern="${FILE_PATH}/${FILE_NAME}-INFO-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

        <!-- 这个会打印出所有的warn及以上级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileWarn" fileName="${FILE_PATH}/warn.log" filePattern="${FILE_PATH}/${FILE_NAME}-WARN-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

        <!-- 这个会打印出所有的error及以上级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileError" fileName="${FILE_PATH}/error.log" filePattern="${FILE_PATH}/${FILE_NAME}-ERROR-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

    </appenders>

    <!--Logger节点用来单独指定日志的形式，比如要为指定包下的class指定不同的日志级别等。-->
    <!--然后定义loggers，只有定义了logger并引入的appender，appender才会生效-->
    <loggers>
        <root level="info">
            <appender-ref ref="Console"/>
            <appender-ref ref="RollingFileInfo"/>
            <appender-ref ref="RollingFileWarn"/>
            <appender-ref ref="RollingFileError"/>
            <appender-ref ref="fileLog"/>
        </root>
    </loggers>

</configuration>
日志配置
logging:
    config: classpath:log4j2-spring.xml

日志冲突报错

解决方法：去掉SpringBoot默认日志配置 ，不仅仅是web，还是有starter以及test

       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <artifactId>spring-boot-starter-logging</artifactId>
                    <groupId>org.springframework.boot</groupId>
                </exclusion>
            </exclusions>
        </dependency>
配置Druid参数

参考链接

指定密码加密算法

加密工具

public class DruidEncryptUtil {

    private static String publicKey;

    private static String privateKey;

    static {
        try {
            String[] keyPair = ConfigTools.genKeyPair(512);
            privateKey = keyPair[0];
            System.out.println("privateKey:" + privateKey);
            publicKey = keyPair[1];
            System.out.println("publicKey:" + publicKey);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchProviderException e) {
            e.printStackTrace();
        }
    }

    public static String encrypt(String plainText) throws Exception {
        String encrypt = ConfigTools.encrypt(privateKey, plainText);
        System.out.println("encrypt:" + encrypt);
        return encrypt;
    }

    public static String decrypt(String encryptText) throws Exception {
        String decrypt = ConfigTools.decrypt(publicKey, encryptText);
        System.out.println("decrypt:" + decrypt);
        return decrypt;
    }

    public static void main(String[] args) throws Exception {
        String encrypt = encrypt("Root_123456");
        System.out.println("encrypt:" + encrypt);
    }

}
修改Springboot配置文件
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql:///xxxxxx
    username: root
    password: b4I1YgZA8w14Qh1DToV7r7SqeZbHxcp5S3y0hN52ifLnwPENbOMYDjXh4kUVwkg65pg8R+ap84kGdY8Cq8scxQ==
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      initial-size: 20
      min-idle: 20
      connectionProperties: config.decrypt=true;config.decrypt.key=${publicKey};
      max-active: 100
      max-wait: 60000
      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
        login-username: admin
        login-password: 123456
      filter:
        stat:
          enabled: true
          slow-sql-millis: 2000
          log-slow-sql: true
        wall:
          enabled: true
        config:
          enabled: true
publicKey: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKpoGsyuhAfBnfnpbRo+qL49WYrwQI+WKy62bN4GGM2fLl29JLnXzWY+Kb9CJbnJMSh7uV22iITYWF3Q+m5o10cCAwEAAQ==
logging:
    config: classpath:log4j2-spring.xml

#logging:
#  level:
#    com:
#      codingfuture:
#        vendingmachineserver: debug

mybatis:
  mapper-locations: classpath:mapper/*Mapper.xml
  configuration:
    map-underscore-to-camel-case: true
    use-generated-keys: true
添加配置类指定拦截规则

MybatisConfiguration

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 */
@Configuration
public class MybatisConfiguration {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new MybatisPlusAllSqlLog());
        return mybatisPlusInterceptor;
    }

}

MybatisPlusAllSqlLog

import com.baomidou.mybatisplus.extension.plugins.inner.InnerInterceptor;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.type.TypeHandlerRegistry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.CollectionUtils;

import java.sql.SQLException;
import java.text.DateFormat;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.regex.Matcher;

public class MybatisPlusAllSqlLog implements InnerInterceptor {
    public static final Logger log = LoggerFactory.getLogger("sys-sql");

    @Override
    public void beforeQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
        logInfo(boundSql, ms, parameter);
    }

    @Override
    public void beforeUpdate(Executor executor, MappedStatement ms, Object parameter) throws SQLException {
        BoundSql boundSql = ms.getBoundSql(parameter);
        logInfo(boundSql, ms, parameter);
    }

    private static void logInfo(BoundSql boundSql, MappedStatement ms, Object parameter) {
        try {
            log.info("parameter = " + parameter);
            // 获取到节点的id,即sql语句的id
            String sqlId = ms.getId();
            log.info("sqlId = " + sqlId);
            // 获取节点的配置
            Configuration configuration = ms.getConfiguration();
            // 获取到最终的sql语句
            String sql = getSql(configuration, boundSql, sqlId);
            log.info("完整的sql:{}", sql);
        } catch (Exception e) {
            log.error("异常:{}", e.getLocalizedMessage(), e);
        }
    }

    // 封装了一下sql语句，使得结果返回完整xml路径下的sql语句节点id + sql语句
    public static String getSql(Configuration configuration, BoundSql boundSql, String sqlId) {
        return sqlId + ":" + showSql(configuration, boundSql);
    }

    // 进行？的替换
    public static String showSql(Configuration configuration, BoundSql boundSql) {
        // 获取参数
        Object parameterObject = boundSql.getParameterObject();
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        // sql语句中多个空格都用一个空格代替
        String sql = boundSql.getSql().replaceAll("[\\s]+", " ");
        if (!CollectionUtils.isEmpty(parameterMappings) && parameterObject != null) {
            // 获取类型处理器注册器，类型处理器的功能是进行java类型和数据库类型的转换
            TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
            // 如果根据parameterObject.getClass(）可以找到对应的类型，则替换
            if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
                sql = sql.replaceFirst("\\?",
                        Matcher.quoteReplacement(getParameterValue(parameterObject)));
            } else {
                // MetaObject主要是封装了originalObject对象，提供了get和set的方法用于获取和设置originalObject的属性值,主要支持对JavaBean、Collection、Map三种类型对象的操作
                MetaObject metaObject = configuration.newMetaObject(parameterObject);
                for (ParameterMapping parameterMapping : parameterMappings) {
                    String propertyName = parameterMapping.getProperty();
                    if (metaObject.hasGetter(propertyName)) {
                        Object obj = metaObject.getValue(propertyName);
                        sql = sql.replaceFirst("\\?",
                                Matcher.quoteReplacement(getParameterValue(obj)));
                    } else if (boundSql.hasAdditionalParameter(propertyName)) {
                        // 该分支是动态sql
                        Object obj = boundSql.getAdditionalParameter(propertyName);
                        sql = sql.replaceFirst("\\?",
                                Matcher.quoteReplacement(getParameterValue(obj)));
                    } else {
                        // 打印出缺失，提醒该参数缺失并防止错位
                        sql = sql.replaceFirst("\\?", "缺失");
                    }
                }
            }
        }
        return sql;
    }

    // 如果参数是String，则添加单引号， 如果是日期，则转换为时间格式器并加单引号； 对参数是null和不是null的情况作了处理
    private static String getParameterValue(Object obj) {
        String value;
        if (obj instanceof String) {
            value = "'" + obj.toString() + "'";
        } else if (obj instanceof Date) {
            DateFormat formatter = DateFormat.getDateTimeInstance(DateFormat.DEFAULT,
                    DateFormat.DEFAULT, Locale.CHINA);
            value = "'" + formatter.format(new Date()) + "'";
        } else {
            if (obj != null) {
                value = obj.toString();
            } else {
                value = "";
            }
        }
        return value;
    }

}

SqlStatementInterceptor

import org.apache.ibatis.cache.CacheKey;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.util.Properties;


@Intercepts({
        @Signature(type = Executor.class, method = "update", args = {MappedStatement.class,
                Object.class}),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class,
                Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class})})
@Component
public class SqlStatementInterceptor implements Interceptor {

    public static final Logger log = LoggerFactory.getLogger("vending-machine-sql");

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        long startTime = System.currentTimeMillis();
        try {
            return invocation.proceed();
        } finally {
            long timeConsuming = System.currentTimeMillis() - startTime;
            log.info("执行SQL:{}ms", timeConsuming);
            if (timeConsuming > 999 && timeConsuming < 5000) {
                log.info("执行SQL大于1s:{}ms", timeConsuming);
            } else if (timeConsuming >= 5000 && timeConsuming < 10000) {
                log.info("执行SQL大于5s:{}ms", timeConsuming);
            } else if (timeConsuming >= 10000) {
                log.info("执行SQL大于10s:{}ms", timeConsuming);
            }
        }
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {

    }
}
开发工具
        <fastjson.version>1.2.78</fastjson.version>
				<commons-lang.version>2.6</commons-lang.version>
        <commons-collections.version>3.2.2</commons-collections.version>
        <commons-io.version>2.6</commons-io.version>
        <mapstruct.version>1.4.2.Final</mapstruct.version>
				<guava.version>30.1-jre</guava.version>
        
				 <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>${guava.version}</version>
        </dependency>

        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct-processor</artifactId>
        </dependency>
使用方式：
// controller
@RestController
@Slf4j
public class SpAttributeController {
    @Autowired
    private SpAttributeService spAttributeService;

    @GetMapping("/find")
    public Result findByPage(PageParam pageParam) {
        try {
            if (log.isInfoEnabled()) {
                log.info("SpAttributeController.findByPage.pageParam:{}", JSON.toJSONString(pageParam));
            }
            Page<SpAttribute> result = PageHelper.startPage(pageParam.getPageNum(), pageParam.getPageSize());
            spAttributeService.findByPage();
            PageData<SpAttribute> pageData = new PageData<>(result.getResult(), result.getTotal());
            return Result.ok(pageData);
        } catch (Exception e) {
            log.error("SpAttributeController.findByPage.error:{}", e.getMessage(), e);
            return Result.error(500, "查询失败");
        }
    }

    @GetMapping("/findById")
    public Result findById(String attrId) {
        try {
            if (log.isInfoEnabled()) {
                log.info("SpAttributeController.findById.attrId:{}", attrId);
            }

            Preconditions.checkArgument(!StringUtils.isBlank(attrId),"attrId不能为空");

            return Result.ok("ok");
        } catch (Exception e) {
            log.error("SpAttributeController.findById.error:{}", e.getMessage(), e);
            return Result.error(500, "查询失败");
        }


    }

    @PostMapping("/add")
    public Result add(@RequestBody SpAttributeDTO spAttributeDTO) {
        try {
            if (log.isInfoEnabled()) {
                log.info("SpAttributeController.add.spAttributeDTO:{}", JSON.toJSONString(spAttributeDTO));
            }

            Preconditions.checkArgument(!StringUtils.isBlank(spAttributeDTO.getAttrName()),
                    "属性名称不能为空");
            Preconditions.checkNotNull(spAttributeDTO.getCatId(), "分类id不能为空");
            // 判断类型集合参数
            // Preconditions.checkArgument(!CollectionUtils.isEmpty(list, "分类ids不能为空");

            return Result.ok("ok");
        } catch (Exception e) {
            log.error("SpAttributeController.add.error:{}", e.getMessage(), e);
            return Result.error(500, "新增失败");
        }
        
    }
}

//service 略
bu离bu弃
关注
springboot整合log日志
weixin_47974543的博客
01-12 545
springboot整合log4j日志记录 我们在做项目的时候不可避免的需要接触到日志，通过日志我们可以获取许多重要的信息： 比如： xxx在什么时间执行了删除等操作，需要进行记录 方法的执行时长，方便我们后续进行优化 项目运行一段时间之后，可能由于数据问题，网络问题，内存问题等出现异常。这时日志可以帮助开发人员快速定位错误位置，更快的解决错误。 在大数据时代，日志可以帮我们确定用户的喜好，比如点击哪个模块、超链接最多，搜索的那个词汇最多 下面准备好一个简单的springboot项目，具
【SpringBoot详细教程】-04-整合开发日志功能【持续更新】
yueyehuguang的博客
09-25 1231
日志记录了系统行为的时间、地点等很多细节的具体信息，在发生错误或者接近某种危险状态时能够及时提醒开发人员处理，往往在系统产生问题时承担问题定位与诊断和解决的重要角色。开发阶段我们可以通过开发工具的控制台查看异常信息，但是一旦上线之后，很多问题只能通过进行日志分析才可以解决。所以日志功能在开发环节中是十分重要的。logback-core：核心代码模块。logback-classic：log4j 的一个改良版本，同时实现了 slf4j 的接口。
springboot整合log4j
sinat_37795871的博客
09-09 565
1、排除自带的logback并引入log4j  &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter&lt;/artifactId&gt; &lt;exclusions&gt;...
Logback 日志框架
最新发布
小李同学的博客
04-21 1874
Logback 作为 Spring Boot 的默认日志框架，提供了高性能、灵活的日志解决方案。（Log4j 作者）设计的高性能日志框架，专为 Java 应用提供高效、灵活的日志解决方案。Spring Boot 默认通过。结构化日志以 JSON 格式记录日志，便于后续分析。依赖集成 Logback，支持开箱即用的日志功能。
springboot整合logback日志的详细配置
_fanny_
12-24 3054
1、引入pom文件，由于springboot默认使用的就是logback日志管理，所以只要引入：spring-boot-starter-web &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation...
Spring Boot统一日志框架
敲机闯天涯
08-10 289
系列文章目录 Spring Boot统一日志框架系列文章目录前言一、日志框架的选择二、SLF4J 的使用三.统一日志框架（通用）四、统一日志框架（Spring Boot） 前言 在项目开发中，日志十分的重要，不管是记录运行情况还是定位线上问题，都离不开对日志的分析。在 Java 领域里存在着多种日志框架，如 JCL、SLF4J、Jboss-logging、jUL、log4j、log4j2、logback 等等。 一、日志框架的选择 市面上常见的日志框架有很多，它们可以被分为两类：日志门面（日志抽象层）
spring boot 整合日志
qq_39552758的博客
11-26 112
在resource文件夹下建logback.xml <?xml version="1.0" encoding="UTF-8"?> <configuration> <!--1，定义日志保存的路径--> <property name="LOG_HOME" value="E:\\xxx\\xxx_log\\xxx_log" /> <!--2，定义一个控制台输出器，名为console--> <appender nam
Java开发案例-springboot-39-整合Plumelog实现日志查询-源代码+文档.rar
05-31
Java开发案例-springboot-39-整合Plumelog实现日志查询-源代码+文档.rar Java开发案例-springboot-39-整合Plumelog实现日志查询-源代码+文档.rar Java开发案例-springboot-39-整合Plumelog实现日志查询-源代码+文档....
Java开发案例-springboot-35-整合TLog实现分布式日志标记追踪-源代码+文档.rar
05-31
Java开发案例-springboot-35-整合TLog实现分布式日志标记追踪-源代码+文档.rar Java开发案例-springboot-35-整合TLog实现分布式日志标记追踪-源代码+文档.rar Java开发案例-springboot-35-整合TLog实现分布式日志...
springboot项目查询es中的日志内容
04-21
在本项目中，我们主要探讨如何使用SpringBoot与Elasticsearch（ES）集成，以便查询存储在ES中的日志内容。Elasticsearch是一种强大的、分布式、实时的搜索和分析引擎，常用于处理大量数据，特别是在日志管理和分析...
2024.10.27- SpringBoot整合Mybatis和日志框架
whisper_Java 的博客
10-27 1210
mysql依赖。
Springboot集成日志
星
01-19 1353
什么是日志级别？ 日志级别就是用来标志信息的重要程度的 日志的级别划分：从低到高：trace<debug<info<warn<error 日志的级别除了区分信息的重要程度，还有一个特别重要的作用是调整日志信息输出的多少 SpringBoot集成logback日志 SpringBoot 项目默认已经集成了 logback日志，所以在 SpringBoot 中使用 logback 日志，不需要导jar包，也不需要导入额外的配置文件。 SpringBoot修改日志的默认配.
springboot集成日志
weixin_43183496的博客
02-08 1146
在 Spring Boot 项目中集成日志记录，可以使用常见的日志框架如 Logback 或 Log4j2。Spring Boot 默认使用的是 Logback，但你也可以根据需求选择其他框架。
springboot 整合日志
weixin_41029286的博客
06-04 316
pom文件中排除默认的log的包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> <exclusions> <exclusion> <groupId>org.springframework.boot</groupI
springboot整合日志
Hello_MAOSONG的博客
07-14 185
整合Log4j 在resources下创建log4j.properties 复制时要把每一行后面的空格去除 log4j.rootLogger=INFO,Console,File log4j.appender.Console=org.apache.log4j.ConsoleAppender log4j.appender.Console.Target=System.out log4j.app...
SpringBoot整合日志
北执南念的博客
03-07 726
SpringBoot整合日志
SpringBoot整合Graylog日志系统实战
这通常涉及到修改日志配置文件，添加GELF输出appender，并配置Graylog的IP地址和端口。此外，可能还需要配置一些额外的属性，比如日志级别和自定义字段。 总结来说，通过这篇文章，读者将学习到如何在SpringBoot...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值