SpringMVC -- 必知必会

　　SpringMVC基于模型--视图--控制器（Model-View-Controller，MVC）模式实现，属于SpringFrameWork的后续产品，已经融合在SpringWebFlow里面。它通过一套注解，让一个简单的Java类成为处理请求的控制器，而无需实现任何接口。同时它还支持RESTful编程风格的请求。SpringMVC是基于方法设计的，相比基于类设计的Struts2要稍微快一些。

一.使用步骤

第一步：导入jar包或Maven坐标

<!-- 这里导入spring-webmvc即可，会自动导入它依赖的其他jar包 -->

<dependency>

   <groupId>org.springframework</groupId>

   <artifactId>spring-webmvc</artifactId>

   <version>5.0.2.RELEASE</version>

</dependency>

第二步：修改并配置web.xml文件

<!-- 修改配置文件头约束为如下：（可到tomcat的web.xml中复制 -->

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee

                      http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"

         version="3.1">

    <!-- 1.配置核心控制器 -->

    <servlet>

        <servlet-name>dispathcerServlet</servlet-name>

        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!-- 配置核心控制器的初始化参数,指定spring的配置文件 -->

        <init-param>

            <param-name>contextConfigLocation</param-name>

            <param-value>classpath:webApplicationContext.xml</param-value>

        </init-param>

        <!-- servlet初始化时机:服务器启动第一个加载 -->

        <load-on-startup>1</load-on-startup>

    </servlet>

    <!-- 2.配置映射路径 -->

    <servlet-mapping>

        <servlet-name>dispathcerServlet</servlet-name>

        <!-- / 代表默认,用其可使用spring的REST风格的url -->

        <url-pattern>/</url-pattern>

    </servlet-mapping>

    <!-- 3.配置编码过滤器：解决post中文乱码问题 -->

    <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>

</web-app>

第三步：创建SpringMVC的配置文件

webApplicationContext.xml

<!-- 1.指定要扫描的包 -->

<context:component-scan base-package="cn.dintalk"/>

<!-- 2.开启mvc的注解驱动-->

<mvc:annotation-driven/>

<!-- 3.配置解析器 -->

<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">

    <property name="prefix" value="/WEB-INF/jsp/"/>

    <property name="suffix" value=".jsp"/>

</bean>

第四步：编写控制器（POJO) ★★★

@Controller

@RequestMapping("/user") //适合模块化开发(不加也可以)

public class HelloController {

   //1. 根据url地址进行url映射(handlerMapping)

    @RequestMapping("/hello")

    public String hello(){

        System.out.println("我的第一个处理器执行了..");

        return "hello";

    }

第五步：编写页面 ★★★

我们在页面中的链接如 .../user/hello便会访问到该方法

总结：完成一次请求的过程

二.URL映射

url映射的规则，主要在添加@RequestMapping注解时指定

//1. 指定单个url地址映射(handlerMapping)

@RequestMapping("/hello")

public String hello(){

//2. 指定多个url地址映射，但需保证不能和其他方法有重复的。

//思考一下为什么。

@RequestMapping({"/hello2","hello1"})

public String hello1(){

//3. 根据请求方式进行映射

@RequestMapping(path = "/hello3",method = RequestMethod.POST)

public String hello3(){

//若当前处理器添加了模块映射：如/user，那么该方法会拦截到所有以POST方式

//请求到该处理器（请求路径以/user结尾，即未定位到指定方法）的请求

@RequestMapping(method = RequestMethod.POST)

    public String hello4(){

//4. 根据请求参数进行映射

//params指定后，若不传参则会报错

@RequestMapping(path = "/hello5",params = {"name","password"})

    public String hello5(String name,String password){

//5. 根据请求消息头进行映射

//不携带cookie消息头就会报错

@RequestMapping(path = "/hello6",headers = {"cookie"})

    public String hello6(){

//6. 根据请求的正文mime类型进行映射

//只有post请求才会有正文

@RequestMapping(path = "/hello7",

    method = RequestMethod.POST,consumes = "multipart/form-data")

    public String hello7(){

三.请求参数的封装

1.简单类型的封装

//处理器的方法,springmvc会自动进行数据类型转换，转换失败则报错

@RequestMapping(path = "/param",params ={"name","age"} )

public String param(String name, Integer age){

//jsp页面

<a href="${pageContext.request.contextPath}/param?name=song&age=21">简单参数的封装</a>

2.数组的封装

//处理器的方法

@RequestMapping(path = "/param1")

public String param1(String[] myAr){

//jsp页面

<form  action="${pageContext.request.contextPath}/param1" method="post">

    arr:<input name="myArr" value="song">

    arr:<input name="myArr" value="hui">

    <%-- hui1会覆盖掉hui --%>

    arr:<input name="myArr[1]" value="hui1">

    arr:<input name="myArr" value="慧">

    <input type="submit" value="封装数组myArr">

</form>

//页面传参数时，后边指定角标的会将前面的覆盖掉

3.POJO的封装

//处理器的方法

@RequestMapping(path = "/param2",params ={"name","age"} )

public String param2(User user){

//jsp页面

<a href="${pageContext.request.contextPath}/param2?name=song&age=21">POJO的封装</a>

4.封装POJO关联的POJO

//处理器的方法

@RequestMapping(path = "/param3")

public String param3(User user){

//jsp页面

<form  action="${pageContext.request.contextPath}/param3" method="post">

    name:<input name="name" value="song"/>

    name:<input name="password" value="hui"/>

    address:<input name="address.province" value="bj">

    address:<input name="address.city" value="zjk">

    <input type="submit" value="封装pojo关联的pojo">

</form>

//封装user中关联的address

5.封装POJO关联的数组

//处理器的方法

@RequestMapping(path = "/param4")

public String param4(User user){

//jsp页面

<form  action="${pageContext.request.contextPath}/param4" method="post">

    name:<input name="name" value="song"/>

    arr:<input name="myArr" value="s">

    arr:<input name="myArr" value="hui">

    <%-- hui1会覆盖掉hui --%>

    arr:<input name="myArr[1]" value="hui1">

    <input type="submit" value="封装pojo关联的arr">

</form>

//页面传参数时，后边指定角标的会将前面的覆盖掉

6.封装POJO关联的List

//处理器的方法

@RequestMapping(path = "/param5")

public String param5(User user){

//jsp页面

<form  action="${pageContext.request.contextPath}/param5" method="post">

    name:<input name="name" value="song"/>

    list:<input name="myList" value="1">

    list:<input name="myList" value="hui">

    <input type="submit" value="封装pojo关联的list">

</form>

7.封装POJO关联的Map

//处理器的方法

 @RequestMapping(path = "/param6")

public String param6(User user){

//jsp页面

<form  action="${pageContext.request.contextPath}/param6" method="post">

    name:<input name="name" value="song"/>

    map:<input name="myMap['s']" value="song">

    map:<input name="myMap[s1]" value="hui">

    <input type="submit" value="封装pojo关联的map">

</form>

//页面传参数指定map的key可用单引号也可不用

四.请求的转发和重定向

//请求转发

@RequestMapping("/hello")

public String hello(){

    System.out.println("我的第一个处理器执行了..");

    return "hello";  // 服务器默认用的是请求转发

}

@RequestMapping("/hello1")

public String hello1(){

    System.out.println("我的第一个处理器执行了..");

    // 自己转发的话，必须用实际视图地址

    return "forward:/WEB-INF/pages/hello.jsp";

}

//请求重定向

@RequestMapping("/hello2")

public String hello2(){

    System.out.println("我的第一个处理器执行了..");

    // 重定向

    return "redirect:http://www.baidu.com";

}

五.SpringMVC下静态资源的访问

　　我们在Spring MVC框架中为了是URL更符合RESTful风格，通常在web.xml中会配置Spring框架servlet 的 url 拦截为 "/" ,也就是拦截所有资源的url请求，这样一来，所有的资源包括， js | css | 图片 | 所有静态资源都将经过框架的servlet拦截。而又没有对应的处理器，因此会找不到资源（404）。因此我们要对静态资源放行：

第一种方法：激活web应用服务器（如Tomcat）的defaultServlet来处理静态文件

web.xml中加入以下配置

<servlet-mapping>

    <servlet-name>default</servlet-name>

    <url-pattern>*.jpg</url-pattern>

</servlet-mapping>

<servlet-mapping>

    <servlet-name>default</servlet-name>

    <url-pattern>*.js</url-pattern>

</servlet-mapping>

<servlet-mapping>

    <servlet-name>default</servlet-name>

    <url-pattern>*.css</url-pattern>

</servlet-mapping>

Tips: 要配置多个，每种文件配置一个,要写在DispatcherServlet的前面,让defaultServlet先拦截，这样就不会进入Spring了，可能性能是最好的。

第二种方法：使用Spring3.0.4以后版本提供的 <mvc:resources />

webApplicationContext.xml中加入以下配置

<mvc:resources mapping="/static/**" location="/static/" />

<!-- 不加下面这句话可能会报错 -->

<mvc:annotation-driven />

Tips: location的值要配到最后一个/ ,如果这里只写到 /static 还是放行不了的。

第三种方法：使用 <mvc:default-servlet-handler/ >

webApplicationContext.xml中加入以下配置

<mvc:default-servlet-handler default-servlet-name="default"/>

Tips：如果用后两种方法的话加载一个静态资源是却要经过框架servlet的层层pattern，会有不必要的性能开销。但对于一些比较重要的静态文件，我们可以将其放在WEB-INF目录下保护起来（该目录下不可直接访问 )，但我们可以在服务端应用(请求转发)。

六.常用注解、异步交互和Restful风格的url

1.常用注解

//1. @RequestParam:可处理请求参数名和处理器方法参数名不一致的情况

@RequestMapping("demo1")

//RequestParam默认required=true,指必须提供,否则报错!将username参数赋值给name

public String demo1(@RequestParam(value = "username",required = false)String name){

//2. @RequestHeader:用指定消息头为处理器参数赋值

@RequestMapping("demo2")

public String demo2(@RequestHeader("accept-encoding")String encode){

//3. @CookieValue:获取cookie的值给处理器参数赋值

@RequestMapping("demo3")

public String demo3(@CookieValue("JSESSIONID")String JsessionId){

//4. @RequestBody:获取请求消息正文,注意只有post请求才有正文

@RequestMapping("demo4")

public String demo4(@RequestBody String Content){

//5. @ModelAttribute:用在参数上，获取指定数据给参数赋值（无对应数据会报错）

@RequestMapping("demo5")

public String demo5(@ModelAttribute("user1") User user1){

//6. @ModelAttribute:用在方法上，会在控制器任意方法执行前执行

    //会把方法的返回值以指定名称存到域对象中。无返回值可通过隐式对象存数据

@ModelAttribute("user")

public User createUser(){

//7. @SessionAttributes:用在类定义上,将存放在model中对应的数据暂存到HttpSession 中。

    //会将model中所有类型为 User的属性添加到会话中。

@SessionAttributes(types=User.class)

    //会将model中属性名为user1和user2的属性添加到会话中。

@SessionAttributes(value={“user1”, “user2”})

    //会将model中所有类型为 User和Dept的属性添加到会话中。

@SessionAttributes(types={User.class, Address.class})

    //会将model中属性名为user1和user2以及类型为Dept的属性添加到会话中。

@SessionAttributes(value={“user1”,“user2”},types={Address.class})

//需要注意的是,value和types之间是取并集的关系

//8. @ResponseBody:将方法返回的对象，通过 HttpMessageConverter接口转换为指定格式的

    //数据如：json,xml 等，通过 Response 响应给客户端

@RequestMapping("/demo8")

@ResponseBody  // 也可加到返回值前面，即User前面：public @ResponseBody User ...

public User demo8(){

//9. @PathVariable:绑定url中占位符如请求url中/delete/{id}，这个{id}就是url占位符。

    //将其赋给处理器参数，结合method=...,可实现rest风格的url

@RequestMapping(value = "/user/{id}",method = RequestMethod.GET)

public String find(@PathVariable("id") Integer uid){

Tips: @ModelAttribute用在参数上是从请求域中获取指定数据赋给参数，用在方法上是每一次访问该处理器的任意方法前都会执行该方法。可将所修饰的方法返回值以指定名称存入请求域中。

2.异步交互

　　使用SpringMVC如何完成ajax的异步交互呢？很简单，我们主要使用它的两个注解来实现:

导入jackson的jar包或Maven坐标

<!-- 该包依赖的其他包会自动导入 -->

<dependency>

  <groupId>com.fasterxml.jackson.core</groupId>

  <artifactId>jackson-databind</artifactId>

  <version>2.9.0</version>

</dependency>

2.1@RequestBody接受异步请求

处理器方法

@RequestMapping("/demo1")

public String demo1(@RequestBody String content) throws IOException {

    ObjectMapper objectMapper = new ObjectMapper();

    //使用jackson解析json数据封装到pojo中

    User user = objectMapper.readValue(content, User.class);

    System.out.println(user);

    System.out.println("异步请求到了");

    return "success";

}

异步请求页面

$(function () {

   $("#b1").click(function () {

       $.ajax({

           type: "POST",

           url: "${pageContext.request.contextPath}/json/demo1",

           dataType: "json",

           contentType: "application/json",

           data: '{"name":"song","password":"hui"}'

       });

   });

})

Tips: 如果不加入contentType:"application/json"会解析失败，因为加入它才会发送json格式的数据。

2.2@ResponseBody返回Json数据

处理器方法

@RequestMapping("/demo2")

@ResponseBody

public User demo2() {

    User user = new User();

    user.setName("da");

    user.setUid(22);

    return user;

}

异步请求页面

$(function () {

    $("#b2").click(function () {

        $.ajax({

            type: "POST",

            url: "${pageContext.request.contextPath}/json/demo2",

            data: '{"name":"song","password":"hui"}',

            dataType: "json",

            contentType: "application/json",

            success: function (data) {

                alert(data.uid);

                alert(data.name);

            }

        });

    });

})

3.Restful风格的url

3.1restful的状态转化特性

　　HTTP 协议，是一个无状态协议，即所有的状态都保存在服务器端。因此，如果客户端想要操作服务器，必须通过某种手段，让服务器端发生 “状态转化 ”（ State Transfer）。而这种转化是建立在表现层之上的，所以就是 “表现层状态转化 ”。具体说，就是 HTTP 协议里面，四个表示操作方式的动词： GET、 POST、 PUT、DELETE。它们分别对应四种基本操作： GET 用来获取资源， POST 用来新建资源， PUT 用来更新资源， DELETE 用来删除资源。

restful 的示例：/account/1 HTTP GET ：得到 id = 1 的 account/account/1 HTTP DELETE ：删除 id = 1 的 account/account/1 HTTP PUT ：更新 id = 1 的 account/account HTTP POST ：新增 account

3.2基于HiddenHttpMethodFilter使用@PathVariable注解构建rest风格的url

　　由于浏览器 form 表单只支持 GET 与 POST 请求，而 DELETE、PUT 等 method 并不支持，Spring3.0 添加了一个过滤器，可以将浏览器请求改为指定的请求方式，发送给我们的控制器方法，使得支持 GET、POST、PUT与 DELETE 请求。

第一步：web.xml中配置过滤器

<!-- 配置过滤器将表单不支持的请求方式转化(支持restful风格) -->

<filter>

    <filter-name>hiddenHttpMethodFilter</filter-name>

    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>

</filter>

<filter-mapping>

    <filter-name>hiddenHttpMethodFilter</filter-name>

    <url-pattern>/*</url-pattern>

</filter-mapping>

第二步：表单书写

<!-- 对于不支持的请求方式,get，post之外的：form表单的method要指定为post

    并且要添加隐藏域。

-->

<form method="post" action="${pageContext.request.contextPath}/user">

    username:<input name="name" value="admin"/><br/>

    <input type="submit" value="注册"/>

</form>

<form method="post" action="${pageContext.request.contextPath}/user/1">

    <input type="hidden" name="_method" value="PUT">

    username:<input name="name" value="admin1"/><br/>

    <input type="submit" value="修改"/>

</form>

<form method="get" action="${pageContext.request.contextPath}/user/1">

    <input type="submit" value="查询"/>

</form>

<form method="post" action="${pageContext.request.contextPath}/user/1">

    <input type="hidden" name="_method" value="DELETE">

    <input type="submit" value="删除"/>

</form>

第三步：处理器方法

@RequestMapping(value = "/user",method = RequestMethod.POST)

public String regist(User user){return "success";}

//{id}参数的占位符

@RequestMapping(value = "/user/{id}",method = RequestMethod.PUT)

public String edit(@PathVariable("id") Integer uid, User user){return "success";}

@RequestMapping(value = "/user/{id}",method = RequestMethod.GET)

public String find(@PathVariable("id") Integer uid){return "success";}

@RequestMapping(value = "/user1{id}",method = RequestMethod.DELETE)

public String delete(@PathVariable("id") Integer uid){return "success";}

七.原始servletAPI、隐式对象和处理器返回值

1.原始servletAPI

　　要使用原始的servletAPI，我们在处理器方法中直接定义参数即可，框架会为我们传入对象。

第一步：导入servlet的jar包或Maven坐标

<dependency>

  <groupId>javax.servlet</groupId>

  <artifactId>javax.servlet-api</artifactId>

  <version>3.1.0</version>

  <scope>provided</scope>

</dependency>

第二步：处理器方法定义参数

@RequestMapping("/demo1")

public String demo1(HttpServletRequest req, HttpServletResponse res){

    System.out.println(req+"==="+res);

2.隐式对象

　　SpringMVC为我们提供好了默认的隐式对象，我们直接使用即可。使用Model,ModelMap和Map可以封装数据到模型对象中（request域级别）。同使用servletAPI一样，我们在处理器方法上定义参数即可使用。

//Model对象

@RequestMapping("/demo2")

public String demo2(Model model){

     User user = new User();

    user.setName("user2");

    model.addAttribute("user",user);

    return "success";

}

//ModelMap对象

@RequestMapping("/demo3")

public String demo3(ModelMap model){

    User user = new User();

    user.setName("user3");

    model.addAttribute("user",user);

    return "success";

}

//Map对象

@RequestMapping("/demo4")

public String demo4(Map model){

    User user = new User();

    user.setName("user4");

    model.put("user",user);

    return "success";

}

Tips: 当然，我们也可以在处理器方法内部直接通过new创建其对象来使用。

3.处理器返回值

　　controller方法的返回值有三种：String、void、ModelAndView。

3.1String

// 返回字符串指定逻辑视图名称，通过视图解析器解析为

// 真实视图地址。

@RequestMapping("/demo1")

public String demo1(){

    return "success";

}

3.2void

// 方法无返回值，我们可以用servletAPI完成转发、重定向、响应。

// 转发

request.getRequestDispatcher("1.jsp").forward(request,response);

//重定向:这里重定向到了当前处理器的demo1方法

response.sendRedirect("demo1")

//直接响应：如json数据

response.setCharacterEncoding("utf-8");

response.setContentType("application/json;charset=utf-8");

response.getWriter().write("我是json串");

3.3ModelAndView

@RequestMapping("/demo3")

public ModelAndView demo3(){

    User user = new User();

    user.setName("haha");

    ModelAndView modelAndView = new ModelAndView();

    modelAndView.setViewName("success");//指定视图

    modelAndView.addObject("user",user);//存放数据

    return modelAndView;

}

八.自定义类型转化器、拦截器和异常

1.自定义类型转换器

　　SpringMVC内置简单类型转换器，所以我们在进行参数封装时SpringMVC会根据类型为我们进行自动转换。开发中，我们可根据需求自定义类型转化器，通过配置加入到SpringMVC的转换器列表中即可。比如我们常常需要将用户输入的日期字符串转换成日期类型的，即String -->java.util.Date的转换。

第一步：自定义类实现Converter<S, T>接口

//自定义类实现了org.springframework.core.convert.converter.Converter 接口

public class DateLocalConvertor implements Converter<String, Date> {

    public String pattern = "yyyy-MM-dd";

    //定义默认日期格式，并提供set方法使其可在配置文件中配置

    public void setPattern(String pattern) {

        this.pattern = pattern;

    }

    //实现接口的转换方法：Source -->Target

    @Override

    public Date convert(String s) {

        if (!StringUtils.isEmpty(s)) {

            try {

                SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);

                Date date = simpleDateFormat.parse(s);

                return date;

            } catch (ParseException e) {

                throw new RuntimeException("您输入的日期格式必须符合"+pattern+"格式");

            }

        } else {

            return null;

        }

    }

}

第二步：注册自定义类型转换器到SpringMVC中

webApplicationContext.xml

<!-- 配置类型转换器工厂 -->

<bean id="converterService" class="org.springframework.context.support.

                                   ConversionServiceFactoryBean">

    <!-- 1.相当于调用了set方法,给工厂注入新的类型转换器  -->

    <property name="converters">

        <!-- 若将来有多个自定义的类型转化器,可以用array标签包裹多个bean -->

        <bean class="cn.dintalk.convertor.DateLocalConvertor"/>

    </property>

</bean>

<!-- 引用自定义类型转化器 -->

<mvc:annotation-driven conversion-service="converterService"/>

第三步：使用

　　如此，我们在前端页面输入日期字符串后，处理器方法在进行封装时会用到我们自定义的类型转换器。否则没有日期类型转换器的话，而又有日期类型的数据封装的话会报400错误。

2.自定义拦截器

　　SpringMVC的处理器拦截器类似于Servlet中的过滤器Filter，用于对处理器进行预处理和后处理。但又有区别：

过滤器：是servlet中的规范，任何java web工程都可使用。
拦截器：是SpringMVC框架的，使用了SpringMVC的工程才能用。
过滤器：配置了url-pattern为 /*后，可拦截所有的资源访问。
拦截器：只拦截访问的控制器的方法，不拦截jsp、html、img等。

我们要自定义拦截器，就必须实现接口：HandlerInterceptor。

第一步：编写普通类实现HandlerInterceptor接口

public class MyInterceptor implements HandlerInterceptor {

    @Override

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

        System.out.println("到达处理器前的方法执行了");

        return true; // 返回true这放行,否则拦截

    }

    @Override

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

        System.out.println("处理器方法执行之后执行的方法执行了");

    }

    @Override

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

        System.out.println("页面完成响应之前的方法执行了");

    }

}

第二步：在webApplicationContext.xml中配置拦截器

<!-- 配置拦截器 -->

<mvc:interceptors>

    <mvc:interceptor>

        <!-- 拦截/inter开头的访问路径 -->

        <mvc:mapping path="/inter/**"/>

        <bean class="cn.dintalk.web.interceptor.MyInterceptor"/>

    </mvc:interceptor>

    <mvc:interceptor>

        <!-- 拦截/user开头的访问路径 -->

        <mvc:mapping path="/user/**"/>

        <!-- 排除/user/login的访问路径(不进行拦截) -->

        <mvc:exclude-mapping path="/user/login"/>

        <bean class="cn.dintalk.web.interceptor.CheckUserInterceptor"/>

    </mvc:interceptor>

</mvc:interceptors>

Tips: 自定义拦截器一般实现第一个方法,即在请求到达处理器前进行拦截作相应处理以决定是否放行;多个处理器的执行顺序按照其配置的上下顺序。

3.自定义异常

3.1异常处理思路

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

3.2编写自定义异常类和错误页面

自定义异常继承Exception,生成构造方法即可

public class CustomException extends Exception {

    public CustomException() {

    }

    public CustomException(String message) {

        super(message);

    }

    public CustomException(String message, Throwable cause) {

        super(message, cause);

    }

    public CustomException(Throwable cause) {

        super(cause);

    }

    public CustomException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {

        super(message, cause, enableSuppression, writableStackTrace);

    }

}

编写错误页面error.jsp用以展示提示信息。

3.3自定义异常处理器

//编写普通类实现org.springframework.web.servlet.HandlerExceptionResolver接口

public class CustomExceptionResolver implements HandlerExceptionResolver {

@Override

public ModelAndView resolveException(HttpServletRequest httpServletRequest,

                                     HttpServletResponse httpServletResponse,

                                     Object o, Exception e) {

    CustomException exception = null;

    if (e instanceof CustomException){//若是自定义异常则转换

        exception = (CustomException)e;//使用时就封装好了消息

    }else {//其他的异常,用自定义异常提示系统繁忙

        exception = new CustomException("系统繁忙");

    }

    ModelAndView modelAndView = new ModelAndView();

    modelAndView.setViewName("error");

    modelAndView.addObject("msg",exception.getMessage());

    return modelAndView;

}

}

3.4配置异常处理器

<!-- 配置异常处理器 -->

<bean id="customExceptionResolver" class="cn.dintalk.web.resolver.CustomExceptionResolver"/>

如此,当程序发生异常的时候,我们就可以截获异常,给用户一个友好的提示。

九.文件的上传

要实现上传文件，对form表单有一定的要求：

method必须是：post
表单的enctype：必须是 "multipart/form-data"
表单中提供type="file"的上传输入域

Tips: 表单的enctype默认值为：application/x-www-form-urlencoded。修改为"multipart/form-data"后request.getParameter()等方法便获取不到数据了。

1.准备上传页面

<h1>上传练习</h1>

<form enctype="multipart/form-data" method="post"

      action="${pageContext.request.contextPath}/upload/demo1">

    name:<input type="text" name="username" value="宋hui">

    file:<input type="file" name="photo">

    <input type="submit" value="上传">

</form>

2.使用Commons-fileupload组件实现上传

第一步：导入jar包或Maven坐标

<!-- 这里会自动导入其所依赖的commos-io包 -->

<dependency>

  <groupId>commons-fileupload</groupId>

  <artifactId>commons-fileupload</artifactId>

  <version>1.3.1</version>

</dependency>

第二步：编写上传控制器

@Controller

@RequestMapping("/upload")

public class UploadController {

    @RequestMapping("/demo1")

    public String demo1(HttpServletRequest request) throws Exception {

        //1.创建文件保存目录

        String rootDir = request.getServletContext().getRealPath("files");

        String chiledDir = new SimpleDateFormat("yyyy-MM-dd").format(new Date());

        File dir = new File(rootDir, chiledDir);

        if (!dir.exists())

            dir.mkdirs();

        //2.创建文件解析工厂

        DiskFileItemFactory diskFileItemFactory = new DiskFileItemFactory();

        //3.获取解析器

        ServletFileUpload upload = new ServletFileUpload(diskFileItemFactory);

        List<FileItem> fileItems = upload.parseRequest(request);

        for (FileItem fileItem : fileItems) {

            if (fileItem.isFormField()) {//是普通字段

                System.out.println(fileItem.getFieldName());//字段的name

                System.out.println(fileItem.getString("utf-8"));//字段值

            } else { // 上传的文件

                String fileName = fileItem.getName();//获取文件名

                String exName = fileName.substring(fileName.lastIndexOf("."));//截取扩展名

                String uuidName = UUID.randomUUID().toString().replace("-", "") + exName;

                System.out.println(uuidName);

                File target = new File(dir, uuidName);

                fileItem.write(target); //写入文件

                fileItem.delete();//清除临时目录中的缓存

            }

        }

        return "success";

    }

}

3.使用SpringMVC提供的组件上传

　　底层使用的还是apache的commons-fileupload组件。

第一步：导入jar包或Maven坐标

<!-- 这里会自动导入其所依赖的commos-io包 -->

<dependency>

  <groupId>commons-fileupload</groupId>

  <artifactId>commons-fileupload</artifactId>

  <version>1.3.1</version>

</dependency>

第二步：编写上传控制器

@Controller

@RequestMapping("/upload")

public class UploadController {

    @RequestMapping("/demo2")

    //参数名称需和表单的输入域名称保持一致

    public String demo2(HttpServletRequest request, String username, MultipartFile photo) throws IOException {

        //1.创建目录

        String rootDir = request.getServletContext().getRealPath("files");

        String chiledDir = new SimpleDateFormat("yyyy-MM-dd").format(new Date());

        File dir = new File(rootDir, chiledDir);

        if (!dir.exists())

            dir.mkdirs();

        //2.读取数据进行保存

        String fileName = photo.getOriginalFilename();//获取文件名

        String exName = fileName.substring(fileName.lastIndexOf("."));//截取扩展名

        String uuidName = UUID.randomUUID().toString().replace("-", "") + exName;

        System.out.println(uuidName);

        File target = new File(dir, uuidName);

        photo.transferTo(target);//存放文件

        return "success";

    }

}

第三步：配置文件解析器

webApplicationContext.xml文件

<!-- 上传文件解析器配置：id值是固定的 -->

<bean id="multipartResolver"

      class="org.springframework.web.multipart.commons.CommonsMultipartResolver">

    <!-- 设置默认编码 -->

    <property name="defaultEncoding" value="utf-8"/>

    <!-- 最大文件大小：字节为单位，这里配置文5M -->

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

</bean>

SpringMVC的使用就总结这么多 ~ _ ~