使用@JsonFormat注解，将它配置到Date类型的get方法上，jackson就会按照配置的格式转换日期类型

@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
//@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
public Date getCreateTime() {
return this .createTime;
}

方法二: 框架 全局处理

<mvc:annotation-driven>
<!-- 处理responseBody 里面日期类型 -->
<mvc:message-converters>
<bean class ="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
<property name="objectMapper">
<bean class ="com.fasterxml.jackson.databind.ObjectMapper">
<property name="dateFormat">
<bean class ="java.text.SimpleDateFormat">
<constructor-arg type="java.lang.String" value="yyyy-MM-dd HH:mm:ss" />
</bean>
</property>
</bean>
</property>
</bean>
</mvc:message-converters>
</mvc:annotation-driven>

方法三 : 局部处理

SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String formattedDate = formatter.format(value);

方法四: jackson 注解处理

@JsonIgnoreProperties
此注解是类注解，作用是json序列化时将java bean中的一些属性忽略掉，序列化和反序列化都受影响。

@JsonIgnore
此注解用于属性或者方法上（最好是属性上），作用和上面的@JsonIgnoreProperties一样。

@JsonFormat
此注解用于属性或者方法上（最好是属性上），可以方便的把Date类型直接转化为我们想要的模式，比如@JsonFormat(pattern = "yyyy-MM-dd HH-mm-ss")

@JsonSerialize

// 反序列化一个固定格式的Date
@JsonDeserialize(using = CustomDateDeserialize. class )
public void setBirthday(Date birthday) {
this .birthday = birthday;
}

// 序列化指定格式的double格式
@JsonSerialize(using = CustomDoubleSerialize. class )
public double getSalary() {
return salary;
}

public class CustomDateDeserialize extends JsonDeserializer<Date> {

private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

@Override
public Date deserialize(JsonParser jp, DeserializationContext ctxt)
throws IOException, JsonProcessingException {

Date date = null ;
try {
date = sdf.parse(jp.getText());
} catch (ParseException e) {
e.printStackTrace();
}
return date;
}
}

表单提交之数据转换-Date类型

在实体类的属性或get方法上加入 @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")，那么表单中的日期字符串就会正确的转换为Date类型了。
还有@NumberFormat注解，暂时没用，就不介绍了，一看就知道是对数字转换用的。

5.json数据返回
在方法上加入@ResponseBody，同时方法返回值为实体对象，spring会自动将对象转换为json格式，并返回到客户端。如下所示：
@RequestMapping("/json1")
@ResponseBody
public Demo json1() {
Demo demo= new Demo();
demo.setBirthday( new Date());
demo.setCreateTime( new Date());
demo.setHeight(170);
demo.setName("tomcat");
demo.setRemark("json测试");
demo.setStatus(( short )1);
return demo;
} 注意：spring配置文件要加上：<mvc:annotation-driven/>，同时还要引入jackson-core.jar,jackson-databind.jar,jackson-annotations.jar(2.x的包)才会自动转换json
这种方式是spring提供的。我们还可以自定义输出json，以上第二条不是说了获取response对象吗，拿到response对象后，任由开发人员宰割，想怎么返回就怎么返回。
方法不要有返回值 ，如下：
@RequestMapping("/json2")
public void json2() {
Demo demo= new Demo();
demo.setBirthday( new Date());
demo.setCreateTime( new Date());
demo.setHeight(170);
demo.setName("tomcat");
demo.setRemark("json测试");
demo.setStatus(( short )1);
String json=JsonUtil.toJson(obj); // ;json处理工具类
HttpServletResponse response = // 获取response对象
response.getWriter().print(json);
} OK，一切很完美。接着恶心的问题迎面而来， date类型转换为json字符串时，返回的是long time值 ，如果你想返回“yyyy-MM-dd HH:mm:ss”格式的字符串，又要自定义了。我很奇怪，不是有@DateTimeFormat注解吗，为什么不利用它。难道@DateTimeFormat只在表单提交时，将字符串转换为date类型，而date类型转换为json字符串时，就不用了。带着疑惑查源码， 原来spring使用jackson转换json字符，而@DateTimeFormat是spring-context包中的类，jackson如何转换，spring不方便作过多干涉 ，于是只能遵守jackson的转换规则，自定义日期转换器。
先写一个日期转换器，如下：
public class JsonDateSerializer extends JsonSerializer<Date> {
private SimpleDateFormat dateFormat= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
@Override
public void serialize(Date date, JsonGenerator gen, SerializerProvider provider) throws IOException, JsonProcessingException {
String value = dateFormat.format(date);
gen.writeString(value);
}
} 在实体类的get方法上配置使用转换器，如下： @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
@JsonSerialize(using=JsonDateSerializer. class )
public Date getCreateTime() {
return this .createTime;
} OK，到此搞定。
你真的满意了吗，这么不优雅的解决方案，假设birthday属性是这样的，只有年月日，无时分秒
@DateTimeFormat(pattern="yyyy-MM-dd")
public Date getBirthday() {
return this .birthday;
}
这意味着，又要为它定制一个JsonDate2Serializer的转换器，然后配置上，像这样

@DateTimeFormat(pattern="yyyy-MM-dd")
@JsonSerialize(using=JsonDate2Serializer. class )
public Date getBirthday() {
return this .birthday;
} 假设还有其它格式的Date字段，还得要为它定制另一个转换器。my god，请饶恕我的罪过，不要让我那么难受
经过分析源码，找到一个不错的方案，此方案将不再使用@JsonSerialize，而只利用@DateTimeFormat配置日期格式，jackson就可以正确转换，但@DateTimeFormat只能配置在get方法上，这也没什么关系。
先引入以下类，此类对jackson的ObjectMapper类做了注解扫描拦截，使它也能对加了@DateTimeFormat的get方法应用日期格式化规则
package com.xxx.utils;

import java.io.IOException;
import java.lang.reflect.AnnotatedElement;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.stereotype.Component;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.introspect.Annotated;
import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;
import com.fasterxml.jackson.databind.introspect.JacksonAnnotationIntrospector;

/**
* json处理工具类
* @author zhangle
*/
@Component
public class JsonUtil {
private static final String DEFAULT_DATE_FORMAT="yyyy-MM-dd HH:mm:ss";
private static final ObjectMapper mapper;

public ObjectMapper getMapper() {
return mapper;
}

static {
SimpleDateFormat dateFormat = new SimpleDateFormat(DEFAULT_DATE_FORMAT);

mapper = new ObjectMapper();
mapper.setDateFormat(dateFormat);
mapper.setAnnotationIntrospector( new JacksonAnnotationIntrospector() {
@Override
public Object findSerializer(Annotated a) {
if (a instanceof AnnotatedMethod) {
AnnotatedElement m=a.getAnnotated();
DateTimeFormat an=m.getAnnotation(DateTimeFormat. class );
if (an!= null ) {
if (!DEFAULT_DATE_FORMAT.equals(an.pattern())) {
return new JsonDateSerializer(an.pattern());
}
}
}
return super .findSerializer(a);
}
});
}

public static String toJson(Object obj) {
try {
return mapper.writeValueAsString(obj);
} catch (Exception e) {
throw new RuntimeException("转换json字符失败!");
}
}

public <T> T toObject(String json,Class<T> clazz) {
try {
return mapper.readValue(json, clazz);
} catch (IOException e) {
throw new RuntimeException("将json字符转换为对象时失败!");
}
}

public static class JsonDateSerializer extends JsonSerializer<Date>{
private SimpleDateFormat dateFormat;
public JsonDateSerializer(String format) {
dateFormat = new SimpleDateFormat(format);
}

@Override
public void serialize(Date date, JsonGenerator gen, SerializerProvider provider)
throws IOException, JsonProcessingException {
String value = dateFormat.format(date);
gen.writeString(value);
}
}
} 再将<mvc:annotation-driven/>改为以下配置，配置一个新的json转换器，将它的ObjectMapper对象设置为JsonUtil中的objectMapper对象，此转换器比spring内置的json转换器优先级更高，所以与json有关的转换，spring会优先使用它。 <mvc:annotation-driven>
<mvc:message-converters>
<bean class ="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
<property name="objectMapper" value="#{jsonUtil.mapper}"/>
<property name="supportedMediaTypes">
<list>
<value>text/json;charset=UTF-8</value>
</list>
</property>
</bean>
</mvc:message-converters>
</mvc:annotation-driven> 接下来就可以这样配置实体类，jackson也能正确转换Date类型 @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
public Date getCreateTime() {
return this .createTime;
}
@DateTimeFormat(pattern="yyyy-MM-dd")
public Date getBirthday() {
return this .birthday;
} Mybatis中可以使用  DATE_FORMAT(datetime,'%Y-%m-%d %H:%i:%s')函数状态当然方法一:使用@JsonFormat注解，将它配置到Date类型的get方法上，jackson就会按照配置的格式转换日期类型@DateTimeFormat(pattern=&quot;yyyy-MM-dd HH:mm:ss&quot;)  //@JsonFormat(pattern=&quot;yyyy-MM... import com.william. mapper .IdCardType; import org.apache.ibatis.type.JdbcType; import org.apache.ibatis.type.TypeHandler; import java .sql.CallableStatement; impor 可以使用to_number函数和to_char来实现完成 sql写法： to_number(to_char(sysdate,'yyyyMMdd')) &gt;= 20180102(类似的 时间 格式数据) Mapper 中写法 to_number(to_char(“ 时间 字段”,'yyyyMMdd')) &gt;= to_number(to_c... 在 mapper 层中执行select查询时，传入Date类型 参数 ，对应数据库字段数据类型也为Date，但执行时传入的 参数 日志却显示Timestamp类型。虽然查询结果并不影响。 mapper 层接口 Recruit selectRecruit(@Param("deptId")Integer deptId, @Param("officeId")Integer officeId, @Param("startTime") Date startTime); 对应 xml 1.匈牙利命名 和 不要盲目使用匈牙利命名 命名规范是程序书写规范中最重要也是最富争议的地方，自古乃兵家必争之地。命名规范有何用？四个字：名正言顺。好的舞鞋是让舞者感觉不到其存在的舞鞋，坏的舞鞋是让舞者带着镣铐起舞。 匈牙利命名法的成本:匈法的表现形式为给变量名附加上类型名前缀，例如：nFoo,szFoo,pFoo,cpFoo分别表示整型变量，字符串型变量，指针型变量和常指针型