zoukankan html css js c++ java

信步漫谈之Struts2—拦截器

主要介绍Struts2的拦截器，结合实例说明。

代码结构：

关键代码：

LoginCheckInterceptor.javapackage com.alfred.interceptor;

import com.alfred.login.action.LoginAction;
import com.alfred.regist.action.RegistAction;
import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;

public class LoginCheckInterceptor extends MethodFilterInterceptor {

	@Override
	protected String doIntercept(ActionInvocation invocation) throws Exception {
		System.out.println("LoginCheckInterceptor doIntercept begin");
		String ret = null;
		if (LoginAction.class == invocation.getAction().getClass()
				|| RegistAction.class == invocation.getAction().getClass()) {
			ret = invocation.invoke();
		} else {
			Object obj = invocation.getInvocationContext().getSession().get(
					"user");
			if (obj != null) {
				ret = invocation.invoke();
			} else {
				return Action.LOGIN;
			}
		}
		System.out.println("LoginCheckInterceptor doIntercept end");
		return ret;
	}

}

MapParametersInterceptor.javapackage com.alfred.interceptor;

import java.util.Map;
import java.util.TreeMap;

import com.opensymphony.xwork2.interceptor.ParametersInterceptor;
import com.opensymphony.xwork2.util.ValueStack;

public class MapParametersInterceptor extends ParametersInterceptor {

	protected void setParameters(final Object action, ValueStack stack,
			final Map<String, Object> parameters) {
		System.out.println("MapParametersInterceptor setParameters begin");
		Map<String, Object> params;
		params = new TreeMap<String, Object>(parameters);

		for (Map.Entry<String, Object> entry : params.entrySet()) {
			String name = entry.getKey().toString();
			if (!name.contains(".")) {
				name = "map." + name;
			}
			Object value = entry.getValue();
			if (isAcceptableParameter(name, action) && isAcceptableValue(value)) {
				if (value != null) {
					Object[] tmp = (Object[]) value;
					if (tmp.length == 1) {
						value = tmp[0];
						if (value != null
								&& value.toString().trim().length() > 0) {
							if (value instanceof String) {
								value = value.toString().trim();
							}
							stack.setValue(name, value);
							// stack.setParameter(name, value);
						}
					} else {
						StringBuffer sb = new StringBuffer();
						for (int x = 0; x < tmp.length; x++) {
							value = tmp[x];
							if (value != null
									&& value.toString().trim().length() > 0) {
								sb.append(value).append(",");
							}
						}
						if (sb.length() > 0) {
							sb = sb.delete(sb.length() - 1, sb.length());
						}
						stack.setValue(name, sb.toString());
					}
				}
			}
		}
		System.out.println("MapParametersInterceptor setParameters end");

	}

}

TimeInterceptor.javapackage com.alfred.interceptor;

import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.Interceptor;

public class TimeInterceptor implements Interceptor {

	public void destroy() {
		System.out.println("timeInterceptor destroy");
	}

	public void init() {
		System.out.println("timeInterceptor init");
	}

	public String intercept(ActionInvocation invocation) throws Exception {
		long begin = System.currentTimeMillis();
		System.out.println("TimeInterceptor intercept begin:" + begin);
		System.out.println("TimeInterceptor:"
				+ invocation.getAction().getClass() + ":"
				+ invocation.getProxy().getMethod());
		// 调用下一步
		String ret = invocation.invoke();
		long end = System.currentTimeMillis();
		long interval = end - begin;
		System.out.println("TimeInterceptor intercept end:" + end
				+ "	interval:" + interval);
		return ret;
	}

}

LoginAction.javapackage com.alfred.login.action;

import java.util.HashMap;
import java.util.Map;

import com.alfred.user.bean.User;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;

public class LoginAction extends ActionSupport {

	private Map<Object, Object> map = new HashMap<Object, Object>();

	public String loginAction() {
		System.out.println("LoginAction loginAction");
		map.put("type", "login");
		String username = map.containsKey("username") ? map.get("username")
				.toString() : "null";
		String password = map.containsKey("password") ? map.get("password")
				.toString() : "null";
		System.out.println("username:" + username);
		System.out.println("password:" + password);
		if (username.equals("admin")) {
			User user = new User();
			user.setUsername(username);
			user.setPassword(password);
			// 存入session
			ActionContext.getContext().getSession().put("user", user);
			return SUCCESS;
		} else {
			return LOGIN;
		}
	}

	public Map<Object, Object> getMap() {
		return map;
	}

	public void setMap(Map<Object, Object> map) {
		this.map = map;
	}

}

RegistAction.javapackage com.alfred.regist.action;

import java.util.HashMap;
import java.util.Map;

import com.alfred.user.bean.User;
import com.opensymphony.xwork2.ActionSupport;

public class RegistAction extends ActionSupport {

	private Map<Object, Object> map = new HashMap<Object, Object>();

	private User user;

	public String registAction() {
		System.out.println("RegistAction registAction");
		map.put("type", "regist");
		return SUCCESS;
	}

	public Map<Object, Object> getMap() {
		return map;
	}

	public void setMap(Map<Object, Object> map) {
		this.map = map;
	}

	public User getUser() {
		return user;
	}

	public void setUser(User user) {
		this.user = user;
	}

}

UserAction.javapackage com.alfred.user.action;

import java.util.HashMap;
import java.util.Map;

import com.alfred.user.bean.User;
import com.opensymphony.xwork2.ActionSupport;

public class UserAction extends ActionSupport {

	private Map<Object, Object> map = new HashMap<Object, Object>();

	private User user = new User();

	@Override
	public String execute() throws Exception {
		System.out.println("UserAction execute");
		map.put("username", user.getUsername());
		map.put("password", user.getPassword());
		return SUCCESS;
	}

	public Map<Object, Object> getMap() {
		return map;
	}

	public void setMap(Map<Object, Object> map) {
		this.map = map;
	}

	public User getUser() {
		return user;
	}

	public void setUser(User user) {
		this.user = user;
	}

}

User.javapackage com.alfred.user.bean;

public class User {
	private String username;
	private String password;

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

}

main.jsp<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
	<head>
	</head>
	<body>
		type:<s:property value="map.type" /><br />
		<s:if test="map.type == 'login'">
			username:<s:property value="map.username" /><br />
			password:<s:property value="map.password" />
		</s:if>
		<s:elseif test="map.type == 'regist'">
			username:<s:property value="user.username" /><br />
			password:<s:property value="user.password" />
		</s:elseif>
		<s:else>
			you are error
		</s:else>

	</body>
</html>

login.jsp<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
	<head>
	</head>
	<body>
		login<br />
		<s:form action="login">
			<s:textfield name="username" label="username"></s:textfield>
			<s:password name="password" label="password"></s:password>
			<s:token></s:token>
			<s:submit value="submit"></s:submit>
		</s:form>
		<s:debug></s:debug>
	</body>
</html>

regist.jsp<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
	<head>
	</head>
	<body>
		regist<br />
		<s:form action="regist">
			<s:textfield name="user.username" label="username"></s:textfield>
			<s:password name="user.password" label="password"></s:password>
			<s:submit value="submit"></s:submit>
		</s:form>
	</body>
</html>

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">
<struts>
	<package name="system" extends="struts-default">
		<interceptors>
			<!-- 拦截器定义 -->
			<interceptor name="TimeInterceptor" class="com.alfred.interceptor.TimeInterceptor" />
			<interceptor name="MapParametersInterceptor" class="com.alfred.interceptor.MapParametersInterceptor" />
			<interceptor name="LoginCheckInterceptor" class="com.alfred.interceptor.LoginCheckInterceptor" />
			<!-- 拦截器栈定义 -->
			<interceptor-stack name="myDefaultStack">
				<interceptor-ref name="TimeInterceptor"></interceptor-ref>
				<interceptor-ref name="MapParametersInterceptor"></interceptor-ref>
				<!-- 判断是否已登录 -->
				<interceptor-ref name="LoginCheckInterceptor">
					<!-- 允许执行的方法 如下只有execute这个方法允许调用该拦截器
					<param name="includeMethods">execute</param> -->
					<!-- 不允许执行的方法 如果有和includeMethods相同的,以includeMethods为主
					<param name="excludeMethods">loginAction,registAction</param> -->
				</interceptor-ref>
			</interceptor-stack>
		</interceptors>
		<!-- 默认拦截器,在action没有加拦截器的情况下,默认加入 -->
		<default-interceptor-ref name="myDefaultStack"></default-interceptor-ref>
		<!-- 全局result配置,会加入各个action -->
		<global-results>
			<result name="login">login.jsp</result>
			<result name="input">WEB-INF/jsp/error.jsp</result>
		</global-results>
		<action name="login"
			class="com.alfred.login.action.LoginAction" method="loginAction">
			<result name="success" type="redirectAction">
				<param name="actionName">user</param>
				<param name="type">${map.type}</param>
				<param name="user.username">${map.username}</param>
				<param name="user.password">${map.password}</param>
			</result>
			<!-- session加入token,避免重复提交
			<interceptor-ref name="token"></interceptor-ref>
			 -->
		</action>
		<action name="regist" class="com.alfred.regist.action.RegistAction" method="registAction">
			<result name="success">WEB-INF/jsp/main.jsp</result>
		</action>
		<action name="user" class="com.alfred.user.action.UserAction">
			<result name="success">WEB-INF/jsp/main.jsp</result>
		</action>
	</package>
</struts>

实例程序中定义了三个拦截器：TimeInterceptor、MapParametersInterceptor、LoginCheckInterceptor，分别是时间捕捉、Map传值、登陆验证功能。

TimeInterceptor实现了Interceptor接口，该接口是Struts2中拦截器的祖先，所有拦截器的最终实现。该接口有三个方法，分别是init、destory、intercept，分别是初始化时执行、销毁时执行、以及具体的拦截操作。同时，Struts2中还定义了一个抽象类AbstractInterceptor，该类实现了Interceptor接口，并空实现了init和destory方法，所以我们也可以直接通过继承AbstractInterceptor类来自定义拦截器（好处是不用实现init和destory方法，和实现Interceptor接口的区别也就在此，实际上这两个方法一般不会去使用）

LoginCheckInterceptor继承自抽象类MethodFilterInterceptor，MethodFilterInterceptor类在AbstractInterceptor的基础上添加了方法过滤，所谓的方法过滤就是允许我们指定哪些action方法要进行拦截处理，哪些action方法不进行action拦截处理，分别定义在excludeMethods（不拦截）和includeMethods（要拦截）中。以下是相关的源码，可以看到MethodFilterInterceptor在intercept实现里添加了一层判断applyInterceptor，用于判断是否执行拦截。也因此继承自MethodFilterInterceptor的子类一般不去实现intercept方法，而是实现MethodFilterInterceptor提供的doIntercept方法（应为如果不实现doIntercept而直接实现intercept，那就等于没继承MethodFilterInterceptor）

MethodFilterInterceptor.java/**
 * <!-- START SNIPPET: javadoc -->
 * 
 * MethodFilterInterceptor is an abstract <code>Interceptor</code> used as
 * a base class for interceptors that will filter execution based on method 
 * names according to specified included/excluded method lists.
 * 
 * <p/>
 * 
 * Settable parameters are as follows:
 * 
 * <ul>
 * 		<li>excludeMethods - method names to be excluded from interceptor processing</li>
 * 		<li>includeMethods - method names to be included in interceptor processing</li>
 * </ul>
 * 
 * <p/>
 * 
 * <b>NOTE:</b> If method name are available in both includeMethods and 
 * excludeMethods, it will be considered as an included method: 
 * includeMethods takes precedence over excludeMethods.
 * 
 * <p/>
 * 
 * Interceptors that extends this capability include:
 * 
 * <ul>
 *    <li>TokenInterceptor</li>
 *    <li>TokenSessionStoreInterceptor</li>
 *    <li>DefaultWorkflowInterceptor</li>
 *    <li>ValidationInterceptor</li>
 * </ul>
 * 
 * <!-- END SNIPPET: javadoc -->
 * 
 * @author <a href='mailto:the_mindstorm[at]evolva[dot]ro'>Alexandru Popescu</a>
 * @author Rainer Hermanns
 * 
 * @see org.apache.struts2.interceptor.TokenInterceptor
 * @see org.apache.struts2.interceptor.TokenSessionStoreInterceptor
 * @see com.opensymphony.xwork2.interceptor.DefaultWorkflowInterceptor
 * @see com.opensymphony.xwork2.validator.ValidationInterceptor
 * 
 * @version $Date$ $Id$
 */
public abstract class MethodFilterInterceptor extends AbstractInterceptor {
    protected transient Logger log = LoggerFactory.getLogger(getClass());
    
    protected Set<String> excludeMethods = Collections.emptySet();
    protected Set<String> includeMethods = Collections.emptySet();

    public void setExcludeMethods(String excludeMethods) {
        this.excludeMethods = TextParseUtil.commaDelimitedStringToSet(excludeMethods);
    }
    
    public Set<String> getExcludeMethodsSet() {
    	return excludeMethods;
    }

    public void setIncludeMethods(String includeMethods) {
        this.includeMethods = TextParseUtil.commaDelimitedStringToSet(includeMethods);
    }
    
    public Set<String> getIncludeMethodsSet() {
    	return includeMethods;
    }

    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        if (applyInterceptor(invocation)) {
            return doIntercept(invocation);
        } 
        return invocation.invoke();
    }

    protected boolean applyInterceptor(ActionInvocation invocation) {
        String method = invocation.getProxy().getMethod();
        // ValidationInterceptor
        boolean applyMethod = MethodFilterInterceptorUtil.applyMethod(excludeMethods, includeMethods, method);
        if (log.isDebugEnabled()) {
        	if (!applyMethod) {
        		log.debug("Skipping Interceptor... Method [" + method + "] found in exclude list.");
        	}
        }
        return applyMethod;
    }
    
    /**
     * Subclasses must override to implement the interceptor logic.
     * 
     * @param invocation the action invocation
     * @return the result of invocation
     * @throws Exception
     */
    protected abstract String doIntercept(ActionInvocation invocation) throws Exception;
    
}

MethodFilterInterceptorUtil.java/**
 * Utility class contains common methods used by 
 * {@link com.opensymphony.xwork2.interceptor.MethodFilterInterceptor}.
 * 
 * @author tm_jee
 */
public class MethodFilterInterceptorUtil {

	/**
     * Static method to decide if the specified <code>method</code> should be
     * apply (not filtered) depending on the set of <code>excludeMethods</code> and 
     * <code>includeMethods</code>. 
     *
     * <ul>
     * <li>
     * 	<code>includeMethods</code> takes precedence over <code>excludeMethods</code>
     * </li>
     * </ul>
     * <b>Note:</b> Supports wildcard listings in includeMethods/excludeMethods
     *
     * @param excludeMethods  list of methods to exclude.
     * @param includeMethods  list of methods to include.
     * @param method the specified method to check
     * @return <tt>true</tt> if the method should be applied.
     */
    public static boolean applyMethod(Set<String> excludeMethods, Set<String> includeMethods, String method) {
        
        // quick check to see if any actual pattern matching is needed
        boolean needsPatternMatch = false;
        for (String includeMethod : includeMethods) {
            if (!"*".equals(includeMethod) && includeMethod.contains("*")) {
                needsPatternMatch = true;
                break;
            }
        }
        
        for (String excludeMethod : excludeMethods) {
            if (!"*".equals(excludeMethod) && excludeMethod.contains("*")) {
                needsPatternMatch = true;
                break;
            }
        }

        // this section will try to honor the original logic, while 
        // still allowing for wildcards later
        if (!needsPatternMatch && (includeMethods.contains("*") || includeMethods.size() == 0) ) {
            if (excludeMethods != null 
                    && excludeMethods.contains(method) 
                    && !includeMethods.contains(method) ) {
                return false;
            }
        }
        
        // test the methods using pattern matching
        WildcardHelper wildcard = new WildcardHelper();
        String methodCopy ;
        if (method == null ) { // no method specified
            methodCopy = "";
        }
        else {
            methodCopy = new String(method);
        }
        for (String pattern : includeMethods) {
            if (pattern.contains("*")) {
                int[] compiledPattern = wildcard.compilePattern(pattern);
                HashMap<String,String> matchedPatterns = new HashMap<String, String>();
                boolean matches = wildcard.match(matchedPatterns, methodCopy, compiledPattern);
                if (matches) {
                    return true; // run it, includeMethods takes precedence
                }
            }
            else {
                if (pattern.equals(methodCopy)) {
                    return true; // run it, includeMethods takes precedence
                }
            }
        }
        if (excludeMethods.contains("*") ) {
            return false;
        }

        // CHECK ME: Previous implementation used include method 
        for ( String pattern : excludeMethods) {
            if (pattern.contains("*")) {
                int[] compiledPattern = wildcard.compilePattern(pattern);
                HashMap<String,String> matchedPatterns = new HashMap<String, String>();
                boolean matches = wildcard.match(matchedPatterns, methodCopy, compiledPattern);
                if (matches) {
                    // if found, and wasn't included earlier, don't run it
                    return false; 
                }
            }
            else {
                if (pattern.equals(methodCopy)) {
                    // if found, and wasn't included earlier, don't run it
                    return false; 
                }
            }
        }
    

        // default fall-back from before changes
        return includeMethods.size() == 0 || includeMethods.contains(method) || includeMethods.contains("*");
    }
    
    /**
     * Same as {@link #applyMethod(Set, Set, String)}, except that <code>excludeMethods</code>
     * and <code>includeMethods</code> are supplied as comma separated string.
     * 
     * @param excludeMethods  comma seperated string of methods to exclude.
     * @param includeMethods  comma seperated string of methods to include.
     * @param method the specified method to check
     * @return <tt>true</tt> if the method should be applied.
     */
    public static boolean applyMethod(String excludeMethods, String includeMethods, String method) {
    	Set<String> includeMethodsSet = TextParseUtil.commaDelimitedStringToSet(includeMethods == null? "" : includeMethods);
    	Set<String> excludeMethodsSet = TextParseUtil.commaDelimitedStringToSet(excludeMethods == null? "" : excludeMethods);
    	
    	return applyMethod(excludeMethodsSet, includeMethodsSet, method);
    }

}

MapParametersInterceptor继承自ParametersInterceptor类，ParametersInterceptor主要功能是实现参数过滤处理，他继承自MethodFilterInterceptor类，可以定义拦截判断参数名长度，参数格式。。。，我们通过继承ParametersInterceptor实现对参数的操作，MapParametersInterceptor重载了setParameters方法，实现的功能是将不是对象的参数（例如：user.username）存放至map中（例如：username->map.username），从而在传递非对象参数时不用在Action中定义大量的属性，而是只需要定义一个map，所有的传递参数都可以从map中获取。

拦截器最关键的方法就是intercept或doIntercept，这是实现具体拦截操作的位置，该方法一个类型为ActionInvocation的参数，通过这个参数我们可以获取到ActionContext对象、调用的Action类名、调用的Action方法等等，方便我们在拦截器中对被拦截Action的判断以及操作。

//获取拦截Action类名
Class<?> cls = invocation.getAction().getClass();
//获取拦截Action方法名
String method = invocation.getProxy().getMethod();
//获取ActionContext
ActionContext actionContext = invocation.getInvocationContext();

拦截器在struts.xml中的定义

拦截器定义在interceptors标签中，定义拦截器名称和拦截器类：

<interceptor name="TimeInterceptor" class="com.alfred.interceptor.TimeInterceptor" />

拦截器栈定义在interceptors标签中，栈内包含有一系列的拦截器引用，之后加载拦截器栈就可以一次性加载该栈内的所有拦截器：

<interceptor-stack name="myDefaultStack">
    <interceptor-ref name="TimeInterceptor"></interceptor-ref>
    <interceptor-ref name="MapParametersInterceptor"></interceptor-ref>
    <!-- 判断是否已登录 -->
    <interceptor-ref name="LoginCheckInterceptor">
        <!-- 允许执行的方法 如下只有execute这个方法允许调用该拦截器
        <param name="includeMethods">execute</param> -->
        <!-- 不允许执行的方法 如果有和includeMethods相同的,以includeMethods为主
        <param name="excludeMethods">loginAction,registAction</param> -->
    </interceptor-ref>
</interceptor-stack>

默认拦截器定义在package下，所谓默认拦截器，就是action在没有加载拦截器的情况下，默认加载的拦截器，通过查看struts-default.xml配置，我们可以看到struts为我们定义的默认拦截器是defaultStack，默认拦截器栈。

<interceptor-stack name="defaultStack">
    <interceptor-ref name="exception"/>
    <interceptor-ref name="alias"/>
    <interceptor-ref name="servletConfig"/>
    <interceptor-ref name="i18n"/>
    <interceptor-ref name="prepare"/>
    <interceptor-ref name="chain"/>
    <interceptor-ref name="scopedModelDriven"/>
    <interceptor-ref name="modelDriven"/>
    <interceptor-ref name="fileUpload"/>
    <interceptor-ref name="checkbox"/>
    <interceptor-ref name="datetime"/>
    <interceptor-ref name="multiselect"/>
    <interceptor-ref name="staticParams"/>
    <interceptor-ref name="actionMappingParams"/>
    <interceptor-ref name="params"/>
    <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-ref name="debugging"/>
    <interceptor-ref name="deprecation"/>
</interceptor-stack>

<default-interceptor-ref name="defaultStack"/>

可以看到defaultStack中引用了大量的拦截器，需要提到的一点就是，如果我们action中引用了一个拦截器，那么就不会再加载默认拦截器了，所以如果想要在action中引用拦截器后仍旧可以使用默认拦截器中的拦截，需在手动加上默认拦截器的引用。

另外，无论是拦截器的引用还是拦截器中都可以加入配置参数，例如：includeMethods、excludeMethods等等，具体参数可以查看API或者看对应拦截器类的属性参数。

查看全文

相关阅读:
spring data jpa 分页查询(小结)
java 工作日判断
 Map的merge方法(java8)
java8 常用JVM 参数修改
 ubuntu docker client 安装
 scala io 读写文件
 Grafana 系统资源监测
 Java8Stream Collectors收集器
 EhCacheUtils 缓存 ehche (将文件临时保存在磁盘)
springboot2.X 整合scala

原文地址：https://www.cnblogs.com/alfredinchange/p/5349905.html