java动态代理学习

前几天看到java的动态代理机制，不知道是啥玩意，然后看了看。死活不知道
invoke(Object proxy, Method m, Object[] args)种的proxy是个什么东西，放在这里有什么用？于是网上到处搜刮，把自己的理解写了写。

/**

 * 相亲接口

 */

public interface XiangQinInterface {

/**

 * 相亲方法

 */

public void xiangQin();

}

/**

 * 张三相亲实现类

 */

public class ZhangSanXiangQinInterfaceImpl implements XiangQinInterface {

public void xiangQin() {

System.out.println("张三去相亲，娶个漂亮老婆。");

}

}

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

/**

 * 相亲可是一辈子的大事，相亲前要准备一下，打扮得帅气些。

 */

public class ReadyInvocationHandler implements InvocationHandler {

//相亲接口的实现类，也就是张三相亲类

private Object zhangSan = null;

public ReadyInvocationHandler(Object realSubject) {

this.zhangSan = realSubject;

}

public Object invoke(Object proxy, Method m, Object[] args) {

Object result = null;

try {

/**

 * 动态代理类$Proxy0调用xiangQin方法时会调用它自己的xiangQin方法，

 * 而它自己的xiangQin方法里面调用的是super.h.invoke(this, , )，也就是父类Proxy的h的invoke方法，

 * 也就是ReadyInvocationHandler类的invoke方法。

 * 所以，invoke(Object proxy, Method m, Object[] args)种的proxy实际上就是动态代理类$Proxy0，

 * 如果你将其强转成XiangQinInterface然后调用它的xiangQin方法，然后它就会调用super.h.invoke(this, , )，这样就会死循环。

 */

/**

 * 网上关于这里最多问题就是Object proxy放在这里用来做什么呢？这个我也不知道，

 * 不过至少我们知道它到底是个什么东西，具体做什么用嘛就不得而知了

 */

System.out.println(proxy.getClass().getSimpleName());

System.out.println("张三相亲前，代理人给他打扮了打扮。");

result = m.invoke(zhangSan, args);

} catch (Exception ex) {

System.exit(1);

}

return result;

}

}

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

/**

 * 张三来到了婚介所(相亲现场)，开始相亲。

 */

public class HunJieSuo {

public static void main(String args[]) {

//先将张三相亲这个相亲的实现类实例化，也就是得到XiangQinInterface接口的一个实例对象

XiangQinInterface zhangSan = new ZhangSanXiangQinInterfaceImpl();

/**

 * 得到ZhangSanXiangQinInterfaceImpl这个类的一个代理类，同时为代理类绑定了一个处理类ReadyInvocationHandler。

 * 听着很绕口，其实就是每次调用ZhangSanXiangQinInterfaceImpl这个子类的xiangQin方法时，

 * 不是zhangSan这个ZhangSanXiangQinInterfaceImpl类的实例去调用，

 * 而是这个ZhangSanXiangQinInterfaceImpl的代理类ReadyInvocationHandler去调用它自己的invoke方法,

 * 这个invoke方法里呢可以调用zhangSan这个实例的xiangQin方法

 */

/**

 * 在java种怎样实现动态代理呢

 * 第一步，我们要有一个接口，还要有一个接口的实现类，而这个实现类呢就是我们要代理的对象，

 * 所谓代理呢也就是在调用实现类的方法时，可以在方法执行前后做额外的工作，这个就是代理。

 * 第二步，我们要自己写一个在要代理类的方法执行时，能够做额外工作的类，而这个类必须继承InvocationHandler接口，

 * 为什么要继承它呢？因为代理类的实例在调用实现类的方法的时候，不会调真正的实现类的这个方法，

 * 而是转而调用这个类的invoke方法（继承时必须实现的方法），在这个方法中你可以调用真正的实现类的这个方法。

 * 第三步，在要用代理类的实例去调用实现类的方法的时候，写出下面两段代码。

 */

XiangQinInterface proxy = (XiangQinInterface) Proxy.newProxyInstance(

zhangSan.getClass().getClassLoader(),

zhangSan.getClass().getInterfaces(),

new ReadyInvocationHandler(zhangSan));

proxy.xiangQin();

/**

 * 这里要解释下中部那段长长的代码的意思，以及具体做了哪些工作？

 * 第一，根据zhangSan.getClass().getClassLoader()这个要代理类的类加载器和

 * zhangSan.getClass().getInterfaces()要代理类所实现的所有的接口

 * 作为参数调用Proxy.getProxyClass(ClassLoader loader, Class<?>... interfaces)

 * 的方法返回代理类的java.lang.Class对象，也就是得到了java动态生成的代理类$Proxy0的Class对象。

 * 同时，java还让这个动态生成的$Proxy0类实现了要代理类的实现的所有接口，并继承了Proxy接口。

 * 第二，实例化这个动态生成的$Proxy0类的一个实例，实例化代理类的构造函数为Proxy(InvocationHandler h)，

 * 也就是说要实例化这个动态生成的$Proxy0类，必须给它一个InvocationHandler参数，也就是我们自己实现的用来在代理类

 * 方法执行前后做额外工作的类ReadyInvocationHandler。

 * 这段代码Proxy.newProxyInstance(zhangSan.getClass().getClassLoader(),zhangSan.getClass().getInterfaces(),new ReadyInvocationHandler(zhangSan))

 * 得到的其实是一个类名叫$Proxy0 extends Proxy implements XiangQinInterface的类。

 * 第三，将这个$Proxy0类强制转型成XiangQinInterface类型，调用xiangQin方法。

 */

}

}

 

 

下面是对源码的分析了，想挑战自己么，继续哦

 

java 动态代理深度学习(Proxy,InvocationHandler),含$Proxy0源码

java 动态代理深度学习,

一.相关类及其方法:

java.lang.reflect.Proxy,
Proxy 提供用于创建动态代理类和实例的静态方法.
newProxyInstance()
返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序
(详见api文档)

java.lang.reflect.InvocationHandler,
InvocationHandler 是代理实例的调用处理程序 实现的接口。
invoke()
在代理实例上处理方法调用并返回结果。在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法。
(详见api文档)

二.源代码:

被代理对象的接口及实现类:
package com.ml.test;

public interface Manager {
public void modify();
}

package com.ml.test;

public class ManagerImpl implements Manager {

@Override
public void modify() {
 System.out.println("*******modify()方法被调用");
}
}

业务代理类:
package com.ml.test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class BusinessHandler implements InvocationHandler {

private Object object = null;

public BusinessHandler(Object object) {
 this.object = object;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args)
 throws Throwable {
 System.out.println("do something before method");
 Object ret = method.invoke(this.object, args);
 System.out.println("do something after method");
 return ret;

}
}

客户端类:
package com.ml.test;
import java.lang.reflect.Proxy;
public class Client {

public static void main(String[] args) {
 // 元对象(被代理对象)
 ManagerImpl managerImpl = new ManagerImpl();

// 业务代理类
 BusinessHandler securityHandler = new BusinessHandler(managerImpl);

// 获得代理类($Proxy0 extends Proxy implements Manager)的实例.
 Manager managerProxy = (Manager) Proxy.newProxyInstance(managerImpl
 .getClass().getClassLoader(), managerImpl.getClass()
 .getInterfaces(), securityHandler);

managerProxy.modify();
}
}

三.执行结果:
do something before method
*******modify()方法被调用
do something after method

四.机制分析:

Proxy.(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)做了以下几件事.
(1)根据参数loader和interfaces调用方法 getProxyClass(loader, interfaces)创建代理类$Proxy.
$Proxy0类实现了interfaces的接口,并继承了Proxy类.
(2)实例化$Proxy0并在构造方法中把BusinessHandler传过去,接着$Proxy0调用父类Proxy的构造器,为h赋值,如下:
class Proxy{
 InvocationHandler h=null;
 protected Proxy(InvocationHandler h) {
 this.h = h;
 }
 ...
}



下面是本例的$Proxy0类的源码(好不容易才把它提出来):

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Manager {

private static Method m1;
private static Method m0;
private static Method m3;
private static Method m2;

static {
 try {
 m1 = Class.forName("java.lang.Object").getMethod("equals",
 new Class[] { Class.forName("java.lang.Object") });
 m0 = Class.forName("java.lang.Object").getMethod("hashCode",
 new Class[0]);
 m3 = Class.forName("com.ml.test.Manager").getMethod("modify",
 new Class[0]);
 m2 = Class.forName("java.lang.Object").getMethod("toString",
 new Class[0]);
 } catch (NoSuchMethodException nosuchmethodexception) {
 throw new NoSuchMethodError(nosuchmethodexception.getMessage());
 } catch (ClassNotFoundException classnotfoundexception) {
 throw new NoClassDefFoundError(classnotfoundexception.getMessage());
 }
}

public $Proxy0(InvocationHandler invocationhandler) {
 super(invocationhandler);
}

@Override
public final boolean equals(Object obj) {
 try {
 return ((Boolean) super.h.invoke(this, m1, new Object[] { obj }))
 .booleanValue();
 } catch (Throwable throwable) {
 throw new UndeclaredThrowableException(throwable);
 }
}

@Override
public final int hashCode() {
 try {
 return ((Integer) super.h.invoke(this, m0, null)).intValue();
 } catch (Throwable throwable) {
 throw new UndeclaredThrowableException(throwable);
 }
}

public final void modify() {
 try {
 super.h.invoke(this, m3, null);
 return;
 } catch (Error e) {
 } catch (Throwable throwable) {
 throw new UndeclaredThrowableException(throwable);
 }
}

@Override
public final String toString() {
 try {
 return (String) super.h.invoke(this, m2, null);
 } catch (Throwable throwable) {
 throw new UndeclaredThrowableException(throwable);
 }
}
}

接着把得到的$Proxy0实例强制转换成Manager.
当执行managerProxy.modify()方法时,就调用了$Proxy0类中的modify()方法.
在modify方法中,调用父类Proxy中的h的invoke()方法.
即InvocationHandler.invoke();

 

 

最后附上几个URL，都是我学习时看的，觉得不错的。

1. http://kuchaguangjie.iteye.com/blog/924265

2. http://hi.baidu.com/icanf/blog/item/4d205b4b617e5e39afc3ab83.html

3. http://blog.csdn.net/magister_feng/article/details/7454349