Java设计模式：静态代理、装饰者、动态代理详解JavaHello, New World!-

代理模式是Java常见的设计模式之一。
代理模式是指不直接调用实际对象，而是通过调用代理，来间接的调用实际的对象。

为什么要采用这种间接的形式来调用对象呢？
场景①：不想直接访问实际的对象；
场景②：对实际的对象的访问存在困难；
场景③：有需求需要将封装对象访问/操作的成员方法进行逻辑增强，而不修改原方法；
在现实生活中，这种情形非常的常见，比如请一个律师代理来打官司。

代理模式可以有 2 种实现的方式：
一种是静态代理，另一种是各大框架都喜欢的动态代理。
还有一种类似静态代理的装饰者模式。

现有 User 实体类：

public class User { private int id; // 编号属性 id private String name; // 姓名属性 name public User() { } public User(int id, String name) { this.id = id; this.name = name; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public String toString() { return "User{" + "id=" + id + ", name='" + name + ''' + '}'; } } 

DAO封装数据访问思想：用来封装对实体类 User 类的访问/操作。
UserDao 接口：

public interface UserDao { void add(); void delete(); void update(); void select(); } 

UserDaoImpl 实现类：

public class UserDaoImpl implements UserDao { @Override public void add() { System.out.println("add"); } @Override public void delete() { System.out.println("delete"); } @Override public void update() { System.out.println("update"); } @Override public void select() { System.out.println("select"); } } 

需求：通过 静态代理、装饰者、动态代理模式分别 增强 add() 方法的逻辑功能。

1. 静态代理设计模式

1.1 静态代理 – 实现步骤

① 自定义一个代理类（增强类）实现和被代理类（被增强类）相同的接口
② 在代理类中声明被代理类的对象
③ 在代理类的方法中使用被代理类调用方法

1.2 静态代理 – 逻辑图 & 源码示例

代理类（该类 UserDaoProxy）、被代理类（UserDaoImpl）:

/**  * 静态代理设计模式  */ // 1.实现和被代理类相同的接口 public class UserDaoProxy implements UserDao { // 2.在代理类中声明被代理类的引用 private UserDao userDao; public UserDaoProxy() {         userDao = new UserDaoImpl(); } // 3.在代理类的方法中使用被代理类调用方法 @Override public void add() {         System.out.println("权限校验");         userDao.add();         System.out.println("日志记录"); } @Override public void delete() { userDao.delete(); } @Override public void update() { userDao.update(); } @Override public void select() { userDao.select(); } } 

测试静态代理类；

public class TestProxy { public static void main(String[] args) { // 测试静态代理模式         UserDaoProxy userDaoProxy = new UserDaoProxy();         userDaoProxy.add();         userDaoProxy.delete(); } 

运行结果：

1.3 静态代理 – 优缺

优点：不修改源码增强被代理类的功能，可以控制被代理类的对象
缺点：必须要重写被代理类接口的所有的方法，耦合性高

2. 装饰者设计模式 – 类似静态代理

2.1 装饰者模式 – 实现步骤

① 自定义一个装饰类（增强类）实现和被装饰类（被增强类）相同的接口
② 在装饰类中声明被装饰类的引用
③ 在装饰类的方法中使用被装饰类调用方法

2.2 装饰者模式 – 逻辑图 & 源码示例

装饰类（该类 UserDaoWrapper）、被装饰类（UserDaoImpl）:

/**  * 装饰设计模式  */ // 1.实现和被装饰类相同的接口 public class UserDaoWrapper implements UserDao { // 2.在装饰类中声明被装饰类的引用 private UserDao userDao; public UserDaoWrapper() { } public UserDaoWrapper(UserDao userDao) { this.userDao = userDao; } // 3.在装饰类的方法中使用被装饰类调用方法 @Override public void add() {         System.out.println("权限校验");         userDao.add();         System.out.println("日志记录"); } @Override public void delete() { userDao.delete(); } @Override public void update() { userDao.update(); } @Override public void select() { userDao.select(); } } 

测试装饰者类：

public class TestProxy { public static void main(String[] args) { // 测试装饰设计模式         UserDaoWrapper userDaoWrapper = new UserDaoWrapper(new UserDaoImpl());         userDaoWrapper.add();         userDaoWrapper.delete(); } 

运行结果：

2.3 装饰者模式 – 优缺

优点：不修改源码增强被代理类的功能，无法控制被代理类的对象
缺点：必须要重写被代理类接口的所有的方法，耦合性高

3. 动态代理设计模式【最优】

动态代理是通过反射来实现的，借助Java自带的 java.lang.reflect.Proxy 通过固定的规则生成。
动态代理本质就是通过反射来生成的一个代理。
在Java中 java.lang.reflect 包下提供了一个 Proxy 类和 InvocationHandler 接口，通过使用这个类和接口就可以生成动态代理对象，Proxy类中的方法创建动态代理对象。

JDK提供的代理只能针对接口做代理，有更强大的代理cglib：
一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。

3.1 动态代理设计模式 – 实现步骤

步骤：——基于接口的方法增强
① 编写一个代理类的接口
② 实现一个真正的代理类，实现该接口
③ 创建一个动态的代理类，实现 InvocationHandler 接口，并重写该 invoke() 方法
④ 在测试类中调用 Proxy.newProxyInstance() 方法生成动态代理对象

优化：③④可合并为实现了对应接口匿名内部类替代。
即 在调用该动态代理对象的成员方法时，是 invoke 增强的方法执行。

3.2 动态代理设计模式 – 逻辑图 & 源码示例

Proxy.newProxyInstance() 方法的参数解释：

 /*  * 通过反射来实现的动态代理核心方法     * @loader: 被代理类对应的类加载器     * @interfaces: 被代理类所实现的所有接口     * @h: 一个用以增强代理类的处理器     * @return Object对象     */ @CallerSensitive public static Object newProxyInstance(ClassLoader loader,                                           Class<?>[] interfaces,                                           InvocationHandler h); 

InvocationHandler 接口的 invoke 方法参数解释：

 /**      * 在代理实例上处理方法调用，并返回结果      * @param proxy 代理类的实例      * @param method 被代理类的原方法      * @param args 被代理类的原方法的实际参数      * @return Object对象      */ @Override public Object invoke(Object proxy, Method method, Object[] args); 

匿名内部类直接测试：

public class TestProxy { public static void main(String[] args) {         UserDao userDao = new UserDaoImpl(); //动态代理设计模式：匿名内部类对象         UserDao p = (UserDao) Proxy.newProxyInstance(                 userDao.getClass().getClassLoader(),                 userDao.getClass().getInterfaces(), //Lambda表达式，等价于 new InvocationHandler(){ invoke(){...} } (proxy, method, argss) -> {                     String methodName = method.getName();                     Object result; //方法名比较：只增强指定的需要增强的方法 if ("add".equals(methodName)) {                         System.out.println("权限校验");                         result = method.invoke(userDao, argss);                         System.out.println("日志记录"); } else {                         result = method.invoke(userDao, argss); } return result; });         p.add();         p.delete(); } 

3.3 动态代理设计模式 – 优缺

优点：不需要重写接口中的所有方法，耦合度更低。
缺点：没有，动态代理就是这么任性，这条gai最靓的仔本仔！