转载

一文搞懂 Spring 数据库事务操作！

作者 | 阿文，责编 | 郭芮

头图 | CSDN 下载自东方IC

出品 | CSDN（ID：CSDNnews）

今天我们一起了解下Spring的数据库事务操作。在操作数据库时，我们经常会使用到事务，为此Spring 提供了专门的用于处理事务的API方便开发者调用，那么本文就着重来讲解下Spring 对于事务的相关功能。

一文搞懂 Spring 数据库事务操作！

Spring 事务的核心接口

Spring 通过一个名为spring-tx-4.3.6-RELEASE 的JAR包来管理事务，在这个JAR包中的org.Springframework.transaction 包中包含了三个接口文件：

PlatformTramsactionManager 主要用于管理事务，包括获取事务的状态、提交事务和回滚事务；
TramsactionDefinition 该接口是事务定义的对象，包括了获取事务的名称、隔离级别、事务的传播行为、超时时间、事务是否只读等；
TramsactionStatus 该接口是事务的状态，描述了某一个时间点事务状态信息，包括刷新事务、获取是否存在保存点、是否是新事务、是否回滚、设置事务回滚。

一文搞懂 Spring 数据库事务操作！

实例讲解

接下来我们将通过实例的方式来讲解如何使用注解的方式来通过Spring 进行事务的处理，手续我们在maven的pom.xml 中增加事务的JAR包：

< dependency >

< groupId > org.springframework </ groupId >

< artifactId > spring-tx </ artifactId >

< version > 4.3.6.RELEASE </ version >

</ dependency >

我们首先准备一个数据库：

CREATE TABLE IF NOT EXISTS `user` (

`id` INT UNSIGNED AUTO_INCREMENT,

`username` VARCHAR ( 100 ) NOT NULL ,

`password` VARCHAR ( 40 ) NOT NULL ,

`jifen` int ( 10 ) NOT NULL ,

PRIMARY KEY ( `id` )) ENGINE = InnoDB DEFAULT CHARSET =utf8;

然后向数据库中写入一些数据，包括了用户名、密码和积分，如下所示：

MariaDB [spring_db]> select * from user;

+----+----------+----------+-------+

| id | username | password | jifen

+----+----------+----------+-------+

1 | zhangsan | 123 | 1000 |

| 2 | lisi | 1234 | 1000

3 | wangwu | 1234 | 1000 |

+----+----------+----------+-------+

3 rows in set ( 0 . 000 sec)

我们要做的事情就是把张三的积分转给李四。

我们需要创建一个 User 类，如下：

package com.SpringDemo;

public class User {

private Integer id;

private String username;

private String password;

private Integer jifen;

public Integer getId () {

return id;

}

public void setId (Integer id) {

this .id = id;

}

public String getUsername () {

return username;

}

public void setJifen (Integer jifen) {

this .jifen = jifen;

}

public Integer getjifen () {

return jifen;

}

public void setUsername (String username) {

this .username = username;

}

public String getPassword () {

return password;

}

public void setPassword (String password) {

this .password = password;

}

public String toString () {

return "User [id=" + id + ", username=" + username + ", password=" + password + "]" ;

}

然后创建一个接口 UserDao：

package com.SpringDemo;

import java.util.List;

public interface UserDao {

public int addUser (User user) ;

public int updateUser (User user) ;

public int deleteUser ( int id) ;

//通过id查询用户

public User findUserById ( int id) ;

//查询所有用户

public List<User> findAllUser () ;

public void transfer (String outUser,String inUser,Integer jifen) ;

}

在UserDao 接口中我们定义了一个transfer 的方法，它包含了三个参数分别是outUser、inUser、jifen。

接来下我们定义实现类 UserDAOImpl：

package com.SpringDemo;

import org.springframework.jdbc.core.BeanPropertyRowMapper;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.jdbc.core.RowMapper;

import org.springframework.transaction.annotation.Isolation;

import org.springframework.transaction.annotation.Propagation;

import org.springframework.transaction.annotation.Transactional;

import java.util. List ;

public class UserDaoImpl implements UserDao {

private JdbcTemplate jdbcTemplate;

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {

this .jdbcTemplate = jdbcTemplate;

}

@Override

public int addUser(User user) {

String sql= "insert into user(username,password) value(?,?)" ;

Object [] obj= new Object []{

user.getUsername(),

user.getPassword()

};

int num = this .jdbcTemplate.update(sql,obj);

return num ;

}

@Override

public int updateUser(User user) {

String sql= "update user set username=?,password=? where id=?" ;

Object [] params= new Object []{

user.getUsername(),

user.getPassword(),

user.getId()

};

int num = this .jdbcTemplate.update(sql,params);

return num ;

}

@Override

public int deleteUser( int id) {

String sql= "delete from user where id=?" ;

int num = this .jdbcTemplate.update(sql,id);

return num ;

}

@Override

public User findUserById( int id) {

String sql= "select * from user where id=?" ;

RowMapper<User> rowMapper= new BeanPropertyRowMapper<User>(User. class );

return this .jdbcTemplate.queryForObject(sql,rowMapper,id);

}

@Override

public List <User> findAllUser() {

String sql= "select * from user" ;

RowMapper<User> rowMapper= new BeanPropertyRowMapper<User>(User. class );

return this .jdbcTemplate.query(sql,rowMapper);

}

@Override

public void transfer( String outUser, String inUser, Integer jifen) {

// 赠送积分

this .jdbcTemplate.update( "update user set jifen=jifen+? where username=?" ,jifen,inUser);

// 模拟系统运行时的突发性问题

int i = 1 / 0 ;

//赠送出积分

this .jdbcTemplate.update( "update user set jifen=jifen-? where username=?" ,jifen,outUser);

}

接下来我们定义一个applicationContext.xml：

<?xml version="1.0" encoding="UTF-8"?>

< beans xmlns = "http://www.springframework.org/schema/beans"

xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop = "http://www.springframework.org/schema/aop"

xmlns:tx = "http://www.springframework.org/schema/tx"

xmlns:context = "http://www.springframework.org/schema/context"

xsi:schemaLocation

"http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-4.3.xsd

http://www.springframework.org/schema/tx

http://www.springframework.org/schema/tx/spring-tx-4.3.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-4.3.xsd

http://www.springframework.org/schema/aop

< bean id = "dataSource"

class

"org.springframework.jdbc.datasource.DriverManagerDataSource"

< property name = "driverClassName" value = "com.mysql.jdbc.Driver" />

< property name = "url" value = "jdbc:mysql://192.168.10.128:3306/spring_db" />

< property name = "username" value = "root" />

< property name = "password" value = "123456" />

</ bean >

< bean id = "jdbcTemplate" class = "org.springframework.jdbc.core.JdbcTemplate" >

< property name = "dataSource" ref = "dataSource" />

</ bean >

< bean id = "userDao" class = "com.SpringDemo.UserDaoImpl" >

< property name = "jdbcTemplate" ref = "jdbcTemplate" />

</ bean >

< bean id = "transactionManager" class = "org.springframework.jdbc.datasource.DataSourceTransactionManager" >

< property name = "dataSource" ref = "dataSource" />

</ bean >

< tx:annotation-driven transaction-manager = "transactionManager" ></ tx:annotation-driven >

</ beans >

Spring 的事务管理方式有2种，一种是传统的编程序事务管理，即通过代码来管理事务的开始、执行和异常以及回滚，一种是声明式管理，即通过配置文件的方式，原理是通过AOP技术实现，我们在实际开发过程中推荐使用声明式事务管理，效率会大大提升，因为只需要通过配置即可。

在该接口中我们我们重写transfer的方法，更新数据库将inUser 的积分进行增加，而对应的outUser 积分要进行减少，但是在这里我们要模拟系统运行的一些突然性问题。之后我们加了一个@Transactionl 注解，并设置了propagation、Isolation、readOnly 三个参数。

@Override

@Transactional (propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT,

readOnly = false )

public void transfer (String outUser, String inUser, Integer jifen) {

// 赠送积分

this .jdbcTemplate.update( "update user set jifen=jifen+? where username=?" ,jifen,inUser);

// 模拟系统运行时的突发性问题

int i = 1 / 0 ;

//赠送出积分

this .jdbcTemplate.update( "update user set jifen=jifen-? where username=?" ,jifen,outUser);

}

注解 @Transactional 的参数含义如下：

一文搞懂 Spring 数据库事务操作！

@Transactional 除了 DEFAULT，还有其他属性，我们可以在Isolation 这个类中看到相对于的定位 @Transactional 注解也可以添加到类级别上。当把@Transactional 注解放在类级别时，表示所有该类的公共方法都配置相同的事务属性信息。

public enum Isolation {

DEFAULT( -1 ),

READ_UNCOMMITTED( 1 ),

READ_COMMITTED( 2 ),

REPEATABLE_READ( 4 ),

SERIALIZABLE( 8 );

private final int value ;

private Isolation ( int value ) {

this . value = value ;

}

public int value () {

return this . value ;

}

Propagation 的属性如下：

public enum Propagation {

REQUIRED( 0 ), //表示当前方法必须运行在一个事务环境中，如果存在就直接使用，否则开启一个新的事务执行该方法

SUPPORTS( 1 ), //如果当前方法处于事务环境中则使用，否则不使用事务

MANDATORY( 2 ), //表示该方法的线程必须在事务中否则抛出异常

REQUIRES_NEW( 3 ), //要求在新事务中执行，如果已经在事务中了则先暂停然后启动新事务执行，如果不在则启动一个新事务后执行

NOT_SUPPORTED( 4 ), //不支持当前事务，总是以非事务状态执行，如果调用该方法的线程处于事务中泽先暂停然后执行

NEVER( 5 ), //不支持当前执行的方法在事务中，如果在抛出异常

NESTED( 6 ); //即便当前执行的方法在事务中也会启动一个新事务，然后执行该方法

private final int value ;

private Propagation ( int value ) {

this . value = value ;

}

public int value () {

return this . value ;

}

此外使用@Transactional 必须保证是在public 级别的方法中使用，@Transactional 只能应用到 public 方法才有效，这是因为在使用 Spring AOP 代理时，Spring 在调用 TransactionInterceptor 在目标方法执行前后进行拦截之前，DynamicAdvisedInterceptor（CglibAopProxy 的内部类）的的 intercept 方法或 JdkDynamicAopProxy 的 invoke 方法会间接调用 AbstractFallbackTransactionAttributeSource（Spring 通过这个类获取 @Transactional 注解的事务属性配置属性信息）的 computeTransactionAttribute 方法。

接下来我们创建一个测试类来进行测试：

package com.SpringDemo;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TransactionTest {

public static void main (String[] args) {

ApplicationContext applicationContext =

new ClassPathXmlApplicationContext( "applicationContext.xml" );

UserDao userDao = (UserDao) applicationContext.getBean( "userDao" );

userDao.transfer( "zhangsan" , "lisi" , 100 );

System.out.println( "赠送积分成功" );

}