GVKun编程网logo

如何使用Jackson重命名JSON序列化中的根密钥（jackson序列化json原理）

12

本文将分享如何使用Jackson重命名JSON序列化中的根密钥的详细内容，并且还将对jackson序列化json原理进行详尽解释，此外，我们还将为大家带来关于Fastjson和Jackson序列化和读

本文将分享如何使用Jackson重命名JSON序列化中的根密钥的详细内容，并且还将对jackson序列化json原理进行详尽解释，此外，我们还将为大家带来关于Fastjson和Jackson序列化和读取json的性能实测、Jackson json序列化和反序列化工具类、Jackson JSON序列化，通过级别定义避免递归、Jackson、FastJson、Gson序列化比较，默认配置下的相关知识，希望对你有所帮助。

本文目录一览：

如何使用Jackson重命名JSON序列化中的根密钥（jackson序列化json原理）

如何使用Jackson重命名JSON序列化中的根密钥（jackson序列化json原理）

我正在使用Jackson对对象列表进行JSON序列化。

这是我得到的：

{"ArrayList":[{"id":1,"name":"test name"}]}

但是我想要这个：

{"rootname":[{"id":1,"name":"test name"}]} // ie showing the string I want as the root name.

下面是我的处理方法：

接口：

public interface MyInterface {
    public long getId();
    public String getName();
}

实现类：

@JsonRootName(value = "rootname")
public class MyImpl implements MyInterface {
    private final long id;
    private String name;

    public MyImpl(final long id,final name) {
        this.id = id;
        this.name = name;
    }

   // getters     
}

JSon序列化：

public class MySerializer {
    public static String serializeList(final List<MyInterface> lists) {
        //check for null value.Throw Exception
        final ObjectMapper mapper = new ObjectMapper();
        mapper.configure(SerializationConfig.Feature.WRAP_ROOT_VALUE,true);
        return mapper.writeValueAsString(lists);
    }
}

测试：

final List<MyInterface> list = new ArrayList<MyImpl>();
MyImpl item = new MyImpl(1L,"test name");
list.add(item);
final String json = MySerializer.serializeList(list);
System.out.println(json);

这是我得到的：

{"ArrayList":[{"id":1,"name":"test name"}]} // ie showing the string I want as the root     name.

还是我错过了什么？我为此使用杰克逊1.9.12。欢迎在这方面提供任何帮助。

Fastjson和Jackson序列化和读取json的性能实测

Fastjson和Jackson序列化和读取json的性能实测

偶然间看到的阿里出品的Fastjson，网上对这个json包好评如潮，性能胜Jackson10倍。
本人本着眼见为实的想法，自己测试一下两者的性能比较。

###测试### POJO对象名字为User，具体代码就不贴了，里面有两个属性，分别是int类型的id和String类型的name，很简单的一个类。

测试程序（只是简单的测试下，这里并未深究其中的各种构造方法）

    public class MyMain {
	private static final int TEST_CASE_NUM = 1000;
	public static void main(String args[]) throws IOException {

		List<User> users = new ArrayList<User>();
		Random random = new Random();

		for (int i = 0; i < TEST_CASE_NUM; i++) {
			User user = new User();
			user.setId(random.nextInt(10));
			user.setName("123");
			users.add(user);
		}

		Monitor.begin();
		for (User u : users){
			String s = JSON.toJSONString(u);
		}
		Monitor.end("serilization of fastjson");

		Monitor.begin();
                                    /**
		 * 这里仅创建一个ObjectMapper实例
		 * 而网上的很多测试程序中，把实例的创建过程
		 * 加入到了for循环中，因此测出来的序列化性能
		 * 有10倍之差，其实其中大部分都消耗在了ObejectMapper
		 * 实例创建上。
		 */
		ObjectMapper objectMapper = new ObjectMapper();
		for (User u : users){
			String s = objectMapper.writeValueAsString(u);
		}
		long endjackson = System.currentTimeMillis();
		Monitor.end("serilization of jackson");


		List<String> strs = new ArrayList<String>();
		for (int j = 0; j < TEST_CASE_NUM; j++) {
			String s = new String("{\"id\":1,\"name\":\"123\"}");
			strs.add(s);
		}

		Monitor.begin();
		for (String s : strs){
			User user = JSON.parseObject(s,User.class);
		}
		Monitor.end("reading string by fastjson");

		Monitor.begin();
                                    ObjectMapper obj = new ObjectMapper();
		for (String s : strs){
			User user = obj .readValue(s,User.class);
		}
		Monitor.end("reading string by jackson");
	}
}

运行程序得到输出：

    serilization of fastjson use 158 ms
serilization of jackson use 339 ms
reading string by fastjson use 49 ms
reading string by jackson use 73 ms

多次运行后结果相差甚微，比例关系基本保持稳定。由此可见fastjson并未如网上传言那般，性能较之于jackson提升10倍。如果将ObjectMapper实例的创建过程也从计时器中提取出来，哪么Jackson与fastjson的序列化性能几乎相同。
然而在反序列方面，fastjson以巨大的优势领先Jackson，将测试的用例个数增加至1000000，得到的输出为：

    reading string by fastjson use 505 ms
reading string by jackson use 1051 ms

fastjson几乎只需要Jackson的一半时间，这个表现相当亮眼。

在这里我们反序列化的字符串是按照实体类中属性的顺序排列的，如果打乱一下顺序呢？
这里还是使用1000000个测试用例，得到的输出结果为：

    reading string by fastjson use 715 ms
reading string by jackson use 1049 ms

因为fastjson默认开启了sort field martch优化算法，打乱顺序之后性能下降，但仍然领先Jackson不少。

###总结### 这次测试使用的是1.9.31版本的Jackson和1.1.39版本的fasijson，测试结果表名fastjson和Jackson在序列化性能上相差不大（主要ObjectMapper类新建实例耗费不少时间），但是在反序列化方面，fastjson要明显领先于Jackson。

Jackson json序列化和反序列化工具类

Jackson json序列化和反序列化工具类

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.List;

/**
 * Jackson json序列化和反序列化工具类
 * Created by macro on 2018/4/26.
 */
public class JsonUtil {

    // 定义jackson对象
    private static final ObjectMapper MAPPER = new ObjectMapper();

    /**
     * 将对象转换成json字符串。
     */
    public static String objectToJson(Object data) {
        try {
            String string = MAPPER.writeValueAsString(data);
            return string;
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
    
    /**
     * 将json结果集转化为对象
     * 
     * @param jsonData json数据
     * @param beanType 对象中的object类型
     */
    public static <T> T jsonToPojo(String jsonData, Class<T> beanType) {
        try {
            T t = MAPPER.readValue(jsonData, beanType);
            return t;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    
    /**
     * 将json数据转换成pojo对象list
     */
    public static <T>List<T> jsonToList(String jsonData, Class<T> beanType) {
        JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);
        try {
            List<T> list = MAPPER.readValue(jsonData, javaType);
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        return null;
    }
    
}

 

Jackson JSON序列化，通过级别定义避免递归

Jackson JSON序列化，通过级别定义避免递归

我使用Jackson库将我的pojo对象序列化为JSON表示形式。例如，我有A类和B类：

class A {
  private int id;
  private B b;

  constructors...
  getters and setters
}

class B {
  private int ind;
  private A a;

  constructors...
  getters and setters
}

如果我要序列化类A中的对象，则有可能在序列化时获得递归。我知道我可以通过使用停止它@JsonIgnore。

是否可以通过深度级别限制序列化？

例如，如果级别为2，则序列化将以这种方式进行：

  • 序列化一个，级别= 0（0 <2正常）->序列化
  • 序列化ab，级别= 1（1 <2 ok）->序列化
  • 序列化ABA，级别= 2（2 <2不正确）->停止

提前致谢。

Jackson、FastJson、Gson序列化比较，默认配置下

Jackson、FastJson、Gson序列化比较，默认配置下

package com.main;
    • import java.util.Date;
  • public class User {
  • private String name;
  • private Integer age;
  • private Date birthday;
  • private String email;
  • public String getName() {
  • return name;
  • }
  • public void setName(String name) {
  • this.name = name;
  • }
  • public Integer getAge() {
  • return age;
  • }
  • public void setAge(Integer age) {
  • this.age = age;
  • }
  • public Date getBirthday() {
  • return birthday;
  • }
  • public void setBirthday(Date birthday) {
  • this.birthday = birthday;
  • }
  • public String getEmail() {
  • return email;
  • }
  • public void setEmail(String email) {
  • this.email = email;
  • }
  • public Double getPercent() {
  • return this.age / 100.0;
  • }
  • public String getPreName() {
  • return "Pre" + this.name;
  • }
  • }

    •         User use

    关于如何使用Jackson重命名JSON序列化中的根密钥和jackson序列化json原理的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于Fastjson和Jackson序列化和读取json的性能实测、Jackson json序列化和反序列化工具类、Jackson JSON序列化，通过级别定义避免递归、Jackson、FastJson、Gson序列化比较，默认配置下的相关知识，请在本站寻找。

    本文标签：

    上一篇在react-js中播放声音（react 播放音频）

    下一篇带ES6的ReactJS：当我交流两个组件时，this.props不是一个函数（react两种组件）

    相关文章