静态代理与动态代理

1.  摘要

代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。

为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。

1.  静态代理

编写一个接口类：

package com.cdut.proxy;

/**
 * 接口
 * @author 李海全
 * 2013-3-29
 *
 */
public interface UserManager {

	
	public void adduser(String username);
	
	public void delUser(int id);
	
}

接口实现：

package com.cdut.proxy;

/**
 * 接口实现类
 * @author 李海全
 * 2013-3-29
 *
 */
public class UserManagerImpl implements UserManager {
@Override
	public void adduser(String username) {
		System.out.println("-----------UserManagerImpl.addUser()----------");
	}

	@Override
	public void delUser(int id) {
		System.out.println("-----------UserManagerImpl.delUser()----------");
	}

}

编写静态代理类UserManagerImplProxy，实现UserManager接口：

package com.cdut.proxy;

/**
 * 静态代理类,在代理中实现在方法执行前和方法执行后检查
 * @author 李海全
 * 2013-3-29
 *
 */
public class UserManagerImplProxy implements UserManager {

	private UserManager userManager;
	
	public UserManagerImplProxy(UserManager userManager) {
		this.userManager = userManager;
	}
	
	@Override
	public void adduser(String username) {
		before();
		this.userManager.adduser(username);
		after();
	}
@Override
	public void delUser(int id) {
		before();
		this.userManager.delUser(id);
		after();
	}
	
	/**
	 * 方法执行前
	 */
	public void before(){
		System.out.println("-----before------------");
	}
	
	/**
	 * 方法执行后
	 */
	public void after(){
		System.out.println("-----after------------");
	}
}

编写客户端：

package com.cdut.proxy;
/**
 * 静态代理类的客户方法 
 * @author 李海全
 * 2013-3-29
 */
public class ClientStaticProxy {

	public static void main(String[] args) {
		 //先实例化一个目标对象   
        UserManager userManager = new UserManagerImpl();  
        //实例化静态代理对象   
        UserManager manager = new UserManagerImplProxy(userManager);  
        //调用代理的目标方法   
        manager.adduser(null);
	}
}

运行结果：

3.动态代理

动态代理类：

package com.cdut.proxy;

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

/**
 * 动态代理类，需要继承InvocationHandler接口,并实现invoke（）方法 
 * @author 李海全
 * 2013-3-29
 *
 */
public class CheckHandler implements InvocationHandler {

	private Object targetObject;

	/**
	 * 代理类声明
	 * @param targetObject 代理对象
	 * @return
	 */
	public Object newProxy(Object targetObject) {
		this.targetObject = targetObject;
		/*
		 * 创建动态代理对象 newProxyInstance方法的参数：
		 *  第一个参数：loader - 定义代理类的类加载器。
		 *  第二个参数：interfaces - * 代理类要实现的接口列表。
		 *  第三个参数：h - 指派方法调用的调用处理程序
		 */
return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),//
				targetObject.getClass().getInterfaces(),//
				this);                    
	}

	
	/**
	 * 在代理实例上处理方法调用并返回结果
	 */
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {

		// 定义返回对象
		Object result = null;
		// 调用before方法
		before();
		// 调用目标对象的方法
		result = method.invoke(this.targetObject, args);
		// 调用after方法
		after();

		return result;

	}

	/**
	 * 方法执行前
	 */
	public void before(){
		System.out.println("-----before------------");
	}
	
	/**
	 * 方法执行后
	 */
	public void after(){
		System.out.println("-----after------------");
	}
}

动态客户端：

package com.cdut.proxy;

import java.lang.reflect.InvocationHandler;

/**
 * 动态代理类的客户方法
 * 
 * @author 李海全 2013-3-29
 * 
 */
public class ClientDynamicProxy {

	public static void main(String[] args) {
		// 获取一个InvocationHandler实现，此处是CheckHandler对象
		CheckHandler handler = new CheckHandler();
		UserManager userManager = (UserManager) handler
				.newProxy(new UserManagerImpl());
		userManager.adduser(null);
		userManager.delUser(0);

	}
}

执行结果：

4.动态代理分析

Java 动态代理机制的出现，使得 Java 开发人员不用手工编写代理类，只要简单地指定一组接口及委托类对象，便能动态地获得代理类。代理类会负责将所有的方法调用分派到委托对象上反射执行，在分派执行的过程中，开发人员还可以按需调整委托类对象及其功能，这是一套非常灵活有弹性的代理框架。

4.1Java动态代理机制

         要了解 Java 动态代理的机制，首先需要了解以下相关的类或接口：

  java.lang.reflect.Proxy：这是 Java 动态代理机制的主类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。 

1. Proxy 的静态方法

// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器
static InvocationHandler getInvocationHandler(Object proxy) 

// 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象
static Class getProxyClass(ClassLoader loader, Class[] interfaces) 

// 方法 3：该方法用于判断指定类对象是否是一个动态代理类
static boolean isProxyClass(Class cl) 

// 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, 
		    InvocationHandler h);

Java.lang.reflect.InvocationHandler：这是调用处理器接口，它自定义了一个 invoke 方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类的代理访问。

清单 2. InvocationHandler 的核心方法

// 该方法负责集中处理动态代理类上的所有方法调用。
//第一个参数既是代理类实例，第二个参数是被调用的方法对象
// 第三个方法是调用参数。
//调用处理器根据这三个参数进行预处理或分派到委托类实例上发射执行
Object invoke(Object proxy, Method method, Object[] args)

每次生成动态代理类对象时都需要指定一个实现了该接口的调用处理器对象（参见 Proxy 静态方法 4 的第三个参数）。
 java.lang.ClassLoader：这是类装载器类，负责将类的字节码装载到 Java 虚拟机（JVM）中并为其定义类对象，然后该类才能被使用。Proxy 静态方法生成动态代理类同样需要通过类装载器来进行装载才能使用，它与普通类的唯一区别就是其字节码是由 JVM 在运行时动态生成的而非预存在于任何一个 .class 文件中。

接下来让我们来了解一下 Java 动态代理机制的一些特点。

首先是动态生成的代理类本身的一些特点。1）包：如果所代理的接口都是 public 的，那么它将被定义在顶层包（即包路径为空），如果所代理的接口中有非 public 的接口（因为接口不能被定义为 protect 或 private，所以除 public 之外就是默认的 package 访问级别），那么它将被定义在该接口所在包（假设代理了 com.cdut.proxy包中的某非 public 接口 A，那么新生成的代理类所在的包就是 com.cdut.proxy），这样设计的目的是为了最大程度的保证动态代理类不会因为包管理的问题而无法被成功定义并访问；2）类修饰符：该代理类具有 final 和 public 修饰符，意味着它可以被所有的类访问，但是不能被再度继承；3）类名：格式是“$ProxyN”，其中 N 是一个逐一递增的阿拉伯数字，代表 Proxy 类第 N 次生成的动态代理类，值得注意的一点是，并不是每次调用 Proxy 的静态方法创建动态代理类都会使得 N 值增加，原因是如果对同一组接口（包括接口排列的顺序相同）试图重复创建动态代理类，它会很聪明地返回先前已经创建好的代理类的类对象，而不会再尝试去创建一个全新的代理类，这样可以节省不必要的代码重复生成，提高了代理类的创建效率。4）类继承关系：该类的继承关系如图：

由图可见，Proxy 类是它的父类，这个规则适用于所有由 Proxy 创建的动态代理类。而且该类还实现了其所代理的一组接口，这就是为什么它能够被安全地类型转换到其所代理的某接口的根本原因。

接下来让我们了解一下代理类实例的一些特点。每个实例都会关联一个调用处理器对象，可以通过 Proxy 提供的静态方法 getInvocationHandler 去获得代理类实例的调用处理器对象。在代理类实例上调用其代理的接口中所声明的方法时，这些方法最终都会由调用处理器的 invoke 方法执行，此外，值得注意的是，代理类的根类 java.lang.Object 中有三个方法也同样会被分派到调用处理器的 invoke 方法执行，它们是 hashCode，equals 和 toString，可能的原因有：一是因为这些方法为 public 且非 final 类型，能够被代理类覆盖；二是因为这些方法往往呈现出一个类的某种特征属性，具有一定的区分度，所以为了保证代理类与委托类对外的一致性，这三个方法也应该被分派到委托类执行。当代理的一组接口有重复声明的方法且该方法被调用时，代理类总是从排在最前面的接口中获取方法对象并分派给调用处理器，而无论代理类实例是否正在以该接口（或继承于该接口的某子接口）的形式被外部引用，因为在代理类内部无法区分其当前的被引用类型。

接着来了解一下被代理的一组接口有哪些特点。首先，要注意不能有重复的接口，以避免动态代理类代码生成时的编译错误。其次，这些接口对于类装载器必须可见，否则类装载器将无法链接它们，将会导致类定义失败。再次，需被代理的所有非 public 的接口必须在同一个包中，否则代理类生成也会失败。最后，接口的数目不能超过 65535，这是 JVM 设定的限制。

最后再来了解一下异常处理方面的特点。从调用处理器接口声明的方法中可以看到理论上它能够抛出任何类型的异常，因为所有的异常都继承于 Throwable 接口，但事实是否如此呢？答案是否定的，原因是我们必须遵守一个继承原则：即子类覆盖父类或实现父接口的方法时，抛出的异常必须在原方法支持的异常列表之内。所以虽然调用处理器理论上讲能够，但实际上往往受限制，除非父接口中的方法支持抛 Throwable 异常。那么如果在 invoke 方法中的确产生了接口方法声明中不支持的异常，那将如何呢？放心，Java 动态代理类已经为我们设计好了解决方法：它将会抛出 UndeclaredThrowableException 异常。这个异常是一个RuntimeException 类型，所以不会引起编译错误。通过该异常的 getCause 方法，还可以获得原来那个不受支持的异常对象，以便于错误诊断。

4.2 Proxy

Proxy 的重要静态变量:

// 映射表：用于维护类装载器对象到其对应的代理类缓存
	private static Map loaderToCache = new WeakHashMap();

// 标记：用于标记一个动态代理类正在被创建中
	private static Object pendingGenerationMarker = new Object();

// 同步表：记录已经被创建的动态代理类类型，主要被方法 isProxyClass 进行相关的判断
	private static Map proxyClasses = Collections
				.synchronizedMap(new WeakHashMap());

// 关联的调用处理器引用
	protected InvocationHandler h;