类似用户权限的需求，有些操作需要登录，有些操作不需要，可以使用过滤器filter，但在此使用过滤器比较死板，如果用的话，就必须在配置文件里加上所有方法，而且 不好使用通配符。这里可以采用一种比较简单灵活的方式，是采用spring 的 methodinterceptor拦截器完成的，并且是基于注解的。大概是用法是这样的：
@loginrequired
@requestmapping(value = "/comment")
public void comment(httpservletrequest req, httpservletresponse res) {
// dosomething,,,,,,,,
}
这里是在spring mvc 的controller层的方法上拦截的，注意上面的@loginrequired 是自定义的注解。这样的话，该方法被拦截后，如果有该注解，则表明该 方法需要用户登录后才能执行某种操作，于是，我们可以判断request里的session或者cookie是否包含用户已经登录的身份，然后判断是否执行该方法；如果没有，则执行另一种操作。
下面是自定义注解的代码：
import java.lang.annotation.elementtype;
import java.lang.annotation.retention;
import java.lang.annotation.retentionpolicy;
import java.lang.annotation.target;
@target(elementtype.method)
@retention(retentionpolicy.runtime)
public @interface loginrequired {
}
下面是自定义的方法拦截器，继续自aop的methodinterceptor
import javax.servlet.http.httpservletrequest;
import org.aopalliance.intercept.methodinterceptor;
import org.aopalliance.intercept.methodinvocation;
public class loginrequiredinterceptor1 implements methodinterceptor {
@override
public object invoke(methodinvocation mi) throws throwable {
object[] ars = mi.getarguments();
for(object o :ars){
if(o instanceof httpservletrequest){
system.out.println("------------this is a httpservletrequest parameter------------ ");
}
}
// 判断该方法是否加了@loginrequired 注解
if(mi.getmethod().isannotationpresent(loginrequired.class)){
system.out.println("----------this method is added @loginrequired-------------------------");
}
//执行被拦截的方法，切记，如果此方法不调用，则被拦截的方法不会被执行。
return mi.proceed();
}
}
配置文件：
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持萬仟网。
希望与广大网友互动？？
点此进行留言吧！

一、拦截器
1、拦截器小介
拦截器的功能类似于web.xml文件中的Filter，能对用户的请求进行拦截，通过拦截用户的请求来实现对页面的控制。拦截器是在Struts-core-2.2.3.jar中进行配置的，原始的拦截器是在struts-default.xml中配置的，里面封存了拦截器的基本使用方法。
Struts2拦截器功能类似于Servlet过滤器。在Action执行execute方法前，Struts2会首先执行struts.xml中引用的拦截器，如果有多个拦截器则会按照上下顺序依次执行，在执行完所有的拦截器的interceptor方法后，会执行Action的execute方法。
Struts2的拦截器必须从com.opensymphoy.xwork2.interceptor.Interceptor中实现该接口，在被定义的拦截器中有下面三个方法需要被实现：
voiddestroy();
voidinit();
String intercept(ActionInvocation invocation) throwsException;
自定义的拦截器需要重写上面三个方法。另外Struts2的拦截器配置文件struts.xml它是继承了原始文件struts-default.xml文件的，这样在相应的中就会自动拥有struts-default.xml中的所有配置信息了。具体代码如下：
...
2、Demo
想要使用拦截器必须要经过配置，struts2采用的是映射的方法，所以想用使用某一个功能就必须在配置文件中配置，拦截器也不例外。所以必须在package中添加相应的拦截器元素，同时将拦截器关联相应的class文件，这样在执行action前才会执行相应的拦截器，具体使用方法如下。
(1)添加配置文件struts.xml，并在该文件中添加拦截器
/error.jsp
/success.jsp
/checkSession.jsp
上面的package中添加了一个名为myInterceptor的拦截器，并为该拦截器注册了一个java类，该类名称为MyInterceptor，并被封存在com.interceptor包中。另外还在该package中添加了相应的action，在执行该action前会首先执行myInterceptor拦截器。
(2)编写被注册的拦截器类MyInterceptor，该类必须实现com.opensymphoy.xwork2.interceptor.Interceptor接口，并重写相应的方法
packagecom.interceptor;
importjava.util.Map;
importcom.entity.User;
importcom.opensymphony.xwork2.ActionContext;
importcom.opensymphony.xwork2.ActionInvocation;
importcom.opensymphony.xwork2.interceptor.Interceptor;
publicclassMyInterceptorimplementsInterceptor{
privateUser user;
publicUser getUser() {
returnuser;
}
publicvoidsetUser(User user) {
this.user = user;
}
@Override
publicvoiddestroy() {
// TODO Auto-generated method stub
System.out.println("----destroy()----");
}
@Override
publicvoidinit() {
// TODO Auto-generated method stub
System.out.println("-----Init()-------");
}
@Override
publicString intercept(ActionInvocation invocation)throwsException {
// TODO Auto-generated method stub
System.out.println("----intercept()------");
Map session= invocation.getInvocationContext().getSession();
if(session.get("username")!=null){
System.out.println("登陆成功！");
//session.put("username",user.getUsername());
returninvocation.invoke();
}else{
System.out.println("登陆失败！");
return"checkError";
}
}
}
(3)经过前面两步后，拦截器已经配置完成，最后一部就是使用拦截器了，在显示页面上添加相应的标签，并为标签指定上面创建的名为demo的action，然后执行页面即可在控制台中打印出相应的拦截器内容。
pageEncoding="UTF-8"%>
html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
Insert title here
用户名：
密  码：
打印输出内容：
分析输出结果，程序编译阶段首先会去读取配置文件struts.xml，在该配置文件action中顺序查找是否添加了拦截器，如果添加了拦截器则根据拦截器名称在中查找是否定义了该拦截器或者拦截器栈，如果发现定义的是拦截器则根据拦截器查找对应的注册的class，最后在包内查找注册的class并执行相应的init()方法；程序运行阶段的大致流程和编译阶段类似，用户在前台提交请求后，会按照注册的action在struts.xml中查找与之相对应的，如果查找到将会查找拦截器，没有查找到的话会相应的抛错，最后执行拦截器注册类的intercept方法。
3、拦截器栈
拦截器同样有栈的概念，它是将使用的拦截器定义到共有的状态下来实现统一管理，这样在package中就可以做到拦截器的共享了，大大便利了拦截器的使用。在一个package中往往会用到重复的interceptor，如果每次都在Action中添加interceptor-ref的话就会很麻烦，那么拦截器栈就是为了解决这个问题而产生的，具体配置如下：
/error.jsp
/success.jsp
/checkSession.jsp
实例中使用了interceptor-stack来定义了一个名称为defaultstack1的拦截器栈，在该栈中添加了要执行的拦截器，把拦截器做了封装，在Action中直接调用该拦截器栈即可，实现了拦截器栈的共享。
4、默认拦截器栈
另外可以定义默认的拦截器栈，即：如果某个Action中没有定义拦截器，那么它会默认执行该公共的拦截器。它和interceptors标签属于同一等级的，使用default-interceptor-ref定义。
/error.jsp
/success.jsp
/checkSession.jsp
定义的默认的拦截器栈只是在Action没有指定拦截器的情况下才执行自定义默认的拦截器栈的，如果在Action中重定义了拦截器，那么它会覆盖自定义默认的拦截器栈的。
5、不执行任何拦截器
还有一种情况是一个package中定义了默认的拦截器，但是在编写的某个Action中并不需要执行任何拦截器，那么此时可以在相应的Action中添加一个名称为defaultStack的拦截器即可，它是系统默认的拦截器，不会有任何操作。
/error.jsp
/success.jsp
/checkSession.jsp
6、拦截方法
6.1 用法
上面的拦截器只是实现了对Action的拦截，其实拦截器的功能很强大，它也可以拦截相应Action方法。和拦截Action不同的是想要拦截方法就必须继承类MethodFilterInterceptor，该类封存在xwork-core.jar中，又一次证明了WebWork是Struts2的核心。另外还需要在配置文件中添加相应的属性来确定拦截的方法和不拦截的方法，具体配置方法如下：
/error.jsp
/success.jsp
/checkSession.jsp
添加要拦截的方法名称
添加不需要拦截的方法名称
继承MethodFilterInterceptor类的相应拦截方法的类中的代码：
packagecom.interceptor;
importjava.util.Map;
importcom.opensymphony.xwork2.ActionContext;
importcom.opensymphony.xwork2.ActionInvocation;
importcom.opensymphony.xwork2.interceptor.MethodFilterInterceptor;
publicclassinterextendsMethodFilterInterceptor {
@Override
publicString doIntercept(ActionInvocation invocation)throwsException {
System.out.println("--intercept()--");
//获取相应的Session
Map session=invocation.getInvocationContext().getSession();
Map request=(Map)ActionContext.getContext().get("request");
String username=(String)request.get("user.username");
if(session.get("username") !=null){
String result=invocation.invoke();
System.out.println("--end()--");
returnresult;
}
}
}
6.2 Demo
来看一个拦截方法的实例，并对结果进行分析。下面的实例演示拦截方法的输出结果，在实例中分别创建了一个loginAction类，添加Action要执行的方法；Inter类，拦截器中重写MethodFilterInterceptor方法，在控制台中输出是否对某个方法进行拦截；login.jsp文件，添加三个按钮，分别演示三个方法的执行。
(1)struts.xml内方法拦截器的定义，在package中定义了一个名称为inter的拦截器，在拦截器中指定了参数，includeMethods用来拦截Method1，excludeMethods中的Method2表示不拦截Methods2方法，具体配置如下代码：
struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
Method1
Method2
success.jsp
error.jsp
Welcome
(2)loginAction类，配置login.jsp中的action，分别在该类中添加Method1-Method3三个方法，其中Method1被拦截，Method2和Method3不被拦截，最后我们查看输出结果。
packagecom.action;
importcom.opensymphony.xwork2.ActionSupport;
publicclassloginActionextendsActionSupport {
@Override
publicString execute()throwsException {
if(this.username.equals("admin") &&this.password.equals("admin")){
return"success";
}elseif(this.username.equals("cancel") &&this.password.equals("cancel")){
return"cancel";
}else{
return"error";
}
}
publicvoidMethod1(){
System.out.println("执行方法:Method1");
}
publicvoidMethod2(){
System.out.println("执行方法:Method2");
}
publicvoidMethod3(){
System.out.println("执行方法:Method3");
}
privateString username;
privateString password;
publicString getUsername(){
returnthis.username;
}
publicvoidsetUsername(String username){
this.username=username;
}
publicString getPassword(){
returnthis.password;
}
publicvoidsetPassword(String password){
this.password=password;
}
}
(3)inter类，继承MethodFilterInterceptor类，用来实现拦截方法。重写doIntercept方法，在该方法中添加拦截的相应信息。
packagecom.interceptor;
importjava.util.Date;
importjava.util.Map;
importcom.action.loginAction;
importcom.opensymphony.xwork2.ActionContext;
importcom.opensymphony.xwork2.ActionInvocation;
importcom.opensymphony.xwork2.interceptor.MethodFilterInterceptor;
publicclassinterextendsMethodFilterInterceptor {
@Override
protectedString doIntercept(ActionInvocation invocation)throwsException {
// TODO Auto-generated method stub
System.out.println("拦截器在Action执行前拦截"+newDate());
String result=invocation.invoke();  //执行Action方法
System.out.println("拦截器在Action执行后拦截"+newDate());
returnresult;
}
}
(4)login.jsp，在jsp页面上添加三个按钮，分别演示三个方法，判断拦截器对方法的拦截情况。三个按钮在点击后回发的action是在javascript中动态的进行添加的，这样做达到了一个form中执行不同的action的方法，当然还有其它的方法，将会在下篇文章中讨论。
pageEncoding="UTF-8"%>
html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
Insert title here
//方法1，定义被拦截的方法的实例
function method1(){
var form=document.forms[0];
form.action="loginaction!Method1";
form.submit();
}
//方法2，为按钮2添加不拦截的方法
function method2(){
var form=document.forms[0];
form.action="loginaction!Method2";
form.submit();
}
//方法3，为按钮3添加不拦截的方法
function method3(){
var form=document.forms[0];
form.action="loginaction!Method3";
form.submit();
}
用户名：
密     码：
运行完成后的页面视图：
(5)分析运行结果，分别单击按钮1、2、3，在控制台中输出结果，按钮1是绑定的method1，该方法在struts.xml中进行了拦截如果结果正确的话会显示被拦截的结果，而相应的按钮2和3只输出运行结果，因为它们没有被拦截。那看下面的结果图：
结果图正好正是了我们的分析结果，按钮1被拦截了，执行了inter类中的doIntercept方法，二相应的按钮2和3没有被拦截。也就是说，Method1被放到了方法拦截器的白名单内，执行要拦截该方法；Method2被放到了拦截器黑名单内，不需要拦截该方法；Method3不做任何处理。
结语
对于拦截器的内容就总结到这里，拦截器提供了很强大的功能，使得开发人员能够在运行时控制输出结果，增加了编程的灵活性。另外对于任何理论性的东西都不要试图去记忆，一定要理性的去分析，多多实践，动手做几个实例，分析结果更深刻的理解。

1.拦截器的概念

java里的拦截器是动态拦截Action调用的对象，它提供了一种机制可以使开发者在一个Action执行的前后执行一段代码，也可以在一个Action

执行前阻止其执行，同时也提供了一种可以提取Action中可重用部分代码的方式。在AOP中，拦截器用于在某个方法或者字段被访问之前，进行拦截

然后再之前或者之后加入某些操作。
2.拦截器的原理

大部分时候，拦截器方法都是通过代理的方式来调用的。Struts2的拦截器实现相对简单。当请求到达Struts2的ServletDispatcher时，Struts2

会查找配置文件，并根据配置实例化相对的拦截器对象，然后串成一个列表（List），最后一个一个的调用列表中的拦截器。Struts2的拦截器是可

插拔的，拦截器是AOP的一个实现。Struts2拦截器栈就是将拦截器按一定的顺序连接成一条链。在访问被拦截的方法或者字段时，Struts2拦截器链

中的拦截器就会按照之前定义的顺序进行调用。
3.自定义拦截器的步骤

第一步：自定义一个实现了Interceptor接口的类，或者继承抽象类AbstractInterceptor。

第二步：在配置文件中注册定义的拦截器。

第三步：在需要使用Action中引用上述定义的拦截器，为了方便也可以将拦截器定义为默认的拦截器，这样在不加特殊说明的情况下，所有的

Action都被这个拦截器拦截。
4.过滤器与拦截器的区别

过滤器可以简单的理解为“取你所想取”，过滤器关注的是web请求；拦截器可以简单的理解为“拒你所想拒”，拦截器关注的是方法调用，比如拦截

敏感词汇。

4.1.拦截器是基于java反射机制来实现的，而过滤器是基于函数回调来实现的。（有人说，拦截器是基于动态代理来实现的）

4.2.拦截器不依赖servlet容器，过滤器依赖于servlet容器。

4.3.拦截器只对Action起作用，过滤器可以对所有请求起作用。

4.4.拦截器可以访问Action上下文和值栈中的对象，过滤器不能。

4.5.在Action的生命周期中，拦截器可以多次调用，而过滤器只能在容器初始化时调用一次。
5.Spring拦截器

5.1.抽象类HandlerInterceptorAdapter

我们如果在项目中使用了Spring框架，那么，我们可以直接继承HandlerInterceptorAdapter.java这个抽象类，来实现我们自己的拦截器。
spring框架，对java的拦截器概念进行了包装，这一点和Struts2很类似。HandlerInterceptorAdapter继承了抽象接口HandlerInterceptor。
6.Spring MVC拦截器简单代码示例
<!-- mvc拦截器 -->
	<mvc:interceptors>
		<mvc:interceptor>
			 <!-- 进行拦截：/**表示拦截所有controller -->
			<mvc:mapping path="/**" />
			
			<!-- 不进行拦截 -->
        	<mvc:exclude-mapping path="输入不需要拦截的路径"/>
			<bean class="拦截器代码路径(xx.xx.HandlerInterceptor)"></bean>
		</mvc:interceptor>
	</mvc:interceptors>

对应的拦截器代码：
public class HandleInterceptor extends HandlerInterceptorAdapter {

	private final Logger logger = Logger.getLogger(HandleInterceptor.class);

	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		// 写入需要拦截器处理的代码，例如为每个链接注入一个时间
		request.setAttribute("currentTime", new Date());
		return true;
	}

java三大器之一 -拦截器

拦截器的定义

java里的拦截器是动态拦截action调用的对象。提供一种机制可以定义在action执行的前后执行的代码，也可以action执行前阻止其执行，同时提供了一种可以提取action中可重用部分的方式。在aop中拦截器用在某个方法或字段被访问之前，在拦截后在其之前或之后执行一些操作。

 

拦截器实现

定义一个java类，实现Interceptor接口，或者继承抽象类AbstractInterceptor

在配置文件中注册拦截器。

在需要action中引用上述定义的拦截器，如果定义为默认拦截器，不加特殊说明，所有action都会被这个拦截器拦截。

 

 

拦截器与框架的结合

1、拦截器和spring

在spring框架中，通过实现HanderInterceptorAdaper抽象类来实现拦截器，HanderInterceptorAdaper继承了抽象接口HanderInterceptorAdaper。

HandlerInterceptorAdaper代码

 

package org.springframework.web.servlet.handler;  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  
import org.springframework.web.servlet.HandlerInterceptor;  
import org.springframework.web.servlet.ModelAndView;  
public abstract class HandlerInterceptorAdapter implements HandlerInterceptor{  
    // 在业务处理器处理请求之前被调用  
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception{  
        return true;  
    }  
    // 在业务处理器处理请求完成之后，生成视图之前执行  
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)  
      throws Exception{  
    }  
    // 在DispatcherServlet完全处理完请求之后被调用，可用于清理资源  
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)  
      throws Exception{  
    }  
}

拦截器的配置 <mvc:interceptors>

        <mvc:interceptor>

            <!-- 拦截所有的请求，这个必须写在前面，也就是写在【不拦截】的上面 -->

            <mvc:mapping path="/**" />

            <!-- 但是排除下面这些，也就是不拦截请求 -->

            <mvc:exclude-mapping path="/login.html" />

            <mvc:exclude-mapping path="/account/login.do" />

            <mvc:exclude-mapping path="/account/regist.do" />

            <bean class="com.msym.cloudnote.interceptors.SessionInterceptor" />

        </mvc:interceptor>

</mvc:interceptors>