1.学习编程｜Spring源码深度解析 读书笔记 第5章：容器的事务事务深度功能扩展
2.Springboot之分布式事务框架Seata实现原理源码分析
3.SpringBoot源码之旅——事务
4.Spring事务注解@Transactional原理解析
5.Spring 源码学习 13：initMessageSource
6.学习编程｜Spring源码深度解析 读书笔记 第4章：bean的加载

学习编程｜Spring源码深度解析 读书笔记 第5章：容器的功能扩展

       深入理解Spring容器的扩展功能：学习笔记

       作者：牛客网-张学友

       在Spring框架中，容器功能的源码源码扩展是其强大和灵活的关键。首先，详细学习ApplicationContext相较于BeanFactory，解析提供了更多功能，事务事务深度它是源码源码增加子弹伤害源码BeanFactory的子类，包含了其所有功能并有所扩充。详细学习主要区分点在于ApplicationContext的解析启动过程和其特有的扩展功能。

       通过`ClassPathXmlApplicationContext`的事务事务深度实例化，开启源码探索之旅。源码源码在构造函数和`refresh`方法中，详细学习Spring对配置文件解析，解析并实现了一系列扩展，事务事务深度如环境变量处理、源码源码配置文件加载、详细学习Spring Expression Language (SPEL)的支持、属性编辑器的注册以及ApplicationContextAwareProcessor的使用等。这些扩展不仅增强了容器的灵活性，还为开发者提供了更丰富的控制选项。

       例如，`refresh`方法中包含了初始化准备工作、BeanFactory的获取和定制、XML文件解析、bean定义填充、Spring表达式解析、属性编辑器注册、BeanPostProcessor的处理、依赖处理和国际化功能等。有h5源码这些步骤体现了Spring框架的高度可扩展性，使得用户可以根据项目需求定制容器行为。

       总结来说，Spring容器的功能扩展涉及到了配置文件处理、表达式语言、事件监听、国际化等多个方面，使得开发过程更加便捷且易于定制。想了解更多细节，可以参考作者的原文链接和更多读书笔记资源。

Springboot之分布式事务框架Seata实现原理源码分析

       在Springboot 2.2. + Seata 1.3.0环境中，Seata通过GlobalTransactionScanner实现全局事务管理。首先，它会扫描带有@GlobalTransactional注解的方法类，作为BeanPostProcessor处理器，通过InstantiationAwareBeanPostProcessor的postProcessAfterInitialization方法中的wrapIfNecessary方法进行全局事务拦截。

       GlobalTransactionScanner判断类方法是否有@GlobalTransactional注解，如果没有则直接返回，否则创建GlobalTransactionalInterceptor。拦截器负责全局事务的执行，包括事务开始、执行本地业务、提交和回滚等步骤。例如，事务开始时，Seata通过SPI技术将xid绑定到当前线程，执行过程中会记录undo log以实现回滚。用户管理软件源码

       Seata自动配置会创建代理数据源（DataSourceProxy），在数据源方法调用时进行代理处理。当调用带有全局事务的方法时，如RestTemplate和Feign，拦截器会传递XID到请求头中，确保跨服务的事务一致性。参与者（被调用服务）通过SeataHandlerInterceptor拦截器获取并绑定XID，然后通过ConnectionProxy代理进行数据库操作，其中ConnectionContext用于判断是否为全局事务。

       总结来说，Seata的核心机制是通过代理、拦截器和XID的传递，确保分布式环境下的事务处理协调和一致性。

SpringBoot源码之旅——事务

       事务是数据操作的逻辑单元，旨在确保数据一致性和操作隔离。它包括两个核心目标：数据一致性和操作隔离。数据一致性要求事务提交后，所有操作成功执行，更改永久生效；而操作隔离则确保多个并发事务独立执行，互不影响。

       事务管理资源不仅限于数据库，也涵盖了消息队列、文件系统等。通常讨论的事务主要指的是“数据库事务”。研究中，我们将围绕MySQL数据库和Spring声明式事务展开，但所涉及的修改安卓ID 源码事务概念、接口抽象和实现方式适用于更广泛的场景。

       在实现声明式事务时，关键概念包括ACID（原子性、一致性、隔离性、持久性）、隔离级别和事务传播机制。实现依赖于AOP（面向切面编程），通过环绕增强在目标方法执行前后启动或提交事务。

       事务增强通常涉及TransactionInterceptor，对于基于JDK接口动态代理的实现，要求方法必须为public或public final，且不能使用protected、private或static修饰。基于CGLib的字节码动态代理在扩展类时受限于final、static、private修饰符。

       事务管理的核心接口包括TransactionDefinition（描述事务属性）和TransactionStatus（表示事务状态），而PlatformTransactionManager则负责创建和管理事务行为。

       ThreadLocal机制用于共享数据库连接，确保同一线程内的操作在同一个事务中。不同线程下的嵌套调用则工作在独立事务中。

       声明式事务通过生成代理对象实现，Spring的MethodInterceptor接口在Bean方法调用时触发TransactionInterceptor。TransactionInterceptor在invoke方法中通过TransactionAspectSupport处理事务，支持声明式和编程式事务。

       事务传播机制中，阿里云外链源码Spring通过AbstractPlatformTransactionManager获取当前事务状态。在DataSourceTransactionManager的具体实现中，通过TransactionSynchronizationManager记录当前事务资源和同步回调，确保操作在一致的事务上下文中执行。

       TransactionSynchronizationManager通过ThreadLocal记录资源和同步信息，便于事务同步。在事务提交流程中，触发回调以精确控制事务操作的不同阶段。

       实现细节涉及流程图和具体的代码示例，这些内容有助于深入理解Spring事务管理的实现。参考资源包括网易云信的技术文章、柳树关于Spring事务的讲解，以及《精通Spring 4.x 企业应用开发实战》等书籍。

Spring事务注解@Transactional原理解析

       事务管理是应用系统开发的关键部分，Spring 提供了丰富且方便的事务管理解决方案，显著简化了代码编写并提高了可维护性。

       以原生JDBC事务处理与Spring的事务处理进行对比，原生代码中充斥着复杂且重复的事务管理逻辑，而使用Spring则通过简单的注解即可实现。例如，针对保存三张表数据的需求（country、city、category），若采用原生JDBC，代码会显得冗长且难于维护。而在Spring中，通过设置特定的事务属性，如`Propagation.REQUIRES_NEW`，只需在对应方法上添加`@Transactional`注解，Spring便会自动处理事务，极大简化了代码。

       Spring的声明式事务机制，通过`TransactionAutoConfiguration`类自动配置事务相关组件，并由`TransactionInterceptor`类执行事务处理逻辑，实现了对带有`@Transactional`注解的方法的代理。此单例对象确保了所有事务逻辑的一致性和高效性。

       在使用`@Transactional`注解时，需要关注其属性的含义，包括`propagation`和`isolation`。`propagation`属性定义了事务的传播行为，如是否需要新事务、是否在当前事务中进行等。`isolation`属性则决定了事务的隔离级别，确保不同事务之间数据的一致性。

       进一步深入了解`@Transactional`注解的实现细节，可参阅Spring源码。GitHub和Gitee提供该代码的同步版本，方便开发者深入研究。

Spring 源码学习 ：initMessageSource

       前言

       阅读完registerBeanPostProcessors源码后，接下来就是initMessageSource这一步骤，其主要功能是初始化国际化文件。

       按照惯例，首先通过官网了解国际化的用法，然后深入研究源码。

       官网1..1. Internationalization using MessageSource[1]中提到，MessageSource的主要作用是使用国际化，定制不同的消息。

       需要注意的是，MessageSource定义的Bean名称必须为messageSource，如果找不到则会默认注册DelegatingMessageSource作为messageSource的Bean。

       1. 创建国际化文件

       2. 声明MessageSource

       在JavaConfig中声明MessageSource，记得名字一定要叫做messageSource！

       3. 测试结果

       执行后输出结果如下：

       了解了国际化是如何使用的之后，再看看这一步的源码，就知道其作用了！

       initMessageSource源码

       这块源码唯一值得关注的地方就是，Bean的名称必须要是messageSource。

       总结

       本文通过官网，了解到什么是国际化，以及国际化的使用，并结合代码和源码，知其然，知其所以然。

       当然本文需要注意的地方就是国际化MessageSource的Bean名称要必须为messageSource。

学习编程｜Spring源码深度解析 读书笔记 第4章：bean的加载

       在Spring框架中，bean的加载过程是一个精细且有序的过程。首先，当需要加载bean时，Spring会尝试通过转换beanName来识别目标对象，可能涉及到别名或FactoryBean的识别。

       加载过程分为几步：从缓存查找单例，Spring容器内单例只创建一次，若缓存中无数据，会尝试从singletonFactories寻找。接着是bean的实例化，从缓存获取原始状态后，可能需要进一步处理以符合预期状态。

       原型模式的依赖检查是单例模式特有的，用来避免循环依赖问题。然后，如果缓存中无数据，会检查parentBeanFactory，递归加载配置。BeanDefinition会被转换为RootBeanDefinition，合并父类属性，确保依赖的正确初始化。

       Spring根据不同的scope策略创建bean，如singleton、prototype等。类型转换是后续步骤，可能将返回的bean转换为所需的类型。FactoryBean的使用提供了灵活的实例化逻辑，用户自定义创建bean的过程。

       当bean为FactoryBean时，getBean()方法代理了FactoryBean的getObject()，允许通过不同的方式配置bean。缓存中获取单例时，会执行循环依赖检测和性能优化。最后，通过ObjectFactory实例singletonFactory定义bean的完整加载逻辑，包括回调方法用于处理单例创建前后的状态。

SpringBoot源码学习——SpringBoot自动装配源码解析+Spring如何处理配置类的

       SpringBoot通过SPI机制，借助外部引用jar包中的META-INF/spring.factories文件，实现引入starter即可激活功能，简化手动配置bean，实现即开即用。

       启动SpringBoot服务，通常使用Main方法启动，其中@SpringBootApplication注解包含@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan，自动装配的核心。

       深入分析@SpringBootApplication，其实质是执行了@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan三个注解的功能，简化了配置过程，强调了约定大于配置的思想。

       SpringBoot的自动装配原理着重于研究如何初始化ApplicationContext，Spring依赖于ApplicationContext实现其功能，SpringApplication#run方法为初始化ApplicationContext的入口。

       分析SpringApplication构造方法，SpringApplication.run(启动类.class, args) 实际调用的是该方法，其关键在于根据项目类型反射生成合适的ApplicationContext。

       选择AnnotationConfigServletWebServerApplicationContext，此上下文具备启动Servlet服务器和注册Servlet或过滤器类型bean的能力。

       准备刷新ApplicationContext，SpringBoot将主类注册到Spring容器中，以便@ConfigurationClassPostProcessor解析主类注解，发挥@Import、@ComponentScan的作用。

       刷新ApplicationContext过程包括一系列前置准备，如将主类信息封装成AnnotatedGenericBeanDefinition，解析注解并调用BeanDefinitionCustomizer自定义处理。

       解析配置类中的注解，通过BeanDefinitionRegistryPostProcessor和ConfigurationClassParser实现，筛选、排序候选者，并解析@Import注解实现自动装配。

       增强配置类，ConfigurationClassPostProcessor对full模式的配置进行增强，确保@Import正确处理，CGLIB用于增强原配置类，确保生命周期完整，避免真正执行@Bean方法逻辑。

       深入解析AutoConfigurationImportSelector实现自动装配，通过spring.boot.enableautoconfiguration设置开启状态，读取spring-autoconfigure-metadata.properties和META-INF/spring.factories文件，筛选并加载自动配置类。

spring—AOP与事务

        title: spring——AOP与事务.md

        date: -- ::

        categories: [Spring]

        tags: [AOP,事务]

        toc: true

        先列出源码中比较重点的几个类：

        1、<aop:before method="before" pointcut-ref="myMethods"/>包装成一个advisor

        2、AspectJAwareAdvisorAutoProxyCreator，当实例化所有bean都会执行到AspectJAwareAdvisorAutoProxyCreatorç±»

        它会检测bean是否advisor以及advice存在，如果有就说明这个bean有切面，有切面那么就会生成代理

        3、jdk的代理，bean里面的所有advisor加入到proxyFactory。

        4、jdkDynamicProxy invoke，拿到bean里面的所有Interceptor，会循环proxyFactory里面的所有advisor

        里面有advice，里面的advice有两种类型，要么是advice，要么是MethodInterceptor类型的

        5、当代理对象调用方式，是一个MethodInterceptor类型的类的链式调用过程，直到容器的大小和索引一致的时候调用JoinPoint目标方法

        before：this.advice.before(),invocation.processd();

        装配参数，切面里面before方法的method对象，method.getParamterTypes()[0]

        最终会把advice封装成MethodInterceptor类型的对象

        程序执行的某个特定位置：如类开始初始化前、类初始化后、类某个方法调用前、调用后、方法抛出异常后。一个类或一段程序代码拥有一些具有边界性质的特定点，这些点中的特定点就称为“连接点”。Spring仅支持方法的连接点，即仅能在方法调用前、方法调用后、方法抛出异常时以及方法调用前后这些程序执行点织入增强。连接点由两个信息确定：第一是用方法表示的程序执行点；第二是用相对点表示的方位。

        每个程序类都拥有多个连接点，如一个拥有两个方法的类，这两个方法都是连接点，即连接点是程序类中客观存在的事物。AOP通过“切点”定位特定的连接点。连接点相当于数据库中的记录，而切点相当于查询条件。切点和连接点不是一对一的关系，一个切点可以匹配多个连接点。在Spring中，切点通过org.springframework.aop.Pointcut接口进行描述，它使用类和方法作为连接点的查询条件，Spring AOP的规则解析引擎负责切点所设定的查询条件，找到对应的连接点。其实确切地说，不能称之为查询连接点，因为连接点是方法执行前、执行后等包括方位信息的具体程序执行点，而切点只定位到某个方法上，所以如果希望定位到具体连接点上，还需要提供方位信息。

        增强是织入到目标类连接点上的一段程序代码，在Spring中，增强除用于描述一段程序代码外，还拥有另一个和连接点相关的信息，这便是执行点的方位。结合执行点方位信息和切点信息，我们就可以找到特定的连接点。

        增强逻辑的织入目标类。如果没有AOP，目标业务类需要自己实现所有逻辑，而在AOP的帮助下，目标业务类只实现那些非横切逻辑的程序逻辑，而性能监视和事务管理等这些横切逻辑则可以使用AOP动态织入到特定的连接点上。

        引介是一种特殊的增强，它为类添加一些属性和方法。这样，即使一个业务类原本没有实现某个接口，通过AOP的引介功能，我们可以动态地为该业务类添加接口的实现逻辑，让业务类成为这个接口的实现类。

        织入是将增强添加对目标类具体连接点上的过程。AOP像一台织布机，将目标类、增强或引介通过AOP这台织布机天衣无缝地编织到一起。根据不同的实现技术，AOP有三种织入的方式：

        a、编译期织入，这要求使用特殊的Java编译器。

        b、类装载期织入，这要求使用特殊的类装载器。

        c、动态代理织入，在运行期为目标类添加增强生成子类的方式。

        Spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。

        一个类被AOP织入增强后，就产出了一个结果类，它是融合了原类和增强逻辑的代理类。根据不同的代理方式，代理类既可能是和原类具有相同接口的类，也可能就是原类的子类，所以我们可以采用调用原类相同的方式调用代理类。

        切面由切点和增强（引介）组成，它既包括了横切逻辑的定义，也包括了连接点的定义，Spring AOP就是负责实施切面的框架，它将切面所定义的横切逻辑织入到切面所指定的连接点中。

        advisor： pointCut advice

        一类功能的增强

        around方法里面代码切面

        事务切面

        缓存切面

        日志切面

        事务（Transaction），一般是指要做的或所做的事情。在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。是数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列操作；这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行；事务是一组不可再分割的操作集合（工作逻辑单元）。

        大致流程形如

        数据库事务拥有几大特性：

        事务的四大特性：

        事务是数据库的逻辑工作单位，事务中包含的各操作要么都做，要么都不做

        事 务执行的结果必须是使数据库从一个一致性状态变到另一个一致性状态。因此当数据库只包含成功事务提交的结果时，就说数据库处于一致性状态。如果数据库系统 运行中发生故障，有些事务尚未完成就被迫中断，这些未完成事务对数据库所做的修改有一部分已写入物理数据库，这时数据库就处于一种不正确的状态，或者说是 不一致的状态。

        一个事务的执行不能其它事务干扰。即一个事务内部的操作及使用的数据对其它并发事务是隔离的，并发执行的各个事务之间不能互相干扰。

        也称永久性，指一个事务一旦提交，它对数据库中的数据的改变就应该是永久性的。接下来的其它操作或故障不应该对其执行结果有任何影响。

        个人理解，事务在Spring中是借助AOP技术来实现的，可以作为AOP中的一个事务切面。spring源码对事务的处理逻辑，自己研究吧！

        ORM框架中以Mybatis为例，事务处理就是用到了一个类Transaction，部分源码如下

        可以看出Transaction管理的就是一个connection，而connection我们很清楚是与用户会话挂钩的。

        那么关系就是Transaction 管理Connection ，而connection与 用户session一对一存在。

        在springBoot中，只需要加入POM就可以了，配合注解使用即可。

        接下来就是事务的控制了。

        首先事务有几大传播属性：

        其中最常见的，用得最多就 PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、 PROPAGATION_NESTED 这三种。事务的传播属性是 spring 特有的，是 spring 用来控制方法事务的一种手段，说直白点就是用来控制方法是否使用同一事务的一种属性，以及按照什么规则回滚的一种手段。

        下面用代码演示这三种属性的机制：

        事务的默认属性就是required，通过Transactional.java中的Propagation propagation() default Propagation.REQUIRED; 可以看出。

        这种情况就是事务1，事务2 都加入到了事务0中。不管是1，2哪个事务抛出异常，事务0都会回滚。数据添加会失败。

        这种情况就是：

        事务0（required） {

        ​ 事务1 （REQUIRES_NEW）

        ​ 事务2

        }

        此时。

        情况a：

        1、如果只是事务2出现了异常，那么事务1会提交，事务2加入到事务0中会回滚。

        2、如果只是事务1出现了异常，那么事务1会回滚，向上层事务0抛异常，事务2会加入到事务0中，这时都会回滚。

        情况b：

        如果事务1，事务2都是REQUIRES_NEW传播属性。那么结果就是：

        1、如果事务1，抛出了异常，那么事务2是不会执行的，那么事务0必然回滚。

        2、如果事务2，抛出异常，那么事务1会提交，表中会有数据。事务2有异常回滚并抛出，事务0回滚。

        NESTED属性其实就是创建了回滚点，有异常时，会回滚到指定的回滚点。

        在这通过代码测试，出现一种情况是，无论事务1，事务2哪个有异常，数据都不会插入成功，原因是，不论是事务1还是事务2都会向事务0抛出异常，事务0捕获到异常后，执行rollback()方法，这就操作成了，事务的全部回滚。

        如果想要事务1和事务2 想要根据自己的回滚点回滚，那么事务0必须自己处理异常，不让spring捕获到这个异常，那么就满足了。把代码改成这种：

        Jack大佬提供了，伪代码分析法。

        按照Spring源码的事务处理逻辑，伪代码大致为：