代理模式小案例

qq_46222229

已于 2022-07-22 13:25:35 修改

阅读量324

点赞数 1

文章标签：代理模式

于 2022-07-22 08:52:38 首次发布

本文链接：https://blog.csdn.net/qq_46222229/article/details/125916283

版权

定义：提供了对目标对象另外的访问方式；即通过代理对象访问目标对象，这样做的好处是：可以在目标对象实现的基础上，增强额外的功能，即扩展目标对象的功能

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

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

接口代码如下：


package cn.baisee.service;
/**
* @Description: 用户业务层接口
* @CreateDate: 2021/3/3 16:24
* @UpdateRemark: 修改内容
* @Version: 1.0
*/
public interface UserService {
    /**
    * 添加用户
    */
    void add();
}

实现类：

package cn.baisee.service.impl;
import cn.baisee.service.UserService;
/**
* @Description: 模拟用户业务层实现描述
* @CreateDate: 2021/3/3 16:27
* @UpdateRemark: 修改内容
* @Version: 1.0
*/
public class UserServiceImpl implements UserService {
/**
* 添加用户
*/
    public void add() {
        System.out.println("添加用户！");
    }
}

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

测试类代码：

package cn.baisee.test;
import cn.baisee.service.UserService;
import cn.baisee.service.impl.UserServiceImpl;
/**
* @Description: 代理模式测试类描述
* @CreateDate: 2021/3/3 16:36
* @UpdateRemark: 修改内容
* @Version: 1.0
*/
public class ProxyTest {
/**
* 测试方法
*
* @param args
*/
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        userService.add();
    }
}

上面是已经写好的代码，现需要添加新的需求，我们不能去在 add 方法中直接添加代码
需求：保存用户之前需要判断是否为离职人员重新入职的情况，如果是，则不需要再将用户添加到数据库，只需要将用户状态由离职改为正式员工即可，在添加员工之后，也需要添加新的业务逻辑，比如给新来的员工发送短信，告诉员工一些信息等等

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

代码如下：

package cn.baisee.proxy;
import cn.baisee.service.UserService;
/**
* @Description: 静态代理描述
* @CreateDate: 2021/3/3 16:42
* @UpdateRemark: 修改内容
* @Version: 1.0
*/
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("在原有方法之后写代码------发送短信");
    }
}

测试：

/**
* 测试方法
*
* @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();
}

运行 main 方法：

静态代理：

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

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

jdk 动态代理：

特点：代理对象，不需要实现接口

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

新建 jdk 动态代理类：

代码如下：

package cn.baisee.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @Description: jdk 动态代理
* @CreateDate: 2021/3/3 17:05
* @UpdateRemark: 修改内容
* @Version: 1.0
*/
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;
            }
        });
    }
}

测试：

/**
* 测试方法
*
* @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();
    }
}

注意点：代理对象不需要实现接口，但是目标对象一定要实现接口，否则不能用动态代理

cglib 动态代理：
和静态代理还有 jdk 动态代理的区别：

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

新建代理类：

引入依赖：

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

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

package cn.baisee.proxy;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* @Description: cglib 动态代理描述
* @CreateDate: 2021/3/4 15:57
* @UpdateRemark: 修改内容
* @Version: 1.0
*/
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 方法