参考:疯狂Java讲义 第18章
前言
复杂度与耦合的矛盾
开发实际应用的软件系统时,通常会存在相同代码段重复出现的情况,在这种情况下,一般都提取为一个方法,在不同的地方调用。
对于如图18.5所示的软件系统,如果需要修改深色部分的代码,则只要修改一个地方即可,而调用该方法的代码段,不管有多少个地方调用了该方法,都完全无须任何修改,只要被调用方法被修改了,所有调用该方法的地方就会自然改变——通过这种方式,大大降低了软件后期维护的复杂度。
但采用这种方式来实现代码复用依然产生一个重要问题:代码段1、代码段2、代码段3和深色代码段分离开了,但代码段1、代码段2和代码段3又和一个特定方法耦合了!最理想的效果是:代码段1、代码段2和代码段3既可以执行深色代码部分,又无须在程序中以硬编码方式直接调用深色代码的方法,这时就可以通过动态代理来达到这种效果。
使用JDK动态代理
下面是一个简单的JDK动态代理的例子
- 由于JDK动态代理只能为接口创建动态代理,所以下面先提供一个Dog接口。
public interface Dog {
void info();
void run();
}
- 为该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类,该类里包含两个通用方法。
- 提供公共调用的方法
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()方法将会作为代理对象的方法实现。
- 新建 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;
}
}
- 新建一个 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;
}
}
- 测试使用
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代理包含的方法与目标对象包含的方法示意图如图: