代理

代理

一、概念

代理模式是常用的Java 设计模式，它的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。按照代理类的创建时期，代理类可分为两种。一种是静态代理另一种是动态代理。

下面用图的形式说明一下代理的框架结构：

可以看到代理类和目标泪都实现了同一个接口，并且客户端不是直接作用于目标类，而是通过了代理类。

二、代理常用模式

1.静态代理

 由程序员创建或由特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。

Service是一个接口

public interface Service {
	public abstract String echo(String msg);
	public abstract Date getDate();
}

ServiceImplement类是是委托类，Service接口的真正实现者

public class ServiceImplement implements Service{

	@Override
	public String echo(String msg) {
	
		return "echo"+msg;
	}

	@Override
	public Date getDate() {
		return new Date();
	}
}

ServiceProxy类是代理类，是通过调用ServiceImplement类的相关方法来提供特定服务的。

public class ServiceProxy implements Service{
	Service service; //表示被代理的Service实例
	ServiceProxy(Service service){
		this.service = service;
	}
	@Override
	public String echo(String msg) {
		System.out.println("开始echo");//预处理
		String retVal = service.echo(msg); //调用被代理的Service实例的echo方法
		System.out.println("结束echo");//事后处理
		return retVal;
	}

	@Override
	public Date getDate() {
		System.out.println("开始执行getDate");//预处理
		Date d =service.getDate();//调用被代理的Service实例的getDate方法
		System.out.println("结束执行getDate");//事后处理
		return d;
	}
}

代理类ServiceProxy的echo()和getDate()方法会分别调用被代理类ServiceImplement对象的echo()和getDate()方法，并且在方法执行前后都会进行简单的操作。

可以看到，类ServiceProxy是由程序员编写的，在程序运行前，它的.class文件就已经存在了，这种方式成为静态代理。

2.动态代理

与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。

Proxy类提供了创建动态代理类及其实例的静态方法。
（1）getProxyClass()静态方法负责创建动态代理类，它的完整定义如下：

public static Class<?> getProxyClass(ClassLoader loader, Class<?>[] interfaces) throws IllegalArgumentException

   参数loader 指定动态代理类的类加载器，参数interfaces 指定动态代理类需要实现的所有接口。

（2）newProxyInstance()静态方法负责创建动态代理类的实例，它的完整定义如下：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler) throws
      IllegalArgumentException

    参数loader 指定动态代理类的类加载器，参数interfaces 指定动态代理类需要实现的所有接口，参数handler 指定与动态代理类关联的 InvocationHandler 对象。
以下两种方式都创建了实现Foo接口的动态代理类的实例：

/**** 方式一 ****/
//创建InvocationHandler对象
InvocationHandler handler = new MyInvocationHandler(...);

//创建动态代理类
Class proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), new Class[] { Foo.class });

//创建动态代理类的实例
Foo foo = (Foo) proxyClass.getConstructor(new Class[] { InvocationHandler.class }).
    newInstance(new Object[] { handler });

/**** 方式二 ****/
//创建InvocationHandler对象
InvocationHandler handler = new MyInvocationHandler(...);

//直接创建动态代理类的实例
Foo foo = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),new Class[] { Foo.class }, handler);

还是以上面静态代理的例子为基础，讲解动态代理的应用，代码如下：

public class ServiceProxyFactory {
	//创建一个实现了Service接口的动态代理的实例
	public static Service getServiceProxy(Service service) {
		//创建一个实现了InvocationHandler接口的实例
		InvocationHandler handler = new InvocationHandler() {

			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				System.out.println("方法开始" + method);
				Object obj = method.invoke(service, args);//调用被代理的Service实例方法
				System.out.println("方法结束" + method);
				return obj;
			}
		};
		return (Service) Proxy.newProxyInstance(
				Service.class.getClassLoader(),
				Service.class.getInterfaces(), handler);//返回Service实例

	}
}

测试代码：

public class Client2 {

	public static void main(String[] args) {
		//创建一个ServiceImplement实例
		Service serviceImpl = new ServiceImplement();
		//获得一个ServiceProxy实例
		Service serviceProxy = ServiceProxyFactory.getServiceProxy(serviceImpl);
		System.out.println("动态代理的名字为："+serviceProxy.getClass().getName());
		System.out.println(serviceProxy.echo("Hello"));//调用echo方法

	}

}

运行Client2，打印结果如下：
动态代理类的名字为$Proxy0
方法开始 public abstract java.lang.String proxy.Service.echo(java.lang.String)
方法结束 public abstract java.lang.String proxy.Service.echo(java.lang.String)
echo:Hello
从结果看出，动态代理类的名字为$Proxy0。

注意到，InvocationHandler 接口为方法调用接口，它声明了负责调用任意一个方法的invoke()方法：
Object invoke(Object proxy,Method method,Object[] args) throws Throwable

参数proxy指定动态代理类实例，参数method指定被调用的方法，参数args 指定向被调用方法传递的参数，invoke()方法的返回值表示被调用方法的返回值。

三、代理的应用

最后来看一个小例子，写一个ArrayList类的代理，实现和ArrayList类中完全相同的功能，并可以计算每个方法运行的时间。

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		final ArrayList<?> tager = new ArrayList();//得到ArrayList对象
		List proxy =(List)Proxy.newProxyInstance(
				List.class.getClassLoader(), 
				ArrayList.class.getInterfaces(),
				new InvocationHandler() {
					
					@Override
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {
						long beginTime = System.currentTimeMillis(); //开始时间
						Thread.sleep(10);
						Object reVal = method.invoke(tager, args); //方法运行
						long endTime = System.currentTimeMillis();
						System.out.println(method.getName()+"运行了"+(endTime-beginTime));//结束时间，共运行了多久
						return reVal;
					}
				});
		proxy.add("你是谁啊啊啊");//实现了和ArrayList一样的方法
		proxy.add("你好");
		proxy.remove("你好");
		System.out.println(proxy.toString());
	}