JDK动态代理说明

       如果我们想实现类似AOP的思想，自己写代码用代理或叫装饰模式也是可以实现的，但这样我们就面临必须给每个需要被装饰（我们暂时就叫它装饰吧）的接口写装饰子类，通过添加自己需要的特定功能并委托实体接口子类完成本体行为。这样我们需要写很多代码，而且很多时候都是重复代码，当然用种种模式可以把重复代码消减到最少，但看起来还是不怎么完美。

       这时候JDK的动态代理就其作用了，它帮我们减少了大量代码的编写工作，使我们可以将注意力放在我们需要添加的特定行为上。那JDK的动态代理又是如何完成的呢？它是通过动态继承基类Proxy并实现我们要代理的接口，将接口实现委托给InvocationHandler中的invoke, 将调用方法以参数形式传给invoke，同时InvocationHandler的子类持有真正的实体类对象以供方法调用。

JDK中动态代理就是代理模式的变体。如图

 


再看一例子：

public interface Hello {

public void say();
}

public class HelloImpl implements Hello {

public void say() {
System.out.println("hello world");
}
}

public class ConcreteInvocationHandler implements InvocationHandler {

private Object realObject;

public ConcreteInvocationHandler(Hello realObject) {
this.realObject = realObject;
}

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("before method operation");
method.invoke(realObject, new Object[0]);
System.out.println("after method operation");
return null;
}
}

public static void main(String[] args) {
Hello hello = (Hello) Proxy.newProxyInstance(Hello.class.getClassLoader(), new Class[] { Hello.class },
new ConcreteInvocationHandler(new HelloImpl()));
hello.say();
}

 

上面的实现已经可以实现我们动态给某个方法添加其他功能了，但是它只能加一次，如果我们能以一种链化的动态代理，可以添加多层拦截那对实际应用可能更有效果，由此我们可以改变一下我们的设计，如图：


 

 

为了更好理解，看下例子。

public interface CustomInvocationHandler extends InvocationHandler {

public void doBefore();

public void doAfter();
}

public abstract class AbstractInvocationHandler implements CustomInvocationHandler {

protected Object realObject;

protected AbstractInvocationHandler successor;

protected AbstractInvocationHandler(Object realObject) {
this.realObject = realObject;
}

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
doBefore();
if (this.successor == null) {
result = method.invoke(this.realObject, args);
} else {
result = successor.invoke(proxy, method, args);
}
doAfter();
return result;
}

public void setSuccessor(AbstractInvocationHandler successor) {
this.successor = successor;
}
}

public class ConcreteInvocationHandler1 extends AbstractInvocationHandler {

protected ConcreteInvocationHandler1(Object realObject) {
super(realObject);
}

public void doAfter() {
System.out.println("doAfter1");
}

public void doBefore() {
System.out.println("doBefore1");
}
}

public class ConcreteInvocationHandler2 extends AbstractInvocationHandler {

protected ConcreteInvocationHandler2(Object realObject) {
super(realObject);
}

public void doAfter() {
System.out.println("doAfter2");
}

public void doBefore() {
System.out.println("doBefore2");
}
}

public class ConcreteInvocationHandler3 extends AbstractInvocationHandler {

protected ConcreteInvocationHandler3(Object realObject) {
super(realObject);
}

public void doAfter() {
System.out.println("doAfter3");
}

public void doBefore() {
System.out.println("doBefore3");
}
}

public class TestLinkedProxy {

public static void main(String[] args) {
Hello hello = new HelloImpl();
ConcreteInvocationHandler1 h1 = new ConcreteInvocationHandler1(hello);
ConcreteInvocationHandler2 h2 = new ConcreteInvocationHandler2(hello);
ConcreteInvocationHandler3 h3 = new ConcreteInvocationHandler3(hello);
h1.setSuccessor(h2);
h2.setSuccessor(h3);
Hello h = (Hello) Proxy.newProxyInstance(Hello.class.getClassLoader(), new Class[] { Hello.class }, h1);
h.say();
}
}

 

再看下运行结果：

doBefore1
doBefore2
doBefore3
hello world
doAfter3
doAfter2
doAfter1

 

OK了，经过改造我们可以实现链化动态代理了，对于实际应用更能体现我们对各个层面上的切入