Java中JDK动态代理

参考：疯狂Java讲义 第18章

前言

复杂度与耦合的矛盾

开发实际应用的软件系统时，通常会存在相同代码段重复出现的情况，在这种情况下，一般都提取为一个方法，在不同的地方调用。

对于如图18.5所示的软件系统，如果需要修改深色部分的代码，则只要修改一个地方即可，而调用该方法的代码段，不管有多少个地方调用了该方法，都完全无须任何修改，只要被调用方法被修改了，所有调用该方法的地方就会自然改变——通过这种方式，大大降低了软件后期维护的复杂度。

但采用这种方式来实现代码复用依然产生一个重要问题：代码段1、代码段2、代码段3和深色代码段分离开了，但代码段1、代码段2和代码段3又和一个特定方法耦合了！最理想的效果是：代码段1、代码段2和代码段3既可以执行深色代码部分，又无须在程序中以硬编码方式直接调用深色代码的方法，这时就可以通过动态代理来达到这种效果。

使用JDK动态代理

下面是一个简单的JDK动态代理的例子

1. 由于JDK动态代理只能为接口创建动态代理，所以下面先提供一个Dog接口。

public interface Dog {
	void info();
	void run();
}

2. 为该Dog接口提供一个或多个实现类。此处先提供一个简单的实现类：GunDog

public class GunDog implements Dog {

	@Override
	public void info() {
		System.out.println("我是一只猎狗");
	}

	@Override
	public void run() {
		System.out.println("我快速奔跑");
	}

}

上面代码没有丝毫的特别之处，该Dog的实现类仅仅为每个方法提供了一个简单实现。再看需要实现的功能：让代码段1、代码段2和代码段3既可以执行深色代码部分，又无须在程序中以硬编码方式直接调用深色代码的方法。此处假设info()、run()两个方法代表代码段1、代码段2，那么要求：程序执行info()、run()方法时能调用某个通用方法，但又不想以硬编码方式调用该方法。下面提供一个DogUtil类，该类里包含两个通用方法。

3. 提供公共调用的方法

public class DogUtil {
	//第一个拦截器方法
	public void method1() {
		System.out.println("==== 模拟第一个通用方法 ====");
	}
	//第一个拦截器方法
	public void method2() {
		System.out.println("==== 模拟第二个通用方法 ====");
	}
}

借助于 Proxy 和 InvocationHandler就 可 以 实 现—— 当 程 序 调用info() 方 法 和 run() 方 法 时 ， 系 统 可 以 “ 自 动 ” 将 method1() 和method2()两个通用方法插入info()和run()方法中执行。
这个程序的关键在于下面的MyInvokationHandler类，该类是一个InvocationHandler实现类，该实现类的invoke()方法将会作为代理对象的方法实现。

4. 新建 MyInvokationHandler 类，实现 InvoketionHandler 接口

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

public class MyInvocationHandler implements InvocationHandler {
	//需要被代理的对象
	private Object target;
	public void setTarget(Object target) {
		this.target = target;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		DogUtil du = new DogUtil();
		du.method1();// 通用方法1
		// 使用反射，调用目标对象的原来的方法
		Object result = method.invoke(target, args);
		du.method2();// 通用方法2
		return result;
	}

}

5. 新建一个 MyProxyFactory 类，用来创建动态代理类对象

public class MyProxyFactory {
	public static Object getProxy(Object target) throws Exception {
		// 创建一个 MyInvocationHandler 对象，并为其设置 target 目标类。
		MyInvocationHandler handler = new MyInvocationHandler();
		handler.setTarget(target);
		// 创建并返回一个动态代理对象
		Object proxyInstance = Proxy.newProxyInstance(
				ClassLoader.getSystemClassLoader()
				, target.getClass().getInterfaces()
				, handler);
		return proxyInstance;
		
	}
}

6. 测试使用

public class TestDemo {

	public static void main(String[] args) throws Exception {
		Dog dog = new GunDog();
		// 根据目标类，获取动态代理对象
		Dog proxyDog = (Dog) MyProxyFactory.getProxy(dog);
		proxyDog.info();
		proxyDog.run();
	}
/*
==== 模拟第一个通用方法 ====
我是一只猎狗
==== 模拟第二个通用方法 ====
==== 模拟第一个通用方法 ====
我快速奔跑
==== 模拟第二个通用方法 ====
 */
}

总结

不难发现采用动态代理可以非常灵活地实现解耦。通常而言，使用Proxy生成一个动态代理时，往往并不会凭空产生一个动态代理，这样没有太大的实际意义。通常都是为指定的目标对象生成动态代理。
这种动态代理在AOP（Aspect Orient Programming，面向切面编程）中被称为AOP代理，AOP代理可代替目标对象，AOP代理包含了目标对象的全部方法。但AOP代理中的方法与目标对象的方法存在差异：AOP代理里的方法可以在执行目标方法之前、之后插入一些通用处理。
AOP代理包含的方法与目标对象包含的方法示意图如图：