本文主要是介绍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的优点
- 集中管理
- 解耦合
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的优点
- 代码无入侵:不修改原始的业务方法,就可以对原始的业务方法进行功能的增强或者是功能的改变 。即解耦合。
- 减少了重复代码 。
- 提高开发效率 。
- 维护方便。
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方法
- @Aspect:标识声明这是⼀个切面类
- @Around:环绕通知,在目标方法的前后都会被执行，后面的表达式表示对哪些方法进行增强
- 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.通知的类型
- @Around:环绕通知,此注解标注的通知方法在目标方法前,后都被执行
- @Before:前置通知,此注解标注的通知方法在目标方法前被执行
- @After:后置通知,此注解标注的通知⽅法在目标方法后被执行,无论是否有异常都会执行
- @AfterReturning:返回后通知,此注解标注的通知方法在目标方法后被执行,有异常不会执行
- @AfterThrowing:异常后通知,此注解标注的通知方法发生异常后执行
由上执行结果可知，执行顺序为：
1.当目标方法执行无异常时：
2.当目标方法执行有异常且throws，往出抛时：
3.当目标方法执行有异常且try...catch...，捕获异常时：
2和3区别在于手动捕获异常时环绕通知前后都会执行，而直接往出抛异常时环绕后的代码不会执行。
4.切点表达式
切点表达式有两种：
- execution(...) 根据方法匹配
- @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执行流程
- 方法执行前，开启事务
- 执行方法
- 若方法正常执行，事务进行提交；若方法出现异常，事务进行回滚
Spring事务隔离级别
Spring中事务隔离级别有5种:
- Isolation.DEFAULT：以连接的数据库的事务隔离级别为主。Spring默认隔离级别
- Isolation.READ_UNCOMMITTE：读未提交
- Isolation.READ_COMMITTED：读已提交
- Isolation.REPEATABLE_READ：可重复读
- Isolation.SERIALIZABLE：串行化
@Transactional(isolation = Isolation.DEFAULT) // 手动设置隔离级别事务传播机制
事务传播机制概念
其实就是多个加了事物的方法之间存在调用关系，多个事务方法存在调用关系时，事务是如何在这些方法间进行传播的。比如有两个方法A,B都被 @Transacional 修饰，且A调用了B，那么B方法在运行时，是加入A的事务，还是重新创建一个新事务呢？
Spring事务传播机制有哪些？
Spring事务传播机制共有7种，默认是Propagation.REQUIRED，可以通过Propagation修改传播机制规则。我的理解是其实主要给被调用的方法的事务设置参数的。
- Propagation.REQUIRED（加入事务）：如果当前存在事务，则加入该事务。如果当前没有事务，则创建⼀个新的事务。即多个存在调用关系的方法都在同一个事务中，一起成功，一起失败。Spring默认传播机制。
- Propagation.SUPPORTS （支持当前事务）：如果当前存在事务，则加入该事务。如果当前没有事务，则以非事务的方式继续运行。
- Propagation.MANDATORY ：如果当前存在事务，则加入该事务。如果当前没有事务，则抛出异常。
- Propagation.REQUIRES_NEW （新建事务）：如果当前存在事务，则把当前事务挂起。无论当前存不存在事务，只要被 Propagation.REQUIRES_NEW 修饰的方法都会开启一个新事物。且开启的事务相互独立，互不干扰，互不影响。比如有A，B两个方法，A调用了B，A虽然调用了B，但A,B是在两个不同的事务中，提交还是回滚取决于自己，互不影响。
- Propagation.NOT_SUPPORTED（不支持当前事务）：以非事务方式，如果当前存在事务，则把当前事务挂起。
- Propagation.NEVER ：以非事务方式运行，如果当前存在事务，则抛出异常。
- Propagation.NESTED（嵌套事务）：如果当前存在事务，则创建⼀个事务作为当前事务的嵌套事务来运行。如果当前没有事务，则该取值等价于PROPAGATION_REQUIRED 。多个存在调用关系且被 @Transcational 修饰的方法，其中某一个方法出现异常，在不考虑异常类型的情况下。若是异常抛出，那么全部都会回滚，此时作用和默认传播事务 REQUIRED 一样。若是内部处理，没让异常抛出并且手动进行了回滚， 那么出现异常的方法才会回滚，其他都正常提交。即实现局部回滚。若仅仅只是内部处理了异常，既没抛出，也没手动回滚，还是会正常提交的。
@Transactional(propagation = Propagation.REQUIRED) // 手动设置事务隔离级别往外抛异常的几种情况
- 对异常没有处理。
- 虽然try...catch...捕获到了异常，但是又重新throw抛出了异常。
抛异常会影响的几种情况
- 如果是被调用方有异常抛出了，会影响调用方。
- 会影响自身，往外抛，自身也会感知到，并进行回滚。
一个方法内有异常但不抛异常，则自身感知不到异常，就会正常提交，不会回滚。想要进行回滚可以通过手动代码回滚。
这篇关于Spring两大核心思想：IOC和AOP的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
