JDK的动态代理改造

最近在编码的时候用到了回调模版，想到了JDK的动态代理在用起来并不怎么方便，如果将其改造成AOP式的方式就能在使用起来方便的多。

package com.fjx.proxy.up.test;

import com.fjx.proxy.up.MethodInterceptor;
import com.fjx.proxy.up.MethodInvocation;
import com.fjx.proxy.up.ProxyUp;

/**
 * 动态代理升级类测试
 * @author FANGJINXIN
 *
 */
public class ProxyUpTest {

	public static void main(String[] args) {
		UserMgr userMgr = new UserMgrImpl();
		Object proxy = ProxyUp.newProxy(userMgr, new MethodInterceptor(){
			public void invoke(MethodInvocation invocation) {
				if(invocation.getMethod().getName().equals("saveUser")){
					System.out.println("开始记录保存日志");
					invocation.process();
					System.out.println("保存成功日志记录完毕");
				}else{
					invocation.process();
				}
			}});
		
		userMgr = (UserMgr)proxy;
		userMgr.saveUser("湘");
		userMgr.sayHello("湘");
	}

}

这样用户只要关系对代理的类的那些方法进行处理了，很像spring的aop
其他代码如下：

package com.fjx.proxy.up;

import java.lang.reflect.Proxy;

/**
 * 动态代理
 * 
 * @author FANGJINXIN
 *
 */
public abstract class ProxyUp {
	
	public static Object newProxy(Object target,MethodInterceptor methodInterceptor){
		MethodInvocation invocation = new MethodInvocation(target,methodInterceptor);
		
		Object obj = Proxy.newProxyInstance(target.getClass().getClassLoader(),
							   				target.getClass().getInterfaces(), 
							   				invocation);
		return obj;
	}
}


package com.fjx.proxy.up;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * 方法回调类
 * @author FANGJINXIN
 *
 */
public class MethodInvocation implements InvocationHandler{
	private Object target;//目标类
	private Method method;//回调的方法
	private Object[] args;//方法参数
	private MethodInterceptor methodInterceptor;//方法拦截对象
	
	public MethodInvocation(Object target, MethodInterceptor methodInterceptor){
		this.target = target;
		this.methodInterceptor = methodInterceptor;
	}
	public MethodInvocation() {
		
	}
	
	/**
	 * 调用目标对象的原始方法
	 */
	public void process(){
		try {
			method.invoke(target, args);
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 重写代理回调方法
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		this.method = method;
		this.args = args;
		methodInterceptor.invoke(this);//调用方法拦截器代理方法
		return proxy;
	}
	
	public Object getTarget() {
		return target;
	}
	public void setTarget(Object target) {
		this.target = target;
	}
	public Method getMethod() {
		return method;
	}
	public void setMethod(Method method) {
		this.method = method;
	}
	public MethodInterceptor getMethodInterceptor() {
		return methodInterceptor;
	}

	
	
	
	
	
}


package com.fjx.proxy.up;

/**
 * 方法回调接口
 * 用户通过实现拦截器来动态代理原始对象
 * 
 * @author FANGJINXIN
 *
 */
public interface MethodInterceptor {
	/**
	 * 方法代理类
	 * @param invocation
	 */
	public void invoke(MethodInvocation invocation);
}

UserMgr自己去写这样的实现会让你想起什么呢？希望大家指点