Spring(1)-粗解动态代理

最新推荐文章于 2024-11-09 20:45:09 发布
最新推荐文章于 2024-11-09 20:45:09 发布
阅读量1.2k 收藏 18
点赞数 25
分类专栏： Spring 文章标签： spring java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_83375295/article/details/138185636
版权

Spring 最核心的概念是IOC、AOP，AOP的核心功能底层实现机制就是动态代理。
本文使用一个案例逐步讲解动态代理的底层原理。
备注：本文内容核心是韩顺平老师课程内容，这是我做的笔记外加个人理解和补充。

案例需求说明

  1. 我们有一个 Vehicle 接口，其中有一个 run 方法；这个接口下有两个实现类 Car 和 Ship
  2. 当运行 Car 对象的 run 方法和 Ship 对象的 run 方法时，输出如下内容：
交通工具开始运行了...
小汽车在公路 running..
交通工具停止运行了...

交通工具开始运行了...
大轮船在公路 running..
交通工具停止运行了...
  1. 思考如何完成

案例解决方案-传统方式

传统按OOP的思想，这个需求解决方法很简单，就是分别创建好接口，再创建对应的实现类，测试即可，主要代码如下：

  1. Vehicle 接口
package com.example.proxy2;  
  
public interface Vehicle {  
    public void run();  
}
  1. Car 实现类
package com.example.proxy2;  
  
public class Car implements Vehicle{  
    public void run(){  
        System.out.println("交通工具开始运行了...");  
        System.out.println("小汽车在公路 running..");  
        System.out.println("交通工具停止运行了...");  
    }  
}
  1. Ship 实现类
package com.example.proxy2;  
  
public class Ship implements Vehicle{  
    public void run(){  
        System.out.println("交通工具开始运行了...");  
        System.out.println("轮船在海上航行..");  
        System.out.println("交通工具停止运行了...");  
    }  
}
  1. Test ，这里用到了动态绑定机制，可以阅读粗解动态绑定机制
package com.example.proxy2;  
  
public class Test {  
    public static void main(String[] args) {  
        Vehicle car = new Car();  
        car.run();  
        Vehicle ship = new Ship();  
        ship.run();  
    }  
}

传统方法好吗，会明显发现有代码冗余，在这个案例中虽然只是输出语句，看起来不算冗余，但是扩展一下如果是某个复杂的实现方法呢，比如某个校验方法，那就显得很冗余了，而且冗余也还好，更主要的是无法对这些方法进行统一管理，修改起来很麻烦，所以解决了需求但是没有很好地解决。

案例解决方案-动态代理

动态代理的思路是在调用方法时，利用反射机制，根据方法去决定调用哪个对象方法
直接上代码：

  1. 我们先写一个类 VehicleProxyProvider
    1. 该类可以返回一个代理对象
    2. 定义一个属性 target_vehicle，将来真正要执行的对象赋值给它，当然这个对象肯定要实现 Vehicle 接口
    3. 定义构造器
    4. 接下来，我们要写一个方法 getProxy ，用来返回一个代理对象
      1. 开始写，随便设置一个返回值null
public class VehicleProxyProvider {  
	// 定义一个属性  
	private Vehicle target_vehicle;
	// 构造器
	public VehicleProxyProvider(Vehicle target_vehicle) {  
	    this.target_vehicle = target_vehicle;  
	}	
	// 返回代理对象方法	
	public Vehicle getProxy(){  
	    return null;  
	}
}
  1. 因为 getProxy 方法很重要，我们单独拿出来细讲
    1. 在 java.lang.reflect 包中有一个类 Proxy，它有一个方法 newProxyInstance() 用来创建代理对象/实例，源码如注释所示
    2. 初始我们对 newProxyInstance() 所需要的三个参数都没有，所以都设置成null，proxy就是代理对象,我们返回它
    3. 初始是 Object proxy = Proxy.newProxyInstance(null, null, null);，需要强转一下类型，才能返回
public Vehicle getProxy(){  
    /**  
     * Proxy.newProxyInstance() 方法  
     * public static Object newProxyInstance(ClassLoader loader,  // 类加载器  
     *                                       Class<?>[] interfaces,  // 将来要代理的对象的接口信息  
     *                                       InvocationHandler h) // 调用处理程序/对象，有一个很重要的方法invoke
     */  
    Vehicle proxy = (Vehicle) Proxy.newProxyInstance(null, null, null);
    return proxy;
}
  1. 我们继续完善Proxy.newProxyInstance(null, null, null)所需要的三个参数
    1. ClassLoader loader 类加载器，相关知识可以查看粗解Java类加载器
    2. Class<?>[] interfaces 要执行的类的接口信息
    3. 创建 InvocationHandler 对象
      1. InvocationHandler 本身是个接口（可以查阅源码）
      2. 接口不能实例化，但是我们就是要得到这个对象，该怎么办？使用匿名对象可以解决。简单理解就是在实现接口方法的同时创建对象。
      3. 这个接口中有个非常重要的方法，public Object invoke(Object proxy, Method method, Object[] args)，这个invoke方法就是我们将来执行 target_vehicle 对象的方法时会调用到
// 类加载器  
ClassLoader classLoader = target_vehicle.getClass().getClassLoader();  
// 要执行的类的接口，我们要代理的是target_vehicle，所以要获取target_vehicle的接口Vehicle  
Class<?>[] interfaces = target_vehicle.getClass().getInterfaces();  
// 调用处理程序  
InvocationHandler invocationHandler = new InvocationHandler() {  
    /**  
     * public Object invoke(Object proxy, Method method, Object[] args)     * proxy: 代理对象  
     * method: 代理对象被调用的方法，我们的例子中是 .run()方法  
     * args: 代理对象调用方法的参数，我们的例子中是 .run()方法中的参数，不过我们的例子中没有参数  
     * return: 返回代理对象调用方法的返回值，我们的例子中是，。run()的返回结果，不过没有返回值只有打印  
     */  
    @Override  
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
        // 在调用目标对象的方法之前，我们可以添加一些自己的操作  
        System.out.println("交通工具开始运行了...");  
        // 调用目标对象的方法，反射  
        Object result = method.invoke(target_vehicle, args);  
        // 在调用目标对象的方法之后，我们可以添加一些自己的操作  
        System.out.println("交通工具停止运行了...");  
        return result;  
    }  
};
  1. 创建好三个需要的参数后，放入到 Proxy.newProxyInstance 中
Vehicle proxy = (Vehicle) Proxy.newProxyInstance(loader, interfaces, invocationHandler);
  1. 测试
    1. 创建一个对象，Car或者Ship，我们这里用Vehicle ship = new Ship();
    2. new VehicleProxyProvider(ship)，将要代理的对象传入进去
    3. 接下来如果还是 ship.run()，那么调用的还是 ship 自身的run方法，没有走代理对象，可以测试一下，我们将Ship类中的第一个和第三个输出注释掉，结果输出轮船在海上航行..
    4. 所以，第三步是要获取一个代理对象 Vehicle proxy = vehicleProxyProvider.getProxy();
    5. 最后，运行代理对象的执行方法 proxy.run();
public class Test {  
    public static void main(String[] args) {  
        // 1. 创建一个轮船对象  
        Vehicle ship = new Ship();  
        // 2. 创建一个 VehicleProxyProvider 对象  
        VehicleProxyProvider vehicleProxyProvider = new VehicleProxyProvider(ship);  
        // 3. 获取代理对象，该对象可以代理执行方法  
        Vehicle proxy = vehicleProxyProvider.getProxy();  
        // 4. 代理对象执行方法
        proxy.run();  
    }  
}

输出：

交通工具开始运行了...
轮船在海上航行..
交通工具停止运行了...
  1. 最后值得一提是：代理对象 proxy 在编译时是 Vehicle 类型，运行时是 Proxy 类型，这个结论比较容易理解，下面主要讲解代码具体的执行过程
    1. 既然我们输出了“交通工具开始运行了…”和“交通工具停止运行了…“，说明一定是执行了invoke(Object proxy, Method method, Object[] args) 方法
    2. 在这个方法中，先输出“交通工具开始运行了…”，再通过反射执行 method.invoke(target_vehicle, args)方法，回来继续输出“交通工具停止运行了…”

总结

动态代理，在哪里体现了动态呢？
执行的对象是动态的，我们创建谁就用谁的方法 Vehicle ship = new Ship();，这里可以创建Ship也可以创建Car；执行的方法是动态的。

完整代码

  1. Vehicle 接口
public interface Vehicle {  
    public void run();  
}
  1. Vehicle 实现类 Ship
public class Ship implements Vehicle{  
    public void run(){  
//        System.out.println("交通工具开始运行了...");  
        System.out.println("轮船在海上航行..");  
//        System.out.println("交通工具停止运行了...");  
    }  
}
  1. VehicleProxyProvider
public class VehicleProxyProvider {  
    // 定义一个属性  
    private Vehicle target_vehicle;  
  
    public VehicleProxyProvider(Vehicle target_vehicle) {  
        this.target_vehicle = target_vehicle;  
    }  
  
    public Vehicle getProxy(){  
        // 类加载器  
        ClassLoader loader = target_vehicle.getClass().getClassLoader();  
        /**  
         * Proxy.newProxyInstance() 方法  
         * public static Object newProxyInstance(ClassLoader loader,  // 类加载器  
         *                                       Class<?>[] interfaces,  // 要执行的类的接口  
         *                                       InvocationHandler h) // 调用处理程序  
         */  
        // 类加载器  
        ClassLoader classLoader = target_vehicle.getClass().getClassLoader();  
        // 要执行的类的接口，我们要代理的是target_vehicle，所以要获取target_vehicle的接口Vehicle  
        Class<?>[] interfaces = target_vehicle.getClass().getInterfaces();  
        // 调用处理程序  
        InvocationHandler invocationHandler = new InvocationHandler() {  
            /**  
             * public Object invoke(Object proxy, Method method, Object[] args)             * proxy: 代理对象  
             * method: 代理对象被调用的方法，我们的例子中是 .run()方法  
             * args: 代理对象调用方法的参数，我们的例子中是 .run()方法中的参数，不过我们的例子中没有参数  
             * return: 返回代理对象调用方法的返回值，我们的例子中是，。run()的返回结果，不过没有返回值只有打印  
             */  
            @Override  
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
                // 在调用目标对象的方法之前，我们可以添加一些自己的操作  
                System.out.println("交通工具开始运行了...");  
                // 调用目标对象的方法，反射  
                Object result = method.invoke(target_vehicle, args);  
                // 在调用目标对象的方法之后，我们可以添加一些自己的操作  
                System.out.println("交通工具停止运行了...");  
                return result;  
            }  
        };  
        Vehicle proxy = (Vehicle) Proxy.newProxyInstance(loader, interfaces, invocationHandler);  
        return proxy;  
    }  
}
marrigo
关注
专栏目录
spring cloud--微服务
Ysuhang的博客
08-22 6317
微服务架构，简单的说就是将单体应用进一步拆分，拆分成更小的服务，每个服务都是一个可以独立运行的项目。Spring Cloud Alibaba 致力于提供微服务开发的一站式解决方案。此项目包含开发分布式应用微服务的必需组件，方便开发者通过 Spring Cloud 编程模型轻松使用这些组件来开发分布式应用服务。依托 Spring Cloud Alibaba，您只需要添加一些注解和少量配置，就可以将 Spring Cloud 应用接入阿里微服务解决方案，通过阿里中间件来迅速搭建分布式应用系统。
SSM框架 --- Spring AOP
weixin_39281866的博客
02-07 781
代理设计模式；Spring AOP相关概念（连接点，切入点，切面，通知等），配置文件方式实现AOP，注解方式实现AOP
springcloud2-注册中心eureka及nacos
张晨光老师的播客
06-25 1035
1，课程回顾 2，本章重点 eureka注册中心 nacos注册中心 3，具体内容3.1 eureka注册中心 https://www.springcloud.cc/spring-cloud-brixton.html#spring-cloud-eureka-server https://docs.spring.io/spring-cloud-netflix/docs/current/reference/html/#spring-cloud-eureka-server 3.1.1 简介 Eureka 是一种
Spring(2)-粗解横切关注点
2401_83375295的博客
04-25 766
本文是Spring AOP的前置内容，过渡作用。
SpringCloud五大组件（一）粗解
xueguchen的博客
07-01 2149
以业务中比较常见的订单业务的下单业务逻辑为例： 用户创建订单后并至支付了相应金额 将订单状态更新为“已支付” 扣减相应的商品库存 通知商家进行发货 给用户增加相应的积分 1. Eureka 订单服务如何调用库存服务、仓储服务，或者积分服务？换句话说，订单服务怎么从哪里了解到库存服务、仓储服务，或者积分服务的位置信息（ip，端口），简单理解就是，A想要找B和C一起玩耍，A首先需要知道B和C的位置在哪里，才能过去找到他们。 为了解决上述问题，订单流程引入Eureka后，流程图如下图所示： Eureka
Spring Boot 企业级开发课后题答案
热门推荐
文轩
07-04 2万+
Spring Boot 企业级开发课后题答案 黑马程序员 加粗字体为答案 第一章 1.1 填空题 Pivotal 团队在原有 spring 框架的基础上开发了全新的Spring Boot框架。 Spring Boot框架在开发过程中大量使用 约定优先配置 的思想来摆脱框架中各种复杂的手动配置。 Spring Boot 2.1.3版本要求Java 8 及以上版本的支持。 Spring Boot2.1.3版本框架官方声明支持的第三方项目构建工具包括有 maven(3.3+) 和 gradle(4.4+.
浅谈JDK动态代理
fhp123的博客
05-06 318
前言：尽管动态代理看起来似乎有一定难度，但却必须拿下。因为Spring的事务控制依赖于AOP，AOP底层实现便是动态代理，环环相扣。到最后，还是看基本功。 主要内容： 一个小需求：给原有方法添加日志打印 静态代理实现日志打印 静态代理的问题 一个小需求：给原有方法添加日志打印 假设现在我们有一个类Calculator，代表一个计算器，它可以进行加减乘除操作。 public class Calculator { //加 public int add(int a, int b) { int r
Spring 注解编程
How many ten years in the life time?
07-14 555
1. 注解基础概念 Ⅰ. 什么是注解编程 指的是在类 或 方法上加入特定的注解(@XXX)，完成特定功能的开发。 @Component public class Xxx {...} Ⅱ. 为什么要讲解注解编程 注解开发方便➢ 代码简洁 开发速度大大提高Spring开发潮流➢ Spring2.x引入注解 Spring3.x完善注解 SpringBoot普及 推广注解编程替换XML这种配置形式，简化配置替换接口，实现调用双方的契约性通过注解的方式，在功能调用者和功能提供者之间达成约定，进而进行功能的调用。..
达内-Spring+SpringMVC+MyBatis框架考试复习
qq_43611391的博客
05-24 2142
第一部分：Spring框架概述、Spring、IOC、单例、多例、依赖注入 文章目录一、 Spring概述+约束引入1 框架概述2 创建的框架3 Spring框架概述4 IOC的入门案例（环境、约束）二、 IOC基本概念和原理1 IOC和DI的概念2 创建IOC的例子3 IOC的实现原理4 IOC获取对象的方式三、 Spring创建对象的方式四、 单例模式和多例模式五、 懒加载六、 Spring容器的初始化和销毁七、 DI依赖注入1 IOC（DI） -- 控制反转（依赖注入）2 通过set方法完成依赖
Spring笔记
qq_49512123的博客
03-26 1468
Spring 1. Spring框架1.1 概述1.2 优点1.3 Spring体系架构2. IoC控制反转2.1 概述2.2 创建一个Spring项目2.2.1 创建maven项目，并导入spring依赖2.2.2 创建业务接口与实现类2.2.3 创建Spring配置文件2.2.4 创建测试类2.3 基于XML的DI2.3.1 set注入简单类型（Java中的基本类型和String类型）引用类型：2.3.2 构造注入(了解)2.3.3 引用类型的自动注入byNamebyType
Spring IOC与AOP源码分析，吊锤面试官 SO easy！
xcz123x的博客
07-11 654
本文对Spring相关知识点做了归纳整理，包括 Spring 优势、其框架结构、核心思想，并对IoC思想及AOP思想进行手动实现，增强对Spring 核心思想的理解。之后对Spring IoC、AOP 的实现方式和特性进行介绍，并对照源码理解其实现思路。 Spring 优势 方便解耦，简化开发 「[注：IoC(降低组件耦合性)、DI(降低业务对象替换的复杂性)]」 AOP编程的思想 「[注：通用任务集中管理，使得代码可更好的复用]」 声明式事务的支持 「[注：@Tra
通向架构师的道路（第二十二天）万能框架spring(四)使用struts2
lifetragedy的专栏
11-16 1万+
一、前言SSH有了，现在我们要把我们的struts层从原来的1.3替换成struts2.x，引入了struts2.0后我们会发觉我们的代码和框架的变化还是不小的二、Struts2的好处1）在struts2的方法里，一切变量是线程安全的，而原有的struts1不是的;2）在struts2中如果你声明了如下这样的代码：    privater String studentName=””; p
2022系统分析师--案例必备知识点汇总
喜欢猪猪
06-11 2132
2022年-系统分析师案例分析的知识点整理
SpEL（Spring Expression Language）入门指南
kersixy的博客
11-05 695
SpEL（Spring Expression Language）是 Spring 框架提供的一个强大的表达式语言，用于在运行时查询和操作对象图。它类似于 JSP EL（JavaServer Pages Expression Language）和 OGNL（Object-Graph Navigation Language），但在功能上更为丰富和强大。
后端SpringBoot及vue proxyTable解决跨域
qq_42059717的博客
11-06 286
昨天上线项目遇到了一个奇怪的问题，本来服务实在腾讯云的轻量应用服务器的，但是迁移到一个香港的服务器之后就出现了各种各样的问题。Nginx 开启Https Springboot开启Https，先后出现了噔噔蹬蹬但是我其实已经部署了一个项目了的，那个用的proxyTable,新部署的这个用的是里边的env控制的。后来改成proxyTable就好了。
Spring中@Autowired@Resource和@Inject注解区别
2401_87333857的博客
11-06 425
同时，它默认是采用byType装配，当指定了1SR-330规范中的@Named注解之后，变成byName装配。它也可以出现在方法上，构造函数上和字段上但是需要注意的是:因为IRE无法决定构造方法注入的优先级，所以规范中规定类中只能有一个构造方法带@Inject注解。@Autowired:来源于spring框架自身默认是byType自动装配，当配合了@Qualifier注解之后，在没有指定name属性时是byType自动装配，当指定了name属性之后，采用byName方式自动装配。
SpringBoot助力的共享汽车业务优化系统
2402_85762143的博客
11-09 872
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。近来，软件工程界趋向于一种新的观点，即认为软件生命周期每一阶段中都应包含测试，从而检验本阶段的成果是否接近预期的目标，尽可能早的发现错误并加以修正，如果不在早期阶段进行测试，错误的延时扩散常常会导致最后成品测试的巨大困难。任务：消除软件故障，保证程序的可靠运行。
为何选择Spring AI Alibaba开发智能客服平台？
最新发布
JavaEdge全是干货的技术号
11-09 448
本文来看如何使用Spring AI Alibaba构建Agent应用。
嵌入式Linux入门具备：C语言基础与基本驱动学习（2）：Linux GIibc IO基础
charlie114514191的博客
11-05 704
对于标准 I/O 库函数来说，它们的操作是围绕 FILE 指针进行的，当使用标准 I/O 库函数打开或创建一个文件时，会返回一个指向 FILE 类型对象的指针（FILE *） ，使用该 FILE 指针与被打开或创建的文件相关联，然后该 FILE 指针就用于后续的标准 I/O 操作（使用标准 I/O 库函数进行 I/O 操作），所以由此可知，FILE 指针的作用相当于文件描述符，只不过 FILE 指针用于标准 I/O 库函数中、而文件描述符则用于文件I/O 系统调用中。函数调用成功返回写入到文件中的字符数；
Spring AOP：静态代理与动态代理深度解析与实战
本文将深入解析Spring AOP中的静态代理和动态代理两种机制，这两种代理模式在Spring框架中的应用对于理解和实现面向切面编程(AOP)至关重要。首先，让我们理解什么是代理。 代理是一种设计模式，它允许我们在不修改...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值