使用spring框架实现数据库事务处理方式

2024-12-24 07:15:06

使用spring框架实现数据库事务处理

事务对于数据库来说是，是对sql语句的一系列操作，这些操作被组织成为一个事务。事务具有原子性的，要么全部执行，要么不执行。若事务中sql语句发生错误，事务需要对已经执行的sql进行回滚操作，撤销先前对数据库的操作，防止数据库出现错误状态。

JDBC对数据库事务处理的支持

jdbc本身提供了对数据库处理的支持，使用java.sql.Connection对象完成事务的提交。使用Connection提交数据库事务处理如下：

发现里面有一个方法叫setAutoCommit()，设置为true时，就是自动提交sql，如果设置为false时，sql语句的提交由程序负责，应用程序必须调用Commit方法，同时在执行sql语句异常处理块中调用rollback方法，对异常发生前进行的数据库进行回滚。

在企业级中，事务一般都是并发执行的，当事务并发执行时，就会发生数据库同步的问题，具体问题可分为下面四种类型：

脏读：
不可重复读：
丢失更新：
幻读：

为了解决上面的四种问题，解决事务并发的问题

JDBC定义了五种事务隔离级别来解决这些并发导致的问题

transaction_read_uncommitted:数据级别最低，俗称脏读，在没有提交数据时，就已经读取到已经更新的数据。
transaction_read_committed:当一个事务进行查询时，允许读取提交前的数据，数据提交后，当前查询就可以读取到数据，update数据的时候并不锁住表。(最长使用)
transaction_repeatable_read:当一个事务进行查询时，不允许读取其他事务更新的数据，可以读取其他事务新增的数据。
transaction_serializable:当一个事务进行查询时，不允许任何对这个事务进行查询，就是把并行改成了串行。不提倡使用。

在spring框架中调用一个数据库事务处理分三步走：

第一步就是配置数据源就是配置数据库的名称和密码，地址等。
第二步就是声明事务管理TransactionManagerspring框架提供了PlatformTransactionManager作为事务管理类的顶层接口，声明了初始化事务，提交事务，回滚事务等接口。接口实现由具体的数据库驱动类实现。具体包括DataTransactionManager等实现类。但是主要还是使用的是DataTransactionManager类。

定义可以执行事务的DAO类DAO提供了应用程序访问数据源必要的接口和方法。

spring 事务实现方式有哪些

编程式事务管理，

在代码中调用 commit()、rollback()等事务管理相关的方法

maven pom.xml文件

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-beans</artifactId>
	<version>4.2.4.RELEASE</version>
</dependency>

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

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-aop</artifactId>
	<version>4.2.4.RELEASE</version>
</dependency>

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-tx</artifactId>
	<version>4.2.4.RELEASE</version>
</dependency>

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-jdbc</artifactId>
	<version>4.2.4.RELEASE</version>
</dependency>

<!-- mysql驱动 -->
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>5.1.18</version>
</dependency>

编程式事务管理，可以通过 java.sql.Connection 控制事务。spring 配置文件

<?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">

	<bean id="driver" class="com.mysql.jdbc.Driver"></bean>

	<bean id="datasource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
		<constructor-arg index="0" name="driver" ref="driver" />
		<constructor-arg index="1">
			<value>jdbc:mysql://localhost:3306/test</value>
		</constructor-arg>
		<constructor-arg index="2">
			<value>root</value>
		</constructor-arg>
		<constructor-arg index="3">
			<value>root</value>
		</constructor-arg>
	</bean>
</beans>

测试代码

package constxiong.interview.transaction;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.sql.DataSource;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TransactionTest {

	public static void main(String[] args) throws Exception {
		testManualTransaction();//测试函数式控制事务
	}

	private static void testManualTransaction() throws SQLException {
		ApplicationContext context = new ClassPathXmlApplicationContext("spring_transaction.xml");
		DataSource ds = (DataSource)context.getBean("datasource");
		Connection conn = ds.getConnection();
		try {
			initTable(conn);//初始化表
			conn.setAutoCommit(false);//设置不自动提交事务
			queryUsers(conn);//查询打印用户表
			deleteUser(conn);//删除 id=1 用户
			conn.rollback();//回滚
			queryUsers(conn);//查询打印用户表
		} finally {
			conn.close();
		}
	}

	private static void initTable(Connection conn) throws SQLException {
		conn.createStatement().execute("drop table if exists user");
		conn.createStatement().execute("create table user(id int, username varchar(60)) ENGINE=InnoDB DEFAULT CHARSET=utf8 ");//是否支持事务与数据库引擎有关，此处删除 ENGINE=InnoDB DEFAULT CHARSET=utf8 可能不支持事务
		conn.createStatement().execute("insert into user values(1, 'user1')");
		conn.createStatement().execute("insert into user values(2, 'user2')");
	}

	private static void deleteUser(Connection conn) throws SQLException {
		conn.createStatement().execute("delete from user where id = 1");
	}

	private static void queryUsers(Connection conn) throws SQLException {
		Statement st = conn.createStatement();
		st.execute("select * from user");
		ResultSet rs = st.getResultSet();
		while (rs.next()) {
			System.out.print(rs.getString("id"));
			System.out.print(" ");
			System.out.print(rs.getString("username"));
			System.out.println();
		}
	}
}

删除用户语句回滚，打印出两个用户

1 user1

2 user2

1 user1

2 user2

TransactionProxyFactoryBean 的声明式事务管理

新增 UserDao 接口

package constxiong.interview.transaction;
import java.util.List;
import java.util.Map;
public interface UserDao {
	/**
	 * 查询用户
	 * @return
	 */
	public List<Map<String, Object>> getUsers();

	/**
	 * 删除用户
	 * @param id
	 * @return
	 */
	public int deleteUser(int id);
}

新增 UserDao 实现

package constxiong.interview.transaction;
import java.util.List;
import java.util.Map;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
public class UserDaoImpl extends JdbcDaoSupport implements UserDao {

	/**
	 * 查询用户
	 * @return
	 */
	public List<Map<String, Object>> getUsers() {
		String sql = "select * from user";
		return this.getJdbcTemplate().queryForList(sql);
	}

	/**
	 * 删除用户
	 * @param id
	 * @return
	 */
	public int deleteUser(int id){
		String sql = "delete from user where id = " + id;
		int result = this.getJdbcTemplate().update(sql);
		if (id == 1) {
			throw new RuntimeException();
		}
		return result;
	}
}

修改 spring 配置文件，添加事务管理器 DataSourceTransactionManager 和事务代理类 TransactionProxyFactoryBean

<?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">

	<bean id="driver" class="com.mysql.jdbc.Driver"></bean>

	<bean id="datasource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
		<constructor-arg index="0" name="driver" ref="driver" />
		<constructor-arg index="1">
			<value>jdbc:mysql://localhost:3306/test</value>
		</constructor-arg>
		<constructor-arg index="2">
			<value>root</value>
		</constructor-arg>
		<constructor-arg index="3">
			<value>root</value>
		</constructor-arg>
	</bean>

	<bean id="userDao" class="constxiong.interview.transaction.UserDaoImpl">
		<property name="dataSource" ref="datasource"></property>
	</bean>

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

	<bean id="userProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
		<property name="transactionManager" ref="tracnsactionManager"></property>
		<property name="target" ref="userDao"></property>
		<property name="transactionAttributes">
			<props>
				<!-- 主要 key 是方法
					ISOLATION_DEFAULT  事务的隔离级别
					PROPAGATION_REQUIRED  传播行为
				-->
				<!-- -Exception 表示发生指定异常回滚，+Exception 表示发生指定异常提交 -->
				<prop key="deleteUser">-java.lang.RuntimeException</prop>
			</props>
		</property>
	</bean>

</beans>

测试代码

package constxiong.interview.transaction;
import java.util.Map;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TransactionTest {
	static ApplicationContext context = new ClassPathXmlApplicationContext("spring_transaction.xml");
	public static void main(String[] args) throws Exception {
		testUseTransactionProxy(); //测试使用 spring TransactionProxyFactoryBean
	}

	private static void testUseTransactionProxy() {
		final UserDao userDao = (UserDao)context.getBean("userProxy");
		printUsers(userDao);//打印用户
		userDao.deleteUser(1);//删除 id=1 用户
	}

	private static void printUsers(UserDao userDao) {
		for (Map<String, Object> user : userDao.getUsers()) {
			System.out.println(user);
		}
	}
}

结果输出

{id=1, username=user1}
{id=2, username=user2}
Exception in thread "main" java.lang.RuntimeException
at constxiong.interview.transaction.UserDaoImpl.deleteUser(UserDaoImpl.java:28)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:302)
at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:190)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157)
at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:99)
at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:281)
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:96)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:208)
at com.sun.proxy.$Proxy3.deleteUser(Unknown Source)
at constxiong.interview.transaction.TransactionTest.testUseTransactionProxy(TransactionTest.java:32)
at constxiong.interview.transaction.TransactionTest.main(TransactionTest.java:13)

注解 @Transactional 的声明式事务管理

UserDaoImpl 删除用户方法添加注解 @Transactional(rollbackFor=RuntimeException.class) 出现 RuntimeException 回滚

package constxiong.interview.transaction;
import java.util.List;
import java.util.Map;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import org.springframework.transaction.annotation.Transactional;
public class UserDaoImpl extends JdbcDaoSupport implements UserDao {
	/**
	 * 查询用户
	 * @return
	 */
	public List<Map<String, Object>> getUsers() {
		String sql = "select * from user";
		return this.getJdbcTemplate().queryForList(sql);
	}

	/**
	 * 删除用户
	 * @param id
	 * @return
	 */
	@Transactional(rollbackFor=RuntimeException.class)
	public int deleteUser(int id){
		String sql = "delete from user where id = " + id;
		int result = this.getJdbcTemplate().update(sql);
		if (id == 1) {
			throw new RuntimeException();
		}
		return result;
	}
}

修改 spring 配置文件，开启 spring 的事务注解能力

<?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"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
	    http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

	<bean id="driver" class="com.mysql.jdbc.Driver"></bean>

	<bean id="datasource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
		<constructor-arg index="0" name="driver" ref="driver" />
		<constructor-arg index="1">
			<value>jdbc:mysql://localhost:3306/test</value>
		</constructor-arg>
		<constructor-arg index="2">
			<value>root</value>
		</constructor-arg>
		<constructor-arg index="3">
			<value>root</value>
		</constructor-arg>
	</bean>

	<bean id="userDao" class="constxiong.interview.transaction.UserDaoImpl">
		<property name="dataSource" ref="datasource"></property>
	</bean>

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

	<!-- 启用事务注解 -->
	<tx:annotation-driven transaction-manager="tracnsactionManager"/>
</beans>

测试代码

package constxiong.interview.transaction;
import java.util.Map;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TransactionTest {
	static ApplicationContext context = new ClassPathXmlApplicationContext("spring_transaction.xml");
	public static void main(String[] args) throws Exception {
		testAnnotationTransaction();
	}	

	private static void testAnnotationTransaction() {
		UserDao userDao = (UserDao)context.getBean("userDao");
		printUsers(userDao);
		userDao.deleteUser(1);
	} 

	private static void printUsers(UserDao userDao) {
		for (Map<String, Object> user : userDao.getUsers()) {
			System.out.println(user);
		}
	}
}

输出结果

{id=1, username=user1}
{id=2, username=user2}
Exception in thread "main" java.lang.RuntimeException
at constxiong.interview.transaction.UserDaoImpl.deleteUser(UserDaoImpl.java:30)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:302)
at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:190)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157)
at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:99)
at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:281)
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:96)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:208)
at com.sun.proxy.$Proxy5.deleteUser(Unknown Source)
at constxiong.interview.transaction.TransactionTest.testAnnotationTransaction(TransactionTest.java:20)
at constxiong.interview.transaction.TransactionTest.main(TransactionTest.java:13)

Aspectj AOP 配置（注解）事务

maven pom.xml 添加 Aspectj 的支持

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

去除 UserDaoImpl 注解@Transactional(rollbackFor=RuntimeException.class)

package constxiong.interview.transaction;
import java.util.List;
import java.util.Map;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
public class UserDaoImpl extends JdbcDaoSupport implements UserDao {
	/**
	 * 查询用户
	 * @return
	 */
	public List<Map<String, Object>> getUsers() {
		String sql = "select * from user";
		return this.getJdbcTemplate().queryForList(sql);
	}

	/**
	 * 删除用户
	 * @param id
	 * @return
	 */
	public int deleteUser(int id){
		String sql = "delete from user where id = " + id;
		int result = this.getJdbcTemplate().update(sql);
		if (id == 1) {
			throw new RuntimeException();
		}
		return result;
	}
}

修改 spring 配置文件，织入切面

<?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/tx
        http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
	    http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

	<bean id="driver" class="com.mysql.jdbc.Driver"></bean>

	<bean id="datasource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
		<constructor-arg index="0" name="driver" ref="driver" />
		<constructor-arg index="1">
			<value>jdbc:mysql://localhost:3306/test</value>
		</constructor-arg>
		<constructor-arg index="2">
			<value>root</value>
		</constructor-arg>
		<constructor-arg index="3">
			<value>root</value>
		</constructor-arg>
	</bean>

	<bean id="userDao" class="constxiong.interview.transaction.UserDaoImpl">
		<property name="dataSource" ref="datasource"></property>
	</bean>

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

	<tx:advice id="txAdvice" transaction-manager="tracnsactionManager">
		<tx:attributes>
			<!-- 为连接点指定事务属性 -->
			<tx:method name="deleteUser" rollback-for="java.lang.RuntimeException"/>
		</tx:attributes>
	</tx:advice>

	<aop:config>
		<!-- 切入点配置 -->
		<aop:pointcut id="point" expression="execution(* *constxiong.interview.transaction.UserDao.deleteUser(..))" />
		<aop:advisor advice-ref="txAdvice" pointcut-ref="point"/>
	</aop:config>
</beans>

测试代码

package constxiong.interview.transaction;
import java.util.Map;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TransactionTest {
	static ApplicationContext context = new ClassPathXmlApplicationContext("spring_transaction.xml");
	public static void main(String[] args) throws Exception {
		testAspectjTransaction();
	}	

	private static void testAspectjTransaction() {
		UserDao userDao = (UserDao)context.getBean("userDao");
		printUsers(userDao);
		userDao.deleteUser(1);
	} 

	private static void printUsers(UserDao userDao) {
		for (Map<String, Object> user : userDao.getUsers()) {
			System.out.println(user);
		}
	}
}

输出结果

{id=1, username=user1}
{id=2, username=user2}
Exception in thread "main" java.lang.RuntimeException
at constxiong.interview.transaction.UserDaoImpl.deleteUser(UserDaoImpl.java:28)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:302)
at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:190)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157)
at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:99)
at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:281)
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:96)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:208)
at com.sun.proxy.$Proxy2.deleteUser(Unknown Source)
at constxiong.interview.transaction.TransactionTest.testAnnotationTransaction(TransactionTest.java:20)
at constxiong.interview.transaction.TransactionTest.main(TransactionTest.java:13)

PS：

这篇仅用事务回滚为例，了解 spring 事务控制，还需要关注数据库的ACID四种特性、事务传播特性、事务的隔离级别（脏读、不可重复读、幻读）。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我们。

详解在Spring Boot中使用数据库事务

我们在前面已经分别介绍了如何在spring Boot中使用JPA以及如何在Spring Boot中输出REST资源.那么关于数据库访问还有一个核心操作那就是事务的处理了,前面两篇博客小伙伴们已经见识到Spring Boot带给我们的巨大便利了,其实不用猜,我们也知道Spring Boot在数据库事务处理问题上也给我们带来惊喜,OK,废话不多说,就来看看如何在Spring Boot中使用事务吧. OK,那我们开始今天愉快的coding旅程吧! 创建Project并添加数据库依赖这个没啥好说的,不
Spring中的事务管理实例详解

本文实例讲述了Spring中的事务管理.分享给大家供大家参考.具体分析如下: 事务简介: 事务管理是企业级应用程序开发中必不可少的技术,用来确保数据的完整性和一致性事务就是一系列的动作,它们被当作一个单独的工作单元.这些动作要么全部完成,要么全部不起作用事务的四个关键属性(ACID) ① 原子性(atomicity):事务室一个原子操作,有一系列动作组成.事务的原子性确保动作要么全部完成,要么完全不起作用 ② 一致性(consistency):一旦所有事务动作完成,事务就被提交.数据和资源就
Spring事务处理流程和原理详解

一.事务理论学习利用数据库事务实现应用事务控制 1.要求:同一个事务需要同一个库的同一个连接. 2. 3.分布式事务 JTA 二.spring事务处理建模 1. 2. 三.spring事务处理流程 1. 2. 以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们.
使用spring框架实现数据库事务处理方式

目录使用spring框架实现数据库事务处理 JDBC对数据库事务处理的支持 JDBC定义了五种事务隔离级别来解决这些并发导致的问题在spring框架中调用一个数据库事务处理分三步走: spring 事务实现方式有哪些在代码中调用 commit().rollback()等事务管理相关的方法 TransactionProxyFactoryBean 的声明式事务管理注解 @Transactional 的声明式事务管理 Aspectj AOP 配置(注解)事务使用spring框架实现数据库事务
Spring框架JdbcTemplate数据库事务管理完全注解方式

目录 Spring JdbcTemplate事务注解配置类方式配置完全注解方式一.创建配置类二.测试注解方式的事务管理 Spring JdbcTemplate事务注解配置类方式配置在之前的操作中,相关的配置还是写在了 xml 配置文件中.现在,使用配置类的方式进行配置. <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework
举例讲解Java的Spring框架中AOP程序设计方式的使用

1.什么是AOP AOP是Aspect Oriented Programming的缩写,意思是面向方面编程,AOP实际是GoF设计模式的延续. 2.关于Spring AOP的一些术语: A.切面(Aspect):在Spring AOP中,切面可以使用通用类或者在普通类中以@Aspect 注解(@AspectJ风格)来实现 B.连接点(Joinpoint):在Spring AOP中一个连接点代表一个方法的执行 C.通知(Advice):在切面的某个特定的连接点(Joinpoint)上执行的动作.
详解Spring框架入门

一.什么是Spring Spring框架是由于软件开发的复杂性而创建的.Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情.然而,Spring的用途不仅仅限于服务器端的开发.从简单性.可测试性和松耦合性角度而言,绝大部分Java应用都可以从Spring中受益.Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架. ◆目的:解决企业应用开发的复杂性 ◆功能:使用基本的JavaBean代替EJB,并提供了更多的企业应用功能 ◆范围:任何Java应用二.
详解Spring框架---IOC装配Bean

IOC装配Bean (1)Spring框架Bean实例化的方式提供了三种方式实例化Bean 构造方法实例化(默认无参数,用的最多) 静态工厂实例化实例工厂实例化下面先写这三种方法的applicationContext.xml配置文件: <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"
详解Java的Spring框架中的事务管理方式

数据库事务是被当作单个工作单元的操作序列.这些操作要么全部完成或全部不成功.事务管理是面向企业应用程序,以确保数据的完整性和一致性RDBMS中的重要组成部分.事务的概念可以用下面的描述为ACID四个关键属性来描述: 原子性: 一个事务应该被视为单个操作单元表示的操作的任一整个序列是成功的或不成功的. 一致性: 这代表了数据库的参照完整性,在桌等唯一主键的一致性隔离性: 可能有很多事务处理相同的数据集的同时,每个事务都应由他人隔离,以防止数据损坏. 持久性: 一旦事务完成,本次事务的结果必须作出
Spring框架接入单机Redis两种实现方式解析

1.Redis的简单介绍 1)Redis 是一个开源(BSD许可)的,内存中的数据结构存储系统,它可以用作数据库.缓存和消息中间件. 它支持多种类型的数据结构,如字符串(strings), 散列(hashes), 列表(lists), 集合(sets), 有序集合(sorted sets) 与范围查询, bitmaps, hyperloglogs 和地理空间(geospatial) 索引半径查询. 这些数据类型都支持push/pop.add/remove及取交集并集和差集及更丰富的操作,而且
YII2框架中操作数据库的方式实例分析

本文实例讲述了YII2框架中操作数据库的方式.分享给大家供大家参考,具体如下: 一.以createCommand方式: // YII2中通过createCommand来处理数据库 // 查询多条记录 // {{%user}} 表示如果设置了表前缀,YII会自动帮你替换 $data1 = YII::$app->db->createCommand('select * from {{%user}}')->queryAll(); // 查询一条记录 // createCommand的第二个参数可
Spring框架通过工厂创建Bean的三种方式实现

工厂模式 Spring中bean的创建,默认是框架利用反射new出来的bean实例.有时候也会有一些复杂的情况. 假设有一个飞机,属性如下,现在需要造很多同型号的飞机,那么唯一需要改变的属性只有DriverName(机长姓名),此时可以使用工厂模式帮我们创建对象,有一个专门帮我们创建对象的类帮我们创建对象,这个类就叫工厂. public class AirPlane { private String DriverName;// 机长姓名 private String AirPlaneName;/
Spring框架实现AOP的两种方式详解

目录第一种AOP实现方式 AfterLog Log 配置文件实例调用定义接口第二种AOP实现方式第一种AOP实现方式 AfterLog package com.xxx.demo.service1; import org.junit.After; import org.springframework.aop.AfterReturningAdvice; import java.lang.reflect.Method; public class AfterLog implements Aft