struts2 拦截器介绍二

最新推荐文章于 2021-04-25 16:16:03 发布
最新推荐文章于 2021-04-25 16:16:03 发布
阅读量913 收藏 1
点赞数
分类专栏： 流行框架之Struts 文章标签： struts interceptor action timer login class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/coolwzjcool/article/details/5098673
版权

转自：http://zhaoshg.javaeye.com/blog/356511

 

 

 

看到网上很多介绍关于拦截器的文章，感觉都不错，但是都没有很详细全面的介绍，所以我就博众家之长，呵呵，写了篇关于struts拦截器的东西。


拦截器的工作原理如上图，在工作的时候每一个Action请求都被包装在一堆拦截器的内部。拦截器可以在Action执行直线做相似的操作也可以在Action执行直后做回收操作。

每一个Action既可以将操作转交给下面的拦截器，Action也可以直接退出操作返回客户既定的画面。

下面我们来讲讲如何使用struts2拦截器，或者是自定义拦截器。

先说说使用Struts自带的拦截器：
在Struts2中已经在struts-default.xml中预定义了一些自带的拦截器，如timer、params等。如果在<package>标签中继承struts-default，则当前package就会自动拥有struts-default.xml中的所有配置。代码如下：

<package name="demo" extends="struts-default" > ... </package>

在struts-default.xml中有一个默认的引用，在默认情况下（也就是<action>中未引用拦截器时）会自动引用一些拦截器。这个默认的拦截器引用如下：

Xml代码 复制代码
  1. <interceptor-stack name="defaultStack">  
  2.     <interceptor-ref name="exception"/>  
  3.     <interceptor-ref name="alias"/>  
  4.     <interceptor-ref name="servletConfig"/>  
  5.     <interceptor-ref name="prepare"/>  
  6.     <interceptor-ref name="i18n"/>  
  7.     <interceptor-ref name="chain"/>  
  8.     <interceptor-ref name="debugging"/>  
  9.     <interceptor-ref name="profiling"/>  
  10.     <interceptor-ref name="scopedModelDriven"/>  
  11.     <interceptor-ref name="modelDriven"/>  
  12.     <interceptor-ref name="fileUpload"/>  
  13.     <interceptor-ref name="checkbox"/>  
  14.     <interceptor-ref name="staticParams"/>  
  15.     <interceptor-ref name="params">  
  16.       <param name="excludeParams">dojo/..*</param>  
  17.     </interceptor-ref>  
  18.     <interceptor-ref name="conversionError"/>  
  19.     <interceptor-ref name="validation">  
  20.         <param name="excludeMethods">input,back,cancel,browse</param>  
  21.     </interceptor-ref>  
  22.     <interceptor-ref name="workflow">  
  23.         <param name="excludeMethods">input,back,cancel,browse</param>  
  24.     </interceptor-ref>  
  25. </interceptor-stack>  


上面在defaultStack中引用的拦截器都可以在<action>中不经过引用就可以使用（如果在<action>中引用了任何拦截器后，要使用在defaultStack中定义的拦截器，也需要在<action>中重新引用，在后面的“二、通过请求调用Action的setter方法(params)”将详细讲解）。
下面我们来看几个简单的拦截器的使用方法。

一、记录拦截器和execute方法的执行时间(timer拦截器)

timer是Struts2中最简单的拦截器，这个拦截器对应的类是com.opensymphony.xwork2.interceptor.TimerInterceptor。它的功能是记录execute方法和其他拦截器（在timer后面定义的拦截器）的intercept方法执行的时间总和。如下面的配置代码所示：

Xml代码 复制代码
  1. <action name="first" class="action.FirstAction">  
  2.     <interceptor-ref name="logger"/>  
  3.     <interceptor-ref name="timer" />  
  4. </action>  


由于在timer后面没有其他的拦截器定义，因此，timer只能记录execute方法的执行时间，在访问first动作时，会在控制台输出类似下面的一条信息：

信息: Executed action [/test/first!execute] took 16 ms.

在使用timer拦截器时，需要commons-logging.jar的支持。将logger引用放到timer的后面，就可以记录logger拦截器的intercept方法和Action的execute方法的执行时间总和，代码如下：

Xml代码 复制代码
  1. <action name="first" class="action.FirstAction">  
  2.     <interceptor-ref name="timer" />  
  3.     <interceptor-ref name="logger"/>  
  4. </action>  


大家可以使用如下的Action类来测试一下timer拦截器：

Java代码 复制代码
  1. package action;   
  2.   
  3. import com.opensymphony.xwork2.ActionSupport;   
  4.   
  5. public class FirstAction extends ActionSupport             
  6.   
  7. {   
  8.        public String execute() throws Exception   
  9.   
  10.        {   
  11.            Thread.sleep(2000); // 延迟2秒   
  12.            return null;   
  13.        }   
  14.   
  15. }  
package action;

import com.opensymphony.xwork2.ActionSupport;

public class FirstAction extends ActionSupport          

{
       public String execute() throws Exception

       {
           Thread.sleep(2000); // 延迟2秒
           return null;
       }

}


如果只记录execute方法的执行时间，一般会输出如下的信息：

信息: Executed action [/test/first!execute] took 2000 ms.

二、通过请求调用Action的setter方法(params)


    当客户端的一个form向服务端提交请求时，如有一个textfield，代码如下：

Jsp代码 复制代码
  1. <s:form action="first" namespace="/test">   
  2.    <s:textfield name="name"/>   
  3.    <s:submit/>   
  4. </s:form>  


在提交后，Struts2将会自动调用first动作类中的setName方法，并将name文本框中的值通过setName方法的参数传入。实际上，这个操作是由params拦截器完成的，params对应的类是com.opensymphony.xwork2.interceptor.ParametersInterceptor。由于params已经在defaultStack中定义，因此，在未引用拦截器的<action>中是会自动引用params的，如下面的配置代码，在访问first动作时，Struts2是会自动执行相应的setter方法的。

<action name="first" class="action.FirstAction">

    ... ...

</action>

但如果在<action>中引用了其他的拦截器，就必须再次引用params拦截器，Struts2才能调用相应的setter方法。如下面的配置代码所示：

Xml代码 复制代码
  1. <action name="first" class="action.FirstAction">  
  2.     <interceptor-ref name="timer" />  
  3.     <interceptor-ref name="params"/>  
  4. </action>  


三、通过配置参数调用Action的setter方法(static-params)

    static-params拦截器可以通过配置<params>标签来调用Action类的相应的setter方法，static-params拦截器对应的类是com.opensymphony.xwork2.interceptor.StaticParametersInterceptor。
    下面配置代码演示了如何使用static-params拦截器：

Xml代码 复制代码
  1. <action name="first" class="action.FirstAction">  
  2.     <interceptor-ref name="timer" />  
  3.     <param name="who">比尔</param>  
  4.     <interceptor-ref name="params"/>  
  5.     <interceptor-ref name="static-params"/>  
  6. </action>  


如果first动作使用上面的配置，在访问first动作时，Struts2会自动调用setWho方法将“比尔”作为参数值传入setWho方法。

四、使用拦截器栈

为了能在多个动作中方便地引用同一个或几个拦截器，可以使用拦截器栈将这些拦截器作为一个整体来引用。拦截器栈要在<package>标签中使用<interceptors>和子标签<interceptor-stack>来定义。代码如下：

Xml代码 复制代码
  1. <package name="demo" extends="struts-default" >  
  2.     <interceptors>  
  3.         <interceptor-stack name="mystack">  
  4.             <interceptor-ref name="timer" />  
  5.             <interceptor-ref name="logger" />  
  6.             <interceptor-ref name="params" />  
  7.             <interceptor-ref name="static-params" />  
  8.         </interceptor-stack>  
  9.     </interceptors>  
  10.   
  11.     <action name="first" class="action.FirstAction">  
  12.         <param name="who">比尔</param>  
  13.         <interceptor-ref name="mystack"/>               
  14.     </action>  
  15. </package>  


这样以来，我们就可以象使用拦截器一样使用拦截器栈。





如何自定义一个拦截器？
自定义一个拦截器，我们需要三步就可以完成了：
1 自定义一个实现Interceptor接口（或者继承自AbstractInterceptor）的类。
2 在strutx.xml中注册上一步中定义的拦截器。
3 在需要使用的Action中引用上述定义的拦截器，为了方便也可将拦截器定义为默认的拦截器，这样在不加特殊声明的情况下所有的Action都被这个拦截器拦截。

Interceptor接口声明了三个方法：

Java代码 复制代码
  1. public interface Interceptor extends Serializable {   
  2.     
  3.     void destroy();   
  4.     
  5.     void init();   
  6.     
  7.     String intercept(ActionInvocation invocation) throws Exception;   
  8. }  
public interface Interceptor extends Serializable {
 
    void destroy();
 
    void init();
 
    String intercept(ActionInvocation invocation) throws Exception;
}


Init方法在拦截器类被创建之后，在对Action镜像拦截之前调用，相当于一个post-constructor方法，使用这个方法可以给拦截器类做必要的初始话操作。

Destroy方法在拦截器被垃圾回收之前调用，用来回收init方法初始化的资源。

Intercept是拦截器的主要拦截方法，如果需要调用后续的Action或者拦截器，只需要在该方法中调用invocation.invoke()方法即可，在该方法调用的前后可以插入Action调用前后拦截器需要做的方法。如果不需要调用后续的方法，则返回一个String类型的对象即可，例如Action.SUCCESS。
另外AbstractInterceptor提供了一个简单的Interceptor的实现，这个实现为：

Java代码 复制代码
  1. public abstract class AbstractInterceptor implements Interceptor {   
  2.     
  3.      public void init() {   
  4.     }   
  5.       
  6.     public void destroy() {   
  7.     }   
  8.     
  9.     
  10.     public abstract String intercept(ActionInvocation invocation) throws Exception;   
  11. }  
public abstract class AbstractInterceptor implements Interceptor {
 
     public void init() {
    }
   
    public void destroy() {
    }
 
 
    public abstract String intercept(ActionInvocation invocation) throws Exception;
}


在不需要编写init和destroy方法的时候，只需要从AbstractInterceptor继承而来，实现intercept方法即可。

我们尝试编写一个Session过滤用的拦截器，该拦截器查看用户Session中是否存在特定的属性（LOGIN属性）如果不存在，中止后续操作定位到LOGIN，否则执行原定操作，代码为：

Java代码 复制代码
  1. public class CheckLoginInterceptor extends AbstractInterceptor {   
  2.     public static final String LOGIN_KEY = "LOGIN";   
  3.     public static final String LOGIN_PAGE = "global.login";   
  4.     
  5.     public String intercept(ActionInvocation actionInvocation) throws Exception {   
  6.     
  7.         System.out.println("begin check login interceptor!");   
  8.         // 对LoginAction不做该项拦截   
  9.         Object action = actionInvocation.getAction();   
  10.         if (action instanceof LoginAction) {   
  11.             System.out.println("exit check login, because this is login action.");   
  12.             return actionInvocation.invoke();   
  13.         }   
  14.     
  15.         // 确认Session中是否存在LOGIN   
  16.         Map session = actionInvocation.getInvocationContext().getSession();   
  17.         String login = (String) session.get(LOGIN_KEY);   
  18.         if (login != null && login.length() > 0) {   
  19.             // 存在的情况下进行后续操作。   
  20.             System.out.println("already login!");   
  21.             return actionInvocation.invoke();   
  22.         } else {   
  23.             // 否则终止后续操作，返回LOGIN   
  24.             System.out.println("no login, forward login page!");   
  25.             return LOGIN_PAGE;   
  26.         }   
  27.     }   
  28. }  
public class CheckLoginInterceptor extends AbstractInterceptor {
    public static final String LOGIN_KEY = "LOGIN";
    public static final String LOGIN_PAGE = "global.login";
 
    public String intercept(ActionInvocation actionInvocation) throws Exception {
 
        System.out.println("begin check login interceptor!");
        // 对LoginAction不做该项拦截
        Object action = actionInvocation.getAction();
        if (action instanceof LoginAction) {
            System.out.println("exit check login, because this is login action.");
            return actionInvocation.invoke();
        }
 
        // 确认Session中是否存在LOGIN
        Map session = actionInvocation.getInvocationContext().getSession();
        String login = (String) session.get(LOGIN_KEY);
        if (login != null && login.length() > 0) {
            // 存在的情况下进行后续操作。
            System.out.println("already login!");
            return actionInvocation.invoke();
        } else {
            // 否则终止后续操作，返回LOGIN
            System.out.println("no login, forward login page!");
            return LOGIN_PAGE;
        }
    }
}


注册拦截器

Xml代码 复制代码
  1. <interceptors>  
  2.             <interceptor  
  3. name="login"    
  4. class="com.jpleasure.teamware.util.CheckLoginInterceptor"/>  
  5.             <interceptor-stack name="teamwareStack">  
  6.                 <interceptor-ref name="login"/>  
  7.                 <interceptor-ref name="defaultStack"/>  
  8.             </interceptor-stack>  
  9. </interceptors>  


将上述拦截器设定为默认拦截器：

Java代码 复制代码
  1. <default-interceptor-ref name="teamwareStack"/>  
<default-interceptor-ref name="teamwareStack"/>


这样在后续同一个package内部的所有Action执行之前都会被login拦截。

注册并引用Interceptor

Xml代码 复制代码
  1. <package name="default" extends="struts-default">  
  2.    <interceptors>  
  3.        <interceptor name="timer" class=".."/>  
  4.        <interceptor name="logger" class=".."/>  
  5.    </interceptors>  
  6.     
  7.    <action name="login" class="tutorial.Login">  
  8.         <interceptor-ref name="timer"/>  
  9.         <interceptor-ref name="logger"/>  
  10.         <result name="input">login.jsp</result>  
  11.         <result name="success"  
  12.             type="redirect-action">/secure/home</result>  
  13.    </action>  
  14. </package>  
  15.    


可以将多个拦截器合并在一起作为一个堆栈调用，当一个拦截器堆栈被附加到一个Action的时候，要想Action执行，必须执行拦截器堆栈中的每一个拦截器。

Xml代码 复制代码
  1. <package name="default" extends="struts-default">  
  2.    <interceptors>  
  3.         <interceptor name="timer" class=".."/>  
  4.         <interceptor name="logger" class=".."/>  
  5.         <interceptor-stack name="myStack">  
  6.            <interceptor-ref name="timer"/>  
  7.            <interceptor-ref name="logger"/>  
  8.         </interceptor-stack>  
  9.     </interceptors>  
  10.     
  11.     <action name="login" class="tutuorial.Login">  
  12.          <interceptor-ref name="myStack"/>  
  13.          <result name="input">login.jsp</result>  
  14.          <result name="success"  
  15.              type="redirect-action">/secure/home</result>  
  16.     </action>  
  17. </package>  




每一个拦截器都可以配置参数，有两种方式配置参数，一是针对每一个拦截器定义参数，二是针对一个拦截器堆栈统一定义所有的参数，例如：

Xml代码 复制代码
  1. <interceptor-ref name="validation">  
  2.   <param name="excludeMethods">myValidationExcudeMethod</param>  
  3. </interceptor-ref>  
  4. <interceptor-ref name="workflow">  
  5.   <param name="excludeMethods">myWorkflowExcludeMethod</param>  
  6. </interceptor-ref>  


或者

Xml代码 复制代码
  1. <interceptor-ref name="defaultStack">  
  2.     <param name="validation.excludeMethods">myValidationExcludeMethod</param>  
  3.     <param name="workflow.excludeMethods">myWorkflowExcludeMethod</param>  
  4. </interceptor-ref>  


每一个拦截器都有两个默认的参数：
excludeMethods - 过滤掉不使用拦截器的方法和
includeMethods – 使用拦截器的方法。

需要说明的几点：
1 拦截器执行的顺序按照定义的顺序执行，例如：

Xml代码 复制代码
  1. <interceptor-stack name="xaStack">  
  2.   <interceptor-ref name="thisWillRunFirstInterceptor"/>  
  3.   <interceptor-ref name="thisWillRunNextInterceptor"/>  
  4.   <interceptor-ref name="followedByThisInterceptor"/>  
  5.   <interceptor-ref name="thisWillRunLastInterceptor"/>  
  6. </interceptor-stack>  


的执行顺序为：

Xml代码 复制代码
  1. thisWillRunFirstInterceptor   
  2.   thisWillRunNextInterceptor   
  3.     followedByThisInterceptor   
  4.       thisWillRunLastInterceptor   
  5.         MyAction1   
  6.         MyAction2 (chain)   
  7.         MyPreResultListener   
  8.         MyResult (result)   
  9.       thisWillRunLastInterceptor   
  10.     followedByThisInterceptor   
  11.   thisWillRunNextInterceptor   
  12. thisWillRunFirstInterceptor  


2 使用默认拦截器配置每个Action都需要的拦截器堆栈，例如：

Xml代码 复制代码
  1. <action name="login"  class="tutorial.Login">  
  2.      <interceptor-ref name="timer"/>  
  3.      <interceptor-ref name="logger"/>  
  4.      <interceptor-ref name="default-stack"/>  
  5.     
  6.      <result name="input">login.jsp</result>  
  7.      <result type="redirect-action">/secure/home</result>  
  8. </action>  


可以按照如下的方式定义：

Xml代码 复制代码
  1. <interceptors>  
  2.      <interceptor-stack name="myStack">  
  3.         <interceptor-ref name="timer"/>  
  4.         <interceptor-ref name="logger"/>  
  5.         <interceptor-ref name="default-stack"/>  
  6.      </interceptor-stack>  
  7. </interceptors>  
  8.     
  9. <default-interceptor-ref name="myStack"/>  
  10.     
  11. <action name="login"  class="tutorial.Login">  
  12.        <result name="input">login.jsp</result>  
  13.        <result type="redirect-action">/secure/home</result>  
  14. </action>  


3 如何访问HttpServletRequest，HttpServletResponse或者HttpSession
有两种方法可以达到效果，使用ActionContext：

Java代码 复制代码
  1. Map attibutes = ActionContext.getContext().getSession();  
Map attibutes = ActionContext.getContext().getSession();


或者实现相应的接口：

Java代码 复制代码
  1. HttpSession            SessionAware   
  2. HttpServletRequest     ServletRequestAware   
  3. HttpServletResponse    ServletResponseAware  
HttpSession            SessionAware
HttpServletRequest     ServletRequestAware
HttpServletResponse    ServletResponseAware



Struts2（XWork）提供的拦截器的功能说明：

  • 拦截器                名字                       说明
  • Alias Interceptor——alias——在不同请求之间将请求参数在不同名字件转换，请求内容不变
  • Chaining Interceptor——chain——让前一个Action的属性可以被后一个Action访问，现在和chain类型的result（<result type=”chain”>）结合使用。
  • Checkbox Interceptor——checkbox——添加了checkbox自动处理代码，将没有选中的checkbox的内容设定为false，而html默认情况下不提交没有选中的checkbox。
  • Cookies Interceptor—— Cookies—— 使用配置的name,value来是指cookies
  • Conversion Error Interceptor—— conversionError—— 将错误从ActionContext中添加到Action的属性字段中。
  • Create Session Interceptor—— createSession—— 自动的创建HttpSession，用来为需要使用到HttpSession的拦截器服务。
  • Debugging Interceptor—— Debugging—— 提供不同的调试用的页面来展现内部的数据状况。
  • Execute and Wait Interceptor—— execAndWait—— 在后台执行Action，同时将用户带到一个中间的等待页面。
  • Exception Interceptor—— exception—— 将异常定位到一个画面
  • File Upload Interceptor—— fileUpload—— 提供文件上传功能
  • I18n Interceptor—— i18n—— 记录用户选择的locale
  • Logger Interceptor—— logger—— 输出Action的名字
  • Message Store Interceptor—— store—— 存储或者访问实现ValidationAware接口的Action类出现的消息，错误，字段错误等。
  • Model Driven Interceptor—— model-driven—— 如果一个类实现了ModelDriven，将getModel得到的结果放在Value Stack中。
  • Scoped Model Driven—— scoped-model-driven—— 如果一个Action实现了ScopedModelDriven，则这个拦截器会从相应的Scope中取出model调用Action的setModel方法将其放入Action内部。
  • Parameters Interceptor—— params—— 将请求中的参数设置到Action中去。
  • Prepare Interceptor—— Prepare—— 如果Acton实现了Preparable，则该拦截器调用Action类的prepare方法。
  • Scope Interceptor—— Scope—— 将Action状态存入session和application的简单方法。
  • Servlet Config Interceptor—— servletConfig—— 提供访问HttpServletRequest和HttpServletResponse的方法，以Map的方式访问。
  • Static Parameters Interceptor—— staticParams—— 从struts.xml文件中将<action>中的<param>中的内容设置到对应的Action中。
  • Roles Interceptor—— roles—— 确定用户是否具有JAAS指定的Role，否则不予执行。
  • Timer Interceptor—— timer—— 输出Action执行的时间
  • Token Interceptor—— token—— 通过Token来避免双击
  • Token Session Interceptor—— tokenSession—— 和Token Interceptor一样，不过双击的时候把请求的数据存储在Session中
  • Validation Interceptor—— validation—— 使用action-validation.xml文件中定义的内容校验提交的数据。
  • Workflow Interceptor—— workflow—— 调用Action的validate方法，一旦有错误返回，重新定位到INPUT画面
  • Parameter Filter Interceptor—— N/A—— 从参数列表中删除不必要的参数
  • Profiling Interceptor—— profiling—— 通过参数激活profile
coolwzjcool
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于struts2的自定义拦截器和struts2的详细流程
CSU：有道无术，术可求，有术无道，止于术！
08-19 879
1.其实我们大家平常都会用struts2用的很多，但是有的时候我们并不是真正的了解struts2的运行机制，下面给大家分享一下struts2的运行流程。MVC框架 解释如下：           1.  所有请求被Struts2核心控制器StrutsPreparaedAndExecuteFilter拦截 2.根据ActionMapper提供的信息决定如何进行下一步 3.Action
教你如何使用Struts2拦截器并且定义自己的拦截器
ds590的专栏
03-28 109
看到网上很多介绍关于拦截器的文章，感觉都不错，但是都没有很详细全面的介绍，所以我就博众家之长，呵呵，写了篇关于struts拦截器的东西。 [img]http://zhaoshg.iteye.com/upload/picture/pic/34221/a38f9a47-ec81-3434-a9eb-a476a27cc555.jpg[/img] 拦截器的工作原理如上图，在工作的时候每一个Acti...
struts2拦截器的使用
ice_fire2008的专栏
01-27 548
 Struts2拦截器的使用      如何使用struts2拦截器，或者自定义拦截器。特别注意，在使用拦截器的时候，在Action里面必须最后一定要引用struts2自带的拦截器缺省堆栈defaultStack,如下(这里我是引用了struts2自带的checkbox拦截器)：  0(必须加，否则出错)也可以改为对全局Action设置自己需要的拦截器，如下：在struts.xml里面
Struts2学习笔记（四）之——struts.xml配置文拦截器
weixin_39941298的博客
08-24 817
struts.xml &lt;?xml version="1.0" encoding="UTF-8" ?&gt; &lt;!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2....
初学Struts2-自定义拦截器及其配置
aa8102980的博客
08-03 103
自定义拦截器，首先新建一个继承自AbstractInterceptor类的类，然后重写intercept方法，代码如下 public class HelloInterceptor extends AbstractInterceptor { @Override public String intercept(ActionInvocation invocatio...
Struts2 struts.xml配置自定义拦截器
a1346238的博客
05-03 225
<!-- 声明拦截器 --> <interceptors> <interceptor name="time" class="com.lwq.interceptor.TimeIntercepter"></interceptor> <interceptor name="demo1" c...
详解Struts2拦截器机制
08-30
主要介绍了详解Struts2拦截器机制，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Struts2学习案例(拦截器)
08-17
自己写的struts2小案例，DAO是用JPA开发，包含Action，mysq等，mvc模式
Struts2拦截器实例.docx
07-12
Struts2拦截器实例——登录校验，登录校验拦截器除了登录请求不被拦截，对用户的所有其他请求进行拦截。对没有登录的用户如果访问其他需要用户的页面进行页面跳转，从新跳转回登录页面。进行登录操作。
struts2 拦截器interceptor教程 示例源码
01-25
struts2 拦截器_教程.zip
struts2自定义拦截器的示例代码
08-29
本篇文章主要介绍了struts2自定义拦截器的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Struts2学习笔记(十一)：自定义拦截器，及其执行流程
秋忆夏伤的博客
08-21 233
HelloInterceptor.java： package com.struts.interceptor; import com.opensymphony.xwork2.ActionInvocation; import com.opensymphony.xwork2.interceptor.Interceptor; /** * 拦截器：普通的 java 类只要实现了 intercept...
Struts2的拦截器，Struts2的执行流程，图解+详解（底层代码）以及 自定义拦截器（配置和使用）
程序员猫爪
06-26 805
一、拦截器的概述 1、什么是拦截器 Interceptor:拦截器，起到的是拦截Action的作用 Filter：过滤器，从客户端向服务器发送的请求。 Interceptor:拦截器，拦截的是客户端对Action的访问。更加细粒度化的拦截。（拦截Action当中具体的方法）。 Struts2框架核心的功能是依赖拦截器实现的。 2、Struts2的执行流程 官方Struts2执行流程图 官方图的原码详解 客户端向服务器发送一个Action的请求，执行核心过滤器（doFilter）方法。 在这个方法当中，调用
使用struts2拦截器，对session失效的校验
etjnety的专栏
08-14 6765
如何使用struts2拦截器，或者自定义拦截器。特别注意，在使用拦截器的时候，在Action里面必须最后一定要引用struts2自带的拦截器缺省堆栈defaultStack,如下(这里我是引用了struts2自带的checkbox拦截器)：   0 (必须加，否则出错) 也可以改为对全局Action设置自己需要的拦截器，如下： 在struts.xml里面定义全局的配置设置
Struts2 过滤器实现只允许POST请求
zhinengshiyanshi的博客
01-09 6187
通过过滤器禁止get请求，写了一个小demo，希望对有需要的朋友有帮助。 首先是jsp文件，就是一个简单的提交的对话框，代码如下： 第二步配置了一下struts.xml，由于不需要返回界面，直接打印到页面上了 第三步就是 Test.java文件 public void encode(){ out.print(
Java框架学习之Struts2(拦截器,校验,文件上传下载,标签使用)
weixin_41588751的博客
04-08 320
1
Struts2中的拦截器使用方法
随遇而安
10-30 1727
Struts2中的拦截器使用方法拦截器的介绍什么是拦截器？拦截器的生命周期如何新建一个自定义的拦截器？自定义的拦截器如何配置在struts.xml框架主配置文件里呢？ 拦截器的介绍 什么是拦截器？ 当一个请求到服务端首先在MVC模式下会执行到Action来响应一个请求，而拦截器是在Action之前被调用的一个对象（Class）。拦截器就是一个类 拦截器的生命周期 Created with Raph...
Struts2之拦截器
Atkx's Blog
04-25 2160
目录标题
struts2中的拦截器
xx510long的博客
11-12 138
一、概述strust2中的拦截器        拦截器是Struts2框架的核心，它主要完成解析请求参数、将请求参数赋值给Action属性、执行数据校验、文件上传等工作。Struts2设计的灵巧性，拦截器起了关键性的作用，当需要扩展Struts2功能时，只需要提供对应拦截器，并将它配置在Struts2容器中即可；如果不需要该功能时，也只需要取消该拦截器的配置即可。         Strut...
struts2权限拦截器
最新发布
05-31
在 Struts2 中，可以使用拦截器来实现权限控制。具体来说，可以编写一个自定义的拦截器，然后在 struts.xml 配置文件中将其配置为需要进行权限控制的 Action 的拦截器。以下是一个简单的权限拦截器示例： ```java ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值