如何配置log4j.xml以獲取「javax.net.debug」的調試信息

Question

我想獲得LDAP連接ssl握手調試信息，所以我設置了系統屬性「javax.net.debug」value「ssl ，握手」像這樣：

System.property("javax.net.debug" , "ssl,handshake"); ，但我沒有得到SSL調試info.In我的項目，使用的log4j.xml控制調試信息，所以我想知道如何配置的log4j.xml得到「javax.net.debug」的調試信息？謝謝你的幫助！

Answer 1

您是否配置了記錄器？ （除了你System.property）javax.net包內

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE log4j:configuration PUBLIC "-//LOGGER" "http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/xml/doc-files/log4j.dtd"> 

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/"> 

    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender"> 
     <layout class="org.apache.log4j.PatternLayout"> 
      <param name="ConversionPattern" value="%d %-5p %c.%M:%L - %m%n" /> 
     </layout> 
    </appender> 
    <appender name="file" class="org.apache.log4j.RollingFileAppender"> 
     <param name="File" value="/var/opt/log/mylogs.log" /> 
     <param name="maxBackupIndex" value="5" /> 
     <param name="maxFileSize" value="5MB" /> 
     <layout class="org.apache.log4j.PatternLayout"> 
      <param name="ConversionPattern" value="%d{dd/MMM/yyyy HH:mm:ss} %-5p %C{2}.%M - %m%n" /> 
     </layout> 
    </appender> 

    <logger name="javax.net.debug"> 
     <level value="DEBUG" /> 
     <appender-ref ref="STDOUT" /> 
     <appender-ref ref="file" /> 
    </logger> 

</log4j:configuration> 

Answer 2

類不會寫Log4J appenders（INFACT他們不使用Log4j庫在所有）。他們很可能會將調試消息輸出到正在運行的java進程的STDOUT或STDERR流中。將這些流重定向到磁盤上的文件，然後可以將這些消息記錄到文件中。如果您正在使用某個服務器（例如Tomcat或JBoss），請閱讀服務器的文檔以瞭解如何控制來自這些進程的I/O流。

Log4j.xml在這裏沒有什麼可做的。

編輯：如果您使用的是Tomcat（或JBoss應用），那麼你可能需要檢查日誌門檻ConsoleAppender在log4j.xml。默認情況下，它被設置爲INFO，並被重定向到日誌目錄中的console.log文件。

Answer 3

SunJSSE具有內置的調試功能，並由系統屬性javax.net.debug（-Djavax.net.debug = all）激活。調試消息打印到STDOUT。

我擴展了java.io.PrintStream類，並通過轉發所有System.out.print方法調用打印到記錄器，我在由log4j配置的應用程序文件日誌中獲取JSSE調試消息。

我激活重定向只有應用程序的記錄器在調試級別：

if (logger.isDebugEnabled()) 
    StdOutLogger.enable(); 

停用重定向致電：

StdOutLogger.disable(); 

請查看StdOutLogger類：

package com.mydomain.util.log4j; 

import java.io.PrintStream; 
import java.util.Locale; 

import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 

public class StdOutLogger extends PrintStream 
{ 
    private static Logger logger = 
    LoggerFactory.getLogger(StdOutLogger.class); 

    private static volatile StdOutLogger systemOutLogger; 
    private static PrintStream originalStream = System.out; 
    private static boolean isEnabled = false; 

    private StringBuilder builder;  
    private String lineSeparator = System.getProperty("line.separator");  

private StdOutLogger(PrintStream original) 
{ 
    super(original); 
    builder = new StringBuilder(); 
    logger.debug("Reassign standard output stream to log" + lineSeparator); 
} 

public static StdOutLogger getInstance() 
{ 
    if(systemOutLogger == null) 
    { 
     synchronized(StdOutLogger.class) 
     { 
      if(systemOutLogger == null) 
       systemOutLogger = new StdOutLogger(originalStream); 
     } 
    } 
    return systemOutLogger; 
} 

/** 
* Enable forwarding System.out.println calls to the logger 
*/ 
public static void enable() 
{ 
    if (isEnabled) 
     return; 

    systemOutLogger = StdOutLogger.getInstance(); 
    try 
    { 
     System.setOut(systemOutLogger); 
     isEnabled = true; 
    } 
    catch (Exception e) 
    { 
     logger.error("Failed to reassign the standard output stream to log: " + e.getMessage()); 
    } 
} 
/** 
* Disable forwarding to the logger resetting the standard output to the console 
*/ 
public static void disable() 
{ 
    if (!isEnabled) 
     return; 
    try 
    { 
     System.setOut(originalStream);  
     isEnabled = false; 
    } 
    catch (Exception e) 
    { 
     logger.error("Failed to reassign the standard output stream: " + e.getMessage()); 
    } 
    systemOutLogger = null; 
} 

@Override 
public void println() 
{ 
    originalStream.println(); 
    printToLogger(lineSeparator, false); 
} 

@Override 
public void print(final String s) 
{ 
    originalStream.print(s); 
    printToLogger(s, false);     
} 

@Override 
public void print(final int i) 
{ 
    originalStream.print(i); 
    printToLogger(String.valueOf(i), false); 
} 

@Override 
public void print(final long l) 
{ 
    originalStream.print(l); 
    printToLogger(String.valueOf(l), false); 
} 

@Override 
public void print(final float f) 
{ 
    originalStream.print(f); 
    printToLogger(String.valueOf(f), false); 
} 

@Override 
public void print(final double d) 
{ 
    originalStream.print(d); 
    printToLogger(String.valueOf(d), false); 
} 

@Override 
public void print(final Object obj) 
{ 
    originalStream.print(obj); 
    printToLogger(String.valueOf(obj), false); 
} 

@Override 
public void print(char c) 
{ 
    originalStream.print(c); 
    printToLogger(String.valueOf(c), false); 
} 

@Override 
public void print(boolean b) 
{ 
    originalStream.print(b); 
    printToLogger(String.valueOf(b), false); 
} 

@Override 
public void println(final String s) 
{ 
    originalStream.println(s); 
    printToLogger(s, true); 
} 

@Override 
public void println(final int i) 
{ 
    originalStream.println(i); 
    printToLogger(String.valueOf(i), true); 
} 

@Override 
public void println(final long l) 
{ 
    originalStream.println(l); 
    printToLogger(String.valueOf(l), true); 
} 

@Override 
public void println(final float f) 
{ 
    originalStream.println(f); 
    printToLogger(String.valueOf(f), true); 
} 

@Override 
public void println(final double d) 
{ 
    originalStream.println(d); 
    printToLogger(String.valueOf(d), true); 
} 

@Override 
public void println(final Object obj) { 
    originalStream.println(obj); 
    printToLogger(String.valueOf(obj), true); 
} 

@Override 
public void println(char c) { 
    originalStream.println(c); 
    printToLogger(String.valueOf(c), true); 
} 

@Override 
public void println(boolean b) { 
    originalStream.println(b); 
    printToLogger(String.valueOf(b), true); 
} 

@Override 
public PrintStream append(CharSequence csq, int start, int end) 
{ 
    CharSequence cs = (csq == null ? "null" : csq); 
    printToLogger(cs.subSequence(start, end).toString(), false); 
    return this; 
} 

@Override 
public void write(int b) 
{ 
    originalStream.write(b); 
    printToLogger(String.valueOf((char)b), false);     
} 

@Override 
public void write(byte buf[], int off, int len) 
{ 
    originalStream.write(buf, off, len); 
    if (buf == null) 
    { 
     throw new NullPointerException(); 
    } 
    else if ((off < 0) || (off > buf.length) || (len < 0) || 
       ((off + len) > buf.length) || ((off + len) < 0)) { 
     throw new IndexOutOfBoundsException(); 
    } 
    else if (len == 0) { 
     return; 
    } 
    byte[] pb = new byte[len]; 
    for (int i = 0 ; i < len ; i++) { 
     pb[i] = (buf[off + i]); 
    } 
    String str = new String(pb); 
    printToLogger(str, false);    
} 

@Override 
public PrintStream printf(String format, Object ... args) 
{ 
    return format(format, args); 
} 

@Override   
public PrintStream format(String format, Object ... args) 
{ 
    originalStream.format(format, args); 
    printToLogger(String.format(format, args), false); 
    return this; 
} 

@Override 
public PrintStream format(Locale l, String format, Object ... args) 
{ 
    originalStream.format(l, format, args); 
    printToLogger(String.format(format, args), false); 
    return this; 
}   

@Override 
public void flush() 
{ 
    originalStream.flush(); 
    if (builder.length() > 0) 
    { 
     logger.debug(builder.toString()); 
     builder = new StringBuilder(); 
    } 
    //builder.append(lineSeparator); 
} 

private void printToLogger(String str, boolean isNewLine) 
{  
    if (str.endsWith(lineSeparator)) 
    { 
     int endIndex = str.lastIndexOf(lineSeparator); 
     str = str.substring(0, endIndex); 
     isNewLine = true; 
    } 
    builder.append(str); 
    if (isNewLine) 
    { 
     logger.debug(builder.toString()); 
     builder = new StringBuilder(); 
    } 
} 

}