So drucken Sie eine Abfragezeichenfolge mit Parameterwerten bei Verwendung von Hibernate

Zur Vereinfachung finden Sie hier dasselbe Konfigurationsbeispiel für Logback (SLF4J).

<appender name="SQLROLLINGFILE">
 <File>/tmp/sql.log</File>
 <rollingPolicy>
  <FileNamePattern>logFile.%d{yyyy-MM-dd}.log</FileNamePattern>
 </rollingPolicy>
 <layout>
  <Pattern>%-4date | %msg %n</Pattern>
 </layout>
</appender>

<logger name="org.hibernate.SQL" additivity="false" >   
 <level value="DEBUG" />    
 <appender-ref ref="SQLROLLINGFILE" />
</logger>

<logger name="org.hibernate.type" additivity="false" >
 <level value="TRACE" />
 <appender-ref ref="SQLROLLINGFILE" />
</logger>

Die Ausgabe in Ihrem sql.log (Beispiel) sieht dann folgendermaßen aus:

2013-08-30 18:01:15,083 | update stepprovider set created_at=?, lastupdated_at=?, version=?, bundlelocation=?, category_id=?, customer_id=?, description=?, icon_file_id=?, name=?, shareStatus=?, spversion=?, status=?, title=?, type=?, num_used=? where id=?
2013-08-30 18:01:15,084 | binding parameter [1] as [TIMESTAMP] - 2012-07-11 09:57:32.0
2013-08-30 18:01:15,085 | binding parameter [2] as [TIMESTAMP] - Fri Aug 30 18:01:15 CEST 2013
2013-08-30 18:01:15,086 | binding parameter [3] as [INTEGER] -
2013-08-30 18:01:15,086 | binding parameter [4] as [VARCHAR] - com.mypackage.foo
2013-08-30 18:01:15,087 | binding parameter [5] as [VARCHAR] -
2013-08-30 18:01:15,087 | binding parameter [6] as [VARCHAR] -
2013-08-30 18:01:15,087 | binding parameter [7] as [VARCHAR] - TODO
2013-08-30 18:01:15,087 | binding parameter [8] as [VARCHAR] -
2013-08-30 18:01:15,088 | binding parameter [9] as [VARCHAR] - [email protected]
2013-08-30 18:01:15,088 | binding parameter [10] as [VARCHAR] - PRIVATE
2013-08-30 18:01:15,088 | binding parameter [11] as [VARCHAR] - 1.0
2013-08-30 18:01:15,088 | binding parameter [12] as [VARCHAR] - 32
2013-08-30 18:01:15,088 | binding parameter [13] as [VARCHAR] - MatchingStep
2013-08-30 18:01:15,089 | binding parameter [14] as [VARCHAR] -
2013-08-30 18:01:15,089 | binding parameter [15] as [INTEGER] - 0
2013-08-30 18:01:15,089 | binding parameter [16] as [VARCHAR] - 053c2e65-5d51-4c09-85f3-2281a1024f64

hibernate.cfg.xml ändern in:

<property name="show_sql">true</property>
<property name="format_sql">true</property>
<property name="use_sql_comments">true</property>

Fügen Sie log4j und darunter in "log4j.properties" ein:

log4j.logger.org.hibernate=INFO, hb
log4j.logger.org.hibernate.SQL=DEBUG
log4j.logger.org.hibernate.type=TRACE

log4j.appender.hb=org.Apache.log4j.ConsoleAppender
log4j.appender.hb.layout=org.Apache.log4j.PatternLayout

Log4JDBC ist eine Lösung von Nice, die die exact -Datenbank mit Parametern an Stelle der Datenbank druckt und nicht die gängigste Antwort, die dies nicht tut. Ein großer Vorteil dabei ist, dass Sie die SQL direkt in Ihr DB-Frontend kopieren und unverändert ausführen können.

http://log4jdbc.sourceforge.net/

https://code.google.com/p/log4jdbc-remix/

Letztere gibt auch eine tabellarische Darstellung der Abfrageergebnisse aus.

Beispielausgabe, in der die generierte SQL-Anweisung zusammen mit der Ergebnissatztabelle aus der Abfrage angezeigt wird:

5. insert into ENQUIRY_APPLICANT_DETAILS (ID, INCLUDED_IN_QUOTE, APPLICANT_ID, TERRITORY_ID, ENQUIRY_ID, ELIGIBLE_FOR_COVER) values (7, 1, 11, 1, 2, 0) 


10 Oct 2013 16:21:22 4953 [main] INFO  jdbc.resultsettable  - |---|--------|--------|-----------|----------|---------|-------|
10 Oct 2013 16:21:22 4953 [main] INFO  jdbc.resultsettable  - |ID |CREATED |DELETED |CODESET_ID |NAME      |POSITION |PREFIX |
10 Oct 2013 16:21:22 4953 [main] INFO  jdbc.resultsettable  - |---|--------|--------|-----------|----------|---------|-------|
10 Oct 2013 16:21:22 4953 [main] INFO  jdbc.resultsettable  - |2  |null    |null    |1          |Country 2 |1        |60     |
10 Oct 2013 16:21:22 4953 [main] INFO  jdbc.resultsettable  - |---|--------|--------|-----------|----------|---------|-------|

Update 2016

Zuletzt habe ich jetzt log4jdbc-log4j2 ( https://code.google.com/archive/p/log4jdbc-log4j2/ ) mit SLF4j und Logback verwendet. Maven-Abhängigkeiten für mein Setup sind wie folgt:

<dependency>
    <groupId>org.bgee.log4jdbc-log4j2</groupId>
    <artifactId>log4jdbc-log4j2-jdbc4.1</artifactId>
    <version>1.16</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>${slf4j.version}</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-core</artifactId>
    <version>${logback.version}</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>$logback.version}</version>
</dependency>

Die Treiber- und DB-URLs sehen dann folgendermaßen aus:

database.driver.class=net.sf.log4jdbc.sql.jdbcapi.DriverSpy
database.url=jdbc:log4jdbc:hsqldb:mem:db_name #Hsql
#database.url=jdbc:log4jdbc:mysql://localhost:3306/db_name 

Meine logback.xml-Konfigurationsdatei sieht wie folgt aus: Diese gibt alle SQL-Anweisungen mit Parametern sowie die Resultset-Tabellen für alle Abfragen aus.

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
            </pattern>
        </encoder>
    </appender>

    <logger name="jdbc.audit" level="ERROR" />
    <logger name="jdbc.connection" level="ERROR" />
    <logger name="jdbc.sqltiming" level="ERROR" />
    <logger name="jdbc.resultset" level="ERROR" />

    <!-- UNCOMMENT THE BELOW TO HIDE THE RESULT SET TABLE OUTPUT -->
    <!--<logger name="jdbc.resultsettable" level="ERROR" /> -->

    <root level="debug">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>

Schließlich musste ich eine Datei namens log4jdbc.log4j2.properties im Stammverzeichnis des Klassenpfads erstellen, z. src/test/resources oder src/main/resources in einem Mevn-Projekt. Diese Datei hat eine Zeile mit der folgenden:

log4jdbc.spylogdelegator.name=net.sf.log4jdbc.log.slf4j.Slf4jSpyLogDelegator

Das Obige hängt von Ihrer Protokollierungsbibliothek ab. Weitere Informationen finden Sie in den Dokumenten unter https://code.google.com/archive/p/log4jdbc-log4j2

Beispielausgabe:

10:44:29.400 [main] DEBUG jdbc.sqlonly -  org.hibernate.engine.jdbc.internal.ResultSetReturnImpl.extract(ResultSetReturnImpl.Java:70)
5. select memberrole0_.member_id as member_i2_12_0_, memberrole0_.id as id1_12_0_, memberrole0_.id 
as id1_12_1_, memberrole0_.member_id as member_i2_12_1_, memberrole0_.role_id as role_id3_12_1_, 
role1_.id as id1_17_2_, role1_.name as name2_17_2_ from member_roles memberrole0_ left outer 
join roles role1_ on memberrole0_.role_id=role1_.id where memberrole0_.member_id=104 

10:44:29.402 [main] INFO  jdbc.resultsettable - 
|----------|---|---|----------|--------|---|-----|
|member_id |id |id |member_id |role_id |id |name |
|----------|---|---|----------|--------|---|-----|
|----------|---|---|----------|--------|---|-----|

Im Falle eines Springboots konfigurieren Sie dies einfach:

Anwendung.yml

logging:
  level:
    org.hibernate.SQL: DEBUG
    org.hibernate.type: TRACE

aplication.properties

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

und nichts weiter.

HTH

Sie können der Zeile "log4j.xml" Kategorienzeilen hinzufügen:

<category name="org.hibernate.type">
    <priority value="TRACE"/>
</category>

und fügen Sie die Eigenschaften für den Ruhezustand hinzu: 

<property name="show_sql">true</property>
<property name="format_sql">true</property>
<property name="use_sql_comments">true</property>

Sie können dies mit dem datasource-proxy tun, wie ich es in diesem Beitrag beschrieben habe.

Angenommen, Ihre Anwendung erwartet eine dataSource-Bean (z. B. über @Resource). So können Sie datasource-proxy konfigurieren:

<bean id="actualDataSource" class="bitronix.tm.resource.jdbc.PoolingDataSource" init-method="init"
  destroy-method="close">
    <property name="className" value="bitronix.tm.resource.jdbc.lrc.LrcXADataSource"/>
    <property name="uniqueName" value="actualDataSource"/>
    <property name="minPoolSize" value="0"/>
    <property name="maxPoolSize" value="5"/>
    <property name="allowLocalTransactions" value="false" />
    <property name="driverProperties">
        <props>
            <prop key="user">${jdbc.username}</prop>
            <prop key="password">${jdbc.password}</prop>
            <prop key="url">${jdbc.url}</prop>
            <prop key="driverClassName">${jdbc.driverClassName}</prop>
        </props>
    </property>
</bean>

<bean id="proxyDataSource" class="net.ttddyy.dsproxy.support.ProxyDataSource">
    <property name="dataSource" ref="testDataSource"/>
    <property name="listener">
        <bean class="net.ttddyy.dsproxy.listener.ChainListener">
            <property name="listeners">
                <list>
                    <bean class="net.ttddyy.dsproxy.listener.CommonsQueryLoggingListener">
                        <property name="logLevel" value="INFO"/>
                    </bean>
                    <bean class="net.ttddyy.dsproxy.listener.DataSourceQueryCountListener"/>
                </list>
            </property>
        </bean>
    </property>
</bean>

<alias name="proxyDataSource" alias="dataSource"/>

Jetzt die Hibernate-Ausgabe vs. Datenquellen-Proxy:

INFO  [main]: n.t.d.l.CommonsQueryLoggingListener - Name:, Time:1, Num:1, Query:{[select company0_.id as id1_6_, company0_.name as name2_6_ from Company company0_][]}
INFO  [main]: n.t.d.l.CommonsQueryLoggingListener - Name:, Time:0, Num:1, Query:{[insert into WarehouseProductInfo (id, quantity) values (default, ?)][19]}
INFO  [main]: n.t.d.l.CommonsQueryLoggingListener - Name:, Time:0, Num:1, Query:{[insert into Product (id, code, company_id, importer_id, name, version) values (default, ?, ?, ?, ?, ?)][phoneCode,1,-5,Phone,0]}

Die datasource-proxy-Abfragen enthalten Parameterwerte. Sie können sogar benutzerdefinierte Interceptors für JDBC-Anweisungen hinzufügen, sodass Sie N + 1-Abfrageprobleme direkt aus Ihren Integrationstests abfangen können .

fügen Sie Ihrer log4j- oder logback-Konfiguration folgende Eigenschaften und Werte hinzu:

org.hibernate.sql=DEBUG
org.hibernate.type.descriptor.sql.BasicBinder=TRACE

schalten Sie den org.hibernate.type Logger ein, um zu sehen, wie die aktuellen Parameter an die Fragezeichen gebunden sind.

<!-- A time/date based rolling appender -->
<appender name="FILE" class="org.Apache.log4j.RollingFileAppender">
    <param name="File" value="logs/system.log" />
    <param name="Append" value="true" />
    <param name="ImmediateFlush" value="true" />
    <param name="MaxFileSize" value="200MB" />
    <param name="MaxBackupIndex" value="100" />

    <layout class="org.Apache.log4j.PatternLayout">
        <param name="ConversionPattern" value="%d %d{Z} [%t] %-5p (%F:%L) - %m%n" />
    </layout>
</appender>

<appender name="journaldev-hibernate" class="org.Apache.log4j.RollingFileAppender">
    <param name="File" value="logs/project.log" />
    <param name="Append" value="true" />
    <param name="ImmediateFlush" value="true" />
    <param name="MaxFileSize" value="200MB" />
    <param name="MaxBackupIndex" value="50" />

    <layout class="org.Apache.log4j.PatternLayout">
        <param name="ConversionPattern" value="%d %d{Z} [%t] %-5p (%F:%L) - %m%n" />
    </layout>
</appender>

<logger name="com.journaldev.hibernate" additivity="false">
    <level value="DEBUG" />
    <appender-ref ref="journaldev-hibernate" />
</logger>

<logger name="org.hibernate" additivity="false">
    <level value="INFO" />
    <appender-ref ref="FILE" />
</logger>

<logger name="org.hibernate.type" additivity="false">
    <level value="TRACE" />
    <appender-ref ref="FILE" />
</logger>

<root>
    <priority value="INFO"></priority>
    <appender-ref ref="FILE" />
</root>

**If you want hibernate to print generated sql queries with real values instead of question marks.**
**add following entry in hibernate.cfg.xml/hibernate.properties:**
show_sql=true
format_sql=true
use_sql_comments=true

**And add following entry in log4j.properties :**
log4j.logger.org.hibernate=INFO, hb
log4j.logger.org.hibernate.SQL=DEBUG
log4j.logger.org.hibernate.type=TRACE
log4j.appender.hb=org.Apache.log4j.ConsoleAppender
log4j.appender.hb.layout=org.Apache.log4j.PatternLayout

Diese Antwort ist eine kleine Abweichung für die Frage ..__ Manchmal benötigen wir die SQL nur für Debug-Zwecke zur Laufzeit ..__ In diesem Fall gibt es eine einfachere Möglichkeit, Debug für Editoren zu verwenden.

• Legen Sie einen Haltepunkt auf org.hibernate.loader.Loader.loadEntityBatch fest (oder navigieren Sie auf dem Stapel, bis Sie dort sind).
• Wenn die Ausführung angehalten wird, prüfen Sie den Wert der Variablen this.sql.

Dies ist für den Winterschlaf 3. Ich bin nicht sicher, ob dies bei anderen Versionen funktioniert.

Mit Hibernate 4 und slf4j/log4j2 habe ich versucht, Folgendes in meiner Konfiguration von log4j2.xml hinzuzufügen:

<Logger name="org.hibernate.type.descriptor.sql.BasicBinder" level="trace" additivity="false"> 
    <AppenderRef ref="Console"/> 
</Logger> 
<Logger name="org.hibernate.type.EnumType" level="trace" additivity="false"> 
    <AppenderRef ref="Console"/>
</Logger>

Aber ohne Erfolg.

Ich habe durch diesen Thread herausgefunden, dass das von hibernate verwendete Jboss-Logging-Framework konfiguriert werden muss, um über slf4j zu protokollieren. Ich habe den VM - Argumenten der Anwendung das folgende Argument hinzugefügt:

-Dorg.jboss.logging.provider=slf4j

Und es hat wie ein Zauber funktioniert.

Die Lösung ist korrekt, aber es werden auch alle Bindungen für die Ergebnisobjekte protokolliert .. Um dies zu verhindern, können Sie einen separaten Appender erstellen und die Filterung aktivieren.

<!-- A time/date based rolling appender -->
<appender name="FILE_HIBERNATE" class="org.jboss.logging.appender.DailyRollingFileAppender">
    <errorHandler class="org.jboss.logging.util.OnlyOnceErrorHandler"/>
    <param name="File" value="${jboss.server.log.dir}/hiber.log"/>
    <param name="Append" value="false"/>
    <param name="Threshold" value="TRACE"/>
    <!-- Rollover at midnight each day -->
    <param name="DatePattern" value="'.'yyyy-MM-dd"/>

    <layout class="org.Apache.log4j.PatternLayout">
        <!-- The default pattern: Date Priority [Category] Message\n -->
        <param name="ConversionPattern" value="%d %-5p [%c] %m%n"/>
    </layout>

    <filter class="org.Apache.log4j.varia.StringMatchFilter">
        <param name="StringToMatch" value="bind" />
        <param name="AcceptOnMatch" value="true" />
    </filter>
    <filter class="org.Apache.log4j.varia.StringMatchFilter">
        <param name="StringToMatch" value="select" />
        <param name="AcceptOnMatch" value="true" />
    </filter>  
    <filter class="org.Apache.log4j.varia.DenyAllFilter"/>
</appender> 

<category name="org.hibernate.type">
  <priority value="TRACE"/>
</category>

<logger name="org.hibernate.type">
   <level value="TRACE"/> 
   <appender-ref ref="FILE_HIBERNATE"/>
</logger>

<logger name="org.hibernate.SQL">
   <level value="TRACE"/> 
   <appender-ref ref="FILE_HIBERNATE"/>
</logger>

mySQL-Jdbc-Treiber hat bereits eine bequeme, um diese Anforderung zu erfüllen, müssen Sie mindestens die jar-Version> = mysql-connect-jar-5.1.6.jar haben

schritt 1: [jdbc.url konfigurieren, um Logger und benutzerdefinierte Protokollierung hinzuzufügen]

    jdbc.url=jdbc:mysql://Host:port/your_db?logger=com.mysql.jdbc.log.Slf4JLogger&profileSQL=true&profilerEventHandler=com.xxx.CustomLoggingProfilerEventHandler

jetzt verwendet es die slf4j-Protokollierung. Wenn Ihre Standardprotokollierung log4j ist, müssen Sie die Abhängigkeiten slf4j-api und slf4j-log4j12 hinzufügen, um die slf4j-Protokollierung zu verwenden

schritt 2: [Schreiben Sie Ihre benutzerdefinierte Protokollierung]

package com.xxx;
import Java.sql.SQLException;
import Java.util.Properties;

import com.mysql.jdbc.Connection;
import com.mysql.jdbc.log.Log;

public class CustomLoggingProfilerEventHandler implements ProfilerEventHandler {
    private Log log;

    public LoggingProfilerEventHandler() {
    }

    public void consumeEvent(ProfilerEvent evt) {
            /**
             * you can only print the sql as        this.log.logInfo(evt.getMessage())
             * you can adjust your sql print log level with: DEBUG,INFO
             * you can also handle the message to meet your requirement
             */ 
            this.log.logInfo(evt);
    }

    public void destroy() {
        this.log = null;
    }

    public void init(Connection conn, Properties props) throws SQLException {
        this.log = conn.getLog();
    }

}

<appender name="console" class="org.Apache.log4j.ConsoleAppender">
    <layout class="org.Apache.log4j.PatternLayout">
    <param name="ConversionPattern" 
      value="%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n" />
    </layout>
</appender>

<logger name="org.hibernate" additivity="false">
    <level value="INFO" />
    <appender-ref ref="console" />
</logger>

<logger name="org.hibernate.type" additivity="false">
    <level value="TRACE" />
    <appender-ref ref="console" />
</logger>

Folgendes hat für mich funktioniert, unter der Eigenschaft "log4j.file":

log4j.logger.org.hibernate.type.descriptor.sql.BasicBinder=TRACE

Einstellungen für den Ruhezustand

hibernate.show_sql=true

Ich mag das für log4j:

log4j.logger.org.hibernate.SQL=trace
log4j.logger.org.hibernate.engine.query=trace
log4j.logger.org.hibernate.type=trace
log4j.logger.org.hibernate.jdbc=trace
log4j.logger.org.hibernate.type.descriptor.sql.BasicExtractor=error 
log4j.logger.org.hibernate.type.CollectionType=error 

wenn Sie den Ruhezustand 3.2.xx verwenden, verwenden Sie __ 

log4j.logger.org.hibernate.SQL=trace

anstatt 

log4j.logger.org.hibernate.SQL=debug 

Alle Antworten hier sind hilfreich. Wenn Sie jedoch eine Spring-Anwendungskontext-XML zum Einrichten der Sitzungsfactory verwenden, können Sie durch Festlegen der Variablen der log4j-SQL-Ebene nur einen Teil des Weges dorthin bringen. Außerdem müssen Sie die Variable hibernate.show_sql festlegen im App-Kontext selbst, damit Hibernate die Werte tatsächlich anzeigt.

ApplicationContext.xml hat:

<property name="hibernateProperties">
            <value>
            hibernate.jdbc.batch_size=25
            ... <!-- Other parameter values here -->
            hibernate.show_sql=true
            </value>
 </property>

Und Ihre log4j-Datei muss

log4j.logger.org.hibernate.SQL=DEBUG

Logging funktioniert aber nicht genau Sie wollen oder wollte ich vor einiger Zeit, aber P6Spy funktioniert perfekt, 

hier ist das einfache Tutorial, das auch MKYONG-Tutorial für P6Spy implementiert wird.

für mich funktionierte es wie charmant.

1. P6Spy-Bibliothek herunterladen 

Holen Sie sich das “p6spy-install.jar“

2. Extrahieren

Extrahieren Sie die p6spy-install.jar-Datei, suchen Sie nach p6spy.jar und spy.properties

3. Bibliotheksabhängigkeit hinzufügen

Fügen Sie p6spy.jar zur Abhängigkeit Ihrer Projektbibliothek hinzu

4. P6Spy-Eigenschaftendatei ändern

Ändern Sie Ihre Datenbankkonfigurationsdatei. Sie müssen Ihren vorhandenen JDBC-Treiber durch einen P6Spy-JDBC-Treiber ersetzen. com.p6spy.engine.spy.P6SpyDriver

Original ist MySQL JDBC-Treiber - com.mysql.jdbc.Driver

<session-factory>
  <property name="hibernate.bytecode.use_reflection_optimizer">false</property>
  <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
  <property name="hibernate.connection.password">password</property>
  <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mkyong</property>
  <property name="hibernate.connection.username">root</property>
  <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
  <property name="show_sql">true</property>
</session-factory>

In P6Spy JDBC-Treiber geändert - com.p6spy.engine.spy.P6SpyDriver

<session-factory>
  <property name="hibernate.bytecode.use_reflection_optimizer">false</property>
  <property name="hibernate.connection.driver_class">com.p6spy.engine.spy.P6SpyDriver
  </property>
  <property name="hibernate.connection.password">password</property>
  <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mkyong</property>
  <property name="hibernate.connection.username">root</property>
  <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
  <property name="show_sql">true</property>
</session-factory>

5. P6Spy-Eigenschaftsdatei ändern Ändern Sie die P6Spy-Eigenschaftendatei - spy.properties.

Ersetzen Sie den real driver durch Ihren vorhandenen MySQL JDBC-Treiber

realdriver=com.mysql.jdbc.Driver

#specifies another driver to use
realdriver2=
#specifies a third driver to use
realdriver3=

Ändern Sie den Speicherort der Protokolldatei Ändern Sie den Speicherort der Protokolldatei in der Eigenschaft logfile. Alle SQL-Anweisungen melden sich in dieser Datei an.

Windows

logfile     = c:/spy.log

* nix

logfile     = /srv/log/spy.log

6. Kopiere “spy.properties” in Projektklassenpfad

Kopieren Sie “spy.properties” in den Stammordner Ihres Projekts. Vergewissern Sie sich, dass Ihr Projekt „spy.properties“ finden kann. Andernfalls wird “spy.properties”-Datei nicht als Ausnahme angezeigt.

Sie können dies protokollieren:

net.sf.hibernate.hql.QueryTranslator

Ausgabebeispiel:

2013-10-31 14:56:19,029 DEBUG [net.sf.hibernate.hql.QueryTranslator] HQL: select noti.id, noti.idmicrosite, noti.fcaducidad, noti.fpublicacion, noti.tipo, noti.imagen, noti.visible, trad.titulo, trad.subtitulo, trad.laurl, trad.urlnom, trad.fuente, trad.texto  from org.ibit.rol.sac.micromodel.Noticia noti join noti.traducciones trad where index(trad)='ca' and noti.visible='S' and noti.idmicrosite=985 and noti.tipo=3446

2013-10-31 14:56:19,029 DEBUG [net.sf.hibernate.hql.QueryTranslator] SQL: select noticia0_.NOT_CODI as x0_0_, noticia0_.NOT_MICCOD as x1_0_, noticia0_.NOT_CADUCA as x2_0_, noticia0_.NOT_PUBLIC as x3_0_, noticia0_.NOT_TIPO as x4_0_, noticia0_.NOT_IMAGEN as x5_0_, noticia0_.NOT_VISIB as x6_0_, traduccion1_.NID_TITULO as x7_0_, traduccion1_.NID_SUBTIT as x8_0_, traduccion1_.NID_URL as x9_0_, traduccion1_.NID_URLNOM as x10_0_, traduccion1_.NID_FUENTE as x11_0_, traduccion1_.NID_TEXTO as x12_0_ from GUS_NOTICS noticia0_ inner join GUS_NOTIDI traduccion1_ on noticia0_.NOT_CODI=traduccion1_.NID_NOTCOD where (traduccion1_.NID_CODIDI='ca' )and(noticia0_.NOT_VISIB='S' )and(noticia0_.NOT_MICCOD=985 )and(noticia0_.NOT_TIPO=3446 )

Log4Jdbc-Plugin wäre am besten für Ihre Anforderung. Es zeigt folgende

1. Complete SQL query being hit to the db
2. Parameter values being passed to the query
3. Execution time taken by each query

Siehe folgenden Link zur Konfiguration von Log4Jdbc-

https://code.google.com/p/log4jdbc/

Verwenden Sie Wireshark oder etwas Ähnliches:

Keine der oben genannten Antworten wird SQL mit Parametern richtig drucken oder ist schmerzhaft. Ich habe dies durch die Verwendung von WireShark erreicht, das alle SQL/Befehle erfasst, die von der Anwendung an Oracle/Mysql usw. mit den Abfragen gesendet werden.

Ruhezustand zeigt Abfrage und ihre Parameterwerte in verschiedenen Zeilen.

Wenn Sie application.properties im Spring Boot verwenden, können Sie unten in der Anwendung.properties hervorgehobene Parameter verwenden.

1. org.hibernate.SQL zeigt Abfragen an

   logging.level.org.hibernate.SQL = DEBUG

2. org.hibernate.type zeigt alle Parameterwerte an, die mit Auswahl-, Einfüge- und Aktualisierungsabfragen zugeordnet werden . logging.level.org.hibernate.type = TRACE

   • org.hibernate.type.EnumType zeigt den Aufzählungsparameterwert an

     logging.level.org.hibernate.type.EnumType = TRACE

     beispiel :: 

     2018-06-14 11:06:28,217 TRACE [main] [EnumType.Java : 321] Binding [active] to parameter: [1]
     

   • sql.BasicBinder zeigt den ganzzahligen, varchar- und booleschen Parameterwert an

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

     beispiel :: 

     • 2018-06-14 11: 28: 29,750 TRACE [http-nio-9891-exec-2] [BasicBinder.Java: 65] Bindungsparameter [1] als [BOOLEAN] - [true]
     • 2018-06-14 11: 28: 29,751 TRACE [http-nio-9891-exec-2] [BasicBinder.Java: 65] Bindungsparameter [2] als [INTEGER] - [1]
     • 2018-06-14 11: 28: 29,752 TRACE [http-nio-9891-exec-2] [BasicBinder.Java: 65] Bindungsparameter [3] als [VARCHAR] - [public]

In Java:

Wandeln Sie Ihre Abfrage in TypedQuery um, wenn es sich um eine CriteriaQuery (javax.persistence) handelt.

Dann:

query.unwrap (org.hibernate.Query.class) .getQueryString ();

Die einfachste Lösung für mich ist die Implementierung eines regulären stringReplace, um Parametereingaben durch Parameterwerte zu ersetzen (alle Parameter werden zur Vereinfachung als String behandelt):

 String debugedSql = sql;
 //then, for each named parameter
     debugedSql = debugedSql.replaceAll(":"+key, "'"+value.toString()+"'");
 //and finnaly
 println(debugedSql);

oder etwas ähnliches für Positionsparameter (?).
Achten Sie auf Nullwerte und bestimmte Werttypen wie z. B. date, wenn ein laufbereiter SQL-Server protokolliert werden soll.

fügen Sie für die Entwicklung mit Wildfly (standalone.xml) die folgenden Logger hinzu:

<logger category="org.hibernate.SQL">
   <level name="DEBUG"/>
</logger>
<logger category="org.hibernate.type.descriptor.sql">
   <level name="TRACE"/>
</logger>