工具类——使用Timber自定义日志并保存文件查看

---

在Android开发中我们都希望自己的一些重要信息用log打印记录方便以后检查，一般我们都用手机连接电脑，打印日志查看，但是万一是用户的手机，你不可可能拿给开发人员连接你的电脑吧，所以我们把日志信息存放在文件中。

一、本库功能

我们将打造一个基于Timber的实用Log库具有以下功能

• 显示log位置信息（常见功能），
• 将log日志信息输出到本地文件存储

因此需要找一个更好的log库。以下两个都是非常好的。
https://github.com/orhanobut/logger ：简单、漂亮、强大的android logger，github上3000+ Star
https://github.com/JakeWharton/timber ：基于Android原生Log的logger，小巧易扩展。

二、使用Timber进行封装

1、配置

在build.grade中引入Timber：

compile 'com.jakewharton.timber:timber:4.3.1'

在继承Application的自定义类中，设置Timber的树，其实Timber是类似管理着一片森林，具体用哪棵树是你自己这边决定的。比如Timber自带的是DebugTree这个类。

 @Override
    public void onCreate() {
        super.onCreate();
        //在这里先使用Timber.plant注册一个Tree，然后调用静态的.d .v 去使用
        if (BuildConfig.DEBUG) {
            Timber.plant(new Timber.DebugTree());
        } else {
            Timber.plant(new FileLoggingTree());
        }
    }

2、使用

Timber.tag("code_gg");        
Timber.d("test Timber %d",10);

然后上面的FileLoggingTree是我这边自己写的一棵树，就是当我用Timber这个封装库拿到了Log的信息后，后面就可以我们自己处理了。比如写到文件中等。我这边先写了一个傻白甜的FileLoggingTree类，仅供参考。后面我们会用到另外一个第三方，就更强大了。

其中String CacheDiaPath = context.getCacheDir().toString();

    private static class FileLoggingTree extends Timber.Tree{
        /**
         * 使用Timber自定义吧log信息存储到文件中
         * 其中String CacheDiaPath = context.getCacheDir().toString();
         */
        @Override
        protected void log(int priority, String tag, String message, Throwable t) {
            if (TextUtils.isEmpty(CacheDiaPath)) {
                return;
            }
            File file = new File(CacheDiaPath + "/log.txt");
            Log.v("日志存储路径", "file.path:" + file.getAbsolutePath() + ",message:" + message);
            FileWriter writer = null;
            BufferedWriter bufferedWriter = null;

            try {
                writer = new FileWriter(file);
                bufferedWriter = new BufferedWriter(writer);
                bufferedWriter.write(message);
                bufferedWriter.flush();
            }catch (IOException e) {
                Log.v("dyp", "存储文件失败");
                e.printStackTrace();
            }finally {
                if (bufferedWriter != null) {
                    try {
                        bufferedWriter.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }

        }
    }

log方法参数一共有int priority, String tag, String message, Throwable t这四个参数，而我这边就是简单的拿了message这个参数的内容，然后保存到了我指定路径下的log.txt文件中。当然Timber可以自己封装.
比如还有记录崩溃信息的树

    private static class CrashReportingTree extends Timber.Tree {

        @Override
        protected void log(int priority, String tag, String message, Throwable t) {
            if (priority == Log.VERBOSE || priority == Log.DEBUG) {
                return;
            }
            FakeCrashLibrary.log(priority, tag, message);
            if (t != null) {
                if (priority == Log.ERROR) {
                    FakeCrashLibrary.logError(t);
                } else if (priority == Log.WARN) {
                    FakeCrashLibrary.logWarning(t);
                }
            }

        }
    }

当然我觉得我写的挺low的。后来我又去查看了一些能写到文件中的log的第三方。发现了logback-android。
logback-android很强大，可以存储信息到

• files
• SQLite databases
• logcat
• sockets
• syslog
• email

所以我们可以用Timber配合logback-android来模拟存储到文件中。
首先又是老样子，附上logback-android源码地址：

https://github.com/tony19/logback-android

第一步：引入logback-android
Gradle

repositories {
  maven { url 'https://oss.sonatype.org/content/repositories/snapshots' }
}
dependencies {
    compile 'org.slf4j:slf4j-api:1.7.21'
    compile 'com.github.tony19:logback-android-core:1.1.1-6'
    compile 'com.github.tony19:logback-android-classic:1.1.1-6'
}

第二步:在以下位置创建一个logback.xml文件,默认情况下这个路径和文件名是固定的

第三步：配置logback文件

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

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

    <!--声明一个时间戳-->
    <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>

    <!--指定logtest采用BASE_ROLL_FILE声明的RollingFileAppender输出日志-->
    <logger name="logtest">
        <appender-ref ref="BASE_ROLL_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>

还有其他的appender提供,详细说明移步: http://logback.qos.ch/manual/appenders.html

第四步：
可以在代码里面使用logback-android了

//以下日志只会在控制台输出
//        Logger logger = LoggerFactory.getLogger(MainActivity.class);
//        logger.trace("angcyo-->{}","trace");
//        logger.debug("angcyo-->{}","debug");
//        logger.info("angcyo-->{}","info");
//        logger.warn("angcyo-->{}","warn");
//        logger.error("angcyo-->{}","error");

//以下日志会在BASE_ROLL_FILE声明的文件中输出，并且也会在控制台输出
        Logger logger = LoggerFactory.getLogger("logtest");
        logger.trace("angcyo-->{}","trace");
        logger.debug("angcyo-->{}","debug");
        logger.info("angcyo-->{}","info");
        logger.warn("angcyo-->{}","warn");
        logger.error("angcyo-->{}","error");

保存在文件中的Log信息：

现在可以用logback-android 来写一颗树供Timber来使用：

public class FileLoggingTree extends Timber.DebugTree {
        static Logger mLogger = LoggerFactory.getLogger(FileLoggingTree.class);
        @Override
        protected void log(int priority, String tag, String message, Throwable t) {
            if (priority == Log.VERBOSE) {
                return;
            }
            String logMessage = tag + ": " + message;
            switch (priority) {
                case Log.DEBUG:
                    mLogger.debug(logMessage);
                    break;
                case Log.INFO:
                    mLogger.info(logMessage);
                    break;
                case Log.WARN:
                    mLogger.warn(logMessage);
                    break;
                case Log.ERROR:
                    mLogger.error(logMessage);
                    break;
            }
        }

    }

然后再调用Timber.plant(new FileLoggingTree());就可以了。