拦截器的使用

穿越：从0开始，构建前后端分离应用

拦截器的作用

拦截器是web项目不可或缺的组成部分，一般使用拦截器实现以下功能

1、登录session验证

　　防止浏览器端绕过登录，直接进入到应用

　　或者session超时后，返回到登录页面

2、记录系统日志

　　一个完善的应用系统，应该具备监控功能，通过完善的系统日志记录系统运行过程中都经历了什么，当发生错误的时候及时通知管理人员，将损失降到最低。同时通过系统日志的监控，也能监控每次访问的响应时长，作为性能调优的参考

3、对请求进行前置或后置的操作

　　比如对于服务端返回的异常信息，可以通过拦截器统一的进行后处理，使其格式统一

拦截器的实现方式

有两种方式

1、基于Spring AOP 的切面方式

2、基于Servlet规范的拦截器

实战

下面分享一下拦截器，在我的项目中是如何使用的。

我分别用基于Spring AOP的拦截器实现了登录验证及系统日志

使用基于Servlet规范的拦截器实现了跨域请求

基于Spring AOP的拦截器-登录验证

实现过程

1、pom中添加依赖

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.1</version>
</dependency>

2、开启Spring对@AspectJ的支持

在spring-mybatis.xml配置文件中，加入下面的内容

<!--开启Spring对@AspectJ的支持-->

<aop:aspectj-autoproxy/>

当然，要先在xml文件头部加上aop的命名空间（红色字体部分）

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

3、新建拦截器类 LoginInterceptor
4、在类上添加注解
     @Component ：将类的实例纳入到Spring 容器中管理
     @Aspect ：声明是基于@ASpectJ的注解实现
5、新建通知方法
    当应用中的方法处于切点表达式声明的范围内的时候，通知将被执行
6、使用@Around、@Before、@After来生命通知的类型是环绕通知、前置通知、后置通知
7、定义切点表达式

具体实现

 1 package com.wt.common.security.interceptor;
 2
 3 import com.wt.common.core.annotations.IgnoreAuth;
 4 import com.wt.common.core.result.HttpResultEntity;
 5 import com.wt.common.core.result.HttpResultHandle;
 6 import com.wt.common.core.utils.ServletNativeObjectUtil;
 7 import com.wt.common.security.handler.HttpSessionHandler;
 8 import com.wt.common.security.model.SysUser;
 9 import org.aspectj.lang.ProceedingJoinPoint;
10 import org.aspectj.lang.annotation.Around;
11 import org.aspectj.lang.annotation.Aspect;
12 import org.aspectj.lang.reflect.MethodSignature;
13 import org.springframework.core.annotation.Order;
14 import org.springframework.stereotype.Component;
15
16 import javax.servlet.http.HttpServletRequest;
17 import java.lang.reflect.Method;
18
19 /**
20  * @ProjectName: syInfo
21  * @Package: com.wt.common.core.interceptor
22  * @Description:
23  * @Author: [email protected]
24  * @CreateDate: 2018/5/16 上午8:20
25  * @Version: v1.0
26  */
27
28 @Component
29 @Order(1)
30 @Aspect
31 public class LoginInterceptor {
32 //    Logger logger = LoggerFactory.getLogger(LoginInterceptor.class);
33
34     @Around("@within(org.springframework.web.bind.annotation.RestController)")
35     public HttpResultEntity loginCheck(ProceedingJoinPoint pjp) throws Throwable {
36         HttpServletRequest request = ServletNativeObjectUtil.getRequest();
37         SysUser loginUser = (SysUser) request.getSession().getAttribute(HttpSessionHandler.Items.LOGINUSER.name());
38
39         final MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
40         final Method method = methodSignature.getMethod();
41         boolean ignoreAuth = method.isAnnotationPresent(IgnoreAuth.class);
42
43         if ((null == loginUser)&&!ignoreAuth) {
44             return new HttpResultEntity(HttpResultHandle.HttpResultEnum.NOTLOG);
45         }
46         return (HttpResultEntity) pjp.proceed();
47     }
48 }

一些说明

在上述过程中需要理解一下的有以下两点
1、切点表达式
@within(org.springframework.web.bind.annotation.RestController)
它的意思代表了，通知的范围是只要有类添加了@RestController的注解，那么类中的方法，只要被调用，都会执行相应的通知
2、为什么这么配置呢？
为什么这么配置：因为我的项目是基于SpringMVC框架的，并且使用的请求都是基于Restful规范的。所以所有的Action都会配置@RestController这个注解，也就是说，所有的后台请求，
3、上述配置要完成的功能是什么？
如果用户没有登录，那么请求就会被打回，并在页面上给与用户提示
4、对于@Around环绕通知的执行过程是什么样的？
正常流：浏览器发起请求-》通知被执行-》在通知的内部，根据业务逻辑判断，该请求是否合法，也就是前置的一些处理，如果合法调用pjp.proceed()方法-》进入controller的方法执行，执行完成后-》返回到通知内部，继续执行pjp.proceed()后面的代码-》返回客户端
异常流：浏览器发起请求-》通知被执行-》在通知的内部，根据业务逻辑判断，该请求是否合法，也就是前置的一些处理，如果不合法，直接return-》浏览器显示处理结果

关于@AspectJ的相关知识就不再这里介绍了，感兴趣的朋友可以查看：@Aspect注解教程

基于Spring AOP的拦截器-系统日志

具体实现

  1 package com.wt.common.security.interceptor;
  2
  3
  4 import com.google.gson.Gson;
  5 import com.wt.common.core.exception.BaseErrorException;
  6 import com.wt.common.core.exception.BaseLogicException;
  7 import com.wt.common.core.result.HttpResultEntity;
  8 import com.wt.common.core.result.HttpResultHandle;
  9 import com.wt.common.core.utils.ServletNativeObjectUtil;
 10 import com.wt.common.security.handler.HttpSessionHandler;
 11 import com.wt.common.security.model.SysUser;
 12 import com.wt.common.security.model.SyslogPerformance;
 13 import com.wt.common.security.service.SyslogPerformanceService;
 14 import org.apache.commons.lang3.StringUtils;
 15 import org.aspectj.lang.ProceedingJoinPoint;
 16 import org.aspectj.lang.annotation.Around;
 17 import org.aspectj.lang.annotation.Aspect;
 18 import org.slf4j.Logger;
 19 import org.slf4j.LoggerFactory;
 20 import org.springframework.beans.factory.annotation.Autowired;
 21 import org.springframework.core.annotation.Order;
 22 import org.springframework.stereotype.Component;
 23
 24 import javax.servlet.http.HttpServletRequest;
 25
 26 /**
 27  * @ProjectName: syInfo
 28  * @Package: com.wt.common.core.interceptor
 29  * @Description:
 30  * @Author: [email protected]
 31  * @CreateDate: 2018/5/16 下午4:14
 32  * @Version: v1.0
 33  */
 34
 35 @Component
 36 @Aspect
 37 @Order(2)
 38 public class LogInterceptor {
 39
 40     Logger logger = LoggerFactory.getLogger(LoginInterceptor.class);
 41
 42     @Autowired
 43     private SyslogPerformanceService syslogPerformanceService;
 44
 45
 46     @Around("@within(org.springframework.web.bind.annotation.RestController)")
 47     public HttpResultEntity logRecord(ProceedingJoinPoint pjp) {
 48         Gson gson = new Gson();
 49         HttpServletRequest request = ServletNativeObjectUtil.getRequest();
 50         SyslogPerformance syslogPerformance = this.setLog(request);
 51         syslogPerformance.setParameters(gson.toJson(pjp.getArgs()));
 52
 53         long startTime = System.currentTimeMillis(), endTime = 0, consume = 0;
 54
 55         String requestInfo = String.format("??{User-Agent:[%s],Protocol:[%s],Remote Addr:[%s],Method:[%s],uri:[%s],Cookie:[%s],operator:[%s],parameters:[%s]}??",
 56                 request.getHeader("User-Agent"), request.getProtocol(), request.getRemoteAddr(),
 57                 request.getMethod(), request.getRequestURI(), request.getHeader("Cookie"),
 58                 "ceshi",
 59                 gson.toJson(pjp.getArgs()));
 60         try {
 61             HttpResultEntity result = (HttpResultEntity) pjp.proceed();
 62             endTime = System.currentTimeMillis();
 63             logger.info(requestInfo);
 64             return result;
 65         } catch (Throwable throwable) {
 66             endTime = System.currentTimeMillis();
 67             if (throwable instanceof BaseLogicException) {
 68                 String errorMessage = ((BaseLogicException) throwable).getExceptionBody().getMessage();
 69                 String errorCode = ((BaseLogicException) throwable).getExceptionBody().getMessage();
 70                 logger.error(StringUtils.join(requestInfo, errorMessage), throwable);
 71                 return HttpResultHandle.getErrorResult(errorCode, errorMessage);
 72             }
 73             if (throwable instanceof BaseErrorException) {
 74                 logger.error(StringUtils.join(requestInfo, throwable.getMessage()), throwable);
 75                 return HttpResultHandle.getErrorResult();
 76             }
 77
 78             logger.error(StringUtils.join(requestInfo, throwable.getMessage()), throwable);
 79             return HttpResultHandle.getErrorResult();
 80
 81         } finally {
 82             consume = endTime - startTime;
 83             syslogPerformance.setTimeConsuming(String.valueOf(consume));
 84             syslogPerformanceService.save(syslogPerformance);
 85         }
 86     }
 87
 88     private SyslogPerformance setLog(HttpServletRequest request) {
 89         SysUser currentUser = (SysUser) request.getSession().getAttribute(HttpSessionHandler.Items.LOGINUSER.name());
 90         SyslogPerformance syslogPerformance = new SyslogPerformance();
 91         syslogPerformance
 92                 .setRemoteHost(request.getRemoteHost())
 93                 .setRemotePort(request.getRemotePort())
 94                 .setRequestType(request.getMethod())
 95                 .setRequestURI(request.getRequestURI());
 96         if(currentUser!=null){
 97             syslogPerformance.setOperatorId(currentUser.getUserId()).setOperatorName(currentUser.getUserName());
 98         }
 99         return syslogPerformance;
100     }
101 }

一些说明

1、如果后台的请求执行正常，那么放行并记录日志

2、如果出现错误，同一处理结果，并返回结果到浏览器

3、无论处理过程是否异常，都会记录到数据库表当中

效果

1、功能如下图，每当一次请求被执行，在日志表中都会进行记录，包括时长，及时间。可以再扩展一下，加上操作人

基于Servlet规范的拦截器-跨域请求

实现过程

1、新建拦截器类CrossDomainInterceptor，并继承自HandlerInterceptor

2、对拦截器进行配置，在spring配置文件中，添加下面的内容

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

    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <mvc:exclude-mapping path="/index.html"/>
            <bean class="com.wt.common.core.interceptor.CrossDomainInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

</beans>

3、重写以下方法

preHandle：在请求调用之前调用

postHandle：在请求执行完成，且返回视图渲染之前调用

afterCompletion：在请求执行完成，并且完成视图渲染之后执行

具体实现

 1 package com.wt.common.core.interceptor;
 2
 3 import org.slf4j.Logger;
 4 import org.slf4j.LoggerFactory;
 5 import org.springframework.core.annotation.Order;
 6 import org.springframework.web.servlet.HandlerInterceptor;
 7
 8 import javax.servlet.http.HttpServletRequest;
 9 import javax.servlet.http.HttpServletResponse;
10
11 /**
12  * @ProjectName: syInfo
13  * @Package: com.wt.common.core.interceptor
14  * @Description:
15  * @Author: [email protected]
16  * @CreateDate: 2018/5/15 下午11:21
17  * @Version: v1.0
18  */
19 @Order(1)
20 public class CrossDomainInterceptor implements HandlerInterceptor {
21     Logger logger = LoggerFactory.getLogger(CrossDomainInterceptor.class);
22     @Override
23     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
24         response.setHeader("Access-Control-Allow-Headers", "X-Requested-With, accept, content-type, xxxx");
25         response.setHeader("Access-Control-Allow-Methods", "GET, HEAD, POST, PUT, DELETE, TRACE, OPTIONS, PATCH");
26         response.setHeader("Access-Control-Allow-Origin", "*");
27         response.setHeader("Access-Control-Allow-Credentials", "true");
28         return true;
29     }
30 }

一些说明

1、这个比较简单，没什么太多说的地方，注意方法的返回值即可，根据项目的业务逻辑，如果请求通行，那么就return true，否则返回false。
2、如果有多个拦截器，执行顺序会按照拦截器在spring配置文件中声明的先后顺序执行，执行过程如下
    如果有A、B两个拦截器，A声明在先，B声明在后，执行顺序为
    A.preHandle-》B.preHandle-》B.postHandle-》A.postHandle

原文地址：https://www.cnblogs.com/lichking2017/p/9053625.html

时间： 2024-08-30 07:41:42

拦截器的使用的相关文章

java web 过滤器跟拦截器的区别和使用

1.首先要明确什么是拦截器.什么是过滤器 1.1 什么是拦截器: 拦截器,在AOP(Aspect-Oriented Programming)中用于在某个方法或字段被访问之前,进行拦截然后在之前或之后加入某些操作.拦截是AOP的一种实现策略. 在Webwork的中文文档的解释为--拦截器是动态拦截Action调用的对象.它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码,也可以在一个action执行前阻止其执行.同时也是提供了一种可以提取action中可重用的部分的方式.

微信小程序之页面拦截器

场景 小程序有52个页面,其中13个页面无需任何身份,另外39个页面需要系统角色.对于这39个页面,如果微信用户没有系统角色,则跳转到登录页.是否有系统角色信息需要通过异步请求来获取. 需求分析&实现 对需求进行抽象,其实要的就是一个过滤器,对小程序页面的访问进行过滤,符合条件的通过,不符合条件进行其他处理. 使用过php的laravel框架的童鞋,肯定一下子就联想到了laravel框架的http中间件:HTTP 中间件提供一个方便的机制来过滤进入应用程序的 HTTP 请求,例如,Laravel

SpringMvc拦截器小测试

前言 俗话说做项目是让人成长最快的方案,最近小编写项目的时候遇到了一个小问题.小编在项目中所负责的后台系统,但是后台系统是通过系统的页面是通过ifame联动的,那么这时候问题就来了,后台所做的所有操作都是联动操作(都是基于所联动的)那么我后台所做的所有操作都是基于后台用户登录的情况下所做的.但是在联动中中所有页面都是单独存在的,如果要解决这个问题就需要在做操作之前判断用后台用户是否已经登录.想知道小编是如何实现的那就接着往下看. 简介 Spring MVC的拦截器不仅可实现Filter的所有功能

7.添加基于Spring的WebService拦截器

客户端拦截器: public class AccountInterceptor extends AbstractPhaseInterceptor<SoapMessage>{ private String name; private String password; public AccountInterceptor(String name,String password) { //Phase值决定了拦截器什么时候拦截到消息 //PRE_PROTOCOL准备请求时拦截 super(Phase.P

struts2学习笔记---自定义拦截器

什么是拦截器? struts2中拦截器分为Struts2定义好的拦截器和自定义的拦截器.其作用是在一个Action执行之前进行拦截,在Action执行之后又加入某些操作. 实现原理 当请求一个Action时,struts2会查找配置文件,并根据这个Action的配置实例化对应的拦截器对象,然后串成一个列表(list),最后一个一个地调用列表中的拦截器. 拦截器的执行流程 1.对Action进行预处理.(正序执行) 2.拦截器自身决定该不该执行后续的拦截器(由invoke()方法的返回值决定).

使用方法拦截器MethodInterceptor和AOP统一处理log

对每个接口的请求记录log的方法有很多种,比如用filter.mvc interceptor.method interceptor等.如果需要记录请求消息的payload,前两种不适用.下面介绍第三种的实现方法. 第一步:引入包依赖 <span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"></span><pre name=&

过滤器、监听器、拦截器的区别

1.过滤器 Servlet中的过滤器Filter是实现了javax.servlet.Filter接口的服务器端程序,主要的用途是过滤字符编码.做一些业务逻辑判断等.其工作原理是,只要你在web.xml文件配置好要拦截的客户端请求,它都会帮你拦截到请求,此时你就可以对请求或响应(Request.Response)统一设置编码,简化操作:同时还可进行逻辑判断,如用户是否已经登陆.有没有权限访问该页面等等工作.它是随你的web应用启动而启动的,只初始化一次,以后就可以拦截相关请求,只有当你的web应用

spring mvc 方法注解拦截器

应用场景,在方法级别对本次调用进行鉴权,如api接口中有个用户唯一标示accessToken,对于有accessToken的每次请求可以在方法加一个拦截器,获得本次请求的用户,存放到request或者session域. python中,之前在python flask中可以使用装饰器来对方法进行预处理,进行权限处理 先看一个实例,使用@access_required拦截: @api.route('/post_apply') @access_required def apply():     "&q

【struts2】预定义拦截器

1)预定义拦截器 Struts2有默认的拦截器配置,也就是说,虽然我们没有主动去配置任何关于拦截器的东西,但是Struts2会使用默认引用的拦截器.由于Struts2的默认拦截器声明和引用都在这个Struts-default.xml里面,因此我们需要到这个文件的struts-default包里去看一下.定义如下: 1 <interceptors> 2 <interceptor name="alias" class="com.opensymphony.xwor

mybatis拦截器

业务需求:由于公司业务需要在所有的sql的增删改查中必须包含officeId,业务以officeId做隔离.因此做了一个Mybatis的的过去器.通过拦截sql处理的过程来判断接口sql是否包含officeId,如果不包含则添加officeId.@NoNeedOffice的注解可以添加在Dao的接口类或方法上.用于标识不需要处理的接口. package com.example.springcloud.provider; import com.example.springcloud.provide