设计模式之 - 代理模式（Proxy Pattern）

package cn.aries.pattern.ProxyPattern;
/**
* 人的行为接口
* @author aries
*/
public interface PersonAction { /**
* 说话
*/
public void personSay();
/**
* 跑步
*/
public void personRunning();
/**
* 吃东西
*/
public void personEating();}

package cn.aries.pattern.ProxyPattern;
public class PersonActionImpl implements PersonAction{
@Override
public void personSay() {
System.out.println("人在说话...");
}
@Override
public void personRunning() {
System.out.println("人在跑步...");
}
@Override
public void personEating() {
System.out.println("人在吃东西...");
}
}

package cn.aries.pattern.ProxyPattern;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;public class ProxyPerson implements InvocationHandler{
//被代理的实例对象
PersonAction obj;
private ProxyPerson(PersonAction obj){
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//执行方法之前打印动作开始。
System.out.println(method.getName() + "ation start ...");
//使用反射执行目标方法
method.invoke(obj, args);
//在方法执行结束时打印动作结束。
System.out.println(method.getName() + "ation end ...");
return null;
}
//定义一个静态方法生成代理对象
public static Object getProxyPersonAction(PersonAction obj){
PersonAction proxy = (PersonAction) Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), new ProxyPerson(obj));
return proxy;
}
}

package cn.aries.pattern.ProxyPattern;public class App {
public static void main(String[] args) throws Exception {
//设置系统参数，将生成的代理类的class文件保存到本地
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
PersonAction pa = new PersonActionImpl();
//调用生成代理类的方法
PersonAction proxyPa = (PersonAction) ProxyPerson.getProxyPersonAction(pa);
//用代理对象调用目标方法
proxyPa.personSay();
proxyPa.personRunning();
proxyPa.personEating();
//打印代理对象的父类
System.out.println(proxyPa.getClass().getSuperclass());
}
}

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException{
if (h == null) {
throw new NullPointerException();
}
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
/*
* Look up or generate the designated proxy class.
这里生成代理类的字节码文件
*/
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
//在这里获取代理类的构造函数，从前面的运行结果中可以得知，代理类是Proxy类的子类
//而constructorParams在Proxy类中是一个静态的常量： private static final Class<?>[] constructorParams = { InvocationHandler.class };
//所以这里获取的带InvocationHandler对象为入参的构造函数，也就是其父类Proxy的构造函数：protected Proxy(InvocationHandler h){...}
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
//这里调用newInstance()方法创建代理对象，其内部实现是：return cons.newInstance(new Object[] {h} );使用反射通过含参（hanlder）生成代理对象。
//其中h赋值给了其父类Proxy类的成员变量： protected InvocationHandler h;
//最终在这里生成代理对象并返回
if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
// create proxy instance with doPrivilege as the proxy class may
// implement non-public interfaces that requires a special permission
return AccessController.doPrivileged(new PrivilegedAction<Object>() {
public Object run() {
return newInstance(cons, ih);
}
});
} else {
return newInstance(cons, ih);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString());
}
}

package com.sun.proxy;import cn.aries.pattern.ProxyPattern.PersonAction;
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 PersonAction {
//这五个静态变量前三个m0,m1,m2分别是代理类继承的Object类的hashcode(),equals(),toString()方法
//其他从m3开始是继承的们定义的接口类的方法根据方法的多少m后面的数字递增
private static Method m1;
private static Method m3;
private static Method m5;
private static Method m0;
private static Method m4;
private static Method m2; static {
try {
//这里使用静态代码块对通过反射对代理对象中的方法进行实例化
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
m3 = Class.forName("cn.aries.pattern.ProxyPattern.PersonAction").getMethod("personEating", new Class[0]);
m5 = Class.forName("cn.aries.pattern.ProxyPattern.PersonAction").getMethod("personRunning", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
m4 = Class.forName("cn.aries.pattern.ProxyPattern.PersonAction").getMethod("personSay", new Class[0]);
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());
}
} public $Proxy0(InvocationHandler paramInvocationHandler)throws{
super(paramInvocationHandler);
} //这里是对我们定义的personEating方法进行实现
//根据类文件我们可以看到，代理类继承了Proxy类，所以其成员变量中包含一个Handler实例对象的引用
//在创建代理实例对象的时候，我们使用的protected Proxy(InvocationHandler h) {this.h = h;}这个构造函数
//所以下面的h就是我们传进去的handler对象
//这里使用handler对象调用自己的invoke()方法，m3就是我们要执行的方法，
//后面的方法的参数，如果有参数就传对应的参数，没有就传null
//此时我们明白了代理对象和handler的关系，以及如何调用到invoke()方法有了明确的认识了。
public final void personEating()throws{
try
{
this.h.invoke(this, m3, null);
return;
}catch (Error|RuntimeException localError){
throw localError;
}catch (Throwable localThrowable){
throw new UndeclaredThrowableException(localThrowable);
}
}
//这里原理同上，为了节省空间这里就不贴出来了
public final void personSay(){...}
public final void personRunning(){...} 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 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);
}
} 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);
}
}
}