（原创）手写一个安卓日志框架

已于 2023-03-20 10:16:43 修改
阅读量513 收藏
点赞数
分类专栏： 实用工具 文章标签： android java 开发语言
于 2021-08-12 19:16:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Android_xiong_st/article/details/119651304
版权

问题引入

其实之前有写过一个简单的日志框架
（原创）分享自己写的几个工具类（十）文件日志记录工具
但是这个工具类有几个问题
1：在主线程执行写日志功能，有一点不太好
2：改造不好，可能存在多个线程去读写同一个文件的问题
3：日志没有存储容量上限
4：日志无法压缩，无法适应“压缩后传送到服务器”的需求
所以我在原来工具类的基础上，做了一下优化和改造
于是一个新的日志框架诞生了！！！
新的日志工具类，主要就是解决这几个问题的
文章尾部会贴出主代码和使用方式
现在开始对这个工具类进行一个基础介绍：

问题1

首先，第一个问题，采用了线程池的方式解决

private static ExecutorService executor = Executors.newFixedThreadPool(5);

创建了一个拥有五个线程的线程池
在记录信息时执行线程池的submit方法
在子线程记录日志

问题2

对于问题2，解决方式就是对线程进行加锁
保证一个线程在执行写入操作时，其他线程不可以操作该文件

private static Lock lock = new ReentrantLock();

调用lock.lock()和lock.unlock()方法
来执行加锁和解锁

问题3

问题3，日志没有存储容量上限
这边定义了一个容量上线

public static final int DEFAULT_CAPACITY = 5120;//默认容量 单位kb  5120即5M

同时定义了两个缓存日志的文件lionlog1.txt和lionlog1.txt
他们容量上限都是5M，当然这个上限你可以灵活改动
他们的逻辑如下
写入文件时先判断lionlog1是否写满了，也就是超出容量5M了
如果没写满，就写lionlog1,并且记录好这次写的文件是lionlog1
如果写满了，就写lionlog2,并且记录好这次写的文件是lionlog2
代码如下：

                    if ((file1.length() / 1024) >= DEFAULT_CAPACITY) {
                        //file1满了
                        seleFile = file2;
                        isfile1 = false;
                    } else {
                        //表示file1没满
                        seleFile = file1;
                        isfile1 = true;
                    }

得到了要写入的文件，进行写入即可
写完后进行容量检查
容量检查逻辑如下：
先判断这些写入的是那个文件
是lionlog1还是lionlog2
如果这次写入的是lionlog1，就判断lionlog1是否超出容量了
如果lionlog1超出容量，就删除lionlog2文件，然后结束
这样做，下次进来，系统就会开始写lionlog2文件

如果这次写入的是lionlog2，就判断lionlog2是否超出容量了
如果lionlog2超出容量，就删除lionlog1文件，然后结束
这样做，下次进来，系统就会开始写lionlog2文件

这样，A文件满了，就清空B
下次进来后就可以写B
直到B满了，再去清空A
下次进来就一直写A

循环往复

代码如下

if (isfile1) {
            //说明使用的是file1存储日志，判断是否超出存储范围
            if ((file1.length() / 1024) >= DEFAULT_CAPACITY) {
                //file1满了，删除file2
                file2.delete();
            }
        } else {
            //说明使用的是file2存储日志，判断是否超出存储范围
            if ((file2.length() / 1024) >= DEFAULT_CAPACITY) {
                //file2满了，删除file1
                file1.delete();
            }
        }

这套逻辑也可以做成链式的
比如有n个日志缓存文件a1,a2,a3,a4…
这样a1满了，就清空a2
下次进来写a2
直到a2满了，就清空a3
下次进来写a2
等到最后一个a(n)满了
就清空a1
重新在a1这里写

问题4

日志无法压缩，无法适应“压缩后传送到服务器”的需求
这个问题，需要用到我之前写的一个文件压缩的工具类ZipUtils
（原创）分享一个文件以及文件夹压缩工具类
我这个日志框架内部就是用这个工具类实现了文件压缩
同时对外部提供了回调接口
方便外部在文件压缩完成后，对压缩后的文件进行一系列的操作
比如上传服务器，备份，删除等等

源码

下面先贴出这个日志框架的源码，然后介绍它的使用方法

/**
 * @introduce : 日志框架
 * <p>
 * creattime : 2021/8/11
 * <p>
 * author : xiongyp
 **/
public class LionLog {


    //是否保存日志
    private static boolean isLog = false;
    //存储路径1
    private static String mStrU1;
    //存储路径2
    private static String mStrU2;
    //要压缩的文件夹
    private static String toZipDir;
    //压缩后的压缩包路径+名称
    private static String toZipFilename;

    public static final int DEFAULT_CAPACITY = 5120;//默认容量 单位kb  5120即5M


    public static void init(Context context, boolean isopen) {
        isLog = isopen;
        mStrU1 = context.getExternalFilesDir(null).getAbsolutePath() + "/Lionlog/lionlog1.txt";
        mStrU2 = context.getExternalFilesDir(null).getAbsolutePath() + "/Lionlog/lionlog2.txt";
        toZipDir = context.getExternalFilesDir(null).getAbsolutePath() + "/Lionlog";
        toZipFilename = context.getExternalFilesDir(null).getAbsolutePath();
    }

    /*
   创建一个拥有5个线程的线程池
    */
    private static ExecutorService executor = Executors.newFixedThreadPool(5);


    private static Lock lock = new ReentrantLock();

    /**
     * @param context
     * @param msg     记录信息
     */
    public static void writeMsgIntoFile(Context context, final String msg) {
        if (context == null || isNullOrNil(msg) || isNullOrNil(mStrU1) || isNullOrNil(mStrU2) || !isLog) {
            return;
        }
        executor.submit(new Runnable() {
            @Override
            public void run() {
                lock.lock();
                try {
//                    Log.d("LionLog", "线程名字:" + Thread.currentThread().getName());
                    long startTime = System.currentTimeMillis(); //起始时间
                    File seleFile;
                    boolean isfile1;
                    File file1 = new File(mStrU1);
                    File file2 = new File(mStrU2);
                    if (!file1.exists() && !file1.getParentFile().exists()) {
                        file1.getParentFile().mkdirs();
                    }
                    if (!file2.exists()) {
                        file2.createNewFile();
                    }
//                    Log.d("LionLog", "前大小:" + (file1.length() / 1024));
                    if ((file1.length() / 1024) >= DEFAULT_CAPACITY) {
                        //file1满了
                        seleFile = file2;
                        isfile1 = false;
                    } else {
                        //表示file1没满
                        seleFile = file1;
                        isfile1 = true;
                    }

                    StringBuilder sb = new StringBuilder();
                    sb.append(getFormatTime())
                            .append(msg)//日志信息
                            .append("\n\n");//加上双换行
                    FileWriter fw = new FileWriter(seleFile.getAbsolutePath(), true);
                    fw.write(sb.toString());
                    fw.flush();
                    fw.close();
//                    Log.d("LionLog", "后大小:"+(file1.length()) );
                    //检查容量
                    checkCapacity(isfile1, file1, file2);
                    notifySystemToScan(context, seleFile);
                    long endTime = System.currentTimeMillis(); //结束时间
                    long runTime = endTime - startTime;
//                    Log.d("LionLog", String.format("日志写入，此次耗时 %d ms", runTime));
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });

    }

    /**
     * 检查容量，判断是否要转储
     *
     * @param isfile1
     * @param file1
     * @param file2
     */
    private static void checkCapacity(boolean isfile1, File file1, File file2) {
        if (isfile1) {
            //说明使用的是file1存储日志，判断是否超出存储范围
            if ((file1.length() / 1024) >= DEFAULT_CAPACITY) {
                //file1满了，删除file2
                file2.delete();
            }
        } else {
            //说明使用的是file2存储日志，判断是否超出存储范围
            if ((file2.length() / 1024) >= DEFAULT_CAPACITY) {
                //file2满了，删除file1
                file1.delete();
            }
        }
    }


    /**
     * 压缩文件
     */
    public static void zipFile() {
        executor.submit(new Runnable() {
            @Override
            public void run() {
                lock.lock();
                FileOutputStream fos1 = null;
                try {
                    /** 测试压缩方法 单个文件夹压缩 */
                    String zipFileName = "/Lionlog_" + new SimpleDateFormat("yyyy-MM-dd-HH:mm:ss").format(new Date()) + ".zip";
                    String toZipFilePath = toZipFilename + zipFileName;
                    fos1 = new FileOutputStream(new File(toZipFilePath));
                    ZipUtils.toZip(toZipDir, fos1, true);
//                    Log.d("SettingsActivity", "压缩结果" + toZipFilePath);

                    mHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            if (onZipSuccListener != null) {
                                //传回压缩结果
                                onZipSuccListener.onZipresult(toZipFilePath,zipFileName);
                            }
                        }
                    });


                    /** 测试压缩方法 多文件压缩 */
//                    List<File> fileList = new ArrayList<>();
//                    fileList.add(new File(mStrU1));//文件列表1
//                    fileList.add(new File(mStrU2));//文件列表2
//                    FileOutputStream fos2 = new FileOutputStream(new File(toZipFilename));//这里写压缩后的压缩包路径以及名称
//                    ZipUtils.toZip(fileList, fos2);
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }

            }
        });

    }

    private static Handler mHandler=new Handler(){
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);

        }
    };

    private static OnZipSuccListener onZipSuccListener;


    public static void setOnZipSuccListener(OnZipSuccListener onZipSuccListener) {
        LionLog.onZipSuccListener = onZipSuccListener;
    }

    public interface OnZipSuccListener {
        /**
         *
         * @param toZipFilePath  全路径
         * @param toZipFileName  文件名
         */
        void onZipresult(String toZipFilePath,String toZipFileName);
    }


    /**
     * 得到格式化时间
     *
     * @return
     */
    private static String getFormatTime() {
        return new SimpleDateFormat("yyyy-MM-dd-HH:mm:ss:").format(new Date());
    }

    /**
     * 扫描sd卡，进行更新
     *
     * @param context
     * @param file
     */
    private static void notifySystemToScan(Context context, File file) {
        if (context == null || file == null || !file.exists()) {
            return;
        }
        Intent intent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
        Uri uri = Uri.fromFile(file);
        intent.setData(uri);
        context.sendBroadcast(intent);
    }

    /**
     * 判断字符串是否为空
     *
     * @param str
     * @return
     */
    private static boolean isNullOrNil(String str) {
        if (str == null || str.length() == 0) {
            return true;
        }
        return false;
    }
}

使用

其实使用很简单，首先在你的application里面这样写：

LionLog.init(this,true);

true代表开启日志记录功能，false就不会去记录日志了

记录日志，调用这个方法即可

LionLog.writeMsgIntoFile(this,"MainActivity记录一条日志:");

如果要对日志进行压缩

LionLog.zipFile();

当然，如果你需要压缩结束后的回调

LionLog.setOnZipSuccListener(new LionLog.OnZipSuccListener() {
            @Override
            public void onZipresult(String toZipFilePath, String toZipFileName) {
                Log.d("MainActivity", "压缩成功");
                Log.d("MainActivity", "全路径："+toZipFilePath);
                Log.d("MainActivity", "压缩包名称："+toZipFileName);
            }
        });

在代码里预先设置这个监听，就可以获取压缩成功后的压缩包全路径以及压缩包的名称了
工具类里是采用当前时间来命名压缩包的名称的，你也可以自己改造

关于这个日志框架，这次就先介绍到这里
以后有更多的提升
也会继续更新的
也欢迎大家给出提升的建议和思路，谢谢啦~

Android_xiong_st
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android-logback-android用于Android的可靠通用快速和灵活的日志记录框架
08-13
logback-android：用于Android的可靠，通用，快速和灵活的日志记录框架
Android-模拟OkHttp手写简易版网络访问框架
08-13
本文将深入探讨如何模拟OkHttp，手写一个简易版的网络访问框架。通过这样的实践，我们可以更好地理解网络请求的工作原理，以及OkHttp的核心特性。 首先，我们需要了解HTTP协议的基本概念。HTTP（超文本传输协议）是...
如何写一个日志框架
XG1057415595的博客
04-09 476
整体功能设计 1、支持控制台打印 2、支持缓存到文件，支持日志文件上传 3、支持接入APM性能监控 需要考虑的细节有哪些？ 1、日志文件 和 APM 的区别是什么？APM 是通过上传部分关键日志，使得开发人员可以查询用户APP 的上传每条日志，进行问题排查；而日志文件是存在用户设备上的，一般情况下不会上传，只有需要的时候，通过开关设置，来触发指定名单用户的日志上传，用来获取更多信息来排查问题。 2、写入日志文件的策略是什么？内存中日志最大数目是多少？什么时候触发写入文件？日志文件多大？线程怎么管理？最
三款 Android 日志框架对比「Logger、Timber、XLog」
最新发布
yan_chenglong的博客
06-21 445
来看看如何使用。
Android写日志文件类
weixin_33806300的博客
08-25 113
import java.io.BufferedWriter; import java.io.File; import java.io.FileWriter; import java.io.IOException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; ...
从零实现一个日志框架（带源码）
良月柒
01-19 428
程序员的成长之路互联网/程序员/技术/资料共享关注阅读本文大概需要 8.2分钟。作者：空无segmentfault.com/a/1190000038760707Java里的各种日志框...
android日记管理,Android 日志管理框架 NativeLogger
weixin_32211243的博客
05-25 358
日志是任何项目开发中的必须组件,它可以记录下来系统的行为,帮助开发者排错,优化系统性能调整系统行为等.既然日志可以帮助我们做很多分析,那么开发者肯定是有很多定制需求的,例如不同环境过滤不同等级的log,格式化输出,输出到文件,打包日志上传分析等等.这里就针对Android平台开发一套日志框架.后续将持续完善.github地址:https://github.com/HiJesse/Android-N...
Android轻量级日志管理框架
weixin_34268579的博客
03-06 265
代码地址如下：http://www.demodashi.com/demo/12134.html ViseLog Android 轻量级日志框架，使用森林对象维护不同的日志树进行日志输出，可以是Logcat树、文件树等，支持Bundle、Intent、Reference、Throwable、Map、Collection、JSON、Xml等格式化的输出。 项目引用：compile 'com.vi...
Android设计思想解读开源框架.pdf
12-23
- **ARouter**：是阿里巴巴开源的一个高性能路由框架，用于解决Android应用中复杂的页面跳转问题。 - **原理**：ARouter通过注解处理器自动生成路由表，并在运行时通过反射机制实现页面的跳转。此外，ARouter还支持...
一起动手编写Android图片加载框架
09-02
本文将带领大家从头开始构建一个简单而实用的Android图片加载缓存框架，深入理解其内部原理和实现细节。 首先，我们要明确一个优秀的图片加载框架应具备的功能： 1. **图片的加载**： - **同步加载与异步加载**：...
Android AOP框架AspectJ使用详解
01-05
之前了解过android的AOP框架，用法主要用来打日志；现在有一个需求需要函数在新线程中执行，并且函数主体执行完之后，在UI线程返回结果。想到手写的话，每次都要new Thread的操作，比较麻烦；因此就尝试用注解的方法...
自己实现简单的日志记录框架
04-14
日志记录明明很简单的东西，被log4j搞得复杂了，个人很不喜欢那么冗余的东西，于是自己构思了一晚上，花了一上午时间写了这个简单的日志记录系统，姑且称为一个简单框架吧。
android--java写日志文件
07-27
android--java写日志文件 android--java写日志文件 android--java写日志文件android--java写日志文件
Android-XLog一个简易的日志打印框架
08-13
XLog一个简易的日志打印框架（支持打印策略自定义，默认提供2种策略：logcat打印和磁盘打印）
Simple-Android-Logger:Android 应用程序的轻量级日志框架
06-05
Simple-Android-Logger 适用于 Android 应用程序的轻量级日志记录框架。 该库旨在作为 Android Studio 中的一个模块包含在 android 项目中。 该框架是围绕 Logger 接口构建的，单个 Logging 类必须实现该接口，以及基于传递的产品 ID 返回 Logger 的具体实现的 LoggerFactory。 使用这个框架，一个项目可以很容易地从调试日志模式切换到生产日志模式。 这最好通过使用整数资源来表示所需的日志记录模式来实现，然后活动可以使用此资源创建一个 Logger 实例，并将此 Logger 实例传递给需要日志功能的其他组件。
Android下自定义日志框架
10-20
Android下的自定义日志框架。移动开发一般没有必要引入第三方日志框架，可以自己编写。
android_simple_sqlite框架
02-07
本项目“android_simple_sqlite”是一个手写的SQLite数据库框架，旨在简化Android应用中的数据库操作。ORM（Object-Relational Mapping）是这个框架的核心特性，它将对象模型与关系型数据库模型进行映射，使得开发者...
android 中写日志
playStudy的专栏
06-03 1242
#include     __android_log_print(ANDROID_LOG_INFO, "MYPROG", "x = %d, y =%d", x,y);
android第三方日志框架,Android 日志记录轻量级框架 Timber
weixin_42102401的博客
05-27 1184
前言Log 日志在 Android 项目开发中的作用非常重要，但项目越做越大，开发者会面临很多问题，比如管理各种不同的 Log，不同版本控制是否输入 Log 等。Timber 是一个轻量级的第三方库，能够帮助开发者更好的使用 Android Log。面临问题项目使用 Log 规范不统一，例如：关于 okhttp 的实现使用了 Logging Interceptor 输出 log，关于 rxjava...
如何手写一个AOP简单框架
03-30
AOP（Aspect Oriented Programming）是一种面向切面编程的编程范式，它可以在程序运行时动态地将代码插入到指定方法的前面、后面或者中间，从而实现对方法的增强。 下面是手写一个简单的AOP框架的步骤： 1. 定义注解 定义一个自定义注解，用于标注需要增强的方法。例如： ```java @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface MyAnnotation { } ``` 2. 定义切面 定义一个切面类，该类包含需要增强的方法以及增强逻辑。例如： ```java public class MyAspect { public void before() { System.out.println("before"); } public void after() { System.out.println("after"); } } ``` 3. 定义代理类 定义一个代理类，该类通过反射机制获取需要增强的方法以及切面类中的增强逻辑，并在方法执行前后调用切面类中的增强逻辑。例如： ```java public class MyProxy { public static Object getProxy(Object target) { return Proxy.newProxyInstance( target.getClass().getClassLoader(), target.getClass().getInterfaces(), (proxy, method, args) -> { Method targetMethod = target.getClass().getMethod(method.getName(), method.getParameterTypes()); if (targetMethod.isAnnotationPresent(MyAnnotation.class)) { MyAspect aspect = new MyAspect(); aspect.before(); Object result = method.invoke(target, args); aspect.after(); return result; } else { return method.invoke(target, args); } }); } } ``` 4. 使用代理类 通过代理类获取代理对象，并使用该对象调用需要增强的方法。例如： ```java public class Main { public static void main(String[] args) { MyClass myClass = new MyClass(); MyClass myProxy = (MyClass) MyProxy.getProxy(myClass); myProxy.method(); } } class MyClass { @MyAnnotation public void method() { System.out.println("method"); } } ``` 当调用代理对象的`method()`方法时，会先调用`MyAspect`中的`before()`方法，然后调用原始对象`MyClass`中的`method()`方法，最后再调用`MyAspect`中的`after()`方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值