jdk动态代理源码学习
最近用到了java的动态代理，虽然会用，但不了解他具体是怎么实现，抽空看看了看他的源码。
说到Java的动态代理就不能不说到代理模式，动态代理也就是多了一个’动态’两字,在《大话设计模式》中不是有这句话吗？“反射，反射程序员的快乐”，这里也不例外，他在底层也是使用了反射来创建对象。
一、 为了让我们更加明白的了解动态代理，我们先来复习一下代理模式吧(没有学过的，也得假装复习是复习呀，不然掉面)。
public interface BookManager {
void addBook();
}
1 package com.test; 2 3 public class Library implements BookManager { 4 5 public void addBook() { 6 // TODO Auto-generated method stub 7 System.out.println("增加图书。。。。。"); 8 } 9 10 }
1 package com.test; 2 3 public class Agent implements BookManager { 4 private BookManager library; 5 6 public BookManager getLibrary() { 7 return library; 8 } 9 10 public void setLibrary(BookManager library) { 11 this.library = library; 12 } 13 14 public void addBook() { 15 // TODO Auto-generated method stub 16 System.out.println("添加图书之前"); 17 library.addBook(); 18 System.out.println("添加图书之后"); 19 } 20 21 }
测试代码
package com.test;
public class BookTest {
public static void main(String[] args) {
BookManager library = new Library();
Agent agent = new Agent();
agent.setLibrary(library);
agent.addBook();
}
}
执行结果为
添加图书之前
增加图书。。。。。
添加图书之后
从这里可以看到在代理模式中要求是都实现了相同的接口，所以这样的代码，移植性不强，所以催生出动态代理。动态代理不要求，必须实现相同的接口，减少了代码量。
先上代码
public interface BookFacade {
public void addBook();
}
public class BookFacadeImpl implements BookFacade,system {
public void addBook() {
// TODO Auto-generated method stub
System.out.println("增加图书方法。。。");
}
public void doSys() {
// TODO Auto-generated method stub
System.out.println("dsfsdfsd");
}
}
public class BookFacadeProxy implements InvocationHandler {
private Object target;
/**
* 绑定委托对象并返回一个代理类
* @param target
* @return
*/
public Object bind(Object target) {
this.target = target;
//取得代理对象
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), this); //要绑定接口(这是一个缺陷，cglib弥补了这一缺陷)
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result=null;
System.out.println("事物开始");
//执行方法
System.out.println("ClassLoad"+proxy.getClass().getSimpleName());
result=method.invoke(target, args);
System.out.println("事物结束");
return result;
}
}
public class TestProxy {
public static void main(String[] args) {
BookFacadeProxy proxy = new BookFacadeProxy();
BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());
bookProxy.addBook();
ProxyGeneratorUtils.writeProxyClassToHardDisk("F:/$Proxy11.class");
}
}
我先声明后面这段代码我盗用了其他网友的成果。
先说明用法，再来解释为什么会是这样的呢？
第一步 你必须得声明一个接口，而且在目标类必须实现这个接口，不然你使用动态代理是不会成功的。
第二步 需要实现 InvocationHandler 接口，创建一个代理类，这个代理类里需要重写invoke方法，在这个方法里，需要写上多被代理对象的调用method.invoke(target, args)，如果不知道method.invoke()是做什么用的，可以去看看反射就明白了。参数有两个一个是被代理的对象，第二个就是调用该方法的参数
第三步 需要获得代理对象，可以通过Object Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
方法来生成一个代理对象。
具体的第一个是使用那一个类加载器加载，第二个就是需要绑定的接口，第三个就是持有处理的对象。
测试方法安装你正常调用相应的方法就行。
测试类执行结果如下
事物开始 增加图书方法。。。 事物结束
现在我们知道用法了，按照我们一般考虑问题的思路是，
生成的代理对象，能调用接口的的方法，肯定是实现了接口这是我们的猜想一，这个涉及到代理对象的生成。
第二个调用addBook方法，能执行，invoke方法，他是怎么调用的呢。
那么我们现在就进入源码吧，先来看看对象是怎么生成的。
Returns an instance of a proxy class for the specified interfaces
that dispatches method invocations to the specified invocation
handler.
看看注释就明白了，返回一个代理类的对象，而且还是实现了你进来接口的类
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
if (h == null) {
throw new NullPointerException();
}
/*
* 生成一个代理类
*/
Class<?> cl = getProxyClass(loader, interfaces);
/*
* 通过反射用构造方法生成一个对象
*/
try {
Constructor cons = cl.getConstructor(constructorParams);
return 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());
}
}
上面大家可以看到，生成了一个对象返回去了，这个对象就是我们所说的代理对象，那么我们可以看看这个class 是怎么生成？
public static Class<?> getProxyClass(ClassLoader loader,
Class<?>... interfaces)
throws IllegalArgumentException
{
验证接口的长度
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
这个class 对象就是我们被返回对象的定义
Class<?> proxyClass = null;
/* collect interface names to use as key for proxy class cache */
String[] interfaceNames = new String[interfaces.length];
// for detecting duplicates
Set<Class<?>> interfaceSet = new HashSet<>();
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");
}
/*
* Verify that the Class object actually represents an
* interface.
*/
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
/*
* Verify that this interface is not a duplicate.
*/
if (interfaceSet.contains(interfaceClass)) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
interfaceSet.add(interfaceClass);
interfaceNames[i] = interfaceName;
}
....... 中间省略N多
生成一个代理class文件，这个就是我们要被返回的class 对象
/*
* Generate the specified proxy class.
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces);
try {
proxyClass = defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
/*
这样我们就知道这个代理对象是怎么生成的。
接下来我们第2个问题就是这个invoke 方法是什么时候调用的。
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces);
从这个方法我们可以看出来，他可以生成一个二进制的文件，那么我们把这个文件写到本地就可以看到这个文件了。
public final class $Proxy110 extends Proxy
implements BookFacade
{
private static Method m1;
private static Method m3;
private static Method m0;
private static Method m2;
public $Proxy110(InvocationHandler paramInvocationHandler)
throws
{
super(paramInvocationHandler);
}
public final boolean equals(Object paramObject)
throws
{
try
{
return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final void addBook()
throws
{
try
{
this.h.invoke(this, m3, null);
return;
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
这个是生成