लॉगिंग के लिए SLF4J

Question

Hibernate 3.x का उपयोग करने के लिए slf4j का उपयोग करने के लिए आप हाइबरनेट 4 में लॉगिंग कॉन्फ़िगर कैसे करते हैं। हाइबरनेट 4.x jboss-logging का उपयोग करता है। मैं एक स्टैंडअलोन एप्लिकेशन लिख रहा हूं जो लॉगिंग के लिए हाइबरनेट 4 और एसएलएफ 4 जे का उपयोग करता है।

मैं SLF4J पर लॉग इन करने के लिए हाइबरनेट को कैसे कॉन्फ़िगर कर सकता हूं?

यदि यह संभव नहीं है, तो मैं हाइबरनेट के लॉगिंग को कैसे कॉन्फ़िगर कर सकता हूं?

हाइबरनेट 4.1 मैनुअल section on logging चेतावनी यह है कि के साथ शुरू होता ...

पूरी तरह से पुराने हो चुके

। हाइबरनेट 4.0 में शुरू होने वाले जेबॉस लॉगिंग का उपयोग करता है। यह दस्तावेज प्राप्त होगा क्योंकि हम इस सामग्री को डेवलपर मार्गदर्शिका में माइग्रेट करते हैं।

... एसएलएफ 4 जे के बारे में बात करने के लिए चला जाता है, और इसलिए बेकार है। न तो getting started guide और न ही developer guide लॉगिंग के बारे में बात करें। न ही migration guide है।

मैंने jboss-logging पर दस्तावेज़ों की जांच की है, लेकिन मैं बिल्कुल भी नहीं ढूंढ पा रहा हूं। GitHub page is silent, और जेबॉस के community projects page में जॉबॉस-लॉगिंग भी सूचीबद्ध नहीं है। मुझे आश्चर्य हुआ कि क्या प्रोजेक्ट के bug tracker में दस्तावेज़ीकरण प्रदान करने से संबंधित कोई समस्या हो सकती है, लेकिन ऐसा नहीं है।

अच्छी खबर यह है कि जब एक जेबॉस एएस 7 जैसे अनुप्रयोग सर्वर के अंदर हाइबरनेट 4 का उपयोग करते हैं, तो लॉगिंग को काफी हद तक आपकी देखभाल की जाती है। लेकिन मैं इसे एक स्टैंडअलोन एप्लिकेशन में कैसे कॉन्फ़िगर कर सकता हूं?

Answer 1

आप इस प्रयास किया:

- Log4J के मामले में slf4j-log4j12.jar। अधिक जानकारी के लिए एसएलएफ 4 जे दस्तावेज देखें। Log4j का उपयोग करने के लिए आपको अपने क्लासपाथ में log4j.properties फ़ाइल भी रखना होगा। एक उदाहरण गुण फ़ाइल src/निर्देशिका में हाइबरनेट साथ वितरित किया जाता है

सिर्फ classpath

Answer 2

पहले आप उस SLF4J का एहसास कर में इन जार और गुण या log4j एक्सएमएल जोड़ने एक प्रवेश पुस्तकालय सही, अपने एक प्रवेश नहीं है आवरण। यह स्वयं कुछ भी लॉग नहीं करता है, यह बस "बैकएंड" को प्रतिनिधि करता है।

jboss-logging को "कॉन्फ़िगर" करने के लिए आप बस अपने क्लासपाथ (jboss-logging के साथ) और jboss-logging आंकड़ों के साथ जो भी लॉग फ्रेमवर्क उपयोग करना चाहते हैं उसे जोड़ दें। http://docs.jboss.org/hibernate/orm/4.3/topical/html/logging/Logging.html

Answer 3

मैं Maven का उपयोग करें और निम्न निर्भरता कहा:: फिर

<dependency> 
    <groupId>org.slf4j</groupId> 
    <artifactId>slf4j-log4j12</artifactId> 
    <version>1.6.6</version> 
</dependency> 

, मैं /src/main/resources में एक log4j.properties फ़ाइलें बनाई:

मैं JBoss लॉगिंग config करने के लिए एक हाइबरनेट केंद्रित गाइड बनाया

# direct log messages to stdout 
log4j.appender.stdout=org.apache.log4j.ConsoleAppender 
log4j.appender.stdout.Target=System.out 
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n 
# set log levels 
log4j.rootLogger=warn 

यह इसे आपके .jar की रूट पर रखेगा। यह एक आकर्षण की तरह काम करता है ...

Answer 4

मैं हाइबरनेट कोर 4.1.7 का उपयोग कर रहा हूं। एक प्लस प्लस स्प्रिंग 3.1.2.RELEASE एक स्टैंडअलोन ऐप में। मैंने Log4j 1.2 जोड़ा।17 मेरी निर्भरताओं के लिए और ऐसा लगता है, क्योंकि जेबॉस लॉगिंग सीधे लॉग 4j पर लॉग ऑन करता है और वसंत कॉमन्स लॉगिंग का उपयोग करता है, चुड़ैल अगर उपलब्ध हो तो लॉग 4j का उपयोग करता है, तो सभी लॉगिंग लॉग 4 जे के माध्यम से कॉन्फ़िगर किया जा सकता है।

यहाँ प्रासंगिक निर्भरता की मेरी सूची है:

के आप Maven का उपयोग कर रहे मान लेते हैं:

<dependency> 
    <groupId>log4j</groupId> 
    <artifactId>log4j</artifactId> 
    <version>1.2.17</version> 
</dependency> 
<dependency> 
    <groupId>org.hibernate</groupId> 
    <artifactId>hibernate-core</artifactId> 
    <version>4.1.7.Final</version> 
</dependency> 
<dependency> 
    <groupId>org.springframework</groupId> 
    <artifactId>spring-context</artifactId> 
    <version>3.1.2.RELEASE</version> 
</dependency> 
<dependency> 
    <groupId>org.springframework</groupId> 
    <artifactId>spring-orm</artifactId> 
    <version>3.1.2.RELEASE</version> 
</dependency> 

Answer 5

Leif's Hypoport post से प्रेरित होकर, यह कैसे मैं "तुला" 4 वापस हाइबरनेट slf4j है।

• एक निर्भरता के रूप में org.slf4j:log4j-over-slf4j जोड़े अपने pom.xml
• को आदेश mvn dependency:tree का उपयोग करना, यह सुनिश्चित कर लें कोई भी कलाकृतियों आप slf4j:slf4j पर depende उपयोग कर रहे हैं की (सटीक होना करने के लिए, कोई विरूपण साक्ष्य एक संकलन होगा गुंजाइश निर्भरता या slf4j:slf4j पर क्रम गुंजाइश निर्भरता)

पृष्ठभूमि: हाइबरनेट 4। एक्स आर्टिफैक्ट org.jboss.logging:jboss-logging पर निर्भरता है। पारगमनशील रूप से, इस आर्टिफैक्ट में आर्टिफैक्ट slf4j:slf4j पर स्कोप निर्भरता प्रदान करता है।

जैसा कि हमने अब org.slf4j:log4j-over-slf4j आर्टिफैक्ट जोड़ा है, org.slf4j:log4j-over-slf4jslf4j:slf4j आर्टिफैक्ट नकल करता है। इसलिए JBoss Logging लॉग अब सब कुछ वास्तव में slf4j के माध्यम से जाना होगा।

मान लें कि आप लॉगबैक का उपयोग अपने लॉगिंग बैकएंड के रूप में कर रहे हैं। यहां एक नमूना pom.xml

<?xml version="1.0" encoding="UTF-8"?> 
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> 
    <modelVersion>4.0.0</modelVersion> 

    .... 
    <properties> 
     .... 
     <slf4j-api-version>1.7.2</slf4j-api-version> 
     <log4j-over-slf4j-version>1.7.2</log4j-over-slf4j-version> 
     <jcl-over-slf4j-version>1.7.2</jcl-over-slf4j-version> <!-- no problem to have yet another slf4j bridge --> 
     <logback-core-version>1.0.7</logback-core-version> 
     <logback-classic-version>1.0.7</logback-classic-version> 
     <hibernate-entitymanager-version>4.1.7.Final</hibernate-entitymanager-version> <!-- our logging problem child --> 
    </properties> 

    <dependencies> 
      <!-- begin: logging-related artifacts .... --> 
      <dependency> 
       <groupId>org.slf4j</groupId> 
       <artifactId>slf4j-api</artifactId> 
       <version>${slf4j-api-version}</version> 
      </dependency> 
      <dependency> 
       <groupId>org.slf4j</groupId> 
       <artifactId>jcl-over-slf4j</artifactId> 
       <version>${jcl-over-slf4j-version}</version> 
      </dependency> 
      <dependency> 
       <groupId>org.slf4j</groupId> 
       <artifactId>log4j-over-slf4j</artifactId> 
       <version>${log4j-over-slf4j-version}</version> 
      </dependency> 
      <dependency> 
       <groupId>ch.qos.logback</groupId> 
       <artifactId>logback-core</artifactId> 
       <version>${logback-core-version}</version> 
      </dependency> 
      <dependency> 
       <groupId>ch.qos.logback</groupId> 
       <artifactId>logback-classic</artifactId> 
       <version>${logback-classic-version}</version> 
      </dependency> 
      <!-- end: logging-related artifacts .... --> 

      <!-- begin: some artifact with direct dependency on log4j:log4j .... --> 
      <dependency> 
      <groupId>org.foo</groupId> 
       <artifactId>some-artifact-with-compile-or-runtime-scope-dependency-on-log4j:log4j</artifactId> 
       <version>${bla}</version> 
       <exclusions> 
        <exclusion> 
         <groupId>log4j</groupId> 
         <artifactId>log4j</artifactId> 
        </exclusion> 
       </exclusions> 
      </dependency> 
      <!-- begin: some artifact with direct dependency on log4j:log4j .... --> 

      <!-- begin: a hibernate 4.x problem child........... --> 
      <dependency> 
       <groupId>org.hibernate</groupId> 
       <artifactId>hibernate-entitymanager</artifactId> 
       <version>${hibernate-entitymanager-version}</version> 
      </dependencies> 
      <!-- end: a hibernate 4.x problem child........... --> 
    .... 
</project> 

अपने classpath पर है, इस src/main/java में स्थित एक के रूप में एक logback.xml है,:

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

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

<root level="info"> 
    <appender-ref ref="console"/> 
</root> 

</configuration> 
<!-- end: logback.xml --> 

कुछ घटक JVM शुरू हुआ समय में logback.xml की पहुंच है कर सकते हैं उचित लॉगिंग के लिए, उदाहरण के लिए जेट्टी मेवेन प्लगइन। उस स्थिति में, अपने आदेश में जावा सिस्टम logback.configurationFile=./path/to/logback.xml जोड़ें (उदा। mvn -Dlogback.configurationFile=./target/classes/logback.xml jetty:run)।

यदि आप अभी भी "कच्चे" कंसोल स्टडआउट हाइबरनेट आउटपुट (जैसे Hibernate: select ...) प्राप्त कर रहे हैं, तो स्टैक ओवरफ़्लो प्रश्न "Turn off hibernate logging to console" लागू हो सकता है।

Answer 6

लॉगबैक के बिना जेबॉस लॉगिंग के साथ काम करने के लिए एसएलएफ 4 जे प्राप्त करने के लिए बैकएंड के रूप में सिस्टम प्रॉपर्टी org.jboss.logging.provider=slf4j का उपयोग करने की आवश्यकता है। log4j-over-slf4j रणनीति इस मामले में काम नहीं कर रही है क्योंकि लॉगिंग जेडीके पर वापस आ जाएगी यदि न तो लॉगबैक और न ही log4j क्लासपाथ में वास्तव में मौजूद नहीं है।

यह एक बाधा का एक सा है और काम करने के लिए आप देखते हैं कि classloader से logback-क्लासिक या org.apache.log4j.Hierarchy log4j से JDK प्रवेश पर वापस गिरने नहीं से JBoss लॉगिंग चाल करने के लिए कम से कम ch.qos.logback.classic.Logger शामिल है autodetection प्राप्त करने के लिए।

जादू org.jboss.logging.LoggerProviders

अद्यतन में व्याख्या की है: इसलिए यह संभव है META-INF/services/org.jboss.logging.LoggerProvider की घोषणा (org.jboss.logging.Slf4jLoggerProvider एक मूल्य के रूप में के साथ) द्वारा इस autodetection के साथ समस्याओं से बचने के लिए सेवा लोडर समर्थन जोड़ा गया है। ऐसा लगता है कि समर्थन log4j2 भी जोड़ा गया है।

Answer 7

तो, बस यह मेरी परियोजना में काम कर रहा है। हाइबरनेट 4, slf4j, लॉगबैक। मेरी परियोजना धीरे-धीरे है, लेकिन मैवेन के लिए समान होना चाहिए।

मूल रूप से अब्दुल सही है। जहां वह सही नहीं है, यह है कि आपको निर्भरता से slf4j को हटाना नहीं है।

org.slf4j: slf4j-api

org.slf4j: log4j-ओवर-slf4j

जैसे

1. संकलित करने के लिए गुंजाइश शामिल logback के लिए (: logback-क्लासिक, ch.qos.logback: logback कोर: ch.qos.logback 1.0.12)

2. पूरी तरह से निर्भरता

परिणाम से log4j libs को बाहर: के माध्यम से हाइबरनेट लॉग लॉगबैक करने के लिए slf4j। बेशक आप लॉगबैक

की तुलना में विभिन्न लॉग कार्यान्वयन का उपयोग करने में सक्षम होना चाहिए ताकि यह सुनिश्चित किया जा सके कि कोई log4j मौजूद नहीं है, युद्ध फ़ाइलों के लिए क्लासपाथ या वेब-इंफ/lib पर अपनी libs जांचें।

बेशक आपने logback.xml में लॉगर्स सेट किए हैं। :

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

Answer 8

देखो https://github.com/jboss-logging/jboss-logging/blob/master/src/main/java/org/jboss/logging/LoggerProviders.java रहे हैं: org.jboss.logging.provider के लिए

static final String LOGGING_PROVIDER_KEY = "org.jboss.logging.provider"; 

private static LoggerProvider findProvider() { 
    // Since the impl classes refer to the back-end frameworks directly, if this classloader can't find the target 
    // log classes, then it doesn't really matter if they're possibly available from the TCCL because we won't be 
    // able to find it anyway 
    final ClassLoader cl = LoggerProviders.class.getClassLoader(); 
    try { 
     // Check the system property 
     final String loggerProvider = AccessController.doPrivileged(new PrivilegedAction<String>() { 
      public String run() { 
       return System.getProperty(LOGGING_PROVIDER_KEY); 
      } 
     }); 
     if (loggerProvider != null) { 
      if ("jboss".equalsIgnoreCase(loggerProvider)) { 
       return tryJBossLogManager(cl); 
      } else if ("jdk".equalsIgnoreCase(loggerProvider)) { 
       return tryJDK(); 
      } else if ("log4j".equalsIgnoreCase(loggerProvider)) { 
       return tryLog4j(cl); 
      } else if ("slf4j".equalsIgnoreCase(loggerProvider)) { 
       return trySlf4j(); 
      } 
     } 
    } catch (Throwable t) { 
    } 
    try { 
     return tryJBossLogManager(cl); 
    } catch (Throwable t) { 
     // nope... 
    } 
    try { 
     return tryLog4j(cl); 
    } catch (Throwable t) { 
     // nope... 
    } 
    try { 
     // only use slf4j if Logback is in use 
     Class.forName("ch.qos.logback.classic.Logger", false, cl); 
     return trySlf4j(); 
    } catch (Throwable t) { 
     // nope... 
    } 
    return tryJDK(); 
} 

तो संभव मान हैं: jboss, jdk, log4j, slf4j।

यदि आप org.jboss.logging.provider सेट नहीं करते हैं तो यह jboss की कोशिश करता है, फिर log4j, फिर slf4j (केवल लॉगबैक उपयोग किया जाता है) और jdk पर फ़ॉलबैक।

मैं slf4jlogback-classic साथ उपयोग करें:

<dependency> 
     <groupId>ch.qos.logback</groupId> 
     <artifactId>logback-classic</artifactId> 
     <version>1.0.13</version> 
     <scope>${logging.scope}</scope> 
    </dependency> 

और सब काम ठीक!

अद्यतन कुछ उपयोगकर्ताओं को बहुत मुख्य App.java में उपयोग करता है:

static { //runs when the main class is loaded. 
    System.setProperty("org.jboss.logging.provider", "slf4j"); 
} 

लेकिन कंटेनर आधारित समाधान इस काम नहीं कर रहा है के लिए।

अद्यतन 2 जो लोग सोचते हैं कि वे jboss-logging के लिए SLF4J के साथ Log4j प्रबंधित करते हैं, यह बिल्कुल नहीं है। jboss-logging सीधे SLF4J के बिना Log4j का उपयोग करता है!

Answer 9

हाइबरनेट 4.3 some documentation कैसे org.jboss.logging को नियंत्रित करने के बारे में है:

• यह एक लॉगिंग प्रदाता के लिए वर्ग-पथ खोज करता है। यह log4j के लिए खोज के बाद slf4j की खोज करता है। तो, सिद्धांत रूप में, यह सुनिश्चित करना कि आपके क्लासपाथ (WAR) में log4j शामिल नहीं है और इसमें slf4j API शामिल है और बैक-एंड काम करना चाहिए।

• अंतिम उपाय के रूप में आप org.jboss.logging.provider सिस्टम प्रॉपर्टी को slf4j पर सेट कर सकते हैं।

---

दस्तावेज के दावों के बावजूद, org.jboss.logging, log4j का उपयोग करने की कोशिश कर रहा पर जोर दिया log4j अनुपस्थित जा रहा है और SLF4J मौजूद होने, मेरे बिलाव लॉग फ़ाइल में निम्न संदेश (/var/log/tomcat/catalina.out) में जिसके परिणामस्वरूप के बावजूद:

log4j:WARN No appenders could be found for logger (org.jboss.logging). 
log4j:WARN Please initialize the log4j system properly. 
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info. 

मुझे dasAnderl ausMinga द्वारा उत्तर के सुझाव का पालन करना था और log4j-over-slf4j पुल शामिल करना था।

Answer 10

मुझे वेबलॉगिक 12 सी और log4j के साथ हाइबरनेट 4 लॉगिंग कार्य करने में कोई समस्या थी। समाधान अपने weblogic-application.xml में निम्नलिखित डाल करने के लिए है:

<prefer-application-packages> 
    <package-name>org.apache.log4j.*</package-name> 
    <package-name>org.jboss.logging.*</package-name> 
</prefer-application-packages> 

Answer 11

किसी को भी है कि एक ही समस्या मैं था का सामना कर सकता है के लिए। यदि आपने यहां दिए गए सभी अन्य समाधानों की कोशिश की है और अभी भी आपके slf4j के साथ काम कर रहे हाइबरनेट लॉगिंग को नहीं देखते हैं, तो ऐसा इसलिए हो सकता है क्योंकि आप एक कंटेनर का उपयोग कर रहे हैं जिसमें उसके फ़ोल्डर पुस्तकालयों में jboss-logging.jar है। इसका मतलब है कि इससे पहले कि आप किसी भी कॉन्फ़िगरेशन को प्रभावित करने के लिए सेट कर सकें, पहले से लोड हो जाता है। वेबलॉगिक में इस समस्या से बचने के लिए आप एप्लिकेशन से लोड की गई लाइब्रेरी को प्राथमिकता देने के लिए कान/मेटा-आईएनएफ में फ़ाइल वेबलॉगिक-एप्लिकेशन.एक्सएमएल में निर्दिष्ट कर सकते हैं। अन्य सर्वर कंटेनर के लिए एक समान तंत्र होना चाहिए।

<?xml version="1.0" encoding="UTF-8"?> 
<wls:weblogic-application xmlns:wls="http://xmlns.oracle.com/weblogic/weblogic-application" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/javaee_5.xsd http://xmlns.oracle.com/weblogic/weblogic-application http://xmlns.oracle.com/weblogic/weblogic-application/1.5/weblogic-application.xsd"> 
    <wls:prefer-application-packages>  
     <!-- logging --> 
     <wls:package-name>org.slf4j.*</wls:package-name> 
     <wls:package-name>org.jboss.logging.*</wls:package-name>    
    </wls:prefer-application-packages> 
    <wls:prefer-application-resources> 
     <wls:resource-name>org/slf4j/impl/StaticLoggerBinder.class</wls:resource-name> 
    </wls:prefer-application-resources>  
</wls:weblogic-application>