Spring-事务

最新推荐文章于 2024-04-17 20:29:08 发布

林⁣熙

最新推荐文章于 2024-04-17 20:29:08 发布

阅读量316

点赞数

分类专栏： Spring 文章标签： spring 数据库事务

本文链接：https://blog.csdn.net/lx1315998513/article/details/106842098

版权

Spring 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

spring整合事务

事务四性质：原子性、持久性、一致性、隔离性

注解方式

添加Aop依赖

<!-- spring aop支持 -->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-aop</artifactId>
	<version>${spring.version}</version>
</dependency>
<!-- aspectj支持 -->
<dependency>
	<groupId>org.aspectj</groupId>
	<artifactId>aspectjweaver</artifactId>
	<version>1.8.7</version>
</dependency>

添加事务管理器

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans
				http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
				http://www.springframework.org/schema/context
				http://www.springframework.org/schema/context/spring-context-4.3.xsd
				http://www.springframework.org/schema/tx
    			http://www.springframework.org/schema/tx/spring-tx-4.3.xsd
				http://www.springframework.org/schema/aop
				http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
 
	<!-- 定义事务管理器 -->
	<bean id="transactionManager" 		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="数据源名称" />
	</bean>
	<!--使用注释事务 -->
	<tx:annotation-driven transaction-manager="transactionManager" />
</beans>

添加@Transactional

声明式事务

添加依赖

<!-- spring aop支持 -->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-aop</artifactId>
	<version>${spring.version}</version>
</dependency>
<!-- aspectj支持 -->
<dependency>
	<groupId>org.aspectj</groupId>
	<artifactId>aspectjweaver</artifactId>
	<version>1.8.7</version>
</dependency>

配置事务管理器

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans
				http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
				http://www.springframework.org/schema/context
				http://www.springframework.org/schema/context/spring-context-4.3.xsd
				http://www.springframework.org/schema/tx
    			http://www.springframework.org/schema/tx/spring-tx-4.3.xsd
				http://www.springframework.org/schema/aop
				http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
 
	<!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="数据源名称" />
	</bean>
	<!--事务通知-->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="方法名*" propagation="REQUIRED" read-only="false" rollback-for="java.lang.Exception" />
		 </tx:attributes>
	</tx:advice>
	<!-- 自动代理 -->
	<aop:aspectj-autoproxy proxy-target-class="true" />

	<!-- 事务处理 -->
	<aop:config>
		<!--切点-->
		<aop:pointcut id="pc" expression="表达式" />
		<!--切点通知-->
		<aop:advisor pointcut-ref="pc" advice-ref="txAdvice" />
	</aop:config>
</beans>

事务常用属性

read-only
指定事务是否为只读事务，默认值为 false；为了忽略那些不需要事务的方法，比如读取数据，可以设置 read-only 为 true。

propagation
事务的传播行为，默认值为 REQUIRED。

常量	含义
Propagation.REQUIRED	如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。这是默认值。
Propagation.REQUIRES_NEW	创建一个新的事务，如果当前存在事务，则把当前事务挂起。
Propagation.SUPPORTS	如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
Propagation.NOT_SUPPORTED	以非事务方式运行，如果当前存在事务，则把当前事务挂起。
Propagation.NEVER	以非事务方式运行，如果当前存在事务，则抛出异常。
Propagation.MANDATORY	如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
Propagation.NESTED	如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于Propagation.REQUIRED

rollbackFor
用于指定能够触发事务回滚的异常类型，如果有多个异常类型需要指定，各类型之间可以通过逗号分隔。{xxx1.class, xxx2.class,……}t
注意
@Transactional注解默认支持运行时异常。对于非运行时异常并不支持，所以需指定以上属性
noRollbackFor
抛出 no-rollback-for 指定的异常类型，不回滚事务。{xxx1.class, xxx2.class,……}

新建maven项目，添加依赖和构建项目：

	<properties>
		<spring.version>4.3.12.RELEASE</spring.version>
	</properties>
	<dependencies>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<!-- spring aop支持 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<!-- aspectj支持 -->
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.8.7</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<!-- 添加MySQL数据库驱动依赖包. -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.30</version>
		</dependency>

		<!-- druid 连接池 -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.0.18</version>
		</dependency>

	</dependencies>
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<!-- 代码检错版本号 -->
					<source>1.8</source>
					<!-- 代码编译版本号 -->
					<target>1.8</target>
					<!--项目字符集 -->
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
		</plugins>
	</build>

新建bean xml config文件，添加对象：


	<!-- 扫描包 -->
	<context:component-scan base-package="com"></context:component-scan>

	<!-- 导入配置文件 -->
	<context:property-placeholder
		location="classpath:jdbc.properties" />

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


	<!--使用注释事务 -->
	<tx:annotation-driven
		transaction-manager="transactionManager" />

	<!-- 德鲁伊数据库连接池 -->
	<bean id="dataSource"
		class="com.alibaba.druid.pool.DruidDataSource" init-method="init"
		destroy-method="close">
		<!-- 基本属性 url、user、password -->
		<property name="driverClassName"
			value="${spring.datasource.driver-class-name}" />
		<property name="url" value="${spring.datasource.url}" />
		<property name="username"
			value="${spring.datasource.username}" />
		<property name="password"
			value="${spring.datasource.password}" />
		<!-- 配置监控统计拦截的filters -->
		<property name="filters" value="stat" />
		<!-- 配置初始化大小、最小、最大 -->
		<property name="maxActive" value="20" />
		<property name="initialSize" value="1" />
		<property name="minIdle" value="1" />

		<!-- 配置获取连接等待超时的时间 -->
		<property name="maxWait" value="60000" />

		<!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
		<property name="timeBetweenEvictionRunsMillis" value="60000" />

		<!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
		<property name="minEvictableIdleTimeMillis" value="300000" />

		<property name="testWhileIdle" value="true" />
		<property name="testOnBorrow" value="false" />
		<property name="testOnReturn" value="false" />

		<!-- 打开PSCache，并且指定每个连接上PSCache的大小 -->
		<property name="poolPreparedStatements" value="true" />
		<property name="maxOpenPreparedStatements" value="20" />
	</bean>


	<bean id="jdbcTemplate"
		class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>

	</bean>

properties配置文件：

spring.datasource.driver-class-name = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://127.0.0.1:3306/j200106?useunicode=true&characterEncoding=utf8&useSSL=true
spring.datasource.username = root
spring.datasource.password = 123456

实体类：

package com.pojo;

import java.util.Date;

public class User {
	//int不能传空，interger能传空。
	private Integer id;
	private String name;
	private Integer age;
	private String sex;
	private Date birth;
	private String pwd;
	private String icon;

	private Integer 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 Integer getAge() {
		return age;
	}

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

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public Date getBirth() {
		return birth;
	}

	public void setBirth(Date birth) {
		this.birth = birth;
	}

	public String getPwd() {
		return pwd;
	}

	public void setPwd(String pwd) {
		this.pwd = pwd;
	}

	public String getIcon() {
		return icon;
	}

	public void setIcon(String icon) {
		this.icon = icon;
	}

	public Integer getMoney() {
		return money;`package com.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.pojo.User;

//spring的注释层级
//controller 控制层，servlet，就是用于接受请求的
//service    业务逻辑--就会出现事务的问题了，一般就是在业务逻辑层添加事务功能
//Respository数据库访问
@Service
public class UserServiceImpl implements UserService {// 业务逻辑层的代码

	// 自动注入 bytype/byname
	// 自动注入也有注解@autowired
	// 自动注入了之后jdbctemplate属性就有对象了，就可以直接使用了。
	@Autowired
	private JdbcTemplate jdcTemplate;

	@Override
	@Transactional // rollback回滚 什么异常不回滚 (noRollbackFor = { ArithmeticException.class })
	public void zhuanzhang() {
		// 编写转账的业务
		// 用户a转账给用户B

		User userA = (User) jdcTemplate.queryForObject("select * from user where id = ? ",
				new BeanPropertyRowMapper(User.class), 1);

		User userB = (User) jdcTemplate.queryForObject("select * from user where id = ? ",
				new BeanPropertyRowMapper(User.class), 2);

		// 开始转账，A转B1000
		userA.setMoney(userA.getMoney() - 1000);
		userB.setMoney(userB.getMoney() + 1000);

		System.out.println(userA);
		System.out.println(userB);

		jdcTemplate.update("update user set money= ? where id = ? ", userA.getMoney(), 1);
		System.out.println(1 / 0);
		jdcTemplate.update("update user set money= ? where id = ? ", userB.getMoney(), 2);

	}

}
`
	}

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

	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", age=" + age + ", sex=" + sex + ", birth=" + birth + ", pwd="
				+ pwd + ", icon=" + icon + ", money=" + money + "]";
	}

}

服务层接口：

package com.service;

public interface UserService {
	void zhuanzhang();
}

服务层实现类：

package com.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.pojo.User;

//spring的注释层级
//controller 控制层，servlet，就是用于接受请求的
//service    业务逻辑--就会出现事务的问题了，一般就是在业务逻辑层添加事务功能
//Respository数据库访问
@Service
public class UserServiceImpl implements UserService {// 业务逻辑层的代码

	// 自动注入 bytype/byname
	// 自动注入也有注解@autowired
	// 自动注入了之后jdbctemplate属性就有对象了，就可以直接使用了。
	@Autowired
	private JdbcTemplate jdcTemplate;

	@Override
	@Transactional // rollback回滚 什么异常不回滚 (noRollbackFor = { ArithmeticException.class })
	public void zhuanzhang() {
		// 编写转账的业务
		// 用户a转账给用户B

		User userA = (User) jdcTemplate.queryForObject("select * from user where id = ? ",
				new BeanPropertyRowMapper(User.class), 1);

		User userB = (User) jdcTemplate.queryForObject("select * from user where id = ? ",
				new BeanPropertyRowMapper(User.class), 2);

		// 开始转账，A转B1000
		userA.setMoney(userA.getMoney() - 1000);
		userB.setMoney(userB.getMoney() + 1000);

		System.out.println(userA);
		System.out.println(userB);

		jdcTemplate.update("update user set money= ? where id = ? ", userA.getMoney(), 1);
		System.out.println(1 / 0);
		jdcTemplate.update("update user set money= ? where id = ? ", userB.getMoney(), 2);

	}

}

@Resource的作用相当于@Autowired，只不过@Autowired按byType自动注入，而@Resource默认按 byName自动注入罢了。@Resource有两个属性是比较重要的，分是name和type，Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性，这时将通过反射机制使用byName自动注入策略。

@Autowired按byType自动注入
@Resource默认按 byName自动注入，有两个属性是比较重要的，分是name和type，适用于byType和byName（2中注入都支持）

注解支持加到方法或者类型上面，都是可以支持的。事务。
或者写在被实现的接口上面。。。。！！
接口被实现后类都会实现拿过来这个注解的
功能。

事务的传播行为

bean对象：

	<context:component-scan base-package="com.liuxi"></context:component-scan>

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

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


	<!--事务通知 -->
	<tx:advice id="txAdvice"
		transaction-manager="transactionManager">
		<tx:attributes>
<!-- 			<tx:method name="zhuanzhang" propagation="REQUIRED" read-only="false" rollback-for="java.lang.Exception" /> -->
			<tx:method name="insert" propagation="SUPPORTS"
				read-only="false" rollback-for="java.lang.Exception" />

		</tx:attributes>


	</tx:advice>
	<!-- 自动代理 -->
	<aop:aspectj-autoproxy proxy-target-class="true" />

	<!-- 事务处理 -->
	<aop:config>
		<!--切点 -->
		<aop:pointcut id="pc"
			expression="execution(* com.liuxi.service.*.*(..))" />
		<!--切点通知 -->
		<aop:advisor pointcut-ref="pc" advice-ref="txAdvice" />
	</aop:config>



	<!--使用注释事务 -->
	<tx:annotation-driven
		transaction-manager="transactionManager" />



	<bean id="dataSource"
		class="com.alibaba.druid.pool.DruidDataSource" init-method="init"
		destroy-method="close">
		<!-- 基本属性 url、user、password -->
		<property name="driverClassName"
			value="${spring.datasource.driver-class-name}" />
		<property name="url" value="${spring.datasource.url}" />
		<property name="username"
			value="${spring.datasource.username}" />
		<property name="password"
			value="${spring.datasource.password}" />
		<!-- 配置监控统计拦截的filters -->
		<property name="filters" value="stat" />
		<!-- 配置初始化大小、最小、最大 -->
		<property name="maxActive" value="20" />
		<property name="initialSize" value="1" />
		<property name="minIdle" value="1" />

		<!-- 配置获取连接等待超时的时间 -->
		<property name="maxWait" value="60000" />

		<!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
		<property name="timeBetweenEvictionRunsMillis" value="60000" />

		<!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
		<property name="minEvictableIdleTimeMillis" value="300000" />

		<property name="testWhileIdle" value="true" />
		<property name="testOnBorrow" value="false" />
		<property name="testOnReturn" value="false" />

		<!-- 打开PSCache，并且指定每个连接上PSCache的大小 -->
		<property name="poolPreparedStatements" value="true" />
		<property name="maxOpenPreparedStatements" value="20" />
	</bean>


	<bean id="jdbcTemplate"
		class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>

	</bean>

UserService：

package com.liuxi.service;

import org.springframework.stereotype.Component;

@Component
public interface UserService {
	void zhuanzhang();

	void insert();
}

实现类：

package com.liuxi.service;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.liuxi.pojo.User;

//spring的注释层级
//controller 控制层，servlet，就是用于接受请求的
//service    业务逻辑--就会出现事务的问题了，一般就是在业务逻辑层添加事务功能
//Respository数据库访问
@Service
public class UserServiceImpl implements UserService {// 业务逻辑层的代码

	// 自动注入 bytype/byname
	// 自动注入也有注解@autowired
	// 自动注入了之后jdbctemplate属性就有对象了，就可以直接使用了。
	@Resource
	private JdbcTemplate jdcTemplate;

	@Resource
	private UserService userService;

	@Override
//	@Transactional // rollback回滚 什么异常不回滚 (noRollbackFor = { ArithmeticException.class })
	public void zhuanzhang() {
		// 编写转账的业务
		// 用户a转账给用户B

		User userA = (User) jdcTemplate.queryForObject("select * from user where id = ? ",
				new BeanPropertyRowMapper(User.class), 1);

		User userB = (User) jdcTemplate.queryForObject("select * from user where id = ? ",
				new BeanPropertyRowMapper(User.class), 2);

		// 开始转账，A转B1000
		userA.setMoney(userA.getMoney() - 1000);
		userB.setMoney(userB.getMoney() + 1000);

		System.out.println(userA);
		System.out.println(userB);

		jdcTemplate.update("update user set money= ? where id = ? ", userA.getMoney(), 1);
		System.out.println(1 / 0);
		jdcTemplate.update("update user set money= ? where id = ? ", userB.getMoney(), 2);

		userService.insert();
	}

//	事务四性质：原子性 要么执行要么不执行、持久性 数据保存在数据库中、隔离性 、一致性 前后一致。
	public void insert() {
		jdcTemplate.update("update user set money= ? where id = ? ", 1000, 3);
		System.out.println(1 / 0);
		jdcTemplate.update("update user set money= ? where id = ? ", 1000, 4);
	}

}