对象,直接指明对象的class类
private static void json(ObjectMapper objectMapper) throws JsonProcessingException {
String json = "{\n" +
" \"name\":\"test-name\",\n" +
" \"pwd\":\"test-pwd\"\n" +
" }";
final JsonPerson jsonPerson = objectMapper.readValue(json, JsonPerson.class);
System.out.println(jsonPerson);

List
一种直接指明ArrayList的class类
private static void json2(ObjectMapper objectMapper) throws JsonProcessingException {
String json2 = "[{\n" +
" \"name\":\"test-name\",\n" +
" \"pwd\":\"test-pwd\"\n" +
" }]";
final List<JsonPerson> jsonPersonList2 = objectMapper.readValue(json2, ArrayList.class);
System.out.println(jsonPersonList2);


另一种使用TypeReference(一般都是用这种)
private static void json3(ObjectMapper objectMapper) throws JsonProcessingException {
String json3 = "[{\n" +
" \"name\":\"test-name\",\n" +
" \"pwd\":\"test-pwd\"\n" +
" }]";
final List<JsonPerson> jsonPersonList = objectMapper.readValue(json3, new TypeReference<List<JsonPerson>>() {});
System.out.println(jsonPersonList);

Map跟List同理,有两种方式
一种直接指明Map的class类
private static void json4(ObjectMapper objectMapper) throws JsonProcessingException {
String json4 = "{\n" +
" \"TestData1\": {\n" +
" \"name\": \"test-name\",\n" +
" \"pwd\": \"test-pwd\"\n" +
" },\n" +
" \"TestData2\": {\n" +
" \"name\": \"test-name2\",\n" +
" \"pwd\": \"test-pwd2\"\n" +
" }\n" +
"}";
final Map<String, JsonPerson> jsonPersonMap = objectMapper.readValue(json4, Map.class);
System.out.println(jsonPersonMap);


另一种使用TypeReference(一般都是用这种)
private static void json5(ObjectMapper objectMapper) throws JsonProcessingException {
String json5 = "{\n" +
" \"TestData1\": {\n" +
" \"name\": \"test-name\",\n" +
" \"pwd\": \"test-pwd\"\n" +
" },\n" +
" \"TestData2\": {\n" +
" \"name\": \"test-name2\",\n" +
" \"pwd\": \"test-pwd2\"\n" +
" }\n" +
"}";
final Map<String, JsonPerson> jsonPersonMap = objectMapper.readValue(json5, new TypeReference<Map<String, JsonPerson>>() {
});
System.out.println(jsonPersonMap);
-
constructType方式:根据输入的参数先构建出需要转化的java类型
-
直接看例子:
先看普通的对象:
private static void json6(ObjectMapper objectMapper) throws JsonProcessingException {
String json6 = "{\n" +
" \"name\":\"test-name\",\n" +
" \"pwd\":\"test-pwd\"\n" +
" }";
final JavaType javaType = objectMapper.constructType(JsonPerson.class);
final JsonPerson jsonPerson = objectMapper.readValue(json6, javaType);
System.out.println(jsonPerson);
-
有人就会说,这很弱鸡呀,还不如直接objectMapper.readValue(json, class)
,别着急,上述是转简单对象的操作而已,这只是先让大家初步认识constructType。
-
先看例子中objectMapper.constructType(JsonPerson.class);
这个方法源码:
public JavaType constructType(Type t) {
_assertNotNull("t", t);
return _typeFactory.constructType(t);
-
此时产生第一个问题:Type类是什么,如果没上述例子,第一次看见这个方法,我们怎么知道要传入什么参数呢?
-
需要补充一下其他知识点,Type是什么:
- Type是Java 编程语言中所有类型的公共高级接口。
- 简单来说:所有的数据类型的类型都是Type, Class也是继承自Type的,再通俗来说,Type就是所有数据类型的“爹”。
- Type的直接子接口(也就是Type具体有哪些类型):
1.ParameterizedType: 表示一种参数化的类型,比如Collection,即普通的泛型。
2.TypeVariable:是各种类型变量的公共父接口,就是泛型里面的类似T、E。
3.GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型,比如List<>[],T[]这种。
4.WildcardType:代表一种通配符类型表达式,类似? super T这样的通配符表达式。 - 下面是找到比较好并且参考的资料, 大家看看他们写的代码例子,应该可以理解这高深的话语了:
- 对java-Type的理解
- java中的Type
- TYPE JAVA类型
-
看完第六大点,就可以解决第五大点的问题,如果还不能理解,就通俗到把Type就认为是类型,constructType就是理解为构造要转化什么java类型。
-
接下来我们看第二个例子:转List对象:
private static void json7(ObjectMapper objectMapper) throws JsonProcessingException {
String json7 = "[{\n" +
" \"name\":\"test-name\",\n" +
" \"pwd\":\"test-pwd\"\n" +
" }]";
final TypeFactory typeFactory = objectMapper.getTypeFactory();
final JavaType jsonPersonType = typeFactory.constructType(JsonPerson.class);
final JavaType javaType = typeFactory.constructParametricType(List.class, jsonPersonType);
final List<JsonPerson> jsonPersonList = objectMapper.readValue(json7, javaType);
System.out.println(jsonPersonList);

若上述的注释可以看的懂,其实也可以用下面简单方式(已有api):
private static void json8(ObjectMapper objectMapper) throws JsonProcessingException {
String json8 = "[{\n" +
" \"name\":\"test-name\",\n" +
" \"pwd\":\"test-pwd\"\n" +
" }]";
final TypeFactory typeFactory = objectMapper.getTypeFactory();
final JavaType javaType = typeFactory.constructCollectionType(List.class, JsonPerson.class);
final List<JsonPerson> jsonPersonList = objectMapper.readValue(json8, javaType);
System.out.println(jsonPersonList);

-
接下来第三个例子:转Map<String, JsonPerson>类型,其实也是大同小异,也是两种方式,细节如下:
private static void json9(ObjectMapper objectMapper) throws JsonProcessingException {
String json9 = "{\n" +
" \"TestData1\": {\n" +
" \"name\": \"test-name\",\n" +
" \"pwd\": \"test-pwd\"\n" +
" },\n" +
" \"TestData2\": {\n" +
" \"name\": \"test-name2\",\n" +
" \"pwd\": \"test-pwd2\"\n" +
" }\n" +
"}";
final TypeFactory typeFactory = objectMapper.getTypeFactory();
final JavaType javaType = typeFactory.constructParametricType(Map.class, String.class, JsonPerson.class);
final Map<String,JsonPerson> jsonPersonMap = objectMapper.readValue(json9, javaType);
System.out.println(jsonPersonMap);

-
为了节约时间,我们将直接给个高级的例子:转为JsonResponse<Map<String,List<JsonPerson>>> 对象
:
@Getter
@ToString
static class JsonResponse<T> {
private String code;
private String message;
private T data;
@Getter
@ToString
static class JsonPerson {
private String name;
private String pwd;
private static void json11(ObjectMapper objectMapper) throws JsonProcessingException {
String json11 = "{\n" +
" \"code\": \"success\",\n" +
" \"data\": {\n" +
" \"TestData1\": [\n" +
" {\n" +
" \"name\": \"test-data-name-one\",\n" +
" \"pwd\": \"test-data-pwd-one\"\n" +
" },\n" +
" {\n" +
" \"name\": \"test-data-name-two\",\n" +
" \"pwd\": \"test-data-pwd-two\"\n" +
" }\n" +
" ],\n" +
" \"TestData2\": [\n" +
" {\n" +
" \"name\": \"test-data2-name-one\",\n" +
" \"pwd\": \"test-data2-pwd-one\"\n" +
" },\n" +
" {\n" +
" \"name\": \"test-data2-name-two\",\n" +
" \"pwd\": \"test-data2-pwd-two\"\n" +
" }\n" +
" ]\n" +
" }\n" +
"}";
final TypeFactory typeFactory = objectMapper.getTypeFactory();
final JavaType listJsonPersonType = typeFactory.constructCollectionType(List.class, JsonPerson.class);
final JavaType stringType = typeFactory.constructType(String.class);
final JavaType mapType = typeFactory.constructMapType(Map.class, stringType, listJsonPersonType);
final JavaType lastType = typeFactory.constructParametricType(JsonResponse.class, mapType);
final JsonResponse<Map<String,List<JsonPerson>>> jsonResponse = objectMapper.readValue(json11, lastType);
System.out.println(jsonResponse);
- 对于怎么实现Feign的自定义Decoder解析器,等写到Feign知识点的时候再说吧,提前剧透一下,Feign真的很有意思。
在工作中,必然少不了JSON转化对象,而一般来说JSON的转化,要么就是在controller层,springboot帮忙转化好了,要么就是简单的常转List、Map等。而在学习Feign时,可以自定义Decoder解析器,对返回报文做个性化处理,但此时对方返回的数据就需要自己将json字符串转为对应的对象了。而在自己转化的时候,发现ObjectMapper提供如下两个方法:一个是class类型的参数,一个是JavaType类型的参数,而该decode方法中,只有Type类型,那到底应该如何操作呢,请看本文
https://www.cnblogs.com/whyblogs/p/15062486.html
Jackson,我感觉是在Java与Json之间相互转换的最快速的框架,当然Google的Gson也很不错,但是参照网上有人的性能测试,看起来还是Jackson比较快一点
Jackson处理一般的JavaBean和Json之间的转换只要使用ObjectMapper 对象的readValue和writeValueAsString两个方法就能实现。但是如果要转换复杂类型Collection如 List,那么
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
package com.fasterxml.jackson.databind;
import com.fasterxml.jackson.annotation.Pr...
要使用ObjectMapper将对象转换为List类型的对象,可以使用以下方法:
1. 使用readValue方法和TypeReference类:objectMapper.readValue(json, new TypeReference<List<YourClass>>() {});
2. 使用convertValue方法:List<YourClass> yourList = objectMapper.convertValue(yourObject, new TypeReference<List<YourClass>>() {});
3. 使用constructType方法:objectMapper.readValue(json, objectMapper.getTypeFactory().constructCollectionType(List.class, YourClass.class));
请根据你的具体需求选择适合的方法来转换对象为List类型的对象。<span class="em">1</span><span class="em">2</span><span class="em">3</span><span class="em">4</span>
设计第三方jar包中有bean对象时,要如何自动加载到被引用的应用中(EnableAutoConfiguration、BeanDefinitionRegistryPostProcessor使用)
设计第三方jar包中有bean对象时,要如何自动加载到被引用的应用中(EnableAutoConfiguration、BeanDefinitionRegistryPostProcessor使用)
xtwoy: