代理模式
Java动态代理
动态代理实现
代理是一种设计模式。在一些情况下，一个对象并不能或者并不希望被其他某些调用，代理就可以在这其中起到中介的作用。
这样既可以使用真实对象的方法，又可以保护目标对象，还可以在真实方法调用的前后进行一些操作。
常见的代理模式实现方式如下：
定义一个接口：
public interface Subject {
String doSth(String name);
}实现接口：
public class RealSubject implements Subject{
public String doSth(String name) {
return String.format("I'm %s, i am doing Real thing now...",new String[]{name});
}
}如果有这样的情况，我们并不想让测试类直接调用RealSubject的doSth方法。
实现接口，创建一个代理的类，让代理类来调用RealSubject对象的方法 ：
public class ProxySubject implements Subject{
private Subject realSubject;
public ProxySubject(Subject realSubject) {this.realSubject = realSubject ;}
public String doSth(String name) {
System.out.println("Proxy start -----");
System.out.println(realSubject.doSth(name)); // 此处执行真实对象的request方法
System.out.println("Proxy end -----");
return "OK";
}
}测试：
public class Test {
public static void main(String[] args) {
RealSubject realSubject = new RealSubject();
Subject subject = new ProxySubject(realSubject);
subject.doSth("Irving");
}
}返回的结果：
Proxy start —–
I’m Irving, i am doing Real thing now…
Proxy end —–
上面实现了一个简单的代理模式，被代理对象的类(RealSubject)和代理类(ProxySubject)都需要实现同一个接口，这会导致
1. 增加维护的复杂度；将来修改接口的时候要改动两个实现，
2. 增加代码量：而且ProxySubject在这里只做了一个“壳”的作用，特意给它写个类实在有点不划算。
此时的代理方式，在程序运行之前就已经确定了谁代理谁。然后按照固定的方式将被代理的对象传入代理类，然后再调用代理类中的方法。
这是静态代理方式。
JDK提供了一种“动态代理”方式：
动态代理类的源码是在程序运行期间由JVM根据反射等动态机制生成的，所以不存在代理类的字节码文件，代理类和被代理的类是在运行期间确定的代理关系。
接下来看看如何使用动态代理的方式生成上面的接口实现RealSubject的代理。
先实现一个处理器，实现InvocationHandler，invoke方法定义了如何处理方法调用时的逻辑，简单处理下：
public class DynamicProxy implements InvocationHandler{
private Object object;
public DynamicProxy(Object obj){
object = obj;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Dynamic Proxy start -----");
System.out.println(method.invoke(object, args));
System.out.println("Dynamic Proxy end -----");
return "OK";
}
}调用类实现：
public class TestDynamic {
public static void main(String[] args) {
Subject realSubject = new RealSubject();
InvocationHandler invocationHandler = new DynamicProxy(realSubject);
Class cls = realSubject.getClass();
Subject subject = (Subject)Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),invocationHandler);
subject.doSth("IRVING");
}
}从DEBUG说起，可以DEBUG看看生成的Subject subject是什么类型的：
$Proxy0类型的，这明显不是我们自定义的类型。
内部类的定义有规范是 A $ B 的格式，但是这里是以$开头的。感觉应该是标记说明是运行时生成的类对象。
观察发现这个对象可以转化成Subject对象，说明这个类可能是实现了这个接口(也可能继承了这个接口的实现类)。
这个对象是如何生成的？
Proxy.newProxyInstance方法传入了三个参数：
加载被代理类的ClassLoader、被代理类型的接口列表、自定义的InvocationHandler实现。
该方法中，有这样一句：
Class<?> cl = getProxyClass0(loader, interfaces);
核心的，这个方法有如下代码：
String proxyName = proxyPkg + proxyClassNamePrefix + num;
/*
* Verify that the class loader hasn't already
* defined a class with the chosen name.
*/
/*
* Generate the specified proxy class.
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces);
try {
proxyClass = defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
其中的proxyClassNamePrefix 就是：
/** prefix for all proxy class names */
private final static String proxyClassNamePrefix = "$Proxy";所以我们的代理类命名为：$Proxy加上一个数字。
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces);这句生成了代理类的字节数组，并且结合后面一句，从内存中加载出来创建了代理类。
再简要看看ProxyGenerator的generateProxyClass方法：
public static byte[] generateProxyClass(final String var0, Class[] var1) {
ProxyGenerator var2 = new ProxyGenerator(var0, var1);
final byte[] var3 = var2.generateClassFile();
if(saveGeneratedFiles) {
AccessController.doPrivileged(new PrivilegedAction() {
public Void run() {
try {
FileOutputStream var1 = new FileOutputStream(ProxyGenerator.dotToSlash(var0) + ".class");
var1.write(var3);
var1.close();
return null;
} catch (IOException var2) {
throw new InternalError("I/O exception saving generated file: " + var2);
}
}
});
}
return var3;
}除了返回class的字节数组，甚至还发现，如果saveGeneratedFiles参数为true的时候，还能把该class保存到磁盘。
稍微修改下main方法：
public class TestDynamic {
public static void main(String[] args) {
Subject realSubject = new RealSubject();
InvocationHandler invocationHandler = new DynamicProxy(realSubject);
Class cls = realSubject.getClass();
byte[] data = ProxyGenerator.generateProxyClass("$myProxy0", cls.getInterfaces());
FileOutputStream out = null;
try {
out = new FileOutputStream("E:\\$myProxy0.class");
out.write(data);
out.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
}用反编译工具查看class的内容：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $myProxy0 extends Proxy
implements Subject
{
private static Method m1;
private static Method m0;
private static Method m3;
private static Method m2;
public $myProxy0(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 (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
public final int hashCode()
throws
{
try
{
return ((Integer)this.h.invoke(this, m0, null)).intValue();
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
public final String doSth(String paramString)
throws
{
try
{
return (String)this.h.invoke(this, m3, new Object[] { paramString });
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
public final String toString()
throws
{
try
{
return (String)this.h.invoke(this, m2, null);
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
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("Subject").getMethod("doSth", new Class[] { Class.forName("java.lang.String") });
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
return;
}
catch (NoSuchMethodException localNoSuchMethodException)
{
throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
}
catch (ClassNotFoundException localClassNotFoundException)
{
}
throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}$myProxy0类继承自Proxy并且实现了Subject接口。
除了重写了hashCode和equals方法之外，它也有一个doSth方法，这和我们之前静态代理模式的代理是一个方式，并且doSth方法触发了InvocationHandler对象h的invoke方法。也就是我们自己实现的Handler。
即，调用代理的doSth方法，也就是调用了InvocationHandler的invoke方法。
return (String)this.h.invoke(this, m3, new Object[] { paramString });
扫一扫
5593
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
