SpringMVC

常用注解

@RequestParam

使用@RequestParam常用于处理简单类型的绑定。

value：参数名字，即入参的请求参数名字，如value=“item_id”表示请求的参数区中的名字为item_id的参数的值将传入；
required：是否必须，默认是true，表示请求中一定要有相应的参数，否则将报；
TTP Status 400 - Required Integer parameter ‘XXXX’ is not present

defaultValue：默认值，表示如果请求中没有同名参数时的默认值

public String editItem(@RequestParam(value="item_id",required=true) String id) {

}

public List<EasyUITreeNode> getItemCatList(@RequestParam(name ="id",
    defaultValue ="0") Long parentId) {
        return service.getItemCatList(parentId);

    }

形参名称为id，但是这里使用value=”item_id”限定请求的参数名为item_id，所以页面传递参数的名必须为item_id。
注意：如果请求参数中没有item_id将跑出异常：
HTTP Status 500 - Required Integer parameter ‘item_id’ is not present

这里通过required=true限定item_id参数为必需传递，如果不传递则报400错误，可以使用defaultvalue设置默认值，即使required=true也可以不传item_id参数值

@RequestMapping

@RequestMapping(value=”/item”)或@RequestMapping(“/item）
value的值是数组，可以将多个url映射到同一个方法

窄化请求映射--分类管理，防止url冲突

在class上添加@RequestMapping(url)指定通用请求前缀， 限制此类下的所有方法请求url必须以请求前缀开头，通过此方法对url进行分类管理。

如下：
@RequestMapping放在类名上边，设置请求前缀
@Controller
@RequestMapping(“/item”)

方法名上边设置请求映射url：
@RequestMapping放在方法名上边，如下：
@RequestMapping(“/queryItem “)

访问地址为：/item/queryItem

请求方法限定 

限定GET方法
@RequestMapping(method = RequestMethod.GET)

如果通过Post访问则报错：
HTTP Status 405 - Request method ‘POST’ not supported

例如：
@RequestMapping(value=”/editItem”,method=RequestMethod.GET)
限定POST方法

@RequestMapping(method = RequestMethod.POST)

如果通过Post访问则报错：
HTTP Status 405 - Request method ‘GET’ not supported

GET和POST都可以
@RequestMapping(method={RequestMethod.GET,RequestMethod.POST})

---

@RequestBody

//请求json响应json
        $.ajax({
            type:"post",
            url:"${pageContext.request.contextPath}/items/sendJson.action",
//表明是json类型
            contentType:"application/json;charset=utf-8",
            data:'{"name":"测试商品","price":99.9}',
            success:function(data){
                alert(data);
            }

作用：
@RequestBody注解用于读取http请求的内容(字符串)，通过springmvc提供的HttpMessageConverter接口将读到的内容转换为json、xml等格式的数据并绑定到controller方法的参数上。

本例子应用：
@RequestBody注解实现接收http请求的json数据，将json数据转换为java对象

//导入jackson的jar包在 controller的方法中可以使用@RequestBody,让spirngMvc将json格式字符串自动转换成java中的pojo
    //页面json的key要等于java中pojo的属性名称
    //controller方法返回pojo类型的对象并且用@ResponseBody注解,springMvc会自动将pojo对象转换成json格式字符串
    @RequestMapping("/sendJson")
    @ResponseBody
    public Items json(@RequestBody Items items) throws Exception{
        System.out.println(items);
        return items;
    }

@ResponseBody

作用：
该注解用于将Controller的方法返回的对象，通过HttpMessageConverter接口转换为指定格式的数据如：json,xml等，通过Response响应给客户端

本例子应用：
@ResponseBody注解实现将controller方法返回对象转换为json响应给客户端

@PathVariable

@RequestMapping(value=”/ viewItems/{id}”)：{×××}占位符，请求的URL可以是“/viewItems/1”或“/viewItems/2”，通过在方法中使用@PathVariable获取{×××}中的×××变量。

@PathVariable用于将请求URL中的模板变量映射到功能处理方法的参数上。如果RequestMapping中表示为”/viewItems/{id}”，id和形参名称一致，@PathVariable不用指定名称。

@RequestMapping("/viewItems/{id}") 
    public @ResponseBody viewItems(@PathVariable("id") String id,Model model) throws Exception{
        //方法中使用@PathVariable获取useried的值，使用model传回页面
        //调用 service查询商品信息
        ItemsCustom itemsCustom = itemsService.findItemsById(id);
        return itemsCustom;
}

springMVC 起步

springmvc与struts2不同

1、springmvc的入口是一个servlet即前端控制器，而struts2入口是一个filter过虑器。
2、springmvc是基于方法开发(一个url对应一个方法)，请求参数传递到方法的形参，可以设计为单例或多例(建议单例)，struts2是基于类开发，传递参数是通过类的属性，只能设计为多例。
3、Struts采用值栈存储请求和响应的数据，通过OGNL存取数据， springmvc通过参数解析器是将request请求内容解析，并给方法形参赋值，将数据和视图封装成ModelAndView对象，最后又将ModelAndView中的模型数据通过reques域传输到页面。Jsp视图解析器默认使用jstl。

请求处理流程

每当用户在Web浏览器中点击链接或提交表单的时候，请求就开始工作了。对请求的工作描述就像是快递投送员。与邮局投递员一样，请求会将信息从一个地方带到另一个地方。
请求是一个十分繁忙的家伙。从离开浏览器开始到获取响应返回，它会经历好多站，在每站都会留下一些信息同时也会带上其他信息。图5.1展示了请求使用Spring MVC所经历的所有站点。

请求旅程的第一站是Spring的DispatcherServlet。与大多数基于Java的Web框架一样，Spring MVC所有的请求都会通过一个前端控制器（front controller）Servlet。前端控制器是常用的Web应用程序模式，在这里一个单实例的Servlet将请求委托给应用程序的其他组件来执行实际的处理。在Spring MVC中，DispatcherServlet就是前端控制器。

DispatcherServlet的任务是将请求发送给Spring MVC控制器（controller）。控制器是一个用于处理请求的Spring组件。在典型的应用程序中可能会有多个控制器，DispatcherServlet需要知道应该将请求发送给哪个控制器。所以DispatcherServlet以会查询一个或多个处理器映射（handler mapping） 来确定请求的下一站在哪里。处理器映射会根据请求所携带的URL信息来进行决策。
一旦选择了合适的控制器，DispatcherServlet会将请求发送给选中的控制器 。到了控制器，请求会卸下其负载（用户提交的信息）并耐心等待控制器处理这些信息。（实际上，设计良好的控制器本身只处理很少甚至不处理工作，而是将业务逻辑委托给一个或多个服务对象进行处理。）
控制器在完成逻辑处理后，通常会产生一些信息，这些信息需要返回给用户并在浏览器上显示。这些信息被称为模型（model）。不过仅仅给用户返回原始的信息是不够的——这些信息需要以用户友好的方式进行格式化，一般会是HTML。所以，信息需要发送给一个视图（view），通常会是JSP。
控制器所做的最后一件事就是将模型数据打包，并且标示出用于渲染输出的视图名。它接下来会将请求连同模型和视图名发送回DispatcherServlet 。这样，控制器就不会与特定的视图相耦合，传递给DispatcherServlet的视图名并不直接表示某个特定的JSP。实际上，它甚至并不能确定视图就是JSP。相反，它仅仅传递了一个逻辑名称，这个名字将会用来查找产生结果的真正视图。DispatcherServlet将会使用视图解析器（view resolver） 来将逻辑视图名匹配为一个特定的视图实现，它可能是也可能不是JSP。
既然DispatcherServlet已经知道由哪个视图渲染结果，那请求的任务基本上也就完成了。它的最后一站是视图的实现（可能是JSP） ，在这里它交付模型数据。请求的任务就完成了。视图将使用模型数据渲染输出，这个输出会通过响应对象传递给客户端（不会像听上去那样硬编码） 。

1、用户发送请求至前端控制器DispatcherServlet
2、DispatcherServlet收到请求调用HandlerMapping处理器映射器。
3、处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
4、DispatcherServlet通过HandlerAdapter处理器适配器调用处理器,你自己写的controller,有注解形式的，有xml和javaconfig的，适配器会自己处理这些问题
5、执行处理器(Controller，也叫后端控制器)。
6、Controller执行完成返回ModelAndView
7、HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet
8、DispatcherServlet将ModelAndView传给ViewReslover视图解析器
9、ViewReslover解析后返回具体View
10、DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。
11、DispatcherServlet响应用户

示例代码

web.xml

 <!-- spirngMvc前端控制器 -->
  <servlet>
    <servlet-name>spirngMvc0523</servlet-name>
    <servlet-class>
 org.springframework.web.servlet.DispatcherServlet
    </servlet-class>

    <!-- 如果没有指定springMvc核心配置文件那么默认会去找/WEB-INF/+<servlet-name>中的内容 +   -servlet.xml配置文件 -->
    <!-- 指定springMvc核心配置文件位置 -->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:SpringMvc.xml</param-value>
    </init-param>

    <!-- tomcat启动的时候就加载这个servlet -->
    <load-on-startup>1</load-on-startup>
  </servlet>


  <servlet-mapping>
    <servlet-name>spirngMvc0523</servlet-name>
    <url-pattern>*.action</url-pattern>
  </servlet-mapping>

controller

@Controller
public class ItemsController {
@RequestMapping("/list")
    public ModelAndView  itemsList() {
    List<Items> itemList = new ArrayList<>();

//模型和视图
        //model模型: 模型对象中存放了返回给页面的数据
        //view视图: 视图对象中指定了返回的页面的位置
        ModelAndView modelAndView = new ModelAndView();

        //将返回给页面的数据放入模型和视图对象中
        modelAndView.addObject("itemList", itemList);

        //指定返回的页面位置
        //由视图解析器来发送到/WEB-INF/jsp/itemList.jsp
        modelAndView.setViewName("itemList");
        return modelAndView;

    }
}

springMVC.xml

<!-- 配置视图解析器 
    作用:在controller中指定页面路径的时候就不用写页面的完整路径名称了,可以直接写页面去掉扩展名的名称
    -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 真正的页面路径 =  前缀 + 去掉后缀名的页面名称 + 后缀 -->
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/"></property>
        <!-- 后缀 -->
        <property name="suffix" value=".jsp"></property>
    </bean>

    <!-- 如果没有显示的配置处理器映射器和处理器适配那么springMvc会去默认的dispatcherServlet.properties中查找,
        对应的处理器映射器和处理器适配器去使用,这样每个请求都要扫描一次他的默认配置文件,效率非常低,会降低访问速度,所以要显示的配置处理器映射器和
        处理器适配器 -->

        <!-- 注解形式的处理器映射器 -->
<!--         <bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"></bean> -->
        <!-- 注解形式的处理器适配器 -->
<!--         <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"></bean> -->

        <!-- 配置最新版的注解的处理器映射器 -->
<!--         <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"></bean> -->
        <!-- 配置最新版的注解的处理器适配器 -->
<!--         <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"></bean> -->

    <!-- 注解驱动:
        作用:替我们自动配置最新版的注解的处理器映射器和处理器适配器
     -->
    <mvc:annotation-driven></mvc:annotation-driven>

乱码问题

解决post乱码问题

在web.xml中加入：

<filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

对于get请求中文参数出现乱码解决方法有两个：

修改tomcat配置文件添加编码与工程编码一致，如下：

<Connector URIEncoding="utf-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>

另外一种方法对参数进行重新编码：

String userName new 
String(request.getParamter("userName").getBytes("ISO8859-1"),"utf-8")

ISO8859-1是tomcat默认编码，需要将tomcat编码后的内容按utf-8编码

参数绑定

绑定基本类型，pojo,vo

<a href="${pageContext.request.contextPath }/itemEdit.action?id=${item.id}">

/**
     * springMvc中默认支持的参数类型:也就是说在controller方法中可以加入这些也可以不加,  加不加看自己需不需要,都行.
     *HttpServletRequest
     *HttpServletResponse
     *HttpSession
     *Model
     */
    @RequestMapping("/itemEdit")
    public String itemEdit(HttpServletRequest reuqest, 
             Model model) throws Exception{

        String idStr = reuqest.getParameter("id");
        Items items = itmesService.findItemsById(Integer.parseInt(idStr));

        //Model模型:模型中放入了返回给页面的数据
        //model底层其实就是用的request域来传递数据,但是对request域进行了扩展.
        model.addAttribute("item", items);

        //如果springMvc方法返回一个简单的string字符串,那么springMvc就会认为这个字符串就是页面的名称
        return "editItem";
    }

    //springMvc可以直接接收基本数据类型,包括string.spirngMvc可以帮你自动进行类型转换.
    //controller方法接收的参数的变量名称必须要等于页面上input框的name属性值
    //public String update(Integer id, String name, Float price, String detail) throws Exception{

    //spirngMvc可以直接接收pojo类型:要求页面上input框的name属性名称必须等于pojo的属性名称
    @RequestMapping("/updateitem")
    public String update(Items items) throws Exception{
        itmesService.updateItems(items);

        return "success";
    }

    //如果Controller中接收的是Vo,那么页面上input框的name属性值要等于vo的属性.属性.属性.....
    @RequestMapping("/search")
    public String search(QueryVo vo) throws Exception{
        System.out.println(vo);
        return "";
    }

ModelMap是Model接口的实现类，通过Model或ModelMap向页面传递数据。
如果使用Model则可以不使用ModelAndView对象，Model对象可以向页面传递数据，View对象则可以使用String返回值替代。不管是Model还是ModelAndView，其本质都是使用Request对象向jsp传递数据。

---

参数类型推荐使用包装数据类型，因为基础数据类型不可以为null
整形：Integer、int
字符串：String
单精度：Float、float
双精度：Double、double
布尔型：Boolean、boolean
说明：对于布尔类型的参数，请求的参数值为true或false。
处理器方法：
public String editItem(Model model,Integer id,Boolean status) throws Exception
请求url：
http://localhost:8080/xxx.action?id=2&status=false

日期等自定义参数绑定

spring有2种类型转换器,一种是propertyEditor,一种是Converter.虽然都是类型转换,但是还是有细微差别.

---

由于日期数据有很多种格式，所以springmvc没办法把字符串转换成日期类型。所以需要自定义参数绑定。前端控制器接收到请求后，找到注解形式的处理器适配器，对RequestMapping标记的方法进行适配，并对方法中的形参进行参数绑定。在springmvc这可以在处理器适配器上自定义Converter进行参数绑定。如果使用可以在此标签上进行扩展。

自定义Converter

public class CustomGlobalStrToDateConverter implements Converter<String, Date> {

    @Override
    public Date convert(String source) {
        try {
            Date date = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").parse(source);
            return date;
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

}

springMVC.xml配置Converter

<!-- 注解驱动:
            替我们显示的配置了最新版的注解的处理器映射器和处理器适配器 -->
    <mvc:annotation-driven conversion-service="conversionService"></mvc:annotation-driven>
<!-- 配置自定义转换器 
    注意: 一定要将自定义的转换器配置到注解驱动上
    -->
    <bean id="conversionService"
        class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <!-- 指定自定义转换器的全路径名称 -->
                <bean class="cn.itheima.controller.converter.CustomGlobalStrToDateConverter"/>
            </set>
        </property>
    </bean>

---

propertyEditor

//这是局部的日期转换器，只在当前controller有效
@Controller
@RequestMapping(value = "/control")
public class CenterController {

    //每一个Springmvc
    @RequestMapping(value = "/test/springmvc.do")
    public String test(String name,Date birthday){


        System.out.println();
        return "";
    }

/*  @InitBinder
    public void initBinder(WebDataBinder binder, WebRequest request) {
        //转换日期格式
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true));

    }
    }

---

配置全局的转换器

/**
 * 日期自定义转换器
 * @author lx
 *
 */
public class CustomDateEdtor implements WebBindingInitializer {

    @Override
    public void initBinder(WebDataBinder binder, WebRequest request) {
        // TODO Auto-generated method stub
        //转换日期格式
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true));
    }

}

SpringMVC.xml

<!-- 配置全局日期转换器 -->
    <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
        <property name="webBindingInitializer">
            <bean class="cn.itcast.core.web.CustomDateEdtor"/>
        </property>
    </bean>

---

可能有人想到Converter实际上是包含PropertyEditor的,那么如果2种转换器都适用,那么究竟会适用哪种呢?Spring默认是首先查找PropertyEditor,然后再查找Converter.

总结:PropertyEditor适用于String到类型,而Converter更加通用用于类型到类型.PropertyEditor优先级更高.

高级参数绑定

a)数组类型的参数绑定

在商品列表页面选中多个商品，然后删除。
此功能要求商品列表页面中的每个商品前有一个checkbook，选中多个商品后点击删除按钮把商品id传递给Controller，根据商品id删除商品信息。

---

jsp:

<c:forEach items="${itemList }" var="item">
<tr>
    <td><input name="ids" value="${item.id}" type="checkbox"></td>
    <td>${item.name }</td>
    <td>${item.price }</td>
    <td><fmt:formatDate value="${item.createtime}" pattern="yyyy-MM-dd HH:mm:ss"/></td>
    <td>${item.detail }</td>
    <td><a href="${pageContext.request.contextPath }/itemEdit.action?id=${item.id}">修改</a></td>
</tr>
</c:forEach>

生成html代码如下：
页面选中多个checkbox向controller方法传递

<table width="100%" border=1>
<tr>
    <td>商品名称</td>
    <td>商品价格</td>
    <td>生产日期</td>
    <td>商品描述</td>
    <td>操作</td>
</tr>
<tr>
    <td><input name="ids" value="1" type="checkbox"></td>
    <td>台式机</td>
    <td>3000.0</td>
    <td>2016-02-03 13:22:53</td>
    <td></td>
    <td><a href="/springmvc-web/itemEdit.action?id=1">修改</a></td>
</tr>
<tr>
    <td><input name="ids" value="2" type="checkbox"></td>
    <td>笔记本</td>
    <td>6000.0</td>
    <td>2015-02-09 13:22:57</td>
    <td></td>
    <td><a href="/springmvc-web/itemEdit.action?id=2">修改</a></td>
</tr>
<tr>
    <td><input name="ids" value="3" type="checkbox"></td>
    <td>背包</td>
    <td>200.0</td>
    <td>2015-02-06 13:23:02</td>
    <td></td>
    <td><a href="/springmvc-web/itemEdit.action?id=3">修改</a></td>
</tr>
</table>

Controller方法中可以用String[]接收，或者pojo的String[]属性接收。两种方式任选其一即可

@RequestMapping("/queryitem")
    public String queryItem(QueryVo queryVo, String[] ids) {
        System.out.println(queryVo.getItems().getName());
        System.out.println(queryVo.getItems().getPrice());
        System.out.println(ids.toString());
        return null;
    }

把String[] ids放入vo中，自动添加

---

b)List类型的绑定

接收List类型的数据必须是pojo的属性，方法的形参为List类型无法正确接收到数据。

class QueryVo {

List<items> itemList;
}

Jsp改造
html:

<tr>
<td>
<input type="text" name=" itemsList[0].id" value="${item.id}"/>
</td>
<td>
<input type="text" name=" itemsList[0].name" value="${item.name }"/>
</td>
<td>
<input type="text" name=" itemsList[0].price" value="${item.price}"/>
</td>
</tr>
<tr>
<td>
<input type="text" name=" itemsList[1].id" value="${item.id}"/>
</td>
<td>
<input type="text" name=" itemsList[1].name" value="${item.name }"/>
</td>
<td>
<input type="text" name=" itemsList[1].price" value="${item.price}"/>
</td>
</tr>

jsp:

<c:forEach items="${itemList }" var="item">
<tr>
    <td><input name="ids" value="${item.id}" type="checkbox"></td>
    <td>
        <input name="id" value="${item.id}" type="hidden">
        <input name="name" value="${item.name }" type="text">
    </td>
    <td><input name="name" value="${item.price }" type="text"></td>
    <td><input name="name" value="<fmt:formatDate value="${item.createtime}" pattern="yyyy-MM-dd HH:mm:ss"/>" type="text"></td>
    <td><input name="name" value="${item.detail }" type="text"></td>
    <td><a href="${pageContext.request.contextPath }/itemEdit.action?id=${item.id}">修改</a></td>
</tr>
</c:forEach>

controller方法返回值

返回ModelAndView（不推荐）

controller方法中定义ModelAndView对象并返回，对象中可添加model数据、指定view。

返回void（不推荐）

如果controller返回值为void则不走springMvc的组件,没有视图解析器,所以要写页面的完整路径名称.

request.getRequestDispatcher("/WEB-INF/jsp/success.jsp").forward(request, response);

在controller方法形参上可以定义request和response，使用request或response指定响应结果：
1、使用request转向页面，如下：
request.getRequestDispatcher(“页面路径”).forward(request, response);

2、也可以通过response页面重定向：
response.sendRedirect(“url”)

3、也可以通过response指定响应结果，例如响应json数据如下：
response.setCharacterEncoding(“utf-8”);
response.setContentType(“application/json;charset=utf-8”);
response.getWriter().write(“json串”);

返回字符串

逻辑视图名

controller方法返回字符串可以指定逻辑视图名，通过视图解析器解析为物理视图地址。
//指定逻辑视图名，经过视图解析器解析为jsp物理路径：/WEB-INF/jsp/item/editItem.jsp

return "item/editItem";

---

Redirect重定向

Contrller方法返回结果重定向到一个url地址，如下商品修改提交后重定向到商品查询方法，参数无法带到商品查询方法中。

//forward:itemEdit表示相对路径,相对路径就是相对于当前目录,当前为类上面指定的items目录.在当前目录下可以使用相对路径随意跳转到某个方法中
//后面forward:/itemEdit路径中以斜杠开头的为绝对路径,绝对路径从项目名后面开始算

return "redirect:itemEdit/"+items.getId();

//model对象封装了request，就算你重定向也可以把数据传过去

redirect方式相当于“response.sendRedirect()”，转发后浏览器的地址栏变为转发后的地址，因为转发即执行了一个新的request和response。
由于新发起一个request原来的参数在转发时就不能传递到下一个url，如果要传参数可以/item/queryItem.action后边加参数，如下：
/item/queryItem?…&…..

---

forward转发

controller方法执行后继续执行另一个controller方法，如下商品修改提交后转向到商品修改页面，修改商品的id参数可以带到商品修改方法中。

//结果转发到editItem，request可以带过去
return "forward:editItem";

forward方式相当于“request.getRequestDispatcher().forward(request,response)”，转发后浏览器地址栏还是原来的地址。转发并没有执行新的request和response，而是和转发前的请求共用一个request和response。所以转发前请求的参数在转发后仍然可以读取到。

异常处理器

springmvc在处理请求过程中出现异常信息交由异常处理器进行处理，自定义异常处理器可以实现一个系统的异常处理逻辑。
系统中异常包括两类：预期异常和运行时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试通过手段减少运行时异常的发生。
系统的dao、service、controller出现都通过throws Exception向上抛出，最后由springmvc前端控制器交由异常处理器进行异常处理

自定义异常类

public class CustomException extends Exception {

    /** serialVersionUID*/
    private static final long serialVersionUID = -5212079010855161498L;

    public CustomException(String message){
        super(message);
        this.message = message;
    }

    //异常信息
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

自定义异常处理器

public class CustomExceptionResolver implements HandlerExceptionResolver {

    @Override
    public ModelAndView resolveException(HttpServletRequest request,
            HttpServletResponse response, Object handler, Exception ex) {

        ex.printStackTrace();

        CustomException customException = null;

        //如果抛出的是系统自定义异常则直接转换
        if(ex instanceof CustomException){
            customException = (CustomException)ex;
        }else{
            //如果抛出的不是系统自定义异常则重新构造一个系统错误异常。
            customException = new CustomException("系统错误，请与系统管理 员联系！");
        }

        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("message", customException.getMessage());
        modelAndView.setViewName("error");

        return modelAndView;
    }

}

错误页面

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt"  prefix="fmt"%> 
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>错误页面</title>

</head>
<body>
您的操作出现错误如下：<br/>
${message }
</body>

</html>

异常处理器配置,springMVC.xml

<!-- 异常处理器 -->
    <bean id="handlerExceptionResolver" class="cn.itcast.ssm.controller.exceptionResolver.CustomExceptionResolver"/>

图片上传

!-- 多媒体解析器 -->
    <!-- 配置文件上传解析器 -->
    <bean id="multipartResolver"
        class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 设定默认编码 -->
        <property name="defaultEncoding" value="UTF-8"></property>
        <!-- 设定文件上传的最大值5MB，5*1024*1024 -->
        <property name="maxUploadSize" value="5242880"></property>
    </bean>

public String update(MultipartFile pictureFile,Items items, Model model, HttpServletRequest request) throws Exception{
        //1. 获取图片完整名称
        String fileStr = pictureFile.getOriginalFilename();
        //2. 使用随机生成的字符串+源图片扩展名组成新的图片名称,防止图片重名
        String newfileName = UUID.randomUUID().toString() + fileStr.substring(fileStr.lastIndexOf("."));
        //3. 将图片保存到硬盘
        pictureFile.transferTo(new File("E:\\image\\" + newfileName));
        //4.将图片名称保存到数据库
        items.setPic(newfileName);
        itmesService.updateItems(items);

    }

RESTful支持

//以?id=${item.id}来传递参数
<a href="${pageContext.request.contextPath }/items/itemEdit?id=${item.id}">

//restful风格，用@PathVariable来取值
<a href="${pageContext.request.contextPath }/items/itemEdit/${item.id}">

用model的重定向和转发是带着数据过去的，所以是?id=xxx的形式。如果你使用@PathVariable会报错的

//这是restful风格的路径
return "redirect:itemEdit/"+items.getId();

拦截器

Spring Web MVC 的处理器拦截器类似于Servlet 开发中的过滤器Filter，用于对处理器进行预处理和后处理。

拦截器定义

Public class HandlerInterceptor1 implements HandlerInterceptor{

    /**
     * controller执行前调用此方法
     * 返回true表示继续执行，返回false中止执行
     * 这里可以加入登录校验、权限拦截等
     */
    @Override
    Public boolean preHandle(HttpServletRequest request,
            HttpServletResponse response, Object handler) throws Exception {
        // TODO Auto-generated method stub
        Return false;
    }
    /**
     * controller执行后但未返回视图前调用此方法
     * 这里可在返回用户前对模型数据进行加工处理，比如这里加入公用信息以便页面显示
     */
    @Override
    Public void postHandle(HttpServletRequest request,
            HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
        // TODO Auto-generated method stub

    }
    /**
     * controller执行后且视图返回后调用此方法
     * 这里可得到执行controller时的异常信息
     * 这里可记录操作日志，资源清理等
     */
    @Override
    Public void afterCompletion(HttpServletRequest request,
            HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        // TODO Auto-generated method stub

    }

}

拦截器配置

针对某种mapping配置拦截器

<bean
    class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping">
    <property name="interceptors">
        <list>
            <ref bean="handlerInterceptor1"/>
            <ref bean="handlerInterceptor2"/>
        </list>
    </property>
</bean>
    <bean id="handlerInterceptor1" class="springmvc.intercapter.HandlerInterceptor1"/>
    <bean id="handlerInterceptor2" class="springmvc.intercapter.HandlerInterceptor2"/>

---

针对所有mapping配置全局拦截器

<!--拦截器 -->
<mvc:interceptors>
    <!-- 多个拦截器的执行顺序等于springMvc.xml中的配置顺序 -->
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <bean class="cn.itcast.springmvc.filter.HandlerInterceptor1"></bean>
    </mvc:interceptor>
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <bean class="cn.itcast.springmvc.filter.HandlerInterceptor2"></bean>
    </mvc:interceptor>
</mvc:interceptors>

定义两个拦截器分别为：HandlerInterceptor1和HandlerInteptor2，每个拦截器的preHandler方法都返回true。

运行流程

HandlerInterceptor1..preHandle..
HandlerInterceptor2..preHandle..

HandlerInterceptor2..postHandle..
HandlerInterceptor1..postHandle..

HandlerInterceptor2..afterCompletion..
HandlerInterceptor1..afterCompletion..

中断流程测试

HandlerInterceptor1的preHandler方法返回false，HandlerInterceptor2返回true，运行流程如下：

HandlerInterceptor1..preHandle..

从日志看出第一个拦截器的preHandler方法返回false后第一个拦截器只执行了preHandler方法，其它两个方法没有执行，第二个拦截器的所有方法不执行，且controller也不执行了。

HandlerInterceptor1的preHandler方法返回true，HandlerInterceptor2返回false，运行流程如下：

HandlerInterceptor1..preHandle..
HandlerInterceptor2..preHandle..
HandlerInterceptor1..afterCompletion..

从日志看出第二个拦截器的preHandler方法返回false后第一个拦截器的postHandler没有执行，第二个拦截器的postHandler和afterCompletion没有执行，且controller也不执行了。

总结：
preHandle按拦截器定义顺序调用
postHandler按拦截器定义逆序调用
afterCompletion按拦截器定义逆序调用

postHandler在拦截器链内所有拦截器返成功调用
afterCompletion只有preHandle返回true才调用

拦截器应用

a)拦截用户请求，判断用户是否登录
b)如果用户已经登录。放行
c)如果用户未登录，跳转到登录页面。

Public class LoginInterceptor implements HandlerInterceptor{

    @Override
    Public boolean preHandle(HttpServletRequest request,
            HttpServletResponse response, Object handler) throws Exception {

        //如果是登录页面则放行
        if(request.getRequestURI().indexOf("login.action")>=0){
            return true;
        }
        HttpSession session = request.getSession();
        //如果用户已登录也放行
        if(session.getAttribute("user")!=null){
            return true;
        }
        //用户没有登录挑战到登录页面
        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);

        return false;
    }
}

---

不知道从哪个版本开始，Spring MVC的mvc命名空间开始支持exclude-mapping。反正笔者最开始写这篇博文的时候是基于Spring3.1.0所写，那时候的mvc命名空间下是没有execlude-mapping定义的。但是笔者现在使用的Spring4.1.0是有exclude-mapping定义的。所以基于该版本补充Spring MVC拦截器的exclude-mapping的用法。mapping只能映射某些需要拦截的请求，而exclude-mapping用来排除某些特定的请求映射。当我们需要拦截的请求映射是比较通用的，但是其中又包含了某个特殊的请求是不需要使用该拦截器的时候我们就可以把它定义为exclude-mapping了。比如像下面示例这样，我们定义的拦截器将拦截所有匹配/interceptor/**模式的请求，但是不能拦截请求“/interceptor/b”，因为它定义为了exclude-mapping。当定义了exclude-mapping时，Spring MVC将优先判断一个请求是否在execlude-mapping定义的范围内，如果在则不进行拦截。

<mvc:interceptors>  
    <mvc:interceptor>  
        <mvc:mapping path="/interceptor/**" />  
        <mvc:exclude-mapping path="/interceptor/b" /><!--  
            不匹配的 -->  
        <bean class="com.host.app.web.interceptor.MyInterceptor" />  
    </mvc:interceptor>  
</mvc:interceptors>  

虽然笔者的示例中interceptor下面定义的mapping只有一个，但实际上一个interceptor下面定义的mapping和exclude-mapping都是可以有多个的。

另外，exclude-mapping的定义规则和mapping的定义规则是一样的，我们也可以使用一个星号表示任意字符，使用两个星号表示任意层次的任意字符。比如下面这样。

<mvc:interceptors>  
    <mvc:interceptor>  
        <mvc:mapping path="/interceptor/**" />  
        <mvc:exclude-mapping path="/interceptor/b/*" /><!--  
            不匹配的 -->  
        <bean class="com.elim.learn.spring.mvc.interceptor.MyInterceptor" />  
    </mvc:interceptor>  
</mvc:interceptors>