Quiero registrar declaraciones SQL en un archivo.
Tengo las siguientes propiedades enapplication.properties

spring.datasource.url=...
spring.datasource.username=user
spring.datasource.password=1234
spring.datasource.driver-class-name=net.sourceforge.jtds.jdbc.Driver

spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

security.ignored=true
security.basic.enabled=false

logging.level.org.springframework.web=INFO
logging.level.org.hibernate=INFO
logging.file=c:/temp/my-log/app.log

Cuando ejecuto mi aplicación

cmd>mvn spring-boot:run

Puedo ver las instrucciones sql en la consola pero no aparecen en un archivo app.log. El archivo contiene solo registros básicos de spring.

¿Qué debo hacer para ver las instrucciones sql en el archivo de registro?

intente usar esto en su archivo de propiedades:

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

Esto también funciona para stdout:

spring.jpa.properties.hibernate.show_sql=true
spring.jpa.properties.hibernate.use_sql_comments=true
spring.jpa.properties.hibernate.format_sql=true

Para registrar valores:

logging.level.org.hibernate.type=trace

Solo agrega esto a application.properties.

Esto funciona para mí (YAML):

spring:
  jpa:
    properties:
      hibernate:
        show_sql: true
        format_sql: true
logging:
  level:
    org:
      hibernate:
        type: trace

Por favor use:

logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.type=TRACE
spring.jpa.show-sql=true

si tiene un logback-spring.xml o algo así, agregue el siguiente código

<logger name="org.hibernate.SQL" level="trace" additivity="false">
    <appender-ref ref="file" />
</logger>

funciona para mi.

Para obtener variables de enlace también:

<logger name="org.hibernate.type.descriptor.sql" level="trace">
    <appender-ref ref="file" />
</logger>

Como esta es una pregunta muy común, escribí este artículo , en el que se basa esta respuesta.

Configuraciones para evitar

No debe usar esta configuración:

spring.jpa.show-sql=true 

El problema show-sqles que las instrucciones SQL se imprimen en la consola, por lo que no hay forma de filtrarlas, como lo haría normalmente con un marco de registro.

Usar el registro de Hibernate

En su archivo de configuración de registro, si agrega el siguiente registrador:

<logger name="org.hibernate.SQL" level="debug"/>

Luego, Hibernate imprimirá las declaraciones SQL cuando PreparedStatementse cree el JDBC . Es por eso que la declaración se registrará utilizando marcadores de posición de parámetros:

INSERT INTO post (title, version, id) VALUES (?, ?, ?)

Si desea registrar los valores de los parámetros de enlace, simplemente agregue también el siguiente registrador:

<logger name="org.hibernate.type.descriptor.sql.BasicBinder" level="trace"/>

Una vez que configure el BasicBinderregistrador, verá que los valores de los parámetros de enlace también se registran:

DEBUG [main]: o.h.SQL - insert into post (title, version, id) values (?, ?, ?)
TRACE [main]: o.h.t.d.s.BasicBinder - binding parameter [1] as [VARCHAR] - [High-Performance Java Persistence, part 1]
TRACE [main]: o.h.t.d.s.BasicBinder - binding parameter [2] as [INTEGER] - [0]
TRACE [main]: o.h.t.d.s.BasicBinder - binding parameter [3] as [BIGINT] - [1]

Usar datasource-proxy

El proxy de origen de datos le permite proxy el JDBC real DataSource, como se ilustra en el siguiente diagrama:

Puede definir el dataSourcebean que utilizará Hibernate de la siguiente manera:

@Bean
public DataSource dataSource(DataSource actualDataSource) {
    SLF4JQueryLoggingListener loggingListener = new SLF4JQueryLoggingListener();
    loggingListener.setQueryLogEntryCreator(new InlineQueryLogEntryCreator());
    return ProxyDataSourceBuilder
        .create(actualDataSource)
        .name(DATA_SOURCE_PROXY_NAME)
        .listener(loggingListener)
        .build();
}

Tenga en cuenta que actualDataSourcedebe ser el DataSourcedefinido por el grupo de conexiones que está utilizando en su aplicación.

Una vez que habilite datasource-proxy, la instrucción SQl se registrará de la siguiente manera:

Name:DATA_SOURCE_PROXY, Time:6, Success:True,
Type:Prepared, Batch:True, QuerySize:1, BatchSize:3,
Query:["insert into post (title, version, id) values (?, ?, ?)"],
Params:[(Post no. 0, 0, 0), (Post no. 1, 0, 1), (Post no. 2, 0, 2)]

Para el controlador del servidor MS-SQL (controlador JDBC de Microsoft SQL Server).

intente usar:

logging.level.com.microsoft.sqlserver.jdbc=debug

en su archivo application.properties.

Mi preferencia personal es establecer:

logging.level.com.microsoft.sqlserver.jdbc=info
logging.level.com.microsoft.sqlserver.jdbc.internals=debug

Puede consultar estos enlaces como referencia:

• https://msdn.microsoft.com/en-us/library/ms378517(v=sql.110).aspx
• https://docs.spring.io/spring-boot/docs/current/reference/html/howto-logging.html

Según la documentación es:

spring.jpa.show-sql=true # Enable logging of SQL statements.

La respuesta aceptada traducida a YAML funciona para mí

logging:
  level:
    org:
      hibernate:
        SQL:
          TRACE
        type:
          descriptor:
            sql:
              BasicBinder:
                TRACE

Podemos usar cualquiera de estos en el archivo application.properties :

spring.jpa.show-sql=true 

example :
//Hibernate: select country0_.id as id1_0_, country0_.name as name2_0_ from country country0_

o

logging.level.org.hibernate.SQL=debug 

example :
2018-11-23 12:28:02.990 DEBUG 12972 --- [nio-8086-exec-2] org.hibernate.SQL   : select country0_.id as id1_0_, country0_.name as name2_0_ from country country0_

Si desea ver los parámetros reales utilizados para consultar, puede usar

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

Luego observe que el valor del parámetro real se muestra como binding parameter......

   2018-08-07 14:14:36.079 DEBUG 44804 --- [           main] org.hibernate.SQL                        : select employee0_.id as id1_0_, employee0_.department as departme2_0_, employee0_.joining_date as joining_3_0_, employee0_.name as name4_0_ from employee employee0_ where employee0_.joining_date=?
    2018-08-07 14:14:36.079 TRACE 44804 --- [           main] o.h.type.descriptor.sql.BasicBinder      : binding parameter [1] as [TIMESTAMP] - [Tue Aug 07 00:00:00 SGT 2018]

Inicie sesión en la salida estándar

añadir application.properties

### to enable
spring.jpa.show-sql=true
### to make the printing SQL beautify
spring.jpa.properties.hibernate.format_sql=true

Esta es la forma más sencilla de imprimir las consultas SQL, aunque no registra los parámetros de las declaraciones preparadas. Y no se recomienda ya que no es como un marco de registro optimizado.

Uso del marco de registro

añadir application.properties

### logs the SQL queries
logging.level.org.hibernate.SQL=DEBUG
### logs the prepared statement parameters
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE
### to make the printing SQL beautify
spring.jpa.properties.hibernate.format_sql=true

Al especificar las propiedades anteriores, las entradas de registros se enviarán al agregado de registro configurado, como log-back o log4j.

Si tiene problemas con esta configuración y parece funcionar a veces y no en otras ocasiones, considere si los momentos en que no funciona son durante las pruebas unitarias.

Muchas personas declaran propiedades de tiempo de prueba personalizadas a través de la @TestPropertySourcesanotación declarada en algún lugar de la jerarquía de herencia de prueba. Esto anulará lo que haya puesto en su application.propertiesconfiguración de propiedades de producción u otra, de modo que los valores que esté configurando se ignoren efectivamente en el momento de la prueba.

Poner spring.jpa.properties.hibernate.show_sql=trueen application.properties no siempre ayudó.

Puede intentar agregar properties.put("hibernate.show_sql", "true");a las propiedades de la configuración de la base de datos.

public class DbConfig {

    @Primary
    @Bean(name = "entityManagerFactory")
    public LocalContainerEntityManagerFactoryBean
    entityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("dataSource") DataSource dataSource
    ) {
        Map<String, Object> properties = new HashMap();
        properties.put("hibernate.hbm2ddl.auto", "validate");
        properties.put("hibernate.show_sql", "true");

        return builder
                .dataSource(dataSource)
                .packages("com.test.dbsource.domain")
                .persistenceUnit("dbsource").properties(properties)
                .build();
    }

Solo necesitas configurar

spring.jpa.show-sql = true en application.properties, por ejemplo, puede consultar este https://github.com/007anwar/ConfigServerRepo/blob/master/application.yaml