动机
- 在面向对象系统中，有些对象由于某种原因（比如对象创建的开销很大，或者某些操作需要安全控制，或者需要进程外的访问等），直接访问会给使用者、或者系统结构代理很多麻烦。
- 如何在不失去透明操作对象的同时来管理/控制这些对象特有的复杂性？增加一层接口是软件开发中常见的解决方式。
模式定义
为其他对象提供一种代理以控制（隔离，使用接口）对这个对象的访问。
类图
总结
- “增加一层间接层”是软件系统中对许多复杂问题的一种常见解决方法。在面向对象系统中，直接使用某些对象会带来很多问题，作为间接层的Proxy对象便是解决这一问题的常用手段。
- 具体Proxy设计模式的实现方法、实现粒度都相差很大，有些可能对某个对象做细粒度的控制，如copy-on-write技术，有些可能对组件模块提供抽象代理层，在架构层次对对象做代理。
- Proxy并不一定要求保持接口完整的一致性，只要能够实现间接控制，有时候损失一些透明性是可以接受的。
- 增加一个代理层，来达成在完成目标功能是实现某些不为外界所感知的功能，比如安全、性能、日志等。典型的就是Spring的切面编程，使用到了的jdk的动态代理和Cglib的字节码代理技术。
实例
场景：
房屋装修，装修公司其实就是代理，真正干活的人是工人师傅，装修公司委托装修工人装修客户的房屋。
三种代理技术
三种代理技术其实都是，创建一个代理类实现一个接口，同时关联被代理类；
不同的是：
静态代理实现的是自己定义的接口；
JDK动态代理实现的是JDK提供的InvocationHandler接口；
Cglib动态代理实现的是Cglib提供的MethodInterceptor接口。
静态代理
总结：
- 代理类和被代理类必须实现相同的接口
- 每次代理一个类，必须手动实现一个代理类，直接造成类数量翻倍，很是麻烦。
- 定义装修房屋的接口
public interface IDecorateHouse {
void decorate();
}
- 装修工人，装修公司分别实现接口，同时装修公司关联装修工人类。
public class DecorationWorker implements IDecorateHouse {
@Override
public void decorate() {
System.out.println("Decoration workers decoration house");
}
}
public class DecorationCompany implements IDecorateHouse {
private DecorationWorker worker;
public DecorationCompany() {
this.worker = new DecorationWorker();
}
@Override
public void decorate() {
System.out.println("Decorate company proxy");
worker.decorate();
}
}
- 客户直接找装修公司装修房子，不再过问具体是谁装修的房子
public class Client {
public static void main(String[] args) {
IDecorateHouse house = new DecorationCompany();
house.decorate();
}
}
JDK动态代理
总结
- JDK的动态代理不需要在为每一个被代理类写一个代理类了。
- 只能代理实现了接口的被代理对象。
- 因为动态代理需要继承被代理类，才能生存代理对象，这是动态代理的实现本质；但是JDK动态代理继承了Proxy类，由于Java语言中不能多继承，导致无法动态代理那么没有实现接口的类对象。
- 设计动态代理工厂类，生成被代理类的代理类
public class DynamicProxyFactory {
private Object target;
public DynamicProxyFactory(Object target) {
this.target = target;
}
public void setTarget(Object target) {
this.target = target;
}
public Object getProxyInstance() {
InvocationHandler handler = (proxy, method, args) -> {
System.out.println("Dynamic proxy decorate house");
Object result = method.invoke(target, args);
return result;
};
Object result = Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
handler);
return result;
}
}
- 客户端调用代理类，需要客户端知道具体的装修工人
public class Client {
public static void main(String[] args) {
DynamicProxyFactory factory = new DynamicProxyFactory(new DecorationWorker());
IDecorateHouse house = (IDecorateHouse)factory.getProxyInstance();
house.decorate();
}
}
Cglib字节码层面代理
总结：
- 实现与JDK代理类基本一致，只不过一个是实现JDK的接口，一个是实现Cglib的接口。
- 因为使用的字节码层面的代理，使用的是继承被代理类的原理。
- Cglib代理也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展。
- Cglib包的底层是通过使用一个小而快的字节码处理框架ASM来转换字节码并生成新的类，不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。
- 因为是使用继承，不能代理final类、类中final和static的方法。
- 性能比较jdk代理高，但是生成速度比jdk动态代理慢，如果是单列模式或者较少创建对象的场景，使用Cglib代理比较好。
- Spring AOP切面原理，使用动态代理：如果被代理的对象实现了接口，使用JDK动态代理，如果没有实现接口使用Cglib代理。
- 创建Cglib代理类，实现cglib的方法拦截接口
public class CglibProxyFactory implements MethodInterceptor {
private Object target;
public CglibProxyFactory(Object target) {
this.target = target;
}
public Object getProxyInstance() {
// 创建Enhancer对象，类似JDK中的Proxy类
Enhancer enhancer = new Enhancer();
// 设置代理类的父类，父类就是被代理对象，代理对象继承被代理对象
enhancer.setSuperclass(target.getClass());
// 设置回调函数
enhancer.setCallback(this);
// 创建代理对象
return enhancer.create();
}
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("Cglib proxy decorate house");
// 如果使用proxy(这个是最终生成的代理对象),使用下面的实现
// return methodProxy.invokeSuper(proxy, args);
// 如果使用target(这个是被代理类),使用下面实现
return methodProxy.invoke(target, args);
}
}
- 客户端调用代理类
public class Client {
public static void main(String[] args) {
CglibProxyFactory proxyFactory = new CglibProxyFactory(new DecorationWorker());
IDecorateHouse house = (IDecorateHouse) proxyFactory.getProxyInstance();
house.decorate();
}
}