精华内容
下载资源
问答
  • Struts2拦截器

    千次阅读 2018-08-02 11:27:15
    1. Struts2拦截器是在访问某个Action或Action的某个方法,字段之前或之后实施拦截,并且Struts2拦截器是可插拔的,拦截器是AOP的一种实现. 2. 拦截器栈(Interceptor Stack)。Struts2拦截器栈就是将拦截器按...

    一、拦截器简介

    1. Struts2拦截器是在访问某个Action或Action的某个方法,字段之前或之后实施拦截,并且Struts2拦截器是可插拔的,拦截器是AOP的一种实现.

    2. 拦截器栈(Interceptor Stack)。Struts2拦截器栈就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时,Struts2拦截器链中的拦截器就会按其之前定义的顺序被调用。

    二、Struts2拦截器原理

    Struts2拦截器的实现原理相对简单,当请求struts2的action时,Struts 2会查找配置文件,并根据其配置实例化相对的    拦截器对象,然后串成一个列表,最后一个一个地调用列表中的拦截器。

    比如:应用要求用户登陆,且必须为指定用户名才可以查看系统中某个视图资源;否则,系统直接转入登陆页面。对于上面的需求,可以在每个Action的执行实际处理逻辑之前,先执行权限检查逻辑,但这种做法不利于代码复用。因为大部分Action里的权限检查代码都大同小异,故将这些权限检查的逻辑放在拦截器中进行将会更加优雅。

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

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

    三、拦截器API

    在Struts2的API中有一个com.opensymphony.xwork2.interceptor包,其中有一些Struts2的内置拦截器对象,他们有不同的功能。所有拦截器都直接或简介地实现Interceptor接口

    Interceptor接口声明了三个方法:

    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的实现,这个实现为:

    public abstract class AbstractInterceptor implements Interceptor {
     
        public void init() {
            //Does nothing
        }
       
        public void destroy() {
            //Does nothing
        }
     
        public abstract String intercept(ActionInvocation invocation) throws Exception{
           // Override to handle interception
        }
    }

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

    四、自定义拦截器

    自定义一个拦截器需要三步:

    1 自定义一个实现Interceptor接口(或者继承自AbstractInterceptor)的类。

    2 在strutx.xml中注册上一步中定义的拦截器。

    3 在需要使用的Action中引用上述定义的拦截器,为了方便也可将拦截器定义为默认的拦截器,这样在不加特殊声明的情况下所有的Action都被这个拦截器拦截。

    实例:使用拦截器过滤文字

    (1)新建一个项目,将Struts2的环境搭建好

    (2)在web.xml中配置Struts2的核心控制器,主要代码:

     <filter>
      	<filter-name>struts2</filter-name>
      	<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
      </filter>
      <filter-mapping>
      	<filter-name>struts2</filter-name>
      	<url-pattern>/*</url-pattern>
      </filter-mapping>

    (3)新建com.xiaobai.action.MessageAction类,并继承ActionSupport类实现Action。主要代码:

    import com.opensymphony.xwork2.ActionSupport;
    public class MessageAction extends ActionSupport {
    	private static final long serialVersionUID = 1L;
    	private String title=null;
    	private String content=null;
    	//省略getter、setter方法
    	public String execute(){
    		return SUCCESS;
    	}
    }

    (4)新建com.xiaobai.interceptor.MyInterceptor类,并继承AbstractInterceptor类,用于实现拦截器功能。主要代码:

    import com.itzcn.action.MessageAction;
    import com.opensymphony.xwork2.Action;
    import com.opensymphony.xwork2.ActionInvocation;
    import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
    
    public class MyInterceptor extends AbstractInterceptor {
    
    	private static final long serialVersionUID = 1L;
    
    	@Override
    	public String intercept(ActionInvocation ai) throws Exception {
    		Object obj=ai.getAction();
    		if(obj!=null){
    			if(obj instanceof MessageAction){
    				MessageAction action=(MessageAction) obj;
    				String content=action.getContent();
    				if(content.contains("administrator")){
    					content=content.replaceAll("administrator","系统管理员");
    				}
    				if(content.contains("admin")){
    					content=content.replaceAll("admin", "管理员");
    				}
    				action.setContent(content);
    				return ai.invoke();
    			}else{
    				return Action.LOGIN;
    			}
    		}else{
    			return Action.LOGIN;
    		}
    	}
    
    }

    (5)在struts.xml中配置Action和拦截器。主要代码:

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts-2.3.dtd">
    
    <struts>
    	
    	<!--<constant name="struts.enable.DynamicMethodInvocation" value="true"/>-->
    	
    	<package name="User" extends="struts-default">
    	
    		<interceptors>
    			<interceptor name="checkLogin" class="com.xiaobai.interceptor.MyInterceptor"></interceptor>
    		</interceptors>
    		
    		<action name="check" method="execute" class="com.xiaobai.action.MessageAction">
    			<result name="success">/success.jsp</result>
    			<result name="login">/success.jsp</result>
    			<interceptor-ref name="defaultStack"></interceptor-ref>
    			<interceptor-ref name="checkLogin"></interceptor-ref>
    		</action>
    		
    	</package>	
    	
    </struts>

    (6)新建index.jsp页面,在其中使用Struts2标签,用于提交内容。主要代码:

     <s:form action="check" method="post">
       <s:textfield name="title" label="标题" ></s:textfield>
       <s:textarea name="content" label="内容" rows="5" cols="18"></s:textarea>
       <s:submit value="发表"></s:submit>
     </s:form>

    (7)新建success.jsp页面,在其中使用Struts2标签,用于显示提交后的内容。主要代码:

      标题:<s:property value="title"/><br>
      内容:<s:property value="content"/>

    另一个小例子:编写一个Session过滤用的拦截器,该拦截器查看用户Session中是否存在特定的属性(LOGIN属性)如果不存在,中止后续操作定位到LOGIN,否则执行原定操作,代码为:

    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;
            }
        }
    }
     
    
    <!--注册拦截器-->
    <interceptors>
        <interceptor  name="login" class="com.jpleasure.teamware.util.CheckLoginInterceptor"/>
        <interceptor-stack name="teamwareStack">
           <interceptor-ref name="login"/>
           <interceptor-ref name="defaultStack"/>
        </interceptor-stack>
    </interceptors>
     
    <!--将上述拦截器设定为默认拦截器:-->
    <default-interceptor-ref name="teamwareStack"/>
    <!--这样在后续同一个package内部的所有Action执行之前都会被login拦截。-->

    五、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

    <!--注册并引用Interceptor-->
    <package name="default" extends="struts-default">
       <interceptors>
           <interceptor name="timer" class=".."/>
           <interceptor name="logger" class=".."/>
       </interceptors>
     
       <action name="login" class="tutorial.Login">
           <interceptor-ref name="timer"/>
           <interceptor-ref name="logger"/>
           <result name="input">login.jsp</result>
           <result name="success"
              type="redirect-action">/secure/home</result>
       </action>
    </package>
     
    <!--可以将多个拦截器合并在一起作为一个堆栈调用,当一个拦截器堆栈被附加到一个Action的时候,
    要想Action执行,必须执行拦截器堆栈中的每一个拦截器。-->
    <package name="default" extends="struts-default">
       <interceptors>
            <interceptor name="timer" class=".."/>
            <interceptor name="logger" class=".."/>
            <interceptor-stack name="myStack">
               <interceptor-ref name="timer"/>
               <interceptor-ref name="logger"/>
            </interceptor-stack>
        </interceptors>
     
        <action name="login" class="tutuorial.Login">
            <interceptor-ref name="myStack"/>
            <result name="input">login.jsp</result>
            <result name="success"
               type="redirect-action">/secure/home</result>
        </action>
    </package>
     
    <!--上述说明的拦截器在默认的Struts2应用中,根据惯例配置了若干个拦截器堆栈,详细情参看struts-default.xml-->
    <!--其中有一个拦截器堆栈比较特殊,他会应用在默认的每一个Action上。-->
    <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">
            <param name="excludeMethods">input,back,cancel,browse</param>
        </interceptor-ref>
        <interceptor-ref name="workflow">
            <param name="excludeMethods">input,back,cancel,browse</param>
        </interceptor-ref>
    </interceptor-stack>
     
    <!--每一个拦截器都可以配置参数,有两种方式配置参数,一是针对每一个拦截器定义参数,二是针对一个拦截器堆栈统一定义所有的参数,例如:-->
    <interceptor-ref name="validation">
     <param name="excludeMethods">myValidationExcudeMethod</param>
    </interceptor-ref>
    <interceptor-ref name="workflow">
     <param name="excludeMethods">myWorkflowExcludeMethod</param>
    </interceptor-ref>
    <!--或者-->
    <interceptor-ref name="defaultStack">
        <param name="validation.excludeMethods">myValidationExcludeMethod</param>
        <param name="workflow.excludeMethods">myWorkflowExcludeMethod</param>
    </interceptor-ref>
    
    <!-- 
    每一个拦截器都有两个默认的参数:
    excludeMethods - 过滤掉不使用拦截器的方法和
    includeMethods – 使用拦截器的方法。
     
    需要说明的几点:
    拦截器执行的顺序按照定义的顺序执行,例如:-->
    <interceptor-stack name="xaStack">
     <interceptor-ref name="thisWillRunFirstInterceptor"/>
     <interceptor-ref name="thisWillRunNextInterceptor"/>
     <interceptor-ref name="followedByThisInterceptor"/>
     <interceptor-ref name="thisWillRunLastInterceptor"/>
    </interceptor-stack>
    <!--的执行顺序为:
    thisWillRunFirstInterceptor
     thisWillRunNextInterceptor
        followedByThisInterceptor
          thisWillRunLastInterceptor
            MyAction1
            MyAction2 (chain)
            MyPreResultListener
            MyResult (result)
          thisWillRunLastInterceptor
        followedByThisInterceptor
     thisWillRunNextInterceptor
    thisWillRunFirstInterceptor
    -->
    <!--使用默认拦截器配置每个Action都需要的拦截器堆栈,例如:-->
    <action name="login" class="tutorial.Login">
         <interceptor-ref name="timer"/>
         <interceptor-ref name="logger"/>
         <interceptor-ref name="default-stack"/>
     
         <result name="input">login.jsp</result>
         <result type="redirect-action">/secure/home</result>
    </action>
    <!--可以按照如下的方式定义:-->
    <interceptors>
         <interceptor-stack name="myStack">
            <interceptor-ref name="timer"/>
            <interceptor-ref name="logger"/>
            <interceptor-ref name="default-stack"/>
         </interceptor-stack>
    </interceptors>
     
    <default-interceptor-ref name="myStack"/>
     
    <action name="login" class="tutorial.Login">
           <result name="input">login.jsp</result>
           <result type="redirect-action">/secure/home</result>
    </action>
    <!--如何访问HttpServletRequest,HttpServletResponse或者HttpSession
    有两种方法可以达到效果,使用ActionContext:
    Map attibutes = ActionContext.getContext().getSession();
    或者实现相应的接口:
    HttpSession            SessionAware
    HttpServletRequest     ServletRequestAware
    HttpServletResponse    ServletResponseAware
    -->
    
    

    Struts2自定义拦截器实例—只允许从登录页面进入系统
    【1】struts.xml:

     <!-- 定义一个拦截器 -->  
            <interceptors>  
                <interceptor name="authority"  
                    class="org.interceptot.LoginInterceptor">  
                </interceptor>  
                
                <!-- 拦截器栈 -->  
                <interceptor-stack name="mydefault">  
                    <interceptor-ref name="defaultStack" />  
                    <interceptor-ref name="authority" />  
                </interceptor-stack>  
            </interceptors>
            
             
            
             <!-- 定义全局Result -->  
            <global-results>  
                <!-- 当返回login视图名时,转入/login.jsp页面 -->  
                <result name="login">/login.jsp</result>  
            </global-results>
            
            
            <action name="show" class="org.action.showAction">  
                <result name="success">/main.jsp</result>  
                <!-- 使用此拦截器 -->  
                <interceptor-ref name="mydefault" />  
            </action>  
            
            
            <!--验证登录用户信息  -->
            <action name="login" class="org.action.loginAction" method="execute">
                <result name="error">/login.jsp</result>  
                <result name="input">/login.jsp</result> 
            </action>

          
    【2】自定义拦截器org.interceptot.LoginInterceptor:

    package org.interceptot;
    import java.util.Map;  
    
    import com.opensymphony.xwork2.Action;  
    import com.opensymphony.xwork2.ActionContext;  
    import com.opensymphony.xwork2.ActionInvocation;  
    import com.opensymphony.xwork2.interceptor.AbstractInterceptor;  
    public class LoginInterceptor extends AbstractInterceptor {  
     
        @Override  
        public String intercept(ActionInvocation invocation) throws Exception {  
      
            // 取得请求相关的ActionContext实例  
            ActionContext ctx = invocation.getInvocationContext();  
            Map session = ctx.getSession();  
            String user = (String) session.get("username");  
      
            // 如果没有登陆,即用户名不存在,都返回重新登陆  
            System.out.println("user:"+user);
            if (user != null) {  
                System.out.println("test");  
                return invocation.invoke();  
            }  
            System.out.println("你还没有登录"); 
            ctx.put("tip", "你还没有登录");  
            return Action.LOGIN;    //返回一个叫login的result结果
      
        }  
      
    }  


    【3】进入主页面的Action:org.action.showAction

    package org.action;
    
    import com.opensymphony.xwork2.ActionSupport;  
    
    public class showAction extends ActionSupport {  
     public String execute() {  
      return "success";  
     }  
    }  

    【4】LoginAction:

    private boolean isInvalid(String value) {     
    return (value == null || value.length() == 0);     
    }  
    if (isInvalid(user.getUsername()))   
           return INPUT;     
     if (isInvalid(user.getPassword()))     
           return INPUT;    
     //登录成功将User放入session中
    HttpServletRequest request = ServletActionContext.getRequest();
    Map  map=ActionContext.getContext().getSession();
    map.put("username", user.getUsername());

    【5】如果我们通过show.action访问main.jsp那么就会被自定义拦截器拦住,拦截器检查session中
    是否有值,有证明用户已经登录,没有则为没有登录,那么就会被跳转到登陆页面。

    六、拦截器与过滤器的区别

    过滤器,是在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的首字母缩写) ,我们知道,面向对象的特点是继承、多态和封装。而封装就要求将功能分散到不同的对象中去,这在软件设计中往往称为职责分配。实际上也就是说,让不同的类设计不同的方法。这样代码就分散到一个个的类中去了。这样做的好处是降低了代码的复杂程度,使类可重用。
          但是人们也发现,在分散代码的同时,也增加了代码的重复性。什么意思呢?比如说,我们在两个类中,可能都需要在每个方法中做日志。按面向对象的设计方法,我们就必须在两个类的方法中都加入日志的内容。也许他们是完全相同的,但就是因为面向对象的设计让类与类之间无法联系,而不能将这些重复的代码统一起来。
        也许有人会说,那好办啊,我们可以将这段代码写在一个独立的类独立的方法里,然后再在这两个类中调用。但是,这样一来,这两个类跟我们上面提到的独立的类就有耦合了,它的改变会影响这两个类。那么,有没有什么办法,能让我们在需要的时候,随意地加入代码呢?这种在运行时,动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。 
          一般而言,我们管切入到指定类指定方法的代码片段称为切面,而切入到哪些类、哪些方法则叫切入点。有了AOP,我们就可以把几个类共有的代码,抽取到一个切片中,等到需要时再切入对象中去,从而改变其原有的行为。
    这样看来,AOP其实只是OOP的补充而已。OOP从横向上区分出一个个的类来,而AOP则从纵向上向对象中加入特定的代码。有了AOP,OOP变得立体了。如果加上时间维度,AOP使OOP由原来的二维变为三维了,由平面变成立体了。从技术上来说,AOP基本上是通过代理机制实现的。 
         AOP在编程历史上可以说是里程碑式的,对OOP编程是一种十分有益的补充。

     

    展开全文
  • Struts2拦截器的学习

    2018-07-03 11:58:56
    首先我应该先要了解Struts2拦截器的执行原理 Struts 2拦截器实现相对简单。当请求到达Struts2的ServletDispatcher时,Struts 2会查找配置文件,并根据其配 置实例化相对的拦截器对象,然后串成一个列表(list)...
    一.首先我应该先要了解Struts2拦截器的执行原理

    Struts 2的拦截器实现相对简单。当请求到达Struts2的ServletDispatcher时,Struts 2会查找配置文件,并根据其配 置实例化相对的拦截器对象,然后串成一个列表(list),最后一个一个地调用列表中的拦截器。事实上,我们之所以能够如此灵活地使用拦截器,完全归功于“动态代理”的使用。动态代理是代理对象根据客户的需求做出不同的处理。对于客户来说,只要知道一个代理对象就行了。

    那Struts2中,拦截器是如何通过动态代理被调用的呢 当Action请求到来的时候,会由系统的代理生成一个Action的代理对象,由这个代理对象调用Action的execute()或指定的方法,并在 struts.xml中查找与该Action对应的拦截器。如果有对应的拦截器,就在Action的方法执行前(后)调用这些拦截器;如果没有对应的拦截 器则执行Action的方法。其中系统对于拦截器的调用,是通过ActionInvocation来实现的。

    Struts2的工作原理图:


    一.通过实例来实现Struts2拦截器的功能
    1.简单的自定义一个拦截器的步骤:

    (1)编写拦截器类,需要实现Interceptor接口或者继承AbstractInterceptor类。

    (2)修改配置文件加上拦截器信息,并完成注册使用(此处省略添加Jar包和创建Web项目的步骤)。


    下面通过实例来演示效果,首先是Action组件,代码如下。



    定义拦截器组件,代码入下。


    最后的重点,在struts.xml文件中进行配置,代码入下。



    至此,一个简单的拦截器组件配置完成。线面我们运行程序查看结果,打开浏览器输入地址,注意:直接访问Action即可,在控制台输入如图所示。


    可以看出拦截器的拦截方法在Action方法执行之前执行了。接下来我们修改一下代码,再来研究一下执行的细节效果。在拦截器中的拦截方法中修改如下。



    同时在index.jsp中加入一行Java代码。



    再次运行结果,控制台的输出结果如下。



    arg0.invoke() 就是通知struts2接着干下面的事情
    比如 调用下一个拦截器 或 执行下一个Action
    拦截器的值返回值要么代表继续拦截 要么是success等一些类Action类提供的静态量
    它会根据这个值去到相应的页面

    分析控制台输出结果:可以发现拦截器、Action和JSP页面执行的过程,首先请求进入拦截器,执行完成拦截器的功能,调用ActionInvocation对象的invoke方法,从而进入到Action中执行Action的处理方法,接着根据配置转入到相应的View(index.jsp)页面,执行完JSP页面代码后,再次回到拦截中,执行剩下的代码。这里值得注意的是:拦截器中的invoke方法执行完毕后,如果还有后续代码,当视图层执行完毕后,还会接着回来执行后面的代码,这也是前面说的为什么拦截器会在Action的执行前和执行后都会运行。


      接着我们来配置两个拦截器,进一步理解多个拦截器是如何系统工作的。在上述的案例中,我们再新增一个拦截器Interceptor2,这次实现Interceptor接口,代码如下。


        接下来就是配置文件的内容,增加了一个新的拦截器,代码入下(配置方法和案例一相同)。


        我们再次运行程序,控制台输出结果如下。

        

        这次控制台输出的结果是两个拦截器依次拦截的效果,大家仔细分析,可以看出多个拦截器的执行也遵循前面的案例规则,即拦截器会依次执行,当执行完JSP页面后会再次进入拦截器里面执行后续的剩下的代码。需要大家注意的是:再回到拦截器里面执行的时候,执行的顺序是倒过来的。最后大家记住:拦截器只是拦截请求Action的组件,对于请求的JSP组件,拦截器是不会工作的!

    2.我对拦截器栈的理解

        在前面的案例中我们已经看到了定义拦截器的代码。接下来仔细研究如何配置拦截器。首先我们已经知道了配置拦截器所需要的以下两个元素。

    (1)通过<interceptor.../>元素来定义拦截器

    (2)在Action中通过<interceptor-ref.../>元素来使用拦截器。

        如果自己写的拦截器比较多,而且每个拦截器都要在Action中依次引用来使用的话,配置起来就比较麻烦了。我们可以利用拦截器栈的概念来进行改进,代码如下。


    我们再次运行程序,控制台输出结果如下(和上述案例运行结果一致)。



        上述配置中在interceptors元素中使用interceptor-ref元素定义拦截器栈,name属性指定拦截器的名称,在栈中依然使用interceptor-ref元素指定引用拦截器。定义好拦截器栈后,在Action中直接引用拦截器栈,从而简化配置。值得注意的是:拦截器栈定义的时候是可以嵌套的,也就是一个拦截器栈里面也还可以引用其他的拦截器栈。

        最后,如果配置文件中大多数Action都想用相同的拦截器或拦截器栈,建议定义默认的拦截器引用,使用<default-interceptor-ref/>元素来定义,其中name属性依然是指定引用拦截器或者拦截器栈的名称,那么配置文件会是如下的形式。


    3.Struts2常用的拦截器

    你打开struts-default.xml这个文件,找到拦截器的定义,这里面的都是常用的。


    这里我就不一一介绍了,如果大家想详细了解可以给我私信或者通过百度的方式了解一下。

    4.Struts2默认拦截器栈

        Struts2对于开发中要经常用到的功能,给大家定义了一个非常重要的拦截器栈:defaultStack拦截器栈。defaultStack拦截器栈组合了多个拦截器,这些拦截器经过精心的设计和挑选,能够满足大多数Web应用程序的需求,我们只要是在定义包的过程中继承struts-default包,那么defaultStack拦截器将会是所有Action默认的拦截器引用。

        例如:

        

        Struts2为我们提供了如此丰富的拦截器,基本上开发时常用的功能都够用了。所以使用它能够大大提高我们的开发效率。最后一个大家要注意的事项:一旦在struts.xml中配置了自己的拦截器,并且使用了,那么系统将不会调用默认的拦截器栈(defaultStack),系统提供的所有功能也将失效。所以一般来说,我们会把自己的拦截器栈和默认的拦截器进行再整合,形成一个新的拦截器栈,将这个新的拦截器栈配成默认的。这样就可以让Struts2即执行开发人员定义的拦截器又拥有系统默认的所有功能。



    好啦,我今天的博客完成啦,欢迎大家继续关注,我会持续更新作品的。








    展开全文
  • Struts2 拦截器的配置: 第一步:在struts.xml文件中加入拦截器配置: 我们可以在配置拦截器的时候,自己定义一个拦截器栈来包含我们自己定义的拦截器(注意:一定要将 defaultStack 加进去,这是框架自带的拦截器...

    Struts2 拦截器的配置:

    第一步:在struts.xml文件中加入拦截器配置:

    我们可以在配置拦截器的时候,自己定义一个拦截器栈来包含我们自己定义的拦截器(注意:一定要将 defaultStack 加进去,这是框架自带的拦截器,能够帮助我们完成表单数据封装等功能)

    <!-- 配置拦截器 -->
    	<interceptors>
    		<interceptor name="mytimer" class="com.test.interceptor.TimerInterceptor" />
    		<interceptor name="checklogin" class="com.test.interceptor.LoginInterceptor" />
    		<!-- 自己定义的拦截器栈 -->
    		<interceptor-stack name="myStack">
    			<interceptor-ref name="defaultStack"></interceptor-ref>
    			<interceptor-ref name="mytimer"></interceptor-ref>
    		</interceptor-stack>
    	</interceptors>

    第二步:使用配置的拦截器

    第一种方法:在action中使用配置的拦截器:

    <action name="param" class="com.test.action.ParamAction">
    		<result>/ognl.jsp</result>
    		<!-- action里面配置拦截器 -->
    		<interceptor-ref name="myStack"></interceptor-ref>
    	</action>

    第二种方法:配置默认拦截器(全局拦截器):

    注意:在单个action配置了拦截器,就不在给这个action配置默认的拦截器,需要自己配置需要的拦截器(注意:别忘了 defaultStack 拦截器)

    <!-- 默认拦截器,在action外面配置拦截器,为该package下的所有action都配置拦截器 -->
    	<default-interceptor-ref name="myStack"></default-interceptor-ref>

    登录拦截实例:

    struts.xml配置(src文件目录下):

    <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts-2.3.dtd" > <struts> <package name="gyx" extends="struts-default">

    <!-- 配置拦截器 -->
    	<interceptors>
    		<interceptor name="mytimer" class="com.test.interceptor.TimerInterceptor" />
    		<interceptor name="checklogin" class="com.test.interceptor.LoginInterceptor" />
    		<interceptor-stack name="myStack">
    			<interceptor-ref name="defaultStack"></interceptor-ref>
    			<interceptor-ref name="mytimer"></interceptor-ref>
    		</interceptor-stack>
    	</interceptors>
    	
    	<!-- 默认拦截器,在action外面配置拦截器,为该package下的所有action都配置拦截器 -->
    	<default-interceptor-ref name="myStack"></default-interceptor-ref>
    	
    	<!-- 全局页面配置 -->
    	<global-results>
    		<result name="login" type="redirect">/login.jsp</result>
    		<result name="error">/error.jsp</result>
    	</global-results>
    	
    	<action name="param" class="com.test.action.ParamAction">
    		<result>/ognl.jsp</result>
    		<interceptor-ref name="checklogin"></interceptor-ref>
    		<interceptor-ref name="myStack"></interceptor-ref>
    		<!-- action里面配置拦截器 
    		<interceptor-ref name="myStack"></interceptor-ref>
    		-->
    	</action>
    	
    	<action name="login" class="com.test.action.LoginAction">
    		<result name="success" type="redirect">/param.jsp</result>
    	</action>
    </package>
    </struts>

    LoginAction(src下的com.test.action包下):

    package com.test.action;
    
    import java.util.Map;
    
    import com.opensymphony.xwork2.ActionContext;
    import com.opensymphony.xwork2.ActionSupport;
    
    public class LoginAction extends ActionSupport {
    
    private String uname;
    private String upwd;
    
    @Override
    public void validate() {
    	if (uname.length()==0) {
    		this.addFieldError("uname", "用户名为空!");
    	}
    	if (upwd.length()==0) {
    		this.addFieldError("upwd", "密码为空!");
    	}
    }
    
    public String execute() throws Exception {
    	if ("admin".equals(uname)&&"123".equals(upwd)) {
    		System.out.println("登录成功");
    		
    		Map session = ActionContext.getContext().getSession();
    		session.put("loginok", "admin");
    		
    		return "success";
    	}else{
    		System.out.println("登录失败");
    		return "error";
    	}
    }
    
    public String getUname() {
    	return uname;
    }
    
    public void setUname(String uname) {
    	this.uname = uname;
    }
    
    public String getUpwd() {
    	return upwd;
    }
    
    public void setUpwd(String upwd) {
    	this.upwd = upwd;
    }
    
    }

    ParamAction(src下的com.test.action包下):

    package com.test.action;
    
    import java.util.HashMap;
    import java.util.Map;
    
    import com.gyx.entity.User;
    import com.opensymphony.xwork2.ActionContext;
    import com.opensymphony.xwork2.ActionSupport;
    
    public class ParamAction extends ActionSupport{
    
    	private User user;
    	
    	@Override
    	public String execute() throws Exception {
    		System.out.println("传入的参数为:"+user);
    		
    		Map session = ActionContext.getContext().getSession();
    		session.put("hero", "剑魔");
    		
    		Map city = new HashMap();
    		city.put("北京", "中国");
    		city.put("东京", "日本");
    		city.put("莫斯科", "俄罗斯");
    		city.put("巴黎", "法国");
    		session.put("city", city);
    		
    		return SUCCESS;
    	}
    
    	public User getUser() {
    		return user;
    	}
    
    	public void setUser(User user) {
    		this.user = user;
    	}
    
    }

    LoginInterceptor(src下的com.test.interceptor包下):登录拦截器

    package com.test.interceptor;
    
    import java.util.Map;
    
    import com.opensymphony.xwork2.Action;
    import com.opensymphony.xwork2.ActionInvocation;
    import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
    
    public class LoginInterceptor extends AbstractInterceptor {
    
    	@Override
    	public String intercept(ActionInvocation invocation) throws Exception {
    		System.out.println("进入登录拦截器");
    		
    		Map session = invocation.getInvocationContext().getSession();
    		Object user =  session.get("loginok");
    		if (user==null) {
    			return Action.LOGIN;
    		}else{
    			return invocation.invoke();
    		}
    	}
    
    }

    TimerInterceptor(src下的com.test.interceptor包下):计时拦截器:

    package com.test.interceptor;
    
    import com.opensymphony.xwork2.ActionInvocation;
    import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
    
    public class TimerInterceptor extends AbstractInterceptor{
    
    	@Override
    	public String intercept(ActionInvocation invocation) throws Exception {
    		System.out.println("进入timer拦截器");
    		long begintimer = System.currentTimeMillis();
    		//放行
    		String result = invocation.invoke();
    		long exetimer = System.currentTimeMillis()-begintimer;
    		System.out.println("执行action,用了"+exetimer);
    		return result;
    	}
    }

    jsp页面:login.jsp

    <!-- 这句加在页面顶部(添加标签库)  -->
    <%@ taglib uri="/struts-tags" prefix="s"%>
    
    <div>
    	<s:form action="login.action" method="post">
    		<s:textfield name="uname" label="用户名:"/><br/>
    		<s:password name="upwd" label="密码:" /><br/>
    		<s:submit value="登录"/>
    	</s:form>
    </div>

    param.jsp:

    <a href="param?user.name=VN&user.age=21">链接</a>
    <form action="param">
    姓名:<input type="text" name="user.name" /><br/>
    年龄:<input type="text" name="user.age" /><br/>
    日期:<input type="text" name="user.now" /><br/>
    性别:男<input type="radio" name="user.sex" value="true"/>
    女<input type="radio" name="user.sex" value="false"/><br/>
    
    爱好:打球<input type="checkbox" name="user.hobbies" value="ball"/>
    玩游戏<input type="checkbox" name="user.hobbies" value="game"/>
    看书<input type="checkbox" name="user.hobbies" value="book"/>
    
    <input type="submit" value="提交" />
    </form>

    ognl.jsp:

    <!-- 这句加在页面顶部(添加标签库)  -->
    <%@ taglib uri="/struts-tags" prefix="s"%>
    
    值栈取值:<s:property value="user.name" /><br/>
    <s:property value="user.hobbies" /><br/>
    作用域取值:<s:property value="#attr.hero" />(在三大作用域中,自动的从小往上找,把第一个找到的显示)
    <br/>
    MAP取值:<s:property value="#session.city" /><br/>
    取MAP中的一个值:<s:property value="#session.city.巴黎" /><br/>
    取MAP中的一个值:<s:property value="#session.city['北京']" /><br/>

    error.jsp:

    <h1>用户登录失败</h1>
    <h1>用户名或者密码错误!</h1>
    展开全文
  • struts2拦截器添加及xss攻击的处理

    千次阅读 2017-06-21 11:25:02
    struts2拦截器添加及xss攻击的处理

    struts2拦截器添加及xss攻击的处理

    先在struts2.xml中添加拦截路径。

    <package name="base" extends="struts-default,json-default" >
    
    <!-- 给文本编辑器配置的bean以及constant -->
    
       <!--拦截器-->
       <interceptors>
          <interceptor name="LoginInterceptor" class="com.spark.tempo.urm.web.interceptor.LoginInterceptor">
             <!--方法不拦截-->
             <param name="excludeMethods">login</param>
          </interceptor>
          <interceptor-stack name="myDefault">
             <interceptor-ref name="defaultStack"/>
             <interceptor-ref name="LoginInterceptor"/>
          </interceptor-stack>
       </interceptors>
    
       <default-interceptor-ref name="myDefault"/>
       <global-results>
          <result name="login">/mgrIndex.jsp</result>
       </global-results>
    </package>
    然后在需要拦截的action中添加注解:

    @ParentPackage(value="base")
    如果action中都有继续统一的BaseAction则可以在BaseAction中写入此注解如:

    @ParentPackage(value="base")
    public class BaseAction extends WebApplicationObjectSupport implements Action {

    在添加拦截器类及方法

    我做这拦截添加了防止页面中传入的xss攻击代码

    2、拦截器要继承MethodFilterInterceptor类这样xml中的<param name="excludeMethods">login</param>不拦截的方法才能生效不然不生效别怪我哟。

    public class LoginInterceptor extends MethodFilterInterceptor {
    
    
        @Resource
        private IBaseService baseService;
        private HttpServletRequest request;
    
        @Override
        public String doIntercept(ActionInvocation acation) throws Exception {
            String actionName = acation.getInvocationContext().getName();//获取action方法名
            Map<String,Object> parameters = acation.getInvocationContext().getParameters();
    
            request = ServletActionContext.getRequest();
    
            ActionContext ac = acation.getInvocationContext();
            ValueStack stack = ac.getValueStack();
            for(Map.Entry<String,Object> map : parameters.entrySet()){
                Object[] obj = (Object[])map.getValue();//获取传入的参数值是否有非法,xss攻击
    
    //            System.out.println("参数名:"+map.getKey()+"   参数值:"+obj[0].toString());
    //            System.out.println("处理参数名:"+map.getKey()+"   处理后参数值:"+XssHttpServletRequestWrapper.xssEncode(obj[0].toString()));
                //action参数中添加处理后的值,防止xss攻击将处理后的参数重新setaction值中
                stack.setValue(map.getKey(), XssHttpServletRequestWrapper.xssEncode(obj[0].toString()));
            }
    
            User user = (User) ServletActionContext.getRequest().getSession().getAttribute(SysContextParam.SessionAttribute.SESSION_CURR_USER);
            //用户已登陆,添加操作日志
            if(user != null){
                //获取访问者ip
                String ip  = request.getHeader("x-forwarded-for");
                if (ip == null || ip.length() == 0) {
                    ip = request.getRemoteAddr();
                }
                //添加日志:
                String logSql = "INSERT INTO t_custom_manager_log (id, operator, create_date, operate_url, ip,operate_project) VALUES(?, ?, ?, ?, ? ,?)";
                baseService.executeUpdateByOrigSQL(logSql, new Object[]{null,user.getName(),new Date(),request.getServletPath(),ip,"1"});
                return acation.invoke();
            }else{
                return "login";
            }
        }
    
    }
     
    

    添加防拦截的xss攻击类

    public class XssHttpServletRequestWrapper {
    
    
        /**
         * 将容易引起xss漏洞的半角字符直接替换成全角字符
         *
         * @param s
         * @return
         */
        public static String xssEncode(String s) {
            if (s == null || s.isEmpty()) {
                return s;
            }
            StringBuilder sb = new StringBuilder(s.length() + 16);
            for (int i = 0; i < s.length(); i++) {
                char c = s.charAt(i);
                switch (c) {
                    case '>':
                        sb.append('');// 全角大于号
                        break;
                    case '<':
                        sb.append('');// 全角小于号
                        break;
    //                case '\'':
    //                    sb.append('‘');// 全角单引号
    //                    break;
    //                case '\"':
    //                    sb.append('“');// 全角双引号
    //                    break;
                    case '(':
                        sb.append('');// 全角
                        break;
                    case ')':
                        sb.append('');// 全角
                        break;
                    case '&':
                        sb.append('');// 全角
                        break;
                    case '\\':
                        sb.append('');// 全角斜线
                        break;
                    case '#':
                        sb.append('');// 全角井号
                        break;
                    case '%':    // < 字符的 URL 编码形式表示的 ASCII 字符(十六进制格式) 是: %3c
                        processUrlEncoder(sb, s, i);
                        break;
                    default:
                        sb.append(c);
                        break;
                }
            }
            return sb.toString();
        }
        private static void processUrlEncoder(StringBuilder sb, String s, int index) {
            if (s.length() >= index + 2) {
                if (s.charAt(index + 1) == '3' && (s.charAt(index + 2) == 'c' || s.charAt(index + 2) == 'C')) {    // %3c, %3C
                    sb.append('');
                    return;
                }
                if (s.charAt(index + 1) == '6' && s.charAt(index + 2) == '0') {    // %3c (0x3c=60)
                    sb.append('');
                    return;
                }
                if (s.charAt(index + 1) == '3' && (s.charAt(index + 2) == 'e' || s.charAt(index + 2) == 'E')) {    // %3e, %3E
                    sb.append('');
                    return;
                }
                if (s.charAt(index + 1) == '6' && s.charAt(index + 2) == '2') {    // %3e (0x3e=62)
                    sb.append('');
                    return;
                }
            }
            sb.append(s.charAt(index));
        }
    }

    好,搞完收工。

    还有就是拦截到返回的参数:login他会返回到struts2中xml

     <global-results>
          <result name="login">/mgrIndex.jsp</result>
       </global-results>
    获取返回的login到mgrIndex.jsp路径中,这我是jsp页面。也可以根据自己的需要添加








    展开全文
  • 拦截器动态拦截Action调用的对象。它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码,也可以在一个action执行前阻止其执行。同时也是提供了一种可以提取action中可重用的部分的方...
  • Struts2 拦截器拦截器在概念上与servlet过滤器或JDK代理类相同。拦截器允许横切功能,把action以及框架分开实现。你可以使用拦截器实现以下操作:在调用action之前提供预处理逻辑。在调用action后提供后处理逻辑。...
  • 一、Interceptor的生命周期 1.初始化拦截器 @Override public void init() { // TODO Auto-generated method stub ...2.拦截器执行 @Override public String intercept(ActionInvocation actionInvoca...
  • 1.拦截器创建: ...拦截器配置:struts.xml     web.xml,添加过滤器 &lt;filter&gt; &lt;filter-name&gt;struts2&lt;/filter-name&gt; &lt;filter-class&...
  • Struts2_拦截器(Action拦截和全局拦截)

    千次阅读 2017-07-11 13:53:40
    先说说什么是拦截器: 拦截器,顾名思义,拦截请求(Action),可以达到增强Action的功能,框架本身默认提供很多拦截器,大概有35种,但往往实际开发中,还需要自定义一些拦截器,比如:权限(访问)拦截。再说说怎么
  • Struts2拦截器Filter

    2019-06-30 16:24:54
    拦截器 拦截器Filter是Struts2的核心。 Struts2拦截器与Servlet中的过滤器相似。 在执行Action的execute()方法之前,Struts2先执行...在Struts2拦截器体系中,Struts2的内建拦截器完成了该框架的大部分操作,...
  • 谈到拦截器,还有一个词大家应该知道——拦截器链(Interceptor Chain,在Struts 2中称为拦截器栈Interceptor Stack)。拦截器链就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时,拦截器链中的...
  • Struts2拦截器详解

    千次阅读 2017-03-08 09:17:26
    成功的花儿,其间浸透了奋斗的泪水和汗水;然而,用泪水和汗水就可以实现一切...Struts2里面封装了很多的功能,有很多拦截器,不是每次这些拦截器都执行,每次执行默认的拦截器Struts2里面默认的拦截器位置: struts
  • 目录Struts框架下的项目运行出现404错误的原因总结**理解Struts2的原理** Struts框架下的项目运行出现404错误的原因总结 本文总结一下隔个人在学习Web应用开发中,使用Struts2框架技术时出现的404错误。 开发工具: ...
  • 今日目录  1、拦截器简介  2Struts2 预定义拦截器&amp;拦截器栈 ... Struts2 拦截器是在访问某个 Action 或 Action 的某个方法,字段之前或之后实施拦截,并且 Struts2 拦截器是可插拔的,拦...
  • 转载/Struts2拦截器实现异常处理机制

    千次阅读 2016-04-21 07:55:19
    创建ErrorInterceptor.java import javax.servlet.http.HttpServletRequest; import org.apache.log4j.Logger; import org.apache.struts2.StrutsStatics; import com.opensymphony.xwork2.ActionInvocation; imp
  • 本方案采用struts2拦截器过滤,将提交上来的参数转码来解决。 配置struts.xml extends=struts-default,> <!-- 配置拦截器 --> <!-- 定义xss拦截器 --> 此处填写拦截器类名></interceptor>
  • Struts2(二)-Struts2之参数绑定和拦截器

    千次阅读 2017-07-26 23:06:02
    Struts2使用原生Servlet的API获取表单的参数,使用模型驱动的方式获取表单参数。 使用原生Servlet的API向页面传递参数。 使用拦截器,做登录校验。
  • Struts2拦截器介绍

    2017-05-08 23:13:05
    Struts2 拦截器在访问某个 Action 方法之前或之后实施拦截, Struts2 拦截器是可插拔的, 拦截器是 AOP 的一种实现.拦截器栈(Interceptor Stack): 将拦截器按一定的顺序联结成一条链. 在访问被拦截的方法时, Struts2...
  • 如何在Struts2中的拦截器中获取 request response 等对象呢?   ActionContext actionContext = invocation.getInvocationContext(); HttpServletRequest request= (HttpServletRequest) actionContext.get...
  • Struts2拦截器实现异常处理

    千次阅读 2016-09-29 20:16:06
    Struts2拦截器实现异常处理机制 在j2ee项目中,系统内部难免会出现一些异常,如果把异常放任不管直接打印到浏览器可能会让用户感觉莫名其妙,也有可能让某些用户找到搞定系统的方法。 所以不要在页面上输出错误...
  • Struts2编写的通用的禁止用户非法访问非登录页面以外的其他页面的拦截器,过滤器,程序附带运行说明和可执行文件,希望给您的工作或学习带来帮助
  • Struts 拦截器不起作用

    2019-04-06 19:14:38
    Struts 拦截器不起作用,在拦截器添加输出发现拦截器未执行,重点检查包结构,很可能是struts.xml中拦截器class与实际拦截器不在同一位置。
  • 详解Struts2拦截器机制

    2017-05-25 11:17:09
    Struts2的核心在于它复杂的拦截器,几乎70%的工作都是由拦截器完成的。...总之,在整个Struts框架中拦截器的作用是相当大的,本篇将从以下几点详细介绍下有关Struts拦截器的内容: 拦截器在Struts中的作用 自定
  • struts2拦截器(拦截指定方法)

    千次阅读 2014-04-15 22:57:02
    Action中使用拦截器,默认情况下会拦截Action中所有的方法,但是在某些情况下,可能只需要拦截Action中的一个或多个方法,有时候也希望不拦截某个方法,这个在Struts2中是怎么实现的呢? Struts2中提供了一个...
  • struts2 由于本身是filter(过滤器)实现, 为了为我们struts2增加一个拦截请求的功能,就开发了一个拦截器,简单来说就是struts2里面的过滤器。 自定义拦截器: package com.xingxue.fil...
  • 自定义拦截器,检查用户是否登录
  • struts2拦截器的一个使用实例

    千次阅读 2018-04-29 22:55:59
    一个关于struts2自定义拦截器使用的例子,觉得很好,记录下来,以备后用。 要求:建立一个拦截器,用户名后缀为“r”的才允许访问“/sec”命名空间下的所有 action。 (拦截器struts.xml,需 要定义拦截器堆栈、...
  • Struts 2拦截器

    千次阅读 2015-02-08 10:06:01
    Struts2拦截器是在访问某个Action或Action的某个方法,字段之前或之后实施拦截,并且Struts2拦截器是可插拔的,拦截器是AOP(Aspect Oriented Programming,面向切面编程)的一种实现 拦截器栈(InterceptorStack)...
  • struts2struts2拦截器

    千次阅读 2015-06-05 00:28:21
    /** *刘梦冰发表于2015-6-5 */struts2提供面向切面(AOP)编程的机制,拦截器便是一种成熟的AOP编程思想的实现,它提供一种机制使开发者能把相对独立的代码抽象出来,配置到action...struts2中称拦截器链为拦截器
  • -- 将已经声明的拦截器加到默认的拦截器里面去 --> <!-- 这个拦截器的名字就叫做defaultStack,这样就直接覆盖了原来的defaultStack --> <!-- 如果不这样写,还可以在像注释这样添加 --> < interceptor-...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,341
精华内容 10,536
关键字:

动态添加struts2拦截器