JDK 动态代理的简单理解

动态代理

代理模式是 Java 中的常用设计模式，代理类通过调用被代理类的相关方法，提供预处理、过滤、事后处理等服务，动态代理及通过反射机制动态实现代理机制。JDK 中的 java.lang.reflect.Proxy 类可以用来实现动态代理。

首先，准备一个简单的接口和实现类

 /**
  * 接口 IHello.java
  */
 public interface IHello {
     void hello();
 }

 /**
  * 实现类 Hello.java
  */
 public class Hello implements IHello {
     @Override
     public void hello() {
         System.out.println("我是Hello.");
     }
 }

通过 Proxy 实现动态代理

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

 import org.junit.Test;

 public class HelloTest {
     @Test
     public void testProxy() throws Exception {
         final IHello hello = new Hello();

         /*
          * proxyHello    : 代理主题角色，代理类的实例
          * IHello        : 抽象主题角色，代理类和被代理类都需要实现的接口，JDK中的动态代理必须针对接口
          * hello         : 真实主题角色，被代理类的实例
          */
         IHello proxyHello = (IHello) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                 new Class[] { IHello.class }, new InvocationHandler() {

                     /*
                      * @param proxy : 当前代理类的一个实例； 若在invoke()方法中调用proxy的非final方法，将造成无限循环调用.
                      */
                     @Override
                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                         // 前置的业务逻辑操作
                         System.out.println("---开始");

                         // 调用被代理类的方法，传入参数args，得到返回
                         Object object = method.invoke(hello, args);

                         // 后置的业务逻辑操作
                         System.out.println("---结束");

                         return object;
                     }
                 });

         proxyHello.hello();
     }
 }