五、Spring中的JdbcTemplate和事务控制

最新推荐文章于 2023-06-17 10:54:38 发布
最新推荐文章于 2023-06-17 10:54:38 发布
阅读量189 收藏
点赞数
分类专栏： Spring 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wssh1854/article/details/106333441
版权

目录

1 Spring中的JdbcTemplate

1.1 JdbcTemplate概述

它是Spring框架中提供的一个对象，是对原始Jdbc API对象的简单封装。Spring框架为我们提供了很多的操作模板类。

  1. 操作关系型数据的：JdbcTemplate、HibernateTemplate；
  2. 操作nosql数据库的：RedisTemplate；
  3. 操作消息队列的：JmsTemplate。

我们今天的主角在 spring-jdbc-5.0.2.RELEASE.jar 中，我们在导包的时候，除了要导入这个jar包外，还需要导入一个 spring-tx-5.0.2.RELEASE.jar（它是和事务相关的）。

1.2 JdbcTemplate对象的创建

我们可以参考它的源码，来一探究竟：

public JdbcTemplate() {
}

public JdbcTemplate(DataSource dataSource) {
	setDataSource(dataSource);
	afterPropertiesSet();
}

public JdbcTemplate(DataSource dataSource, Boolean lazyInit) {
	setDataSource(dataSource);
	setLazyInit(lazyInit);
	afterPropertiesSet();
}

除了默认构造函数之外，都需要提供一个数据源。既然有set方法，依据我们之前学过的依赖注入，我们可以在配置文件中配置这些对象。

1.3 Spring中配置数据源【会用】

1.3.1 环境搭建

在这里插入图片描述

1.3.2 编写Spring的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    	http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

1.3.3 配置数据源

我们之前已经接触过了两个数据源，C3P0和DBCP。要想使用这两数据源都需要导入对应的jar包。

1.3.3.1 配置C3P0数据源

导入 c3p0-0.9.2.1.jar 到工程的lib目录。在Spring的配置文件中配置：

<!-- 配置C3P0数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql:///spring_day02"></property>
    <property name="user" value="root"></property>
    <property name="password" value="1234"></property>
</bean>
1.3.3.2 配置DBCP数据源

导入 commons-dbcp.jar 、commons-pool.jar 到工程的lib目录。在Spring的配置文件中配置：

<!-- 配置DBCP数据源 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql:// /spring_day02"></property>
    <property name="username" value="root"></property>
    <property name="password" value="1234"></property>
</bean>
1.3.3.3 配置Spring内置数据源

Spring框架也提供了一个内置数据源，我们也可以使用Spring的内置数据源，它就在 spring-jdbc-5.0.2.REEASE.jar 包中：

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql:///spring_day02"></property>
    <property name="username" value="root"></property>
    <property name="password" value="1234"></property>
</bean>

1.3.4 将数据库连接的信息配置到属性文件中

  1. 定义属性文件：

    jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///spring_day02
jdbc.username=root
jdbc.password=123

  2. 引入外部的属性文件：

    1. 一种方式：
      <!-- 引入外部属性文件：-->
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location" value="classpath:jdbc.properties"/>
</bean>
    2. 另一种方式：
      <context:property-placeholder location="classpath:jdbc.properties"/>

1.4 JdbcTemplate的增删改查操作

1.4.1 前期准备

  1. 创建数据库：

    CREATE DATABASE spring_day02;
USE spring_day02;

  2. 创建表：

    CREATE TABLE account (
	id INT PRIMARY KEY auto_increment,
	NAME VARCHAR (40),
	money FLOAT
) CHARACTER SET utf8 COLLATE utf8_general_ci;

1.4.2 在Spring配置文件中配置JdbcTemplate

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    	http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 配置一个数据库的操作模板：JdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置数据源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql:///spring_day02"></property>
        <property name="username" value="root"></property>
        <property name="password" value="1234"></property>
    </bean>
</beans>

1.4.3 最基本使用

public class JdbcTemplateDemo2 {
	public static void main(String[] args) {
		//1. 获取Spring容器
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2.根据id获取bean对象
		JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
		//3.执行操作
		jt.execute("insert into account(name,money)values('eee',500)");
	}
}

1.4.4 保存操作

public class JdbcTemplateDemo3 {
	public static void main(String[] args) {
		//1. 获取Spring容器
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2.根据id获取bean对象
		JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
		//3.执行操作
		//保存
		jt.update("insert into account(name,money)values(?,?)","fff",5000);
	}
}

1.4.5 更新操作

public class JdbcTemplateDemo3 {
	public static void main(String[] args) {
		//1. 获取Spring容器 
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2.根据id获取bean对象
		JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
		//3.执行操作
		//修改
		jt.update("update account set money = money-? where id = ?",300,6);
	}
}

1.4.6 删除操作

public class JdbcTemplateDemo3 {
	public static void main(String[] args) {
		//1. 获取Spring容器
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2.根据id获取bean对象
		JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
		//3.执行操作
		//删除
		jt.update("delete from account where id = ?",6);
	}
}

1.4.7 查询所有操作

public class JdbcTemplateDemo3 {
	public static void main(String[] args) {
		//1. 获取Spring容器 
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2.根据id获取bean对象
		JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
		//3.执行操作
		//查询所有
		List<Account> accounts = jt.query("select * from account where money > ? ", new AccountRowMapper(), 500);
		for (Account o : accounts){
			System.out.println(o);
		}
	}
}

public class AccountRowMapper implements RowMapper<Account>{
	@Override
    public Account mapRow(ResultSet rs, int rowNum) throws SQLException {
		Account account = new Account();
		account.setId(rs.getint("id"));
		account.setName(rs.getString("name"));
		account.setMoney(rs.getfloat("money"));
		return account;
	}
}

1.4.8 查询一个操作

  1. 使用RowMapper的方式（常用的方式）：

    public class JdbcTemplateDemo3 {
	public static void main(String[] args) {
		//1. 获取Spring容器 
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2.根据id获取bean对象
		JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
		//3.执行操作
		//查询一个
		List<Account> as = jt.query("select * from account where id = ? ", new AccountRowMapper(), 55);
		System.out.println(as.isEmpty()?"没有结果":as.get(0));
	}
}

  2. 使用ResultSetExtractor的方式（不常用的方式）：

    public class JdbcTemplateDemo3 {
	public static void main(String[] args) {
		//1. 获取Spring容器 
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2.根据id获取bean对象
		JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
		//3.执行操作
		//查询一个
		Account account = jt.query("select * from account where id = ?", new AccountResultSetExtractor(),3);
		System.out.println(account);
	}
}

1.4.9 查询返回一行一列操作

public class JdbcTemplateDemo3 {
	public static void main(String[] args) {
		//1. 获取Spring容器 
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2.根据id获取bean对象
		JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
		//3.执行操作
		//查询返回一行一列：使用聚合函数，在不使用group by语句时，都是返回一行一列。最常用的就是分页中获取总记录条数
		Integer total = jt.queryForObject("select count(*) from account where money > ? ",Integer.class,500);
		System.out.println(total);
	}
}

1.5 在DAO中使用JdbcTemplate

1.5.1 准备实体类

/**
 * 账户的实体
 */
public class Account implements Serializable {
	private Integer id;
	private String name;
	private float money;
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public float getMoney() {
		return money;
	}
	public void setMoney(float money) {
		this.money = money;
	}
	
	@Override
    public String toString() {
		return "Account [id=" + id + ", name=" + name + ", money=" + money + "]";
	}
}

1.5.2 第一种方式：在DAO中定义JdbcTemplate

/**
 * 账户的接口
 */
public interface IAccountDao {
    /**
     * 根据id查询账户信息
     * @param id
     * @return
     */
    Account findAccountById(Integer id);

    /**
     * 根据名称查询账户信息
     * @return
     */
    Account findAccountByName(String name);

    /**
     * 更新账户信息
     * @param account
     */
    void updateAccount(Account account);
}

/**
 * 账户的持久层实现类
 * 此版本的dao，需要给dao注入JdbcTemplate
 */
public class AccountDaoImpl implements IAccountDao {
    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public Account findAccountById(Integer id) {
        List<Account> list = jdbcTemplate.query("select * from account where id = ? ", new AccountRowMapper(), id);
        return list.isEmpty() ? null : list.get(0);
    }

    @Override
    public Account findAccountByName(String name) {
        List<Account> list = jdbcTemplate.query("select * from account where name = ? ", new AccountRowMapper(), name);
        if (list.isEmpty()) {
            return null;
        }
        if (list.size() > 1) {
            throw new RuntimeException("结果集不唯一，不是只有一个账户对象");
        }
        return list.get(0);
    }

    @Override
    public void updateAccount(Account account) {
        jdbcTemplate.update("update account set money = ? where id = ? ", account.getMoney(), account.getId());
    }
}

配置文件：

<?xml version="### 1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    	http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 配置一个dao -->
    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
        <!-- 注入jdbcTemplate -->
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
    <!-- 配置一个数据库的操作模板：JdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置数据源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql:///spring_day04"></property>
        <property name="username" value="root"></property>
        <property name="password" value="1234"></property>
    </bean>
</beans>

思考：此种方式有什么问题吗？
答案：有个小问题。就是我们的DAO有很多时，每个DAO都有一些重复性的代码。下面就是重复代码：

private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
	this.jdbcTemplate = jdbcTemplate;
}

能不能把它抽取出来呢？请看下一小节。

1.5.3 第二种方式：让DAO继承JdbcDaoSupport

JdbcDaoSupport是Spring框架为我们提供的一个类，该类中定义了一个JdbcTemplate对象，我们可以直接获取使用，但是要想创建该对象，需要为其提供一个数据源，具体源码如下：

public abstract class JdbcDaoSupport extends DaoSupport {
	//定义对象
	private JdbcTemplate jdbcTemplate;
	//set方法注入数据源，判断是否注入了，注入了就创建JdbcTemplate
	public final void setDataSource(DataSource dataSource) {
		if (this.jdbcTemplate == null || dataSource != this.jdbcTemplate.getDataSource()) {
			//如果提供了数据源就创建JdbcTemplate
			this.jdbcTemplate = createJdbcTemplate(dataSource);
			initTemplateConfig();
		}
	}
	//使用数据源创建
	JdcbTemplate protected JdbcTemplate createJdbcTemplate(DataSource dataSource) {
		return new JdbcTemplate(dataSource);
	}
	//当然，我们也可以通过注入JdbcTemplate对象
	public final void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
		initTemplateConfig();
	}
	//使用getJdbcTmeplate方法获取操作模板对象
	public final JdbcTemplate getJdbcTemplate() {
		return this.jdbcTemplate;
	}
}

/**
 * 账户的接口
 */
public interface IAccountDao {
    /**
     * 根据id查询账户信息
     * @param id
     * @return
     */
    Account findAccountById(Integer id);

    /**
     * 根据名称查询账户信息
     * @return
     */
    Account findAccountByName(String name);

    /**
     * 更新账户信息
     * @param account
     */
    void updateAccount(Account account);
}

/**
 * 账户的持久层实现类
 * 此版本dao，只需要给它的父类注入一个数据源
 */
public class AccountDaoImpl2 extends JdbcDaoSupport implements IAccountDao {
    @Override
    public Account findAccountById(Integer id) {
        //getJdbcTemplate()方法是从父类上继承下来的。
        List<Account> list = getJdbcTemplate().query("select * from account where id = ? ", new AccountRowMapper(), id);
        return list.isEmpty() ? null : list.get(0);
    }

    @Override
    public Account findAccountByName(String name) {
        //getJdbcTemplate()方法是从父类上继承下来的。
        List<Account> list = getJdbcTemplate().query("select * from account where name = ? ", new AccountRowMapper(), name);
        if (list.isEmpty()) {
            return null;
        }
        if (list.size() > 1) {
            throw new RuntimeException("结果集不唯一，不是只有一个账户对象");
        }
        return list.get(0);
    }

    @Override
    public void updateAccount(Account account) {
        //getJdbcTemplate()方法是从父类上继承下来的。
        getJdbcTemplate().update("update account set money = ? where id = ? ", account.getMoney(), account.getId());
    }
}

配置文件：

<?xml version="### 1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    	http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 配置dao2 -->
    <bean id="accountDao2" class="com.itheima.dao.impl.AccountDaoImpl2">
        <!-- 注入dataSource -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置数据源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql:///spring_day04"></property>
        <property name="username" value="root"></property>
        <property name="password" value="1234"></property>
    </bean>
</beans>

思考：两版DAO有什么区别呢？
答案：

  1. 第一种在DAO类中定义JdbcTemplate的方式，适用于所有配置方式（XML和注解都可以）；
  2. 第二种让DAO继承JdbcDaoSupport的方式，只能用于基于XML的方式，注解用不了。

2 Spring中的事务控制

2.1 Spring事务控制我们要明确的

  1. JavaEE体系进行分层开发，事务处理位于业务层，Spring提供了分层设计业务层的事务处理解决方案；
  2. Spring框架为我们提供了一组事务控制的接口。具体在后面的第二小节介绍。这组接口是在 spring-tx-5.0.2.RELEASE.jar 中；
  3. Spring的事务控制都是基于AOP的，它既可以使用编程的方式实现，也可以使用配置的方式实现。我们学习的重点是使用配置的方式实现。

2.2 Spring中事务控制的API介绍

2.2.1 PlatformTransactionManager

此接口是Spring的事务管理器，它里面提供了我们常用的操作事务的方法，如下：

  1. TransactionStatus getTransaction(TransactionDefinition definition) ：获得事务状态信息；
  2. void commit(TransactionStatus status) ：提交事务；
  3. void rollback(TransactionStatus status) ：回滚事务。

我们在开发中都是使用它的实现类，如下：

  1. DataSourceTransactionManager ：用于Spring JDBC以及MyBatis框架的事务代理；
  2. HibernateTransactionManager ：用于Hibernate框架事务代理；
  3. JpaTransactionManager ：用于JPA框架的事务代理；
  4. JdoTransactionManager ：用于JDO框架的事务代码；
  5. JtaTransactionManager ：用于JTA事务代理，一个事务跨多资源必须要使用。

真正管理事务的对象：

  1. org.springframework.jdbc.datasource.DataSourceTransactionManager ：使用Spring JDBC或MyBatis进行持久化数据时使用；
  2. org.springframework.orm.hibernate5.HibernateTransactionManager ：使用Hibernate版本进行持久化数据时使用。

2.2.2 TransactionDefinition

它是事务的定义信息对象，里面有如下方法：

  1. int getPropagationBehavior() ：获取事务传播行为；
  2. int getIsolationLevel() ：获取事务隔离级别；
  3. int getTimeout() ：获取事务超时时间；
  4. boolean isReadOnly() ：获取事务是否只读；
  5. String getName() ：获取事务对象名称。

读写型事务：增加、删除、修改、开启事务；
只读型事务：执行查询时，也会开启事务。

2.2.2.1 事务的隔离级别

事务隔离级别反映事务提交并发访问时的处理态度：

  1. ISOLATION_DEFAULT ：默认级别，归属下列某一种；
  2. ISOLATION_READ_UNCOMMITTED ：可以读取未提交数据；
  3. ISOLATION_READ_COMMITTED ：只能读取已提交数据，解决脏读问题(Oracle默认级别)；
  4. ISOLATION_REPEATABLE_READ ：是否读取其他事务提交修改后的数据，解决不可重复读问题（MySQL默认级别）；
  5. ISOLATION_SERIALIZABLE ：是否读取其他事务提交添加后的数据，解决幻影读问题。
2.2.2.2 事务的传播行为
  1. REQUIRED ：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值）；
  2. SUPPORTS ：支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务）；
  3. MANDATORY ：使用当前的事务，如果当前没有事务，就抛出异常；
  4. REQUERS_NEW ：新建事务，如果当前在事务中，把当前事务挂起；
  5. NOT_SUPPORTED ：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起；
  6. NEVER ：以非事务方式运行，如果当前存在事务，抛出异常；
  7. NESTED ：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行REQUIRED类似的操作。
2.2.2.3 超时时间

默认值是-1，没有超时限制。如果有，以秒为单位进行设置。

2.2.2.4 是否是只读事务

建议查询时设置为只读。

2.2.3 TransactionStatus

此接口提供的是事务具体的运行状态，描述了某个时间点上事务对象的状态信息，包含有6个具体的操作：

  1. void flush() ：刷新事务；
  2. boolean hasSavepoint() ：获取是否是否存在存储点；
  3. boolean isCompleted() ：获取事务是否完成；
  4. boolean isNewTransaction() ：获取事务是否为新的事务；
  5. boolean isRollbackOnly() ：获取事务是否回滚；
  6. void setRollbackOnly() ：设置事务回滚。

2.3 基于XML的声明式事务控制（配置方式）【掌握】

2.3.1 环境搭建

2.3.1.1 第一步：拷贝必要的jar包到工程的lib目录

在这里插入图片描述

2.3.1.2 第二步：创建Spring的配置文件并导入约束

此处需要导入aop和tx两个名称空间：

<?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" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    	http://www.springframework.org/schema/beans/spring-beans.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">
</beans>
2.3.1.3 第三步：准备数据库表和实体类

  1. 创建数据库：

    CREATE DATABASE spring_day04;
USE spring_day04;

  2. 创建表：

    CREATE TABLE account(
	id INT PRIMARY KEY auto_increment,
	name VARCHAR(40),
	money FLOAT
) CHARACTER SET utf8 COLLATE utf8_general_ci;

  3. 账户的实体类：

    public class Account implements Serializable {
	private Integer id;
	private String name;
	private float money;
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public float getMoney() {
		return money;
	}
	public void setMoney(float money) {
		this.money = money;
	}
	
	@Override
    public String toString() {
		return "Account [id=" + id + ", name=" + name + ", money=" + money + "]";
	}
}
2.3.1.4 第四步：编写业务层接口和实现类
  1. 账户的业务层接口：
    public interface IAccountService {
	/** 
  	 * 根据id查询账户信息 
 	 * @param id 
 	 * @return 
 	 */
	Account findAccountById(Integer id); //查

	/**
  	 * 转账 
  	 * @param sourceName 转出账户名称 
  	 * @param targeName 转入账户名称 
  	 * @param money 转账金额 
  	 */
	void transfer(String sourceName,String targeName,float money); //增删改
}
  2. 账户的业务层实现类：
    public class AccountServiceImpl implements IAccountService {
	private IAccountDao accountDao;
	public void setAccountDao(IAccountDao accountDao) {
		this.accountDao = accountDao;
	}
	
	@Override
	public Account findAccountById(Integer id) {
		return accountDao.findAccountById(id);
	}
	
	@Override
    public void transfer(String sourceName, String targeName, float money) {
		//1.根据名称查询两个账户
		Account source = accountDao.findAccountByName(sourceName);
		Account target = accountDao.findAccountByName(targeName);
		//2.修改两个账户的金额
		source.setMoney(source.getMoney()-money); //转出账户减钱
		target.setMoney(target.getMoney()+money); //转入账户加钱
		//3.更新两个账户
		accountDao.updateAccount(source);
		int i=1/0;
		accountDao.updateAccount(target);
	}
}
2.3.1.5 第五步：编写Dao接口和实现类
  1. 账户的持久层接口：
    public interface IAccountDao {
	/** 
	 * 根据id查询账户信息
	 * @param id 
	 * @return 
	 */
	Account findAccountById(Integer id);
	
	/** 
	 * 根据名称查询账户信息
  	 * @return
	 */
	Account findAccountByName(String name);
	
	/**
  	 * 更新账户信息
  	 * @param account
  	 */
	void updateAccount(Account account);
}
  2. 账户的持久层实现类：此版本dao，只需要给它的父类注入一个数据源。
    public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {
	
	@Override
	public Account findAccountById(Integer id) {
		List<Account> list = getJdbcTemplate().query("select * from account where id = ? ",new AccountRowMapper(),id);
		return list.isEmpty()?null:list.get(0);
	}
	
	@Override
	public Account findAccountByName(String name) {
		List<Account> list = getJdbcTemplate().query("select * from account where name = ?",new AccountRowMapper(),name);
		if(list.isEmpty()){
			return null;
		}
		if(list.size()>1){
			throw new RuntimeException("结果集不唯一，不是只有一个账户对象");
		}
		return list.get(0);
	}
	
	@Override
	public void updateAccount(Account account) {
		getJdbcTemplate().update("update account set money = ? where id = ?",account.getMoney(),account.getId());
	}
}
  3. 账户的封装类RowMapper的实现类：
    public class AccountRowMapper implements RowMapper<Account> {
	
	@Override
	public Account mapRow(ResultSet rs, int rowNum) throws SQLException {
		Account account = new Account();
		account.setId(rs.getint("id"));
		account.setName(rs.getString("name"));
		account.setMoney(rs.getfloat("money"));
		return account;
	}
}
2.3.1.6 第六步：在配置文件中配置业务层和持久层对
<!-- 配置service -->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
    <property name="accountDao" ref="accountDao"></property>
</bean>

<!-- 配置dao -->
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
    <!-- 注入dataSource -->
    <property name="dataSource" ref="dataSource"></property>
</bean>

<!-- 配置数据源 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql:///spring_day04"></property>
    <property name="username" value="root"></property>
    <property name="password" value="1234"></property>
</bean>

2.3.2 配置步骤

2.3.2.1 第一步：配置事务管理器
<!-- 配置一个事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!-- 注入DataSource -->
    <property name="dataSource" ref="dataSource"></property>
</bean>
2.3.2.2 第二步：配置事务的通知引用事务管理器
<!-- 事务的配置 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
</tx:advice>
2.3.2.3 第三步：配置事务的属性
<!--在tx:advice标签内部 配置事务的属性 -->
<tx:attributes>
    <!-- 指定方法名称：是业务核心方法 -->
    <tx:method name="*" read-only="false" propagation="REQUIRED"/>
    <tx:method name="find*" read-only="true" propagation="SUPPORTS"/>
</tx:attributes>
  1. read-only ：是否是只读事务。默认false，不只读；
  2. isolation ：指定事务的隔离级别。默认值是使用数据库的默认隔离级别；
  3. propagation ：指定事务的传播行为；
  4. timeout ：指定超时时间。默认值为：-1。永不超时；
  5. rollback-for ：用于指定一个异常，当执行产生该异常时，事务回滚。产生其他异常，事务不回滚。没有默认值，任何异常都回滚；
  6. no-rollback-for ：用于指定一个异常，当产生该异常时，事务不回滚，产生其他异常时，事务回滚。没有默认值，任何异常都回滚。
2.3.2.4 第四步：配置AOP切入点表达式
<!-- 配置aop -->
<aop:config>
    <!-- 配置切入点表达式 -->
    <aop:pointcut expression="execution(* com.itheima.service.impl.*.*(..))" id="pt1"/>
</aop:config>
2.3.2.5 第五步：配置切入点表达式和事务通知的对应关系
<!-- 在aop:config标签内部：建立事务的通知和切入点表达式的关系 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"/>

2.4 基于注解的配置方式

2.4.1 环境搭建

2.4.1.1 第一步：拷贝必备的jar包到工程的lib目录

在这里插入图片描述

2.4.1.2 第二步：创建Spring的配置文件导入约束并配置扫描的包
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation=" http://www.springframework.org/schema/beans 
    	http://www.springframework.org/schema/beans/spring-beans.xsd 
    	http://www.springframework.org/schema/aop 
    	http://www.springframework.org/schema/aop/spring-aop.xsd 
    	http://www.springframework.org/schema/tx 
    	http://www.springframework.org/schema/tx/spring-tx.xsd 
    	http://www.springframework.org/schema/context 
    	http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 配置spring创建容器时要扫描的包 -->
    <context:component-scan base-package="com.itheima"></context:component-scan>
    <!-- 配置JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置spring提供的内置数据源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/spring_day02"></property>
        <property name="username" value="root"></property>
        <property name="password" value="1234"></property>
    </bean>
</beans>
2.4.1.3 第三步：创建数据库表和实体类

和基于xml的配置相同。

2.4.1.4 第四步：创建业务层接口和实现类并使用注解让Spring管理
/** 
 * 账户的业务层实现类
 */
@Service("accountService")
public class AccountServiceImpl implements IAccountService {
	
	@Autowired
    private IAccountDao accountDao;
	
  	//其余代码和基于XML的配置相同
}
2.4.1.5 第五步：创建Dao接口和实现类并使用注解让Spring管理
/**
 * 账户的持久层实现类
 */
@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {

	@Autowired
	private JdbcTemplate jdbcTemplate;

	//其余代码和基于XML的配置相同
}

2.4.2 配置步骤

2.4.2.1 第一步：配置事务管理器并注入数据源
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
</bean>
2.4.2.2 第二步：在业务层使用@Transactional注解
@Service("accountService")
@Transactional(readOnly=true,propagation=Propagation.SUPPORTS)
public class AccountServiceImpl implements IAccountService {
	
	@Autowired
	private IAccountDao accountDao;
	
	@Override
	public Account findAccountById(Integer id) {
		return accountDao.findAccountById(id);
	}
	
	@Override
	@Transactional(readOnly=false,propagation=Propagation.REQUIRED) 
	public void transfer(String sourceName, String targeName, float money) {
		//1.根据名称查询两个账户
		Account source = accountDao.findAccountByName(sourceName);
		Account target = accountDao.findAccountByName(targeName);
		//2.修改两个账户的金额
		source.setMoney(source.getMoney()-money); //转出账户减钱
		target.setMoney(target.getMoney()+money); //转入账户加钱
		//3.更新两个账户
		accountDao.updateAccount(source);
		//int i=1/0;
		accountDao.updateAccount(target);
	}
}

该注解的属性和xml中的属性含义一致。该注解可以出现在接口上、类上和方法上：

  1. 出现接口上：表示该接口的所有实现类都有事务支持；
  2. 出现在类上：表示类中所有方法有事务支持；
  3. 出现在方法上：表示方法有事务支持。

以上三个位置的优先级：方法>类>接口。

2.4.2.3 第三步：在配置文件中开启spring对注解事务的支持
<!-- 开启spring对注解事务的支持 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

2.4.3 不使用xml的配置方式

@Configuration
@EnableTransactionManagement
public class SpringTxConfiguration {
	//里面配置数据源，配置JdbcTemplate,配置事务管理器。在之前的步骤已经写过了。
}
`Ernest
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring+JdbcTemplate进行事务管理
zeo_123的博客
05-11 1083
事务添加到 JavaEE 三层结构里面Service层（业务逻辑层）在Spring进行事务管理操作有两种方式：编程式事务管理和声明式事务管理（使用）声明式事务管理（1）基于注解方式（使用）（2）基于xml配置文件方式在Spring进行声明式事务管理，底层使用AOP原理Spring事务管理API。提供一个接口PlatformTransactionManager，代表事务管理器，这个接口针对不同的框架提供不同的实现类。
Spring JdbcTemplate & Spring 事务操作
str125757855的博客
11-21 967
一、JdbcTemplate 什么是 JdbcTemplate Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作 使用JdbcTemplate准备工作 （1）引入相关jar 包 （2）在 spring 配置文件配置数据库连接池 <!-- 数据库连接池 --> <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close
JdbcTemplate的事务控制.docx
07-26
JdbcTemplate是spring-jdbc提供的数据库核心操作类，那对JdbcTemplate进行事务控制呢？
66-Spring的JDBCTemplate与声明式事务
qq_59609098的博客
04-23 1127
核心方法： 举个栗子： 查询数据库所有账户信息到Account实体中： Spring整合JdbcTemplate ： 需求 基于Spring的xml配置实现账户的CRUD案例 步骤分析： 创建java项目，导入坐标 ： 编写Account实体类： 编写AccountDao接口和实现类： 编写AccountService接口和实现类： 编写spring核心配置文件 ： 编写测试代码： 实现转账案例： 步骤分析： 创建java项目，导入坐标 ： 编写Account实体类： 编写Ac
Spring5笔记2 - JDBC Template操作数据库、事务操作
m0_50736744的博客
08-06 438
（1）Spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库操作 数据库中的表 1、批量操作：操作表里面多条记录 2、JdbcTemplate实现批量添加操作 注意： 原子性（Atomicity）：事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成，要么完全不起作用。(不可分割，要么都成功，要么都失败)一致性（Consistency）：一旦事务完成（不管成功还是失败），系统必须确保它所建模的业务处于一致的状态，而不会是部分完成部分失败。在现实中
spring实现jdbctemplate添加事务支持示例
10-26
主要介绍了spring实现jdbctemplate添加事务支持示例，重写JdbcTemplate增加beginTranstaion,commit,rollback方法,需要的朋友可以参考下
配制Spring事务和JdbcTemplate使用
10-08
配制Spring事务和JdbcTemplate使用 配制Spring事务和JdbcTemplate使用
4.Spring中的JdbcTemplate,Spring中的的事务，
11-15
Spring中的JdbcTemplate,Spring中的的事务.。。。。。。。
详解spring boot中使用JdbcTemplate
08-30
JdbcTemplate 是在JDBC API基础上提供了更抽象的封装，并提供了基于方法注解的事务管理... 通过使用SpringBoot自动配置功能并代替我们自动配置beans，下面给大家介绍spring boot中使用JdbcTemplate相关知识，一起看看吧
Spring(六)JdbcTemplate，事务控制
weixin_50204197的博客
03-03 1623
JdbcTemplate，spring事务，Transaction
JdbcTemplate的事务控制
热门推荐
天天向上
07-12 2万+
前言 JdbcTemplate是spring-jdbc提供的数据库核心操作类，那对JdbcTemplate进行事务控制呢？ 我的环境：spring-boot-2.1.3，druid-1.1.3。 原生Jdbc的事务控制 即，批处理+自动提交的控制方式， public static void demo(String[] args) throws SQLException, ClassNo...
jdbctemplate事务控制_spring事务管理
weixin_39894473的博客
11-26 229
什么是事务？事务是一个不可分割操作序列，也是数据库并发控制的基本单位，其执行的结果必须使数据库从一种一致性状态变到另一种一致性状态。个人理解：这个好比一颗导弹，落到一群人中间，如果不炸大家都没事，一炸大家都必死。(要么全部成功，要么全部失败)事务的特性(ACID)：原子性(atomicity)：是事务最小单位，不可再分割，对其修改要么全部执行(成功)，要么全部不执行(失败)。一致性(co...
Spring6 JdbcTemplate和事务
最新发布
Lifelong learning
06-17 3778
数据库事务( transaction)是访问并可能操作各种数据项的一个数据库操作序列，这些操作要么全部执行,要么全部不执行，是一个不可分割的工作单位。事务由事务开始与事务结束之间执行的全部数据库操作组成。
Spring入门笔记（三）之JdbcTemplate和事务管理
qq_32971807的博客
10-24 7079
Craig Walls所著《Spring实战》一书里说，Spring的两大关键字：DI（依赖注入），AOP（面向切面编程）。在之前的两篇博客里，我们已经学习了spring的核心，DI和AOP。大头我们已经学完了，这篇博客主要是介绍剩下的一些知识点，如JdbcTemplate和事务管理等。 1 JdbcTemplate spring 提供用于操作JDBC工具类，类似：DBUtils。
SpringBoot系列: JdbcTemplate 事务控制
weixin_34132768的博客
10-26 651
============================Spring JdbcTemplate 事务控制============================之前使用 JDBC API 操作, 经常用到的对象有: connection 和 preparedStatement. dbConnection.setAutoCommit(false); //transaction block s...
spring学习-JdbcTemplate简单操作和事务控制
林北
06-18 6570
JdbcTemplate JdbcTemplate是spring对JDBC操作的进一步封装，下面就通过简单的CRUD来了解JdbcTemplate如何操作，连接池直接用的spring内置的连接池DriverManagerDataSource 首先配置JdbcTemplate和数据源 <bean id="jdbcTemplate" class="org.springframework....
spring中的JdbcTemlate以及Spring事务控制
OneFine的技术博客
02-29 411
spring中的JdbcTemlate以及Spring事务控制
Spring框架 - 事务控制（四）＞＞ JdbcTemplate基本使用
Fate的博客
01-28 105
JdbcTemplate基本使用 1.JdbcTemplate概述(了解) jdbcTemplate是spring框架中提供的一个对象，是对原始繁琐的Jdbc API对象的简单封装。spring框架为我们提供了很多的操作模板类。例如：操作关系型数据的JdbcTemplate和HibernateTemplate，操作nosql数据库的RedisTemplate，操作消息队列的JmsTemplate等等。 通过jdbcTemplate对象中的方法，我们可以直接执行sql语句，返回数据或封装数据。 2.JdbcT
Spring之JdbcTemplate 的事务控制 （编程式）基于XML和注解
运算符重载之String
08-09 279
声明式事务控制1. 编程式事务控制相关对象1.1 PlatformTransactionManager1.2 TransactionDefinition2 编程式事务控制2.1 事务隔离级别2.2 事务传播行为2.3 TransactionStatus2.4 知识要点3 基于 XML 的声明式事务控制3.1 什么是声明式事务控制3.2 声明式事务控制的实现3.3 切点方法的事务参数的配置3.4 知识要点4 基于注解的声明式事务控制4.1 使用注解配置声明式事务控制4.2 注解配置声明式事务控制解析4.3 知
jdbctemplate 事务_Spring编程式和声明式事务实例讲解
05-17
在 Spring 中，我们可以通过编程式事务和声明式事务来处理数据库事务。下面我来分别介绍一下这两种事务的实现。 ## 编程式事务 编程式事务是通过代码实现事务控制，需要手动创建和提交事务。Spring 提供了一个名为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值