用kotlin打印出漂亮的android日志(三)——基于责任链模式打印任意对象

SAF-Kotlin-log 是一个Android的日志框架,这几天我抽空重新更新了一下代码。

github地址:https://github.com/fengzhizi715/SAF-Kotlin-log

一. 打印几个Android常用的对象

1.1 Uri的打印

        Uri uri = Uri.parse("http://www.java2s.com:8080/yourpath/fileName.htm?stove=10&path=32&id=4#harvic");
        L.json(uri);

打印效果:

Uri.png

1.2 Bundle的打印

        User u = new User();
        u.userName = "tony";
        u.password = "123456";
        
        Bundle bundle = new Bundle();
        bundle.putString("key1","this is key1");
        bundle.putInt("key2",100);
        bundle.putBoolean("key3",true);
        bundle.putSerializable("key4",u);
        L.json(bundle);

打印效果:

Bundle.png

目前,它默认支持JSON字符串、集合、Map、Bundle、Intent、Reference、Throwable、Uri等类型的打印,分别做了特别的格式化处理。

二. 使用责任链模式,改造打印对象的方法

在使用责任链模式之前,json()方法是这样的,需要使用when表达式来判断某个类应该对应哪个方法来打印对象。

    /**
     * 将任何对象转换成json字符串进行打印
     */
    @JvmStatic
    fun json(obj: Any?) {

        if (obj == null) {
            d("object is null")
            return
        }

        when(obj) {

            is String -> string2JSONString(obj)

            is Map<*, *> -> map2JSONString(obj)

            is Collection<*> -> collection2JSONString(obj)

            is Bundle -> bundle2JSONString(obj)

            is Reference<*> -> reference2JSON(obj)

            is Intent -> intent2JSON(obj)

            is Uri -> uri2JSON(obj)

            is Throwable -> throwable2JSONString(obj)

            else -> {

                try {
                    val s = getMethodNames()

                    var msg = obj.javaClass.toString() + LoggerPrinter.BR + "║ "
                    val objStr = JSON.toJSONString(obj)
                    val jsonObject = JSONObject(objStr)
                    var message = jsonObject.toString(LoggerPrinter.JSON_INDENT)
                    message = message.replace("\n".toRegex(), "\n║ ")

                    println(String.format(s, msg+ message))
                } catch (e: JSONException) {
                    e("Invalid Json")
                }
            }
        }
    }

使用责任链模式之后,json()是这样的,一行代码代替了when表达式。

    /**
     * 将任何对象转换成json字符串进行打印
     */
    @JvmStatic
    fun json(obj: Any?) {

        if (obj == null) {
            d("object is null")
            return
        }

        firstHandler.handleObject(obj)
    }

2.1 为何需要责任链模式?

目前日志类L只能打印几种类型的对象,或者是默认地将对象打印成json。如果要对某一个对象类做一些个性化的格式化并打印出来,按照原先的做法需要修改json()方法的when表达式。

为了符合“开闭原则”,对扩展开放、对修改关闭。我考虑使用责任链模式来替代when表达式,未来有其他需求只需增加一个单独的Handler即可。

2.2 如何使用责任链模式?

首先,定义一个基类的Handler用于对象的处理,这个Handler还会被赋予一个nextHandler表示责任链中的下一个处理者。如果当前的Handler处理不了,则交给下一个Handler来处理。

/**
 * Created by tony on 2017/11/27.
 */
abstract class BaseHandler {

    // 责任链的下一个节点,即处理者
    private var nextHandler: BaseHandler? = null

    // 捕获具体请求并进行处理,或是将请求传递到责任链的下一级别
    fun handleObject(obj: Any) {

        if (obj == null) {
            return
        }

        if (!handle(obj)) {
            // 当前处理者不能胜任,则传递至责任链的下一节点
            if (this.nextHandler != null) {
                this.nextHandler!!.handleObject(obj)
            }
        }
    }

    // 设置责任链中的下一个处理者
    fun setNextHandler(nextHandler: BaseHandler) {
        this.nextHandler = nextHandler
    }

    // 定义链中每个处理者具体的处理方式
    protected abstract fun handle(obj: Any): Boolean
}

定义完基类的Handler之后,需要定义各个具体的Handler。以BundleHandler为例,它是专门用于格式化Bundle并打印出来。

import android.os.Bundle
import com.alibaba.fastjson.JSON
import com.safframework.log.L
import com.safframework.log.LoggerPrinter
import com.safframework.log.parser.Parser
import com.safframework.log.utils.Utils
import org.json.JSONException
import org.json.JSONObject

/**
 * Created by tony on 2017/11/27.
 */
class BundleHandler():BaseHandler(), Parser<Bundle> {

    override fun handle(obj: Any): Boolean {

        if (obj is Bundle) {

            val s = L.getMethodNames()
            println(String.format(s, parseString(obj)))
            return true
        }

        return false
    }

    override fun parseString(bundle: Bundle): String {

        var msg = bundle.javaClass.toString() + LoggerPrinter.BR + "║ "

        val jsonObject = JSONObject()
        for (key in bundle.keySet()) {

            val isPrimitiveType = Utils.isPrimitiveType(bundle.get(key))

            try {

                if (isPrimitiveType) {
                    jsonObject.put(key.toString(), bundle.get(key))
                } else {
                    jsonObject.put(key.toString(), JSONObject(JSON.toJSONString(bundle.get(key))))
                }
            } catch (e: JSONException) {
                L.e("Invalid Json")
            }

        }

        var message = jsonObject.toString(LoggerPrinter.JSON_INDENT)
        message = message.replace("\n".toRegex(), "\n║ ")

        return msg + message
    }
}

定义完各个Handler之后,需要把各个Handler串联起来。在日志类L中使用Kotlin的init代码块来做这件事,init代码块相当于Java的静态代码块。

    private val handlers = ArrayList<BaseHandler>()
    private var firstHandler:BaseHandler

    init{
        handlers.add(StringHandler())
        handlers.add(CollectionHandler())
        handlers.add(MapHandler())
        handlers.add(BundleHandler())
        handlers.add(IntentHandler())
        handlers.add(UriHandler())
        handlers.add(ThrowableHandler())
        handlers.add(ReferenceHandler())
        handlers.add(ObjectHandler())

        val len = handlers.size
        for (i in 0..len - 1) {
            if (i > 0) {
                handlers[i - 1].setNextHandler(handlers[i])
            }
        }

        firstHandler = handlers[0]
    }

做完这些之后,才能通过一行代码来处理各种对象。

firstHandler.handleObject(obj)

三. 自定义对象的解析处理

目前在框架中只能处理8种对象,或者使用默认的方式将对象打印成json风格。

如果有个性化的需求,可以自定义类来实现,只需继承BaseHandler。

例如,定义一个UserHandler

import com.safframework.log.L;
import com.safframework.log.handler.BaseHandler;

import org.jetbrains.annotations.NotNull;


/**
 * Created by tony on 2017/11/27.
 */

public class UserHandler extends BaseHandler {

    @Override
    protected boolean handle(@NotNull Object obj) {

        if (obj instanceof User) {

            User u = (User)obj;

            String s = L.getMethodNames();
            System.out.println(String.format(s, u.userName+":"+u.password));
            return true;
        }

        return false;
    }
}

在使用UserHandler之前,使用默认的ObjectHandler将对象格式化后打印出来。L添加了UserHandler之后,再打印user对象就不再使用默认的ObjectHandler,而是使用UserHandler来格式化对象。

        User u = new User();
        u.userName = "tony";
        u.password = "123456";
        L.json(u);

        L.addCustomerHandler(new UserHandler());
        L.json(u);

打印效果

自定义Handler.png

四. 总结

这篇文章应该算是很久之前两篇文章的后续,现在越来越多的工具我开始使用Kotlin来开发。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏pangguoming

Android Data Binding(数据绑定)用户指南

1)介绍 这篇文章介绍了如何使用Data Binding库来写声明的layouts文件,并且用最少的代码来绑定你的app逻辑和layouts文件。 Data B...

43480
来自专栏大内老A

[ASP.NET MVC]通过对HtmlHelper扩展简化“列表控件”的绑定

在众多表单元素中,有一类<select>元素用于绑定一组预定义列表。传统的ASP.NET Web Form中,它对应着一组重要的控件类型,即ListContro...

21250
来自专栏Android 研究

OKHttp源码解析(五)--OKIO简介及FileSystem

okio是由square公司开发的,它补充了java.io和java.nio的不足,以便能够更加方便,快速的访问、存储和处理你的数据。OKHttp底层也是用该库...

28430
来自专栏跟着阿笨一起玩NET

关于webservice不支持方法重载的解决办法

15210
来自专栏Android-薛之涛

Android-Gson小总

几乎每次项目中都要用到Gson来解析json数据,今天想做个总结。ok,现在我们先来了解一下JSONObject和JsonObject的区别(我个人总结了三点)...

16430
来自专栏恰童鞋骚年

.NET基础拾遗(4)委托、事件、反射与特性

  委托这个概念对C++程序员来说并不陌生,因为它和C++中的函数指针非常类似,很多码农也喜欢称委托为安全的函数指针。无论这一说法是否正确,委托的的确确实现了和...

9520
来自专栏草根专栏

.NET Core装饰模式和.NET Core的Stream

Beverage是所有咖啡饮料的抽象类, 里面的cost方法是抽象的. description变量在每个子类里面都需要设置(表示对咖啡的描述).

432130
来自专栏码农分享

LinqToExcel.Extend 源码分析

展开目录结构,我们能够更加请详细的分析出每个目录所完成的功能模块。 这里主要讲解工具集中最重要的一个模块Validate

16440
来自专栏Android知识点总结

1-SIII--Json在Android中的使用--Gson

14140
来自专栏草根专栏

.NET Core/.NET之Stream简介

之前写了一篇C#装饰模式的文章提到了.NET Core的Stream, 所以这里尽量把Stream介绍全点. (都是书上的内容) .NET Core/.NET的...

42440

扫码关注云+社区

领取腾讯云代金券