文章出自：
http://rejoy.iteye.com/blog/1627405?page=2#comments
http://langyu.iteye.com/blog/410071
和动态代理有关的有两个类
1.interface InvocationHandler
Object invoke(Object proxy, Method method, Object[] args)
2.class Proxy
真正表示动态代理的类，提供两个静态方法:
Class<?> getProxyClass(ClassLoader loader, Class<?>[] interface)
用来产生代理类，参数要提供interface数组，它会生成这些interface的“虚拟实现”，
用来冒充真实的对象。
Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
产生代理对象，多了InvocationHandler参数(只是InvocationHandler接口的实现类)，
它与代理对象关联，当请求分发到代理对象后，会自动执行h.invoke(…)方法，
invoke方法就是我们用来做N多事情的地方 -_-。
利用JDK实现动态代理的例子如下：
Hello.java
package com.yusj.service;
/**
* 目标对象实现的接口,用JDK来生成代理对象一定要实现一个接口
* @author yushaojian
*
*/
public interface Hello {
/**
* 目标方法sayHello
* @param say
*/
public abstract void sayHello(String say) ;
/**
* 目标方法pring
* @param str
*/
public abstract void pring(String str) ;
}
HelloImpl.java
package com.yusj.service.impl;
import com.yusj.service.Hello;
/**
* 目标对象
* @author yushaojian
*
*/
public class HelloImpl implements Hello {
/**
* @see com.yusj.service.Hello#sayHello(String)
*/
@Override
public void sayHello(String say) {
System.out.println("Say hello to "+say) ;
}
/**
* @see com.yusj.service.Hello#pring(String)
*/
@Override
public void pring(String str) {
System.out.println("pring : "+str) ;
}
}
MyInvocationHandler.java
package com.yusj.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 实现自己的InvocationHandler
* @author yushaojian
*
*/
public class MyInvocationHandler implements InvocationHandler {
// 目标对象
private Object target ;
/**
* 构造方法
* @param target 目标对象
*/
public MyInvocationHandler(Object target) {
super() ;
this.target = target ;
}
/**
* 重写执行目标对象的方法
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// 在目标对象的方法执行之前做一些操作
doBefore();
// 执行目标对象方法
Object result = method.invoke(target, args) ;
// 在目标对象的方法执行之后做一些操作
after();
return result;
}
/**
* 获取目标对象的代理对象
* @return 代理对象
*/
public Object getProxy(){
return Proxy.newProxyInstance(Hello.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
private void doBefore() {
System.out.println("before....");
}
private void after() {
System.out.println("after....");
}
}
Test.java
package com.yusj.test;
import com.yusj.proxy.MyInvocationHandler;
import com.yusj.service.Hello;
import com.yusj.service.impl.HelloImpl;
/**
* 动态代理测试类
* @author yushaojian
*
*/
public class Test {
public static void main(String[] args) {
// 实例化目标对象
Hello h = new HelloImpl() ;
// 实例化InvocationHandler
MyInvocationHandler myInvocationHandler = new MyInvocationHandler(h);
// 根据目标对象生成代理对象
Hello proxy = (Hello)myInvocationHandler.getProxy();
// 通过代理对象调用目标方法(这里无论访问哪个方法，都是会把请求转发到myInvocationHandler.invoke)
proxy.sayHello("张三");
proxy.pring("大家好");
/**
* 输出结果:
* before....
* Say hello to 张三
* after....
* before....
* pring : 大家好
* after....
*
*/
}
}
用起来是很简单吧，其实这里基本上就是AOP的一个简单实现了，在目标对象的方法执行之前和执行之后进行了增强。Spring的AOP实现其实也是用了Proxy和InvocationHandler这两个东西的。
用起来是比较简单，但是如果能知道它背后做了些什么手脚，那就更好不过了。首先来看一下JDK是怎样生成代理对象的。既然生成代理对象是用的Proxy类的静态方newProxyInstance，那么我们就去它的源码里看一下它到底都做了些什么？
/**
* loader:类加载器
* interfaces:目标对象实现的接口
* h:InvocationHandler的实现类
*/
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
if (h == null) {
throw new NullPointerException();
}
/*
* Look up or generate the designated proxy class.
*/
Class cl = getProxyClass(loader, interfaces);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
// 调用代理对象的构造方法（也就是$Proxy0(InvocationHandler h)）
Constructor cons = cl.getConstructor(constructorParams);
// 生成代理类的实例并把MyInvocationHandler的实例传给它的构造方法
return (Object) cons.newInstance(new Object[] { h });
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString());
} catch (IllegalAccessException e) {
throw new InternalError(e.toString());
} catch (InstantiationException e) {
throw new InternalError(e.toString());
} catch (InvocationTargetException e) {
throw new InternalError(e.toString());
}
}
我们再进去getProxyClass方法看一下
public static Class<?> getProxyClass(ClassLoader loader,
Class<?>... interfaces)
throws IllegalArgumentException
{
// 如果目标类实现的接口数大于65535个则抛出异常（我XX，谁会写这么NB的代码啊？）
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// 声明代理对象所代表的Class对象（有点拗口）
Class proxyClass = null;
String[] interfaceNames = new String[interfaces.length];
Set interfaceSet = new HashSet(); // for detecting duplicates
// 遍历目标类所实现的接口
for (int i = 0; i < interfaces.length; i++) {
// 拿到目标类实现的接口的名称
String interfaceName = interfaces[i].getName();
Class interfaceClass = null;
try {
// 加载目标类实现的接口到内存中
interfaceClass = Class.forName(interfaceName, false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != interfaces[i]) {
throw new IllegalArgumentException(
interfaces[i] + " is not visible from class loader");
}
// 中间省略了一些无关紧要的代码 .......
// 把目标类实现的接口代表的Class对象放到Set中
interfaceSet.add(interfaceClass);
interfaceNames[i] = interfaceName;
}
// 把目标类实现的接口名称作为缓存（Map）中的key
Object key = Arrays.asList(interfaceNames);
Map cache;
synchronized (loaderToCache) {
// 从缓存中获取cache
cache = (Map) loaderToCache.get(loader);
if (cache == null) {
// 如果获取不到，则新建地个HashMap实例
cache = new HashMap();
// 把HashMap实例和当前加载器放到缓存中
loaderToCache.put(loader, cache);
}
}
synchronized (cache) {
do {
// 根据接口的名称从缓存中获取对象
Object value = cache.get(key);
if (value instanceof Reference) {
proxyClass = (Class) ((Reference) value).get();
}
if (proxyClass != null) {
// 如果代理对象的Class实例已经存在，则直接返回
return proxyClass;
} else if (value == pendingGenerationMarker) {
try {
cache.wait();
} catch (InterruptedException e) {
}
continue;
} else {
cache.put(key, pendingGenerationMarker);
break;
}
} while (true);
}
try {
// 中间省略了一些代码 .......
// 这里就是动态生成代理对象的最关键的地方
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces);
try {
// 根据代理类的字节码生成代理类的实例
proxyClass = defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
// add to set of all generated proxy classes, for isProxyClass
proxyClasses.put(proxyClass, null);
}
// 中间省略了一些代码 .......
return proxyClass;
}
进去ProxyGenerator类的静态方法generateProxyClass，这里是真正生成代理类class字节码的地方。
public static byte[] generateProxyClass(final String name,
Class[] interfaces)
{
ProxyGenerator gen = new ProxyGenerator(name, interfaces);
// 这里动态生成代理类的字节码，由于比较复杂就不进去看了
final byte[] classFile = gen.generateClassFile();
// 如果saveGeneratedFiles的值为true，则会把所生成的代理类的字节码保存到硬盘上
if (saveGeneratedFiles) {
java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction<Void>() {
public Void run() {
try {
FileOutputStream file =
new FileOutputStream(dotToSlash(name) + ".class");
file.write(classFile);
file.close();
return null;
} catch (IOException e) {
throw new InternalError(
"I/O exception saving generated file: " + e);
}
}
});
}
// 返回代理类的字节码
return classFile;
}
现在，JDK是怎样动态生成代理类的字节的原理已经一目了然了。
