spring jdbc 编程式事务

最新推荐文章于 2022-09-15 17:53:07 发布
最新推荐文章于 2022-09-15 17:53:07 发布
阅读量747 收藏
点赞数
分类专栏： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feier7501/article/details/24145031
版权

所谓编程式事务指的是通过编码方式实现事务，即类似于JDBC编程实现事务管理。


新建maven工程，pom文件如下：

<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>spring-jdbc</groupId>
	<artifactId>spring-jdbc</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<properties>
		<spring.group>org.springframework</spring.group>
		<spring.version>3.1.1.RELEASE</spring.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>${spring.group}</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>${spring.group}</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>${spring.group}</groupId>
			<artifactId>spring-aspects</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>${spring.group}</groupId>
			<artifactId>spring-test</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>${spring.group}</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>${spring.group}</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>${spring.group}</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>${spring.group}</groupId>
			<artifactId>spring-expression</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>${spring.group}</groupId>
			<artifactId>spring-beans</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>${spring.group}</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>${spring.group}</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>${spring.group}</groupId>
			<artifactId>spring-oxm</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>${spring.group}</groupId>
			<artifactId>spring-web</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>${spring.group}</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>${spring.group}</groupId>
			<artifactId>spring-webmvc-portlet</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.6</version>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>com.oracle</groupId>
			<artifactId>ojdbc14</artifactId>
			<version>10.2.0.1.0</version>
		</dependency>

		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjrt</artifactId>
			<version>1.7.4</version>
		</dependency>

		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.7.4</version>
		</dependency>

	</dependencies>
</project>

SQL： 

CREATE TABLE TB_USER
(
    ID INTEGER PRIMARY KEY,
    USER_NAME VARCHAR2(20) NOT NULL,
    USER_AGE INTEGER NOT NULL
);


java代码：

package springjdbc;

public interface IUserDao {
	void insertUser(User user);
}


package springjdbc;

public class User {
	private String username;
	private int age;

	public User(String username, int age) {
		this.username = username;
		this.age = age;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

}


PlatformTransactionManager

package springjdbc.transactions.programmatic.platform;

import java.sql.Types;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import springjdbc.IUserDao;
import springjdbc.User;

public class UserDao implements IUserDao {

	@Autowired
	private PlatformTransactionManager platformTransactionManager;
	
	@Autowired
	private JdbcTemplate jdbcTemplate;

	public void setPlatformTransactionManager(PlatformTransactionManager platformTransactionManager) {
		this.platformTransactionManager = platformTransactionManager;
	}

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

	public void insertUser(User user) {
		DefaultTransactionDefinition def = new DefaultTransactionDefinition();
		TransactionStatus status = platformTransactionManager.getTransaction(def);

		String sql = "insert into tb_user (id, user_name, user_age) values (1, ?, ?)";
		Object[] params = new Object[] { user.getUsername(), user.getAge(), };
		int[] types = new int[] { Types.VARCHAR, Types.INTEGER, };
		try {
			jdbcTemplate.update(sql, params, types);
			jdbcTemplate.update(sql, params, types);
			platformTransactionManager.commit(status);
		} catch (DataAccessException e) {
			platformTransactionManager.rollback(status);
			throw e;
		}
	}

}


springjdbc/transactions/programmatic/platformContext.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:p="http://www.springframework.org/schema/p" 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-3.0.xsd
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context-3.0.xsd
	http://www.springframework.org/schema/tx
	http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
	<context:annotation-config />
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>
	<bean id="dataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="url" value="jdbc:oracle:thin:@localhost:1521:ORCL" />
		<property name="username" value="HIBERNATE" />
		<property name="password" value="HIBERNATE" />
		<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
	</bean>
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource" />
	</bean>
	<bean id="userDao" class="springjdbc.transactions.programmatic.platform.UserDao">
	</bean>

</beans>



测试类： 


package springjdbc.transactions.programmatic;

import java.util.Random;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import springjdbc.IUserDao;
import springjdbc.User;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("platformContext.xml")
public class TestPlatform {
	
	@Autowired
	ApplicationContext context;
	
	@Test
	public void test() throws Exception {
		Random random = new Random();
		IUserDao dao = context.getBean("userDao", IUserDao.class);
		int id = random.nextInt(100);
		User user = new User("user" + id, id);
		dao.insertUser(user);
	}

}


运行，会报错，因为ID相同，但是，会回滚，数据库里没有插入数据。

TransactionTemplate

package springjdbc.transactions.programmatic.template;

import java.sql.Types;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionTemplate;

import springjdbc.IUserDao;
import springjdbc.User;

public class UserDao implements IUserDao {

	@Autowired
	private JdbcTemplate jdbcTemplate;

	@Autowired
	private TransactionTemplate transactionTemplate;

	public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
		this.transactionTemplate = transactionTemplate;
	}

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

	public void insertUser(final User user) {
		transactionTemplate.execute(new TransactionCallback<Integer>() {
			public Integer doInTransaction(TransactionStatus status) {
				String sql = "insert into tb_user (id, user_name, user_age) values (1, ?, ?)";
				Object[] params = new Object[] { user.getUsername(), user.getAge(), };
				int[] types = new int[] { Types.VARCHAR, Types.INTEGER, };
				jdbcTemplate.update(sql, params, types);
				return jdbcTemplate.update(sql, params, types);
			}
		});
	}

}


springjdbc/transactions/programmatic/templateContext.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:p="http://www.springframework.org/schema/p" 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-3.0.xsd
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context-3.0.xsd
	http://www.springframework.org/schema/tx
	http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
	<context:annotation-config />
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>
	<bean id="txTemplate"
		class="org.springframework.transaction.support.TransactionTemplate">
		<property name="transactionManager" ref="transactionManager"></property>
	</bean>
	<bean id="dataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="url" value="jdbc:oracle:thin:@localhost:1521:ORCL" />
		<property name="username" value="HIBERNATE" />
		<property name="password" value="HIBERNATE" />
		<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
	</bean>
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource" />
	</bean>
	<bean id="userDao" class="springjdbc.transactions.programmatic.template.UserDao">
	</bean>

</beans>


测试类： 

package springjdbc.transactions.programmatic;

import java.util.Random;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import springjdbc.IUserDao;
import springjdbc.User;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("templateContext.xml")
public class TestTemplate {
	
	@Autowired
	ApplicationContext context;
	
	@Test
	public void test() throws Exception {
		Random random = new Random();
		IUserDao dao = context.getBean("userDao", IUserDao.class);
		int id = random.nextInt(100);
		User user = new User("user" + id, id);
		dao.insertUser(user);
	}

}


运行，会报错，因为ID相同，但是，会回滚，数据库里没有插入数据。


feier7501
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring-jdbc支持（编程式事务）
fwb7014的博客
07-13 118
spring 学习   其一    ----------------------- Spring对jdbc操作的包装类-------JdbcTemplate              org.springframework.jdbc.core.support.JdbcDaoSupport;             可以方便我们采用jdbc的方式对数据库进行操作            &lt...
Spring JDBC-Spring对事务管理的支持
小工匠
09-21 1万+
概述 事务管理关键抽象 Spring事务管理的实现类 Spring JDBC 和MybBatis的事务管理器的配置 JPA的事务管理器的配置 Hibernate的事务管理器的配置 JTA 的事务管理器的配置 事务同步管理器 事务的传播行为 示例 编程式的事务管理 示例概述 Spring为事务管理提供了一致的编程模板，在高层次建立了统一的事务抽象。也就是说，不管选择Spring JDBC、Hibern
分布式事务管理Atomikos
zhangm2020的博客
09-15 4833
Atomikos是一个非常流行的开源事务管理器，并且可以嵌入到你的Spring Boot应用中。Tomcat应用服务器没有实现JTA规范，当使用Tomcat作为应用服务器的时候，需要使用第三方的事务管理器类来作为全局的事务管理器，而Atomikos框架就是这个作用，将事务管理整合到应用中，而不依赖于application server。
springboot1学习（三）atomikos分布式事务
qq_19841133的博客
01-29 224
文章目录spring事务分类声明式事务atomikos分布式事务 spring事务分类 spring事务可分为编程式事务和声明式事务 声明式事务又可分为xml版和注解版 声明式事务 写service层，注意添加 @Transactional注解 import org.springframework.transaction.annotation.Transactional; @Service public class User1Service { @Autowired private T
Spring编程式和声明式事务实例讲解
weixin_34186931的博客
05-22 431
Java面试通关手册（Java学习指南）：github.com/Snailclimb/… 历史回顾： 可能是最漂亮的Spring事务管理详解 Spring事务管理 Spring支持两种方式的事务管理： 编程式事务管理： 通过Transaction Template手动管理事务，实际应用中很少使用， 使用XML配置声明式事务： 推荐使用（代码侵入性最小），实际是通过AOP实现 实现声明式事...
spring编程式事务实现
07-30
Spring提供了两种主要的事务管理方式：声明式事务管理和编程式事务管理。本篇文章将聚焦于编程式事务管理，特别是如何通过`TransactionTemplate`进行事务控制。 1. **Spring编程式事务管理**： 编程式事务管理允许...
spring 整合JDBC和AOP事务的方法
08-27
Spring 框架提供了多种方式来实现事务，包括编程式事务和声明式事务。今天我们主要介绍声明式事务。 声明式事务是指使用 @Transactional 注解来实现事务的管理。我们可以在服务层或控制层的方法上添加该注解，从而...
Spring JDBC常用Jar包
11-20
2. **spring-tx-3.2.3.RELEASE.jar**: Spring的事务管理模块，提供了编程式和声明式事务管理支持。在Spring JDBC中，事务管理是关键功能，它确保了数据库操作的原子性、一致性、隔离性和持久性（ACID特性）。通过这...
SpringJDBC.rar_SpringJDBC_spring jdbc
09-24
编程式事务管理可以通过`PlatformTransactionManager`接口实现，而声明式事务管理则通过`@Transactional`注解实现。 3. **结果集处理**： - Spring JDBC提供了RowMapper接口，用于将数据库查询结果映射为Java对象...
spring声明式事务管理+jdbc+连接池.zip
08-25
本资料包"spring声明式事务管理+jdbc+连接池.zip"显然是针对Spring框架在数据库操作方面的深入学习，特别是如何利用Spring进行声明式事务管理和JDBC操作，以及如何配置和使用数据库连接池。接下来，我们将详细探讨这...
spring 事物控制---多数据源与 atomikos 分布式事务配置(接之前未完成的部分)
u013561386的博客
07-04 2854
解决在多个不同数据源中同时操作各自表时保证数据的完整性，用automikos分布式事务，例如操作A库表a,B库表b,如果b表操作失败，a,b 同时回滚
Spring + Atomikos 分布式事务实现方式
benluobobo的专栏
11-13 2万+
前段时间发现对分布式事务了解的不够清晰，最近又重新看了一下分布式事务，简单做个记录，以后方便查看 Java规范对分布式事务定义了标准的规范Java事务API和Java事务服务，分别是JTA和JTS 一个分布式事务必须包括一个事务管理器和多个资源管理器， 资源管理器是任意类型的持久化数据存储，而事务管理器则是承担着所有事务参与单元者的相互通讯的责任 JTA的规
spring JDBC 编程式事务管理
月夜楓
10-16 430
JDBC 编程式事务管理 Spring提供两种方式实现编程式的事务管理，一是直接使用PlatformTransactionManager实现，二 是使用org.springframework.transaction.support.TransactionTemplate。 先来看 看 如何使 用 PlatformTransactionManager  ，在这 边使用 它 的实现 类 别 Dat
Spring JTA接口+Atomikos实现申明式分布式事务控制
Jerry的一亩三分地
09-15 1117
1. 在pom文件引入atomikos依赖 用maven要简单一点，只需要加入两个依赖： com.atomikos transactions-jdbc 3.7.0 javax.transaction jta 1.1 2. 将需要分布式事务的数据源变成AtomikosDataSourceBean
spring事务隔离级别、传播行为以及spring+mybatis+atomikos实现分布式事务管理
半山闲人的专栏
04-10 2万+
1.事务的定义：事务是指多个操作单元组成的合集，多个单元操作是整体不可分割的，要么都操作不成功，要么都成功。其必须遵循四个原则（ACID）。 2.事务隔离级别：spring有五大隔离级别，其在TransactionDefinition中定义 3.事务传播行为：七大传播行为
事务声明声明式事务和编程式事务介绍
06-24 1万+
编程式事务：所谓编程式事务指的是通过编码方式实现事务，即类似于JDBC编程实现事务管理。管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。 声明式事务 ：管理建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务
atomikos JTA 分布式事务配置和原理
zwkwd的专栏
03-31 1万+
概述           本人现在正在做税务项目平台,为以后税务开发做准备,由于功能比较多,考虑到以后会有多种数据库参与,所以需要支持分布式事务. 对于事务,可以理解为原子操作,即要不都成功,要不都成仁.          对于单个数据库来说,可以通过conn来对事务进行设置自己提交,来控制同一个conn下的事务处理,但是对于多数据库,或者是对于业务逻辑的原理处理,我们就需要用到分布式事务了
Spring事务管理实现方式之编程式事务与声明式事务详解
热门推荐
半山闲人的专栏
04-12 5万+
1.编程式事务：编码方式实现事务管理（代码演示为JDBC事务管理） Spring实现编程式事务，依赖于2大类，分别是上篇文章提到的PlatformTransactionManager，与模版类TransactionTemplate（推荐使用）。下面分别详细介绍Spring是如何通过该类实现事务管 2.声明式事务：可知编程式事务每次实现都要单独实现，但业务量大功能复杂时，使用编程式事务无疑是痛苦的，而声明式事务不同，声明式事务属于无侵入式，不会影响业务逻辑的实现。
spring jdbc与事务管理
最新发布
05-17
Spring JDBC 是 Spring Framework 提供的一种 JDBC 操作方式，它可以简化 JDBC 操作，并且提供了许多有用的特性，如异常转换、批处理、分页查询等。Spring JDBC 与事务管理密切相关，因为在实际应用中，数据操作常常需要保证事务的一致性。 Spring JDBC 提供了 JdbcTemplate 类，该类封装了 JDBC 操作，可以直接使用该类来进行数据库操作。在进行事务管理时，Spring 提供了声明式事务和编程式事务两种方式。 声明式事务是通过配置文件或注解来实现的，可以将事务管理与业务代码分离。在声明式事务中，需要使用 TransactionManager 和 TransactionInterceptor 这两个类来实现事务的管理。在配置文件中，可以通过 <tx:advice> 元素来定义事务拦截器，通过 <tx:attributes> 元素来定义具体的事务属性。 编程式事务则是通过代码来实现事务管理，需要手动创建事务、提交事务和回滚事务。在 Spring 中，可以使用 TransactionTemplate 类来实现编程式事务管理。该类提供了 execute() 方法，该方法内部会自动创建事务、执行业务代码，如果业务代码执行成功，则提交事务，否则回滚事务。 总之，Spring JDBC 与事务管理紧密相连，Spring 提供了丰富的事务管理方式，开发者可以根据具体需求选择不同的方式来管理事务。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值