gson排除欄位，包含欄位工具類大全,構建普通的gson物件，包括對時間的轉換
GsonUtils.java gson工具類
package cn.itcast.oa.util;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonObject;
import org.apache.commons.io.IOUtils;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.security.InvalidParameterException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* gson的工具類
*
* @author miles
*/
public class GsonUtils {
/**
* 將一個物件轉成json字串
*
* @param obj
* @return
*/
public static String toJson(Object obj) {
return toJsonExclude(obj);
}
/**
* 將一個物件轉成json字串並指定需要排除的屬性名稱列表
* 如果沒有指定屬性名稱集合，則將會全部轉換
* 預設時間會以時間戳的格式進行轉換
*
* @param obj
* @param exclusionFields
* @return String
*/
public static String toJsonExclude(Object obj, String... exclusionFields) {
validateJsonObject(obj);
//建立GsonBuilder
GsonBuilder builder = new GsonBuilder();
//設定時間格式
builder.registerTypeAdapter(Date.class, new DateConverter());
//設定需要被排除的屬性列表
if (exclusionFields != null && exclusionFields.length > 0) {
GsonExclusion gsonFilter = new GsonExclusion();
gsonFilter.addExclusionField(exclusionFields);
builder.setExclusionStrategies(gsonFilter);
}
//建立Gson並進行轉換
Gson gson = builder.create();
return gson.toJson(obj);
}
/**
* 將一個物件轉成json字串並指定需要需要轉換的屬性名稱列表
* 如果沒有指定屬性名稱集合，則將會全部轉換
* 預設時間會以yyyy-MM-dd HH:mm:ss的格式進行轉換
*
* @param obj
* @param includeFields
* @return
*/
public static String toJsonInclude(Object obj, String... includeFields) {
validateJsonObject(obj);
//建立GsonBuilder
GsonBuilder builder = new GsonBuilder();
//設定時間格式
builder.registerTypeAdapter(Date.class, new DateConverter());
//設定需要轉換的屬性名稱
if (includeFields != null && includeFields.length > 0) {
GsonInclusion gsonFilter = new GsonInclusion();
gsonFilter.addInclusionFields(includeFields);
builder.setExclusionStrategies(gsonFilter);
}
//建立Gson並進行轉換
Gson gson = builder.create();
String json = gson.toJson(obj);
System.out.println("json;;;;"+json);
return json;
}
/**
* 通過response輸出json資料
*
* @param response HttpServletResponse物件
* @param json json字串
*/
public static void printJson(HttpServletResponse response, String json) {
PrintWriter writer = null;
try {
response.setContentType("application/json");
writer = response.getWriter();
writer.print(json);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (writer != null) {
writer.close();
}
}
}
public static Map<String, Object> convertJson2Map(String json) {
if (json == null) return null;
Gson gson = new GsonBuilder().create();
return gson.fromJson(json, HashMap.class);
}
public static void printJson(HttpServletResponse response, String key, String value) {
JsonObject jsonObject = new JsonObject();
jsonObject.addProperty(key, value);
printJson(response, jsonObject.toString());
}
/**
* 將一個集合轉成{data:[]}形式的物件
*
* @param response
* @param data
*/
public static void printCollectionJson(HttpServletResponse response, List data, String... includes) {
String json = toCollectionJson(data, includes);
printJson(response, json);
}
/**
* 將一個集合轉成{data:[]}形式的字串
*
* @param data
* @return
*/
public static String toCollectionJson(List data, String... includes) {
Map<String, List> map = new HashMap<String, List>();
map.put("data", data);
return toJsonInclude(map, includes);
}
public static void printJson(HttpServletResponse response, String key, Integer value) {
JsonObject jsonObject = new JsonObject();
jsonObject.addProperty(key, value);
printJson(response, jsonObject.toString());
}
public static void printJson(HttpServletResponse response, String key, Float value) {
JsonObject jsonObject = new JsonObject();
jsonObject.addProperty(key, value);
printJson(response, jsonObject.toString());
}
public static void printJson(HttpServletResponse response, String key, Double value) {
JsonObject jsonObject = new JsonObject();
jsonObject.addProperty(key, value);
printJson(response, jsonObject.toString());
}
public static void printJson(HttpServletResponse response, String key, Boolean value) {
JsonObject jsonObject = new JsonObject();
jsonObject.addProperty(key, value);
printJson(response, jsonObject.toString());
}
/**
* 通過response輸出json資料
*
* @param response HttpServletResponse物件
* @param obj object
*/
public static void printJsonObject(HttpServletResponse response, Object obj) {
if (obj == null) return;
if (obj instanceof String) {
printJson(response, (String) obj);
return;
}
String json = toJson(obj);
printJson(response, json);
}
public static void printError(HttpServletResponse response, String reason) {
JsonObject jsonObject = new JsonObject();
jsonObject.addProperty("error", reason);
printJson(response, jsonObject.toString());
}
private static void validateJsonObject(Object obj) {
if (obj == null) {
throw new NullPointerException("要轉成json的物件不能為空！");
}
if (obj instanceof String || obj instanceof Number || obj instanceof Boolean) {
throw new RuntimeException("要轉成json字串的必須是複雜(引用)型別的物件！");
}
}
/**
* 從request body中取出資料流（json字串），並進行utf-8轉碼後，使用Gson轉換成指定型別的物件
* 如果request、clazz為空，則丟擲異常
*
* @param request 包含請求體的request物件
* @param clazz 要轉成的物件的型別
* @param excludeFields（可選，要排除的欄位）
* @param <T>
* @return clazz指定的型別
*/
public static <T> T wrapDataToEntity(HttpServletRequest request, Class<T> clazz, String... excludeFields) {
if (request == null || clazz == null) {
throw new InvalidParameterException("引數不能為空！");
}
String data = null;
try {
data = IOUtils.toString(request.getInputStream(), "utf-8");
} catch (IOException e) {
e.printStackTrace();
}
GsonBuilder builder = new GsonBuilder();
builder.registerTypeAdapter(Date.class, new DateConverter());
//要排除的欄位
if (excludeFields != null && excludeFields.length > 0) {
GsonExclusion exclusions = new GsonExclusion();
exclusions.addExclusionField(excludeFields);
builder.setExclusionStrategies(exclusions);
}
Gson gson = builder.create();
T entity = gson.fromJson(data, clazz);
return entity;
}
public static void printSuccess(HttpServletResponse response) {
printJson(response, "success", true);
}
}
/**
* gson轉換器的過濾器：轉換的時候不轉換被指定的屬性名稱或者類型別
*
* @author miles
*/
import com.google.gson.ExclusionStrategy;
import com.google.gson.FieldAttributes;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* gson轉換器的過濾器：轉換的時候不轉換被指定的屬性名稱或者類型別
*
* @author miles
*/
public class GsonExclusion implements ExclusionStrategy {
private List<String> exclusionFields;//要被排除的屬性名稱集合
private List<Class> exclusionClasses;//需要被排除的型別
/**
* 新增需要被排除的屬性名稱
*
* @param fieldName
* @return
*/
public GsonExclusion addExclusionField(String... fieldName) {
if (exclusionFields == null) {
exclusionFields = new ArrayList<String>();
}
if (fieldName != null && fieldName.length > 0) {
for (int i = 0; i < fieldName.length; i++) {
exclusionFields.add(fieldName[i]);
}
}
return this;
}
public GsonExclusion addExclusionClass(Class<?>... classes) {
if (exclusionClasses == null) {
exclusionClasses = new ArrayList<Class>();
}
exclusionClasses.addAll(Arrays.asList(classes));
return this;
}
@Override
public boolean shouldSkipField(FieldAttributes f) {
if (exclusionFields == null || exclusionFields.size() < 1) {
return false;
}
String fieldName = f.getName();
if (exclusionFields.contains(fieldName)) {
return true;
}
return false;
}
@Override
public boolean shouldSkipClass(Class<?> clazz) {
if (exclusionClasses == null || exclusionClasses.size() < 1) {
return false;
}
if (exclusionClasses.contains(clazz)) {
return true;
}
return false;
}
public List<String> getExclusionFields() {
return exclusionFields;
}
public void setExclusionFields(List<String> exclusionFields) {
this.exclusionFields = exclusionFields;
}
}
GsonInclusion .java
package cn.itcast.oa.util;
import java.util.ArrayList;
import java.util.List;
import com.google.gson.ExclusionStrategy;
import com.google.gson.FieldAttributes;
/**
* gson轉換的過濾器：只轉換被設定的屬性列表
*
* @author miles
*/
public class GsonInclusion implements ExclusionStrategy {
private List<String> inclusionFields;//要被轉換的屬性名稱集合
/**
* 新增只需要被轉換的屬性名稱
*
* @param fieldName 屬性名稱的可變陣列
* @return
*/
public GsonInclusion addInclusionFields(String... fieldName) {
if (inclusionFields == null) {
inclusionFields = new ArrayList<String>();
}
if (fieldName != null && fieldName.length > 0) {
for (int i = 0; i < fieldName.length; i++) {
inclusionFields.add(fieldName[i]);
}
}
return this;
}
public boolean shouldSkipField(FieldAttributes f) {
String fieldName = f.getName();
if (inclusionFields.contains(fieldName)) {
return false;
}
return true;
}
@Override
public boolean shouldSkipClass(Class<?> clazz) {
return false;
}
public List<String> getinclusionFields() {
return inclusionFields;
}
public void setinclusionFields(List<String> inclusionFields) {
this.inclusionFields = inclusionFields;
}
}
GsonFactory .java
package cn.itcast.oa.util;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import java.util.Date;
/**
* Created by miles on 13-12-10.
* gson工廠物件，負責產生各種Gson物件
*/
public class GsonFactory {
/**
* 構建一個普通的gson物件（包含對時間的轉換）
*
* @return
*/
public static Gson build() {
GsonBuilder builder = new GsonBuilder();
builder.registerTypeAdapter(Date.class, new DateConverter());//時間轉換器
return builder.create();
}
}
DateConverter .java
package cn.itcast.oa.util;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import com.google.gson.stream.JsonWriter;
/**
* Created by miles on 13-12-10.
* 時間轉換器，預設只支援yyyy-MM-dd、yyyy-MM-dd HH:mm:ss和時間戳型別的資料
* 將json字串中的時間字串轉為時間，將時間轉為時間戳
*/
public class DateConverter extends TypeAdapter<Date> {
private String pattern = "yyyy-MM-dd HH:mm:ss";
public DateConverter() {
}
public DateConverter(String pattern) {
if (pattern != null) {
this.pattern = pattern;
}
}
public void write(JsonWriter out, Date value) throws IOException {
if (value == null) {
out.nullValue();
return;
}
// SimpleDateFormat format = new SimpleDateFormat(pattern);
// String dateFormatAsString = format.format(value);
out.value(value.getTime());
}
@Override
/**
* 將字串轉為date
* 預設使用yyy-MM-dd HH:mm:ss的正則規則
*/
public Date read(JsonReader in) throws IOException {
if (in.peek() == JsonToken.NULL) {
in.nextNull();
return null;
}
String json = in.nextString();
if (json.matches("\\d+")) {
return new Date(Long.parseLong(json));
} else if (json.matches("\\d{4}-\\d{1,2}-\\d{1,2}")) {
pattern = "yyyy-MM-dd";
}
Date date = null;
try {
date = new SimpleDateFormat(pattern).parse(json);
} catch (ParseException e) {
e.printStackTrace();
}
return date;
}
}