spring配置里面的事物管理

最新推荐文章于 2023-01-24 21:12:58 发布
最新推荐文章于 2023-01-24 21:12:58 发布
阅读量531 收藏
点赞数
分类专栏： spring 文章标签： spring Spring
在前面我们介绍的都是基于注解的方式来使用事务，现在来学习下基于XML的方式怎样来配置事务，先把PersonServiceBean.java里的注解去掉，
PersonServiceBean.java
Java代码
  1. package cn.itcast.service.impl;
  3. import java.util.List;
  5. import javax.sql.DataSource;
  7. import org.springframework.jdbc.core.JdbcTemplate;
  9. import cn.itcast.bean.Person;
  10. import cn.itcast.service.PersonService;
  12. public class PersonServiceBean implements PersonService {
  13. private JdbcTemplate jdbcTemplate;
  15. public void setDataSource(DataSource dataSource) {
  16. this.jdbcTemplate = new JdbcTemplate(dataSource);
  17. }
  19. public void delete(Integer personid) throws Exception{
  20. jdbcTemplate.update("delete from person where id=?", new Object[]{personid},
  21. new int[]{java.sql.Types.INTEGER});
  22. }
  24. public Person getPerson(Integer personid) {
  25. return (Person)jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid},
  26. new int[]{java.sql.Types.INTEGER}, new PersonRowMapper());
  27. }
  29. @SuppressWarnings("unchecked")
  30. public List<Person> getPersons() {
  31. return (List<Person>)jdbcTemplate.query("select * from person", new PersonRowMapper());
  32. }
  34. public void save(Person person) {
  35. jdbcTemplate.update("insert into person(name) values(?)", new Object[]{person.getName()},
  36. new int[]{java.sql.Types.VARCHAR});
  37. }
  39. public void update(Person person) {
  40. jdbcTemplate.update("update person set name=? where id=?", new Object[]{person.getName(), person.getId()},
  41. new int[]{java.sql.Types.VARCHAR, java.sql.Types.INTEGER});
  42. }
  43. }
[java] view plain copy print ?
  1. package cn.itcast.service.impl;
  3. import java.util.List;
  5. import javax.sql.DataSource;
  7. import org.springframework.jdbc.core.JdbcTemplate;
  9. import cn.itcast.bean.Person;
  10. import cn.itcast.service.PersonService;
  12. public class PersonServiceBean implements PersonService {
  13. private JdbcTemplate jdbcTemplate;
  15. public void setDataSource(DataSource dataSource) {
  16. this.jdbcTemplate = new JdbcTemplate(dataSource);
  17. }
  19. public void delete(Integer personid) throws Exception{
  20. jdbcTemplate.update("delete from person where id=?", new Object[]{personid},
  21. new int[]{java.sql.Types.INTEGER});
  22. }
  24. public Person getPerson(Integer personid) {
  25. return (Person)jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid},
  26. new int[]{java.sql.Types.INTEGER}, new PersonRowMapper());
  27. }
  29. @SuppressWarnings("unchecked")
  30. public List<Person> getPersons() {
  31. return (List<Person>)jdbcTemplate.query("select * from person", new PersonRowMapper());
  32. }
  34. public void save(Person person) {
  35. jdbcTemplate.update("insert into person(name) values(?)", new Object[]{person.getName()},
  36. new int[]{java.sql.Types.VARCHAR});
  37. }
  39. public void update(Person person) {
  40. jdbcTemplate.update("update person set name=? where id=?", new Object[]{person.getName(), person.getId()},
  41. new int[]{java.sql.Types.VARCHAR, java.sql.Types.INTEGER});
  42. }
  43. } 
package cn.itcast.service.impl;

import java.util.List;

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;

import cn.itcast.bean.Person;
import cn.itcast.service.PersonService;

public class PersonServiceBean implements PersonService {
	private JdbcTemplate jdbcTemplate;
	
	public void setDataSource(DataSource dataSource) {
		this.jdbcTemplate = new JdbcTemplate(dataSource);
	}
	
	public void delete(Integer personid) throws Exception{
		jdbcTemplate.update("delete from person where id=?", new Object[]{personid},
				new int[]{java.sql.Types.INTEGER});
	}
	
	public Person getPerson(Integer personid) {		
		return (Person)jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid}, 
				new int[]{java.sql.Types.INTEGER}, new PersonRowMapper());
	}

	@SuppressWarnings("unchecked")
	public List<Person> getPersons() {
		return (List<Person>)jdbcTemplate.query("select * from person", new PersonRowMapper());
	}

	public void save(Person person) {
		jdbcTemplate.update("insert into person(name) values(?)", new Object[]{person.getName()},
				new int[]{java.sql.Types.VARCHAR});
	}

	public void update(Person person) {
		jdbcTemplate.update("update person set name=? where id=?", new Object[]{person.getName(), person.getId()},
				new int[]{java.sql.Types.VARCHAR, java.sql.Types.INTEGER});
	}
}


目前这个bean是不受Spring管理的，我们通过配置文件的方式，在XML文件中对这个bean进行事务配置。
如果我们采用基于XML方式来配置事务的话，beans.xml里的<tx:annotation-driven transaction-manager="txManager"/>
这个就不再需要使用，删掉。
我们介绍下，如何使用基于XML方式配置事务，


采用基于XML方式配置事务
--------------------------------------------------------------------

Xml代码 复制代码
  1. <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  2. <property name="dataSource" ref="dataSource"/>
  3. </bean>
  4. <aop:config>
  5. <aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/>
  6. <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
  7. </aop:config>
  8. <tx:advice id="txAdvice" transaction-manager="txManager">
  9. <tx:attributes>
  10. <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
  11. <tx:method name="*"/>
  12. <!--其它方法使用默认的事务行为-->
  13. </tx:attributes>
  14. </tx:advice>
[xml] view plain copy print ?
  1. <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  2. <property name="dataSource" ref="dataSource"/>
  3. </bean>
  4. <aop:config>
  5. <aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/>
  6. <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
  7. </aop:config>
  8. <tx:advice id="txAdvice" transaction-manager="txManager">
  9. <tx:attributes>
  10. <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
  11. <tx:method name="*"/>
  12. <!--其它方法使用默认的事务行为-->
  13. </tx:attributes>
  14. </tx:advice>



我们配置了一个<aop:config>,里面的切入点pointcut，它对哪些方法进行拦截呢？对cn.itcast.service这个包，及其子包底下的所有类的所有方法，实现拦截。 拦截到方法后，运用一个advisor（通知）,这个通知大家要注意，Spring里面已经给我们提供了一个事务通知了，通过<aop:advisor advice-ref...这个配置把它引入进来，这个通知，使用了上面的切入点，也就是说当拦截到这些业务方法的执行的时候呢，它会交给txAdvice这个事务通知进行处理.
txAdvice这个bean的定义，实际上在Spring容器里它也会注册一个事务管理器，应该说是注册一个通知管理器，专门用来做事务处理的这么一个bean。

接下来配置beans.xml

Xml代码 复制代码
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:context="http://www.springframework.org/schema/context"
  5. xmlns:aop="http://www.springframework.org/schema/aop"
  6. xmlns:tx="http://www.springframework.org/schema/tx"
  7. xsi:schemaLocation="http://www.springframework.org/schema/beans
  8. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
  9. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
  10. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
  11. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
  13. <context:property-placeholder location="classpath:jdbc.properties"/>
  14. <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
  15. <property name="driverClassName" value="${driverClassName}"/>
  16. <property name="url" value="${url}"/>
  17. <property name="username" value="${username}"/>
  18. <property name="password" value="${password}"/>
  19. <!-- 连接池启动时的初始值 -->
  20. <property name="initialSize" value="${initialSize}"/>
  21. <!-- 连接池的最大值 -->
  22. <property name="maxActive" value="${maxActive}"/>
  23. <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
  24. <property name="maxIdle" value="${maxIdle}"/>
  25. <!-- 最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
  26. <property name="minIdle" value="${minIdle}"/>
  27. </bean>
  29. <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  30. <property name="dataSource" ref="dataSource"/>
  31. </bean>
  33. <aop:config>
  34. <aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/>
  35. <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
  36. </aop:config>
  37. <tx:advice id="txAdvice" transaction-manager="txManager">
  38. <tx:attributes>
  39. <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
  40. <tx:method name="*"/>
  41. </tx:attributes>
  42. </tx:advice>
  44. <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean">
  45. <property name="dataSource" ref="dataSource"/>
  46. </bean>
  47. </beans>
[xml] view plain copy print ?
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:context="http://www.springframework.org/schema/context"
  5. xmlns:aop="http://www.springframework.org/schema/aop"
  6. xmlns:tx="http://www.springframework.org/schema/tx"
  7. xsi:schemaLocation="http://www.springframework.org/schema/beans
  8. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
  9. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
  10. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
  11. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
  13. <context:property-placeholder location="classpath:jdbc.properties"/>
  14. <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
  15. <property name="driverClassName" value="${driverClassName}"/>
  16. <property name="url" value="${url}"/>
  17. <property name="username" value="${username}"/>
  18. <property name="password" value="${password}"/>
  19. <!-- 连接池启动时的初始值 -->
  20. <property name="initialSize" value="${initialSize}"/>
  21. <!-- 连接池的最大值 -->
  22. <property name="maxActive" value="${maxActive}"/>
  23. <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
  24. <property name="maxIdle" value="${maxIdle}"/>
  25. <!-- 最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
  26. <property name="minIdle" value="${minIdle}"/>
  27. </bean>
  29. <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  30. <property name="dataSource" ref="dataSource"/>
  31. </bean>
  33. <aop:config>
  34. <aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/>
  35. <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
  36. </aop:config>
  37. <tx:advice id="txAdvice" transaction-manager="txManager">
  38. <tx:attributes>
  39. <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
  40. <tx:method name="*"/>
  41. </tx:attributes>
  42. </tx:advice>
  44. <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean">
  45. <property name="dataSource" ref="dataSource"/>
  46. </bean>
  47. </beans>


配置好事务了，PersonServiceBean这业务bean就可以受事务管理了。现在就可以使用Spring里面的声明式事务对它进行管理了，现在做一下测试，看事务是否应用起来了。
打开单元测试，执行save方法，保存一些数据进去。。
PersonServiceTest.java

Java代码 复制代码
  1. package junit.test;
  2. import org.junit.BeforeClass;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  7. import cn.itcast.bean.Person;
  8. import cn.itcast.service.PersonService;
  10. public class PersonServiceTest {
  11. private static PersonService personService;
  13. @BeforeClass
  14. public static void setUpBeforeClass() throws Exception {
  15. try {
  16. ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
  17. personService = (PersonService) cxt.getBean("personService");
  18. } catch (RuntimeException e) {
  19. e.printStackTrace();
  20. }
  21. }
  23. @Test public void save(){
  24. for(int i=10; i<15; i++)
  25. personService.save(new Person("传智播客"+ i));
  26. }
  28. ..................................
  30. @Test public void delete(){
  31. try {
  32. personService.delete(3);
  33. } catch (Exception e) {
  34. e.printStackTrace();
  35. }
  36. }
  38. ..................................
  39. }
[java] view plain copy print ?
  1. package junit.test;
  2. import org.junit.BeforeClass;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  7. import cn.itcast.bean.Person;
  8. import cn.itcast.service.PersonService;
  10. public class PersonServiceTest {
  11. private static PersonService personService;
  13. @BeforeClass
  14. public static void setUpBeforeClass() throws Exception {
  15. try {
  16. ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
  17. personService = (PersonService) cxt.getBean("personService");
  18. } catch (RuntimeException e) {
  19. e.printStackTrace();
  20. }
  21. }
  23. @Test public void save(){
  24. for(int i=10; i<15; i++)
  25. personService.save(new Person("传智播客"+ i));
  26. }
  28. ..................................
  30. @Test public void delete(){
  31. try {
  32. personService.delete(3);
  33. } catch (Exception e) {
  34. e.printStackTrace();
  35. }
  36. }
  38. ..................................
  39. } 
package junit.test; 
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.itcast.bean.Person;
import cn.itcast.service.PersonService;

public class PersonServiceTest {
	private static PersonService personService;

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		try {
			ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
			personService = (PersonService) cxt.getBean("personService");
		} catch (RuntimeException e) {
			e.printStackTrace();
		}
	}

	@Test public void save(){
		for(int i=10; i<15; i++)
			personService.save(new Person("传智播客"+ i));
	}

	..................................

	@Test public void delete(){
		try {
			personService.delete(3);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	..................................
}


现在数据库person表的记录如下：看图


为了进一步验证事务配置起作用了，我们可以这样做

Java代码 复制代码
  1. public void delete(Integer personid) throws Exception{
  2. jdbcTemplate.update("delete from person where id=?", new Object[]{personid},
  3. new int[]{java.sql.Types.INTEGER});
  4. jdbcTemplate.update("delete from person_wrong_name where id=7");
  5. }
[java] view plain copy print ?
  1. public void delete(Integer personid) throws Exception{
  2. jdbcTemplate.update("delete from person where id=?", new Object[]{personid},
  3. new int[]{java.sql.Types.INTEGER});
  4. jdbcTemplate.update("delete from person_wrong_name where id=7");
  5. } 
public void delete(Integer personid) throws Exception{
		jdbcTemplate.update("delete from person where id=?", new Object[]{personid},
				new int[]{java.sql.Types.INTEGER});
		jdbcTemplate.update("delete from person_wrong_name where id=7");
	}


在PersonServiceBean.java的delete方法里面，执行两条update语句，默认情况下这两条语句都会在同一个事务里执行，如果说这个方法没有开启事务的话，这两条update语句会在各自的事务里执行（也就是说他们不能在同一事务里执行），我们通过这样来判断delete方法是否开了事务，如果开了事务，两条update语句就在同一事务里执行，如果没开事务，就会在各自的事务里执行，也就是说第二个update语句故意写错了，第二条语句会出错，它是否会引起第一条update语句的回滚呢？如果我们应用上了Spring的事务管理，他必然会一起回滚，如果没应用上的话，第一条update语句是会运行成功的。
运行单元测试的delete方法，

Java代码 复制代码
  1. @Test public void delete(){
  2. try {
  3. personService.delete(3);
  4. } catch (Exception e) {
  5. e.printStackTrace();
  6. }
  7. }
[java] view plain copy print ?
  1. @Test public void delete(){
  2. try {
  3. personService.delete(3);
  4. } catch (Exception e) {
  5. e.printStackTrace();
  6. }
  7. } 
@Test public void delete(){
    try {
        personService.delete(3);
    } catch (Exception e) {
        e.printStackTrace();
    }
}



JUnit显示出错，查看数据库person表记录，发现id为3和7的记录还在，如图：



说明开了事务，两条都不被删。
假如我们没有应用事务管理的话，在beans.xml里，把下面的语句注释掉

Xml代码 复制代码
  1. <!--
  2. <aop:config>
  3. <aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/>
  4. <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
  5. </aop:config>
  6. <tx:advice id="txAdvice" transaction-manager="txManager">
  7. <tx:attributes>
  8. <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
  9. <tx:method name="*"/>
  10. </tx:attributes>
  11. </tx:advice>
  12. -->
[xml] view plain copy print ?
  1. <!--
  2. <aop:config>
  3. <aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/>
  4. <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
  5. </aop:config>
  6. <tx:advice id="txAdvice" transaction-manager="txManager">
  7. <tx:attributes>
  8. <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
  9. <tx:method name="*"/>
  10. </tx:attributes>
  11. </tx:advice>
  12. -->


看下当我们没有应用Spring的事务管理器的时候，它是否能删除id=3这条记录（既是第一个update语句顺利提交不回滚）呢？
现在数据库person表的记录如下，看图：


运行单元测试的delete方法，JUnit说运行时出错，看数据库，如图：


id=3的记录不见了，id=7的记录还存在，这代表，事务管理器没有应用上，因为第一条update语句是在一个事务里执行，第二条update语句是在另一个事务里执行，因为它没有应用上Spring提供的事务管理，所以说他们两个update语句会在单独的事务中执行。 第一条是执行成功的，第二条是执行失败的。我们通过观察结果就可以看到它目前并没有应用上事务管理，所以一定要注意：以后在开发的时候，一定要确保你们的bean是受Spring的事务管理的。如果不受管理的话，你们就无法应用Spring给我们提供的这些功能，也就是说业务方法开启的时候给我们打开事务，在业务方法结束的时候根据运行情况如果没有抛出运行期例外的话，那么它就给我们提交事务，否则它就给我们回滚事务，这点大家是要注意的。

基于XML方式使用事务就给大家介绍完了，具体使用XML方式配置事务，还是使用注解方式配置事务，Spring开发团队就建议我们采用注解方式来配置事务，因为采用注解方式来使用事务的话，我们的配置可以做到精确控制，可以针对某一个方法,使用起来比较灵活。如果采用配置方式为某个业务方法定义某些事务行为的话，那么这个配置文件配置内容会很臃肿，所以Spring的开发团队建议我们采用注解方式来配置事务。
但是目前在企业开发中，目前大部分项目使用的还是基于XML配置方式来使用事务，但是以后很多新项目也慢慢开始转向到了注解方式，这两种方式大家都需要去熟悉。

crazy_leega
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring 事务相关配置
流楚丶格念的博客
07-25 2345
但是对于编译器异常，Spring事务是不进行回滚的，所以需要使用rollbackFor来设置要回滚的异常。例如methodA方法调用methodB方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个新事务运行，这就是由methodB的事务传播行为决定的。但是对于编译器异常（例如IOException），Spring事务是不进行回滚的。虽然学会了使用Spring回滚事务，但是有一种异常Spring事务默认是不进行回滚的那就是编译器异常。......
Spring 事务管理的详细讲解及使用
康康要加油的博客
03-14 1万+
文章目录一、 Spring 事务管理简介二、Spring 事务管理器1、Spring 事务管理接口1.1、 PlatformTransactionManager 接口1.2、 TransactionDefinition 接口1.3、 TransactionStatus 接口2、Spring 中包含的事务管理器三、 事务的传播行为四、 Spring 声明式事务管理1、Jar 包依赖2、使用 XML 文件方式实现声明式事务管理2.1、 搭建环境创建项目创建实体类创建持久层创建业务层配置 Spring JDBC2
Spring 事务的配置和使用详解（包括手动对事务的控制部分）
whbing1471的博客
01-05 1万+
最近项目中用到了spring的注解类的事务管理，所以特地学习和记录一下spring的配置和使用。项目中使用的是springMVC + mybatis + mysql。spring的版本是4.3.0.RELEASE。1. spring 注解事务的配置Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式
Springboot Mybatis MySQL读写分离及事物配置
wantnrun的专栏
02-05 6188
为什么需要读写分离 当项目越来越大和并发越来大的情况下，单个数据库服务器的压力肯定也是越来越大，最终演变成数据库成为性能的瓶颈，而且当数据越来越多时，查询也更加耗费时间，当然数据库数据过大时，可以采用数据库分库分表，同时数据库压力过大时，也可以采用Redis等缓存技术来降低压力，但是任何一种技术都不是万金油，很多时候都是通过多种技术搭配使用，而本文主要就是介绍通过读写分离来加快数据库读取速度
【Spring】spring事务配置
Le vent se lève, il faut tenter de vivre
08-26 806
划重点了~
Spring事务管理详解
01-24 2646
Spring 支持两种方式的事务管理，分别是编程式事务管理与声明式事务管理。
Java spring - 事务管理
Garson的博客
10-08 1214
spring-事务，呕心沥血的细节和作者内心对话！
Spring中的事务管理详解
qq_41359998的博客
03-02 852
Spring中的事义管理详解 一、回顾一下事务 事务在项目开发过程非常重要，涉及到数据的一致性的问题，不容马虎！ 事务管理是企业级应用程序开发中必备技术，用来确保数据的完整性和一致性。 事务就是把一系列的动作当成一个独立的工作单元，这些动作要么全部完成，要么全部不起作用。 事务的四个属性ACID 原子性（atomicity） 事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用 一致性（consistency） 一旦所有事务动作完成，事务就要被提交。数据和资源处于一
Spring事务管理（详解+实例）
热门推荐
Trigl的博客
03-25 8万+
写这篇博客之前我首先读了《Spring in action》，之后在网上看了很多关于Spring事务管理的文章，具体参考文章如下： 1、将相应的接口依赖图理清出 2、将每个类的具体配置弄明白 3、将具体的配置给出来 4、给出具体的例子（一个声明式的一个编程式的）
【Spring】之事务管理与事务失效
王廷云的博客
10-25 854
本地事务失效问题 总结：同一个对象内事务方法之间互相调用时，事务默认会失效，原因是绕过了代理对象。 在 SpringBoot 里面我们使用 @Transactional(propagation=Propagation.REQUIRED) 注解来开启事务，如果是不同服务之间的调用，比如：A 服务的 a() 方法调用了 B 服务的 b() 方法，a、b 方法都开启了事务，那么它们各自的事务是有效的。 但如果在同一个 Service 中有 a()、b()、c() 三个方法，每个方法都开启了事务，比如，我 a 方
Spring声明式事务配置管理方法
03-02
发布于2013-5-6项目使用SSH架构，现在要添加Spring事务管理功能，针对当前环境，只需要添加Spring2.0AOP类库即可。添加方法：点击项目右键->BuildPath->Addlibrarys:打开AddLibraries对话框，然后选定...
Spring.html
03-23
概念:面向切面编程,在不改变源码的情况下对方法进行增强,抽取横切关注点(日志处理,事务管理,安全检查,性能测试等等),使用AOP进行增强,使程序员只需要关注与业务逻辑编写. 专业术语 目标Target:需要增强的类 ...
Spring Ibatis Demo
10-30
这是一个servlet + spring + ibatis 的完整例子，里面包含了spring的事务管理以及所有的jar包，下载下来后直接改下数据库配置就可以运行！从界面到action，业务层，dao层有现成的代码！
JTA事务源码示例
12-20
-- JTA事务管理器 --> class="org.springframework.transaction.jta.JtaTransactionManager"> <!-- 数据源A --> ${jdbc.driver}"/> ${jdbc.url}"/> ${jdbc.username}"/> ${jdbc....
Spring + Hibernate + Struts 事务配置小例子（带提示框等小技巧）
05-27
-- 配置事务管理器 --> class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <!-- 配置事务拦截器--> class="org.springframework.transaction.interceptor....
springmybatis
09-05
查询出列表，也就是返回list, 在我们这个例子中也就是 List<User> , 这种方式返回数据，需要在User.xml 里面配置返回的类型 resultMap, 注意不是 resultType, 而这个resultMap 所对应的应该是我们自己配置的 ...
基于SSM框架的实验室设备管理系统
最新发布
11-11
spring功能是实现参数参数注入，请求分发处理，对数据库操作进行事务控制，其中mybatis使用注解查询，整体上大部分使用xml配置，少部分使用注解 2.前端使用HTML+javascript+css+jquery 绝大部分请求使用ajax发送，...
使用spring mvc+c3p0+jpa 框架搭建环境
11-25
本基础框架采用 spring mvc+c3p0+jpa的配置方式，里面配置了spring事务管理,异常处理,登陆拦截器 等，全部自己动手搭建，经过测试通过。如果你苦于一个万能的java ee框架搭建，你可以参考。个人喜欢专研技术，但不...
java版飞机大战源码-Study-Spring-Cloud:SpringCloud学习
06-04
Cloud里面主流框架和组件的基本使用，还要部分源码原理的理解 掌握学习的技巧和决解问题的思路 二、架构演进和分布式系统基础知识 2.1 传统架构演进到分布式架构 简介：讲解单机应用和分布式应用架构演进基础知识 ...
spring只读事务里面有写事务怎么改
09-18
2. 在Spring的事务管理配置文件（如XML配置文件或注解配置类）中，将只读事务的isolation属性设置为默认级别或其他适当的级别，以允许读写操作。例如，将isolation属性设置为READ_COMMITTED或其他适合的级别。 3. 在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值