Spring源码解析之-- 事务InfrastructureAdvisorAutoProxyCreator 分析

最新推荐文章于 2023-08-18 11:36:23 发布
最新推荐文章于 2023-08-18 11:36:23 发布
阅读量2k 收藏 7
点赞数 1
分类专栏： spring 文章标签： spring java AbstractAutoPro transactionMan
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mamamalululu00000000/article/details/114396496
版权

目录

一、介绍

上一章 Spring源码解析之-- 事务注解 处理流程 分析我们已经 介绍了 事务的 分析过程，这一章，详细对其中的 几个步骤 分析在何时 起作用.

二、InfrastructureAdvisorAutoProxyCreator 分析

2.1 结构

在这里插入图片描述
从层次结构图上，可以看出 InfrastructureAdvisorAutoProxyCreator 继承了 AbstractAutoProxyCreator， 而AbstractAutoProxyCreator 实现了SmartInstantiationAwareBeanPostProcessor 接口， 所以在每一个bean 初始化过程都是会运行 postProcessAfterInitialization 方法

关于 BeanPostProcessor 相关的运行机制 ，可以查看 spring源码解析之—BeanPostProcessor解析

2.1 解析

2.1.1 postProcessBeforeInstantiation

我们知道 在Bean 实例化之前会运行 postProcessBeforeInstantiation，我们先看一下 AbstractAutoProxyCreator.class 里面对应的
postProcessBeforeInstantiation 实现， 这里会先判断一些是否需要代理， 在postProcessAfterInitialization 里面会获取

public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
        // 主要对 FactoryBean 的前缀加一下"&"
		Object cacheKey = getCacheKey(beanClass, beanName);
        // 判断targetSourcedBeans 是否包含beanName, targetSourcedBeans 里放的是 已经处理好的targetSource
		if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
		    // 如果 advisedBeans里面包含 cachekey，返回null, 说明此 beanClass 之前已经被处理过了
			if (this.advisedBeans.containsKey(cacheKey)) {
				return null;
			}
			/** 这里判断beanClass 是否 Advice.class,Pointcut.class,Advisor.class,
			AopInfrastructureBean.class ,如果实现了这些接口，就不需要代理，放入advisedBeans中， value 设置为False
			shouldSkip: 主要就是判断给定的bean名称是否表示"original instance"
			*/
			if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
				this.advisedBeans.put(cacheKey, Boolean.FALSE);
				return null;
			}
		}

		/**
		这里是获取自定义的 targetSource，Spring 提供了LazyInitTargetSourceCreator， QuickTargetSourceCreator，
		也可以自定义,获取到targetSource，加入到targetSourcedBeans 里面，创建代理
        AbstractAutoProxyCreator 被很多的类继承， 所以getAdvicesAndAdvisorsForBean 的实现也各不相同
        这里我们 就只AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean 的逻辑
         具体在下面getAdvicesAndAdvisorsForBean  和createProxy 的逻辑下面分析
		**/
		TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
		if (targetSource != null) {
			if (StringUtils.hasLength(beanName)) {
				this.targetSourcedBeans.add(beanName);
			}
			Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
			Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
			this.proxyTypes.put(cacheKey, proxy.getClass());
			return proxy;
		}

		return null;
	}

2.1.2 postProcessAfterInitialization

接下来看一下postProcessAfterInitialization 的相关逻辑

	@Override
	public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
		if (bean != null) {
		// 主要对 FactoryBean 的前缀加一下"&"
			Object cacheKey = getCacheKey(bean.getClass(), beanName);
			//判断是否是否循环依赖
			if (this.earlyProxyReferences.remove(cacheKey) != bean) {
			    // 对当前bean 进行封装
				return wrapIfNecessary(bean, beanName, cacheKey);
			}
		}
		return bean;
	}

2.1.3 wrapIfNecessary

wrapIfNecessary主要的逻辑是：

  1. 从 targetSourcedBeans 获取， 如果有直接返回
  2. 从 advisedBeans 获取，如果为false, 直接返回，不需要增强
  3. 判断是否是 Advice.class,Pointcut.class,Advisor.class, AopInfrastructureBean.class ,如果实现了这些接口，就不需要增强，直接返回，并放入advisedBeans里面
  4. 获取 适合的 候选增强器
  5. 创建对应的代理并返回
	protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
	     // 如果已经处理过了，直接返回
		if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
			return bean;
		}
		//从advisedBeans获取beanName 对应的，是否需要advise, false 就说明不需要封装，直接返回
		if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
			return bean;
		}
		/** 这里判断beanClass 是否 Advice.class,Pointcut.class,Advisor.class,
			AopInfrastructureBean.class ,如果实现了这些接口，就不需要代理，放入advisedBeans中， value 设置为False
			shouldSkip: 主要就是判断给定的bean名称是否表示"original instance"
		*/
		if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return bean;
		}

		// Create proxy if we have advice.
		// 获取 适合的 候选增强器
		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
		if (specificInterceptors != DO_NOT_PROXY) {
		    // 首先将cacheKey 放入advisedBeans ,并设置TRUE
			this.advisedBeans.put(cacheKey, Boolean.TRUE);
		    // 对适合的bean 创建 一个AOP 代理，详细代码下面分析
			Object proxy = createProxy(
					bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
			this.proxyTypes.put(cacheKey, proxy.getClass());
			return proxy;
		}
        // 如果上面没有找到适合的 advice,设置为 false
		this.advisedBeans.put(cacheKey, Boolean.FALSE);
		return bean;
	}

2.1.4 getAdvicesAndAdvisorsForBean

	protected Object[] getAdvicesAndAdvisorsForBean(
			Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
        //找出适合的 候选增强器
		List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
		if (advisors.isEmpty()) {
			return DO_NOT_PROXY;
		}
		return advisors.toArray();
	}

2.1.4 findEligibleAdvisors

findEligibleAdvisors 的主要逻辑就是：

  1. 找到所有实现了Advisor接口的候选增强器类
  2. 对所有的候选增强器进行遍历,选出匹配beanClass的
  3. 有一个 hook方法,用于有需要可以自定义实现, 最后进行排序,然后 输出
	protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
	   // 找出所有的实现了Advisor接口的候选增强器类
		List<Advisor> candidateAdvisors = findCandidateAdvisors();
		// 选出匹配的 增强器
		List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
		// 这个是钩子方法,用于用户自定义实现
		extendAdvisors(eligibleAdvisors);
		// 进行排序
		if (!eligibleAdvisors.isEmpty()) {
			eligibleAdvisors = sortAdvisors(eligibleAdvisors);
		}
		return eligibleAdvisors;
	}

	protected List<Advisor> findCandidateAdvisors() {
		Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
		return this.advisorRetrievalHelper.findAdvisorBeans();
	}

2.1.4 findAdvisorBeans

findAdvisorBeans 方法里面的主要逻辑就是 ：

  1. 首先判断一下缓存 cachedAdvisorBeanNames 里面是否有数据，有就直接拿来使用
  2. 如果没有，这里主要是调用DefaultListableBeanFactory#getBeanNamesForType 的方法， 根据Type 类型，找到Advisor.class 所有对应的 beanName ,并缓存到 cachedAdvisorBeanNames
  3. 根据获取到的 advisorNames ， 遍历对应的 Bean ，然后返回

下面是相关源码解析

public List<Advisor> findAdvisorBeans() {
		// 获取缓存的advisor Bean 的名称列表，如果为null, 
		String[] advisorNames = this.cachedAdvisorBeanNames;
		if (advisorNames == null) {
			/** 这里是根据type  类型获取所有Advisor 对应的所有的类的beanName， 里面其实是调用的
			DefaultListableBeanFactory#getBeanNamesForType
			**/
			advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
					this.beanFactory, Advisor.class, true, false);
			this.cachedAdvisorBeanNames = advisorNames;
		}
		if (advisorNames.length == 0) {
			return new ArrayList<>();
		}

		List<Advisor> advisors = new ArrayList<>();
		for (String name : advisorNames) {
		 // isEligibleBean()是提供的一个钩子方法，这里默认返回值都是true
			if (isEligibleBean(name)) {
				if (this.beanFactory.isCurrentlyInCreation(name)) {
					if (logger.isTraceEnabled()) {
						logger.trace("Skipping currently created advisor '" + name + "'");
					}
				}
				else {
					try {
					   // 根据beanName 获取对应的Bean,加到advisors 里面
						advisors.add(this.beanFactory.getBean(name, Advisor.class));
					}
					catch (BeanCreationException ex) {
						Throwable rootCause = ex.getMostSpecificCause();
						if (rootCause instanceof BeanCurrentlyInCreationException) {
							BeanCreationException bce = (BeanCreationException) rootCause;
							String bceBeanName = bce.getBeanName();
							if (bceBeanName != null && this.beanFactory.isCurrentlyInCreation(bceBeanName)) {
								if (logger.isTraceEnabled()) {
									logger.trace("Skipping advisor '" + name +
											"' with dependency on currently created bean: " + ex.getMessage());
								}
								// Ignore: indicates a reference back to the bean we're trying to advise.
								// We want to find advisors other than the currently created bean itself.
								continue;
							}
						}
						throw ex;
					}
				}
			}
		}
		return advisors;
	}

2.1.5 AopUtils#findAdvisorsThatCanApply

findAdvisorsThatCanApply 这里 主要逻辑为：

  1. 判断候增强器是否为空，为空直接返回

2.对候选增强器 进行遍历， 首先是处理的 引介增强器IntroductionAdvisor 的，并判断是否匹配
4. 再次遍历,先排查已经处理过的 IntroductionAdvisor 类型后 ,判断是否匹配

	public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
	    // 如果候选增强器为空，直接返回
		if (candidateAdvisors.isEmpty()) {
			return candidateAdvisors;
		}
		List<Advisor> eligibleAdvisors = new ArrayList<>();
		// 进行遍历，如果Advisor是IntroductionAdvisor 的实例，并且匹配，加到list 里面
		for (Advisor candidate : candidateAdvisors) {
		    // 首先处理 引介 增强型
			if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
				eligibleAdvisors.add(candidate);
			}
		}
		boolean hasIntroductions = !eligibleAdvisors.isEmpty();
		// 再次处理，先排查已经处理过的IntroductionAdvisor类型
		for (Advisor candidate : candidateAdvisors) {
			if (candidate instanceof IntroductionAdvisor) {
				// already processed
				continue;
			}
			if (canApply(candidate, clazz, hasIntroductions)) {
				eligibleAdvisors.add(candidate);
			}
		}
		return eligibleAdvisors;
	}

2.1.6 AbstractAutoProxyCreator#createProxy

createProxy的主要流程如下：

  1. 首先判断一下beanFactory 是否是 ConfigurableListableBeanFactory 类型， 暴露targetclass， 主要就是对BeanDefinition 增加一个属性
  2. 创建代理工厂，复制一些属性，判断是用jdk动态代理，还是 CLLIB 代理
  3. 将advice 封装成 advisors ,然后根据 上面的 具体的哪种代理，创建AopProxy ，然后 获取具体的代理对象
protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
			@Nullable Object[] specificInterceptors, TargetSource targetSource) {
        // 如果beanFactory 是 ConfigurableListableBeanFactory 类型
        // 这里暴露targetclass， 主要就是对BeanDefinition 增加一个属性
		if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
			AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
		}
        // 创建代理工厂
		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.copyFrom(this);
        /** proxyTargetClass 默认是 false, 也就是说默认是 jdk 代理
        这里判断一下，是否需要设为cglib 代理
        目标对象实现了接口 – 使用CGLIB代理机制
        目标对象没有接口(只有实现类) – 使用CGLIB代理机制
         **/
		if (!proxyFactory.isProxyTargetClass()) {
			if (shouldProxyTargetClass(beanClass, beanName)) {
				proxyFactory.setProxyTargetClass(true);
			}
			else {
				evaluateProxyInterfaces(beanClass, proxyFactory);
			}
		}
        // 这里是获取所有的advisors ,将 advice封装成 advisors
		Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
		proxyFactory.addAdvisors(advisors);
		proxyFactory.setTargetSource(targetSource);
		customizeProxyFactory(proxyFactory);
        //用来配置是否允许修改代理的配置,默认为false
		proxyFactory.setFrozen(this.freezeProxy);
		if (advisorsPreFiltered()) {
			proxyFactory.setPreFiltered(true);
		}
         /** 获取AopProxy， 这里会根据 上面的是jdk 代理还是CGLIb代理，返回对应的
         JdkDynamicAopProxy 或者 ObjenesisCglibAopProxy ,  然后再获取具体的代理对象
         **/
		return proxyFactory.getProxy(getProxyClassLoader());
	}
	
	public Object getProxy(@Nullable ClassLoader classLoader) {
		return createAopProxy().getProxy(classLoader);
	}

在这里插入图片描述

evaluateProxyInterfaces的主要逻辑如下：

  1. 获取beanclass 所有的 interface
  2. 对所有的interface 继续判断，是否是 回调接口，或者一些内部语言接口 ，并且需要 有至少一个方法
  3. 如果适合jdk 代理，那就所有的接口加入，不然就使用CGLIB代理
	protected void evaluateProxyInterfaces(Class<?> beanClass, ProxyFactory proxyFactory) {
		Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, getProxyClassLoader());
		boolean hasReasonableProxyInterface = false;
		for (Class<?> ifc : targetInterfaces) {
			if (!isConfigurationCallbackInterface(ifc) && !isInternalLanguageInterface(ifc) &&
					ifc.getMethods().length > 0) {
				hasReasonableProxyInterface = true;
				break;
			}
		}
		if (hasReasonableProxyInterface) {
			// Must allow for introductions; can't just set interfaces to the target's interfaces only.
			for (Class<?> ifc : targetInterfaces) {
			  // 添加代理接口
				proxyFactory.addInterface(ifc);
			}
		}
		else {
		   // 如果没有找到，就是用 CGLib代理
			proxyFactory.setProxyTargetClass(true);
		}
	}

三、小结

本章详细分析了InfrastructureAdvisorAutoProxyCreator 的层次结构，以及一些事务功能的初始化工作.

支付宝微信
支付宝微信
如果有帮助记得打赏哦特别需要您的打赏哦
一直打铁
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
Spring AOP源码解析一：AOP代理重要bean---AnnotationAwareAspectJAutoProxyCreator的创建
qq_35634181的博客
08-24 459
最近在学习Spring AOP，就顺便看了一下Spring AOP的源码，这里记录一下，防止七秒钟的记忆。之前写过一篇关于Spring AOP的基本使用：Spring AOP 基本概念和使用，建议大家先去观看一下，再回来阅读这篇文章。 AOP是一种思想和理念，可以使用这种思想来简化代码开发的耦合性和难度，有句话说的好，天上飞的理念，必有落地的实现，那么实现了AOP这个思想的具体实现由SpringAOP和AspectJ技术，他们都是根据AOP的思想实现的。 Sp...
（三）Spring源码分析----tx事务管理
u012417552的专栏
08-12 262
Spring事务是基于AOP代理完成的，有了前面的AOP源码分析基础，Spring事务理解起来就比较简单了，我们先看一看Spring中的注解版事务配置例子： Spring配置类：同开启AOP功能一样，事务功能也需要通过注解@EnableTransactionManagement进行开启，同时需要配置事务管理器，默认使用DataSourceTransationManager事务管理器。 @Co...
spring自动代理
baidu_36074048的博客
08-20 396
spring默认提供的几种auto-proxy：    BeanNameAutoProxyCreator   :  可以配置需要被进行auto-proxy的bean names列表，它控制的是需要代理的bean列表InfrastructureAdvisorAutoProxyCreator  DefaultAdvisorAutoProxyCreator :  将对应匹配的advisor，
SpringBoot复习（54）用于事务处理的InfrastructureAdvisorAutoProxyCreator BeanPostProcessor是在哪里被注册到容器的？
最新发布
amadeus_liu2的博客
08-18 63
从类的继承关系看InfrastructureAdvisorAutoProxyCreator是一个BeanPostProcessor.类包装成了BeanDefinition注册到了Spring容器。
Infrastructure changes in Spring 2.1-m2
BLOG域名:programb.blog.csdn.net
05-14 141
Engineering Ben Hale June 01, 2007 With the release of Spring 2.1-m2, some significant changes have been made to the infrastructure of the Spring distribution. Please see the announcement and changelog for the complete list of changes. Distribution The dis
SpringAOP自动代理创建器AnnotationAwareAspectJAutoProxyCreator
clyu的博客
03-06 531
前言 Spring 提供了自动代理机制，可以让容器自动生成代理，从而把开发人员从繁琐的配置中解脱出来 。 具体是使用 BeanPostProcessor 来实现这项功能。 这三种自动代理创建器分别为： 1、BeanNameAutoProxyCreator：基于Bean配置名规则的自动代理生成器：允许为一组特定配置名的Bean自动创建代理实例的代理创建器 2、DefaultAdvisorAutoPr...
Spring project infrastructure updates
BLOG域名:programb.blog.csdn.net
05-17 206
Engineering Chris Beams June 27, 2012 Introduction Over the last year a number of significant changes have been made to the infrastructure and processes we use to keep the Spring family of projects running smoothly. You may have seen individual announcemen
Spring源码解析
xiang_yu_pai的博客
04-10 2306
一、IOC过程 第一步：xml配置文件 第二步：使用工厂类 第三步：通过反射创建类 二、IOC接口 1.BeanFactory：IOC基本实现，Spring内部使用，不提供给开发人员使用。加载配置文件时不创建对象 2.ApplicationContext：BeanFactory的子接口，功能更强大，加载配置文件随便创建对象 三、管理Bean对象 1.DI：依赖注入，配置属性 （1）通过set方法注入（通过在xml bean标签配置property属性，也是通过set方法注入的） （2）通过构造器注入（通过在
Spring5源码13-AOP源码分析(上)
java_lujj的博客
08-30 139
Spring 借助AspectJ的切点表达式语言来定义 Spring 切面AspectJ指示器描述arg()限制连接点匹配参数为指定类型的执行方法@args()限制连接点匹配参数由指定注解标注的执行方法用于匹配是连接点的执行方法this()限制连接点匹配 AOP代理的bean引用为指定类型的类target限制连接点匹配的目标对象为指定类型的类@target()限制连接点匹配特定的执行对象，这些对象对应的类要具有指定类型的注解within()限制连接点匹配指定的类型。...
spring学习_04-事务源码解析
early_or_later的博客
06-20 112
实现： configuration设置： 关注点：和aop一样，先看一下EnableXXX注解 @EnableTransactionManagement @Import(TransactionManagementConfigurationSelector.class) 注入了这样两个bean AutoProxyRegistrar： 和aop的注册一样，注入一个bean beanName：org.springframework.aop.config.interna..
Spring5源码-事务(AutoProxyRegistrar和ProxyTransactionManagementConfiguration)
java_lujj的博客
09-15 165
方法的实现在其父类// 获取事务属性，如果// 判断声明类是否是 Object}// 尝试从缓冲中获取= null) {}else {}}else {// 没有缓存，则开始解析// 获取// 放入缓存中}else {// 获取合适的方法名称}}}}}...// 解析事务注解属性// 如果只允许解析public 方法 && 当前方法不是 publissh}
Learning Spring-Cloud – Infrastructure and Configuration
a19576的专栏
03-16 719
https://www.javacodegeeks.com/2015/06/learning-spring-cloud-infrastructure-and-configuration.html Learning Spring-Cloud – Writing a microservice : http://www.itpub.net/thread-1928298-1-1.html
【小家Spring】Spring AOP的核心类：AbstractAdvisorAutoProxy自动代理创建器深度剖析（AnnotationAwareAspectJAutoProxyCreator）
架构师：通透，才能写出好代码！
04-16 6421
前言 上篇博文：【小家Spring】面向切面编程之—Spring AOP的原理讲解以及源码分析（Cannot find current proxy: Set ‘exposeProxy’ property on ） 已经刚刚结合实例，介绍了Spring AOP的过程原理以及对源码进行了逐步分析~ 但是这中间当时事忽略了整个Spring AOP最为核心的一个类：自动代理创建器。 因此本文将以Annot...
吃透Spring源码（二十一）：事物初始化流程之注解配置方式
吃透Java
03-16 414
一，例子准备 BookDao.java public class BookDao { @Autowired JdbcTemplate jdbcTemplate; public JdbcTemplate getJdbcTemplate() { return jdbcTemplate; } public void setJdbcTemplate(JdbcTemplate jdbcTemplate) { this.jdbcTemplat
Spring源码分析笔记--事务管理
weixin_30493321的博客
12-13 107
核心类 InfrastructureAdvisorAutoProxyCreator 本质是一个后置处理器，和AOP的后置处理器类似，但比AOP的使用级别低。当开启AOP代理模式后，优先使用AOP的后置处理器。 AopConfigUtils： /** * The bean name of the internally managed auto-proxy creator. */ ...
声明式事务源码分析
qq_39794062的博客
05-28 97
声明式事务工作原理 @EnableTransactionManagement注解会给容器中导入TransactionManagementConfigurationSelector组件 @EnableTransactionManagement注解的AdviceMode默认值为Proxy TransactionManagementConfigurationSelector组件会调用selectImports()方法带导入AutoProxyRegistrar和ProxyTransactionManagement
Spring源码分析十六：事务实现② - ProxyTransactionManagementConfiguration
猫吻鱼的博客
07-12 4192
一、前言 本文是笔者阅读Spring源码的记录文章，由于本人技术水平有限，在文章中难免出现错误，如有发现，感谢各位指正。在阅读过程中也创建了一些衍生文章，衍生文章的意义是因为自己在看源码的过程中，部分知识点并不了解或者对某些知识点产生了兴趣，所以为了更好的阅读源码，所以开设了衍生篇的文章来更好的对这些知识点进行进一步的学习。 由于 事务的源码和 前篇的 Aop 源码逻辑很类似，所以本篇中某些内容不会展开去讲解，建议先阅读完 Spring源码分析十一：@AspectJ方式的AOP再来阅读本文会更好理解。 –
spring事务原理解析-01
snail-jie的博客
04-04 722
事务原理概述 注册自动创建代理类：InfrastructureAdvisorAutoProxyCreator 1.1 通过@Import导入注册类列表，关注AutoProxyRegistrar 1.2 遍历注册类，调用其registerBeanDefinitions方法 1.3 通过AutoProxyRegistrar创建自动代理类：InfrastructureAdvisorAutoProxyCreator 通过InfrastructureAdvisorAutoProxyCreator创建代理类 2.1
Spring事务学习笔记（一）
xueguchen的博客
08-31 247
1. 事务 指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。 事务由事务开始(begin transaction)和事务结束(end transaction)之间执行的全体操作组成。 特性： 原子性（atomicity）：一个事务是一个不可分割的工作单位，事务中包括的操作要么都做，要么都不做。 一致性（consistency）：事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。 隔离性（isolation）：一个事务的执行不能被其他事务干扰。即一个事务内
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一直打铁

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值