2.4.7 Spring JDBCTemplate & 声明式事务

最新推荐文章于 2024-05-04 18:46:49 发布
最新推荐文章于 2024-05-04 18:46:49 发布
阅读量79 收藏
点赞数
分类专栏： 事务控制 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47134119/article/details/111435983
版权

2.4.7 Spring JDBCTemplate & 声明式事务

文章目录

主要内容

  • Spring的JdbcTemplate
  • Spring的事务
  • Spring集成web环境

一 Spring的JdbcTemplate

1.1 JdbcTemplate是什么？

JdbcTemplate是spring框架中提供的一个模板对象，是对原始繁琐的Jdbc API对象的简单封装。
核心对象
JdbcTemplate jdbcTemplate = new JdbcTemplate(DataSource dataSource);
核心方法

int update(); 执行增、删、改语句
List query(); 查询多个
T queryForObject(); 查询一个
new BeanPropertyRowMapper<>(); 实现ORM映射封装

举个栗子
查询数据库所有账户信息到Account实体中

public class JdbcTemplateTest {
    @Test
    public void testFindAll() throws Exception {
        // 创建核心对象 
        JdbcTemplate jdbcTemplate = new JdbcTemplate(JdbcUtils.getDataSource());
        // 编写sql 
        String sql = "select * from account";
        // 执行sql 
        List<Account> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Account.class));
    }
}

1.2 Spring整合JdbcTemplate

需求
基于Spring的xml配置实现账户的CRUD案例
步骤分析

  1. 创建java项目，导入坐标
  2. 编写Account实体类
  3. 编写AccountDao接口和实现类
  4. 编写AccountService接口和实现类
  5. 编写spring核心配置文件
  6. 编写测试代码

1）创建java项目，导入坐标

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lagou</groupId>
    <artifactId>spring_jdbctemplate</artifactId>
    <version>1.0-SNAPSHOT</version>


    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.15</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
    </dependencies>

</project>

2）编写Account实体类

public class Account {
    private Integer id;
    private String name;
    private Double money;
    //get、set、tostring
}

3）编写AccountDao接口和实现类
AccountDao接口

public interface AccountDao {
    public List<Account> findAll();

    public Account findById(Integer id);

    public void save(Account account);

    public void update(Account account);

    public void delete(Integer id);
}

AccountDaoImpl 实现类

package com.lagou.dao.impl;

import com.lagou.dao.AccountDao;
import com.lagou.domain.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    /*
        查询所有账户
     */
    public List<Account> findAll() {
        // 需要用到jdbcTemplate
        String sql = "select * from account";
        List<Account> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Account>(Account.class));

        return list;
    }

    /*
        根据ID查询账户
     */
    public Account findById(Integer id) {
        String sql = "select * from account where id = ?";
        Account account = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Account>(Account.class), id);
        return account;
    }

    /*
        添加账户
     */
    public void save(Account account) {
        String sql = "insert into account values(null,?,?)";
        jdbcTemplate.update(sql,account.getName(),account.getMoney());


    }

    /*
        更新账户
     */
    public void update(Account account) {
        String sql = "update account set money = ? where name = ?";
        jdbcTemplate.update(sql,account.getMoney(),account.getName());

    }

    /*
        根据ID删除账户
     */
    public void delete(Integer id) {
        String sql = "delete from account where id = ?";
        jdbcTemplate.update(sql,id);

    }
}

4）编写AccountService接口和实现类
AccountService接口

package com.lagou.servlet;
import com.lagou.domain.Account;
import java.util.List;

public interface AccountService {

    /*
       查询所有账户
    */
    public List<Account> findAll();

    /*
        根据ID查询账户
     */
    public Account findById(Integer id);

    /*
        添加账户
     */
    public void save(Account account);

    /*
        更新账户信息
     */
    public void update(Account account);

    /*
        根据ID删除账户
     */
    public void delete(Integer id);

}

AccountSerivceImpl 实现类

package com.lagou.servlet.impl;

import com.lagou.dao.AccountDao;
import com.lagou.domain.Account;
import com.lagou.servlet.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class AccountSerivceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;


    public List<Account> findAll() {
        List<Account> all = accountDao.findAll();

        return all;
    }

    public Account findById(Integer id) {
        Account account = accountDao.findById(id);

        return account;
    }

    public void save(Account account) {

        accountDao.save(account);

    }

    public void update(Account account) {

        accountDao.update(account);

    }

    public void delete(Integer id) {

        accountDao.delete(id);

    }
}

5）编写spring核心配置文件
applicationContext.xml

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


    <!--IOC注解扫描-->
    <context:component-scan base-package="com.lagou"/>

    <!--引入properties-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--dataSource-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--jdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <constructor-arg name="dataSource" ref="dataSource"/>
    </bean>
</beans>

jdbc.properties配置文件

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///spring_db
jdbc.username=root
jdbc.password=123

6）编写测试代码

package com.lagou.test;

import com.lagou.domain.Account;
import com.lagou.servlet.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class AccountServiceImplTest {

    @Autowired
    private AccountService accountService;


    // 测试保存
    @Test
    public void testSave(){

        Account account = new Account();
        account.setName("lucy");
        account.setMoney(1000d);
        accountService.save(account);
    }

    // 测试查询所有
    @Test
    public void testFindAll(){

        List<Account> all = accountService.findAll();
        for (Account account : all) {
            System.out.println(account);
        }
    }

    //测试根据ID进行查询
    @Test
    public void testFindById(){

        Account account = accountService.findById(1);
        System.out.println(account);

    }

    // 测试账户修改
    @Test
    public void testUpdate(){

        Account account = new Account();
        account.setName("tom");
        account.setMoney(1000d);

        accountService.update(account);
    }

    // 测试根据ID删除账户
    @Test
    public void testDelete(){

        accountService.delete(4);
    }
}

1.3 实现转账案例

步骤分析

  1. 创建java项目，导入坐标
  2. 编写Account实体类
  3. 编写AccountDao接口和实现类
  4. 编写AccountService接口和实现类
  5. 编写spring核心配置文件
  6. 编写测试代码

1）创建java项目，导入坐标
pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lagou</groupId>
    <artifactId>spring_transfer_tx</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.15</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
    </dependencies>
</project>

2）编写Account实体类

package com.lagou.domain;

public class Account {

    private Integer id;
    private String name;
    private Double money;

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + 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 Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }
}

3）编写AccountDao接口和实现类
AccountDao 接口

package com.lagou.dao;

public interface AccountDao {


    /*
        减钱：转出操作
     */
    public void out(String outUser,Double money);

    /*
       加钱：转入操作
    */
    public void in(String inUser,Double money);

}

AccountDaoImpl 实现类

package com.lagou.dao.impl;

import com.lagou.dao.AccountDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;


    public void out(String outUser, Double money) {
        String sql = "update account set money = money - ? where name = ?";
        jdbcTemplate.update(sql,money,outUser);
    }

    public void in(String inUser, Double money) {
        String sql = "update account set money = money + ? where name = ?";
        jdbcTemplate.update(sql,money,inUser);

    }
}

4）编写AccountService接口和实现类
AccountSerivce 接口

package com.lagou.servlet;

public interface AccountSerivce {

    /*
        转账方法
     */

    public void transfer(String outUser,String inUser,Double money);
}

AccountServiceImpl 实现类

package com.lagou.servlet.impl;

import com.lagou.dao.AccountDao;
import com.lagou.servlet.AccountSerivce;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional
public class AccountServiceImpl implements AccountSerivce {

    @Autowired
    private AccountDao accountDao;


    //@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ,timeout = -1,readOnly = false)
    public void transfer(String outUser, String inUser, Double money) {

        //调用dao的out及in方法
        accountDao.out(outUser,money);

        int i = 1/0;

        accountDao.in(inUser,money);
    }
}

5）编写spring核心配置文件
applicationContext.xml

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

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
  <!--IOC注解扫描-->  
  <context:component-scan base-package="com.lagou"/>  
  <!--加载jdbc配置文件-->  
  <context:property-placeholder location="classpath:jdbc.properties"/>  
  <!--把数据库连接池交给IOC容器-->  
  <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> 
    <property name="driverClassName" value="${jdbc.driver}"/>  
    <property name="url" value="${jdbc.url}"/>  
    <property name="username" value="${jdbc.username}"/>  
    <property name="password" value="${jdbc.password}"/> 
  </bean>  
  <!--把JdbcTemplate交给IOC容器-->  
  <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> 
    <constructor-arg name="dataSource" ref="dataSource"/> 
  </bean> 
</beans>

jdbc.properties 文件

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///spring_db
jdbc.username=root
jdbc.password=root

6）编写测试代码

package com.lagou.test;

import com.lagou.config.SpringConfig;
import com.lagou.servlet.AccountSerivce;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class AccountServiceImplTest {

    @Autowired
    private AccountSerivce accountSerivce;

    @Test
    public void testTransfer(){
        accountSerivce.transfer("tom","jerry",100d);
    }
}

二 Spring的事务

2.1 Spring中的事务控制方式

Spring的事务控制可以分为编程式事务控制和声明式事务控制。
编程式
开发者直接把事务的代码和业务代码耦合到一起，在实际开发中不用。
声明式
开发者采用配置的方式来实现的事务控制，业务代码与事务代码实现解耦合，使用的AOP思想。

2.2 编程式事务控制相关对象【了解】

2.2.1 PlatformTransactionManager

PlatformTransactionManager接口，是spring的事务管理器，里面提供了我们常用的操作事务的方法。

方法说明
TransactionStatus getTransaction(TransactionDefinition definition);获取事务的状态信息
void commit(TransactionStatus status)；提交事务
void rollback(TransactionStatus status)；回滚事务

注意：

  • PlatformTransactionManager 是接口类型，不同的 Dao 层技术则有不同的实现类。
  • Dao层技术是jdbcTemplate或mybatis时： DataSourceTransactionManager
  • Dao层技术是hibernate时： HibernateTransactionManager
  • Dao层技术是JPA时：JpaTransactionManager

2.2.2 TransactionDefinition

TransactionDefinition接口提供事务的定义信息（事务隔离级别、事务传播行为等等）

方法说明
int getIsolationLevel()获得事务的隔离级别
int getPropogationBehavior()获得事务的传播行为
int getTimeout()获得超时时间
boolean isReadOnly()是否只读

1）事务隔离级别
设置隔离级别，可以解决事务并发产生的问题，如脏读、不可重复读和虚读（幻读）。

  • ISOLATION_DEFAULT 使用数据库默认级别
  • ISOLATION_READ_UNCOMMITTED 读未提交
  • ISOLATION_READ_COMMITTED 读已提交
  • ISOLATION_REPEATABLE_READ 可重复读
  • ISOLATION_SERIALIZABLE 串行化

2）事务传播行为
事务传播行为指的就是当一个业务方法【被】另一个业务方法调用时，应该如何进行事务控制。

方法说明
REQUIRED如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到
这个事务中。一般的选择（默认值）
SUPPORTS支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务）
MANDATORY使用当前的事务，如果当前没有事务，就抛出异常
REQUERS_NEW新建事务，如果当前在事务中，把当前事务挂起
NOT_SUPPORTED以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
NEVER以非事务方式运行，如果当前存在事务，抛出异常
NESTED如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行

在这里插入图片描述

  • read-only（是否只读）：建议查询时设置为只读
  • timeout（超时时间）：默认值是-1，没有超时限制。如果有，以秒为单位进行设置

2.2.3 TransactionStatus

TransactionStatus 接口提供的是事务具体的运行状态。

方法说明
boolean isNewTransaction()是否是新事务
boolean hasSavepoint()是否是回滚点
boolean isRollbackOnly()事务是否回滚
boolean isCompleted()事务是否完成

可以简单的理解三者的关系：事务管理器通过读取事务定义参数进行事务管理，然后会产生一系列的事务状态。

2.2.4 实现代码

1）配置文件

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

<!--事务管理器交给IOC-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
  <property name="dataSource" ref="dataSource"/> 
</bean>

2）业务层代码

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;
    @Autowired
    private PlatformTransactionManager transactionManager;

    @Override
    public void transfer(String outUser, String inUser, Double money) {
        // 创建事务定义对象
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        // 设置是否只读，false支持事务 
        def.setReadOnly(false);
        // 设置事务隔离级别，可重复读mysql默认级别 
        def.setIsolationLevel(TransactionDefinition.ISOLATION_REPEATABLE_READ);
        // 设置事务传播行为，必须有事务 
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

        // 配置事务管理器 
        TransactionStatus status = transactionManager.getTransaction(def);

        try {
            // 转账 
            accountDao.out(outUser, money);
            accountDao.in(inUser, money);
            // 提交事务 
            transactionManager.commit(status);
        } catch (Exception e) {
            e.printStackTrace();
            // 回滚事务 
            transactionManager.rollback(status);
        }
    }
}

2.2.5 知识小结

Spring中的事务控制主要就是通过这三个API实现的

  • PlatformTransactionManager 负责事务的管理，它是个接口，其子类负责具体工作
  • TransactionDefinition 定义了事务的一些相关参数
  • TransactionStatus 代表事务运行的一个实时状态
    理解三者的关系：事务管理器通过读取事务定义参数进行事务管理，然后会产生一系列的事务状态。

2.3 基于XML的声明式事务控制【重点】

在 Spring 配置文件中声明式的处理事务来代替代码式的处理事务。底层采用AOP思想来实现的。
声明式事务控制明确事项：

  • 核心业务代码(目标对象) （切入点是谁？）
  • 事务增强代码(Spring已提供事务管理器)）（通知是谁？）
  • 切面配置（切面如何配置？）

2.3.1 快速入门

需求
使用spring声明式事务控制转账业务。
步骤分析

  1. 引入tx命名空间
  2. 事务管理器通知配置
  3. 事务管理器AOP配置
  4. 测试事务控制转账业务代码

1）引入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: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
		http://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
">
</beans>

2）事务管理器通知配置

<!--事务管理器--> 
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource"></property> 
</bean> 
<!--通知增强--> 
<tx:advice id="txAdvice" transaction-manager="transactionManager"> 
<!--定义事务的属性--> 
	<tx:attributes> <tx:method name="*"/> </tx:attributes> 
</tx:advice>

3）事务管理器AOP配置

<!--aop配置-->
 <aop:config>
 	<!--切面配置-->
    <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.lagou.servlet.impl.AccountServiceImpl.*(..))"/>
</aop:config>-->

4）测试事务控制转账业务代码

@Override 
public void transfer(String outUser, String inUser, Double money) { 
	accountDao.out(outUser, money); 
	// 制造异常 int i = 1 / 0; 
	accountDao.in(inUser, money); 
}

2.3.2 事务参数的配置详解

<tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" timeout="-1" read-only="false"/> 
* name：切点方法名称 
* isolation:事务的隔离级别 
*  propogation：事务的传播行为 
*  timeout：超时时间 
*  read-only：是否只读

CRUD常用配置

<tx:attributes> 
	<tx:method name="save*" propagation="REQUIRED"/> 	
	<tx:method name="delete*" propagation="REQUIRED"/> 
	<tx:method name="update*" propagation="REQUIRED"/> 
	<tx:method name="find*" read-only="true"/> 
	<tx:method name="*"/> 
</tx:attributes>

2.3.3 知识小结

  • 平台事务管理器配置
  • 事务通知的配置
  • 事务aop织入的配置

2.4 基于注解的声明式事务控制【重点】

2.4.1 常用注解

步骤分析

  1. 修改service层，增加事务注解
  2. 修改spring核心配置文件，开启事务注解支持

1）修改service层，增加事务注解

@Service
@Transactional
public class AccountServiceImpl implements AccountSerivce {

    @Autowired
    private AccountDao accountDao;


    @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ,timeout = -1,readOnly = false)
    public void transfer(String outUser, String inUser, Double money) {

        //调用dao的out及in方法
        accountDao.out(outUser,money);

        int i = 1/0;

        accountDao.in(inUser,money);
    }
}

2）修改spring核心配置文件，开启事务注解支持
添加如下配置

<!--事务管理器--> 
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
	<property name="dataSource" ref="dataSource"/>
</bean> 
<!--事务的注解支持--> 
<tx:annotation-driven/>

2.4.2 纯注解

核心配置类 ，SpringConfig 类

@Configuration  // 声明该类为核心配置类
@ComponentScan("com.lagou")  // 包扫描
@Import(DataSourceConfig.class) //导入其他配置类
@EnableTransactionManagement //事务的注解驱动，相当于<!--事务的注解支持--> <tx:annotation-driven/>
public class SpringConfig {

    @Bean
    public JdbcTemplate getJdbcTemplate(@Autowired DataSource dataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        return jdbcTemplate;
    }

    @Bean
    public PlatformTransactionManager getPlatformTransactionManager(@Autowired DataSource dataSource){
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager(dataSource);
        return dataSourceTransactionManager;
    }
}

数据源配置类，DataSourceConfig类

package com.lagou.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;

import javax.sql.DataSource;

@PropertySource("classpath:jdbc.properties") //引入properties文件
public class DataSourceConfig {

    @Value("${jdbc.driverClassName}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;



    @Bean //会把当前方法的返回值对象放进IOC容器中
    public DataSource getDataSource(){

        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driver);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }
}

2.4.3 知识小结

  • 平台事务管理器配置（xml、注解方式）
  • 事务通知的配置（@Transactional注解配置）
  • 事务注解驱动的配置 < tx:annotation-driven/>、@EnableTransactionManagement

三 Spring集成web环境

3.1 ApplicationContext应用上下文获取方式

应用上下文对象是通过 new ClasspathXmlApplicationContext(spring配置文件) 方式获取的，但是每次从容器中获得Bean时都要编写 new ClasspathXmlApplicationContext(spring配置文件) ，这样的弊端是配置文件加载多次，应用上下文对象创建多次。
解决思路分析：
在Web项目中，可以使用ServletContextListener监听Web应用的启动，我们可以在Web应用启动时，就加载Spring的配置文件，创建应用上下文对象ApplicationContext，在将其存储到最大的域servletContext域中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了。

3.2 Spring提供获取应用上下文的工具

上面的分析不用手动实现，Spring提供了一个监听器ContextLoaderListener就是对上述功能的封装，该监听器内部加载Spring配置文件，创建应用上下文对象，并存储到ServletContext域中，提供了一个客户端工具WebApplicationContextUtils供使用者获得应用上下文对象。
所以我们需要做的只有两件事：

  1. 在web.xml中配置ContextLoaderListener监听器（导入spring-web坐标）
  2. 使用WebApplicationContextUtils获得应用上下文对象ApplicationContext

3.3 实现

1）导入Spring集成web的坐标

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lagou</groupId>
    <artifactId>spring_web</artifactId>
    <version>1.0-SNAPSHOT</version>

    <packaging>war</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
    </dependencies>
</project>

其他相关准备：
a.Account实体类

public class Account {

    private Integer id;
    private String name;
    private Double money;
	//get、set、tostring
}

b.AccountServlet 业务

package com.lagou.servlet;

import com.lagou.domain.Account;
import org.springframework.context.ApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

import java.io.IOException;

public class AccountServlet extends javax.servlet.http.HttpServlet {

    protected void doPost(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws javax.servlet.ServletException, IOException {
        doGet(request,response);
    }

    protected void doGet(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws javax.servlet.ServletException, IOException {

        // classPathXmlApplicationContext对象存到servletContext域中
     /*   ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        Account account = (Account) classPathXmlApplicationContext.getBean("account");
        System.out.println(account);
*/
        ApplicationContext webApplicationContext = WebApplicationContextUtils.getWebApplicationContext(request.getServletContext());
        Account account = (Account) webApplicationContext.getBean("account");
        System.out.println(account);

    }
}

c.核心配置文件applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns: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
		http://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
">

    <!--配置account-->
    <bean id="account" class="com.lagou.domain.Account">
        <property name="id" value="1"/>
        <property name="name" value="子慕"/>
        <property name="money" value="100"/>
    </bean>
</beans>

2）配置ContextLoaderListener监听器
web.xml里

<!--全局参数：指定applciationContext.xml文件的路径-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

    <!--spring的监听器 contextLoaderListenere-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

3）通过工具获得应用上下文对象
servlet的doGet()里

package com.lagou.servlet;

import com.lagou.domain.Account;
import org.springframework.context.ApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

import java.io.IOException;

public class AccountServlet extends javax.servlet.http.HttpServlet {

    protected void doPost(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws javax.servlet.ServletException, IOException {
        doGet(request,response);
    }

    protected void doGet(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws javax.servlet.ServletException, IOException {

        // classPathXmlApplicationContext对象存到servletContext域中
     /*   ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        Account account = (Account) classPathXmlApplicationContext.getBean("account");
        System.out.println(account);
*/
        ApplicationContext webApplicationContext = WebApplicationContextUtils.getWebApplicationContext(request.getServletContext());
        Account account = (Account) webApplicationContext.getBean("account");
        System.out.println(account);

    }
}

一 Spring的JdbcTemplate

1.1 JdbcTemplate是什么？

1.1.1 JdbcTemplate是什么？

weixin_47134119
关注
专栏目录
3.16Spring对jdbcTemplate查询语句的封装和编程式事务及声明式事务
哈希的博客
03-19 514
1、Spring对jdbcTemplate查询语句的封装2、Spring对jdbc事务的封装（编程式和声明式）1、NamedParameterJdbcTemplate、RowMapper都是接口，具体的用法得看下它们的实现类。然后再一步一步看懂代码。代码TestQuery.javapackage com.jdbc; import java.sql.PreparedStatement; impor...
goby红队&社区版-win-64-2.4.7
11-27
"goby红队&社区版-win-64-2.4.7"这一标题揭示了我们正在讨论的是Goby的一个特定版本，适用于64位Windows操作系统，版本号为2.4.7，同时包含了红队和社区两个版本的功能。 Goby红队版是专门为安全测试和渗透测试设计...
2.4.7 Spring JDBCTemplate,编程式事务, 声明式事务(基于XML,注解), Spring集成web环境(监听器)
chengh1993的博客
12-06 299
任务三：Spring JDBCTemplate & 声明式事务 课程任务主要内容： * Spring的JdbcTemplate * Spring的事务 * Spring集成web环境 一 Spring的JdbcTemplate 1.1 JdbcTemplate是什么？ JdbcTemplate是spring框架中提供的一个模板对象，是对原始繁琐的Jdbc API对象的简单封装。 核心对象 JdbcTemplate jdbcTemplate = new JdbcTemplate(Data
Spring：JdbcTemplate、声明式事务
qq_51476114的博客
11-02 227
JdbcTemplate 一个简单、轻薄的Jdbc的封装工具。 常用API JdbcTemplate jdbcTemplate= new JdbcTemplate(DataSource dataSource); 构造方法 update("sql",Object args...) 增删改操作 query("sql',new BeanPropertyRowMapper<>(),Object args...) 查询所有（返回的是list） queryForObject("...
Spring之JdbcTemplate 的事务控制 （编程式）基于XML和注解
运算符重载之String
08-09 486
声明式事务控制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 知
spring5 JdbcTemplate 事务
chengqingshihuishui的博客
01-16 303
1、事务概念 https://blog.csdn.net/chengqingshihuishui/article/details/111806766 2、事务操作 3、事务操作演示 需求： 银行转账 * lucy 转账100元 给mary * lucy少100，mary多100 3.1 创建数据表，添加记录 用SQLyog直接创建好数据表 3.2 编写spring配置文件，和上例一样的。bean1.xml下写配置。 （1）配置druid数据池 （2）jdbcTempla.
FWtools 2.4.7
03-12
**FWtools 2.4.7 知识点详解** FWtools是一款强大的开源地理信息系统（GIS）工具集，主要用于处理和管理地理空间数据。在2.4.7这个版本中，它提供了丰富的功能，帮助用户进行高效的数据操作，特别是在切片、金字塔...
OpenCV-2.4.7.zip
02-05
OpenCV 2.4.7 是该库的一个较旧版本，但仍然被许多开发者用于教学、研究以及在某些特定应用场景下保持稳定性的需求。 安装OpenCV 2.4.7的过程相对简单，提供的"OpenCV-2.4.7.exe"是一个可执行文件，双击运行后，...
SourceTree 2.4.7 Windows
01-08
SourceTree是强大的Git/Mercurial桌面客户端，支持Windows和Mac操作系统。通过SourceTree美观简单的界面，你可以放弃命令行了。
spark-2.4.7-bin-hadoop2.6.tgz
03-17
Spark是Apache软件基金会下的一个开源大数据处理框架，其2.4.7版本是该框架的一个稳定版本，提供了高效、容错性好且易于使用的数据处理能力。与Hadoop2.6版本兼容，意味着Spark可以充分利用Hadoop的分布式存储系统...
配制Spring事务和JdbcTemplate使用
10-08
配制Spring事务和JdbcTemplate使用 配制Spring事务和JdbcTemplate使用
编程式事务 与 声明式事务
专注于Groovy语言，grails框架与管理之道
10-23 2667
采用声明式事务1、了解事务的传播特性 1、propagation_required:如果当前存在一个事务，则支持当前事务，如果没有事务则开启事务 2、propagation_supports:如果存在一个事务，则支持当前事务，如果没有事务则非事务执行 3、propagation_mandatory:如果存在一个事务，则支持当前事务，如果没有事务则抛出异常 4、propagation_requi
spring中JDBC编程式事务
yeson6的专栏
12-07 3442
在spring采用纯JDBC进行数据库操作：applicationContext.xml<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.
Spring JDBC 编程式事务
swadian2008的博客
01-25 1402
编程式事务管理是通过编写代码实现的事务管理，包括定义事务的开始、正常执行后的事务提交和异常时的事务回滚。 Spring 出现以前，编程式事务管理是基于 POJO 应用的唯一选择。在 Hibernate 中，我们需要在代码中显式调用 beginTransaction()、commit()、rollback() 等事务管理相关的方法，这就是编程式事务管理。而通过 Spring 提供的事务管理 API，我们可以在代码中灵活控制事务的执行。 下面根据在《Spring事务》一节讲解的 PlatformTransa
（十一）Spring 事务 - JdbcTemplate
dhe_lone的博客
04-21 852
事务特性 事务并发问题 JdbcTemplate增删改查
6.JdbcTemplate基本使用&事务控制{编程式（了解三个对象）&声明式（xml&注解配置）}
weixin_44519169的博客
02-16 455
JdbcTemplate基本使用 01-JdbcTemplate基本使用-概述(了解) JdbcTemplate是spring框架中提供的一个对象，是对原始繁琐的Jdbc API对象的简单封装。spring框架为我们提供了很多的操作模板类。例如：操作关系型数据的JdbcTemplate和HibernateTemplate，操作nosql数据库的RedisTemplate，操作消息队列的JmsTemplate等等。 02-JdbcTemplate基本使用-开发步骤(理解) ①导入spring-jdbc和spr
Spring JdbcTemplate&声明式事务
无区新手的博客
07-10 167
JdbcTemplate基本使用 JdbcTemplate基本使用-概述(了解) JdbcTemplate是spring框架中提供的一个对象，是对原始繁琐的Jdbc API对象的简单封装。spring框架为我们提供了很多的操作模板类。例如：操作关系型数据的JdbcTemplate和HibernateTemplate，操作nosql数据库的RedisTemplate，操作消息队列的JmsTemplate等等。 JdbcTemplate基本使用-开发步骤(理解) 导入s..
Spring学习day04（JdbcTemplate和Spring中的事务控制）
qq_34504626的博客
03-21 517
一、Spring中的JdbcTemplate 1、JdbcTemplate概述 它是Spring框架中提供的一个对象，是对原始Jdbc API对象的简单封装。Spring框架为我们提供了很多的操作模板类。 操作关系型数据的：JdbcTemplate、HibernateTemplate 操作nosql非关系型数据库的：RedisTemplate 操作消息队列的：JmsTemplate 2、Jdb...
JdbcTemplate
最新发布
我的博客
05-04 1194
事务的隔离级别是数据库事务属性，用来定义一个事务可能受其他并发事务影响的程度。数据库事务必须具备ACID属性（原子性、一致性、隔离性、持久性），而隔离级别主要关注隔离性，防止多个事务并发执行时产生的问题，如脏读、不可重复读和幻读。Spring框架中的声明式事务管理是一种基于AOP（面向切面编程）的事务管理方式，它允许开发者通过声明的方式来管理事务，而不是通过编程的方式。是Spring中两种最常用的事务传播行为，它们定义了事务的边界以及方法如何与现有事务关联。注解或者XML配置来实现的。
OpenCV 2.4.7参考手册：核心功能与图像处理
"OpenCV2.4.7的帮助文档包含了该版本OpenCV的详细技术信息，是开发者使用OpenCV2.4.7进行图像处理和计算机视觉应用的重要参考资料。" OpenCV（Open Source Computer Vision Library）是一个开源的计算机视觉库，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值