基于maven学习SpringMVC笔记包含环境搭建、springMVC特有的方式收参，流程跳转、参数传递、注解开发、文件上传下载、拦截器、全局异常处理

本文链接：https://blog.csdn.net/qq_44025656/article/details/89605545

springMVC笔记

引言

概念： 是MVC开发中控制层的框架，解决对应的控制层的问题
作用：1.接收数据
      2.调用业务
      3.流程跳转
优势：1.SpringMVC是spring体系的一个组成部分，可以与Spring体系无缝对接
     2.SpringMVC无论从开发效率或者运行效率都比Struts2高很多

第一个SpringMVC程序的开发

1 环境搭建引入相关依赖 pom.xml

 <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <!--javaEE规范-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <scope>provided</scope>
    </dependency>
    <!--spring相关jar-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>4.3.2.RELEASE</version>
      <scope>test</scope>
    </dependency>

    <!--引入springmvc-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>

2.初始化web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>

  <!--读取spring.xml 文件-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring.xml</param-value>
  </context-param>
  <!--配置SpringMVC解决POST方式乱码的过滤器-->
  <filter>
    <filter-name>encodingFilter</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>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>


  <!--配置Spring的监听工厂-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>


  <!--配置SpringMVC的核心类-->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--读取SpringMVC的配置文件-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <!--伴随tomcat的启动进行加载-->
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <!--访问后台的URL-->
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>

</web-app>

3.dispatcher.xml (springMVC配置文件)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!--配置注解 告知springMVC在哪个包下使用注解-->
    <context:component-scan base-package="com.baizhi.*"></context:component-scan>
<!--配置视图解析器-->
    <bean id="resourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--配置前缀-->
        <property name="prefix">
            <value>/</value>
        </property>
        <!--配置后缀-->
        <property name="suffix">
            <value>.jsp</value>
        </property>
    </bean>
    <!--集合url解析器-->
    <mvc:annotation-driven></mvc:annotation-driven>
 </beans>

1SpringMVC路径访问 get/post

package com.baizhi.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
 * @Controller 作用 创建action对象
 * @RequestMapping("/Testfirst") 书写在类上相当于包名 访问该类的访问路径
 * */
@Controller
@RequestMapping("/Testfirst")
public class FirstController {
    /**
     *   @RequestMapping("/first")  书写在方法上 访问该方法的路径
     *   此处定义方法的语法： public String 方法名随意 throws Exception{ return "";}
     * */
    @RequestMapping("/first")
    public String first()throws  Exception{
        System.out.println ("我是第一个springMVC程序");
        //调转到index.jsp中
        return "index";
    }
    /**
     * 表示 该方法只能用get方法访问
     * */
@RequestMapping(value = "/seconde",method = RequestMethod.GET)
    public String seconde()throws Exception{
    System.out.println ("我是第二个springMVC程序");
        return "index";
    }


    /**
     * 表示 该方法只能用get方法访问
     * */
    @RequestMapping(value = "/three",method = RequestMethod.POST)
    public String san()throws Exception{
        System.out.println ("我是第三个springMVC程序");
        return "index";
    }

    /**
     * 表示 该方法可以用get/post两种方法访问
     * */
    @RequestMapping(value = "/four",method ={RequestMethod.POST,RequestMethod.GET})
    public String four()throws Exception{
        System.out.println ("我是第四个springMVC程序");
        return "index";
    }
}

4.SpringMVC的收参

4.1 原始方式收参

   //原始方法收参
    @RequestMapping("/res")
    public String reseive(HttpServletRequest request){
        String name = request.getParameter ("name");
        String age = request.getParameter ("age");
        System.out.println (name);
        System.out.println (age);
        return "index";
    }

4.2 springMVC收参

4.2.1 零散变量收参

第一种形式

1.当表单的name属性的值与后台方法参数中形参的值一致
表单：
  <!--零散变量收参-->
        <form action="${pageContext.request.contextPath}/Reseive/resMVC.do" method="post">
            <input type="text" name="name"></br>
            <input type="text" name="age"></br>
            <input type="submit" value="零散变量1">
        </form>
        
后台：
 //利用springMVC收参
    //零散变量收参   springMVC 支持自动类型转换 八种基本类型+String
    @RequestMapping("/resMVC")
    public String reseiveMVC(String name,Integer age){
        System.out.println (name);
        System.out.println (age);
        return "index";
    }

第二种形式

1.当表单的name属性的值与后台方法参数中形参的值不一致

表单：
  <!--零散变量收参-->
        <form action="${pageContext.request.contextPath}/Reseive/resMVC1.do" method="post">
            <input type="text" name="n"></br>
            <input type="text" name="f"></br>
            <input type="submit" value="零散变量2">
        </form>
 
    后台：
  //当表单的name属性值与方法参数中形参名不一致 但是有不能改变其形参名 可以用@RequestParam 注解指定
    //指定的收参名必须和单的name属性值一样
    @RequestMapping("/resMVC1")
    public String reseiveMVC1(@RequestParam("n") String name, @RequestParam("f")Integer age){
        System.out.println (name);
        System.out.println (age);
        return "index";
    }

第三种形式

3.当 方法定义的参数个数与实际form表单提交的个数不一致时

表单：
  <!--零散变量收参-->
        <form action="${pageContext.request.contextPath}/Reseive/resMVC2.do" method="post">
            <input type="text" name="n"></br>
            <input type="submit" value="零散变量3">
        </form>
        
    后台：
     /*  当表单的name属性值与方法参数中形参名不一致 但是有不能改变其形参名 可以用@RequestParam 注解指定
    指定的收参名必须和单的name属性值一样
    当 方法定义的参数个数与实际form表单提交的个数不一致时
    需要默认指定 @RequestParam(value = "f",defaultValue = "20"
    防止抛异常
    */
    @RequestMapping("/resMVC2")
    public String reseiveMVC2(@RequestParam("n") String name, @RequestParam(value = "f",defaultValue = "20")Integer age){
        System.out.println (name);
        System.out.println (age);
        return "index";
    }

注意：1.springMVC会进行自动类型转换 8种基本类型+String
1.@@RuestParam作用
@RuestParam("收参的名称") ：如果传过来的形参名和方法中key参数不一致 可使用指定
//设置属性的默认值 防止传参时接收不到数据时抛异常
@RuestParam("收参的名称" value"a",defaultValue='18') 当传过来的参数个数与方法中定义的参数个数不一致


2.通过对象形式收参

4.2.2 对象类型收参

第一种形式

1.springMVC在接收对象类型时，name属性的值与对象所封装的实体类的属性名一致
    
 表单：
    <form action="${pageContext.request.contextPath}/User/UserTest1.do" method="post">
      <!--springMVC在接收对象类型时，name属性的值与对象所封装的实体类的属性名一致-->
            <input type="text" name="username">
            <input type="text" name="password">
            <input type="text" name="age">
            <input type="submit" value="注册">
        </form>
        
 后台： controller
public class UserController {
    //测试对象类型收参
    @RequestMapping("/UserTest1")
    public String UserTest1(User user) throws Exception{
        System.out.println (user);
        return "index";
    }

  后台： 所封装的实体类
  public class User {
    private String username;
    private String password;
    private String age;
有参无参get/set/ toString 省略
}

第二种形式

2.解决对象嵌套问题
表单：
  <form action="${pageContext.request.contextPath}/User/UserTest2.do" method="post">
            <!--springMVC在接收对象类型时，name属性的值与对象所封装的实体类的属性名一致-->
            <input type="text" name="username"></br>
            <input type="text" name="password"></br>
            <input type="text" name="age"></br>
            <!--处理对象嵌套问题 User类中封装对象的对象的属性名.其属性值-->
            <input type="text" name="address.city"></br>
            <input type="text" name="address.street"></br>
            <input type="submit" value="注册">
        </form>
        
后台：controller
    //测试对象嵌套对象 在user对象中嵌套adress对象
    @RequestMapping("/UserTest2")
    public String UserTest2(User user) throws Exception{
        System.out.println (user);
        return "index";
    }

  后台： 所封装的实体类 1
      public class User {
    private String username;
    private String password;
    private String age;
    private Address address;
     有参无参get/set/ toString 省略     
    }
  后台： 所封装的实体类 2
      public class Address {
    private String city;
    //街道
    private String street;
      有参无参get/set/ toString 省略     
      }

接收日期类型

第一种形式

1.springMVC默认的日期类型为: 年/月/日
表单：
  <form action="${pageContext.request.contextPath}/User/UserTest3.do" method="post">
     <!--springMVC在接收对象类型时，name属性的值与对象所封装的实体类的属性名一致-->
            <input type="text" name="username"></br>
            <input type="text" name="password"></br>
            <input type="text" name="age"></br>
            <!--处理日期类型 当type属性为文本 type="text"-->
            <input type="text" name="birthdate"></br>
            
            <input type="text" name="address.city"></br>
            <input type="text" name="address.street"></br>
            <input type="submit" value="注册">
        </form>
注意：用户页面文本框输入的日期格式为：2019/04/12
    后台： controller
    //测试对象嵌套对象 在user对象中嵌套adress对象
    //处理日期类型
    @RequestMapping("/UserTest3")
    public String UserTest3(User user) throws Exception{
        System.out.println (user);
        return "index";
    }
后台 :entity 默认情况下
public class User {
    private String username;
    private String password;
    private String age;
    //日期格式
    private Date birthdate;
    private Address address;
    
    }

第二种形式

1. @DateTimeFormat 为日期指定格式: 年-月-日
表单：
  <form action="${pageContext.request.contextPath}/User/UserTest3.do" method="post">
     <!--springMVC在接收对象类型时，name属性的值与对象所封装的实体类的属性名一致-->
            <input type="text" name="username"></br>
            <input type="text" name="password"></br>
            <input type="text" name="age"></br>
            <!--处理日期类型 当type属性为文本 type="text"-->
            <input type="text" name="birthdate"></br>
    <!-- 注意: 处理日期类型 当type属性为data type="data" 分隔符看起来是/ 其实是 -  -->
              <input type="date" name="birthdate"></br>
            <input type="text" name="address.city"></br>
            <input type="text" name="address.street"></br>
            <input type="submit" value="注册">
        </form>
注意：用户页面文本框输入的日期格式为：2019-04-12
    后台： controller
    //测试对象嵌套对象 在user对象中嵌套adress对象
    //处理日期类型
    @RequestMapping("/UserTest3")
    public String UserTest3(User user) throws Exception{
        System.out.println (user);
        return "index";
    }
后台 :entity 
public class User {
    private String username;
    private String password;
    private String age;
    //日期格式 使用注解    @DateTimeFormat 为日期指定格式
     @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date birthdate;
    private Address address;
    
    }

接收数组类型处理批量删除

表单：
<form action="${pageContext.request.contextPath}/Arry/ArryTest1.do" method="post">
            <input type="checkbox" name="hobby" value="1"></br> 吃饭
            <input type="checkbox" name="hobby" value="2"></br> 睡觉
            <input type="checkbox" name="hobby" value="3"></br> 玩
            <input type="submit" value="提交">
</form>
后台：controller
 //接收数组类型的数据
    @RequestMapping("/ArryTest1")
    public String ArryTest1(String [] hobby) throws Exception{
        for (String s : hobby) {
            System.out.println (s);
        }
        return "index";
    }

5.springMVC的跳转

5.1 controller—>jsp

1.
    //controller-------->jsp
    //采用 fprward
    @RequestMapping("/toJsp1")
    public String toJsp1(User user) throws Exception{
        System.out.println ("方法A");
        return "index";
    }
       
   2. 
    //controller-------->jsp
    //采用 redirect
    //注意：当指定跳转方式时，视图解析器失效 需要书写全路径
    @RequestMapping("/toJsp2")
    public String toJsp2(User user) throws Exception{
        System.out.println ("方法B");
        return "redirect:/index.jsp";

5.2 controller—> controller

 1. 采用 forward
     // controller------> controller  
    //采用 forward
    //方法 c ---跳到 ----方法 D
    @RequestMapping("/toJsp3")
    public String toJsp3(User user) throws Exception{
        System.out.println ("方法C");
        return "forward:/User/toJsp4.do";
    }
      
  // controller------> jsp
    //方法 D ---跳到 ----jsp
    @RequestMapping("/toJsp4")
    public String toJsp4(User user) throws Exception{
        System.out.println ("方法D");
        return "index";
}


2.采用 redirect
    // controller------> controller  
    //采用 redirect
    //方法 E ---跳到 ----方法 F
    @RequestMapping("/toJsp5")
    public String toJsp5(User user) throws Exception{
        System.out.println ("方法E");
        return "redirect:/User/toJsp6.do";
    }

    // controller------> jsp
    @RequestMapping("/toJsp6")
    public String toJsp6(User user) throws Exception{
        System.out.println ("方法F");
        return "index";
    }

6 springMVC的参数传递

原始方法传递

  //通过原始的方法传递收据
    @RequestMapping("/te1")                       //直接通过参数获取作用域
    public String test1(HttpServletRequest request, HttpSession session)throws Exception{
          //通过request作用域存值
        request.setAttribute ("request","request 小白");
        //通过session作用域存值
        session.setAttribute ("session","session 小黑");
        return "index";
    }

通过Model 或 ModelMap 替换request作用域

  //通过Model 或 ModelMap 替换request作用域
    @RequestMapping("/te2")
    public String test2(Model model, ModelMap modelMap)throws Exception{
        //通过model存值
        model.addAttribute ("model","ww===model");
        //通过modelMap存值
        modelMap.addAttribute ("modelMap","ff===modelMap");
        return "forward:/index.jsp";
    }

@SessionAttributes 存值

package com.baizhi.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.SessionAttributes;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

/***
 * 测试springMVC参数传递
 * */
@Controller
@RequestMapping("/scope")
//向session作用域中存入登录成功的用户
@SessionAttributes(value = {"model1","model2"})
public class Test5 {
    // springMVC测试 @SessionAttributes 存值
    /**
     * 相等于session存值 必须先用model存到request作用域中 在转存到session作用域中
     * */
    @RequestMapping("/te3")
    public String test3(Model model)throws Exception{
        model.addAttribute ("model1","小可爱");
        model.addAttribute ("model2","小乖乖");
        return "index";
    }
}

ModelAndView 机制测试

// ModelAndView 机制测试
//作用：传递数据（相当于request作用域） 并跳转到页面
    @RequestMapping("/te4")
    public ModelAndView test4()throws Exception{
    //创建 ModelAndView 对象
        ModelAndView modelAndView = new ModelAndView ();
        //相当于request 作用域中存值
        modelAndView.addObject ("modelAndView","美好的明天");
        //设置相对应的路径跳转
        modelAndView.setViewName ("index");
        return modelAndView;
    }

7 将集合或者对象转为json串

将对象转为json串 @ResponseBody 注解

@ResponseBody  注解

 //1. 把java中对象转换为json串   @ResponseBody Admin 把admin对象转换为json
    @RequestMapping("/test5ToJson.do")
    public @ResponseBody Admin test5ToJson()throws Exception{
        Admin admin = new Admin (1,"aa","bb","ss","女");
        return admin;
    }

2 将集合转为json串 @ResponseBody 注解

 //2. 把java中集合转换为json串
    @RequestMapping("/test6ToJson.do")
    public @ResponseBody List<Admin>  test6ToJson()throws Exception{
        List<Admin> list = new ArrayList<> ();
        Admin admin1 = new Admin (1,"aa","bb","ss","女");
        Admin admin2 = new Admin (2,"aa2","bb","ss","男");
        Admin admin3 = new Admin (3,"aa3","bb","ss","男");
       list.add (admin1);
       list.add (admin2);
       list.add (admin3);
        return list;
    }

#####8.springMVC处理文件上传

此处以上传头像为例：

1.导入文件上传的依赖：

1.导入文件上传的依赖：
<!--引入文件上传依赖-->
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.6</version>
    </dependency>
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.3.3</version>
    </dependency>

2 配置文件上传的视图解析器

 <!--配置文件上传的视图解析器-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!--配置文件上传大小-->
        <property name="maxUploadSize">
            <!--限制文件大小为10MB-->
            <value>10240000</value>
        </property>
    </bean>

3 新建一个文件夹作为文件上传的目标 uplodeTest

4 属性 controller类

package com.baizhi.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpSession;
import java.io.File;

@Controller
@RequestMapping("/uplode")
public class uplode {
    //springMVC实现文件上传
    @RequestMapping("/testUplode")   //获取上传的文件
    public String testUplode(MultipartFile uplode, HttpSession session) throws Exception{
        //通过session获取servletContext
        ServletContext servletContext = session.getServletContext ();
           //获取目标文件夹的绝对路径
        String realPath = servletContext.getRealPath ("/uplodeTest");
         //获取上传文件的名称  uplode.getOriginalFilename ()
        File file = new File (realPath + "/" + uplode.getOriginalFilename ());
        //把文件上传的内容添加到空文件夹中
        uplode.transferTo (file);
        return "index";
    }
}

5 form表单

 <form action="${pageContext.request.contextPath}/uplode/testUplode.do" method="post" enctype="multipart/form-data">
            <input type="file" name="uplode">
            <input type="submit" value="上传文件">
        </form

9.SpringMVC中文件下载处理

书写下载的controller

package com.baizhi.controller;

import org.apache.commons.io.FileUtils;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpSession;
import java.io.File;
/**
 * 测试文件下载
 * */

@Controller
@RequestMapping("/down")
public class downlodeController {

    //测试文件下载
    @RequestMapping("/testDowload.do")
    public ResponseEntity<byte []> testDowload(String filename, HttpSession session)throws Exception{
        //获取下载文件所在的目录
        ServletContext servletContext = session.getServletContext ();
        //此处下载的文件路径必须是本项目上传文件时设置的目标文件的路径
        String realPath = servletContext.getRealPath ("empImg");
        //代表下载的目标文件
        File file = new File (realPath + "/" + filename);
        //把下载的文件转换为字节数组
        byte[] bytes = FileUtils.readFileToByteArray (file);
        //设置http协议请求头
        HttpHeaders httpHeaders = new HttpHeaders ();
        //解决下载文件后文件名乱码问题
        String dowmume = new String (filename.getBytes ("UTF-8"), "iso-8859-1");
        //设置下载时打开的方式     以附件的形式打开
        httpHeaders.setContentDispositionFormData ("attachment",dowmume);
        //设置下载方式时二进制流的方式
        httpHeaders.setContentType (MediaType.APPLICATION_OCTET_STREAM);
        ResponseEntity<byte[]> responseEntity = new ResponseEntity<> (bytes, httpHeaders, HttpStatus.CREATED);
        return  responseEntity;
    }
}

jsp页面此处以下载头像为例

 
<td>
  href="${pageContext.request.contextPath}/down/testDowload.do?filename=${emp.code}">emp downlode</a>
 </td>
                    
 //解释说明：   filename=${emp.code} 表示从数据库获取文件名并传到后台进行下载

10.SpringMVC中全局异常处理

作用: 统一管理所有的异常实现 HandlerExceptionResolver

(以登录注册为例) 详细讲解

1.书写登录注册的controller

1.书写登录注册的controller

package com.baizhi.controller;
import com.baizhi.exception.LoginException;
import com.baizhi.exception.RegisterException;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/excepion")
public class Test6ExceptionController {
    //登录时异常
    @RequestMapping("/login")
    public String longin()throws Exception{
        System.out.println ("我是登录的方法");
        //抛出登录异常
        throw new LoginException ();
    }
        //注册时异常
     @RequestMapping("/register")
    public String register()throws Exception{
        System.out.println ("我是注册方法");
        throw new RegisterException ();
    }
}

2.定义一个类实现 HandlerExceptionResolver 接口处理全局异常

package com.baizhi.controller;

import com.baizhi.exception.LoginException;
import com.baizhi.exception.RegisterException;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 处理全局异常
 * */
public class GlobalExceptionHandler implements HandlerExceptionResolver {
   /**
    * 返回值是 ModelAndView ，传递数据并跳转页面
    * */
   @Override
   //参数 Exception e 将会捕捉到所有手动抛出异常的相关信息
   public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
       //创建 ModelAndView 对象
       ModelAndView modelAndView = new ModelAndView ();
       if (e instanceof LoginException) {
           modelAndView.addObject ("message", "小二学习中");
       } else if (e instanceof RegisterException) {
           modelAndView.addObject ("message", "小二学习中11");
       }
       //跳转到异常页面  告知用户产生异常
       modelAndView.setViewName ("index");
        return modelAndView;
   }
}

3.在springMVC.xml配置全局异常处理的类

  <!--配置全局异常的信息-->
  <bean  id="globalExceptionHandler" class="com.baizhi.controller.GlobalExceptionHandler"></bean>

4.在index.jsp 获取所抛异常时的提示信息

<%@page pageEncoding="UTF-8" contentType="text/html; UTF-8" isELIgnored="false" %>
<html>
<body>
<h1>全局异常 ${requestScope.message}</h1>
</body>
</html>

11 springMVC中的拦截器（以强制登录为例） implements HandlerInterceptor

1 存储登录成功的用户信息

package com.baizhi.controller;
import com.baizhi.entity.Admin;
import com.baizhi.service.AdminService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.SessionAttributes;
@Controller
@RequestMapping("/admin1")
//向session作用域中存入登录成功的用户
@SessionAttributes(value = {"adm"})
public class AdminAction  {
    //调用 service层 采用自动注入
    @Autowired
    private AdminService adminService;
    //管理员登录
    @RequestMapping("/loginAdminAction")
    public String loginAdminAction(Admin admin, Model model)throws Exception{
        Admin adm = adminService.loginAdminService (admin);
        if (adm!=null){
            //用model先存request作用域 在转存session作用域
            model.addAttribute ("adm",adm);
            return "redirect:/emp/findAllEmpAction.do";
        }else {
            return "redirect:/jsp/login.jsp";
        }
    }
}

2 书写强制登录拦截器类

package com.baizhi.controller;
import com.baizhi.entity.Admin;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

/***
 * springMVC中强制登录拦截器
     固定格式：implements HandlerInterceptor
 */

public class LoginInterceptor implements HandlerInterceptor {
    //在目标方法执行之前执行
    @Override
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
        HttpSession session = httpServletRequest.getSession ();
        Admin adm = (Admin) session.getAttribute ("adm");
        if (adm!=null){
            //登录成功可以放行，让程序继续向下执行
            return true;
        }else{
            //登录不成 直接响应到登录页面 程序无法向下执行
         httpServletResponse.sendRedirect ("/ssm3.0/jsp/login.jsp");
            return false;
        }
    }
    //运行在目标方法跳转页面之前
    @Override
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
    }
    //目标方法执行之后
    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {

    }
}

3 springMVC.xml 中配置拦截器

<!--配置拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
        <!--表示拦截的方法  emp包下所有的方法 -->
            <mvc:mapping path="/emp/**"/>
            <!--表示不拦截的方法-->
            <!-- <mvc:exclude-mapping path="/target/C.do"/>-->
            <bean id="interceptor" class="com.baizhi.controller.LoginInterceptor"></bean>
        </mvc:interceptor>
    </mvc:interceptors>