| 姓名： |
|
| 密码： |
|
| 确认密码： |
|
|
|
在 register.jsp 的代码中使用了 EL 语句“$1{uname}”取出“model.addAttribute(“uname”，user.getUname())”中的值。对于 EL 和 JSTL 的相关知识，读者可参考《JSP教程》。
login.jsp 的核心代码如下：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
Insert title here
6）测试应用
运行 springMVCDemo02 应用的首页面，进行程序测试。
通过处理方法的形参接收请求参数
通过处理方法的形参接收请求参数也就是直接把表单参数写在控制器类相应方法的形参中，即形参名称与请求参数名称完全相同。该接收参数方式适用于 get 和 post 提交请求方式。用户可以将“通过实体 Bean 接收请求参数”部分中控制器类 UserController 中 register 方法的代码修改如下：
@RequestMapping("/register")
/**
* 通过形参接收请求参数，形参名称与请求参数名称完全相同
*/
public String register(String uname,String upass,Model model) {
if ("zhangsan".equals(uname)
&& "123456".equals(upass)) {
logger.info("成功");
return "login"; // 注册成功，跳转到 login.jsp
} else {
logger.info("失败");
// 在register.jsp页面上可以使用EL表达式取出model的uname值
model.addAttribute("uname", uname);
return "register"; // 返回 register.jsp
}
}
通过 HttpServletRequest 接收请求参数
通过 HttpServletRequest 接收请求参数适用于 get 和 post 提交请求方式，可以将“通过实体 Bean 接收请求参数”部分中控制器类 UserController 中 register 方法的代码修改如下：
@RequestMapping("/register")
/**
* 通过HttpServletRequest接收请求参数
*/
public String register(HttpServletRequest request,Model model) {
String uname = request.getParameter("uname");
String upass = request.getParameter("upass");
if ("zhangsan".equals(uname)
&& "123456".equals(upass)) {
logger.info("成功");
return "login"; // 注册成功，跳转到 login.jsp
} else {
logger.info("失败");
// 在register.jsp页面上可以使用EL表达式取出model的uname值
model.addAttribute("uname", uname);
return "register"; // 返回 register.jsp
}
}
通过 @PathVariable 接收 URL 中的请求参数
通过 @PathVariable 获取 URL 中的参数，控制器类示例代码如下：
@Controller
@RequestMapping("/user")
public class UserController {
@RequestMapping("/user")
// 必须节method属性
/**
* 通过@PathVariable获取URL的参数
*/
public String register(@PathVariable String uname,@PathVariable String upass,Model model) {
if ("zhangsan".equals(uname)
&& "123456".equals(upass)) {
logger.info("成功");
return "login"; // 注册成功，跳转到 login.jsp
} else {
// 在register.jsp页面上可以使用EL表达式取出model的uname值
model.addAttribute("uname", uname);
return "register"; // 返回 register.jsp
}
}
}
在访问“http://localhost：8080/springMVCDemo02/user/register/zhangsan/123456”路径时，上述代码自动将 URL 中的模板变量 {uname} 和 {upass} 绑定到通过 @PathVariable 注解的同名参数上，即 uname=zhangsan、upass=123456。
通过 @RequestParam 接收请求参数
通过 @RequestParam 接收请求参数适用于 get 和 post 提交请求方式，可以将“通过实体 Bean 接收请求参数”部分控制器类 UserController 中 register 方法的代码修改如下：
@RequestMapping("/register")
/**
* 通过@RequestParam接收请求参数
*/
public String register(@RequestParam String uname,
@RequestParam String upass, Model model) {
if ("zhangsan".equals(uname) && "123456".equals(upass)) {
logger.info("成功");
return "login"; // 注册成功，跳转到 login.jsp
} else {
// 在register.jsp页面上可以使用EL表达式取出model的uname值
model.addAttribute("uname", uname);
return "register"; // 返回 register.jsp
}
}
通过 @RequestParam 接收请求参数与“通过处理方法的形参接收请求参数”部分的区别如下：当请求参数与接收参数名不一致时，“通过处理方法的形参接收请求参数”不会报 404 错误，而“通过 @RequestParam 接收请求参数”会报 404 错误。
通过 @ModelAttribute 接收请求参数
当 @ModelAttribute 注解放在处理方法的形参上时，用于将多个请求参数封装到一个实体对象，从而简化数据绑定流程，而且自动暴露为模型数据，在视图页面展示时使用。
而“通过实体 Bean 接收请求参数”中只是将多个请求参数封装到一个实体对象，并不能暴露为模型数据（需要使用 model.addAttribute 语句才能暴露为模型数据，数据绑定与模型数据展示后面教程中会讲解）。
通过 @ModelAttribute 注解接收请求参数适用于 get 和 post 提交请求方式，可以将“通过实体 Bean 接收请求参数”中控制器类 UserController 中 register 方法的代码修改如下：
@RequestMapping("/register")
public String register(@ModelAttribute("user") UserForm user) {
if ("zhangsan".equals(uname) && "123456".equals(upass)) {
logger.info("成功");
return "login"; // 注册成功，跳转到 login.jsp
} else {
logger.info("失败");
// 使用@ModelAttribute("user")与model.addAttribute("user",user)的功能相同
//register.jsp页面上可以使用EL表达式${user.uname}取出ModelAttribute的uname值
return "register"; // 返回 register.jsp
}
}
六、Spring MVC的转发与重定向
重定向是将用户从当前处理请求定向到另一个视图（例如 JSP）或处理请求，以前的请求（request）中存放的信息全部失效，并进入一个新的 request 作用域；转发是将用户对当前处理的请求转发给另一个视图或处理请求，以前的 request 中存放的信息不会失效。
转发是服务器行为，重定向是客户端行为。
1）转发过程
客户浏览器发送 http 请求，Web 服务器接受此请求，调用内部的一个方法在容器内部完成请求处理和转发动作，将目标资源发送给客户；在这里转发的路径必须是同一个 Web 容器下的 URL，其不能转向到其他的 Web 路径上，中间传递的是自己的容器内的 request。
在客户浏览器的地址栏中显示的仍然是其第一次访问的路径，也就是说客户是感觉不到服务器做了转发的。转发行为是浏览器只做了一次访问请求。
2）重定向过程
客户浏览器发送 http 请求，Web 服务器接受后发送 302 状态码响应及对应新的 location 给客户浏览器，客户浏览器发现是 302 响应，则自动再发送一个新的 http 请求，请求 URL 是新的 location 地址，服务器根据此请求寻找资源并发送给客户。
在这里 location 可以重定向到任意 URL，既然是浏览器重新发出了请求，那么就没有什么 request 传递的概念了。在客户浏览器的地址栏中显示的是其重定向的路径，客户可以观察到地址的变化。重定向行为是浏览器做了至少两次的访问请求。
在 Spring MVC 框架中，控制器类中处理方法的 return 语句默认就是转发实现，只不过实现的是转发到视图。示例代码如下：
@RequestMapping("/register")
public String register() {
return "register"; //转发到register.jsp
}
在 Spring MVC 框架中，重定向与转发的示例代码如下：
package controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
@RequestMapping("/index")
public class IndexController {
@RequestMapping("/login")
public String login() {
//转发到一个请求方法（同一个控制器类可以省略/index/）
return "forward:/index/isLogin";
}
@RequestMapping("/isLogin")
public String isLogin() {
//重定向到一个请求方法
return "redirect:/index/isRegister";
}
@RequestMapping("/isRegister")
public String isRegister() {
//转发到一个视图
return "register";
}
}
在 Spring MVC 框架中，不管是重定向或转发，都需要符合视图解析器的配置，如果直接转发到一个不需要 DispatcherServlet的资源，例如：
return "forward:/html/my.html";
则需要使用 mvc：resources 配置：
七、@ModelAttribute注解的使用
通过 org.springframework.web.bind.annotation.ModelAttribute 注解类型可经常实现以下两个功能：
1）绑定请求参数到实体对象（表单的命令对象）
@RequestMapping("/register")
public String register(@ModelAttribute("user") UserForm user) {
if ("zhangsan".equals(uname) && "123456".equals(upass)) {
logger.info("成功");
return "login";
} else {
logger.info("失败");
return "register";
}
在上述代码中“@ModelAttribute（“user”）UserForm user”语句的功能有两个：
- 将请求参数的输入封装到 user 对象中。
- 创建 UserForm 实例。
以“user”为键值存储在 Model 对象中，和“model.addAttribute（“user”，user）”语句的功能一样。如果没有指定键值，即“@ModelAttribute UserForm user”，那么在创建 UserForm 实例时以“userForm”为键值存储在 Model 对象中，和“model.addAtttribute（“userForm”, user）”语句的功能一样。
2）注解一个非请求处理方法
被 @ModelAttribute 注解的方法将在每次调用该控制器类的请求处理方法前被调用。这种特性可以用来控制登录权限，当然控制登录权限的方法有很多，例如拦截器、过滤器等。
使用该特性控制登录权限，创建 BaseController，代码如下所示：
@RequestMapping("/register")
public String register(@ModelAttribute("user") UserForm user) {
if ("zhangsan".equals(uname) && "123456".equals(upass)) {
logger.info("成功");
return "login";
} else {
logger.info("失败");
return "register";
}
创建 ModelAttributeController ，代码如下所示：
package controller;
import javax.servlet.http.HttpSession;
import org.springframework.web.bind.annotation.ModelAttribute;
public class BaseController {
@ModelAttribute
public void isLogin(HttpSession session) throws Exception {
if (session.getAttribute("user") == null) {
throw new Exception("没有权限");
}
}
}
在上述 ModelAttributeController 类中的 add、update、delete 请求处理方法执行时，首先执行父类 BaseController 中的 isLogin 方法判断登录权限，可以通过地址“http://localhost：8080/springMVCDemo02/admin/add”测试登录权限。
八、拦截器（Interceptor）的配置及使用
在开发一个网站时可能有这样的需求：某些页面只希望几个特定的用户浏览。对于这样的访问权限控制，应该如何实现呢？拦截器就可以实现上述需求。在 Struts 2 框架中，拦截器是其重要的组成部分，Spring MVC 框架也提供了拦截器功能。
Spring MVC 的拦截器（Interceptor）与 Java Servlet的过滤器（Filter）类似，它主要用于拦截用户的请求并做相应的处理，通常应用在权限验证、记录请求信息的日志、判断用户是否登录等功能上。
拦截器的定义
在 Spring MVC 框架中定义一个拦截器需要对拦截器进行定义和配置，定义一个拦截器可以通过两种方式：一种是通过实现 HandlerInterceptor 接口或继承 HandlerInterceptor 接口的实现类来定义；另一种是通过实现 WebRequestInterceptor 接口或继承 WebRequestInterceptor 接口的实现类来定义。
本节以实现 HandlerInterceptor 接口的定义方式为例讲解自定义拦截器的使用方法。示例代码如下：
package interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
public class TestInterceptor implements HandlerInterceptor {
@Override
public void afterCompletion(HttpServletRequest request,
HttpServletResponse response, Object handler, Exception ex)
throws Exception {
System.out.println("afterCompletion方法在控制器的处理请求方法执行完成后执行，即视图渲染结束之后执行");
}
@Override
public void postHandle(HttpServletRequest request,
HttpServletResponse response, Object handler,
ModelAndView modelAndView) throws Exception {
System.out.println("postHandle方法在控制器的处理请求方法调用之后，解析视图之前执行");
}
@Override
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response, Object handler) throws Exception {
System.out.println("preHandle方法在控制器的处理请求方法调用之前，解析视图之前执行");
return false;
}
}
在上述拦截器的定义中实现了 HandlerInterceptor 接口，并实现了接口中的 3 个方法。有关这 3 个方法的描述如下。
- preHandle 方法：该方法在控制器的处理请求方法前执行，其返回值表示是否中断后续操作，返回 true 表示继续向下执行，返回 false 表示中断后续操作。
- postHandle 方法：该方法在控制器的处理请求方法调用之后、解析视图之前执行，可以通过此方法对请求域中的模型和视图做进一步的修改。
- afterCompletion 方法：该方法在控制器的处理请求方法执行完成后执行，即视图渲染结束后执行，可以通过此方法实现一些资源清理、记录日志信息等工作。
拦截器的配置
让自定义的拦截器生效需要在 Spring MVC 的配置文件中进行配置，配置示例代码如下：
在上述示例代码中， 元素用于配置一组拦截器，其子元素 < bean> 定义的是全局拦截器，即拦截所有的请求。
元素中定义的是指定路径的拦截器，其子元素 用于配置拦截器作用的路径，该路径在其属性 path 中定义。
如上述示例代码中，path 的属性值“/**”表示拦截所有路径，“/gotoTest”表示拦截所有以“/gotoTest”结尾的路径。如果在请求路径中包含不需要拦截的内容，可以通过 子元素进行配置。
需要注意的是， 元素的子元素必须按照 、、 的顺序配置。
九、拦截器的执行流程
本节我们主要讲解 SpringMVC 拦截器的执行流程。分两部分介绍，首先介绍单个拦截器执行流程然后介绍多个拦截器的执行流程。
单个拦截器的执行流程
在配置文件中如果只定义了一个拦截器，程序将首先执行拦截器类中的 preHandle 方法，如果该方法返回 true，程序将继续执行控制器中处理请求的方法，否则中断执行。如果 preHandle 方法返回 true，并且控制器中处理请求的方法执行后、返回视图前将执行 postHandle 方法，返回视图后才执行 afterCompletion 方法。
下面通过一个应用 springMVCDemo06 演示拦截器的执行流程，具体步骤如下：
1）创建应用
创建一个名为 springMVCDemo06 的 Web 应用，并将 Spring MVC 相关的 JAR 包复制到 lib 目录中。
2）创建 web.xml
在 WEB-INF 目录下创建 web.xml 文件，该文件中的配置信息如下：
springmvc
org.springframework.web.servlet.DispatcherServlet
1
springmvc
/
3）创建控制器类
在 src 目录下创建一个名为 controller 的包，并在该包中创建控制器类 Interceptor Controller，代码如下：
package Controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class InterceptorController {
@RequestMapping("/gotoTest")
public String gotoTest() {
System.out.println("正在测试拦截器，执行控制器的处理请求方法中");
return "test";
}
}
4）创建拦截器类
在 src 目录下创建一个名为 interceptor 的包，并在该包中创建拦截器类 TestInterceptor，代码与《拦截器的配置和使用》教程中的示例代码相同。
5）创建配置文件 springmvc-servlet.xml
在 WEB-INF 目录下创建配置文件 springmvc-servlet.xml，代码如下：
6）创建视图 JSP文件
在 WEB-INF 目录下创建一个 jsp 文件夹，并在该文件夹中创建一个 JSP 文件 test.jsp，代码如下：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
Insert title here
视图
<%System.out.println("视图渲染结束。"); %>
7）测试拦截器
首先将 springMVCDemo06 应用发布到 Tomcat 服务器，并启动 Tomcat 服务器，然后通过地址“http://localhost:8080/springMVCDemo06/gotoTest”测试拦截器。程序正确执行后控制台的输出结果如图 1 所示。
多个拦截器的执行流程
在 Web 应用中通常需要有多个拦截器同时工作，这时它们的 preHandle 方法将按照配置文件中拦截器的配置顺序执行，而它们的 postHandle 方法和 afterCompletion 方法则按照配置顺序的反序执行。
下面通过修改“单个拦截器的执行流程”小节的 springMVCDemo06 应用来演示多个拦截器的执行流程，具体步骤如下：
1）创建多个拦截器
在 springMVCDemo06 应用的 interceptor 包中创建两个拦截器类 Interceptor1 和 Interceptor2。
package interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
public class Interceptor1 implements HandlerInterceptor {
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response, Object handler) throws Exception {
System.out.println("Interceptor preHandle 方法执行");
/** 返回true表示继续向下执行，返回false表示中断后续的操作 */
return true;
}
@Override
public void postHandle(HttpServletRequest request,
HttpServletResponse response, Object handler,
ModelAndView modelAndView) throws Exception {
System.out.println("Interceptor1 postHandle 方法执行");
}
@Override
public void afterCompletion(HttpServletRequest request,
HttpServletResponse response, Object handler, Exception ex)
throws Exception {
System.out.println("Interceptor1 afterCompletion 方法执行");
}
}
Interceptor2 类的代码如下：
package interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
public class Interceptor2 implements HandlerInterceptor {
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response, Object handler) throws Exception {
System.out.println("Interceptor2 preHandle 方法执行");
/** 返回true表示继续向下执行，返回false表示中断后续的操作 */
return true;
}
@Override
public void postHandle(HttpServletRequest request,
HttpServletResponse response, Object handler,
ModelAndView modelAndView) throws Exception {
System.out.println("Interceptor2 postHandle 方法执行");
}
@Override
public void afterCompletion(HttpServletRequest request,
HttpServletResponse response, Object handler, Exception ex)
throws Exception {
System.out.println("Interceptor2 afterCompletion 方法执行");
}
}
2）配置拦截器
在配置文件 springmvc-servlet.xml 中的 元素内配置两个拦截器 Interceptor1 和 Interceptor2，配置代码如下：
3）测试多个拦截器
首先将 springMVCDemo06 应用发布到 Tomcat 服务器并启动 Tomcat 服务器，然后通过地址“http://localhost：8080/springMVCDemo06/gotoTest”测试拦截器。程序正确执行后控制台的输出结果如图 2 所示。
注意preHandle和postHandle是先进先出（1 2），afterCompletion先进后出（2 1）
十、Spring MVC拦截器实现用户登录权限验证案例
本节将通过拦截器来完成一个用户登录权限验证的 Web 应用 springMVCDemo07，具体要求如下：只有成功登录的用户才能访问系统的主页面 main.jsp，如果没有成功登录而直接访问主页面，则拦截器将请求拦截，并转发到登录页面 login.jsp。当成功登录的用户在系统主页面中单击“退出”链接时回到登录页面。
具体实现步骤如下：
1）创建应用
创建 Web 应用 springMVCDemo07，并将 Spring MVC 相关的 JAR 包复制到 lib 目录中。
2）创建 POJO 类
在 springMVCDemo07 的 src 目录中创建 pojo 包，并在该包中创建 User 类，具体代码如下：
public class User {
private String uname;
private String upwd;
//省略setter和getter方法
}
3）创建控制器类
在 springMVCDemo07 的 src 目录中创建 controller 包，并在该包中创建控制器类 UserController，具体代码如下：
package controller;
import javax.servlet.http.HttpSession;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import pojo.User;
@Controller
public class UserController {
/**
* 登录页面初始化
*/
@RequestMapping("/toLogin")
public String initLogin() {
return "login";
}
/**
* 处理登录功能
*/
@RequestMapping("/login")
public String login(User user, Model model, HttpSession session) {
System.out.println(user.getUname());
if ("zhangsan".equals(user.getUname())
&& "123456".equals(user.getUpwd())) {
// 登录成功，将用户信息保存到session对象中
session.setAttribute("user", user);
// 重定向到主页面的跳转方法
return "redirect:main";
}
model.addAttribute("msg", "用户名或密码错误，请重新登录！ ");
return "login";
}
/**
* 跳转到主页面
*/
@RequestMapping("/main")
public String toMain() {
return "main";
}
/**
* 退出登录
*/
@RequestMapping("/logout")
public String logout(HttpSession session) {
// 清除 session
session.invalidate();
return "login";
}
}
4）创建拦截器类
在 springMVCDemo07 的 src 目录中创建 interceptor 包，并在该包中创建拦截器类 LoginInterceptor，具体代码如下：
package interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
public class LoginInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response, Object handler) throws Exception {
// 获取请求的URL
String url = request.getRequestURI();
// login.jsp或登录请求放行，不拦截
if (url.indexOf("/toLogin") >= 0 || url.indexOf("/login") >= 0) {
return true;
}
// 获取 session
HttpSession session = request.getSession();
Object obj = session.getAttribute("user");
if (obj != null)
return true;
// 没有登录且不是登录页面，转发到登录页面，并给出提示错误信息
request.setAttribute("msg", "还没登录，请先登录！");
request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request,
response);
return false;
}
@Override
public void afterCompletion(HttpServletRequest arg0,
HttpServletResponse arg1, Object arg2, Exception arg3)
throws Exception {
// TODO Auto-generated method stub
}
@Override
public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1,
Object arg2, ModelAndView arg3) throws Exception {
// TODO Auto-generated method stub
}
}
5）配置拦截器
在 WEB-INF 目录下创建配置文件 springmvc-servlet.xml 和 web.xml。web.xml 的代码和 springMVCDemo07 一样，这里不再赘述。在 springmvc-servlet.xml 文件中配置拦截器 LoginInterceptor，具体代码如下：
6）创建视图 JSP 页面
在 WEB-INF 目录下创建文件夹 jsp，并在该文件夹中创建 login.jsp 和 main.jsp。
login.jsp 的代码如下：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
Insert title here
${msg }
main.jsp 的代码如下：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
Insert title here
当前用户：${user.uname }
退出
7）发布并测试应用
首先将 springMVCDemo07 应用发布到 Tomcat 服务器并启动 Tomcat 服务器，然后通过地址“http://localhost:8080/springMVCDemo07/main”测试应用，运行效果如图 1 所示。
从图 1 可以看出，当用户没有登录而直接访问系统主页面时请求将被登录拦截器拦截，返回到登录页面，并提示信息。如果用户在用户名框中输入“zhangsan”，在密码框中输入“123456”，单击“登录”按钮后浏览器的显示结果如图 2 所示。如果输入的用户名或密码错误，浏览器的显示结果如图 3 所示。
当单击图 2 中的“退出”链接后，系统将从主页面返回到登录页面。
十一、Spring MVC统一异常处理的3种方式（附带实例）
在 Spring MVC 应用的开发中，不管是对底层数据库操作，还是业务层或控制层操作，都会不可避免地遇到各种可预知的、不可预知的异常需要处理。
如果每个过程都单独处理异常，那么系统的代码耦合度高，工作量大且不好统一，以后维护的工作量也很大。
如果能将所有类型的异常处理从各层中解耦出来，这样既保证了相关处理过程的功能单一，又实现了异常信息的统一处理和维护。
幸运的是，SpringMVC 框架支持这样的实现。Spring MVC 统一异常处理有以下 3 种方式：
- 使用 Spring MVC 提供的简单异常处理器 SimpleMappingExceptionResolver。
- 实现 Spring 的异常处理接口 HandlerExceptionResolver 自定义自己的异常处理器。
- 使用 @ExceptionHandler 注解实现异常处理
本节主要根据这 3 种处理方式讲解 Spring MVC 应用的异常统一处理。
为了验证 Spring MVC 框架的 3 种异常处理方式的实际效果，需要开发一个测试应用 springMVCDemo10，从 Dao 层、Service 层、Controller 层分别抛出不同的异常（SQLException、自定义异常和未知异常），然后分别集成 3 种方式进行异常处理，进而比较其优缺点。springMVCDemo10 应用的结构如图 1 所示。
3 种异常处理方式的相似部分有 Dao 层、Service 层、View 层、MyException、TestException Controller 以及 web.xml，下面分别介绍这些相似部分。
基础工程
1）创建应用 springMVCDemo10
创建应用 springMVCDemo10，并导入 Spring MVC 相关的 JAR 包。
2）创建自定义异常类
在 src 目录下创建 exception 包，并在该包中创建自定义异常类 MyException。具体代码如下：
package exception;
public class MyException extends Exception {
private static final long serialVersionUID = 1L;
public MyException() {
super();
}
public MyException(String message) {
super(message);
}
}
3）创建 Dao 层
在 src 目录下创建 dao 包，并在该包中创建 TestExceptionDao 类，在该类中定义 3 个方法，分别抛出“数据库异常”“自定义异常”和“未知异常”。具体代码如下：
package dao;
import java.sql.SQLException;
import org.springframework.stereotype.Repository;
@Repository("TestExceptionDao")
public class TestExceptionDao {
public void daodb() throws Exception {
throw new SQLException("Dao中数据库异常");
}
public void daomy() throws Exception {
throw new SQLException("Dao中自定义异常");
}
public void daono() throws Exception {
throw new SQLException("Dao中未知异常");
}
}
4）创建 Service 层
在 src 目录下创建 service 包，并在该包中创建 TestExceptionService 接口和 TestExceptionServiceImpl 实现类，在该接口中定义 6 个方法，其中有 3 个方法调用 Dao 层中的方法，有 3 个是 Service 层的方法。
Service 层的方法是为演示 Service 层的“数据库异常”“自定义异常”和“未知异常”而定义的。
TestExceptionService 接口的代码如下：
package service;
public interface TestExceptionService {
public void servicemy() throws Exception;
public void servicedb() throws Exception;
public void daomy() throws Exception;
public void daodb() throws Exception;
public void serviceno() throws Exception;
public void daono() throws Exception;
}
TestExceptionServiceImpl 实现类的代码如下：
package service;
import java.sql.SQLException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import dao.TestExceptionDao;
import exception.MyException;
@Service("testExceptionService")
public class TestExceptionServiceImpl implements TestExceptionService {
@Autowired
private TestExceptionDao testExceptionDao;
@Override
public void servicemy() throws Exception {
throw new MyException("Service中自定义异常");
}
@Override
public void servicedb() throws Exception {
throw new SQLException("Service中数据库异常");
}
@Override
public void daomy() throws Exception {
testExceptionDao.daomy();
}
@Override
public void daodb() throws Exception {
testExceptionDao.daodb();
}
@Override
public void serviceno() throws Exception {
throw new SQLException("Service中未知异常");
}
@Override
public void daono() throws Exception {
testExceptionDao.daono();
}
}
5）创建控制器类
在 src 目录下创建 controller 包，并在该包中创建 TestExceptionController 控制器类，代码如下：
package controller;
import java.sql.SQLException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import service.TestExceptionService;
import exception.MyException;
@Controller
public class TestExceptionController {
@Autowired
private TestExceptionService testExceptionService;
@RequestMapping("/db")
public void db() throws Exception {
throw new SQLException("控制器中数据库异常");
}
@RequestMapping("/my")
public void my() throws Exception {
throw new MyException("控制器中自定义异常");
}
@RequestMapping("/no")
public void no() throws Exception {
throw new Exception("控制器中未知异常");
}
@RequestMapping("/servicedb")
public void servicedb() throws Exception {
testExceptionService.servicedb();
}
@RequestMapping("/servicemy")
public void servicemy() throws Exception {
testExceptionService.servicemy();
}
@RequestMapping("/serviceno")
public void serviceno() throws Exception {
testExceptionService.serviceno();
}
@RequestMapping("/daodb")
public void daodb() throws Exception {
testExceptionService.daodb();
}
@RequestMapping("/daomy")
public void daomy() throws Exception {
testExceptionService.daomy();
}
@RequestMapping("/daono")
public void daono() throws Exception {
testExceptionService.daono();
}
}
6）创建 View 层
View 层中共有 5 个 JSP 页面，下面分别介绍。
测试应用首页面 index.jsp 的代码如下：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@taglib prefix="spring" uri="http://www.springframework.org/tags"%>
Insert title here
所有的演示例子
404 错误对应页面 404.jsp 的代码如下：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@taglib prefix="spring" uri="http://www.springframework.org/tags"%>
Insert title here
资源已不在。
未知异常对应页面 error.jsp 的代码如下：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" isErrorPage="true"%>
<%@taglib prefix="spring" uri="http://www.springframework.org/tags"%>
Insert title here
未知错误：
<%=exception %>
错误内容：
<%
exception.printStackTrace(response.getWriter());
%>
自定义异常对应页面 my-error.jsp 的代码如下：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" isErrorPage="true"%>
<%@taglib prefix="spring" uri="http://www.springframework.org/tags"%>
Insert title here
自定义异常错误：
<%=exception %>
错误内容：
<%
exception.printStackTrace(response.getWriter());
%>
SQL 异常对应页面 sql-error.jsp 的代码如下：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" isErrorPage="true"%>
<%@taglib prefix="spring" uri="http://www.springframework.org/tags"%>
Insert title here
数据库异常错误：
<%=exception %>
错误内容：
<%
exception.printStackTrace(response.getWriter());
%>
7）web.xml
对于 Unchecked Exception 而言，由于代码不强制捕获，往往被忽略，如果运行期产生了 Unchecked Exception，而代码中又没有进行相应的捕获和处理，则可能不得不面对 404、500 等服务器内部错误提示页面，所以在 web.xml 文件中添加了全局异常 404 处理。具体代码如下：
404
/WEB-INF/jsp/404.jsp
从上述 Dao 层、Service 层以及 Controller 层的代码中可以看出，它们只管通过 throw 和 throws 语句抛出异常，并不处理。下面分别从 3 种方式统一处理这些异常。
使用SimpleMappingExceptionResolver类异常处理
使用 org.springframework.web.servlet.handler.SimpleMappingExceptionResolver 类统一处理异常时需要在配置文件中提前配置异常类和 View 的对应关系。配置文件 springmvc-servlet.xml 的具体代码如下：
my-error
sql-error
在配置完成后就可以通过 SimpleMappingExceptionResolver 异常处理器统一处理 《Spring MVC统一异常处理的3种方式（附带实例）》中的异常。
发布 springMVCDemo10 应用到 Tomcat 服务器并启动服务器，然后即可通过地址“http://localhost:8080/springMVCDemo10/”测试应用。
使用HandlerExceptionResolver接口异常处理
org.springframework.web.servlet.HandlerExceptionResolver 接口用于解析请求处理过程中所产生的异常。开发者可以开发该接口的实现类进行 Spring MVC应用的异常统一处理。
在 springMVCDemo10 应用的 exception 包中创建一个 HandlerExceptionResolver 接口的实现类 MyExceptionHandler，具体代码如下：
package exception;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;
public class MyExceptionHandler implements HandlerExceptionResolver {
@Override
public ModelAndView resolveException(HttpServletRequest arg0,
HttpServletResponse arg1, Object arg2, Exception arg3) {
Map model = new HashMap();
model.put("ex", arg3);
// 根据不同错误转向不同页面（统一处理），即异常与View的对应关系
if (arg3 instanceof MyException) {
return new ModelAndView("my-error", model);
} else if (arg3 instanceof SQLException) {
return new ModelAndView("sql-error", model);
} else {
return new ModelAndView("error", model);
}
}
}
需要将实现类 MyExceptionHandler 在配置文件中托管给 Spring MVC 框架才能进行异常的统一处理，配置代码为
在实现 HandlerExceptionResolver 接口统一处理异常时将配置文件的代码修改如下：
发布 springMVCDemo10 应用到 Tomcat 服务器并启动服务器，然后即可通过地址“http://localhost:8080/springMVCDemo10/”测试应用。
使用@ExceptionHandler注解异常处理
创建 BaseController 类，并在该类中使用 @ExceptionHandler 注解声明异常处理方法，具体代码如下：
package controller;
import java.sql.SQLException;
import javax.servlet.http.HttpServletRequest;
import org.springframework.web.bind.annotation.ExceptionHandler;
import exception.MyException;
public class BaseController {
/** 基于@ExceptionHandler异常处理 */
@ExceptionHandler
public String exception(HttpServletRequest request, Exception ex) {
request.setAttribute("ex", ex);
// 根据不同错误转向不同页面，即异常与view的对应关系
if (ex instanceof SQLException) {
return "sql-error";
} else if (ex instanceof MyException) {
return "my-error";
} else {
return "error";
}
}
}
将所有需要异常处理的 Controller 都继承 BaseController 类，示例代码如下：
@Controller
public class TestExceptionController extends BaseController{
...
}
在使用 @ExceptionHandler 注解声明统一处理异常时不需要配置任何信息，此时将配置文件的代码修改如下：
发布 springMVCDemo10 应用到 Tomcat 服务器并启动服务器，然后即可通过地址“http://localhost:8080/springMVCDemo10/”测试应用。
十二、Spring MVC单/多文件上传
基础
Spring MVC框架的文件上传是基于 commons-fileupload 组件的文件上传，只不过 SpringMVC 框架在原有文件上传组件上做了进一步封装，简化了文件上传的代码实现，取消了不同上传组件上的编程差异。
commons-fileupload组件
由于 Spring MVC 框架的文件上传是基于 commons-fileupload 组件的文件上传，因此需要将 commons-fileupload 组件相关的 JAR（commons-fileupload-1.3.1.jar 和 commons-io-2.4.jar）复制到 Spring MVC 应用的 WEB-INF/lib 目录下。下面讲解如何下载相关 JAR 包。
Commons 是 Apache 开放源代码组织中的一个 Java子项目，该项目包括文件上传、命令行处理、数据库连接池、XML 配置文件处理等模块。fileupload 就是其中用来处理基于表单的文件上传的子项目，commons-fileupload 组件性能优良，并支持任意大小文件的上传。
commons-fileupload 组件可以从“http://commons.apache.org/proper/commons-fileupload/”下载，本教程采用的版本是 1.2.2。下载它的 Binares 压缩包（commons-fileupload-1.3.1-bin.zip），解压缩后的目录中有两个子目录，分别是 lib 和 site。
在 lib 目录下有一个 JAR 文件——commons-fileupload-1.3.1.jar，该文件是 commons-fileupload 组件的类库。在 site 目录中是 commons-fileupload 组件的文档，也包括 API 文档。
commons-fileupload 组件依赖于 Apache 的另外一个项目——commons-io，该组件可以从“http://commons.apache.org/proper/commons-io/”下载，本教程采用的版本是 2.4。下载它的 Binaries 压缩包（commons-io-2.4-bin.zip），解压缩后的目录中有 4 个 JAR 文件，其中有一个 commons-io-2.4.jar 文件，该文件是 commons-io 的类库。
基于表单的文件上传
标签
文件上传的表单例子如下：
对于基于表单的文件上传，不要忘记使用 enctype 属性，并将它的值设置为 multipart/form-data，同时将表单的提交方式设置为 post。为什么要这样呢？下面从 enctype 属性说起。
表单的 enctype 属性指定的是表单数据的编码方式，该属性有以下 3 个值。
- application/x-www-form-urlencoded：这是默认的编码方式，它只处理表单域里的 value 属性值。
- multipart/form-data：该编码方式以二进制流的方式来处理表单数据，并将文件域指定文件的内容封装到请求参数里。
- text/plain：该编码方式只有当表单的 action 属性为“mailto：”URL 的形式时才使用，主要适用于直接通过表单发送邮件的方式。
由上面 3 个属性的解释可知，在基于表单上传文件时 enctype 的属性值应为 multipart/form-data。
MultipartFile接口
在 Spring MVC 框架中上传文件时将文件相关信息及操作封装到 MultipartFile 对象中，因此开发者只需要使用 MultipartFile 类型声明模型类的一个属性即可对被上传文件进行操作。该接口具有如下方法。
| 名称 |
作用 |
| byte[] getBytes() |
以字节数组的形式返回文件的内容 |
| String getContentType() |
返回文件的内容类型 |
| InputStream getInputStream() |
返回一个InputStream，从中读取文件的内容 |
| String getName() |
返回请求参数的名称 |
| String getOriginalFillename() |
返回客户端提交的原始文件名称 |
| long getSize() |
返回文件的大小，单位为字节 |
| boolean isEmpty() |
判断被上传文件是否为空 |
| void transferTo(File destination) |
将上传文件保存到目标目录下 |
在上传文件时需要在配置文件中使用 Spring 的 org.springframework.web.multipart.commons.CommonsMultipartResolver 类配置 MultipartResolver 用于文件上传。
下面我们分两节介绍 Spring MVC 单文件上传和多文件上传：
Spring MVC单文件上传（附带实例）
本节通过一个应用案例 springMVCDemo11 讲解 Spring MVC 框架如何实现单文件上传，具体步骤如下：
1）创建应用并导入 JAR 包
创建应用 springMVCDemo11，将 SpringMVC 相关的 JAR 包、commons-fileupload 组件相关的 JAR 包以及 JSTL 相关的 JAR 包导入应用的 lib 目录中，如图 1 所示。
图 1 springMVCDemo11
2）创建 web.xml 文件
在 WEB-INF 目录下创建 web.xml 文件。为防止中文乱码，需要在 web.xml 文件中添加字符编码过滤器，这里不再赘述。
3）创建文件选择页面
在 WebContent 目录下创建 JSP页面 oneFile.jsp，在该页面中使用表单上传单个文件，具体代码如下：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
Insert title here
4）创建 POJO 类
在 src 目录下创建 pojo 包，在该包中创建 POJO 类 FileDomain。然后在该 POJO 类中声明一个 MultipartFile 类型的属性封装被上传的文件信息，属性名与文件选择页面 oneFile.jsp 中的 file 类型的表单参数名 myfile 相同。具体代码如下：
package pojo;
import org.springframework.web.multipart.MultipartFile;
public class FileDomain {
private String description;
private MultipartFile myfile;
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public MultipartFile getMyfile() {
return myfile;
}
public void setMyfile(MultipartFile myfile) {
this.myfile = myfile;
}
}
5）创建控制器类
在 src 目录下创建 controller 包，并在该包中创建 FileUploadController 控制器类。具体代码如下：
package controller;
import java.io.File;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import pojo.FileDomain;
@Controller
public class FileUploadController {
// 得到一个用来记录日志的对象，这样在打印信息时能够标记打印的是哪个类的信息
private static final Log logger = LogFactory.getLog(FileUploadController.class);
/**
* 单文件上传
*/
@RequestMapping("/onefile")
public String oneFileUpload(@ModelAttribute FileDomain fileDomain,
HttpServletRequest request) {
/*
* 文件上传到服务器的位置“/uploadfiles”,该位置是指
* workspace\.metadata\.plugins\org.eclipse
* .wst.server.core\tmp0\wtpwebapps, 发布后使用
*/
String realpath = request.getServletContext()
.getRealPath("uploadfiles");
String fileName = fileDomain.getMyfile().getOriginalFilename();
File targetFile = new File(realpath, fileName);
if (!targetFile.exists()) {
targetFile.mkdirs();
}
// 上传
try {
fileDomain.getMyfile().transferTo(targetFile);
logger.info("成功");
} catch (Exception e) {
e.printStackTrace();
}
return "showOne";
}
}
6）创建 Spring MVC 的配置文件
在上传文件时需要在配置文件中使用 Spring 的 CommonsMultipartResolver 类配置 MultipartResolver 用于文件上传，应用的配置文件 springmvc-servlet.xml 的代码如下：
7）创建成功显示页面
在 WEB-INF 目录下创建 JSP 文件夹，并在该文件夹中创建单文件上传成功显示页面 showOne.jsp。具体代码如下：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
Insert title here
${fileDomain.description }
${fileDomain.myfile.originalFilename }
8）测试文件上传
发布 springMVCDemo11 应用到 Tomcat 服务器并启动 Tomcat 服务器，然后通过地址“http://localhost:8080/springMVCDemo11/oneFile.jsp”运行文件选择页面，运行结果如图 2 所示。
在图 2 中选择文件并输入文件描述，然后单击“提交”按钮上传文件，若成功则显示如图 3 所示的结果。
Spring MVC多文件上传（附带实例）
本小节继续通过 springMVCDemo11 应用案例讲解 Spring MVC框架如何实现多文件上传，具体步骤如下：
1）创建多文件选择页面
在 WebContent 目录下创建 JSP 页面 multiFiles.jsp，在该页面中使用表单上传多个文件，具体代码如下：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
Insert title here
2）创建 POJO 类
在上传多文件时需要 POJO 类 MultiFileDomain 封装文件信息，MultiFileDomain 类的具体代码如下：
package pojo;
import java.util.List;
import org.springframework.web.multipart.MultipartFile;
public class MultiFileDomain {
private List description;
private List myFile;
// 省略setter和getter方法
}
3）添加多文件上传处理方法
在控制器类 FileUploadController 中添加多文件上传的处理方法 multiFileUpload，具体代码如下：
/**
* 多文件上传
*/
@RequestMapping("/multifile")
public String multiFileUpload(@ModelAttribute MultiFileDomain multiFileDomain,HttpServletRequest request) {
String realpath = request.getServletContext().getRealPath("uploadfiles");
File targetDir = new File(realpath);
if (!targetDir.exists()) {
targetDir.mkdirs();
}
List files = multiFileDomain.getMyFile();
for (int i = 0; i < files.size(); i++) {
MultipartFile file = files.get(i);
String fileName = file.getOriginalFilename();
File targetFile = new File(realpath, fileName);
// 上传
try {
file.transferTo(targetFile);
} catch (Exception e) {
e.printStackTrace();
}
}
logger.info("成功");
return "showMulti";
}
4）创建成功显示页面
在 JSP 文件夹中创建多文件上传成功显示页面 showMulti.jsp，具体代码如下：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
Insert title here
| 详情 |
文件名 |
| ${description} |
${multiFileDomain.myfile[loop.count-1].originalFilename} |
5）测试文件上传
发布 springMVCDemo11 应用到 Tomcat 服务器并启动 Tomcat 服务器，然后通过地址“http://localhost:8080/springMVCDemo11/multiFiles.jsp”运行多文件选择页面，运行结果如图 1 所示。
在图 1 中选择文件并输入文件描述，然后单击“提交”按钮上传多个文件，若成功则显示如图 2 所示的结果。
十三、Spring MVC文件下载
本节主要讲解 Spring MVC文件下载的实现方法和实现过程。
文件下载的实现方法
实现文件下载有以下两种方法：
通过超链接实现下载固然简单，但暴露了下载文件的真实位置，并且只能下载存放在 Web 应用程序所在的目录下的文件。
利用程序编码实现下载可以增加安全访问控制，还可以从任意位置提供下载的数据，可以将文件存放到 Web 应用程序以外的目录中，也可以将文件保存到数据库中。
利用程序实现下载需要设置两个报头：
1）Web 服务器需要告诉浏览器其所输出内容的类型不是普通文本文件或 HTML 文件，而是一个要保存到本地的下载文件，这需要设置 Content-Type 的值为 application/x-msdownload。
2）Web 服务器希望浏览器不直接处理相应的实体内容，而是由用户选择将相应的实体内容保存到一个文件中，这需要设置 Content-Disposition 报头。
该报头指定了接收程序处理数据内容的方式，在 HTTP 应用中只有 attachment 是标准方式，attachment 表示要求用户干预。在 attachment 后面还可以指定 filename 参数，该参数是服务器建议浏览器将实体内容保存到文件中的文件名称。
设置报头的示例如下：
response.setHeader("Content-Type", "application/x-msdownload");
response.setHeader("Content-Disposition", "attachment;filename="+filename);
文件下载的过程
下面继续通过 springMVCDemo11 应用讲述利用程序实现下载的过程，要求从《Spring MVC单文件上传》上传文件的目录（workspace.metadata.plugins\org.eclipse.wst.server.core\tmp0\wtpwebapps\springMVCDemo11\uploadfiles）中下载文件，具体开发步骤如下：
1）编写控制器类
首先编写控制器类 FileDownController，在该类中有 3 个方法，即 show、down 和 toUTF8String。其中，show 方法获取被下载的文件名称；down 方法执行下载功能；toUTF8String 方法是下载保存时中文文件名的字符编码转换方法。
FileDownController 类的代码如下：
package controller;
import java.io.File;
import java.io.FileInputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
public class FileDownController {
// 得到一个用来记录日志的对象，在打印时标记打印的是哪个类的信息
private static final Log logger = LogFactory
.getLog(FileDownController.class);
/**
* 显示要下载的文件
*/
@RequestMapping("showDownFiles")
public String show(HttpServletRequest request, Model model) {
// 从 workspace\.metadata\.plugins\org.eclipse.wst.server.core\
// tmp0\wtpwebapps\springMVCDemo11\下载
String realpath = request.getServletContext()
.getRealPath("uploadfiles");
File dir = new File(realpath);
File files[] = dir.listFiles();
// 获取该目录下的所有文件名
ArrayList fileName = new ArrayList();
for (int i = 0; i < files.length; i++) {
fileName.add(files[i].getName());
}
model.addAttribute("files", fileName);
return "showDownFiles";
}
/**
* 执行下载
*/
@RequestMapping("down")
public String down(@RequestParam String filename,
HttpServletRequest request, HttpServletResponse response) {
String aFilePath = null; // 要下载的文件路径
FileInputStream in = null; // 输入流
ServletOutputStream out = null; // 输出流
try {
// 从workspace\.metadata\.plugins\org.eclipse.wst.server.core\
// tmp0\wtpwebapps下载
aFilePath = request.getServletContext().getRealPath("uploadfiles");
// 设置下载文件使用的报头
response.setHeader("Content-Type", "application/x-msdownload");
response.setHeader("Content-Disposition", "attachment; filename="
+ toUTF8String(filename));
// 读入文件
in = new FileInputStream(aFilePath + "\\" + filename);
// 得到响应对象的输出流，用于向客户端输出二进制数据
out = response.getOutputStream();
out.flush();
int aRead = 0;
byte b[] = new byte[1024];
while ((aRead = in.read(b)) != -1 & in != null) {
out.write(b, 0, aRead);
}
out.flush();
in.close();
out.close();
} catch (Throwable e) {
e.printStackTrace();
}
logger.info("下载成功");
return null;
}
/**
* 下载保存时中文文件名的字符编码转换方法
*/
public String toUTF8String(String str) {
StringBuffer sb = new StringBuffer();
int len = str.length();
for (int i = 0; i < len; i++) {
// 取出字符中的每个字符
char c = str.charAt(i);
// Unicode码值为0~255时，不做处理
if (c >= 0 && c <= 255) {
sb.append(c);
} else { // 转换 UTF-8 编码
byte b[];
try {
b = Character.toString(c).getBytes("UTF-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
b = null;
}
// 转换为%HH的字符串形式
for (int j = 0; j < b.length; j++) {
int k = b[j];
if (k < 0) {
k &= 255;
}
sb.append("%" + Integer.toHexString(k).toUpperCase());
}
}
}
return sb.toString();
}
}
2）创建文件列表页面
下载文件示例需要一个显示被下载文件的 JSP 页面 showDownFiles.jsp，代码如下：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
Insert title here
