更多 Java 高级知识方面的文章，请参见文集《Java 高级知识》
代理模式
- 委托类：具体提供服务
-
代理类：通过调用委托类对象的方法来提供服务。代理类的作用包括：
- 调用具体方法前进行预处理，包括：
- 数据的验证及过滤
- 权限的验证
- 开启事务
- 查询缓存
- 建立数据库连接
- 记录日志等等。
- 调用具体方法后进行后处理，包括：
- 提交事务
- 更新缓存
- 关闭数据库连接
- 记录日志等等。
- 调用具体方法前进行预处理，包括：
代理模式分为两种形式：
- 静态代理：程序运行前，代理类已经存在于 class 字节码文件中，程序运行中只是创建代理类的对象。
- 动态代理：程序运行中动态创建出代理类及其对象（原理：通过反射来动态产生字节码）
静态代理
示例如下：
public class Proxy_Test {
public static void main(String[] args) throws Exception {
AddProxy proxy = new AddProxy(new AddImpl());
proxy.add(1, 2);
}
}
// 共同的接口
interface Add {
int add(int a, int b);
}
// 委托类
class AddImpl implements Add {
public int add(int a, int b) {
return a + b;
}
}
// 代理类
class AddProxy implements Add {
// 代理类关联一个委托类对象
private AddImpl impl;
// 通过构造方法传入委托类的对象
public AddProxy(AddImpl impl) {
this.impl = impl;
}
public int add(int a, int b) {
// 预处理，记录日志
System.out.println("Add start");
// 通过调用委托类对象的方法来提供服务
return impl.add(a, b);
}
}
可以看出：
- 委托类和代理类需要实现同一个接口
- 委托类具体提供服务
- 代理类通过调用委托类对象的方法来提供服务，在调用前进行预处理操作，例如记录日志
- 代理类关联一个委托类对象，并通过构造方法传入委托类的对象
静态代理的问题
代理类与委托类一一对应。
如果有多个委托类，例如在上述的例子中存在 AddImpl MinusImpl MultiplyImpl DivideImpl，则需要对应地构造多个代理类，产生重复的代码，因为每个代理类的功能其实都一样，例如记录日志。
动态代理
一个代理类完成全部的代理功能，代理一个或多个委托类。
Proxy 类
所在包：import java.lang.reflect.Proxy;
通过 Proxy 类的 newProxyInstance 方法可以为一个或多个接口动态地创建出代理类及其对象。
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
该方法返回一个代理类对象，该对象实现了指定的接口 Class<?>[] interfaces。
在 newProxyInstance 方法中，会调用如下代码：即在运行时动态生成代理类的字节码，并将字节码转换为代理类的对象。
/*
* Generate the specified proxy class.
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
InvocationHandler 接口
所在包：import java.lang.reflect.InvocationHandler;
实现如下的 invoke 方法：
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
Processes a method invocation on a proxy instance and returns the result. This method will be invoked on an invocation handler when a method is invoked on a proxy instance that it is associated with.
当调用代理类对象的方法时，会自动调用该 invoke 方法。
在该 invoke 方法中进行预处理，调用委托类方法 method，后处理，返回结果。
通过动态代理类实现如上的静态代理功能，完整的代码如下：
public class Proxy_Test {
public static void main(String[] args) throws Exception {
// 动态创建 AddImpl 的代理类对象
Add addProxy = (Add) generateProxy(new AddImpl());
addProxy.add(1, 2);
// 动态创建 MinusImpl 的代理类对象
Minus minusProxy = (Minus) generateProxy(new MinusImpl());
minusProxy.minus(1, 2);
}
public static Object generateProxy(Object obj) {
// 通过 Proxy 类的 newProxyInstance 方法可以为一个或多个接口动态地创建出代理类及其对象
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 预处理，记录日志
System.out.println(method.getName() + " start");
// 实际调用委托类的具体方法
return method.invoke(obj, args);
}
});
}
}
// 共同的接口
interface Add {
int add(int a, int b);
}
interface Minus {
int minus(int a, int b);
}
interface Multiply {
int multiply(int a, int b);
}
interface Divide {
int divide(int a, int b);
}
// 委托类
class AddImpl implements Add {
public int add(int a, int b) {
return a + b;
}
}
class MinusImpl implements Minus {
public int minus(int a, int b) {
return a - b;
}
}
class MultiplyImpl implements Multiply {
public int multiply(int a, int b) {
return a * b;
}
}
class DivideImpl implements Divide {
public int divide(int a, int b) {
return a / b;
}
}
动态代理的原理
调用代理类的方法时 addProxy.add(1, 2);，会自动触发 invoke 方法，invoke 方法中调用委托类的方法 method.invoke(obj, args);。
实际上，invoke 方法不是显示调用的，它是一个回调函数。
动态代理的问题
委托类需要实现某一个接口，例如 AddImpl 需要实现 Add，MinusImpl 需要实现 Minus。
CGLib 可以弥补这个缺陷，不需要实现特定的接口。
CGLib 通过继承来实现，动态产生的代理类实际上为委托类的子类，代理类通过 Method Override 实现了代码增强。
例如：
Enhancer e = new Enhancer();
e.setSuperclass(AddImpl.class);
e.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
// 预处理，记录日志
System.out.println(method.getName() + " start");
return method.invoke(o, objects);
}
});
// 动态产生的代理类实际上为委托类的子类
AddImpl proxy = (AddImpl)e.create();
proxy.add(1, 2);
关于 CGLib 和 JDK Proxy 的比较，可以参见 Stack Overflow
