详解spring mvc4使用及json 日期转换解决方案

时间:2022-09-03 11:10:26

又到搭新开发环境的时候,总是不免去网上搜下目前最新的框架。spring是web开发必用的框架,于是乎下载了目前最新的spring4.0.3,同时越来越不想用struts2,想试试spring mvc,也将spring-webmvc4.0.3下了下来,投入两天时间学习后,发现还是挺优雅的,特别是从3.0后,spring mvc使用注解方式配制,以及对rest风格的支持,真是完美致极。

下面将这两天研究到的问题做个总结,供参考。

1.request对象的获取

方式1:在controller方法上加入request参数,spring会自动注入,如:

?
1
public String list(HttpServletRequest request,HttpServletResponse response)

方式2:在controller类中加入@Resource private HttpServletRequest request 属性,spring会自动注入,这样不知道会不会出现线程问题,因为一个controller实例会为多个请求服务,暂未测试。

方式3:在controller方法中直接写代码获取

?
1
2
HttpServletRequest request =((ServletRequestAttributes)
RequestContextHolder.getRequestAttributes()).getRequest();

方式4:在controller中加入以下方法,此方法会在执行此controller的处理方法之前执行

?
1
2
3
4
5
@ModelAttribute
private void initServlet(HttpServletRequest request,HttpServletResponse response) {
 //String p=request.getParameter("p");
 //this.req=request;//实例变量,有线程安全问题,可以使用ThreadLocal模式保存
}

2.response对象的获取

可以参照以上request的获取方式1和方式4,方式2和方式3对response对象无效!

3.表单提交之数据填充
直接在方法上加入实体对象参数,spring会自动填充对象中的属性,对象属性名要与<input>的name一致才会填充,如:

?
1
public boolean doAdd(Demo demo)

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

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

5.json数据返回

在方法上加入@ResponseBody,同时方法返回值为实体对象,spring会自动将对象转换为json格式,并返回到客户端。如下所示:

?
1
2
3
4
5
6
7
8
9
10
11
12
@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对象后,任由开发人员宰割,想怎么返回就怎么返回。

方法不要有返回值,如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
@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的转换规则,自定义日期转换器。

先写一个日期转换器,如下:

?
1
2
3
4
5
6
7
8
9
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方法上配置使用转换器,如下:

?
1
2
3
4
5
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
@JsonSerialize(using=JsonDateSerializer.class)
public Date getCreateTime() {
 return this.createTime;
}

OK,到此搞定。

你真的满意了吗,这么不优雅的解决方案,假设birthday属性是这样的,只有年月日,无时分秒

?
1
2
3
4
@DateTimeFormat(pattern="yyyy-MM-dd")
public Date getBirthday() {
 return this.birthday;
}

这意味着,又要为它定制一个JsonDate2Serializer的转换器,然后配置上,像这样

?
1
2
3
4
5
@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方法应用日期格式化规则

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
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会优先使用它。

?
1
2
3
4
5
6
7
8
9
10
11
12
<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类型

?
1
2
3
4
5
6
7
8
@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;
}

完毕,一切都完美了。

 补充

写了那么多,发现白忙活了一场,原来jackson也有一个@JsonFormat注解,将它配置到Date类型的get方法上后,jackson就会按照配置的格式转换日期类型,而不自定义转换器类,欲哭无泪啊。辛苦了那么多,其实别人早已提供,只是没有发现而已。

不说了,直接上方案吧。

1.spring配置照样是这样:

?
1
<mvc:annotation-driven>

2.JsonUtil可以不用了,但如果要自己从response对象输出json,那么还是可以用,但改成了这样

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package com.xxx.utils;
 
import java.io.IOException;
import java.text.SimpleDateFormat;
import org.springframework.stereotype.Component;
import com.fasterxml.jackson.databind.ObjectMapper;
 
/**
 * 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;
 
 static {
  SimpleDateFormat dateFormat = new SimpleDateFormat(DEFAULT_DATE_FORMAT);
  mapper = new ObjectMapper();
  mapper.setDateFormat(dateFormat);
 }
  
 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字符转换为对象时失败!");
  }
 }
}

3.实体类的get方法就需要多一个@JsonFormat的注解配置

?
1
2
3
4
5
6
7
8
9
10
@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;
}
@DateTimeFormat(pattern="yyyy-MM-dd")
@JsonFormat(pattern="yyyy-MM-dd",timezone = "GMT+8")
public Date getBirthday() {
 return this.birthday;
}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持服务器之家。

原文链接:http://blog.csdn.net/zhanngle/article/details/24123659/