SpringBoot----SQL数据库事务处理

朴灿烈づ我的快乐病毒、 2022-04-18 00:06 233阅读 0赞

> **一、事务有四个特性：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";
>           }
>      
>     }
> 
>  
> 
> 主体架构图：
> 
> ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x2aGFvZ3Vhbmcw_size_16_color_FFFFFF_t_70][]
> 
> 在运行之前我们先看一下数据库中表的数据：
> 
> ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x2aGFvZ3Vhbmcw_size_16_color_FFFFFF_t_70 1][]
> 
> ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x2aGFvZ3Vhbmcw_size_16_color_FFFFFF_t_70 2][]
> 
> **测试类测的数据程序程序，运行结果如下**：
> 
> ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x2aGFvZ3Vhbmcw_size_16_color_FFFFFF_t_70 3][] 
> 
> **之所以保存是应为我们在Service 业务层派出了一个new RuntimeException()异常，我们看一下数据库中的数据是否有变动，结果如下：**
> 
>                 ![20181105202720822.png][]
> 
>                                  ![20181105202731801.png][]
> 
> **数据没有变化，说明我们使用@Transactional 事务注解起作用了，保准了数据的原子性。**
> 
>  
> 
> **我们将自己抛异常的地方注释掉,然后再次运行查看数据库中表的结果，如下：**
> 
>                               ![20181105203140699.png][]
> 
>                 ![20181105203156389.png][]
> 
> **可以看到数据已经插入到表中去了。**
> 
> **我们将@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)
> 
> 查看数据表中的结果：
> 
>                  ![20181105203655628.png][]
> 
>                                    ![20181105203715741.png][]
> 
> **可以看出第一个表RoncooUser表中插入了一条数据，而RoncooUserLog表中没有插入新得数据，这足够说明@Transaction 可以添加事务 保证事务的ACID属性**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x2aGFvZ3Vhbmcw_size_16_color_FFFFFF_t_70]: /images/20220418/2b2e5fda2e224198b556c29f8ab8a88a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x2aGFvZ3Vhbmcw_size_16_color_FFFFFF_t_70 1]: /images/20220418/cd8ede197483492b8d8f1732a822b55e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x2aGFvZ3Vhbmcw_size_16_color_FFFFFF_t_70 2]: /images/20220418/23e5dfa2da884476b504fd269ed41a80.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x2aGFvZ3Vhbmcw_size_16_color_FFFFFF_t_70 3]: /images/20220418/6989506e6020468896b9266b20577471.png
[20181105202720822.png]: /images/20220418/ce52e4e2524d43c8a20b80e2a3ed29e4.png
[20181105202731801.png]: /images/20220418/c99e80a60ad94f1c8ab4009c046442ab.png
[20181105203140699.png]: /images/20220418/0d9c5de11ab244f889db199ebfa6b63f.png
[20181105203156389.png]: /images/20220418/7bbe2e0a8d7d4fad9820343242bac781.png
[20181105203655628.png]: /images/20220418/56f6b4a01d784aea8b07706f32c8eb53.png
[20181105203715741.png]: /images/20220418/929c5748f796482ba59531bc4a160899.png