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属性