hibernate java SpringJDBC与声明式事务操作

文章目录

Spring JDBC与事务操作一、Spring整合JDBC的环境（一）添加依赖坐标（二）添加jdbc.properties的配置（三）创建Spring的配置文件（四）配置数据源（五）JDBC测试

二、持久层账户模块操作（例）（一）账户接口方法定义1. 定义账户实体类2.定义账户的接口类3.定义接口的实现类

（二）、账户记录添加实现1. 添加账户记录2.添加账户记录返回主键3.批量添加账户，返回受影响的行数

（三）账户记录查询的实现1. 查询用户的账户记录总数2.查询指定账户记录详情3. 多条件查询用户账户记录

（四）账户记录的更新操作1.更新账户记录2.批量更新账户记录

（五）账户记录删除实现1.删除账户记录2.批量删除账户记录

三、事务的概念（一）事务的四大特性（ACID）1. 原子性（Atomicity）2. 一致性（Consistency）3.隔离性（Isolation）4. 持久性（Durability）

（二）Spring事务核心接口1. JDBC事务2. Hibernate事务3. Java持久化API事务（JPA）4. Java原生API事务

（三）Spring事务控制的配置1. XML配置（1）添加命名空间（2）设置AOP代理（3）配置事务管理器（4）配置事务的相关通知（5）配置AOP

2. 注解配置（1）配置事务管理器（2）配置注解支持（3）加入事务注解

（四）Spring事务控制——模拟转账的实现1.接口方法定义2.接口实现3.业务层方法4.测试

Spring JDBC与事务操作

一、Spring整合JDBC的环境

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

（一）添加依赖坐标

junit

junit

4.12

org.springframework

spring-context

5.3.14

org.springframework

spring-test

5.3.14

org.aspectj

aspectjweaver

1.9.6

org.springframework

spring-jdbc

5.3.14

org.springframework

spring-tx

5.3.14

mysql

mysql-connector-java

8.0.16

com.mchange

c3p0

0.9.5.5

org.projectlombok

lombok

RELEASE

compile

（二）添加jdbc.properties的配置

jdbc.driver=com.mysql.cj.jdbc.Driver

jdbc.url=jdbc:mysql://localhost/spring_jdbc?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false

jdbc.username = root

jdbc.password = root

jdbc.maxActive= 50

initialPoolSize=20

maxPoolSize=100

minPoolSize=10

maxIdleTime=600

acquireIncrement=5

maxStatements=5

idleConnectionTestPeriod=60

（三）创建Spring的配置文件

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

https://www.springframework.org/schema/context/spring-context.xsd

">

需要添加相应的命名空间，并且开启自动化扫描组件，使用context的property-placeholder属性，并指定location属性值为指定的配置文件。

（四）配置数据源

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

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

C3P0数据源配置

模板类配置

Spring把JDBC中的重复操作组合成了一个模板类org.springframework.jdbc.core.JdbcTemplate

（五）JDBC测试

创建数据库表

创建tb_account表，并插入相应的数据支持。

USE MyBatis;

CREATE TABLE tb_account(

account_id int(11) NOT NULL PRIMARY KEY AUTO_INCREMENT,

account_name varchar(20) NOT NULL,

account_type varchar(20) NOT NULL,

money double NOT NULL ,

remark varchar(50),

create_time datetime NOT NULL,

update_time datetime NOT NULL ,

user_id int(11) NOT NULL

);

INSERT INTO tb_account (account_id, account_name, account_type, money, remark, create_time, update_time, user_id)

VALUES (1,'账户1','建设银行',1000,'零花钱','2020-03-19 02:42:42','2020-03-19 02:42:56',1);

INSERT INTO tb_account(account_id, account_name, account_type, money, remark, create_time, update_time, user_id) VALUES

(2,'账户2','招商银行',500,'兼职费','2020-03-20 02:43:56','2020-03-20 02:46:57',1);

使用Junit测试

@Test

public void testTemplate1(){

//获取Spring的上下文环境

ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

JdbcTemplate jdbcTemplate = context.getBean("jdbcTemplate", JdbcTemplate.class);

//定义sql语句

String totalUsers="SELECT count(1) FROM tb_account";

Integer total = jdbcTemplate.queryForObject(totalUsers, Integer.class);

System.out.println("共有"+total+"条数据");

}

@Test

public void testJdbcTemplate2(){

//获取Spring的上下文环境

ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

JdbcTemplate jdbcTemplate = context.getBean("jdbcTemplate", JdbcTemplate.class);

String sql="SELECT count(1) FROM tb_account WHERE user_id=?";

Integer integer = jdbcTemplate.queryForObject(sql, Integer.class,2);

System.out.println("记录总数："+integer);

}

junit测试改进

首先创建基类测试类

@RunWith(SpringJUnit4ClassRunner.class)//将测试运行在Spring的测试环境中

@ContextConfiguration(locations = {"classpath:spring.xml"})//设置要加载的配置文件，使用注解进行配置。

public class BaseTest {

}

需要注意的是基类测试类不需要书写任何内容，只需要在类上添加两个注解

@RunWith（SpringJUnit4ClassRunner.class）：此处表示将原先的junit测试添加到Spring的测试环境之中去。

@ContextConfiguration（locations={xxxx，xxxx}）：此处表示设置要加载的配置文件，locations表示配置文件的数组名，之后添加一个数组，数组的内容是需要使用到的xml配置文件。

创建基本的测试类

public class SpringJDBCTest extends BaseTest{

/**使用注解来注入*/

@Resource

private JdbcTemplate jdbcTemplate;

@Test

public void testTemplate1(){

//定义sql语句

String totalUsers="SELECT count(1) FROM tb_account";

Integer total = jdbcTemplate.queryForObject(totalUsers, Integer.class);

System.out.println("共有"+total+"条数据");

}

@Test

public void testJdbcTemplate2(){

String sql="SELECT count(1) FROM tb_account WHERE user_id=?";

Integer integer = jdbcTemplate.queryForObject(sql, Integer.class,2);

System.out.println("记录总数："+integer);

}

}

此处需要注意的是将jdbcTemplate类对象作为属性注入到测试类中，并通过@Resource注解完成属性的注入。并且具体的测试类只需要继承父类BaseTest即可完成对配置文件的加载及junit环境添加到Spring环境之中去的操作。

二、持久层账户模块操作（例）

此处使用Spring JDBC完成增删改查操作

（一）账户接口方法定义

1. 定义账户实体类

Account.java类

@Data

@AllArgsConstructor

@NoArgsConstructor

public class Account {

private Integer accountId;

private String accountName;

private String accountType;

private Double money;

private String remark;

private Date createTime;

private Date updateTime;

private Integer userId;

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;

}

}

2.定义账户的接口类

IAccountDao.java

/** * @author lambda * 添加、修改、删除、查询账户

* 1. 添加账户

* 添加账户记录，返回受影响的行数

* 添加账户记录，返回主键 *

* 批量添加账户记录，返回受影响的行数

* 2. 修改账户

* 修改账户记录，返回受影响的行数

* 批量修改账户记录，返回受影响的行数

*3.删除账户

* 删除账户记录，返回受影响的行数

*批量删除账户记录，返回受影响的行数

* 4. 查询账户

* 查询指定用户账户的总记录数

* 查询指定账户的账户详情，返回账户对象

* *多条件查询指定用户的账户列表，返回一个账户集合 *

* */public interface IAccountDao {

* /** * 添加账户记录，返回受影响的行数

* * @param account

* * @return

* */

* int addAccount(Account account);

* /**

* * 添加账户记录，返回主键

* * @param account

* * @return

* */

* int addAccountPrimaryKey(Account account);

* /**

* * 批量添加账户记录，返回受影响的行数

* * @param accounts

* * @return

* */

* int addAccountBatch(List accounts);

* /**

* * 查询指定用户账户的总记录数

* * @param userId

* * @return

* */

* int queryAccountCount(int userId);

* /**

* * 查询指定账户的账户详情，返回账户对象

* * @param accountId

* * @return

* */

* Account queryAccountByAccountId(int accountId);

* /**

* * 多条件查询指定用户的账户列表，返回一个账户集合

* * @param userId

* * @param accountName

* * @param accountType

* * @param createTime

* * @return

* */

* List queryAccountByParams(int userId,String accountName,String accountType,String createTime);

* /**

* * 修改账户记录，返回受影响的行数,传入整个账户对象

* * @param account

* * @return

* */

* int updateAccount(Account account);

* /**

* * 批量修改账户记录，返回受影响的行数

* * @param accounts

* * @return

* */

* int updateAccountBatch(List accounts);

* /**

* * 删除账户记录，返回受影响的行数

* * @param accountId

* * @return

* */

* int deleteAccount(int accountId);

* /**

* * 批量删除账户记录，返回受影响的行数

* * @param ids

* * @return

* */

* int deleteAccountBatch(int[] ids);}

3.定义接口的实现类

@Repository

public class AccountDaoImpl implements IAccountDao {

/**由于操作数据库需要使用Spring-JDBC，因此需要传入jdbcTemplate模板对象， * 并完成注入到当前类中*/

@Resource

private JdbcTemplate jdbcTemplate;

@Override

public int addAccount(Account account) {

return 0;

}

@Override

public int addAccountPrimaryKey(Account account) {

return 0;

}

@Override

public int addAccountBatch(List accounts) {

return 0;

}

@Override

public int queryAccountCount(int userId) {

return 0;

}

@Override

public Account queryAccountByAccountId(int accountId) {

return null;

}

@Override

public List queryAccountByParams(int userId, String accountName, String accountType, String createTime) {

return null;

}

@Override

public int updateAccount(Account account) {

return 0;

}

@Override

public int updateAccountBatch(List accounts) {

return 0;

}

@Override

public int deleteAccount(int accountId) {

return 0;

}

@Override

public int deleteAccountBatch(int[] ids) {

return 0;

}

}

由于操作数据库需要使用Spring-JDBC，因此需要传入jdbcTemplate模板对象

（二）、账户记录添加实现

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

1. 添加账户记录

添加账户记录返回首影响的行数

@Override

public int addAccount(Account account) {

String sql="INSERT INTO tb_account(account_name,account_type,money,remark,create_time" + ",update_time,user_id) VALUES(?,?,?,?,now(),now(),?)";

int update = jdbcTemplate.update(sql, account.getAccountName(), account.getAccountType(), account.getMoney(), account.getRemark(), account.getUserId());

return update;

}

@Test

public void addAccount(){

int i = accountDao.addAccount(new Account("账户3", "工商银行", 200.0, "奖金", 1));

if (i>0){

System.out.println("插入成功！");

}

}

jdbcTemplate.update方法需要传入对应的sql语句，并传递相应的参数。参数以可变参数的形式添加到对应的表中。

2.添加账户记录返回主键

/**

* 添加记录返回主键

* @param account

* @return

*/

@Override

public int addAccountPrimaryKey(Account account) {

String sql="INSERT INTO tb_account(account_name,account_type,money,remark,create_time" +",update_time,user_id)VALUES(?,?,?,?,now(),now(),?)";

//定义该对象，用于获取我们记录的主键

GeneratedKeyHolder keyHolder = new GeneratedKeyHolder();

//需要传入两个参数，一个是PreparedStatementCreator,一个是keyHolder

jdbcTemplate.update(con -> {

//此处需要利用lambda表达式去预编译sql语句，并设置返回主键(tatement.RETURN_GENERATED_KEYS)

PreparedStatement ps=con.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);

//执行完之后可以通过keyHolder获取主键

return keyHolder.getKey().intValue();

}

@Test

public void addAccountPrimaryKey(){

Account account = new Account("账户4", "中国银行", 300.0, "绩效奖", 4); int key = accountDao.addAccountPrimaryKey(account);

System.out.println("主键为："+key);

}

GeneratedKeyHolder keyHolder = new GeneratedKeyHolder();此处表示获取键值对象，后续可以用来获取主键 jdbcTemplate.update（PreparedStatementCreator pcs，KeyHolder keyHolder）此处表示执行update方法，并且传入的参数有经过处理的预处理语句（使用lambda表达式来进行设置sql语句的相关参数并返回预处理语句对象ps）和键对象最后通过keyHolder.getKey().intValue();来获取新添加的对象的主键值。

3.批量添加账户，返回受影响的行数

/**

* 批量添加账户，返回受影响的行数

* @param accounts

* @return

*/

@Override

public int addAccountBatch(List accounts) {

String sql="INSERT INTO tb_account(account_name,account_type,money,remark,create_time" +

",update_time,user_id)VALUES(?,?,?,?,now(),now(),?)";

//调用batchUpdate批量添加,需要传入sql语句和BatchPreparedStatementSetter pss对象

int rows= jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {

@Override

public void setValues(PreparedStatement ps, int i) throws SQLException {

//此处由于传入的是集合，所以需要通过i来获取指定的Account对象（会自动循环）

Account account=accounts.get(i);

//设置参数

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());

}

@Override

public int getBatchSize() {

//直接返回集合的大小，即受影响的行数

return accounts.size();

}

}).length;

//jdbcTemplate.batchUpdate返回的是数组，通过length属性可以获取数组的大小，即受影响的行数

return rows;

}

@Test

public void addAccountBatch(){

List accounts=new ArrayList<>();

accounts.add(new Account("账户5", "广东发展银行", 400.0, "出勤奖", 2));

accounts.add(new Account("账户6", "浦发银行", 600.0, "年终奖", 2));

int i = accountDao.addAccountBatch(accounts);

System.out.println("添加了"+i+"条记录");

}

jdbcTemplate.batchUpdate表示执行批量添加操作，主要参数有要执行的sql语句和BatchPreparedStatementSetter pss对象。由于需要传入BatchPreparedStatementSetter对象。所以new一个对象，并实现其中的两个方法setValues和getBatchSizesetValues是使用预处理语句来对相应的sql语句进行预处理，并且通过循环取出集合中每一个值进行相应的赋值操作。getBatchSize最终返回的是经过预处理的集合的大小。最终返回数组的大小。

（三）账户记录查询的实现

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

1. 查询用户的账户记录总数

@Override

public int queryAccountCount(int userId) {

//定义sql语句(其中的count中的括号可以填写*表示全部，可以添加1,表示第一个字段的总数，也就是总数)

String sql="SELECT COUNT(1) FROM tb_account WHERE user_id=?";

//调用查询方法(其中的参数依次表示为sql语句，返回的类型，以及参数值)

Integer integer = jdbcTemplate.queryForObject(sql, Integer.class, userId);

return integer;

}

@Test

public void queryAccountCount(){

int i = accountDao.queryAccountCount(1);

System.out.println("1号用户的账户一共有："+i+"条");

}

jdbcTemplate.queryForObject用来执行查询操作，参数为sql语句，返回值的类型，以及方法的参数值。最终将返回的结果返回即可获取指定用户的总账户数。

2.查询指定账户记录详情

/**

* 查询指定账户记录详情，返回账户对象

* @param accountId

* @return

*/

@Override

public Account queryAccountByAccountId(int accountId) {

String sql="SELECT * FROM tb_account WHERE account_id=?";

//调用查询对象的方法,此处方法的第二个参数是一个函数式接口对象，lambda表达式,返回account对象

Account account= jdbcTemplate.queryForObject(sql,(rs,rowNum)->{ //在内存中创建一个账户对象来设置相应的信息以便后续返回

Account acc=new Account();

acc.setAccountId(accountId);

acc.setAccountName(rs.getString("account_name"));

acc.setAccountType(rs.getString("account_type"));

acc.setMoney(rs.getDouble("money"));

acc.setRemark(rs.getString("remark"));

acc.setCreateTime(rs.getDate("create_time"));

acc.setUpdateTime(rs.getDate("update_time"));

acc.setUserId(rs.getInt("user_id"));

return acc;

},accountId);

return account;

}

@Test

public void queryAccountByAccountId(){

Account account = accountDao.queryAccountByAccountId(1);

System.out.println(account);

}

此处的queryForObject方法主要有3个参数，一个是sql，一个是RowMapper对象，一个是对应的可变参数RowMaper参数是一个函数式接口，可以使用lambda表达式，该接口中需要传入行集和行数，需要接收返回的Account（Account的各个信息由行集中获取并返回。）最终返回为一个Account对象

3. 多条件查询用户账户记录

@Override

public List queryAccountByParams(int userId, String accountName, String accountType, String createTime) {

//首先定义sql语句

String sql="SELECT * FROM tb_account WHERE user_id=?";

//定义一个参数集合，因为是多条件查询

List