SpringBoot----SQL数据库事务处理
一、事务有四个特性：ACID
原子性（Atomicity）：事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成，
要么完全不起作用。
一致性（Consistency）：一旦事务完成（不管成功还是失败），系统必须确保它所建模的业务处于一致的状
态，而不会是部分完成部分失败。在现实中的数据不应该被破坏。
隔离性（Isolation）：可能有许多事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，
防止数据损坏。
持久性（Durability）：一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响，这样就能从
任何系统崩溃中恢复过来。通常情况下，事务的结果被写到持久化存储器中。
二、传播行为
当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运
行，也可能开启一个新事务，并在自己的事务中运行。
Spring 定义了七种传播行为：
PROPAGATION_REQUIRED 表示当前方法必须运行在事务中。如果当前事务存在，方法将会在该事务中运
行。否则，会启动一个新的事务，Spring 默认使用
PROPAGATION_SUPPORTS 表示当前方法不需要事务上下文，但是如果存在当前事务的话，那么该方法会
在这个事务中运行
PROPAGATION_MANDATORY 表示该方法必须在事务中运行，如果当前事务不存在，则会抛出一个异常
PROPAGATION_REQUIRED_NEW 表示当前方法必须运行在它自己的事务中。一个新的事务将被启动。如果
存在当前事务，在该方法执行期间，当前事务会被挂起。如果使用 JTATransactionManager 的话，则需要
访问 TransactionManager
PROPAGATION_NOT_SUPPORTED 表示该方法不应该运行在事务中。如果存在当前事务，在该方法运行期
间，当前事务将被挂起。如果使用 JTATransactionManager 的话，则需要访问 TransactionManager
PROPAGATION_NEVER 表示当前方法不应该运行在事务上下文中。如果当前正有一个事务在运行，则会抛
出异常
PROPAGATION_NESTED 表示如果当前已经存在一个事务，那么该方法将会在嵌套事务中运行。嵌套的事务
可以独立于当前事务进行单独地提交或回滚。如果当前事务不存在，那么其行为与
PROPAGATION_REQUIRED 一样。注意各厂商对这种传播行为的支持是有所差异的。可以参考资源管理器的
文档来确认它们是否支持嵌套事务
三、隔离级别
隔离级别定义了一个事务可能受其他并发事务影响的程度。
ISOLATION_DEFAULT 使用后端数据库默认的隔离级别，Spring 默认使用，mysql 默认的隔离级别为：
Repeatable Read(可重复读)
ISOLATION_READ_UNCOMMITTED 读未提交，最低的隔离级别，允许读取尚未提交的数据变更，可能会导致
脏读、幻读或不可重复读
ISOLATION_READ_COMMITTED 读已提交，允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读
或不可重复读仍有可能发生
ISOLATION_REPEATABLE_READ 可重复读，对同一字段的多次读取结果都是一致的，除非数据是被本身事
务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生
ISOLATION_SERIALIZABLE 可串行化，最高的隔离级别，完全服从 ACID 的隔离级别，确保阻止脏读、不可
重复读以及幻读，也是最慢的事务隔离级别，因为它通常是通过完全锁定事务相关的数据库表来实现的
脏读（Dirty reads）——脏读发生在一个事务读取了另一个事务改写但尚未提交的数据时。如果改写再
稍后被回滚了，那么第一个事务获取的数据就是无效的。
不可重复读（Nonrepeatable read）——不可重复读发生在一个事务执行相同的查询两次或两次以上，但
是每次都得到不同的数据时。这通常是因为另一个并发事务在两次查询期间进行了更新。
幻读（Phantom read）——幻读与不可重复读类似。它发生在一个事务（T1）读取了几行数据，接着另一
个并发事务（T2）插入了一些数据时。在随后的查询中，第一个事务（T1）就会发现多了一些原本不存在
的记录。
四、属性说明 @Transactional
a、isolation：用于指定事务的隔离级别。默认为底层事务的隔离级别。
b、noRollbackFor：指定遇到指定异常时强制不回滚事务。
c、noRollbackForClassName：指定遇到指定多个异常时强制不回滚事务。该属性可以指定多个异常类
名。
d、propagation:指定事务的传播属性。
e、readOnly：指定事务是否只读。表示这个事务只读取数据但不更新数据，这样可以帮助数据库引擎优
化事务。若真的是一个只读取的数据库应设置 readOnly=true
f、rollbackFor：指定遇到指定异常时强制回滚事务。
g、rollbackForClassName：指定遇到指定多个异常时强制回滚事务。该属性可以指定多个异常类名。
h、timeout：指定事务的超时时长。
注意：
1.mysql 为例，存储引擎不能使用 MyISAM，应该使用 InnoDB
dao接口层：
package com.nyist.transation.dao; import com.nyist.transation.model.RoncooUser; public interface RoncooUserDao { int insert(RoncooUser roncooUser); int deleteById(int id); int updateById(RoncooUser roncooUser); RoncooUser selectById(int id); }package com.nyist.transation.dao; import com.nyist.transation.model.RoncooUserLog; import org.springframework.data.domain.Page; import org.springframework.data.domain.Pageable; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.Query; import java.util.List; public interface RoncooUserLogDao extends JpaRepository<RoncooUserLog, Integer> { /** * @param string * @return */ @Query(value = "select u from RoncooUserLog u where u.userName=?1") List<RoncooUserLog> findByUserName(String userName); /** * @param string * @param string2 * @return */ List<RoncooUserLog> findByUserNameAndUserIp(String string, String string2); /** * @param exampl * @param pageable * @return */ Page<RoncooUserLog> findByUserName(String userName, Pageable pageable); }daoImpl 实现类：
package com.nyist.transation.dao.Impl; import com.nyist.transation.dao.RoncooUserDao; import com.nyist.transation.model.RoncooUser; import com.nyist.transation.util.base.JdbcDaoImpl; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.stereotype.Repository; @Repository public class RoncooUserDaoImpl extends JdbcDaoImpl implements RoncooUserDao { //JdbcTemplate 是 SpringBoot 特有的一个包 支持对数据库的原生开发 @Autowired private JdbcTemplate jdbcTemplate; @Override public int insert(RoncooUser roncooUser) { String sql = "insert into roncoo_user(name, create_time) values (?, ?)"; return jdbcTemplate.update(sql, roncooUser.getName(),roncooUser.getCreateTime()); } @Override public int deleteById(int id) { String sql = "delete from roncoo_user where id=?"; return jdbcTemplate.update(sql, id); } @Override public int updateById(RoncooUser roncooUser) { String sql = "update roncoo_user set name=?, create_time=? where id=?"; return jdbcTemplate.update(sql, roncooUser.getName(), roncooUser.getCreateTime(), roncooUser.getId()); } @Override public RoncooUser selectById(int id) { String sql = "select * from roncoo_user where id=?"; /*RoncooUser roncooUser = jdbcTemplate.queryForObject(sql, new RowMapper<RoncooUser>() { @Override public RoncooUser mapRow(ResultSet rs, int rowNum) throws SQLException { RoncooUser roncooUser = new RoncooUser(); roncooUser.setId(rs.getInt("id")); roncooUser.setName(rs.getString("name")); roncooUser.setCreateTime(rs.getDate("create_time")); return roncooUser; } }, id);*/ return queryForObject(sql,RoncooUser.class,id); } }测试类：
package com.nyist.transation; import com.nyist.transation.service.UserService; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.context.junit4.SpringRunner; @RunWith(SpringRunner.class) @SpringBootTest public class TransationApplicationTests { @Autowired private UserService userService; @Test public void register() { String result = userService.register("无境", "192.168.1.1"); System.out.println(result); } }Service 业务层：
package com.nyist.transation.service; import com.nyist.transation.dao.RoncooUserDao; import com.nyist.transation.dao.RoncooUserLogDao; import com.nyist.transation.model.RoncooUser; import com.nyist.transation.model.RoncooUserLog; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import java.util.Date; @Service public class UserService { @Autowired private RoncooUserDao roncooUserDao; @Autowired private RoncooUserLogDao roncooUserLogDao; /** * 用户注册 * * @return*/ /** * * Transactional 开始事务的注解 */ @Transactional public String register(String name, String ip) { // 1.添加用户 RoncooUser roncooUser = new RoncooUser(); roncooUser.setName(name); roncooUser.setCreateTime(new Date()); roncooUserDao.insert(roncooUser); // 测试使用 boolean flag = true; if (flag) { throw new RuntimeException(); } // 2.添加注册日志 RoncooUserLog roncooUserLog = new RoncooUserLog(); roncooUserLog.setUserName(name); roncooUserLog.setUserIp(ip); roncooUserLog.setCreateTime(new Date()); roncooUserLogDao.save(roncooUserLog); return "success"; } }
主体架构图：
在运行之前我们先看一下数据库中表的数据：
测试类测的数据程序程序，运行结果如下：
之所以保存是应为我们在Service 业务层派出了一个new RuntimeException()异常，我们看一下数据库中的数据是否有变动，结果如下：
数据没有变化，说明我们使用@Transactional 事务注解起作用了，保准了数据的原子性。
我们将自己抛异常的地方注释掉,然后再次运行查看数据库中表的结果，如下：
可以看到数据已经插入到表中去了。
我们将@TranTransaction 注解注释掉，主动抛一个new RuntimeException()异常，查看结果如下：
2018-11-05 20:34:32.994 |-DEBUG [main] org.springframework.jdbc.core.JdbcTemplate [860] -| Executing prepared SQL update 2018-11-05 20:34:32.995 DEBUG 40924 --- [ main] o.s.jdbc.core.JdbcTemplate : Executing prepared SQL statement [insert into roncoo_user(name, create_time) values (?, ?)] 2018-11-05 20:34:32.995 |-DEBUG [main] org.springframework.jdbc.core.JdbcTemplate [609] -| Executing prepared SQL statement [insert into roncoo_user(name, create_time) values (?, ?)] java.lang.RuntimeException at com.nyist.transation.service.UserService.register(UserService.java:36) at com.nyist.transation.TransationApplicationTests.register(TransationApplicationTests.java:19) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:498) at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50) at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12) at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47) at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17) at org.springframework.test.context.junit4.statements.RunBeforeTestExecutionCallbacks.evaluate(RunBeforeTestExecutionCallbacks.java:74) at org.springframework.test.context.junit4.statements.RunAfterTestExecutionCallbacks.evaluate(RunAfterTestExecutionCallbacks.java:84) at org.springframework.test.context.junit4.statements.RunBeforeTestMethodCallbacks.evaluate(RunBeforeTestMethodCallbacks.java:75) at org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.java:86) at org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.java:84) at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:251) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:97) at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290) at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71) at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288) at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58) at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268) at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61) at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:70) at org.junit.runners.ParentRunner.run(ParentRunner.java:363) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:190)查看数据表中的结果：
可以看出第一个表RoncooUser表中插入了一条数据，而RoncooUserLog表中没有插入新得数据，这足够说明@Transaction 可以添加事务 保证事务的ACID属性