Spring MVC应用中SQL语句输出的完整指南从配置到实现助你轻松调试数据库操作

威震华夏关云长

引言：为什么需要输出SQL语句进行调试

在Spring MVC应用开发过程中，数据库操作是一个核心环节。当应用出现性能问题或数据操作异常时，能够清晰地查看实际执行的SQL语句对于问题诊断至关重要。通过输出SQL语句，开发者可以：

• 验证生成的SQL是否符合预期
• 检查参数绑定是否正确
• 分析SQL执行效率
• 快速定位数据操作错误

然而，Spring MVC应用默认情况下并不会直接输出执行的SQL语句，需要我们进行相应的配置才能实现。本文将详细介绍在Spring MVC应用中如何配置和实现SQL语句的输出，帮助开发者轻松调试数据库操作。

基础准备：了解Spring MVC中的数据访问层

在深入配置SQL输出之前，我们需要先了解Spring MVC应用中常见的数据访问技术：

1. JDBC (Java Database Connectivity)：Java中最基础的数据库访问方式
2. Hibernate：一个流行的ORM(对象关系映射)框架
3. JPA (Java Persistence API)：Java持久化API标准
4. Spring Data JPA：Spring基于JPA的数据访问抽象层
5. MyBatis：另一个流行的持久层框架，更注重SQL控制

不同的数据访问技术，配置SQL输出的方式也有所不同。接下来，我们将逐一介绍各种技术栈下如何配置SQL输出。

通过日志框架配置SQL输出

日志框架是输出SQL语句最常用的方式，它不仅可以输出SQL语句，还能输出参数、执行时间等详细信息。常见的日志框架有Logback、Log4j2等。

使用Logback配置SQL输出

Logback是Spring Boot默认的日志框架，配置简单且功能强大。以下是通过Logback配置SQL输出的方法：

1. 首先，在src/main/resources目录下创建logback-spring.xml文件：

2. <?xml version="1.0" encoding="UTF-8"?>
3. <configuration>
4.     <!-- 定义日志输出格式 -->
5.     <property name="LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"/>
6.    
7.     <!-- 控制台输出 -->
8.     <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
9.         <encoder>
10.             <pattern>${LOG_PATTERN}</pattern>
11.         </encoder>
12.     </appender>
13.    
14.     <!-- 文件输出 -->
15.     <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
16.         <file>logs/application.log</file>
17.         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
18.             <fileNamePattern>logs/application.%d{yyyy-MM-dd}.log</fileNamePattern>
19.             <maxHistory>30</maxHistory>
20.         </rollingPolicy>
21.         <encoder>
22.             <pattern>${LOG_PATTERN}</pattern>
23.         </encoder>
24.     </appender>
25.    
26.     <!-- Hibernate SQL输出配置 -->
27.     <logger name="org.hibernate.SQL" level="DEBUG" additivity="false">
28.         <appender-ref ref="CONSOLE"/>
29.         <appender-ref ref="FILE"/>
30.     </logger>
31.    
32.     <!-- Hibernate SQL参数输出配置 -->
33.     <logger name="org.hibernate.type.descriptor.sql.BasicBinder" level="TRACE" additivity="false">
34.         <appender-ref ref="CONSOLE"/>
35.         <appender-ref ref="FILE"/>
36.     </logger>
37.    
38.     <!-- Spring Data JPA Repository输出配置 -->
39.     <logger name="org.springframework.data" level="DEBUG" additivity="false">
40.         <appender-ref ref="CONSOLE"/>
41.         <appender-ref ref="FILE"/>
42.     </logger>
43.    
44.     <!-- MyBatis SQL输出配置 -->
45.     <logger name="com.yourpackage.mapper" level="DEBUG" additivity="false">
46.         <appender-ref ref="CONSOLE"/>
47.         <appender-ref ref="FILE"/>
48.     </logger>
49.    
50.     <!-- 根日志级别 -->
51.     <root level="INFO">
52.         <appender-ref ref="CONSOLE"/>
53.         <appender-ref ref="FILE"/>
54.     </root>
55. </configuration>

复制代码

1. 在application.properties或application.yml中配置日志级别：

2. # application.properties
3. logging.level.org.hibernate.SQL=DEBUG
4. logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE
5. logging.level.org.springframework.data=DEBUG
6. logging.level.com.yourpackage.mapper=DEBUG

复制代码

或者使用YAML格式：

2. # application.yml
3. logging:
4.   level:
5.     org.hibernate.SQL: DEBUG
6.     org.hibernate.type.descriptor.sql.BasicBinder: TRACE
7.     org.springframework.data: DEBUG
8.     com.yourpackage.mapper: DEBUG

复制代码

使用Log4j2配置SQL输出

Log4j2是另一个强大的日志框架，性能优异。以下是通过Log4j2配置SQL输出的方法：

1. 首先，添加Log4j2依赖（如果使用Spring Boot，需要排除默认的Logback）：

2. <!-- pom.xml -->
3. <dependency>
4.     <groupId>org.springframework.boot</groupId>
5.     <artifactId>spring-boot-starter-web</artifactId>
6.     <exclusions>
7.         <exclusion>
8.             <groupId>org.springframework.boot</groupId>
9.             <artifactId>spring-boot-starter-logging</artifactId>
10.         </exclusion>
11.     </exclusions>
12. </dependency>
13. <dependency>
14.     <groupId>org.springframework.boot</groupId>
15.     <artifactId>spring-boot-starter-log4j2</artifactId>
16. </dependency>

复制代码

1. 在src/main/resources目录下创建log4j2-spring.xml文件：

2. <?xml version="1.0" encoding="UTF-8"?>
3. <Configuration status="WARN">
4.     <Properties>
5.         <Property name="LOG_PATTERN">%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</Property>
6.     </Properties>
7.    
8.     <Appenders>
9.         <Console name="Console" target="SYSTEM_OUT">
10.             <PatternLayout pattern="${LOG_PATTERN}"/>
11.         </Console>
12.         
13.         <RollingFile name="File" fileName="logs/application.log"
14.                      filePattern="logs/application-%d{yyyy-MM-dd}-%i.log">
15.             <PatternLayout pattern="${LOG_PATTERN}"/>
16.             <Policies>
17.                 <TimeBasedTriggeringPolicy/>
18.                 <SizeBasedTriggeringPolicy size="10 MB"/>
19.             </Policies>
20.             <DefaultRolloverStrategy max="10"/>
21.         </RollingFile>
22.     </Appenders>
23.    
24.     <Loggers>
25.         <!-- Hibernate SQL输出配置 -->
26.         <Logger name="org.hibernate.SQL" level="DEBUG" additivity="false">
27.             <AppenderRef ref="Console"/>
28.             <AppenderRef ref="File"/>
29.         </Logger>
30.         
31.         <!-- Hibernate SQL参数输出配置 -->
32.         <Logger name="org.hibernate.type.descriptor.sql.BasicBinder" level="TRACE" additivity="false">
33.             <AppenderRef ref="Console"/>
34.             <AppenderRef ref="File"/>
35.         </Logger>
36.         
37.         <!-- Spring Data JPA Repository输出配置 -->
38.         <Logger name="org.springframework.data" level="DEBUG" additivity="false">
39.             <AppenderRef ref="Console"/>
40.             <AppenderRef ref="File"/>
41.         </Logger>
42.         
43.         <!-- MyBatis SQL输出配置 -->
44.         <Logger name="com.yourpackage.mapper" level="DEBUG" additivity="false">
45.             <AppenderRef ref="Console"/>
46.             <AppenderRef ref="File"/>
47.         </Logger>
48.         
49.         <Root level="INFO">
50.             <AppenderRef ref="Console"/>
51.             <AppenderRef ref="File"/>
52.         </Root>
53.     </Loggers>
54. </Configuration>

复制代码

通过Hibernate/JPA配置SQL输出

Hibernate是最常用的JPA实现之一，提供了多种方式来配置SQL输出。

在application.properties/yml中配置

最简单的方式是在Spring Boot的配置文件中直接配置Hibernate属性：

2. # application.properties
3. # 显示SQL语句
4. spring.jpa.show-sql=true
5. # 格式化SQL语句
6. spring.jpa.properties.hibernate.format_sql=true
7. # 显示SQL注释
8. spring.jpa.properties.hibernate.use_sql_comments=true
9. # 显示统计信息
10. spring.jpa.properties.hibernate.generate_statistics=true

复制代码

或者使用YAML格式：

2. # application.yml
3. spring:
4.   jpa:
5.     show-sql: true
6.     properties:
7.       hibernate:
8.         format_sql: true
9.         use_sql_comments: true
10.         generate_statistics: true

复制代码

通过编程方式配置

如果你更喜欢通过Java代码进行配置，可以创建一个配置类：

2. import org.hibernate.SessionFactory;
3. import org.springframework.beans.factory.annotation.Autowired;
4. import org.springframework.context.annotation.Bean;
5. import org.springframework.context.annotation.Configuration;
6. import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
7. import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
9. import javax.sql.DataSource;
10. import java.util.Properties;
12. @Configuration
13. public class HibernateConfig {
15.     @Autowired
16.     private DataSource dataSource;
18.     @Bean
19.     public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
20.         LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
21.         em.setDataSource(dataSource);
22.         em.setPackagesToScan("com.yourpackage.model");
24.         HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
25.         em.setJpaVendorAdapter(vendorAdapter);
27.         Properties properties = new Properties();
28.         // 显示SQL语句
29.         properties.setProperty("hibernate.show_sql", "true");
30.         // 格式化SQL语句
31.         properties.setProperty("hibernate.format_sql", "true");
32.         // 显示SQL注释
33.         properties.setProperty("hibernate.use_sql_comments", "true");
34.         // 显示统计信息
35.         properties.setProperty("hibernate.generate_statistics", "true");
36.         
37.         em.setJpaProperties(properties);
39.         return em;
40.     }
41. }

复制代码

使用Hibernate拦截器/监听器输出SQL

Hibernate提供了拦截器(Interceptor)和事件监听器(EventListener)机制，我们可以利用这些机制来输出更详细的SQL信息：

2. import org.hibernate.EmptyInterceptor;
3. import org.hibernate.type.Type;
4. import java.io.Serializable;
5. import java.util.Iterator;
7. public class SqlOutputInterceptor extends EmptyInterceptor {
9.     @Override
10.     public String onPrepareStatement(String sql) {
11.         System.out.println("Hibernate SQL: " + sql);
12.         return super.onPrepareStatement(sql);
13.     }
15.     @Override
16.     public void beforeTransactionCompletion(Transaction tx) {
17.         System.out.println("Transaction about to complete");
18.     }
19. }

复制代码

然后配置Hibernate使用这个拦截器：

2. @Bean
3. public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
4.     LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
5.     // ... 其他配置
6.    
7.     Properties properties = new Properties();
8.     properties.setProperty("hibernate.ejb.interceptor", "com.yourpackage.interceptor.SqlOutputInterceptor");
9.    
10.     em.setJpaProperties(properties);
11.     return em;
12. }

复制代码

通过MyBatis配置SQL输出

MyBatis是另一个流行的持久层框架，它提供了灵活的方式来控制SQL输出。

在MyBatis配置文件中设置

在MyBatis的配置文件mybatis-config.xml中，可以设置settings来控制SQL输出：

2. <?xml version="1.0" encoding="UTF-8"?>
3. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
4. <configuration>
5.     <settings>
6.         <!-- 打印查询语句 -->
7.         <setting name="logImpl" value="STDOUT_LOGGING"/>
8.         <!-- 其他设置 -->
9.         <setting name="cacheEnabled" value="true"/>
10.         <setting name="lazyLoadingEnabled" value="true"/>
11.         <setting name="multipleResultSetsEnabled" value="true"/>
12.         <setting name="useColumnLabel" value="true"/>
13.         <setting name="useGeneratedKeys" value="false"/>
14.         <setting name="defaultExecutorType" value="SIMPLE"/>
15.         <setting name="defaultStatementTimeout" value="25000"/>
16.     </settings>
17. </configuration>

复制代码

通过Spring Boot配置文件设置

如果你使用的是Spring Boot与MyBatis的集成，可以在application.properties或application.yml中配置：

2. # application.properties
3. # MyBatis SQL输出配置
4. mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

复制代码

或者使用YAML格式：

2. # application.yml
3. mybatis:
4.   configuration:
5.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

复制代码

使用MyBatis拦截器输出SQL

MyBatis提供了拦截器(Interceptor)机制，我们可以利用它来实现更复杂的SQL输出功能：

2. import org.apache.ibatis.executor.Executor;
3. import org.apache.ibatis.mapping.BoundSql;
4. import org.apache.ibatis.mapping.MappedStatement;
5. import org.apache.ibatis.mapping.ParameterMapping;
6. import org.apache.ibatis.plugin.*;
7. import org.apache.ibatis.session.ResultHandler;
8. import org.apache.ibatis.session.RowBounds;
10. import java.text.SimpleDateFormat;
11. import java.util.Date;
12. import java.util.List;
13. import java.util.Properties;
15. @Intercepts({
16.     @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),
17.     @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
18. })
19. public class SqlOutputInterceptor implements Interceptor {
21.     @Override
22.     public Object intercept(Invocation invocation) throws Throwable {
23.         MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
24.         Object parameter = invocation.getArgs()[1];
25.         
26.         BoundSql boundSql = mappedStatement.getBoundSql(parameter);
27.         String sql = boundSql.getSql();
28.         List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
29.         
30.         // 格式化SQL输出
31.         String formattedSql = formatSql(sql, parameter, parameterMappings);
32.         
33.         // 输出SQL
34.         System.out.println("=============================================");
35.         System.out.println("Time: " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date()));
36.         System.out.println("SQL ID: " + mappedStatement.getId());
37.         System.out.println("SQL: " + formattedSql);
38.         System.out.println("=============================================");
39.         
40.         // 执行原方法
41.         Object result = invocation.proceed();
42.         
43.         return result;
44.     }
46.     private String formatSql(String sql, Object parameter, List<ParameterMapping> parameterMappings) {
47.         // 这里可以实现SQL格式化逻辑
48.         // 简单示例：直接返回原SQL
49.         return sql;
50.     }
52.     @Override
53.     public Object plugin(Object target) {
54.         return Plugin.wrap(target, this);
55.     }
57.     @Override
58.     public void setProperties(Properties properties) {
59.         // 可以读取配置的属性
60.     }
61. }

复制代码

然后，在MyBatis配置中注册这个拦截器：

2. import org.apache.ibatis.session.SqlSessionFactory;
3. import org.mybatis.spring.SqlSessionFactoryBean;
4. import org.springframework.context.annotation.Bean;
5. import org.springframework.context.annotation.Configuration;
7. import javax.sql.DataSource;
9. @Configuration
10. public class MyBatisConfig {
12.     @Bean
13.     public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
14.         SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
15.         sessionFactory.setDataSource(dataSource);
16.         
17.         // 注册拦截器
18.         SqlOutputInterceptor sqlOutputInterceptor = new SqlOutputInterceptor();
19.         sessionFactory.setPlugins(sqlOutputInterceptor);
20.         
21.         return sessionFactory.getObject();
22.     }
23. }

复制代码

通过Spring Data JPA配置SQL输出

Spring Data JPA是Spring基于JPA的数据访问抽象层，它简化了数据访问操作。配置Spring Data JPA的SQL输出主要依赖于底层JPA实现（如Hibernate）的配置。

基本配置

2. # application.properties
3. # 显示SQL语句
4. spring.jpa.show-sql=true
5. # 格式化SQL语句
6. spring.jpa.properties.hibernate.format_sql=true
7. # 显示SQL注释
8. spring.jpa.properties.hibernate.use_sql_comments=true
9. # 显示统计信息
10. spring.jpa.properties.hibernate.generate_statistics=true

复制代码

使用Repository接口方法输出SQL

Spring Data JPA允许我们通过Repository接口定义查询方法，我们可以通过自定义Repository实现来输出SQL：

2. import org.springframework.data.jpa.repository.JpaRepository;
3. import org.springframework.data.jpa.repository.Query;
4. import org.springframework.data.repository.query.Param;
6. public interface UserRepository extends JpaRepository<User, Long>, UserRepositoryCustom {
8.     @Query("SELECT u FROM User u WHERE u.username = :username")
9.     User findByUsername(@Param("username") String username);
10. }
12. public interface UserRepositoryCustom {
13.     User customFindById(Long id);
14. }
16. public class UserRepositoryImpl implements UserRepositoryCustom {
18.     @PersistenceContext
19.     private EntityManager entityManager;
21.     @Override
22.     public User customFindById(Long id) {
23.         // 使用EntityManager创建查询
24.         TypedQuery<User> query = entityManager.createQuery("SELECT u FROM User u WHERE u.id = :id", User.class);
25.         query.setParameter("id", id);
26.         
27.         // 输出SQL
28.         System.out.println("Executing custom query: " + query.unwrap(org.hibernate.Query.class).getQueryString());
29.         
30.         return query.getSingleResult();
31.     }
32. }

复制代码

使用JPA EntityListener输出SQL

JPA提供了实体监听器(EntityListener)机制，我们可以利用它来监控实体的生命周期事件：

2. import javax.persistence.*;
4. public class EntityListener {
6.     @PrePersist
7.     public void prePersist(Object entity) {
8.         System.out.println("About to persist: " + entity);
9.     }
11.     @PostPersist
12.     public void postPersist(Object entity) {
13.         System.out.println("Persisted: " + entity);
14.     }
16.     @PreUpdate
17.     public void preUpdate(Object entity) {
18.         System.out.println("About to update: " + entity);
19.     }
21.     @PostUpdate
22.     public void postUpdate(Object entity) {
23.         System.out.println("Updated: " + entity);
24.     }
26.     @PreRemove
27.     public void preRemove(Object entity) {
28.         System.out.println("About to remove: " + entity);
29.     }
31.     @PostRemove
32.     public void postRemove(Object entity) {
33.         System.out.println("Removed: " + entity);
34.     }
35. }
37. @Entity
38. @EntityListeners(EntityListener.class)
39. @Table(name = "users")
40. public class User {
41.     @Id
42.     @GeneratedValue(strategy = GenerationType.IDENTITY)
43.     private Long id;
44.    
45.     @Column(name = "username")
46.     private String username;
47.    
48.     @Column(name = "email")
49.     private String email;
50.    
51.     // getters and setters
52. }

复制代码

格式化和美化输出的SQL语句

原始的SQL输出通常是一行字符串，难以阅读。我们可以通过一些工具和技术来格式化和美化SQL输出。

使用Hibernate内置格式化功能

Hibernate提供了内置的SQL格式化功能：

2. # application.properties
3. spring.jpa.properties.hibernate.format_sql=true

复制代码

这将使Hibernate输出格式化的SQL，例如：

2. SELECT
3.     user0_.id AS id1_0_,
4.     user0_.email AS email2_0_,
5.     user0_.username AS username3_0_
6. FROM
7.     users user0_
8. WHERE
9.     user0_.username=?

复制代码

使用P6Spy格式化SQL

P6Spy是一个JDBC驱动包装器，可以拦截和记录数据库操作。以下是使用P6Spy格式化SQL的步骤：

1. 添加P6Spy依赖：

2. <!-- pom.xml -->
3. <dependency>
4.     <groupId>p6spy</groupId>
5.     <artifactId>p6spy</artifactId>
6.     <version>3.9.1</version>
7. </dependency>

复制代码

1. 配置P6Spy：

在src/main/resources目录下创建spy.properties文件：

2. # P6Spy配置文件
3. modulelist=com.p6spy.engine.logging.P6LogFactory,com.p6spy.engine.outage.P6OutageFactory
4. # 自定义日志格式
5. logMessageFormat=com.p6spy.engine.spy.appender.MultiLineFormat
6. # 使用自定义的日志记录器
7. appender=com.p6spy.engine.spy.appender.StdoutLogger
8. # 是否记录JDBC操作
9. deregisterdrivers=true

复制代码

1. 修改数据源配置：

2. # application.properties
3. # 将原来的JDBC URL改为P6Spy格式
4. spring.datasource.url=jdbc:p6spy:mysql://localhost:3306/your_database
5. spring.datasource.username=your_username
6. spring.datasource.password=your_password
7. spring.datasource.driver-class-name=com.p6spy.engine.spy.P6SpyDriver

复制代码

自定义SQL格式化工具

你也可以创建自己的SQL格式化工具：

2. import org.apache.commons.lang3.StringUtils;
3. import org.hibernate.engine.spi.QueryParameters;
4. import org.hibernate.engine.spi.SessionImplementor;
5. import org.hibernate.loader.custom.CustomLoader;
6. import org.hibernate.loader.custom.SQLQueryReturn;
7. import org.hibernate.persister.collection.SQLLoadableCollection;
8. import org.hibernate.persister.entity.SQLLoadable;
10. import java.util.List;
12. public class SqlFormatter {
14.     public static String formatSql(String sql, Object[] parameters) {
15.         // 简单的SQL格式化实现
16.         if (StringUtils.isBlank(sql)) {
17.             return "";
18.         }
20.         // 添加换行和缩进
21.         String formattedSql = sql.replaceAll("(?i)\\bSELECT\\b", "\nSELECT")
22.                 .replaceAll("(?i)\\bFROM\\b", "\nFROM")
23.                 .replaceAll("(?i)\\bWHERE\\b", "\nWHERE")
24.                 .replaceAll("(?i)\\bGROUP BY\\b", "\nGROUP BY")
25.                 .replaceAll("(?i)\\bORDER BY\\b", "\nORDER BY")
26.                 .replaceAll("(?i)\\bHAVING\\b", "\nHAVING")
27.                 .replaceAll("(?i)\\bAND\\b", "\n    AND")
28.                 .replaceAll("(?i)\\bOR\\b", "\n    OR");
30.         // 替换参数占位符
31.         if (parameters != null && parameters.length > 0) {
32.             for (Object param : parameters) {
33.                 String paramStr = param != null ? param.toString() : "NULL";
34.                 formattedSql = formattedSql.replaceFirst("\\?", "'" + paramStr + "'");
35.             }
36.         }
38.         return formattedSql;
39.     }
40. }

复制代码

然后，在拦截器或监听器中使用这个格式化工具：

2. @Override
3. public String onPrepareStatement(String sql) {
4.     // 获取参数（这里需要根据实际情况获取）
5.     Object[] parameters = getParameters();
6.    
7.     // 格式化SQL
8.     String formattedSql = SqlFormatter.formatSql(sql, parameters);
9.    
10.     System.out.println("Formatted SQL:\n" + formattedSql);
11.     return sql;
12. }

复制代码

SQL输出中常见问题及解决方案

在配置SQL输出过程中，可能会遇到一些常见问题。下面列出了一些问题及其解决方案。

问题1：SQL语句没有输出

可能原因：

• 日志级别设置不正确
• 配置文件位置或名称不正确
• 没有正确加载配置文件

解决方案：

1. 检查日志级别设置是否正确，确保相关包的日志级别设置为DEBUG或TRACE：

2. logging.level.org.hibernate.SQL=DEBUG
3. logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE

复制代码

1. 确认配置文件位置和名称是否正确：Logback配置文件应位于src/main/resources/logback-spring.xmlLog4j2配置文件应位于src/main/resources/log4j2-spring.xmlMyBatis配置文件应位于src/main/resources/mybatis-config.xml
2. Logback配置文件应位于src/main/resources/logback-spring.xml
3. Log4j2配置文件应位于src/main/resources/log4j2-spring.xml
4. MyBatis配置文件应位于src/main/resources/mybatis-config.xml
5. 确保配置文件被正确加载，可以在应用启动时检查日志输出。

确认配置文件位置和名称是否正确：

• Logback配置文件应位于src/main/resources/logback-spring.xml
• Log4j2配置文件应位于src/main/resources/log4j2-spring.xml
• MyBatis配置文件应位于src/main/resources/mybatis-config.xml

确保配置文件被正确加载，可以在应用启动时检查日志输出。

问题2：SQL语句输出但参数值显示为”?”

可能原因：

• 没有配置参数输出
• 参数日志级别设置不正确

解决方案：

1. 确保参数输出配置正确：

2. # Hibernate参数输出
3. logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE
5. # MyBatis参数输出
6. mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

复制代码

1. 使用P6Spy或其他工具来显示参数值：

2. # spy.properties
3. logMessageFormat=com.p6spy.engine.spy.appender.MultiLineFormat
4. appender=com.p6spy.engine.spy.appender.StdoutLogger

复制代码

问题3：SQL语句输出太多，影响性能

可能原因：

• 生产环境开启了SQL输出
• 日志级别设置过低

解决方案：

1. 在生产环境中关闭SQL输出或提高日志级别：

2. # 生产环境配置
3. spring.jpa.show-sql=false
4. logging.level.org.hibernate.SQL=INFO

复制代码

1. 使用Spring Profile来区分开发和生产环境：

2. # application-dev.properties
3. spring.jpa.show-sql=true
4. logging.level.org.hibernate.SQL=DEBUG
6. # application-prod.properties
7. spring.jpa.show-sql=false
8. logging.level.org.hibernate.SQL=INFO

复制代码

1. 使用条件化配置：

2. @Bean
3. @Profile("dev")
4. public DataSource dataSource() {
5.     // 开发环境数据源配置
6. }
8. @Bean
9. @Profile("prod")
10. public DataSource dataSource() {
11.     // 生产环境数据源配置
12. }

复制代码

问题4：SQL语句格式不美观，难以阅读

可能原因：

• 没有启用SQL格式化
• 使用了默认的简单格式化器

解决方案：

1. 启用Hibernate的SQL格式化：

2. spring.jpa.properties.hibernate.format_sql=true

复制代码

1. 使用P6Spy或其他格式化工具：

2. # spy.properties
3. logMessageFormat=com.p6spy.engine.spy.appender.MultiLineFormat

复制代码

1. 自定义SQL格式化器：

2. public class CustomSqlFormatter implements MessageFormattingStrategy {
4.     @Override
5.     public String formatMessage(int connectionId, String now, long elapsed, String category, String prepared, String sql, String url) {
6.         return !"".equals(sql.trim()) ? "=============================\n" +
7.                 "Execute SQL: " + formatSql(sql) + "\n" +
8.                 "Execution Time: " + elapsed + " ms\n" +
9.                 "=============================" : "";
10.     }
12.     private String formatSql(String sql) {
13.         // 实现SQL格式化逻辑
14.         return sql;
15.     }
16. }

复制代码

然后在spy.properties中配置：

2. logMessageFormat=com.yourpackage.CustomSqlFormatter

复制代码

实际应用示例

让我们通过一个完整的Spring MVC应用示例，展示如何配置和实现SQL语句输出。

项目结构

2. src/main/java/com/example/demo/
3. ├── config/
4. │   ├── HibernateConfig.java
5. │   └── MyBatisConfig.java
6. ├── controller/
7. │   └── UserController.java
8. ├── interceptor/
9. │   └── SqlOutputInterceptor.java
10. ├── model/
11. │   └── User.java
12. ├── repository/
13. │   ├── UserRepository.java
14. │   └── UserRepositoryImpl.java
15. └── DemoApplication.java
17. src/main/resources/
18. ├── application.yml
19. ├── logback-spring.xml
20. └── mybatis-config.xml

复制代码

配置文件

2. spring:
3.   datasource:
4.     url: jdbc:mysql://localhost:3306/demo_db
5.     username: root
6.     password: password
7.     driver-class-name: com.mysql.cj.jdbc.Driver
8.   jpa:
9.     show-sql: true
10.     hibernate:
11.       ddl-auto: update
12.     properties:
13.       hibernate:
14.         format_sql: true
15.         use_sql_comments: true
16.         generate_statistics: true
18. mybatis:
19.   mapper-locations: classpath:mapper/*.xml
20.   configuration:
21.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
23. logging:
24.   level:
25.     org.hibernate.SQL: DEBUG
26.     org.hibernate.type.descriptor.sql.BasicBinder: TRACE
27.     org.springframework.data: DEBUG
28.     com.example.demo.mapper: DEBUG

复制代码

2. <?xml version="1.0" encoding="UTF-8"?>
3. <configuration>
4.     <property name="LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"/>
5.    
6.     <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
7.         <encoder>
8.             <pattern>${LOG_PATTERN}</pattern>
9.         </encoder>
10.     </appender>
11.    
12.     <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
13.         <file>logs/demo.log</file>
14.         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
15.             <fileNamePattern>logs/demo.%d{yyyy-MM-dd}.log</fileNamePattern>
16.             <maxHistory>30</maxHistory>
17.         </rollingPolicy>
18.         <encoder>
19.             <pattern>${LOG_PATTERN}</pattern>
20.         </encoder>
21.     </appender>
22.    
23.     <logger name="org.hibernate.SQL" level="DEBUG" additivity="false">
24.         <appender-ref ref="CONSOLE"/>
25.         <appender-ref ref="FILE"/>
26.     </logger>
27.    
28.     <logger name="org.hibernate.type.descriptor.sql.BasicBinder" level="TRACE" additivity="false">
29.         <appender-ref ref="CONSOLE"/>
30.         <appender-ref ref="FILE"/>
31.     </logger>
32.    
33.     <logger name="org.springframework.data" level="DEBUG" additivity="false">
34.         <appender-ref ref="CONSOLE"/>
35.         <appender-ref ref="FILE"/>
36.     </logger>
37.    
38.     <logger name="com.example.demo.mapper" level="DEBUG" additivity="false">
39.         <appender-ref ref="CONSOLE"/>
40.         <appender-ref ref="FILE"/>
41.     </logger>
42.    
43.     <root level="INFO">
44.         <appender-ref ref="CONSOLE"/>
45.         <appender-ref ref="FILE"/>
46.     </root>
47. </configuration>

复制代码

2. <?xml version="1.0" encoding="UTF-8"?>
3. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
4. <configuration>
5.     <settings>
6.         <setting name="logImpl" value="STDOUT_LOGGING"/>
7.     </settings>
8. </configuration>

复制代码

Java代码

2. import javax.persistence.*;
3. import java.io.Serializable;
5. @Entity
6. @Table(name = "users")
7. @EntityListeners(EntityListener.class)
8. public class User implements Serializable {
10.     @Id
11.     @GeneratedValue(strategy = GenerationType.IDENTITY)
12.     private Long id;
13.    
14.     @Column(name = "username", nullable = false, unique = true)
15.     private String username;
16.    
17.     @Column(name = "email", nullable = false)
18.     private String email;
19.    
20.     // 构造函数
21.     public User() {}
22.    
23.     public User(String username, String email) {
24.         this.username = username;
25.         this.email = email;
26.     }
27.    
28.     // getters and setters
29.     public Long getId() {
30.         return id;
31.     }
32.    
33.     public void setId(Long id) {
34.         this.id = id;
35.     }
36.    
37.     public String getUsername() {
38.         return username;
39.     }
40.    
41.     public void setUsername(String username) {
42.         this.username = username;
43.     }
44.    
45.     public String getEmail() {
46.         return email;
47.     }
48.    
49.     public void setEmail(String email) {
50.         this.email = email;
51.     }
52. }

复制代码

2. import javax.persistence.*;
4. public class EntityListener {
6.     @PrePersist
7.     public void prePersist(Object entity) {
8.         System.out.println("About to persist: " + entity);
9.     }
11.     @PostPersist
12.     public void postPersist(Object entity) {
13.         System.out.println("Persisted: " + entity);
14.     }
16.     @PreUpdate
17.     public void preUpdate(Object entity) {
18.         System.out.println("About to update: " + entity);
19.     }
21.     @PostUpdate
22.     public void postUpdate(Object entity) {
23.         System.out.println("Updated: " + entity);
24.     }
26.     @PreRemove
27.     public void preRemove(Object entity) {
28.         System.out.println("About to remove: " + entity);
29.     }
31.     @PostRemove
32.     public void postRemove(Object entity) {
33.         System.out.println("Removed: " + entity);
34.     }
35. }

复制代码

2. import com.example.demo.model.User;
3. import org.springframework.data.jpa.repository.JpaRepository;
4. import org.springframework.data.jpa.repository.Query;
5. import org.springframework.data.repository.query.Param;
7. public interface UserRepository extends JpaRepository<User, Long>, UserRepositoryCustom {
9.     @Query("SELECT u FROM User u WHERE u.username = :username")
10.     User findByUsername(@Param("username") String username);
11. }

复制代码

2. import com.example.demo.model.User;
4. public interface UserRepositoryCustom {
5.     User customFindById(Long id);
6. }

复制代码

2. import com.example.demo.model.User;
4. import javax.persistence.EntityManager;
5. import javax.persistence.PersistenceContext;
6. import javax.persistence.TypedQuery;
8. public class UserRepositoryImpl implements UserRepositoryCustom {
10.     @PersistenceContext
11.     private EntityManager entityManager;
13.     @Override
14.     public User customFindById(Long id) {
15.         TypedQuery<User> query = entityManager.createQuery("SELECT u FROM User u WHERE u.id = :id", User.class);
16.         query.setParameter("id", id);
17.         
18.         // 输出SQL
19.         System.out.println("Executing custom query: " + query.unwrap(org.hibernate.Query.class).getQueryString());
20.         
21.         return query.getSingleResult();
22.     }
23. }

复制代码

2. import org.apache.ibatis.executor.Executor;
3. import org.apache.ibatis.mapping.BoundSql;
4. import org.apache.ibatis.mapping.MappedStatement;
5. import org.apache.ibatis.plugin.*;
6. import org.apache.ibatis.session.ResultHandler;
7. import org.apache.ibatis.session.RowBounds;
9. import java.text.SimpleDateFormat;
10. import java.util.Date;
11. import java.util.Properties;
13. @Intercepts({
14.     @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),
15.     @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
16. })
17. public class SqlOutputInterceptor implements Interceptor {
19.     @Override
20.     public Object intercept(Invocation invocation) throws Throwable {
21.         MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
22.         Object parameter = invocation.getArgs()[1];
23.         
24.         BoundSql boundSql = mappedStatement.getBoundSql(parameter);
25.         String sql = boundSql.getSql();
26.         
27.         // 输出SQL
28.         System.out.println("=============================================");
29.         System.out.println("Time: " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date()));
30.         System.out.println("SQL ID: " + mappedStatement.getId());
31.         System.out.println("SQL: " + sql);
32.         System.out.println("=============================================");
33.         
34.         // 执行原方法
35.         Object result = invocation.proceed();
36.         
37.         return result;
38.     }
40.     @Override
41.     public Object plugin(Object target) {
42.         return Plugin.wrap(target, this);
43.     }
45.     @Override
46.     public void setProperties(Properties properties) {
47.         // 可以读取配置的属性
48.     }
49. }

复制代码

2. import com.example.demo.model.User;
3. import com.example.demo.repository.UserRepository;
4. import org.springframework.beans.factory.annotation.Autowired;
5. import org.springframework.web.bind.annotation.*;
7. import java.util.List;
8. import java.util.Optional;
10. @RestController
11. @RequestMapping("/api/users")
12. public class UserController {
14.     @Autowired
15.     private UserRepository userRepository;
17.     @GetMapping
18.     public List<User> getAllUsers() {
19.         return userRepository.findAll();
20.     }
22.     @GetMapping("/{id}")
23.     public User getUserById(@PathVariable Long id) {
24.         // 使用自定义查询方法
25.         return userRepository.customFindById(id);
26.     }
28.     @GetMapping("/username/{username}")
29.     public User getUserByUsername(@PathVariable String username) {
30.         return userRepository.findByUsername(username);
31.     }
33.     @PostMapping
34.     public User createUser(@RequestBody User user) {
35.         return userRepository.save(user);
36.     }
38.     @PutMapping("/{id}")
39.     public User updateUser(@PathVariable Long id, @RequestBody User userDetails) {
40.         Optional<User> userOptional = userRepository.findById(id);
41.         if (userOptional.isPresent()) {
42.             User user = userOptional.get();
43.             user.setUsername(userDetails.getUsername());
44.             user.setEmail(userDetails.getEmail());
45.             return userRepository.save(user);
46.         }
47.         return null;
48.     }
50.     @DeleteMapping("/{id}")
51.     public void deleteUser(@PathVariable Long id) {
52.         userRepository.deleteById(id);
53.     }
54. }

复制代码

2. import org.springframework.boot.SpringApplication;
3. import org.springframework.boot.autoconfigure.SpringBootApplication;
5. @SpringBootApplication
6. public class DemoApplication {
8.     public static void main(String[] args) {
9.         SpringApplication.run(DemoApplication.class, args);
10.     }
11. }

复制代码

运行示例

当运行这个应用并访问API时，你将在控制台和日志文件中看到类似以下的SQL输出：

2. =============================================
3. Time: 2023-05-20 14:30:45.123
4. SQL ID: com.example.demo.repository.UserRepository.customFindById
5. SQL: SELECT u FROM User u WHERE u.id = ?
6. =============================================
8. Hibernate:
9.     select
10.         user0_.id as id1_0_,
11.         user0_.email as email2_0_,
12.         user0_.username as username3_0_
13.     from
14.         users user0_
15.     where
16.         user0_.id=?
17. 2023-05-20 14:30:45.125 TRACE 12345 --- [nio-8080-exec-1] o.h.type.descriptor.sql.BasicBinder   : binding parameter [1] as [BIGINT] - [1]
19. About to update: User{id=1, username='john_doe', email='john@example.com'}
20. Updated: User{id=1, username='john_doe_updated', email='john.updated@example.com'}

复制代码

总结

在Spring MVC应用中配置和实现SQL语句输出是数据库操作调试的重要手段。本文详细介绍了多种配置方法，包括：

1. 通过日志框架（Logback、Log4j2）配置SQL输出
2. 通过Hibernate/JPA配置SQL输出
3. 通过MyBatis配置SQL输出
4. 通过Spring Data JPA配置SQL输出
5. 格式化和美化SQL输出的方法
6. 常见问题及解决方案

通过这些方法，开发者可以轻松地在开发和测试阶段查看实际执行的SQL语句及其参数，从而更高效地调试数据库操作。

在实际应用中，建议根据项目需求和环境选择合适的SQL输出方式，并注意在生产环境中关闭或限制SQL输出，以避免性能问题和安全风险。同时，利用条件化配置（如Spring Profile）来区分不同环境的配置，是一个良好的实践。

希望本文能帮助你在Spring MVC应用中轻松实现SQL语句输出，提高数据库操作调试的效率。

版权声明

1、转载或引用本网站内容(Spring MVC应用中SQL语句输出的完整指南从配置到实现助你轻松调试数据库操作)须注明原网址及作者(威震华夏关云长)，并标明本网站网址(https://www.pixtech.cc/)。

2、对于不当转载或引用本网站内容而引起的民事纷争、行政处理或其他损失，本网站不承担责任。

3、对不遵守本声明或其他违法、恶意使用本网站内容者，本网站保留追究其法律责任的权利。

本文地址: https://www.pixtech.cc/thread-31555-1-1.html