小白十六篇 责任链模式

责任链模式

多个拦截器对于同一件事情实现多重拦截，即一个对象在一条链上被多个拦截器拦截处理。
对于一个真实对象，以三层拦截器为例子:

• 到达第一个拦截器将使用第一个动态代理proxy_1
• 到达第二个拦截器将使用第二个动态代理proxy_2并且是在第一个动态代理的基础上生成
• 到达第三个拦截器将使用第三个动态代理proxy_3并且是在第二个动态代理的基础上生成

达到层层控制的效果。

责任链模式案例

1. 拦截器接口定义

import java.lang.reflect.Method;
/**
*   责任链模式
 *	 JDK动态代理  定义拦截器接口
 * @author WW
 *
 */
public interface Interceptor {
	/**
	 * 	调用真实对象前调用
	 * @param proxy  代理对象
	 * @param target  真实对象
	 * @param method 当前调用方法
	 * @param args  当前调用方法的参数
	 * @return true 反射真实对象
	 * 		   false 调用around方法
	 */
	public boolean before(Object proxy,Object target,Method method,Object[] args);
	/**
	 * before方法返回false的情况下调用
	 * @param proxy 代理对象
	 * @param target 真实对象
	 * @param method 当前调用方法
	 * @param args 当前调用方法的参数
	 */
	public void around(Object proxy,Object target,Method method,Object[] args);
	/**
	 * 	反射真实对象方法或者around方法执行之后调用
	 * @param proxy 代理对象
	 * @param target 真实对象
	 * @param method 当前调用方法
	 * @param args 当前调用方法的参数
	 */
	public void after(Object proxy,Object target,Method method,Object[] args);
}

2. 拦截器实现，以三个拦截器为例子，创建三个拦截器
   三个拦截器的大致实现都是相同的，这里并未给出具体的业务逻辑实现，只是简单的表明该方法被调用，具体的业务逻辑需要具体的情况吓制定。

import java.lang.reflect.Method;
/**
 * 责任链模式
 * 第一个拦截器 实现拦截器定义接口
 * @author WW
 */
public class InterceptorChain1 implements Interceptor{
	@Override
	public boolean before(Object proxy, Object target, Method method, Object[] args) {
		System.err.println("------- 拦截器 1 ---- before方法.....");
		return true;
	}
	@Override
	public void around(Object proxy, Object target, Method method, Object[] args) {
		System.err.println("------- 拦截器 1 ---- around方法.....");
	}
	@Override
	public void after(Object proxy, Object target, Method method, Object[] args) {
		System.err.println("------- 拦截器 1 ---- after方法.....");
	}
}
/*--------------------------------------------------------------------------------------------------------------------*/
import java.lang.reflect.Method;
/**
 * 责任链模式
 * 第二个拦截器  实现拦截器接口
 * @author WW
 */
public class InterceptorChain2 implements Interceptor{
	@Override
	public boolean before(Object proxy, Object target, Method method, Object[] args) {
		System.err.println("------- 拦截器 2 ---- before方法.....");
		return true;
	}
	@Override
	public void around(Object proxy, Object target, Method method, Object[] args) {
		System.err.println("------- 拦截器 2 ---- around方法.....");
	}
	@Override
	public void after(Object proxy, Object target, Method method, Object[] args) {
		System.err.println("------- 拦截器 2 ---- after方法.....");
	}
}
/*--------------------------------------------------------------------------------------------------------------------*/
import java.lang.reflect.Method;
/**
 * 责任链模式
 * 第三个拦截器  实现拦截器接口
 * @author WW
 */
public class InterceptorChain3 implements Interceptor{
	@Override
	public boolean before(Object proxy, Object target, Method method, Object[] args) {
		System.err.println("------- 拦截器 3 ---- before方法.....");
		return true;
	}
	@Override
	public void around(Object proxy, Object target, Method method, Object[] args) {
		System.err.println("------- 拦截器 3 ---- around方法.....");
	}
	@Override
	public void after(Object proxy, Object target, Method method, Object[] args) {
		System.err.println("------- 拦截器 3 ---- after方法.....");
	}
}

3. 通过JDK动态代理的方式使用拦截器

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * 责任链模式
 * JDK动态代理中使用拦截器
 * @author WW
 */
public class JdkProxyInterceptor implements InvocationHandler{
	//真实对象
	private Object target;
	//拦截器全限定名
	private String interClass = null;
	public JdkProxyInterceptor(Object target,String interceptor) {
		this.target = target;
		this.interClass = interceptor;
	}
	/**
	 *  	绑定真实对象并返回一个代理对象
	 * @param target  真实对象
	 * @param interceptor
	 * @return  代理对象
	 */
	public static Object bind(Object target,String  interceptor) {
		//获得代理对象
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), 
				target.getClass().getInterfaces(), 
				new JdkProxyInterceptor(target, interceptor));
	}
	/**
	 * 	通过代理对象调用方法  首先会进入这个方法 而不是直接真实对象调用方法
	 * @param proxy 代理对象
	 * @param method 当前被调用的方法
	 * @param args 方法的参数
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		if (interClass == null) {
			//没有拦截器 则直接反射调用
			return method.invoke(target, args);
		}
		Object result = null;
		//通过反射生成拦截器
		Interceptor interceptor = (Interceptor)
				Class.forName(interClass).newInstance();
		//调用前置方法
		if (interceptor.before(proxy,target, method, args)) {
			//反射原有方法
			result = method.invoke(target, args);
		}else {
			//before方法返回false 执行 around方法
			interceptor.around(proxy, target, method, args);
		}
		//调用后置方法
		interceptor.after(proxy, target, method, args);
		return result;
	}
}

4. 准备真实对象，需要接口和实现类

/**
 * 	真实对象接口
 * @author WW
 *
 */
public interface TrueObject {
	public void method();
}
/*--------------------------------------------------------------------------------------------------------------------*/
/**
 * 	真实对象接口的实现类
 * @author WW
 */
public class TrueObjectImpl implements TrueObject{
	@Override
	public void method() {
		System.err.println("Responsility Chain test demo for true object.");
	}
}

5. 测试类编写

/**
 * 责任链模式 测试类
 * @author WW
 */
public class Test {
	public static void main(String[] args) {
		TrueObject proxy_1 = (TrueObject) JdkProxyInterceptor
				.bind(new TrueObjectImpl(), "com.ww.inter.InterceptorChain1");
		TrueObject proxy_2 = (TrueObject) JdkProxyInterceptor
				.bind(proxy_1, "com.ww.inter.InterceptorChain2");
		TrueObject proxy_3 = (TrueObject) JdkProxyInterceptor
				.bind(proxy_2,"com.ww.inter.InterceptorChain3");
		proxy_3.method();
	}
}

6. 测试结果
   
   通过上面的层层包裹的图，以及测试的结果，这个责任链模式对于真实对象调用方法的开始和结束是有特定的顺序的，这也符合责任链模式的思想。
   完成！