深入理解Spirng——IOC，AOP相关

最新推荐文章于 2024-04-30 12:12:17 发布
最新推荐文章于 2024-04-30 12:12:17 发布
阅读量149 收藏
点赞数
文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wolfberry9/article/details/106988018
版权

Spring

在这里插入图片描述

Spring是什么？干什么的？怎么用?

参考文章：https://blog.csdn.net/YKorey/article/details/80629291

Spring是什么？

1.是一个轻量级的开源框架，是为解决企业应用开发的复杂性而创建的；

2.是一个三层架构，也为J2EE应用程序开发提供集成的框架；

​ web层：Spring MVC;

​ 业务层：Spring的IOC；

​ 持久层：Spring的JDBC、ORM、等持久层框架

3.Spring的核心是：控制反转（ioc）和面向切面编程(aop);

IOC 控制反转

  • 控制反转模式(也称依赖性介入)，主要是不创建对象，但是描述创建它们的方式，在代码中不直接与对象和服务连接，但在配文件中描述哪一组件需要哪一个服务；

  • IOC的设计目标是与JavaBean组件一起使用

  • 直接作用在功能的底层；

  • Spring里面最高级的抽象是BeanFactory(对应的是工厂模式)；

    BeanFactory有两种模式：单态、原型；

    单态：查询时对具有特定名称的对象共享实例进行检索；eg:Singleton

    原型：每次检索都会创建单独的对象(在每个用户都需要自己的对象时，原型模式是最适合的)；

AOP面向切面编程

  • 是oop(Object Oriented Programming,面向对象编程)的补充和完善

    oop:引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的集合。

    oop允许开发者定义纵向的关系，它导致了大量代码的重复，不利于各个模块的重用。

    纵向：与核心功能有关联,opp

    横向：与核心功能毫无关系。日志、安全性、异常处理等，散布在各处的无关代码，被称为横切(cross cutting)

  • AOP是和OOP相反的一种叫做"横切"的技术。将影响到多个类的公共行为都封装到一个可重用模块，这就是AOP中的A(Aspect,切面，与业务无关，主要是减少代码的复用)

  • 横切把系统分为两个部分：核心关注点 (业务处理的主要流程) 和 横切关注点 (在核心关注点里的多出,各处基本相同)；

  • AOP的作用在于分离系统中的各种关注点,将核心关注点和横切关注点分离开来；

  • 横切关注点：eg：对哪些方法进行拦截,拦截后的处理；

  • 切面 :类是对物体特征的抽象，切面就是对横切关注点的抽象；

  • Spring中AOP代理由Spring的IoC容器负责生成、管理、依赖关系也由IoC容器负责管理(AOP代理可以直接使用容器中的其它bean实例作为目标，这种关系可由IOC容器的依赖注入提供；

  • Spring的代理默认使用java动态代理来创建AOP代理，这样可以为任何接口实例创建代理；

  • 当需要代理的类不是代理接口的时候，Spring会切换为使用CGLIB代理；

CGLIB：就是一个强大的,高性能的代码生成库,主要通过 对字节码的操作为对象引入间接级别,以控制对象的访问)；

AOP基本概念

Joinpoint（连接点）

​ 被拦截到的每个点，spring中指被拦截到的每一个方法，spring aop一个连接点即代表一个方法的执行。

Pointcut（切入点）

​ 对连接点进行拦截的定义（匹配规则定义 规定拦截哪些方法，对哪些方法进行处理），spring 有专门的表达式语言定义。

Advice（通知）

拦截到每一个连接点即（每一个方法）后所要做的操作

1. 前置通知 （前置增强）— before()  执行方法前通知
2. 返回通知（返回增强）— afterReturn 方法正常结束返回后的通知
3. 异常抛出通知（异常抛出增强）— afetrThrow()
4. 最终通知 — after  无论方法是否发生异常，均会执行该通知。
5. 环绕通知 — around  包围一个连接点（join point）的通知，如方法调用。这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。
五大注解

@Before: 前置通知, 在方法执行之前执行；

@After: 后置通知, 在方法执行之后执行 ；

@AfterRunning: 返回通知, 在方法返回结果之后执行；

@AfterThrowing: 异常通知, 在方法抛出异常之后；

@Around: 环绕通知, 围绕着方法执行；

Aspect（切面）

​ 切入点与通知的结合，决定了切面的定义，切入点定义了要拦截哪些类的哪些方法，通知则定义了拦截过方法后要做什么，切面则是横切关注点的抽象，与类相似，类是对物体特征的抽象，切面则是横切关注点抽象。

Target（目标对象）

​ 被代理的目标对象

Weave（织入）

​ 将切面应用到目标对象并生成代理对象的这个过程即为织入

Introduction（引入）

​ 在不修改原有应用程序代码的情况下，在程序运行期为类动态添加方法或者字段的过程称为引入

注解式AOP实例
/**
 * 切面
 *  切入点和通知的抽象   （与面向对象中的 类 相似）
 * 	定义 切入点和通知 （切入点定义了要拦截哪些类的哪些方法，通知则定义了拦截过方法后要做什么）
 */
@Component // 将对象交给IOC容器去实例化
@Aspect // 声明当前类是一个切面
public class LogCut {

    /**
     *  切入点：
     *      匹配规则。规定什么方法被拦截、需要处理什么方法
     *  定义切入点
     *    @Pointcut("匹配规则")
     *
     *    Aop 切入点表达式简介
     *       1. 执行任意公共方法：
     *       	execution(public *(..))
     *       2. 执行任意的set方法
     *       	execution(* set*(..))
     *		 3. 执行com.xxxx.service包下任意类的任意方法
     *      	execution(* com.xxxx.service.*.*(..))
     *       4. 执行com.xxxx.service 包 以及子包下任意类的任意方法
     *     		execution(* com.xxxx.service..*.*(..))
     *
     *    	 注：表达式中的第一个* 代表的是方法的修饰范围
     *			可选值：private、protected、public （* 表示所有范围）		
     */
    @Pointcut("execution (* com.xxxx.service..*.*(..) )")
    public void cut(){}

    /**
     * 声明前置通知   并将通知应用到定义的切入点上
     * 目标类方法执行前 执行该通知
     *
     */
   @Before(value = "cut()")
    public void before() {
        System.out.println("前置通知.....");
    }

    /**
     * 声明返回通知   并将通知应用到定义的切入点上
     * 目标类方法（无异常）执行后 执行该通知
     *
     */
   @AfterReturning(value = "cut()")
    public void afterReturn() {
        System.out.println("返回通知.....");
    }

    /**
     * 声明最终通知   并将通知应用到定义的切入点上
     * 目标类方法（无异常或有异常）执行后 执行该通知
     *
     */
    @After(value = "cut()")
    public void after() {
        System.out.println("最终通知.....");
    }

    /**
     * 声明异常通知   并将通知应用到定义的切入点上
     * 目标类方法出现异常时 执行该通知
     */
    @AfterThrowing(value="cut()",throwing = "e")
    public void afterThrow(Exception e) {
        System.out.println("异常通知....." + "  异常原因：" + e.getCause());
    }

    /**
     *  声明环绕通知  并将通知应用到切入点上
     *  方法执行前后  通过环绕通知定义相应处理
     *      需要通过显式调用对应的方法，否则无法访问指定方法 (pjp.proceed();)
     * @param pjp
     * @return
     */
    @Around(value = "cut()")
    public Object around(ProceedingJoinPoint pjp) {
        System.out.println("前置通知...");

        Object object = null;
        try {
            object = pjp.proceed();
            System.out.println(pjp.getTarget() + "======" + pjp.getSignature());
            // System.out.println("返回通知...");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("异常通知...");
        }
        System.out.println("最终通知...");

        return object;
    }

}

AOP总结

理解

1.面向切面，相比oop关注的是代码中的层或面

2.解耦，提高系统扩展性

3.提高代码复用

总结

1.连接点：每一个方法

2.切入点：匹配的方法集合

3.切面：连接点与切入点的集合决定了切面，横切关注点的抽象

4.通知：几种通知

5.目标对象：被代理对象

6.织入：程序运行期将切面应用到目标对象 并生成代理对象的过程

7.引入：在不修改原始代码的情况下，在程序运行期为程序动态引入方法或字段的过程

Spring是干什么的？

1.方便解耦，简化开发

2.方便的对程序进行拦截、运行、监控等功能

3.可以对事物声明

4.属于一个万能的框架，跟很多框架百搭

Spring怎么用

和SpringBoot的区别在于，需要在resource目录下创建xml，使用bean标签

风生白衣笑
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring IOC和AOP代码与笔记整理
12-07
彻底学会Spring的IOC和AOP——理论+实操，参考：https://blog.csdn.net/qq_39735940/article/details/121754987
CGLIB(Code Generation Library)详解
热门推荐
小楼一夜听春雨
04-19 5万+
什么是CGLIB CGLIB是一个强大的、高性能的代码生成库。其被广泛应用于AOP框架（Spring、dynaop）中，用以提供方法拦截操作。Hibernate作为一个比较受欢迎的ORM框架，同样使用CGLIB来代理单端（多对一和一对一）关联（延迟提取集合使用的另一种机制）。CGLIB作为一个开源项目，其代码托管在github，地址为：https://github.com/cglib/cglib为什么
spring Aop 配置文件方式+JoinPoint获取参数
11-04 1万+
 http://www.springframework.org/schema/beans"      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"      xmlns:aop="http://www.springframework.org/schema/aop"      xmlns:tx="http://www.spring
aop基本概念和声明方式
lbl的博客
09-03 467
概念 advice/通知： 什么时候干什么事情 pointcut/切点： 什么地方可以干这个事情 advice与pointcut组成切面/aspect，在什么地方什么时候干什么事情 joinpoint：软件中的连接点，这些点可以织入切面。 五种通知类型 before after after-returning after-throwing around xml配置方式 &lt...
aop简单介绍
weixin_42402753的博客
07-28 481
1.背景介绍 什么是aop     AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向...
Spring学习（一）之概述&IOC
weixin_44049332的博客
01-22 139
Spring（一） 一、Spring的概述 1、 Spring是什么？ Spring是一个full-stack轻量级开源框架
Springboot入门——初学者对Spring Ioc技术的理解与运用，包含Bean生命周期
01-21
Spring所依赖的两个核心理念：控制反转（Ioc）、面向切面编程（AOP） 初学者可能不理解什么叫控制反转，那么我们来进一步描述一下Ioc。 Ioc是一种通过描述来生成或获取对象的技术，这里的对象当然是指java对象。 在...
使用SPRINGAOP框架和EJB组件
02-27
摘要快速发展的开发人员社区、对各种后端技术（包括JMS、JTA、JDO、Hibernate、iBATIS等等）的支持，以及（更为重要的）非侵入性的轻量级IoC容器和内置的AOP运行时，这些因素使得SpringFramework对于J2EE应用程序...
Spring系列——带你走进Spring大门!
12-21
上一期我们讲了计算机网络的相关协议——计算机网络体系结构？TCP/IP协议？这些你都知道多少？ 这期让我们来学习新的知识——Spring系列！ 跟随时光来开启Spring的大门！ 思维导图： 1，初识Spring； 1. 百科介绍...
java4种对象引用级别
淋雨西河的博客
06-28 503
参考文档：https://www.cnblogs.com/gudi/p/6403953.html 参考文档：https://www.cnblogs.com/skywang12345/p/3154474.html 从JDK1.2版本开始，把对象的引用分为四种级别，从而使程序能更加灵活的控制对象的生命周期。细分的准则是体现在被GC回收的优先级上，这四种级别由高到低依次为：强引用 > 软引用 > 弱引用 > 虚引用 强引用StrongReference： 如果一个对象具有强...
SpringAop之joinPoint讲解
学习不止境的博客
08-19 1万+
摸鱼的时候继续复刻demo，没错，同之前一篇文章，在写aop时又发现自己对aop只停留在面试阶段，甚至还不如，完全不会实践，所以在此记录复刻aop用到的的一些且自己已经遗忘的知识。那么复刻的一个需求点我以最简单来说对于此次要学习的内容：就是通过joinPoint获取方法上的特定注解。那么这个就是系统操作日志的注解，主要到时候用aop的joinPoint获取标注在方法上该注解联合方法的相关内容将其转化为系统日志并进行存储。那么问题来了，什么是joinPoint？...
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 960
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 904
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Lambda表达式特点
weixin_57763462的博客
04-24 834
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
Java解决最长公共前缀
无人罪的博客
04-28 237
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 458
待更新。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 909
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
Spring cloud原理详解
qq_33449977的博客
04-28 351
想象一下，你开了一家餐馆，一开始只卖汉堡，后来生意火了，你又增加了炸鸡、披萨、冰淇淋各种摊位，每个摊位就是一个微服务，它们各自独立工作，但又得相互配合。有时候，某个服务可能太忙了，电话老打不通，这时候Spring Cloud还有个叫Hystrix的断路器，它会说：“嘿，别打了，那边线路忙，我给你个备用方案或者告诉你稍后再试。至于餐馆运营情况，Spring Cloud Sleuth和Zipkin这些工具，就像监控摄像头，记录服务间的每一次交互，方便你查看哪里出了问题，优化服务流程。
【限流】基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
最新发布
qq_43209531的博客
04-30 217
基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
spring  ioc aop面试题
03-16
1. 什么是Spring IOC？ Spring IOC（Inversion of Control）是一种设计模式，它将对象的创建和依赖关系的管理从应用程序代码中分离出来，交给Spring容器来管理。Spring IOC通过依赖注入（Dependency Injection）的方式，将对象之间的依赖关系注入到对象中，从而实现对象之间的解耦。 2. 什么是Spring AOP？ Spring AOP（Aspect Oriented Programming）是一种编程范式，它通过将横切关注点（Cross-cutting Concerns）从业务逻辑中分离出来，实现了代码的模块化和重用。Spring AOP通过在运行时动态地将切面（Aspect）织入到目标对象的方法中，实现了对目标对象的增强。 3. Spring IOC和AOP的关系是什么？ Spring IOC和AOP是Spring框架的两个核心特性。Spring IOC通过依赖注入的方式，实现了对象之间的解耦，从而提高了代码的可维护性和可测试性。Spring AOP通过将横切关注点从业务逻辑中分离出来，实现了代码的模块化和重用，从而提高了代码的可读性和可维护性。Spring IOC和AOP的结合，可以实现更加灵活和可扩展的应用程序架构。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值