设计模式（十三）——代理模式(Proxy)

一、理解:

    代理模式,用于为其他对象提供一种代理以控制对该对象的访问。

    为什么不直接使用某个对象，却要“画蛇添足”的在外部增加一层，间接对其进行访问？考虑下面的一些情况：

1、某个图形界面初始化时，实例化某些对象需要较长时间。但我们又不希望界面停顿太久，因此，我们将这些对象的初始化时间进行控制，延迟到第一次使用的时候。

2、对于不同用户，希望提供某个对象的不同方法，以控制该对象的访问权限。

3、我们希望某些远程方法的调用，就如在本地使用一样方便。

以上这些情况下，我们就需要使用代理，用一个代理指向他，而仅提供代理给用户使用。

类图如下：

有以下的注意点：

1、    代理类Proxy和真正的类RealSubject都需要实现共同的接口(或者继承某个类)Subject。

2、    在使用的时候，使用多态的性质，用Proxy替代RealSubject。

3、    Proxy类中，持有对于RealSubject对象的直接访问。

这篇文章的例子还不错：http://gongjiayun.iteye.com/blog/948778

下面是一些常用的代理：     

       (1) 远程代理(Remote Proxy)：为一个位于不同的地址空间的对象提供一个本地的代理对象，这个不同的地址空间可以是在同一台主机中，也可是在另一台主机中，远程代理又称为大使(Ambassador)。
       (2) 虚拟代理(Virtual Proxy)：如果需要创建一个资源消耗较大的对象，先创建一个消耗相对较小的对象来表示，真实对象只在需要时才会被真正创建。
       (3) 保护代理(Protect Proxy)：控制对一个对象的访问，可以给不同的用户提供不同级别的使用权限。
       (4) 缓冲代理(Cache Proxy)：为某一个目标操作的结果提供临时的存储空间，以便多个客户端可以共享这些结果。
       (5) 智能引用代理(Smart Reference Proxy)：当一个对象被引用时，提供一些额外的操作，例如将对象被调用的次数记录下来等。
       在这些常用的代理模式中，有些代理类的设计非常复杂，例如远程代理类，它封装了底层网络通信和对远程对象的调用，其实现较为复杂。

二、Java中的动态代理

    代理模式，在代理类中封装了一些方法，使得更方便的使用真是对象。在java中，提供了动态代理的方法。可以使用Proxy类的newProxyInstance静态方法，实例化一个Proxy对象，提供给用户使用。该方法有3个参数：(ClassLoader loader, Class<?>[] interfaces, InvocationHandlerh)

1、ClassLoader：被代理的类的类加载器。第二个参数中的所有的接口，都由该类加载器加载。

2、Class<?>[] interfaces，提供Proxy类需要实现的接口方法。

3、用户要做的是写一个实现了InvocationHandler接口的类，重写invoke方法，该方法提供截取到方法调用时候的实现方案。

    可是，既然能够通过实现一个类，该类持有真实对象的引用，来提供代理，为什么java还要费神提供给我们动态代理Proxy类呢？

1、有一个无法改变的类，他有几十个方法，我只想重写其中的某一个方法，并且提供原有类的所有方法。用上述的代理方式，需要定义原有的所有方法，调用realSubject.method()，代码冗余。

2、某个类，实现了多个接口，而我只想在代理类中，对某个接口的实现方式进行改变，而在上述的代理方式中，为了接口的一致性，需要实现真实类的所有接口。

一个比较2的代码案例如下：

	interface Run {
		void runit();
		void runit1();
	}
	
	interface Shout {
		void out();
	}

	class Car implements Run, Shout {
		@Override
		public void out() {
			System.out.println("car shout!");
		}

		@Override
		public void runit() {
			System.out.println("car run!");
		}

		@Override
		public void runit1() {
			System.out.println("car run1!");
		}

	}

	class ProxyInvocationHandler implements InvocationHandler {
		// 所有的方法调用，都会在这里截获。转化为该方法的调用
		@Override
		public Object invoke(Object obj, Method method, Object[] aobj)
				throws Throwable {
			System.out.println("proxy invoke!" + method.getName());
			return obj;
		}
	}
	
	public static void main(String[] args) {

		Car c = new Car();
		c.out();
		c.runit();

		Shout s = (Shout) Proxy.newProxyInstance(Shout.class.getClassLoader(),
				new Class<?>[] { Shout.class }, new ProxyInvocationHandler());
		Run r = (Run) Proxy.newProxyInstance(Run.class.getClassLoader(),
				new Class<?>[] { Run.class, Shout.class },
				new ProxyInvocationHandler());

		// 只能将代理对象转为为相应的接口，如下代码编译出错
		// Car cc = (Car) Proxy.newProxyInstance(Car.class.getClassLoader(),
		// new Class<?>[] { Car.class }, new ProxyInvocationHandler());
		s.out();
		r.runit();
		r.runit1();
	}

    Java中的动态代理，由于invoke捕获的方法是在Proxy.newProxyInstance方法的第二个参数中，所指定的接口的方法。因此，可以理解为返回一个类代理接口，该接口将该类实现的指定接口方法进行重写。