设计模式之代理模式(Proxy)

所谓的代理模式，也就是指通过一个代理对象来代替原对象在不改变原来代码的基础上对某一对象进行额外的控制，从而更好的体现对象中的单一职责。但是对于静态代理来说，一个接口只能服务于一种类型，如果要代理方法很多的时候，则要为每一个方法定义接口。这样就要学习一下动态代理和反射机制。这里我们学习一下动态代理。

 

动态代理有两种方式：

一、需要被代理类实现接口，jdk的动态代理就是这种方式

二、通过继承的方式实现，不需要通过实现接口，cglib是这种方式。

 

这里我们细说一下jdk的动态代理：

假如说你想实现在不改变原方法的基础上在方法执行前后增加一些日志来记录执行的信息或进行权限控制、事务提交等，那要怎么做呢，我们来看一个例子：

新建一个接口：

/**
 * 目标对象实现的接口，用JDK来生成代理对象一定要实现一个接口
 * @author zyb
 * @since 2012-8-9
 *
 */
public interface UserService {

	/**
	 * 目标方法 
	 */
	public abstract void add();

}

 

/**
 * 目标对象
 * @author zyb
 * @since 2012-8-9
 *
 */
public class UserServiceImpl implements UserService {

	/* (non-Javadoc)
	 * @see dynamic.proxy.UserService#add()
	 */
	public void add() {
		System.out.println("--------------------add---------------");
	}
}

接下来我们建立一个实现了InvocationHandler接口的处理器，然后使用类java.lang.reflect.Proxy中的静态方法生成一个userService的代理类，并把这个类当做userService使用

 

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

/**
 * 实现自己的InvocationHandler
 * @author zyb
 * @since 2012-8-9
 *
 */
public class MyInvocationHandler implements InvocationHandler {
	
	// 目标对象 
	private Object target;
	
	/**
	 * 构造方法
	 * @param target 目标对象 
	 */
	public MyInvocationHandler(Object target) {
		super();
		this.target = target;
	}


	/**
	 * 执行目标对象的方法
	 */
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		
		// 在目标对象的方法执行之前简单的打印一下
		System.out.println("------------------before------------------");
		
		// 执行目标对象的方法
		Object result = method.invoke(target, args);
		
		// 在目标对象的方法执行之后简单的打印一下
		System.out.println("-------------------after------------------");
		
		return result;
	}

	/**
	 * 获取目标对象的代理对象
	 * @return 代理对象
	 */
	public Object getProxy() {
		return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), 
				target.getClass().getInterfaces(), this);
	}
}

接下来我们创建一个测试类：

public class ProxyTest {

	@Test
	public void testProxy() throws Throwable {
		// 实例化目标对象
		UserService userService = new UserServiceImpl();
		
		// 实例化InvocationHandler
		MyInvocationHandler invocationHandler = new MyInvocationHandler(userService);
		
		// 根据目标对象生成代理对象
		UserService proxy = (UserService) invocationHandler.getProxy();
		
		// 调用代理对象的方法
		proxy.add();
		
	}
}

执行结果为：

-----------before------------
-----------add ------------
-----------after------------

这样我们就实现了在不改变add方法的基础上再方法前后增加了一些内容，这就是jdk的动态代理，通过Proxy类的newProxyInstance生成了代理类。那么动态代理类时如何产生的呢。

1.产生代理类$Proxy0类

执行了Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)

将产生$Proxy0类，它继承Proxy对象，并根据第二个参数，实现了被代理类的所有接口，自然就可以生成接口要实现的所有方法了（这时候会重写hashcode，toString和equals三个方法），但是还没有具体的实现体；

2.    将代理类$Proxy0类加载到JVM中

这时候是根据Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)它的第一个参数----就是被代理类的类加载器，把当前的代理类加载到JVM中

3.    创建代理类$Proxy0类的对象

调用的$Proxy0类的$Proxy0（InvocationHandler）构造函数，生成$Proxy0类的对象

参数就是Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)它的第三个参数

这个参数就是我们自己实现的InvocationHandler对象，我们知道InvocationHandler对象中组合加入了代理类代理的接口类的实现类；所以，$Proxy0对象调用所有要实现的接口的方法，都会调用InvocationHandler对象的invoke（）方法实现；

 

很多开源的框架就是用到了动态代理技术，比如spring的AOP。

对于jdk底层是如何生成二进制class文件的，参考：http://rejoy.iteye.com/blog/1627405