25.SSM-SpringMVC延续--拦截器与异常处理思想

醉梦依依惜

已于 2023-12-16 15:44:52 修改

阅读量554

点赞数

分类专栏： web技术文章标签： java 前端 spring

于 2023-04-15 22:57:04 首次发布

本文链接：https://blog.csdn.net/khmff/article/details/130176706

版权

web技术专栏收录该内容

59 篇文章 2 订阅

订阅专栏

（4.2）java程序加载拦截器（springboot不使用xml配置文件）。

（5）多拦截器。

（5.1）spirng-mvc.xml配置文件。

（5.2）拦截器参考类。

（6）拦截器的拦截范围——重点。

（6.1）拦截器的拦截范围-前端控制器内部。

（6.2）如果静态资源满足拦截条件，但还是请求成功了的原因——并非请求成功。

一、拦截器。

（1）拦截器的作用。

（2）拦截器与过滤器的区别。

拦截器（Interceptor）和过滤器（Filter）的作用部分相似，都可以拦截请求并进行处理。但是它们的实现方式不同，主要区别有以下几点：

1.实现方式不同：拦截器是基于 Java 反射机制实现的，而过滤器是基于 Servlet 规范实现的。

2.对象不同：拦截器是针对 Spring MVC 中的请求进行拦截处理的，而过滤器可以对所有的请求进行拦截处理。

3.程序上下文不同：拦截器只能获取到 Spring MVC 的上下文信息，而过滤器可以获取到整个 Servlet 的上下文信息。

4.支持 AOP 的能力：拦截器可以更好地支持 AOP 思想，而过滤器则不能。

5.控制粒度不同：拦截器可以对请求进行细粒度的控制，而过滤器的粒度较粗，只能对请求进行简单的转发或者重定向等操作。

因此，在实际开发中，如果需要对 Spring MVC 中的请求进行一些 AOP 方面的处理或者需要对请求进行更加细粒度的控制，可以使用拦截器；如果只需要对请求进行一些简单的处理（如：字符编码、文件上传、登录验证等），则可以使用过滤器。

（3）拦截器的方法及执行时间。

拦截器方法的执行时间：

preHandle：请求在执行控制器方法前，执行该方法。

postHandle：请求执行完控制器方法后执行，然后才把响应结果返回给浏览器。

afterComjpletion：响应结果成功返回浏览器之后，才执行该拦截器方法。

控制器方法没有写返回数据时：

控制器方法有写返回数据时：

浏览器的数据是在postHandle方法执行完之后才返回的。（显示时间是执行完控制器方法的时间）

（4）拦截器的快速入门。

（4.1）xml配置加载拦截器。

（4.2）java程序加载拦截器（springboot不使用xml配置文件）。

拦截器：

public class IpCountInterceptor implements HandlerInterceptor {
    @Autowired
    private IpCountService ipCountService;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        ipCountService.count();
        return true;
    }
}

将IpCountInterceptor拦截器添加到 SpringMVC配置中，并且指定了拦截的路径模式：

@Configuration
public class SpringMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(ipCountInterceptor()).addPathPatterns("/**");
    }

    @Bean
    public IpCountInterceptor ipCountInterceptor(){
        return new IpCountInterceptor();
    }
}

（5）多拦截器。

（5.1）spirng-mvc.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:mvc="http://www.springframework.org/schema/mvc"
       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  http://www.springframework.org/schema/context/spring-context.xsd
                            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--1、mvc的注解驱动-->
    <mvc:annotation-driven/>
    <!--2、配置视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--3、静态资源权限开放-->
    <mvc:default-servlet-handler/>

    <!--4、组件扫描-->
    <context:component-scan base-package="controller"/>

    <!--5、配置拦截器-->
    <mvc:interceptors>
        <!--拦截器的执行顺序的按照这里的顺序执行的,如果想让哪个先执行，就放前面-->
        <mvc:interceptor>
            <!--对哪些资源执行拦截操作，可配置多个-->
            <mvc:mapping path="/**"/>
            <!--配置哪些资源排除拦截操作，可配置多个-->
            <mvc:exclude-mapping path="/user/login"/>
            <bean class="interceptor.MyInterceptor1"/>
        </mvc:interceptor>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="interceptor.MyInterceptor2"/>
        </mvc:interceptor>
    </mvc:interceptors>

</beans>

（5.2）拦截器参考类。

package interceptor;
public class MyInterceptor1 implements HandlerInterceptor {
    //运行结果：
    preHandle......
    preHandle222222......
    目标资源执行......
    postHandle222222......
    postHandle......
    afterCompletion222222......
    afterCompletion......

    @Override
    //在目标方法执行之前，执行
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle......");
        String param = request.getParameter("param");
        if ("yes".equals(param)){
            return true;
        }else {
            request.getRequestDispatcher("/error.jsp").forward(request,response);
            return false;//返回false：不放行;true：放行
        }
    }
    @Override
    //在目标方法执行之后，视图对象返回之前执行
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        modelAndView.addObject("name","itheima");
        System.out.println("postHandle......");
    }
    @Override
    //在流程都执行完毕后，执行
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion......");
    }
}

（6）拦截器的拦截范围——重点。

<!--SpringMVC的前端控制器-->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup><!--表示服务器启动就创建-->
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <!--<url-pattern>/user/*</url-pattern>-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>

笔记：/user/*的映射地址包含/user及其/user/下的。

（6.1）拦截器的拦截范围-前端控制器内部。

进入前端控制器的请求才能被拦截器拦截。（即进入前端控制器后，如果满足拦截器的拦截条件，那么就拦截）。

（6.2）如果静态资源满足拦截条件，但还是请求成功了的原因——并非请求成功。

一般情况下，JSP 中的静态资源（例如图片、CSS、JavaScript 等）请求也是需要经过拦截器的。如果你的 JSP 中引用的静态资源不需要经过拦截器，一般有以下几种情况：

1.静态资源已经被缓存。浏览器在请求静态资源时，如果该资源已经被缓存在本地，那么浏览器就不会发送请求到服务器，因此也就不会经过拦截器。

2.拦截器没有对该静态资源进行拦截。一些拦截器可能只对特定类型的请求进行拦截，例如只对动态请求（如 JSP、Servlet 等）进行拦截，而对静态资源不进行拦截。这种情况需要查看拦截器的配置，了解其拦截规则。

总的来说，无论是动态资源还是静态资源，在请求处理过程中都可能会经过拦截器，这取决于拦截器的配置和运行环境。

笔记：如果静态资源满足拦截条件，但是浏览器正常展示页面，那么就是静态资源被缓存了，浏览器并没有访问服务器，而是使用了缓存的静态资源，你可以试着换一个浏览器访问。

（7）拦截器的应用-登录权限控制。

package interceptor;
public class PrivilegeInterceptor implements HandlerInterceptor {
    //这里不需要重写三个，因为只需要用到一个，不用到（不写操作的方法）的就不重写
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //逻辑：判断用户是否登录，本质：判断session中有没有user
        HttpSession session = request.getSession();
        User user = (User) session.getAttribute("user");
        if (user == null){
            //没有登录，重定向和转发都可以
            //request.getRequestDispatcher("/login.jsp").forward(request,response);//可以返回true
            response.sendRedirect(request.getContextPath()+"/login.jsp");//重定向后不能返回true
            return false;
        }
        return true;//放行，访问目标资源
    }
}

二、SpringMVC异常处理。

（1）异常处理思路。

原本我们处理异常的方式是try...catch

（2）异常处理的两种方式。

（2.1）简单异常处理器。

笔记：程序遇到异常就到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:mvc="http://www.springframework.org/schema/mvc"
       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/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
">
    <!--1、mvc注解驱动-->
    <mvc:annotation-driven/>
    <!--2、配置视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--3、静态资源权限开放-->
    <mvc:default-servlet-handler/>
    <!--4、组件扫描  扫描Controller-->
    <context:component-scan base-package="controller"/>
    <!--5、配置异常处理器-->
    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <property name="defaultErrorView" value="error"/>
        <property name="exceptionMappings">
            <map>
                <!--key写异常类的路径，value写出现这个异常后要跳转的页面，没有扩展名是因为配置了视图解析器，有前缀后缀-->
                <entry key="java.lang.ClassCastException" value="error1"/>
                <!--下面这个是自定义异常,也可以不使用前缀后缀（参考前缀后缀-添加规则）-->
                <entry key="exception.MyException" value="redirect:/error2.jsp"/>
            </map>
        </property>
    </bean>
    <!--自定义异常处理器-->
    <!--<bean class="resolver.MyExceptionResolver"/>-->
</beans>

（2.2）自定义异常处理器。

自定义异常处理器类：

public class MyExceptionResolver implements HandlerExceptionResolver {
    /*
        参数Exception：异常对象
        返回值ModelAndView：跳转到错误视图信息
     */
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
        ModelAndView modelAndView = new ModelAndView();
        //左边的对象是否是它右边的类的实例(或子类实例)
        if (e instanceof MyException){
            modelAndView.addObject("info","自定义异常");
        }else if (e instanceof ClassCastException){
            modelAndView.addObject("info","类转换异常");
        }
        modelAndView.setViewName("error");
        return modelAndView;
    }
}

配置自定义处理器：

    <!--自定义异常处理器-->
    <bean class="resolver.MyExceptionResolver"/>

（3）常见的异常-不重要。

public class DemoServiceImpl implements DemoService {
    public void show1() {
        System.out.println("抛出类型转换异常....");
        Object str = "zhangsan";
        Integer num = (Integer)str;
    }
    public void show2() {
        System.out.println("抛出除零异常....");
        int i = 1/0;
    }
    public void show3() throws FileNotFoundException {
        System.out.println("文件找不到异常....");
        InputStream in = new FileInputStream("C:/xxx/xxx/xxx.txt");
    }
    public void show4() {
        System.out.println("空指针异常.....");
        String str = null;
        str.length();
    }
    public void show5() throws MyException {
        System.out.println("自定义异常....");
        throw new MyException();//抛出一个异常，可以选择try...catch进行捕获，这里选择把异常抛出去
    }
}