概述

代理模式（Proxy Pattern）是指为其他对象提供一种代理，以控制对这个对象的访问。
代理对象在客户端和目标对象之间起到中介作用，代理模式属于结构型设计模式。使用
代理模式主要有两个目的：一保护目标对象，二增强目标对象。

静态代理

静态代理很简单，就是代理对象持有目标对象的引用，通过调用代理对象的方法简介调用目标对象。简单看下代码：

  2. /**
  3.  * 通用Mapper接口
  4.  *
  5.  * @author xingxingwu.hand-china.com 
  6.  */
  7. public interface Mapper {
  8.     /**
  9.      * 保存接口
  10.      *
  11.      * @return 保存后的数据
  12.      */
  13.     public void save();
  14. }
  16. /**
  17.  * UserMapper
  18.  *
  19.  * @author xingxingwu.hand-china.com 
  20.  */
  21. public class UserMapper implements Mapper {
  23.     @Override
  24.     public void save() {
  25.         System.out.println("保存用户成功");
  27.     }
  28. }
  30. /**
  31.  * 事务代理处理器
  32.  *
  33.  * @author xingxingwu.hand-china.com 
  34.  */
  35. public class TransactionHandler implements Mapper {
  36.     private Mapper target;
  38.     public TransactionHandler(Mapper target) {
  39.         this.target = target;
  40.     }
  41.     @Override
  42.     public void save() {
  43.         System.out.println("开启事务");
  44.         try {
  45.             target.save();
  46.             System.out.println("关闭事务");
  47.         } catch (Exception e) {
  48.             System.out.println("事务回滚");
  49.         }
  51.     }
  52. }
  54. public class Client {
  56.     public static void main(String[] args) {
  57.         TransactionHandler transactionHandler = new TransactionHandler(new UserMapper());
  58.         transactionHandler.save();
  59.     }
  61. }
  63. 执行结果：
  64. 开启事务
  65. 保存用户成功
  66. 关闭事务

静态代理有很大的局限性，只能通过手动完成代理操作，如果被代理类增加新的方法，代理类需要同步
新增，违背开闭原则。

动态代理

动态代理和静态对比基本思路是一致的，只不过动态代理功能更加强大，随着业务的扩展适应性更强。使用动态代理相当于是能够适应复杂的业务场景。

JDK动态代理

还是以事务处理为例，我们修改TransactionHandler的实现方式：

  1. **
  2.  * 事务代理处理器
  3.  *
  4.  * @author xingxingwu.hand-china.com 
  5.  */
  6. public class TransactionHandler implements InvocationHandler {
  7.     private Object target;
  9.     public TransactionHandler(Object target) {
  10.         this.target = target;
  11.     }
  13.     public static Object getInstance(Object target) {
  14.         Class<?> clazz = target.getClass();
  15.         return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), new TransactionHandler(target));
  16.     }
  18.     @Override
  19.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  20.         System.out.println("开启事务");
  21.         Object obj = null;
  22.         try {
  23.             obj = method.invoke(this.target, args);
  24.             System.out.println("关闭事务");
  25.         } catch (Exception e) {
  26.             System.out.println("事务回滚");
  27.         }
  28.         return obj;
  29.     }
  30. }

客户端逻辑也要修改：

  1. public class Client {
  2.     public static void main(String[] args) {
  3.          Mapper userMapper = (Mapper) TransactionHandler.getInstance(new UserMapper());
  4.             userMapper.save();
  5.     }
  7. }
  9. 执行结果：
  10. 开启事务
  11. 保存用户成功
  12. 关闭事务

上述代码我们基于JDK Proxy实现了动态代理。JDK Proxy底层是基于字节码重组实现的。如果想了解实现源码，请参考另外一篇文章。