android 自定义日志工具类XLog

最新推荐文章于 2024-08-09 07:29:07 发布
最新推荐文章于 2024-08-09 07:29:07 发布
阅读量613 收藏
点赞数
分类专栏： 技术 文章标签： android 日志 工具类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yugui865/article/details/51915077
版权

项目源码：https://github.com/lany192/XLog

初始化：

XLog.init(Application application, boolean debug);//在app启动时调用，可以放在Application类中调用，也可以在第一个Activity界面调用

public class SampleActivity extends AppCompatActivity {
    private final String TAG = this.getClass().getSimpleName();
    private String json = "{\"desc\":\"OK\",\"status\":1000,\"data\":{\"wendu\":\"22\",\"ganmao\":\"风较大，较易发生感冒，注意防护。\",\"forecast\":[{\"fengxiang\":\"北风\",\"fengli\":\"5-6级\",\"high\":\"高温 24℃\",\"type\":\"晴\",\"low\":\"低温 11℃\",\"date\":\"3日星期六\"},{\"fengxiang\":\"北风\",\"fengli\":\"4-5级\",\"high\":\"高温 19℃\",\"type\":\"晴\",\"low\":\"低温 8℃\",\"date\":\"4日星期日\"},{\"fengxiang\":\"无持续风向\",\"fengli\":\"微风\",\"high\":\"高温 21℃\",\"type\":\"晴\",\"low\":\"低温 9℃\",\"date\":\"5日星期一\"},{\"fengxiang\":\"无持续风向\",\"fengli\":\"微风\",\"high\":\"高温 21℃\",\"type\":\"多云\",\"low\":\"低温 10℃\",\"date\":\"6日星期二\"},{\"fengxiang\":\"无持续风向\",\"fengli\":\"微风\",\"high\":\"高温 24℃\",\"type\":\"晴\",\"low\":\"低温 12℃\",\"date\":\"7日星期三\"},{\"fengxiang\":\"无持续风向\",\"fengli\":\"微风\",\"high\":\"高温 23℃\",\"type\":\"晴\",\"low\":\"低温 11℃\",\"date\":\"8日星期四\"}],\"yesterday\":{\"fl\":\"微风\",\"fx\":\"无持续风向\",\"high\":\"高温 23℃\",\"type\":\"晴\",\"low\":\"低温 12℃\",\"date\":\"2日星期五\"},\"aqi\":\"59\",\"city\":\"北京\"}}";
    private String XML = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><!--  Copyright w3school.com.cn --><note><to>George</to><from>John</from><heading>Reminder</heading><body>Don't forget the meeting!</body></note>";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_sample);
        XLog.init(getApplication(),true);
        //XLog.init(TAG);
        //XLog.setSettings(true, 3, 2);
        XLog.d("hello1");
        XLog.e("hello2");
        XLog.w("hello3");
        XLog.v("hello4");
        XLog.json(json);
        XLog.xml("Hello",XML);
    }
}


XLog.java文件:

package com.lany.xlog;

import android.app.Application;
import android.content.Context;
import android.text.TextUtils;
import android.util.Log;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

import javax.xml.transform.OutputKeys;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

public final class XLog {
    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 = "XLog";
    private static final int V = 0x1;//verbose
    private static final int D = 0x2;//debug
    private static final int I = 0x3;//info
    private static final int W = 0x4;//warn
    private static final int E = 0x5;//error
    private static final int A = 0x6;//assert
    private static final int J = 0x7;//json
    private static final int X = 0x8;//xml
    private static boolean DEBUG = true;
    private static Context mContext;

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

    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);
    }

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

    public static void file(File targetDirectory, Object msg) {
        printFile(null, targetDirectory, null, msg);
    }

    public static void file(String tag, File targetDirectory, Object msg) {
        printFile(tag, targetDirectory, null, msg);
    }

    public static void file(String tag, File targetDirectory, String fileName, Object msg) {
        printFile(tag, targetDirectory, fileName, msg);
    }

    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];
        switch (type) {
            case V:
            case D:
            case I:
            case W:
            case E:
            case A:
                printDefault(type, tag, headString + msg);
                break;
            case J:
                printJson(tag, msg, headString);
                break;
            case X:
                printXml(tag, msg, headString);
                break;
        }
    }

    private static void printFile(String tagStr, File targetDirectory, String fileName, Object objectMsg) {
        if (!DEBUG) {
            return;
        }
        String[] contents = wrapperContent(tagStr, objectMsg);
        String tag = contents[0];
        String msg = contents[1];
        String headString = contents[2];
        printFile(tag, targetDirectory, fileName, headString, msg);
    }

    private static String[] wrapperContent(String tagStr, Object... objects) {
        final int STACK_TRACE_INDEX = 5;
        final String SUFFIX = ".java";
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        StackTraceElement targetElement = stackTrace[STACK_TRACE_INDEX];
        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 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 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, sub);
                index += maxLength;
            }
            print(type, tag, msg.substring(index, msg.length()));
        } else {
            print(type, tag, msg);
        }
    }

    private static void print(int type, String tag, String msg) {
        switch (type) {
            case V:
                log2File("V", tag, msg, null);
                Log.v(tag, msg);
                break;
            case D:
                log2File("D", tag, msg, null);
                Log.d(tag, msg);
                break;
            case I:
                log2File("I", tag, msg, null);
                Log.i(tag, msg);
                break;
            case W:
                log2File("W", tag, msg, null);
                Log.w(tag, msg);
                break;
            case E:
                log2File("E", tag, msg, null);
                Log.e(tag, msg);
                break;
            case A:
                log2File("A", tag, msg, null);
                Log.wtf(tag, msg);
                break;
        }
    }

    private static void printJson(String tag, String msg, String headString) {
        String message;
        try {
            final int JSON_INDENT = 4;
            if (msg.startsWith("{")) {
                JSONObject jsonObject = new JSONObject(msg);
                message = jsonObject.toString(JSON_INDENT);
            } else if (msg.startsWith("[")) {
                JSONArray jsonArray = new JSONArray(msg);
                message = jsonArray.toString(JSON_INDENT);
            } 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) || line.equals("\n") || line.equals("\t") || 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 void printFile(String tag, File targetDirectory, String fileName, String headString, String msg) {
        fileName = (fileName == null) ? getLogFileName(new Date()) : fileName;
        if (save2File(targetDirectory, fileName, msg)) {
            Log.d(tag, headString + " save log success ! location is >>>" + targetDirectory.getAbsolutePath() + "/" + fileName);
        } else {
            Log.e(tag, headString + " save log fails !");
        }
    }

    private static boolean save2File(File dic, String fileName, String msg) {
        File file = new File(dic, fileName);
        try {
            OutputStream outputStream = new FileOutputStream(file);
            OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream, "UTF-8");
            outputStreamWriter.write(msg);
            outputStreamWriter.flush();
            outputStream.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            return false;
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            return false;
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

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

    private static Context getAppContext() {
        if (mContext == null) {
            throw new IllegalArgumentException("XLog has not been initialized");
        }
        return mContext;
    }

    private static synchronized void log2File(String level, String tag, String msg, Throwable tr) {
        Date now = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss", Locale.getDefault());
        String fileName = getLogFileName(now);
        FileOutputStream fos = null;
        try {
            fos = getAppContext().openFileOutput(fileName, Context.MODE_PRIVATE | Context.MODE_APPEND);
            StringBuilder sb = new StringBuilder();
            sb.append(level);
            sb.append(" ");
            sb.append(sdf.format(now));
            sb.append(" ");
            sb.append(tag);
            sb.append(" ");
            sb.append(msg);
            if (tr != null) {
                sb.append("\n");
                StringWriter sw = new StringWriter();
                tr.printStackTrace(new PrintWriter(sw, true));
                sb.append(sw.toString());
            }
            sb.append("\n");
            fos.write(sb.toString().getBytes());
            fos.flush();
        } catch (Exception e) {
            Log.e(TAG, "添加日志异常", e);
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    Log.e(TAG, "关闭日志文件异常", e);
                }
            }
        }
    }

    /**
     * 获取指定日期日志
     *
     * @param date
     * @return
     */
    public static synchronized String getLogText(Date date) {
        String fileName = getLogFileName(date);
        FileInputStream fis = null;
        StringBuilder sb = new StringBuilder();
        try {
            fis = getAppContext().openFileInput(fileName);
            byte[] buffer = new byte[10240];
            while (true) {
                int len = fis.read(buffer);
                if (len <= 0) {
                    break;
                }
                sb.append(new String(buffer, 0, len));
            }
            fis.close();
        } catch (FileNotFoundException e) {
            return "未找到对应的日志文件";
        } catch (Exception e) {
            Log.e(TAG, "获取日志文本异常", e);
            StringWriter sw = new StringWriter();
            e.printStackTrace(new PrintWriter(sw, true));
            return sw.toString();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    Log.e(TAG, "获取日志文本异常", e);
                }
            }
        }
        return sb.toString();
    }

    /**
     * 清除指定日志日志文件
     *
     * @param date
     */
    public static synchronized void clearLogText(Date date) {
        String fileName = getLogFileName(date);
        FileOutputStream outputStream = null;
        try {
            outputStream = getAppContext().openFileOutput(fileName, Context.MODE_PRIVATE);
            outputStream.write("".getBytes());
            outputStream.flush();
        } catch (Exception e) {
            Log.e(TAG, "clear log file error", e);
        } finally {
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    Log.e(TAG, "close log file error", e);
                }
            }
        }
    }

    private static void deleteExpiredLogs(int expiredDays) {
        File dir = getAppContext().getFilesDir();
        File[] subFiles = dir.listFiles();
        if (subFiles != null) {
            int logFileCnt = 0;
            int expiredLogFileCnt = 0;
            final int DAY_MILLISECONDS = 24 * 60 * 60 * 1000;//one day
            long expiredTimeMillis = System.currentTimeMillis() - (expiredDays * DAY_MILLISECONDS);
            for (File file : subFiles) {
                if (file.getName().startsWith(TAG)) {
                    ++logFileCnt;
                    if (file.lastModified() < expiredTimeMillis) {
                        ++expiredLogFileCnt;
                        boolean deleteResult = file.delete();
                        if (deleteResult) {
                            i(TAG, "Delete expired log files successfully:" + file.getName());
                        } else {
                            e(TAG, "Delete expired log files failure:" + file.getName());
                        }
                    }
                }
            }
            Log.i(TAG, "删除过期日志:文件总数=" + (subFiles.length) + ", 日志文件数=" + logFileCnt + ", 过期日志文件数=" + expiredLogFileCnt);
        }
    }
}


丽江的蓝天
关注
专栏目录
日志库Logger/xLog:使用对比解析
学习是修养的提升
07-29 7079
前言几种常用的日志库  通过对比：logger、timber、xLog、KLog、log4j 日志库 ；个人最终选择了logger;当然另外几个也很强大；只是 从个人的开发需求角度来说 logger更适合本人罢了（早期个人使用过log4j日志库）。 给出上述库的飞升台： logger: https://github.com/orhanobut/logger timber: https://
Android-XLog一个简易的日志打印框架
08-13
XLog一个简易的日志打印框架（支持打印策略自定义，默认提供2种策略：logcat打印和磁盘打印）
XLog —— 强大的Android日志库
gitblog_00495的博客
08-09 1019
XLog —— 强大的Android日志库 xLogAndroid logger, pretty, powerful and flexible, log to everywhere, save to file, all you want is here.项目地址:https://gitcode.com/gh_mirrors/xl/xLog 1. 项目介绍 XLog是一个高效的、可配置的日志库，旨...
Android高性能日志模块-Xlog 正篇
涛的博客
06-22 3653
Android高性能日志模块-Xlog 前言 日志可以帮助我们定位问题，记录当前程序的运行状态。与后端开发不同的是，Android中的Log原生支持的仅是本地调试和信息记录，并不能很方便地定位远程问题。当有用户反馈时,通常是给用户重新编一个打开日志的安装包或通过远程的开关给特定用户开启日志,别无他法。 原生的Log方案主要是为程序发布前服务的,实际工程中日志应该是随着Release包上线的。 微信的xlog 微信团队开源了一个基础组件项目——Mars， Xlog是其中日志部分的开源代码。微信团队利用Xlog
Android高性能日志模块-Xlog 前篇
涛的博客
06-07 890
Android高性能日志模块Android高性能日志模块-Xlog前期准备安装VirtualBox增强工具clone mars项目安装cmake，python ，ndk编译mars Android高性能日志模块-Xlog 根据 腾讯mars-Xlog搭建一个高可用的日志系统，实现日志的文件写入并根据注解进行代码的插桩埋点。 前期准备 参考 腾讯mars-Xlog接入指南可以知道我们如果需要 armeabi 和 x86_64 以外的CPU架构支持的话需要自行进行本地编译。所以这边使用 Oracle VM Vi
探索XLog：Android与Java的日志管理新标杆
最新发布
gitblog_00658的博客
08-09 612
探索XLog：Android与Java的日志管理新标杆 xLogAndroid logger, pretty, powerful and flexible, log to everywhere, save to file, all you want is here.项目地址:https://gitcode.com/gh_mirrors/xl/xLog 在软件开发的世界里，日志记录是调试和监控应用...
安卓日志工具类android日志工具类xlog工具类xlog.rar
06-02
本资源提供了一个名为“xlog”的日志工具类，它为Android开发者提供了更高效、灵活的日志管理功能。下面我们将详细探讨“xlog”工具类的主要特点、优势以及如何在实际开发中使用它。 首先，xlog工具类允许开发者将...
史上最强的Android日志库XLogXLog.zip
07-19
4. **格式化输出**：XLog支持自定义日志格式，可以包含时间戳、线程信息、堆栈跟踪等，使得日志更易于阅读和分析。 5. **过滤与筛选**：开发者可以通过设置过滤规则，只显示关心的日志，避免被无关信息淹没。 6. *...
Xlog加密使用指引配套资源
12-11
这样的工具通常会提供自定义的日志级别，方便在不同环境中调整日志输出的详细程度，比如在调试时启用更详细的日志，在生产环境中则只输出关键信息。 4. **Android日志系统**： Android系统的日志系统是一个强大的...
Android 微信高性能日志存储库Xlog的使用
热门推荐
朱豪凯的博客
02-18 1万+
XLog是什么 腾讯开源的Mars项目中有个XLOG日志库。 XLog是一个高性能文本存储方案，在真实环境中经受了微信数亿级别的考验，稳定性无出其右。 由于其是使用C语言来实现的，故有占用性能、内存小，存储速度快等优点， 支持多线程，甚至多进程的使用，支持定期删除日志， 同时，拥有特定算法，进行了文件的压缩，甚至可以配置文件加密。 如何使用 1.依赖XLOG implementation "com...
XLog:适用于Android的强大日志实用程序
04-30
XLog A powerful log util for android 主要功能  *标记Log代码位置，（在android studio中可以点击快速定位）  *支持Kotlin  *支持Log打印监听  *支持JSON格式打印，自动格式化JSON 使用方法 1.在build.gradle 中集成： compile 'com.yyxk.XLog:xlog:1.0.4' 2.在Application的onCreate()方法里进行初始化： //最简单集成 XLog.init(true,"123"); 或者初始化一个Log打印监听器： XLog.init(true, "123", new LogListener() { @Override public void whenLogPrint(int type, String tag, String msg,
腾讯XLog文件解密，和android 使用的So库
02-19
腾讯XLog的文件解密，已封装成EXE文件，把EXE文件和xlog文件放到一个文件夹内双击解密即可，注意：这个是默认加密模式的，还有android用的jni 的So库
XLog Utils Master
01-22
安卓Log工具类，支持自动保存Log,过期删除Log,控制Log存储大小,自定义上传Log 自定义Crash操作
Android使用XLog打印与收集程序运行详细日志
天下武功唯CODING不破
09-09 4756
开源项目XLog的介绍及使用
Android日志输出到控制台、文件（XLog开源日志工具）
bjxiaxueliang的CODING技术小馆
12-16 2808
Android 日志工具 最近项目开发中，遇到一个痛点： 项目模块较多，不同日志混合在一起；出现线上问题时，所有日志信息混合在一起，定位困难。 为解决这个问题，有了这个工具。这个工具有以下作用： 开发模式 debug 为 true 时，打印在控制台，同时打印到文件； 发版模式 debug 为 fase 时，只打印到文件； 方便日志上传 支持日志压缩上传 缓存文件 区分模块 支持不同功能模块，日志...
Android日志打印框架xLog超详细使用详解
生擒嫦娥炖玉兔的博客
03-11 1万+
在android开发过程中必不可少的会用到Logcat去调试程序。正式上线后一般也还的手机用户的操作日志或异常日志方便开发人及时确定问题。我前几天发现一个好用的日志框架——XLog，已经用在项目上了，推荐给大家！当然，我说的不是指微信mars下的xlog日志，是另一款开源框架。大家习惯看英文文档的可以去官网：https://github.com/elvishew/xLog 这里是考虑到官网的说明比较简单且是英文的，所以才写了这篇博客，推荐给大家的同时，也是方便以后自己看。 一、简...
解密android日志xlog,XLog 详解及源码分析
weixin_39610724的博客
06-05 1780
一、前言这里的 XLog 不是微信 Mars 里面的 xLog，而是elvishew的xLog。感兴趣的同学可以看看作者 elvishwe 的官文史上最强的 Android 日志库 XLog。这里先过一下它的特点以及与其余日志库的比较。文章主要分析 xLog 中的所有特性的实现，以及作为一个日志工具，它实际的需求是什么。特点1.全局配置(TAG，各种格式化器...)或者基于单条日志的配置2.支持打...
自定义Android Mars XLog日志存储格式
"Android Mars XLog 是微信开源的一款高性能日志库，其默认的存储格式是固定的，但可以通过自定义源码来改变日志的存储格式。主要涉及的源码文件有`appender.cc`和`formater.cc`，通过修改这两部分的代码，可以去除...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值