Spring学习(二十五)-Spring事务源码分析

绝地灬酷狼 2024-02-19 16:10 79阅读 0赞

Spring事务源码分析：

@EnableTransactionManagement 开启基于注解的事务管理功能；

给方法上标注 @Transactional 表示当前方法是一个事务方法；

@EnableTransactionManagement：

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Import(TransactionManagementConfigurationSelector.class)
    public @interface EnableTransactionManagement {
    
    	
    	boolean proxyTargetClass() default false;
    
    	
    	AdviceMode mode() default AdviceMode.PROXY;
    
    	
    	int order() default Ordered.LOWEST_PRECEDENCE;
    
    }

TransactionManagementConfigurationSelector：

public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {
    
    	@Override
    	protected String[] selectImports(AdviceMode adviceMode) {
    		switch (adviceMode) {
    		    //代理 给容器中AutoProxyRegistrar和ProxyTransactionManagementConfiguration组件
    			case PROXY:
    				return new String[] {AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName()};
    			//切面
    			case ASPECTJ:
    				return new String[] {TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME};
    			default:
    				return null;
    		}
    	}
    
    }

AutoProxyRegistrar：

public class AutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
    
    	private final Log logger = LogFactory.getLog(getClass());
    
    	@Override
    	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    		boolean candidateFound = false;
    		Set<String> annoTypes = importingClassMetadata.getAnnotationTypes();
    		for (String annoType : annoTypes) {
    			AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annoType);
    			if (candidate == null) {
    				continue;
    			}
    			Object mode = candidate.get("mode");
    			Object proxyTargetClass = candidate.get("proxyTargetClass");
    			if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() &&
    					Boolean.class == proxyTargetClass.getClass()) {
    				candidateFound = true;
    				//如果是AdviceMode.PROXY
    				if (mode == AdviceMode.PROXY) {
    				    //当需要的时候注册自动代理创建器
    					AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
    					if ((Boolean) proxyTargetClass) {
    						AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
    						return;
    					}
    				}
    			}
    		}
    		if (!candidateFound) {
    			String name = getClass().getSimpleName();
    			logger.warn(String.format("%s was imported but no annotations were found " +
    					"having both 'mode' and 'proxyTargetClass' attributes of type " +
    					"AdviceMode and boolean respectively. This means that auto proxy " +
    					"creator registration and configuration may not have occurred as " +
    					"intended, and components may not be proxied as expected. Check to " +
    					"ensure that %s has been @Import'ed on the same class where these " +
    					"annotations are declared; otherwise remove the import of %s " +
    					"altogether.", name, name, name));
    		}
    	}
    
    }
    //注册自动代理创建器
    public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
    		return registerAutoProxyCreatorIfNecessary(registry, null);
    	}
    //给容器中注册一个 InfrastructureAdvisorAutoProxyCreator 组件
    public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
    		return registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source);
    }
    //InfrastructureAdvisorAutoProxyCreator 组件 它也是一个后置处理器
    public class InfrastructureAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCreator {
    
    	private ConfigurableListableBeanFactory beanFactory;
    
         //初始化工厂
    	@Override
    	protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    		super.initBeanFactory(beanFactory);
    		this.beanFactory = beanFactory;
    	}
    
    	@Override
    	protected boolean isEligibleAdvisorBean(String beanName) {
    		return (this.beanFactory.containsBeanDefinition(beanName) &&
    				this.beanFactory.getBeanDefinition(beanName).getRole() == BeanDefinition.ROLE_INFRASTRUCTURE);
    	}
    
    }
    InfrastructureAdvisorAutoProxyCreator作用：关系图
    
    作用：利用后置处理器机制在对象创建以后，包装对象，返回一个代理对象（增强器），代理对象执行方法利用拦截器链进行调用
    
    
    //注册自动代理创建器定义信息
    private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {
    		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    		//public static final String AUTO_PROXY_CREATOR_BEAN_NAME ="org.springframework.aop.config.internalAutoProxyCreator";
    		if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
    			BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
    			if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
    				int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
    				int requiredPriority = findPriorityForClass(cls);
    				if (currentPriority < requiredPriority) {
    					apcDefinition.setBeanClassName(cls.getName());
    				}
    			}
    			return null;
    		}
    		//构建RootBeanDefinition 对象
    		RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
    		beanDefinition.setSource(source);
    		beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
    		beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    		//往容器中注册该bean的定义信息
    		registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
    		return beanDefinition;
    }
    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
    			throws BeanDefinitionStoreException {
    
     。。。。。。。。。。。。。。。。。。。
     BeanDefinition oldBeanDefinition;
    
     oldBeanDefinition = this.beanDefinitionMap.get(beanName);
     if (oldBeanDefinition != null) {
    	 。。。。。。。。。。。。。。。。。。。
    	 //使用map保存到容器中
    	 this.beanDefinitionMap.put(beanName, beanDefinition);
     }
    	 。。。。。。。。。。。。。。。。。。。。。
     if (oldBeanDefinition != null || containsSingleton(beanName)) {
    	 resetBeanDefinition(beanName);
    	}
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70][]

ProxyTransactionManagementConfiguration：

//配置类 
    @Configuration
    public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {
       
       //注册事务增强器
    	@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
    	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    	public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
    		BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
    		//注册事务属性解析器
    		advisor.setTransactionAttributeSource(transactionAttributeSource());
    		//事务拦截器
    		advisor.setAdvice(transactionInterceptor());
    		advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
    		return advisor;
    	}
    
    	//注册事务属性解析器
    	@Bean
    	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    	public TransactionAttributeSource transactionAttributeSource() {
    		return new AnnotationTransactionAttributeSource();
    	}
        //事务拦截器
    	@Bean
    	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    	public TransactionInterceptor transactionInterceptor() {
    		TransactionInterceptor interceptor = new TransactionInterceptor();
    		//保存事务的属性信息
    		interceptor.setTransactionAttributeSource(transactionAttributeSource());
    		// this.txManager PlatformTransactionManager 事务管理者
    		if (this.txManager != null) {
    		    //设置了事务管理信息
    			interceptor.setTransactionManager(this.txManager);
    		}
    		return interceptor;
    	}
    
    }
    //注册各种事务解析器，解析器解析各种标签如new SpringTransactionAnnotationParser()
    public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) {
    	this.publicMethodsOnly = publicMethodsOnly;
    	this.annotationParsers = new LinkedHashSet<TransactionAnnotationParser>(2);
    	this.annotationParsers.add(new SpringTransactionAnnotationParser());
    	。。。。。。。。。。。。。。。。。。。。
    }
    	
    //SpringTransactionAnnotationParser
    @Override
    public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {
    	AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(ae, Transactional.class);
    	if (attributes != null) {
    		return parseTransactionAnnotation(attributes);
    	}
    	else {
    		return null;
    	}
    }
    
    public TransactionAttribute parseTransactionAnnotation(Transactional ann) {
    	return parseTransactionAnnotation(AnnotationUtils.getAnnotationAttributes(ann, false, false));
    }
    //@Transactional内各种属性信息
    protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
    	RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
    	Propagation propagation = attributes.getEnum("propagation");
    	rbta.setPropagationBehavior(propagation.value());
    	Isolation isolation = attributes.getEnum("isolation");//隔离
    	rbta.setIsolationLevel(isolation.value());//隔离数值
    	rbta.setTimeout(attributes.getNumber("timeout").intValue());//超时
    	rbta.setReadOnly(attributes.getBoolean("readOnly"));//只。。。
    	rbta.setQualifier(attributes.getString("value"));//属性值
    	。。。。。。。。。。。。。。。。。。。。。
    	。。。。。。。。。。。。。。。。。。。
    	rbta.getRollbackRules().addAll(rollBackRules);
    	return rbta;
    }	
    
    TransactionInterceptor：关系图
    作用：1.先获取事务相关的属性2.再获取PlatformTransactionManager，如果事先没有添加指定任何transactionmanger最终会从容器中按照类型获取一个PlatformTransactionManager；
    3.执行目标方法如果异常，获取到事务管理器，利用事务管理回滚操作；如果正常，利用事务管理器，提交事务
    
    public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable {
         。。。。。
    	@Override
    	public Object invoke(final MethodInvocation invocation) throws Throwable {
    	
    		Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
    
    		// 在目标方法执行的时候；执行拦截器链；
    		//TransactionInterceptor：事务拦截器：
    		return invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback() {
    			@Override
    			public Object proceedWithInvocation() throws Throwable {
    				return invocation.proceed();
    			}
    		});
    	}
          。。。。。
    
    	//---------------------------------------------------------------------
    	// 支持序列化
    	//---------------------------------------------------------------------
        。。。。。。。。。
    }
    
    protected Object invokeWithinTransaction(Method method, Class<?> targetClass, final InvocationCallback invocation)
    			throws Throwable {
    
    		//先获取事务相关的属性
    		final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
    		final PlatformTransactionManager tm = determineTransactionManager(txAttr);
    		final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
    		//如果是一个事务
    		if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
    			//如果事先没有添加指定任何transactionmanger最终会从容器中按照类型获取一个PlatformTransactionManager
    			TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
    			Object retVal = null;
    			try {
    				//执行目标方法 如果正常，
    				retVal = invocation.proceedWithInvocation();
    			}
    			catch (Throwable ex) {
    				//如果异常，获取到事务管理器，利用事务管理回滚操作；
    				completeTransactionAfterThrowing(txInfo, ex);
    				throw ex;
    			}
    			finally {
    				cleanupTransactionInfo(txInfo);
    			}
    			//利用事务管理器，提交事务
    			commitTransactionAfterReturning(txInfo);
    			return retVal;
    		}
    		。。。。。。。。。。。。。
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 1][]

具体流程可以在项目中根据上面注册的两个组件点击debug查看，这里详述太麻烦，我比较懒。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/d2b3be6bfb884d92b85305afd5305064.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/caa98d0d617949bdbd3b741295bcc128.png