SpringMVC学习笔记(四)

1、AbstractWizardFormController

       AbstractWizardFormController 能够实现向导式的页面。如果用户需要填写的表单内容很多，就有必要将其拆为几个页面，使用户能通过“上一步”和“下一步”按钮方便地在向导页面间导航，例 如，设计一个在线调查的向导，就可以方便地引导用户一步一步完成调查表单的填写。

我们以注册新用户为例，RegisterController需要用户填写基本资料、联系方式和详细地址，由于表单内容较多，我们让用户分3个页面分步完成注册。

我们无须处理“下一步”和“上一步”按钮，Spring会自动显示正确的页面，我们只需要处理最后用户单击“完成”按钮提交的整个表单对象。

/**

 * 用户注册向导

 * @spring.bean name="/register.do"

 * @spring.property name="commandClass" value="example.chapter7.User"

 * @spring.property name="pages" list="registerStep0,registerStep1, registerStep2"

 */

public class RegisterController extends AbstractWizardFormController {

    private UserService userService;

    /**

     * @spring.property ref="userService"

     */

    public void setUserService(UserService userService) {

        this.userService = userService;

    }

    // 当用户单击"_finish"按钮时,触发processFinish()方法:

    protected ModelAndView processFinish(HttpServletRequest request,

            HttpServletResponse response, Object command, BindException errors)

            throws Exception {

        User user = (User)command;

        userService.register(user);

        Map model = new HashMap();

        model.put("username", user.getUsername());

        return new ModelAndView("registerSuccess", model);

    }

}

 

那 么，Spring是如何知道下一个或上一个需要显示的页面呢？

除了指定command Class为User对象外，我们还需要将几个View的逻辑名称注入到RegisterController的pages属性中，注意到 AbstractWizardController的pages是从下标0开始计数的，因此，我们将注册的3个页面依次命名为 registerStep0.jsp、registerStep1.jsp和registerStep2.jsp。

除了指定pages属性外，我们还需要按照一定的规则来编写JSP页面，才能告诉Spring如何显示下一页或上一页。在表单的提交按钮上，必须以_target+索引命名按钮 ，例如：

 

<input type="submit" name="_target1" value="下一步">将前进到索引为1的页面，即registerStep1.jsp。

<input type="submit" name="_target0" value="上一步">将返回到索引为0的页面，即registerStep0.jsp。

最后一个“完成”按钮必须以“_finish”命名。

<input type="submit" name="_finish" value="完成">

 

当用户单击“完成”按钮后，Spring将调用processFinish()方法处理表单。

如果需要验证表单，在AbstractWizardController中，就无法使用Validator来进行验证，因为用户在每个页面仅填写了部分内 容，直到用户单击“完成”按钮时，整个表单对象才被填充完毕，因此，在任何一个页面中验证Command都将失败，为此，验证必须在 AbstractWizardController的validatePage()方法中进行，Spring将传入page参数，我们就根据这个参数对 command对象进行部分验证。

// 每当用户单击"_target?"准备前进到下一步时,触发validatePage()来验证当前页:

protected void validatePage(Object command, Errors errors, int page) {

    User user = (User)command;

    if(page==0) {

        // 验证username,password:

        if(!user.getUsername().matches("[a-zA-Z0-9]{3,20}"))

            errors.rejectValue("username", "error.username", "用户名不符合要求");

        if(userService.isExist(user.getUsername()))

            errors.rejectValue("username", "error.username", "用户名已存在");

        if(user.getPassword()==null || user.getPassword().length()<6)

            errors.rejectValue("password", "error.password", "口令至少为6个字符");

    }

    else if(page==1) {

        // 验证email,blog,website:

        if(user.getEmail()==null)

            errors.rejectValue("email", "error.email.empty", "电子邮件不能为空");

        else if(!user.getEmail().matches("[a-zA-Z0-9\\_\\-]+\\@[a-zA-Z0-9\\_ \\-]+[\\.[a-zA-Z0-9\\_\\-]+]{1,2}"))

            errors.rejectValue("email", "error.email", "电子邮件地址无效");

        if(user.getBlog()==null || user.getBlog().trim().equals(""))

            errors.rejectValue("blog", "error.blog", "博客地址不能为空");

        if(user.getWebsite()==null || user.getWebsite().trim().equals(""))

            errors.rejectValue("website", "error.website", "网址地址不能为空");

    }

    else if(page==2) {

        // 验证province,city,zip:略过

    }

}

 若验证未通过，则将停留在当前页，并可以通过<form:errors>显示相应的错误信息，待用户更正后，才可以继续前进到下一页。

也许注意到了，第一个页面有两个口令框，其中，第二个口令框名称为password2，在User对象中并没有对应的属性，Spring不会自动绑定它。 那么，如何验证用户两次输入的口令是否一致呢？我们一般不愿意更改User对象，因为User对象很可能对应数据库中的某个表，而数据库表不会存储同一用 户的两份相同的口令。此时，可以通过 JavaScript来验证，既方便，又能避免修改User对象。 因此，在Web应用程序的设计中，不要仅仅拘泥于JavaEE框架，对于 JavaScript、AJAX等技术也要充分利用。

2、重定向URL

 

重定向URL会使服务器向客户端发送一个 Redirect响应，并包含一个目标URL。客户端接收到Redirect响应后，会立刻重新请求新的URL，这一点和Forward不同。前者使客户 端发送了两次独立的HTTP请求，而后者请求是在服务器内部处理的，客户端并不知道服务器端对Request是否做了Forward处理。

重定向功能的主要用途是为了在服务器端修改了某 一资源的URL后，原有客户仍可以继续通过原来的URL访问该资源。由于重定向会使客户端发送两次请求，所以降低了网络效率，并且不便于用户在浏览器中单 击“后退”按钮返回上一个页面。对于Web应用程序而言，决不能大量使用重定向功能。

在Controller中实现 Redirect也非常容易。最简单的方法是直接调用HttpServlet Response对象的sendRedirect()方法，然后返回null。一旦返回的ModelAndView为null，Spring就认为 Controller自己已经完成了请求处理，不再按照常规的MVC流程继续处理请求。

例如，对于用户注销登录的操作，在清理了Session的内容后，就可以将用户重定向到登录页面。LogoutController代码如下。

 

/**

 * @spring.bean name="/logout.do"

 */

public class LogoutController extends AbstractController {

    protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response) throws Exception {

        request.getSession().removeAttribute("USERNAME");

        response.sendRedirect("login.do");

        return null;

    }

}

 

另一种 实现重定向的方法不用直接调用HttpServletResponse对象的sendRedirect()方法，而是返回一个带有 “redirect:”前缀的View，这样，ViewResolver就知道这是一个重定向操作，于是不再渲染视图，而是直接向客户端发送 Redirect响应。

return new ModelAndView("redirect:login.do");

Spring还提供了一个RedirectView对象，也可以实现重定向操作，不过使用RedirectView使Controller和View的耦合稍微紧密了一点，推荐的方法是使用“redirect:”前缀。

使用重定向要注意的一点是，重定向的资源不可位于/WEB-INF/目录下，因为用户无法通过URL直接访问位于/WEB-INF/目录下的资源，而使用MVC流程通过forward调用/WEB-INF/目录下的资源是允许的。

 

3、处理异常

       如果Controller在处理用户请求时发生了异常，自己捕获异常并跳转到出错页面会使核心逻辑混乱。Spring的MVC框架提供了一个HandlerExceptionResolver，为所有的Controller抛出的异常提供一个统一的入口。

/**

 * @spring.bean id="handlerExceptionResolver"

 */

public class MyHandlerExceptionResolver implements HandlerExceptionResolver {

    private Log log = LogFactory.getLog(getClass());

    public ModelAndView resolveException(HttpServletRequest request,

            HttpServletResponse response, Object handler, Exception ex) {

        log.warn("Handle exception: " + ex.getClass().getName());

        if(ex instanceof NeedLoginException)

            return new ModelAndView("redirect:login.do");

        Map model = new HashMap();

        model.put("ex", ex.getClass().getSimpleName());

        model.put("message", ex.getMessage());

        return new ModelAndView("error", model);

    }

}

 

MyHandlerExceptionResolver 根据Exception类型判断如何处理异常，如果是NeedLoginException，说明系统要求用户登录，这时直接将用户导向到登录页面；对于 其他类型的异常，则直接将异常的错误信息显示给用户，注意返回的视图名称为“error”，实际的视图文件即为“/error.jsp”。

使用 HandlerExceptionResolver可以避免在应用程序的每一个Controller中都去处理异常，将异常统一放到 HandlerExceptionResolver中可以极大地简化异常处理逻辑，也便于在一个统一的地方记录异常日志。对于无法处理的异常，可以给用户 显示一个友好的出错页面。

 

4、拦截请求

       我们已使用 Filter可以拦截用户请求，并实现相应的处理。Spring的MVC框架也提供了一个拦截器链，可以由多个HandlerInterceptor构 成，允许在Controller处理用户请求的前后有机会处理请求。和Filter相比，HandlerInterceptor是在Spring的IoC 容器中配置的，可以注入任意的组件，而Filter定义在Spring容器之外，因此，注入IoC组件比较困难，或者难以得到一个优雅的设计。

HandlerInterceptor接口定义了以下3个方法。

boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)

void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)

void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)

 

（1）preHandle()方法在Controller执行前调用，其返回值指定了是否应当继续处理请求。若返回false，Spring MVC框架将不再继续调用下一个拦截器，也不会将请求交给Controller处理，整个请求处理将到此结束。

（2）postHandler()方法在Controller执行完毕后调用，此时Controller仅返回了ModelAndView对象，还没有对视图进行渲染，在这个方法中有机会对ModelAndView进行修改。

（3）afterCompletion()方法在整个请求全部完成后调用，通过判断参数ex是否为null就可以判断是否产生了异常。

通过HandlerInterceptor，就有机会在一个请求执行的3个阶段对其进行拦截。例如，为了统计Web应用程序的性能，我们设计了一个性能拦截器，将每个用户请求的处理时间记录下来。PerformanceHandlerInterceptor实现如下。

/**

 * @spring.bean id="performanceHandler"

 */

public class PerformanceHandlerInterceptor implements HandlerInterceptor {

    private final Log log = LogFactory.getLog(PerformanceHandlerInterceptor. class);

    private static final String START_TIME = "PERF_START";

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        request.setAttribute(START_TIME, System.currentTimeMillis());

        return true;

    }

    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

        // 不需要处理postHandler, 保留空方法即可

    }

    public void afterCompletion(HttpServletRequest request, HttpServlet Response response, Object handler, Exception ex) throws Exception {

        Long startTime = (Long)request.getAttribute(START_TIME);

        if(startTime!=null) {

            long last = System.currentTimeMillis() - startTime.longValue();

            String uri = request.getRequestURI();

            String query = request.getQueryString();

            if(query!=null)

                uri = uri + '?' + query;

            log.info("URL: " + uri);

            log.info("Execute: " + last + "ms.");

        }

    }

}

 

由于我 们必须保证PerformanceHandlerInterceptor是线程安全的，因此，绝不可将起始时间记录在 PerformanceHandlerInterceptord 的成员变量中。由于每个请求都对应一个独立的HttpServletRequest实例，因此，将起始时间放入HttpServletRequest实例 中就保证了线程安全。

然后，将其添加到handlerMapping中的interceptor列表中。

<bean id="handlerMapping" class="org.springframework.web.servlet.handler. BeanNameUrlHandlerMapping">

    <property name="interceptors">

        <list>

            <ref bean="performanceHandler" />

        </list>

    </property>

</bean>

 

运行应用程序，在浏览器中请求/login.do，查看控制台输出如下。

[2006/11/20 22:33:41.857] URL: /login.do

[2006/11/20 22:33:41.857] Execute: 3781ms.

[2006/11/20 22:33:45.325] URL: /login.do

[2006/11/20 22:33:45.325] Execute: 0ms.

可以看到PerformanceHandlerInterceptor记录的处理时间。首次执行/login.do请求时，耗时3秒多，这是因为服务器需要编译JSP文件，随后刷新页面，由于可以跳过JSP的编译步骤，/login.do请求在1ms内就完成了。

 

5、处理文件上传

文件上传是Web应用程序中常见的功能。本质上，浏览器在向服务器发送文件时，其HTTP请求必须以multipart/form-data的形式发送，该规范定义在RFC 2388（http://www.ietf.org/rfc/rfc2388.txt）中，可以实现一次上传一个或多个文件。不过，JavaEE的Web 规范并没有内置处理multipart请求的功能，因此，要实现文件上传，就必须借助于第三方组件，或者自己手动编码解析 HttpServletRequest。

Apache Commons FileUpload（http://jakarta.apache.org/commons/fileupload）组件和COS FileUpload（http://www.servlets.com/cos）组件都是常见的处理文件上传的组件，Spring很好地对这两种组件进 行了封装。在Spring中处理文件上传时，根本无须与这两个组件的API打交道，只需用到Spring提供的 MultipartHttpServletRequest对象，就可以轻松实现文件上传的功能。

默认地，Spring不会处理文件上传，即所有的以multipart/form-data形式发送的请求都不被处理，如果要处理Multipart请求，需要在Spring的XML配置文件中申明一个MultipartResolver。

<bean id="multipartResolver" class="org.springframework.web.multipart. commons.CommonsMultipartResolver">

    <!-- 最大允许上传文件大小:1M -->

    <property name="maxUploadSize" value="1048576" />

</bean>

 maxUploadSize属性指定了最大所能上传的文件大小，若超出了最大范围，Spring将会直接抛出异常。

如果一个请求不是Multipart请求，它就会按照正常的流程处理；

如果一个请求是Multipart请求，Spring就会自动调用MultipartResolver，然后将 HttpServletRequest请求变为MultipartHttpServletRequest请求，开发者只需要处理 MultipartHttpServletRequest对象就可以了。

如何得知一个请求是否是MultipartHttpServletRequest类型呢？通过instanceof操作就能非常简单地判断出来。 我们在UploadController中实现文件上传的代码如下。

public class UploadController implements Controller {

    private Log log = LogFactory.getLog(getClass());

    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {

        // 判断request是不是multipart请求:

        if(request instanceof MultipartHttpServletRequest) {

            MultipartHttpServletRequest multipart = (MultipartHttpServlet Request)request;

            MultipartFile file = multipart.getFile("file");

            if(file==null || file.isEmpty()) {

                // 文件不存在:

                response.sendError(HttpServletResponse.SC_BAD_REQUEST);

                return null;

            }

            String filename = file.getOriginalFilename();

            log.info("Upload file name: " + filename);

            // 获取文件扩展名:

            String ext = "";

            int pos;

            if((pos = filename.lastIndexOf('.'))!=(-1)) {

                ext = URLEncoder.encode(filename.substring(pos).trim(), "UTF-8");

            }

            InputStream input = null;

            OutputStream output = null;

            // 确定服务器端写入文件的文件名:

            String uploadFile = request.getSession()

                    .getServletContext()

                    .getRealPath("/upload" + System.currentTimeMillis() + ext);

            try {

                // 获得上传文件的输入流:

                input = file.getInputStream();

                // 写入到服务器的本地文件:

                output = new BufferedOutputStream(new FileOutputStream(uploadFile));

                byte[] buffer = new byte[1024];

                int n;

                while((n=input.read(buffer))!=(-1)) {

                    output.write(buffer, 0, n);

                }

            }

            finally {

                // 必须在finally中关闭输入/输出流:

                if(input!=null) {

                    try {

                        input.close();

                    }

                    catch(IOException ioe) {}

                }

                if(output!=null) {

                    try {

                        output.close();

                    }

                    catch(IOException ioe) {}

                }

            }

            // 告诉浏览器文件上传成功:

            Writer writer = response.getWriter();

            writer.write("File uploaded successfully!");

            writer.flush();

        }

        else {

            // 非multipart/form-data请求,发送一个错误:

            response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);

        }

        return null;

    }

}

 

仔细查看上面的代码，可能会发现，我们根本没有调用Commons FileUpload或COS FileUpload组件的API，Spring已经完全为我们封装好了。那么，Spring如何确定使用Commons FileUpload还是使用COS FileUpload呢？答案是发现哪个就用哪个。

如果在/WEB-INF/lib目录下放置Commons FileUpload的jar包，Spring就会自动使用Commons FileUpload，COS FileUpload也是如此，这样带来的好处是完全屏蔽了底层组件的API，如果需要替换底层组件，只需要替换相应的jar包，甚至连XML配置文件都不用改动。

在 WebUpload工程中，我们使用的是Commons FileUpload，只需将commons- fileupload.jar和commons-io.jar放到/WEB-INF/lib目录下，剩下的事情就由Spring处理了。使用任何文本编辑器编写一个最简单的上传文件的index.html页面。

<html><head>

<meta http-equiv="Content-Type" content="text/html; charset=utf-8">

<title>Upload File</title>

</head>

<body>

<form action="upload.do" method="post" enctype="multipart/form-data" name="form1">

<p>请选择需要上传的文件：<input type="file" name="file"></p>

<p><input type="submit" name="Submit" value="上传"></p>

</form>

</body>

</html>

 

配置好DispatcherServlet后，运行这个Web应用程序，打开index.html，选择待上传的文件。文件上传成功后，就可以在服务器的Web应用的根目录下找到已上传的文件。

对于非file类型的表单字段，仍可以调用MultipartHttpServletRequest的getParameter()方法获得相应的字段值，因为MultipartHttpServletRequest也实现了HttpServletRequest接口。

也可以在SimpleFormController中将表单中上传的文件绑定到byte[]类型的属性中，不过，如果上传文件较大，则将消耗较大的服务器内存，因此，采用何种解决方案需要视情况而定。