SpringMVC06（SSM的整合与异常处理以及拦截器）

最新推荐文章于 2021-06-20 16:11:39 发布

FallingWhite

最新推荐文章于 2021-06-20 16:11:39 发布

阅读量198

点赞数

分类专栏：学习笔记文章标签： ssm springmvc

本文链接：https://blog.csdn.net/charaface/article/details/115099588

版权

学习笔记专栏收录该内容

8 篇文章 0 订阅

订阅专栏

SSM整合

springmvc的学习已进入尾声，现在，我们将进行SSM的整合
SpringMVC01
SpringMVC02
SpringMVC03
SpringMVC04
SpringMVC05
SpringMVC06（SSM的整合）

首先，我们将进行基本项目结构的创建
在这里插入图片描述
随后，在maven配置文件里进行需要包的导入。

 <dependency>
      <!--第三方事务包，服务器无法启动时启用-->
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.1.1</version>
    </dependency>
    <dependency>
      <!--测试单元-->
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!--加入servlet依赖和springmvc依赖-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <!--为了使用Spring的监听器对象，加入依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <!--AOP依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <!--  aspectj依赖  -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <dependency>
      <!--spring核心ioc-->
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <!--spring事务管理-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <!--mybatis依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.1</version>
    </dependency>
    <!--mybatis和spring集成的依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.1</version>
    </dependency>
    <!--mysql驱动-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.9</version>
    </dependency>
    <!--阿里的数据库连接池-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.12</version>
    </dependency>
    <!--为传输json格式到浏览器，导入依赖-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>
    <!--jsp依赖项-->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.2.1-b03</version>
      <scope>provided</scope>
    </dependency>

在创建好测试用的实体类和数据库以及dao接口和mapperl文件后，便进行mybatis.xml的配置在这里插入图片描述

public interface StudentDao {
    int insertStudent(Student student);
    List<Student> showStudent();
    //dao接口
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.fallingwhite.dao.StudentDao">
        <insert id="insertStudent" parameterType="com.fallingwhite.domain.Student">
        insert  into student values(#{id},#{name},#{password},#{age})
    </insert>
        <select id="showStudent" resultType="com.fallingwhite.domain.Student">
        select id,name,password,age from student order by id asc
    </select>
    </mapper>
    <!--mapper文件 -->

在这里插入图片描述

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--控制mybatis的全局行为-->
<!--    <settings>-->
<!--        <setting name="logImpl" value="STDOUT_LOGGING"/>-->
<!--    </settings>-->
    <!--设置别名-->
    <typeAliases>
        <!--实体类所在的包名(不是实体类的包名也可以)-->
        <package name="com.fallingwhite.domain"/>
    </typeAliases>

    <mappers>
        <!--加载映射文件-->
        <package name="com.fallingwhite.dao"/>
        <!--name代表所在包名，这个包内的所有mapper.xml都能一次加载
        使用package的要求
        1.mapper文件名称和dao接口名必须完全一样，包括大小写
        2.mapper文件和dao接口必须在同一目录
        -->
    </mappers>
</configuration>

随后建立service层所需文件
在这里插入图片描述


public interface StudentService {
    int insertStudent(Student student);
    List<Student> showStudent();
}

在这里插入图片描述

@Service
public class StudentServiceImpl implements StudentService {
    //引用类型Dao
    @Autowired
    private StudentDao studentDao;

    public StudentDao getStudentDao() {
        return studentDao;
    }

    public void setStudentDao(StudentDao studentDao) {
        this.studentDao = studentDao;
    }

    @Override
    public int insertStudent(Student student) {
        int num=studentDao.insertStudent(student);
        return 0;
    }

    @Override
    public List<Student> showStudent() {
        List<Student> students=studentDao.showStudent();
        return students;
    }
}

随后建立Spring所需的xml文件，进行相关配置，并将mybatis所需连接池与sqlSessionFactoryBean交给Spring管理，并进行注解的处理
首先进行数据库数据配置文件的创建
在这里插入图片描述

jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=root
jdbc.MaxActive=20

随后编写applicationContext.xml

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--spring配置文件，声明service，dao，工具类等对象-->
    <!--把数据库连接参数单独写在一个文件中,使用标签引入-->
    <context:property-placeholder location="classpath:config/jdbc.properties"/>

    <!--声明数据源DataSource，作用是连接数据库-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <!--使用set注入填写连接数据库所需要的信息-->
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="maxActive" value="${jdbc.MaxActive}"/>
    </bean>
    <!--声明的是mybatis中提供的sqlsessionfactorybean类，这个类内部创建sqlsessionfactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--set注入，把数据库连接池的属性托付给了dataSource属性-->
        <property name="dataSource" ref="myDataSource"/>
        <!--mybatis主配置文件的位置
        configLocation属性是Resource类型的
        他的赋值，使用value，指定文件的路径，使用calsspath：表示文件的位置
        -->
        <property name="configLocation" value="classpath:config/mybatis.xml"/>

    </bean>

    <!--创建dao对象，使用sqlSession的getMapper（Student.class）
            MapperScannerConfigurer：在内部调用getMapper（）生成每个dao接口的代理对象
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定SqlSessionFactory对象的id-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--指定dao接口所在的包名
        MapperScannerConfigurer会扫描这个包中的所有接口，执行一次getMapper（）方法，得到每个接口的的对象。
        创建好的dap对象放入Spring的容器中。
        -->
        <property name="basePackage" value="com.fallingwhite.dao"/>
    </bean>
    <!--声明service的注解@service所在包的位置-->
    <context:component-scan base-package="com.fallingwhite.service.Impl"/>
    <!--事务的配置，注解的配置，aspectj的配置，一般在搭建好后再配置-->
</beans>

之后进行springmvc的相关配置
在Controller层进行配置

@Controller
@RequestMapping("/student")
public class StudentController {
    @Resource
    private StudentService studentService;

    public StudentService getStudentService() {
        return studentService;
    }

    public void setStudentService(StudentService studentService) {
        this.studentService = studentService;
    }

    //注册学生
    @RequestMapping("/addStudent.do")
    public ModelAndView addStudent(Student student){
        //调用service处理student
        String tip="注册失败";
        int nums=studentService.insertStudent(student);
        if (nums>0){
            tip="学生"+student.getName()+"注册成功";
        }
        ModelAndView mv=new ModelAndView();
        mv.addObject("tip",tip);
        mv.setViewName("test1");
        return mv;
    }
    //展示学生
    @RequestMapping("/showStudents.do")
    @ResponseBody
    public List<Student> showStudents(){
        //调用service处理student
        //在引入jq文件后，请重启服务器，因为idea可能无法立刻识别
      List<Student> students= studentService.showStudent();
      return students;
    }

}

dispaterServlet.xml的编写

<?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 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--springmvc配置文件，声明controller和其他web相关对象-->

    <!--声明组件扫描器-->
    <context:component-scan base-package="com.fallingwhite.controller"/>
    <!--声明视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/><!--配置前缀时千万别忘了/开头-->
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--注解驱动
    1.处理ajax请求，返回json
    2.解决静态资源访问问题-->
    <mvc:annotation-driven/>
    <!--处理静态资源-->
    <mvc:resources mapping="/static/**" location="/static/"/>

再在web.xml中进行配置：

<?xml version="1.0" encoding="UTF-8"?>
<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_4_0.xsd"
         version="4.0">
    <!--注册中央调度器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:config/dispatcherServlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

    <!--注册spring的监听器-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:config/applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!--注册字符集过滤器-->
    <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>
        <init-param>
            <param-name>forceRequestEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

自此，SSM的整合便完成了，接下来我们便来进行测试

<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="utf-8" %>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>index</title>
</head>
<base href="http://localhost/SSM01/">
<body>
<div align="center">
    <p> SSM整合的例子</p>
    <img src="static/images/setting.png">
    <table>
        <tr>
            <td><a href="registerStudent.jsp">注册学生</a></td>
        </tr>
        <tr>
            <td><a href="showStudent.jsp">查看学生</a></td>
        </tr>
    </table>
</div>
<button><a href="test/testForward.do">测试forward</a></button>
<form action="test/testRedirect.do" method="post" >
    <input type="text" name="name">
    <input type="text" name="password">
    <input type="submit" value="测试redirect">
</form>
<form action="test/testException.do" method="post" >
    <input type="text" name="name">
    <input type="text" name="age">
    <input type="submit" value="测试Exception">
</form>
</body>
</html>

在目标页面进行相应的请求处理，便可知道自己是否整合成功。

如何进行异常处理以及拦截器的配置

异常处理
首先进行自定义异常的创建
在这里插入图片描述
因为是测试，所以只实现两个方法

public class MyUserException extends Exception{
    public MyUserException() {
        super();
    }

    public MyUserException(String message) {
        super(message);
    }
}

其余两个类则是继承该类进行重写

在这里插入图片描述
代码与解释如下

/*@ControllerAdvice
    控制器增强（给控制器添加功能——异常处理）
    位置：在类的上面
    特点：必须让框架知道该注解的所在包名，需要在springmvc配置文件声明组件扫描器，指定@ControllerAdvice所在包名
 */

@ControllerAdvice
public class GlobalExceptionHandler {
    //定义方法，处理发生的异常
    /*处理异常的方法和控制器方法一样，可以有多个参数，可以有ModelAndView String void 类型的返回值
    *
    * 形参：Exception，表示Controller中抛出的异常对象
    * 通过形参可以获取发生的异常信息
    *
    * @ExceptionHandler(定义的异常class)：表示异常的类型，当发生此类型异常时
    * 由当前方法处理
    * */
    @ExceptionHandler(value = NameException.class)
    public ModelAndView doNameException(Exception e){
        //处理NameException的异常
        /*
        * 异常发生处理逻辑：
        * 1.需要把异常记录下来，记录到数据库，日志文件。
        *   记录日志发生的时间，哪个方法发生的，错误内容
        * 2.发送通知，把异常的信息通过邮件，短信，微信发送给相关人员。
        * 3.给用户友好的提示。
        * */
        ModelAndView mv=new ModelAndView();
        mv.addObject("msg","姓名必须是zs，其它用户不能访问");
        mv.addObject("ex",e);
        mv.setViewName("nameError");
        return mv;
    }

    @ExceptionHandler(value = AgeException.class)
    public ModelAndView doAgeException(Exception e){
        ModelAndView mv=new ModelAndView();
        mv.addObject("msg","年龄错误，不能访问");
        mv.addObject("ex",e);
        mv.setViewName("ageError");
        return mv;
    }

    //在进行测试时最好关掉，以免不知道哪里出错
    @ExceptionHandler //唯一，处理其它类型的异常
    public ModelAndView doDefaultException(Exception e){
        //处理其它的异常
        /*
         * 异常发生处理逻辑：
         * 1.需要把异常记录下来，记录到数据库，日志文件。
         *   记录日志发生的时间，哪个方法发生的，错误内容
         * 2.发送通知，把异常的信息通过邮件，短信，微信发送给相关人员。
         * 3.给用户友好的提示。
         * */
        ModelAndView mv=new ModelAndView();
        mv.addObject("msg","默认处理方法");
        mv.addObject("ex",e);
        mv.setViewName("nameError");
        return mv;
    }
}

在dispatcherServlet.xml中添加以下代码

<!--声明ControllerAdvice的组件扫描器-->
    <context:component-scan base-package="com.fallingwhite.handler"/>

便可将异常的处理交给spring。

拦截器
建立以下类
在这里插入图片描述

*HandlerInterceptor接口中的方法在5.2.5中是需要用哪个重写哪个，但是在4.3版本中需要全部重写*/
/*拦截器，拦截用户的请求*/
public class MyInterceptor implements HandlerInterceptor {
   /*preHandle预处理方法
   *    参数：
   *    Object Handler：被拦截的控制器对象（Controller对象）
   * 返回值boolean
   *    true：请求通过了拦截器的验证，可以执行处理器方法。
   *    false：到return false后就停止了
   * 特点：
   * 1.方法在控制器方法（@Controller中的方法）之前执行
   *    用户的请求首先到达此方法
   * 2.在这个方法中可以获取用户信息，验证请求是否符合要求
   * eg：可以验证用户是否登录，验证用户是否有访问某个地址（url）的权限。
   *    如果验证失败，可以截断请求，请求不会被处理。
   *    验证成功，可以放行，此时控制器方法才能执行
   * */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("拦截器的preHandle的测试");
        return true;
    }
    /*postHandle后处理方法
    *参数：
    * object handler：被拦截的处理器对象
    * 特点：
    * 1.在处理器方法之后执行
    * 2.能够获取处理器方法的返回值ModelAndView，可以修改ModelAndView中的数据和视图，影响到最后的执行结果
    * 3.主要是用于对结果的二次修正。
    * */
    @Override
    public void postHandle(HttpServletRequest request,
                           HttpServletResponse response,
                           Object handler, ModelAndView modelAndView) throws Exception {
        //eg:对原来的doSome方法进行调整
        if(modelAndView!=null){
            //修改数据
            modelAndView.addObject("mydate",new Date());
            modelAndView.setViewName("other");
        }

    }
    /*afterCompletion：最后执行的方法
    *参数：object handler：被拦截的处理器对象
    * Exception ex：程序中发生的异常
    * 特点：
    * 1.在请求处理完后执行的，框架中规定，在你的视图处理完后，对视图执行了forward。就认为请求处理完成。
    * 2.一般用作资源回收工作，程序的运行中默认产生了一些对象，在这里可以删除，把占用的内存回收
    * */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

随后在dispatcherServlet.xml中添加以下代码

    <mvc:interceptors>
        <!--声明第一个拦截器-->
        <mvc:interceptor>
            <!--指定拦截的请求uri地址
                    path：就是uri地址，可以使用通配符**
                    **表示任意字符，甚至是多级目录和多级目录中的文件
                eg:http://localhost/SSM02/test/testForward.do
            -->
            <mvc:mapping path="/user/**"/>
            <bean class="com.fallingwhite.handler.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>