代理模式介绍（静态代理、jdk动态代理、cglib代理）

已于 2023-12-03 21:18:27 修改
阅读量1k 收藏 22
点赞数 20
分类专栏： 设计模式 文章标签： 代理模式 java 开发语言 动态代理
于 2023-12-03 21:11:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39464523/article/details/134745764
版权

一、静态代理

（一）定义

1、定义

为其他对象提供一种代理以控制对这个对象的访问；

2、涉及到的角色

（1）抽象主题角色：真实主题和代理主题的共同接口，便于在使用真实主题的地方都可以使用代理主题；
（2）代理主题角色：代理类，负责控制对真实主题的引用，在需要的时候创建和删除真实主题，并且在真实主题处理完毕后做预处理和善后处理的工作；
（3）真实主题角色：被代理角色，业务逻辑的具体执行者；

（二）类图

在这里插入图片描述

（三）代码实现

1、抽象主题角色（业务接口）
package com.xiaobai.design_pattern.proxy;

/**
 * @author wangtw
 * @date 2023/12/1 23:03
 * @description 代理模式-抽象主题角色
 */
public interface IGamePlayer {

    /**
     * 打怪
     */
    void killBoss();

    /**
     * 升级
     */
    void upGrade();
}
2、真实主题角色（具体业务功能）
package com.xiaobai.design_pattern.proxy;

/**
 * @author wangtw
 * @date 2023/12/1 23:04
 * @description 代理模式-真实主题角色
 */
public class GamePlayer implements IGamePlayer{

    /**
     * 打怪角色
     */
    private String name;

    public GamePlayer(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    /**
     * 打怪
     */
    @Override
    public void killBoss() {
        System.out.println(this.name + "在打野怪");
    }

    /**
     * 升级
     */
    @Override
    public void upGrade() {
        System.out.println(this.name + "升了1级");
    }
}
3、代理主题角色（代理类）
package com.xiaobai.design_pattern.proxy;

import java.lang.reflect.Field;
import java.util.Date;

/**
 * @author wangtw
 * @date 2023/12/1 23:10
 * @description
 */
public class GamePlayerProxy implements IGamePlayer{

    private IGamePlayer gamePlayer;

    public GamePlayerProxy(IGamePlayer gamePlayer) {
        this.gamePlayer = gamePlayer;
    }

    private void start() {
        System.out.println("开始时间为" + new Date());
    }

    private void end() {
        System.out.println("结束时间为" + new Date());
    }

    /**
     * 获取角色名称
     * @param operateStep
     */
    private void operatePerson(String operateStep) {
        Class<? extends IGamePlayer> aClass = gamePlayer.getClass();
        Field[] declaredFields = aClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            if (declaredField.getName().equals("name")) {
                declaredField.setAccessible(true);
                try {
                    Object name = declaredField.get(gamePlayer);
                    System.out.println(name + operateStep + "操作");
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Override
    public void killBoss() {
        operatePerson("开始");
        start();
        this.gamePlayer.killBoss();
    }

    @Override
    public void upGrade() {
        this.gamePlayer.upGrade();
        operatePerson("结束");
        end();
    }
}
4、测试类
package com.xiaobai.design_pattern.proxy;

import org.junit.jupiter.api.Test;

/**
 * @author wangtw
 * @date 2023/12/1 23:21
 * @description 代理模式测试类
 */
public class ClientDemo {

    @Test
    public void test() {
        IGamePlayer player = new GamePlayer("芈月");
        IGamePlayer proxy = new GamePlayerProxy(player);
        proxy.killBoss();
        proxy.upGrade();
    }
}

输出：

芈月开始操作
开始时间为Sat Dec 02 20:14:09 CST 2023
芈月在打野怪
芈月升了1级
芈月结束操作
结束时间为Sat Dec 02 20:14:09 CST 2023

（四）总结

1、代理模式的优点：
（1）职责清晰：真实角色负责处理实际的业务逻辑，不用关心非本职的事务，通过代理完成附加的事务；
（2）高扩展性：不同的需求可能会有不同的真实角色，只要实现了接口，代理类就可以完全在不做任何修改的情况下代理各种真实主题角色；
2、静态代理模式的缺点：
（1）若抽象主题角色增加功能，会影响代理类；
（2）不同的功能需求可能会有不同的代理类；

二、jdk动态代理

（一）使用动态代理的场景

在程序执行期间，使用jdk的反射机制创建代理类对象，动态指定要代理的对象；
不依赖于业务接口；
静态代理目标很多时，可以使用动态代理，避免静态代理的缺点；

（二）代码实现

1、创建代理类

代理类需要实现InvocationHandler接口，并重写invoke方法，生成代理类对象后，调用目标类实现方法时会调用生成代理对象中的invoke方法

package com.xiaobai.design_pattern.proxy;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Date;

/**
 * @author wangtw
 * @date 2023/12/2 21:36
 * @description jdk动态代理处理器
 */
public class JdkGamePlayerProxy implements InvocationHandler {

    private Object targetObject;

    public JdkGamePlayerProxy(Object object) {
        this.targetObject = object;
    }

    private void start() {
        System.out.println("开始时间为" + new Date());
    }

    private void end() {
        System.out.println("结束时间为" + new Date());
    }

    /**
     * 获取角色名称
     * @param operateStep
     */
    private void operatePerson(String operateStep) {
        Class<?> aClass = this.targetObject.getClass();
        Field[] declaredFields = aClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            if (declaredField.getName().equals("name")) {
                declaredField.setAccessible(true);
                try {
                    Object name = declaredField.get(this.targetObject);
                    System.out.println(name + operateStep + "操作");
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     *
     * @param proxy 代理对象
     * @param method 方法
     * @param args 方法参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("============开始执行" + method.getName() + "方法==============");
        operatePerson("开始");
        start();
        Object invoke = method.invoke(this.targetObject, args);
        operatePerson("结束");
        end();
        System.out.println("============结束执行" + method.getName() + "方法==============");
        return invoke;
    }
}
2、测试方法

使用java.lang.reflect.Proxy#newProxyInstance生成代理对象

@Test
public void jdkProxyTest() {
    //生成代理类文件 在根目录的同级目录，com下
    System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
    IGamePlayer player = new GamePlayer("澜");
    Class<? extends IGamePlayer> playerClass = player.getClass();
    //代理类 实现需要实现InvocationHandler接口，重写invoke方法 传入业务实现类对象
    JdkGamePlayerProxy jdkGamePlayerProxy = new JdkGamePlayerProxy(player);

    // 创建代理类对象
    /**
     *
     loader – the class loader to define the proxy class
     interfaces – the list of interfaces for the proxy class to implement
     h – the invocation handler to dispatch method invocations to
     */
    IGamePlayer proxy = (IGamePlayer) Proxy.newProxyInstance(playerClass.getClassLoader(),
            playerClass.getInterfaces(), jdkGamePlayerProxy);
    System.out.println(proxy.getClass());
    proxy.killBoss();
    proxy.upGrade();
}

在这里插入图片描述
输出：

class com.sun.proxy.$Proxy9
开始执行killBoss方法==
澜开始操作
开始时间为Sat Dec 02 23:27:05 CST 2023
澜在打野怪
澜结束操作
结束时间为Sat Dec 02 23:27:05 CST 2023
结束执行killBoss方法==
开始执行upGrade方法==
澜开始操作
开始时间为Sat Dec 02 23:27:05 CST 2023
澜升了1级
澜结束操作
结束时间为Sat Dec 02 23:27:05 CST 2023
结束执行upGrade方法==

jdk动态代理依赖于java.lang.reflect,里面有三个类:InvocationHandler,Method,Proxy

三、cglib动态代理

（一）说明

1、说明

cglib动态代理需要依赖第三方，以下代码使用spring生态的cglib包（org.springframework.cglib）实现cglib代理；

2、基础类介绍：

org.springframework.cglib.proxy.MethodInterceptor：方法拦截器类；
org.springframework.cglib.proxy.Enhancer：增强类；
org.springframework.cglib.proxy.MethodProxy：方法代理类

（二）代码实现

拦截器需要实现org.springframework.cglib.proxy.MethodInterceptor接口，重写intercept方法，使用org.springframework.cglib.proxy.MethodProxy#invoke执行目标方法

1、拦截器实现
package com.xiaobai.design_pattern.proxy;

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Date;

/**
 * @author wangtw
 * @date 2023/12/3 20:17
 * @description
 */
public class CglibGamePlayerProxy implements MethodInterceptor {

    private Object targetObject;

    public CglibGamePlayerProxy(Object targetObject) {
        this.targetObject = targetObject;
    }

    private void start() {
        System.out.println("开始时间为" + new Date());
    }

    private void end() {
        System.out.println("结束时间为" + new Date());
    }

    /**
     * 获取角色名称
     * @param operateStep
     */
    private void operatePerson(String operateStep) {
        Class<?> aClass = this.targetObject.getClass();
        Field[] declaredFields = aClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            if (declaredField.getName().equals("name")) {
                declaredField.setAccessible(true);
                try {
                    Object name = declaredField.get(this.targetObject);
                    System.out.println(name + operateStep + "操作");
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("============开始执行" + method.getName() + "方法==============");
        operatePerson("开始");
        start();
        Object result = methodProxy.invoke(this.targetObject, objects);
        operatePerson("结束");
        end();
        System.out.println("============结束执行" + method.getName() + "方法==============");
        return result;
    }
}
2、测试方法

使用org.springframework.cglib.proxy.Enhancer对目标类进行增强，并设置回调拦截器

@Test
public void cglibProxyTest() {
    IGamePlayer gamePlayer = new GamePlayer("亚瑟");

    // 对目标方法进行增强
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(IGamePlayer.class); // 设置要代理的父类
    enhancer.setCallback(new CglibGamePlayerProxy(gamePlayer)); // 设置回调的拦截器

    IGamePlayer proxy = (IGamePlayer) enhancer.create(); // 创建代理对象

    proxy.killBoss();
    proxy.upGrade();
}

输出：

开始执行killBoss方法==
亚瑟开始操作
开始时间为Sun Dec 03 20:47:39 CST 2023
亚瑟在打野怪
亚瑟结束操作
结束时间为Sun Dec 03 20:47:39 CST 2023
结束执行killBoss方法==
开始执行upGrade方法==
亚瑟开始操作
开始时间为Sun Dec 03 20:47:39 CST 2023
亚瑟升了1级
亚瑟结束操作
结束时间为Sun Dec 03 20:47:39 CST 2023
结束执行upGrade方法==

参考：

韩敬海 设计模式（Java版）
Java-JDK动态代理
JDK动态代理
动态代理之 cglib 实现

王小白杂货店
关注
专栏目录
代理模式详细讲解
康康要加油的博客
03-11 6416
文章目录一、什么是代理模式？二、 为什么使用代理模式？三、 代理模式的实现1、静态代理1.1、 创建公共的接口1.2、 创建被代理角色1.3、 创建代理角色1.4、 创建测试类2、动态代理的实现2.1、 使用 JDK 的 Proxy 类实现动态代理1、 创建业务接口2、 创建接口实现类3、 创建生成代理对象的工厂4、 创建切面对象5、 创建测试类2.2、 使用 CGLIB 实现动态代理1、添加 jar 包2、 创建业务接口3、创建接口实现类4、创建生成代理对象的工厂5、 创建切面6、 创建测试类 一、什么
代理模式之静态代理，JDK动态代理和cglib动态代理
烟雨星空的博客
12-27 1264
代理模式，顾名思义，就是通过代理去完成某些功能。比如，你需要购买火车票，不想跑那么远到火车站售票窗口买，可以去附近的火车票代售点买，或者到携程等第三方网站买。这个时候，我们就把火车站叫做目标对象或者委托对象，也可以叫被代理对象，而火车票代售点和携程就叫做代理对象。 一、静态代理 静态代理是最简单的代理模式。需要定义一个接口，然后委托类和代理类分别实现这个接口 //待实现的接口 public int...
JDK动态代理与静态代理的简单介绍，并附带示例
最新发布
Reggie97的博客
04-07 1395
本文详细介绍了什么是JDK动态代理，介绍了其优势和特点，以及作用。同时，作为类比，介绍了静态代理方式，并附有示例。最后介绍了动态代理的实现方式，也附带有示例。
代理模式的详细介绍
yang的博客
05-08 1万+
代理模式的应用场景 在实际生活中，我们经常见到这样的场景，如：租房中介、售票黄牛、婚介、经纪人、快递、事务代理、非侵入式日只监听等，这些都是代理模式的实际体现。代理模式的定义也非常简单，是指为其它对象提供一种代理，以控制对这个对象的访问。 代理对象在客户端和目标对象之间起到中介作用，代理模式属于结构性设计模式。使用代理模式主要有两个目的：一是保护目标对象，二是增强目标对象，下面是代理模式的结构类图...
Spring之面向接口增强实现类
Mr顺
09-03 1927
代理模式 是通过代理对象访问目标对象，这样可以在目标对象基础上增强额外的功能，如添加权限，访问控制和审计等功能。 例如：房产中介代替业主卖房 静态代理 静态代理中代理类与被代理类都需要实现同一个接口，这就说明我们的一个静态代理类只能代理一个类，并且还要事先知道我们要代理哪个类才能写代理类，如果我们有其他类还想使用代理那就必须再写一个代理类。 然而在实际开发中我们是可能是有非常多的类是需要被代理的，并且事先我们可能并不知道我们要代理哪个类。所以如果继续使用静态代理反而会增加许多的工作量，并且效率低下，代码复用
jdk静态代理和动态代理
qiaziliping的博客
08-11 468
jdk静态代理和jdk动态代理
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理）
06-21
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理） Java 动态代理是 Java 编程语言中的一种强大工具，广泛应用于 Spring AOP、Hibernate 数据查询、测试框架的后端 mock、RPC 远程调用、Java 注解...
代理模式-静态动态代理-jdk动态代理-cglib动态代理
11-12
在Java中，代理模式有多种实现方式，包括静态代理、JDK动态代理和CGLIB动态代理。 **静态代理** 静态代理是最早也是最基础的代理实现方式。在静态代理中，我们需要创建一个代理类，这个代理类与原始类（被代理类）...
静态代理、jdk动态代理、cglib动态代理
02-27
JDK 动态代理是 Java 语言中的一种代理模式实现方式，它使用 Java 反射机制来实现代理对象的创建。在 JDK 动态代理中，我们不需要在编译时创建代理类，而是使用 Java 反射机制在运行时动态创建代理对象。 JDK 动态...
【设计模式】代理模式之JDK动态代理与CGLIb代理区别
讯开技术孵化器博客
05-24 871
一、什么是代理？ 代理模式是Java中常见的一种模式，英文名字叫走Proxy或者Surrogate，代理的本意是一个人代表另一个人，或者一个机构代表另一个机构，采取行动，因而，代理和现实生活中的中介有很大的类似，你买房子、卖房子，可以自己去操作，但是需要了解和买卖房产无关的细节，如契税等，而找一个中介，则不用关心这些与买卖房产无直接关系的中间细节，只关心业务本身。 代理分为静态代理和动态代理 ...
Java两种动态代理JDK动态代理和CGLIB动态代理
热门推荐
Java相关领域
08-07 14万+
目录 代理模式 JDK动态代理 cglib动态代理 测试 代理模式 代理模式是23种设计模式的一种，他是指一个对象A通过持有另一个对象B，可以具有B同样的行为的模式。为了对外开放协议，B往往实现了一个接口，A也会去实现接口。但是B是“真正”实现类，A则比较“虚”，他借用了B的方法去实现接口的方法。A虽然是“伪军”，但它可以增强B，在调用B的方法前后都做些其他的事情。Spring AOP...
深入理解代理模式：静态代理与JDK动态代理
Rico's Blogs
03-01 1万+
摘要： 　　 　　代理模式为其他对象提供了一种代理以控制对这个对象的访问，具体实现包括两大类：静态代理和动态代理。Java动态代理机制的出现使得Java开发人员只需要简单地指定一组接口及委托类对象便能动态地获得代理类，并且其所生成的代理类在将所有的方法调用分派到委托对象上反射执行的同时，还可以对方法进行增强，这也正是Spring AOP的实现基础。通过阅读本文，读者将会对代理模式和Java动态...
jdk动态代理详解(通俗易懂,5分钟带你快速理解动态代理)全网最简
weixin_44042734的博客
07-16 7795
jdk动态代理详解(通俗易懂,5分钟带你快速理解动态代理)
JDK动态代理代理与Cglib代理区别
github_39433650的博客
05-28 1827
JDK动态代理代理与Cglib代理区别 在Java中，许多框架的底层都是基于动态代理来实现的，比如Aop，mybaits动态生成数据库操作类。在Java中有两种动态代理的方法，一种是JDK原生的动态代理，一种是基于Cglib的代理方式 什么是代理模式 为其他对象提供一种代理以控制对这个对象的访问 什么是动态代理 与静态代理在程序运行前就已经存在的方式不同，动态代理指的是代理类是在运行时才被创建...
Spring的两种代理方式：JDK动态代理和CGLIB动态代理
C.
02-10 4万+
代理模式代理模式的英文叫做Proxy或Surrogate，中文都可译为”代理“，所谓代理，就是一个人或者一个机构代表另一个人或者另一个机构采取行动。在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用 A. 抽象主题角色 声明了真实主题和代理主题的共同接口，这样一来在任何可以使用真实主题的地方都可以是使用代理主题 B. 代理主题（Prox
深入理解JDK动态代理，代理模式
weixin_62569149的博客
07-10 414
本章以理论 + 实践来帮助你理解代理模式，通过比较通俗的语言，来带领你们一步步上道
代理模式介绍
m0_58736477的博客
06-19 95
代理模式介绍 •对一个类的功能进行增强或对类中的方法进行拦截 •应用场景：要增强一个类或方法，但不能修改原来的类代码。 如：对业务类中每个方法添加日志记录的功能，使用代理模式给每个方法添加了日志，又没有修改原来的业务代码。 ...
【设计模式】五、代理模式（10分钟悄悄搞定）
小小程序员
10-21 257
目录一、什么是代理模式？二、为什么要用代理模式？优点缺点三、静态代理1、创建接口2、实现接口3、创建代理类4、测试5、总结四、动态代理1、JDK代理模式1.1 创建代理类1.2 测试1.3 探究原理2、CGLIB2.1 maven 项目需要进入2.2 创建对象2.3 创建代理类2.4 测试类2.5 CGLIB总结3 JDK与CGLIB 对比Spring中的代理 一、什么是代理模式？ 代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。 举个栗子: 我们要买房子，虽然可以自己一个小区一个小区
Java代理模式详解：静态代理、JDK与CGLIB动态代理
代理模式分为静态代理、JDK动态代理和CGLIB动态代理三种实现方式，每种都有其特定的优点和应用场景。静态代理虽然效率最高但灵活性较低，适用于已明确代理类的情况。JDK动态代理基于接口，适合通用业务，如性能日志...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值