Jak wydrukować ciąg zapytania z wartościami parametrów podczas korzystania z Hibernate

Dla wygody, oto ten sam przykład konfiguracji dla 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>

Wyjście w SQL.log (przykład) wtedy wygląda tak:

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

Zmień hibernate.cfg.xml na:

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

Dołącz log4j i poniżej wpisy w "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

Log4JDBC to ładne rozwiązanie, które wyświetla dokładny SQL przechodzący do bazy danych z parametrami na miejscu, a nie najpopularniejszą tutaj odpowiedzią, która tego nie robi. Jedną z głównych udogodnień jest to, że możesz skopiować SQL bezpośrednio do interfejsu DB i wykonać tak, jak jest.

Http://log4jdbc.sourceforge.net/

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

Ten ostatni wyprowadza również tabelaryczną reprezentację zapytania wyniki.

Przykładowe wyjście pokazujące wygenerowany SQL z paramami w miejscu wraz z tabelą result set Z zapytania:

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

Aktualizacja 2016

Ostatnio używam log4jdbc-log4j2 ( https://code.google.com/archive/p/log4jdbc-log4j2 / ) z SLF4j i logback. Maven zależności wymagane dla mojej konfiguracji są następujące:

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

Adresy URL Sterownika i DB wyglądają następująco:

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 #MySQL

<?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>

W końcu musiałem utworzyć plik o nazwie log4jdbc.log4j2właściwości w katalogu głównym ścieżki klas, np. src / test / resources lub src / main / resources w projekcie Mevn. Ten plik ma jedną linię, która jest poniżej:

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

Powyższe zależy od biblioteki logowania. Zobacz dokumenty na https://code.google.com/archive/p/log4jdbc-log4j2 więcej informacji

Próbka Wyjście:

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

Możesz dodać linie kategorii do log4j.xml:

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

I dodać właściwości hibernate:

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

Dodaj następujące właściwości i wartości do konfiguracji log4j lub logback:

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

W przypadku spring boot jest używany , wystarczy skonfigurować to:

Aplikacja.yml

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

Aplikacja.właściwości

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

HTH

Włącz rejestrator org.hibernate.type, aby zobaczyć, jak rzeczywiste parametry są powiązane ze znakami zapytania.

Możesz to zrobić używającdatasource-proxy , jak opisałem wTen post .

Zakładając, że Twoja aplikacja oczekuje fasoli dataSource (np. via @Resource), Oto jak możesz skonfigurować datasource-proxy:

<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"/>

Teraz wyjście Hibernate vs datasource-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]}

Zapytania datasource-proxy zawierają wartości parametrów i możesz nawet dodać niestandardowe przechwytywacze instrukcji JDBC, dzięki czemu możesz wychwycić N+1 problemów z zapytaniami bezpośrednio z testów integracyjnych .

**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

<!-- 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>

Ta odpowiedź to mała wariancja na pytanie. Czasami potrzebujemy sql tylko do celów debugowania w runtime. W takim przypadku istnieje łatwiejszy sposób, używając debugowania na edytorach.

• Ustaw punkt przerwania na org.hibernacja.ładowacz.Ładowacz.loadEntityBatch (lub nawiguj po stosie aż tam);
• gdy wykonanie jest zawieszone, spójrz na wartość zmiennej this.sql;

To dla hibernate 3. Nie jestem pewien, czy to działa na innych wersjach.

Rozwiązanie jest poprawne, ale rejestruje również wszystkie powiązania dla obiektów wynikowych. Aby temu zapobiec, możliwe jest utworzenie osobnego appendera i włączenie filtrowania, na przykład:

<!-- 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>

Podoba mi się to dla 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 

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

Używając Hibernate 4 i slf4j / log4j2, próbowałem dodać następujące elementy w moim log4j2.konfiguracja xml:

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

Dowiedziałem się przez ten wątek , że framework JBoss-logging używany przez hibernate musi być skonfigurowany, aby logować się przez slf4j. dodałem następujący argument do argumentów VM aplikacji:

-Dorg.jboss.logging.provider=slf4j

Mysql JDBC driver już zapewnić wygodne, aby spełnić ten wymóg, musisz przynajmniej mieć wersję jar > = mysql-connect-jar-5.1.6.jar

Krok 1: [Konfiguracja jdbc.adres URL do dodania loggera i niestandardowego logowania]

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

Teraz używa logowania slf4j, jeśli domyślnym logowaniem jest log4j, musisz dodać zależności slf4j-api, slf4j-log4j12, aby użyć logowania slf4j

Krok 2: [napisz własne logowanie]

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

}

Oto, co dla mnie zadziałało, ustawione poniżej właściwości w pliku log4j.:

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

Ustawienia Właściwości Hibernate:

hibernate.show_sql=true

Jeśli używasz hibernate 3.2.xx use

log4j.logger.org.hibernate.SQL=trace

Zamiast

log4j.logger.org.hibernate.SQL=debug 

Możesz to zalogować:

net.sf.hibernate.hql.QueryTranslator

Przykład wyjścia:

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 )

Wtyczka Log4Jdbc byłaby najlepsza dla Twoich wymagań. Pokazuje następujące -

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

Patrz poniżej link do konfiguracji Log4Jdbc -

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

Logowanie działa, ale nie dokładnie chcesz lub chciałem jakiś czas temu, ale P6Spy Działa doskonale ,

Oto prosty samouczek do zaimplementowania, jak również MKYONG tutorial dla P6Spy.

Dla mnie to działało jak urok.

1. Pobierz bibliotekę P6Spy

Pobierz " p6spy-install.jar "

1. Extract it

Rozpakuj plik p6spy-install.jar, poszukaj p6spy.jar i spy.properties

1. Dodaj zależność biblioteki

Dodaj p6spy.jar do zależności Biblioteki projektu

1. Modyfikuj Plik Właściwości P6Spy

Zmodyfikuj plik konfiguracyjny bazy danych. Musisz wymienić istniejący sterownik JDBC na P6Spy JDBC driver- – [9]}

Original is MySQL JDBC driver- 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>

Zmieniono go na Sterownik P6Spy JDBC - 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>

1. zmodyfikuj właściwości P6Spy plik Modyfikuj Plik Właściwości P6Spy - {–7]}

Zastąp real driver istniejącym sterownikiem MySQL JDBC

realdriver=com.mysql.jdbc.Driver

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

Zmiana lokalizacji pliku dziennika Zmień lokalizację pliku dziennika we właściwości logfile, wszystkie polecenia SQL będą się logować do tego pliku.

Okna

logfile     = c:/spy.log

*nix

logfile     = /srv/log/spy.log

1. Copy “spy.properties” to project classpath

Skopiuj “spy.properties” do folderu głównego projektu, upewnij się, że projekt może zlokalizować "Szpieg.właściwości", w przeciwnym razie wyświetli monit “spy.properties” file not found exception.

Użyj Wireshark lub czegoś podobnego:

Żadna z wyżej wymienionych odpowiedzi nie wyświetli poprawnie sql z parametrami lub jest uciążliwa. Osiągnąłem to za pomocą WireShark , który rejestruje wszystkie polecenia sql wysyłane z aplikacji do Oracle/Mysql itp. z zapytaniami.

Wszystkie odpowiedzi są pomocne, ale jeśli używasz Spring application context XML do konfiguracji fabryki sesji, ustawienie zmiennej poziomu log4j SQL tylko część drogi tam, musisz również ustawić hibernate.zmienna show_sql w samym kontekście aplikacji, aby Hibernate zaczął faktycznie pokazywać wartości.

ApplicationContext.XML ma:

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

I Twój plik log4j potrzebuje

log4j.logger.org.hibernate.SQL=DEBUG

W Języku Java:

Przekształć zapytanie w TypedQuery, jeśli jest to CriteriaQuery (javax.persistence).

Then:

Zapytanie.unwrap(org.hibernacja.Zapytanie.klasy).getQueryString ();

Hibernate pokazuje kwerendy i ich wartości parametrów w różnych liniach.

Jeśli używasz aplikacji.właściwości w spring boot i możesz użyć podświetlonego parametru w aplikacji.właściwości.

1. Org.hibernacja.SQL wyświetli zapytania

   Logging.level.org.hibernate. SQL=DEBUG

2. Org.hibernacja.Typ pokaże wszystkie wartości parametrów, które będą mapowane z zaznaczeniem, wstawieniem i aktualizacją zapytania. logging.level.org.hibernate. type=TRACE

   • Org.hibernacja.Typ.EnumType wyświetli wartość parametru enum type

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

     Przykład ::

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

   • Sql.BasicBinder wyświetli wartość parametru integer, varchar, Typ boolean

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

     Przykład ::

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

Najprostszym rozwiązaniem dla mnie jest zaimplementowanie zwykłego stringReplace, aby zastąpić wejścia parametrów wartościami parametrów (traktując wszystkie parametry jako string, dla uproszczenia):

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

Lub coś podobnego do parametrów pozycyjnych (?).
Dbaj o wartości null i określone typy wartości, takie jak date, jeśli chcesz, aby Run ready sql był rejestrowany.