优化KLog工具文件保存

感谢凯哥的KLog，对我的Android开发给予了很大的帮助。KLog是一款开发中很好用的log工具，功能都很棒，就是在日志保存这有点瑕疵。最近由于项目需要把log存储本地中方便后面问题排查，看下KLog的保存只支持单条日志单个文件保存，这样很不好，我的需求是实现全局配置后的log保存，并清理清理指定过期时间前的文件，所以我就安装我的需要修改了源码，为了方便自己和大家就写了这边文章，欢迎大家点评。

主要修改两个地方，一是 、修改KLog的初始化方法如下：

/**
     * init Plog
     */
    public synchronized static void init(Application application, boolean debug) {
        mContext = application.getApplicationContext();
        DEBUG = debug;
        //7 day expired
        deleteExpiredLogs(7);
    }

二是、在打印log新里执行本地文件保存，我自己只需要保存“D”、“E”两个级别的log。

private static void printLog(int type, String tagStr, Object... objects) {
        if (!DEBUG) {
            return;
        }
        String[] contents = wrapperContent(STACK_TRACE_INDEX_5, tagStr, objects);

        String tag = contents[0];
        String msg = contents[1];
        String headString = contents[2];
        if (type==D||type==E){
            print(type, tagStr, headString, Arrays.toString(objects));
        }
        switch (type) {
            case V:
            case D:
            case I:
            case W:
            case E:
            case A:
                printDefault(type, tag, headString, headString + msg);
                break;
            case J:
                printJson(tag, msg, headString);
                break;
            case X:
                printXml(tag, msg, headString);
                break;
            default:
        }
    }

就是这么简单，本地log，studio log两不误。还可以不少完善地方，比如可以指定log是否保存，而不是全部强制保存，比如配置保存的日志级别等，这边可以工具直接的需要去定制，下面是log工具完整源码。

/**
 * 说明：
 *
 * @author Pan Yingdao
 * @time : 2019/9/24/024
 */
public class Plog {
    private static final String LINE_SEPARATOR = System.getProperty("line.separator");
    private static final String NULL_TIPS = "Log with null object";
    private static final String TAG = "Plog";
    private static final String SUFFIX = ".java";
    private static final int V = 0x1;
    private static final int D = 0x2;
    private static final int I = 0x3;
    private static final int W = 0x4;
    private static final int E = 0x5;
    private static final int A = 0x6;
    private static final int J = 0x7;
    private static final int X = 0x8;
    private static boolean DEBUG = true;
    private static String mGlobalTag;
    private static boolean mIsGlobalTagEmpty = true;
    @SuppressLint("StaticFieldLeak")
    private static Context mContext;

    /**
     * init Plog
     */
    public synchronized static void init(Application application, boolean debug) {
        mContext = application.getApplicationContext();
        DEBUG = debug;
        //7 day expired
        deleteExpiredLogs(7);
    }

    /**
     * init Plog
     */
    public synchronized static void init(Application application, boolean debug, @Nullable String tag) {
        mContext = application.getApplicationContext();
        DEBUG = debug;
        mGlobalTag = tag;
        mIsGlobalTagEmpty = TextUtils.isEmpty(mGlobalTag);
        //7 day expired
        deleteExpiredLogs(7);
    }

    public static void v(Object msg) {
        printLog(V, null, msg);
    }

    public static void v(String tag, Object... objects) {
        printLog(V, tag, objects);
    }

    public static void d(Object msg) {
        printLog(D, null, msg);
    }

    public static void d(String tag, Object... objects) {
        printLog(D, tag, objects);
    }

    public static void i(Object msg) {
        printLog(I, null, msg);
    }

    public static void i(String tag, Object... objects) {
        printLog(I, tag, objects);
    }

    public static void w(Object msg) {
        printLog(W, null, msg);
    }

    public static void w(String tag, Object... objects) {
        printLog(W, tag, objects);
    }

    public static void e(Object msg) {
        printLog(E, null, msg);
    }

    public static void e(String tag, Object... objects) {
        printLog(E, tag, objects);
    }

    public static void a(Object msg) {
        printLog(A, null, msg);
    }

    public static void a(String tag, Object... objects) {
        printLog(A, tag, objects);
    }

    public static void json(String jsonFormat) {
        printLog(J, null, jsonFormat);
    }

    public static void json(String tag, String jsonFormat) {
        printLog(J, tag, jsonFormat);
    }

    public static void xml(String xml) {
        printLog(X, null, xml);
    }

    private static void printLog(int type, String tagStr, Object... objects) {
        if (!DEBUG) {
            return;
        }
        String[] contents = wrapperContent(tagStr, objects);

        String tag = contents[0];
        String msg = contents[1];
        String headString = contents[2];

        if (type==D||type==E){
            print(type, tagStr, headString, Arrays.toString(objects));
        }
        switch (type) {
            case V:
            case D:
            case I:
            case W:
            case E:
            case A:
                printDefault(type, tag, headString, headString + msg);
                break;
            case J:
                printJson(tag, msg, headString);
                break;
            case X:
                printXml(tag, msg, headString);
                break;
            default:
        }
    }

    private static String[] wrapperContent2(String tagStr, Object... objects) {
        final int stackTraceIndex = 5;
        final String suffix = ".java";
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        StackTraceElement targetElement = stackTrace[stackTraceIndex];
        String className = targetElement.getClassName();
        String[] classNameInfo = className.split("\\.");
        if (classNameInfo.length > 0) {
            className = classNameInfo[classNameInfo.length - 1] + suffix;
        }
        if (className.contains("$")) {
            className = className.split("\\$")[0] + suffix;
        }
        String methodName = targetElement.getMethodName();
        int lineNumber = targetElement.getLineNumber();
        if (lineNumber < 0) {
            lineNumber = 0;
        }
        String methodNameShort = methodName.substring(0, 1).toUpperCase() + methodName.substring(1);
        String tag = (tagStr == null ? className : tagStr);
        if (TextUtils.isEmpty(tag)) {
            tag = TAG;
        }
        String msg = (objects == null) ? NULL_TIPS : getObjectsString(objects);
        String headString = "[ (" + className + ":" + lineNumber + ")#" + methodNameShort + " ] ";
        return new String[]{tag, msg, headString};
    }

    private static String[] wrapperContent(String tagStr, Object... objects) {

        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        StackTraceElement targetElement = stackTrace[5];
        String className = targetElement.getClassName();
        String[] classNameInfo = className.split("\\.");
        if (classNameInfo.length > 0) {
            className = classNameInfo[classNameInfo.length - 1] + SUFFIX;
        }

        if (className.contains("$")) {
            className = className.split("\\$")[0] + SUFFIX;
        }

        String methodName = targetElement.getMethodName();
        int lineNumber = targetElement.getLineNumber();

        if (lineNumber < 0) {
            lineNumber = 0;
        }

        String tag = (tagStr == null ? className : tagStr);

        if (mIsGlobalTagEmpty && TextUtils.isEmpty(tag)) {
            tag = TAG;
        } else if (!mIsGlobalTagEmpty) {
            tag = mGlobalTag;
        }

        String msg = (objects == null) ? NULL_TIPS : getObjectsString(objects);
        String headString = "[ (" + className + ":" + lineNumber + ")#" + methodName + " ] ";

        return new String[]{tag, msg, headString};
    }

    private static String getObjectsString(Object... objects) {
        if (objects.length > 1) {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append("\n");
            for (int i = 0; i < objects.length; i++) {
                Object object = objects[i];
                if (object == null) {
                    stringBuilder.append("Param").append("[").append(i).append("]").append(" = ").append("null").append("\n");
                } else {
                    stringBuilder.append("Param").append("[").append(i).append("]").append(" = ").append(object.toString()).append("\n");
                }
            }
            return stringBuilder.toString();
        } else {
            Object object = objects[0];
            return object == null ? "null" : object.toString();
        }
    }

    private static void printDefault(int type, String tag, String headString, String msg) {
        int index = 0;
        int maxLength = 4000;
        int countOfSub = msg.length() / maxLength;
        if (countOfSub > 0) {
            for (int i = 0; i < countOfSub; i++) {
                String sub = msg.substring(index, index + maxLength);
                print(type, tag, headString, sub);
                index += maxLength;
            }
            print(type, tag, headString, msg.substring(index));
        } else {
            print(type, tag, headString, msg);
        }
    }

    private static void print(int type, String tag, String headString, String msg) {
        switch (type) {
            case V:
//                log2File("V", tag, msg);
                Log.v(tag, msg);
                break;
            case D:
                log2File2("D", tag, msg, headString, getLogFileName(new Date()));
                Log.d(tag, msg);
                break;
            case I:
//                log2File("I", tag, msg);
                Log.i(tag, msg);
                break;
            case W:
//                log2File("W", tag, msg);
                Log.w(tag, msg);
                break;
            case E:
//                log2File("E", tag, msg, null);
                File file = new File(MY_LOG_URL);
                if (!file.exists()) {
                    KLog.e("创建log: " + file.mkdirs());
                }
                log2File2("E", MY_LOG_URL, msg, headString, getLogFileName(new Date()));
                Log.e(tag, msg);
                break;
            case A:
//                log2File2("A", tag, msg, getLogFileName(new Date()));
                Log.wtf(tag, msg);
                break;
            default:
        }
    }

    private static void printJson(String tag, String msg, String headString) {
        String message;
        try {
            final int jsonIndent = 4;
            if (msg.startsWith("{")) {
                JSONObject jsonObject = new JSONObject(msg);
                message = jsonObject.toString(jsonIndent);
            } else if (msg.startsWith("[")) {
                JSONArray jsonArray = new JSONArray(msg);
                message = jsonArray.toString(jsonIndent);
            } else {
                message = msg;
            }
        } catch (JSONException e) {
            message = msg;
        }
        Log.d(tag, "╔═══════════════════════════════════════════════════════════════════════════════════════");
        message = headString + LINE_SEPARATOR + message;
        String[] lines = message.split(LINE_SEPARATOR);
        for (String line : lines) {
            Log.d(tag, "║ " + line);
        }
        Log.d(tag, "╚═══════════════════════════════════════════════════════════════════════════════════════");
    }

    private static void printXml(String tag, String xml, String headString) {
        if (xml != null) {
            xml = formatXml(xml);
            xml = headString + "\n" + xml;
        } else {
            xml = headString + NULL_TIPS;
        }
        Log.d(tag, "╔═══════════════════════════════════════════════════════════════════════════════════════");
        String[] lines = xml.split(LINE_SEPARATOR);
        for (String line : lines) {
            if (!(TextUtils.isEmpty(line) || "\n".equals(line) || "\t".equals(line) || TextUtils.isEmpty(line.trim()))) {
                Log.d(tag, "║ " + line);
            }
        }
        Log.d(tag, "╚═══════════════════════════════════════════════════════════════════════════════════════");
    }

    private static String formatXml(String inputXml) {
        try {
            Source xmlInput = new StreamSource(new StringReader(inputXml));
            StreamResult xmlOutput = new StreamResult(new StringWriter());
            Transformer transformer = TransformerFactory.newInstance().newTransformer();
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
            transformer.transform(xmlInput, xmlOutput);
            return xmlOutput.getWriter().toString().replaceFirst(">", ">\n");
        } catch (Exception e) {
            e.printStackTrace();
            return inputXml;
        }
    }

    private static String getLogFileName(Date date) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd", Locale.getDefault());
        return sdf.format(date) + ".txt";
    }

    private static synchronized void log2File2(String level, String path, String msg, String headString, String fileName) {
        Date now = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss", Locale.getDefault());
        String fileName2 = path + ((fileName == null) ? getLogFileName(now) : fileName);

        File file = new File(fileName2);
        OutputStream outputStream = null;

        try {

            outputStream = new FileOutputStream(file, true);

            StringBuilder sb = new StringBuilder();
            sb.append(level);
            sb.append(" ");
            sb.append(sdf.format(now));
            sb.append(" ");
            sb.append(headString);
            sb.append(" ");
            sb.append(msg);
            sb.append("\n");
            StringWriter sw = new StringWriter();
            sb.append(sw.toString());
            sb.append("\n");
            byte[] data = sb.toString().getBytes();
            for (byte datum : data) {
                outputStream.write(datum);
            }
            outputStream.flush();
            outputStream.close();
        } catch (Exception e) {
            Log.e(TAG, "添加日志异常", e);
        } finally {
            if (outputStream != null) {
                try {                 
                    outputStream.close();
                } catch (IOException e) {
                    Log.e(TAG, "关闭日志文件异常", e);
                }
            }
        }
    }


    /**
     * 检查是否有需要清理文件
     */
    private static void deleteExpiredLogs(int day) {
        File dir = new File(MY_LOG_URL);
        File[] subFiles = dir.listFiles();
        if (subFiles != null) {
            int logFileCnt = 0;
            int expiredLogFileCnt = 0;
            //one day
            final int dayMilliseconds = 24 * 60 * 60 * 1000;
            //day * dayMilliseconds 表示7天的毫秒值
            long expiredTimeMillis = System.currentTimeMillis() - (day * dayMilliseconds);
            for (File file : subFiles) {
                ++logFileCnt;
                KLog.e("文件最后修改时间", file.lastModified());
                KLog.e("比较时间", expiredTimeMillis);
                if (file.lastModified() < expiredTimeMillis) {
                    ++expiredLogFileCnt;
                    boolean deleteResult = file.delete();
                    if (deleteResult) {
                        e(TAG, "Delete expired log files successfully:" + file.getName());
                        Log.e(TAG, "删除过期日志:文件总数=" + (subFiles.length) + ", 日志文件数=" + logFileCnt + ", " +
                                "过期日志文件数=" + expiredLogFileCnt);
                    } else {
                        e(TAG, "Delete expired log files failure:" + file.getName());
                    }
                } else {
                    KLog.e("当前log文件没有过期", file.getName());
                }
            }
        }
    }

}