1、动态代理的概念
动态代理是在程序运行时，动态的创建一个实现了目标对象所实现的所有接口的增强对象。通过Proxy类实现。
（增强对象=被增强对象+增强）
图片.png
2、Proxy动态生成代理对象的简单实现
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class Demo {
public void fun1() {
//通过本类可以获取加载本类的类加载器，使用这个类加载器来加载我们要创建的动态对象
ClassLoader loader = this.getClass().getClassLoader();
InvocationHandler h = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] objects)
throws Throwable {
return null;
}
};
//获得我们想要的动态对象
Object object = Proxy.newProxyInstance(loader, new Class[] { A.class, B.class }, h);
}
}
//定义两个接口
interface A {
public void a();
}
interface B {
public void b();
}
3、创建动态对象时的三大参数
a.ClassLoader：类加载器，所有的class文件要加载到JVM的内存中成为Class对象都需要类加载器将其加载到内存中。
b.interfaces：产生的代理对象需要实现的所有的接口数组，即2代码中的new Class[] { A.class, B.class }
c.InvocationHandler：调用处理器
4、InvocationHandler（调用处理器的invoke方法）
invoke的三个参数：
a.proxy：调用接口方法的对象，生成的代理对象
b.method：代理对象调用的方法
c.objects：代理对象调用方法时传递过来的参数
在代理对象每次调用接口中的方法时都会执行invoke方法。
5、代理工程的实现
a.前置增强接口
/**
* 前置增强
* @author John
*
*/
public interface BeforeAdvice {
//前置增强方法
public void before();
}
b.后置增强接口
/**
* 后置增强
* @author John
*
*/
public interface AfterAdvice {
//后置增强方法
public void after();
}
c.目标对象接口
/**
* 目标对象
* @author John
*
*/
public interface Target {
//目标方法
public void targetMethod();
}
d.代理工程类
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 代理工厂
* @author John
*
*/
public class ProxyFactory {
private Object targetObject;// 目标对象
private BeforeAdvice beforeAdvice;// 前置增强
private AfterAdvice afterAdvice;// 后置增强
/**
* 生成代理对象
*
* @return 代理对象
*/
public Object createProxy() {
// 给出三大参数
ClassLoader loader = this.getClass().getClassLoader();
Class[] interfaces = targetObject.getClass().getInterfaces();
InvocationHandler h = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// 如果前置增强不为空，执行前置增强
if (beforeAdvice != null) {
beforeAdvice.before();
}
// 执行目标方法
Object result = method.invoke(targetObject, args);
// 如果后置增强不为空，执行后置增强
if (afterAdvice != null) {
afterAdvice.after();
}
// 返回目标方法执行结果
return result;
}
};
Object object = Proxy.newProxyInstance(loader, interfaces, h);
return object;
}
/**
* 无参构造方法
*/
public ProxyFactory() {
super();
}
/**
* 有参构造方法
*
* @param targetObject
* 目标对象
* @param beforeAdvice
* 前置增强
* @param afterAdvice
* 后置增强
*/
public ProxyFactory(Object targetObject, BeforeAdvice beforeAdvice,
AfterAdvice afterAdvice) {
super();
this.targetObject = targetObject;
this.beforeAdvice = beforeAdvice;
this.afterAdvice = afterAdvice;
}
public Object getTargetObject() {
return targetObject;
}
public void setTargetObject(Object targetObject) {
this.targetObject = targetObject;
}
public BeforeAdvice getBeforeAdvice() {
return beforeAdvice;
}
public void setBeforeAdvice(BeforeAdvice beforeAdvice) {
this.beforeAdvice = beforeAdvice;
}
public AfterAdvice getAfterAdvice() {
return afterAdvice;
}
public void setAfterAdvice(AfterAdvice afterAdvice) {
this.afterAdvice = afterAdvice;
}
}
e.测试代码
import org.junit.Test;
public class Test2 {
@Test
public void fun1() {
ProxyFactory factory = new ProxyFactory(new Target() {
@Override
public void targetMethod() {
System.out.println("我是目标对象的实现类");
}
}, new BeforeAdvice() {
@Override
public void before() {
System.out.println("我是前置增强");
}
}, new AfterAdvice() {
@Override
public void after() {
System.out.println("我是后置增强");
}
});
Target targetProxy = (Target) factory.createProxy();
targetProxy.targetMethod();
}
}
f.运行结果
图片.png
（如有错误，欢迎指正）
网友评论