Java 以编程方式配置LogBack。阿盖恩

在我的android程序中，我使用slf4j logback。使用xml配置，所有功能都可以正常工作：

<configuration>
<property name="LOG_DIR" value="/sdcard/Results/.logs" />
<appender
        name="LOGCAT"
        class="ch.qos.logback.classic.android.LogcatAppender" >
    <tagEncoder>
        <pattern>akrit</pattern>
    </tagEncoder>
    <encoder>
        <pattern>[%class{0}][%thread] %msg%n</pattern>
    </encoder>
</appender>

<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>${LOG_DIR}/log.txt</file>
    <append>true</append>
    <encoder>
        <pattern>%date{ISO8601} [%thread] %-5level %logger{0} %msg%n</pattern>
    </encoder>
    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
        <fileNamePattern>${LOG_DIR}/log.%d.txt</fileNamePattern>
        <maxHistory>14</maxHistory>
    </rollingPolicy>
</appender>

<root level="DEBUG" >
    <appender-ref ref="LOGCAT" />
    <appender-ref ref="FILE" />
</root>

阿克丽特
[%class{0}][%thread]%msg%n
${LOG\u DIR}/LOG.txt
真的
%日期{ISO8601}[%thread]-5级别%logger{0}%msg%n
${LOG\u DIR}/LOG.%d.txt
14

但以编程方式配置的相同代码逻辑不起作用-logcat和logfile为空：

package projects.common.logger;

import org.slf4j.LoggerFactory;
import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.android.LogcatAppender;
import ch.qos.logback.classic.encoder.PatternLayoutEncoder;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.rolling.RollingFileAppender;
import ch.qos.logback.core.rolling.TimeBasedRollingPolicy;
public class LogBack {
    private static boolean debugMode = true;
    private static String logPath = null;
    public static Logger getLogger(Class<?> _clazz) {
        //return getLoggerXML(_clazz);
        return configureLogbackDirectly(_clazz, debugMode, logPath);
    }
    public static Logger getLoggerXML(Class<?> _clazz) {
        return (Logger) LoggerFactory.getLogger(_clazz);
    }
    public static void setDebugMode(boolean _debugMode) {
        debugMode = _debugMode;
    }
    public static void setLogPath(String _logPath) {
        logPath = _logPath;
    }
    private static Logger configureLogbackDirectly(Class<?> _clazz, boolean _debug, String _logPath) {
        LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
        context.reset();
        Logger root = (Logger) LoggerFactory.getLogger(_clazz);
        root.setLevel(Level.ERROR);
        if (_debug)
            root.setLevel(Level.DEBUG);
        root.addAppender(logCat(context));
        if (_logPath != null)
            root.addAppender(logFile(context, _logPath));
        return root;
    }
    private static RollingFileAppender<ILoggingEvent> logFile(LoggerContext _context, String _filePath) {
        RollingFileAppender<ILoggingEvent> rollingFileAppender = new RollingFileAppender<ILoggingEvent>();
        rollingFileAppender.setAppend(true);
        rollingFileAppender.setContext(_context);
        rollingFileAppender.setFile(_filePath + "/log.txt");
        TimeBasedRollingPolicy<ILoggingEvent> rollingPolicy = new TimeBasedRollingPolicy<ILoggingEvent>();
        rollingPolicy.setFileNamePattern(_filePath + "/log.%d.txt");
        rollingPolicy.setMaxHistory(7);
        rollingPolicy.setParent(rollingFileAppender);
        rollingPolicy.setContext(_context);
        rollingPolicy.start();
        rollingFileAppender.setRollingPolicy(rollingPolicy);
        PatternLayoutEncoder encoder = new PatternLayoutEncoder();
        encoder.setPattern("%date{ISO8601} [%thread] %-5level %logger{0} %msg%n");
        encoder.setContext(_context);
        encoder.start();
        rollingFileAppender.setEncoder(encoder);
        rollingFileAppender.setName("rollingFileAppender");
        rollingFileAppender.start();
        return rollingFileAppender;
    }
    private static LogcatAppender logCat(LoggerContext _context) {
        PatternLayoutEncoder encoder = new PatternLayoutEncoder();
        encoder.setContext(_context);
        encoder.setPattern("[%thread] %msg%n");
        encoder.start();
        PatternLayoutEncoder tag_encoder = new PatternLayoutEncoder();
        tag_encoder.setContext(_context);
        tag_encoder.setPattern("%class{0}");
        tag_encoder.start();
        LogcatAppender logcatAppender = new LogcatAppender();
        logcatAppender.setContext(_context);
        logcatAppender.setEncoder(encoder);
        logcatAppender.setTagEncoder(tag_encoder);
        logcatAppender.setName("logcatAppender");
        logcatAppender.start();
        return logcatAppender;
    }
}

package projects.common.logger；
导入org.slf4j.LoggerFactory；
导入ch.qos.logback.classic.Level；
导入ch.qos.logback.classic.Logger；
导入ch.qos.logback.classic.LoggerContext；
导入ch.qos.logback.classic.android.LogcatAppender；
导入ch.qos.logback.classic.encoder.PatternLayoutEncoder；
导入ch.qos.logback.classic.spi.ILoggingEvent；
导入ch.qos.logback.core.rolling.RollingFileAppender；
导入ch.qos.logback.core.rolling.TimeBasedRollingPolicy；
公共类回写{
私有静态布尔调试模式=true；
私有静态字符串logPath=null；
公共静态记录器getLogger（clazz类）{
//返回getLoggerXML（_clazz）；
直接返回configurelogback（_clazz，debugMode，logPath）；
}
公共静态记录器getLoggerXML（类_clazz）{
return（Logger）LoggerFactory.getLogger（_clazz）；
}
公共静态void setDebugMode（布尔_debugMode）{
debugMode=_debugMode；
}
公共静态void setLogPath（字符串_logPath）{
logPath=_logPath；
}
专用静态记录器直接配置Logback（类_clazz、布尔_debug、字符串_logPath）{
LoggerContext=（LoggerContext）LoggerFactory.getILoggerFactory（）；
reset（）；
Logger root=（Logger）LoggerFactory.getLogger（_clazz）；
root.setLevel（Level.ERROR）；
如果（_调试）
setLevel（Level.DEBUG）；
addAppender（logCat（context））；
如果（_logPath！=null）
addAppender（日志文件（上下文，_logPath））；
返回根；
}
私有静态RollingFileAppender日志文件（LoggerContext\u context，String\u filePath）{
RollingFileAppender RollingFileAppender=新的RollingFileAppender（）；
rollingFileAppender.setAppend（true）；
rollingFileAppender.setContext（_context）；
rollingFileAppender.setFile（_filePath+“/log.txt”）；
TimeBasedRollingPolicy rollingPolicy=新的TimeBasedRollingPolicy（）；
rollingPolicy.setFileNamePattern（_filePath+“/log.%d.txt”）；
rollingPolicy.setMaxHistory（7）；
rollingPolicy.setParent（rollingFileAppender）；
rollingPolicy.setContext（_context）；
rollingPolicy.start（）；
rollingFileAppender.setRollingPolicy（rollingPolicy）；
PatternLayoutCoder编码器=新PatternLayoutCoder（）；
setPattern（“%date{ISO8601}[%thread]-5level%logger{0}%msg%n”）；
编码器.setContext（_context）；
encoder.start（）；
rollingFileAppender.setEncoder（编码器）；
setName（“rollingFileAppender”）；
rollingFileAppender.start（）；
返回rollingFileAppender；
}
专用静态LogcatAppender logCat（LoggerContext\u context）{
PatternLayoutCoder编码器=新PatternLayoutCoder（）；
编码器.setContext（_context）；
编码器.setPattern（“[%thread]%msg%n”）；
encoder.start（）；
PatternLayoutCoder标记_编码器=新PatternLayoutCoder（）；
tag_encoder.setContext（_context）；
tag_encoder.setPattern（“%class{0}”）；
tag_encoder.start（）；
LogcatAppender LogcatAppender=新LogcatAppender（）；
logcatAppender.setContext（_context）；
logcatAppender.setEncoder（编码器）；
logcatAppender.setTagEncoder（tag_编码器）；
logcatAppender.setName（“logcatAppender”）；
logcatAppender.start（）；
返回logcatAppender；
}
}

i、 e.如果活动行“return getLoggerXML（_clazz）；”-全部正常， “直接返回configureLogback（_clazz，debugMode，logPath）；”-无。 怎么了