JAVAWEB开发之Spring详解之——Spring事务管理详解（四种事务管理方式）

最新推荐文章于 2022-01-28 17:45:32 发布
最新推荐文章于 2022-01-28 17:45:32 发布
阅读量1.2k 收藏 4
点赞数 3
文章标签： 数据库 java

事务：

事务：是逻辑上一组操作，要么全都成功，要么全都失败。
事务特性：ACID
  • 原子性: 事务不可分割。
  • 一致性: 事务执行的前后，数据完整性保持一致。
  • 隔离性: 一个事务执行的时候，不应该受到其他事务的干扰。
  • 持久性: 一旦结束，数据就永久的保存到了数据库。
如果不考虑隔离性，会出现以下问题：
  • 脏读: 一个事务读到了另一个事务未提交的数据。
  • 不可重复读: 一个事务读到了另一个事务已经提交的数据(update) 导致一个事务中多次查询结果不一致。
  • 虚读: 一个事务读到了另一个事务已经提交的数据(insert) 到最后一个事务多次查询结果不一致。
事务的隔离级别：
  • 未提交读(Read uncommitted): 以上情况都有可能发生。
  • 已提交读(Read committed): 避免脏读，但是不可重复读、虚读有可能发生。
  • 可重复读(Read Repeatable): 避免脏读，不可重复读，但是虚读有可能发生。
  • 串行的(Serizable): 避免以上所有情况。

Spring提供的事务管理的API

分层开发中：事务处在Service层
Spring事务管理高层抽象主要包括3个接口:
  • PlatformTransactionManager 事务管理器
  • TransactionDefinition 事务定义信息(隔离、传播‘超时、只读)
  • TransactionStatus 事务具体运行状态
如下图所示：

PlatformTransactionManager: 平台事务管理器
  • commit(TransactionStatus status)
  • getTransaction(TransactionDefinition definition)
  • rollback(TransactionStatus status)
TransactionDefinition: 事务定义
  • ISOLATION_XXX: 事务隔离级别。
  • PROPAGATION_XXX: 事务的传播行为(不是JDBC中特有的，为了解决实际开发的问题)。
TransactionStatus: 事务状态
  • 是否有保存点
  • 是否是一个新的事务
  • 事务是否已经提交
关系: PlatformTransactionManager通过TransactionDefinition设置事务相关信息管理事务，管理事务过程中，产生一些事务状态，状态由TransactionStatus记录。
API详解：

PlatformTransactionManager

Spring为不同的持久化框架提供了不同PlatformTransactionManager接口的实现


TransactionDefinition(定义事务的隔离级别和传播行为)

事务的隔离级别: 分为4种
如下图所示：

脏读: 一个事务读取到了另一个事务改写但还未提交的数据，如果这些数据回滚，则读取到的数据是无效的。
不可重复读:在同一个事务中，多次读取同一数据返回的结果有所不同。换句话说，后续读取可以读取到另一事务已经提交的更新数据。相反，" 可重复读 " 在同一事务中多次读取数据时能够保证所读取的数据是一样的，也就是后续读取不能读取到另一事务已经提交的更新数据。
幻读: 即虚读，一个事务读取了几行记录后，另一个事务插入一些记录，欢度就发生了。在后续的查询中，第一个事务就会发现原来没有的记录。
事务的传播行为（七种）
事务的传播行为:(不是JDBC事务管理的范畴，是用来解决开发实际的问题)传播行为主要用来解决业务层之间调用的事务关系。一般事务是开启在Service层的，但是在开发场景中会出现一个业务层调用另一个业务层进行实现，如果这两个业务层都存在事务管理，这是就需要通过定义事务的传播行为来解决业务层之间调用的事务关系了。

假设Service有两个A和B涉及到调用关系(ServiceA中方法内部调用ServiceB中的方法)：

  • PROPAGATION_REQUIRED：支持当前的事务，如果不存在就创建一个。如果A有事务，B使用A的事务,如果A没有事务，B就开启一个新的事务(保证A和B在同一个事务中)。
  • PROPAGATION_SUPPORTS：支持当前事务，如果不存在就不使用事务。A、B：如果A有事务，B使用A的事务，如果A没有事务，B就不使用事务。
  • PROPAGATION_MANDATORY：支持当前的事务，如果不存在就会抛出异常。A、B: 如果A有事务,B使用A的事务,如果A没有事务则抛出异常。
  • PROPAGATION_REQUIRES_NEW：如果有事务存在，则挂起当前事务，创建一个新的事务。A、B: 如果A有事务，B将A的事务挂起,重新创建一个新的事务(保证A和B不在同一个事务中)。
  • PROPAGATION_NOT_SUPPORTED：以非事务的方式运行，如果有事务存在，挂起当前的事务。A、B:非事务的方式运行,A有事务就会挂起当前的事务。
  • PROPAGATION_NEVER：以非事务的方式运行，如果有事务存在则抛出异常。
  • PROPAGATION_NESTED：如果当前事务存在，则嵌套事务执行。它基于SavePoint(保存点)技术。A、B: A有事务,A执行事务之后的内容保存到SavePoint，若B事务有异常，由自己设置事务提交还是回滚。

特别注意：事务的传播行为是由被调用的一方的事务传播特性来决定的。
常用的事务传播行为只有三种(非常重要):
PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、PROPAGATION_NESTED
详解事务的传播行为：
对于PROPAGATION_REQUIRES_NEW行为如下代码存在调用关系 
ServiceA {
    /**  
     * 事务属性配置为 PROPAGATION_REQUIRED  
     */  
    void methodA() {   
        ServiceB.methodB();   
    }   
}   
  
ServiceB {
    /**  
     * 事务属性配置为 PROPAGATION_REQUIRES_NEW  
     */    
    void methodB() {   
    }  
}

这种情况下, 因为 ServiceB#methodB 的事务属性为 PROPAGATION_REQUIRES_NEW, 所以两者不会发生任何关系, ServiceA#methodA 和 ServiceB#methodB 不会因为对方的执行情况而影响事务的结果, 因为它们根本就是两个事务, 在 ServiceB#methodB 执行时 ServiceA#methodA 的事务已经挂起了，所谓的挂起就是暂停methodA中事务的执行，等待ServiceB#methodB中事务执行完毕 再继续执行。不管ServiceB#methodB是执行成功提交还是失败回滚，都丝毫不影响ServiceA#methodA事务的执行和提交。不管ServiceA#methodA是成功执行还是失败回滚也不会影响ServiceB#methodB的提交和执行(也就是说保证两个事务互不影响)

而PROPAGATION_NESTED嵌套事务如下所示：

ServiceA {
    /**  
     * 事务属性配置为 PROPAGATION_REQUIRED  
     */  
    void methodA() {   
        ServiceB.methodB();   
    }  
}   
  
ServiceB {
    /**  
     * 事务属性配置为 PROPAGATION_NESTED  
     */    
    void methodB() {   
    }   
}
现在的情况就变得比较复杂了, ServiceB#methodB 的事务属性被配置为 PROPAGATION_NESTED, 此时两者之间又将如何协作呢? ServiceB#methodB 如果 rollback, 那么内部事务(即 ServiceB#methodB) 将回滚到它执行前的 SavePoint(注意, 嵌套事务中最核心的概念), 而外部事务(即 ServiceA#methodA) 可以有以下两种处理方式:
1. 改写 ServiceA 如下 

ServiceA {   
       
    /**  
     * 事务属性配置为 PROPAGATION_REQUIRED  
     */  
    void methodA() {   
        try {   
            ServiceB.methodB();   
        } catch (SomeException) {   
            // 执行其他业务, 如 ServiceC.methodC();   
        }   
    }   
  
}
这种方式也是嵌套事务最有价值的地方, 它起到了分支执行的效果, 如果 ServiceB.methodB 失败, 那么执行 ServiceC.methodC(), 而 ServiceB.methodB 已经回滚到它执行之前的 SavePoint, 所以不会产生脏数据(相当于此方法从未执行过), 这种特性可以用在某些特殊的业务中, 而 PROPAGATION_REQUIRED 和 PROPAGATION_REQUIRES_NEW 都没有办法做到这一点

2. 代码不做任何修改, 那么如果内部事务(即 ServiceB#methodB) rollback, 那么首先 ServiceB.methodB 回滚到它执行之前的 SavePoint(在任何情况下都会如此), 外部事务(即 ServiceA#methodA) 将根据具体的配置决定自己是 commit 还是 rollback (+MyCheckedException ).

嵌套事务与新事务的区别：

PROPAGATION_REQUIRES_NEW 启动一个新的, 不依赖于环境的 "内部" 事务. 这个事务将被完全 committed 或 rolled back 而不依赖于外部事务, 它拥有自己的隔离范围, 自己的锁, 等等. 当内部事务开始执行时, 外部事务将被挂起, 内务事务结束时, 外部事务将继续执行.
另一方面, PROPAGATION_NESTED 开始一个 "嵌套的" 事务, 它是已经存在事务的一个真正的子事务. 嵌套事务开始执行时, 它将取得一个 savepoint. 如果这个嵌套事务失败, 我们将回滚到此 savepoint. 嵌套事务是外部事务的一部分, 只有外部事务结束后它才会被提交.
由此可见, PROPAGATION_REQUIRES_NEW 和 PROPAGATION_NESTED 的最大区别在于, PROPAGATION_REQUIRES_NEW 完全是一个新的事务, 而 PROPAGATION_NESTED 则是外部事务的子事务, 如果外部事务 commit, 嵌套事务也会被 commit, 这个规则同样适用于 roll back.

Spring中的事务管理方式：

Spring的事务管理分为两类:

编程式事务管理：手动编写代码完成事务管理。在实际开发中很少使用,通过TransactionTemplate手动管理事务。

声明式事务管理：不需要手动编写代码，通过配置实现。开发中推荐使用(代码的侵入性最小)。Spring的声明式事务是通过AOP实现的。

事务操作环境的搭建

CREATE TABLE `account` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL,
  `money` double DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
INSERT INTO `account` VALUES ('1', 'aaa', '1000');
INSERT INTO `account` VALUES ('2', 'bbb', '1000');
INSERT INTO `account` VALUES ('3', 'ccc', '1000');

创建一个WEB项目

导入相应的jar包

开发Spring必须的jar包

  • spring-beans-3.2.0.RELEASE.jar
  • spring-context-3.2.0.RELEASE.jar
  • spring-core-3.2.0.RELEASE.jar
  • spring-expression-3.2.0.RELEASE.jar

日志相关的jar

  • com.springsource.org.apache.commons.logging-1.1.1.jar
  • com.springsource.org.apache.log4j-1.2.15.jar

数据库相关的jar

  • spring-jdbc-3.2.0.RELEASE.jar (支持JDBC的包)
  • spring-tx-3.2.0.RELEASE.jar (涉及事务的包)
  • com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar (c3p0连接池的包)
  • mysql-connector-java-5.0.4-bin.jar (数据库驱动)

测试包

  • spring-test-3.2.0.RELEASE.jar (spring整合Junit4的测试包)

添加配置文件applicationContextX.xml、jdbc.properties、log4j.properties

jdbc.properties

jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql:///spring3_day03
jdbc.user = root
jdbc.password =root
log4j.properties 

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=info, stdout
创建类

AccountService、AccountDao以及实现类

在Spring中进行注册

	<!-- 业务层类 -->
	<bean id="accountService" class="spring3.transaction.demo.AccountServiceImpl">
		<!-- 在业务层注入Dao -->
		<property name="accountDao" ref="accountDao"/>
	</bean>
	
	<!-- 持久层类 -->
	<bean id="accountDao" class="spring3.transaction.demo1X.AccountDaoImpl">
		<!-- 注入连接池的对象,通过连接池对象创建模板. -->
		<property name="dataSource" ref="dataSource"/>
	</bean>

方式一: 手动编码的方式完成事务管理

需要事务管理器: 真正管理事务对象
第一步: 在Spring配置文件中注册事务管理器 
        <!-- 配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 需要注入连接池,通过连接池获得连接 -->
		<property name="dataSource" ref="dataSource"/>
	</bean>
第二步: 注册事务模板类(在事务模板类中还可以注入事务的隔离级别以及事务的传播行为等信息) 
        <!-- 事务管理的模板 -->
	<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
		<property name="transactionManager" ref="transactionManager"/>
	</bean>
第三步: 在业务层注入模板类(由模板类管理事务) 
        <!-- 业务层类 -->
	<bean id="accountService" class="spring3.transaction.demo1.AccountServiceImpl">
		<!-- 在业务层注入Dao -->
		<property name="accountDao" ref="accountDao"/>
		<!-- 在业务层注入事务的管理模板 -->
		<property name="transactionTemplate" ref="transactionTemplate"/>
	</bean>
第四步: 在业务层代码上使用模板 
public void transfer(final String from, final String to, final Double money) {
		transactionTemplate.execute(new TransactionCallbackWithoutResult() {
			@Override
			protected void doInTransactionWithoutResult(TransactionStatus status) {
				accountDao.out(from, money);
				int d = 1 / 0;
				accountDao.in(to, money);
			}
		});
	}
手动编码方式的缺点: 代码量增加，代码有侵入性。
手动编码实现的具体代码如下(在demo1包下新建类)：
AccountDao 
package spring3.transaction.demo1;

public interface AccountDao {
	/**
	 * 转出的方法
	 * @param from	:转出的人
	 * @param money	:要转账的金额
	 */
	public void out(String from, Double money);
	/**
	 * 转入的方法
	 * @param to	:转入的人
	 * @param money	:要转账的金额
	 */
	public void in(String to, Double money);
}
AccountDaoImpl 
package spring3.transaction.demo1;

import java.util.jar.Attributes.Name;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao  {
    
	/**
	 * 转出的方法
	 * @param from	:转出的人
	 * @param money	:要转账的金额
	 */
	public void out(String from, Double money){
		String sql = "update account set money = money - ? where name = ?";
		this.getJdbcTemplate().update(sql, money,from);
	}
	/**
	 * 转入的方法
	 * @param to	:转入的人
	 * @param money	:要转账的金额
	 */
	public void in(String to, Double money){
		String sql = "update account set money = money + ? where name = ?";
		this.getJdbcTemplate().update(sql, money,to);
	}

}
AccountService 
package spring3.transaction.demo1;

public interface AccountService {
	/**
	 * 转账的方法
	 * @param from:从哪转出
	 * @param to:转入给谁
	 * @param money:转账的金额
	 */
	public void transfer(String from, String to, Double money);
}
AccountServiceImpl 
package spring3.transaction.demo1;

import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

public class AccountServiceImpl implements AccountService {
	private AccountDao accountDao;
	private TransactionTemplate transactionTemplate;

	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}

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

	/**
	 * 转账的方法
	 * 
	 * @param from:从哪转出
	 * @param to:转入给谁
	 * @param money:转账的金额
	 */
	public void transfer(final String from, final String to, final Double money) {
		transactionTemplate.execute(new TransactionCallbackWithoutResult() {
			@Override
			protected void doInTransactionWithoutResult(TransactionStatus arg0) {
				accountDao.out(from, money);
				int d=1/0;
				accountDao.in(to, money);
			}
		});
	}

}
在src下新建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">

	<!-- 引入外部的属性文件 -->
	<context:property-placeholder location="classpath:jdbc.properties" />

	<!-- 配置c3p0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driver}" />
		<property name="jdbcUrl" value="${jdbc.url}" />
		<property name="user" value="${jdbc.user}" />
		<property name="password" value="${jdbc.password}" />
	</bean>

	<!-- 业务层类 -->
	<bean id="accountService" class="spring3.transaction.demo1.AccountServiceImpl">
		<!-- 在业务层注入Dao -->
		<property name="accountDao" ref="accountDao" />
		<!-- 在业务层注入事务的管理模板 -->
		<property name="transactionTemplate" ref="transactionTemplate" />
	</bean>

	<!-- 持久层类 -->
	<!-- 注入DataSource数据源 JdbcDaoSuppor会自动检测JdbcTemplate是否设置，如果没有则自动设置 -->
	<bean id="accountDao" class="spring3.transaction.demo1.AccountDaoImpl">
		<!-- 注入连接池对象，通过连接池对象创建JDBC模板 -->
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 事务管理模板 -->
	<bean id="transactionTemplate"
		class="org.springframework.transaction.support.TransactionTemplate">
		<!-- 注入事务管理器 必须注入的属性: 事务管理器-->
		<property name="transactionManager" ref="transactionManager" />
		<property name="isolationLevelName" value="ISOLATION_DEFAULT" />
		<property name="propagationBehaviorName" value="PROPAGATION_REQUIRED"/>
	</bean>

	<!-- 配置事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 需要注入连接池,通过连接池获取连接 -->
		<property name="dataSource" ref="dataSource" />
	</bean>
</beans>
测试代码如下 SpringTest1 
package spring3.transaction.demo1;

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

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest1 {
	@Autowired
	@Qualifier("accountService")
	private AccountService accountService;

	@Test
	public void demo1() {
		// 完成转账操作
		accountService.transfer("aaa", "bbb", 100d);
	}
}
发现往Service中注入事务模板后 执行时 代码回滚 查询表如下：

屏蔽掉service实现类中的异常代码(int d=1/0;)后运行

成功转账 如果不屏蔽异常 且不使用事务模板 则异常上面的代码能执行 出现了异常就会抛出 无法执行下面的转入代码，就会造成一方的钱被扣掉了，另一方还没收到钱。
注意事项：
在Service实现类中需要注入TransactionTemplate(事务模板)TransactionTemplate依赖于DataSourceTransactionManager(事务管理器)，而DataSourceTransactionManager依赖于DataSource构造
使用的是JdbcTemplate模板，因此Dao要继承自JdbcDaoSupport类 ，注入属性时只需要往Dao中注入DataSource即可，会自动创建JdbcTemplate模板
查看JdbcDaoSupport的源码如下： 
public abstract class JdbcDaoSupport extends DaoSupport {

	private JdbcTemplate jdbcTemplate;


	/**
	 * Set the JDBC DataSource to be used by this DAO.
	 */
	public final void setDataSource(DataSource dataSource) {
		if (this.jdbcTemplate == null || dataSource != this.jdbcTemplate.getDataSource()) {
			this.jdbcTemplate = createJdbcTemplate(dataSource);
			initTemplateConfig();
		}
	}
......
}
可以发现向继承自JdbcDaoSupport类的Dao注入DataSource时 会判断当前Dao的JdbcTemplate模板是否存在，如果不存在就会自动创建模板并完成初始化操作。

方式二: 声明式事务管理(原始方式)

使用原始的TransactionProxyFactoryBean
再导入AOP相关的jar包: com.springsource.org.aopalliance-1.0.0.jar、spring-aop-3.2.0.RELEASE.jar
新建包demo2，开发步骤如下：
第一步: 注册平台事务管理器 
        <!-- 事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 注入连接池 -->
		<property name="dataSource" ref="dataSource"/>
	</bean>
第二步: 创建业务层代理对象 
        <!-- 配置生成代理对象 -->
	<bean id="accountServiceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
		<!-- 目标对象 -->
		<property name="target" ref="accountService"/>
		<!-- 注入事务管理器 -->
		<property name="transactionManager" ref="transactionManager"/>
		<!-- 事务的属性设置 -->
		<property name="transactionAttributes">
			<props>
				<prop key="transfer">PROPAGATION_REQUIRED</prop>
			</props>
		</property>
	</bean>
第三步: 编写测试类
千万注意: 注入的是代理对象 
@Autowired
@Qualifier("accountServiceProxy")
private AccountService accountService;
prop格式: PROPAGATION,ISOLATION,readOnly,-Exception,+Exception
顺序：传播行为,隔离级别,事务是否只读,发生哪些异常可以回滚事务(默认所有异常都进行回滚),发生了哪些异常不会滚进行提交事务
示例代码如下：(demo2下的)
AccountDao 
package spring3.transaction.demo2;

public interface AccountDao {
	/**
	 * 转出的方法
	 * @param from	:转出的人
	 * @param money	:要转账的金额
	 */
	public void out(String from, Double money);
	/**
	 * 转入的方法
	 * @param to	:转入的人
	 * @param money	:要转账的金额
	 */
	public void in(String to, Double money);
}
AccountDaoImpl 
package spring3.transaction.demo2;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao  {
    
	/**
	 * 转出的方法
	 * @param from	:转出的人
	 * @param money	:要转账的金额
	 */
	public void out(String from, Double money){
		String sql = "update account set money = money - ? where name = ?";
		this.getJdbcTemplate().update(sql, money,from);
	}
	/**
	 * 转入的方法
	 * @param to	:转入的人
	 * @param money	:要转账的金额
	 */
	public void in(String to, Double money){
		String sql = "update account set money = money + ? where name = ?";
		this.getJdbcTemplate().update(sql, money,to);
	}

}
AccountService 
package spring3.transaction.demo2;

public interface AccountService {
	/**
	 * 转账的方法
	 * @param from:从哪转出
	 * @param to:转入给谁
	 * @param money:转账的金额
	 */
	public void transfer(String from, String to, Double money);
}
AccountServiceImpl 
package spring3.transaction.demo2;

public class AccountServiceImpl implements AccountService {

	private AccountDao accountDao;
	
	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}

	/**
	 * 转账的方法
	 * 
	 * @param from  :从哪转出
	 * @param to  :转入的人
	 * @param money:转账金额
	 */
	public void transfer(String from, String to, Double money) {
		accountDao.out(from, money);
		int d=1/0;
		accountDao.in(to, money);
	}

}
在src下新建applicationContext2.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">

	<!-- 引入外部的属性文件 -->
	<context:property-placeholder location="classpath:jdbc.properties" />

	<!-- 配置c3p0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driver}" />
		<property name="jdbcUrl" value="${jdbc.url}" />
		<property name="user" value="${jdbc.user}" />
		<property name="password" value="${jdbc.password}" />
	</bean>

	<!-- 业务层类 -->
	<bean id="accountService" class="spring3.transaction.demo2.AccountServiceImpl">
		<!-- 在业务层注入Dao -->
		<property name="accountDao" ref="accountDao" />
	</bean>

	<!-- 持久层类 -->
	<bean id="accountDao" class="spring3.transaction.demo2.AccountDaoImpl">
		<!-- 注入连接池对象,通过连接池对象创建模板 -->
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 注入连接池 -->
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 配置生成代理对象 -->
	<bean id="accountServiceProxy"
		class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
		<!-- 目标对象 -->
		<property name="target" ref="accountService" />
		<!-- 注入事务管理器对象 -->
		<property name="transactionManager" ref="transactionManager" />
		<!-- 事务的属性设置 -->
		<property name="transactionAttributes">
			<props>
				<!-- * 表示对目标对象的中的所有方法进行增强 -->
				<prop key="transfer">PROPAGATION_REQUIRED,ISOLATION_DEFAULT,+java.lang.ArithmeticException</prop>
			</props>
		</property>
	</bean>

</beans>
新建测试类SpringTest2 
package spring3.transaction.demo2;

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

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class SpringTest2 {
	@Autowired
	@Qualifier("accountServiceProxy")
	private AccountService accountService;

	@Test
	public void demo1() {
		accountService.transfer("aaa", "bbb", 100d);
	}
}
由于配置了一个除法异常提交事务的属性 所以当执行到异常时就会提交事务

方式三:声明式事务管理(自动代理:基于切面Aspect********)

开发步骤如下：新建package demo3
第一步:导入相应的jar包
需要在以上的基础上再导入AspectJ相关Jar包，AspectJ依赖于Spring Aop,所以除了需要导入aop和aop联盟的包之外，再导入Aspect的包(spring-aspects-3.2.0.RELEASE.jar和 com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar)
第二步: 引入相应约束(aop和tx的约束) 
<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:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd">
第三步: 注册事务管理器 
	<!-- 事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"/>
	</bean>
第四步:定义增强(事务管理) 
        <!-- 定义一个增强 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<!-- 增强(事务)的属性的配置 -->
		<tx:attributes>
			<!-- 
				isolation:DEFAULT	:事务的隔离级别.
				propagation			:事务的传播行为.
				read-only			:false.不是只读
				timeout				:-1
				no-rollback-for		:发生哪些异常不回滚
				rollback-for		:发生哪些异常回滚事务
			 -->
			<tx:method name="transfer"/>
		</tx:attributes>
	</tx:advice>
第五步: 定义AOP的配置(切点和通知的组合) 
        <!-- aop配置定义切面和切点的信息 -->
	<aop:config>
		<!-- 定义切点:哪些类的哪些方法应用增强 -->
		<aop:pointcut expression="execution(* spring3.transaction.demo3.AccountService+.*(..))" id="mypointcut"/>
		<!-- 定义切面: -->
		<aop:advisor advice-ref="txAdvice" pointcut-ref="mypointcut"/>
	</aop:config>
第六步: 编写测试类
注入Service对象，不需要再注入代理对象(生成这个类的时候已经是代理对象)
具体代码如下所示：
AccountDao 
package spring3.transaction.demo3;

public interface AccountDao {
	/**
	 * 转出的方法
	 * @param from	:转出的人
	 * @param money	:要转账的金额
	 */
	public void out(String from, Double money);
	/**
	 * 转入的方法
	 * @param to	:转入的人
	 * @param money	:要转账的金额
	 */
	public void in(String to, Double money);
}
AccountDaoImpl 
package spring3.transaction.demo3;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao  {
    
	/**
	 * 转出的方法
	 * @param from	:转出的人
	 * @param money	:要转账的金额
	 */
	public void out(String from, Double money){
		String sql = "update account set money = money - ? where name = ?";
		this.getJdbcTemplate().update(sql, money,from);
	}
	/**
	 * 转入的方法
	 * @param to	:转入的人
	 * @param money	:要转账的金额
	 */
	public void in(String to, Double money){
		String sql = "update account set money = money + ? where name = ?";
		this.getJdbcTemplate().update(sql, money,to);
	}

}
AccountService 
package spring3.transaction.demo3;

public interface AccountService {
	/**
	 * 转账的方法
	 * @param from:从哪转出
	 * @param to:转入给谁
	 * @param money:转账的金额
	 */
	public void transfer(String from, String to, Double money);
}
AccountServiceImpl 
package spring3.transaction.demo3;

public class AccountServiceImpl implements AccountService {

	private AccountDao accountDao;

	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}

	/**
	 * 转账的方法
	 * 
	 * @param from
	 *            :从哪转出
	 * @param to
	 *            :转入的人
	 * @param money:转账金额
	 */
	public void transfer(String from, String to, Double money) {
		accountDao.out(from, money);
		// int d=1/0;
		accountDao.in(to, money);
	}

}
在src下新建配置文件applicationContext3.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:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

	<!-- 引入外部属性文件 -->
	<context:property-placeholder location="classpath:jdbc.properties" />

	<!-- 配置c3p0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driver}" />
		<property name="jdbcUrl" value="${jdbc.url}" />
		<property name="user" value="${jdbc.user}" />
		<property name="password" value="${jdbc.password}" />
	</bean>

	<!-- 业务层类 -->
	<bean id="accountService" class="spring3.transaction.demo3.AccountServiceImpl">
		<!-- 在业务层注入Dao -->
		<property name="accountDao" ref="accountDao" />
	</bean>

	<!-- 持久层类 -->
	<bean id="accountDao" class="spring3.transaction.demo3.AccountDaoImpl">
		<!-- 注入连接池对象,通过连接池对象创建模板 -->
		<property name="dataSource" ref="dataSource" />
	</bean>

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

	<!-- 定义一个增强 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<!-- 增强事务的属性配置 -->
 		<!-- 
			isolation:DEFAULT	:事务的隔离级别.
			propagation			:事务的传播行为.
			read-only			:false.不是只读
			timeout				:-1
			no-rollback-for		:发生哪些异常不回滚
			rollback-for		:发生哪些异常回滚事务
		 -->
		<tx:attributes>
			<tx:method name="transfer" isolation="DEFAULT" propagation="REQUIRED"
				read-only="false" />
		</tx:attributes>
	</tx:advice>

	<!-- aop配置定义切面和切点信息 -->
	<aop:config>
		<!-- 定义切点: 哪些类的哪些方法应用增强 -->
		<aop:pointcut
			expression="execution(* spring3.transaction.demo3.AccountService+.*(..))"
			id="myPointcut" />
		<!-- 定义切面 -->
		<aop:advisor advice-ref="txAdvice" pointcut-ref="myPointcut" />
	</aop:config>

</beans>
新建测试类SpringTest3 
package spring3.transaction.demo3;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
/**
 * 声明式事务的使用:基于切面的
 * @author liuxun
 *
 */
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext3.xml")
public class SpringTest3 {
	@Autowired
	@Qualifier("accountService")
	AccountService accountService;

	@Test
	public void demo1() {
		accountService.transfer("aaa", "bbb", 100d);
	}

}
打开AccountServiceImpl中被屏蔽的异常 测试如下

把异常代码屏蔽后运行如下

方式四:基于注解的事务管理

开发步骤:
第一步: 事务管理器 
        <!-- 事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"/>
	</bean>
第二步: 注解事务 
        <!-- 开启注解的事务管理 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>
第三步: 在Service上使用注解@Transactional
具体代码如下：
再新建一个包demo4，新建AccountDao、AccountDaoImpl、AccountService 代码和demo3相同
AccountServiceImpl 
package spring3.transaction.demo4;

import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Transactional(isolation = Isolation.DEFAULT, propagation = Propagation.REQUIRED, readOnly = false)
public class AccountServiceImpl implements AccountService {

	private AccountDao accountDao;

	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}

	/**
	 * 转账的方法
	 * 
	 * @param from
	 *            :从哪转出
	 * @param to
	 *            :转入的人
	 * @param money:转账金额
	 */
	public void transfer(String from, String to, Double money) {
		accountDao.out(from, money);
		// int d=1/0;
		accountDao.in(to, money);
	}

}
在src下新建applicationContext4.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:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

	<!-- 引入外部属性文件 -->
	<context:property-placeholder location="classpath:jdbc.properties" />

	<!-- 配置c3p0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driver}" />
		<property name="jdbcUrl" value="${jdbc.url}" />
		<property name="user" value="${jdbc.user}" />
		<property name="password" value="${jdbc.password}" />
	</bean>

	<!-- 业务层类 -->
	<bean id="accountService" class="spring3.transaction.demo4.AccountServiceImpl">
		<!-- 在业务层注入Dao -->
		<property name="accountDao" ref="accountDao" />
	</bean>

	<!-- 持久层类 -->
	<bean id="accountDao" class="spring3.transaction.demo4.AccountDaoImpl">
		<!-- 注入连接池对象,通过连接池对象创建模板 -->
		<property name="dataSource" ref="dataSource" />
	</bean>

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

	<!-- 开启注解的事务管理 -->
	<!-- 若不配置 "transaction-manager"属性，默认查找名称为transactionManager的事务管理器Bean -->
	<tx:annotation-driven transaction-manager="transactionManager" />

</beans>
新建SpringTest4测试类 
package spring3.transaction.demo4;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
/**
 * 声明式事务的使用:基于切面的
 * @author liuxun
 *
 */
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext4.xml")
public class SpringTest4 {
	@Autowired
	@Qualifier("accountService")
	AccountService accountService;

	@Test
	public void demo1() {
		accountService.transfer("aaa", "bbb", 100d);
	}

}
运行


iteye_18817
关注
Java中的事务管理详解
C_V_Better的博客
03-26 664
事务管理是Java开发中确保数据一致性和完整性的重要手段。编程式事务管理提供了精细的控制，适用于特殊需求的场景；声明式事务管理则通过框架自动管理事务，简化了代码，提高了开发效率。根据具体的应用场景和需求，选择合适的事务管理方式，可以更好地保证数据的可靠性和稳定性。希望本文的示例和讲解对您有所帮助，如果您在事务管理方面有任何疑问，欢迎随时交流探讨！
JAVAWEB开发之Spring详解之——Spring的入门以及IOC容器装配Bean(xml和注解的方式)、Spring整合web开发、整合Junit4测试
04-22 2969
Spring框架学习路线 Spring的IOCSpring的AOP，AspectJSpring的事务管理，三大框架的整合 Spring框架概述 什么是Spring？  Spring是分层的JavaSE/EE full-stack(一站式)轻量级开源框架。 所谓分层： SUN提供的EE的三层结构：web层、业务层、数据访问层(也称持久层，集成层)。Struts2是we
Spring事务操作示例（四种方式）
07-04
Spring事务操作示例（四种方式），包含完整代码和数据库文件（基于MySQL，在项目sql文件夹中），可运行，学习Spring事务详见博客：http://blog.youkuaiyun.com/daijin888888/article/details/51822257
Spring的四种事务管理（一种编程式事务+三种声明事务）<学习随笔>
强强强子的博客
09-04 1万+
Spring的4种事务管理（1种编程式事务+三种声明事务） 一、Spring事务的介绍 二、编程式事务xml的配置 注入后直接在service层调用模板的方法使用 三、基于AOP方式的声明式事务管理 prop的具体配置 使用AOP声明式事务是时service层必须注入代理类 四、基于Asp
揭开Spring事务处理
JDream314的专栏
10-12 4万+
Spring事务处理你未关注过的原理 本文对Spring实现事务处理的真正原理进行追究，从而从中提炼出一些见解。   说到Spring事务原理，百度一下最多的就是Spring的AOP了，本文当然不是给你将AOP的原理，如果是这样，我也就没必要写这篇文章了，直接转载一篇就行了。借助Spring的AOP的原理，提出一个问题。             此处先粘贴出Spring事务需要的配置内
Spring事务管理详解_基本原理_事务管理方式
niceyoo的博客
04-07 210
Spring事务管理详解_基本原理_事务管理方式 1. 事务的基本原理 Spring事务的本质其实就是数据库对事务的支持，使用JDBC的事务管理机制,就是利用java.sql.Connection对象完成对事务的提交，那在没有Spring帮我们管理事务之前，我们要怎么做。 Connection conn = DriverManager.ge...
java web 事务详解
zhuh的专栏
11-19 310
事务的ACID 答：  - 原子性(Atomic)：事务中各项操作，要么全做要么全不做，任何一项操作的失败都会导致整个事务的失败；  - 一致性(Consistent)：事务结束后系统状态是一致的；  - 隔离性(Isolated)：并发执行的事务彼此无法看到对方的中间状态；  - 持久性(Durable)：事务完成后所做的改动都会被持久化，即使发生灾难性的失败。通过日志和同步备份可以在故障发生后...
JAVAWEB开发之Spring详解之——AOP底层剖析(基于JDK和cglib)、Spring中的AOP以及基于AspectJ的AOP实现、Spring的JDBCTemplate详解
04-27 1429
AOP概述  什么是AOP？ AOP—Aspect Oriented Programming 面向切面编程。AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码(性能监视、事务管理、安全检查、缓存)。Spring AOP使用后纯Java实现，不需要专门的编译工程和类加载器，在运行期间通过代理方式向目标类组织增强代码。AspectJ是一个基于Java语言的AOP框架，Spring2.
JAVAWEB开发之权限管理(一)——权限管理详解(权限管理原理以及方案)、不使用权限框架的原始授权方式详解
热门推荐
07-13 9万+
知识清单 1.了解基于资源的权限管理方式 2. 掌握权限数据模型 3. 掌握基于url的权限管理(不使用Shiro权限框架的情况下实现权限管理) 4. shiro实现用户认证 5. shiro实现用户授权 6. shiro与企业web项目整合开发的方法 权限管理原理知识 什么是权限管理 只要有用户参与的系统一般都要有权限管理，权限管理实现对用户访问系统的控制。按照安全规则或安全策
独门架构——JavaWeb开发应用详解（电子版）
07-18
《独门架构——JavaWeb开发应用详解》是一本深度探讨JavaWeb开发技术的专业书籍，旨在帮助已经具备Java基础知识的学习者和开发者进一步提升在Web领域的专业技能。本书详细讲解了JavaWeb开发中的各种核心概念、技术和...
JavaWeb开发框架与核心技术资源详解
最新发布
02-25
接下来阐述了JavaWeb的核心技术资源，涉及Servlet作为核心组件及其资源、简化的Servlet-JSP、轻量级开发框架-Spring，重点讲述了SpringMVC模块；此外提到了进阶部分的内容，像是JDBC的运用、前端技术配合后端的互动...
Java Web(四)：事务控制
yu1755128147的博客
10-15 567
一、JDBC事务的概述 1、事务定义：一个包含多个步骤的业务操作。如果这个业务操作被事务管理，则这多个步骤要么同时成功，要么同时失败。 2、使用Connection对象管理事务： 开启事务：voidsetAutoCommit(booleanautoCommit) 提交事务：void commit() 回滚事务： void rollback(); 二、JDBC事务操作 1、数据库配置...
Spring事务处理的两种方式 .
vincent
08-06 838
spring事务管理： 可以通过两种方式实现： 一是用AOP来控制事务： -->   二是用事务拦截器的方式来控制事务： PROPA
Spring中的几种事务处理方式
wangheid的专栏
08-31 3757
<br /> 1、用原始的transactionfactorybean的,代理dao事务处理 <br /> 2、用aop:config声明要进行事务增强的切面,用tx:advice声明具体方法的事务属性,及应用到的事务管理器 <br /> 3、使用@transactional注解配置声明事务 <br /> 如有一代表用户的域对象user: <br /> package com.domain; <br /> import java.io.serializable; <br />
Spring事务处理
qq_43788522的博客
07-06 1613
1、什么是事务？ 保证业务操作完整性的一种数据库机制（事务由数据库控制，java代码只是对这种事务的调用） 事务的四个特点 A（原子性） C（一致性） I（隔离性） D（持久性） 如何控制事务 采用不同的持久化技术，控制事务的方式是不同的 jdbc Connection.setAutoCommit(false)` Connection.commit(); Connection.rollback(); Mybatis： Mybatis自动开启事务，你只要关心事务提交和回滚 sqlSessio
JavaWeb事务处理
gx_hxl的博客
06-23 1447
首先我们来了解一下事务的四大特性（ACID）： 1、原子性（Atomicity）： 原子是不可分割的执行单元，要么一起执行，要么不执行 2、一致性（Consistency）： 事务执行前后，数据的完整约束性不被破坏，典型的例子：银行转账 3、隔离性（Isolation）： 事务之间完全独立，互不影响，但是在事务四大特性中，隔离性并不是严格意义上的隔离，数据库定义了四种隔离级别，隔离级别...
Spring-----事务处理的两种方式
yangliye2020的博客
07-14 517
一、编程式事务处理 定义：通过业务层中注入事务管理器对象对事务进行控制的方式。 二、声明式事务处理 【重点使用】 定义：通过利用aop面向切面编程进行事务控制，并对事务属性在配置文件中完成细粒度配置 优点：通用； 减少代码冗余； 让程序员更专注于业务逻辑的编程； 便于代码维护和管理 开发： 1. mybatis将编程式事务处理中 环绕通知封装成一个通知类， 在spring.xml中可以直接根据<tx:advice&gt...
spring事务管理方式
先相信你自己，然后别人才会相信你。
08-06 2606
Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。 DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实际为SessionFactory，TransactionManager的实现为 HibernateTransactionManager。 根据代理机制的不同，总结
事务管理--(Spring两种方式)
S mile0804的博客
01-28 1万+
一、什么是事务？ 事务是由步数据库操作序列组成的逻辑执行单元，这系列操作要么全部执行，要么全部放弃执行 二、事务的特性（ACID） 1. 原子性 事务是一个不可分割的最小工作单位，事务中的操作要么都发生，要么都不发生 2. 一致性 事务必须是数据库从一个一致性的状态变换到另外一个一致性的状态 3. 持久性 事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来的其他操作和数据库故障不应该对其有任何影响 4. 隔离性 一个事务的执行不能被其他事务所干扰，即一个事务内部的操......
JavaWeb开发的智能社区管理系统功能详解
智能社区管理系统主要采用Java语言开发，使用Javaweb技术作为后端实现。这通常意味着使用Java的Servlet技术以及Java的Server Pages（JSP）技术来处理Web页面生成和服务器端逻辑。系统的前端页面开发则依赖于HTML、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值