Struts2（八）：拦截器的简单实现原理

Struts2（8）：拦截器的简单实现原理
什么是拦截器：
拦截器，在AOP（Aspect-Oriented Programming）中用于在执行目标对象某个方法或字段被访问之前，进行拦截然后在之前或之后加入某些操作。拦截是AOP的一种实现策略。
下面模拟拦截器的实现，一共需要5个类：
1，目标对象接口 TargetInterface.java
2，目标对象接口实现类  Target.java
3，拦截器类  Interceptor.java
4，处理器类 MyHandler.java
5，代理类 MyProxy.java

1，TargetInterface接口中声明一个doSomething方法

public interface TargetInterface {
   public void doSomething();
}

2，Target 类实现TargetInterface接口，并实现doSomething方法

public class Target implements TargetInterface {

	public void doSomething() {
		System.out.println("do something");
	}

}

3，Interceptor.java拦截器中定义两个方法，分别执行在目标对象方法前，后执行。

public class Interceptor {
	public void before(){
		System.out.println("before...");
	}
	public void after(){
		System.out.println("after...");
	}
}

4，在处理器类MyHandler类中将目标对象与拦截器类关联起来，使用反射调用目标对象，并在执行目标对象方法前后执行拦截器中的方法。

public class MyHandler implements InvocationHandler {

	private Object object;

	private Interceptor interceptor = new Interceptor();

	public void setObject(Object object) {
		this.object = object;
	}

	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object result = null;
		interceptor.before();
		result = method.invoke(object, args);
		interceptor.after();
		return result;
	}

}

5，在代理类MyProxy中声明处理器类，通过动态代理调用处理器类。

public class MyProxy {
	public Object getProxy(Object object){
		MyHandler myhandler = new MyHandler();
		myhandler.setObject(object);
		return Proxy.newProxyInstance(Target.class.getClassLoader(), object.getClass().getInterfaces(), myhandler);
	}
}

最后写一个测试类来进行测试：

public class Client {
	public static void main(String[] args) {
		TargetInterface target = new Target();
		MyProxy myProxy = new MyProxy();
		TargetInterface proxy = (TargetInterface)myProxy.getProxy(target);
		proxy.doSomething();
	}
}

结果将打印出
before
do something
after