Spring JDBC 和 事务控制

徐宇曦 2021-01-22 18:12:17
spring 事务 jdbc 控制


==================

主要内容

Spring 整合 JDBC 环境

​ Spring 框架除了提供 IOC 与 AOP 核心功能外,同样提供了基于JDBC 的数据访问功能,使得访问持久层数据更加方便。使用 Spring JDBC 环境,首先需要一套 Spring 整合 JDBC 的环境。

添加依赖坐标

<!-- 添加相关的依赖坐标 -->
<!-- spring 框架坐标依赖添加 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.4.RELEASE</version>
</dependency>
<!-- spring 测试环境 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.2.4.RELEASE</version>
<scope>test</scope>
</dependency>
<!-- aop -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.5</version>
</dependency>
<!-- spring jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.4.RELEASE</version>
</dependency>
<!-- spring事物 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.2.4.RELEASE</version>
</dependency>
<!-- mysql 驱动包 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.19</version>
</dependency>
<!-- c3p0 连接池 -->
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.5.5</version>
</dependency> 

添加 jdbc 配置文件

在src/main/resources目录下新建jdbc.properties配置文件,并设置对应的配置信息

# 驱动名
jdbc.driver=com.mysql.cj.jdbc.Driver
# 数据库连接
jdbc.url=jdbc:mysql://localhost:3306/(数据库名称)?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
# 数据库用户名称
jdbc.user=(数据库账号)
# 数据库用户密码
jdbc.password=(数据库密码) 

以下为可选配置

# 指定连接池的初始化连接数。取值应在minPoolSize 与 maxPoolSize 之间.Default:3
initialPoolSize=20
# 指定连接池中保留的最大连接数. Default:15
maxPoolSize=100
# 指定连接池中保留的最小连接数
minPoolSize=10
# 最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。 Default:0
maxIdleTime=600
# 当连接池中的连接耗尽的时候c3p0一次同时获取的连接数. Default:3
acquireIncrement=5
# JDBC的标准,用以控制数据源内加载的PreparedStatements数量。
maxStatements=5
# 每60秒检查所有连接池中的空闲连接.Default:0
idleConnectionTestPeriod=60 

修改 spring 配置文件

<!-- 加载properties 配置文件,用来读取jdbc.properties文件中的数据 -->
<context:property-placeholder location="jdbc.properties" /> 

spring.xml

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!-- Spring扫描注解的配置 -->
<context:component-scan base-package="com.xxxx" />
<!-- 加载properties 配置文件 -->
<context:property-placeholder location="jdbc.properties" />
</beans> 

配置数据源

​ 由于建立数据库连接是一个非常耗时耗资源的行为,所以通过连接池预先同数据库建立一些连接,放在内存中,应用程序需要建立数据库连接时直接到连接池中申请一个就行,用完后再放回去。

C3P0 与 DBCP 二选一即可

​ DBCP(DataBase connection pool),数据库连接池。是 apache 上的一个 java 连接池项目,也是 tomcat 使用的连接池组件。单独使用dbcp需要2个包:commons-dbcp.jar,commons-pool.jar dbcp,没有自动回收空闲连接的功能。

​ C3P0是一个开源的JDBC连接池,它实现了数据源,支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate,Spring等。c3p0有自动回收空闲连接功能。

C3P0 数据源配置

<!-- 配置 c3p0 数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!-- property标签的value属性对应的是jdbc.properties中的值 -->
<property name="driverClass" value="${jdbc.driver}"></property>
<property name="jdbcUrl" value="${jdbc.url}"></property>
<property name="user" value="${jdbc.user}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean> 

C3P0 其他额外配置(对应的值在jdbc.properties文件中指定)

<!-- 指定连接池中保留的最大连接数。 Default:15-->
<property name="maxPoolSize" value="${maxPoolSize}"/>
<!-- 指定连接池中保留的最小连接数。-->
<property name="minPoolSize" value="${minPoolSize}"/>
<!-- 指定连接池的初始化连接数。取值应在minPoolSize 与 maxPoolSize 之间.Default:3-->
<property name="initialPoolSize" value="${initialPoolSize}"/>
<!-- 最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。 Default:0-->
<property name="maxIdleTime" value="${maxIdleTime}"/>
<!-- 当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。 Default:3-->
<property name="acquireIncrement" value="${acquireIncrement}"/>
<!-- JDBC的标准,用以控制数据源内加载的PreparedStatements数量。
但由于预缓存的statements属于单个connection,而不是整个连接池所以设置这个参数需要考虑到多方面的因数。如果maxStatements与maxStatementsPerConnection均为0,则缓存被关闭。Default:0-->
<property name="maxStatements" value="${maxStatements}"/>
<!-- 每60秒检查所有连接池中的空闲连接。Default:0 -->
<property name="idleConnectionTestPeriod" value="${idleConnectionTestPeriod}"/> 

DBCP 数据源配置

<!-- 配置dbcp数据源-->
<bean id="myDataSource" class="org.apache.commons.dbcp2.BasicDataSource">
<property name="driverClassName" value="${jdbc.driver}" />
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.user}"/>
<property name="password" value="${jdbc.password}"/>
<!-- 连接池启动时的初始值 -->
<property name="initialSize" value="1"/>
<!-- 最大空闲值.当经过一个高峰时间后,连接池可以将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止 -->
<property name="maxIdle" value="2"/>
<!-- 最小空闲值.当空闲的连接数少于阀值时,连接池就会预申请一些连接,以避免洪峰来时再申请而造成的性能开销 -->
<property name="minIdle" value="1"/>
</bean> 

模板类配置

​ Spring把 JDBC 中重复的操作建立成了一个模板类:org.springframework.jdbc.core.JdbcTemplate 。

<!-- 配置JdbcTemplate实例,并注入一个dataSource数据源-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean> 

JDBC 测试

创建指定数据库

选择连接,右键选择"新建数据库",设置数据库的名称和编码格式

创建数据表

使用 JUnit 测试

通过 junit 测试 jdbcTemplate bean 是否获取到

JUnit 测试
public class SpringJdbcTest01 {
@Test
public void testQueryCount() {
// 获取spring上下文环境
ApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
// 得到模板类 JdbcTemplate对象
JdbcTemplate jdbcTemplate = (JdbcTemplate) ctx.getBean("jdbcTemplate");
// 定义sql语句
String sql = "select count(1) from tb_account";
// 执行查询操作(无参数)
Integer total= jdbcTemplate.queryForObject(sql, Integer.class);
System.out.println("总记录数:" + total);
}
@Test
public void testQueryCountByUserId() {
// 获取spring上下文环境
ApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
// 得到模板类 JdbcTemplate对象
JdbcTemplate jdbcTemplate = (JdbcTemplate) ctx.getBean("jdbcTemplate");
// 定义sql语句
String sql = " select count(1) from tb_account where user_id = ?";
// 执行查询操作(有参数)
Integer total = jdbcTemplate.queryForObject(sql, Integer.class, 1);
System.out.println("总记录数:" + total);
}
} 
简单封装
public class SpringJdbcTest02 {
private JdbcTemplate jdbcTemplate;
@Before
public void init() {
// 得到Spring上下文环境
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
// 得到模板类 JdbcTemplate对象
jdbcTemplate = (JdbcTemplate) ac.getBean("jdbcTemplate");
}
@Test
public void testQueryCount() {
// 定义sql语句
String sql = "select count(1) from tb_account";
// 执行查询操作(无参数)
Integer total= jdbcTemplate.queryForObject(sql, Integer.class);
System.out.println("总记录数:" + total);
}
@Test
public void testQueryCountByUserId() {
// 定义sql语句
String sql = " select count(1) from tb_account where user_id = ?";
// 执行查询操作(有参数)
Integer total = jdbcTemplate.queryForObject(sql, Integer.class, 1);
System.out.println("总记录数:" + total);
}
} 
注解封装
@RunWith
就是一个运行器
@RunWith(JUnit4.class) 就是指用JUnit4来运行
@RunWith(SpringJUnit4ClassRunner.class) 让测试运行于Spring测试环境
@ContextConfiguration
Spring整合JUnit4测试时,使用注解引入多个配置文件
@ContextConfiguration(Locations="classpath:applicationContext.xml")
@ContextConfiguration(locations = {"classpath:spring.xml", "classpath:bean.xml"}) 
@RunWith(SpringJUnit4ClassRunner.class) // 将junit测试加到spring环境中
@ContextConfiguration(locations = {"classpath:spring.xml"}) // 设置要加载的资源文件
public class SpringJdbcTest03 {
@Resource
private JdbcTemplate jdbcTemplate;
@Test
public void testQueryCount() {
// 定义sql语句
String sql = "select count(1) from tb_account";
// 执行查询操作(无参数)
Integer total= jdbcTemplate.queryForObject(sql, Integer.class);
System.out.println("总记录数:" + total);
}
} 
通用封装
  1. 定义一个父类,设置通用的配置信息

    /**
 */
@RunWith(SpringJUnit4ClassRunner.class) // 将junit测试加到spring环境中
@ContextConfiguration(locations = {"classpath:spring.xml"}) // 设置要加载的资源文件
public class BaseTest {
}
```
  1. 继承通用的测试类

    public class SpringJdbcTest04 extends BaseTest {
    @Resource
    private JdbcTemplate jdbcTemplate;
    @Test
    public void testQueryCount() {
    // 定义sql语句
    String sql = "select count(1) from tb_account";
    // 执行查询操作(无参数)
    Integer total= jdbcTemplate.queryForObject(sql, Integer.class);
    System.out.println("总记录数:" + total);
    }
    } 

持久层账户模块操作

​ 当完成 Spring Jdbc 环境集成后,这里使用spring jdbc 完成账户单表crud 操作。

账户接口方法定义

定义实体类

Account.java

package com.xxxx.entity;
import java.util.Date;
/**
* 用户账户类
*/
public class Account {
private Integer accountId; // 账户ID,主键
private String accountName; // 账户名称
private String accountType; // 账户类型
private Double money; // 账户金额
private String remark; // 账户备注
private Integer userId; // 用户ID,账户所属用户
private Date createTime; // 创建时间
private Date updateTime; // 修改时间
public Account() {
}
public Account(String accountName, String accountType, Double money,
String remark, Integer userId) {
this.accountName = accountName;
this.accountType = accountType;
this.money = money;
this.remark = remark;
this.userId = userId;
}
@Override
public String toString() {
return "Account{" +
"accountId=" + accountId +
", accountName='" + accountName + ''' +
", accountType='" + accountType + ''' +
", money=" + money +
", remark='" + remark + ''' +
", userId=" + userId +
", createTime=" + createTime +
", updateTime=" + updateTime +
'}';
}
public Integer getAccountId() {
return accountId;
}
public void setAccountId(Integer accountId) {
this.accountId = accountId;
}
public String getAccountName() {
return accountName;
}
public void setAccountName(String accountName) {
this.accountName = accountName;
}
public String getAccountType() {
return accountType;
}
public void setAccountType(String accountType) {
this.accountType = accountType;
}
public Double getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
public Integer getUserId() {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getUpdateTime() {
return updateTime;
}
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
} 

定义接口类

IAccountDao.java

package com.xxxx.dao;
import com.xxxx.entity.Account;
import java.util.List;
/**
* 用户模块 接口定义
* 1. 添加账户
* 添加账户记录,返回受影响的行数
* 添加账户记录,返回记录的主键
* 批量添加账户记录,返回受影响的行数
* 2. 查询账户
* 查询指定用户的账户总记录数,返回记录数
* 查询指定账户记录详情,返回账户对象
* 多条件查询指定用户的账户列表,返回账户集合
* 3. 更新账户
* 更新账户记录,返回受影响的行数
* 批量更新账户记录,返回受影响的行数
* 4. 删除账户
* 删除账户记录,返回受影响的行数
* 批量删除账户记录,返回受影响的行数
*/
public interface IAccountDao {
/**
* 添加账户
* 添加账户记录,返回受影响的行数
* @param account
* @return
*/
public int addAccount(Account account) ;
/**
* 添加账户
* 添加账户记录,返回记录的主键
* @param account
* @return
*/
public int addAccountHasKey(Account account);
/**
* 添加账户
* 批量添加账户记录,返回受影响的行数
* @param accounts
* @return
*/
public int addAccountBatch(List<Account> accounts);
/**
* 查询账户
* 查询指定用户的账户总记录数,返回记录数
* @param userId
* @return
*/
public int queryAccountCount(Integer userId);
/**
* 查询账户
* 查询指定账户记录详情,返回账户对象
* @param accountId
* @return
*/
public Account queryAccountById(Integer accountId);
/**
* 查询账户
* 多条件查询指定用户的账户列表,返回账户集合
* @param userId
* @param accountName
* @param accountType
* @param createTime
* @return
*/
public List<Account> queryAccountsByParams(Integer userId, String accountName, String accountType, String createTime);
/**
* 更新账户
* 更新账户记录,返回受影响的行数
* @param account
* @return
*/
public int updateAccountById(Account account);
/**
* 更新账户
* 批量更新账户记录,返回受影响的行数
* @param accounts
* @return
*/
public int updateAccountBatch(List<Account> accounts);
/**
* 删除账户
* 删除账户记录,返回受影响的行数
* @param accountId
* @return
*/
public Integer deleteAccoutById(Integer accountId);
/**
* 删除用户
* 批量删除账户记录,返回受影响的行数
* @param ids
* @return
*/
public int deleteAccountBatch(Integer[] ids);
} 

定义接口实现类

package com.xxxx.dao.impl;
import com.xxxx.dao.IAccountDao;
import com.xxxx.entity.Account;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.List;
/**
* 账户模块接口实现类
*/
@Repository
public class AccountDaoImpl implements IAccountDao {
// JdbcTemplate 模板类注入
@Resource
private JdbcTemplate jdbcTemplate;
@Override
public int addAccount(Account account) {
return 0;
}
@Override
public int addAccountHasKey(Account account) {
return 0;
}
@Override
public int addAccountBatch(List<Account> accounts) {
return 0;
}
@Override
public int queryAccountCount(Integer userId) {
return 0;
}
@Override
public Account queryAccountById(Integer accountId) {
return null;
}
@Override
public List<Account> queryAccountsByParams(Integer userId, String accountName, String accountType, String createTime) {
return null;
}
@Override
public int updateAccountById(Account account) {
return 0;
}
@Override
public int updateAccountBatch(List<Account> accounts) {
return 0;
}
@Override
public Integer deleteAccoutById(Integer accountId) {
return null;
}
@Override
public int deleteAccountBatch(Integer[] ids) {
return 0;
}
} 

账户记录添加实现

​ 在企业项目开发时,对于记录的添加可能涉及到多种添加方式,比如添加单条记录,批量添加多条记录等情况。这里对于账户记录添加方式分为三种方式:添加单条记录返回受影响行数、添加单条记录返回主键、批量添加多条记录。

添加账户记录

/**
* 添加单条记录,返回受影响的行数
* @param account
* @return
*/
@Override
public int addAccount(Account account) {
String sql = "insert into tb_account(account_name,account_type,money,remark," +
"user_id,create_time,update_time) values (?,?,?,?,?,now(),now())";
Object[] objs = {account.getAccountName(),account.getAccountType(),
account.getMoney(),account.getRemark(),account.getUserId()};
return jdbcTemplate.update(sql,objs);
} 

测试方法

/**
* 添加账户记录,得到受影响的行数
*/
@Test
public void testAddAccount() {
// 准备要添加的数据
Account account = new Account("张三","建设银行",100.0,"零花钱",1);
// 调用对象的添加方法,返回受影响的行数
int row = accountDao.addAccount(account);
System.out.println("添加账户受影响的行数:" + row);
} 

添加记录返回主键

/**
* 添加单条记录,返回主键
* @param account
* @return
*/
@Override
public int addAccountHasKey(Account account) {
String sql = "insert into tb_account(account_name,account_type,money,remark," +
"user_id,create_time,update_time) values (?,?,?,?,?,now(),now())";
// 定义keyHolder 对象 获取记录主键值
KeyHolder keyHolder = new GeneratedKeyHolder();
jdbcTemplate.update(connection -> {
// 预编译sql语句,并设置返回主键
PreparedStatement ps =
connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
// 设置参数
ps.setString(1,account.getAccountName());
ps.setString(2,account.getAccountType());
ps.setDouble(3,account.getMoney());
ps.setString(4,account.getRemark());
ps.setInt(5,account.getUserId());
return ps;
},keyHolder);
// 得到返回的主键
Integer key = keyHolder.getKey().intValue();
return key;
} 

测试方法

/**
* 添加账户记录,返回主键
*/
@Test
public void testAddAccountHasKey() {
// 准备要添加的数据
Account account = new Account("李四","招商银行",200.0,"兼职费",2);
// 调用对象的添加方法,返回主键
int key = accountDao.addAccountHasKey(account);
System.out.println("添加账户返回的主键:" + key);
} 

批量添加账户记录

/**
* 添加多条记录,返回受影响的行数
* @param accounts
* @return
*/
@Override
public int addAccountBatch(final List<Account> accounts) {
String sql = "insert into tb_account(account_name,account_type,money,remark," +
"user_id,create_time,update_time) values (?,?,?,?,?,now(),now())";
int rows = jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
@Override
public void setValues(PreparedStatement preparedStatement, int i)
throws SQLException {
// 设置参数
preparedStatement.setString(1,accounts.get(i).getAccountName());
preparedStatement.setString(2,accounts.get(i).getAccountType());
preparedStatement.setDouble(3,accounts.get(i).getMoney());
preparedStatement.setString(4,accounts.get(i).getRemark());
preparedStatement.setInt(5,accounts.get(i).getUserId());
}
@Override
public int getBatchSize() {
return accounts.size();
}
}).length;
return rows;
} 

测试方法

/**
* 批量添加数据,返回受影响的行数
*/
@Test
public void testAddAccountBatch() {
// 准备要添加的数据
Account account = new Account("王五","农业银行",2000.0,"工资",3);
Account account2 = new Account("赵六","中国银行",280.0,"奖金",3);
Account account3 = new Account("田七","工商银行",800.0,"零花钱",3);
List<Account> accountList = new ArrayList<>();
accountList.add(account);
accountList.add(account2);
accountList.add(account3);
// 调用对象的添加方法,返回主键
int rows = accountDao.addAccountBatch(accountList);
System.out.println("批量添加账户受影响的行数:" + rows);
} 

账户记录查询实现

​ 账户记录查询这里提供了三种查询方式,查询指定用户所有账户记录数,查询单条账户记录详情,多条件查询指定用户账户记录。

查询用户的账户总记录数

/**
* 查询指定用户的账户总记录数,返回记录数
* @param userId
* @return
*/
@Override
public int queryAccountCount(Integer userId) {
String sql = "select count(1) from tb_account where user_id = ?";
int count = jdbcTemplate.queryForObject(sql,Integer.class,userId);
return count;
} 

测试方法

/**
* 查询用户的账户总记录数,返回总记录数
*/
@Test
public void testQueryAccountCount(){
// 查询ID为1的用户的账户总记录数
int total = accountDao.queryAccountCount(1);
System.out.println("总记录数:" + total);
} 

查询指定账户记录详情

/**
* 查询某个账户记录详情,返回账户对象
* @param accountId
* @return
*/
@Override
public Account queryAccountById(Integer accountId) {
String sql = "select * from tb_account where account_id = ?";
Account account = jdbcTemplate.queryForObject(sql, new Object[]{accountId}, (resultSet, i) -> {
Account acc = new Account();
acc.setAccountId(resultSet.getInt("account_id"));
acc.setMoney(resultSet.getDouble("money"));
acc.setAccountName(resultSet.getString("account_name"));
acc.setAccountType(resultSet.getString("account_type"));
acc.setRemark(resultSet.getString("remark"));
acc.setCreateTime(resultSet.getDate("create_time"));
acc.setUpdateTime(resultSet.getDate("update_time"));
acc.setUserId(resultSet.getInt("user_id"));
return acc;
});
return account;
} 

测试方法

/**
* 查询指定账户的记录详情,返回账户对象
*/
@Test
public void testQueryAccountById(){
// 查询ID为1的账户记录的详情
Account account = accountDao.queryAccountById(1);
System.out.println("账户详情:" + account.toString());
} 

多条件查询用户账户记录

/**
* 多条件查询指定用户的账户列表,返回账户集合
* @param userId 用户Id
* @param accountName 账户名称 (模糊查询)
* @param accountType 账户类型
* @param createTime 账户创建时间
* @return
*/
@Override
public List<Account> queryAccountsByParams(Integer userId, String accountName, String accountType,
String createTime) {
String sql = "select * from tb_account where user_id = ? ";
List<Object> params = new ArrayList<>();
params.add(userId);
// 判断是否有条件查询
// 如果账户名称不为空,通过账户名称模糊匹配
if (StringUtils.isNotBlank(accountName)) {
sql += " and account_name like concat('%',?,'%') ";
params.add(accountName);
}
// 如果账户类型不为空,通过指定类型名称查询
if (StringUtils.isNotBlank(accountType)) {
sql += " and account_type = ? ";
params.add(accountType);
}
// 如果创建时间不为空,查询创建时间大于指定时间的账户记录
if (StringUtils.isNotBlank(createTime)) {
sql += " and create_time > ? ";
params.add(createTime);
}
// 将集合转换成数组
Object[] objs = params.toArray();
List<Account> accountList = jdbcTemplate.query(sql, objs, (resultSet, rowNum) -> {
Account acc = new Account();
acc.setAccountId(resultSet.getInt("account_id"));
acc.setMoney(resultSet.getDouble("money"));
acc.setAccountName(resultSet.getString("account_name"));
acc.setAccountType(resultSet.getString("account_type"));
acc.setRemark(resultSet.getString("remark"));
acc.setCreateTime(resultSet.getDate("create_time"));
acc.setUpdateTime(resultSet.getDate("update_time"));
acc.setUserId(resultSet.getInt("user_id"));
return acc;
});
return accountList;
} 

测试方法

/**
* 多条件查询用户的账户记录,返回账户集合
*/
@Test
public void testQueryAccountByParams(){
// 查询用户的账户列表
List<Account> accountList = accountDao.queryAccountsByParams(3,null,null,null);
// 通过指定条件查询用户的账户列表
List<Account> accountList02 = accountDao.queryAccountsByParams(3,"张",null,null);
System.out.println(accountList.toString());
System.out.println(accountList02.toString());
} 

账户记录更新实现

更新账户记录

/**
* 更新指定账户记录,返回受影响的行数
* @param account
* @return
*/
@Override
public int updateAccountById(Account account) {
String sql = "update tb_account set account_name = ?, account_type = ?, " +
" money = ? ,remark = ?,user_id = ? ,update_time = now() " +
" where account_id = ? ";
Object[] objs = {account.getAccountName(),account.getAccountType(),
account.getMoney(), account.getRemark(),account.getUserId(),
account.getAccountId()};
return jdbcTemplate.update(sql,objs);
} 

测试方法

/**
* 更新指定账户记录,返回受影响的行数
*/
@Test
public void testUpdateAccount(){
// 准备要修改的数据
Account account = new Account("张三1","建设银行1",500.0,"零花钱加倍",1);
account.setAccountId(1);
int row = accountDao.updateAccountById(account);
System.out.println("修改账户返回受影响的行数:" + row);
} 

批量更新账户记录

/**
* 批量新账户记录,返回受影响的行数
* @param accounts
* @return
*/
@Override
public int updateAccountBatch(List<Account> accounts) {
String sql = "update tb_account set account_name = ?, account_type = ?, " +
" money = ? ,remark = ?,user_id = ? ,update_time = now() " +
" where account_id = ? ";
int rows = jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
@Override
public void setValues(PreparedStatement ps, int i) throws SQLException {
// 设置参数
ps.setString(1,accounts.get(i).getAccountName());
ps.setString(2,accounts.get(i).getAccountType());
ps.setDouble(3,accounts.get(i).getMoney());
ps.setString(4,accounts.get(i).getRemark());
ps.setInt(5,accounts.get(i).getUserId());
ps.setInt(6,accounts.get(i).getAccountId());
}
@Override
public int getBatchSize() {
return accounts.size();
}
}).length;
return rows;
} 

测试方法

/**
* 批量更新账户记录,返回受影响的行数
*/
@Test
public void testUpdateAccountBatch(){
// 准备要修改的数据
Account account = new Account("a3","建设银行3",300.0,"零花钱加倍3",3);
account.setAccountId(3);
Account account2 = new Account("a4","建设银行4",400.0,"零花钱加倍4",3);
account2.setAccountId(4);
List<Account> accountList = new ArrayList<>();
accountList.add(account);
accountList.add(account2);
int rows = accountDao.updateAccountBatch(accountList);
System.out.println("批量修改账户记录返回受影响的行数:" + rows);
} 

账户记录删除实现

删除账户记录

/**
* 删除账户记录,返回受影响的行数
* @param accountId
* @return
*/
@Override
public Integer deleteAccoutById(Integer accountId) {
String sql = "delete from tb_account where account_id= ? ";
Object[] objs = {accountId};
return jdbcTemplate.update(sql,objs);
} 

测试方法

/**
* 删除账户记录,返回受影响的行数
*/
@Test
public void testDeleteAccount(){
// 删除ID为1的账户记录
int row = accountDao.deleteAccoutById(1);
System.out.println("删除账户记录返回受影响的行数:" + row);
} 

批量删除账户记录

 /**
* 批量删除账户记录,返回受影响的行数
* @param ids
* @return
*/
@Override
public int deleteAccountBatch(Integer[] ids) {
String sql = "delete from tb_account where account_id = ?";
int row = jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
@Override
public void setValues(PreparedStatement ps, int i) throws SQLException {
ps.setInt(1,ids[i]);
}
@Override
public int getBatchSize() {
return ids.length;
}
}).length;
return row;
} 

测试方法

/**
* 批量删除账户记录,返回受影响的行数
*/
@Test
public void testDeleteAccountBatch(){
// 删除多个id的账户记录
Integer[] ids = new Integer[]{2,3};
int rows = accountDao.deleteAccountBatch(ids);
System.out.println("批量删除账户记录返回受影响的行数:" + rows);
} 

Spring 事务控制

转账场景模拟实现

接口方法定义

/**
* 收入
* @param tarAid 收入金额的账户ID
* @param money 收入金额
* @return
*/
public int inAccount(Integer tarAid, Double money);
/**
* 支出
* @param outAid 支出金额的账户ID
* @param money 支出金额
* @return
*/
public int outAccount(Integer outAid, Double money); 

实现对应接口

​ 对于转账涉及到双方账户以及对应转账金额,所以有入账和出账两个方法。

/**
* 账户收入
* @param tarAid 账户ID
* @param money 收入金额
* @return
*/
@Override
public int inAccount(Integer tarAid, Double money) {
// 修改指定ID的金额 (加上金额)
String sql = "update tb_account set money = money + ? where account_id = ? ";
Object[] objs = {money, tarAid};
return jdbcTemplate.update(sql,objs);
}
/**
* 账户支出
* @param outAid 账户ID
* @param money 支出金额
* @return
*/
@Override
public int outAccount(Integer outAid, Double money) {
// 修改指定ID的金额 (减去金额)
String sql = "update tb_account set money = money - ? where account_id = ? ";
Object[] objs = {money, outAid};
return jdbcTemplate.update(sql,objs);
} 

转账方法实现

package com.xxxx.service;
import com.xxxx.dao.IAccountDao;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
public class AccountService {
@Resource
private IAccountDao accountDao;
/**
* 转账业务操作
* @param outAid 支出账户
* @param inAid 收入账户
* @param money 支出金额/收入金额
* @return
*/
public int updateAccountByTransfer(Integer outAid, Integer inAid, Double money){
int row = 0;
/**
* 张三账户向李四账户转账100元
* 张三账户的金额 - 100
* 李四账户的金额 + 100
*/
// 支出,修改金额返回受影响的行数
int outRow = accountDao.outAccount(1,100.0);
// 收入,修改金额返回受影响的行数
int inRow = accountDao.inAccount(2,100.0);
// 当两个操作都执行成功时,转账成功
if (outRow == 1 && inRow == 1) {
row = 1; // 成功
}
return row;
}
} 

​ 仔细思考代码会发现,在程序运行中无法保证 service 层业务代码不发生异常,如果通过 jdbc 的方式处理事务,此时需要手动方式控制事务,这样的话凡是涉及到事务控制的业务方法均需要开发人员手动来进行事务处理,无法满足生产的需要。

Spring 事务概念

事务的四大特性(ACID)

  • 原子性(Atomicity)

    ​ 共生死,要么全部成功,要么全部失败!

  • 一致性(Consistency)

    ​ 事务在执行前后,数据库中数据要保持一致性状态。(如转账的过程 账户操作后数据必须保持一致)

  • 隔离性(Isolation)

    ​ 事务与事务之间的执行应当是相互隔离互不影响的。(多个角色对统一记录进行操作必须保证没有任何干扰),当然没有影响是不可能的,为了让影响级别降到最低,通过隔离级别加以限制:

    ​ 1. READ_UNCOMMITTED (读未提交)

    ​ 隔离级别最低的一种事务级别。在这种隔离级别下,会引发脏读、不可重复读和幻读。

    ​ 2. READ_COMMITTED (读已提交)

    ​ 读到的都是别人提交后的值。这种隔离级别下,会引发不可重复读和幻读,但避免了脏读。

    ​ 3. REPEATABLE_READ (可重复读)

    ​ 这种隔离级别下,会引发幻读,但避免了脏读、不可重复读。

    ​ 4. SERIALIZABLE (串行化)

    ​ 最严格的隔离级别。在Serializable隔离级别下,所有事务按照次序依次执行。

    ​ 脏读、不可重复读、幻读都不会出现。

  • 持久性(Durability)

    ​ 事务提交完毕后,数据库中的数据的改变是永久的。

Spring 事务核心接口

​ Spring 事务管理的实现有许多细节,如果对整个接口框架有个大体了解会非常有利于我们理解事务,下面通过讲解 Spring 的事务接口来了解 Spring 实现事务的具体策略。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TopwzVC2-1611309424483)(/SpringJDBC-03.png)]

​ Spring 并不直接管理事务,而是提供了多种事务管理器,他们将事务管理的职责委托给 Hibernate 或者 JTA 等持久化机制所提供的相关平台框架的事务来实现。

​ Spring 事务管理器的接口是org.springframework.transaction.PlatformTransactionManager,通过这个接口,Spring 为各个平台如 JDBC、Hibernate 等都提供了对应的事务管理器,但是具体的实现就是各个平台自己的事情了。此接口的内容如下:

public interface PlatformTransactionManager(){
// 由 TransactionDefinition 得到 TransactionStatus 对象
TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
// 提交
void commit(TransactionStatus status) throws TransactionException;
// 回滚
void rollback(TransactionStatus status) throws TransactionException;
} 

​ 从这里可知具体的具体的事务管理机制对 Spring 来说是透明的,它并不关心那些,那些是对应各个平台需要关心的,所以 Spring 事务管理的一个优点就是为不同的事务 API 提供一致的编程模型,如 JTA、JDBC、Hibernate、JPA。下面分别介绍各个平台框架实现事务管理的机制。

JDBC 事务

​ 如果应用程序中直接使用 JDBC 来进行持久化,此时使用 DataSourceTransactionManager 来处理事务边界。为了使用DataSourceTransactionManager,需要使用如下的 XML 将其装配到应用程序的上下文定义中:

<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean> 

​ 实际上,DataSourceTransactionManager 是通过调用 java.sql.Connection 来管理事务,而后者是通过 DataSource 获取到的。通过调用连接的 commit() 方法来提交事务,同样,事务失败则通过调用 rollback() 方法进行回滚。

Hibernate 事务

​ 如果应用程序的持久化是通过 Hibernate 实现的,那么你需要使用 HibernateTransactionManager。对于 Hibernate3,需要在 Spring 上下文定义中添加如下的声明:

<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean> 

​ sessionFactory 属性需要装配一个 Hibernate 的 session 工厂,HibernateTransactionManager 的实现细节是它将事务管理的职责委托给 org.hibernate.Transaction 对象,而后者是从 Hibernate Session 中获取到的。当事务成功完成时,HibernateTransactionManager 将会调用 Transaction 对象的 commit() 方法,反之,将会调用 rollback() 方法。

Java 持久化 API 事务(JPA)

​ Hibernate 多年来一直是 Java 持久化标准,但是现在 Java 持久化 API 作为真正的 Java 持久化标准进入大家的视野。如果你计划使用 JPA 的话,那你需要使用 Spring 的 JpaTransactionManager 来处理事务。你需要在 Spring 中这样配置 JpaTransactionManager:

<bean id="transactionManager"
class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean> 

​ JpaTransactionManager 只需要装配一个 JPA 实体管理工厂(javax.persistence.EntityManagerFactory 接口的任意实现)。 JpaTransactionManager 将与由工厂所产生的 JPA EntityManager 合作来构建事务。

Java 原生 API 事务

​ 如果应用程序没有使用以上所述的事务管理,或者是跨越了多个事务管理源(比如两个或者是多个不同的数据源),此时需要使用 JtaTransactionManager:

<bean id="transactionManager"
class="org.springframework.transaction.jta.JtaTransactionManager">
<property name="transactionManagerName" value="java:/TransactionManager" />
</bean> 

​ JtaTransactionManager 将事务管理的责任委托给 javax.transaction.UserTransaction 和javax.transaction.TransactionManager 对象,其中事务成功完成通过 UserTransaction.commit() 方法提交,事务失败通过 UserTransaction.rollback() 方法回滚。

Spring 事务控制配置

​ 通过 jdbc 持久化事务,对于事务配置实现由两种方式即:Xml 配置,注解配置。

XML 配置

添加命名空间

在spring.xml配置文件的添加事务和aop的命名空间

事务

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

AOP

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

配置如下

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd"> 
设置aop代理
<!-- 开启AOP代理 -->
<aop:aspectj-autoproxy /> 
配置事务管理器
<!-- 事务管理器定义 -->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--数据源 -->
<property name="dataSource" ref="dataSource"></property>
</bean> 
配置事务相关通知

一般来说增删改方法 propagation=Required,对于查询方法使用 read-only=“true”

<!-- 配置事务通知 transaction-manager属性表示这个事务通知是哪个事务管理器管理的-->
<!--
tx:method的属性:
name
是必须的,表示与事务属性关联的方法名(业务方法名),对切入点进行细化。
通配符(*)可以用来指定一批关联到相同的事务属性的方法。
如:'get*'、'handle*'、'on*Event'等等.
propagation
不是必须的,默认值是REQUIRED
表示事务传播行为, 包括:
REQUIRED,SUPPORTS,MANDATORY,NEVER
REQUIRES_NEW,NOT_SUPPORTED,NESTED
isolation
不是必须的,默认值DEFAULT
表示事务隔离级别(数据库的隔离级别)
timeout
不是必须的,默认值-1(永不超时)
表示事务超时的时间(以秒为单位)
read-only
不是必须的,默认值false不是只读的
表示事务是否只读
rollback-for
不是必须的
表示将被触发进行回滚的 Exception(s);以逗号分开。
如:'com.foo.MyBusinessException,ServletException'
no-rollback-for
不是必须的
表示不被触发进行回滚的 Exception(s);以逗号分开。
如:'com.foo.MyBusinessException,ServletException'
任何 RuntimeException 将触发事务回滚
-->
<tx:advice id="txAdvice" transaction-manager="txManager">
<!--对以add update delete query开头的所有方法进行事务处理-->
<tx:attributes>
<!--定义什么方法需要使用事务 name代表的是方法名(或方法匹配)-->
<!-- 匹配以 add 开头的所有方法均加入事务 -->
<tx:method name="add*" propagation="REQUIRED" />
<!-- 匹配以 update 开头的所有方法均加入事务 -->
<tx:method name="update*" propagation="REQUIRED" />
<!-- 匹配以 delete 开头的所有方法均加入事务 -->
<tx:method name="delete*" propagation="REQUIRED" />
<!-- 匹配以 query 开头的所有方法均加入事务 -->
<tx:method name="query*" read-only="true" />
</tx:attributes>
</tx:advice> 
事务传播行为介绍:
@Transactional(propagation=Propagation.REQUIRED)
如果有事务, 那么加入事务, 没有的话新建一个(默认情况下)
@Transactional(propagation=Propagation.NOT_SUPPORTED)
容器不为这个方法开启事务
@Transactional(propagation=Propagation.REQUIRES_NEW)
不管是否存在事务,都创建一个新的事务,原来的挂起,新的执行完毕,继续执行老的事务
@Transactional(propagation=Propagation.MANDATORY)
必须在一个已有的事务中执行,否则抛出异常
@Transactional(propagation=Propagation.NEVER)
必须在一个没有的事务中执行,否则抛出异常(与 Propagation.MANDATORY 相反)
@Transactional(propagation=Propagation.SUPPORTS)
如果其他 bean 调用这个方法,在其他 bean 中声明事务,那就用事务.
如果其他 bean 没有声明事务,那就不用事务.
@Transactional(propagation=Propagation.NESTED)
支持当前事务,如果当前事务存在,则执行一个嵌套事务,如果当前没有事务,就新建一个事务。 
配置aop
<!-- aop 切面定义 (切入点和通知) -->
<aop:config>
<!-- 设置切入点 设置需要被拦截的方法 -->
<aop:pointcut expression="execution(* com.xxxx.service..*.*(..) )" id="cut" />
<!-- 设置通知 事务通知 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="cut"/>
<aop:adviso 

注解配置

配置事务管理器
<!-- spring 注解式事务声明 -->
<!-- 事务管理器定义 -->
<bean id="txManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean> 
配置注解支持
<tx:annotation-driven transaction-manager="txManager"/> 
方法上加入事务注解

Service 方法上在需要添加事务的方法上加入事务注解

@Override
@Transactional(propagation=Propagation.REQUIRED)
public void saveUser(String userName,String userPwd){
User user1=new User();
user1.setUserName(userName);
user1.setUserPwd(userPwd);
userDao.saveUser(user1);
userDao.delUserById(2);
} 

备注:默认 spring 事务只在发生未被捕获的 runtimeexcetpion 时才回滚。

spring aop 异常捕获原理:

被拦截的方法需显式抛出异常,并不能经任何处理,这样aop 代理才能捕获到方法的异常,才能进行回滚,默认情况下 aop 只捕获 runtimeexception 的异常,但可以通过配置来捕获特定的异常并回滚换句话说在 service 的方法中不使用 try catch 或者在 catch 中最后加上 throw new RunTimeexcetpion(),这样程序异常时才能被 aop 捕获进而回滚.

版权声明
本文为[徐宇曦]所创,转载请带上原文链接,感谢
https://segmentfault.com/a/1190000039064220

  1. 【计算机网络 12(1),尚学堂马士兵Java视频教程
  2. 【程序猿历程,史上最全的Java面试题集锦在这里
  3. 【程序猿历程(1),Javaweb视频教程百度云
  4. Notes on MySQL 45 lectures (1-7)
  5. [computer network 12 (1), Shang Xuetang Ma soldier java video tutorial
  6. The most complete collection of Java interview questions in history is here
  7. [process of program ape (1), JavaWeb video tutorial, baidu cloud
  8. Notes on MySQL 45 lectures (1-7)
  9. 精进 Spring Boot 03:Spring Boot 的配置文件和配置管理,以及用三种方式读取配置文件
  10. Refined spring boot 03: spring boot configuration files and configuration management, and reading configuration files in three ways
  11. 精进 Spring Boot 03:Spring Boot 的配置文件和配置管理,以及用三种方式读取配置文件
  12. Refined spring boot 03: spring boot configuration files and configuration management, and reading configuration files in three ways
  13. 【递归,Java传智播客笔记
  14. [recursion, Java intelligence podcast notes
  15. [adhere to painting for 386 days] the beginning of spring of 24 solar terms
  16. K8S系列第八篇(Service、EndPoints以及高可用kubeadm部署)
  17. K8s Series Part 8 (service, endpoints and high availability kubeadm deployment)
  18. 【重识 HTML (3),350道Java面试真题分享
  19. 【重识 HTML (2),Java并发编程必会的多线程你竟然还不会
  20. 【重识 HTML (1),二本Java小菜鸟4面字节跳动被秒成渣渣
  21. [re recognize HTML (3) and share 350 real Java interview questions
  22. [re recognize HTML (2). Multithreading is a must for Java Concurrent Programming. How dare you not
  23. [re recognize HTML (1), two Java rookies' 4-sided bytes beat and become slag in seconds
  24. 造轮子系列之RPC 1:如何从零开始开发RPC框架
  25. RPC 1: how to develop RPC framework from scratch
  26. 造轮子系列之RPC 1:如何从零开始开发RPC框架
  27. RPC 1: how to develop RPC framework from scratch
  28. 一次性捋清楚吧,对乱糟糟的,Spring事务扩展机制
  29. 一文彻底弄懂如何选择抽象类还是接口,连续四年百度Java岗必问面试题
  30. Redis常用命令
  31. 一双拖鞋引发的血案,狂神说Java系列笔记
  32. 一、mysql基础安装
  33. 一位程序员的独白:尽管我一生坎坷,Java框架面试基础
  34. Clear it all at once. For the messy, spring transaction extension mechanism
  35. A thorough understanding of how to choose abstract classes or interfaces, baidu Java post must ask interview questions for four consecutive years
  36. Redis common commands
  37. A pair of slippers triggered the murder, crazy God said java series notes
  38. 1、 MySQL basic installation
  39. Monologue of a programmer: despite my ups and downs in my life, Java framework is the foundation of interview
  40. 【大厂面试】三面三问Spring循环依赖,请一定要把这篇看完(建议收藏)
  41. 一线互联网企业中,springboot入门项目
  42. 一篇文带你入门SSM框架Spring开发,帮你快速拿Offer
  43. 【面试资料】Java全集、微服务、大数据、数据结构与算法、机器学习知识最全总结,283页pdf
  44. 【leetcode刷题】24.数组中重复的数字——Java版
  45. 【leetcode刷题】23.对称二叉树——Java版
  46. 【leetcode刷题】22.二叉树的中序遍历——Java版
  47. 【leetcode刷题】21.三数之和——Java版
  48. 【leetcode刷题】20.最长回文子串——Java版
  49. 【leetcode刷题】19.回文链表——Java版
  50. 【leetcode刷题】18.反转链表——Java版
  51. 【leetcode刷题】17.相交链表——Java&python版
  52. 【leetcode刷题】16.环形链表——Java版
  53. 【leetcode刷题】15.汉明距离——Java版
  54. 【leetcode刷题】14.找到所有数组中消失的数字——Java版
  55. 【leetcode刷题】13.比特位计数——Java版
  56. oracle控制用户权限命令
  57. 三年Java开发,继阿里,鲁班二期Java架构师
  58. Oracle必须要启动的服务
  59. 万字长文!深入剖析HashMap,Java基础笔试题大全带答案
  60. 一问Kafka就心慌?我却凭着这份,图灵学院vip课程百度云