SpringBoot事务详解（含示例代码）

在Spring Boot中，事务是用于管理数据库操作的重要机制。Spring Boot提供了多种方式来处理事务，主要包括编程式事务管理和声明式事务管理。下面是对这两种事务管理方式的分类和代码说明。

事务管理方式

编程式事务管理

 编程式事务管理是通过在代码中显式地控制事务的开始、提交和回滚来管理事务。下面是使用编程式事务管理的代码示例：

import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
import import org.springframework.transaction.support.TransactionTemplate;

@Service
public class UserService {
    private final TransactionTemplate transactionTemplate;

    public UserService(TransactionTemplate transactionTemplate) {
        this.transactionTemplate = transactionTemplate;
    }

    public void updateUser(User user) {
        transactionTemplate.execute(new TransactionCallback<Void>() {
            public Void doInTransaction(TransactionStatus status) {
                try {
                    // 更新用户信息
                    userDao.updateUser(user);
                    // 其他数据库操作
                    // ...
                    return null;
                } catch (Exception e) {
                    status.setRollbackOnly();
                    throw e;
                }
            }
        });
    }
}

在上述代码中，TransactionTemplate是Spring提供的用于编程式事务管理的模板类。通过调用execute方法，在其中执行需要进行事务管理的代码逻辑。在执行过程中，可以通过TransactionStatus对象来控制事务的提交或回滚。

声明式事务管理

 声明式事务管理是通过使用注解或XML配置来定义事务的边界和属性，由Spring框架自动管理事务的开始、提交和回滚。下面是使用注解方式的声明式事务管理的代码示例：

import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    @Transactional
    public void updateUser(User user) {
        try {
            // 更新用户信息
            userDao.updateUser(user);
            // 其他数据库操作
            // ...
        } catch (Exception e) {
            throw e;
        }
    }
}

在上述代码中，@Transactional注解被应用于updateUser方法上，表示该方法需要进行事务管理。Spring框架会根据注解的配置自动创建事务，并在方法执行结束后根据执行结果决定是提交事务还是回滚事务。

总结起来，编程式事务管理需要在代码中显式地控制事务的开始、提交和回滚，而声明式事务管理通过注解或XML配置来定义事务的边界和属性，由Spring框架自动管理事务的行为。

常用的事务注解

@Transactional：用于标识一个方法需要进行事务管理。

@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    @Transactional
    public void updateUser(User user) {
        try {
            // 更新用户信息
            userDao.updateUser(user);
            // 其他数据库操作
            // ...
        } catch (Exception e) {
            throw e;
        }
    }
}

在上述示例中，@Transactional注解被应用于updateUser方法上，表示该方法需要进行事务管理。Spring框架会根据注解的配置自动创建事务，并在方法执行结束后根据执行结果决定是提交事务还是回滚事务。

@Transactional(propagation = Propagation.REQUIRED)：指定事务的传播行为。

示例代码：

@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    @Transactional(propagation = Propagation.REQUIRED)
    public void updateUser(User user) {
        try {
            // 更新用户信息
            userDao.updateUser(user);
            // 其他数据库操作
            // ...
        } catch (Exception e) {
            throw e;
        }
    }
}

在上述示例中，@Transactional(propagation = Propagation.REQUIRED)指定了事务的传播行为为REQUIRED，表示如果当前方法已经存在一个事务，则加入该事务；如果不存在事务，则创建一个新的事务。

@Transactional(isolation = Isolation.READ_COMMITTED)：指定事务的隔离级别。

示例代码：

@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    @Transactional(isolation = Isolation.READ_COMMITTED)
    public void updateUser(User user) {
        try {
            // 更新用户信息
            userDao.updateUser(user);
            // 其他数据库操作
            // ...
        } catch (Exception e) {
            throw e;
        }
    }
}

在上述示例中，@Transactional(isolation = Isolation.READ_COMMITTED)指定了事务的隔离级别为READ_COMMITTED，表示读取已经被其他事务提交的数据，而不能读取到未提交的数据。

@Transactional(rollbackFor = Exception.class)：指定回滚条件。

示例代码：

@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    @Transactional(rollbackFor = Exception.class)
    public void updateUser(User user) {
        try {
            // 更新用户信息
            userDao.updateUser(user);
            // 其他数据库操作
            // ...
        } catch (Exception e) {
            throw e;
        }
    }
}

在上述示例中，@Transactional(rollbackFor = Exception.class)指定了回滚条件为发生任何异常时回滚事务。

这些是一些常见的Spring Boot事务注解及其使用方式。根据你的具体需求，可以选择适当的注解进行事务管理。

SpringBoot事务传播机制

REQUIRED：如果当前方法已经存在一个事务，则加入该事务；如果不存在事务，则创建一个新的事务。

@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    @Transactional(propagation = Propagation.REQUIRED)
    public void updateUser(User user) {
        try {
            // 更新用户信息
            userDao.updateUser(user);
            // 其他数据库操作
            // ...
        } catch (Exception e) {
            throw e;
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void createUser(User user) {
        try {
            // 创建用户
            userDao.createUser(user);
            // 其他数据库操作
            // ...
        } catch (Exception e) {
            throw e;
        }
    }
}

在上述代码中，updateUser和createUser方法都使用了@Transactional(propagation = Propagation.REQUIRED)注解，表示它们都需要在一个事务中运行。如果在调用updateUser或createUser方法时已经存在一个事务，则这两个方法将加入该事务。如果不存在事务，则会创建一个新的事务。

REQUIRES_NEW：无论当前是否存在事务，都创建一个新的事务。如果当前存在事务，则将该事务挂起。

@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void updateUser(User user) {
        try {
            // 更新用户信息
            userDao.updateUser(user);
            // 其他数据库操作
            // ...
        } catch (Exception e) {
            throw e;
        }
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void createUser(User user) {
        try {
            // 创建用户
            userDao.createUser(user);
            // 其他数据库操作
            // ...
        } catch (Exception e) {
            throw e;
        }
    }
}

在上述代码中，updateUser和createUser方法都使用了@Transactional(propagation = Propagation.REQUIRES_NEW)注解，表示它们都需要在一个新的事务中运行。无论当前是否存在事务，都会创建一个新的事务，并在方法执行完毕后提交或回滚该事务。

SUPPORTS：如果当前存在事务，则加入该事务；如果不存在事务，则以非事务方式执行。

@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    @Transactional(propagation = Propagation.SUPPORTS)
    public void updateUser(User user) {
        try {
            // 更新用户信息
            userDao.updateUser(user);
            // 其他数据库操作
            // ...
        } catch (Exception e) {
            throw e;
        }
    }

    @Transactional(propagation = Propagation.SUPPORTS)
    public void createUser(User user) {
        try {
            // 创建用户
            userDao.createUser(user);
            // 其他数据库操作
            // ...
        } catch (Exception e) {
            throw e;
        }
    }
}

在上述代码中，updateUser和createUser方法都使用了@Transactional(propagation = Propagation.SUPPORTS)注解，表示它们以非事务方式执行，但如果当前存在事务，则会加入该事务中进行执行。