Spring的数据库编程

最新推荐文章于 2023-05-17 11:57:37 发布
最新推荐文章于 2023-05-17 11:57:37 发布
阅读量521 收藏 2
点赞数 2
分类专栏： Spring学习 文章标签： 数据库 spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53217531/article/details/130339993
版权

文章目录

章节概述

​ 数据库用于处理持久化业务产生的数据，应用程序在运行过程中经常要操作数据库。一般情况下，数据库的操作由持久层来实现。作为扩展性较强的一站式开发框架，Spring也提供了持久层Spring JDBC功能，Spring JDBC可以管理数据库连接资源，简化传统JDBC的操作，进而提升程序数据库操作的效率。本章将对Spring JDBC相关知识进行详细讲解。

Spring JDBC

JDBCTemplate作用

​ 针对数据库操作，Spring框架提供了JdbcTemplate类，JdbcTemplate是一个模板类，Spring JDBC中的更高层次的抽象类均在JdbcTemplate模板类的基础上创建。

JdbcTemplate类提供了操作数据库的基本方法，包括添加、删除、查询和更新。在操作数据库时，JdbcTemplate类简化了传统JDBC中的复杂步骤，这可以让开发人员将更多精力投入到业务逻辑中。

抽象类JdbcAccessor的属性

​ JdbcTemplate类继承自抽象类JdbcAccessor，同时实现了JdbcTemplate接口。抽象类JdbcAccessor提供了一些访问数据库时使用的公共属性，具体如下：

•DataSource：DataSource主要功能是获取数据库连接。在具体的数据操作中，它还提供对数据库连接的缓冲池和分布式事务的支持。

•SQLExceptionTranslator：SQLExceptionTranslator是一个接口，它负责对SQLException异常进行转译工作。

Spring JDBC中的4个包说明
包名说明
core（核心包）包含了JDBC的核心功能,包括JdbcTemplate类、SimpleJdbcInsert类、SimpleJdbcCall类以及NamedParameterJdbcTemplate类。
dataSource（数据源包）包含访问数据源的实用工具类,它有多种数据源的实现,可以在Java EE容器外部测试JDBC代码。
object（对象包）以面向对象的方式访问数据库,它可以执行查询、修改和更新操作并将返回结果作为业务对象，并且在数据表的列和业务对象的属性之间映射查询结果。
support（支持包）包含了core和object包的支持类，如提供异常转换功能的SQLException类。

Spring对数据库的操作都封装在了core、dataSource、object和support这4个包中，想要使用Spring JDBC，就需要对这些包进行配置。

在Spring中，JDBC的配置是在配置文件applicationContext.xml中完成的，包括配置数据源、配置JDBC模板和配置注入类。

<!-- 1.配置数据源 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
     <!-- 数据库驱动 -->
     <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
     <!-- 连接数据库url -->
     <property name="url" value="jdbc:mysql://localhost:3306/spring"/>
     <property name="username" value="root"/><!-- 连接数据库用户名 -->
     <property name="password" value="root"/><!-- 连接数据库密码 -->
</bean>
<!-- 2.配置JDBC模板 -->
<bean id="JdbcTemplate"   class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
</bean>
<!-- 3.配置注入类 -->
<bean id="xxx" class="Xxx">	<property name="JdbcTemplate" ref="JdbcTemplate"/></bean>
dataSource配置4个属性的含义
属性名含义
driverClassName所使用的驱动名称,对应驱动JAR包中的Driver类
url数据源地址
username访问数据库的用户名
password访问数据库的密码
dataSource属性值的设定要求

​ 在dataSource的4个属性中，需要根据数据库类型或者系统配置设置相应的属性值。例如，如果数据库类型不同，需要更改驱动名称；如果数据库不在本地，则需要将地址中的localhost替换成相应的主机IP；默认情况下，数据库端口号可以省略，但如果修改过MySQL数据库的端口号，则需要加上修改后的端口号。此外，连接数据库的用户名和密码需要与数据库创建时设置的用户名和密码保持一致。

JDBCTemplate的常用方法

excute()方法

execute()方法用于执行SQL语句，其语法格式如下：

jdTemplate.execute("SQL 语句");

以创建数据表的SQL语句为例，来演示excute()方法的使用：

  1. 创建数据库：在MySQL中，创建一个名为spring的数据库。

  2. 创建项目并引入依赖：在IDEA中创建一个名为chapter09的Maven项目，然后在pom.xml文件中加载使用到的Spring 基础包、Spring依赖包、MySQL数据库的驱动JAR包、Spring JDBC的JAR包和Spring事务处理的JAR包。

    <!– 这里只展示了其中一个JAR包-->
<!-- MySQL数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
            <scope>runtime</scope>
        </dependency>

  3. 编写配置文件：在chapter09项目的src/main/resources目录下，创建配置文件applicationContext.xml，在该文件中配置数据源Bean和JDBC模板Bean，并将数据源注入到JDBC模板中。

    <!-- 1. 配置数据源 -->
<bean id="dataSource" class= "org.springframework.jdbc.datasource.DriverManagerDataSource">
	<property name="driverClassName" value="com.mysql.jdbc.Driver" />
	<property name="url" value="jdbc:mysql://localhost/spring" />
	<property name="username" value="root" />
	<property name="password" value="root" /></bean>
<!-- 2. 配置 JDBC 模板 -->
<bean id="jdbcTemplate" 	   class="org.springframework.jdbc.core.JdbcTemplate">
	<property name="dataSource" ref="dataSource" /></bean>

  4. 编写测试类：创建测试类TestJdbcTemplate，在该类的main()方法中获取JdbcTemplate实例，然后调用execute()方法执行创建数据表的SQL语句。

    public class TestJdbcTemplate {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new
            ClassPathXmlApplicationContext("applicationContext.xml");
        JdbcTemplate jdTemplate =
                (JdbcTemplate) applicationContext.getBean("jdbcTemplate");
        jdTemplate.execute("create table account(" +
                "id int primary key auto_increment," +
                “username varchar(50)," + 	"balance double)");
        System.out.println("账户表account创建成功！");}
}

  5. 查看运行结果：在IDEA中启动TestJdbcTemplate类，再次查询spring数据库。

update()方法

JdbcTemplate类中常用的update()方法 ：

方法说明
int update(String sql)该方法是最简单的update()方法重载形式,它直接执行传入的SQL语句,并返回受影响的行数。
int update(PreparedStatementCreator psc)该方法执行参数psc返回的语句,然后返回受影响的行数。
int update(String sql, PreparedStatementSetter pss)该方法通过参数pss设置SQL语句中的参数,并返回受影响的行数。
int update(String sql,Object… args)该方法可以为SQL语句设置多个参数,这些参数保存在参数args中,使用Object…设置SQL语句中的参数,要求参数不能为NULL,并返回受影响的行数。

演示update()方法的使用，该案例要求添加、更新、删除用户账户。案例具体实现步骤如下所示。

  1. 编写实体类：创建Account类，在该类中定义属性，以及其对应的getter/setter方法。

    public class Account {
       private Integer id;       	               // 账户id
       private String username; 	// 用户名
       private Double balance;  	// 账户余额
       // 省略gettter/setter方法
       public String toString() {
	return "Account [id=" + id + ", "
	+ "username=" + username + ", balance=" + balance + "]";}
}

  2. 编写Dao层接口：创建接口AccountDao，并在接口中定义添加、更新和删除账户的方法。

    public interface AccountDao {
	// 添加
	public int addAccount(Account account);
	// 更新
	public int updateAccount(Account account);
	// 删除
	public int deleteAccount(int id);
}

  3. 实现Dao层接口：创建AccountDao接口的实现类AccountDaoImpl，并在类中实现添加、更新和删除账户的方法。

    public class AccountDaoImpl implements AccountDao {
      // 定义JdbcTemplate属性，此处省略setter方法
      private JdbcTemplate jdbcTemplate;
      // 这里只展示（添加账户）的操作
      public int addAccount(Account account) {
            String sql = "insert into account(username,balance) value(?,?)";
            Object[] obj = new Object[] {// 定义数组来存放SQL语句中的参数
                  account.getUsername(), account.getBalance() 	};
	// 执行添加操作，返回的是受SQL语句影响的记录条数
            return this.jdbcTemplate.update(sql, obj);}
}

  4. 编写配置文件：在applicationContext.xml中，定义一个id为accountDao的Bean，用于将jdbcTemplate注入到accountDao实例中。

    <!--定义id为accountDao的Bean-->
<bean id="accountDao" class="com.itheima.AccountDaoImpl">
          <!-- 将jdbcTemplate注入到accountDao实例中 -->
          <property name="jdbcTemplate" ref="jdbcTemplate" />
</bean>

  5. 测试添加功能：创建测试类TestAddAccount，该类主要用于添加用户账户信息。

    public class TestAddAcount {
    public static void main(String[] args) {
        ApplicationContext applicationContext =new 
            ClassPathXmlApplicationContext("applicationContext.xml");
        AccountDao accountDao =
                (AccountDao) applicationContext.getBean("accountDao");
        Account account = new Account();
        account.setUsername("tom");	account.setBalance(1000.00);
        int num = accountDao.addAccount(account);
        if (num > 0) { System.out.println("成功插入了" + num + "条数据！");
        } else { System.out.println("插入操作执行失败！"); }
}}

  6. 查看执行第5步后的运行结果：在IDEA中启动TestAddAccount类，控制台会输出结果。此时再次查询spring数据库中的account表。

  7. 测试更新功能：执行完插入操作后，接下来调用JdbcTemplate类的update()方法执行更新操作。

    public class TestUpdateAccount {
    public static void main(String[] args) {
        ApplicationContext applicationContext =new 
            ClassPathXmlApplicationContext("applicationContext.xml");
        AccountDao accountDao =
                (AccountDao) applicationContext.getBean("accountDao");
        Account account = new Account();
        account.setId(1);	account.setUsername("tom");
        account.setBalance(2000.00);
        int num = accountDao.updateAccount(account);
        if (num > 0) {System.out.println("成功修改了" + num + "条数据！");
        } else {System.out.println("修改操作执行失败！");}	}}

  8. 查看执行第7步后的运行结果：在IDEA中启动TestUpdateAccount类，控制台会输出结果。此时再次查询spring数据库中的account表。

  9. 测试删除功能：创建测试类TestDeleteAccount，该类主要用于测试删除用户账户信息。

    public class TestDeleteAccount {
    public static void main(String[] args) {
        // 加载配置文件
        ApplicationContext applicationContext =new 
            ClassPathXmlApplicationContext("applicationContext.xml");
        // 获取AccountDao实例
        AccountDao accountDao =
                (AccountDao) applicationContext.getBean("accountDao");
        // 执行deleteAccount()方法，并获取返回结果
        int num = accountDao.deleteAccount(1);
        // 输出语句省略
}}

  10. 查看执行第9步后的运行结果：在IDEA中启动TestDeleteAccount类，控制台会输出结果。此时再次查询spring数据库中的account表。

query()方法

JdbcTemplate类中常用的查询方法

方法说明
List query(String sql, RowMapper rowMapper)执行String类型参数提供的SQL语句,并通过参数rowMapper返回一个List类型的结果。
List query(String sql, PreparedStatementSetter pss, RowMapper rowMapper)根据String类型参数提供的SQL语句创建PreparedStatement对象,通过参数rowMapper将结果返回到List中。
List query(String sql,Object[] args, RowMapper rowMapper)使用Object[]的值来设置SQL语句中的参数值,rowMapper是个回调方法,直接返回List类型的数据。
queryForObject(String sql,RowMapper rowMapper,Object… args)将args参数绑定到SQL语句中,并通过参数rowMapper返回一个Object类型的单行记录。
queryForList(String sql,Object[] args, class elementType)该方法可以返回多行数据的结果,但必须返回列表,args参数是sql语句中的参数,elementType参数返回的是List数据类型。

通过一个具体的案例演示query()方法的使用：

  1. 插入数据：向数据表account中插入几条数据。

    insert into `account`(`id`,`username`,`balance`) 
values
 (1,'zhangsan',100),(3,'lisi',500),(4,'wangwu',300);

  2. 编写查询方法：在前面的AccountDao接口中，声明findAccountById()方法，通过id查询单个账户信息；声明findAllAccount()方法，用于查询所有账户信息。

    // 通过id查询
public Account findAccountById(int id);
// 查询所有账户
public List<Account> findAllAccount();

  3. 实现查询方法：在前面的的AccountDaoImpl类中，实现AccountDao接口中的findAccountById()方法和findAllAccount()方法，并调用query()方法分别进行查询。

    // 这里只展示了其中一个方法，通过id查询单个账户信息
public Account findAccountById(int id) {
    //定义SQL语句
    String sql = "select * from account where id = ?";
    // 创建一个新的BeanPropertyRowMapper对象
    RowMapper<Account> rowMapper = 
	new BeanPropertyRowMapper<Account>(Account.class);
    // 将id绑定到SQL语句中，通过RowMapper返回Object类型的单行记录
    return this.jdbcTemplate.queryForObject(sql, rowMapper, id);
}

  4. 测试条件查询：创建测试类FindAccountByIdTest，用于测试条件查询。

    public class FindAccountByIdTest {
    public static void main(String[] args) {
        // 加载配置文件
        ApplicationContext applicationContext =new 
            ClassPathXmlApplicationContext("applicationContext.xml");
        // 获取AccountDao实例
        AccountDao accountDao =
                (AccountDao) applicationContext.getBean("accountDao");
        Account account = accountDao.findAccountById(1);
        System.out.println(account);	}
}

  5. 测试查询所有用户信息：创建测试类FindAllAccountTest，用于查询所有用户账户信息。

    public class FindAllAccountTest {
    public static void main(String[] args) {
        // 加载配置文件
        ApplicationContext applicationContext =new 
             ClassPathXmlApplicationContext("applicationContext.xml");
        // 获取AccountDao实例
        AccountDao accountDao =
                (AccountDao) applicationContext.getBean("accountDao");
        List<Account> account = accountDao.findAllAccount(); // 执行方法
        for (Account act : account) {// 循环输出集合中的对象
            System.out.println(act); } }
}

  6. 查看运行结果：在IDEA中启动FindAllAccountTest类，控制台会输出结果。

Spring事务管理概述

事务管理的核心接口

spring-tx-5.2.8.RELEAS依赖包的3个接口 ：

​ PlatformTransactionManager接口：可以根据属性管理事务。

​ TransactionDefinition接口：用于定义事务的属性。

​ TransactionStatus接口：用于界定事务的状态 。

PlatformTransactionManager接口 ：

PlatformTransactionManager 接口主要用于管理事务，该接口中提供了三个管理事物的方法。

方法说明
TransactionStatus用于获取事务状态信息
void commit(TransactionStatus status)用于提交事务
void rollback(TransactionStatus status)用于回滚事务
TransactionDefinition接口 ：

​ TransactionDefinition接口中定义了事务描述相关的常量，其中包括了事务的隔离级别、事务的传播行为、事务的超时时间和是否为只读事务。

事务的隔离级别 ：

隔离级别说明
ISOLATION_DEFAULT采用当前数据库默认的事务隔离级别。
ISOLATION_READ_UNCOMMITTED读未提交。允许另外一个事务读取到当前未提交的数据，隔离级别最低，可能会导致脏读、幻读或不可重复读。
ISOLATION_READ_COMMITTED读已提交。被一个事务修改的数据提交后才能被另一个事务读取，可以避免脏读，无法避免幻读，而且不可重复读。
ISOLATION_ REPEATABLE_READ允许重复读，可以避免脏读，资源消耗上升。这是MySQL数据库的默认隔离级别。
REPEATABLE_SERIALIZABLE事务串行执行，也就是按照时间顺序一一执行多个事务，不存在并发问题，最可靠，但性能与效率最低。

事务的传播行为 ：

​ 事务的传播行为是指处于不同事务中的方法在相互调用时，方法执行期间，事务的维护情况。例如，当一个事务的方法B调用另一个事务的方法A时，可以规定A方法继续在B方法所属的现有事务中运行，也可以规定A方法开启一个新事务，在新事务中运行，B方法所属的现有事务先挂起，等A方法的新事务执行完毕后再恢复。

TransactionDefinition接口中定义的7种事务传播行为：

传播行为说明
PROPAGATION_REQUIRED默认的事务传播行为。如果当前存在一个事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
PROPAGATION_SUPPORTS读未提交。允许如果当前存在一个事务，则加入该事务；如果当前没有事务，则以非事务方式执行。
PROPAGATION_MANDATORY当前必须存在一个事务，如果没有，就抛出异常。
PROPAGATION_REQUIRES_NEW创建一个新的事务，如果当前已存在一个事务，将已存在的事务挂起。
PROPAGATION_NOT_SUPPORTED不支持事务，在没有事务的情况下执行，如果当前已存在一个事务，则将已存在的事务挂起。
ROPAGATION_NEVER永远不支持当前事务，如果当前已存在一个事务，则抛出异常。
PROPAGATION_NESTED如果当前存在事务，则在当前事务的一个子事务中执行。

事务的超时时间 ：

​ 事务的超时时间是指事务执行的时间界限，超过这个时间界限，事务将会回滚。TransactionDefinition接口提供了TIMEOUT_DEFAULT常量定义事务的超时时间。

事务是否只读 ：

​ 当事务为只读时，该事务不修改任何数据，只读事务有助于提升性能，如果在只读事务中修改数据，会引发异常。

​ TransactionDefinition接口中除了提供事务的隔离级别、事务的传播行为、事务的超时时间和是否为只读事务的常量外，还提供了一系列方法来获取事务的属性。

TransactionDefinition接口常用方法 ：

方法说明
int getPropagationBehavior()返回事务的传播行为
int getIsolationLevel()返回事务的隔离层次
int getTimeout()返回事务的超时属性
boolean isReadOnly()判断事务是否为只读
String getName()返回定义的事务名称
TransactionStatus接口 ：
方法说明
boolean isNewTransaction()判断当前事务是否为新事务
boolean hasSavepoint()判断当前事务是否创建了一个保存点
boolean isRollbackOnly()判断当前事务是否被标记为rollback-only
void setRollbackOnly()将当前事务标记为rollback-only
boolean isCompleted()判断当前事务是否已经完成（提交或回滚）
void flush()刷新底层的修改到数据库

事务管理的方式

Spring中的事务管理的两种方式：

​ Spring中的事务管理分为两种方式，一种是传统的编程式事务管理，另一种是声明式事务管理。

​ 编程式事务管理：通过编写代码实现的事务管理，包括定义事务的开始、正常执行后的事务提交和异常时的事务回滚。

​ 声明式事务管理：通过AOP技术实现的事务管理，其主要思想是将事务管理作为一个“切面”代码单独编写，然后通过AOP技术将事务管理的“切面”代码植入到业务目标类中。

声明式事务管理

基于XML方式的声明式事务 ：

如何实现XML方式的声明式事务：

​ 基于XML方式的声明式事务管理是通过在配置文件中配置事务规则的相关声明来实现的。在使用XML文件配置声明式事务管理时，首先要引入tx命名空间，在引入tx命名空间之后，可以使用tx:advice元素来配置事务管理的通知，进而通过Spring AOP实现事务管理。

​ 配置tx:advice元素时，通常需要指定 id 和 transaction-manager 属性，其中，id 属性是配置文件中的唯一标识，transaction-manager 属性用于指定事务管理器。除此之外，tx:advice元素还包含子元素<tx: attributes>，tx:attributes元素可配置多个tx:method子元素，tx:method子元素主要用于配置事务的属性。

tx:method元素的常用属性 ：
属性说明
name用于指定方法名的匹配模式，该属性为必选属性，它指定了与事务属性相关的方法名。
propagation用于指定事务的传播行为。
isolation用于指定事务的隔离级别。
read-only用于指定事务是否只读。
timeout用于指定事务超时时间。
rollback-for用于指定触发事务回滚的异常类。
no-rollback-for用于指定不触发事务回滚的异常类。
案例演示

如何通过XML方式实现Spring的声明式事务管理：

  1. 导入依赖：在chapter09项目的pom.xml文件中加入aspectjweaver依赖包和aopalliance依赖包作为实现切面所需的依赖包

    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.6</version>
      <scope>runtime</scope>	</dependency>
<dependency>
      <groupId>aopalliance</groupId>
      <artifactId>aopalliance</artifactId>
      <version>1.0</version>	</dependency>

  2. 定义Dao层方法：AccountDao接口中声明转账方法transfer()。

    // 转账
public void transfer(String outUser,
	String inUser,
	Double money);

  3. 实现Dao层方法：AccountDaoImpl实现类中实现AccountDao接口中的transfer()方法。

    // 转账 inUser：收款人； outUser：汇款人； money：收款金额
public void transfer(String outUser, String inUser, Double money) {
    // 收款时，收款用户的余额=现有余额+所汇金额
    this.jdbcTemplate.update("update account set balance = balance +? "
            + "where username = ?",money, inUser);
    // 模拟系统运行时的突发性问题
    int i = 1/0;
    // 汇款时，汇款用户的余额=现有余额-所汇金额
    this.jdbcTemplate.update("update account set balance = balance-? "
            + "where username = ?",money, outUser);
}

  4. 修改配置文件：修改chapter09项目的配置文件applicationContext.xml，添加命名空间等相关配置代码。

    <beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
“><!-- 引入命名空间，这里只列举了两个-->
    <!-- 1.配置数据源；2.配置JDBC模板；3.定义id为accountDao的Bean；前3步省略--><!-- 4.事务管理器，依赖于数据源 -->
    <bean id="transactionManager" class= "org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" /></bean>
</beans>

  5. 测试系统：创建测试类TransactionTest。

    public class TransactionTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext =
            new ClassPathXmlApplicationContext("applicationContext.xml");
        // 获取AccountDao实例
        AccountDao accountDao =
                (AccountDao)applicationContext.getBean("accountDao");
        // 调用实例中的转账方法
        accountDao.transfer("lisi", "zhangsan", 100.0);
        // 输出提示信息
        System.out.println("转账成功！");}}

  6. 查看表数据：在执行转账操作前，也就是在执行第5不操作前，先查看account表中的数据。

  7. 再查看表数据：在执行第5步后，控制台中报出了“/by zero”的算术异常信息。此时再次查询数据表account。

    未使用事物管理的缺陷：

    ​ 由XML方式实现声明式事务管理的案例可知，zhangsan的账户余额增加了100，而lisi的账户确没有任何变化，这样的情况显然是不合理的。这就是没有事务管理，系统无法保证数据的安全性与一致性，下面使用事务管理解决该问题。

  8. 使用事务管理测试系统：在第4步的代码文件中添加事务管理的配置。

    <!-- 5.编写通知，需要编写对切入点和具体执行事务细节-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED"
                       isolation="DEFAULT" read-only="false" /></tx:attributes>
</tx:advice>
<!-- 6.编写aop，使用AspectJ的表达式，让spring自动对目标生成代理-->
<aop:config>
        <aop:pointcut expression="execution(* com.itheima.*.*(..))"
                      id="txPointCut" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut" 
</aop:config>

基于注解方式的声明式事务

@Transactional的属性
属性说明
value用于指定使用的事务管理器
propagation用于指定事务的传播行为
isolation用于指定事务的隔离级别
timeout用于指定事务的超时时间
readonly用于指定事务是否为只读
rollbackFor用于指定导致事务回滚的异常类数组
rollbackForClassName用于指定导致事务回滚的异常类名称数组
noRollbackFor用于指定不会导致事务回滚的异常类数组
noRollbackForClassName用于指定不会导致事务回滚的异常类名称数组
案例演示

对上一小节的案例进行修改，以注解方式来实现项目中的事务管理：

  1. 创建配置文件：创建配置文件applicationContext-annotation.xml，在该文件中声明事务管理器等配置信息。

    <!– 前四步省略-->
<!-- 1.配置数据源：数据库驱动；连接数据库的url；连接数据库的用户名；连接数据库的密码 -->
<!-- 2.配置JDBC模板：默认必须使用数据源 -->
<!--3.定义id为accountDao的Bean：将jdbcTemplate注入到AccountDao实例中 -->		
<!-- 4.事务管理器，依赖于数据源 -->
<!-- 5.注册事务管理器驱动 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

  2. 修改Dao层实现类：在AccountDaoImpl类的transfer()方法上添加事务注解@Transactional。

    @Transactional(propagation = Propagation.REQUIRED, 
            isolation = Isolation.DEFAULT, readOnly = false)
public void transfer(String outUser, String inUser, Double money) {
    // 收款时，收款用户的余额=现有余额+所汇金额
    this.jdbcTemplate.update("update account set balance = balance +? "
            + "where username = ?",money, inUser);
    // 模拟系统运行时的突发性问题
    int i = 1/0;
    // 汇款时，汇款用户的余额=现有余额-所汇金额
    this.jdbcTemplate.update("update account set balance = balance-? "
            + "where username = ?",money, outUser);
}

  3. 编写测试类：创建测试类AnnotationTest。

    public class AnnotationTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext =new 
   ClassPathXmlApplicationContext("applicationContext-annotation.xml");
        // 获取AccountDao实例
        AccountDao accountDao =
                (AccountDao)applicationContext.getBean("accountDao");
        // 调用实例中的转账方法
        accountDao.transfer("lisi", "zhangsan", 100.0);
        // 输出提示信息
        System.out.println("转账成功！");}}

本章小结

​ 本章主要讲解了Spring的数据库编程。首先介绍了Spring JDBC，包括JdbcTemplate概述和Spring JDBC的配置；然后讲解了JdbcTemplate的增删改查操作，包括excute()方法、update()方法和query()方法；接着讲解了Spring事务管理概述，包括事务管理的核心接口和事务管理的方式；最后讲解了两种实现声明式事务管理的方式，基于XML方式的声明式事务和基于注解方式的声明式事务。通过本章的学习，读者可以对Spring的数据库编程有一定的了解，为框架中数据库开发奠定了基础。

魏什码
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
实验3 基于Spring的数据库编程
11-18
一：实验目的 1、了解JDBC模块作用及事务管理两种方式（XML方式与注解方式） 2、熟悉JDBC配置及事务管理的3个核心接口 3、掌握JdbcTemplate类中的...基于Spring中的JdbcTemplate及声明式事务管理编程实现以下功能；
Spring数据库编程
iiiiiaaaaa337的博客
04-01 139
注：jdbc:mysql://localhost:3306/spring?在jdbc的配置中 由于idea 无法识别& 所以需要写& 的转义字符 &在要实现的的方法上添加@Transactional。使用注解需要在xml中添加所需要的驱动。entity：定义学生类。
第9章 Spring的数据库编程
小猪宝宝的博客
09-01 2080
本章主要讲解了Spring的数据库编程。首先介绍了Spring JDBC，包括JdbcTemplate概述和Spring JDBC的配置；然后讲解了JdbcTemplate的增删改查操作，包括excute()方法、update()方法和query()方法；接着讲解了Spring事务管理概述，包括事务管理的核心接口和事务管理的方式；最后讲解了两种实现声明式事务管理的方式，基于XML方式的声明式事务和基于注解方式的声明式事务。
Spring-事务操作
笔记别偷看
04-01 276
概念 事务是指数据库中的一个操作序列，它由一系列的SQL指令组成。在Java EE程序开发中，事务管理是一个影响范围较广的领域，在程序与数据库交互时，保证事务的正确执行尤为重要。由于实际开发中事务管理存在的诸多弊端，Spring框架针对事务管理提供了自己的解决方案。 对于事务管理，Spring采用的方式是通过在高层次建立事务抽象，然后在此基础上提供一个统一的编程模型，这意味着，Spring具有在多种环境中配置和使用事务的能力，无论是Spring JDBC，还是以MyBatis为代表的ORM框架，Sprin
java 连接数据库实现用户登录功能
10-31
java 连接数据库实现用户登录功能 能运行成功，适合初学者借鉴学习。亲测可用， 谢谢支持。
Spring自学编程代码
08-11
自学Spring所产生的代码，包含IOC、AOP的入门以及进阶，Spring与数据库(MySQL)的交互。(该资源不仅包含我写的代码，一切Spring、aspect、jdbc等所需jar包都俱全，项目导入就能跑起来)
spring+springMVC+mybaits+mysq（SSM）学生信息管理系统实战开发教程
06-12
本系统框架采用的是SSM，即spring、springMVC、mybaits，数据库采用的MySQL，前端采用当前最流行的管理类框架easyui，当然咱们本项目的重点是讲解ssm框架，所以最开始会给大家讲ssm框架原理，流程架构等，后面会结合...
spring5 +reactive编程
11-11
主要介绍spring5 webflux模块相关的内容，包括spring5的一些新特性，webflux的简单使用，异步常见的处理方式，webclient处理微服务的一些场景；Reactive-Streams 编程的实现规范，目前主流的一些响应式编程框架；...
Spring基于XML方式配置事务
halftwo的博客
06-06 4397
配置步骤 一、配置事务管理器 在Bean配置文件中配置事务管理器。 需要注入数据源。 举个例子： &amp;lt;!-- 配置事务管理器 --&amp;gt; &amp;lt;bean id=&quot;transactionManager&quot; class=&quot;org.springframework.jdbc.datasource.DataSourceTransactionManager&quot;&amp;gt;
JavaEE企业级应用开发教程 第五章
public000001的博客
01-14 1182
JavaEE企业级应用开发教程 课后题第五章答案
JavaEE简单示例——Spring的数据库编程
hssjsh的博客
03-23 300
JavaEE简单示例——Spring的数据库编程
JavaEE应用开发---期末复习题
最新发布
中国移不动的博客
05-17 1万+
1.singleton（单例模式）：在单例模式下，Spring 容器中只会存在一个共享的 Bean 实例，所有对 Bean 的请求，只要请求的 id（或 name）与 Bean 的定义相匹配，就会返回 Bean 的同一个实例；在Spring MVC中，DispatcherServlet是整个框架的核心，它接收所有的客户端请求，并根据请求中的URL信息，将请求分发给相应的HandlerMapping、HandlerAdapter和Handler进行处理。可以通过此方法对请求域中的模型和视图做出进一步的修改。
07 Spring事务
m0_51697147的博客
08-03 1038
事务：不可分割的原子操作，即一系列的操作要么同时成功，要么同时失败。 1.事务简介、2.事务管理方案、3.事务管理器、4.事务控制的API、5.事务的相关配置、6.事务的传播行为、7.事务的隔离级别、8.注解配置声明式事务......
第4章 Spring的数据库开发
dengpan1889的博客
05-22 230
4.1 Spring JDBC Spring的JDBC模块负责数据库资源管理和错误处理，化简了开发者对数据库的操作。 4.11 Spring JdbcTemplate的解析 * JdbcTemplate类是Spring JDBC的核心类 * JdbcTemplate类的继承结构: 抽象类JdbcAccessor为子类提供了一些访问数据库时使用的公共属性： DateS...
Spring JDBC
m0_64895976的博客
02-17 390
一、Spring数据库编程主要使用Spring JDBC模块的core包和dataSource包。 core包是JDBC的核心功能包，包括常用的JdbcTemplate类； dataSource包是访问数据源的工具类包。 使用Spring JDBC操作数据库，需要对其进行配置 二、配置数据源 <?xml version="1.0" encoding="UTF-8" ?> <beans xmlns="http://www.springframework.org/s
Spring与数据库编程
qq_33700236的博客
04-09 409
1. 传统JDBC的缺点 一般的JDBC代码如下： 传统的JDBC代码中含有大量的异常处理语句，使得代码繁杂。 2. 配置数据库资源 在实际工作中，大部分会配置成为数据库连接池，我们既可以使用 Spring 内部提供的类，也可以使用第3方数据库连接或者从Web服务器中通过 JNDI 获取数据源。 1.使用简单数据库配置 配置SimpleDriverDataSource： 这样就能够配置一个最简单的数据源。这个配置一般用于测试，因为它不是一个数据库连接池，只是一个很简单的数据库连接的应用。在更多的时候，
Spring 数据库编程
m0_57303886的博客
04-11 97
和Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'JdbcTemplate' defined in class path resource [applicationContext.xml]: Failed to。
spring数据库事务管理
04-11
好的，对于spring数据库事务管理，我可以给您提供一些基本的信息。在Spring框架中，我们可以通过编程或者声明式的方式来管理数据库事务。编程式事务管理需要我们手动在代码中编写事务管理的代码，而声明式事务管理则...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值