spring多线程事物解决办法

SpringBoot多线程事务管理解决方案

最新推荐文章于 2025-07-25 14:03:38 发布

原创最新推荐文章于 2025-07-25 14:03:38 发布 · 5.5k 阅读

2 ·

CC 4.0 BY-SA版权

在项目中遇到多线程环境下事务无法正常回滚的问题，即使在方法上添加了事务注解。主线程中的事务操作仍能生效。为解决此问题，可以采用SpringBoot的上下文获取方式，配置自定义事务管理器，并结合JdbcTemplate和TransactionManager来实现多线程事务控制。

1、最近做项目使用了多线，但是发现多线程事务无法起作用，就是多线程运行时每个线程的方法虽然加了事务的注解但是数据插入依旧不会回滚

2、此时主线程操作数据插入事物是起作用的。

springboot 解决办法

先获取spring的context

配置中添加事物管理器1

package luculent.fupin.tools;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class SpringUtil implements ApplicationContextAware {

    private static ApplicationContext applicationContext = null;

    @Override

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException{

        if (SpringUtil.applicationContext == null) {

            SpringUtil.applicationContext = applicationContext;

        }
    }

    // 获取applicationContext

    public static ApplicationContext getApplicationContext(){

        return applicationContext;

    }

    // 通过name获取 Bean.

    public static Object getBean(String name){

        return getApplicationContext ().getBean (name);

    }

    // 通过class获取Bean.

    public static <T> T getBean(Class<T> clazz){

        return getApplicationContext ().getBean (clazz);

    }

    // 通过name,以及Clazz返回指定的Bean

    public static <T> T getBean(String name,Class<T> clazz){

        return getApplicationContext ().getBean (name, clazz);

    }

}

import java.util.Properties;

import javax.sql.DataSource;

import org.springframework.boot.bind.RelaxedPropertyResolver;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.orm.hibernate4.HibernateTemplate;
import org.springframework.orm.hibernate4.LocalSessionFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import com.alibaba.druid.pool.DruidDataSource;

@Configuration
@EnableTransactionManagement
public class DruidDataSourceConfiguration implements EnvironmentAware {

    private RelaxedPropertyResolver propertyResolver;

    @Override
    public void setEnvironment(Environment env){
        this.propertyResolver = new RelaxedPropertyResolver (env,"spring.hibernate.");
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource druidDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource (); 
        return druidDataSource;
    }

    
    
    
    @Bean
    public LocalSessionFactoryBean sessionFactory(){
        LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean ();
        sessionFactory.setDataSource (this.druidDataSource ());
        sessionFactory.setPackagesToScan (new String[] { "luculent.fastb" });
        
        sessionFactory.setHibernateProperties (hibernateProperties ());
        return sessionFactory;
    }

    // 创建事务管理器1
    @Bean(name = "transactionManager")
    public PlatformTransactionManager txManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
    
    @Bean
    public HibernateTemplate hibernateTemplate(){
        HibernateTemplate temp = new HibernateTemplate ();
        temp.setSessionFactory (this.sessionFactory ().getObject ());
        return temp;
    }

    @Bean
    public PersistenceExceptionTranslationPostProcessor exceptionTranslation(){
        return new PersistenceExceptionTranslationPostProcessor ();
    }

    Properties hibernateProperties(){
        return new Properties () {

            /**
             * 
             */
            private static final long serialVersionUID = 1285306698726701874L;

            {  
                setProperty ("show_sql", propertyResolver.getProperty ("show_sql"));
                setProperty ("current_session_context_class", propertyResolver.getProperty ("current_session_context_class"));
            }
        };
    }
}

获取

jdbcTemplate

transactionManager

用自己写的事物替代

package luculent.fupin.runable;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Import;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import luculent.fupin.tools.SpringUtil;


@Import(value = { SpringUtil.class })
public class PlatformInitiative{
	
	private static final Logger logger = LoggerFactory.getLogger(PlatformInitiative.class);
	
	private static JdbcTemplate jdbcTemplate = (JdbcTemplate) SpringUtil.getBean ("jdbcTemplate");

	private static DataSourceTransactionManager transactionManager ;
	private static DefaultTransactionDefinition definition;
	
	static{//初始化 DefaultTransactionDefinition
		//WebApplicationContext webctx = ContextLoader.getCurrentWebApplicationContext();
		definition = new DefaultTransactionDefinition();
		definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
		definition.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
		transactionManager = (DataSourceTransactionManager) SpringUtil.getBean ("transactionManager");
	} 
   
    public static boolean insert(String[] sqls){

        if (sqls != null && sqls.length > 0) {
            for ( String sql : sqls ) {
            	return insert(sql);
            }
        }
        return false;
    }
    public static boolean insert(String sql){
   	 
		boolean saveFlag = false;
		TransactionStatus transactionStatus = (TransactionStatus) transactionManager.getTransaction(definition);
		try {
    		int rId =  jdbcTemplate.update (sql);
    		if(rId > 0){
				 saveFlag = true;
			 }
		} catch (Exception e) { 
			logger.error("platformInitiativeHessian-save: -error",e);
		}
    	if(saveFlag ){
    		transactionManager.commit(transactionStatus);
    	}else{
    		transactionManager.rollback(transactionStatus);
    	}
		return saveFlag;
	}
	 
	 
	public static boolean insertBatch(String[] sqls){
	 
		boolean saveFlag = false;
		TransactionStatus transactionStatus = (TransactionStatus) transactionManager.getTransaction(definition);
		try {
    		int[] ides = jdbcTemplate.batchUpdate (sqls);
    		if(ides != null && ides.length > 0){
				 saveFlag = true;
			 }
		} catch (Exception e) { 
			logger.error("platformInitiativeHessian-save: -error",e);
		}
    	if(saveFlag ){
    		transactionManager.commit(transactionStatus);
    	}else{
    		transactionManager.rollback(transactionStatus);
    	}
		return saveFlag;
	}
	
	public static boolean update(String upState,String state,String id){
		
		boolean saveFlag = false;
		TransactionStatus transactionStatus = (TransactionStatus) transactionManager.getTransaction(definition);
		try {
			 int rId = jdbcTemplate.update (upState, new Object[] { state, id });
			 if(rId > 0){
				 saveFlag = true;
			 }
		} catch (Exception e) { 
			logger.error("platformInitiativeHessian-save: -error",e);
		}
    	if(saveFlag ){
    		transactionManager.commit(transactionStatus);
    	}else{
    		transactionManager.rollback(transactionStatus);
    	}
		return saveFlag;
	} 
	
	public static boolean update(String sql, Object... args){
		
		boolean saveFlag = false;
		TransactionStatus transactionStatus = (TransactionStatus) transactionManager.getTransaction(definition);
		try {
			 int rId = jdbcTemplate.update (sql,args);
			 if(rId > 0){
				 saveFlag = true;
			 }
		} catch (Exception e) { 
			logger.error("platformInitiativeHessian-save: -error",e);
		}
    	if(saveFlag ){
    		transactionManager.commit(transactionStatus);
    	}else{
    		transactionManager.rollback(transactionStatus);
    	}
		return saveFlag;
	} 
}