简单理解Struts2中拦截器与过滤器的区别及执行顺序
struts2
1．strust2框架来历简介：WebWork是由OpenSymphony组织开发的,致力于组件化和代码重用的J2EE Web框架。
(同时也是一个成熟的基于Web的MVC框架)MVC：Model View Controller，model是模型，view是视图，controller是控制器，是一种框架模式。
随着WebWork框架的发展,衍生出了strust2框架,因此strust2框架是WebWork的升级,而不是一个全新的框架,因此稳点性、性能等方面都有很好的保证,而且也同时吸收了struts1框架和WebWork俩者的优点.所以strust2框架也是一个基于Web的MVC框架注意:strust2框架并不是struts1框架的延续或者升级,俩者有着很大的不同2．web项目中的三层架构(和MVC是俩个完全不同的架构)1.表示层(Struts2框架就是工作在这个地方)2.业务逻辑层(service层，处理业务逻辑,比如判断用户名是否存在、密码是否正确、权限是否拥有、账号是否被冻结、账号是否异常、用户积分是否到达操作要求等等，多为一些执行某一个操作条件的判断)3.数据访问层(dao层，专门处理和数据库进行交换的事情，jdbc/hibernate就在这里使用)在项目中,这些不同的分层的表现形式,其实就是在我们自己建的不同的package 中写上各自分层中所使用的java类.比如在项目中我们建了三个package，三个package中java类的作用分别为表示层的代码、业务逻辑层代码、数据访问层代码。
注意：可以理解为，MVC架构是这里说描述的三层架构的一部分，即：三层架构中的表示层可以使用mvc架构的框架来实现，例如使用struts2框架.3．使用struts2框架的好处(为什么要使用struts2框架)减少编程人员代码的编写,使代码更加简洁明了,缩短开发时间,增加开发效率.4．struts2框架引入到web项目中首先使用Eclipse/MyEclipse中建一个web项目.1.把struts2相关jar包引入到项目中。
02-Struts2的工作流程及配置文件
Struts2的工作流程及配置文件--- ---Struts2.0的流程图从图中看到Struts2的工作流程如下：1.服务器接收到的请求首先经过一组过滤器链（实际中的其他过滤器可能还包括诸如Spring 的字符过滤器CharactorEncodingFilter、V elocity的过滤器等，一般FilterDispatcher位于过滤器的最后一个执行），过滤器链按照你在web.xml中的配置顺序在接收客户请求时顺序执行，在向客户发送响应时反序执行，Struts2的核心FilterDispatcher在web.xml中的配置如下：<filter><filter-name>setCharactor</filter-name><!-- 配置字符过滤--><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param></filter><filter><filter-name>struts2</filter-name><!-- 配置Struts2过滤器--><filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class> </filter><filter-mapping><filter-name>setCharactor</filter-name><url-pattern>/*</url-pattern></filter-mapping><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping>注意：如果你使用的是W ebLogic6.1作为应用服务器，需要使用FilterDispatcherCompatW eblogic61替代FilterDispatcher。
拦截器和过滤器的区别以及AOP概念
过滤器，是在java web中，你传入的request,response提前过滤掉一些信息，或者提前设置一些参数，然后再传入servlet或者struts的 action进行业务逻辑，比如过滤掉非法url（不是login.do的地址请求，如果用户没有登陆都过滤掉）,或者在传入servlet或者 struts的action前统一设置字符集，或者去除掉一些非法字符拦截器，是在面向切面编程的就是在你的service或者一个方法，前调用一个方法，或者在方法后调用一个方法比如动态代理就是拦截器的简单实现，在你调用方法前打印出字符串（或者做其它业务逻辑的操作），也可以在你调用方法后打印出字符串，甚至在你抛出异常的时候做业务逻辑的操作。
拦截器与过滤器的区别：1. 拦截器是基于java的反射机制的，而过滤器是基于函数回调。
2. 拦截器不依赖与servlet容器，过滤器依赖与servlet容器。
3. 拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。
4. 拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。
5. 在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次执行顺序：过滤前 - 拦截前 - Action处理 - 拦截后 - 过滤后。
个人认为过滤是一个横向的过程，首先把客户端提交的内容进行过滤(例如未登录用户不能访问内部页面的处理)；过滤通过后，拦截器将检查用户提交数据的验证，做一些前期的数据处理，接着把处理后的数据发给对应的Action；Action处理完成返回后，拦截器还可以做其他过程(还没想到要做啥)，再向上返回到过滤器的后续操作。
面向切面编程（AOP是Aspect Oriented Program的首字母缩写），我们知道，面向对象的特点是继承、多态和封装。
而封装就要求将功能分散到不同的对象中去，这在软件设计中往往称为职责分配。
实际上也就是说，让不同的类设计不同的方法。
struts2核心工作流程与原理
struts2核心工作流程与原理做为一名技术人员，听到太多关于.net和java的比较的话题。
我想对那些技术人员说，请先了解一下什么是java（或者.net）吧，其实你根本不了解。
这是Struts2官方站点提供的Struts 2 的整体结构。
一个请求在Struts2框架中的处理大概分为以下几个步骤1.客户端提起一个（HttpServletRequest）请求,如上文在浏览器中输入”http://localhost:8080/TestMvc/add.action”就是提起一个（HttpServletRequest）请求。
2.请求被提交到一系列（主要是三层）的过滤器（Filter），如（ActionContextCleanUp、其他过滤器（SiteMesh等）、 FilterDispatcher）。
注意这里是有顺序的，先ActionContextCleanUp，再其他过滤器（SiteMesh等）、最后到 FilterDispatcher。
3.FilterDispatcher是控制器的核心，就是mvc中c控制层的核心。
下面粗略的分析下我理解的FilterDispatcher工作流程和原理：FilterDispatcher进行初始化并启用核心doFilter其代码如下：public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain ) throws IOException, ServletException {HttpServletRequest request = (HttpServletRequest) req;HttpServletResponse response = (HttpServletResponse) res;ServletContext servletContext = filterConfig.getServletContext();// 在这里处理了HttpServletRequest和HttpServletResponse。
Struts2知识点总结
Struts2基础知识Struts2概述1.Struts2框架应用javaee三层结构中的web层框架。
2.Struts2框架在struts1和webwork基础之上发展的全新框架。
3.Struts2所解决的问题：在以往实现一个功能时，都需要写很多的servlet，从而造成后期维护上的不方便。
图解：4.现在比较稳定的Struts2版本struts-2.3.24-all.zip5.web层常见框架1.struts2.springMVCStruts2框架入门1.导入jar包1.在lib里面有jar包，但不能全部导入，因为里面含有一些spring包，是不能使用的，导入会导致程序不能运行。
2.到app目录里面复制案例的jar包是最好的方法。
2.创建action3.配置action类的访问路径1.创建struts2核心配置文件，该核心配置文件位置和名称是固定的，位置必须在src下面，名称为struts.xml 。
2.引入dtd约束，可以在案例文件中找到，复制在struts.xml文件中即可。
3.action的配置*注意访问路径：http://域名/端口号/项目名/action名.action注意：.action可以省略，但建议不要省略，为了兼容一些老版本的浏览器。
4.配置Struts2的过滤器，可以在案例中的web.xml文件中找到，复制粘贴即可。
Struts2执行过程图解：Struts2配置1.是一种常量标签2.修改Struts2的默认常量值1.常用方式在struts.xml中进行配置。
2.其它两种方式1.在src下面创建struts.properties文件并修改。
2.在web.xml文件中进行修改。
3.Struts2最常用的常量struts.il8n.encoding=UTF-8,解决表单在通过post方式提交中文时，中文乱码的问题。
Struts2笔记(一)可使用全局页面。
1、配置方法：在package标签下配置2、注意：该标签只能在一个package标签中使用，如果有多个标签，需要重新定义。
spring中过滤器（filter）、拦截器（interceptor）和切面（aop）的执行顺序
spring中过滤器（filter）、拦截器（interceptor）和切面（aop）的执行顺序转自：https:///huxiaodong1994/article/details/829918281. 程序执行的顺序是先进过滤器，再进拦截器，最后进切面。
注意：如果拦截器中preHandle方法返回的为false时，则无法进入切面，例子如下。
@RestController @RequestMapping('/user') public class UserController { @GetMapping('/{id:\\d }') @JsonView(erDetailView.class) public User getInfo(@PathVariable String id) { User user = new User(); user.setUsername('tom'); return user; } }编写方法的过滤器：@Componentpublic class TimeFilter implements Filter {/* (non-Javadoc)* @see javax.servlet.Filter#init(javax.servlet.FilterConfig)*/@Overridepublic void init(FilterConfig filterConfig) throws ServletException {System.out.println('time filter init');}/* (non-Javadoc)* @see javax.servlet.Filter#doFilter(javax.servlet.ServletRequest, javax.servlet.ServletResponse, javax.servlet.FilterChain) */@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {System.out.println('time filter start');long start = new Date().getTime();chain.doFilter(request, response);System.out.println('time filter:' (new Date().getTime() - start));System.out.println('time filter finish');}/* (non-Javadoc)* @see javax.servlet.Filter#destroy()*/@Overridepublic void destroy() {System.out.println('time filter destroy');}}编写方法的拦截器：@Component public class TimeInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponseresponse, Object handler) throws Exception { System.out.println('preHandle'); System.out.println(((HandlerMethod)handler).getBean().getClass ().getName());System.out.println(((HandlerMethod)handler).getMethod().getN ame()); request.setAttribute('startTime', new Date().getTime()); return true; } @Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { System.out.println('postHandle'); Long start = (Long)request.getAttribute('startTime'); System.out.println('time interceptor 耗时:' (new Date().getTime() - start)); } @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { System.out.println('afterCompletion'); Long start = (Long) request.getAttribute('startTime'); System.out.println('time interceptor 耗时:' (new Date().getTime() - start)); System.out.println('ex is ' ex); } }编写方法的切面：@Aspect@Componentpublic class TimeAspect {@Before('execution(public * erController.*(..))')public Object handlerControllerMethod() throws Throwable {System.out.println('time aspect start');return new Object();}}运行结果：1、当拦截器中preHandle的方法返回为true时：` time filter start preHandle erController$$EnhancerBySpringCGLIB $$b0bb0dcf getInfo time aspect start postHandle time interceptor 耗时:76 afterCompletion time interceptor 耗时:76 ex is null time filter:92 time filter finish time filter start time filter:46 time filter finish2、当拦截器中preHandle的方法返回为false时：time filter startpreHandleerController$$EnhancerBySpringC GLIB$$b0bb0dcfgetInfotime filter:12time filter finishtime filter starttime filter:23time filter finish2. 当程序有异常抛出时，回先进入切面，然后在进入自定义的ControllerAdvice中。
struts2常见面试题
struts2常见面试题Introduction:Struts2是一种用于开发Java Web应用程序的开源Web应用框架。
在软件工程领域，Struts2常常是面试中的热门话题。
本文将介绍一些常见的Struts2面试题，并提供详细解答和示例。
Question 1: 什么是Struts2框架？它的主要特点是什么？Struts2是一个基于MVC设计模式的Web应用框架。
它通过集成多个核心组件（如拦截器、过滤器、表单验证等）提供了一套丰富的功能，用于简化开发和管理Java Web应用程序。
Struts2的主要特点包括：1. 松耦合：Struts2使用基于配置的方式来管理组件之间的依赖关系，降低了模块之间的耦合。
2. 灵活性：开发人员可以根据自己的需求进行扩展和定制，以适应不同的项目需求。
3. 可测试性：Struts2的组件松耦合特点使得单元测试变得容易，并且可以方便地模拟用户请求进行测试。
Question 2: Struts2的核心组件有哪些？Struts2的核心组件包括：1. Action：处理用户请求的核心组件，负责接收请求并执行相应的业务逻辑。
2. Interceptor：用于对请求进行预处理和后处理的拦截器组件。
3. Result：负责生成响应结果，可以是页面视图或其他格式的数据（如JSON、XML等）。
4. FilterDispatcher：负责将请求分发给合适的Action处理。
5. ValueStack：用于存储Action处理的结果数据，支持OGNL表达式以便于数据的访问和操作。
Question 3: 如何定义一个Struts2的Action？在Struts2中，可以通过以下几种方式来定义一个Action：1. 实现Action接口：通过实现Action接口，并提供相应的业务方法来处理请求。
2. 继承ActionSupport类：ActionSupport是一个提供了一些方便方法的抽象类，可以直接继承并实现自己的业务逻辑。
struts2流程以及源码解析
1.1 Struts2请求处理1. 一个请求在Struts2框架中的处理步骤：a) 客户端初始化一个指向Servlet容器的请求；b) 根据Web.xml配置，请求首先经过ActionContextCleanUp过滤器，其为可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助（SiteMesh Plugin），主要清理当前线程的ActionContext和Dispatcher；c) 请求经过插件过滤器，如：SiteMesh、etc等过滤器；d) 请求经过核心过滤器FilterDispatcher，执行doFilter方法，在该方法中，询问ActionMapper来决定这个请求是否需要调用某个Action；e) 如果ActionMapper决定需要调用某个Action，则ActionMapper会返回一个ActionMapping实例（存储Action的配置信息），并创建ActionProxy （Action代理）对象，将请求交给代理对象继续处理；f) ActionProxy对象根据ActionMapping和Configuration Manager询问框架的配置文件，找到需要调用的Action类；g) ActionProxy对象创建时，会同时创建一个ActionInvocation的实例；h) ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用；i) 一旦Action执行完毕，ActionInvocation实例负责根据struts.xml中的配置创建并返回Result。
Result通常是一个需要被表示的JSP或者FreeMarker 的模版，也可能是另外的一个Action链；j) 如果要在返回Result之前做些什么，可以实现PreResultListener接口，PreResultListener可以在Interceptor中实现，也可以在Action中实现；k) 根据Result对象信息，生成用户响应信息response，在生成响应过程中可以使用Struts2 框架中继承的标签，在此过程中仍会再次涉及到ActionMapper；2. Struts2请求处理示意图：1.2 Struts2请求处理源码分析当用户向Struts2发送请求时，FilterDispatcher的doFilter()方法自动调用，doFilter()方法处理请求过程，如下：1. 创建值栈对象stack；2. 创建Action上下文对象；3. 对请求进行重新封装，此次封装根据请求内容的类型不同，返回不同的对象：如果为multipart/form-data类型，则返回MultiPartRequestWrapper类型的对象，该对象服务于文件上传，否则返回StrutsRequestWrapper类型的对象，MultiPartRequestWrapper是StrutsRequestWrapper的子类，而这两个类都是HttpServletRequest接口的实现。
Struts2的拦截器配置
拦截器实例
public class SimpleInterceptor extends AbstractInterceptor { private String name; public void setName(String name) { = name; } public String intercept(ActionInvocation invocation) throws Exception { LoginAction action = (LoginAction)invocation.getAction(); ......... String result = invocation.invoke(); ...... return result; } }
Struts 专题篇
第九章 Struts 2 的拦截器 主讲：陈宝峰
内容描述
● ● ● ● ● ●
拦截器概述 拦截器配置 使用拦截器的配置 使用默认拦截器的配置 拦截器实例 方法过滤
拦截器概述
● ●
拦截器是 Struts 2 中的重要组成部分 大量的内建拦截器完成了大部分的 Struts2 框架的工作
结束
使用默认拦截器的配置
<package name=” 包名” > <interceptors> <interceptor name=” 拦截器名 1” class=”......” /> ...... <interceptor-stack name=” 拦截器栈名 1”> <interceptor-ref name=” 拦截器名 1” /> ...... </interceptor-stack> </interceptors> <default-interceptor-ref name=” 拦截器名或拦截器栈名” /> <action ...... /> </package>
Struts2知识点详解
Struts 2的基本流程Struts 2框架由3个部分组成：核心控制器FilterDispatcher、业务控制器和用户实现的业务逻辑组件。
在这3个部分里，Struts 2框架提供了核心控制器FilterDispatcher，而用户需要实现业务控制器和业务逻辑组件。
2.核心控制器：FilterDispatcherFilterDispatcher是Struts 2框架的核心控制器，该控制器作为一个Filter运行在Web应用中，它负责拦截所有的用户请求，当用户请求到达时，该Filter会过滤用户请求。
如果用户请求以action结尾，该请求将被转入Struts 2框架处理。
Struts 2框架获得了*.action请求后，将根据*.action请求的前面部分决定调用哪个业务逻辑组件，例如，对于login.action请求，Struts 2调用名为login的Action来处理该请求。
Struts 2应用中的Action都被定义在struts.xml文件中，在该文件中定义Action时，定义了该Action的name属性和class属性，其中name属性决定了该Action处理哪个用户请求，而class属性决定了该Action的实现类。
Struts 2用于处理用户请求的Action实例，并不是用户实现的业务控制器，而是Action代理——因为用户实现的业务控制器并没有与Servlet API耦合，显然无法处理用户请求。
而Struts 2框架提供了系列拦截器，该系列拦截器负责将HttpServletRequest请求中的请求参数解析出来，传入到Action中，并回调Action 的execute方法来处理用户请求。
显然，上面的处理过程是典型的AOP（面向切面编程）处理方式。
图3.19显示了这种处理模型。
图3.19 Struts 2的拦截器和Action从图3.19中可以看出，用户实现的Action类仅仅是Struts 2的Action代理的代理目标。
Interceptor的基本介绍和使用
Interceptor的基本介绍和使⽤简介java⾥的拦截器是动态拦截Action调⽤的对象，它提供了⼀种机制可以使开发者在⼀个Action执⾏的前后执⾏⼀段代码，也可以在⼀个Action执⾏前阻⽌其执⾏，同时也提供了⼀种可以提取Action中可重⽤部分代码的⽅式。
在AOP中，拦截器⽤于在某个⽅法或者字段被访问之前，进⾏拦截然后再之前或者之后加⼊某些操作。
⽬前，我们需要掌握的主要是Spring的拦截器，Struts2的拦截器不⽤深究，知道即可。
原理⼤部分时候，拦截器⽅法都是通过代理的⽅式来调⽤的。
Struts2的拦截器实现相对简单。
当请求到达Struts2的ServletDispatcher时，Struts2会查找配置⽂件，并根据配置实例化相对的拦截器对象，然后串成⼀个列表（List），最后⼀个⼀个的调⽤列表中的拦截器。
Struts2的拦截器是可插拔的，拦截器是AOP的⼀个实现。
Struts2拦截器栈就是将拦截器按⼀定的顺序连接成⼀条链。
在访问被拦截的⽅法或者字段时，Struts2拦截器链中的拦截器就会按照之前定义的顺序进⾏调⽤。
⾃定义拦截器的步骤第⼀步：⾃定义⼀个实现了Interceptor接⼝的类，或者继承抽象类AbstractInterceptor。
第⼆步：在配置⽂件中注册定义的拦截器。
第三步：在需要使⽤Action中引⽤上述定义的拦截器，为了⽅便也可以将拦截器定义为默认的拦截器，这样在不加特殊说明的情况下，所有的Action都被这个拦截器拦截。
Spring拦截器5.1，抽象类HandlerInterceptorAdapter我们如果在项⽬中使⽤了Spring框架，那么，我们可以直接继承HandlerInterceptorAdapter.java这个抽象类，来实现我们⾃⼰的拦截器。
框架，对java的拦截器概念进⾏了包装，这⼀点和Struts2很类似。
HandlerInterceptorAdapter继承了抽象接⼝HandlerInterceptor。
开源框架之struts2笔记归纳
Struts部分： (1)1)为什么要学习Struts框架 (2)2)为什么使用MVC？ (2)3)MVC在JavaWeb中的实现 (2)*4) Struts2的主要工作流程 (2)3.Struts2框架的历史 (4)*4.Struts2框架基本使用 (4)1.Struts2使用基本规则 (5)Struts2标签+OGNL表达式 (6)2）OGNL工作原理 (6)4.OGNL在Struts2中的应用 (8)1）xwork对ognl进行扩展和改造 (8)*2）ValueStack对象(参考valuestack.jpg) (9)*3）在JSP中访问ValueStack数据方法 (9)a.使用Struts标签+OGNL表达式 (9)b.使用EL表达式 (9)1.Struts2框架Action组件的核心应用 (10)1）Action组件基本原理 (10)*3）Action属性注入 (11)*4）如何利用一个Action处理多个请求 (11)1.前期课程回顾 (11)1.Result组件原理 (12)1）Result组件的作用 (12)2）Result组件实现规则 (12)*2.常用的几种Result组件 (13)2）Action响应 (13)1.Struts2标签 (14)1）通用标签 (14)2）表单标签 (15)2.拦截器组件 (15)*2）掌握自定义拦截器的使用 (16)Struts部分：======================Day01=========================1)为什么要学习Struts框架Struts框架是MVC设计模式的实现，基于Struts开发可以简化开发难度，提高开发效率。
2)为什么使用MVC？MVC是一个非常优秀的设计思想，基于该思想架构程序，可以提高程序的结构灵活性，便于日后维护、扩展和升级。
3)MVC在JavaWeb中的实现Servlet,JSP,Filter,JDBCa.原ShoppingCart程序就是一个MVC结构实现View实现部分：采用JSP组件实现Model实现部分：采用DAO、Entity等组件实现Controller实现部分：采用ActionServlet组件实现b.ShoppingCart程序虽然基于MVC，但结构还有一些问题：当请求数量比较多时，需要在Servlet中编写大量的if...else分支语句，而且Servlet代码量非常多。
struts2面试题(自己总结)
Struts2面试题1、struts2工作流程Struts 2框架本身大致可以分为3个部分：核心控制器FilterDispatcher、业务控制器Action和用户实现的企业业务逻辑组件。
核心控制器FilterDispatcher是Struts 2框架的基础，包含了框架内部的控制流程和处理机制。
业务控制器Action和业务逻辑组件是需要用户来自己实现的。
用户在开发Action和业务逻辑组件的同时，还需要编写相关的配置文件，供核心控制器FilterDispatcher来使用。
Struts 2的工作流程相对于Struts 1要简单，与WebWork框架基本相同，所以说Struts 2是WebWork的升级版本。
基本简要流程如下：1 、客户端初始化一个指向Servlet容器的请求；2、这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）3 、接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action4、如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy5、ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类6、ActionProxy创建一个ActionInvocation的实例。
7、ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。
8、一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。
java开发框架面试题整理
Java开发框架面试Struts2热点面试题？1. 简述Struts2 的工作流程:①. 请求发送给StrutsPrepareAndExecuteFilter②. StrutsPrepareAndExecuteFilter 判定该请求是否是一个Struts2 请求③. 若该请求是一个Struts2 请求，则StrutsPrepareAndExecuteFilter 把请求的处理交给ActionProxy④. ActionProxy 创建一个ActionInvocation 的实例，并进行初始化⑤. ActionInvocation 实例在调用Action 的过程前后，涉及到相关拦截器（Intercepter）的调用。
⑥. Action 执行完毕，ActionInvocation 负责根据struts.xml 中的配置找到对应的返回结果。
调用结果的execute 方法，渲染结果。
⑦. 执行各个拦截器invocation.invoke() 之后的代码⑧. 把结果发送到客户端2. Struts2 拦截器和过滤器的区别：①、过滤器依赖于Servlet容器，而拦截器不依赖于Servlet容器。
②、Struts2 拦截器只能对Action 请求起作用，而过滤器则可以对几乎所有请求起作用。
③、拦截器可以访问Action 上下文(ActionContext)、值栈里的对象(ValueStack)，而过滤器不能.④、在Action 的生命周期中，拦截器可以多次调用，而过滤器只能在容器初始化时被调用一次。
3. 为什么要使用Struts2 & Struts2 的优点：①. 基于MVC 架构，框架结构清晰。
②. 使用OGNL: OGNL 可以快捷的访问值栈中的数据、调用值栈中对象的方法③. 拦截器: Struts2 的拦截器是一个Action 级别的AOP, Struts2 中的许多特性都是通过拦截器来实现的, 例如异常处理，文件上传，验证等。
SpringBoot使用过滤器和拦截器分别实现REST接口简易安全认证示例代码详解
SpringBoot使⽤过滤器和拦截器分别实现REST接⼝简易安全认证⽰例代码详解本⽂通过⼀个简易安全认证⽰例的开发实践，理解过滤器和拦截器的⼯作原理。
很多⽂章都将过滤器（Filter）、拦截器（Interceptor）和监听器（Listener）这三者和Spring关联起来讲解，并认为过滤器（Filter）、拦截器（Interceptor）和监听器（Listener）是Spring提供的应⽤⼴泛的组件功能。
但是严格来说，过滤器和监听器属于Servlet范畴的API，和Spring没什么关系。
因为过滤器继承⾃javax.servlet.Filter接⼝，监听器继承⾃javax.servlet.ServletContextListener接⼝，只有拦截器继承的是org.springframework.web.servlet.HandlerInterceptor接⼝。
上⾯的流程图参考⾃⽹上资料，⼀图胜千⾔。
看完本⽂以后，将对过滤器和拦截器的调⽤过程会有更深刻理解。
⼀、安全认证设计思路有时候内外⽹调⽤API，对安全性的要求不⼀样，很多情况下外⽹调⽤API的种种限制在内⽹根本没有必要，但是⽹关部署的时候，可能因为成本和复杂度等问题，内外⽹要调⽤的API会部署在⼀起。
实现REST接⼝的安全性，可以通过成熟框架如Spring Security或者 shiro 搞定。
但是因为安全框架往往实现复杂（我数了下Spring Security，洋洋洒洒⼤概有11个核⼼模块，shiro的源码代码量也⽐较惊⼈）同时可能要引⼊复杂配置（能不能让⼈痛快⼀点），不利于中⼩团队的灵活快速开发、部署及问题排查。
很多团队⾃⼰造轮⼦实现安全认证，本⽂这个简易认证⽰例参考⾃我所在的前⼚开发团队，可以认为是个基于token的安全认证服务。
⼤致设计思路如下：1、⾃定义http请求头，每次调⽤API都在请求头⾥传⼈⼀个token值2、token放在缓存（如redis）中，根据业务和API的不同设置不同策略的过期时间3、token可以设置⽩名单和⿊名单，可以限制API调⽤频率，便于开发和测试，便于紧急处理异状，甚⾄临时关闭API4、外⽹调⽤必须传⼈token，token可以和⽤户有关系，⽐如每次打开页⾯或者登录⽣成token写⼊请求头，页⾯验证cookie和token有效性等在Spring Security框架⾥有两个概念，即认证和授权，认证指可以访问系统的⽤户，⽽授权则是⽤户可以访问的资源。
Struts2-interceptor
Struts2拦截器一、什么是拦截器？1、拦截器，在AOP（Aspect-Oriented Programming<面向切面编程>）中用于在某个方法或字段被访问之前，进行拦截然后在之前或之后加入某些操作。
拦截是AOP的一种实现策略。
在Webwork的中文文档的解释为——拦截器是动态拦截Action调用的对象。
它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码，也可以在一个action执行前阻止其执行。
同时也是提供了一种可以提取action 中可重用的部分的方式。
2、拦截器链（Interceptor Chain，在Struts 2中称为拦截器栈Interceptor Stack）。
拦截器链就是将拦截器按一定的顺序联结成一条链。
在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。
3、如何使用struts2拦截器，或者自定义拦截器。
特别注意，在使用拦截器的时候，在Action里面必须最后一定要引用struts2自带的拦截器缺省堆栈defaultStack,如下(这里我是引用了struts2自带的checkbox拦截器)：<interceptor-ref name="checkbox"><param name="uncheckedValue">0</param></interceptor-ref><interceptor-ref name="defaultStack"/>(必须加，否则出错)4、也可以改为对全局Action设置自己需要的拦截器，如下：在struts.xml里面定义全局的配置设置<package name="struts-shop" extends="struts-default"><interceptors><interceptor-stack name="myStack"><interceptor-ref name="checkbox"><param name="uncheckedValue">0</param></interceptor-ref><interceptor-ref name="defaultStack"/></interceptor-stack></interceptors><default-interceptor-ref name="myStack"/>（这句是设置所有Action自动调用的拦截器堆栈）</package>struts-action.xml里面配置Action如下：<package name="LogonAdmin" extends="struts-shop">（这里扩展struts.xml里面定义的配置就可以了）<action name="logon" class="logonAction"><result>/jsp/smeishop/admin/index.jsp</result> <resul t name="error">/jsp/smeishop/admin/logon.jsp</result><result name="input">/jsp/smeishop/admin/logon.jsp</result> </action><action name="logout" class="logoutAction"><result>/jsp/smeishop/admin/logon.jsp</result></action></package>二、Struts2自带的配置及其拦截器配置1、Struts2 拦截器 [Interceptor]拦截器的工作原理如上图，每一个Action请求都包装在一系列的拦截器的内部。
拦截器的执行顺序
您使用的浏览器不受支ቤተ መጻሕፍቲ ባይዱ建议使用新版浏览器
拦截器的执行顺序
1.在请求到来的时候，拦截器会拦截，执行preHandle方法。如果该方法的返回值为true， 就继续往下执行，否则，就结束执行，往下就不在执行任何方法。 该方法在目标方法执行之前执行。 可以考虑做权限、日志或者事务。 2.在preHandle的返回值为true的情况下，就继续执行请求的jsp页面或者controller。 3.执行完请求后，执行postHandle方法。 该方法在目标方法执行之后执行，但在渲染视图之前执行， 可以对请求域中的属性或视图做出修改。 4.最后执行afterComplete方法。 做一些资源清理的工作。
拦截器（Interceptor）与过滤器（Filter）
拦截器（Interceptor）与过滤器（Filter）⽬录⼀、⽤户的普通Http请求执⾏顺序⼆、过滤器、拦截器添加后的执⾏顺序三、拦截器（Interceptor）的基本定义 拦截器是⾯向切⾯（AOP）编程中应⽤的⼀种统⼀处理⽅案，就是在你的Controller、Servie或者⼀个Method调⽤⼀个Method，或者在Method调⽤⼀个Method之后，统⼀的进⾏处理的⽅案，基于Java的反射机制。
拦截器，在AOP（Aspect-Oriented Programming）中可以⽤于在某个⽅法或者字段被访问之前，进⾏拦截，然后在之前或者之后加⼊某些统⼀的处理⽅法。
拦截是AOP的⼀种具象的实现⽅式。
拦截器将很多service或者Controller中共有的⾏为提炼出来，在某些⽅法执⾏的前后执⾏，提炼为通⽤的处理⽅式，让被拦截的⽅法都能享受这⼀共有的功能，让代码更加简洁，同时，当共有的功能需要发⽣调整、变动的时候，不必修改很多的类或者⽅法，只要修改这个拦截器就可以了，可复⽤性很强。
Spring MVC 中的Interceptor拦截请求是通过HandlerInterceptor来实现的。
四、拦截器（Interceptor）必须实现的三个⽅法 1）总览 2）preHandle（HttpServletRequest request， HttpServletResponse response， Object handle）⽅法 该⽅法将在请求处理之前进⾏调⽤。
SpringMVC 中的Interceptor 是链式的调⽤的，在⼀个应⽤中或者说是在⼀个请求中可以同时存在多个Interceptor 。
每个Interceptor 的调⽤会依据它的声明顺序依次执⾏，⽽且最先执⾏的都是Interceptor 中的preHandle ⽅法，所以可以在这个⽅法中进⾏⼀些前置初始化操作或者是对当前请求的⼀个预处理，也可以在这个⽅法中进⾏⼀些判断来决定请求是否要继续进⾏下去。
Struts2默认拦截器解析
Struts2默认拦截器解析使用struts2，拦截器大家经常使用，当然默认情况我们除了自定义的拦截器外，会使用struts2默认的拦截器，那他究竟有哪些默认的拦截器？每个拦截器都是做什么的呢？我们来看下对应的源码，打开对应源码下的struts2-default.xml文件我们可以看到对应很多的拦截器信息，如下<interceptors><interceptor name="alias"class="com.opensymphony.xwork2.interceptor.AliasInterceptor"/><interceptor name="autowiring"class="com.opensymphony.xwork2.spring.interceptor.ActionAutowiringInt erceptor"/><interceptor name="chain"class="com.opensymphony.xwork2.interceptor.ChainingInterceptor"/> <interceptor name="conversionError"class="org.apache.struts2.interceptor.StrutsConversionErrorIntercepto r"/><interceptor name="cookie"class="org.apache.struts2.interceptor.CookieInterceptor"/><interceptor name="createSession"class="org.apache.struts2.interceptor.CreateSessionInterceptor"/> <interceptor name="debugging"class="org.apache.struts2.interceptor.debugging.DebuggingInterceptor" /><interceptor name="externalRef"class="com.opensymphony.xwork2.interceptor.ExternalReferencesInterceptor"/><interceptor name="execAndWait"class="org.apache.struts2.interceptor.ExecuteAndWaitInterceptor"/> <interceptor name="exception"class="com.opensymphony.xwork2.interceptor.ExceptionMappingIntercepto r"/><interceptor name="fileUpload"class="org.apache.struts2.interceptor.FileUploadInterceptor"/> <interceptor name="i18n"class="com.opensymphony.xwork2.interceptor.I18nInterceptor"/><interceptor name="logger"class="com.opensymphony.xwork2.interceptor.LoggingInterceptor"/> <interceptor name="modelDriven"class="com.opensymphony.xwork2.interceptor.ModelDrivenInterceptor"/> <interceptor name="scopedModelDriven"class="com.opensymphony.xwork2.interceptor.ScopedModelDrivenIntercept or"/><interceptor name="params"class="com.opensymphony.xwork2.interceptor.ParametersInterceptor"/> <interceptor name="prepare"class="com.opensymphony.xwork2.interceptor.PrepareInterceptor"/> <interceptor name="staticParams"class="com.opensymphony.xwork2.interceptor.StaticParametersIntercepto r"/><interceptor name="scope"class="org.apache.struts2.interceptor.ScopeInterceptor"/><interceptor name="servletConfig"class="org.apache.struts2.interceptor.ServletConfigInterceptor"/> <interceptor name="sessionAutowiring"class="org.apache.struts2.spring.interceptor.SessionContextAutowiring Interceptor"/><interceptor name="timer"class="com.opensymphony.xwork2.interceptor.TimerInterceptor"/> <interceptor name="token"class="org.apache.struts2.interceptor.TokenInterceptor"/><interceptor name="tokenSession"class="org.apache.struts2.interceptor.TokenSessionStoreInterceptor"/> <interceptor name="validation"class="org.apache.struts2.interceptor.validation.AnnotationValidation Interceptor"/><interceptor name="workflow"class="com.opensymphony.xwork2.interceptor.DefaultWorkflowInterceptor "/><interceptor name="store"class="org.apache.struts2.interceptor.MessageStoreInterceptor"/> <interceptor name="checkbox"class="org.apache.struts2.interceptor.CheckboxInterceptor"/><interceptor name="profiling"class="org.apache.struts2.interceptor.ProfilingActivationInterceptor" /><interceptor name="roles" class="org.apache.struts2.interceptor.RolesInterceptor"/> <!-- Deprecated name forms scheduled for removal in Struts 2.1.0. The camelCase versions are preferred. See ww-1707 --><interceptor name="external-ref"class="com.opensymphony.xwork2.interceptor.ExternalReferencesIntercep tor"/><interceptor name="model-driven"class="com.opensymphony.xwork2.interceptor.ModelDrivenInterceptor"/> <interceptor name="static-params"class="com.opensymphony.xwork2.interceptor.StaticParametersIntercepto r"/><interceptor name="scoped-model-driven"class="com.opensymphony.xwork2.interceptor.ScopedModelDrivenIntercept or"/><interceptor name="servlet-config"class="org.apache.struts2.interceptor.ServletConfigInterceptor"/> <interceptor name="token-session" class="org.apache.struts2.interceptor.TokenSessionStoreInterceptor"/><!-- Basic stack --><interceptor-stack name="basicStack"><interceptor-ref name="exception"/><interceptor-ref name="servletConfig"/><interceptor-ref name="prepare"/><interceptor-ref name="checkbox"/><interceptor-ref name="params"/><interceptor-ref name="conversionError"/></interceptor-stack><!-- Sample validation and workflow stack --><interceptor-stack name="validationWorkflowStack"><interceptor-ref name="basicStack"/><interceptor-ref name="validation"/><interceptor-ref name="workflow"/></interceptor-stack><!-- Sample file upload stack --><interceptor-stack name="fileUploadStack"><interceptor-ref name="fileUpload"/><interceptor-ref name="basicStack"/></interceptor-stack><!-- Sample model-driven stack --><interceptor-stack name="modelDrivenStack"><interceptor-ref name="modelDriven"/><interceptor-ref name="basicStack"/></interceptor-stack><!-- Sample action chaining stack --><interceptor-stack name="chainStack"><interceptor-ref name="chain"/><interceptor-ref name="basicStack"/></interceptor-stack><!-- Sample i18n stack --><interceptor-stack name="i18nStack"><interceptor-ref name="i18n"/><interceptor-ref name="basicStack"/></interceptor-stack><!-- An example of the params-prepare-params trick. This stack is exactly the same as the defaultStack, except that itincludes one extra interceptor before the prepare interceptor:the params interceptor.This is useful for when you wish to apply parameters directlyto an object that you wish to load externally (such as a DAOor database or service layer), but can't load that objectuntil at least the ID parameter has been loaded. By loadingthe parameters twice, you can retrieve the object in theprepare() method, allowing the second params interceptor toapply the values on the object. --><interceptor-stack name="paramsPrepareParamsStack"><interceptor-ref name="exception"/><interceptor-ref name="alias"/><interceptor-ref name="params"/><interceptor-ref name="servletConfig"/><interceptor-ref name="prepare"/><interceptor-ref name="i18n"/><interceptor-ref name="chain"/><interceptor-ref name="modelDriven"/><interceptor-ref name="fileUpload"/><interceptor-ref name="checkbox"/><interceptor-ref name="staticParams"/><interceptor-ref name="params"/><interceptor-ref name="conversionError"/><interceptor-ref name="validation"><paramname="excludeMethods">input,back,cancel</param></interceptor-ref><interceptor-ref name="workflow"><paramname="excludeMethods">input,back,cancel</param></interceptor-ref></interceptor-stack><!-- A complete stack with all the common interceptors in place.Generally, this stack should be the one you use, though itmay do more than you need. Also, the ordering can beswitched around (ex: if you wish to have yourservlet-relatedobjects applied before prepare() is called, you'd need to moveservlet-config interceptor up.This stack also excludes from the normal validation and workflowthe method names input, back, and cancel. These typically areassociated with requests that should not be validated.--><interceptor-stack name="defaultStack"><interceptor-ref name="exception"/><interceptor-ref name="alias"/><interceptor-ref name="servletConfig"/><interceptor-ref name="prepare"/><interceptor-ref name="i18n"/><interceptor-ref name="chain"/><interceptor-ref name="debugging"/><interceptor-ref name="profiling"/><interceptor-ref name="scopedModelDriven"/><interceptor-ref name="modelDriven"/><interceptor-ref name="fileUpload"/><interceptor-ref name="checkbox"/><interceptor-ref name="staticParams"/><interceptor-ref name="params"><param name="excludeParams">dojo\..*</param></interceptor-ref><interceptor-ref name="conversionError"/><interceptor-ref name="validation"><paramname="excludeMethods">input,back,cancel,browse</param></interceptor-ref><interceptor-ref name="workflow"><paramname="excludeMethods">input,back,cancel,browse</param></interceptor-ref></interceptor-stack><!-- The completeStack is here for backwards compatibility for applications that still refer to the defaultStack by theold name --><interceptor-stack name="completeStack"><interceptor-ref name="defaultStack"/></interceptor-stack><!-- Sample execute and wait stack.Note: execAndWait should always be the *last* interceptor. --><interceptor-stack name="executeAndWaitStack"><interceptor-ref name="execAndWait"><paramname="excludeMethods">input,back,cancel</param></interceptor-ref><interceptor-ref name="defaultStack"/><interceptor-ref name="execAndWait"><paramname="excludeMethods">input,back,cancel</param></interceptor-ref></interceptor-stack><default-interceptor-ref name="defaultStack"/>是配置对应的拦截器栈，下面我们来看对应的拦截器栈都有哪些？都是做什么的？如果不配置拦截器，默认使用他自己的defaultStack，我们看到，defaultStack包含了基本上所有的拦截器，所以基本上都能满足我们的需求，但是我们一般情况下用不了这么多拦截器栈的，经过这么多拦截器栈肯定会影响性能的，所以我们可以根据不通的场景，选择合适的拦截器栈。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
(5)findInputStream(String name, String packagePrefix)：搜索类路径下的静态资源。
Debugging Interceptor
debugging
提供不同的调试用的页面来展现内部的数据状况。
Execute and Wait Interceptor
execAndWait
在后台执行Action，同时将用户带到一个中间的等待页面。
Exception Interceptor
exception
(12)setMapper(ActionMapper actionMapper)
(13)setEncoding(String val)
(14)setServeStaticContent(String val)
(15)setServeStaticBrowserCache(String val)
附：
Struts2（XWork）提供的拦截器的功能说明：
需注意的是：他会暴露一些比较敏感的信息例如，properites文件中的数据库连接信息。
注：过滤器支持以下初始参数：
config -被调入的逗号隔开的XML文件列表。
actionPackages -被actions扫描的逗号隔开的packages列表。
configProviders -逗号分隔的实现了ConfigurationProvider接口(建造Configuration时被使用)的实现类。
(10)parse(String packages)：返回一个数组通过解析一个指定逗号分隔的packages列表。
(11)prepareDispatcherAndWrapRequest(HttpServletRequest request, HttpServletResponse response)：对给定的request对象进行封装返回一个封装HttpServletRequest对象。例如显示的处理multipart数据。
拦截器
名字
说明
Alias Interceptor
alias
在不同请求之间将请求参数在不同名字件转换，请求内容不变
Chaining Interceptor
chain
让前一个Action的属性可以被后一个Action访问，现在和chain类型的result（<result type=”chain”>）结合使用。
(8)getFilterConfig()：获取FilterConfig实例。
(9)getServletContext()：给WebLogic的一些版本提供一个工作区。
(9)init(FilterConfig filterCongfig)：创建默认的dispatcher对象和设置静态资源的默认包信息来初始化filter。
(2)createDispatcher(FilterConfig filterConfig)：创建默认的dispatcher对象，如果需要的话，子类可以重载此方法，自定义一个dispatcher对象。
(3)destory()：调用dispatcher.cleanup()，依次释放本地线程，销毁dispatcher对象。
1、拦截器是基于java反射机制的，而过滤器是基于函数回调的。
2、过滤器依赖于servlet容器，而拦截器不依赖于servlet容器。
3、拦截器只能对Action请求起作用，而过滤器则可以对几乎所有请求起作用。
4、拦截器可以访问Action上下文、值栈里的对象，而过滤器不能。
5、在Action的生命周期中，拦截器可以多次调用，而过滤器只能在容器初始化时被调用一次。
Servlet Config Interceptor
servletConfig
提供访问HttpServletRequest和HttpServletResponse的方法，以Map的方式访问。
Static Parameters Interceptor
staticParams
从struts.xml文件中将<action>中的<param>中的内容设置到对应的Action中。
f) Result类型可以是jsp或者freeMark等
g)这些组件和ActionMapper一起返回给请求的url（注意拦截器的执行顺序）
h)响应的返回是通过我们在web.xml中配置的过滤器
i)如果ActionContextCleanUp是当前使用的，则FilterDispatecher将不会清理sreadlocal ActionContext;如果ActionContextCleanUp不使用，则将会去清理sreadlocals。
1，Eclipse安装spket插件。（两种方式）：
(2)清除ActionContext
过滤器为了确保内存溢出，会自动的清除ActionContext。这可能会存在一些问题，在和其它的框架集成时，例如SiteMesh。ActionContextCleanUp提供了怎么处理这些问题的一些信息。
(3)维护静态内容
过滤器也会维护在Struts2中使用的一些公共的静态的内容，例如JavaScript文件，CSS文件等。搜索/struts/*范围内的请求，然后将/struts/后面的值映射到一些struts的公共包中，也可以在你的类路径中搜索。默认情况下会去查找以下包：org.apache.struts2.static.template。这样你只用请求/struts/xhtml/styles.css，XHTML UI主题默认的样式表将会被返回。同样，AJAX UI组件需要的JavaScript文件，也可以在org.apache.struts2.static包中被找到。如果你想加入其它被搜索的包，在web.xml中设置filter时，通过给"actionPackages"初始参数一个逗号隔开的包列表值来设定。
org.apache.struts2.dispatcher.FilterDispatcher的四个功能
org.apache.struts2.dispatcher.FilterDispatcher是Struts2的主要的Filter，负责四个方面的功能：
(1)执行Actions
(2)清除ActionContext
Model Driven Interceptor
model-driven
如果一个类实现了ModelDriven，将getModel得到的结果放在Value Stack中。
Scoped Model Driven
scoped-model-driven
如果一个Action实现了ScopedModelDriven，则这个拦截器会从相应的Scope中取出model调用Action的setModel方法将其放入Action内部。
将异常定位到一个画面
File Upload Interceptor
fileUpload
提供文件上传功能
I18n Interceptor
i18n
记录用户选择的locale
Logger Interceptor
logger
输出Action的名字
Message Store Interceptor
store
存储或者访问实现ValidationAware接口的Action类出现的消息，错误，字段错误等。
Roles Interceptor
roles
确定用户是否具有JAAS指定的Role，否则不予执行。
查看图片附件
10:41
评论/浏览(0 / 762)
分类:企业架构
2010-07-29
缩略显示
Eclipse支持jQuery自动提示
博客分类：
jQuery
感谢：/blog/458372
简单理解Struts2中拦截器与过滤器的区别及执行顺序
当接收到一个httprequest ,
a)当外部的httpservletrequest到来时
b)初始到了servlet容器传递给一个标准的过滤器链
c) FilterDispatecher会去查找相应的ActionMapper，如果找到了相应的ActionMapper它将会将控制权限交给ActionProxy
Parameters Interceptor
params
将请求中的参数设置到Action中去。
Prepare Interceptor
prepare
如果Acton实现了Preparable，则该拦截器调用Action类的prepare方法。
Scope Interceptor
scope
将Action状态存入session和application的简单方法。
(4)filterConfig：通过初始参数，提供一个FilterConfig实例。
(5)lastModifiedCal：在缓存静态content，提供一个格化的日期用于设定头信息。
(6)log：提供一个logging实例。
(7)patchPrefixs：存储静态资源的路径前缀信息。
(8)serveStatic：存储StrutsConstants.STRUTS_SERVE_STATIC_CONTENT的设置。
Conversion Error Interceptor
conversionError
将错误从ActionContext中添加到Action的属性字段中。
Create Session Interceptor
createSession
自动的创建HttpSession，用来为需要使用到HttpSession的拦截器服务。