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了，经过改造我们可以实现链化动态代理了，对于实际应用更能体现我们对各个层面上的切入