这段时间在学习spring的AOP，而AOP的基础就是动态代理，所以本文详细介绍代理模式（包括动态代理和静态代理）
代理模式：
代理模式的作用：为其他对象提供一种代理以控制对这个对象的访问。
在某些情况下，一个客户不想或者不能直接引用一个对象，而代理对象可以在客户端和目标对象之间起到中介作用。
静态代理：
1、首先抽象角色类，可以定义一个接口或者抽象类：
<pre name="code" class="java">/**
* 真实对象和代理对象共同的接口
*
*/
public interface Subject
{
public abstract void request();
}2、真实对象，完成实际工作：
/**
* 真实角色
*
*/
public class RealSubject implements Subject
{
public void request()
{
System.out.println("I am realSubejct");
}
}/**
* 代理角色
*
*/
public class ProxySubejct implements Subject
{
//代理对象中含有对真实对象的引用
private RealSubject realSubject;
public void request()
{
//调用真实对象之前的操作
System.out.println("preRequest");
if(null == realSubject)
{
realSubject = new RealSubject();
}
//真实对象完成的动作
realSubject.request();
//调用真实对象后完成的附加操作
System.out.println("post");
}
}4、客户端的调用：
public class Test
{
public static void main(String[] args)
{
Subject subject = new ProxySubejct();
subject.request();
}
}</pre><span style="font-family: SimSun; font-size: 18px;">5、打印结果：</span><p></p><p></p><pre name="code" class="java"><pre name="code" class="java">preRequest
I am realSubejct
post如上展示，静态代理可以实现客户端通过调用代理对象，从而间接调用了真实对象，并且在调用真实对象的同时还可以附件另外一些操作。但静态的代理的缺点是真实对象必须已经存在，且作为代理对象的内部属性，这就意味着一个真实对象必须对应一个代理对象，这样在对象多的情况下会导致类的急剧膨胀；另外如果事先不知道真实角色，该如何使用代理呢？为了解决这两个问题，下面介绍动态代理。
动态代理：
所谓Dynamic Proxy是这样一种class，它是在运行时生成，在生成时必须提供一组接口给它，然后该class就宣称实现了这些接口。你当然可以把它当做接口中的任意一个实例来用。这个动态代理类其实就是一个Proxy，它不会做任何实质性的工作，在生成它的实例的时候必须提供一个handler，由它接管实际的工作。
Java的动态代理类位于java.lang.reflect包下，一般会涉及到两个类：
Proxy：代理类
InvocationHandler:
该接口中仅定义一个方法，
<pre name="code" class="java">public Object invoke(Object proxy, Method method, Object[] args)其中，proxy代指代理类，method指的是被代理的方法，args指的是该方法的参数数组（无参时设置为null）
这个抽象方法在代理类中动态实现。
1、首先定义抽象角色和真实角色：
<pre name="code" class="java">/**
* 抽象角色
*
*/
public interface Subject
{
public abstract void request();
}<pre name="code" class="java">/**
* 真实角色
*
*/
public class RealSubject implements Subject
{
public void request()
{
System.out.println("I am realSubejct");
}
}2、之后定义一个DynamicSubject类：
<pre name="code" class="java">/**
* 该代理类的内部属性是一个object，实际使用的时候可以通过构造器传递一个对象
* 该类实现了invoke方法，该方法中的method.invoke()本质是调用被代理类对象将要执行的方法
* 通过动态代理类，我们可以在执行真实对象方法的前后加入自己额外的方法
*
*/
public class DynamicSubject implements InvocationHandler
{
//对真实对象的引用
private Object obj;
public DynamicSubject(Object obj)
{
this.obj = obj;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable
{
System.out.println("Before calling:" + method);
//通过反射调用方法
method.invoke(obj,args);
System.out.println("After calling:" + method);
return null;
}
}
3、客户端调用：
<pre name="code" class="java">public class Client
{
public static void main(String[] args)
{
RealSubject realSubject = new RealSubject();
InvocationHandler handler = new DynamicSubject(realSubject);
//动态生成代理类，代理类转换成了接口类型
Subject subject = (Subject) Proxy.newProxyInstance(realSubject
.getClass().getClassLoader(), realSubject.getClass()
.getInterfaces(), handler);
//调用代理类的request，实际上是由handler接管，调用handler的invoke()方法
subject.request();
System.out.println(subject.getClass());
}
}
4、运行的结果：
<pre name="code" class="java">Before calling:public abstract void DynamicProxy.Subject.request()
I am realSubejct
After calling:public abstract void DynamicProxy.Subject.request()
class com.sun.proxy.$Proxy0其中$Proxy0为动态生成的代理类的名称。
动态代理模式最关键的地方就是调用代理类的request方法时，为什么会跳转到调用handler对象的invoker()方法，下面我把动态生成的代理类输出并反编译出来。
5、生成动态代理类的方法：
<pre name="code" class="java"> /**
* 将动态代理类输出到文件中
*/
public static void createProxy()
{
String name = "proxy";
byte[] data = ProxyGenerator.generateProxyClass(name,new Class[]{RealSubject.class});
FileOutputStream fos;
try
{
fos = new FileOutputStream(name + ".class");
fos.write(data);
fos.close();
}
catch (FileNotFoundException e)
{
e.printStackTrace();
}
catch (IOException e)
{
e.printStackTrace();
}
}6、将生成的动态代理类proxy.class反编译，展示如下：
<pre name="code" class="java">import DynamicProxy.RealSubject;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class proxy extends Proxy
implements RealSubject
{
private static Method m4;
private static Method m1;
private static Method m3;
private static Method m7;
private static Method m5;
private static Method m9;
private static Method m0;
private static Method m8;
private static Method m6;
private static Method m2;
public proxy(InvocationHandler paramInvocationHandler)
throws
{
super(paramInvocationHandler);
}
public final void wait(long paramLong)
throws InterruptedException
{
try
{
this.h.invoke(this, m4, new Object[] { Long.valueOf(paramLong) });
return;
}
catch (Error|RuntimeException|InterruptedException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
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 request()
throws
{
try
{
this.h.invoke(this, m3, null);
return;
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final Class getClass()
throws
{
try
{
return (Class)this.h.invoke(this, m7, null);
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final void wait()
throws InterruptedException
{
try
{
this.h.invoke(this, m5, null);
return;
}
catch (Error|RuntimeException|InterruptedException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final void notifyAll()
throws
{
try
{
this.h.invoke(this, m9, null);
return;
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final int hashCode()
throws
{
try
{
return ((Integer)this.h.invoke(this, m0, null)).intValue();
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final void notify()
throws
{
try
{
this.h.invoke(this, m8, null);
return;
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final void wait(long paramLong, int paramInt)
throws InterruptedException
{
try
{
this.h.invoke(this, m6, new Object[] { Long.valueOf(paramLong), Integer.valueOf(paramInt) });
return;
}
catch (Error|RuntimeException|InterruptedException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final String toString()
throws
{
try
{
return (String)this.h.invoke(this, m2, null);
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
static
{
try
{
m4 = Class.forName("DynamicProxy.RealSubject").getMethod("wait", new Class[] { Long.TYPE });
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
m3 = Class.forName("DynamicProxy.RealSubject").getMethod("request", new Class[0]);
m7 = Class.forName("DynamicProxy.RealSubject").getMethod("getClass", new Class[0]);
m5 = Class.forName("DynamicProxy.RealSubject").getMethod("wait", new Class[0]);
m9 = Class.forName("DynamicProxy.RealSubject").getMethod("notifyAll", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
m8 = Class.forName("DynamicProxy.RealSubject").getMethod("notify", new Class[0]);
m6 = Class.forName("DynamicProxy.RealSubject").getMethod("wait", new Class[] { Long.TYPE, Integer.TYPE });
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());
}
}
}可以看出，动态代理类实现RealSubject接口，并继承Proxy。直到这里，我们已经很清楚地知道动态代理模式在调用代理类的request方法时，为什么会跳转到调用handler对象的invoker()方法。在反编译中，列出了proxy类所有的方法，其中在reqeust的方法中，就是通过handler对象调用invoker()方法。而handler对象就是通过动态代理类的父类Proxy的构造函数注入的。另外调用的request方法，就是通过反射获取的：
<pre name="code" class="java">m3 = Class.forName("DynamicProxy.RealSubject").getMethod("request", new Class[0]); 
247
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
