最近在编码的时候用到了回调模版,想到了JDK的动态代理在用起来并不怎么方便,如果将其改造成AOP式的方式就能在使用起来方便的多。
这样用户只要关系对代理的类的那些方法进行处理了,很像spring的aop
其他代码如下:
UserMgr自己去写这样的实现会让你想起什么呢?希望大家指点
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自己去写这样的实现会让你想起什么呢?希望大家指点