工作笔记-Spring5的坑:Could not obtain transaction-synchronized Session for current thread

探讨了在项目中将Hibernate和Spring升级至5版本后遇到的常见问题,特别是关于如何正确获取当前事务的session,以及在不同情况下如何避免Couldnotobtaintransaction-synchronizedSessionforcurrentthread错误。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

最近项目把Hibernate和Spring升级到了5,记录出现的常见问题。

想要获取当前的事务的session,在Hibernate3通过HibernateDaoSupport的getSession()方法:

	protected final Session getSession()
		throws DataAccessResourceFailureException, IllegalStateException {

		return getSession(this.hibernateTemplate.isAllowCreate());
	}

升级到Hibernate5以后,该方法被删除,可以使用currentSession()方法代替

	protected final Session currentSession() throws DataAccessResourceFailureException {
		SessionFactory sessionFactory = getSessionFactory();
		Assert.state(sessionFactory != null, "No SessionFactory set");
		return sessionFactory.getCurrentSession();
	}

替换以后,运行程序,发现报错org.hibernate.HibernateException: Could not obtain transaction-synchronized Session for current thread,下面贴部分错误提示。

org.hibernate.HibernateException: Could not obtain transaction-synchronized Session for current thread
	at org.springframework.orm.hibernate5.SpringSessionContext.currentSession(SpringSessionContext.java:137)
	at org.hibernate.internal.SessionFactoryImpl.getCurrentSession(SessionFactoryImpl.java:699)
	at org.springframework.orm.hibernate5.support.HibernateDaoSupport.currentSession(HibernateDaoSupport.java:136)

错误提示很直白了,就是当前没有事务的session,所以报错, 将代码做以下调整,可以解决:

Session session = null;
try {
	    session = currentSession();
	} catch (HibernateException he) {
		//当前没有事务不做任何处理
	}

Spring3在没有当前事务的情况下不会报错,Spring5却出现了错误?追踪下源码,发现两者的区别。

先看Spring3的处理,从HibernateDaoSupport的getSession开始追踪,最终找到org.springframework.orm.hibernate3.SessionFactoryUtils的doGetSession方法:

private static Session doGetSession(
			SessionFactory sessionFactory, Interceptor entityInterceptor,
			SQLExceptionTranslator jdbcExceptionTranslator, boolean allowCreate)
			throws HibernateException, IllegalStateException {

		Assert.notNull(sessionFactory, "No SessionFactory specified");

		Object resource = TransactionSynchronizationManager.getResource(sessionFactory);
		if (resource instanceof Session) {
			return (Session) resource;
		}
		SessionHolder sessionHolder = (SessionHolder) resource;
		if (sessionHolder != null && !sessionHolder.isEmpty()) {
			// pre-bound Hibernate Session
			Session session = null;
			if (TransactionSynchronizationManager.isSynchronizationActive() &&
					sessionHolder.doesNotHoldNonDefaultSession()) {
				// Spring transaction management is active ->
				// register pre-bound Session with it for transactional flushing.
				session = sessionHolder.getValidatedSession();
				if (session != null && !sessionHolder.isSynchronizedWithTransaction()) {
					logger.debug("Registering Spring transaction synchronization for existing Hibernate Session");
					TransactionSynchronizationManager.registerSynchronization(
							new SpringSessionSynchronization(sessionHolder, sessionFactory, jdbcExceptionTranslator, false));
					sessionHolder.setSynchronizedWithTransaction(true);
					// Switch to FlushMode.AUTO, as we have to assume a thread-bound Session
					// with FlushMode.MANUAL, which needs to allow flushing within the transaction.
					FlushMode flushMode = session.getFlushMode();
					if (flushMode.lessThan(FlushMode.COMMIT) &&
							!TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
						session.setFlushMode(FlushMode.AUTO);
						sessionHolder.setPreviousFlushMode(flushMode);
					}
				}
			}
			else {
				// No Spring transaction management active -> try JTA transaction synchronization.
				session = getJtaSynchronizedSession(sessionHolder, sessionFactory, jdbcExceptionTranslator);
			}
			if (session != null) {
				return session;
			}
		}

		logger.debug("Opening Hibernate Session");
		Session session = (entityInterceptor != null ?
				sessionFactory.openSession(entityInterceptor) : sessionFactory.openSession());

		// Use same Session for further Hibernate actions within the transaction.
		// Thread object will get removed by synchronization at transaction completion.
		if (TransactionSynchronizationManager.isSynchronizationActive()) {
			// We're within a Spring-managed transaction, possibly from JtaTransactionManager.
			logger.debug("Registering Spring transaction synchronization for new Hibernate Session");
			SessionHolder holderToUse = sessionHolder;
			if (holderToUse == null) {
				holderToUse = new SessionHolder(session);
			}
			else {
				holderToUse.addSession(session);
			}
			if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
				session.setFlushMode(FlushMode.MANUAL);
			}
			TransactionSynchronizationManager.registerSynchronization(
					new SpringSessionSynchronization(holderToUse, sessionFactory, jdbcExceptionTranslator, true));
			holderToUse.setSynchronizedWithTransaction(true);
			if (holderToUse != sessionHolder) {
				TransactionSynchronizationManager.bindResource(sessionFactory, holderToUse);
			}
		}
		else {
			// No Spring transaction management active -> try JTA transaction synchronization.
			registerJtaSynchronization(session, sessionFactory, jdbcExceptionTranslator, sessionHolder);
		}

		// Check whether we are allowed to return the Session.
		if (!allowCreate && !isSessionTransactional(session, sessionFactory)) {
			closeSession(session);
			throw new IllegalStateException("No Hibernate Session bound to thread, " +
				"and configuration does not allow creation of non-transactional one here");
		}

		return session;
	}

提取关键代码

logger.debug("Opening Hibernate Session");
		Session session = (entityInterceptor != null ?
				sessionFactory.openSession(entityInterceptor) : sessionFactory.openSession());

在没有获取到当前事务的session时创建一个session,所以不管当前有没有做事务(注解或显示创建),getSession()都不会报错。

再看Spring5,从HibernateDaoSupport开始跟踪currentSession()的实现,如果你的SessionFactory配置的是LocalSessionFactoryBean的工厂模式的话,会在org.hibernate.internal.SessionFactoryImpl找到CurrentSession的实现

	public Session getCurrentSession() throws HibernateException {
		if ( currentSessionContext == null ) {
			throw new HibernateException( "No CurrentSessionContext configured!" );
		}
		return currentSessionContext.currentSession();
	}

进一步追踪currentSessionContext, 找到初始化方法

		currentSessionContext = buildCurrentSessionContext();

详细代码

	private CurrentSessionContext buildCurrentSessionContext() {
		String impl = properties.getProperty( Environment.CURRENT_SESSION_CONTEXT_CLASS );
		// for backward-compatibility
		if ( impl == null ) {
			if ( canAccessTransactionManager() ) {
				impl = "jta";
			}
			else {
				return null;
			}
		}

		if ( "jta".equals( impl ) ) {
//			if ( ! transactionFactory().compatibleWithJtaSynchronization() ) {
//				LOG.autoFlushWillNotWork();
//			}
			return new JTASessionContext( this );
		}
		else if ( "thread".equals( impl ) ) {
			return new ThreadLocalSessionContext( this );
		}
		else if ( "managed".equals( impl ) ) {
			return new ManagedSessionContext( this );
		}
		else {
			try {
				Class implClass = serviceRegistry.getService( ClassLoaderService.class ).classForName( impl );
				return ( CurrentSessionContext ) implClass
						.getConstructor( new Class[] { SessionFactoryImplementor.class } )
						.newInstance( this );
			}
			catch( Throwable t ) {
				LOG.unableToConstructCurrentSessionContext( impl, t );
				return null;
			}
		}
	}

第一行代码的Environment.CURRENT_SESSION_CONTEXT_CLASS我们可以在org.springframework.orm.hibernate5.LocalSessionFactoryBuilder中找到赋值,所以我们知道实际使用的是SpringSessionContext这个类。

public LocalSessionFactoryBuilder(
			@Nullable DataSource dataSource, ResourceLoader resourceLoader, MetadataSources metadataSources) {

		super(metadataSources);

		getProperties().put(AvailableSettings.CURRENT_SESSION_CONTEXT_CLASS, SpringSessionContext.class.getName());
            //后略
		}

进一步追踪,会找到currentSession()在SpringSessionContext里的实现,代码比较长,分段看。

Object value = TransactionSynchronizationManager.getResource(this.sessionFactory);
		if (value instanceof Session) {
			return (Session) value;
		}
		else if (value instanceof SessionHolder) {
			SessionHolder sessionHolder = (SessionHolder) value;
			Session session = sessionHolder.getSession();
			if (!sessionHolder.isSynchronizedWithTransaction() &&
					TransactionSynchronizationManager.isSynchronizationActive()) {
				TransactionSynchronizationManager.registerSynchronization(
						new SpringSessionSynchronization(sessionHolder, this.sessionFactory, false));
				sessionHolder.setSynchronizedWithTransaction(true);
				// Switch to FlushMode.AUTO, as we have to assume a thread-bound Session
				// with FlushMode.MANUAL, which needs to allow flushing within the transaction.
				FlushMode flushMode = SessionFactoryUtils.getFlushMode(session);
				if (flushMode.equals(FlushMode.MANUAL) &&
						!TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
					session.setFlushMode(FlushMode.AUTO);
					sessionHolder.setPreviousFlushMode(flushMode);
				}
			}
			return session;
		}

第一段:从TransactionSynchronizationManager找session。

跟进getResource方法,(TransactionSynchronizationManager)

	@Nullable
	public static Object getResource(Object key) {
		Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
		Object value = doGetResource(actualKey);
		if (value != null && logger.isTraceEnabled()) {
			logger.trace("Retrieved value [" + value + "] for key [" + actualKey + "] bound to thread [" +
					Thread.currentThread().getName() + "]");
		}
		return value;
	}

继续跟进,doGetResource方法,(TransactionSynchronizationManager)

	private static Object doGetResource(Object actualKey) {
		Map<Object, Object> map = resources.get();
		if (map == null) {
			return null;
		}
		Object value = map.get(actualKey);
		// Transparently remove ResourceHolder that was marked as void...
		if (value instanceof ResourceHolder && ((ResourceHolder) value).isVoid()) {
			map.remove(actualKey);
			// Remove entire ThreadLocal if empty...
			if (map.isEmpty()) {
				resources.remove();
			}
			value = null;
		}
		return value;
	}

resources.get()返回的一个map,回头看resource的声明

private static final ThreadLocal<Map<Object, Object>> resources =
			new NamedThreadLocal<>("Transactional resources");

resources是一个ThreadLocal线程变量,在TransactionSynchronizationManager中有对其进行添加绑定的方法:

public static void bindResource(Object key, Object value) throws IllegalStateException {
		Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
		Assert.notNull(value, "Value must not be null");
		Map<Object, Object> map = resources.get();
		// set ThreadLocal Map if none found
		if (map == null) {
			map = new HashMap<>();
			resources.set(map);
		}
		Object oldValue = map.put(actualKey, value);
		// Transparently suppress a ResourceHolder that was marked as void...
		if (oldValue instanceof ResourceHolder && ((ResourceHolder) oldValue).isVoid()) {
			oldValue = null;
		}
		if (oldValue != null) {
			throw new IllegalStateException("Already value [" + oldValue + "] for key [" +
					actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]");
		}
		if (logger.isTraceEnabled()) {
			logger.trace("Bound value [" + value + "] for key [" + actualKey + "] to thread [" +
					Thread.currentThread().getName() + "]");
		}
	}

通过实验发现,在方法有@Transational注解的情况下,getResource返回的value是一个sessionHolder,在没有注解的情况下返回的value是null。既而想到,注解的实现过程,调用了bindResource方法。

我们知道Spring注解基本都是基于AOP实现的,spring-tx是对事务支持的包,在里面找到了TransactionAspectSupport,里面有这样一个方法

@Nullable
	protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
			final InvocationCallback invocation) throws Throwable {

		// If the transaction attribute is null, the method is non-transactional.
		TransactionAttributeSource tas = getTransactionAttributeSource();
		final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
		final PlatformTransactionManager tm = determineTransactionManager(txAttr);
		final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

		if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
			// Standard transaction demarcation with getTransaction and commit/rollback calls.
			TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
			Object retVal = null;
			try {
				// This is an around advice: Invoke the next interceptor in the chain.
				// This will normally result in a target object being invoked.
				retVal = invocation.proceedWithInvocation();
			}
			catch (Throwable ex) {
				// target invocation exception
				completeTransactionAfterThrowing(txInfo, ex);
				throw ex;
			}
			finally {
				cleanupTransactionInfo(txInfo);
			}
			commitTransactionAfterReturning(txInfo);
			return retVal;
		}


//后略

在所有添加@Transaction注解的方法执行前,都会调用此方法,里面有个关键的调用createTransactionIfNecessary。跟进去

	protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
			@Nullable TransactionAttribute txAttr, final String joinpointIdentification) {

		// If no name specified, apply method identification as transaction name.
		if (txAttr != null && txAttr.getName() == null) {
			txAttr = new DelegatingTransactionAttribute(txAttr) {
				@Override
				public String getName() {
					return joinpointIdentification;
				}
			};
		}

		TransactionStatus status = null;
		if (txAttr != null) {
			if (tm != null) {
				status = tm.getTransaction(txAttr);
			}
			else {
				if (logger.isDebugEnabled()) {
					logger.debug("Skipping transactional joinpoint [" + joinpointIdentification +
							"] because no transaction manager has been configured");
				}
			}
		}
		return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
	}

tm就是我们配置的HibernateTransactionManager,这里不会是null,继续进入,找到org.springframework.transaction.support.AbstractPlatformTransactionManager的getTransaction方法

	public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
		Object transaction = doGetTransaction();

		// Cache debug flag to avoid repeated checks.
		boolean debugEnabled = logger.isDebugEnabled();

		if (definition == null) {
			// Use defaults if no transaction definition given.
			definition = new DefaultTransactionDefinition();
		}

		if (isExistingTransaction(transaction)) {
			// Existing transaction found -> check propagation behavior to find out how to behave.
			return handleExistingTransaction(definition, transaction, debugEnabled);
		}

		// Check definition settings for new transaction.
		if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
			throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());
		}

		// No existing transaction found -> check propagation behavior to find out how to proceed.
		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
			throw new IllegalTransactionStateException(
					"No existing transaction found for transaction marked with propagation 'mandatory'");
		}
		else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
				definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
				definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
			SuspendedResourcesHolder suspendedResources = suspend(null);
			if (debugEnabled) {
				logger.debug("Creating new transaction with name [" + definition.getName() + "]: " + definition);
			}
			try {
				boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
				DefaultTransactionStatus status = newTransactionStatus(
						definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
				doBegin(transaction, definition);
				prepareSynchronization(status, definition);
				return status;
			}
			catch (RuntimeException | Error ex) {
				resume(null, suspendedResources);
				throw ex;
			}
		}
		else {
			// Create "empty" transaction: no actual transaction, but potentially synchronization.
			if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
				logger.warn("Custom isolation level specified but no actual transaction initiated; " +
						"isolation level will effectively be ignored: " + definition);
			}
			boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
			return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);
		}
	}

Propagation声明为PROPAGATION_REQUIRED(默认)、PROPAGATION_REQUIRES_NEW、PROPAGATION_NESTED的事务会进入else if 分支,进入doBegin,该方法的实现在org.springframework.transaction.support.HibernateTransactionManager

	protected void doBegin(Object transaction, TransactionDefinition definition) {
		HibernateTransactionObject txObject = (HibernateTransactionObject) transaction;

		//略
		Session session = null;

		try {
			//前略

			// Bind the session holder to the thread.
			if (txObject.isNewSessionHolder()) {
				TransactionSynchronizationManager.bindResource(obtainSessionFactory(), txObject.getSessionHolder());
			}
			txObject.getSessionHolder().setSynchronizedWithTransaction(true);
		}

		catch (Throwable ex) {
			//略
		}
	}

最终进行了bindResource操作。所以回到最开始的CurrentSession()的代码。

Object value = TransactionSynchronizationManager.getResource(this.sessionFactory);这一行,将获得sessionHolder, 然后返回session。

所以在没有注解的情况下,没有bindResource操作,value的值将是null,进入到下一个判断分支:

if (this.transactionManager != null && this.jtaSessionContext != null) {
			try {
				if (this.transactionManager.getStatus() == Status.STATUS_ACTIVE) {
					Session session = this.jtaSessionContext.currentSession();
					if (TransactionSynchronizationManager.isSynchronizationActive()) {
						TransactionSynchronizationManager.registerSynchronization(
								new SpringFlushSynchronization(session));
					}
					return session;
				}
			}
			catch (SystemException ex) {
				throw new HibernateException("JTA TransactionManager found but status check failed", ex);
			}
		}

在this.transactionManager和this.jtaSessionContext都非空的情况下,进入这个分支。找到这两个成员变量的赋值代码:

	public SpringSessionContext(SessionFactoryImplementor sessionFactory) {
		this.sessionFactory = sessionFactory;
		try {
			JtaPlatform jtaPlatform = sessionFactory.getServiceRegistry().getService(JtaPlatform.class);
			this.transactionManager = jtaPlatform.retrieveTransactionManager();
			if (this.transactionManager != null) {
				this.jtaSessionContext = new SpringJtaSessionContext(sessionFactory);
			}
		}
		catch (Exception ex) {
			LogFactory.getLog(SpringSessionContext.class).warn(
					"Could not introspect Hibernate JtaPlatform for SpringJtaSessionContext", ex);
		}
	}

观察这一行JtaPlatform jtaPlatform = sessionFactory.getServiceRegistry().getService(JtaPlatform.class);

sessionFactory是我们的LocalSessionFactoryBean工厂类创建的SessionFactoryImpl,如果项目没有使用JTA的事务管理,所以这里jtaPlatform返回的是NoJtaPlatForm;retrieveTransactionManager()返回的是Null, 最终初始化以后jtaSessionContext为null。 

所以也进入不了CurrentSession()的第二个if分支。

进入下一个分支的判断:

if (TransactionSynchronizationManager.isSynchronizationActive()) {
			Session session = this.sessionFactory.openSession();
			if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
				session.setFlushMode(FlushMode.MANUAL);
			}
			SessionHolder sessionHolder = new SessionHolder(session);
			TransactionSynchronizationManager.registerSynchronization(
					new SpringSessionSynchronization(sessionHolder, this.sessionFactory, true));
			TransactionSynchronizationManager.bindResource(this.sessionFactory, sessionHolder);
			sessionHolder.setSynchronizedWithTransaction(true);
			return session;
		}

进入TransactionSynchronizationManager.isSynchronizationActive()方法

	public static boolean isSynchronizationActive() {
		return (synchronizations.get() != null);
	}

如果threadLocal变量synchronizations有内容,才会返回true。看synchronizations的定义

	private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations =
			new NamedThreadLocal<>("Transaction synchronizations");

TransactionSynchronizationManager.isSynchronizationActive()返回true说明当前已经处于事务当中,可以继续处理生成嵌套事务。

最后三个分支都没有进入的话:

		else {
			throw new HibernateException("Could not obtain transaction-synchronized Session for current thread");
		}

出现报错。

 

有错误的地方请指教,拜托了!

这个错误通常出现在使用 SpringHibernate 整合时,尤其是在涉及事务管理的情况下。具体来说,`HibernateSystemException` 包裹了底层的 `HibernateException` 异常,提示“无法获得当前线程同步的事务Session”,意味着尝试获取与当前线程绑定并且处于活动状态的 Hibernate 会话失败。 ### 可能的原因及解决办法 #### 1. 缺少 @Transactional 注解 最常见的原因是忘记在业务方法上添加适当的事务注释(如 `@Transactional`)。如果希望某个特定的操作在一个事务上下文中执行,则必须明确指出这一点。检查控制器层、服务层等地方是否遗漏了该注解。 **解决方案**: 确保相关的 service 方法上有正确的 `@Transactional` 注解: ```java @Service public class MyService { @Autowired private SomeRepository repository; @Transactional(readOnly = false) public void performAction() { // ... your code here ... } } ``` #### 2. 数据源配置不正确 另一个可能是数据源或 sessionFactory bean 的配置有问题,导致 spring 没有找到合适的 session 来进行操作。 **解决方案**: 验证应用程序上下文中的 DataSource 和 LocalSessionFactoryBean 是否已正确定义,并确保它们能够正常工作。 ```xml <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"> <!-- Data Source configuration --> </bean> <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean"> <property name="dataSource" ref="dataSource"/> <property name="packagesToScan" value="com.example.model"/> <property name="hibernateProperties"> <props> <prop key="hibernate.dialect">...</prop> <!-- Other properties --> </props> </property> </bean> ``` 对于基于 Java Config 的应用,你可以这样做: ```java @Configuration @EnableTransactionManagement @ComponentScan(basePackages={"com.example"}) public class AppConfig { @Bean(name = "dataSource") public BasicDataSource dataSource(){ final BasicDataSource basicDataSource = new BasicDataSource(); // 设置连接池属性... return basicDataSource; } @Bean public LocalSessionFactoryBean sessionFactory(@Qualifier("dataSource") DataSource ds){ final LocalSessionFactoryBean sessionFactoryBean = new LocalSessionFactoryBean(); sessionFactoryBean.setDataSource(ds); sessionFactoryBean.setPackagesToScan(new String[]{"com.example"}); Properties hibernateProperties = new Properties(); hibernateProperties.put("hibernate.dialect", "..."); sessionFactoryBean.setHibernateProperties(hibernateProperties); return sessionFactoryBean; } } ``` #### 3. TransactionManager 配置缺失或无效 Spring 使用 PlatformTransactionManager 接口来协调事务边界。如果你的应用缺少它或者它的设置不当也可能会引发这个问题。 **解决方案**: 添加并验证 `PlatformTransactionManager` Bean 是否存在且已被正确注入到其他组件中: ```xml <!-- XML-based config --> <tx:annotation-driven/> <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/> </bean> ``` 如果是采用纯Java配置的方式,请确保已经启用了 `@EnableTransactionManagement` 并声明了相应的 Manager 实现: ```java // Java-based config @Bean @Autowired public PlatformTransactionManager txManager(SessionFactory sf) { return new HibernateTransactionManager(sf); } @EnableTransactionManagement ``` 此外,在某些场景下还需要考虑是否有多个数据库资源同时参与同一个事务的问题,此时需要更复杂的分布式事务支持方案。 --- 总结而言,“Could not obtain transaction-synchronized Session” 错误通常是由于缺乏必要的事务管理机制或是其配置上的失误造成的。通过对上述各项内容逐一排查可以帮助定位和解决问题的根本原因。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值