/**PageBeginHtml Block Begin **/ /***自定义返回顶部小火箭***/ /*生成博客目录的JS 开始*/ /*生成博客目录的JS 结束*/

SpringMVC（4.2）：Controller接口控制器详解（2）

原文出处： 张开涛


4.5、ServletForwardingController

将接收到的请求转发到一个命名的servlet，具体示例如下：

  1 package cn.javass.chapter4.web.servlet;
  2 public class ForwardingServlet extends HttpServlet {
  3     @Override
  4     protected void doGet(HttpServletRequest req, HttpServletResponse resp)
  5     throws ServletException, IOException {
  6 
  7         resp.getWriter().write("Controller forward to Servlet");
  8 
  9     }
 10 }
  1 <servlet>
  2     <servlet-name>forwarding</servlet-name>
  3     <servlet-class>cn.javass.chapter4.web.servlet.ForwardingServlet</servlet-class>
  4 </servlet>
  1 <!— 在chapter4-servlet.xml配置处理器 -->
  2 <bean name="/forwardToServlet"
  3 class="org.springframework.web.servlet.mvc.ServletForwardingController">
  4         <property name="servletName" value="forwarding"></property>
  5 </bean>



当我们请求/forwardToServlet时，会被转发到名字为“forwarding”的servlet处理，该sevlet的servlet-mapping标签配置是可选的。

4.6、BaseCommandController

命令控制器通用基类，提供了以下功能支持：

1、数据绑定：请求参数绑定到一个command object（命令对象，非GoF里的命令设计模式），这里的命令对象是指绑定请求参数的任何POJO对象；

   commandClass：表示命令对象实现类，如UserModel；

   commandName：表示放入请求的命令对象名字（默认command），request.setAttribute(commandName, commandObject);

2、验证功能：提供Validator注册功能，注册的验证器会验证命令对象属性数据是否合法；

   validators：通过该属性注入验证器，验证器用来验证命令对象属性是否合法；

该抽象类没有没有提供流程功能，只是提供了一些公共的功能，实际使用时需要使用它的子类。

4.7、AbstractCommandController

命令控制器之一，可以实现该控制器来创建命令控制器，该控制器能把自动封装请求参数到一个命令对象，而且提供了验证功能。

1、创建命令类（就是普通的JavaBean类/POJO）


  1 package cn.javass.chapter4.model;
  2 public class UserModel {
  3     private String username;
  4     private String password;
  5         //省略setter/getter  
  6 }

2、实现控制器

  1 package cn.javass.chapter4.web.controller;
  2 //省略import  
  3 public class MyAbstractCommandController extends AbstractCommandController {
  4     public MyAbstractCommandController() {
  5         //设置命令对象实现类  
  6         setCommandClass(UserModel.class);
  7     }
  8     @Override
  9     protected ModelAndView handle(HttpServletRequest req, HttpServletResponse resp, Object command, BindException errors) throws Exception {
 10         //将命令对象转换为实际类型  
 11         UserModel user = (UserModel) command;
 12         ModelAndView mv = new ModelAndView();
 13         mv.setViewName("abstractCommand");
 14         mv.addObject("user", user);
 15         return mv;
 16     }
 17 }
  1 <!— 在chapter4-servlet.xml配置处理器 -->
  2 <bean name="/abstractCommand"
  3 class="cn.javass.chapter4.web.controller.MyAbstractCommandController">
  4         <!-- 也可以通过依赖注入 注入命令实现类 -->
  5         <!-- property name="commandClass" value="cn.javass.chapter4.model.UserModel"/-->
  6 </bean>
  1 <!— WEB-INF/jsp/abstractCommand.jsp视图下的主要内容 -->
  2 
  3 ${user.username }-${user.password }



当我们在浏览器中输入“http://localhost:9080/springmvc-chapter4/abstractCommand?username=123&password=123”，会自动将请求参数username和password绑定到命令对象；绑定时按照JavaBean命名规范绑定；

a633b31a42f0224c9bf66cd3cc886e04__2


4.8、AbstractFormController

用于支持带步骤的表单提交的命令控制器基类，使用该控制器可以完成：

1、定义表单处理（表单的渲染），并从控制器获取命令对象构建表单；

2、提交表单处理，当用户提交表单内容后，AbstractFormController可以将用户请求的数据绑定到命令对象，并可以验证表单内容、对命令对象进行处理。

  1       @Override
  2 rotected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response)
  3     throws Exception {
  4      //1、是否是表单提交？ 该方法实现为（"POST".equals(request.getMethod())），即POST表示表单提交  
  5 if (isFormSubmission(request)) {
  6     try {
  7         Object command = getCommand(request);
  8         ServletRequestDataBinder binder = bindAndValidate(request, command);
  9         BindException errors = new BindException(binder.getBindingResult());
 10               //表单提交应该放到该方法实现  
 11         return processFormSubmission(request, response, command, errors);
 12     }
 13     catch (HttpSessionRequiredException ex) {
 14               //省略部分代码  
 15         return handleInvalidSubmit(request, response);
 16     }
 17 }
 18 else {
 19     //2、表示是表单展示，该方法又转调showForm方法，因此我们需要覆盖showForm来完成表单展示  
 20     return showNewForm(request, response);
 21 }

bindOnNewForm：是否在进行表单展示时绑定请求参数到表单对象，默认false，不绑定；

sessionForm：session表单模式，如果开启（true）则会将表单对象放置到session中，从而可以跨越多次请求保证数据不丢失（多步骤表单常使用该方式，详解AbstractWizardFormController），默认false；

Object formBackingObject(HttpServletRequest request) ：提供给表单展示时使用的表单对象（form object表单要展示的默认数据），默认通过commandName暴露到请求给展示表单；

Map referenceData(HttpServletRequest request, Object command, Errors errors)：展示表单时需要的一些引用数据（比如用户注册，可能需要选择工作地点，这些数据可以通过该方法提供），如：


  1 protected Map referenceData(HttpServletRequest request) throws Exception {
  2              Map model = new HashMap();
  3              model.put("cityList", cityList);
  4              return model;
  5 }


    这样就可以在表单展示页面获取cityList数据。

SimpleFormController继承该类，而且提供了更简单的表单流程控制。

4.9、SimpleFormController

提供了更好的两步表单支持：

1、准备要展示的数据，并到表单展示页面；

2、提交数据数据进行处理。

第一步，展示：

a633b31a42f0224c9bf66cd3cc886e04__2

第二步，提交表单：

a633b31a42f0224c9bf66cd3cc886e04__2


接下来咱们写一个用户注册的例子学习一下：

（1、控制器


  1 package cn.javass.chapter4.web.controller;
  2 //省略import  
  3 public class RegisterSimpleFormController extends SimpleFormController {
  4     public RegisterSimpleFormController() {
  5         setCommandClass(UserModel.class); //设置命令对象实现类  
  6         setCommandName("user");//设置命令对象的名字  
  7     }
  8     //form object 表单对象，提供展示表单时的表单数据（使用commandName放入请求）  
  9     protected Object formBackingObject(HttpServletRequest request) throws Exception {
 10         UserModel user = new UserModel();
 11         user.setUsername("请输入用户名");
 12         return user;
 13     }
 14     //提供展示表单时需要的一些其他数据    
 15     protected Map referenceData(HttpServletRequest request) throws Exception {
 16         Map map = new HashMap();
 17         map.put("cityList", Arrays.asList("山东", "北京", "上海"));
 18         return map;
 19     }
 20     protected void doSubmitAction(Object command) throws Exception {
 21         UserModel user = (UserModel) command;
 22         //TODO 调用业务对象处理  
 23         System.out.println(user);
 24     }
 25 }


setCommandClass和setCommandName：分别设置了命令对象的实现类和名字；

formBackingObject和referenceData：提供了表单展示需要的视图；

doSubmitAction：用于执行表单提交动作，由onSubmit方法调用，如果不需要请求/响应对象或进行数据验证，可以直接使用doSubmitAction方法进行功能处理。

（2、spring配置（chapter4-servlet.xml）

  1 <bean name="/simpleForm"
  2 class="cn.javass.chapter4.web.controller.RegisterSimpleFormController">
  3         <property name="formView" value="register"/>
  4         <property name="successView" value="redirect:/success"/>
  5 </bean>
  6 <bean name="/success" class="cn.javass.chapter4.web.controller.SuccessController"/>

formView：表示展示表单时显示的页面；

successView：表示处理成功时显示的页面；“redirect:/success”表示成功处理后重定向到/success控制器；防止表单重复提交；

“/success” bean的作用是显示成功页面，此处就不列举了。

（3、视图页面

  1 <!-- register.jsp 注册展示页面-->
  2 <form method="post">
  3 username:<input type="text" name="username" value="${user.username}"><br/>
  4 password:<input type="password" name="username"><br/>
  5 city:<select>
  6   <c:forEach items="${cityList }" var="city">
  7    <option>${city}</option>
  8   </c:forEach>
  9 </select><br/>
 10 <input type="submit" value="注册"/>
 11 </form>



此处可以使用${user.username}获取到formBackingObject设置的表单对象、使用${cityList}获取referenceData设置的表单支持数据；

到此一个简单的两步表单到此结束，但这个表单有重复提交表单的问题，而且表单对象到页面的绑定是通过手工绑定的，后边我们会学习spring标签库（提供自动绑定表单对象到页面）。

4.10、CancellableFormController

一个可取消的表单控制器，继承SimpleFormController，额外提供取消表单功能。

1、表单展示：和SimpleFormController一样；

2、表单取消：和SimpleFormController一样；

3、表单成功提交：取消功能处理方法为：onCancel(Object command)，而且默认返回cancelView属性指定的逻辑视图名。

   那如何判断是取消呢？如果请求中有参数名为“_cancel”的参数，则表示表单取消。也可以通过cancelParamKey来修改参数名（如“_cancel.x”等）。

a633b31a42f0224c9bf66cd3cc886e04__2



示例：

（1、控制器

复制RegisterSimpleFormController一份命名为CanCancelRegisterSimpleFormController，添加取消功能处理方法实现：

  1 @Override
  2 protected ModelAndView onCancel(Object command) throws Exception {
  3     UserModel user = (UserModel) command;
  4     //TODO 调用业务对象处理  
  5     System.out.println(user);
  6     return super.onCancel(command);
  7 }

onCancel：在该功能方法内实现取消逻辑，父类的onCancel方法默认返回cancelView属性指定的逻辑视图名。

（2、spring配置（chapter4-servlet.xml）

  1 <bean name="/canCancelForm"
  2 class="cn.javass.chapter4.web.controller.CanCancelRegisterSimpleFormController">
  3         <property name="formView" value="register"/>
  4         <property name="successView" value="redirect:/success"/>
  5         <property name="cancelView" value="redirect:/cancel"/>
  6 </bean>
  7 <bean name="/cancel" class="cn.javass.chapter4.web.controller.CancelController"/>

（3、视图页面（修改register.jsp）

  1 <input type="submit" name="_cancel" value="取消"/>


该提交按钮的作用是取消，因为name="_cancel"，即请求后会有一个名字为_cancel的参数，因此会执行onCancel功能处理方法。

（4、测试：

在浏览器输入“http://localhost:9080/springmvc-chapter4/canCancelForm”，则首先到展示视图页面，点击“取消按钮”将重定向到“http://localhost:9080/springmvc-chapter4/cancel”，说明取消成功了。

实际项目可能会出现比如一些网站的完善个人资料都是多个页面（即多步），那应该怎么实现呢？接下来让我们看一下spring Web MVC提供的对多步表单的支持类AbstractWizardFormController。


4.11、AbstractWizardFormController

向导控制器类提供了多步骤（向导）表单的支持（如完善个人资料时分步骤填写基本信息、工作信息、学校信息等）

假设现在做一个完善个人信息的功能，分三个页面展示：

1、页面1完善基本信息；

2、页面2完善学校信息；

3、页面3完善工作信息。

这里我们要注意的是当用户跳转到页面2时页面1的信息是需要保存起来的，还记得AbstractFormController中的sessionForm吗？ 如果为true则表单数据存放到session中，哈哈，AbstractWizardFormController就是使用了这个特性。

a633b31a42f0224c9bf66cd3cc886e04__2


向导中的页码从0开始；

PARAM_TARGET = “_target”：

用于选择向导中的要使用的页面参数名前缀，如“_target0”则选择第0个页面显示，即图中的“wizard/baseInfo”，以此类推，如“_target1”将选择第1页面，要得到的页码为去除前缀“_target”后的数字即是；

PARAM_FINISH = “_finish”：

如果请求参数中有名为“_finish”的参数，表示向导成功结束，将会调用processFinish方法进行完成时的功能处理；

PARAM_CANCEL = “_cancel”：

如果请求参数中有名为“_cancel”的参数，表示向导被取消，将会调用processCancel方法进行取消时的功能处理；

向导中的命令对象：

向导中的每一个步骤都会把相关的参数绑定到命令对象，该表单对象默认放置在session中，从而可以跨越多次请求得到该命令对象。

接下来具体看一下如何使用吧。

（1、修改我们的模型数据以支持多步骤提交：



  1 public class UserModel {
  2     private String username;
  3     private String password;
  4     private String realname; //真实姓名  
  5     private WorkInfoModel workInfo;
  6     private SchoolInfoModel schoolInfo;
  7     //省略getter/setter  
  8 }
  9 
 10 
 11 public class SchoolInfoModel {
 12     private String schoolType; //学校类型：高中、中专、大学  
 13     private String schoolName; //学校名称  
 14     private String specialty; //专业  
 15 //省略getter/setter  
 16 }
 17 
 18 
 19 public class WorkInfoModel {
 20     private String city; //所在城市  
 21     private String job; //职位  
 22     private String year; //工作年限  
 23 //省略getter/setter  
 24 }


（2、控制器

  1 package cn.javass.chapter4.web.controller;
  2 //省略import  
  3 public class InfoFillWizardFormController extends AbstractWizardFormController {
  4     public InfoFillWizardFormController() {
  5         setCommandClass(UserModel.class);
  6         setCommandName("user");
  7     }
  8     protected Map referenceData(HttpServletRequest request, int page) throws Exception {
  9         Map map = new HashMap();
 10         if(page==1) { //如果是填写学校信息页 需要学校类型信息  
 11             map.put("schoolTypeList", Arrays.asList("高中", "中专", "大学"));
 12         }
 13         if(page==2) {//如果是填写工作信息页 需要工作城市信息  
 14             map.put("cityList", Arrays.asList("济南", "北京", "上海"));
 15         }
 16         return map;
 17     }
 18     protected void validatePage(Object command, Errors errors, int page) {
 19         //提供每一页数据的验证处理方法  
 20     }
 21     protected void postProcessPage(HttpServletRequest request, Object command, Errors errors, int page) throws Exception {
 22         //提供给每一页完成时的后处理方法  
 23     }
 24     protected ModelAndView processFinish(HttpServletRequest req, HttpServletResponse resp, Object command, BindException errors) throws Exception {
 25         //成功后的处理方法  
 26         System.out.println(command);
 27         return new ModelAndView("redirect:/success");
 28     }
 29     protected ModelAndView processCancel(HttpServletRequest request, HttpServletResponse response, Object command, BindException errors) throws Exception {
 30         //取消后的处理方法  
 31         System.out.println(command);
 32         return new ModelAndView("redirect:/cancel");
 33     }
 34 }


page页码：是根据请求中以“_target”开头的参数名来确定的，如“_target0”，则页码为0；

referenceData：提供每一页需要的表单支持对象，如完善学校信息需要学校类型，page页码从0开始（而且根据请求参数中以“_target”开头的参数来确定当前页码，如_target1，则page=1）；

validatePage：验证当前页的命令对象数据，验证应根据page页码来分步骤验证；

postProcessPage：验证成功后的后处理；

processFinish：成功时执行的方法，此处直接重定向到/success控制器（详见CancelController）；

processCancel：取消时执行的方法，此处直接重定向到/cancel控制器（详见SuccessController）；

其他需要了解：

allowDirtyBack和allowDirtyForward：决定在当前页面验证失败时，是否允许向导前移和后退，默认false不允许；

onBindAndValidate(HttpServletRequest request, Object command, BindException errors, int page)：允许覆盖默认的绑定参数到命令对象和验证流程。

（3、spring配置文件（chapter4-servlet.xml）

  1 <bean name="/infoFillWizard"
  2 class="cn.javass.chapter4.web.controller.InfoFillWizardFormController">
  3     <property name="pages">
  4         <list>
  5             <value>wizard/baseInfo</value>
  6             <value>wizard/schoolInfo</value>
  7             <value>wizard/workInfo</value>
  8        </list>
  9     </property>
 10 </bean>


（4、向导中的每一步视图

（4.1、基本信息页面(第一步) baseInfo.jsp：
  1 <form method="post">
  2 真实姓名:<input type="text" name="realname" value="${user.realname}">
  3 <input type="submit" name="_target1" value="下一步"/>
  4 </form>
（4.2、学校信息页面(第二步) schoolInfo.jsp：
  1 <form method="post">
  2 学校类型：<select name="schoolInfo.schoolType">
  3   <c:forEach items="${schoolTypeList }" var="schoolType">
  4    <option value="${schoolType }"
  5        <c:if test="${user.schoolInfo.schoolType eq schoolType}">
  6            selected="selected"
  7        </c:if>
  8    >
  9        ${schoolType}
 10    </option>
 11   </c:forEach>
 12 </select>
 13 学校名称：<input type="text" name="schoolInfo.schoolName" value="${user.schoolInfo.schoolName}"/>
 14 专业：<input type="text" name="schoolInfo.specialty" value="${user.schoolInfo.specialty}"/>
 15 <input type="submit" name="_target0" value="上一步"/>
 16 <input type="submit" name="_target2" value="下一步"/>
 17 </form>


（4.3、工作信息页面(第三步) workInfo.jsp：
  1 <form method="post">
  2 所在城市：<select name="workInfo.city">
  3   <c:forEach items="${cityList }" var="city">
  4    <option value="${city }"
  5        <c:if test="${user.workInfo.city eq city}">selected="selected"</c:if>
  6    >
  7      ${city}
  8    </option>
  9   </c:forEach>
 10 </select>
 11 职位：<input type="text" name="workInfo.job" value="${user.workInfo.job}"/>
 12 工作年限：<input type="text" name="workInfo.year" value="${user.workInfo.year}"/>
 13 <input type="submit" name="_target1" value="上一步"/>
 14 <input type="submit" name="_finish" value="完成"/>
 15 <input type="submit" name="_cancel" value="取消"/>
 16 </form>
 17


当前页码为2；

name=”_target1″：上一步，表示向导上一步要显示的页面的页码为1；

name=”_finish”：向导完成，表示向导成功，将会调用向导控制器的processFinish方法；

name=”_cancel”：向导取消，表示向导被取消，将会调用向导控制器的processCancel方法；

到此向导控制器完成，此处的向导流程比较简单，如果需要更复杂的页面流程控制，可以选择使用Spring Web Flow框架。

4.12、ParameterizableViewController

参数化视图控制器，不进行功能处理（即静态视图），根据参数的逻辑视图名直接选择需要展示的视图。

  1 <bean name="/parameterizableView"
  2 class="org.springframework.web.servlet.mvc.ParameterizableViewController">
  3 <property name="viewName" value="success"/>
  4 </bean>


该控制器接收到请求后直接选择参数化的视图，这样的好处是在配置文件中配置，从而避免程序的硬编码，比如像帮助页面等不需要进行功能处理，因此直接使用该控制器映射到视图。

4.13、AbstractUrlViewController

提供根据请求URL路径直接转化为逻辑视图名的支持基类，即不需要功能处理，直接根据URL计算出逻辑视图名，并选择具体视图进行展示：

urlDecode：是否进行url解码，不指定则默认使用服务器编码进行解码（如Tomcat默认ISO-8859-1）；

urlPathHelper：用于解析请求路径的工具类，默认为org.springframework.web.util.UrlPathHelper。

UrlFilenameViewController是它的一个实现者，因此我们应该使用UrlFilenameViewController。

4.14、UrlFilenameViewController

将请求的URL路径转换为逻辑视图名并返回的转换控制器，即不需要功能处理，直接根据URL计算出逻辑视图名，并选择具体视图进行展示：

根据请求URL路径计算逻辑视图名；

  1 <bean name="/index1/*"
  2 class="org.springframework.web.servlet.mvc.UrlFilenameViewController"/>
  3 <bean name="/index2/**"
  4 class="org.springframework.web.servlet.mvc.UrlFilenameViewController"/>
  5 <bean name="/*.html"
  6 class="org.springframework.web.servlet.mvc.UrlFilenameViewController"/>
  7 <bean name="/index3/*.html"
  8 class="org.springframework.web.servlet.mvc.UrlFilenameViewController"/>

/index1/*：可以匹配/index1/demo，但不匹配/index1/demo/demo，如/index1/demo逻辑视图名为demo；

/index2/**：可以匹配/index2路径下的所有子路径，如匹配/index2/demo，或/index2/demo/demo，“/index2/demo”的逻辑视图名为demo，而“/index2/demo/demo”逻辑视图名为demo/demo；

/*.html：可以匹配如/abc.html，逻辑视图名为abc，后缀会被删除（不仅仅可以是html）；

/index3/*.html：可以匹配/index3/abc.html，逻辑视图名也是abc;

上述模式为Spring Web MVC使用的Ant-style 模式进行匹配的：

 

  1 
  2 ?    匹配一个字符，如/index? 可以匹配 /index1 ， 但不能匹配 /index 或 /index12
  3 *    匹配零个或多个字符，如/index1/*，可以匹配/index1/demo，但不匹配/index1/demo/demo
  4 **   匹配零个或多个路径，如/index2/**：可以匹配/index2路径下的所有子路径，如匹配/index2/demo，或/index2/demo/demo
  5 
  6 如果我有如下模式，那Spring该选择哪一个执行呢？当我的请求为“/long/long”时如下所示：
  7 /long/long
  8 /long/**/abc
  9 /long/**
 10 /**
 11 Spring的AbstractUrlHandlerMapping使用：最长匹配优先；
 12 如请求为“/long/long” 将匹配第一个“/long/long”，但请求“/long/acd” 则将匹配 “/long/**”，如请求“/long/aa/abc”则匹配“/long/**/abc”，如请求“/abc”则将匹配“/**”


UrlFilenameViewController还提供了如下属性：

prefix：生成逻辑视图名的前缀；

suffix：生成逻辑视图名的后缀；

  1 protected String postProcessViewName(String viewName) {
  2         return getPrefix() + viewName + getSuffix();
  3 }
  1 <bean name="/*.htm" class="org.springframework.web.servlet.mvc.UrlFilenameViewController">
  2         <property name="prefix" value="test"/>
  3         <property name="suffix" value="test"/>
  4 </bean>

当prefix=“test”，suffix=“test”，如上所示的/*.htm：可以匹配如/abc.htm，但逻辑视图名将变为testabctest。

4.15、MultiActionController

之前学过的控制器如AbstractCommandController、SimpleFormController等一般对应一个功能处理方法（如新增），如果我要实现比如最简单的用户增删改查（CRUD Create-Read-Update-Delete），那该怎么办呢？

4.15.1 解决方案

1、每一个功能对应一个控制器，如果是CRUD则需要四个控制器，但这样我们的控制器会暴增，肯定不可取；

2、使用spring Web MVC提供的MultiActionController，用于支持在一个控制器里添加多个功能处理方法，即将多个请求的处理方法放置到一个控制器里，这种方式不错。

4.15.2 问题

1、  MultiActionController如何将不同的请求映射不同的请求的功能处理方法呢？

Spring Web MVC提供了MethodNameResolver（方法名解析器）用于解析当前请求到需要执行的功能处理方法的方法名。默认使用InternalPathMethodNameResolver实现类，另外还提供了ParameterMethodNameResolver和PropertiesMethodNameResolver，当然我们也可以自己来实现，稍候我们仔细研究下它们是如何工作的。

2、那我们的功能处理方法应该怎么写呢？

public (ModelAndView | Map | String | void) actionName(HttpServletRequest request, HttpServletResponse response, [,HttpSession session] [,AnyObject]);

哦，原来如此，我们只需要按照如上格式写我们的功能处理方法即可；此处需要注意一下几点：

1、返回值：即模型和视图部分；

ModelAndView：模型和视图部分，之前已经见过了；

Map：只返回模型数据，逻辑视图名会根据RequestToViewNameTranslator实现类来计算，稍候讨论；

String：只返回逻辑视图名；

void：表示该功能方法直接写出response响应（如果其他返回值类型（如Map）返回null则和void进行相同的处理）；

2、actionName：功能方法名字；由methodNameResolver根据请求信息解析功能方法名，通过反射调用；

3、形参列表：顺序固定，“[]”表示可选，我们来看看几个示例吧：

  1 //表示到新增页面
  2 
  3 public ModelAndView toAdd(HttpServletRequest request, HttpServletResponse response);
  4 
  5 //表示新增表单提交，在最后可以带着命令对象
  6 
  7 public ModelAndView add(HttpServletRequest request, HttpServletResponse response, UserModel user);
  8 
  9 //列表，但只返回模型数据，视图名会通过RequestToViewNameTranslator实现来计算
 10 
 11 public Map list(HttpServletRequest request, HttpServletResponse response);
 12 
 13 //文件下载，返回值类型为void，表示该功能方法直接写响应
 14 
 15 public void fileDownload(HttpServletRequest request, HttpServletResponse response)
 16 
 17 //第三个参数可以是session
 18 
 19 public ModelAndView sessionWith(HttpServletRequest request, HttpServletResponse response, HttpSession session);
 20 
 21 //如果第三个参数是session，那么第四个可以是命令对象，顺序必须是如下顺序
 22 
 23 public void sessionAndCommandWith(HttpServletRequest request, HttpServletResponse response, HttpSession session, UserModel user)
 24

4、异常处理方法，MultiActionController提供了简单的异常处理，即在请求的功能处理过程中遇到异常会交给异常处理方法进行处理，式如下所示：

  1 public ModelAndView anyMeaningfulName(HttpServletRequest request, HttpServletResponse response, ExceptionClass exception)
  2 
  3 MultiActionController会使用最接近的异常类型来匹配对应的异常处理方法，示例如下所示：
  4 
  5 //处理PayException
  6 
  7 public ModelAndView processPayException(HttpServletRequest request, HttpServletResponse response, PayException ex)
  8 
  9 //处理Exception
 10 
 11 public ModelAndView processException(HttpServletRequest request, HttpServletResponse response,  Exception ex)
 12

4.15.3 MultiActionController类实现

类定义：public class MultiActionController extends AbstractController implements LastModified ，继承了AbstractController，并实现了LastModified接口，默认返回-1；

核心属性：

delegate：功能处理的委托对象，即我们要调用请求处理方法所在的对象，默认是this；

methodNameResolver：功能处理方法名解析器，即根据请求信息来解析需要执行的delegate的功能处理方法的方法名。

核心方法：

  1 //判断方法是否是功能处理方法
  2 private boolean isHandlerMethod(Method method) {
  3     //得到方法返回值类型
  4     Class returnType = method.getReturnType();
  5     //返回值类型必须是ModelAndView、Map、String、void中的一种，否则不是功能处理方法
  6     if (ModelAndView.class.equals(returnType) || Map.class.equals(returnType) || String.class.equals(returnType) ||
  7             void.class.equals(returnType)) {
  8         Class[] parameterTypes = method.getParameterTypes();
  9         //功能处理方法参数个数必须>=2，且第一个是HttpServletRequest类型、第二个是HttpServletResponse
 10         //且不能Controller接口的handleRequest(HttpServletRequest request, HttpServletResponse response)，这个方法是由系统调用
 11         return (parameterTypes.length >= 2 &&
 12                 HttpServletRequest.class.equals(parameterTypes[0]) &&
 13                 HttpServletResponse.class.equals(parameterTypes[1]) &&
 14                 !("handleRequest".equals(method.getName()) && parameterTypes.length == 2));
 15     }
 16     return false;
 17 }


  1 //是否是异常处理方法
  2 private boolean isExceptionHandlerMethod(Method method) {
  3     //异常处理方法必须是功能处理方法 且 参数长度为3、第三个参数类型是Throwable子类
  4     return (isHandlerMethod(method) &&
  5             method.getParameterTypes().length == 3 &&
  6             Throwable.class.isAssignableFrom(method.getParameterTypes()[2]));
  7 }
  8 
  9 
 10 
 11 
 12 
 13 
 14 private void registerHandlerMethods(Object delegate) {
 15     //缓存Map清空
 16     this.handlerMethodMap.clear();
 17     this.lastModifiedMethodMap.clear();
 18     this.exceptionHandlerMap.clear();
 19 
 20     //得到委托对象的所有public方法
 21     Method[] methods = delegate.getClass().getMethods();
 22     for (Method method : methods) {
 23         //验证是否是异常处理方法，如果是放入exceptionHandlerMap缓存map
 24         if (isExceptionHandlerMethod(method)) {
 25             registerExceptionHandlerMethod(method);
 26         }
 27         //验证是否是功能处理方法，如果是放入handlerMethodMap缓存map
 28         else if (isHandlerMethod(method)) {
 29             registerHandlerMethod(method);
 30             registerLastModifiedMethodIfExists(delegate, method);
 31         }
 32     }
 33 }
 34 
 35 
 36 
 37 
 38 
 39 protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response)
 40         throws Exception {
 41     try {
 42         //1、使用methodNameResolver 方法名解析器根据请求解析到要执行的功能方法的方法名
 43         String methodName = this.methodNameResolver.getHandlerMethodName(request);
 44         //2、调用功能方法（通过反射调用，此处就粘贴代码了）
 45         return invokeNamedMethod(methodName, request, response);
 46     }
 47     catch (NoSuchRequestHandlingMethodException ex) {
 48         return handleNoSuchRequestHandlingMethod(ex, request, response);
 49     }
 50 }
 51 
 52 
 53 
 54


接下来，我们看一下MultiActionController如何使用MethodNameResolver来解析请求到功能处理方法的方法名。

4.15.4 MethodNameResolver

1、InternalPathMethodNameResolver：MultiActionController的默认实现，提供从请求URL路径解析功能方法的方法名，从请求的最后一个路径（/）开始，并忽略扩展名；如请求URL是“/user/list.html”，则解析的功能处理方法名为“list”，即调用list方法。该解析器还可以指定前缀和后缀，通过prefix和suffix属性，如指定prefix=”test_”,则功能方法名将变为test_list；

2、ParameterMethodNameResolver：提供从请求参数解析功能处理方法的方法名，并按照如下顺序进行解析：

（1、 methodParamNames：根据请求的参数名解析功能方法名（功能方法名和参数名同名）；

  1 <property name="methodParamNames" value="list,create,update"/>

如上配置时，如果请求中含有参数名list、create、update时，则功能处理方法名为list、create、update，这种方式的可以在当一个表单有多个提交按钮时使用，不同的提交按钮名字不一样即可。

  ParameterMethodNameResolver也考虑到图片提交按钮提交问题：

    <input type="image" name="list"> 和submit类似可以提交表单，单击该图片后会发送两个参数“list.x=x轴坐标”和“list.y=y轴坐标”（如提交后会变为list.x=7&list.y=5）；因此我们配置的参数名（如list）在会加上“.x” 和 “.y”进行匹配。


  1 for (String suffix : SUBMIT_IMAGE_SUFFIXES)  {//SUBMIT_IMAGE_SUFFIXES {“.x”, “.y”}
  2     if (request.getParameter(name + suffix) != null) {// name是我们配置的methodParamNames
  3         return true;
  4     }
  5 }

（2、paramName：根据请求参数名的值解析功能方法名，默认的参数名是action，即请求的参数中含有“action=query”，则功能处理方法名为query；

（3、logicalMappings：逻辑功能方法名到真实功能方法名映射，如下所示：

  1 <property name="logicalMappings">
  2     <props>
  3         <prop key="doList">list</prop>
  4     </props>
  5 </property>


即如果步骤1或2解析出逻辑功能方法名为doList（逻辑的），将会被重新映射为list功能方法名（真正执行的）。

（4、defaultMethodName：默认的方法名，当以上策略失败时默认调用的方法名。

3、PropertiesMethodNameResolver：提供自定义的从请求URL解析功能方法的方法名，使用一组用户自定义的模式到功能方法名的映射，映射使用Properties对象存放，具体配置示例如下：

  1 <bean id="propertiesMethodNameResolver"
  2 class="org.springframework.web.servlet.mvc.multiaction.PropertiesMethodNameResolver">
  3     <property name="mappings">
  4         <props>
  5               <prop key="/create">create</prop>
  6               <prop key="/update">update</prop>
  7               <prop key="/delete">delete</prop>
  8               <prop key="/list">list</prop>
  9               <!-- 默认的行为 -->
 10               <prop key="/**">list</prop>
 11         </props>
 12     </property>
 13 </bean>

对于/create请求将调用create方法，Spring内部使用PathMatcher进行匹配（默认实现是AntPathMatcher）。

4.15.5 RequestToViewNameTranslator

用于直接将请求转换为逻辑视图名。默认实现为DefaultRequestToViewNameTranslator。

1、DefaultRequestToViewNameTranslator：将请求URL转换为逻辑视图名，默认规则如下：

  http://localhost:9080/web上下文/list -------> 逻辑视图名为list

  http://localhost:9080/web上下文/list.html -------> 逻辑视图名为list(默认删除扩展名)

  http://localhost:9080/web上下文/user/list.html -------> 逻辑视图名为user/list

4.15.6 示例

（1、控制器UserController

  1 package cn.javass.chapter4.web.controller;
  2 //省略import
  3 public class UserController extends MultiActionController {
  4     //用户服务类
  5     private UserService userService;
  6     //逻辑视图名 通过依赖注入方式注入，可配置
  7     private String createView;
  8     private String updateView;
  9     private String deleteView;
 10     private String listView;
 11     private String redirectToListView;
 12     //省略setter/getter
 13 
 14     public String create(HttpServletRequest request, HttpServletResponse response, UserModel user) {
 15         if("GET".equals(request.getMethod())) {
 16             //如果是get请求 我们转向 新增页面
 17             return getCreateView();
 18         }
 19         userService.create(user);
 20         //直接重定向到列表页面
 21         return getRedirectToListView();
 22     }
 23     public ModelAndView update(HttpServletRequest request, HttpServletResponse response, UserModel user) {
 24         if("GET".equals(request.getMethod())) {
 25             //如果是get请求 我们转向更新页面
 26             ModelAndView mv = new ModelAndView();
 27             //查询要更新的数据
 28             mv.addObject("command", userService.get(user.getUsername()));
 29             mv.setViewName(getUpdateView());
 30             return mv;
 31         }
 32         userService.update(user);
 33         //直接重定向到列表页面
 34         return new ModelAndView(getRedirectToListView());
 35     }
 36 
 37     public ModelAndView delete(HttpServletRequest request, HttpServletResponse response, UserModel user) {
 38         if("GET".equals(request.getMethod())) {
 39             //如果是get请求 我们转向删除页面
 40             ModelAndView mv = new ModelAndView();
 41             //查询要删除的数据
 42             mv.addObject("command", userService.get(user.getUsername()));
 43             mv.setViewName(getDeleteView());
 44             return mv;
 45         }
 46         userService.delete(user);
 47         //直接重定向到列表页面
 48         return new ModelAndView(getRedirectToListView());
 49     }
 50 
 51     public ModelAndView list(HttpServletRequest request, HttpServletResponse response) {
 52         ModelAndView mv = new ModelAndView();
 53         mv.addObject("userList", userService.list());
 54         mv.setViewName(getListView());
 55         return mv;
 56     }
 57 
 58     //如果使用委托方式，命令对象名称只能是command
 59     protected String getCommandName(Object command) {
 60         //命令对象的名字 默认command
 61         return "command";
 62     }
 63 }

增删改：如果是GET请求方法，则表示到展示页面，POST请求方法表示真正的功能操作；

  getCommandName：表示是命令对象名字，默认command，对于委托对象实现方式无法改变，因此我们就使用默认的吧。

（2、spring配置文件chapter4-servlet.xml

  1 <bean id="userService" class="cn.javass.chapter4.service.UserService"/>
  2 <bean name="/user/**" class="cn.javass.chapter4.web.controller.UserController">
  3     <property name="userService" ref="userService"/>
  4     <property name="createView" value="user/create"/>
  5     <property name="updateView" value="user/update"/>
  6     <property name="deleteView" value="user/delete"/>
  7     <property name="listView" value="user/list"/>
  8     <property name="redirectToListView" value="redirect:/user/list"/>
  9     <!-- 使用PropertiesMethodNameResolver来解析功能处理方法名 -->
 10     <!--property name="methodNameResolver" ref="propertiesMethodNameResolver"/-->
 11 </bean>


userService：用户服务类，实现业务逻辑；

依赖注入：对于逻辑视图页面通过依赖注入方式注入，redirectToListView表示增删改成功后重定向的页面，防止重复表单提交；

默认使用InternalPathMethodNameResolver解析请求URL到功能方法名。

（3、视图页面

（3.1、list页面（WEB-INF/jsp/user/list.jsp）

  1 <a href="${pageContext.request.contextPath}/user/create">用户新增</a>
  2 <table border="1" width="50%">
  3    <tr>
  4       <th>用户名</th>
  5       <th>真实姓名</th>
  6       <th>操作</th>
  7    </tr>
  8    <c:forEach items="${userList}" var="user">
  9    <tr>
 10       <td>${user.username }</td>
 11       <td>${user.realname }</td>
 12       <td>
 13           <a href="${pageContext.request.contextPath}/user/update?username=${user.username}">更新</a>
 14           |
 15           <a href="${pageContext.request.contextPath}/user/delete?username=${user.username}">删除</a>
 16       </td>
 17    </tr>
 18    </c:forEach>
 19 </table>


（3.2、update页面（WEB-INF/jsp/user/update.jsp）

  1 <form action="${pageContext.request.contextPath}/user/update" method="post">
  2 用户名： <input type="text" name="username" value="${command.username}"/>
  3 真实姓名：<input type="text" name="realname" value="${command.realname}"/>
  4 <input type="submit" value="更新"/>
  5 </form>


（4、测试：

默认的InternalPathMethodNameResolver将进行如下解析：

http://localhost:9080/springmvc-chapter4/user/list————>list方法名；

http://localhost:9080/springmvc-chapter4/user/create————>create方法名；

http://localhost:9080/springmvc-chapter4/user/update————>update功能处理方法名；

http://localhost:9080/springmvc-chapter4/user/delete————>delete功能处理方法名。

我们可以将默认的InternalPathMethodNameResolver改为PropertiesMethodNameResolver：

  1 <bean id="propertiesMethodNameResolver"
  2 class="org.springframework.web.servlet.mvc.multiaction.PropertiesMethodNameResolver">
  3     <property name="mappings">
  4         <props>
  5               <prop key="/user/create">create</prop>
  6               <prop key="<span style="font-size: 1em; line-height: 1.5;">/user/</span><span style="font-size: 1em; line-height: 1.5;">update">update</prop></span>
  7               <prop key="<span style="font-size: 1em; line-height: 1.5;">/user/</span><span style="font-size: 1em; line-height: 1.5;">delete">delete</prop></span>
  8               <prop key="<span style="font-size: 1em; line-height: 1.5;">/user/</span><span style="font-size: 1em; line-height: 1.5;">list">list</prop></span>
  9               <prop key="/**">list</prop><!-- 默认的行为 -->
 10           </props>
 11     </property>
 12     <property name="alwaysUseFullPath" value="false"/><!-- 不使用全路径 -->
 13 </bean>
 14 <bean name="/user/**" class="cn.javass.chapter4.web.controller.UserController">
 15        <!—省略其他配置，详见配置文件-->
 16        <!-- 使用PropertiesMethodNameResolver来解析功能处理方法名 -->
 17        <property name="methodNameResolver" ref="propertiesMethodNameResolver"/>
 18 </bean>

/**表示默认解析到list功能处理方法。

如上配置方式可以很好的工作，但必须继承MultiActionController，Spring Web MVC提供给我们无需继承MultiActionController实现方式，即使有委托对象方式，继续往下看吧。

4.15.7、委托方式实现

（1、控制器UserDelegate

   将UserController复制一份，改名为UserDelegate，并把继承MultiActionController去掉即可，其他无需改变。

（2、spring配置文件chapter4-servlet.xml 

  1 <!—委托对象-->
  2 <bean id="userDelegate" class="cn.javass.chapter4.web.controller.UserDelegate">
  3    <property name="userService" ref="userService"/>
  4    <property name="createView" value="user2/create"/>
  5    <property name="updateView" value="user2/update"/>
  6    <property name="deleteView" value="user2/delete"/>
  7    <property name="listView" value="user2/list"/>
  8    <property name="redirectToListView" value="redirect:/user2/list"/>
  9 </bean>
 10 <!—控制器对象-->
 11 <bean name="/user2/**"
 12 class="org.springframework.web.servlet.mvc.multiaction.MultiActionController">
 13 <property name="delegate" ref="userDelegate"/>
 14     <property name="methodNameResolver" ref="parameterMethodNameResolver"/>
 15 </bean>

delegate：控制器对象通过delegate属性指定委托对象，即实际调用delegate委托对象的功能方法。

methodNameResolver：此处我们使用ParameterMethodNameResolver解析器；

  1 <!—ParameterMethodNameResolver -->
  2 <bean id="parameterMethodNameResolver"
  3 class="org.springframework.web.servlet.mvc.multiaction.ParameterMethodNameResolver">
  4 <!-- 1、根据请求参数名解析功能方法名 -->
  5     <property name="methodParamNames" value="create,update,delete"/>
  6     <!-- 2、根据请求参数名的值解析功能方法名 -->
  7     <property name="paramName" value="action"/>
  8 <!-- 3、逻辑方法名到真实方法名的映射 -->
  9     <property name="logicalMappings">
 10        <props>
 11            <prop key="doList">list</prop>
 12        </props>
 13     </property>
 14     <!—4、默认执行的功能处理方法 -->
 15     <property name="defaultMethodName" value="list"/>
 16 </bean>



1、methodParamNames：create,update,delete，当请求中有参数名为这三个的将被映射为功能方法名，如“<input type=”submit” name=”create” value=”新增”/>”提交后解析得到的功能方法名为create;

2、paramName：当请求中有参数名为action，则将值映射为功能方法名，如“<input type=”hidden”name=”action” value=”delete”/>”，提交后解析得到的功能方法名为delete；

3、logicalMappings：逻辑功能方法名到真实功能方法名的映射，如：

http://localhost:9080/springmvc-chapter4/user2?action=doList；

    首先请求参数“action=doList”，则第二步解析得到逻辑功能方法名为doList；

    本步骤会把doList再转换为真实的功能方法名list。

4、defaultMethodName：以上步骤如果没有解析到功能处理方法名，默认执行的方法名。

（3、视图页面

（3.1、list页面（WEB-INF/jsp/user2/list.jsp）

  1 <a href="${pageContext.request.contextPath}/user2?action=create">用户新增</a>
  2 <table border="1" width="50%">
  3    <tr>
  4       <th>用户名</th>
  5       <th>真实姓名</th>
  6       <th>操作</th>
  7    </tr>
  8    <c:forEach items="${userList}" var="user">
  9    <tr>
 10       <td>${user.username }</td>
 11       <td>${user.realname }</td>
 12       <td>
 13           <a href="${pageContext.request.contextPath}/user2?action=update&username=${user.username}">更新</a>
 14           |
 15           <a href="${pageContext.request.contextPath}/user2?action=delete&username=${user.username}">删除</a>
 16       </td>
 17    </tr>
 18    </c:forEach>
 19 </table>

（3.2、update页面（WEB-INF/jsp/user2/update.jsp）

  1 <form action="${pageContext.request.contextPath}/user2" method="post">
  2 <input type="hidden" name="action" value="update"/>
  3 用户名： <input type="text" name="username" value="${command.username}"/>
  4 真实姓名：<input type="text" name="realname" value="${command.realname}"/>
  5 <input type="submit" value="更新"/>
  6 </form>


通过参数name=“action” value=“update”来指定要执行的功能方法名update。

（3.3、create页面（WEB-INF/jsp/user2/create.jsp）

  1 <form action="${pageContext.request.contextPath}/user2" method="post">
  2 用户名： <input type="text" name="username" value="${command.username}"/>
  3 真实姓名：<input type="text" name="realname" value="${command.realname}"/>
  4 <input type="submit" name="create" value="新增"/>
  5 </form>

（4、测试：

使用ParameterMethodNameResolver将进行如下解析：

http://localhost:9080/springmvc-chapter4/user2?create      ————>create功能处理方法名（参数名映射）；

http://localhost:9080/springmvc-chapter4/user2?action=create————>create功能处理方法名（参数值映射）；

http://localhost:9080/springmvc-chapter4/user2?update      ————>update功能处理方法名；

http://localhost:9080/springmvc-chapter4/user2?action=update————>update功能处理方法名；

http://localhost:9080/springmvc-chapter4/user2?delete      ————>delete功能处理方法名；

http://localhost:9080/springmvc-chapter4/user2?action=delete————>delete功能处理方法名；

http://localhost:9080/springmvc-chapter4/user2?doList      ————>通过logicalMappings解析为list功能处理方法。

http://localhost:9080/springmvc-chapter4/user2?action=doList————>通过logicalMappings解析为list功能处理方法。

http://localhost:9080/springmvc-chapter4/user2————>默认的功能处理方法名list（默认）。



4.16、数据类型转换和数据验证

a633b31a42f0224c9bf66cd3cc886e04__2


流程：

1、首先创建数据绑定器，在此此会创建ServletRequestDataBinder类的对象，并设置messageCodesResolver（错误码解析器）；

2、提供第一个扩展点，初始化数据绑定器，在此处我们可以覆盖该方法注册自定义的PropertyEditor（请求参数——>命令对象属性的转换）；

3、进行数据绑定，即请求参数——>命令对象的绑定；

4、提供第二个扩展点，数据绑定完成后的扩展点，此处可以实现一些自定义的绑定动作；

5、验证器对象的验证，验证器通过validators注入，如果验证失败，需要把错误信息放入Errors（此处使用BindException实现）；

6、提供第三个扩展点，此处可以实现自定义的绑定/验证逻辑；

7、将errors传入功能处理方法进行处理，功能方法应该判断该错误对象是否有错误进行相应的处理。

4.16.1、数据类型转换

请求参数（String）——>命令对象属性（可能是任意类型）的类型转换，即数据绑定时的类型转换，使用PropertyEditor实现绑定时的类型转换。

一、spring内建的PropertyEditor如下所示：

image

二、Spring内建的PropertyEditor支持的属性（符合JavaBean规范）操作：


image

三、示例：

接下来我们写自定义的属性编辑器进行数据绑定：

（1、模型对象：

  1 package cn.javass.chapter4.model;
  2 //省略import
  3 public class DataBinderTestModel {
  4     private String username;
  5     private boolean bool;//Boolean值测试
  6     private SchoolInfoModel schooInfo;
  7     private List hobbyList;//集合测试，此处可以改为数组/Set进行测试
  8     private Map map;//Map测试
  9     private PhoneNumberModel phoneNumber;//String->自定义对象的转换测试
 10     private Date date;//日期类型测试
 11     private UserState state;//String——>Enum类型转换测试
 12     //省略getter/setter
 13 }
 14 
 15 package cn.javass.chapter4.model;
 16 //如格式010-12345678
 17 public class PhoneNumberModel {
 18     private String areaCode;//区号
 19     private String phoneNumber;//电话号码
 20     //省略getter/setter
 21 }

(2、PhoneNumber属性编辑器

前台输入如010-12345678自动转换为PhoneNumberModel。

  1 package cn.javass.chapter4.web.controller.support.editor;
  2 //省略import
  3 public class PhoneNumberEditor extends PropertyEditorSupport {
  4     Pattern pattern = Pattern.compile("^(\\d{3,4})-(\\d{7,8})$");
  5     @Override
  6     public void setAsText(String text) throws IllegalArgumentException {
  7         if(text == null || !StringUtils.hasLength(text)) {
  8             setValue(null); //如果没值，设值为null
  9         }
 10         Matcher matcher = pattern.matcher(text);
 11         if(matcher.matches()) {
 12             PhoneNumberModel phoneNumber = new PhoneNumberModel();
 13             phoneNumber.setAreaCode(matcher.group(1));
 14             phoneNumber.setPhoneNumber(matcher.group(2));
 15             setValue(phoneNumber);
 16         } else {
 17             throw new IllegalArgumentException(String.format("类型转换失败，需要格式[010-12345678]，但格式是[%s]", text));
 18         }
 19     }
 20     @Override
 21     public String getAsText() {
 22         PhoneNumberModel phoneNumber = ((PhoneNumberModel)getValue());
 23         return phoneNumber == null ? "" : phoneNumber.getAreaCode() + "-" + phoneNumber.getPhoneNumber();
 24     }
 25 }
 26

PropertyEditorSupport：一个PropertyEditor的支持类；

setAsText：表示将String——>PhoneNumberModel，根据正则表达式进行转换，如果转换失败抛出异常，则接下来的验证器会进行验证处理；

getAsText：表示将PhoneNumberModel——>String。

（3、控制器

需要在控制器注册我们自定义的属性编辑器。

此处我们使用AbstractCommandController，因为它继承了BaseCommandController，拥有绑定流程。

  1 package cn.javass.chapter4.web.controller;
  2 //省略import
  3 public class DataBinderTestController extends AbstractCommandController {
  4     public DataBinderTestController() {
  5         setCommandClass(DataBinderTestModel.class); //设置命令对象
  6         setCommandName("dataBinderTest");//设置命令对象的名字
  7     }
  8     @Override
  9     protected ModelAndView handle(HttpServletRequest req, HttpServletResponse resp, Object command, BindException errors) throws Exception {
 10         //输出command对象看看是否绑定正确
 11         System.out.println(command);
 12         return new ModelAndView("bindAndValidate/success").addObject("dataBinderTest", command);
 13     }
 14     @Override
 15     protected void initBinder(HttpServletRequest request, ServletRequestDataBinder binder) throws Exception {
 16         super.initBinder(request, binder);
 17         //注册自定义的属性编辑器
 18         //1、日期
 19         DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 20         CustomDateEditor dateEditor = new CustomDateEditor(df, true);
 21         //表示如果命令对象有Date类型的属性，将使用该属性编辑器进行类型转换
 22         binder.registerCustomEditor(Date.class, dateEditor);
 23         //自定义的电话号码编辑器
 24         binder.registerCustomEditor(PhoneNumberModel.class, new PhoneNumberEditor());
 25     }
 26 }


initBinder:第一个扩展点，初始化数据绑定器，在此处我们注册了两个属性编辑器；

CustomDateEditor：自定义的日期编辑器，用于在String<——>日期之间转换；

binder.registerCustomEditor(Date.class, dateEditor)：表示如果命令对象是Date类型，则使用dateEditor进行类型转换；

PhoneNumberEditor：自定义的电话号码属性编辑器用于在String<——> PhoneNumberModel之间转换；

binder.registerCustomEditor(PhoneNumberModel.class, newPhoneNumberEditor())：表示如果命令对象是PhoneNumberModel类型，则使用PhoneNumberEditor进行类型转换；

（4、spring配置文件chapter4-servlet.xml

  1 <bean name="/dataBind"
  2 class="cn.javass.chapter4.web.controller.DataBinderTestController"/>


（5、视图页面（WEB-INF/jsp/bindAndValidate/success.jsp）

  1 EL phoneNumber:${dataBinderTest.phoneNumber}
  2 EL state:${dataBinderTest.state}
  3 EL date:${dataBinderTest.date}

视图页面的数据没有预期被格式化，如何进行格式化显示呢？请参考【第七章  注解式控制器的数据验证、类型转换及格式化】。

（6、测试：

1、在浏览器地址栏输入请求的URL，如

http://localhost:9080/springmvc-chapter4/dataBind?username=zhang&bool=yes&schooInfo.specialty=computer&hobbyList[0]=program&hobbyList[1]=music&map[key1]=value1&map[key2]=value2&phoneNumber=010-12345678&date=2012-3-18 16:48:48&state=blocked

2、控制器输出的内容：

DataBinderTestModel [username=zhang, bool=true, schooInfo=SchoolInfoModel [schoolType=null, schoolName=null, specialty=computer], hobbyList=[program, music], map={key1=value1, key2=value2}, phoneNumber=PhoneNumberModel [areaCode=010, phoneNumber=12345678], date=Sun Mar 18 16:48:48 CST 2012, state=锁定]

类型转换如图所示：

a633b31a42f0224c9bf66cd3cc886e04__2


四、注册PropertyEditor

1、使用WebDataBinder进行控制器级别注册PropertyEditor（控制器独享）

如“【三、示例】”中所使用的方式，使用WebDataBinder注册控制器级别的PropertyEditor，这种方式注册的PropertyEditor只对当前控制器独享，即其他的控制器不会自动注册这个PropertyEditor，如果需要还需要再注册一下。

2、使用WebBindingInitializer批量注册PropertyEditor

如果想在多个控制器同时注册多个相同的PropertyEditor时，可以考虑使用WebBindingInitializer。

示例：

（1、实现WebBindingInitializer

  1 package cn.javass.chapter4.web.controller.support.initializer;
  2 //省略import
  3 public class MyWebBindingInitializer implements WebBindingInitializer {
  4     @Override
  5     public void initBinder(WebDataBinder binder, WebRequest request) {
  6         //注册自定义的属性编辑器
  7         //1、日期
  8         DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  9         CustomDateEditor dateEditor = new CustomDateEditor(df, true);
 10         //表示如果命令对象有Date类型的属性，将使用该属性编辑器进行类型转换
 11         binder.registerCustomEditor(Date.class, dateEditor);
 12         //自定义的电话号码编辑器
 13         binder.registerCustomEditor(PhoneNumberModel.class, new PhoneNumberEditor());
 14     }
 15 }

通过实现WebBindingInitializer并通过binder注册多个PropertyEditor。

（2、修改【三、示例】中的DataBinderTestController，注释掉initBinder方法；

（3、修改chapter4-servlet.xml配置文件：

  1 <!-- 注册WebBindingInitializer实现 -->
  2 <bean id="myWebBindingInitializer" class="cn.javass.chapter4.web.controller.support.initializer.MyWebBindingInitializer"/>
  3 <bean name="/dataBind" class="cn.javass.chapter4.web.controller.DataBinderTestController">
  4     <!-- 注入WebBindingInitializer实现 -->
  5     <property name="webBindingInitializer" ref="myWebBindingInitializer"/>
  6 </bean>


（4、尝试访问“【三、示例】”中的测试URL即可成功。

使用WebBindingInitializer的好处是当你需要在多个控制器中需要同时使用多个相同的PropertyEditor可以在WebBindingInitializer实现中注册，这样只需要在控制器中注入WebBindingInitializer即可注入多个PropertyEditor。

3、全局级别注册PropertyEditor（全局共享）

只需要将我们自定义的PropertyEditor放在和你的模型类同包下即可，且你的Editor命名规则必须是“模型类名Editor”，这样Spring会自动使用标准JavaBean架构进行自动识别，如图所示：

a633b31a42f0224c9bf66cd3cc886e04__2

此时我们把“DataBinderTestController”的“binder.registerCustomEditor(PhoneNumberModel.class, new PhoneNumberEditor());”注释掉，再尝试访问“【三、示例】”中的测试URL即可成功。

这种方式不仅仅在使用Spring时可用，在标准的JavaBean等环境都是可用的，可以认为是全局共享的（不仅仅是Spring环境）。

PropertyEditor被限制为只能String<——>Object之间转换，不能Object<——>Object，Spring3提供了更强大的类型转换（TypeConversion）支持，它可以在任意对象之间进行类型转换，不仅仅是String<——>Object。


4.16.2、数据验证

1、数据绑定失败：比如需要数字却输入了字母；

2、数据不合法：可以认为是业务错误，通过自定义验证器验证，如用户名长度必须在5-20之间，我们却输入了100个字符等；

3、错误对象：当我们数据绑定失败或验证失败后，错误信息存放的对象，我们叫错误对象，在spring Web MVC中Errors是具体的代表者；线程不安全对象；

4、错误消息：是硬编码，还是可配置？实际工作应该使用配置方式，我们只是把错误码（errorCode）放入错误对象，在展示时读取相应的错误消息配置文件来获取要显示的错误消息(errorMessage)；

4.16.2.1、验证流程

a633b31a42f0224c9bf66cd3cc886e04__2

1、首先进行数据绑定验证，如果验证失败会通过MessageCodesResolver生成错误码放入Errors错误对象；

2、数据不合法验证，通过自定义的验证器验证，如果失败需要手动将错误码放入Errors错误对象；

4.16.2.2、错误对象和错误消息

错误对象的代表者是Errors接口，并且提供了几个实现者，在Spring Web MVC中我们使用的是如下实现：


a633b31a42f0224c9bf66cd3cc886e04__2

相关的错误方法如下：

Errors：存储和暴露关于数据绑定错误和验证错误相关信息的接口，提供了相关存储和获取错误消息的方法：

 

  1 package org.springframework.validation;
  2 public interface Errors {
  3   //=========================全局错误消息（验证/绑定对象全局的）=============================
  4   //注册一个全局的错误码（）
  5   void reject(String errorCode);
  6   //注册一个全局的错误码，当根据errorCode没有找到相应错误消息时，使用defaultMessage作为错误消息
  7   void reject(String errorCode, String defaultMessage);
  8   //注册一个全局的错误码，当根据errorCode没有找到相应错误消息时（带错误参数的），使用defaultMessage作为错误消息
  9   void reject(String errorCode, Object[] errorArgs, String defaultMessage);
 10   //=========================全局错误消息（验证/绑定整个对象的）=============================
 11   //=========================局部错误消息（验证/绑定对象字段的）=============================
 12   //注册一个对象字段的错误码，field指定验证失败的字段名
 13   void rejectValue(String field, String errorCode);
 14   void rejectValue(String field, String errorCode, String defaultMessage);
 15   void rejectValue(String field, String errorCode, Object[] errorArgs, String defaultMessage);
 16   //=========================局部错误消息（验证/绑定对象字段的）=============================
 17   boolean hasErrors();      ////是否有错误
 18   boolean hasGlobalErrors(); //是否有全局错误
 19   boolean hasFieldErrors();  //是否有字段错误
 20   Object getFieldValue(String field); //返回当前验证通过的值，或验证失败时失败的值；
 21 }

getFieldValue：可以得到验证失败的失败值，这是其他Web层框架很少支持的，这样就可以给用户展示出错时的值（而不是空或其他的默认值等）。

BindingResult：代表数据绑定的结果，继承了Errors接口。

BindException：代表数据绑定的异常，它继承Exception，并实现了BindingResult，这是内部使用的错误对象。

示例：

（1、控制器

  1 package cn.javass.chapter4.web.controller;
  2 //省略import
  3 public class ErrorController extends AbstractCommandController {
  4        public ErrorController() {
  5               setCommandClass(DataBinderTestModel.class);
  6               setCommandName("command");
  7        }
  8        @Override
  9        protected ModelAndView handle(HttpServletRequest req, HttpServletResponse resp, Object command, BindException errors) throws Exception {
 10               //表示用户名不为空
 11               errors.reject("username.not.empty");
 12               //带有默认错误消息
 13               errors.reject("username.not.empty1", "用户名不能为空1");
 14               //带有参数和默认错误消息        
 15               errors.reject("username.length.error", new Object[]{5, 10});
 16 
 17               //得到错误相关的模型数据
 18               Map model = errors.getModel();
 19               return new ModelAndView("bindAndValidate/error", model);
 20        }
 21 }



errors.reject(“username.not.empty”)：注册全局错误码“username.not.empty”，我们必须提供messageSource来提供错误码“username.not.empty”对应的错误信息（如果没有会抛出NoSuchMessageException异常）；

errors.reject(“username.not.empty1″, “用户名不能为空1″)：注册全局错误码“username.not.empty1”，如果从messageSource没没有找到错误码“username.not.empty1”对应的错误信息，则将显示默认消息“用户名不能为空1”；

errors.reject(“username.length.error”, new Object[]{5, 10})：错误码为“username.length.error”，而且错误信息需要两个参数，如我们在我们的配置文件中定义“用户名长度不合法，长度必须在{0}到{1}之间”，则实际的错误消息为“用户名长度不合法，长度必须在5到10之间”

errors.getModel()：当有错误信息时，一定将errors.getModel()放入我们要返回的ModelAndView中，以便使用里边的错误对象来显示错误信息。

（2、spring配置文件chapter4-servlet.xml

  1 <bean id="messageSource"
  2        class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
  3     <property name="basename" value="classpath:messages"/>
  4     <property name="fileEncodings" value="utf-8"/>
  5     <property name="cacheSeconds" value="120"/>
  6 </bean>
  7 
  8 <bean name="/error" class="cn.javass.chapter4.web.controller.ErrorController"/>

messageSource：用于获取错误码对应的错误消息的，而且bean名字默认必须是messageSource。

messages.properties（需要执行NativeToAscii）

  1 username.not.empty=用户名不能为空
  2 username.length.error=用户名长度不合法，长度必须在{0}到{1}之间

（3、视图页面（WEB-INF/jsp/bindAndValidate/error.jsp）

  1 <%@taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
  2 <!-- 表单的默认命令对象名为command -->
  3 <form:form commandName="command">
  4     <form:errors path="*"></form:errors>
  5 </form:form>



form标签库：此处我们使用了spring的form标签库；

<form:form commandName=”command”>:表示我们的表单标签，commandName表示绑定的命令对象名字，默认为command；

<form:errors path=”*”></form:errors>：表示显示错误信息的标签，如果path为“*”表示显示所有错误信息。

接下来我们来看一下 数据绑定失败和数据不合法时，如何处理。

4.16.2.3、数据绑定失败

如我们的DataBinderTestModel类：

bool：boolean类型，此时如果我们前台传入非兼容的数据，则会数据绑定失败；

date：Date类型，此时如果我们前台传入非兼容的数据，同样会数据绑定失败；

phoneNumber：自定义的PhoneNumberModel类型，如果如果我们前台传入非兼容的数据，同样会数据绑定失败。

示例：

（1、控制器，DataBinderErrorTestController。


  1 package cn.javass.chapter4.web.controller;
  2 //省略import
  3 public class DataBinderErrorTestController extends SimpleFormController {
  4        public DataBinderErrorTestController() {
  5               setCommandClass(DataBinderTestModel.class);
  6               setCommandName("dataBinderTest");
  7        }
  8        @Override
  9        protected ModelAndView showForm(HttpServletRequest request, HttpServletResponse response, BindException errors) throws Exception {
 10               //如果表单提交有任何错误都会再回到表单展示页面
 11               System.out.println(errors);
 12               return super.showForm(request, response, errors);
 13        }
 14        @Override
 15        protected void doSubmitAction(Object command) throws Exception {
 16               System.out.println(command); //表单提交成功（数据绑定成功）进行功能处理
 17     }
 18        @Override
 19        protected void initBinder(HttpServletRequest request, ServletRequestDataBinder binder) throws Exception {
 20               super.initBinder(request, binder);
 21               //注册自定义的属性编辑器
 22               //1、日期
 23               DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 24               CustomDateEditor dateEditor = new CustomDateEditor(df, true);
 25               //表示如果命令对象有Date类型的属性，将使用该属性编辑器进行类型转换
 26               binder.registerCustomEditor(Date.class, dateEditor);
 27 
 28               //自定义的电话号码编辑器
 29               binder.registerCustomEditor(PhoneNumberModel.class, new PhoneNumberEditor());
 30        }
 31 }

此处我们使用SimpleFormController；

showForm：展示表单，当提交表单有任何数据绑定错误会再回到该方法进行表单输入（在此处我们打印错误对象）；

doSubmitAction：表单提交成功，只要当表单的数据到命令对象绑定成功时，才会执行；

（2、spring配置文件chapter4-servlet.xml

  1 <bean name="/dataBindError"
  2 class="cn.javass.chapter4.web.controller.DataBinderErrorTestController">
  3    <property name="formView" value="bindAndValidate/input"/>
  4    <property name="successView" value="bindAndValidate/success"/>
  5 </bean>

（3、视图页面（WEB-INF/jsp/bindAndValidate/ input.jsp）

  1 <%@ page language="java" contentType="text/html; charset=UTF-8"   pageEncoding="UTF-8"%>
  2 <%@taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
  3 <!-- 表单的命令对象名为dataBinderTest -->
  4 <form:form commandName="dataBinderTest">
  5     <form:errors path="*" cssStyle="color:red"></form:errors>
  6     bool:<form:input path="bool"/>
  7     phoneNumber:<form:input path="phoneNumber"/>
  8     date:<form:input path="date"/>
  9     <input type="submit" value="提交"/>
 10 </form:form>

此处一定要使用form标签库，借此我们可以看到它的强大支持（别的大部分Web框架所不具备的，展示用户验证失败的数据）。

<form:form commandName=“dataBinderTest”>：指定命令对象为dataBinderTest，默认command；

<form:errors path=“*” cssStyle=“color:red”></form:errors>：显示错误消息，当提交表单有错误时展示错误消息（数据绑定错误/数据不合法）；

<form:input path=“bool”/>：等价于（<input type=’text’>），但会从命令对象中取出bool属性进行填充value属性，或如果表单提交有错误会从错误对象取出之前的错误数据（而非空或默认值）；

<input type=“submit” value=“提交“/>：spring没有提供相应的提交按钮，因此需要使用html的。

（4、测试

在地址栏输入如下地址：http://localhost:9080/springmvc-chapter4/dataBindError

image

全部是错误数据，即不能绑定到我们的命令对象；

当提交表单后，我们又回到表单输入页面，而且输出了一堆错误信息

a633b31a42f0224c9bf66cd3cc886e04__2

1、错误消息不可读；

2、表单元素可以显示之前的错误的数据，而不是默认值/空；

（5、问题

这里最大的问题是不可读的错误消息，如何让这些错误消息可读呢？

首先我们看我们的showForm方法里输出的“errors”错误对象信息：


  1 org.springframework.validation.BindException: org.springframework.validation.BeanPropertyBindingResult: 3 errors
  2 
  3 Field error in object 'dataBinderTest' on field 'bool': rejected value [www]; codes [typeMismatch.dataBinderTest.bool,typeMismatch.bool,typeMismatch.boolean,typeMismatch]; arguments [org.springframework.context.support.DefaultMessageSourceResolvable: codes [dataBinderTest.bool,bool]; arguments []; default message [bool]]; default message [Failed to convert property value of type 'java.lang.String' to required type 'boolean' for property 'bool'; nested exception is java.lang.IllegalArgumentException: Invalid boolean value [www]]
  4 
  5 Field error in object 'dataBinderTest' on field 'date': rejected value [123]; codes [typeMismatch.dataBinderTest.date,typeMismatch.date,typeMismatch.java.util.Date,typeMismatch]; arguments [org.springframework.context.support.DefaultMessageSourceResolvable: codes [dataBinderTest.date,date]; arguments []; default message [date]]; default message [Failed to convert property value of type 'java.lang.String' to required type 'java.util.Date' for property 'date'; nested exception is java.lang.IllegalArgumentException: Could not parse date: Unparseable date: "123"]
  6 
  7 Field error in object 'dataBinderTest' on field 'phoneNumber': rejected value [123]; codes [typeMismatch.dataBinderTest.phoneNumber,typeMismatch.phoneNumber,typeMismatch.cn.javass.chapter4.model.PhoneNumberModel,typeMismatch]; arguments [org.springframework.context.support.DefaultMessageSourceResolvable: codes [dataBinderTest.phoneNumber,phoneNumber]; arguments []; default message [phoneNumber]]; default message [Failed to convert property value of type 'java.lang.String' to required type 'cn.javass.chapter4.model.PhoneNumberModel' for property 'phoneNumber'; nested exception is java.lang.IllegalArgumentException: 类型转换失败，需要格式[010-12345678]，但格式是[123]]


数据绑定失败（类型不匹配）会自动生成如下错误码（错误码对应的错误消息按照如下顺序依次查找）：

1、typeMismatch.命令对象名.属性名

2、typeMismatch.属性名

3、typeMismatch.属性全限定类名（包名.类名）

4、typeMismatch

⊙内部使用MessageCodesResolver解析数据绑定错误到错误码，默认DefaultMessageCodesResolver，因此想要详细了解如何解析请看其javadoc；

⊙建议使用第1个进行错误码的配置。

因此修改我们的messages.properties添加如下错误消息（需要执行NativeToAscii）：

  1 typeMismatch.dataBinderTest.date=您输入的数据格式错误，请重新输入（格式：2012-03-19 22:17:17）
  2 #typeMismatch.date=2
  3 #typeMismatch.java.util.Date=3
  4 #typeMismatch=4

a633b31a42f0224c9bf66cd3cc886e04__2


到此，数据绑定错误我们介绍完了，接下来我们再看一下数据不合法错误。

4.16.2.4、数据不合法

1、比如用户名长度必须在5-20之间，而且必须以字母开头，可包含字母、数字、下划线；

2、比如注册用户时 用户名已经存在或邮箱已经存在等；

3、比如去一些论坛经常会发现，您发的帖子中包含×××屏蔽关键字等。

还有很多数据不合法的场景，在此就不罗列了，对于数据不合法，Spring Web MVC提供了两种验证方式：

◆编程式验证器验证

◆声明式验证

先从编程式验证器开始吧。

4.16.2.4.1、编程式验证器

一、验证器接口

  1 package org.springframework.validation;
  2 public interface Validator {
  3 boolean supports(Class<?> clazz);
  4 void validate(Object target, Errors errors);
  5 }


Validator接口：验证器，编程实现数据验证的接口；

supports方法：当前验证器是否支持指定的clazz验证，如果支持返回true即可；

validate方法：验证的具体方法，target参数表示要验证的目标对象（如命令对象），errors表示验证出错后存放错误信息的错误对象。

示例：

（1、验证器实现

  1 package cn.javass.chapter4.web.controller.support.validator;
  2 //省略import
  3 public class UserModelValidator implements Validator {
  4     private static final Pattern USERNAME_PATTERN = Pattern.compile("[a-zA-Z]\\w{4,19}");
  5     private static final Pattern PASSWORD_PATTERN = Pattern.compile("[a-zA-Z0-9]{5,20}");
  6     private static final Set<String> FORBINDDDEN_WORD_SET = new HashSet<String>();
  7     static {
  8        FORBINDDDEN_WORD_SET.add("fuc k"); //删掉空格
  9        FORBINDDDEN_WORD_SET.add("admin");
 10     }
 11     @Override
 12     public boolean supports(Class<?> clazz) {
 13        return UserModel.class == clazz;//表示只对UserModel类型的目标对象实施验证
 14     }
 15     @Override
 16     public void validate(Object target, Errors errors) {
 17        //这个表示如果目标对象的username属性为空，则表示错误（简化我们手工判断是否为空）
 18        ValidationUtils.rejectIfEmpty(errors, "username", "username.not.empty");
 19 
 20        UserModel user = (UserModel) target;
 21 
 22        if(!USERNAME_PATTERN.matcher(user.getUsername()).matches()) {
 23            errors.rejectValue("username", "username.not.illegal");//如果用户名不合法
 24        }
 25 
 26        for(String forbiddenWord : FORBINDDDEN_WORD_SET) {
 27            if(user.getUsername().contains(forbiddenWord)) {
 28               errors.rejectValue("username", "username.forbidden", new Object[]{forbiddenWord}, "您的用户名包含非法关键词");//用户名包含屏蔽关键字
 29               break;
 30            }
 31        }
 32        if(!PASSWORD_PATTERN.matcher(user.getPassword()).matches()) {
 33            errors.rejectValue("password","password.not.illegal", "密码不合法");//密码不合法
 34        }
 35     }
 36 }


supports方法：表示只对UserModel类型的对象验证；

validate方法：数据验证的具体方法，有如下几个验证：

1、用户名不合法（长度5-20，以字母开头，随后可以是字母、数字、下划线）

USERNAME_PATTERN.matcher(user.getUsername()).matches() //使用正则表达式验证

errors.rejectValue(“username”, “username.not.illegal”);//验证失败为username字段添加错误码

2、屏蔽关键词：即用户名中含有不合法的数据（如admin）

user.getUsername().contains(forbiddenWord) //用contains来判断我们的用户名中是否含有非法关键词

errors.rejectValue(“username”, “username.forbidden”, new Object[]{forbiddenWord}, “您的用户名包含非法关键词”);//验证失败为username字段添加错误码（参数为当前屏蔽关键词）（默认消息为”您的用户名包含非法关键词”）

3、密码不合法

在此就不罗列代码了；

4、ValidationUtils

ValidationUtils.rejectIfEmpty(errors, “username”, “username.not.empty”);

表示如果目标对象的username属性数据为空，则添加它的错误码；

内部通过（value == null || !StringUtils.hasLength(value.toString())）实现判断value是否为空，从而简化代码。

（2、spring配置文件chapter4-servlet.xml

  1 <bean id="userModelValidator"
  2 class="cn.javass.chapter4.web.controller.support.validator.UserModelValidator"/>
  3 <bean name="/validator"
  4 class="cn.javass.chapter4.web.controller.RegisterSimpleFormController">
  5     <property name="formView" value="registerAndValidator"/>
  6     <property name="successView" value="redirect:/success"/>
  7     <property name="validator" ref="userModelValidator"/>
  8 </bean>

此处使用了我们第4.9节创建的RegisterSimpleFormController。

（3、错误码配置（messages.properties），需要执行NativeToAscii


  1 username.not.empty=用户名不能为空
  2 username.not.illegal=用户名错误，必须以字母开头，只能出现字母、数字、下划线，并且长度在5-20之间
  3 username.forbidden=用户名中包含非法关键词【{0}】
  4 password.not.illegal=密码长度必须在5-20之间
  5

（4、视图页面（/WEB-INF/jsp/registerAndValidator.jsp）

  1 <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
  2 <%@taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
  3 <form:form commandName="user">
  4 
  5 <form:errors path="*" cssStyle="color:red"></form:errors>
  6 
  7 username:<form:input path="username"/>
  8 <form:errors path="username" cssStyle="color:red"></form:errors>
  9 
 10 
 11 password:<form:password path="password"/>
 12 <form:errors path="password" cssStyle="color:red"></form:errors>
 13 
 14 <input type="submit" value="注册"/>
 15 </form:form>
 16


form:errors path=“username”：表示只显示username字段的错误信息；

（5、测试

地址：http://localhost:9080/springmvc-chapter4/validator


image

当我们输入错误的数据后，会报错（form:errors path=“*”显示所有错误信息，而form:errors path=“username”只显示该字段相关的）。

问题：

如MultiActionController控制器相关方法没有提供给我们errors对象（Errors），我们应该怎么进行错误处理呢？

此处给大家一个思路，errors本质就是一个Errors接口实现，而且在页面要读取相关的错误对象，该错误对象应该存放在模型对象里边，因此我们可以自己创建个errors对象并将其添加到模型对象中即可。

此处我们复制4.15节的UserController类为UserAndValidatorController，并修改它的create（新增）方法添加如下代码片段：

  1 BindException errors = new BindException(user, getCommandName(user));
  2 //如果用户名为空
  3 if(!StringUtils.hasLength(user.getUsername())) {
  4     errors.rejectValue("username", "username.not.empty");
  5 }
  6 if(errors.hasErrors()) {
  7     return new ModelAndView(getCreateView()).addAllObjects(errors.getModel());
  8 }


√ new BindException(user, getCommandName(user))：使用当前的命令对象，和命令对象的名字创建了一个BindException作为errors；

√StringUtils.hasLength(user.getUsername())：如果用户名为空就是用errors.rejectValue(“username”, “username.not.empty”);注入错误码；

√errors.hasErrors()：表示如果有错误就返回到新增页面并显示错误消息；

√ModelAndView(getCreateView()).addAllObjects(errors.getModel())：此处一定把errors对象的模型数据放在当前的ModelAndView中，作为当前请求的模型数据返回。

在浏览器地址栏输入：http://localhost:9080/springmvc-chapter4/userAndValidator/create 到新增页面

image

用户名什么都不输入，提交后又返回到新增页面 而且显示了错误消息说明我们的想法是正确的。

4.16.2.4.2、声明式验证器

从Spring3开始支持JSR-303验证框架，支持XML风格和注解风格的验证，目前在@RequestMapping时才能使用，也就是说基于Controller接口的实现不能使用该方式（但可以使用编程式验证，有需要的可以参考hibernatevalidator实现），我们将在第七章详细介绍。

到此Spring2风格的控制器我们就介绍完了，以上控制器从spring3.0开始已经不推荐使用了（但考虑到还有部分公司使用这些@Deprecated类，在此也介绍了一下），而是使用注解控制器实现（@Controller和@RequestMapping）。

posted @ 2017-09-06 22:16  一品堂.技术学习笔记  阅读(912)  评论(0)  编辑  收藏  举报