SpringMVC 总结04 异常处理与拦截器+SSM框架整合

最新推荐文章于 2024-02-01 04:30:00 发布

JT.L

最新推荐文章于 2024-02-01 04:30:00 发布

阅读量211

点赞数

分类专栏： Java框架学习文章标签：拦截器异常处理

本文链接：https://blog.csdn.net/amazinx/article/details/103564466

版权

Java框架学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

第三章：SpringMCV的异常处理

说明：也是SpringMVC框架提供的异常处理。

基本思路：

处理步骤

1、编写自定义异常类

package com.jtl.exception;
/**
 * @author JT.L
 * @date 2019/12/16 14:01:18
 * @description 自定义异常类
 */
public class SysException extends Exception {
    /**
     * 存储提示信息
     */
    private String message;
    public SysException(String message) {
        this.message = message;
    }
    @Override
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
}

2、编写异常处理器

/**
 * @author JT.L
 * @date 2019/12/16 14:38:08
 * @description 异常处理器
 */
public class SysExceptionResolver implements HandlerExceptionResolver {
    /**
     * 处理异常业务逻辑
     *
     * @param httpServletRequest
     * @param httpServletResponse
     * @param o 当前处理器这个对象 用的很少
     * @param ex
     * @return
     */
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception ex) {
        // 获取到异常对象
        SysException e = null;
        if (ex instanceof SysException) {
            e = (SysException) ex;
        } else {
            e = new SysException("系统正在维护...");
        }
        ModelAndView mv = new ModelAndView();
        mv.addObject("errorMsg", e.getMessage());
        mv.setViewName("error");
        return mv;
    }
}

3、配置异常处理器

在springmvc.xml中配置：就是一个普通的bean标签对象

    <!--配置异常处理器对象-->
    <bean id="sysExceptionResolver" class="com.jtl.exception.SysExceptionResolver"/>

其他、Controller方法已经error页面

    @RequestMapping("/testException")
    public String testException() throws SysException{
        System.out.println("execute testException...");
        try {
            // 模拟异常
            int a = 10 / 0;
        } catch (Exception e) {
            // 打印异常信息（控制台）
            e.printStackTrace();
            // 抛出自定义异常信息
            // 模拟调用service方法出错
            throw new SysException("查询所有用户出现错误了...");
        }
        return "success";
    }

在相应位置创建一个error.jsp文件，作为友好的错误提示页面

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
${errorMsg}
</body>
</html>

插曲：

对于这个函数的说明，虽然形参是Exception（SysException的父类），但是如果你传入的是SysException这个子类对象，是不会将SysException转成Exception对象的，它本身还是SysException这个对象，可以通过instanceof来进行判断传入的具体对象是哪一个，是不是子类对象！例：

    public static void main(String[] args) {
        function(new Son());
    }
    private static void function(Father f){
         if (f instanceof Son){
             System.out.println("This is son.");
         }else {
             System.out.println("This is father.");
         }
    }

说明：Father是Son的父类，当实参传入Son时，打印结果为：This is son.

第四章：SpringMVC框架中的拦截器

说明：拦截器功能上类似与Servlet开发中的过滤器Filter，过滤器可以去拦截你后台的资源。补充：Spring MVC 的处理器拦截器类似于 Servlet 开发中的过滤器 Filter，用于对处理器（就是Controller这个类）进行预处理和后处理。

流程图：

说明：
（预处理）在请求Controller之前会先经过拦截器，（后处理）Controller执行完往某个页面去跳它还会再回来再经过拦截器。
当你发请求，拦截器会先执行放行之前的代码，代码走完，然后放行，后面的Controller就正常执行；当Controller执行完想往页面跳转回来会执行放行之后的代码，最后才是跳转到某某页面中去。

拦截器与过滤器区别：
过滤器：什么都可以拦截，且任何java web工程都能用。
拦截器：只能拦控制器方法，只能在SpringMVC框架中去使用。
拦截器能做的事过滤器全部都能做，过滤器能做的事拦截器就不一定做的了（比如，拦截jsp、js、html、css、image等）。

4.1 快速入门程序

4.1.1 编写拦截器类

public class MyInterceptor1 implements HandlerInterceptor {
    /**
     * 预处理，Controller方法执行前
     * return true 放行，执行下一个拦截器，如果没有(下一个拦截器)，执行Controller中的方法
     * return false不放行，通过request&response对象直接跳转到某个页面去(等于没执行Controller方法)，作一些提示信息，如：您没权限访问。(跳转到提示权限页面)
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("execute MyInterceptor1 preHandle...");
        return true;
    }
}

4.1.2 配置拦截器

在springmvc.xml配置文件中配置：

    <!--配置拦截器-->
    <mvc:interceptors>
        <!--配置(具体某个)拦截器-->
        <mvc:interceptor>
            <!--要拦截的具体方法-->
            <mvc:mapping path="/user/**"/><!--或者这样写：<mvc:mapping path="/user/*"/>-->
            <!--所有方法全部拦截：<mvc:mapping path="/**"/>-->
            <!--不要拦截的方法
            <mvc:exclude-mapping path=""/>
            这两者配置其中一个即可
            -->
            <!--配置拦截器对象，把类配上表明拦截器注入成功-->
            <bean class="com.jtl.interceptor.MyInterceptor1"/>
        </mvc:interceptor>
    </mvc:interceptors>

4.1.3 其他

Controller类：

    @RequestMapping("/testInterceptor")
    public String testInterceptor(){
        System.out.println("execute testInterceptor...");
        return "success";
    }

success.jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h3>执行成功</h3>
<%System.out.println("execute success.jsp");%>
</body>
</html>

4.1.4 控制台打印结果

说明：先执行拦截器的预处理；然后是Controller方法；最后是跳转页面里的方法。

4.2 拦截器中的其他方法

一种有三个方法。

4.2.0 不放行演示

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("execute MyInterceptor1...");
        request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request, response);
        return false;
    }

4.2.1 postHandle方法

    /**
     * 后处理方法，Controller方法执行后，success.jsp执行之前
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("execute MyInterceptor1 postHandle...");
        //request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request, response);
        //modelAndView.setViewName("error");注意控制台的输出信息与上面请求转发的作对比，其实就是少了success.jsp页面的输出
    }

4.2.2 afterCompletion方法

    /**
     * success.jsp页面执行后，该方法会执行（也就是最后执行的一个方法）
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("execute MyInterceptor1 afterCompletion...");
        // 这个时候就不能跳转页面了，会出现如下错误(控制台)：Cannot forward after response has been committed
        // request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request, response);
    }

4.2.3 总结：

1、预处理：在Controller之前，可以做一些逻辑的判断，如：用户登没登录逻辑判断，如果登录直接放行，否则跳到登录页面去。

2、后处理：也可以跳页面。

3、afterCompletion()：可以释放一些资源，如：关闭流。

4.3 拓展 --- 两个拦截器

4.3.1 配置第二个拦截器

    <!--配置拦截器-->
    <mvc:interceptors>
        <!--配置(具体某个)拦截器-->
        <mvc:interceptor>
            <!--要拦截的具体方法-->
            <mvc:mapping path="/user/**"/>
            <!--配置拦截器对象，把类配上表明拦截器注入成功-->
            <bean class="com.jtl.interceptor.MyInterceptor1"/>
        </mvc:interceptor>
        <!--配置第二个拦截器-->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <!--注册拦截器对象-->
            <bean class="com.jtl.interceptor.MyInterceptor2"/>
        </mvc:interceptor>
    </mvc:interceptors>

4.3.2 创建一个新的拦截器

MyInterceptor2里面的内容与MyInterceptor1一样只是打印信息修改一下。

4.3.3 执行流程结果：

说明：就是按照一开始最上面那个流程图来执行的。

附：SSM整合

思路图：

说明：
表现层就是Controller，注解：@Controller
业务层就是service，注解：@Service
持久层就是dao，注解：@Repository。dao层只需要提供接口，因为在IOC容器中会自动生成一个代理对象去执行具体的事。

1、Spring整合SpringMVC

去web.xml配置上一个监听器，并指明spring配置文件的路径

    <!--配置Spring的监听器，默认只加载WEB-INF目录下的applicationContext.xml配置文件-->
    <listener>
        <!--这个类来自：<artifactId>spring-web</artifactId>这个坐标-->
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!--设置配置文件的路径-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

2、Spring整合Mybatis

去spring配置文件中，配置上SqlSessionFactory工厂，目的就是为了让dao接口的代理对象存入到IOC容器中。

    <!--Spring整合Mybatis框架(将dao接口的代理对象存入容器，用于service层注入dao对象)【说白了就是将dao放入容器中】-->
    <!--配置连接池（c3p0）-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql:///ssm_demo1"/>
        <property name="user" value="root"/>
        <property name="password" value="123456"/>
    </bean>
    <!--配置SqlSessionFactory工厂-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--这个类可以通过连接池来构建session工厂-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--配置AccountDao接口所在的包-->
    <bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.jtl.dao"/>
    </bean>

3、dao代理对象的进一步说明

这是一段测试Mybatis的代码，充分说明了dao代理对象的作用以及它生成的过程，必须经过SqlSessionFactory工厂。

    @Test
    public void run2() throws Exception {
        Account account = new Account();
        account.setName("JTL");
        account.setMoney(100D);
        // 加载配置文件 这种方式就是Mybatis方式 没用有spring 后面把SqlMapConfig.xml注释掉后，相当于将Mybatis交给spring管理了
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 创建SqlSessionFactory对象
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        // 创建SqlSession对象
        SqlSession session = factory.openSession();
        // 获取到代理对象
        AccountDao dao = session.getMapper(AccountDao.class);
        // 保存
        dao.saveAccount(account);

        // 提交事务（做增删改需要自己提交事务）
        session.commit();

        // 关闭资源
        session.close();
        in.close();
    }

最后，SSM整合项目github地址：SSM框架整合demo

JT.L

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC 总结04 异常处理与拦截器+SSM框架整合

第三章：SpringMCV的异常处理说明：也是SpringMVC框架提供的异常处理。基本思路：处理步骤1、编写自定义异常类package com.jtl.exception;/** * @author JT.L * @date 2019/12/16 14:01:18 * @description 自定义异常类 */public class SysExcepti...
复制链接

扫一扫