代理模式之动态代理

已于 2023-02-10 16:52:13 修改
阅读量84 收藏
点赞数
文章标签： spring
于 2021-05-14 10:18:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36184384/article/details/116779734
版权

Spring环境中支持两种动态代理

一、使用jdk提供的动态代理的场景

  1. 特点：当被代理对象是接口并且有对应的实现类(子类)的时候，可以采用该种代理方式。
  2. spring环境下的代码实现

首先是父接口

package my.reflect;

import org.springframework.stereotype.Component;

//表述计算器的行为（加减乘除）
//被代理对象是接口（interface）
public interface Calculator {

    Integer add(Integer x, Integer y) throws NoSuchMethodException;
    Integer sub(Integer x, Integer y) throws NoSuchMethodException;
    Integer mul(Integer x, Integer y) throws NoSuchMethodException;
    Integer div(Integer x, Integer y) throws NoSuchMethodException;
}

其次是实现类

package my.reflect;

import org.springframework.stereotype.Component;

//被代理的类添加到IOC容器中，保证ioc容器能扫描到
@Component
public class CalculatorImpl implements Calculator {

    @Override
    public Integer add(Integer x, Integer y) throws NoSuchMethodException {
        int result = x + y;
        return result;
    }

    @Override
    public Integer sub(Integer x, Integer y) throws NoSuchMethodException {
        int result = x - y;
        return result;
    }

    @Override
    public Integer mul(Integer x, Integer y) throws NoSuchMethodException {
        int result = x * y;
        return result;
    }

    @Override
    public Integer div(Integer x, Integer y) throws NoSuchMethodException {
        int result = x / y;
        return result;
    }
}

然后是代理类

package my.proxy;

import my.reflect.Calculator;
import my.utils.LogUtil2;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 本案例采用jdk中的动态代理，该方式前提要有接口和实现接口的子类；
 * 但是在真实的环境中，并不是所有的被代理类都有父类接口，此时要使用spring提供的cglib实现动态代理
 */
public class CalculatorProxy {
    /**
     * @param calculator 被代理对象，即目标对象
     * @return 代理对象
     */
    public static Calculator getCalculator(Calculator calculator){
        //获取被代理对象的类加载器
        ClassLoader classLoader = calculator.getClass().getClassLoader();
        //获取被代理对象的所有接口
        Class<?>[] interfaces = calculator.getClass().getInterfaces();
        //用来执行被代理类需要执行的方法
        InvocationHandler invocationHandler = new InvocationHandler() {
            //注意invoke()方法的执行顺序，调用CalculatorProxy.getCalculator(targetObj)的时候，invoke()是没有执行的，只有用代理对象去调用目标对象的具体方法时，invoke()才执行
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //开始调用被代理类的方法
                Object result = null;
                try{
                    LogUtil2.methodStartLog(method,args);
                    result = method.invoke(calculator,args);
                    LogUtil2.methodStopLog(method,result);
                }catch (Exception e){
                    LogUtil2.methodExceptionLog(method,e);
                    e.printStackTrace();
                }finally {
                    LogUtil2.methodFinallyLog(method);
                }
                return result;
            }
        };
        Object o = Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
        return (Calculator) o;
    }
}

日志类

package my.utils;


import java.lang.reflect.Method;
import java.util.Arrays;


public class LogUtil2 {
    /**
     * 方法的入参个数不确定，所以采用可变参数的形式
     * @param objects
     */
    public static void methodStartLog(Method method, Object ... objects){
        System.out.println(method.getName()+"方法开始执行，入参为："+ Arrays.asList(objects));
    }

    public static void methodStopLog(Method method, Object ... objects){
        System.out.println(method.getName()+"方法执行完毕，结果为："+ Arrays.asList(objects));
    }

    public static void methodExceptionLog(Method method, Exception e){
        System.out.println(method.getName()+"方法出现异常："+ e.getCause().getMessage());
    }

    public static void methodFinallyLog(Method method){
        System.out.println(method.getName()+"方法最终输出结果");
    }
}

测试类


import my.proxy.CalculatorProxy;
import my.reflect.Calculator;
import my.reflect.CalculatorImpl;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class JunitTest {

@Test
    public void jdk_proxy_test() {
        try {
            CalculatorImpl targetObj = new CalculatorImpl();
            //被代理对象targerObj作为入参返生成代理对象calculator_proxy
            Calculator calculator_proxy = CalculatorProxy.getCalculator(targetObj);
            //代理对象调用被代理对象的具体某个方法时回调invoke()具体执行
            calculator_proxy.div(1,2);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }

二、使用CGLIB提供的动态代理的场景

  1. 特点：被代理对象仅仅是普普通通的一个类，没有实现父接口，此时spring使用的cglib提供的动态代理
  2. spring环境下的代码实现

首先是被代理类

package my.reflect;

import org.springframework.stereotype.Component;

//被代理的类添加到IOC容器中，保证ioc容器能扫描到
@Component
public class CalculatorImpl {

    
    public Integer add(Integer x, Integer y) throws NoSuchMethodException {
        int result = x + y;
        return result;
    }

   
    public Integer sub(Integer x, Integer y) throws NoSuchMethodException {
        int result = x - y;
        return result;
    }

    
    public Integer mul(Integer x, Integer y) throws NoSuchMethodException {
        int result = x * y;
        return result;
    }

    
    public Integer div(Integer x, Integer y) throws NoSuchMethodException {
        int result = x / y;
        return result;
    }
}

其次是代理类

package my.proxy;

import my.utils.LogUtil2;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class Calculator_cglib_proxy_factory implements MethodInterceptor {
    private Object target;

    public Calculator_cglib_proxy_factory() {
        super();
    }

    public Calculator_cglib_proxy_factory(Object target) {
        super();
        this.target = target;
    }

    /**
     * 创建代理的方法，生成CGLIB代理对象
     * target目标对象，需要增强的对象
     * 返回目标对象的CGLIB代理对象
     */
    public Object createProxy(){
        //增强器，创建一个动态类对象，即增强类对象
        Enhancer enhancer = new Enhancer();
        //继承被代理类(目标对象target)，也就继承了target的方法和属性
        enhancer.setSuperclass(target.getClass());
        //设置回调,程序执行目标方法时调用intercept方法
        enhancer.setCallback(this);
        //生成代理对象
        Object o = enhancer.create();
        return o;
    }
    /**
     * intercept方法会在程序执行目标方法时被调用
     * proxyObj CGLIB根据指定父类生成的代理对象
     * method拦截方法
     * args拦截方法的参数数组
     * methodProxy方法的代理对象，用于执行父类的方法
     * 返回代理结果
     */
    @Override
    public Object intercept(Object proxyObj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

        LogUtil2.methodStartLog(method,args);
        Object result = method.invoke(target, args);
        LogUtil2.methodStopLog(method,result);
        return null;
    }
}

日志类

package my.utils;


import java.lang.reflect.Method;
import java.util.Arrays;


public class LogUtil2 {
    /**
     * 方法的入参个数不确定，所有采用可变参数的形式
     * @param objects
     */
    public static void methodStartLog(Method method, Object ... objects){
        System.out.println(method.getName()+"方法开始执行，入参为："+ Arrays.asList(objects));
    }

    public static void methodStopLog(Method method, Object ... objects){
        System.out.println(method.getName()+"方法执行完毕，结果为："+ Arrays.asList(objects));
    }

    public static void methodExceptionLog(Method method, Exception e){
        System.out.println(method.getName()+"方法出现异常："+ e.getCause().getMessage());
    }

    public static void methodFinallyLog(Method method){
        System.out.println(method.getName()+"方法最终输出结果");
    }
}

测试类

import my.proxy.CalculatorProxy;
import my.reflect.Calculator;
import my.reflect.CalculatorImpl;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class JunitTest {


    @Test
    public void cglib_test(){
         try {
         	//入参目标对象，生成代理对象
            CalculatorImpl proxy_Obj = (CalculatorImpl)new Calculator_cglib_proxy_factory(new CalculatorImpl()).createProxy();
            //用代理对象执行目标方法，此时会回调intercept()方法，由invoke()方法具体执行
            proxy_Obj.mul(2,5);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
   }

总结

spring中使用那种动态代理的方式主要取决于代理对象是否实现父接口，如果没有就用cglib的，否则就用jdk自带的，无论采用哪一种方式，核心方法都是invoke()方法，cglib生成的代理对象都是被代理对象的子类，运用的机制是反射机制。（来自小白coder的一点看法，如有错误，请大佬们批评指正，谢谢）

大番薯_y
关注
Java设计模式——代理设计模式（静态代理和动态代理）
04-15
在Java编程中，设计模式是一种解决常见问题的模板或最佳实践，它可以帮助开发者编写更加灵活、可维护和可扩展的代码。代理设计模式是其中的一种，它的主要作用是在...在实际开发中，应根据项目需求选择合适的代理模式。
代理模式中的动态代理
Leon_Jinhai_Sun的博客
11-05 98
动态代理和静态对比基本思路是一致的，只不过动态代理功能更加强大，随着业务的扩展适应性更强。如果还以找对象为例，使用动态代理相当于是能够适应复杂的业务场景。不仅仅只是父亲给儿子找对象，如果找对象这项业务发展成了一个产业，进而出现了媒婆、婚介所等这样的形式。那么，此时用静态代理成本就更大了，需要一个更加通用的解决方案，要满足任何单身人士找对象的需求。我们升级一下代码，先来看JDK实现方式： JDK实现方式 创建媒婆（婚介）JDKMeipo类： public class JDKMeipo implem..
代理模式———动态代理
YXXXYX的博客
01-30 2488
动态代理 动态代理凭借其灵活性在框架中有着广泛的应用，下面简单记录一下我的学习理解； 代理模式： 基本概念 在百度百科中没有动态代理的概念，但是动态代理其实就是代理模式中的一种，所以在了解动态代理前最好先了解一下代理模式； 代理模式（英语：Proxy Pattern）是程序设计中的一种设计模式； 代理模式就是为其他对象提供一种代理以控制对这个对象的访问；在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用； 通过加粗的字可以了解到，代理模式应用到什么地方
设计模式系列 - 代理模式及动态代理详解
beauty-coding 的博客
02-28 615
代理模式详解 jdk & cglib 动态代理 详解 代理模式 & 装饰器模式 对比
10分钟看懂动态代理设计模式
weixin_33778778的博客
03-02 3694
动态代理是Java语言中非常经典的一种设计模式，也是所有设计模式中最难理解的一种。本文将通过一个简单的例子模拟JDK动态代理实现，让你彻底明白动态代理设计模式的本质，文章中可能会涉及到一些你没有学习过的知识点或概念。如果恰好遇到了这些知识盲点，请先去学习这部分知识，再来阅读这篇文章。 什么是代理 从字面意思来看，代理比较好理解，无非就是代为处理的意思。举个例子，你在上大学的时候，总是喜欢逃课。...
设计模式之代理模式分析使用
热门推荐
张彦峰的博客
05-21 164万+
代理模式原理和使用分析总结
设计模式——代理模式
vincewm的博客
04-30 1853
静态代理、JDK动态代理、Cglib 代理
Spring的AOP之代理模式
长安不及十里的博客
08-03 5065
关于两者之间的性能的话，网上有人对于不通版本的jdk进行测试，经过多次试验，测试结果大致是这样的，在1.6和1.7的时候，JDK动态代理的速度要比CGLib动态代理的速度要慢，但是并没有教科书上的10倍差距，在JDK1.8的时候，JDK动态代理的速度已经比CGLib动态代理的速度快很多了，但是JDK动态代理和CGLIB动态代理的适用场景还是不一样的哈！动态代理生成的代理类通常是在运行时通过字节码生成技术生成的，因此在创建代理对象时，需要一个 ClassLoader 来加载这个新生成的代理类。
java模式设计-代理模式之动态代理.ppt
12-09
在Java中，动态代理是代理模式的一种实现方式，它允许我们在运行时创建代理对象，这种方式比静态代理更加灵活。动态代理在JDK 1.3及以后的版本中得到了支持，主要涉及到三个核心类：`Proxy`、`InvocationHandler`和`...
代理模式-静态动态代理-jdk动态代理-cglib动态代理
11-12
在Java中，代理模式有多种实现方式，包括静态代理、JDK动态代理和CGLIB动态代理。 **静态代理** 静态代理是最早也是最基础的代理实现方式。在静态代理中，我们需要创建一个代理类，这个代理类与原始类（被代理类）...
Spring Framework 学习总结博客
2302_80084329的博客
09-13 1087
通过本文的学习，我们从Spring的核心架构入手，逐步理解了IoC和DI的概念，并通过代码示例掌握了如何在实际项目中使用这些技术。Spring通过IoC容器管理bean，依赖注入将bean之间的关系解耦，大大简化了复杂系统的开发过程。这些基本的Spring知识是理解其高级特性（如AOP、事务管理）的基础，掌握这些概念后，我们可以更加自如地使用Spring构建复杂的企业级应用。
基于spring的博客系统（总）
2202_76101487的博客
09-12 1409
本文写了基于spring mvc创建的博客系统；
java项目之基于springboot的贸易行业crm系统（源码+文档）
sinat_26552841的博客
09-13 482
基于springboot的贸易行业crm系统的主要使用者分为： 管理员功能有个人中心，部门管理，员工管理，产品分类管理，产品信息管理，客户信息管理，市场活动管理，销售订单管理，配送订单管理。员工可以操作自己的个人中心，客户信息，产品信息，销售订单，配送订单，售后回访等。
构建基于SpringBoot的在线学习平台
2402_85762143的博客
09-14 856
首页、课程信息、个人中心、后台管理、购物车等功能，这给管理者的工作带来了巨大的挑战，面对大量的信息，传统的管理系统，都是通过笔记的方式进行详细信息的统计，后来出现电脑，通过电脑输入软件将纸质的信息统计到电脑上，这种方式比较传统，而且想要统计数据信息比较麻烦，还受时间和空间的影响，所以为此开发了在线视频教育平台；可以在多种平台上运用的，兼容性比较强，适应市面上大多数操作系统，不会出现乱码的现像，其扩展性和维护性都更好，具有分析问题和解决问题的能力，是面向过程的程序设计方便我们编写的代码更强壮。
spring综合性利用工具-SpringBootVul-GUI(五)
siu~
09-12 879
一个半自动化springboot打点工具，内置目前springboot所有漏洞
基于SpringBoot项目实现Docker容器化部署
最新发布
不惑
09-18 755
将Spring Boot项目部署到Docker容器中的涉及几个主要步骤： Docker容器化部署Spring Boot项目的原理涉及将应用程序及其依赖项打包到一个Docker镜像中，然后在容器内运行该镜像。这使得应用程序在不同环境中更加可移植和隔离，同时也方便了部署和扩展。使用Docker可以大大简化应用程序的部署流程，并提供了更好的资源管理和隔离，以及更高的可伸缩性。
Java动态代理模式深度解析
"Java 代理模式详解，包括代理模式的概念、相关类和接口以及Java动态代理的机制和特点。" 代理模式是设计模式的一种，它允许我们为一个目标对象创建一个代理，这个代理对象可以在调用实际对象之前或之后添加额外的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值