Proxy模式1--JAVA中的代理实现

一。首先需要了解下面3个类的API：java系统支持的代理就是这3个类+反射来实现。

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

 

二。下面的这段测试代码，目的就是：将一个ArrayList对象的操作进行代理，每个method前后都输出一行字符串。

核心代码是

Class clz = ArrayList.class;
Object proxyed_Object = Proxy.newProxyInstance(clz.getClassLoader(),
         clz.getInterfaces(), new MyInvocationHandle(new ArrayList(10)));

生成一个ArrayList的代理的对象。

package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;

/**
 * DEMO:测试java中的代理
 * 
 * 代理了一个ArrayList对象，并在调用方法前后各加了一个systemout输出
 * @author wei.songw
 * 
 */
public class MyInvocationHandle implements InvocationHandler {

	//对代理对象的引用.
	private List aList;

	/**
	 * 构造器。
	 * @param list 代理对象
	 */
	public MyInvocationHandle(Object list) {
		this.aList = (List) list;
	}

	/**
	 * InvocationHandler的方法实现
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		
		//方法前调用，插入一段消息
		System.out.println("before : "+method.getName());
		
		//调用方法.
		Object object = method.invoke(aList, args);
		
		//方法后调用，插入一段消息
		System.out.println("after : "+method.getName());
		
		return object;
	}



	public static void main(String[] args) {
		//需要代理一个ArrayList对象，因此按照API构造一个Proxy对象
		//,同时也初始化了处理Proxy的MyInvocationHandle对象
		Class clz = ArrayList.class;
		Object proxyed_Object = Proxy.newProxyInstance(clz.getClassLoader(),
				clz.getInterfaces(), new MyInvocationHandle(new ArrayList(10)));
		
//TEST1:查看一下代理生成类的接口？？？
//		Class<!---->[] itfs = proxyed_Object.getClass().getInterfaces();
//		for (int i = 0; i < itfs.length; i++) {
//			System.out.println(itfs[i].getName());
//		}
		
		//注意！这里操作的是代理类！
		List list = (List)proxyed_Object;
		list.add(Integer.valueOf(10));
		
//TEST2:输出一下list的大小，确认add方法被调用		
//		System.out.println(list.size());
	}
}

输出如下：

before : add
after : add

如果将TEST2段代码去掉注释，可以看到如下输出：

before : add
after : add
before : size
after : size
1

证明add方法确实被调用了。

 三。代理模式的结构图（UML+时序图）

通过UML图可以看到代理类和被代理实际对象实现同一接口/或者一个抽象类，因此外部调用Subject，是感觉不到代理类的存在。

 

问题出现了：上面的测试代码中，被代理ArrayList对象，并未与调用者MyInvocationHandle实现同样的接口 。那是怎么实现代理模式的呢？

看Proxy类的文档，写到：

   /**
     * Returns an instance of a proxy class for the specified interfaces
     * that dispatches method invocations to the specified invocation
     * handler.  This method is equivalent to:
     * 
     *     Proxy.getProxyClass(loader, interfaces).
     *         getConstructor(new Class[] { InvocationHandler.class }).
     *         newInstance(new Object[] { handler });
     * 
     *
     * 
Proxy.newProxyInstance throws
     * IllegalArgumentException for the same reasons that
     * Proxy.getProxyClass does.
     *
     * @param	loader the class loader to define the proxy class
     * @param	interfaces the list of interfaces for the proxy class
     *		to implement
     * @param   h the invocation handler to dispatch method invocations to
     * @return	a proxy instance with the specified invocation handler of a
     *		proxy class that is defined by the specified class loader
     *		and that implements the specified interfaces
     * @throws	IllegalArgumentException if any of the restrictions on the
     *		parameters that may be passed to getProxyClass
     *		are violated
     * @throws	NullPointerException if the interfaces array
     *		argument or any of its elements are null, or
     *		if the invocation handler, h, is
     *		null
     */

返回一个实现指定接口的代理类实例，并绑定方法调用到一个指定的invocation handler.

如果将TEST1段注释去掉，可以看到这个代理对象实现了如下接口：

 java.util.List    java.util.RandomAccess     java.lang.Cloneable      java.io.Serializable

 

并且Proxy.newProxyInstance等同于

     *     Proxy.getProxyClass(loader, interfaces).
     *         getConstructor(new Class[] { InvocationHandler.class }).
     *         newInstance(new Object[] { handler });

这里是部分源码：

	    for (int i = 0; i < interfaces.length; i++) {
		int flags = interfaces[i].getModifiers();
		if (!Modifier.isPublic(flags)) {
		    String name = interfaces[i].getName();
		    int n = name.lastIndexOf('.');
		    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
		    if (proxyPkg == null) {
			proxyPkg = pkg;
		    } else if (!pkg.equals(proxyPkg)) {
			throw new IllegalArgumentException(
			    "non-public interfaces from different packages");
		    }
		}
	    }

 

通过时序图可以看到，外部Client和代理类打交道，而代理类在调用实际对象时可以增加一些有益的操作。