代理模式（Proxy Pattern）

男娘i 2024-03-27 15:06 0阅读 0赞

### **代理模式**定义： ###

提供了对目标对象另外的访问方式；即通过代理对象访问目标对象。

举个例子：猪八戒去找高翠兰结果是孙悟空变的，可以这样理解：把高翠兰的外貌抽象出来，高翠兰和孙悟空都实现了这个接口，猪八戒访问高翠兰的时候看不出来这个是孙悟空，所以说孙悟空是高翠兰代理类。

**优点：** 1、职责清晰。 2、高扩展性（可以在目标对象实现的基础上，增强额外的功能，即扩展目标对象的功能）。 3、智能化。

**缺点：** 1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。 2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

编程中的一个思想：不要随意去修改别人已经写好的代码或者方法，如果需要修改，可以通过代理的方式来扩展方法

> **注意事项：** 1、和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。 2、和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。

#### 代码演示：  ####

创建  maven  项目

模拟业务层代码，创建cn.xs .service.UserService  接口

接口代码如下：

public interface UserService {
    /**
    * 添加用户
    */
    void add();
    }

实现类：

public class UserServiceImpl implements UserService {
    /**
    * 添加用户
    */
    public void add() {
    System.out.println("添加用户！");
    }
    }

创建测试类测试添加方法：

public class ProxyTest {
    /**
    * 测试方法
    *
    * @param args
    */
    public static void main(String[] args) {
    UserService userService = new UserServiceImpl();
    userService.add();
    }
    }

上面是已经写好的代码，现需要添加新的需求，我们不能去在  add  方法中直接添加代码

需求：保存用户之前需要判断是否为离职人员重新入职的情况，如果是，则不需要再将用户添加到数据库，只需要将用户状态由离职改为正式员工即可，在添加员工之后，也需要添加新的业务逻辑，比如给新来的员工发送短信，告诉员工一些信息等

用静态代理完成功能扩展：

新建静态代理类: ProxyStatic

public class ProxyStatic implements UserService {
    /* 需要扩展的目标对象 */
    private UserService userService;
        /**
        * 实例化 UserService 对象
        *
        * @param userService
        */
            public ProxyStatic(UserService userService) {
                this.userService = userService;
            }
        /**
        * 扩展功能的方法
        */
            public void add() {
                System.out.println("在原有方法之前写代码------判断是否是离职人员入职");
                // 原有功能不修改
                userService.add();
                System.out.println("在原有方法之后写代码------发送短信");
            }
    }

测试：

public static void main(String[] args) {
        // UserService userService = new UserServiceImpl();
        // userService.add();
        // 1. 静态代理
        UserService userService = new UserServiceImpl();
        ProxyStatic proxy = new ProxyStatic(userService);
        proxy.add();
    }

运行  main  方法：

![bd6b1b01e7944461acea84297cea0ca2.png][]

> 静态代理： 
> 
> **优点** ：可以在不修改原有保存逻辑的前提下，对原有保存方法进行扩展 
> 
> **缺点** ：因为代理对象需要与目标对象实现相同的接口，所以会有很多代理类，类太多，同时，一旦 
> 
> 接口增加方法，目标对象与代理对象都要维护

用动态代理完成功能扩展：

> **jdk**  **动态代理** ： 
> 
> 特点：代理对象，不需要实现接口 
> 
> 代理对象的生成，是利用  jdk  的  api  ，动态的在内存中构建代理对象（需要我们指定创建代理 
> 
> 对象 / 目标对象实现的接口类型）

新建 jdk 动态代理类：ProxyJdk

public class ProxyJdk {
    /* 声明目标对象 */
    private Object target;
    /**
    * 实例化目标对象
    *
    * @param proxy
    */
    public ProxyJdk(Object target) {
    this.target = target;
    }
    /**
    * 获取代理对象
    *
    * @return
    */
    public Object getProxy() {
        // newProxyInstance 的三个参数：
        // 第一个参数是该类的类加载器
        // 第二个是需要代理实例的接口列表，因为该原因，所以，实例必须要有接口
        // 第三个参数不能为空，代理对象的所有方法调用都被委托到 invoke 方法
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
        target.getClass().getInterfaces(), new InvocationHandler() {
        public Object invoke(Object object, Method method, Object[] args)throws Throwable {
                    System.out.println("在原有方法之前写代码------判断是否是离职人员入职");
                    Object invoke = method.invoke(target, args);
                    System.out.println("在原有方法之后写代码------发送短信");
                    return invoke;
                }
            });
        }
    }

测试：

public static void main(String[] args) {
        // UserService userService = new UserServiceImpl();
        // userService.add();
        // 1. 静态代理
        // UserService userService = new UserServiceImpl();
        // ProxyStatic proxy = new ProxyStatic(userService);
        // proxy.add();
    // 2. jdk 动态代理
        UserService userService = new UserServiceImpl();
        ProxyJdk proxyJdk = new ProxyJdk(userService);
            // 获取代理对象
            Object proxy = proxyJdk.getProxy();
            if (proxy instanceof UserService) {
                ((UserService) proxy).add();
        }
    }

> **cglib**  **动态代理**  **和 静态代理 还有 jdk**  **动态代理的区别**： 
> 
> 静态代理和  jdk  动态代理模式都是要求对象是实现一个接口的目标对象，但是有时候目标对象 
> 
> 只是一个单独的对象，并没有任何的接口，这个时候就可以使用以目标对象子类的方式来实现代理

新建代理类： Proxycglib

引入依赖：

<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.3.4</version>
    </dependency>

代理类实现  MethodInterceptor  接口，代码如下：

public class ProxyCglib implements MethodInterceptor {
    /* 声明动态代理对象 */
    private Object target;
    /**
    * 实例化代理对象
    *
    * @param proxy
    */
    public ProxyCglib(Object target) {
    this.target = target;
    }
    /**
    * 代理功能扩展
    *
    * @param o
    * @param method
    * @param objects
    * @param methodProxy
    * @return
    * @throws Throwable
    */
    public Object intercept(Object o, Method method, Object[] objects,
    MethodProxy methodProxy) throws Throwable {
    System.out.println("在原有方法之前写代码------判断是否是离职人员入职");
    Object invoke = method.invoke(target, objects);
    System.out.println("在原有方法之后写代码------发送短信");
    return invoke;
    }
    /**
    * 获取代理对象
    *
    * @return
    */
    public Object getProxy() {
    // Enhancer允许为非接口类型创建一个Java代理。
    // Enhancer动态创建了给定类型的子类但是拦截了所有的方法。
    // 和Proxy不一样的是，不管是接口还是类他都能正常工作。
    Enhancer enhancer = new Enhancer();
    // 设置代理类字节码，不需要获取接口
    enhancer.setSuperclass(target.getClass());
    // 设置回调，需要传递当前对象
    enhancer.setCallback(this);
    // 创建代理对象并返回
    return enhancer.create();
    }
    }

测试：

/**
    * 测试方法
    *
    * @param args
    */
    public static void main(String[] args) {
    // UserService userService = new UserServiceImpl();
    // userService.add();
    // 1. 静态代理
    // UserService userService = new UserServiceImpl();
    // ProxyStatic proxy = new ProxyStatic(userService);
    // proxy.add();
    // 2. jdk 动态代理
    // UserService userService = new UserServiceImpl();
    // ProxyJdk proxyJdk = new ProxyJdk(userService);
    // 获取代理对象
    // Object proxy = proxyJdk.getProxy();
    // if (proxy instanceof UserService) {
    // ((UserService) proxy).add();
    // }
    // 3. cglib 动态代理
    UserServiceImpl userService = new UserServiceImpl();
    ProxyCglib proxyCglib = new ProxyCglib(userService);
    // 获取代理对象
    Object proxy = proxyCglib.getProxy();
    if (proxy instanceof UserServiceImpl) {
    ((UserService) proxy).add();
    }
    }

> **Enhancer 与 Proxy 的区别：** 
> 
> Enhancer  是  cglib  中的一个类， Proxy  是  jdk  中的 
> 
> Enhancer  既能代理普通的  class  ，也能代理接口。 Enhancer  创建一个被代理对象的子类并且拦截 所有的方法调用（包括从 Object  中继承的  toString  和  hashCode  方法）。 Enhancer  不能拦截  final 方法

[bd6b1b01e7944461acea84297cea0ca2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/7bb1801896034689873fff32e4af1478.png