设计模式：结构型-代理模式

╰+攻爆jí腚メ 2022-11-17 13:47 194阅读 0赞

### 目录 ###

*  第一章 代理模式介绍
 *  第二章 代理模式实现（静态代理）
 *   *  2.1、抽象主题类
     *  2.2、真实主题类
     *  2.3、代理类
     *  2.4、测试类
 *  第三章 代理模式实现（JDK动态代理）
 *   *  3.1、抽象主题类
     *  3.2、真实主题类
     *  3.3、代理类
     *  3.4、测试类
 *  第四章 代理模式实现（CGLIB动态代理）
 *   *  4.1、抽象主题类
     *  4.2、真实主题类
     *  4.3、代理类
     *  4.4、测试类
 *  第五章 代理模式应用

--------------------

> 项目地址：https://gitee.com/caochenlei/design-pattern

# 第一章 代理模式介绍 #

代理模式的介绍：

在有些情况下，一个客户不能或者不想直接访问另一个对象，这时需要找一个中介帮忙完成某项任务，这个中介就是代理对象。例如，购买火车票不一定要去火车站买，可以通过 12306 网站购买。

代理模式（Proxy Pattern）中，由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。这种类型的设计模式属于结构型模式。

根据代理的创建时期，代理模式分为静态代理和动态代理。

*  静态：由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的 .class 文件就已经存在了。
 *  动态：在程序运行时，运用反射机制动态创建而成。

代理模式的优点：

*  代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用。
 *  代理对象可以扩展目标对象的功能。
 *  代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度，增加了程序的可扩展性。

代理模式的缺点：

*  代理模式会造成系统设计中类的数量增加。可以使用动态代理方式，降低系统设计中类的数量。
 *  在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢。
 *  增加了系统的复杂度。

代理模式的场景：

*  远程代理，这种方式通常是为了隐藏目标对象存在于不同地址空间的事实，方便客户端访问。例如，用户申请某些网盘空间时，会在用户的文件系统中建立一个虚拟的硬盘，用户访问虚拟硬盘时实际访问的是网盘空间。
 *  虚拟代理，这种方式通常用于要创建的目标对象开销很大时。例如，下载一幅很大的图像需要很长时间，因某种计算比较复杂而短时间无法完成，这时可以先用小比例的虚拟代理替换真实的对象，消除用户对服务器慢的感觉。
 *  安全代理，这种方式通常用于控制不同种类客户对真实对象的访问权限。
 *  智能指引，主要用于调用目标对象时，代理附加一些额外的处理功能。例如，增加计算真实对象的引用次数的功能，这样当该对象没有被引用时，就可以自动释放它。
 *  延迟加载，指为了提高系统的性能，延迟对目标的加载。例如，Hibernate 中就存在属性的延迟加载和关联表的延时加载。

代理模式的角色：

*  抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。
 *  真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
 *  代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。

![fecac36f198c776fdb6969c2df4b03e2.gif][]

# 第二章 代理模式实现（静态代理） #

## 2.1、抽象主题类 ##

UserDao

public interface UserDao { 
        public void save();
    
        public void delete();
    
        public void update();
    
        public void find();
    }

## 2.2、真实主题类 ##

UserDaoImpl

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

## 2.3、代理类 ##

UserDaoProxy

public class UserDaoProxy implements UserDao { 
        private UserDao userDao;
    
        public UserDaoProxy(UserDao userDao) { 
            this.userDao = userDao;
        }
    
        @Override
        public void save() { 
            userDao.save();
        }
    
        @Override
        public void delete() { 
            System.out.println("UserDaoProxy 权限校验 ...");
            userDao.delete();
            System.out.println("UserDaoProxy 日志记录 ...");
        }
    
        @Override
        public void update() { 
            userDao.update();
        }
    
        @Override
        public void find() { 
            userDao.find();
        }
    }

## 2.4、测试类 ##

Client

public class Client { 
        public static void main(String[] args) { 
            UserDao userDao = new UserDaoImpl();
            UserDao userDaoProxy = new UserDaoProxy(userDao);
            userDaoProxy.save();
            userDaoProxy.delete();
            userDaoProxy.update();
            userDaoProxy.find();
        }
    }

UserDaoImpl save ...
    UserDaoProxy 权限校验 ...
    UserDaoImpl delete ...
    UserDaoProxy 日志记录 ...
    UserDaoImpl update ...
    UserDaoImpl find ...

# 第三章 代理模式实现（JDK动态代理） #

## 3.1、抽象主题类 ##

UserDao

public interface UserDao { 
        public void save();
    
        public void delete();
    
        public void update();
    
        public void find();
    }

## 3.2、真实主题类 ##

UserDaoImpl

## 3.3、代理类 ##

UserDaoProxy

public class UserDaoProxy { 
        private UserDao userDao;
    
        public UserDaoProxy(UserDao userDao) { 
            this.userDao = userDao;
        }
    
        public UserDao createUserDao() { 
            Class<? extends UserDao> clazz = userDao.getClass();
            UserDao ud = (UserDao) Proxy.newProxyInstance(
                    clazz.getClassLoader(),
                    clazz.getInterfaces(),
                    new InvocationHandler() { 
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                            Object result;
                            if ("delete".equals(method.getName())) { 
                                System.out.println("UserDaoProxy 权限校验 ...");
                                result = method.invoke(userDao, args);
                                System.out.println("UserDaoProxy 日志记录 ...");
                            } else { 
                                result = method.invoke(userDao, args);
                            }
                            return result;
                        }
                    });
            return ud;
        }
    }

## 3.4、测试类 ##

Client

public class Client { 
        public static void main(String[] args) { 
            UserDao userDao = new UserDaoImpl();
            UserDao userDaoProxy = new UserDaoProxy(userDao).createUserDao();
            userDaoProxy.save();
            userDaoProxy.delete();
            userDaoProxy.update();
            userDaoProxy.find();
        }
    }

UserDaoImpl save ...
    UserDaoProxy 权限校验 ...
    UserDaoImpl delete ...
    UserDaoProxy 日志记录 ...
    UserDaoImpl update ...
    UserDaoImpl find ...

# 第四章 代理模式实现（CGLIB动态代理） #

> 注意：本章节需要使用maven工程，在这里不在源码里演示了。

<dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>2.2.2</version>
    </dependency>

## 4.1、抽象主题类 ##

CGLib 动态代理方式可以无需使用抽象主题类。

## 4.2、真实主题类 ##

UserDaoImpl

public class UserDaoImpl { 
        public void save() { 
            System.out.println("UserDaoImpl save ...");
        }
    
        public void delete() { 
            System.out.println("UserDaoImpl delete ...");
        }
    
        public void update() { 
            System.out.println("UserDaoImpl update ...");
        }
    
        public void find() { 
            System.out.println("UserDaoImpl find ...");
        }
    }

## 4.3、代理类 ##

UserDaoImplProxy

public class UserDaoImplProxy { 
        public UserDaoImpl createUserDaoImpl() { 
            //创建增强对象
            Enhancer enhancer = new Enhancer();
            //设置父类对象
            enhancer.setSuperclass(UserDaoImpl.class);
            //设置回调方法
            enhancer.setCallback(new MethodInterceptor() { 
                @Override
                public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { 
                    Object result;
                    if ("delete".equals(method.getName())) { 
                        System.out.println("UserDaoImplProxy 权限校验 ...");
                        result = methodProxy.invokeSuper(proxy, args);
                        System.out.println("UserDaoImplProxy 日志记录 ...");
                    } else { 
                        result = methodProxy.invokeSuper(proxy, args);
                    }
                    return result;
                }
            });
            //返回代理对象
            return (UserDaoImpl) enhancer.create();
        }
    }

## 4.4、测试类 ##

Client

public class Client { 
        public static void main(String[] args) { 
            UserDaoImpl userDaoImplProxy = new UserDaoImplProxy().createUserDaoImpl();
            userDaoImplProxy.save();
            userDaoImplProxy.delete();
            userDaoImplProxy.update();
            userDaoImplProxy.find();
        }
    }

UserDaoImpl save ...
    UserDaoProxy 权限校验 ...
    UserDaoImpl delete ...
    UserDaoProxy 日志记录 ...
    UserDaoImpl update ...
    UserDaoImpl find ...

# 第五章 代理模式应用 #

Spring 使用动态代理实现 AOP 时有两个非常重要的类，即 JdkDynamicAopProxy 类和 CglibAopProxy 类，其类图如下：

![62876834e93e9174ca2e29d7af4fd45f.png][]

Spring 中的代理选择如下：

*  当 Bean 有实现接口时，Spring 会用 JDK 动态代理方式。
 *  当 Bean 没有实现接口时，Spring 会选择 CGLib 动态代理方式。

Spring 可以通过配置强制使用 CGLib 动态代理，只需在 Spring 的配置文件中加入如下代码即可。

<aop:aspectj-autoproxy proxy-target-class="true"/>

[fecac36f198c776fdb6969c2df4b03e2.gif]: /images/20221022/5a0a46eddcb84496afd05ae375913593.png
[62876834e93e9174ca2e29d7af4fd45f.png]: /images/20221022/061f19ec470949dda080938694266481.png