logback在安卓的配置

前言
Logback是由log4j创始人设计的又一个开源日志组件。logback当前分成三个模块：logback-core,logback- classic和logback-access。logback-core是其它两个模块的基础模块。logback-classic是log4j的一个 改良版本。此外logback-classic完整实现SLF4J API使你可以很方便地更换成其它日志系统如log4j或JDK14 Logging。logback-access访问模块与Servlet容器集成提供通过Http来访问日志的功能。
这边android的配置比较简单，底下是我的logbackjar包：

可以看到里面有classic和core两个包，由于我这便是自己整合进去self4j这个包，所以大家不用再手动加入sel4f这个包了。我把这个包放入了libs底下
配置
这步骤，其实是利用assets包的自动加载功能，实现日志的配置初始化。因此在assets里面放入logback.xml这个包，logback.xml这个包在我这边的配置如下：

<!--debug属性用来决定是否打印logback的日志信息-->
<configuration debug='false'>

    <!--声明一个属性,用来指定log文件存放的路径-->
    <property name="LOG_DIR" value="/sdcard/Framework/frameworkLog"/>

    <!--声明一个时间戳-->
    <timestamp datePattern="yyyyMMdd" key="today"/>

    <!--用于在控制台输出的Appender-->
    <appender name="LOGCAT" class="ch.qos.logback.classic.android.LogcatAppender">
        <encoder>
            <pattern>%-5relative [%thread][%file:%M:%line] - %msg%n</pattern>
        </encoder>
    </appender>

    <!--声明一个FileAppender-->
    <appender name="BASE_FILE" class="ch.qos.logback.core.FileAppender">
        <!--初始化的时候不创建文件,在第一次使用的时候创建文件-->
        <lazy>true</lazy>
        <!--log追加到文件,否则覆盖文件-->
        <append>true</append>
        <!--用来保存log的文件全路径-->
        <file>${LOG_DIR}/base.log</file>
        <!--输出log的格式-->
        <encoder>
            <!--<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} [%file:%line] - %msg%n</pattern>-->
            <pattern>%date [%thread] %-5level %logger{36} [%file:%line] - %msg%n</pattern>
        </encoder>
    </appender>

    <!--声明一个RollingFileAppender-->
    <appender name="BASE_ROLL_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_DIR}/base.roll.${today}.log</file>
        <append>true</append>
        <encoder>
            <pattern>%date %-5relative [%thread] %-5level %logger{36} [%file:%M:%line] - %msg%n
            </pattern>
        </encoder>

        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOG_DIR}/base.roll.%d{yyyy-MM-dd}.log</fileNamePattern>
            <!--最大保存7天的日志-->
            <maxHistory>7</maxHistory>
        </rollingPolicy>

        <!--文件大于10mb,切换文件-->
        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
            <maxFileSize>10MB</maxFileSize>
        </triggeringPolicy>
    </appender>

    <!--指定frameworkLog采用BASE_ROLL_FILE声明的RollingFileAppender输出日志-->
    <logger name="frameworkLog">
        <appender-ref ref="BASE_ROLL_FILE"/>
    </logger>

    <!--指定baseLog采用BASE_FILE声明的FileAppender输出日志-->
    <logger name="baseLog">
        <appender-ref ref="BASE_FILE"/>
    </logger>


    <!-- Write INFO (and higher-level) messages to the log file -->
    <root level="TRACE">
        <appender-ref ref="LOGCAT"/>
    </root>

    <!--支持的level-->
    <!--TRACE-->
    <!--DEBUG-->
    <!--INFO-->
    <!--WARN-->
    <!--ERROR-->

    <!--<pattern>
      %d{yyyy-MM-dd HH:mm:ss} [%level] - %msg%n
      Logger: %logger
      Class: %class
      File: %file
      Caller: %caller
      Line: %line
      Message: %m
      Method: %M
      Relative: %relative
      Thread: %thread
      Exception: %ex
      xException: %xEx
      nopException: %nopex
      rException: %rEx
      Marker: %marker
      %n
  </pattern>-->

    <!--引用其他位置的配置信息-->
    <!--<includes>-->
    <!--<include file="/sdcard/foo.xml"/>-->
    <!--<include resource="assets/config/test.xml"/>-->
    <!--<include resource="AndroidManifest.xml"/>-->

    <!--<include file="/sdcard/logback/logback-test.xml"/>-->
    <!--<include file="/sdcard/logback/logback.xml"/>-->
    <!--<include resource="AndroidManifest.xml"/>-->
    <!--<include resource="assets/logback-test.xml"/>-->
    <!--<include resource="assets/logback.xml"/>-->
    <!--</includes>-->
</configuration>

LOG_DIR是日志的主保存目录，例如我这边是/sdcard/Framework/frameworkLog，就保存在这个目录下。
LogcatAppender这个是输出的格式
FileAppender是基础的FileAppender，可以在

 <logger name="frameworkLog">
        <appender-ref ref="BASE_ROLL_FILE"/>
    </logger>

配置输出器
pattern标签是输出的格式
file标签是文件保存路径
append如果是true就是日志不覆盖式保存
RollingFileAppender是按天固定生成的日志
LogcatAppender这是在控制台输出的日志
这里配置完毕，接下来写个工具类：

package com.zzy.framework.util;

import com.zzy.framework.global.GlobalData;

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

public class LogUtil {
    /**
     * 获得Logger
     *
     * @param clazz 日志发出的类
     * @return Logger
     */
    public static Logger get(Class<?> clazz) {
        return LoggerFactory.getLogger(clazz);
    }

    /**
     * 获得Logger
     *
     * @param name 自定义的日志发出者名称
     * @return Logger
     */

    public static Logger get(String name) {
        return LoggerFactory.getLogger(name);
    }

    /**
     * @return 获得日志，自动判定日志发出者
     */

    public static Logger get() {
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        return LoggerFactory.getLogger(stackTrace[2].getClassName());
    }

    /**
     * Trace等级日志，小于debug<br>
     * <p/>
     * <p/>
     * 由于动态获取Logger，效率较低，建议在非频繁调用的情况下使用！！
     *
     * @param format    格式文本，{} 代表变量
     * @param arguments 变量对应的参数
     */

    public static void trace(String format, Object... arguments) {
        if (GlobalData.isDebug) {
            trace(innerGet(), format, arguments);
        }
    }

    /**
     * Trace等级日志，小于Debug
     *
     * @param log       日志对象
     * @param format    格式文本，{} 代表变量
     * @param arguments 变量对应的参数
     */

    public static void trace(Logger log, String format, Object... arguments) {
        if (GlobalData.isDebug) {
            log.trace(format, arguments);
        }
    }

    /**
     * Debug等级日志，小于Info<br>
     * <p/>
     * <p/>
     * 由于动态获取Logger，效率较低，建议在非频繁调用的情况下使用！！
     *
     * @param format    格式文本，{} 代表变量
     * @param arguments 变量对应的参数
     */

    public static void debug(String format, Object... arguments) {
        if (GlobalData.isDebug) {
            debug(innerGet(), format, arguments);
        }
    }

    /**
     * Debug等级日志，小于Info
     *
     * @param log       日志对象
     * @param format    格式文本，{} 代表变量
     * @param arguments 变量对应的参数
     */

    public static void debug(Logger log, String format, Object... arguments) {
        if (GlobalData.isDebug) {
            log.debug(format, arguments);
        }
    }

    /**
     * Info等级日志，小于Warn<br>
     * <p/>
     * <p/>
     * 由于动态获取Logger，效率较低，建议在非频繁调用的情况下使用！！
     *
     * @param format    格式文本，{} 代表变量
     * @param arguments 变量对应的参数
     */

    public static void info(String format, Object... arguments) {
        if (GlobalData.isDebug) {
            info(innerGet(), format, arguments);
        }
    }

    /**
     * Info等级日志，小于Warn
     *
     * @param log       日志对象
     * @param format    格式文本，{} 代表变量
     * @param arguments 变量对应的参数
     */

    public static void info(Logger log, String format, Object... arguments) {
        if (GlobalData.isDebug) {
            log.info(format, arguments);
        }
    }

    /**
     * Warn等级日志，小于Error<br>
     * <p/>
     * <p/>
     * 由于动态获取Logger，效率较低，建议在非频繁调用的情况下使用！！
     *
     * @param format    格式文本，{} 代表变量
     * @param arguments 变量对应的参数
     */

    public static void warn(String format, Object... arguments) {
        if (GlobalData.isDebug) {
            warn(innerGet(), format, arguments);
        }
    }


    /**
     * Warn等级日志，小于Error
     *
     * @param log       日志对象
     * @param format    格式文本，{} 代表变量
     * @param arguments 变量对应的参数
     */

    public static void warn(Logger log, String format, Object... arguments) {
        if (GlobalData.isDebug) {
            log.warn(format, arguments);
        }
    }


    /**
     * Warn等级日志，小于Error<br>
     * <p/>
     * <p/>
     * 由于动态获取Logger，效率较低，建议在非频繁调用的情况下使用！！
     *
     * @param e         需在日志中堆栈打印的异常
     * @param format    格式文本，{} 代表变量
     * @param arguments 变量对应的参数
     */

    public static void warn(Throwable e, String format, Object... arguments) {
        if (GlobalData.isDebug) {
            warn(innerGet(), e, format(format, arguments));
        }
    }

    /**
     * Warn等级日志，小于Error
     *
     * @param log       日志对象
     * @param e         需在日志中堆栈打印的异常
     * @param format    格式文本，{} 代表变量
     * @param arguments 变量对应的参数
     */

    public static void warn(Logger log, Throwable e, String format, Object... arguments) {
        if (GlobalData.isDebug) {
            log.warn(format(format, arguments), e);
        }
    }

    /**
     * Error等级日志<br>
     * <p/>
     * <p/>
     * 由于动态获取Logger，效率较低，建议在非频繁调用的情况下使用！！
     *
     * @param format    格式文本，{} 代表变量
     * @param arguments 变量对应的参数
     */

    public static void error(String format, Object... arguments) {
        if (GlobalData.isDebug) {
            error(innerGet(), format, arguments);
        }
    }

    /**
     * Error等级日志<br>
     *
     * @param log       日志对象
     * @param format    格式文本，{} 代表变量
     * @param arguments 变量对应的参数
     */

    public static void error(Logger log, String format, Object... arguments) {
        if (GlobalData.isDebug) {
            log.error(format, arguments);
        }
    }

    /**
     * Error等级日志<br>
     * <p/>
     * <p/>
     * 由于动态获取Logger，效率较低，建议在非频繁调用的情况下使用！！
     *
     * @param e         需在日志中堆栈打印的异常
     * @param format    格式文本，{} 代表变量
     * @param arguments 变量对应的参数
     */

    public static void error(Throwable e, String format, Object... arguments) {
        if (GlobalData.isDebug) {
            error(innerGet(), e, format(format, arguments));
        }
    }


    /**
     * Error等级日志<br>
     * <p/>
     * <p/>
     * 由于动态获取Logger，效率较低，建议在非频繁调用的情况下使用！！
     *
     * @param log       日志对象
     * @param e         需在日志中堆栈打印的异常
     * @param format    格式文本，{} 代表变量
     * @param arguments 变量对应的参数
     */

    public static void error(Logger log, Throwable e, String format, Object... arguments) {
        if (GlobalData.isDebug) {
            log.error(format(format, arguments), e);
        }
    }

    /**
     * 格式化文本
     *
     * @param template 文本模板，被替换的部分用 {} 表示
     * @param values   参数值
     * @return 格式化后的文本
     */

    private static String format(String template, Object... values) {
        return String.format(template.replace("{}", "%s"), values);
    }

    /**
     * @return 获得日志，自动判定日志发出者
     */
    private static Logger innerGet() {
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        return LoggerFactory.getLogger(stackTrace[3].getClassName());
    }

}

这是我配置的工具类，调用方法通过，无非用通过：

    private Logger log = LogUtil.get("frameworkLog");
     LogUtil.info(log, TAG, "onDestroy");

 这种调用方式。就可以在每天的日志输出了，借下来你可以去/sdcard/Framework/frameworkLog自己设置的目录下看看日志