关闭

gson排除字段,包含字段工具类大全,构建普通的gson对象,包括对时间的转换

标签: gson排除包含时间转换
541人阅读 评论(0) 收藏 举报
分类:

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);
    }
}



GsonExclusion .java

/**
 * gson转换器的过滤器:转换的时候不转换被指定的属性名称或者类类型
 *
 * @author miles
 */

package cn.itcast.oa.util;


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;
    }
}

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:6239次
    • 积分:222
    • 等级:
    • 排名:千里之外
    • 原创:17篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条