Jackson通過泛型進行字符串與實例對象互轉（一）

最近非微服務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);		
    }


}