Json Date日期格式化以及字段过滤

json 数据的日期格式化一直都是一个问题，没有能够按照自己想要的格式格式化的方法或者工具，所以把自己用过的整理一下.

引入jar包：
jackson-all-1.8.5.jar 不一定固定这个版本.
org.codehaus.jackson.map.ObjectMapper.class 需要导入这个转换对象.

maven依赖：版本自适配

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.15</version>
</dependency>

Null转空串""

// Date日期格式化
ObjectMapper mapper = new ObjectMapper();
mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
// 将null替换为""
mapper.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
	@Override
	public void serialize(Object obj, JsonGenerator jg, SerializerProvider sp)
		throws IOException, JsonProcessingException {
		jg.writeString(""); // Null 值转 “”（String串）
	}
});

实现json字段的过滤：

// 只保留包含的字段
// 实现自定义字段保留filterOutAllExcept，过滤serializeAllExcept
mapper.setFilters(new SimpleFilterProvider().addFilter(ReportLoss.class.getName(),
	SimpleBeanPropertyFilter.serializeAllExcept("id", "title")));
mapper.setAnnotationIntrospector(new JacksonAnnotationIntrospector(){
	@Override
	public Object findFilterId(AnnotatedClass ag) {
		return ag.getName();
	}
});

格式化后的结果获取：

// 得到格式化后的json数据
String asString = mapper.writeValueAsString(queryActiveList);

注解的释义：

注解使用：（对象）

字段注解过滤
@JsonIgnore属性上	或者		@JsonIgnoreProperties({"createTime","valid"})实体类上

@JsonProperty("idName")更改字段名，属性上

// 过滤对象的null属性.
mapper.setSerializationInclusion(Inclusion.NON_NULL);
// 过滤map中的null值
mapper.configure(Feature.WRITE_NULL_MAP_VALUES, false);

json转map：

//JSONObject转Map<String, Object>
@SuppressWarnings("unchecked")
private Map<String, Object> getJsonToMap(JSONObject json) {
	Map<String,Object> map = new HashMap<String, Object>();
	try {
		ObjectMapper mapper = new ObjectMapper();
		map = mapper.readValue(json.toString(), Map.class);
	} catch (Exception e) {
		e.printStackTrace();
	}
	return map;
}

为了方便，整理了一份工具类：JsonDMOUtil.java

JsonDMOUtil.java （json日期格式化以及转换工具类）

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

/**
 * jsonDMUtil工具类 by cdw
 */
public class JsonDMOUtil {

    /**
     * @param object      格式化的数据
     * @param dateFormate 格式化的日期格式
     * @return 返回格式化后的数据
     */
    public static String jsonDateFormate(Object object, String dateFormate) {
        String asString = "";
        try {
            // Date日期格式化
            if ("".equals(dateFormate.trim()) || dateFormate == null) {
                dateFormate = "yyyy-MM-dd HH:mm:ss";
            }
            ObjectMapper mapper = JsonDMOUtil.getObjectMapper(dateFormate);
            // 得到格式化后的json数据
            asString = mapper.writeValueAsString(object);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return asString;
    }

    /**
     * @param object      格式化的数据
     * @param dateFormate 格式化的日期格式
     * @return 返回格式化后的数据
     */
    public static JSONObject jsonDTOFormate(Object object, String dateFormate) {
        String asString = "";
        try {
            // Date日期格式化
            if ("".equals(dateFormate.trim()) || dateFormate == null) {
                dateFormate = "yyyy-MM-dd HH:mm:ss";
            }
            ObjectMapper mapper = JsonDMOUtil.getObjectMapper(dateFormate);
            // 得到格式化后的json数据
            asString = mapper.writeValueAsString(object);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return JSON.parseObject(asString);
    }

    /**
     * @param object      格式化的数据,将JSONObject转成Map
     * @param dateFormate 格式化的日期格式
     * @return 返回格式化后的数据
     */
    @SuppressWarnings("unchecked")
    public static Map<String, String> jsonDTMFormate(Object object, String dateFormate) {
        Map<String, String> resultMap = new HashMap<String, String>();
        try {
            JSONObject jsonObj = JSON.parseObject(object.toString());
            // Date日期格式化
            if ("".equals(dateFormate.trim()) || dateFormate == null) {
                dateFormate = "yyyy-MM-dd HH:mm:ss";
            }
            ObjectMapper mapper = JsonDMOUtil.getObjectMapper(dateFormate);
            JSONObject header = jsonObj.getJSONObject("header");
            JSONObject body = jsonObj.getJSONObject("body");
            Map<String, String> headerMap = null;
            Map<String, String> bodyMap = null;
            if (header != null) {
                headerMap = mapper.readValue(header.toString(), Map.class);
                for (Entry<String, String> map : headerMap.entrySet()) {
                    resultMap.put(map.getKey(), map.getValue());
                }
            }
            if (body != null) {
                bodyMap = mapper.readValue(body.toString(), Map.class);
                for (Entry<String, String> map : bodyMap.entrySet()) {
                    resultMap.put(map.getKey(), map.getValue());
                }
            }
            if (resultMap.isEmpty()) {
                resultMap = mapper.readValue(jsonObj.toString(), Map.class);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return resultMap;
    }

    /**
     * @param object 格式化的数据,
     *               默认格式化的日期格式（"yyyy-MM-dd HH:mm:ss"）
     * @return 返回格式化后的数据
     */
    public static String jsonDateFormate(Object object) {
        String asString = "";
        try {
            // Date日期格式化
            ObjectMapper mapper = JsonDMOUtil.getObjectMapper("yyyy-MM-dd HH:mm:ss");
            asString = mapper.writeValueAsString(object);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return asString;
    }

    /**
     * @param object 格式化的数据,
     *               默认格式化的日期格式（"yyyy-MM-dd HH:mm:ss"）
     * @return 返回格式化后的数据
     */
    public static JSONObject jsonDTOFormate(Object object) {
        String asString = "";
        try {
            // Date日期格式化
            ObjectMapper mapper = JsonDMOUtil.getObjectMapper("yyyy-MM-dd HH:mm:ss");
            asString = mapper.writeValueAsString(object);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return JSON.parseObject(asString);
    }

    /**
     * @param object 格式化的数据,将JSONObject转成Map,
     *               默认格式化的日期格式（"yyyy-MM-dd HH:mm:ss"）
     * @return 返回格式化后的数据
     */
    @SuppressWarnings("unchecked")
    public static Map<String, String> jsonDTMFormate(Object object) {
        Map<String, String> resultMap = new HashMap<String, String>();
        try {
            JSONObject jsonObj = JSON.parseObject(object.toString());
            // Date日期格式化
            ObjectMapper mapper = JsonDMOUtil.getObjectMapper("yyyy-MM-dd HH:mm:ss");
            JSONObject header = jsonObj.getJSONObject("header");
            JSONObject body = jsonObj.getJSONObject("body");
            Map<String, String> headerMap = null;
            Map<String, String> bodyMap = null;
            if (header != null) {
                headerMap = mapper.readValue(header.toString(), Map.class);
                for (Entry<String, String> map : headerMap.entrySet()) {
                    resultMap.put(map.getKey(), map.getValue());
                }
            }
            if (body != null) {
                bodyMap = mapper.readValue(body.toString(), Map.class);
                for (Entry<String, String> map : bodyMap.entrySet()) {
                    resultMap.put(map.getKey(), map.getValue());
                }
            }
            if (resultMap.isEmpty()) {
                resultMap = mapper.readValue(jsonObj.toString(), Map.class);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return resultMap;
    }

    /**
     * @param dateFormate 格式化的日期格式
     * @return 返回ObjectMapper对象
     */
    private static ObjectMapper getObjectMapper(String dateFormate) {
        // Date日期格式化
        ObjectMapper mapper = new ObjectMapper();
        mapper.setDateFormat(new SimpleDateFormat(dateFormate));
        // 将null替换为""
        mapper.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
            @Override
            public void serialize(Object obj, JsonGenerator jg, SerializerProvider sp)
                    throws IOException {
                jg.writeString(""); // Null 值转 “”（String串）
            }
        });
        return mapper;
    }

}

转载请注明出处！