रूट-लॉगर WARN

Question

के साथ स्प्रिंग-बूट बैनर प्रदर्शित करें विकास और परीक्षण वातावरण के तहत रूट लॉगर स्तर DEBUG या INFO है। वसंत-बूट बैनर स्टार्टअप पर प्रदर्शित होता है:

2017-03-23 14:31:00,322 [INFO ]     - 
:: Spring Boot ::   (v1.5.2.RELEASE) 
:: Application ::   AcMe (v1.0-SNAPSHOT) 
:: Build ::    2017-03-23 09:53 

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

लॉगबैक को कॉन्फ़िगर कैसे करें ताकि बैनर उत्पादन में भी प्रदर्शित किया जा सके?

मेरा अनुमान है एक और लकड़हारा जोड़ने के लिए था, लेकिन निम्नलिखित (और एक जैसे विन्यास) काम नहीं किया:

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

यहाँ मेरी विन्यास

application.properties:

spring.main.banner-mode=log 

आवेदन -devel.properties:

logging.config=classpath:logging-spring-devel.xml 

application-production.properties:

प्रवेश-devel.xml (बैनर प्रदर्शित किया)

 LOG_PATH:-${LOG_TEMP:-${java.io.tmpdir:-/tmp}}/}application.log}"/> 
     <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender"> 
      <file>${LOG_FILE}</file> 
      ... 
     </appender> 
     <root level="INFO"> 
      <appender-ref ref="FILE"/> 
     </root> 
    </configuration> 

प्रवेश-production.xml (बैनर प्रदर्शित नहीं)

 LOG_PATH:-${LOG_TEMP:-${java.io.tmpdir:-/tmp}}/}application.log}"/> 
     <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender"> 
      <file>${LOG_FILE}</file> 
      ... 
     </appender> 
     <root level="WARN"> 
      <appender-ref ref="FILE"/> 
     </root> 
    </configuration> 

Answer 1

एक बैनर प्रिंटिंग के दौरान स्प्रिंग बूट के INFO स्तर के लॉगर का उपयोग करता है।

साधारण समाधान इस विशेष वर्ग के लिए INFO स्तर सक्षम करने के लिए किया जाएगा: एक वर्ग के लिए प्रवेश स्तर बदलने

<logger name="org.springframework.boot.SpringApplication" 
     level="INFO" additivity="false"> 
    <appender-ref ref="FILE"/> 
</logger> 

Answer 2

यह वह जगह है , मैं किसके साथ आया था। यह नियमित कार्यान्वयन में केवल लॉगर को बदलने के विचार के आसपास लपेटता है।

डिफ़ॉल्ट लॉग कार्यान्वयन का उपयोग करने में समस्या है जिस तरह से कॉमन्स-लॉगिंग को slf4j पुल के माध्यम से अनुकूलित किया जाता है।

यह शायद, ugliest कोड जीवित में से एक है इसलिए उम्मीद है कि हम आगामी वसंत-बूट विज्ञप्ति में एक फिक्स देखेंगे ...

चरण 1: रजिस्टर एक नया आवेदन श्रोता

/META-INF /spring.factory

org.springframework.context.ApplicationListener=ac.me.appevents.BannerDisplay 

चरण 2: लागू आवेदन श्रोता

package ac.me.appevents; 

import org.jetbrains.annotations.NotNull; 
import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
import org.slf4j.Marker; 
import org.slf4j.MarkerFactory; 
import org.springframework.boot.ResourceBanner; 
import org.springframework.boot.context.event.ApplicationEnvironmentPreparedEvent; 
import org.springframework.context.ApplicationListener; 
import org.springframework.core.env.Environment; 
import org.springframework.core.io.DefaultResourceLoader; 
import org.springframework.core.io.Resource; 
import org.springframework.core.io.ResourceLoader; 
import org.springframework.util.ClassUtils; 

import java.io.ByteArrayOutputStream; 
import java.io.PrintStream; 
import java.io.UnsupportedEncodingException; 

public class BannerDisplay implements ApplicationListener<ApplicationEnvironmentPreparedEvent> { 
    /** 
    * Banner location property key. 
    */ 
    private static final String BANNER_LOCATION_PROPERTY = "banner.location"; 

    /** 
    * Default banner location. 
    */ 
    private static final String BANNER_LOCATION_PROPERTY_VALUE = "banner.txt"; 

    private static final Logger LOG = LoggerFactory.getLogger(BannerDisplay.class); 

    private static final Marker MRK = MarkerFactory.getMarker("Banner"); 

    private ResourceLoader resourceLoader; 

    private Class<?> deduceMainApplicationClass() { 
     try { 
      StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); 
      for (StackTraceElement stackTraceElement : stackTrace) { 
       if ("main".equals(stackTraceElement.getMethodName())) { 
        return Class.forName(stackTraceElement.getClassName()); 
       } 
      } 
     } 
     catch (ClassNotFoundException ex) { 
      // Swallow and continue 
     } 
     return null; 
    } 

    @Override 
    public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) { 
     Environment environment = event.getEnvironment(); 

     String location = environment.getProperty(BANNER_LOCATION_PROPERTY, BANNER_LOCATION_PROPERTY_VALUE); 
     ResourceLoader resLoader = getResourceLoader(); 
     Resource resource = resLoader.getResource(location); 
     if (resource.exists()) { 
      ResourceBanner banner = new ResourceBanner(resource); 
      ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
      banner.printBanner(environment, deduceMainApplicationClass(), new PrintStream(baos)); 
      String charset = environment.getProperty("banner.charset", "UTF-8"); 
      try { 

       LOG.info(MRK, baos.toString(charset)); 
      } 
      catch (UnsupportedEncodingException e) { 
       LOG.warn(MRK, "Unsupported banner charset encoding.", e); 
      } 

     } 
    } 

    @NotNull 
    private ResourceLoader getResourceLoader() { 
     if (resourceLoader == null) { 
      this.resourceLoader = new DefaultResourceLoader(ClassUtils.getDefaultClassLoader()); 
     } 
     return resourceLoader; 
    } 

    public void setResourceLoader(final ResourceLoader resourceLoader) { 
     this.resourceLoader = resourceLoader; 
    } 
} 

Answer 3

सबसे पहले, मुझे यह स्वीकार करना होगा कि मैंने इसका परीक्षण नहीं किया है, लेकिन कम से कम यह आपको कुछ विचार दे सकता है।

आप spring.main.banner-mode=log हटा सकते हैं और अपना खुद का रैपर कार्यान्वयन प्रदान कर सकते हैं जो प्रदत्त आउटपुट स्ट्रीम के बजाय लॉगर का उपयोग करेगा।कोड कुछ इस तरह दिखना चाहिए:

public class BannerLoggerWrapper implements Banner { 

    private static final Log logger = LogFactory.getLog(BannerLoggerWrapper.class); 
    private Banner actual; 

    public BannerLoggerWrapper(Banner actual) { 
     this.actual = actual; 
    } 

    @Override 
    public void printBanner(Environment environment, Class<?> sourceClass, PrintStream out) { 
     try { 
      logger.info(createStringFromBanner(environment, sourceClass)); 
     } catch (UnsupportedEncodingException ex) { 
      logger.warn("Failed to create String for banner", ex); 
     } 
    } 

    private String createStringFromBanner(Environment environment, Class<?> sourceClass) throws UnsupportedEncodingException { 
     ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
     actual.printBanner(environment, sourceClass, new PrintStream(baos)); 
     String charset = environment.getProperty("banner.charset", "UTF-8"); 
     return baos.toString(charset); 
    } 

} 

आप इस कक्षा में logger.warn साथ logger.info जगह ले सकता है या आप इस लकड़हारा के लिए specificaly अतिरिक्त config बना सकते हैं:

<logger name="your.package.name.BannerLoggerWrapper" level="INFO" additivity="false"> 
    <appender-ref ref="FILE"/> 
</logger> 

documentation के अनुसार आप स्प्रिंग बूट करने के लिए कॉन्फ़िगर कर सकते हैं SpringApplication.setBanner(…​) का उपयोग करके अपने बैनर कार्यान्वयन का उपयोग करें।