Voglio registrare le istruzioni SQL in un file.
Ho le seguenti proprietà inapplication.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

Quando eseguo la mia applicazione

cmd>mvn spring-boot:run

Vedo le istruzioni sql nella console ma non compaiono in un file app.log. Il file contiene solo registri di base dalla primavera.

Cosa devo fare per visualizzare le istruzioni sql nel file di registro?

prova a usarlo nel tuo file delle proprietà:

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

Questo funziona anche per stdout:

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

Per registrare i valori:

logging.level.org.hibernate.type=trace

Aggiungi questo a application.properties.

Questo funziona per me (YAML):

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

Si prega di utilizzare:

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

se hai un logback-spring.xml o qualcosa del genere, aggiungi il seguente codice

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

per me va bene.

Per ottenere anche le variabili di bind:

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

Poiché questa è una domanda molto comune, ho scritto questo articolo , su cui si basa questa risposta.

Impostazioni da evitare

Non dovresti usare questa impostazione:

spring.jpa.show-sql=true 

Il problema show-sqlè che le istruzioni SQL sono stampate nella console, quindi non c'è modo di filtrarle, come faresti normalmente con un framework di registrazione.

Utilizzo della registrazione ibernata

Nel tuo file di configurazione del registro, se aggiungi il seguente logger:

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

Quindi, Hibernate stamperà le istruzioni SQL quando PreparedStatementviene creato JDBC . Ecco perché l'istruzione verrà registrata utilizzando i segnaposto dei parametri:

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

Se si desidera registrare i valori dei parametri di bind, aggiungere anche il seguente logger:

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

Una volta impostato il BasicBinderlogger, vedrai che vengono registrati anche i valori dei parametri di bind:

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]

Utilizzo del proxy dell'origine dati

Il proxy dell'origine dati consente di eseguire il proxy del JDBC effettivo DataSource, come illustrato dal diagramma seguente:

È possibile definire il dataSourcebean che verrà utilizzato da Hibernate come segue:

@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();
}

Si noti che actualDataSourcedeve essere DataSourcedefinito dal pool di connessioni che si sta utilizzando nella propria applicazione.

Una volta abilitato datasource-proxy, l'istruzione SQl verrà registrata come segue:

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)]

Per il driver del server MS-SQL (driver JDBC per Microsoft SQL Server).

prova a usare:

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

nel tuo file application.properties.

La mia preferenza personale è di impostare:

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

Puoi consultare questi link come riferimento:

• 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

Secondo la documentazione è:

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

La risposta accettata tradotta a YAML funziona per me

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

Possiamo usare uno di questi nel file 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_

Se si desidera visualizzare i parametri effettivi utilizzati per la query, è possibile utilizzare

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

Quindi notare che il valore del parametro effettivo viene visualizzato come 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]

Accedi all'output standard

Aggiungere a application.properties

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

Questo è il modo più semplice per stampare le query SQL anche se non registra i parametri delle istruzioni preparate. E non è raccomandato poiché non è un framework di registrazione ottimizzato.

Utilizzo di Logging Framework

Aggiungere a 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

Specificando le proprietà precedenti, le voci dei registri verranno inviate all'appender di registri configurato come log-back o log4j.

Se hai problemi con questa impostazione e sembra funzionare a volte e non altre volte, considera se i tempi in cui non funziona sono durante i test unitari.

Molte persone dichiarano proprietà personalizzate del tempo di test tramite l' @TestPropertySourcesannotazione dichiarata da qualche parte nella gerarchia dell'ereditarietà del test. Ciò sovrascriverà qualsiasi cosa tu abbia inserito nelle tue application.propertieso altre impostazioni delle proprietà di produzione in modo che quei valori che stai impostando vengano effettivamente ignorati al momento del test.

Mettere spring.jpa.properties.hibernate.show_sql=truein application.properties non ha sempre aiutato.

Puoi provare ad aggiungere properties.put("hibernate.show_sql", "true");alle proprietà della configurazione del database.

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();
    }

Devi solo impostare

spring.jpa.show-sql = true in application.properties, ad esempio, puoi fare riferimento a questo https://github.com/007anwar/ConfigServerRepo/blob/master/application.yaml