详解设计模式：代理模式

深藏阁楼爱情的钟 2023-09-23 17:02 80阅读 0赞

> 代理模式（Proxy Pattern），Java 常见的设计模式之一，是 GoF 的 23 种设计模式中的一种结构型设计模式。
> 
> 代理模式 是指客户端并不直接调用实际的对象，而是通过调用代理对象，来间接的调用实际的对象。代理对象 具备真实对象的功能，并代替真实对象完成相应操作，并能够在操作执行的前后，对操作进行增强处理（为真实对象提供代理，然后供其他对象通过代理访问真实对象）。
> 
> ~
> 
> 本篇内容包括：关于代理模式、代理（静态代理）实现 Demo、代理（动态代理）实现 Demo、代理（CGLIB 动态代理）实现 Demo

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

### 文章目录 ###

*   *  一、关于代理模式
     *   *   *  1、关于代理模式
             *  2、关于代理模式的构成
             *  3、关于代理模式的XML
             *  4、关于代理模式的应用场景
             *  5、关于代理模式的优缺点
     *  二、代理（静态代理）实现 Demo
     *   *   *  1、Demo 实现
             *  2、Demo 测试
     *  三、代理（动态代理）实现 Demo
     *   *   *  1、动态代理
             *  2、Demo 实现
             *  3、Demo 测试
     *  四、代理（CGLIB 动态代理）实现 Demo
     *   *   *  1、CGLIB 动态代理
             *  2、Maven 坐标
             *  3、Demo 实现
             *  4、Demo 测试

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

## 一、关于代理模式 ##

#### 1、关于代理模式 ####

代理模式（Proxy Pattern），Java 常见的设计模式之一，是 GoF 的 23 种设计模式中的一种结构型设计模式。

代理模式 是指客户端并不直接调用实际的对象，而是通过调用代理对象，来间接的调用实际的对象。代理对象 具备真实对象的功能，并代替真实对象完成相应操作，并能够在操作执行的前后，对操作进行增强处理（为真实对象提供代理，然后供其他对象通过代理访问真实对象）。

Java 中的代理按照代理类生成时机不同又分为静态代理和动态代理。静态代理代理类在编译期就生成，而动态代理代理类则是在 Java 运行时动态生成。动态代理又有 JDK 代理和 CGLib 代理两种。

#### 2、关于代理模式的构成 ####

适配器模式一般包含三种角色：

*  抽象主题角色（Subject）：通过接口或抽象类声明真实角色实现的业务方法。
 *  代理主题角色（Proxy）：实现抽象角色，是真实角色的代理（访问层），通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。
 *  真实主题角色（RealSubject）：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。

#### 3、关于代理模式的XML ####

![在这里插入图片描述][81cc6e63e65049918bc848efaa31ce80.png_pic_center]

#### 4、关于代理模式的应用场景 ####

当无法或不想直接引用某个对象或访问某个对象存在困难时，可以通过代理对象来间接访问。使用代理模式主要有两个目的：一是保护目标对象，二是增强目标对象。

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

#### 5、关于代理模式的优缺点 ####

\# 代理模式的优点：

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

\# 代理模式的缺点：

*  代理模式会造成系统设计中类的数量增加（静态）
 *  在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢（静态）；
 *  增加了系统的复杂度

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

## 二、代理（静态代理）实现 Demo ##

#### 1、Demo 实现 ####

\# Subject 抽象主题

interface Subject {
        void Request();
    }

\# RealSubject 真实主题

class RealSubject implements Subject {
        public void Request() {
            System.out.println("访问真实主题方法...");
        }
    }

\# Proxy 代理

class Proxy implements Subject {
        
        private RealSubject realSubject;
        public void Request() {
        
            if (realSubject == null) {
        
                realSubject = new RealSubject();
            }
            preRequest();
            realSubject.Request();
            postRequest();
        }
        public void preRequest() {
        
            System.out.println("访问真实主题之前的预处理。");
        }
        public void postRequest() {
        
            System.out.println("访问真实主题之后的后续处理。");
        }
    }

#### 2、Demo 测试 ####

\# 测试

public class Client {
        
        public static void main(String[] args) {
        
            Proxy proxy = new Proxy();
            proxy.Request();
        }
    }

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

## 三、代理（动态代理）实现 Demo ##

#### 1、动态代理 ####

由于静态代理只能够对一种类型（接口）进行代理，如果想要对多种类型进行代理的话就需要创建多个代理类，为了弥补了静态代理的不足，从而出现了动态代理，使用反射技术实现

反射包 java.lang.reflect, 里面有三个类：InvocationHandler, Method, Proxy。

#### 2、Demo 实现 ####

\# SellTickets 抽象主题

public interface SellTickets {
        
        void sell();
    }

\# TrainStation 真实主题

public class TrainStation implements SellTickets {
        
    
        public void sell() {
        
            System.out.println("火车站卖票");
        }
    }

\# ProxyFactory 代理工厂，用来创建代理对象

public class ProxyFactory {
        
    
        private TrainStation station = new TrainStation();
    
        public SellTickets getProxyObject() {
        
            //使用Proxy获取代理对象
            /*
                newProxyInstance()方法参数说明：
                    ClassLoader loader ： 类加载器，用于加载代理类，使用真实对象的类加载器即可
                    Class<?>[] interfaces ： 真实对象所实现的接口，代理模式真实对象和代理对象实现相同的接口
                    InvocationHandler h ： 代理对象的调用处理程序
             */
            SellTickets sellTickets = (SellTickets) Proxy.newProxyInstance(station.getClass().getClassLoader(),
                    station.getClass().getInterfaces(),
                    new InvocationHandler() {
        
                        /*
                            InvocationHandler中invoke方法参数说明：
                                proxy ： 代理对象
                                method ： 对应于在代理对象上调用的接口方法的 Method 实例
                                args ： 代理对象调用接口方法时传递的实际参数
                         */
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
    
                            System.out.println("代理点收取一些服务费用(JDK动态代理方式)");
                            //执行真实对象
                            Object result = method.invoke(station, args);
                            return result;
                        }
                    });
            return sellTickets;
        }
    }

#### 3、Demo 测试 ####

\# 测试

public class Client {
        
        public static void main(String[] args) {
        
            //获取代理对象
            ProxyFactory factory = new ProxyFactory();
            
            SellTickets proxyObject = factory.getProxyObject();
            proxyObject.sell();
        }
    }

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

## 四、代理（CGLIB 动态代理）实现 Demo ##

#### 1、CGLIB 动态代理 ####

同样是上面的案例，我们再次使用 CGLIB 代理实现。

如果没有定义 SellTickets 接口，只定义了 TrainStation(火车站类)。很显然 JDK 代理是无法使用了，因为 JDK 动态代理要求必须定义接口，对接口进行代理。

CGLIB 是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为 JDK 的动态代理提供了很好的补充。

#### 2、Maven 坐标 ####

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

#### 3、Demo 实现 ####

//火车站
    public class TrainStation {
        
    
        public void sell() {
        
            System.out.println("火车站卖票");
        }
    }
    
    //代理工厂
    public class ProxyFactory implements MethodInterceptor {
        
    
        private TrainStation target = new TrainStation();
    
        public TrainStation getProxyObject() {
        
            //创建Enhancer对象，类似于JDK动态代理的Proxy类，下一步就是设置几个参数
            Enhancer enhancer =new Enhancer();
            //设置父类的字节码对象
            enhancer.setSuperclass(target.getClass());
            //设置回调函数
            enhancer.setCallback(this);
            //创建代理对象
            TrainStation obj = (TrainStation) enhancer.create();
            return obj;
        }
    
        /*
            intercept方法参数说明：
                o ： 代理对象
                method ： 真实对象中的方法的Method实例
                args ： 实际参数
                methodProxy ：代理对象中的方法的method实例
         */
        public TrainStation intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        
            System.out.println("代理点收取一些服务费用(CGLIB动态代理方式)");
            TrainStation result = (TrainStation) methodProxy.invokeSuper(o, args);
            return result;
        }
    }

#### 4、Demo 测试 ####

//测试类
    public class Client {
        
        public static void main(String[] args) {
        
            //创建代理工厂对象
            ProxyFactory factory = new ProxyFactory();
            //获取代理对象
            TrainStation proxyObject = factory.getProxyObject();
    
            proxyObject.sell();
        }
    }

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

我的博客即将同步至腾讯云开发者社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan?invite\_code=28bx1ao8mslcw

[81cc6e63e65049918bc848efaa31ce80.png_pic_center]: https://img-blog.csdnimg.cn/81cc6e63e65049918bc848efaa31ce80.png#pic_center