Spring两大核心思想：IOC和AOP

2024-02-19 23:12
文章标签 java spring ioc aop 两大 核心思想

本文主要是介绍Spring两大核心思想：IOC和AOP，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

IOC:控制反转

Ioc概念

Ioc的优点

Spring Ioc

AOP:面向切面编程

AOP的优点

Spring AOP

1.添加依赖

2.核心概念

3.通知的类型

4.切点表达式

5.公共切点 @pointCut

6.切面优先级 @Order

7.使用自定义注解完成AOP的开发 

Spring AOP实现有几种方式？

Spring AOP 的原理,也就是Spring底层是如何实现AOP的？

Spring对于事物的实现

Spring事务隔离级别

事务传播机制

事务传播机制概念

Spring事务传播机制有哪些？

往外抛异常的几种情况

抛异常会影响的几种情况

IOC:控制反转

Ioc概念

先来说说IOC：IOC是一种思想。 控制反转，即对对象的控制权发生反转。即获取依赖对象的过程发生了反转。感觉就是传参的时候不再是单单传某个变量，而是直接传所要依赖的对象。这样不会再因为一处地方要增加参数或减少参数，而影响其它代码。耦合度降低。

Ioc的优点

  1. 集中管理
  2. 解耦合

Spring Ioc

Spring Ioc 则是实现了这种思想，获取依赖对象时 Spring Ioc 帮我们对对象做了管理。我们不再需要手动new对象，而是用的时候从Spring容器中取即可，即DI(依赖注入)。Spring ioc 可以理解为是 一个容器，可以用来存取对象。对对象的生命周期的控制权由程序员交给了Spring来管理。

对对象的控制权发生了变化，由之前的开发人员手动new对象，变为由Spring框架帮我们来管理对象，用的时候对象直接依赖注入(DI)。

AOP:面向切面编程

AOP是一种思想，是对一类事物的集中处理。比如：登录拦截请求，统一异常，同一结果返回等。而拦截器就是AOP的一种具体实现。AOP作用的维度更加细致(可以根据包、类、方法名、参数等进行拦截),能够实现更加复杂的业务逻辑。简单来说就是，AOP的作用就是保证开发者在不修改源代码的前提下，为系统中的业务组件添加某种通用功能。AOP就是代理模式的典型应用。Spring AOP就是AOP的一种实现方式,还有AspectJ，CGLIB。

AOP的优点

  1. 代码无入侵:不修改原始的业务方法,就可以对原始的业务方法进行功能的增强或者是功能的改变 。即解耦合。
  2. 减少了重复代码 。
  3. 提高开发效率 。
  4. 维护方便。

Spring AOP

1.添加依赖

    <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency>

2.核心概念

  • 1.切点(PointCut)：提供一组规则(切点表达式)，告诉程序对哪些方法进行功能增强
  • 2.连接点(Join Point)： 满足切点表达式规则的方法，就是连接点
  • 3.通知(Advice)：对满足切点表达式的方法具体要做哪些事，比如下面的记录方法执行耗时    
  • 4.切面(Aspect)：切面=切点+通知

切点和连接点的关系：切点就是满足切点表达式的所有方法，一个保存了许多连接点的集合，而连接点就是某一个方法，集合中的一个元素。

举例：全体同学上课

那切点就是：全体同学

连接点就是：张三，李四，某一个同学，其实就是执行目标方法

通知就是：上课

切面就是：整个定义的aop方法

  1. @Aspect:标识声明这是⼀个切面类
  2. @Around:环绕通知,在目标方法的前后都会被执行，后面的表达式表示对哪些方法进行增强
  3.  PrceedingJoinPoint.proceed()让原始方法执行

如下为记录一个方法执行耗时

@Aspect //声明该类为切面类
@Slf4j
@Component
@Order(2) //指定多个类的执行次序  值越小，优先级越高
//比如记录一个接口的执行时间
public class TestAspect {@Around("execution(* com.example.demo.controller.UserController.*.*(..))") //切点 生效 的范围 具体即某个接口，类或者包 自定义 切点表达式public Object record(ProceedingJoinPoint  pj) {  // pj 连接点/*** 以下为通知*/// 记录开始时间long start = System.currentTimeMillis();// 目标方法执行 以下为标准写法Object result = null;try {result = pj.proceed(); //执行原方法} catch (Throwable e) {log.error(pj.toShortString()+"发生异常，e:",e);}// 日志打印切点执行时间log.info(pj.getSignature()+"cost time:"+(System.currentTimeMillis()-start)+"ms");return result;}}

3.通知的类型

  1. @Around:环绕通知,此注解标注的通知方法在目标方法前,后都被执行
  2. @Before:前置通知,此注解标注的通知方法在目标方法前被执行 
  3. @After:后置通知,此注解标注的通知⽅法在目标方法后被执行,无论是否有异常都会执行
  4. @AfterReturning:返回后通知,此注解标注的通知方法在目标方法后被执行,有异常不会执行
  5. @AfterThrowing:异常后通知,此注解标注的通知方法发生异常后执行

由上执行结果可知，执行顺序为：

1.当目标方法执行无异常时：

2.当目标方法执行有异常且throws，往出抛时：

3.当目标方法执行有异常且try...catch...，捕获异常时：

2和3区别在于手动捕获异常时环绕通知前后都会执行，而直接往出抛异常时环绕后的代码不会执行。

4.切点表达式

切点表达式有两种：

  1. execution(...) 根据方法匹配
  2. @annotation(...) 根据注解匹配

区别是：execution表达式更适用有规则的，如果我们要匹配多个无规则的方法，更适合用注解。比如仅仅要匹配两个不同类中的的某个方法，直接在该方法上加注解。

示例

  • 匹配UserController下的所有无参方法
execution(* com.example.demo.controller.UserController.*())
  •  UserController下的 public 修饰，返回类型为 String 方法名为 getUserInfo ，无参方法
execution(public String com.example.demo.controller.UserController.getInfo())

5.公共切点 @pointCut

一个切面类中可以包含多个切点，多个切点的切点表达式可能会重复，我们可以采用@PointCut把共同的切点表达式提取出来，使用时直接调用即可。

@Aspect
@Slf4j
@Component
public class TestAspect {@Pointcut("execution(* com.example.demo.controller.UserController.*(..))")public void pt() {}@After("pt()")public void doAfter() {log.info("执行After...");}@Before("pt()")public void doBefore() {log.info("执行Before...");}}

还有一种情况，当公共切点和想要调用的切点不在同一个切面类中时：

@Aspect
@Slf4j
@Component
public class TestAspect2 {/*** 当公共切点和调用处不在同一个切面类中时，要写出该公共切点的全限定方法名* 全限定方法名 = 路径(包名) + 类名 + 方法名*/@After("com.example.demo.aspect.TestAspect3.pt()")public void doAfter() {log.info("执行After2...");}@Before("com.example.demo.aspect.TestAspect3.pt()")public void doBefore() {log.info("执行Before2...");}}

6.切面优先级 @Order

当我们在项目中定义了多个切面类时，并且这个切面类的多个切点都匹配到了同一个目标方法。如果我们对执行顺序有要求的话，可以在切面类上使用@Order()注解来设置执行优先级。

@Aspect //声明为一个切面类
@Slf4j //日志打印
@Component //对象添加到Spring框架中
@Order(3) //切面优先级
public class TestAspect1 {@Pointcut("execution(* com.example.demo.controller.UserController.*(..))")public void pt() {}@After("pt()")public void doAfter() {log.info("执行After1...");}@Before("pt()")public void doBefore() {log.info("执行Before1...");}}

@Order()括号中的数字越小，优先级越高。越先执行。

7.使用自定义注解完成AOP的开发 

  • 1.先自定义一个注解
@Target(ElementType.METHOD) //作用范围 此处是方法
@Retention(RetentionPolicy.RUNTIME) //生命周期 此处是运行时
public @interface TestAnnotation {
}
  • 2.在切点表达式中加入该注解
@Aspect
@Component
@Slf4j
public class TestAspect {@Around("@annotation(com.example.demo.aspect.TestAnnotation)") //此处加自定义注解public Object record(ProceedingJoinPoint joinPoint) {log.info("around继续");Object result = null;try {result = joinPoint.proceed();} catch (Throwable e) {log.error("joinPoint.toShortString()+"发生异常，e:",e");}return result;}
}
  • 3.在目标方法上加自定义注解，这种就适合不规则的，想要匹配哪个方法就在哪个方法上添加注解。
    @TestAnnotation //在目标方法上添加自定义注解@RequestMapping("/getuserinfo")public void getUserinfo(HttpServletRequest request) {log.info("执行目标方法");}

Spring AOP实现有几种方式？

1.基于Aspect注解

    @Aspect注解是aspectJ提供的，Spring中也用到了这个注解，修饰类，声明这是一个切面类

2.基于自定义注解

  • 第一步：自定义一个注解，设置词注解的作用范围，生命周期，
  • 第二步：在切点表达式中加入该注解，
  • 第三步：在目标方法上加入自定义注解。想匹配哪个方法就在哪个方法上加注解，适合不规                   则的。

3.基于代理来实现

      具体是基于动态代理实现的，两种方式，一种是JDK动态代理，另一种是CGlib动态代理。两种都使用了，具体使用哪种方式，与代理对象(是否是一个实现了接口的类)和项目配置有关。

Spring AOP 的原理,也就是Spring底层是如何实现AOP的？

代理模式概念

也叫委托模式，就是提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。就好比生活中的明星都有经纪人，一些人想要找明星拍戏，代言等，都不是直接与明星谈的，而是找其经纪人。 代理模式又分为静态代理和动态代理。

静态代理：在程序运行前代理类就已经固定好了，即代理类的.class文件已经存在了。使用起来不灵活。

动态代理：与静态代理相比，动态代理更加灵活。不再是提前写好代理，而是由JVM运行时，程序运行过程中根据需要动态生成。即创建代理对象的时机是在运行时。动态代理底层又是基于反射实现的。

Spring AOP是基于动态代理实现的 ，有两种方式：

1.基于JDK动态代理。有缺陷，只能代理实现了接口的类，不能代理普通类。

2.基于CGlib动态代理。接口和普通类都可以代理。

运行时使用哪种方式与项目配置和代理对象有关。

存在一个属性 proxyTargetClass ，可以使用注解或配置设置它，默认是false。

proxyTargetClass目标对象代理方式
false实现了接口JDK代理
false未实现接口(只有实现类)CGlib代理
true实现了接口CGlib代理
true未实现接口(只有实现类)CGlib代理

由上表可知，当属性为默认值false时，目标对象实现了接口的类就用JDK代理，未实现接口的类(普通类)就用CGlib代理。当属性值被设置为true时，无论是接口还是普通类都使用CGlib代理。

可以通过如下注解设置默认值：

@EnableAspectJAutoProxy(proxyTargetClass = true) //作用于类上

Springboot2.x版本以前默认是JDK代理，Springboot2.x版本开始，默认使用CGlib代理。可以在yml文件配置中修改，如下默认是true，即CGlib代理。修改为false，则是JDK代理。

Spring对于事物的实现

1.编程式(手动式)：开启事务，提交事务，回滚事务

开启事务，相当于新开了一条分支，在分支上进行增删改查，并不会影响到主干，只有提交事务操作，才会合并到主干上，实现真正的增删改查。而回滚事务也是在分支上进行增删改查，不过并没有合并，销毁了这个分支。说是没有合并，但是自增主键上却是留有痕迹的。 从日志来看，回滚是比提交少了一条提交日志。 

2.声明式(注解) : 方法上添加 @Transactional 注解，将整个方法看做一个原子性操作，执行成功自动提交事务，发生异常等自动回滚。默认异常是属于运行时异常或Error时，才进行回滚。也可以如下设置。

@Transactional(rollbackFor = {Exception.class})  // 设置回滚的异常类型
  • 发生异常时，如果异常往外抛了，事务会进行回滚
  • 发生异常时，如果异常进行处理(即捕获 try...catch... )了(虽然捕获了异常，但若是throw异常，还是会回滚，重点是没有往外抛)，事务会进行提交

总结：发生异常时，不考虑异常类型的情况下，事务提交还是回滚，就看异常有没有往外抛。就好比往外抛时注解感知到了，才回滚，如果内部发现并处理，并没有往外抛，外面也感知不到，所以就正常提交了。

那如果我们既想捕获，又不想事务提交，有两种办法：

  • 1.手动重新往外抛异常
    @Transactional@RequestMapping("/test")public String test() {// 捕获异常try {int a = 1/0; }catch (Exception e) {log.error("发生了异常");throw e;  // 第一种 捕获到异常再往出抛异常}return "test";}
  • 2.手动回滚事务
    @Transactional@RequestMapping("/test")public String test() {// 捕获异常try {int a = 1/0; }catch (Exception e) {log.error("发生了异常");//第二种 手动回滚事务TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); }return "test";}

@Transactional执行流程

  1. 方法执行前，开启事务
  2. 执行方法
  3. 若方法正常执行，事务进行提交；若方法出现异常，事务进行回滚

Spring事务隔离级别

Spring中事务隔离级别有5种:

  1. Isolation.DEFAULT：以连接的数据库的事务隔离级别为主。Spring默认隔离级别
  2. Isolation.READ_UNCOMMITTE：读未提交
  3. Isolation.READ_COMMITTED：读已提交
  4. Isolation.REPEATABLE_READ：可重复读
  5. Isolation.SERIALIZABLE：串行化
@Transactional(isolation = Isolation.DEFAULT) // 手动设置隔离级别

事务传播机制

事务传播机制概念

其实就是多个加了事物的方法之间存在调用关系，多个事务方法存在调用关系时，事务是如何在这些方法间进行传播的。比如有两个方法A,B都被 @Transacional 修饰，且A调用了B，那么B方法在运行时，是加入A的事务，还是重新创建一个新事务呢？

Spring事务传播机制有哪些？

Spring事务传播机制共有7种，默认是Propagation.REQUIRED，可以通过Propagation修改传播机制规则。我的理解是其实主要给被调用的方法的事务设置参数的。

  1. Propagation.REQUIRED（加入事务）：如果当前存在事务，则加入该事务。如果当前没有事务，则创建⼀个新的事务。即多个存在调用关系的方法都在同一个事务中，一起成功，一起失败。Spring默认传播机制。
  2. Propagation.SUPPORTS （支持当前事务）：如果当前存在事务，则加入该事务。如果当前没有事务，则以非事务的方式继续运行。
  3. Propagation.MANDATORY ：如果当前存在事务，则加入该事务。如果当前没有事务，则抛出异常。
  4. Propagation.REQUIRES_NEW （新建事务）：如果当前存在事务，则把当前事务挂起。无论当前存不存在事务，只要被 Propagation.REQUIRES_NEW 修饰的方法都会开启一个新事物。且开启的事务相互独立，互不干扰，互不影响。比如有A，B两个方法，A调用了B，A虽然调用了B，但A,B是在两个不同的事务中，提交还是回滚取决于自己，互不影响。
  5. Propagation.NOT_SUPPORTED（不支持当前事务）：以非事务方式，如果当前存在事务，则把当前事务挂起。
  6. Propagation.NEVER ：以非事务方式运行，如果当前存在事务，则抛出异常。
  7. Propagation.NESTED（嵌套事务）：如果当前存在事务，则创建⼀个事务作为当前事务的嵌套事务来运行。如果当前没有事务，则该取值等价于PROPAGATION_REQUIRED 。多个存在调用关系且被 @Transcational 修饰的方法，其中某一个方法出现异常，在不考虑异常类型的情况下。若是异常抛出，那么全部都会回滚，此时作用和默认传播事务 REQUIRED 一样。若是内部处理，没让异常抛出并且手动进行了回滚， 那么出现异常的方法才会回滚，其他都正常提交。即实现局部回滚。若仅仅只是内部处理了异常，既没抛出，也没手动回滚，还是会正常提交的。
@Transactional(propagation = Propagation.REQUIRED) // 手动设置事务隔离级别

往外抛异常的几种情况

  1. 对异常没有处理。
  2. 虽然try...catch...捕获到了异常，但是又重新throw抛出了异常。

抛异常会影响的几种情况

  1. 如果是被调用方有异常抛出了，会影响调用方。
  2. 会影响自身，往外抛，自身也会感知到，并进行回滚。

一个方法内有异常但不抛异常，则自身感知不到异常，就会正常提交，不会回滚。想要进行回滚可以通过手动代码回滚。

这篇关于Spring两大核心思想：IOC和AOP的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/726295。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
JAVA智听未来一站式有声阅读平台听书系统小程序源码

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来，一站式有声阅读平台听书系统 🌟&nbsp;开篇：遇见未来，从“智听”开始 在这个快节奏的时代，你是否渴望在忙碌的间隙，找到一片属于自己的宁静角落？是否梦想着能随时随地，沉浸在知识的海洋，或是故事的奇幻世界里？今天，就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统，它正悄悄改变着我们的阅读方式，让未来触手可及！ 📚&nbsp;第一站：海量资源，应有尽有 走进“智听
阅读更多...
在cscode中通过maven创建java项目

在cscode中通过maven创建java项目

在cscode中创建java项目 可以通过博客完成maven的导入 建立maven项目 使用快捷键 Ctrl + Shift + P 建立一个 Maven 项目 1 Ctrl + Shift + P 打开输入框2 输入 "> java create"3 选择 maven4 选择 No Archetype5 输入 域名6 输入项目名称7 建立一个文件目录存放项目，文件名一般为项目名8 确定
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2