1、json字符串转对象,不带实体类
//用法示例
ObjectMapper mapper = new ObjectMapper();
JsonNode rootNode = mapper.readTree(requestStr); //获得根节点
JsonNode txnType = rootNode.get("txnType"); //获得某个json字段
String result = txnType.asText(); //获得它的值
2、json字符串转对象,带实体类的转换
//用法示例
ObjectMapper objectMapper = new ObjectMapper();
AccountBean acc = objectMapper.readValue(json, AccountBean.class);
3、对象转json字符串
//用法示例
ObjectMapper objectMapper = new ObjectMapper();
String result = objectMapper.writeValueAsString(object);
注:writeValueAsString可以转换map、list等集合,实体类
4、json字符串转对象,高级用法一, JavaType
UserBean.java
package test;
public class UserBean {
String name;
String password;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
Test.java
package test;
import java.util.List;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
public class Test {
public static void main(String[] args) {
//使用JavaType
String constent = "[{\"name\":\"张三\",\"password\":\"123\"},{\"name\":\"李四\",\"password\":\"456\"}]";
ObjectMapper mapper = new ObjectMapper();
JavaType javaType = mapper.getTypeFactory().constructCollectionType(List.class, UserBean.class);
try {
List<UserBean> lists = mapper.readValue(constent, javaType);
System.out.println(lists.get(0).getName());
System.out.println(lists.get(0).getPassword());
} catch (Exception e) {
e.printStackTrace();
}
}
}
JavaType的作用:JavaType对象对应着一个java类型,用于寻找对应的反序列化器
参考jackson代码,传入一个上下文,一个工厂,一个JavaType
public JsonDeserializer<Object> findValueDeserializer(DeserializationContext ctxt, DeserializerFactory factory, JavaType propertyType)
throws JsonMappingException
{
JsonDeserializer<Object> deser = _findCachedDeserializer(propertyType); //从缓存中寻找
if (deser != null) {
return deser;
}
deser = _createAndCacheValueDeserializer(ctxt, factory, propertyType); //创建新的
if (deser == null) {
deser = _handleUnknownValueDeserializer(propertyType); //处理未知类型
}
return deser;
}
5、json字符串转对象,高级用法二,TypeReference
json数组转成list
try {
String json = "[{\"name\":\"张三\",\"password\":\"123\"},{\"name\":\"李四\",\"password\":\"456\"}]";
List<UserBean> userBeanList = mapper.readValue(json, new TypeReference<List<UserBean>>() {});
String userName = userBeanList.get(0).getName();
System.out.println(userName);
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
参考jackson代码
public abstract class TypeReference<T> implements Comparable<TypeReference<T>>
{
protected final Type _type;
protected TypeReference()
{
Type superClass = getClass().getGenericSuperclass();
if (superClass instanceof Class<?>) { // sanity check, should never happen
throw new IllegalArgumentException("Internal error: TypeReference constructed without actual type information");
}
/* 22-Dec-2008, tatu: Not sure if this case is safe -- I suspect
* it is possible to make it fail?
* But let's deal with specific
* case when we know an actual use case, and thereby suitable
* workarounds for valid case(s) and/or error to throw
* on invalid one(s).
*/
_type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
}
public Type getType() { return _type; }
/**
* The only reason we define this method (and require implementation
* of <code>Comparable</code>) is to prevent constructing a
* reference without type information.
*/
@Override
public int compareTo(TypeReference<T> o) { return 0; }
// just need an implementation, not a good one... hence ^^^
}
在TypeReference内部,会获得T的这个泛型类型
写一个例子程序Test.java:
try {
//生成一个匿名内部类,是TypeReference抽象类的子类
TypeReference ttt = new TypeReference<List<UserBean>>() {};
//获得当前匿名类的类类型
Class clazz = ttt.getClass();
System.out.println("1: " + clazz);
//获得此匿名类父类的Type类型,即TypeReference<List<UserBean>>的Type类型
//Type是Java编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型
//实际上Type接口只是一个标记,Class类实现了Type接口
Type superClass = ttt.getClass().getGenericSuperclass();
System.out.println("2: " + superClass);
//获得ParameterizedType参数化类型,即泛型
ParameterizedType p = (ParameterizedType)superClass;
System.out.println("3: " + p);
//getActualTypeArguments获取参数化类型的数组,泛型可能有多个
Type type = p.getActualTypeArguments()[0];
System.out.println("4: " + type);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
执行结果:
1: class test.Test$1
2: com.fasterxml.jackson.core.type.TypeReference<java.util.List<com.ips.core.pbcs.biz.gateway.UserBean>>
3: com.fasterxml.jackson.core.type.TypeReference<java.util.List<com.ips.core.pbcs.biz.gateway.UserBean>>
4: java.util.List<com.ips.core.pbcs.biz.gateway.UserBean>
加断点可以看到,保存的信息:
参考资料:
https://blog.csdn.net/liang5630/article/details/40185591
https://www.jianshu.com/p/0851fe6f7d62