spring mvc 使用session

 

转自：http://anffvf.blog.163.com/blog/static/314754201101342148699/

Spring2.5 访问 Session 属性的四种策略 
Posted on 2008-10-12 16:57 mingj 阅读(1613) 评论(2)  编辑  收藏 所属分类: Spring  
WEB 应用通常会引入 Session，用来在服务端和客户端之间保存一系列动作/消息的状态，比如网上购物维护 user 登录信息直到 user 退出。在 user 登录后，Session 周期里有很多 action 都需要从 Session 中得到 user，再验证身份权限，或者进行其他的操作。这其中就会涉及到程序去访问 Session属性的问题。在java中，Servlet 规范提供了 HttpSession对象来满足这种需求。开发人员可以从 HttpServletRquest对象得到 HttpSession，再从HttpSession中得到状态信息。

还是回到购物车的例子，假设在 controller 某个方法（本文简称为action）中我们要从HttpSession中取到user对象。如果基于Servlet，标准的代码会是这样的：


public void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
User user = (User)req.getSession().getAttribute("currentUser");
//
}
这样的代码在传统的Servlet程序中是很常见的：因为使用了 Servlet API，从而对 Servlet API产生依赖。这样如果我们要测试 action，我们就必须针对 HttpServletRequest、HttpServletResponse 和 HttpSession类提供 mock 或者 stub 实现。当然现在已经有很多开源的 Servlet 测试框架帮助我们减轻这个痛苦，包括 Spring 就自带了对了这些类的 stub 实现，但那还是太冗繁琐碎了。那有没有比较好的办法来让我们的 controller 更 POJO，让我们的 action 脱离 Servlet API 依赖，更有益于测试和复用呢？我们来看看在 Spring2.5 中访问 Session 属性的几种策略，并将在本博的后续文章继续探究解决方案选择后面的深层含义。


（一）通过方法参数传入HttpServletRequest对象或者HttpSession对象
笔者的前一篇文章已经简单介绍了Spring2.5的annotation使得 controller 摆脱了 Servlet API 对方法参数的限制，这里就不赘述了。有兴趣的同学可以参考这里。Spring对annotationed的 action 的参数提供自动绑定支持的参数类型包括 Servlet API 里面的 Request/Response/HttpSession（包含Request、Response在Servlet API 中声明的具体子类）。于是开发人员可以通过在 action 参数中声明 Request 对象或者 HttpSession 对象，来让容器注入相应的对象。

action 的代码如下：


@RequestMapping
public void hello(HttpSession session){
User user = (User)session.getAttribute("currentUser");
//
}
优点：
1. 程序中直接得到底层的 Request/HttpSession 对象，直接使用 Servlet API 规范中定义的方法操作这些对象中的属性，直接而简单。
2. action 需要访问哪些具体的 Session 属性，是由自己控制的，真正精确到 Session 中的每个特定属性。
不足：
1. 程序对 Servlet API 产生依赖。虽然 controller 类已经不需要从 HttpServlet 继承，但仍需要 Servlet API 才能完成编译运行，乃至测试。
2. 暴露了底层 Servlet API，暴露了很多并不需要的底层方法和类，开发人员容易滥用这些 API。

（二）通过定制拦截器（Interceptor）在controller类级别注入需要的User对象
Interceptor 是 Spring 提供的扩展点之一，SpringMVC 会在 handle 某个 request 前后调用在配置中定义的 Interceptor 完成一些切面的工作，比如验证用户权限、处理分发等，类似于 AOP。那么，我们可以提取这样一个“横切点”，在 SpringMVC 调用 action 前，在 Interceptor 的 preHandle 方法中给 controller 注入 User 成员变量，使之具有当前登录的 User 对象。

此外还需要给这些特定 controller 声明一类 interface，比如 IUserAware。这样开发人员就可以只针对这些需要注入 User 对象的 controller 进行注入增强。

IUserAware 的代码：

public interface IUserAware {
public void setUser();
}

controller 的代码：

@Controller
public GreetingController implements IUserAware {
private User user;
public void setUser(User user){
  this.user = user;
}

@RequestMapping
public void hello(){
  //user.sayHello();
}
//
}

Interceptor 的代码：

public class UserInjectInterceptor extends HandlerInterceptorAdapter {
@Override
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object handler) throws Exception {
        if (handler.isAssignableFrom(IUserAware)){
        User user = (User)httpServletRequest.getSession().getAttribute("currentUser");
        IUserAware userAware = (IUserAware) handler;
        userAware.setUser(user);
        }
        return super.preHandle(httpServletRequest, httpServletResponse, handler);
    }
    //
}

为了让 SpringMVC 能调用我们定义的 Interceptor，我们还需要在 SpringMVC 配置文件中声明该 Interceptor，比如：

<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">
    <property name="interceptors">
        <list>
            <ref bean="userInjectInterceptor"/><!-- userInjectInterceptor bean 的声明省略-->
        </list>
    </property>
</bean>
优点：
1. 对 Servlet API 的访问被移到了自 SpringMVC API 扩展的 Interceptor，controller 不需要关心 User 如何得到。
2. 开发人员可以通过随时添加或移除 Interceptor 来完成对不同参数在某一类型 controller 上的注入。
3. controller 的 User 对象通过外界注入，测试时开发人员可以很容易地注入自己想要的 User 对象。
4. controller 类去掉了对 Servlet API 的依赖，更 POJO 和通用。
5. controller 类是通过对 interface 的声明来辅助完成注入的，并不存在任何继承依赖。
不足：
1. SpringMVC 对 controller 默认是按照单例（singleton）处理的，在 controller 类中添加一个成员变量，可能会引起多线程的安全问题。
2. 因为 User 对象是定义为 controller 的成员变量，而且是通过 setter 注入进来，在测试时需要很小心地保证对controller 注入了 User 对象，否则有可能我们拿到的就不一定是一个“好公民”（Good Citizen）。

其实，一言而蔽之，这些不足之所以出现，是因为我们把某个 action 级别需要的 User 对象上提到 controller 级别，破坏了 the convention of stateless for controller classes，而 setter 方式的注入又带来了一些隐含的繁琐和不足。当然，我们可以通过把 controller 声明为“prototype”来绕过 stateless 的约定，也可以保证每次 new 一个 controller 的同时给其注入一个 User 对象。但是我们有没有更简单更 OO 的方式来实现呢？答案是有的。

（三）通过方法参数处理类（MethodArgumentResolver）在方法级别注入User对象
正如前面所看到的，SpringMVC 提供了不少扩展点给开发人员扩展，让开发人员可以按需索取，plugin 上自定义的类或 handler。那么，在 controller 类的层次上，SpringMVC 提供了 Interceptor 扩展，在 action 上有没有提供相应的 handler 呢？如果我们能够对 action 实现注入，出现的种种不足了。

通过查阅 SpringMVC API 文档，SpringMVC 其实也为 action 级别提供了方法参数注入的 Resolver 扩展，允许开发人员给 HandlerMapper 类 set 自定义的 MethodArgumentResolver。

action 的代码如下：

@RequestMapping
public void hello(User user){
//user.sayHello()
}

Resolver 的代码如下：

public class UserArgumentResolver implements WebArgumentResolver {

    public Object resolveArgument(MethodParameter methodParameter, NativeWebRequest webRequest) throws Exception {
        if (methodParameter.getParameterType().equals(User.class)) {
            return webRequest.getAttribute("currentUser", RequestAttributes.SCOPE_SESSION);
        }
        return UNRESOLVED;
    }
}


配置文件的相关配置如下：

<bean class="org.springframework.web.servlet.mvc.annotation.OwnAnnotationMethodHandlerAdapter">
    <property name="customArgumentResolver">
        <ref bean="userArgumentResolver"/><!-- userArgumentResolver bean 的定义省略 -->
    </property>
</bean>
优点：
1. 具备第二种方案的所有优点
2. 真正做到了按需分配，只在真正需要对象的位置注入具体的对象，减少其他地方对该对象的依赖。
3. 其他人能很容易地从 action 的参数列表得知 action 所需要的依赖，API 更清晰易懂。
4. 对于很多 action 需要的某一类参数，可以在唯一的设置点用很方便一致的方式进行注入。
不足：
1. 对象依赖注入是针对所有 action， 注入粒度还是较粗。不能做到具体 action 访问具体的 Session 属性

（四）通过 SpringMVC 的 SessionAttributes Annotation 关联 User 属性
SpringMVC 文档提到了 @SessionAttributes annotation，和 @ModelAttribute 配合使用可以往 Session 中存或者从 Session 中取指定属性名的具体对象。文档里说；

The type-level @SessionAttributes annotation declares session attributes used by a specific handler. This will typically list the names of model attributes which should be transparently stored in the session or some conversational storage, serving as form-backing beans between subsequent requests.

很明显，@SessionAttributes 是用来在 controller 内部共享 model 属性的。从文档自带的例子来看，标注成 @SessionAttributes 属性的对象，会一直保留在 Session 或者其他会话存储中，直到 SessionStatus 被显式 setComplete()。那这个 annotation 对我们有什么帮助呢？

答案就是我们可以在需要访问 Session 属性的 controller 上加上 @SessionAttributes，然后在 action 需要的 User 参数上加上 @ModelAttribute，并保证两者的属性名称一致。SpringMVC 就会自动将 @SessionAttributes 定义的属性注入到 ModelMap 对象，在 setup action 的参数列表时，去 ModelMap 中取到这样的对象，再添加到参数列表。只要我们不去调用 SessionStatus 的 setComplete() 方法，这个对象就会一直保留在 Session 中，从而实现 Session 信息的共享。

controller的代码如下：

@Controller
@SessionAttributes("currentUser")
public class GreetingController{
@RequestMapping
public void hello(@ModelAttribute("currentUser") User user){
  //user.sayHello()
}
//
}

使用这种方案，还需要在 SpringMVC 配置文件的 ViewResolver 定义处，加上 p:allowSessionOverride="true"，这样如果你对 User 对象做了修改，SpringMVC 就会在渲染 View 的同时覆写 Session 中的相关属性。



优点： 
1. 具备第二种方案的所有优点
2. 使用 Annotation 声明对 Session 特定属性的存取，每个 action 只需要声明自己想要的 Session 属性。
3. 其他人能很容易地从 action 的参数列表得知 action 所需要的依赖，API 更清晰易懂。
不足：
1. 对于相同属性的 Session 对象，需要在每个 action 上定义。
2. 这种方案并不是 SpringMVC 的初衷，因此有可能会引起一些争议。

纵观这四类方法，我们可以看出我们对 Session 属性的访问控制设置，是从所有 Servlet，到某一类型的 controller 的成员变量，到所有 action 的某一类型参数，再到具体 action 的具体对象。每种方案都有各自的优点和不足：第一种方案虽然精确，但可惜引入了对 Servlet API 的依赖，不利于 controller 的测试和逻辑复用。第二、三种方案虽然解决了对 Servlet API 的依赖，也分别在 controller 和 action 级别上提供了对 Session 属性的访问，但注入粒度在一定程度上还是不够细，要想对具体属性进行访问可能会比较繁琐。不过，这在另一方面也提供了简便而统一的方法来对一系列相同类型的参数进行注入。第四种方案通过使用 Annotation，不仅摆脱了 Servlet API 的依赖，而且在 action 级别上提供了对 Session 具体属性的访问控制。但是这种访问有可能会粒度过细，需要在很多不同 action 上声明相同的 annotation。而且，毕竟这种用法并不是 SpringMVC 的初衷和推荐的，可能会带来一些争议。



本文演示了 Spring2.5 访问 Session 属性的几种不同解决方案，并分析了各自的优点和不足。本文并不打算对这些解决方案评出对错，只是试图列出在选择方案时的思维过程以及选择标准。每种方案都能满足某一类上下文的需求，在特定的开发环境和团队中都可能会是最优的选择。但是笔者还是发现，整个过程中，一些平常容易忽视的 OOP 的准则或者原则在发挥着效应，鉴于本文篇幅已经较长，就留到后续文章中继续探讨解决方案选择背后的深层含义，敬请期待。

----------------------------

http://apps.hi.baidu.com/share/detail/18993218

 

转)使用 Spring 2.5 基于注解驱动的 Spring MVC－2

绑定模型对象中某个属性

Spring 2.0 定义了一个 org.springframework.ui.ModelMap 类，它作为通用的模型数据承载对象，传递数据供视图所用。我们可以在请求处理方法中声明一个 ModelMap 类型的入参，Spring 会将本次请求模型对象引用通过该入参传递进来，这样就可以在请求处理方法内部访问模型对象了。来看下面的例子：

清单 9. 使用 ModelMap 访问请示对应的隐含模型对象

@RequestMapping(params = "method=listBoardTopic")   public String listBoardTopic(@RequestParam("id")int topicId,   User user,ModelMap model) {       bbtForumService.getBoardTopics(topicId);       System.out.println("topicId:" + topicId);       System.out.println("user:" + user);       //① 将user对象以currUser为键放入到model中       model.addAttribute("currUser",user);        return "listTopic";   }

 

 

对于当次请求所对应的模型对象来说，其所有属性都将存放到 request 的属性列表中。象上面的例子，ModelMap 中的 currUser 属性将放到 request 的属性列表中，所以可以在 JSP 视图页面中通过 request.getAttribute(“currUser”) 或者通过 ${currUser} EL 表达式访问模型对象中的 user 对象。从这个角度上看， ModelMap 相当于是一个向 request 属性列表中添加对象的一条管道，借由 ModelMap 对象的支持，我们可以在一个不依赖 Servlet API 的 Controller 中向 request 中添加属性。

在默认情况下，ModelMap 中的属性作用域是 request 级别是，也就是说，当本次请求结束后，ModelMap 中的属性将销毁。如果希望在多个请求中共享 ModelMap 中的属性，必须将其属性转存到 session 中，这样 ModelMap 的属性才可以被跨请求访问。

Spring 允许我们有选择地指定 ModelMap 中的哪些属性需要转存到 session 中，以便下一个请求属对应的 ModelMap 的属性列表中还能访问到这些属性。这一功能是通过类定义处标注 @SessionAttributes 注解来实现的。请看下面的代码：

清单 10. 使模型对象的特定属性具有 Session 范围的作用域

package com.baobaotao.web;    …  import org.springframework.ui.ModelMap;  import org.springframework.web.bind.annotation.SessionAttributes;    @Controller  @RequestMapping("/bbtForum.do")  @SessionAttributes("currUser") //①将ModelMap中属性名为currUser的属性  //放到Session属性列表中，以便这个属性可以跨请求访问  public class BbtForumController {  …      @RequestMapping(params = "method=listBoardTopic")      public String listBoardTopic(@RequestParam("id")int topicId, User user,  ModelMap model) {          bbtForumService.getBoardTopics(topicId);          System.out.println("topicId:" + topicId);          System.out.println("user:" + user);          model.addAttribute("currUser",user); //②向ModelMap中添加一个属性          return "listTopic";      }    }

 

 

我们在 ② 处添加了一个 ModelMap 属性，其属性名为 currUser，而 ① 处通过 @SessionAttributes 注解将 ModelMap 中名为 currUser 的属性放置到 Session 中，所以我们不但可以在 listBoardTopic() 请求所对应的 JSP 视图页面中通过 request.getAttribute(“currUser”) 和 session.getAttribute(“currUser”) 获取 user 对象，还可以在下一个请求所对应的 JSP 视图页面中通过 session.getAttribute(“currUser”) 或 ModelMap#get(“currUser”) 访问到这个属性。

这里我们仅将一个 ModelMap 的属性放入 Session 中，其实 @SessionAttributes 允许指定多个属性。你可以通过字符串数组的方式指定多个属性，如 @SessionAttributes({“attr1”,”attr2”})。此外，@SessionAttributes 还可以通过属性类型指定要 session 化的 ModelMap 属性，如 @SessionAttributes(types = User.class)，当然也可以指定多个类，如 @SessionAttributes(types = {User.class,Dept.class})，还可以联合使用属性名和属性类型指定：@SessionAttributes(types = {User.class,Dept.class},value={“attr1”,”attr2”})。

上面讲述了如何往ModelMap中放置属性以及如何使ModelMap中的属性拥有Session域的作用范围。除了在JSP视图页面中通过传统的方法访问ModelMap中的属性外，读者朋友可能会问：是否可以将ModelMap中的属性绑定到请求处理方法的入参中呢？答案是肯定的。Spring为此提供了一个@ModelAttribute的注解，下面是使用@ModelAttribute注解的例子：

清单 11. 使模型对象的特定属性具有 Session 范围的作用域

 

package com.baobaotao.web;    import com.baobaotao.service.BbtForumService;  import org.springframework.beans.factory.annotation.Autowired;  import org.springframework.stereotype.Controller;  import org.springframework.ui.ModelMap;  import org.springframework.web.bind.annotation.RequestMapping;  import org.springframework.web.bind.annotation.RequestParam;  import org.springframework.web.bind.annotation.SessionAttributes;  import org.springframework.web.bind.annotation.ModelAttribute;    import javax.servlet.http.HttpServletRequest;  import javax.servlet.http.HttpSession;    @Controller  @RequestMapping("/bbtForum.do")  @SessionAttributes("currUser") //①让ModelMap的currUser属性拥有session级作用域  public class BbtForumController {        @Autowired  private BbtForumService bbtForumService;        @RequestMapping(params = "method=listBoardTopic")      public String listBoardTopic(@RequestParam("id")int topicId, User user,  ModelMap model) {          bbtForumService.getBoardTopics(topicId);          System.out.println("topicId:" + topicId);          System.out.println("user:" + user);          model.addAttribute("currUser",user); //②向ModelMap中添加一个属性          return "listTopic";      }        @RequestMapping(params = "method=listAllBoard")     //③将ModelMap中的  public String listAllBoard(@ModelAttribute("currUser") User user) {   //currUser属性绑定到user入参中。          bbtForumService.getAllBoard();          System.out.println("user:"+user);          return "listBoard";      }  }

 

 

在 ② 处，我们向 ModelMap 中添加一个名为 currUser 的属性，而 ① 外的注解使这个 currUser 属性拥有了 session 级的作用域。所以，我们可以在 ③ 处通过 @ModelAttribute 注解将 ModelMap 中的 currUser 属性绑定以请求处理方法的 user 入参中。

所以当我们先调用以下 URL 请求： http://localhost/bbtForum.do?method=listBoardTopic&id=1&userName=tom&dept.deptId=12

以执行listBoardTopic()请求处理方法，然后再访问以下URL： http://localhost/sample/bbtForum.do?method=listAllBoard

你将可以看到 listAllBoard() 的 user 入参已经成功绑定到 listBoardTopic() 中注册的 session 级的 currUser 属性上了。

 

回页首

 

 

请求处理方法的签名规约

方法入参

我们知道标注了 @RequestMapping 注解的 Controller 方法就成为了请求处理方法，Spring MVC 允许极其灵活的请求处理方法签名方式。对于方法入参来说，它允许多种类型的入参，通过下表进行说明：

 

请求处理方法入参的可选类型 说明

Java 基本数据类型和 String	默认情况下将按名称匹配的方式绑定到 URL 参数上，可以通过 @RequestParam 注解改变默认的绑定规则
request/response/session	既可以是 Servlet API 的也可以是 Portlet API 对应的对象，Spring 会将它们绑定到 Servlet 和 Portlet 容器的相应对象上
org.springframework.web.context.request.WebRequest	内部包含了 request 对象
java.util.Locale	绑定到 request 对应的 Locale 对象上
java.io.InputStream/java.io.Reader	可以借此访问 request 的内容
java.io.OutputStream / java.io.Writer	可以借此操作 response 的内容
任何标注了 @RequestParam 注解的入参	被标注 @RequestParam 注解的入参将绑定到特定的 request 参数上。
java.util.Map / org.springframework.ui.ModelMap	它绑定 Spring MVC 框架中每个请求所创建的潜在的模型对象，它们可以被 Web 视图对象访问（如 JSP）
命令/表单对象（注：一般称绑定使用 HTTP GET 发送的 URL 参数的对象为命令对象，而称绑定使用 HTTP POST 发送的 URL 参数的对象为表单对象）	它们的属性将以名称匹配的规则绑定到 URL 参数上，同时完成类型的转换。而类型转换的规则可以通过 @InitBinder 注解或通过 HandlerAdapter 的配置进行调整
org.springframework.validation.Errors / org.springframework.validation.BindingResult	为属性列表中的命令/表单对象的校验结果，注意检验结果参数必须紧跟在命令/表单对象的后面
rg.springframework.web.bind.support.SessionStatus	可以通过该类型 status 对象显式结束表单的处理，这相当于触发 session 清除其中的通过 @SessionAttributes 定义的属性

 

Spring MVC 框架的易用之处在于，你可以按任意顺序定义请求处理方法的入参（除了 Errors 和 BindingResult 必须紧跟在命令对象/表单参数后面以外），Spring MVC 会根据反射机制自动将对应的对象通过入参传递给请求处理方法。这种机制让开发者完全可以不依赖 Servlet API 开发控制层的程序，当请求处理方法需要特定的对象时，仅仅需要在参数列表中声明入参即可，不需要考虑如何获取这些对象，Spring MVC 框架就象一个大管家一样“不辞辛苦”地为我们准备好了所需的一切。下面演示一下使用 SessionStatus 的例子：

清单 12. 使用 SessionStatus 控制 Session 级别的模型属性

@RequestMapping(method = RequestMethod.POST)  public String processSubmit(@ModelAttribute Owner owner,   BindingResult result, SessionStatus status) {//<——①      new OwnerValidator().validate(owner, result);      if (result.hasErrors()) {          return "ownerForm";      }      else {          this.clinic.storeOwner(owner);          status.setComplete();//<——②          return "redirect:owner.do?ownerId=" + owner.getId();      }  }

 

 

processSubmit() 方法中的 owner 表单对象将绑定到 ModelMap 的“owner”属性中，result 参数用于存放检验 owner 结果的对象，而 status 用于控制表单处理的状态。在 ② 处，我们通过调用 status.setComplete() 方法，该 Controller 所有放在 session 级别的模型属性数据将从 session 中清空。

方法返回参数

在低版本的 Spring MVC 中，请求处理方法的返回值类型都必须是 ModelAndView。而在 Spring 2.5 中，你拥有多种灵活的选择。通过下表进行说明：

 

请求处理方法入参的可选类型 说明

void	此时逻辑视图名由请求处理方法对应的 URL 确定，如以下的方法： @RequestMapping("/welcome.do") public void welcomeHandler() { } 对应的逻辑视图名为“welcome”
String	此时逻辑视图名为返回的字符，如以下的方法： @RequestMapping(method = RequestMethod.GET) public String setupForm(@RequestParam("ownerId") int ownerId, ModelMap model) { Owner owner = this.clinic.loadOwner(ownerId); model.addAttribute(owner); return "ownerForm"; } 对应的逻辑视图名为“ownerForm”
org.springframework.ui.ModelMap	和返回类型为 void 一样，逻辑视图名取决于对应请求的 URL，如下面的例子： @RequestMapping("/vets.do") public ModelMap vetsHandler() { return new ModelMap(this.clinic.getVets()); } 对应的逻辑视图名为“vets”，返回的 ModelMap 将被作为请求对应的模型对象，可以在 JSP 视图页面中访问到。
ModelAndView	当然还可以是传统的 ModelAndView。

 

应该说使用 String 作为请求处理方法的返回值类型是比较通用的方法，这样返回的逻辑视图名不会和请求 URL 绑定，具有很大的灵活性，而模型数据又可以通过 ModelMap 控制。当然直接使用传统的 ModelAndView 也不失为一个好的选择。

 

回页首

 

 

注册自己的属性编辑器

Spring MVC 有一套常用的属性编辑器，这包括基本数据类型及其包裹类的属性编辑器、String 属性编辑器、JavaBean 的属性编辑器等。但有时我们还需要向 Spring MVC 框架注册一些自定义的属性编辑器，如特定时间格式的属性编辑器就是其中一例。

Spring MVC 允许向整个 Spring 框架注册属性编辑器，它们对所有 Controller 都有影响。当然 Spring MVC 也允许仅向某个 Controller 注册属性编辑器，对其它的 Controller 没有影响。前者可以通过 AnnotationMethodHandlerAdapter 的配置做到，而后者则可以通过 @InitBinder 注解实现。

下面先看向整个 Spring MVC 框架注册的自定义编辑器：

清单 13. 注册框架级的自定义属性编辑器

>bean class="org.springframework.web.servlet.mvc.annotation.  AnnotationMethodHandlerAdapter"<      >property name="webBindingInitializer"<          >bean class="com.baobaotao.web.MyBindingInitializer"/<      >/property<  >/bean<

 

 

MyBindingInitializer 实现了 WebBindingInitializer 接口，在接口方法中通过 binder 注册多个自定义的属性编辑器，其代码如下所示：

清单 14.自定义属性编辑器

package org.springframework.samples.petclinic.web;    import java.text.SimpleDateFormat;  import java.util.Date;    import org.springframework.beans.factory.annotation.Autowired;  import org.springframework.beans.propertyeditors.CustomDateEditor;  import org.springframework.beans.propertyeditors.StringTrimmerEditor;  import org.springframework.samples.petclinic.Clinic;  import org.springframework.samples.petclinic.PetType;  import org.springframework.web.bind.WebDataBinder;  import org.springframework.web.bind.support.WebBindingInitializer;  import org.springframework.web.context.request.WebRequest;    public class MyBindingInitializer implements WebBindingInitializer {        public void initBinder(WebDataBinder binder, WebRequest request) {          SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");          dateFormat.setLenient(false);          binder.registerCustomEditor(Date.class,               new CustomDateEditor(dateFormat, false));          binder.registerCustomEditor(String.class, new StringTrimmerEditor(false));      }  }

 

 

如果希望某个属性编辑器仅作用于特定的 Controller，可以在 Controller 中定义一个标注 @InitBinder 注解的方法，可以在该方法中向 Controller 了注册若干个属性编辑器，来看下面的代码：

清单 15. 注册 Controller 级的自定义属性编辑器

@Controller  public class MyFormController {        @InitBinder      public void initBinder(WebDataBinder binder) {          SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");          dateFormat.setLenient(false);          binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, false));      }      …  }

 

 

注意被标注 @InitBinder 注解的方法必须拥有一个 WebDataBinder 类型的入参，以便 Spring MVC 框架将注册属性编辑器的 WebDataBinder 对象传递进来。

 

回页首

 

 

如何准备数据

在编写 Controller 时，常常需要在真正进入请求处理方法前准备一些数据，以便请求处理或视图渲染时使用。在传统的 SimpleFormController 里，是通过复写其 referenceData() 方法来准备引用数据的。在 Spring 2.5 时，可以将任何一个拥有返回值的方法标注上 @ModelAttribute，使其返回值将会进入到模型对象的属性列表中。来看下面的例子：

清单 16. 定义为处理请求准备数据的方法

package com.baobaotao.web;    import com.baobaotao.service.BbtForumService;  import org.springframework.beans.factory.annotation.Autowired;  import org.springframework.stereotype.Controller;  import org.springframework.ui.ModelMap;  import org.springframework.web.bind.annotation.ModelAttribute;  import org.springframework.web.bind.annotation.RequestMapping;  import org.springframework.web.bind.annotation.RequestParam;  import org.springframework.web.bind.annotation.SessionAttributes;    import java.util.ArrayList;  import java.util.List;  import java.util.Set;    @Controller  @RequestMapping("/bbtForum.do")  public class BbtForumController {        @Autowired      private BbtForumService bbtForumService;        @ModelAttribute("items")//<——①向模型对象中添加一个名为items的属性      public List<String> populateItems() {          List<String> lists = new ArrayList<String>();          lists.add("item1");          lists.add("item2");          return lists;      }        @RequestMapping(params = "method=listAllBoard")      public String listAllBoard(@ModelAttribute("currUser")User user, ModelMap model) {          bbtForumService.getAllBoard();          //<——②在此访问模型中的items属性          System.out.println("model.items:" + ((List<String>)model.get("items")).size());          return "listBoard";      }  }

 

 

在 ① 处，通过使用 @ModelAttribute 注解，populateItem() 方法将在任何请求处理方法执行前调用，Spring MVC 会将该方法返回值以“items”为名放入到隐含的模型对象属性列表中。

所以在 ② 处，我们就可以通过 ModelMap 入参访问到 items 属性，当执行 listAllBoard() 请求处理方法时，② 处将在控制台打印出“model.items:2”的信息。当然我们也可以在请求的视图中访问到模型对象中的 items 属性。

 

回页首

 

 

小结

Spring 2.5 对 Spring MVC 进行了很大增强，现在我们几乎完全可以使用基于注解的 Spring MVC 完全替换掉原来基于接口 Spring MVC 程序。基于注解的 Spring MVC 比之于基于接口的 Spring MVC 拥有以下几点好处：

方便请求和控制器的映射； 
方便请求处理方法入参绑定URL参数； 
Controller 不必继承任何接口，它仅是一个简单的 POJO。

但是基于注解的 Spring MVC 并不完美，还存在优化的空间，因为在某些配置上它比基于 XML 的配置更繁琐。比如对于处理多个请求的 Controller 来说，假设我们使用一个 URL 参数指定调用的处理方法（如 xxx.do?method=listBoardTopic），当使用注解时，每个请求处理方法都必须使用 @RequestMapping() 注解指定对应的 URL 参数（如 @RequestMapping(params = "method=listBoardTopic")），而在 XML 配置中我们仅需要配置一个 ParameterMethodNameResolver 就可以了。

 

参考资料

学习
Spring 系列：Spring 框架简介：优秀的 Spring 框架入门系列，了解 Spring 框架的基本概念。 
轻量级开发的成功秘诀，第 3 部分: Spring 露出水面：介绍了在 Spring 框架的轻量级 Ioc 容器。 
Spring Framework 和 IBM WebSphere Application Server：Interface21 的首席执行官 Rod Johnson 和 IBM 的 WebSphere Open Source 主管 Paul Buck 讨论了 Spring Framework 通过 IBM WebSphere Application Server 认证对 Spring 和 WebSphere 产品系列的开发人员和客户有何重要意义。 
Tiger 中的注释，第 1 部分: 向 Java 代码中添加元数据：解释了元数据如此有用的原因，向您介绍了 Java 语言中的注释，并研究了 Tiger 的内置注释。 
Tiger 中的注释，第 2 部分: 定制注释：说明了如何创建定制注释，如何用自己的注释注解文档，并进一步定制代码。 
获得产品和技术
Springframework 网站：下载 Spring 框架。