SpringMVC+MyBatis 返回时间格式转换解决方案

Mybatis中可以使用  DATE_FORMAT(datetime,'%Y-%m-%d %H:%i:%s')函数状态

当然

方法一:

使用@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;  
}  

方法二: 框架全局处理

  
      
          
            class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">  
                  
                    class="com.fasterxml.jackson.databind.ObjectMapper">  
                          
                            class="java.text.SimpleDateFormat">  
                                  
                              
                          
                      
                  
              
          
    


方法三 : 局部处理

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 {    
    
    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配置文件要加上:,同时还要引入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 {  
   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 toObject(String json,Class clazz) {  
                try {  
                        return mapper.readValue(json, clazz);  
                } catch (IOException e) {  
                        throw new RuntimeException("将json字符转换为对象时失败!");  
                }  
        }  
          
        public static class JsonDateSerializer extends JsonSerializer{  
            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);  
            }  
        }  
}  
再将改为以下配置,配置一个新的json转换器,将它的ObjectMapper对象设置为JsonUtil中的objectMapper对象,此转换器比spring内置的json转换器优先级更高,所以与json有关的转换,spring会优先使用它。
  
      
        class
="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">  
              
              
                  
                    text/json;charset=UTF-8  
                
  
                
          
      
  
接下来就可以这样配置实体类,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;  
}  


你可能感兴趣的:(#,Java基础,开发架构,#,Spring学习到SSM开发,JavaWeb开发基础)