Posted in Working Skills, 技术

【工作代码】复杂 JSON 值替换处理

总结下最近的工作遇到的点:
入参复杂 JSON 层层嵌套,Java 怎么优雅的处理。

一、关于 JSON

JSON 是类似 XML 用于存储和交互文本信息。但优于 XML ,其更小,更快,更易懂和解析。其是一个无序的”名称/值”对的集合。由

{ 左括号
"" 名称 String
:
值
} 右括号

组成。然后 名称值对 以逗号分隔。

二、场景描述

是一个正则匹配替换的操作。一个很长很复杂的 JSON 入参,通过正则匹配其 content 对应的值中的图片地址并替换。

三、思考

框架选型 – fastjson
(fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器,来自阿里巴巴的工程师开发。)

a . 思路
Java 是面向对象的语言。我要利用 fastjson 把复杂的 JSON 写出其对应的 BO 对象,然后正则替换 content 内容(即 operatorContent 方法),然后重新生成 JSON 响应。即下面代码操作:

OperatorBO operatorBO = JSON.parseObject(jsonString, OperatorBO.class);
operatorBO.setContent(operatorContent(operatorBO.getContent()));
String newJsonString = JSON.toJSONString(operatorBO);

 

好处:代码易读,容易维护
坏处:BO 实在是太复杂,而且很多数组嵌数组。PHP -> Java 服务化过程中很多不可控,容易出 BUG。

涉及的API :
序列化对象到 JSON:

String jsonString = JSON.toJSONString(obj);

反序列化 JSON 到对象:

VO vo = JSON.parseObject("...", VO.class);
摘要: 原创出处:www.bysocket.com 泥瓦匠BYSocket 希望转载,保留摘要,谢谢!

b . 思路
只是替换操作,所以不用太考虑代码易读性。直接利用 fastjson 直接转出 JSONArray 对象,然后操作该对象即可。JSONArray 对象本质就是一个 List<Object> 如下代码:

public class JSONArray extends JSON {
    private final List<Object> list;
    protected transient Object relatedArray;
}

具体伪代码如下:

String jsonString = "[{" + "\"content\":\"content value 1\"" + "}]";
JSONArray itemDataJsonArr = JSON.parseArray(jsonString);
String content = itemDataJsonArr.getJSONObject(0).getString("content");
content = content + "23";
itemDataJsonArr.getJSONObject(0).put(CONTENT,content);

好处:不用关心其他复杂的键值对,目标只关注要替换的节点名称。
坏处:代码不易读,相对也还容易维护。

涉及的API :
替换对应的节点名称的值:

JSONObject.put("...",value);

反序列化 JSON 到 JSONArray 对象:

JSONArray jSONArray = JSON.parseObject("...");

思路 c d e …

 

四、小结

根据服务化场景,在不确定入参 JSON 的复杂度情况下,选择了思路 b.这篇其实是工作上的小小结。任何技术,任何框架的 API 是否好用优雅,是具体场景决定的。

如以上文章或链接对你有帮助的话,别忘了在文章结尾处评论哈~ 你也可以点击页面右边“分享”悬浮按钮哦,让更多的人阅读这篇文章。

Posted in Java, 技术

有趣的译文 《Java Pattern 那些小事》

摘要: 原创出处:www.bysocket.com 泥瓦匠BYSocket 希望转载,保留摘要,谢谢!

一、现代的玩具 – Java 可以做很多事

一个 Q 与 A 的对话,展示了 Java 那些小事。

Q : 5 是整数吗?

A : 是。


Q : -23 是数吗?

A : 是,但负数使用场景很少。


Q : 5.32 是整数吗?

A : 不是,我们不用这种数值类型表示 5.32 。


Q : 5 属于什么数值类型?

A : int (整型)。
批注: int 是基本类型,int 代表整数。


Q : 快,想出另一个整数!

A : 19?


Q : 那 true 属于什么数值类型?

A : boolean (布尔型)。


Q : false 属于什么数值类型?

A : boolean。


Q : 想得出其他布尔值吗?

A : 没有,布尔值只有 true 和 false。


Q : int 是什么?

A : 一种类型。


Q : boolean 是什么?

A : 另一种类型。


Q : 什么是类型?

A : 类型是一个相关值集合的名称。


Q : 能举例解释下类型吗?

A : 使用类型就像使用一种集合一样。比如使用 boolean 可以表示逻辑值:是与非


Q : 能创建新的类型吗?

A : 我们还不知道怎么创建。


Q : 画出下面类的基本关系。

abstract class Seasoning {}

class Salt extends Seasoning {}

class Pepper extends Seasoning {}

A : 这样画?
图 1.1 Seasoning 类关系图

wechatimg4


Q : 是的。Seasoning 是数据类型,Salt 和 Pepper 是 Seasoning 的具体类型。

A : 好的。三个都是新类型吗?


Q : 是的。那么 new Salt() 是一个 Seasoning 吗?

A : 是的。 new Salt() new 关键字表示创建了 Salt 的一个实例,每个 Salt 的实例也是 Seasoning。


Q : new Pepper() 也是吗?

A : 是的。它也是一个 Seasoning。 new Pepper() new 关键字表示创建了 Pepper 的一个实例,每个 Pepper 的实例也是 Seasoning。


Q : 什么是 abstract , class 和 extends 关键字?

A : 简单地说:
abstract class 表示抽象数据类型
class 表示具体类型
extends 连接了具体类型到数据类型


Q : 还有其他的 Seasoning 具体类型吗?

A : 没有,因为只有 Salt 和 Pepper 继承 Seasoning。


Q : 正确。只有 Salt 和 Pepper 是 Seasoning 的具体类型。我们见过类似 Seasoning 数据类型吗?

A : 没有。但是 boolean 类型有两个值:true 和 false。
批注:值与具体类型是不同的。


Q : 再定义一个 Seasoning 具体类型:

class Thyme extends Seasoning {}

A : 再来一个:

class Sage extends Seasoning {}

Q : 4 个 Seasoning 具体类型了。

A : 是的。


Q : 什么是笛卡尔点?

A : 是一对数字。


Q : 曼哈顿地点位于哪里?

A : 两个城市街道的十字路口。


Q : 看代码,CartesianPt 类和 ManhattanPt 类有啥不同于 Salt 类和 Pepper 类

abstract class Point {}
class CartesianPt extends Point {
    int x;
    int y;
    CartesianPt(int _x, int _y){
        x = _x;
        y = _y;
    }
}
class ManhattanPt extends Point {
    int x;
    int y;
    ManhattanPt(int _x, int _y){
        x = _x;
        y = _y;
    }

}

A : 两个类中 {} 包含了三个元素。x 和 y 是表示点的坐标,但是构造函数里面包含什么呢?(批注:构造函数是同类名的函数)


Q : CartesianPt 和 ManhattanPt 各自的构造函数里面包含各自的字段值。

A : 那怎么使用构造函数呢?


Q : new 关键字作用于构造函数,会创建一个新的该类型实例。

A : 这样子呀。


Q : 比如下面的代码:

new CartesianPt(2,3);

使用 CartesianPt 的构造函数,创建一个 CartesianPt 实例。

A : 这样创建的 CartesianPt 实例 ,其字段 x 值为 2,y 值为 3。

class CartesianPt extends Point {

还有 extends 关键字表示创建的 CartesianPt 也是 Point。


Q : 对。那么下面代码是创建一个 ManhattanPt 实例吗?

new ManhattanPt(2,3);

A : 是,它也有 x 值为 2,y 值为 3。


Q : 构造函数就这样?

A : 基本是了,但在没有定义过构造函数的代码里,以前用过构造函数。这是怎么实现的呢?


Q : 比如 Salt 和 Pepper 没有任何字段,但是它们有个默认构造函数。

A : 这是正确使用默认构造函数的方式吗?


Q : 是的。默认构造函数没有包含字段值。使用 new 关键字创建实例时,创建的实例没有字段值。

A : 好,下面这段代码呢?

new Point()

Q : Point 是一个抽象类,它是不完整的类,所以 new 关键字不能创建 Point 实例。

A : 这就说得通了,继续。


Q : 以下定义的类是另一种抽象数据类型和它的具体数据类型吗?

abstract class Num {}
class Zero extends Num {}
class OneMoreThan extends Num {
    Num predecessor;
    OneMoreThan (Num p) {
        predecessor = p;
    }
}

A : 是的。它们定义了一种抽象数据类型和两个具体数据类型。
图 1.2 Num 类关系图

wechatimg5


Q : new Zero() 是 Num 的实例吗?

A : 明显是的。就像 new Salt() 是 Salt 的一个实例。


Q : new OneMoreThan(new Zero()) 是 Num 的实例吗?

A : 是。OneMoreThan 继承了 Num,new OneMoreThan() 是一个 OneMoreThan 实例,本身也是一个 Num 实例,并包含了一个 Num 实例(这里是指new Zero())。


Q : 为什么 OneMoreThan 可以这样实现?

A : new Zero() 是一个 Num 实例,OneMoreThan 的实例创建时,包含了 Zero 的实例。


Q : 包含 Zero 实例?

A : OneMoreThan 的实例拥有一个值叫做 predecessor,即这个值可以是 new Zero()。


Q : predecessor 只能是 Zero 的实例?

A : 不是的。Num predecessor 说明了 predecessor 是一个 Num,所以具体表现为 OneMoreThan 或者 Zero 的实例。


Q : 那 new OneMoreThan(new OneMoreThan(new Zero()))呢?

A : 一个 Num 的实例,最外层的 new OneMoreThan 拥有了一个 Num 的实例:new OneMoreThan(new Zero())


Q : 那 new OneMoreThan(0)?

A : 胡说,0 不是一个 Num 。


Q : new Zero() 和 0 一样吗?

A : 不一样,虽然 new Zero() 和 0 概念相似,但不一样。


Q : new OneMoreThan(new Zero()) 和 1 概念相似?

A : 是的,但是他们是不一样的。


Q : new OneMoreThan( new OneMoreThan( new OneMoreThan(new Zero())))和哪个数概念相似?

A : 3


Q : Num 比 boolean 多吗?

A : 多很多。


Q : 比 int 多吗?

A : 不。


Q : 说下 new Zero() 和 0 的区别呢?

A : 我们得区别它们。new Zero() 是 Zero 的一个实例,意味着也是 Num 。0 是一个 int。


Q : 正确。不同数据类型的实例就是不同的。

A : 类型是一系列实例的统称。


Q : 基本类型(int 和 boolean)是不同的。

A : 那些不是基本类型呢?


Q : 类定义不引入基本类型,比如上面提到的 new Zero() 不单单是 Zero 的实例,也是 Num。任何继承 Num 的数据类型都是。

A : 然后呢?


Q : 就像每个数据类型继承 Object。

A : 就是说,所有类都是一个对象。


Q : 正确,下面有所体现。

A : 好的。


建议一:
自定义数据类型时,使用抽象类
自定义具体数据类型时,使用 extends 关键词继承抽象类


Q : 看看下面的定义?

abstract class Layer {}
class Base extends Layer {
    Object o;
    Base(Object o) {
        this.o = o;
    }
}
class Slice extends Layer {
    Layer l;
    Slice(Layer l) {
        this.l = l;
    }
}

A : 定义了 Layer 抽象数据类型和其两个具体数据类型 Base 和 Slice。其中 Base 包含一个值对象 Object。


Q : new Base(new Zero()) 是什么?

A : 一个 Base 的实例,即是 Layer 又是 Object 的实例。


Q : new Base(new Salt()) 是什么?

A : 一个 Base 的实例。但 new Base(new Salt())new Base(new Zero()) 是同一个数据类型吗?


Q : 是的。因为对象实例由 new 关键字创建,而它们都是 Base。

A : 因为 Base 包含的值对象是 Object。所以可以是 new Salt()new Zero()


Q : 任何都是个 Object 吗?

A : new 关键字创建的都是对象。自然 String 、Arrays 也是对象,这里我们不展开讲。


Q : 是的。下面的是 Layer 实例吗?

new Base(5)

A : 5 没有通过 new 创建,所以这个错误的语法。


Q : 下面的是 Layer 实例吗?

new Base(false)

A : false 没有通过 new 创建,所以这个错误的语法。


Q : 下面的是 Layer 实例吗?

 new Base(new Integer(5))

A : 是的。 new Integer(5) 创建了一个 int 对象。


Q : 那么怎么创建一个 Layer 实例拥有 false?

A : 简单:

 new Base(new Boolean(false))

Q : int Integer / boolean Boolean 混乱了?

A : 以后会涉及到。


Q : 期待更多吧。

A : 迫不及待。