Provide a surrogate or placeholder for another object to control access to it.
代理模式
抽象类
public abstract class AbstractSubject {
public abstract void work();
}
被代理对象
public class Subject extends AbstractSubject {
@Override
public void work() {
System.out.println(getClass() + " execute work()");
}
}
代理
public class Proxy extends AbstractSubject {
Subject subject;
@Override
public void work() {
System.out.println("Proxy call happening now");
// Lazy initialization
if (subject == null) {
subject = new Subject();
}
subject.work();
}
}
运行
public class Proxy extends AbstractSubject {
Subject subject;
@Override
public void work() {
System.out.println("Proxy call happening now");
// Lazy initialization
if (subject == null) {
subject = new Subject();
}
subject.work();
}
}
类图
proxy.png
代理的作用：
- 延迟初始化被代理对象，仅当真正需要时才被初始化，特别是当被代理对象初始化比较消耗资源时。
- 可以在被代理对象的方法执行前后，添加任意需要的动作。
JAVA动态代理
JDK实现了代理模式，通过java.lang.reflect.Proxy.newProxyInstance类来创建代理对象，并且需要一个java.lang.reflect.InvocationHandler接口的实现类，代理对象会实现被代理对象实现的接口，当调用代理对象的方法，JDK就会执行InvocationHandler.invoke()方法，此时给了我们添加额外动作的机会。
接口
public interface IFoo {
// 接口方法默认是public abstract的，不需要添加修饰符
Object bar(Object obj);
}
实现类
public class Foo implements IFoo {
public Object bar(Object obj) {
System.out.println("Foo execute bar(obj)");
return obj;
}
}
InvocationHandler实现类
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class DebugInvocationHandler implements InvocationHandler {
private Object obj;
private DebugInvocationHandler(Object obj) {
this.obj = obj;
}
public static Object newInstance(Object obj) {
// 返回代理对象
return Proxy.newProxyInstance(
obj.getClass().getClassLoader(), // 类加载器
obj.getClass().getInterfaces(), // 被代理类实现的接口
new DebugInvocationHandler(obj)); // InvocationHandler实例
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result;
try {
System.out.println("before method " + method.getName());
result = method.invoke(obj, args);
} catch (InvocationTargetException e) {
throw e.getTargetException();
} catch (Exception e) {
throw new RuntimeException("unexpected invocation exception: " + e.getMessage());
} finally {
System.out.println("after method " + method.getName());
}
return result;
}
}
执行
public class Test {
public static void main(String[] args) {
/**
* java.lang.reflect.Proxy类需要一个java.lang.reflect.InvocationHandler对象
*
* Proxy.newProxyInstance()方法返回一个代理对象，该代理对象实现了被代理对象实现的接口（IFoo）
*
* 调用代理对象的方法，JDK就会执行InvocationHandler.invoke()方法，此时给了我们添加额外动作的机会
*/
IFoo proxy = (IFoo) DebugInvocationHandler.newInstance(new Foo());
proxy.bar(null);
}
}
Spring中的AOP就是通过代理来实现，有三种实现方式：动态代理，CGLIB，AspectJ 。
动态代理只能对存在接口的实现类进行代理，CGLIB可以直接对类进行代理，AspectJ可以在类加载时织入。
参考：
