如何配置log4j.xml以获取调试信息；“javax.net.debug”；

我想获取LDAP connect ssl握手调试信息，因此我将系统属性“javax.net.debug”值设置为“ssl，握手”，如下所示：

System.property（“javax.net.debug”、“ssl、握手”）
但是我没有得到ssl调试信息。在我的项目中，使用log4j.xml来控制调试信息，所以我想知道如何配置log4j.xml来获得“javax.net.debug”的调试信息？谢谢你的帮助
 您是否已配置记录器？（除了System.property之外）


javax.net中的类
包不会写入
Log4J附件
（实际上它们根本不使用Log4J库）。他们很可能会将调试消息输出到运行java进程的
STDOUT
或
STDERR
流。将这些流重定向到磁盘上的文件，然后您可以将这些消息记录在该文件中。如果您使用的是某台服务器（例如Tomcat或JBoss），请阅读该服务器关于如何控制来自这些进程的I/O流的文档

Log4j.xml
与此无关

编辑：如果您使用的是Tomcat（或Jboss），那么您可能需要在
log4j.xml
中检查
ConsolePender
的日志阈值。默认情况下，它被设置为
INFO
，并重定向到日志目录中的
console.log
文件。
SunJSSE具有内置调试功能，并由系统属性javax.net.debug（-Djavax.net.debug=all）激活。打印到标准输出的调试消息

我扩展了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(); 
    }
} 

包com.mydomain.util.log4j；
导入java.io.PrintStream；
导入java.util.Locale；
导入org.slf4j.Logger；
导入org.slf4j.LoggerFactory；
公共类StdOutLogger扩展了PrintStream
{   
专用静态记录器=
LoggerFactory.getLogger（StdOutLogger.class）；
专用静态易失性StdOutLogger系统输出记录器；
私有静态PrintStream originalStream=System.out；
私有静态布尔值isEnabled=false；
私人建筑商；
私有字符串lineSeparator=System.getProperty（“line.separator”）；
专用StdOutLogger（打印流原件）
{
超级（原件）；
生成器=新的StringBuilder（）；
调试（“将标准输出流重新分配给日志”+行分隔符）；
}
公共静态StdOutLogger getInstance（）
{ 
if（systemOutLogger==null）
{ 
已同步（StdOutLogger.class）
{ 
if（systemOutLogger==null）
systemOutLogger=新的StdOutLogger（原始流）；
} 
} 
返回系统输出记录器；
}
/**
*启用将System.out.println调用转发到记录器
*/
公共静态void enable（）
{
如果（已启用）
返回；
systemOutLogger=StdOutLogger.getInstance（）；
尝试
{
系统放样（系统输出记录器）；
isEnabled=true；
} 
捕获（例外e）
{
logger.error（“未能将标准输出流重新分配给日志：+e.getMessage（））；
}   
}
/**
*禁用转发至记录器，重置控制台的标准输出
*/
公共静态无效禁用（）
{
如果（！isEnabled）
返回；
尝试
{
系统放样（原始流程）；
isEnabled=false；
} 
捕获（例外e）
{
logger.error（“未能重新分配标准输出流：+e.getMessage（））；
}
systemOutLogger=null；
}
@凌驾
public void println（）
{
originalStream.println（）；
printToLogger（行分隔符，假）；
}
@凌驾
公共作废打印（最终字符串s）
{
原始流打印；
打印日志（s，假）；
}
@凌驾
公开作废打印（最终int i）
{
原始流打印（i）；
printToLogger（String.valueOf（i），false）；
}
@凌驾
公开作废打印（最终长l）
{
原始流打印（l）；
printToLogger（字符串.valueOf（l），false）；
}
@凌驾
公开作废打印（最终浮动f）
{
原始流打印（f）；
printToLogger（String.valueOf（f），false）；
}
@凌驾
公开作废打印（最终双d）
{
原始流打印（d）；
printToLogger（String.valueOf（d），false）；
}
@凌驾
公共作废打印（最终对象obj）
{
原始流打印（obj）；
printToLogger（String.valueOf（obj），false）；
}
@凌驾
公共作废打印（字符c）
{
原始流打印（c）；
printToLogger（String.valueOf（c），false）；
}
@凌驾
公共作废打印（布尔b）
{
原始流打印（b）；
printToLogger（String.valueOf（b），false）；
}
@凌驾
public void println（最终字符串s）
{
原始流打印号（s）；
printToLogger（s，正确）；
}
@凌驾
公共无效打印LN（最终整数i）
{
原始流println（i）；
printToLogger（String.valueOf（i），true）；
}
@凌驾
公共作废打印LN（最终长l）
{
原始流println（l）；
printToLogger（String.valueOf（l），真）；
}
@凌驾
公共作废打印LN（最终浮动f）
{
原始流println（f）；
printToLogger（String.valueOf（f），true）；
}
@凌驾
公共作废打印LN（最终双d）
{
原始流println（d）；
printToLogger（String.valueOf（d），true）；
}
@凌驾
公共无效打印LN（最终对象obj）{
原始流println（obj）；
printToLogger（String.valueOf（obj），true）；
}
@凌驾
公共无效打印LN（字符c）{
原始流println（c）；
printToLogger（String.valueOf（c），true）；
}
@凌驾
公共void println（布尔b）{
原创
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(); 
    }
} 

<appender name="STDOUTLOG" class="org.jboss.logging.appender.DailyRollingFileAppender">
    <errorHandler class="org.jboss.logging.util.OnlyOnceErrorHandler"/>
    <param name="File" value="${jboss.server.log.dir}/stdout.log"/>
    <param name="Append" value="false"/>
    <param name="DatePattern" value="'.'yyyy-MM-dd"/>
    <layout class="org.apache.log4j.PatternLayout">
      <!-- The default pattern: Date Priority [Category] (Thread) Message\n -->
      <param name="ConversionPattern" value="%d %-5p [%c] (%t) %m%n"/>
    </layout>
</appender>

<appender name="STDERRLOG" class="org.jboss.logging.appender.DailyRollingFileAppender">
    <errorHandler class="org.jboss.logging.util.OnlyOnceErrorHandler"/>
    <param name="File" value="${jboss.server.log.dir}/stderr.log"/>
    <param name="Append" value="false"/>
    <param name="DatePattern" value="'.'yyyy-MM-dd"/>
    <layout class="org.apache.log4j.PatternLayout">
      <!-- The default pattern: Date Priority [Category] (Thread) Message\n -->
      <param name="ConversionPattern" value="%d %-5p [%c] (%t) %m%n"/>
    </layout>
</appender>

...(snip)...

<category name="STDOUT" additivity="false">
    <priority value="INFO" />
    <appender-ref ref="STDOUTLOG"/>
</category>

<category name="STDERR" additivity="false">
    <priority value="INFO" />
    <appender-ref ref="STDERRLOG"/>
</category>