<think>我们使用Spring Boot集成
MyBatis，并
配置Log4j来
打印SQL日志。这里假设使用
Log4j 1.x版本（虽然现在推荐
Log4j2，但问题中指定了
log4j）。
在Spring Boot中，通常我们使用`application.properties`或`application.yml`来
配置，但
日志配置通常需要单独的
log4j.properties文件。
注意：Spring Boot默认使用Logback，如果要使用
Log4j，需要排除Logback并引入
Log4j依赖。
步骤：
1. 添加依赖（Maven示例）
2. 创建
log4j.properties
配置文件
3.
配置MyBatis的Mapper接口的
日志级别为DEBUG（因为
SQL执行
日志是在DEBUG级别输出的）
详细步骤：
第一步：在pom.
xml中添加依赖，并排除Spring Boot默认的logging（Logback），然后引入
Log4j。
第二步：在src/main/resources目录下创建
log4j.properties文件，并
配置日志输出。
注意：
MyBatis的
日志输出是通过Mapper接口的包名或者全限定类名来控制的。通常，我们会将Mapper接口放在一个特定的包下（如com.example.mapper），然后设置这个包的
日志级别为DEBUG。
示例代码：
1. Maven依赖
配置：
```
xml
<dependencies>
<!-- Spring Boot Starter Web -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<!-- 排除默认的
日志框架 -->
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- 引入
log4j -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-
log4j</artifactId>
<version>1.3.8.RELEASE</version> <!-- 注意：Spring Boot 1.x版本有对
log4j的starter，2.x版本不再支持
log4j1，如果使用2.x请改用
log4j2 -->
</dependency>
<!--
MyBatis Spring Boot Starter -->
<dependency>
<groupId>org.
mybatis.spring.boot</groupId>
<artifactId>
mybatis-spring-boot-starter</artifactId>
<version>2.1.4</version> <!-- 请根据实际版本选择 -->
</dependency>
<!-- 其他依赖 -->
</dependencies>
```
注意：如果使用Spring Boot 2.x，官方不再提供对
log4j 1.x的支持，而是使用
log4j2。因此，如果项目必须使用
log4j 1.x，可能需要额外
配置。但这里我们按照问题要求，使用
log4j1。
但是，由于Spring Boot 2.x已经不再支持
log4j1，所以如果使用Spring Boot 2.x，建议使用
log4j2。这里我们假设使用Spring Boot 1.5.x版本。
或者，如果你使用Spring Boot 2.x，并且必须使用
log4j1，可以手动排除logback，并添加
log4j1的依赖，但需要自己解决兼容性问题。
为了简单起见，我们以Spring Boot 1.5.x为例。
2. 创建
log4j.properties文件（src/main/resources/
log4j.properties）:
```properties
# 设置根
日志级别为WARN，输出到控制台
log4j.rootLogger=WARN, stdout
# 设置
MyBatis的Mapper接口所在的包为DEBUG级别（这样才会
打印SQL）
log4j.logger.com.example.mapper=DEBUG
# 控制台输出
配置
log4j.appender.stdout=org.apache.
log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.
log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p [%t] %c{1}:%L - %m%n
# 如果需要显示
SQL语句的参数，可以
配置MyBatis的
日志实现为STDOUT_LOGGING（可选，但通常
log4j配置已经可以
打印SQL，参数需要额外设置）
# 但是注意：
MyBatis自身有
日志实现，它会使用
log4j来输出。默认情况下，
MyBatis不会
打印参数值，只会
打印带?的
SQL。
# 如果需要
打印参数，可以
配置log4j.logger.java.
sql.PreparedStatement=DEBUG（但这样会
打印所有PreparedStatement，可能过多）
# 或者使用
MyBatis的插件如p6spy，这里不展开。
# 如果希望看到
SQL语句中的参数值，可以设置：
log4j.logger.java.
sql.Connection=DEBUG
log4j.logger.java.
sql.Statement=DEBUG
log4j.logger.java.
sql.PreparedStatement=DEBUG
log4j.logger.java.
sql.ResultSet=DEBUG
```
注意：将`com.example.mapper`替换为你的Mapper接口所在的包。
3. 在application.properties中指定
MyBatis配置（可选）：
```properties
# 指定
MyBatis的Mapper文件位置
mybatis.mapper-locations=classpath:mapper/*.
xml
#
配置MyBatis的
日志实现（如果使用
log4j，可以不用
配置，
MyBatis会自动使用
log4j）
mybatis.configuration.log-impl=org.apache.ibatis.logging.
log4j.
Log4jImpl
```
但是，在Spring Boot中，
MyBatis会自动检测
日志实现，所以通常不需要
配置`log-impl`。
4. 如果使用Spring Boot 2.x，并且想使用
log4j2，那么依赖
配置如下：
```
xml
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<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-
log4j2</artifactId>
</dependency>
<!--
MyBatis依赖 -->
</dependencies>
```
然后使用
log4j2.
xml配置文件。但问题要求
log4j，所以这里不展开
log4j2。
由于问题指定了
log4j，我们按照
log4j1的
配置。
但是，请注意：Spring Boot 2.x已经不支持
log4j1，如果使用Spring Boot 2.x，建议迁移到
log4j2。如果坚持使用
log4j1，需要手动添加
log4j1的依赖并排除其他
日志框架，但可能会遇到兼容性问题。
因此，以下是一个折中方案：使用
log4j-over-slf4j将
log4j的
日志输出重定向到SLF4J，然后由SLF4J输出到logback（或其他）。但这样就不能使用
log4j.properties
配置了。
考虑到问题要求，我们给出Spring Boot 1.5.x +
log4j1的
配置。
如果使用Spring Boot 2.x，并且必须使用
log4j1，可以尝试以下依赖
配置（但不推荐）：
```
xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-
log4j12</artifactId>
<version>1.7.30</version>
</dependency>
```
然后
配置log4j.properties。
总结：在Spring Boot 1.5.x中，使用
log4j1
配置MyBatis打印SQL日志的步骤如上。
但是，更常见的做法是使用logback或
log4j2。因此，如果条件允许，建议升级到
log4j2。
最后，我们给出一个在Spring Boot 2.x中使用
log4j2的
配置示例（供参考，因为问题要求
log4j，但考虑到实际，提供备选）：
log4j2.
xml配置（
打印SQL）:
```
xml
<?
xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
<Appenders>
<Console name="Console" target="SYSTEM_OUT">
<PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
</Console>
</Appenders>
<Loggers>
<!-- 设置
MyBatis接口的包为DEBUG级别 -->
<Logger name="com.example.mapper" level="DEBUG" additivity="false">
<AppenderRef ref="Console"/>
</Logger>
<Root level="warn">
<AppenderRef ref="Console" />
</Root>
</Loggers>
</Configuration>
```
由于问题要求
log4j（即
log4j1），所以主要提供
log4j1的
配置。
如果
配置后仍然不
打印SQL，请检查：
1. 包名是否正确
2.
日志级别是否足够（DEBUG）
3. 是否还有其他
日志框架干扰
希望以上内容能帮助解决问题。
§§相关问题§§:
1. 在Spring Boot中如何
配置log4j2来
打印MyBatis的
SQL日志？
2. 如何让
MyBatis在
日志中
打印SQL语句的参数值（而不是带?的语句）？
3. 在Spring Boot 2.x中如何排除默认的Logback并改用
log4j2？
4. 如何将
MyBatis的
SQL日志输出到单独的文件？</think># Spring Boot +
MyBatis +
Log4j 配置 SQL 日志打印
在 Spring Boot 项目中整合
MyBatis 和
Log4j 来
打印 SQL 日志，需要
配置 MyBatis 的
日志实现和
Log4j 的
日志级别。以下是完整的
配置方案：
## 完整
配置步骤
### 1. 添加 Maven 依赖 (`pom.
xml`)
```
xml
<dependencies>
<!-- Spring Boot Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--
MyBatis Spring Boot Starter -->
<dependency>
<groupId>org.
mybatis.spring.boot</groupId>
<artifactId>
mybatis-spring-boot-starter</artifactId>
<version>2.2.2</version>
</dependency>
<!--
Log4j 依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-
log4j</artifactId>
<version>1.3.8.RELEASE</version> <!-- 适配 Spring Boot 2.x -->
</dependency>
<!-- 数据库驱动 (以 My
SQL 为例) -->
<dependency>
<groupId>my
sql</groupId>
<artifactId>my
sql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>
```
### 2.
配置 `
log4j.properties` (核心
配置)
在 `src/main/resources` 目录下创建 `
log4j.properties` 文件：
```properties
# 设置根
日志级别为 WARN
log4j.rootLogger=WARN, stdout
# 控制台输出
配置
log4j.appender.stdout=org.apache.
log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.
log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p [%t] %c{1}:%L - %m%n
#
配置 MyBatis SQL 日志输出
# 1.
打印执行的
SQL 语句
log4j.logger.java.
sql.Connection=DEBUG
log4j.logger.java.
sql.Statement=DEBUG
log4j.logger.java.
sql.PreparedStatement=DEBUG
log4j.logger.java.
sql.ResultSet=DEBUG
# 2.
打印 MyBatis Mapper 接口的
SQL (推荐方式)
log4j.logger.com.example.mapper=TRACE
# 3.
打印 MyBatis 操作
日志
log4j.logger.org.
mybatis=DEBUG
log4j.logger.org.apache.ibatis=TRACE
# 4.
打印 JDBC 事务
日志
log4j.logger.org.springframework.jdbc.datasource.DataSourceTransactionManager=DEBUG
# 5.
打印 SQL 参数值 (需要额外
配置)
log4j.logger.jdbc.
sqlonly=DEBUG
log4j.logger.jdbc.
sqltiming=INFO
```
### 3.
配置 `application.properties`
```properties
# 数据源
配置
spring.datasource.url=jdbc:my
sql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.my
sql.cj.jdbc.Driver
#
MyBatis 配置
# 指定
MyBatis 使用
Log4j 作为
日志实现
mybatis.configuration.log-impl=org.apache.ibatis.logging.
log4j.
Log4jImpl
# 指定 Mapper 文件位置
mybatis.mapper-locations=classpath:mapper/*.
xml
```
### 4. 创建 Mapper 接口和
XML
`src/main/java/com/example/mapper/UserMapper.java`:
```java
package com.example.mapper;
import com.example.model.User;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
@Mapper
public interface UserMapper {
List<User> findAllUsers();
User findUserById(Long id);
void insertUser(User user);
}
```
`src/main/resources/mapper/UserMapper.
xml`:
```
xml
<?
xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//
mybatis.org//DTD Mapper 3.0//EN"
"http://
mybatis.org/dtd/
mybatis-3-mapper.dtd">
<mapper namespace="com.example.mapper.UserMapper">
<select id="findAllUsers" resultType="com.example.model.User">
SELECT * FROM users
</select>
<select id="findUserById" resultType="com.example.model.User">
SELECT * FROM users WHERE id = #{id}
</select>
<insert id="insertUser" parameterType="com.example.model.User">
INSERT INTO users (name, email)
VALUES (#{name}, #{email})
</insert>
</mapper>
```
### 5. 创建 Service 和 Controller
`src/main/java/com/example/service/UserService.java`:
```java
package com.example.service;
import com.example.mapper.UserMapper;
import com.example.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class UserService {
@Autowired
private UserMapper userMapper;
public List<User> getAllUsers() {
return userMapper.findAllUsers();
}
public User getUserById(Long id) {
return userMapper.findUserById(id);
}
public void createUser(User user) {
userMapper.insertUser(user);
}
}
```
`src/main/java/com/example/controller/UserController.java`:
```java
package com.example.controller;
import com.example.model.User;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/users")
public class UserController {
@Autowired
private UserService userService;
@GetMapping
public List<User> getAllUsers() {
return userService.getAllUsers();
}
@GetMapping("/{id}")
public User getUserById(@PathVariable Long id) {
return userService.getUserById(id);
}
@PostMapping
public void createUser(@RequestBody User user) {
userService.createUser(user);
}
}
```
##
日志输出详解
### 1.
SQL 语句输出示例
```
DEBUG [http-nio-8080-exec-1] java.
sql.PreparedStatement: - ==> Preparing: SELECT * FROM users WHERE id = ?
DEBUG [http-nio-8080-exec-1] java.
sql.PreparedStatement: - ==> Parameters: 1(Long)
```
### 2. 完整
SQL 日志输出（带参数值）
如果需要显示完整的
SQL 语句（包含实际参数值），添加以下
配置：
```properties
# 在
log4j.properties 中添加
log4j.logger.jdbc.
sqlonly=DEBUG
log4j.logger.jdbc.
sqltiming=INFO
```
然后在代码中注册 JDBC
日志拦截器：
`src/main/java/com/example/config/JdbcLogConfig.java`:
```java
package com.example.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import net.sf.
log4jdbc.
Log4jdbcProxyDataSource;
import net.sf.
log4jdbc.tools.
Log4JdbcCustomFormatter;
import net.sf.
log4jdbc.tools.LoggingType;
import javax.
sql.DataSource;
@Configuration
public class JdbcLogConfig {
@Bean
public DataSource dataSource(DataSource originalDataSource) {
Log4jdbcProxyDataSource proxyDataSource = new
Log4jdbcProxyDataSource(originalDataSource);
Log4JdbcCustomFormatter formatter = new
Log4JdbcCustomFormatter();
formatter.setLoggingType(LoggingType.MULTI_LINE);
formatter.set
SqlPrefix("
SQL:::");
proxyDataSource.setLogFormatter(formatter);
return proxyDataSource;
}
}
```
添加依赖：
```
xml
<dependency>
<groupId>org.lazyluke</groupId>
<artifactId>
log4jdbc-remix</artifactId>
<version>0.2.7</version>
</dependency>
```
输出示例：
```
SQL::: SELECT * FROM users WHERE id = 1
```
## 常见问题解决
### 1.
SQL 日志不显示
- 检查 `
log4j.properties` 中包路径是否正确
- 确认 `
mybatis.configuration.log-impl=org.apache.ibatis.logging.
log4j.
Log4jImpl`
- 检查
日志级别是否设置为 TRACE 或 DEBUG
### 2.
日志过多问题
```properties
# 只
打印 SQL 不
打印结果集
log4j.logger.java.
sql.ResultSet=ERROR
# 只
打印 SQL 执行时间超过 100ms 的语句
log4j.logger.jdbc.
sqltiming=WARN
log4j.logger.jdbc.
sqltiming.threshold=100
```
### 3.
日志输出到文件
```properties
log4j.appender.file=org.apache.
log4j.RollingFileAppender
log4j.appender.file.File=logs/
sql.log
log4j.appender.file.MaxFileSize=10MB
log4j.appender.file.MaxBackupIndex=10
log4j.appender.file.layout=org.apache.
log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
# 将
SQL 日志单独输出到文件
log4j.logger.com.example.mapper=TRACE, file
```
## 最佳实践建议
1. **环境区分**：开发环境使用 TRACE，生产环境使用 DEBUG
2. **敏感信息**：避免在
日志中
打印密码等敏感数据
3. **
日志轮转**：
配置日志文件大小限制和备份策略
4. **性能监控**：使用 `jdbc.
sqltiming` 监控慢
SQL
5. **异步
日志**：在高并发场景下使用异步
日志记录器
本文详细介绍了如何通过Maven引入log4jdbc-log4j2依赖来实现MyBatis打印SQL日志功能，包括配置log4j.properties文件、调整rootLogger级别以确保控制台输出详细SQL语句，以及定制化日志输出以精简不必要的信息。通过配置，开发者可以方便地调试SQL执行过程，同时控制不同日志组件的输出级别。
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
