基于Spring WebFlux的拦截器实现

合集下载

SpringCloud使用Feign拦截器实现URL过滤和RequestParam加密

SpringCloud使⽤Feign拦截器实现URL过滤和RequestParam加密⼀、FeignInterceptor.class拦截器package com.xiaohang.socialcard.pre.intercepter;import com.xiaohang.socialcard.pre.utils.SM4Util;import feign.RequestInterceptor;import feign.RequestTemplate;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.factory.annotation.Value;import org.springframework.context.annotation.Configuration;import java.util.*;@Configuration@Slf4jpublic class FeignInterceptor implements RequestInterceptor {@Value("${encrypt.urls}")private String[] urlList;@Overridepublic void apply(RequestTemplate template) {if (Arrays.asList(urlList).contains(template.url())) {//根据URL地址过滤请求("请求参数为：{}", template.queryLine());//?param=123456Collection<String> paramList = template.queries().get("param");String param = paramList.iterator().next();try {// 加密param = SM4Util.encryptEcb("1234567890", param);} catch (Exception e) {e.printStackTrace();}Map<String, Collection<String>> newQueries = new HashMap<>();Collection<String> value = new ArrayList<>();value.add(param);newQueries.put("param", value);template.queries(newQueries);// 替换原有对象("加密后参数为：{}", template.queryLine());//?param=xxxxxx}}}⼆、配置⽂件application.ymlchangsha-payment.url: http://xx.xx.xx.xx:8080encrypt.urls: /openInter/getToken,/openInter/dispatchPayEx,/bcs/balance三、APIFeign接⼝package com.xiaohang.socialcard.pre.feign;import com.xiaohang.socialcard.pre.model.ChangShaResp;import com.xiaohang.socialcard.pre.pojo.Loffee;import flix.feign.FeignClient;import org.springframework.web.bind.annotation.*;@FeignClient(name = "changsha-payment", url = "${changsha-payment.url}")public interface ChangShaApi {@RequestMapping(method = RequestMethod.GET, path = "openInter/getToken", consumes = "*/*", produces = "application/json;charset=UTF-8")ChangShaResp getToken(@RequestParam(name = "param", required = true) String param);@RequestMapping(method = RequestMethod.POST, value = "openInter/dispatchPayEx", produces = "text/html", consumes = "application/x-www-form-urlencoded") String payPage(@RequestParam(name = "param", required = true) String param);@RequestMapping(method = RequestMethod.POST, path = "/bcs/balance", produces = "text/html", consumes = "application/x-www-form-urlencoded")String downLoadPay(@RequestParam(name = "param", required = true) String param);四、启动类Application.classpackage com.xiaohang.socialcard.pre;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import flix.feign.EnableFeignClients;@EnableFeignClients@SpringBootApplicationpublic class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);}}五、pom.xml<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion><groupId>com.xiaohang</groupId><artifactId>pre-socialcard-changsha</artifactId><version>1.0-SNAPSHOT</version><packaging>jar</packaging><parent><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-parent</artifactId><version>Camden.SR5</version></parent><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><java.version>1.8</java.version><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-eureka</artifactId><version>1.2.3.RELEASE</version></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-feign</artifactId><version>1.2.5.RELEASE</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.16.18</version></dependency><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-core</artifactId><version>2.9.9</version></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><dependencies><dependency><groupId>org.springframework</groupId><artifactId>springloaded</artifactId><version>1.2.5.RELEASE</version></dependency></dependencies></plugin></plugins></build> </project>。

SpringBoot之HandlerInterceptor拦截器的使用详解

SpringBoot之HandlerInterceptor拦截器的使⽤详解前⾔平常项⽬开发过程中，会遇到登录拦截，权限校验，参数处理，防重复提交等问题，那拦截器就能帮我们统⼀处理这些问题。

⼀、实现⽅式1.1 ⾃定义拦截器⾃定义拦截器，即拦截器的实现类，⼀般有两种⾃定义⽅式：定义⼀个类，实现org.springframework.web.servlet.HandlerInterceptor接⼝。

定义⼀个类，继承已实现了HandlerInterceptor接⼝的类，例如org.springframework.web.servlet.handler.HandlerInterceptorAdapter抽象类。

1.2 添加Interceptor拦截器到WebMvcConfigurer配置器中⾃定义配置器，然后实现WebMvcConfigurer配置器。

以前⼀般继承org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter类，不过SrpingBoot 2.0以上WebMvcConfigurerAdapter类就过时了。

有以下2中替代⽅法：直接实现org.springframework.web.servlet.config.annotation.WebMvcConfigurer接⼝。

（推荐）继承org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport类。

但是继承WebMvcConfigurationSupport会让SpringBoot对mvc的⾃动配置失效。

不过⽬前⼤多数项⽬是前后端分离，并没有对静态资源有⾃动配置的需求，所以继承WebMvcConfigurationSupport也未尝不可。

⼆、HandlerInterceptor ⽅法介绍preHandle：预处理，在业务处理器处理请求之前被调⽤，可以进⾏登录拦截，编码处理、安全控制、权限校验等处理；default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {return true;}postHandle：后处理，在业务处理器处理请求执⾏完成后，⽣成视图之前被调⽤。

Spring+Session+interceptor+ajax（拦截器）的登陆和退出

Spring+Session+interceptor+ajax（拦截器）的登陆和退出⽅法⼀使⽤servlet⾃带的HttpSession注意点： HttpSession应该作为⽅法的参数//登⼊public boolean customerLogin(HttpSession httpSession) { httpSession.setAttribute( "customer" , customer);}// 退出public String customerOut(HttpSession httpSession) {httpSession.removeAttribute( "customer" );return "login" ;}⽅法⼆：使⽤spring的@SessionAttributes("logincustomer")//登⼊@Controller@SessionAttributes("logincustomer")public class CustomerController {public JSONObject customerLogin(@RequestBody JSONObject json, ModelMap model,HttpServletResponse response) {model.addAttribute( "logincustomer" , logincustomer);}}// 退出@RequestMapping(value = "customerout" )public String customerOut(SessionStatus sessionStatus) {sessionStatus.setComplete(); // 只对@SessionAttributes("customer")有⽤，对HttpSession没⽤// 使⽤sessionStatus.setComplete( );会将所有的session全部清掉，return "login" ;}拦截器(interceptor)注意：拦截器跟ajax结合⽤的话使⽤这条语句response.sendRedirect(request. getContextPath()+"/login.jsp");实现不了调转，要把结果传给前端，再在前端上实现跳转因此要判断请求是否是ajax请求package com.dessert.interceptor;import java.io.OutputStream;import java.io.PrintStream;import javax.servlet.ServletOutputStream;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import javax.servlet.http.HttpSession;import org.springframework.web.servlet.ModelAndView;import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;public class CommonInterceptor extends HandlerInterceptorAdapter {/**在拦截器中中有三个⽅法：* preHandler：在进⼊Handler⽅法之前执⾏了，使⽤于⾝份认证，⾝份授权，登陆校验等，⽐如⾝份认证，⽤户没有登陆，拦截不再向下执⾏，*返回值为false，即可实现拦截；否则，返回true时，拦截不进⾏执⾏； postHandler* :进⼊Handler⽅法之后，返回ModelAndView之前执⾏，使⽤场景从ModelAndView参数出发，⽐如，将公⽤的模型数据在这⾥传⼊到视图，*也可以统⼀指定显⽰的视图等； afterHandler :在执⾏Handler完成后执⾏此⽅法，使⽤于统⼀的异常处理，统⼀的⽇志处理等；*/@ Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)throws Exception {HttpSession session =request.getSession();if (session.getAttribute("logincustomer") != null ) {// System.out.println(session.getAttribute("costomer"));return true ;}// 如果是ajax请求，请求头会有x-requested-withString requestWith = request.getHeader("x-requested-with" );if (requestWith != null && requestWith.equalsIgnoreCase("XMLHttpRequest" )){if (session.getAttribute("logincustomer") == null ) {return false ;} else if (session.getAttribute("logincustomer") != null ) {return true ;}} else {response.sendRedirect(request. getContextPath() +"/login.jsp" );}return false ;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,ModelAndView modelAndView) throws Exception {}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {}}springmvc中对拦截器的配置< mvc:interceptors >< mvc:interceptor >< mvc:mapping path ="/**" />< !-- <mvc:exclude-mapping path="/index.jsp" /> -->< mvc:exclude-mapping path ="/*login" />< mvc:exclude-mapping path ="/forgotpwd" / >< mvc:exclude-mapping path ="/customerregister" />< mvc:exclude-mapping path ="/vaildtel" /><mvc:exclude-mapping path ="/css/**" />< mvc:exclude-mapping path ="/js/**" />< mvc:exclude-mapping path ="/myutil/**" />< mvc:exclude- mapping path ="/images/**" />< bean class ="com.dessert.interceptor .CommonInterceptor" >< / bean ></ mvc:interceptor > </ mvc:interceptors >。

利用Spring 框架中的后置拦截器实现Web应用系统中用户注册成功后系统自动发送邮件的应用实例

</bean>
<bean id="oneSendMailAfterAdvice"
class="com.px1987.webbank.account.intercept.SendMailAfterAdvice">
杨教授工作室，版权所有，盗版必究， 2/5 页
杨教授工作室精心创作的优秀程序员职业提升必读系列资料
if(returnResult){
doSendMail(userMail);
}
}
public boolean doSendMail(String userMail){ System.out.println("已经向"+userMail+"发送了邮件");
邮件的代码
// 在此编程实现发送
return true;
杨教授工作室，版权所有，盗版必究， 3/5 页
杨教授工作室精心创作的优秀程序员职业提升必读系列资料
public class TestSendMailInterceptorBySpringAOP { public TestSendMailInterceptorBySpringAOP() { UserInfoInterface oneUserInfoBean=null; ApplicationContext
（2）编程 SendMailAfterAdvice 拦截器程序类的功能代码 package com.px1987.webbank.account.intercept; import ng.reflect.Method; import org.springframework.aop.AfterReturningAdvice; import erInfoVO; public class SendMailAfterAdvice implements AfterReturningAdvice {

springboot-实现WebService（CXF实现）的拦截器（Interceptor）

springboot-实现WebService（CXF实现）的拦截器（Interceptor）拦截器（Interceptor）是CXF功能最主要的扩展点，可以在不对核心模块进行修改的情况下，动态添加很多功能。

拦截器和JAX-WS Handler、Filter的功能类似，当服务被调用时，就会创建一个拦截器链（Interceptor Chain），拦截器链在服务输入（IN）或输出（OUT）阶段实现附加功能。

拦截器可以在客户端，也可以在服务端添加。

当客户端发起一个WebService请求时，在客户端会创建输出拦截器链(outinterceptor)，服务端接收到客户端的后，会创建输入拦截器链(ininterceptor)。

当服务端返回响应消息时，响应消息会经过服务端的输出拦截链，客户端接收到服务端的响应时，会创建输入拦截器链，响应消息先经过输入拦截器链处理。

拦截器在服务端和客户端的作用如图所示。

注：上图来源于网络。

下面，我们以一个Header认证为例，来演示CXF的拦截器的使用。

1、客户端拦截器[java] view plain copy1.public class ClientAuthorInterceptor extends AbstractPhaseInterceptor<SoapMessage> {2.3./**4.* 客户端申请的token信息5.*/6.private String token;7.8.public ClientAuthorInterceptor(String token) {9.// 设置拦截器的时机，在发送请求到服务端之前进行拦截10.super(Phase.PREPARE_SEND);11.this.token = token;12.}13.14.@Override15.public void handleMessage(SoapMessage soap) throw s Fault {16.// 在soap消息中添加认证头信息17.List<Header> headers = soap.getHeaders();18.Document doc = DOMUtils.createDocument();19.Element auth = doc.createElement(AuthorHeader.HEA DER_NAME);20.Element token = doc.createElement(AuthorHeader.HE ADER_TOKEN);21.token.setTextContent(this.token);22.auth.appendChild(token);23.Header header = new SoapHeader(new QName(Auth orHeader.HEADER_NAME), auth);24.headers.add(header);25.}26.}注意：客户端是outinterceptor2、服务端拦截器下面，服务端对发送的消息进行拦截，并做认证[java] view plain copy1.@Slf4j2.@Component3.public class AuthInterceptor extends AbstractPhaseInterc eptor<SoapMessage> {4.5.@Autowired6.private AuthorizationRepository repository;7.8.public AuthInterceptor() {9.super(ER_LOGICAL);10.}11.12.@Override13.public void handleMessage(SoapMessage message) t hrows Fault {14.Header header = message.getHeader(new QName("a uthrity"));15.if(null == header){16.log.warn("token没有认证通过!原因为：客户端请求中不存在认证的Header");17.throw new Fault(new AuthenticationException("token 没有认证通过!原因为：客户端请求中不存在认证的Header"));18.}19.Element ele = (Element) header.getObject();20.if(null == ele){21.log.warn("token没有认证通过!原因为：客户端请求中认证的Header无认证信息");22.throw new Fault(new AuthenticationException("token 没有认证通过!原因为：客户端请求中认证的Header无认证信息"));23.}24.Node node = ele.getFirstChild();25.if(null == node){26.log.warn("token没有认证通过!原因为：客户端请求中认证的Header无认证信息");27.throw new Fault(new AuthenticationException("token 没有认证通过!原因为：客户端请求中认证的Header无认证信息"));28.}29.String token = node.getTextContent();30.if(null == token || token.isEmpty()){31.log.warn("token没有认证通过!原因为：客户端请求中认证的Header无token信息");32.throw new Fault(new AuthenticationException("token 没有认证通过!原因为：客户端请求中认证的Header无token信息"));33.}34.Authorization auth = repository.findByToken(token);35.if(null == auth){36.log.warn("token没有认证通过!原因为：客户端请求中认证的token信息无效，请查看申请流程中的正确token信息");37.throw new Fault(new AuthenticationException("token 没有认证通过!原因为：客户端请求中认证的token信息无效，请查看申请流程中的正确token信息，流程申请地址:http://127.0.0.1:8080/email"));38.}("客户端认证成功，token有效!");40.}41.}注：服务端为ininterceptor编写拦截器很简单，只需继承AbstractPhaseInterceptor类并实现handleMessage即可。

spring拦截器实现原理

spring拦截器实现原理
Spring拦截器是Spring框架中的一种重要功能，它可以在控制器之前和控制器之后拦截web请求，从而实现对web请
求的前置处理和后置处理。

具体而言，Spring拦截器的实现原理主要分为以下几个步骤：
1、定义拦截器：首先需要定义拦截器，即实现Spring的HandlerInterceptor接口，定义拦截器会在控制器之前和之后拦
截web请求。

3、配置拦截器：接着需要配置拦截器，指定需要拦截的
路径，并配置拦截器的顺序，以及是否需要拦截ajax请求等。

4、前置处理：当用户发送web请求时，Spring框架会自
动检测此请求是否与配置的拦截器路径匹配，如果匹配，Spring框架会自动调用拦截器的preHandle()方法，此方法可以在控制器执行之前对web请求进行前置处理。

5、控制器处理：如果拦截器的preHandle()方法返回true，Spring框架会继续处理请求，调用控制器的逻辑处理方法；如
果返回false，Spring框架会直接将请求转发到拦截器的postHandle()方法。

6、后置处理：当控制器处理完成后，Spring框架会自动调用拦截器的postHandle()方法，此方法可以在控制器执行之后对web请求进行后置处理。

以上就是Spring拦截器的实现原理，Spring拦截器可以帮助我们在控制器之前和之后拦截web请求，从而实现对web 请求的前置处理和后置处理，是Spring框架中一种重要的功能。

详解Spring拦截器流程及多个拦截器的执行顺序

详解Spring拦截器流程及多个拦截器的执⾏顺序⽬录拦截器的定义测试拦截器多个拦截器的执⾏顺序让 preHandle 进⾏拦截总结拦截器是 Spring MVC 中的组件，它可以在进⼊请求⽅法前做⼀些操作，也可以在请求⽅法后和渲染视图后做⼀些事情。

拦截器的定义SpringMVC 的拦截器只需要实现 HandlerInterceptor 接⼝，并进⾏配置即可。

HandlerInterceptor 接⼝的定义如下：public interface HandlerInterceptor {default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {return true;}default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception { }default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {}}在 HandlerInterceptor 中共有三个⽅法，每个⽅法的含义如下：preHandler：进⼊请求⽅法之前执⾏；postHandler：请求⽅法执⾏完成之后执⾏；afterCompletion：视图渲染后执⾏。

拦截器的执⾏流程在 preHandle ⽅法中，它的返回值是 boolean 类型的，它的返回值影响着请求⽅法，以及 postHandle 和 afterCompletion 的执⾏。

使用springMVC通过Filter实现防止xss注入

使⽤springMVC通过Filter实现防⽌xss注⼊springMVC Filter防⽌xss注⼊跨站脚本⼯具（cross 斯特scripting），为不和层叠样式表（cascading style sheets,CSS）的缩写混淆，故将跨站脚本攻击缩写为XSS。

恶意攻击者往web页⾯⾥插⼊恶意scriptScript代码，当⽤户浏览该页之时，嵌⼊其中Web⾥⾯的Script代码会被执⾏，从⽽达到恶意攻击⽤户的⽬的。

防⽌XSS攻击简单的预防就是对Request请求中的⼀些参数去掉⼀些⽐较敏感的脚本命令。

原本是打算通过springMVC的HandlerInterceptor机制来实现的，通过获取request然后对request中的参数进⾏修改，结果虽然值修改了，但在Controller中获取的数值还是没有修改的。

没办法就是要Filter来完成。

简单来说就是创建⼀个新的httpRequest类XsslHttpServletRequestWrapper，然后重写⼀些get⽅法（获取参数时对参数进⾏XSS判断预防）。

@WebFilter(filterName="xssMyfilter",urlPatterns="/*")public class MyXssFilter implements Filter{@Overridepublic void init(FilterConfig filterConfig) throws ServletException {}@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {XsslHttpServletRequestWrapper xssRequest = new XsslHttpServletRequestWrapper((HttpServletRequest)request);chain.doFilter(xssRequest , response);}@Overridepublic void destroy() {}}XSS代码的过滤是在XsslHttpServletRequestWrapper中实现的，主要是覆盖实现了getParameter，getParameterValues，getHeader这⼏个⽅法，然后对获取的value值进⾏XSS处理。

详解SpringMVC拦截器配置及使用方法

详解SpringMVC拦截器配置及使⽤⽅法本⽂介绍了SpringMVC拦截器配置及使⽤⽅法，分享给⼤家，具体如下：常见应⽤场景1、⽇志记录：记录请求信息的⽇志，以便进⾏信息监控、信息统计、计算PV（Page View）等。

2、权限检查：如登录检测，进⼊处理器检测检测是否登录，如果没有直接返回到登录页⾯；3、性能监控：有时候系统在某段时间莫名其妙的慢，可以通过拦截器在进⼊处理器之前记录开始时间，在处理完后记录结束时间，从⽽得到该请求的处理时间（如果有反向代理，如apache可以⾃动记录）；4、通⽤⾏为：读取cookie得到⽤户信息并将⽤户对象放⼊请求，从⽽⽅便后续流程使⽤，还有如提取Locale、Theme信息等，只要是多个处理器都需要的即可使⽤拦截器实现。

5、OpenSessionInView：如Hibernate，在进⼊处理器打开Session，在完成后关闭Session。

本质也是AOP（⾯向切⾯编程），也就是说符合横切关注点的所有功能都可以放⼊拦截器实现。

配置⽂件定义两个拦截器 HandleInterceptor1 ， HandleInterceptor2<mvc:interceptors><mvc:interceptor><mvc:mapping path="/**"/><bean class="com.xwx.interceptor.HandleInterceptor1"></bean></mvc:interceptor><mvc:interceptor><mvc:mapping path="/**"/><bean class="com.xwx.interceptor.HandleInterceptor2"></bean></mvc:interceptor></mvc:interceptors>使⽤⽅法preHandle 在Handle执⾏前执⾏return true 继续执⾏ false不继续执⾏在modelAndView 执⾏前执⾏在 Handle 执⾏后执⾏HandleInterceptor1 .javapackage com.xwx.interceptor;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.apache.log4j.Logger;import org.springframework.web.servlet.HandlerInterceptor;import org.springframework.web.servlet.ModelAndView;public class HandleInterceptor1 implements HandlerInterceptor {public static Logger log = Logger.getLogger(HandleInterceptor1.class.getName());/*** 在Handle执⾏前执⾏* return true 继续执⾏ false不继续执⾏*/public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)throws Exception {("HandleInterceptor1 ...... preHandle");return true;}/*** 在modelAndView 执⾏前执⾏*/public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,ModelAndView modelAndView) throws Exception {("HandleInterceptor1 ...... postHandle");}/*** 在 Handle 执⾏后执⾏*/public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {("HandleInterceptor1 ...... afterCompletion");}}HandleInterceptor2 .javapackage com.xwx.interceptor;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.apache.log4j.Logger;import org.springframework.web.servlet.HandlerInterceptor;import org.springframework.web.servlet.ModelAndView;public class HandleInterceptor2 implements HandlerInterceptor {public static Logger log = Logger.getLogger(HandleInterceptor2.class.getName());/*** 在Handle执⾏前执⾏* return true 继续执⾏ false不继续执⾏*/public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)throws Exception {("HandleInterceptor2 ...... preHandle");return false;}/*** 在modelAndView 执⾏前执⾏*/public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,ModelAndView modelAndView) throws Exception {("HandleInterceptor2 ...... postHandle");}/*** 在 Handle 执⾏后执⾏*/public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {("HandleInterceptor2 ...... afterCompletion");}}拦截器执⾏顺序preHandle 按顺序执⾏， postHandle afterCompletion 则是逆向执⾏16:08:29,187 INFO HandleInterceptor1:20 - HandleInterceptor1 ...... preHandle16:08:29,187 INFO HandleInterceptor2:20 - HandleInterceptor2 ...... preHandle16:08:29,640 INFO HandleInterceptor2:29 - HandleInterceptor2 ...... postHandle16:08:29,640 INFO HandleInterceptor1:29 - HandleInterceptor1 ...... postHandle16:08:29,706 INFO HandleInterceptor2:38 - HandleInterceptor2 ...... afterCompletion16:08:29,706 INFO HandleInterceptor1:38 - HandleInterceptor1 ...... afterCompletion第⼀个拦截器没通过，不会继续执⾏。

spring拦截器（interceptor）简介

spring拦截器（interceptor）简介1. 拦截器⽤途（1）拦截未登录⽤户直接访问某些链接（2）拦截⽇志信息（3）拦截⾮法攻击，⽐如sql注⼊2. 涉及jar、类（1）spring-webmvc.jar （2）HandlerInterceptor(org.springframework.web.servlet：接⼝)、 AsyncHandlerInterceptor(org.springframework.web.servlet：接⼝)、　 HandlerInterceptorAdapter(org.springframework.web.servlet.handler.HandlerInterceptorAdapter：抽象类)3.业务类（1）实现（implements）实现HandlerInterceptor接⼝或者⼦接⼝（2）继承（extends）继承HandlerInterceptor接⼝⼦类（抽象类）（3）涉及的⽅法 preHandle、postHandle、afterCompletion4.测试代码LoginInterceptor1public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler throws Exception {2 ("--------preHandle-------" + request.getRequestURI());3 HttpSession session = request.getSession();4 String login_account = String.valueOf(session.getAttribute(CommonConstants.SESSION_KEY+session.getId()));5 if(!request.getRequestURI().contains("/baselogin/")){6 if (StringUtils.isBlank(login_account) || "null".equalsIgnoreCase(login_account)) {7 response.sendRedirect("/baselogin/loginPage.htm");8 return false;9 }10 }11 return true;12 }1314public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)throws Exception { 15 ("--------postHandle-------" + request.getRequestURI());16 }1718public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {19 ("--------afterCompletion-------" + request.getRequestURI());20 }2122public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {23 ("--------afterConcurrentHandlingStarted-------" + request.getRequestURI());24 }执⾏顺序：preHandle -> controller -> postHandle -> afterCompletion配置：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:context="/schema/context"xmlns:xsi="/2001/XMLSchema-instance" xmlns:aop="/schema/aop"xmlns:p="/schema/p" xmlns:mvc="/schema/mvc"xsi:schemaLocation="/schema/context/schema/context/spring-context-3.2.xsd/schema/beans/schema/beans/spring-beans-3.2.xsd/schema/aop/schema/aop/spring-aop-3.2.xsd/schema/mvc/schema/mvc/spring-mvc-3.2.xsd"><mvc:interceptors><mvc:interceptor><mvc:mapping path="/*/*.htm"/><bean class="org.bighead.interceptor.LoginInterceptor"/></mvc:interceptor></mvc:interceptors><beans>。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

基于Spring WebFlux的拦截器实现
Spring WebFlux: 编写拦截器
Spring WebFlux是Spring 5+的一部分, 提供了一种新的响应性Web框架。

在基于Spring MVC 的传统应用程序(Servlet Filter, HandlerInterceptor)中编写过滤器的方式与在基于Spring WebFlux的应用程序中编写过滤器的方式截然不同，本文将简单介绍使用WebFlux编写过滤器的方法。

方法1: WebFilter
使用WebFilter编写的拦截器会广泛影响到所有端点,并覆盖了用函数样式编写的WebFlux端点，以及使用注释样式编写的端点。

. Kotlin中的WebFilter如下所示：
@Bean
fun sampleWebFilter(): WebFilter {
return WebFilter { e: ServerWebExchange, c: WebFilterChain ->
val l: MutableList<String> = e.getAttributeOrDefault(KEY, mutableListOf())
l.add("From WebFilter")
e.attributes.put(KEY, l)
c.filter(e)
}
}
WebFilter 只是添加了一个请求属性，该属性的值是一个集合。

方法2: HandlerFilterFunction
这种方法更加的专注于使用函数样式编写的端点。

这里我们参考下面的代码来使用RouterFunctions
来构建一个filter。

按照下面的办法设置Spring WebFlux 的端点：
@Bean
fun route(): RouterFunction<*> = router
{ GET("/react/hello", { r ->
ok().body(fromObject(
Greeting("${r.attribute(KEY).orElse("[Fallback]: ")}: Hello")
))
POST("/another/endpoint", TODO())
PUT("/another/endpoint", TODO())
})
}
通过下面的代码看到，单独拦截这些API 的HanderFIlterFunction 可以被高度集中地添加：
fun route(): RouterFunction<*> = router
{ GET("/react/hello", { r ->
ok().body(fromObject(
Greeting("${r.attribute(KEY).orElse("[Fallback]: ")}: Hello")
))
})
POST("/another/endpoint", TODO())
PUT("/another/endpoint", TODO())
}.filter({ r: ServerRequest, n: HandlerFunction<ServerResponse> ->
val greetings: MutableList<String> = r.attribute(KEY)
.map { v ->
v as MutableList<String>
}.orElse(mutableListOf())
greetings.add("From HandlerFilterFunction")
r.attributes().put(KEY, greetings)
n.handle(r)
})
请注意，不需要明确Kotlin中的类型我添加它只是为了明确某些lambda表达式中的类型。

结束语
WebFilter和HandlerFilterFunction与使用Servlet规范编写过滤器或使用HandlerInterceptors的基于Spring-WebMVC的方法大不相同。

这篇文章总结了新的方法。

有关更多信息，我在我的my git repo中提供了示例，git 上面有详细信息。