精华内容
下载资源
问答
  • eclipse环境下基于tomcat-7.0.82构建struts2项目 eclipse环境下基于已构建struts2项目整合spring+hibernate 基于已构建S2SH项目配置全注解方式简化配置文件 首先简单说明一下为什么需要在s2

    周末真的是懒到心慌。。。。。。

    本文是在完整s2sh项目基础上添加的,不太了解s2sh项目构建的朋友可以先参考一下这几篇文章:

    eclipse环境下基于tomcat-7.0.82构建struts2项目

    eclipse环境下基于已构建struts2项目整合spring+hibernate

    基于已构建S2SH项目配置全注解方式简化配置文件

    首先简单说明一下为什么需要在s2sh项目中配置题目所述三项:

    1.struts2动态调用:

    如果不配置动态调用,我们只能在一个action中调用一个默认excute()方法,每请求调用一个方法就需要编写一个action,这样就会加大开发的工作量,因此这是刚需。

    2.Servlet过滤器

    Servlet过滤器我们可以理解为一个独立的web组件,它拦截请求和响应,以便查看、提取或以某种方式操作正在客户机和服务器之间交换的数据。过滤器是通常封装了一些功能的 Web 组件,这些功能虽然很重要,但是对于处理客户机请求或发送响应来说不是决定性的。

    3.struts2拦截器

    struts2拦截器是是其核心,拦截器可以让我们在action和result执行之前或者之后完成一些操作,比如权限验证,未登陆的用户不被允许访问某些资源等。

    过滤器与拦截器的区别

    首先过滤器是基于servlet的基础上进行的操作,是属于全局的,可过滤到所有请求资源,包括.css等文件,而拦截器是基于struts2的,只能过滤到请求action的方法。

    相同点,二者的实现都可看作是模块化的,可理解为是aop的一种策略。

    配置步骤:

    第一步:配置struts2动态调用

    在struts.xml配置文件中的<struts></struts>节点内声明struts2支持动态调用、并规定匹配怎样的字符交给struts2进行处理,代码如下:

        <!-- 让struts2支持动态方法调用 以感叹号方式调用action中的多个方法 -->
        <constant name="struts.enable.DynamicMethodInvocation" value="true" />
    
        <!-- 所有匹配*.action、do的请求都由struts2处理 -->
        <constant name="struts.action.extension" value="action,do" />

    第二步:配置servlet过滤器

    过滤器的配置需要我们实现servlet的Filter接口,并实现其抽象方法destroy()、doFilter(ServletRequest arg0, ServletResponse arg1,FilterChain arg2)、init(FilterConfig arg0),三个方法含义分别是初始化、过滤操作、销毁,接着需要我们在web.xml进行声明自定义过滤器,因为web.xml才是servlet的第一容器,给出自定义过滤器代码如下:

    复制代码
    package wjt.com.test.filter;
    
    import java.io.IOException;
    
    import javax.servlet.Filter;
    import javax.servlet.FilterChain;
    import javax.servlet.FilterConfig;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    
    public class CharacterFilter implements Filter{
    
        @Override
        public void destroy() {
            // TODO Auto-generated method stub
            
        }
    
        @Override
        public void doFilter(ServletRequest arg0, ServletResponse arg1,
                FilterChain arg2) throws IOException, ServletException {
            System.out.println("过滤器...");
            arg2.doFilter(arg0, arg1);
        }
    
        @Override
        public void init(FilterConfig arg0) throws ServletException {
            // TODO Auto-generated method stub
            
        }
    
    }
    复制代码

    修改后的web.xml如下:

    复制代码
    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
      <display-name>SSHDemo</display-name>
      
          <!-- spring的监听器配置开始 -->
        <!-- spring监听器的作用:提供实例(IOC) -->
          <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </context-param>
        
        <listener>
            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
        </listener>
        
            <!--过滤非法字符,该配置必须在最前面 -->
        <filter>
            <filter-name>characterFilter</filter-name>
            <filter-class>wjt.com.test.filter.CharacterFilter</filter-class>
            <init-param>
                <param-name>encoding</param-name>
                <param-value>UTF-8</param-value>
            </init-param>
        </filter>
        <filter-mapping>   <!-- 指定过滤器映射 -->
            <filter-name>characterFilter</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>
      
      <!-- 将请求路径交由struts过滤 -->
      <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>
    </web-app>
    复制代码

     

    第三步:配置struts2拦截器

    struts2的拦截器接口有多个,根接口也包含初始化、执行拦截操作、销毁三个抽象方法,这里我们继承MethodFilterInterceptor抽象类,该类内部已经对初始化和销毁的方法进行了实现,因此只需要实现执行拦截操作的抽象方法即可,当然如果有初始化和销毁操作,我们这里也可以对其进行定义覆盖父类同名方法的实现,代码如下:

    复制代码
    package wjt.com.test.interceptor;
    
    import org.apache.struts2.ServletActionContext;
    
    import com.opensymphony.xwork2.ActionInvocation;
    import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;
    
    /**
     * 自定义方法拦截器
     * 
     * @author Together
     *
     */
    public class MethodInterceptor extends MethodFilterInterceptor{
    
        /**
         * 
         */
        private static final long serialVersionUID = 1L;
    
        @Override
        protected String doIntercept(ActionInvocation arg0) throws Exception {
            System.err.println("拦截器生效...");
            String action=(String) ServletActionContext.getRequest().getSession().getAttribute("action");
            System.out.println("action:"+action);
            StringBuffer requstPath=ServletActionContext.getRequest().getRequestURL();
            System.out.println("requstPath:"+requstPath);
            System.err.println("拦截器结束...");
            return arg0.invoke();
        }
    
    }
    复制代码

    配置struts.xml文件,使拦截器生效,配置如下:

    复制代码
    <?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"><!-- 这里要和struts2版本号统一 -->
    
    <struts>
    
        <!-- 告知Struts2运行时使用Spring来创建对象 -->
        <constant name="struts.objectFactory" value="spring" />
    
        <!-- 让struts2支持动态方法调用 以感叹号方式调用action中的多个方法 -->
        <constant name="struts.enable.DynamicMethodInvocation" value="true" />
    
        <!-- 所有匹配*.action、do的请求都由struts2处理 -->
        <constant name="struts.action.extension" value="action,do" />
    
        <package name="default" namespace="/" extends="struts-default">
    
            <interceptors>
    
                <!-- 先定义拦截器 -->
                <interceptor name="myInterceptor" class="wjt.com.test.interceptor.MethodInterceptor">
                    <!-- 指定系统初始化给拦截器的参数 -->
                    <!-- <param name="hello">吴静涛</param> -->
                </interceptor>
    
                <!-- 加到自己设置的拦截器栈里边去 -->
                <interceptor-stack name="myStack">
                    <interceptor-ref name="myInterceptor"></interceptor-ref>
                    <interceptor-ref name="defaultStack"></interceptor-ref>
                </interceptor-stack>
    
            </interceptors>
    
            <!-- 改变系统默认的拦截器,改成自己的默认拦截器,并且一个系统只能有一个默认的拦截器,这样这个拦截器栈会默认应用到所有的Action上去 -->
            <default-interceptor-ref name="myStack" />
    
        </package>
    
    </struts>
    复制代码

    配置action实现类,若使对action实现类的请求经过自定义拦截器的处理,需要我们对其添加@ParentPackage("default"),该注解添加到action类名上方,作为action的第一注解存在。

    测试:

    到这里题目所属三项配置就完毕了,启动项目并请求action后截图如下所示表示配置成功:

     

    这里只给出简单配置,读者朋友最好还是在理解原理的前期下使用,本人还是刚毕业小白,对原理的理解还不够深,还没能达到陈述原理的水平,有不合理的地方还请大家指出。

    展开全文
  • Struts2拦截器介绍

    2016-12-05 11:08:00
    一、拦截器简介 Struts拦截器和Action的关系如图: 为了在使用拦截器时制定参数值,应通过<interceptor-ref …/>元素添加<param …/>子元素来为拦截器指定参数值。下面是配置拦截器动态指定参数值的语法...

    一、拦截器简介

    Struts拦截器和Action的关系如图:

    2016-12-05_10-05-48

    为了在使用拦截器时制定参数值,应通过<interceptor-ref …/>元素添加<param …/>子元素来为拦截器指定参数值。下面是配置拦截器动态指定参数值的语法。

      1: <interceptor-stack name="拦截器栈一">
    
      2:     <interceptor-ref name="拦截器一">
    
      3:         <param name="参数一">参数值一</param>
    
      4:         <param name="参数二">参数值二</param>
    
      5:     </interceptor-ref>
    
      6: </interceptor-stack>

    二、自定义拦截器

    1、简单的拦截器

        用户要开发自己的拦截器,需要实现com.opensymphony.xwork2.interceptor.Interceptor接口。下面实现了一个简单的拦截器

        1、SimpleInterceptor.java

      1: package cc.openhome;
    
      2: import java.util.Date;
    
      3: import com.opensymphony.xwork2.ActionInvocation;
    
      4: import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
    
      5: public class SimpleInterceptor extends AbstractInterceptor {
    
      6:   //简单的拦截器的名字
    
      7:   private String name;
    
      8:   //为该简单拦截器设置名字的setter方法
    
      9:   //拦截Action方法的intercept方法
    
     10:   @Override
    
     11:   public String intercept(ActionInvocation invocation) throws Exception {
    
     12:     // TODO Auto-generated method stub
    
     13:     //取得被拦截的Action实例
    
     14:     LoginAction action = (LoginAction) invocation.getAction();    
    
     15:     //打印
    
     16:     System.out.println("正在执行 ‘"+name+"’ 拦截器的动作========"+"开始执行登录的时间为:"+new Date());    
    
     17:     //取得开始执行Action的时间
    
     18:     long start = System.currentTimeMillis();    
    
     19:     //执行该拦截器的后一个拦截器,或者直接指定Action的execute()方法
    
     20:     String result = invocation.invoke();
    
     21:     System.out.println("正在执行 ‘"+name+" ’拦截器的动作========"+"执行完登录的时间为:"+new Date());  
    
     22:     //取得执行完Action的时间
    
     23:     long end = System.currentTimeMillis();
    
     24:     System.out.println("正在执行 ‘"+name+"’ 拦截器的动作========"+"Action执行了"+(end-start)+"毫秒");
    
     25:     return result;
    
     26:   }
    
     27:   public String getName() {
    
     28:     return name;
    
     29:   }
    
     30: 
    
     31:   public void setName(String name) {
    
     32:     this.name = name;
    
     33:   }
    
     34: }
    
     35: 

        2、struts.xml

      1: <?xml version="1.0" encoding="UTF-8" ?>
    
      2: <!DOCTYPE struts PUBLIC
    
      3:   "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    
      4:   "http://struts.apache.org/dtds/struts-2.3.dtd">
    
      5: <struts>   
    
      6:   <package name="struts2" extends="struts-default">    
    
      7:     <!-- 配置应用所使用的拦截器 -->    
    
      8:         <interceptors>
    
      9:           <!-- 配置mysimple拦截器 -->
    
     10:           <interceptor name="mysimple" class="cc.openhome.SimpleInterceptor">
    
     11:             <!-- 为该拦截器指定参数值 -->
    
     12:             <param name="name">简单拦截器</param>
    
     13:           </interceptor>    
    
     14:           <interceptor name="authority" class="cc.openhome.AuthorityInterceptor"/>
    
     15:         </interceptors>  
    
     16:         <action name="login" class="cc.openhome.LoginAction">          
    
     17:           <result name="success">/success.jsp</result>
    
     18:           <result name="error">/error.jsp</result>
    
     19:           <result name="input">/denglu.jsp</result>
    
     20:           <interceptor-ref name="defaultStack"/>
    
     21:           <interceptor-ref name="mySimple">
    
     22:               <param name="name">动态拦截器</param>
    
     23:           </interceptor-ref>
    
     24:         </action>
    
     25:     </package>
    
     26: </struts>

        3、登录页面login.jsp

      1: <%@ page language="java" contentType="text/html; charset=UTF-8"
    
      2:     pageEncoding="UTF-8"%>
    
      3: <%@ taglib prefix="s" uri="/struts-tags"%>
    
      4: <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    
      5: <html>
    
      6:   <head>
    
      7:     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    
      8:     <title>登录界面</title>
    
      9:   </head>
    
     10:   <body>
    
     11:     <s:form action="login">
    
     12:       <s:textfield name="username" label="用户名"/>
    
     13:       <s:textfield name="password" label="密    码"/>
    
     14:       <s:submit value="登录"/>
    
     15:     </s:form>
    
     16:   </body>
    
     17: </html>

        4、LoginAction.java

      1: package cc.openhome;
    
      2: import com.opensymphony.xwork2.Action;
    
      3: import com.opensymphony.xwork2.ModelDriven;
    
      4: public class LoginAction  implements Action{
    
      5:   private String username;
    
      6:   private String password;
    
      7:   public String getUsername() {
    
      8:     return username;
    
      9:   }
    
     10:   public void setUsername(String username) {
    
     11:     this.username = username;
    
     12:   }
    
     13:   public String getPassword() {
    
     14:     return password;
    
     15:   }
    
     16:   public void setPassword(String password) {
    
     17:     this.password = password;
    
     18:   }
    
     19:   @Override
    
     20:   public String execute() throws Exception {
    
     21:     // TODO Auto-generated method stub
    
     22:     return SUCCESS;
    
     23:   }
    
     24: }
    
     25: 

        5、运行结果

     

    2016-12-05_10-33-17

     

    2、拦截器的执行顺序

        修改struts.xml如下

      1: <?xml version="1.0" encoding="UTF-8" ?>
    
      2: <!DOCTYPE struts PUBLIC
    
      3:   "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    
      4:   "http://struts.apache.org/dtds/struts-2.3.dtd">
    
      5: <struts> 
    
      6:   <constant name="struts.custom.i18n.resources" value="messageResource"></constant>
    
      7:   <package name="openhome" extends="struts-default">
    
      8:     <!-- 配置应用所使用的拦截器 -->    
    
      9:         <interceptors>
    
     10:           <!-- 配置mysimple拦截器 -->
    
     11:           <interceptor name="mysimple" class="cc.openhome.SimpleInterceptor">
    
     12:             <!-- 为该拦截器指定参数值 -->
    
     13:             <param name="name">简单拦截器</param>
    
     14:           </interceptor>
    
     15:         </interceptors>      
    
     16:     <action name="login" class="cc.openhome.LoginAction" method="execute">
    
     17:       <result name="input">/input.jsp</result>
    
     18:       <result name="success">/WEB-INF/page/welcome.jsp</result>
    
     19:       <result name="error">/WEB-INF/page/error.jsp</result>
    
     20:       <interceptor-ref name="defaultStack" />
    
     21:       <interceptor-ref name="mysimple">
    
     22:         <param name="name">第一个动态拦截器</param>
    
     23:       </interceptor-ref>
    
     24:       <interceptor-ref name="mysimple">
    
     25:         <param name="name">第二个动态拦截器</param>
    
     26:       </interceptor-ref>      
    
     27:     </action>
    
     28:   </package>
    
     29:     <!-- Add packages here -->
    
     30: </struts>
    
     31:   

        运行结果如下:可以看到先配置的拦截器,先获得执行机会。

    2016-12-05_10-38-24

    3、方法拦截器

        如果不需要拦截特定的方法,假如不拦截execute方法,则在控制台上就不会输出任何信息。

        只需要修改提供方法过滤的拦截器

        MyFilterInterceptor.java

      1: package cc.openhome;
    
      2: import java.util.Date;
    
      3: import com.opensymphony.xwork2.ActionInvocation;
    
      4: import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;
    
      5: public class MyFilterInterceptor extends MethodFilterInterceptor {
    
      6:   private String name;  
    
      7:   public String getName() {
    
      8:     return name;
    
      9:   }
    
     10:   public void setName(String name) {
    
     11:     this.name = name;
    
     12:   }
    
     13:   @Override
    
     14:   protected String doIntercept(ActionInvocation invocation) throws Exception {
    
     15:     // TODO Auto-generated method stub
    
     16:     //取得被拦截的Action实例
    
     17:         LoginAction action = (LoginAction) invocation.getAction();
    
     18:         
    
     19:         //打印
    
     20:         System.out.println("正在执行 ‘"+name+"’ 拦截器的动作========"+"开始执行登录的时间为:"+new Date());
    
     21:         
    
     22:         //取得开始执行Action的时间
    
     23:         long start = System.currentTimeMillis();
    
     24:         
    
     25:         //执行该拦截器的后一个拦截器,或者直接指定Action的execute()方法
    
     26:         String result = invocation.invoke();
    
     27:         System.out.println("正在执行 ‘"+name+" ’拦截器的动作========"+"执行完登录的时间为:"+new Date());
    
     28:         
    
     29:         //取得执行完Action的时间
    
     30:         long end = System.currentTimeMillis();
    
     31:         System.out.println("正在执行 ‘"+name+"’ 拦截器的动作========"+"Action执行了"+(end-start)+"毫秒");
    
     32:         return result;
    
     33:   }
    
     34: }
    
     35: 

        struts.xml

      1: <?xml version="1.0" encoding="UTF-8" ?>
    
      2: <!DOCTYPE struts PUBLIC
    
      3:   "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    
      4:   "http://struts.apache.org/dtds/struts-2.3.dtd">
    
      5: <struts> 
    
      6:   <package name="openhome" extends="struts-default">
    
      7:     <!-- 配置应用所使用的拦截器 -->    
    
      8:         <interceptors>
    
      9:           <!-- 配置myfilter拦截器 -->
    
     10:           <interceptor name="myfilter" class="cc.openhome.MyFilterInterceptor">
    
     11:             <!-- 为该拦截器指定参数值 -->
    
     12:             <param name="name">方法过滤拦截器</param>
    
     13:           </interceptor>  
    
     14:           </interceptor>        
    
     15:           <interceptor name="authority" class="cc.openhome.AuthorityInterceptor"/>
    
     16:         </interceptors>      
    
     17:     <action name="login" class="cc.openhome.LoginAction" method="execute">
    
     18:       <result name="input">/input.jsp</result>
    
     19:       <result name="success">/WEB-INF/page/welcome.jsp</result>
    
     20:       <result name="error">/WEB-INF/page/error.jsp</result>
    
     21:       <interceptor-ref name="defaultStack" />
    
     22:       <interceptor-ref name="myfilter">
    
     23:         <param name="name">改名后的方法拦截器</param>
    
     24:         <param name="excludeMethods">execute</param>
    
     25:       </interceptor-ref>      
    
     26:     </action>
    
     27:   </package>  
    
     28:     <!-- Add packages here -->
    
     29: </struts>
    
     30:   

    3、拦截结果的监听器

            为了更精确的定义在execute方法执行前后的结构,以及执行后再处理Result执行的动作。这个监听器通过手动注册在拦截内部,必须实现PreReslutListener接口。  

        MyPreResultListener.java

      1: package cc.openhome;
    
      2: import com.opensymphony.xwork2.ActionInvocation;
    
      3: import com.opensymphony.xwork2.interceptor.PreResultListener;
    
      4: public class MyPreResultListener implements PreResultListener {
    
      5:   @Override
    
      6:   public void beforeResult(ActionInvocation invocation, String resultCode) {
    
      7:     // TODO Auto-generated method stub
    
      8:     System.out.println("返回的逻辑视图是:"+resultCode);
    
      9:   }
    
     10: }
    
     11: 

        BeforeResultInterceptor.java

      1: package cc.openhome;
    
      2: import com.opensymphony.xwork2.ActionInvocation;
    
      3: import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
    
      4: public class BeforeResultInterceptor extends AbstractInterceptor {  
    
      5:   @Override
    
      6:   public String intercept(ActionInvocation invocation) throws Exception {
    
      7:     // TODO Auto-generated method stub
    
      8:     //将一个拦截器结果的监听器注册给该拦截器
    
      9:     invocation.addPreResultListener(new MyPreResultListener());
    
     10:     System.out.println("execute方法执行之前的拦截。。。");    
    
     11:     //调用下一个拦截器,或者Action的执行方法execute()
    
     12:     String result = invocation.invoke();
    
     13:     System.out.println("execute方法执行之后的拦截。。。");
    
     14:     return result;
    
     15:   }  
    
     16: }
    
     17: 

        struts.xml

      1: <?xml version="1.0" encoding="UTF-8" ?>
    
      2: <!DOCTYPE struts PUBLIC
    
      3:   "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    
      4:   "http://struts.apache.org/dtds/struts-2.3.dtd">
    
      5: <struts> 
    
      6:   <constant name="struts.custom.i18n.resources" value="messageResource"></constant>
    
      7:   <package name="openhome" extends="struts-default">
    
      8:     <!-- 配置应用所使用的拦截器 -->    
    
      9:         <interceptors>       
    
     10:           <!-- 配置myresult拦截器 -->
    
     11:           <interceptor name="myresult" class="cc.openhome.BeforeResultInterceptor">
    
     12:             <!-- 为该拦截器指定参数值 -->
    
     13:             <param name="name">结果的拦截器</param>
    
     14:           </interceptor>    
    
     15:         </interceptors>      
    
     16:     <action name="login" class="cc.openhome.LoginAction" method="execute">
    
     17:       <result name="input">/input.jsp</result>
    
     18:       <result name="success">/WEB-INF/page/welcome.jsp</result>
    
     19:       <result name="error">/WEB-INF/page/error.jsp</result>
    
     20:       <interceptor-ref name="defaultStack" />
    
     21:       <interceptor-ref name="myresult">
    
     22:         <param name="name">结果拦截器</param>
    
     23:       </interceptor-ref>      
    
     24:     </action>
    
     25:     <!-- Add packages here -->
    
     26: </struts>
    
     27:   

        运行结果

    2016-12-05_10-56-33

    转载于:https://www.cnblogs.com/liuzhongfeng/p/6133144.html

    展开全文
  • 拦截器Struts2的一个重要的概念,Struts中有80%的功能都通过拦截器实现。 意义:完成更高层次的解耦,无须侵入框架本身即可添加新的功能。拦截器是AOP的一个实现,底层通过动态代理模式完成。 拦截器是Action的...

     

    2012/6/26 星期二 天气阴有雨

    今天详细讲解一下Struts中的拦截器的作用和用法。

    拦截器是Struts2的一个重要的概念,Struts中有80%的功能都通过拦截器实现。

    意义:完成更高层次的解耦,无须侵入框架本身即可添加新的功能。拦截器是AOP的一个实现,底层通过动态代理模式完成。

    拦截器是Action的拦截器,可以将一些重用功能放到拦截器中,降低Action的复杂性,提高代码的重用性。

    常用功能:封装请求参数,文件上传,异常处理等。这些都是默认的拦截器defaultStack为我们完成的工作,一旦为Action指定了相应的拦截器,则默认的拦截器不再起作用,如果需要它再起作用,则必须显示制定默认拦截器。

    拦截器继承AbstractInterceptor抽象类或者实现Interceptor接口类,重写方法。

    主要方法:String interccept(ActionInvocation invocation);执行拦截动作和处理事件。

    参数invocation包含了Action的引用,invocation.invoke()方法将控制权转给下一个拦截器或者调用的Action方法。返回值是逻辑视图。

    拦截器配置及使用:

    <interceptors>
    
    <interceptor name="timer" class=".."/>
    
    <interceptor name="logger" class=".."/>
    
    </interceptors>
    


     

    为了方便使用,我们可以配置拦截器栈,相当于多个拦截器的集合。

    <interceptor-stack name="myStack">
    
    <interceptor-ref name="timer"/>
    
    <interceptor-ref name="logger"/>
    
    </interceptor-stack>
    


     

    然后在Action中使用:

    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>
    


     

     

    展开全文
  • 1.新建项目,添加jar包到WEB-INF目录下的lib文件夹...2.新建web.xml,添加struts2核心过滤,和默认首页 1 <?xml version="1.0" encoding="UTF-8"?> 2 <web-app version="2.5" xmlns="http://java.s...

     

    1.新建项目,添加jar包到WEB-INF目录下的lib文件夹,并添加到builde path里面

    整体目录结构如下

    2.新建web.xml,添加struts2核心过滤器,和默认首页

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
     3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     4     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
     5     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
     6     <welcome-file-list>
     7         <welcome-file>main.jsp</welcome-file>
     8     </welcome-file-list>
     9 
    10     <filter>
    11         <filter-name>StrutsPrepareAndExecuteFilter</filter-name>
    12         <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    13     </filter>
    14 
    15     <filter-mapping>
    16         <filter-name>StrutsPrepareAndExecuteFilter</filter-name>
    17         <url-pattern>/*</url-pattern>
    18     </filter-mapping>
    19 
    20 </web-app>

     3. 新建一个User Javabean ,编写loginAction

    在   cn.test.domain  包下建User类

     1 package cn.test.domain;
     2 
     3 public class User {
     4     private String username;
     5     private String password;
     6 
     7     public String getUsername() {
     8         return username;
     9     }
    10 
    11     public void setUsername(String username) {
    12         this.username = username;
    13     }
    14 
    15     public String getPassword() {
    16         return password;
    17     }
    18 
    19     public void setPassword(String password) {
    20         this.password = password;
    21     }
    22 
    23     @Override
    24     public String toString() {
    25         return "User [password=" + password + ", username=" + username + "]";
    26     }
    27 
    28 }

    在  cn.test.action  包下 建 LoginActoin,模拟用户登陆,判断登陆用户是否为指定用户,不是,就返回逻辑视图名" input ",跳转到login.jsp 去让用户登陆

     1 package cn.test.action;
     2 
     3 import cn.test.domain.User;
     4 
     5 import com.opensymphony.xwork2.ActionContext;
     6 import com.opensymphony.xwork2.ActionSupport;
     7 import com.opensymphony.xwork2.ModelDriven;
     8 
     9 public class LoginActoin extends ActionSupport implements ModelDriven<User>{
    10 
    11     private static final long serialVersionUID = 1L;
    12     private User user = new User();  //必须要有该Javabean的实例
    13     @Override
    14     public User getModel() {
    15         return user;
    16     }
    17     @Override
    18     public String execute() throws Exception {
    19         // 获取ActionContext
    20         ActionContext context = ActionContext.getContext();
    21         if("admin".equals(user.getUsername())&& "123".equals(user.getPassword())){
    22             //把用户存储在session中
    23             context.getSession().put("user", user);
    24             return SUCCESS;
    25         }else {
    26             context.put("msg", "用户名密码不正确");
    27             return INPUT;
    28         }
    29         
    30     }
    31     
    32 
    33 }

    注:这里使用了struts2的模型驱动来获取请求参数值

      在 Struts2中, Action处理请求参数还有另外一种方式,叫做模型驱动( Modeldriven)。过实现 Modeldriven接口来接收请求参数, Action类必须实现 Modeldriven接口,引入JavaBea的实例 ,并且重写 get Model()方法,这个方法返回的就是 Action所使用的数据模型对象。

      模型驱动方式通过 Javabean模型进行数据传递。只要是普通的 Javabean,就可以充当模型部分。采用这种方式, Javabean所封装的属性与表单的属性一一对应, Javabean将成为数据传递的载体。使用模型驱动方式, Action类通过get*()的方法来获取模型,其中  *  代表具体的模型对象,代码如上LoginActoin 中背景颜色部分所示。

      使用模型驱动时,其登录页面 userlogin.jsp也要做相应调整。使用ModelDriver的方式,一个Action只能对应一个Model,因此不需要添加 user前缀,页面上的username对应到这个Model的username属性。属性驱动的方法和模刑驱动的方法各有优缺点,实际开发中,应根据不同情况来选择使用。

    4.在 cn.test.action 包下创建  BookAction ,写增删改查四个方法

     1 package cn.test.action;
     2 
     3 import com.opensymphony.xwork2.ActionSupport;
     4 
     5 public class BookAction extends ActionSupport {
     6 
     7     private static final long serialVersionUID = 1L;
     8     public String add(){
     9         System.out.println("book add");
    10         return SUCCESS;
    11     }
    12     public String del(){
    13         System.out.println("book del");
    14         return SUCCESS;
    15     }
    16     public String update(){
    17         System.out.println("book update");
    18         return SUCCESS;
    19     }
    20     public String find(){
    21         System.out.println("book find");
    22         return SUCCESS;
    23     }
    24 
    25 }

    5.在 cn.test.interceptor 包下创建自定义拦截器类PrivilegeInterceptor ,根据session中有无指定用户,进行权限控制

     1 package cn.test.interceptor;
     2 
     3 import com.opensymphony.xwork2.Action;
     4 import com.opensymphony.xwork2.ActionContext;
     5 import com.opensymphony.xwork2.ActionInvocation;
     6 import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
     7 
     8 /**
     9  * 自定义拦截器类,获取session中有无登陆用户,完成页面跳转的权限控制
    10  * 
    11  * @author Administrator
    12  * 
    13  */
    14 public class PrivilegeInterceptor extends AbstractInterceptor {
    15 
    16     private static final long serialVersionUID = 1L;
    17 
    18     @Override
    19     public String intercept(ActionInvocation invocation) throws Exception {
    20         // 获取actionContext
    21         ActionContext actionContext = invocation.getInvocationContext();
    22         // 获取session中的用户
    23         Object user = actionContext.getSession().get("user");
    24         if (null != user) {
    25             return invocation.invoke(); // 继续向下执行
    26         } else {
    27             actionContext.put("msg", "对不起,您还未登陆!");
    28             return Action.LOGIN; // 返回逻辑视图名"login",由对应的result配置,跳转到登陆页面
    29         }
    30     }
    31 
    32 }

    6.在webcontent目录下创建4个视图页面:主页main.jsp  ,登陆页login.jsp ,操作成功页success.jsp , 404错误页error.jsp

    (1)main.jsp  定义增删改查4个链接,请求路径中action的命名按照  book_* 的方式命名,方便struts里面配置Action的动态调用

     1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
     2 <%
     3 String path = request.getContextPath();
     4 String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
     5 %>
     6 
     7 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
     8 <html>
     9   <head>
    10     <base href="<%=basePath%>">
    11     <title>main.jsp</title>
    12   </head>
    13   
    14   <body>
    15    <a href="<%=basePath%>book_add">bookAdd</a> <br>
    16    <a href="<%=basePath%>book_del">bookDel</a> <br>
    17    <a href="<%=basePath%>book_update">bookUpdate</a> <br>
    18    <a href="<%=basePath%>book_find">bookFind</a> <br>
    19   </body>
    20 </html>

    (2),登陆页login.jsp 

     1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
     2 <%
     3     String path = request.getContextPath();
     4     String basePath = request.getScheme() + "://"
     5             + request.getServerName() + ":" + request.getServerPort()
     6             + path + "/";
     7 %>
     8 
     9 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    10 <html>
    11     <head>
    12         <base href="<%=basePath%>">
    13         <title>登陆</title>
    14     </head>
    15     <body>
    16         ${requestScope.msg }
    17         <br>
    18         <form action="<%=basePath%>login.action" method="post">
    19             <table>
    20                 <tr>
    21                     <td><label style="text-align:right;">用户名:</label></td>
    22                     <td><input type="text" name="username"/></td>
    23                 </tr>
    24                 <tr>
    25                     <td><label style="text-align:right;">密码:</label></td>
    26                     <td><input type="password" name="password"/></td>
    27                 </tr>
    28                 <tr >
    29                     <td colspan="2" align="right"><input type="submit" value="登陆"/></td>
    30                 </tr>
    31             </table>
    32         </form>
    33     </body>
    34 </html>

    (3)操作成功页success.jsp 

     1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
     2 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
     3 <html>
     4   <head>
     5     <title>success.jsp</title>
     6    </head>
     7   
     8   <body>
     9   用户${user.username }操作成功!
    10    </body>
    11 </html>

    (4)   404错误页error.jsp

     1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
     2 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
     3 <html>
     4   <head>
     5     <title>error page</title>
     6    </head>
     7   
     8   <body>
     9                您访问的页面不存在<br>
    10   </body>
    11 </html>

    7.配置struts。xml,声明自定义拦截器,拦截器栈以及对book操作的action,和处理404错误的action

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <!DOCTYPE struts PUBLIC
     3     "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
     4     "http://struts.apache.org/dtds/struts-2.3.dtd">
     5 <struts>
     6     
     7     <package name="intercepter" namespace="/" extends="struts-default">
     8         <!-- 声明拦截器 -->
     9         <interceptors>
    10             <interceptor name="privilege" class="cn.test.interceptor.PrivilegeInterceptor"></interceptor> <!--自定义拦截器-->
    11             <!-- 自定义拦截器栈,放入自定义的拦截器和struts的默认拦截器 -->
    12             <interceptor-stack name="myStack">
    13                 <interceptor-ref name="privilege"></interceptor-ref>
    14                 <interceptor-ref name="defaultStack"></interceptor-ref>
    15             </interceptor-stack>
    16         </interceptors>
    17         
    18         <!-- 默认的 Action配置要放在拦截器配置的后面 -->
    19         <default-action-ref name="defaultAction"></default-action-ref>
    20         
    21         <!-- 用户登陆操作   action里面不写方法名,默认之心execute()方法!!!-->
    22         <action name="login" class="cn.test.action.LoginActoin" >
    23             <result>/main.jsp</result>
    24             <result name="input">/login.jsp</result>
    25         </action>
    26         <!-- book操作action -->
    27         <action name="book_*" class="cn.test.action.BookAction" method="{1}">
    28             <result name="success">/success.jsp</result>
    29             <result name="login">/login.jsp</result>
    30             <!-- 在action中使用自定义拦截器,对book操作的actoin进行权限控制 
    31             放在哪个action,就对那个action进行权限控制的拦截-->
    32             <interceptor-ref name="myStack"></interceptor-ref>
    33         </action>
    34         
    35         <!-- 注意,package元素里面的子元素是有顺序要求的,如果写错位置,启动时会报错,一般把action写在最后面 -->
    36         <action name="defaultAction">
    37             <result>/error.jsp</result>
    38         </action>
    39     </package>
    40 
    41 </struts>

    book操作action类中只返回了一个success作为result 的name属性值, 下面action中配置的    <result name="login">/login.jsp</result> ,这个result是拦截器用的,当拦截器检测到用户没有登陆时,就返回“login”这个逻辑视图名;

    关于动态调用,action 的method={1},表示 method属性值取 action的name属性的值里边的第一个*的值。如果请求里是book_add 那么method 就是add,则执行Action中的add方法。

    <!-- book操作action -->
            <action name="book_*" class="cn.test.action.BookAction" method="{1}">
                <result name="success">/success.jsp</result>
                <result name="login">/login.jsp</result>
                <interceptor-ref name="myStack"></interceptor-ref>   <!--调用拦截器栈 -->
            </action>

    8. 部署并测试

    (1)访问http://localhost:8080/strutsstu4-2/  自动跳转到main.jsp 

    (2)随便点击一个链接,比如update ,提示还未登陆,红框里面的提示消息是 PrivilegeInterceptor 拦截器类中返回的 ,说明拦截器工作了。

    (3)输入错误用户名密码测试,提示用户名密码不正确,同时,页面跳转到了登陆页,可以看到浏览器中的地址成了login.action,

      

    (4)输入admin 123登陆     

       

     可以在main.jsp中加入 当前登陆用户:${username } <br/> ,效果会看的更明显

    点击bookFind,可以看到浏览器地址发生变化,请求book_find这个action 

     

    (5) 请求一个不存在的actoin: 

    遇到的问题:添加默认的 Action配置时,给放在了拦截器配置的前面,导致启动时报错,提示信息如下:

    Caused by: 元素类型为 "package" 的内容必须匹配 "(result-types?,interceptors?,default-interceptor-ref?,default-action-ref?,default-class-ref?,global-results?,global-exception-mappings?,action*)"。 - file:/D:/Tomcat/apache-tomcat-6.0.30/webapps/strutsstu4-2/WEB-INF/classes/struts.xml:42:12

     其实括号里面的红字部分就已经提示了package中各个元素要遵从的顺序,可以看到,default-action-ref是在default-interceptor-ref?的后面,也就是说默认Action应该配置在拦截器后面

     

    示例代码下载地址  https://github.com/liuch0228/Struts2SSH.git

     

    转载于:https://www.cnblogs.com/enjoyjava/p/8997959.html

    展开全文
  • Struts2框架的大多数核心功能都是作为拦截器来实现的。 例如为action动态添加 输入验证(验证用户输入的是否正确) 对象组装(将用户输入的数据转换为对象的属性) 权限控制(如访问者为登录用户) 日志记录...
  • struts2多文件上传

    2011-12-22 13:38:29
    动态添加文本框,可以一次性上传多个文件,使用struts2拦截器对上传文件的类型进行过滤
  • 4.3 研究内建的Struts 2拦截器 67 4.3.1 工具拦截器 67 4.3.2 数据转移拦截器 67 4.3.3 工作流拦截器 69 4.3.4 其他拦截器 72 4.3.5 内建的拦截器栈 73 4.4 声明拦截器 74 4.4.1 声明独立的拦截器和拦截器栈 74 ...
  • cxf 拦截器

    2013-10-20 18:42:20
    你可以在不对核心模块进行修改的情况下,动态添加很多功能(你可以想象Struts2拦截器的优点)。这对于CXF这个以处理消息为中心的服务框架来说是非常有用的,CXF通过在Interceptor中对消息进行特殊处理,实现了很多...
  • 两个目标场景 同一业务逻辑 只是展现页面不同(如标清 高清) 目前的线上程序均是只支持场景1:标清 ...同时添加拦截器 return invocation.invoke()+"_"+epgCode 且struts配置文件修改为 &...
  • struts2 详解文档

    2014-09-26 12:34:57
    自定义拦截器 对Action中所有方法进行输入校验 对Action指定方法进行校验 输入校验的流程 基于XML配置方式实现对action的所有方法进行校验 基于XML配置方式实现对指定action方法校验 配置国际化全局资源文件、...
  • Struts2 in action中文版

    2015-09-23 11:30:12
    4.3 研究内建的Struts 2拦截器 67 4.3.1 工具拦截器 67 4.3.2 数据转移拦截器 67 4.3.3 工作流拦截器 69 4.3.4 其他拦截器 72 4.3.5 内建的拦截器栈 73 4.4 声明拦截器 74 4.4.1 声明独立的拦截器和拦截器栈 74 ...
  • CXF自定义拦截器实现权限控制

    千次阅读 2014-06-08 00:20:04
    在我们学习Java的征途中碰到了很多拦截器: Servlet中的Filter就是一个拦截器, Struts2中也有拦截器,. CXF中的拦截器其基本原理还是使用动态代理, 我们可以在不对核心模块进行修改的情况下, 动态添加一些功能, 从而...
  • 一、使用反射动态添加权限 在该系统中,我使用struts2的时候非常规范,访问的Action的形式都是"ActionClassName_MethodName.action?参数列表",所以可以非常方便的使用反射初始化权限表。 比较关键的是获取所有...
  • 你可以在不对核心模块进行修改的情况下,动态添加很多功能(你可以想象Struts2拦截器的优点)。这对于CXF这个以处理消息为中心的服务框架来说是非常有用的,CXF通过在Interceptor中对消息进行特殊处理,实现了很多...
  • Struts2 学习笔记

    2010-11-30 16:47:46
    01 Struts2-Action 5 一、 Struts作用: 5 二、 搭建Struts2的运行环境: 5 三、 Namespace 6 四、 标签 6 五、 Action 6 六、 路径问题的说明 8 ...09 自定义拦截器 38 10 类型转换 38 Struts2总结 39
  • 研磨Struts2 的480页高清完整pdf

    热门讨论 2012-11-23 01:58:41
    2.2.4 下载Struts2以及认识Struts2包结构 2.3 从Servlet+JSP+JavaBean实现MVC开始 2.3.1 起点概述 2.3.2 建立动态的Web工程 2.3.3 配置工程运行环境 2.3.4 编写JavaBean 2.3.5 编写Servlet 2.3.6 配置web.xml 2.3.7 ...
  • 你可以在不对核心模块进行修改的情况下,动态添加很多功能(你可以想象Struts2拦截器的优点)。这对于CXF这个以处理消息为中心的服务框架来说是非常有用的,CXF通过在Interceptor中对消息进行特殊处理,实现了很多...
  •  10.3 struts 2自带的拦截器  10.4 配置拦截器  10.5 preresultlistener接口  10.6 开发执行安全验证的拦截器  10.7 使用拦截器注解  10.8 小结 第11章 类型转换  11.1 传统的数据处理过程  11.2 struts 2对...
  • 你可以在不对核心模块进行修改的情况下,动态添加很多功能(你可以想象Struts2拦截器的优点)。这对于CXF这个以处理消息为中心的服务框架来说是非常有用的,CXF通过在Interceptor中对消息进行特殊处理,实现了很多...
  • Struts2 环境搭建步骤: 1)新建动态Web工程 2)去Struts2的DEMO中找到blank工程,将lib包下的jar全部复制...3)配置web.xml,实现过滤器拦截,找到blank工程下的web.xml文件 4)添加Struts.xml配置文件 5)配置dtd提示
  •  10.3 struts 2自带的拦截器  10.4 配置拦截器  10.5 preresultlistener接口  10.6 开发执行安全验证的拦截器  10.7 使用拦截器注解  10.8 小结 第11章 类型转换  11.1 传统的数据处理过程  11.2 struts 2对...
  •  10.3 struts 2自带的拦截器  10.4 配置拦截器  10.5 preresultlistener接口  10.6 开发执行安全验证的拦截器  10.7 使用拦截器注解  10.8 小结 第11章 类型转换  11.1 传统的数据处理过程  11.2 struts 2对...
  •  10.3 struts 2自带的拦截器  10.4 配置拦截器  10.5 preresultlistener接口  10.6 开发执行安全验证的拦截器  10.7 使用拦截器注解  10.8 小结 第11章 类型转换  11.1 传统的数据处理过程  11.2 struts 2对...
  •  10.3 struts 2自带的拦截器  10.4 配置拦截器  10.5 preresultlistener接口  10.6 开发执行安全验证的拦截器  10.7 使用拦截器注解  10.8 小结 第11章 类型转换  11.1 传统的数据处理过程  11.2 struts 2对...
  •  10.3 struts 2自带的拦截器  10.4 配置拦截器  10.5 preresultlistener接口  10.6 开发执行安全验证的拦截器  10.7 使用拦截器注解  10.8 小结 第11章 类型转换  11.1 传统的数据处理过程  11.2 struts 2对...
  •  10.3 struts 2自带的拦截器  10.4 配置拦截器  10.5 preresultlistener接口  10.6 开发执行安全验证的拦截器  10.7 使用拦截器注解  10.8 小结 第11章 类型转换  11.1 传统的数据处理过程  11.2 struts 2对...

空空如也

空空如也

1 2 3
收藏数 58
精华内容 23
关键字:

动态添加struts2拦截器