最近非微服务web开发中,json报文经常遇见,经常需要进行json报文与request response接口对象互转,这里使用的 Jackson;
maven:
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.10.0</version>
</dependency>
- Jackson处理一般的JavaBean和Json之间的转换只要使用ObjectMapper 对象的
- readValue和
- writeValueAsString两个方法就能实现。
如果需要转换格式化的json字符串需要使用方法writerWithDefaultPrettyPrinter()
objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(objT)
但是如果要转换复杂类型Collection如 List<YourBean>,那么就需要先反序列化复杂类型 为泛型的Collection Type。
如果是ArrayList<YourBean>那么使用ObjectMapper 的getTypeFactory().constructParametricType(collectionClass, elementClasses);
- 如果是HashMap<String,YourBean>那么 ObjectMapper 的getTypeFactory().constructParametricType(HashMap.class,String.class, YourBean.class);如果是List<YourBean>那么
- ObjectMapper 的getTypeFactory().constructParametricType(List.class, YourBean.class);
实体类:
package cn.json.bean;
import java.io.Serializable;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
//@JsonIgnoreProperties({"sex","addTime"}) //序列化时忽略的属性名称集合 ,加载类上,给出的属性都不序列化
public class student implements Serializable{
/**
* @Fields serialVersionUID :
*/
private static final long serialVersionUID = -6510230638877789163L;
@JsonProperty("stu_id") //序列化时,如果要修改某些属性的名字,可以使用, 序列化 将id改为 stu_id
private Integer id ;
// @JsonIgnore //序列化时忽略字段,可以加载 属性上 、方法上
private String name ;
private Integer age ;
private String sex;
private Date addTime ;
public Date getAddTime() {
return addTime;
}
public void setAddTime(Date addTime) {
this.addTime = addTime;
}
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 String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
@Override
public String toString() {
return "student [id=" + id + ", name=" + name + ", age=" + age + ", sex=" + sex + ", addTime=" + addTime + "]";
}
}
泛型实现的工具类:
package com.json.JsonUtils;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JsonUtils {
public static ObjectMapper objectMapper=new ObjectMapper();
//使用静态代码块 将objectMapper对象,将序列化对象设为默认方式
static {
objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
}
/**
* @字符串反序列化转对象
* @param <T>
* @param json 字符串
* @param clazz class反射
* @return
*/
@SuppressWarnings({ "finally", "unchecked" })
public static <T> T StrtoObj(String json, Class<T> clazz) {
T resp=null;
if(json.isEmpty()||clazz==null) {
return null;
}
try {
resp= clazz.equals(String.class)? (T)json:objectMapper.readValue(json, clazz);
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (JsonProcessingException e) {
e.printStackTrace();
}finally {
return resp;
}
}
/**
* @对象转json字符串
* @param <T>
* @param objT
* @return
*/
public static <T> String ObjtoStr( T objT) {
String resp=null;
if(objT==null) {
return null;
}
try {
resp=(String) (objT.equals(String.class)?objT:objectMapper.writeValueAsString(objT));
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return resp;
}
/**
* @对象转格式化json字符串
* @param <T>
* @param objT 传入对象
* @return
*/
public static <T> String ObjtoStrPretty( T objT) {
String resp=null;
if(objT==null) {
return null;
}
try {
resp=(String) (objT.equals(String.class)?objT:objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(objT));
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return resp;
}
/**
* @字符串反序列化转对象)(map,list对象)
* @param <T>
* @param json 字符串
* @param clazz class反射
* @return
*/
@SuppressWarnings({ "finally", "unchecked" })
public static <T> T StrtoObj(String json, TypeReference<T> typeReference) {
T resp=null;
if(json.isEmpty()||typeReference==null) {
return null;
}
try {
resp= typeReference.getType().equals(String.class)? (T)json:objectMapper.readValue(json, typeReference);
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (JsonProcessingException e) {
e.printStackTrace();
}finally {
return resp;
}
}
/**
* @反序列化复杂类型字符串
* @throws JsonProcessingException
* @throws JsonMappingException
*
*/
public static <T> T StrtoObj(String json, Class<?> collectionClass ,Class<?> ... elementClass) throws JsonMappingException, JsonProcessingException{
final JavaType javaType=objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClass);
return objectMapper.readValue(json, javaType);
}
}
测试代码:
package com.json.JsonUtils;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.annotation.JsonSerialize.Inclusion;
import cn.json.bean.student;
/**
* Hello world!
*
*/
public class Demo
{
private static final ObjectMapper MAPPER = new ObjectMapper();
public static void main( String[] args ) throws JsonProcessingException, ClassNotFoundException
{
// // 序列化时 ,属性值为null的忽略
// MAPPER.setSerializationInclusion(JsonInclude.Include.NON_NULL);
MAPPER.setSerializationInclusion(JsonInclude.Include.ALWAYS);
// MAPPER.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
// MAPPER.setSerializationInclusion(JsonInclude.Include.NON_NULL);
// MAPPER.setSerializationInclusion(JsonInclude.Include.NON_DEFAULT);
//通过该方法对mapper对象进行设置,所有序列化的对象都将按改规则进行系列化
//JsonInclude.Include.ALWAYS 默认
//JsonInclude.Include.NON_DEFAULT 属性为默认值不序列化
//JsonInclude.Include.NON_EMPTY 属性为 空(“”) 或者为 NULL 都不序列化
//JsonInclude.Include.NON_NULL 属性为NULL 不序列化
student stu1 = new student();
stu1.setId(1);
stu1.setName("aaav");
stu1.setSex("男");
stu1.setAddTime(new Date());
stu1.setAge(11);
student stu2 = new student();
stu2.setId(2);
stu2.setName("bbbb");
stu2.setSex("男");
stu2.setAddTime(new Date());
stu2.setAge(12);
String data = MAPPER.writeValueAsString(stu1);
System.out.println("1:"+data);
List<student> sList=new ArrayList<student>();
List<student> slist = null;
sList.add(stu1);
sList.add(stu2);
Map<String, student> map1=new HashMap<String, student>();
Map<String, student> map2=null;
map1.put("stu1", stu1);
map1.put("stu2", stu2);
/*************字符串转对象 public static <T> T StrtoObj(String json, Class<T> clazz)***************/
student strtostu1 =(student) JsonUtils.StrtoObj(data, Class.forName("cn.json.bean.student"));
System.out.println("反序列化对象结果:"+strtostu1.toString());
/*************转格式化的json字符串 public static <T> String ObjtoStrPretty( T objT)***************/
String data1 =JsonUtils.ObjtoStrPretty(strtostu1);
System.out.println("漂亮的序列化对象结果:"+data1);
/*************转json字符串 public static <T> String ObjtoStr( T objT)***********/
String stu3 =JsonUtils.ObjtoStr(strtostu1);
System.out.println("序列化对象结果:"+stu3);
/*********NO1***** public static <T> T StrtoObj(String json, TypeReference<T> typeReference)**********/
String liststr =JsonUtils.ObjtoStr(sList);
System.out.println("list序列化结果:"+liststr.toString());
String strmap =JsonUtils.ObjtoStr(map1);
System.out.println("map序列化结果:"+strmap.toString());
/*********NO1***** public static <T> T StrtoObj(String json, TypeReference<T> typeReference)**********/
slist=JsonUtils.StrtoObj(liststr, new TypeReference<List<student>>(){});
System.out.println("list反序列化结果:"+slist);
map2=JsonUtils.StrtoObj(strmap, new TypeReference<Map<String, student>>(){});
System.out.println("map反序列化结果:"+map2);
/*********NO2***** public static <T> T StrtoObj(String json, Class<?> collectionClass ,Class<?> ... elementClass)**********/
slist=JsonUtils.StrtoObj(liststr,ArrayList.class,student.class);
System.out.println("list反序列化结果:"+slist);
map2=JsonUtils.StrtoObj(strmap,HashMap.class,String.class,student.class);
System.out.println("map反序列化结果:"+map2);
}
}