jackson的readValue和convertValue方法

已于 2023-01-04 21:25:55 修改
阅读量1w 收藏 51
点赞数 19
分类专栏： java 文章标签： jackson
于 2022-03-25 18:15:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuxiao723846/article/details/123728803
版权

jackson是一个强大的json工具库，但api不够直观（至少不如fastJson），使用起来总是没有那么友好。本文介绍readValue和convertValue这两个方法的使用和区别。

在使用jackson对json处理之前， 首先要创建ObjectMapper对象：

ObjectMapper objectMapper = new ObjectMapper()

说明：这个对象是线程安全的，在网上看到过，在高并发环境下，为了保证线程安全会有较高的锁竞争，所以很多时候都是每次通过new来创建ObjectMapper。

一、readValue()方法：

这个方法有很多个重载，但是总的来说都是用来将json字符串，转换成一个object（bean、map、List<bean/map>）。

先来看一些准备数据：

@Data
public class User {
	private String name;
	private String nameEn;
}

//简单类型
String arrayStr = "[{\"name\":\"Zhangsan\"},{\"nameEn\":\"Lisi\"}]";
String jsonStr = "{\"name\":\"a\",\"nameEn\":\"b\"}";

//复杂类型
private static String getComplex1() throws Exception{
    List<Map<String,User>> list = new ArrayList<>();
    Map<String,User> m1 = new HashMap<>();
    m1.put("1", new User("zs","zs_en"));
    Map<String,User> m2 = new HashMap<>();
    m2.put("3", new User("ls","ls_en"));
    list.add(m1);
    list.add(m2);
    
    return new ObjectMapper().writeValueAsString(list);
}
private static String getComplex2() throws Exception{
    Map<String,List<User>> m = new HashMap<>();
    List<User> list1 = new ArrayList<>();
    list1.add(new User("tt","tt1"));
    m.put("1", list1);
    
    List<User> list2 = new ArrayList<>();
    list2.add(new User("ww","ww1"));
    m.put("2", list2);
    
    return new ObjectMapper().writeValueAsString(m);
}

readValue支持一下三种api：

  • readValue(String content, Class<T>  valueType)

  • readValue(String content, TypeReference<T> valueTypeRef)

  • readValue(String content, JavaType valueType)

1、readValue(String content, Class<T>  valueType)使用：

/**
* readValue(String content, Class<T>  valueType)
*/

//bean
User uu = new ObjectMapper().readValue(jsonStr, User.class);
System.out.println(uu);//User(name=a, nameEn=b)
//map
Map mm = new ObjectMapper().readValue(jsonStr, Map.class);
System.out.println(mm);//{name=a, nameEn=b}

//默认jackson将每个json对象封装成LinkedHashMap，然后放到list中
List<Map> readValue = new ObjectMapper().readValue(arrayStr, List.class);
System.out.println(readValue);//[{name=Zhangsan}, {nameEn=Lisi}]

//List<bean> 无法构造

//复杂类型
String complexStr1 = getComplex1(); //List<Map<String, User>>
String complexStr2 = getComplex2(); //Map<String,List<User>>

List<Map> list1 = new ObjectMapper().readValue(complexStr1, List.class);
System.out.println(list1); //[{1={name=zs, nameEn=zs_en}}, {3={name=ls, nameEn=ls_en}}]

Map map1 = new ObjectMapper().readValue(complexStr2, Map.class);
System.out.println(map1); //{1=[{name=tt, nameEn=tt1}], 2=[{name=ww, nameEn=ww1}]}

说明：该api主要是用来将json字符串装成bean或者map，对于json数组的情况，默认是转成LinkedHashMap放到list中（无法指定list元素类型），所以对于List<Bean>这种结构，推荐使用下面两种方式。

2、readValue(String content, TypeReference valueTypeRef)使用：

TypeReference可以用来指定反序列化时数据类型，支持json对象和json数组。

示例：

/**
 * readValue(String content, TypeReference valueTypeRef) 
 */
private static  void typeReference() throws Exception {
    //bean
    User uu1 = new ObjectMapper().readValue(jsonStr, new TypeReference<User>(){});
    System.out.println(uu1); //User(name=a, nameEn=b)
    //map
    Map mm1 = new ObjectMapper().readValue(jsonStr, new TypeReference<Map>(){});
    System.out.println(mm1); //{name=a, nameEn=b}
    
    //list<bean/map>
    List<User> userList = new ObjectMapper().readValue(arrayStr, new TypeReference<List<User>>(){});
    System.out.println(userList); //[User(name=Zhangsan, nameEn=null), User(name=null, nameEn=Lisi)]
    
    List<Map> mapList = new ObjectMapper().readValue(arrayStr, new TypeReference<List<Map>>(){});
    System.out.println(mapList); //[{name=Zhangsan}, {nameEn=Lisi}]
    
    //复杂类型
    String complexStr1 = getComplex1(); //List<Map<String, User>>
    String complexStr2 = getComplex2(); //Map<String,List<User>>
    
    List<Map<String, User>> list1 = new ObjectMapper().readValue(complexStr1, new TypeReference<List<Map<String, User>>>(){});
    System.out.println(list1); //[{1=User(name=zs, nameEn=zs_en)}, {3=User(name=ls, nameEn=ls_en)}]
    Map<String, List<User>> map1 = new ObjectMapper().readValue(complexStr2, new TypeReference<Map<String,List<User>>>(){});
    System.out.println(map1); //{1=[User(name=tt, nameEn=tt1)], 2=[User(name=ww, nameEn=ww1)]}
}

说明：该api可以将json对象和json数组的字符串转成对应的bean/map 和 List<bean/map>。

3、readValue(String content, JavaType valueType)使用：

利用 TypeFactory.constructParametricType()进行JavaType的类型构造

3.1）通过TypeFactory构造不同的JavaType：

1）constructMapType(Class<? extends Map> mapClass, Class<?> keyClass, Class<?> valueClass)：

转换成map，同时指定key和value类型；

注：无法通过TypeFactory直接构造出一个Bean

2）constructCollectionType(Class<? extends Collection> collectionClass, Class<?> elementClass)：

转成成list，并指定元素类型；

3）constructParametricType:

这个方法可以处理各种复杂结构，主要有以下两个声明：

public JavaType constructParametricType(Class<?> parametrized, Class<?>... parameterClasses) 
public JavaType constructParametricType(Class<?> rawType, JavaType... parameterTypes)

方法中后面的可变形参参数必须一致。JavaType可以通过调用getRawClass方法来变成Class类型。对于复杂结构，核心思路：从内到外构造类型，从右到左，一步一步来！

3.2）示例：

/**
     * readValue(String content, JavaType valueType) 
     */
    private static void javaTypeTest() throws Exception {
        System.out.println("--------JavaType---------");
        //bean 无法构造
        
        //map
        Map<String,String> mm = new ObjectMapper().readValue(jsonStr, 
                new ObjectMapper().getTypeFactory().constructMapType(HashMap.class, String.class, String.class));
        System.out.println(mm);
        
        //List<bean>
        CollectionType userListType = new ObjectMapper().getTypeFactory().constructCollectionType(ArrayList.class, User.class);
        List<User> userList2 = new ObjectMapper().readValue(arrayStr, userListType);
        System.out.println(userList2);//[User(name=Zhangsan, nameEn=null), User(name=null, nameEn=Lisi)]
        //List<Map>
        CollectionType mapListType = new ObjectMapper().getTypeFactory().constructCollectionType(ArrayList.class, Map.class);
        List<Map> mapList2 = new ObjectMapper().readValue(arrayStr, mapListType);
        System.out.println(mapList2);//[{name=Zhangsan}, {nameEn=Lisi}]
        
        //复杂类型
        String complexStr1 = getComplex1(); //List<Map<String, User>>
        String complexStr2 = getComplex2(); //Map<String,List<User>>
        
        //先构造内部结构innerType
        JavaType innerType = objectMapper.getTypeFactory().constructParametricType(Map.class, String.class, User.class);
        //再构造List<innerType>结构
        JavaType resultType = objectMapper.getTypeFactory().constructParametricType(List.class, innerType);
        List<Map<String,User>> list1 = objectMapper.readValue(complexStr1, resultType);
        System.out.println(list1); //[{1={name=zs, nameEn=zs_en}}, {3={name=ls, nameEn=ls_en}}]
        
        //先构造右边部分rightType
        JavaType rightType = objectMapper.getTypeFactory().constructParametricType(List.class, User.class);
        //在构造全局Map<String,rightType>
        JavaType resultType1 = objectMapper.getTypeFactory().constructParametricType(Map.class, String.class, rightType.getRawClass());
        Map<String,List<User>> map1 = objectMapper.readValue(complexStr2, resultType1);
        System.out.println(map1); //{1=[{name=tt, nameEn=tt1}], 2=[{name=ww, nameEn=ww1}]}
    }

3.3）TyepReference和JavaType区别：

TypeReference比javaType模式更加方便，代码也更加简洁，看一下例子：

//JavaType list<bean>
@Test
public void test4() throws Exception {
    ObjectMapper mapper = new ObjectMapper();
    JavaType javaType = mapper.getTypeFactory().constructParametricType(List.class, Student.class);

    List<Student> list = new ArrayList<>();
    list.add(new Student("adai",21));
    list.add(new Student("apei",22));
    String json = mapper.writeValueAsString(list);
    List<Student> student2 = mapper.readValue(json, javaType);
    System.out.println(student2.get(0).getName());
}

//JavaType Map<String,Bean>
@Test
public void test5() throws Exception {
    ObjectMapper mapper = new ObjectMapper();
    // 第二个参数是Map的key，第三个参数是Map的value
    JavaType javaType = mapper.getTypeFactory().constructParametricType(Map.class, String.class, Student.class); 

    Map<String, Student> map = new HashMap<>();
    map.put("first",new Student("adai",21));
    map.put("second",new Student("apei",22));
    String json = mapper.writeValueAsString(map);
    Map<String, Student> result = mapper.readValue(json, javaType);
    System.out.println(result.get("first").getName());
}


//TypeReference list<bean>
@Test
public void test6() throws Exception {
    ObjectMapper mapper = new ObjectMapper();
    List<Student> list = new ArrayList<>();
    list.add(new Student("adai",21));
    list.add(new Student("apei",22));
    String json = mapper.writeValueAsString(list);
    List<Student> student2 = mapper.readValue(json, new TypeReference<List<Student>>(){}); 
    System.out.println(student2.get(0).getName());
}
//TypeReference Map<Strin,bean>
@Test
public void test7() throws Exception {
    ObjectMapper mapper = new ObjectMapper();
    Map<String, Student> map = new HashMap<>();
    map.put("first",new Student("adai",21));
    map.put("second",new Student("apei",22));
    String json = mapper.writeValueAsString(map);
    Map<String, Student> result = mapper.readValue(json, new TypeReference<Map<String,Student>>(){});
    System.out.println(result.get("first").getName());
}

4、其他

readValue出了上面从String读取json字符串外，还支持从InputStrea、URL等源读取json字符串，然后进行转换。例如：

InputStream in = null;
Map m = objectMapper.readValue(in, Map.class);

Jackson还有一个很有意思的功能，虽然没有广泛的被人所知道。那就是POJO和POJO之间的转换。概念性的可以理解成POJO1->JSON->POJO2，但是实际上会省略中间这一步，不会真正的生成JSON，而会用其他更高效的实现：

ResultType result = mapper.convertValue(sourceObject, ResultType.class);

例如：

// List<Integer> -> int[]
List<Integer> sourceList = ...;
int[] ints = mapper.convertValue(sourceList, int[].class);
// POJO -> Map
Map<String,Object> propertyMap = mapper.convertValue(pojoValue, Map.class);
// Map -> POJO
PojoType pojo = mapper.convertValue(propertyMap, PojoType.class);
// decode Base64! (default byte[] representation is base64-encoded String)

设置，还可以做base64

//解码
String base64 = "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz";
byte[] binary = mapper.convertValue(base64, byte[].class);
System.out.println(new String(binary));
//编码
String str = "Man is distinguished, not only by his reason, but by this";
String base = mapper.convertValue(str.getBytes(), String.class);
System.out.println(base);

二、convertValue()方法

从方法名字上来看，该方法是用来做转换的，将一个object转成其他object或List<object>，不能将json字符串转成object。所以和readValue有个本质的区别是：convertValue方法输入的是对象，而不是字符串。

convertValue同readValue一样，也有三个重载：

  • convertValue(Object fromValue, Class<T> toValueType) 
  • convertValue(Object fromValue, TypeReference<T> valueTypeRef) 
  • convertValue(Object fromValue, JavaType javaType) 

接下来只以convertValue(Object fromValue, TypeReference<T> valueTypeRef)  为例看一下：

private static void convertTest() {
    System.out.println("-----------------");
    //convertValue三种用法：将object转成object 或 List<object>
    //注：不能将string转成object 下面这两种都会报错
    //        User uu = new ObjectMapper().convertValue(jsonStr, User.class);
    //        System.out.println(uu);
    //        
    //        Map mm = new ObjectMapper().convertValue(jsonStr, Map.class);
    //        System.out.println(mm);
    
    //bean > map
    User u = new User("aaa","aaa_en");
    Map<String,String> map1 = new ObjectMapper().convertValue(u, new TypeReference<Map<String,String>>(){});
    System.out.println(map1); //{name=aaa, nameEn=aaa_en}
    
    //map > bean
    User user1 = new ObjectMapper().convertValue(map1, new TypeReference<User>(){});
    System.out.println(user1); //User(name=aaa, nameEn=aaa_en)
    
    //List<bean> > List<Map>
    List<User> list1 = new ArrayList<>();
    list1.add(user1);
    List<Map<String,String>> list2 = new ObjectMapper().convertValue(list1, new TypeReference<List<Map<String,String>>>(){});
    System.out.println(list2); //[{name=aaa, nameEn=aaa_en}]
    
    //list<Map> > list<Bean>
    List<User> list3 = new ObjectMapper().convertValue(list1, new TypeReference<List<User>>(){});
    System.out.println(list3); //[User(name=aaa, nameEn=aaa_en)]
}

三、bean和map之间的转换方法

根据上面可知使用jackson的convertValue方法可以在bean和map之间进行转换。此外，还可以通过如下方法：

1、Apache commons-beanutils工具：

<!-- https://mvnrepository.com/artifact/commons-beanutils/commons-beanutils -->
<dependency>
    <groupId>commons-beanutils</groupId>
    <artifactId>commons-beanutils</artifactId>
    <version>1.9.3</version>
</dependency>

示例：

public static void main(String... strings) throws Exception {
    User u = new User();
    u.setName("aaa");
    u.setNameEn("bbb");

    //bean to map
    Map describe = new BeanMap(u);
    System.out.println(describe); //BeanMap<JsonUtils.User(name=aaa, nameEn=bbb)>
    
    //bean to map
    Map<String, String> map = BeanUtils.describe(u);
    //{name=aaa, nameEn=bbb, class=class com.tencent.rating.common.utils.JsonUtils$User}
    System.out.println(map);
    
    //map to bean
    User uu = new User();
    BeanUtils.populate(uu, describe);
    System.out.println(uu); //JsonUtils.User(name=aaa, nameEn=bbb)
}

@Data
public static class User {
    private String name;
    private String nameEn;
}

注：使用describe方法将bean转成map时，会多一个class信息在map中。

https://www.hicode.club/articles/2018/03/18/1550590751627.html

https://juejin.cn/post/6844903694379548679

https://www.cnblogs.com/AdaiCoffee/p/10933091.html#3-jackson-%E5%A4%84%E7%90%86%E6%B3%9B%E5%9E%8B%E8%BD%AC%E6%8D%A2

赶路人儿
关注
  • 19
    点赞
  • 踩
  • 51
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Jackson ObjectMapper readValue过程
weixin_34128534的博客
11-30 1599
v1.整体调用栈 v2.看一下调用栈的两个方法 　　 　　 　　 　　resolve 方法中通过 Iterator i$ = this._beanProperties.iterator() 遍历属性的所有子属性，缓存对应的 deserializer。观察调用栈的方法，可以发现是循环调用的。 v3.比如寻找自定义的 LocalDateTim...
对象序列化(2)：objectMapper.readValue详解
mingyuli的博客
08-06 2万+
·
谈谈jackson的mapper.readValue方法的智能性
最新发布
yuchangyuan5237的博客
06-12 213
jackson序列化的智能性
java使用objectMapper.convertValue转Object为List＜Map＞
还在活水泥的未来包工头
03-10 3119
使用 ObjectMapper 的 convertValue 方法可以将一个对象转换为另一种类型的对象。调用 convertValue 方法，将原始对象和 TypeReference 对象作为参数传入。定义一个 TypeReference 对象，用于指定转换后的类型为 List。TypeReference是引用的哪个包下的。
ObjectMapper.convertValue() 遇到的一些问题
热门推荐
ZCR的博客
11-29 2万+
源代码： public <T> T convertValue(Object fromValue, TypeReference<?> toValueTypeRef) throws IllegalArgumentException { return (T) _convert(fromValue, _typeFactory.constructType(toValueTypeRef...
ObjectMapper.convertValue() 和 TypeReference
qq_42051115的博客
08-19 9592
解释 首先ObjectMapper.convertValue()是用来进行类型转换的一个工具，TypeReference 是描述一个复杂泛型的工具类。 jackson objectMapper json字符串常用的方法列举： 1.对象转json字符串 User user=new User(); String userJson=mapper.writeValueAsString(user); 2.json转换为对象 String json = "{\"name\":\"Test\"}"; Map user
ObjectMapper.readValue()
qq_52360246的博客
11-08 1840
用于response body反序列化
jackson-core-2.10.0.zip
07-10
- `jackson-core-2.10.0.jar`: 主要的JAR文件，包含了所有核心功能的类和方法。 - `LICENSE`: 许可证文件，描述了库的授权条款。 - `NOTICE`: 关于使用库的注意事项和第三方依赖的版权信息。 - 可能还包括源码、文档...
例举fastJson和jackson转json的区别
10-17
在Java开发中，将对象转换为JSON格式是一个常见的任务，FastJson和Jackson是两个非常流行的JSON库。它们都提供了高效且便捷的API用于JSON序列化和反序列化，但它们在处理方式上存在一些差异。以下是对FastJson和...
Jackson进行JSON解析和序列化jar包
06-18
Jackson是Java领域中广泛使用的JSON处理库，以其高效性能和灵活的功能著称。在Java应用程序中，JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，常用于前后端交互或者存储数据。Jackson库提供了JSON...
Jackson2.9 三个jar包文件下载
05-19
Jackson是Java领域中广泛使用的JSON处理库，它提供了一套高效、灵活的API来解析、生成、序列化和反序列化JSON数据。Jackson 2.9版本是该库的一个稳定版本，包含了三个主要的jar包文件，分别是： 1. jackson-...
jackson-core-2.7.0.jar和源码
07-22
通过`readValue()`和`writeValue()`方法，我们可以轻松地在JSON字符串和Java对象间进行序列化和反序列化。 4. **类型处理**: Jackson支持处理各种复杂的Java类型，包括泛型、集合、数组、自定义类型等，同时还支持...
jackson的objectMapper反序列化复杂对象TypeReference
奔跑的菜鸡
08-18 6498
objectMapper.readValue的三个重载方法 //简单型，就是 直接 UserBase.class 就可。 public <T> T readValue(String content, Class<T> valueType); //valueTypeRef)；复杂的可以 用这个 public <T> T readValue(String content, TypeReference<T> //这个书写起来比较麻烦，就不说明了，不常用，前2个
jackson使用问题:mapper.readValue()将JSON字符串转反序列化为对象失败或异常
weixin_30455067的博客
11-09 1万+
问题根源：转化目标实体类的属性要与被转JSON字符串总的字段 一 一对应！字符串里可以少字段，但绝对不能多字段。 先附上我这段出现了问题的源码： // 1.接收并转化相应的参数。需要在pom.xml中引入jackson-databind这个包 String shopStr = HttpServletRequestUtil.getString(request,...
mapper.readValue()将JSON字符串转反序列化为对象失败或异常问题
qq_41727840的博客
01-26 4980
$('#submit').click(function () { var product={}; //声明一个商品json对象，从表单中获取对应属性值 if(isEdit){ product.productId=productId; } product.productName=$('#product-name').val(); product.product...
学习新知识
ppppoooo6的博客
10-26 727
ObjectMapper 可以通过mapper.readValue方法把json转化成各种自己想要的内容 mapper.readValue(json,entity.class)；（entity可以是实体Entity，数组Entity[]，List）。 通过mapper.writeValue把想要的转成json Java8 ：： 下面，我们以定义了4个方法的Car这个类
Jackson使用指北
东流长江水的博客
11-19 366
Jackson使用指北 1. 概述 Jackson是目前在web开发中使用最多，速度最快的一种json序列化和反序列化框架。本文主要结合Jackson在项目中的实际使用进行介绍。 2. 字段忽略 2.1 json转POJO时，忽略某些字段 只需要在实体类上加上@JsonIgnoreProperties(ignoreUnknown = true)注解就可以。 2.2 POJO转json时，忽略某些字段 @JsonIgnore注解用来忽略某些字段，可以用在Field或者Getter方法上，用在Setter方法时
Jackson objectMapper.readValue 方法 详解
m0_46161749的博客
07-31 3870
请转看下面的网站: https://www.cnblogs.com/del88/p/13098678.html
get(/video_list?param=+ JSON.stringify({page: this.page}))后端接受请求@RequestMapping(value = "/video_list", method = RequestMethod.GET) public R videoList(@RequestParam(name = "param") Map<String, Object> param报ERROR Failed to convert value of type 'java.lang.String' to required type 'java.util.Map';解决案例
06-03
可以尝试如下解决方案： 1. 在前端代码中，将请求参数使用encodeURIComponent()方法进行编码，以避免参数中包含特殊字符造成的问题。例如： ``` let param = encodeURIComponent(JSON.stringify({page: this.page})); axios.get('/video_list?param=' + param).then(response => { // 处理响应数据 }).catch(error => { // 处理错误 }); ``` 2. 在后端代码中，使用@RequestBody注解接收JSON格式的请求参数，并使用Jackson库将JSON格式的参数转换为Map类型。例如： ``` @RequestMapping(value = "/video_list", method = RequestMethod.GET) public R videoList(@RequestBody String param) throws IOException { ObjectMapper mapper = new ObjectMapper(); Map<String, Object> paramMap = mapper.readValue(param, new TypeReference<Map<String, Object>>() {}); // 处理请求参数 } ``` 这样就可以避免将字符串类型的请求参数转换为Map类型时出现的错误了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

赶路人儿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值