动态代理

[quote]
前两天看了网上的一篇文章:用jdk的动态代理实现AOP, 看的还不错，虽然那篇文章是启蒙性质的。

动态代理:
Proxy模式在jive的设计中利用的很充分，jive中利用Proxy模式里进行权限的验证。缺点是对每个核心类都要写一个Proxy，重复代码的地方很多。动态代理的特点是，不要静态的写Proxy类，而是在运行时由jdk自己帮助生成类，然后注入到classloader中去。

代码：
public interface BusinessProcess{
void processBusiness();
}

public class BusinessProcessImpl implements BusinessProcess{
public void processBusiness(){
System.out.println("in businessProcessImpl");
}
}

如果要对BusinessProcessImpl增加权限验证功能，那么静态代理代码：
public class BusinessProcessProxy implements BusinessProcess{
private BusinessProcess target;
public BusinessProcessProxy(BusinessProcess target){
this.target = target;
}

public void processBusiness(){
checkPermission();
this.target.processBusiness();
}
}

动态代理:
public class PermissionHandler implements InvocationHandler {
private Object target;
public LoggerHandler(Object target){
this.target = target;
}

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
checkPermission();
Object result = method.invoke(this.target,args);
return result;
}
}

测试代码：
BusinessProcessImpl impl = new BusinessProcessImpl();
PermissionHandler handler = new PermissionHandler (impl);
BusinessProcess proxy = (BusinessProcess)Proxy.newProxyInstance(impl.getClass().getClassLoader(),impl.getClass().getInterfaces(), handler);
proxy.processBusiness();

//proxy对象是BusinessProcess接口的一个实现类，但是不是BusinessProcessImpl的子类
//! (BusinessProcessImpl)proxy 错误！


看起来好像静态代理和动态代理没什么区别，但是仔细一看，静态代理代理的target只能是BusinessProcess对象，而动态代理却能够代理任何一个Object对象，这就是关键区别。所以程序中不需要为每个核心类写一个Proxy，而公用一个就可以。

动态代理的实现原理：
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
proxyClass = defineClass0(loader, proxyName,proxyClassFile, 0,proxyClassFile.length);
这是java.lang.reflect.Proxy的两行关键代码，第一行代码生成名为proxyName, 实现的接口为interfaces的一个类的字节码。
第二行代码，将生成的字节码注入到classloader中去。

第一次为某个object生成proxyClass可能比较耗费性能，但是Proxy方法作了缓存，可以弥补这一点。此外，动态代理只能够对 interfaces进行动态的代理, 也就是说它先找出需要代理的对象实现的所有的interface, 然后只对所有的这些interface的所有的方法代理，对象除了interfaces以外的方法不予处理。
[/quote]