热门标签
热门文章
- 1在启动MYSQL时出现问题：“ERROR 2003 (HY000): Can't connect to MySQL server on 'localhost' (10061)”
- 2机器学习算法——EM算法_介绍em算法
- 3sparksql自定义数据源
- 4图像处理与计算机视觉资源汇总——论文+代码+教材+视频等等_h. bay, t. tuyt, l. van gool, "a fast hierarchical
- 5快递物流管理系统的设计与实现(SSM,MySQL)_快递物流关系系统项目设计
- 6云平台自动化安全监控工具PacBot_云平台 在线安全检测工具
- 7深度强化学习主流算法介绍（一）：DQN系列_深度强化算法
- 8浅谈软件测试工程师如何编写测试用例_测试开发工程师面试测试用例怎么写
- 9C++编写的Web框架有哪些？
- 10慢SQL治理经验分享_写个慢sql
当前位置: article > 正文
【实用代码】日志转Json详细解析 （LogToJson）_日志文件数据转换
作者：Cpp五条 | 2024-05-15 09:09:29
赞
踩
日志文件数据转换
在项目中记录日志的时候，常常会直接输出一个对象，直接输出对象会调用对象的toString方法，最终一会把一个对象的每个字段甚至嵌套的字段都打印出来。但是一般拿到日志需要做某些分析或排查问题的时候，常常需要将日志转成json字符串，方便在各种中间件传输以及接口调用。本文针对这种场景，设计了一种快速将日志转换成json的工具，非常实用，并且提出了一种通用的方法去做类似的转换工作。
1.需求背景
背景
在项目中输出各种日志，常常会把一些对象一起输出来，如下：
//请求有问题，将请求的request对象输出，便于排查问题
LogUtil.error(log, "request error, request=", request);
- 1
- 2
- 3
但是输出后的这个对象，往往是按照重写的toString方法来进行输出的，这种输出效果我们看完全可以，但是如果要用它来排查问题，肯定不太方便，例如：将这个请求重试一遍，debug一下；将这个请求传到mq中排查一下链路。等等还有很多。这些操作往往有一个共性，就是，它需要是一个json字符串，因为json是一般的序列化手段，所以如果用json格式的对象去排查问题肯定要方便的多。
看到这里就有个问题了，既然我们需要json格式的对象，我们在打日志的时候用fastjson打出来不就好了吗?
可是可以，但是任何json工具都是基于反射的，比起直接输出对象，性能上要差很多，并且json格式的数据相比而言会占用额外的空间。
所以更常见的做法是：打印日志的时候直接输出对象，然后需要转成json的时候再用相应的工具转成json来使用。
而一般的toString方法常使用Lombok的插件生成，所以本文代码主要针对Lombok生成的toString方法来考虑。
对于这种日志转换，如果要能考虑到方方面面，本身是一个非常庞大的工程，但是日常使用的时候，大部分场景是用不到的，所以我们需要针对一般的case分析出恰到好处的需求。
case分析
假设有一个订单类，如下：
@Data
public class Order {
private String name;
private int count;
private double money;
private Buyer buyer;
private List<String> items;
private Date createTime;
private boolean isPay;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
编译后的toString方法为：
public String toString() {
return "Order(name=" + this.getName() + ", count=" + this.getCount() + ", money=" + this.getMoney() + ", buyer=" + this.getBuyer() + ", items=" + this.getItems() + ", createTime=" + this.getCreateTime() + ", isPay=" + this.isPay() + ")";
}
- 1
- 2
- 3
其中购买者类如下：
@Data
public class Buyer {
String uid;
String type;
Map<String, String> extInfo;
}
- 1
- 2
- 3
- 4
- 5
- 6
编译后的toString方法为：
public String toString() {
return "Buyer(uid=" + this.getUid() + ", type=" + this.getType() + ", extInfo=" + this.getExtInfo() + ")";
}
- 1
- 2
- 3
现在我构造如下一个order对象：
public static void main(String[] args) throws ParseException{
Order order = new Order();
order.setCount(1);
order.setMoney(5.20d);
order.setName("name");
Buyer buyer = new Buyer();
buyer.setUid("uid");
buyer.setType("online");
Map<String, String> extInfo = new HashMap<>();
extInfo.put("note", "12345");
buyer.setExtInfo(extInfo);
order.setBuyer(buyer);
List<String> items = new ArrayList<>();
items.add("item1");
items.add("item2");
order.setItems(items);
order.setCreateTime(new GregorianCalendar(2022, Calendar.AUGUST, 25, 0, 0, 0).getTime());
System.out.println(order);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
那么日志输出，应该为一下内容：
Order(name=name, count=1, money=5.2, buyer=Buyer(uid=uid, type=online, extInfo={note=12345}), items=[item1, item2], createTime=Thu Aug 25 00:00:00 CST 2022, isPay=true)
- 1
而我们理想条件下，应该需要得到如下的json字符串：
{
"isPay": true,
"money": 5.2,
"createTime": "2022-08-25 00:00:00",
"name": "name",
"count": 1,
"items": [
"item1",
"item2"
],
"buyer": {
"uid": "uid",
"type": "online",
"extInfo": {
"note": "12345"
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
我们仔细观察一下，从这个转换中，我们可以得到以下的基本信息：
- boolean，double，int等基本类型要能正确转换。
- 数组和集合类型要能正确转换。
- map类型要能正确转换。
- 日期类型要能正确转换。
- 嵌套的对象要能正确转换。
不过，还有一种case很常见，但是上面这个例子没体现出来的地方，就是继承的场景，我们稍微更改一下上面的类，Buyer类进行拆分，变成如下两个类，满足继承关系：
@Data
public class User {
String uid;
}
- 1
- 2
- 3
- 4
- 5
@Data
@ToString(callSuper=true)
public class Buyer extends User{
String type;
Map<String, String> extInfo;
}
- 1
- 2
- 3
- 4
- 5
- 6
注意：@ToString(callSuper=true) 表示生成toString方法的时候，连同父类的属性一起打印出来。
这样打印的结果是：
Order(name=name, count=1, money=5.2, buyer=Buyer(super=User(uid=uid), type=online, extInfo={note=12345}), items=[item1, item2], createTime=Thu Aug 25 00:00:00 CST 2022, isPay=true)
- 1
注意加了super=()。
也就是说我们还需要处理这种场景下的转换。
在上面我们打印了时间，发现默认是CST（中央标准时间）格式的时间，所以我们需要转换为更直白一点的时间表示，在某些国际业务场景下，UTC（协调世界时）也非常常用，所以需要考虑一下这两种不同格式时间的转换。
还有这样一个场景，如果一个对象为空，java里面默认会打印出：<null>。
好了，上面是从一个工具的使用场景去分析的需求，接下来，我们还需要站在技术侧的角度去思考一些问题。
我们仔细对比一下日志和需要的json：
Order(name=name, count=1, money=5.2, buyer=Buyer(super=User(uid=uid), type=online, extInfo={note=12345}), items=[item1, item2], createTime=Thu Aug 25 00:00:00 CST 2022, isPay=true)
- 1
{"isPay":true,"money":5.2,"createTime":"2022-08-25 00:00:00","name":"name","count":1,"items":["item1","item2"],"buyer":{"uid":"uid","type":"online","extInfo":{"note":"12345"}}}
- 1
发现在日志的体现里，所有东西都被当成了字符串，也没有双引号啥的；但是在json里面，有的数字就是数字展示，有的数字就是带双引号的，被视作字符串，那我们怎么知道日志里面的数字到底对应的是数字还是单引号呢？
有人可能会说用反射去取类的字段就可以了，但是这里有个前提条件，要能拿到这个类，但是作为一个临时使用的工具来说，还要专门去导入需要的jar包，未免过于麻烦，当然能拿到类用反射去匹配字段肯定是最快的方式，在这里我们的实现不需要能拿到类就能转换成json。
那么既然不拿这个类，就无法区分到底哪些是数字哪些是字符串了，需要做一个取舍，但是有这样一个情况，在很多中间件里，如果实际是int类型，你传了一个"123"，实际上反序列化的时候它也能拓展支持，只要字段名相同，所以这里我们可以适当取舍，对所有数字类型和布尔类型，都当成字符串来处理，实在最后类型对不上，手调几个也没太大关系，反正定位是临时使用的工具。
需求标准
综上，我们需要满足如下需求：
- 能处理数组、集合类型。
- 能处理map类型。
- 能处理对象嵌套类型。
- 能处理继承。
- 能处理空对象。
- 能处理两种不同的时间表示方式。
- 其余数字、布尔类型，均当做字符串来进行处理。
当然，实际转换的过程可能要更加复杂，但是大部分情况下，这些类型已经够用了，所以此处我们仅针对这些情况来考虑转换。
2.设计分析
记下来我们详细分析一下，要实现这样应该工具，应该从哪几个方面下手。
首先，我们要知道，一个json，本身就是一个大map，我们把所有的属性构造成map键值对的方式后用fastjson转一下就可以变成json字符串，现在难点就来到了如何把里面所有的属性提取出来构造一个map。
再来观察一下打印输出的结果：
Order(name=name, count=1, money=5.2, buyer=Buyer(super=User(uid=uid), type=online, extInfo={note=12345}), items=[item1, item2], createTime=Thu Aug 25 00:00:00 CST 2022, isPay=true)
- 1
我们可以某些细节：
- 一个对象的表示方式是对象名后接一对小括号，小括号里面是这个对象的一些属性。属性间用逗号分隔。
- 数组和集合类型的表示方式是
[a,b,c]。中括号里面内容用逗号分隔 - map的表示方式是
{a=xx,b=xx}。大括号里面是一些键值对，用逗号分隔。 - 时间格式相对比较固定。
- 父类的内容会以
super()的方式进行表达。 - 其余类型基本上是
a=xx这样。
我们拿到这样一个字符串后，首先应该做的就是确定我们当前拿到的是个什么类型，是对象类型、集合类型、map类型还是什么，知道是种什么类型后，然然层层深入往里面进行处理，递归的处理，直到处理到我们能轻松解决的类型为止。
如何确定拿到的字符串是一个什么类型，在我们不知道原类的基础上，我们唯一的办法就是，根据这些类型的特征来判断，很明显：使用正则表达式是一种不错的方法，这几种类型的正则表达式如下所示：
//CST日期匹配正则
private static Pattern cstDatePattern = Pattern.compile("^[a-zA-Z]{3} [a-zA-Z]{3} [0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2} CST ((19|20)\\d{2})$");
//UTC日期匹配正则
private static Pattern utcDatePattern = Pattern.compile("^[0-9]{4}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}.[0-9]{3}$]");
//数字类型匹配正则
private static Pattern numPattern = Pattern.compile("^-?[0-9]+\\.?[0-9]*$");
//集合类型
private static Pattern listPattern = Pattern.compile("^\\[.*\\]$");
//map类型
private static Pattern mapPattern = Pattern.compile("^\\{.*\\}$");
//对象类型
private static Pattern objectPattern = Pattern.compile("^[a-zA-Z0-9\\.]+\\(.+\\)$");
//super
private static Pattern superPattern = Pattern.compile("^super=[a-zA-Z0-9\\.]+\\(.+\\)$");
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
知道是什么类型后，我们应该深入的去解析每一种类型里面的字段，这里可能存在嵌套，比如一个对象里面的一个属性它还是一个对象，那么我们要能把里面属性的字符串内容给分割出来才行，要分割里面的对象，不能简单的通过某种分隔符来做，因为里面这个对象还可能嵌套了n层，面对这种嵌套的场景，我们常使用栈来处理。
经过上面的分析，我们的处理无非三步：
- 确定当前处理的字符串部分属于什么类型。
- 如何分割出下一个要处理的类型（递归处理）。
- 处理我们能处理的那几种类型。
我们可以借助栈，使用如下工具类来分割出下一个要处理的部分。
public static class ToStringTokenUtils {
private static List<Character> TOKEN_LEFT = Arrays.asList('(', '[', '{');
private static List<Character> TOKEN_RIGHT = Arrays.asList(')', ']', '}');
static String splitToken(String str) {
if(StringUtils.isBlank(str)) {
return str;
}
int index = indexOfSplitToken(str, ',');
return str.substring(0, index);
}
static Pair<String, String> parseToken(String token) {
int index = indexOfSplitToken(token, '=');
return new Pair<>(token.substring(0, index), token.substring(index + 1));
}
private static int indexOfSplitToken(String token, char split) {
Deque<Character> stack = new LinkedList<>();
for(int i = 0; i < token.length(); i++) {
char c = token.charAt(i);
if(TOKEN_LEFT.contains(c)) {
stack.push(c);
} else if(TOKEN_RIGHT.contains(c)) {
//括号一定要匹配
if(TOKEN_LEFT.indexOf(stack.peek()) != TOKEN_RIGHT.indexOf(c)) {
throw new RuntimeException("括号匹配异常, stack=" + stack + ",token=" + token);
}
stack.pop();
} else if(c == split && stack.isEmpty()) {
return i;
}
}
if(stack.isEmpty()) {
return token.length();
}
//匹配结束都没匹配到，匹配异常
throw new RuntimeException("获取分割下标异常, stack=" + stack + ",token=" + token);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
3.实现代码
导包：
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.76</version>
</dependency>
<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
<version>2.6</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
</dependency>
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
import com.alibaba.fastjson.JSON;
import javafx.util.Pair;
import org.apache.commons.lang.StringUtils;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Pattern;
/**
* @author ATFWUS
*/
public class LogToJson {
private static final String NULL = "<null>";
//CST日期匹配正则
private static Pattern cstDatePattern = Pattern.compile("^[a-zA-Z]{3} [a-zA-Z]{3} [0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2} CST ((19|20)\\d{2})$");
//UTC日期匹配正则
private static Pattern utcDatePattern = Pattern.compile("^[0-9]{4}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}.[0-9]{3}$]");
//数字类型匹配正则
private static Pattern numPattern = Pattern.compile("^-?[0-9]+\\.?[0-9]*$");
//集合类型
private static Pattern listPattern = Pattern.compile("^\\[.*\\]$");
//map类型
private static Pattern mapPattern = Pattern.compile("^\\{.*\\}$");
//对象类型
private static Pattern objectPattern = Pattern.compile("^[a-zA-Z0-9\\.]+\\(.+\\)$");
//super
private static Pattern superPattern = Pattern.compile("^super=[a-zA-Z0-9\\.]+\\(.+\\)$");
public static String toJsonString(String str) throws ParseException{
return JSON.toJSONString(strToMap(str));
}
public static <T> T toObject(String str, Class<T> clazz) throws ParseException {
return JSON.parseObject(toJsonString(str), clazz);
}
private static Map<String, Object> strToMap(String str) throws ParseException {
//空校验
str = StringUtils.trim(str);
if(StringUtils.isEmpty(str)) {
return str == null ? null : new HashMap<>();
}
//获取str主要内容 第一个"()"
str = StringUtils.substringAfter(str, "(").trim();
str = StringUtils.substringBeforeLast(str, ")").trim();
//开始构造
String token;
Map<String, Object> map = new HashMap<>();
while(StringUtils.isNotEmpty(str) && StringUtils.isNotEmpty(token = ToStringTokenUtils. splitToken(str))) {
str = StringUtils.removeStart(str, token).trim();
str = StringUtils.removeStart(str, ",").trim();
// 如果带"super="(lombok的@ToString(callSuper=true), 按照当前层继续处理
if(superPattern.matcher(token).matches()) {
token = token.substring(token.indexOf("(") + 1, token.length() - 1);
str = String.format("%s, %s", token, str);
continue;
}
Pair<String, String> pair = ToStringTokenUtils.parseToken(token);
map.put(pair.getKey(), buildTypeValue(pair.getKey(), pair.getValue()));
}
return map;
}
private static Object buildTypeValue(String key, String value) throws ParseException {
// value为null的情况
if(StringUtils.isEmpty(value)) {
return null;
} else if (NULL.equals(value)) {
return null;
}
// CST日期类型
if(cstDatePattern.matcher(value).matches()) {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date us = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzzz yyyy", Locale.ENGLISH).parse(value);
return format.format(us);
}
// UTC日期类型
if(utcDatePattern.matcher(value).matches()) {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date us = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS", Locale.ENGLISH).parse(value);
return format.format(us);
}
// 数字类型
if(numPattern.matcher(value).matches()) {
return value;
}
// 集合类型
if(listPattern.matcher(value).matches()) {
return buildListValue(value);
}
// map类型
if(mapPattern.matcher(value).matches()) {
return buildMapValue(value);
}
// 对象类型
if(objectPattern.matcher(value).matches()) {
return strToMap(value);
}
//其余一律当做str处理
return value;
}
private static Object buildListValue(String value) throws ParseException {
List<Object> result = new ArrayList<>();
// 去除左右括号
value = value.substring(1, value.length() - 1).trim();
String token = null;
while(StringUtils.isNotBlank(value) && StringUtils.isNotBlank(token = ToStringTokenUtils.splitToken(value))) {
result.add(buildTypeValue(null, token));
value = StringUtils.removeStart(value, token).trim();
value = StringUtils.removeStart(value, ",").trim();
}
return result;
}
private static Object buildMapValue(String value) throws ParseException {
Map<Object, Object> result = new HashMap<>();
value = value.substring(1, value.length() - 1).trim();
if(StringUtils.isEmpty(value)) {
return result;
}
String token = null;
while(StringUtils.isNotEmpty(token = ToStringTokenUtils.splitToken(value))) {
Pair<String, String> pair = ToStringTokenUtils.parseToken(token);
result.put(buildTypeValue(pair.getKey(), pair.getKey()), buildTypeValue(pair.getKey(), pair.getValue()));
value = StringUtils.removeStart(value, token).trim();
value = StringUtils.removeStart(value, ",").trim();
}
return result;
}
public static class ToStringTokenUtils {
private static List<Character> TOKEN_LEFT = Arrays.asList('(', '[', '{');
private static List<Character> TOKEN_RIGHT = Arrays.asList(')', ']', '}');
static String splitToken(String str) {
if(StringUtils.isBlank(str)) {
return str;
}
int index = indexOfSplitToken(str, ',');
return str.substring(0, index);
}
static Pair<String, String> parseToken(String token) {
int index = indexOfSplitToken(token, '=');
return new Pair<>(token.substring(0, index), token.substring(index + 1));
}
private static int indexOfSplitToken(String token, char split) {
Deque<Character> stack = new LinkedList<>();
for(int i = 0; i < token.length(); i++) {
char c = token.charAt(i);
if(TOKEN_LEFT.contains(c)) {
stack.push(c);
} else if(TOKEN_RIGHT.contains(c)) {
//括号一定要匹配
if(TOKEN_LEFT.indexOf(stack.peek()) != TOKEN_RIGHT.indexOf(c)) {
throw new RuntimeException("括号匹配异常, stack=" + stack + ",token=" + token);
}
stack.pop();
} else if(c == split && stack.isEmpty()) {
return i;
}
}
if(stack.isEmpty()) {
return token.length();
}
//匹配结束都没匹配到，匹配异常
throw new RuntimeException("获取分割下标异常, stack=" + stack + ",token=" + token);
}
}
public static void main(String[] args) throws ParseException{
Order order = new Order();
order.setCount(1);
order.setMoney(5.20d);
order.setName("name");
Buyer buyer = new Buyer();
buyer.setUid("uid");
buyer.setType("online");
Map<String, String> extInfo = new HashMap<>();
extInfo.put("note", "12345");
buyer.setExtInfo(extInfo);
order.setBuyer(buyer);
List<String> items = new ArrayList<>();
items.add("item1");
items.add("item2");
order.setItems(items);
order.setCreateTime(new GregorianCalendar(2022, Calendar.AUGUST, 25, 0, 0, 0).getTime());
order.setPay(true);
String logStr = order.toString();
System.out.println(logStr);
System.out.println(LogToJson.toJsonString(logStr));
System.out.println(JSON.toJSONString(order));
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
- 206
- 207
- 208
- 209
- 210
- 211
- 212
输出结果：
Order(name=name, count=1, money=5.2, buyer=Buyer(super=User(uid=uid), type=online, extInfo={note=12345}), items=[item1, item2], createTime=Thu Aug 25 00:00:00 CST 2022, isPay=true)
{"isPay":"true","money":"5.2","createTime":"2022-08-25 00:00:00","name":"name","count":"1","items":["item1","item2"],"buyer":{"uid":"uid","type":"online","extInfo":{"note":"12345"}}}
{"buyer":{"extInfo":{"note":"12345"},"type":"online","uid":"uid"},"count":1,"createTime":1661356800000,"items":["item1","item2"],"money":5.2,"name":"name","pay":true}
- 1
- 2
- 3
- 4
从实用性上来讲，应该能解决大部分项目中这种日志转json的问题，少部分复杂的对象可能还需要手动调整一下。
4.通用思想+未来拓展
本文实现了较为简单场景下的日志向json的转换，优势是不需要知道原类，使用正则匹配的方式确定可能的类型，整个实现过程中，参考了fastjson源代码的设计，能较为简单的表达fastjson分层设计的思想里面的一点：一个类处理一种类型， 若嵌套，嵌套的部分交给其它类来处理，单一职责。
在不知道原类的情况下做转换，会存在一个致命缺陷：字符串和某些类型无法区分，理论上来说，要拿到这个类通过反射来逐一匹配字段才能完全正确，当然这里面也会存在很多问题，这是未来值得拓展的一点。
本篇文章算是抛砖引玉了，在这种对象、日志、json等之间的转换，还是存在很多细节问题的，去仔细阅读以下fastjson的源码可能会有更多收获。
ATFWUS 2022-08-25
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/572107
推荐阅读
相关标签
