关于Spring MVC拦截器的简介以及使用

合集下载

SpringBoot使用过滤器、拦截器、切面（AOP），及其之间的区别和执行顺序

SpringBoot使⽤过滤器、拦截器、切⾯（AOP），及其之间的区别和执⾏顺序先上代码，下⾯的demo中包含多个拦截器、过滤器，以及切⾯的前置通知/后置通知/环绕通知：下⾯总结⼀下相关原理：⾸先了解⼀下SpringMVC的执⾏流程具体流程如下1. ⽤户发起请求到前端控制器（Controller）2. 前端控制器没有处理业务逻辑的能⼒，需要找到具体的模型对象处理（Handler），到处理器映射器（HandlerMapping）中查找Handler对象（Model）。

3. HandlerMapping返回执⾏链，包含了2部分内容：① Handler对象、②拦截器数组4. 前端处理器通过处理器适配器包装后执⾏Handler对象。

5. 处理业务逻辑。

6. Handler处理完业务逻辑，返回ModelAndView对象，其中view是视图名称，不是真正的视图对象。

7. 将ModelAndView返回给前端控制器。

8. 视图解析器（ViewResolver）返回真正的视图对象（View）。

9. （此时前端控制器中既有视图⼜有Model对象数据）前端控制器根据模型数据和视图对象，进⾏视图渲染。

10. 返回渲染后的视图（html/json/xml）返回。

11. 给⽤户产⽣响应。

核⼼就是DispatcherServlet核⼼控制器，我们看源码可知道DispatcherServlet是Servlet的⼦类下⾯⽤⼀张图说⼀下过滤器、Servlet容器、拦截器、AOP、Controller之间的关系然后具体执⾏流程如下：拦截器和过滤器的区别1、拦截器不依赖与servlet容器是SpringMVC⾃带的，过滤器依赖于Servlet容器。

2、拦截器是基于java的反射机制的，⽽过滤器是基于函数回调。

3、拦截器只能对action请求起作⽤，⽽过滤器则可以对⼏乎所有的请求起作⽤。

4、拦截器可以访问controller上下⽂、值栈⾥的对象，⽽过滤器不能访问。

浅谈SpringMVC中Interceptor和Filter区别

浅谈SpringMVC中Interceptor和Filter区别Interceptor主要作⽤：拦截⽤户请求，进⾏处理，⽐如判断⽤户登录情况、权限验证，只要针对Controller请求进⾏处理，是通过HandlerInterceptor。

Interceptor分两种情况，⼀种是对会话的拦截，实现spring的HandlerInterceptor接⼝并注册到mvc的拦截队列中，其中preHandle()⽅法在调⽤Handler之前进⾏拦截(上图步骤3)，postHandle()⽅法在视图渲染之前调⽤(上图步骤5)，afterCompletion()⽅法在返回相应之前执⾏；另⼀种是对⽅法的拦截，需要使⽤@Aspect注解，在每次调⽤指定⽅法的前、后进⾏拦截。

Filter主要作⽤：过滤字符编码、做⼀些业务逻辑判断，主要⽤于对⽤户请求进⾏预处理，同时也可进⾏逻辑判断。

Filter在请求进⼊servlet容器执⾏service()⽅法之前就会经过filter过滤（上图步骤1），不像Intreceptor⼀样依赖于springmvc框架，只需要依赖于servlet。

Filter启动是随WEB应⽤的启动⽽启动，只需要初始化⼀次，以后都可以进⾏拦截。

Filter有如下⼏个种类：⽤户授权Filter：检查⽤户请求，根据请求过滤⽤户⾮法请求；⽇志Filter：记录某些特殊的⽤户请求；解码Filter：对⾮标准编码的请求解码。

Filter和Interceptor的区别1. Filter是基于函数回调（doFilter()⽅法）的，⽽Interceptor则是基于Java反射的（AOP思想）。

2. Filter依赖于Servlet容器，⽽Interceptor不依赖于Servlet容器。

3. Filter对⼏乎所有的请求起作⽤，⽽Interceptor只能对action请求起作⽤。

4. Interceptor可以访问Action的上下⽂，值栈⾥的对象，⽽Filter不能。

handlerinterceptoradapter posthandle处理返回参数

handlerinterceptoradapter posthandle处理返回参数`HandlerInterceptorAdapter` 是Spring MVC 中的一个拦截器适配器，用于在请求处理前、请求处理后以及视图渲染后进行一些自定义的操作。

在`HandlerInterceptorAdapter` 中，`postHandle` 方法用于在请求处理后进行一些操作，包括修改返回的视图或模型等。

以下是一个简单的示例，演示如何在`postHandle` 方法中处理返回的参数：```javaimport javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.springframework.web.servlet.HandlerInterceptor;import org.springframework.web.servlet.ModelAndView;import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;public class CustomInterceptor extends HandlerInterceptorAdapter {@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,ModelAndView modelAndView) throws Exception {// 在请求处理后进行一些操作if (modelAndView != null) {// 获取原始的模型数据ModelAndView originalModelAndView = modelAndView;// 进行一些处理，修改返回的参数modelAndView = new ModelAndView("customView");modelAndView.addObject("customAttribute", "customValue");// 将原始的模型数据拷贝到新的ModelAndView 中modelAndView.addAllObjects(originalModelAndView.getModel());}}}```在上面的示例中，`postHandle` 方法接收了`HttpServletRequest`、`HttpServletResponse`、被处理的处理程序（controller 方法）、以及`ModelAndView` 对象。

Java中的拦截器

Java中的拦截器⼀.　拦截器的概念和作⽤拦截器（Interceptor）是⼀种动态拦截⽅法调⽤的机制，在SpringMVC中动态拦截控制器⽅法的执⾏作⽤：1. 在指定的⽅法调⽤前后执⾏预先设定的代码2. 阻⽌原始⽅法的执⾏3. 总结：增强核⼼原理：AOP思想⼆. 拦截器和过滤器的区别归属不同：Filter属于Servlet技术，Interceptor属于SpringMVC技术拦截内容不同：Filter对所有访问进⾏增强，Interceptor仅针对SpringMVC的访问进⾏增强三. 拦截器代码实现【第⼀步】定义拦截器做法：定义⼀个类，实现HandlerInterceptor接⼝即可@Component //注意当前类必须受Spring容器控制//定义拦截器类，实现HandlerInterceptor接⼝public class ProjectInterceptor implements HandlerInterceptor {@Override//原始⽅法调⽤前执⾏的内容//返回值类型可以拦截控制的执⾏，true放⾏，false终⽌public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { System.out.println("preHandle..."+contentType); return true;}@Override//原始⽅法调⽤后执⾏的内容public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndViewmodelAndView) throws Exception { System.out.println("postHandle...");}@Override//原始⽅法调⽤完成后执⾏的内容public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { System.out.println("afterCompletion..."); }}【第⼆步】配置加载拦截器@Configurationpublic class SpringMvcSupport extends WebMvcConfigurationSupport { @Autowired private ProjectInterceptor projectInterceptor; @Override protected void addInterceptors(InterceptorRegistry registry) { //配置拦截器 registry.addInterceptor(projectInterceptor) .addPathPatterns("/books","/books/*"); }}使⽤标准接⼝WebMvcConfigurer简化开发（注意：侵⼊式较强）　@Configuration@ComponentScan({"com.itheima.controller"})@EnableWebMvc//实现WebMvcConfigurer接⼝可以简化开发，但具有⼀定的侵⼊性public class SpringMvcConfig implements WebMvcConfigurer { @Autowired private ProjectInterceptor projectInterceptor; @Override public void addInterceptors(InterceptorRegistry registry) { //配置多拦截器 registry.addInterceptor(projectInterceptor) .addPathPatterns("/books","/books/*"); }}。

什么是SpringMVC？

什么是SpringMVC？⼀、什么是SpringMVC？1.SpringMVC 是⼀种基于 Java 的实现 MVC 设计模型的请求驱动类型的轻量级 Web 框架，属于SpringFrameWork的后续产品，已经融合在Spring Web Flow 中。

2.SpringMVC = Spring +MVCspring mvc类似于struts的⼀个MVC开框架，其实都是属于spring，spring mvc需要有spring的架包作为⽀撑才能跑起来.spring是⼀个⼀站式的框架，提供了表现层（springmvc）到业务层（spring）再到数据层（springdata）的全套解决⽅案；spring的两⼤核⼼IOC(控制反转)和AOP(⾯向切⾯编程)更是给我们的程序解耦和代码的简介提供了⽀持。

Spring框架图：从Spring的结构图可以看出，springMVC位于spring web端的⼀个框架，是⼀种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使⽤了MVC架构模式的思想，将web层进⾏职责解耦。

附：基于请求驱动指的就是使⽤请求-响应模型。

从名字上就可以窥探出，Spring>SpringMVC，那么事实上，spring和SpringMVC是⼀种⽗⼦关系。

SpringMVC是spring扩展出的⼀个应⽤于web端的框架。

在这⾥需要注意的⼀点，就是到底什么是⽗⼦容器关系：spring主要的作⽤是黏合其他模块组件，进⾏统⼀管理，springmvc则主要是负责web端。

那么，我们都知道，我们在应⽤spring的时候，可以使⽤注⼊。

这个时候，如果我们的web端是⽤的SpringMVC，这个时候，controller理论上是通过SpringMVC去注⼊，但是，使⽤spring注⼊，同样是可⾏的。

同理，service等层，使⽤SpringMVC配置的统⼀扫描装配也是可以的。

黑马程序员springmvc教程第二天：拦截器(1)

拦截器拦截定义定义拦截器，实现HandlerInterceptor接口。

接口中提供三个方法。

publicclass HandlerInterceptor1implements HandlerInterceptor { //进入 Handler方法之前执行//用于身份认证、身份授权//比如身份认证，如果认证通过表示当前用户没有登陆，需要此方法拦截不再向下执行@Overridepublicboolean preHandle(HttpServletRequest request,HttpServletResponse response, Object handler) throws Exception {//return false表示拦截，不向下执行//return true表示放行returnfalse;}//进入Handler方法之后，返回modelAndView之前执行//应用场景从modelAndView出发：将公用的模型数据(比如菜单导航)在这里传到视图，也可以在这里统一指定视图@Overridepublicvoid postHandle(HttpServletRequest request,HttpServletResponse response, Object handler,ModelAndView modelAndView) throws Exception { }//执行Handler完成执行此方法//应用场景：统一异常处理，统一日志处理@Overridepublicvoid afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)throws Exception {}}拦截器配置针对HandlerMapping配置springmvc拦截器针对HandlerMapping进行拦截设置，如果在某个HandlerMapping中配置拦截，经过该 HandlerMapping映射成功的handler最终使用该拦截器。

拦截器基本功能介绍

拦截器基本功能介绍拦截器基本功能介绍
1、什么是拦截器？
是springmvc中的⼀种对象，实现HandlerInterceptor接⼝的类都叫拦截器。

2、作⽤：
拦截⽤户的请求，对请求做预先的判断处理⼯作
3、
拦截器是全局的，可以对多个Controller做拦截。

⼀个项⽬可以有0个或者多个拦截器，⼀起拦截⽤户的请求。

拦截器常⽤在：⽤户登录处理、权限检查、记录⽇志。

拦截器的使⽤步骤：
1、定义类实现HandlerInterceptor接⼝。

2、在springmvc配置⽂件中声明拦截器，让框架知道拦截器的存在。

拦截器的执⾏时间：
1、在请求处理之前，也就是controller类中的⽅法执⾏之前先被拦截。

2、在控制器⽅法执⾏之后也会执⾏拦截器。

3、在请求处理完成后也会执⾏拦截器。

过滤器、拦截器应用场景、区别和使用

过滤器、拦截器应⽤场景、区别和使⽤
应⽤场景
过滤器的应⽤：字符编码转换，敏感词过滤、登陆权限验证、资源访问权限等
拦截器的应⽤：AOP、需要有⼀些业务逻辑（需要注⼊Bean等）
区别
1. 过滤器配置再web.xml中、拦截器配置springmvc的配置⽂件中（即在DispatcherServlet的contextConfigLocation属性指定⽂件所在位
置，默认加载的是：/WEB-INF/servlet名称-servlet.xml(springmvc-servlet.xml)）
2. 过滤器基于函数回调、拦截器基于反射
3. 过滤器⼏乎对所有请求起作⽤，拦截器只对⽬标执⾏⽅法（action⽅法）起作⽤
4. 过滤器：对请求进⾏预处理、再交给Servlet处理并且⽣成响应，最后Filter再对服务器响应进⾏后处理
拦截器：可以再⽅法执⾏前调⽤（preHandle）、⽅法执⾏后（postHandle）、视图页⾯渲染后（afterCompletion）
执⾏流程
过滤器初始化-》（客户端请求过来）dofilter处理请求-》到达dispatchServlet，在⽬标⽅法执⾏前preHandle-》（放⾏，返回true）执⾏⽬标⽅法-》（正常返回，异常则不执⾏）postHandle-》（⽆论⽬标⽅法是否执⾏或者执⾏是否出现异常，都会执⾏）afterCompletion-》dofilter 处理响应-》客户端加载页⾯。

基于SpringMVC拦截器和注解实现controller中访问权限控制

基于SpringMVC拦截器和注解实现controller中访问权限控制SpringMVC的拦截器HandlerInterceptorAdapter对应提供了三个preHandle，postHandle，afterCompletion⽅法。

1. preHandle在业务处理器处理请求之前被调⽤；2. postHandle在业务处理器处理请求执⾏完成后,⽣成视图之前执⾏；3. afterCompletion在DispatcherServlet完全处理完请求后被调⽤,可⽤于清理资源等；所以要想实现⾃⼰的权限管理逻辑，需要继承HandlerInterceptorAdapter并重写其三个⽅法。

⼀、⾃定义拦截器配置⽅法1. 在sping的xml配置中可以⽤<mvc:interceptors>和<mvc:interceptor>来配置拦截器类（实现HandlerInterceptorAdapter）2. 在javaConfig中配置通过WebMvcConfiguration的实现类配置拦截器类（实现HandlerInterceptorAdapter）⼆、⽰例2.1、javaconfig中配置SpringMVC⽰例1、新建⼀个springboot项⽬auth-demo22、权限校验相关的注解package com.dxz.authdemo2.web.auth;import ng.annotation.ElementType;import ng.annotation.Retention;import ng.annotation.RetentionPolicy;import ng.annotation.Target;@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)public @interface Permission {/** 检查项枚举 */PermissionEnum[] permissionTypes() default {};/** 检查项关系 */RelationEnum relation() default RelationEnum.OR;}package com.dxz.authdemo2.web.auth;import java.io.PrintWriter;import ng.annotation.Annotation;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import javax.servlet.http.HttpSession;import org.springframework.beans.factory.annotation.Autowired;import ponent;import org.springframework.web.method.HandlerMethod;import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;/*** 权限检查拦截器*/@Componentpublic class PermissionCheckInterceptor extends HandlerInterceptorAdapter {/** 权限检查服务 */@Autowiredprivate PermissionCheckProcessor permissionCheckProcessor;@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {//Class<?> clazz = handler.getClass();Class<?> clazz = ((HandlerMethod)handler).getBeanType();System.out.println("PermissionCheckInterceptor.preHandle()" + clazz);for(Annotation a : clazz.getAnnotations()){System.out.println(a);}if (clazz.isAnnotationPresent(Permission.class)) {Permission permission = (Permission) clazz.getAnnotation(Permission.class);return permissionCheckProcessor.process(permission, request, response);}return true;}public boolean preHandle2(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { System.out.println("SecurityInterceptor:"+request.getContextPath()+","+request.getRequestURI()+","+request.getMethod()); HttpSession session = request.getSession();if (session.getAttribute("uid") == null) {System.out.println("AuthorizationException:未登录！"+request.getMethod());if("POST".equalsIgnoreCase(request.getMethod())){response.setContentType("text/html; charset=utf-8");PrintWriter out = response.getWriter();out.write("未登录！");out.flush();out.close();}else{response.sendRedirect(request.getContextPath()+"/login");}return false;} else {return true;}}}package com.dxz.authdemo2.web.auth;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import ponent;@Componentpublic class PermissionCheckProcessor {public boolean process(Permission permission, HttpServletRequest request, HttpServletResponse response) {PermissionEnum[] permissionTypes = permission.permissionTypes();try {String uid = request.getParameter("uid");if ("duanxz".equals(uid)) {System.out.println("认证成功");return true;} else {System.out.println("认证失败");return false;}} catch (Exception e) {return false;}}}package com.dxz.authdemo2.web.auth;public enum PermissionEnum {DEVELOPER_VALID, DEVELOPER_FREEZE;}package com.dxz.authdemo2.web.auth;public enum RelationEnum {OR, AND;}3、SpringMVC拦截器配置package com.dxz.authdemo2.web.auth;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.annotation.Configuration;import org.springframework.web.servlet.config.annotation.InterceptorRegistry;import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;@Configurationpublic class WebMvcConfiguration extends WebMvcConfigurerAdapter {@AutowiredPermissionCheckInterceptor permissionCheckInterceptor;@Overridepublic void addInterceptors(InterceptorRegistry registry) {// addPathPatterns ⽤于添加拦截规则// excludePathPatterns ⽤户排除拦截// 映射为 user 的控制器下的所有映射registry.addInterceptor(permissionCheckInterceptor).addPathPatterns("/admin/*").excludePathPatterns("/index", "/");super.addInterceptors(registry);}}4、测试controllerpackage com.dxz.authdemo2.web;import javax.servlet.http.HttpServletRequest;import org.springframework.stereotype.Controller;import org.springframework.ui.ModelMap;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import org.springframework.web.servlet.ModelAndView;import com.dxz.authdemo2.web.auth.Permission;import com.dxz.authdemo2.web.auth.PermissionEnum;@Controller@RequestMapping("/admin")@Permission(permissionTypes = { PermissionEnum.DEVELOPER_VALID })public class AppDetailController {@RequestMapping(value="/appDetail", method = RequestMethod.GET)public String doGet(ModelMap modelMap, HttpServletRequest httpServletRequest) { //1. 业务操作，此处省略System.out.println("appDetail.htm 处理中...");return "appDetail";}}package com.dxz.authdemo2.web;import javax.servlet.http.HttpServletRequest;import org.springframework.stereotype.Controller;import org.springframework.ui.ModelMap;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import com.dxz.authdemo2.web.auth.Permission;import com.dxz.authdemo2.web.auth.PermissionEnum;@Controller@RequestMapping("index")public class IndexController {@RequestMapping(method = RequestMethod.GET)public void doGet(ModelMap modelMap, HttpServletRequest httpServletRequest) {System.out.println("index");}}cotroller中的jsp⽂件appDetail.jsp<html><h1>appDetail</h1></html>启动类：package com.dxz.authdemo2;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.EnableAutoConfiguration;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.context.annotation.Bean;import org.springframework.web.servlet.ViewResolver;import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer; import org.springframework.web.servlet.config.annotation.EnableWebMvc;import org.springframework.web.servlet.view.InternalResourceViewResolver;@EnableWebMvc@EnableAutoConfiguration@SpringBootApplicationpublic class AuthDemo2Application {public static void main(String[] args) {SpringApplication.run(AuthDemo2Application.class, args);}// 配置JSP视图解析器@Beanpublic ViewResolver viewResolver() {InternalResourceViewResolver resolver = new InternalResourceViewResolver();resolver.setPrefix("/WEB-INF/views/");resolver.setSuffix(".jsp");return resolver;}}结果：访问：访问：2.2、xml中配置SpringMVC⽰例⾸先在springmvc.xml中加⼊⾃⼰定义的拦截器我的实现逻辑PermissionCheckInterceptor，如下：<mvc:interceptors><mvc:interceptor><mvc:mapping path="/" /><mvc:mapping path="/user/**" /><mvc:mapping path="/test/**" /><bean class="com.dxz.authdemo2.web.auth.PermissionCheckInterceptor"></bean></mvc:interceptor> </mvc:interceptors>。

详解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拦截器不拦截静态资源的三种处理方式方法

SpringMVC拦截器不拦截静态资源的三种处理⽅式⽅法SpringMVC提供<mvc:resources>来设置静态资源，但是增加该设置如果采⽤通配符的⽅式增加拦截器的话仍然会被拦截器拦截，可采⽤如下⽅案进⾏解决：⽅案⼀、拦截器中增加针对静态资源不进⾏过滤(涉及spring-mvc.xml)<mvc:resources location="/" mapping="/**/*.js"/><mvc:resources location="/" mapping="/**/*.css"/><mvc:resources location="/assets/" mapping="/assets/**/*"/><mvc:resources location="/images/" mapping="/images/*" cache-period="360000"/><mvc:interceptors><mvc:interceptor><mvc:mapping path="/**/*"/><mvc:exclude-mapping path="/**/fonts/*"/><mvc:exclude-mapping path="/**/*.css"/><mvc:exclude-mapping path="/**/*.js"/><mvc:exclude-mapping path="/**/*.png"/><mvc:exclude-mapping path="/**/*.gif"/><mvc:exclude-mapping path="/**/*.jpg"/><mvc:exclude-mapping path="/**/*.jpeg"/><mvc:exclude-mapping path="/**/*login*"/><mvc:exclude-mapping path="/**/*Login*"/><bean class="com.luwei.console.mg.interceptor.VisitInterceptor"></bean></mvc:interceptor></mvc:interceptors>⽅案⼆、使⽤默认的静态资源处理Servlet处理静态资源(涉及spring-mvc.xml, web.xml)在spring-mvc.xml中启⽤默认Servlet<mvc:default-servlet-handler/>在web.xml中增加对静态资源的处理<servlet-mapping><servlet-name>default</servlet-name><url-pattern>*.js</url-pattern><url-pattern>*.css</url-pattern><url-pattern>/assets/*"</url-pattern><url-pattern>/images/*</url-pattern></servlet-mapping>但是当前的设置必须在Spring的Dispatcher的前⾯⽅案三、修改Spring的全局拦截设置为*.do的拦截（涉及web.xml）<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:spring-mvc.xml</param-value></init-param><load-on-startup>1</load-on-startup><async-supported>true</async-supported></servlet><servlet-mapping><servlet-name>SpringMVC</servlet-name><url-pattern>*.do</url-pattern></servlet-mapping>这样设置，Spring就会只针对以'.do'结尾的请求进⾏处理，不再维护静态资源针对这三种⽅案的优劣分析：第⼀种⽅案配置⽐较臃肿，多个拦截器时增加⽂件⾏数，不推荐使⽤；第⼆种⽅案使⽤默认的Servlet进⾏资源⽂件的访问，Spring拦截所有请求，然后再将资源⽂件交由默认的Sevlet进⾏处理，性能上少有损耗；第三种⽅案Spring只是处理以'.do'结尾的访问，性能上更加⾼效，但是再访问路径上必须都以'.do'结尾，URL不太⽂雅；综上所述，推荐使⽤第⼆和第三中⽅案以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

过滤器，拦截器，aop区别与使用场景

过滤器，拦截器，aop区别与使⽤场景1. 什么是过滤器过滤器，顾名思义就是起到过滤筛选作⽤的⼀种事物，只不过相较于现实⽣活中的过滤器，这⾥的过滤器过滤的对象是客户端访问的web资源，也可以理解为⼀种预处理⼿段，对资源进⾏拦截后，将其中我们认为的杂质（⽤户⾃⼰定义的）过滤，符合条件的放⾏，不符合的则拦截下来。

1.1 过滤器常见使⽤场景统⼀设置编码过滤敏感字符登录校验URL级别的访问权限控制数据压缩1.2 springboot整合过滤器bean注⼊⽅式a) 编写Filterpublic class HeFilter implements Filter {@Overridepublic void init(FilterConfig filterConfig) throws ServletException {}@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {System.out.println("您已进⼊filter过滤器，您的请求正常，请继续遵规则...");chain.doFilter(request, response);}@Overridepublic void destroy() {}}b) 编写Filter配置类@Configurationpublic class ServletConfig {@Beanpublic FilterRegistrationBean heFilterRegistration() {FilterRegistrationBean registration = new FilterRegistrationBean(new HeFilter());registration.addUrlPatterns("/*");return registration;}}注解⽅式@Slf4j@Component// filterName就是当前类名称，还有⼀个urlPattens的参数，这个参数表⽰要过滤的URL上的后缀名，是多参数，可以⽤数组表⽰。

详解SpringBootAOP拦截器（Aspect注解方式）

详解SpringBootAOP拦截器（Aspect注解⽅式）常⽤⽤于实现拦截的有：Filter、HandlerInterceptor、MethodInterceptor第⼀种Filter属于Servlet提供的，后两者是spring提供的，HandlerInterceptor属于Spring MVC项⽬提供的，⽤来拦截请求，在MethodInterceptor之前执⾏。

实现⼀个HandlerInterceptor可以实现接⼝HandlerInterceptor，也可以继承HandlerInterceptorAdapter类，两种⽅法⼀样。

这个不在本⽂范围，具体使⽤之前已经写过SpringBoot的（SpringMVC的使⽤⼀样，区别只是配置）MethodInterceptor是AOP项⽬中的拦截器，它拦截的⽬标是⽅法，即使不是Controller中的⽅法。

实现MethodInterceptor拦截器⼤致也分为两种，⼀种是实现MethodInterceptor接⼝，另⼀种利⽤Aspect的注解或配置。

关于实现MethodInterceptor接⼝的这种⽅法，还需要在配置⽂件中做配置，在SpringMVC中使⽤还可以，在SpringBoot中使⽤起来似乎没有那么⽅便。

本⽂主要还是说Aspect注解⽅式，个⼈觉得这种⽅法才⽐较灵活，与配置与⼯程整个代码都没有耦合（你添加⼀个类，做⼏个注解就可以⽤了，⽆需在其他地⽅再做什么），更易应⽤。

⾸先为你的SpringBoot项⽬添加maven依赖，让其⽀持aop（其实就是⾃动引⼊aop需要的⼀些jar）在pom.xml中添加依赖：<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency>然后创建Aspect测试类：package com.shanhy.sboot.aop;import ng.JoinPoint;import ng.annotation.After;import ng.annotation.Aspect;import ng.annotation.Before;import org.springframework.core.annotation.Order;import ponent;@Aspect // FOR AOP@Order(-99) // 控制多个Aspect的执⾏顺序，越⼩越先执⾏@Componentpublic class TestAspect {@Before("@annotation(test)")// 拦截被TestAnnotation注解的⽅法；如果你需要拦截指定package指定规则名称的⽅法，可以使⽤表达式execution(...)，具体百度⼀下资料⼀⼤堆 public void beforeTest(JoinPoint point, TestAnnotation test) throws Throwable {System.out.println("beforeTest:" + ());}@After("@annotation(test)")public void afterTest(JoinPoint point, TestAnnotation test) {System.out.println("afterTest:" + ());}}这样就完成了，然后创建⼀个Controller验证⼀下：@RestController@RequestMapping("/test")public class TestController {@TestAnnotation(name="abc")@RequestMapping("/show")public String show() {return "OK";}@RequestMapping("/show2")public String show2() {return "OK2";}}此时我们访问show请求，就会被拦截，控制台会打印输出。

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>。

拦截器实现原理

拦截器实现原理拦截器是一种常见的程序设计模式，常用于Web开发中请求的拦截处理。

拦截器通过对请求的拦截，可以实现日志记录、安全验证、权限控制等功能，提高Web应用的安全性和可维护性。

本文将从定义、分类和实现原理三个方面介绍拦截器的相关知识。

一、定义拦截器是指在应用程序运行过程中，拦截某个操作并在该操作之前或之后进行处理的一种程序设计模式。

它可以拦截Web请求、方法调用等操作，并对其进行相应的处理。

二、分类根据拦截器的使用场景和功能，可以将其分为以下几种类型：1. Web拦截器Web拦截器是指用于拦截Web请求的拦截器，常用于对请求进行安全验证、权限控制、日志记录等功能。

常见的Web拦截器包括SpringMVC中的HandlerInterceptor、Struts2中的Interceptor等。

2. AOP拦截器AOP拦截器是指应用于AOP编程中的拦截器，用于拦截方法调用等操作，并进行相应的处理。

常见的AOP拦截器包括Spring框架中的MethodInterceptor、AspectJ中的Interceptor等。

3. 日志拦截器日志拦截器是指用于拦截某个操作并记录日志的拦截器。

常用于记录系统运行日志、用户操作日志等。

常见的日志拦截器包括Log4j、Logback等。

三、实现原理拦截器的实现原理主要涉及到反射和链式调用两个方面。

以下以Web拦截器为例，介绍其实现原理：1. 反射Web拦截器常常通过反射机制实现对请求的拦截。

具体实现方式如下：（1）定义一个拦截器接口，并实现doInterceptor方法。

该方法接受参数为HttpServletRequest和HttpServletResponse对象，用于对请求进行操作。

public interface HandlerInterceptor {boolean doInterceptor(HttpServletRequest request, HttpServletResponseresponse);}（2）在拦截器实现类中实现doInterceptor方法，并使用反射机制调用控制器中相应的方法。

Springmvc拦截器实现原理解析

Springmvc拦截器实现原理解析概述SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter,⽤于对处理器进⾏预处理和后处理。

开发者可以⾃⼰定义⼀些拦截器来实现特定的功能。

过滤器与拦截器的区别：拦截器是AOP思想的具体应⽤。

过滤器servlet规范中的⼀部分，任何java web⼯程都可以使⽤在url-pattern中配置了/*之后，可以对所有要访问的资源进⾏拦截拦截器拦截器是SpringMVC框架⾃⼰的，只有使⽤了SpringMVC框架的⼯程才能使⽤拦截器只会拦截访问的控制器⽅法，如果访问的是jsp/html/css/image/js是不会进⾏拦截的⾃定义拦截器那如何实现拦截器呢？想要⾃定义拦截器，必须实现 HandlerInterceptor 接⼝。

新建⼀个Moudule ，添加web⽀持配置web.xml 和 springmvc-servlet.xml ⽂件编写⼀个拦截器package com.xiaohua.interceptor;import org.springframework.web.servlet.HandlerInterceptor;import org.springframework.web.servlet.ModelAndView;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;public class MyInterceptor implements HandlerInterceptor {//在请求处理的⽅法之前执⾏//如果返回true执⾏下⼀个拦截器//如果返回false就不执⾏下⼀个拦截器public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {System.out.println("------------处理前------------");return true;}//在请求处理⽅法执⾏之后执⾏public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception { System.out.println("------------处理后------------");}//在dispatcherServlet处理后执⾏,做清理⼯作.public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {System.out.println("------------清理------------");}}在springmvc的配置⽂件中配置拦截器<mvc:interceptors><mvc:interceptor><mvc:mapping path="/**"/><bean class="com.xiaohua.interceptor.MyInterceptor"/></mvc:interceptor></mvc:interceptors>编写⼀个Controller，接收请求package com.xiaohua.controller;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;//测试拦截器的控制器@Controllerpublic class InterceptorController {@RequestMapping("/interceptor")@ResponseBodypublic String testFunction() {System.out.println("控制器中的⽅法执⾏了");return "hello";}}前端 index.jsp<a href="${pageContext.request.contextPath}/interceptor" rel="external nofollow" >拦截器测试</a>启动tomcat 测试⼀下！验证⽤户是否登陆（认证⽤户）实现思路有⼀个登陆页⾯，需要写⼀个controller访问页⾯。

springmvc-机制(拦截器、aop、异常)

◆Spring-mvc知识➢概念Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，Spring Web MVC 也是要简化我们日常Web开发的。

图1 Spring Web MVC核心架构图理解这张图之前我们得先知道以下的几个名词：前端控制器（DispatcherServlet）、请求到处理器映射（HandlerMapping）、处理器适配器（HandlerAdapter）、视图解析器（ViewResolver）、处理器或页面控制器（Controller）、验证器（Validator）、命令对象（Command 请求参数绑定到的对象就叫命令对象）、表单对象（Form Object 提供给表单展示和提交到的对象就叫表单对象）步骤解析：核心架构的具体流程步骤如下：1、首先用户发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；2、DispatcherServlet——>HandlerMapping，HandlerMapping将会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器（页面控制器）对象、多个HandlerInterceptor拦截器）对象，通过这种策略模式，很容易添加新的映射策略；3、DispatcherServlet——>HandlerAdapter，HandlerAdapter将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；4、HandlerAdapter——>处理器功能处理方法的调用，HandlerAdapter将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个ModelAndView 对象（包含模型数据、逻辑视图名）；5、ModelAndView的逻辑视图名——> ViewResolver，ViewResolver将把逻辑视图名解析为具体的View，通过这种策略模式，很容易更换其他视图技术；6、View——>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model 实际是一个Map数据结构，因此很容易支持其他视图技术；7、返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。

springmvc拦截器（定义、配置以及执行流程）

springmvc拦截器（定义、配置以及执⾏流程）⼀、拦截器概念springmvc中的拦截器（interceptor）类似于Servlet中的过滤器（Filter），它主要⽤于拦截⽤户请求并做相应的处理。

在实际项⽬中会经常使⽤到拦截器，例如在购物⽹站中通过拦截器可以拦截未登录的⽤户，禁⽌其购买商品，或者使⽤它来验证已登录⽤户是否有相应的操作权限（即权限验证），记录请求信息的⽇志等应⽤。

所谓拦截器，就是能够在进⾏某个操作之前拦截请求，如果请求符合条件就允许在往下执⾏。

⽐如说，海关就是⼀个拦截器，他拦截进出⼝的货物，如果货物满⾜进出⼝条件，则放⾏，否则就拦截，退回处理。

⼆、拦截器定义和配置使⽤在springmvc中要使⽤拦截器，就需要对拦截器类进⾏定义和配置，通常拦截器类可以通过两种⽅式来定义。

第⼀种通过实现HandleInterceptor接⼝，或者继承HandleInterceptor接⼝的实现类HandleInterceptorAdapter来定义；第⼆种通过实现WebRequestInterceptor接⼝，或继承WebRequestInterceptor接⼝的实现类来定义。

1、拦截器的定义：以实现HandleInterceptor接⼝为例public class LoginInterceptor implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {//做⼀些操作⽅法返回类型为布尔值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 {//做⼀些操作}}从以上可以看出，⾃定义的拦截器类实现了HandlerInterceptor接⼝，并且实现了接⼝中的三个⽅法。

SpringMVC通过拦截器处理sql注入、跨站XSS攻击风险

SpringMVC通过拦截器处理sql注⼊、跨站XSS攻击风险sql注⼊就是通过url或者post提交数据时候，字符串类型的参数会被别⼈利⽤传⼊sql语句，最终破坏数据库或者达到⼀些见不得⼈的⽬的。

有时候因为业务需要url中会带⼀些参数，⽐如 ?type=xxx ⼀些⼈就会把type写成sql语句⽐如:?type=’ or 1=1– 最终拼接成的sql语句就变成了：select * from table where disabled=0 and type=” or 1=1 – and id=1 如此⼀来 – 后⾯的条件就会被屏蔽，结果就成了 1=1 也就是查询这张表所有数据。

这还算是最温柔的，更有甚者，把输⼊的参数变成update delete drop 不就⿇烦⼤了。

跨站攻击和链接注⼊差不多，会有⼀些java、html的代码注⼊进来。

⼀样的处理。

下⾯说⼀下最简单、直接、有效的⽅式吧：直接写⼀个spring的拦截器来处理⼀下，sql注⼊的就直接拦截不给访问了，因为⼀些乱七⼋糟的参数也是⽆法正常继续访问的，其他注⼊清理⼀下就⾏了：package org.jeecgframework.core.interceptors;import java.util.Enumeration;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.springframework.web.servlet.HandlerInterceptor;import org.springframework.web.servlet.ModelAndView;public class SqlInjectInterceptor implements HandlerInterceptor{@Overridepublic void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3)throws Exception {// TODO Auto-generated method stub}@Overridepublic void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3)throws Exception {// TODO Auto-generated method stub}@Overridepublic boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {Enumeration<String> names = arg0.getParameterNames();while(names.hasMoreElements()){String name = names.nextElement();String[] values = arg0.getParameterValues(name);for(String value: values){//sql注⼊直接拦截if(judgeSQLInject(value.toLowerCase())){arg1.setContentType("text/html;charset=UTF-8");arg1.getWriter().print("参数含有⾮法攻击字符,已禁⽌继续访问！");return false;}//跨站xss清理clearXss(value);}}return true;}/*** 判断参数是否含有攻击串* @param value* @return*/public boolean judgeSQLInject(String value){if(value == null || "".equals(value)){return false;}String xssStr = "and|or|select|update|delete|drop|truncate|%20|=|-|--|;|'|%|#|+|,|//|/| |\\|!=|(|)";String[] xssArr = xssStr.split("\\|");for(int i=0;i<xssArr.length;i++){if(value.indexOf(xssArr[i])>-1){return true;}}return false;}/*** 处理跨站xss字符转义** @param value* @return*/private String clearXss(String value) {if (value == null || "".equals(value)) {return value;}value = value.replaceAll("<", "<").replaceAll(">", ">");value = value.replaceAll("\$", "(").replace("\$", ")");value = value.replaceAll("'", "'");value = value.replaceAll("eval\$(.*)\$", "");value = value.replaceAll("[\\\"\\\'][\\s]*javascript:(.*)[\\\"\\\']","\"\"");value = value.replace("script", "");return value;}}然后spring-mvc.xml配置中加⼊拦截器：<mvc:interceptor><mvc:mapping path="/**" /><bean class="org.jeecgframework.core.interceptors.SqlInjectInterceptor" /> </mvc:interceptor>⾄此，测试⼀波，基本解决问题。

handlerinterceptor 获取请求参数工具类

handlerinterceptor 获取请求参数工具类一、概述在进行Web开发中，我们经常需要获取请求参数进行业务逻辑处理。

而在使用Spring MVC框架时，可以通过编写HandlerInterceptor获取请求参数，并进行相应的处理。

本文将介绍如何编写一个用于获取请求参数的HandlerInterceptor工具类，并详细讨论其使用方法和注意事项。

二、HandlerInterceptor简介2.1 HandlerInterceptor的作用HandlerInterceptor是Spring MVC框架提供的一个拦截器接口，用于在请求处理过程中进行拦截和处理。

它可以对请求进行预处理和后处理，并且能够获取请求参数等信息。

2.2 HandlerInterceptor接口方法HandlerInterceptor接口包含以下三个方法： 1. preHandle：在请求处理之前进行调用，返回值决定是否继续处理请求 2. postHandle：在请求处理之后, 视图渲染之前进行调用 3. afterCompletion：在整个请求处理完毕后进行调用，可以进行一些资源清理工作三、编写HandlerInterceptor获取请求参数的工具类3.1 创建Interceptor类首先，我们需要创建一个继承HandlerInterceptor接口的自定义Interceptor类，用于实现拦截器的具体逻辑。

public class ParamInterceptor implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {// 在preHandle方法中获取请求参数并进行处理String param1 = request.getParameter("param1");String param2 = request.getParameter("param2");// 对请求参数进行处理// ...return true; // 返回true表示继续处理请求，返回false表示中断请求}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse res ponse, Object handler, ModelAndView modelAndView) throws Exception {// 在postHandle方法中进行后处理// ...}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {// 在afterCompletion方法中进行一些清理工作// ...}}3.2 配置拦截器在Spring MVC的配置文件中，需要将自定义的Interceptor类配置为一个拦截器，并指定拦截的URL地址。