Spring的事务控制，事务属性，基于标签的事务配置方式

最新推荐文章于 2024-04-22 23:29:05 发布
最新推荐文章于 2024-04-22 23:29:05 发布
阅读量291 收藏
点赞数 1
分类专栏： Spring mybatis 文章标签： 数据库 spring java mysql mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tuc1997/article/details/115709706
版权

1. 事务

1. 什么是事务？

保证业务操作完整性的一种数据库机制

事务的4特点： A C I D
1. A 原子性
2. C 一致性
3. I 隔离性
4. D 持久性

1.2 如何控制事务

JDBC:


    Connection.setAutoCommit(false);
    Connection.commit();
    Connection.rollback();

Mybatis：
Mybatis自动开启事务


   sqlSession(Connection).commit();
   sqlSession(Connection).rollback();

结论：控制事务的底层 都是Connection对象完成的。

2. Spring控制事务的开发

Spring是通过AOP的方式进行事务开发

2.1 开发步骤

2.1.1. 原始对象
  1. 原始对象 —》 原始方法 —》核心功能 (业务处理+DAO调用)
  2. DAO作为Service的成员变量，依赖注入的方式进行赋值
public class XXXUserServiceImpl{
   private xxxDAO xxxDAO
   set get
}
2.1.2 额外功能

额外功能原本应该通过实现MethodInterceptor接口，在invoke方法里面实现：

public Object invoke(MethodInvocation invocation){
      try{
        Connection.setAutoCommit(false);
        Object ret = invocation.proceed();
        Connection.commit();
      }catch(Exception e){
        Connection.rollback();
      }
        return ret;
   }

或者在类上面加上@Aspect注解 就可以告知Spring这是一个额外功能的实现类，在方法加上@Around注解，就可以在注解里面定义切入点了,不需要实现任何接口

而Spring提供了org.springframework.jdbc.datasource.DataSourceTransactionManager事务管理器来管理事务，会自动帮助我们完成上面invoke方法里面的开启事务， 提交事务和回滚事务，我们只要在使用时给他注入连接池 让dataSourceTransactionManager获取连接 进而通过连接控制事务，完成事务控制的这一额外功能 。

2.1.3 切入点

Spring还提供了@Transactional 这一注解来定义事务额外功能的切入点，他控制了事务的额外功能加入给哪些业务方法。

  1. 类上：类中所有的方法都会加入事务
  2. 方法上：这个方法会加入事务
2.1.4 组装切面

还提供了tx:annotation-driven/这个标签支持事务注解，他会告诉spring开启事务注解了，然后我们里面吧额外功能，也就是dataSourceTransactionManager传给transaction-manager这个属性即可

2.2. 编码实现Spring控制事务

2.2.1 搭建开发环境

依赖：

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

userDAO接口和Mapper映射文件

public interface UserDao {
    public void save(User user);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.tcgroup.dao.UserDao">

    <insert id="save" parameterType="user">
        insert into mybatis.users(id,name,pwd) values (#{id},#{name},#{password})
    </insert>

</mapper>
2.2.2 接口
public interface UserService {
    public void register(User user);

}
2.2.3 实现类（原始类）
//通过@Transactional注解 让这个类所有的方法都实现事务的额外功能
@Transactional
public class UserServiceImpl implements UserService{
    private UserDao userDao;

    
    //set get方法让spring通过set吧userDAO注入进来
    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void register(User user) {
        userDao.save(user);
    }
}
2.2.4 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/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx https://www.springframework.org/schema/tx/spring-tx.xsd">

<!-- 这里吧连接数据库的参数放到db.properties文件里面去了  指定spring读取db.properties配置 -->
        <context:property-placeholder location="classpath:db.properties"  />

<!-- 连接池配置 -->
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
                <property name="driverClassName" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
        </bean>

<!--    通过SQLSessionFactoryBean创建SQLSessionFactory     -->
        <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
<!--    告诉SQLSessionFactoryBean用上面的连接池 -->
                <property name="dataSource" ref="dataSource"/>
<!--    给com.tcgroup.entity这个包下面的类起别名         -->
                <property name="typeAliasesPackage" value="com.tcgroup.entity"/>
<!--    指定Mapper文件路径            -->
                <property name="mapperLocations">
                        <list>
<!--    这里的value是String类型的文件路径， 也是用/做分隔符      -->
                             <value>classpath:com/tcgroup/dao/*Mapper.xml</value>
                        </list>
                </property>
        </bean>
<!--    通过MapperScannerConfigurer创建dao对象      -->
        <bean id="scanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!--    告诉MapperScannerConfigurer 工厂是上面这个sqlSessionFactoryBean           -->
                <property name="sqlSessionFactoryBeanName" value="sqlSessionFactoryBean"/>
<!--    让MapperScannerConfigurer在 com.tcgroup.dao这个包里面找对应的接口，创建对应的dao对象           -->
                <property name="basePackage" value="com.tcgroup.dao"/>
        </bean>

<!--  在UserServiceImpl里面注入UserDAO对象  上面scanner已经创建了 首字母小写获取即可  -->
        <bean id="userService" class="com.tcgroup.service.UserServiceImpl">
            <property name="userDao" value="userDao"/>
        </bean>

<!--    实现事务控制额外功能的类-->
        <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--    注入连接池    让dataSourceTransactionManager获取连接 进而通过连接控制事务    -->
            <property name="dataSource" ref="dataSource"/>
        </bean>

<!--    <tx:annotation-driven/>这个标签 就是支持事务注解的（@Transactional） -->
<!--    transaction-manager 获取额外功能-->
        <tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>
</beans>
2.2.5 测试（测试回滚可以在原始方法 UserServiceImpl的register方法里面抛出异常）
public void test2(){
    ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("/applicationContext.xml");
    //spring生产出来的接口实例默认是首字母小写
    UserDao userDao = (UserDao) classPathXmlApplicationContext.getBean("userDao");

    User user = new User();
    user.setName("黄鹤楼");
    user.setPassword("huanghekou");
    userDao.save(user);
}

2.3 细节

<tx:annotation-driven transaction-manager="dataSourceTransactionManager" proxy-target-class="true"/>

通过proxy-target-class这个属性 我们可以进行动态代理底层实现的切换 默认是 false也就是 JDK提供的动态代理模式，如果原始类没有实现接口，可以改成true 改成Cglib继承的方式实现动态代理

3. Spring中的事务属性(Transaction Attribute)

3.1 什么是事务属性

属性：描述物体特征的一系列值
比如： 性别 身高 体重 …
事务属性：描述事务特征的一系列值

  1. 隔离属性 isloation
  2. 传播属性 propagation
  3. 只读属性 readOnly
  4. 超时属性 timeout
  5. 异常属性 rollbackFor=,noRollbackFor=,)

3.2 如何添加事务属性

上面实现Spring的事务控制时 我们需要在实现类（原始类）或者方法上面加上@Transactional注解，而在@Transactional注解里面，就可以加上事务的属性
@Transactional(isloation=,propagation=,readOnly=,timeout=,rollbackFor=,noRollbackFor=,)

3.3 事务属性详解

3.3.1 隔离属性 (ISOLATION)
隔离属性的概念：他描述了事务解决并发问题的特征

  1. 什么是并发
    多个事务(用户)在同一时间，访问操作了相同的数据

     同一时间：0.000几秒 微小前 微小后

  2. 并发会产生那些问题
    1. 脏读
    2. 不可重复读
    3. 幻影读

  3. 并发问题如何解决
    通过隔离属性解决，隔离属性中设置不同的值，解决并发处理过程中的问题。

事务并发产生的问题
  • 脏读

脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。

例如：张三的卡余额为5000,事务A中把他的余额改为3000,但事务A尚未提交。
与此同时，
事务B正在读取张三的余额，读取到张三的工资为3000。
随后，
事务A发生异常，而回滚了事务。张三的余额又回滚为5000。
最后，
事务B读取到的张三余额为3000的数据即为脏数据，事务B做了一次脏读。

解决方案 @Transactional(isolation=Isolation.READ_COMMITTED)

  • 不可重复读

是指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改，那么第一个事务两次读到的的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的，因此称为是不可重复读。

例如：在事务A中，读取到张三的余额为5000，操作没有完成，事务还没提交。
与此同时，
事务B把张三的余额改为8000，并提交了事务。
随后，
在事务A中，再次读取张三的余额，此时余额变为8000。

在一个事务中前后两次读取的结果并不致，导致了不可重复读，注意：1 不可重复读不是脏读，8000也不是脏数据 2 不可重复读发生在一个事务中（事务A）

解决方案 @Transactional(isolation=Isolation.REPEATABLE_READ)
本质： 数据库底层会为我们操作的这个数据加上一把行锁

  • 幻影读

是指当事务不是独立执行时发生的一种现象，例如第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行，就好象发生了幻觉一样。

例如：目前工资为5000的员工有10人，事务A读取所有工资为5000的人数为10人。
此时，
事务B插入一条工资也为5000的记录。
这是，事务A再次读取工资为5000的员工，记录为11人。此时产生了幻读。

解决方案 @Transactional(isolation=Isolation.SERIALIZABLE)
本质：数据库底层会为我们操作的这个表加上一把表锁

Spring 事务的隔离级别:

  1. ISOLATION_DEFAULT：
    这是一个 PlatfromTransactionManager 默认的隔离级别，
    使用数据库默认的事务隔离级别.
    另外四个与 JDBC 的隔离级别相对应
    MySQL默认 : REPEATABLE_READ
    Oracle默认: READ_COMMITTED

  2. ISOLATION_READ_UNCOMMITTED： 这是事务最低的隔离级别， 它充许令外一个
    事务可以看到这个事务未提交的数据。
    这种隔离级别会产生脏读，不可重复读和幻像读。

  3. ISOLATION_READ_COMMITTED：保证一个事务修改的数据提交后才能被另外一
    个事务读取。另外一个事务不能读取该事务未提交的数。

  4. ISOLATION_REPEATABLE_READ： 这种事务隔离级别可以防止脏读， 不可重复读。
    但是可能出现幻像读。
    它除了保证一个事务不能读取另一个事务未提交的数据外， 还保证了避免下面的
    情况产生(不可重复读)。

  5. ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务
    被处理为顺序执行,除了防止脏读，不可重复读外，还避免了幻像读。

数据库对于隔离属性的支持
隔离属性的值MySQLOracle
READ UNCOMMITTED√×
READ COMMITTED√√(默认隔离级别)
REPEATABLE READ√(默认隔离级别)×
SERIALIZABLE√√

Oracle不支持REPEATABLE_READ值 如何解决不可重复读
采用的是多版本比对的方式 解决不可重复读的问题

  • 查看数据库默认隔离属性
  • MySQL
select @@tx_isolation;
  • Oracle
SELECT s.sid, s.serial#,
   CASE BITAND(t.flag, POWER(2, 28))
      WHEN 0 THEN 'READ COMMITTED'
      ELSE 'SERIALIZABLE'
   END AS isolation_level
FROM v$transaction t 
JOIN v$session s ON t.addr = s.taddr
AND s.sid = sys_context('USERENV', 'SID');
总结

事务的隔离级别和数据库运行效率是成反比的，隔离级别越高，运行效率越低。

隔离级别（从高到底）： SERIALIZABLE>REPEATABLE_READ>READ_COMMITTED>READ_UNCOMMITTED
运行效率： READ_UNCOMMITTED<READ_COMMITTED>REPEATABLE_READ>SERIALIZABLE

隔离属性在实战中的建议

推荐使用Spring指定的ISOLATION_DEFAULT

  1. MySQL repeatable_read
  2. Oracle read_commited

未来实战中，并发访问情况很低

如果真遇到并发问题，推荐优先用乐观锁解决
Hibernate(JPA) Version
MyBatis 通过拦截器自定义开发

3.3.2 传播属性(PROPAGATION)
事务嵌套

什么叫做事务的嵌套：他指的是一个大的事务中，包含了若干个小的事务

我们在开发一个复杂的系统时可能经常出现这样的场景：比如，A函数中调用了B函数，而A函数和B函数同时都使用了事务，比如Service调用另一个service，这样就出现了事务嵌套

问题：大事务中融入了很多小的事务，他们彼此影响，最终就会导致外部大的事务，丧失了事务的原子性

传播属性的概念

描述了事务解决嵌套问题的特征

传播属性的值及其用法
传播属性的值外部不存在事务外部存在事务用法备注（常用场景）
REQUIRED开启新的事务融合到外部事务中@Transactional(propagation = Propagation.REQUIRED)增删改方法
SUPPORTS不开启事务融合到外部事务中@Transactional(propagation = Propagation.SUPPORTS)查询方法
REQUIRES_NEW开启新的事务挂起外部事务，创建新的事务@Transactional(propagation = Propagation.REQUIRES_NEW)日志记录方法中
NOT_SUPPORTED不开启事务挂起外部事务@Transactional(propagation = Propagation.NOT_SUPPORTED)及其不常用
NEVER不开启事务抛出异常@Transactional(propagation = Propagation.NEVER)及其不常用
MANDATORY抛出异常融合到外部事务中@Transactional(propagation = Propagation.MANDATORY)及其不常用

如果外部存在事务， 内部事务融合到外部事务中去，那么就只有外部事务一个事务，事务嵌套就不存在了

默认的传播属性

REQUIRED是传播属性的默认值

推荐传播属性的使用方式

增删改 方法：直接使用默认值REQUIRED（不需要显示指定值）
查询 操作：显示指定传播属性的值为SUPPORTS

3.3.3 只读属性(readOnly)

针对于只进行查询操作的业务方法，可以加入只读属性，提供运行效率

默认值：false

3.3.4 超时属性(timeout)

指定了事务等待的最长时间

  1. 为什么事务进行等待？
    当前事务访问数据时，有可能访问的数据被别的事务进行加锁的处理，那么此时本事务就必须进行等待。
  2. 等待时间 单位：秒
  3. 如何应用
    @Transactional(timeout=2)
  4. 超时属性的默认值 -1
    等待时间最终由对应的数据库来指定
3.3.5 异常属性

Spring事务处理过程中当程序抛出异常时

默认 对于RuntimeException及其子类 采用的是回滚的策略
默认 对于Exception及其子类 采用的是提交的策略

设置对于Exception及其子类采用回滚策略
rollbackFor = {java.lang.Exception.class}

设置对于RuntimeException及其子类采用提交策略
noRollbackFor = {java.lang.RuntimeException,xxx,xx}

@Transactional(rollbackFor = {java.lang.Exception.class},noRollbackFor = {java.lang.RuntimeException.class})

建议：实战中使用RuntimeExceptin及其子类 使用事务异常属性的默认值也就是不进行设置

3.4 事务属性常见配置总结

  1. 隔离属性 默认值
  2. 传播属性 Required(默认值) 增删改 Supports 查询操作
  3. 只读属性 readOnly false 增删改 true 查询操作
  4. 超时属性 默认值 -1
  5. 异常属性 默认值

增删改操作 @Transactional
查询操作 @Transactional(propagation=Propagation.SUPPORTS,readOnly=true)

4. 基于标签的事务配置方式(事务开发的第二种形式)

4.1. 基于注解 @Transaction的事务配置回顾

1. 原始对象
<bean id="userService" class="com.tcgroup.service.UserServiceImpl">
  <property name="userDAO" ref="userDAO"/>
</bean>

2.额外功能
<!--DataSourceTransactionManager-->
<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
</bean>

3.通过@Transactional加入切入点 设置事务属性
@Transactional(isolation=,propagation=,...)
public class UserServiceImpl implements UserService {
    private UserDAO userDAO;

4.整合切面
<tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>

4.2 基于标签的事务配置

1. 原始对象
<bean id="userService" class="com.tcgroup.service.UserServiceImpl">
  <property name="userDAO" ref="userDAO"/>
</bean>

2.额外功能
<!--DataSourceTransactionManager-->
<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
</bean>

3.事务属性 
<tx:advice id="txAdvice" transacation-manager="dataSourceTransactionManager">
    <tx:attributes>
          <tx:method name="register" isoloation="",propagation=""></tx:method>
          <tx:method name="login" .....></tx:method>
          等效于 
          @Transactional(isolation=,propagation=,)
          public void register(){
        
          }
      
    </tx:attributes>
</tx:advice>

<aop:config>
    4.切入点
     <aop:pointcut id="pc" expression="execution(* com.tcgroup.service.UserServiceImpl.register(..))"></aop:pointcut>
    5.切面组装
     <aop:advisor advice-ref="txAdvice" pointcut-ref="pc"></aop:advisor>
</aop:config>

问题：

  1. 有一个方法， tx:attributes里面就得写一个标签
  2. 切入点 ，指定了具体的方法，未来有非常多的方法需要加，最好直接用包切入点， 切入service包及其子包

4.3 基于标签的事务配置在实战中的应用方式

<bean id="userService" class="com.tcgroup.service.UserServiceImpl">
  <property name="userDAO" ref="userDAO"/>
</bean>

<!--DataSourceTransactionManager-->
<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
</bean>


                    
<tx:advice id="txAdvice" transacation-manager="dataSourceTransactionManager">
    <tx:attributes>
          <tx:method name="register"></tx:method>
        编程时候 service中负责进行增删改操作的方法 都以modify开头，用*做通配符
          <tx:method name="modify*"></tx:method>
        把*放在modify*下面,表示除了上面定义过的方法意外的其他方法，一般是除了增删改以外的查询操作   命名无所谓 
          <tx:method name="*" propagation="SUPPORTS"  read-only="true"></tx:method>
    </tx:attributes>
</tx:advice>

		应用的过程中，service放置到service包中，用包切入点
<aop:config>
     <aop:pointcut id="pc" expression="execution(* com.tcgroup.service..*.*(..))"></aop:pointcut>
     <aop:advisor advice-ref="txAdvice" pointcut-ref="pc"></aop:advisor>
</aop:config>
Tdercode
关注
专栏目录
Spring事务Transaction配置的五种注入方式详解
08-30
Spring事务Transaction配置的五种注入方式详解 Spring框架中的事务管理是通过TransactionManager来实现的，TransactionManager是Spring事务管理的核心组件。Spring提供了多种方式来配置事务，下面将详细介绍Spring...
Spring基于XML方式配置事务
12-19
这里我们主要探讨的是"Spring基于XML方式配置事务"，这涉及到Spring的事务管理器、事务属性以及如何在XML配置文件中定义这些元素。 首先，Spring的事务管理分为两种模式：编程式事务管理和声明式事务管理。编程式...
Spring的事务控制
Student111w的博客
01-22 235
spring事务控制我们要明确的事 第一：JavaEE 体系进行分层开发，事务处理位于业务层，Spring 提供了分层设计业务层的事务处理解决方案。 第二：spring 框架为我们提供了一组事务控制的接口。具体在后面的第二小节介绍。这组接口是在spring-tx-5.0.2.RELEASE.jar 中。 第三：spring 的事务控制都是基于 AOP 的，它既可以使用编程的方式实现，也可以使用配置的方式实现。我们学习的重点是使用配置的方式实现。 事务管理的对象 org.springframework.jdb
Spring事务控制
qq_62965575的博客
01-08 2300
Spring事务介绍、事务控制、Spring中事务控制的API介绍、Spring动态代理控制事务、Spring AOP控制事务、基于注解的AOP控制事务
spring事务控制
weixin_51262054的博客
06-03 189
PlatformTransactionManager接口是spring的事务管理器，它里面提供了我们常用的操作事务的方法。注意：PlatformTransactionManager是接口类型，不同的Dao层技术则有不同的实现类，例如:Dao层技术是jcbc或mybatis 时: org.springframework.jdbc.datasource.Data.SourceTransactionManager。
spring 事物通过<tx 标签配置
wcp88888888的专栏
11-28 179
配置文件如下： &lt;?xml version="1.0" encoding="UTF-8"?&gt;&lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.spri
Spring中对于事务的控制
m0_52305392的博客
09-26 268
spring中对于事务的三种支持方式
Spring的事务属性
把思想充满在语言之中
06-11 486
<br />在TransactionDefinition接口中定义了五个不同的事务隔离级别 <br />ISOLATION_DEFAULT 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.另外四个与JDBC的隔离级别相对应 ISOLATION_READ_UNCOMMITTED 这是事务最低的隔离级别，它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。 ISOLATION_READ_COMMITTED  保证一
Spring如何基于aop实现事务控制
08-24
Spring框架中提供了多种方式来实现事务控制，基于AOP（Aspect-Oriented Programming，面向方面编程）是其中的一种常用方式。通过使用AOP，可以将事务控制逻辑从业务逻辑中分离出来，提高代码的可读性和可维护性。 ...
spring事务的属性
weixin_42541254的博客
09-12 184
spring事务属性的种类： 传播行为、隔离级别、只读和事务超时 a) 传播行为定义了被调用方法的事务边界。 b) 隔离级别 在操作数据时可能带来 3 个副作用，分别是脏读、不可重复读、幻读。为了避免这 3 中副作用的发生，在标准的 SQL 语句中定义了 4 种隔离级别，分别是未提交读、已提交读、可重复读、可序列化。而在 spring 事务中提供了 5 种隔离级别来对应在 SQL 中定义...
【Spring进阶系列丨最终篇】一文详解Spring中的事务控制
最新发布
陈橘又青的博客
04-22 2万+
- 事务需要放在业务层(service) - Spring的事务是基于AOP的 - Spring的事务控制有两种：编程式事务【了解】和==声明式事务==【重点】 - 声明式事务分为：基于xml配置和基于注解配置
事务的属性
去宇宙
03-11 245
spring对事务的管理，并不是spring直接管理。而是通过事务管理器交给JPA，JTA，hibernate，jdbc等来进行管理。jpa：jpaTransactionManagerjta：jtaTransactionManagerhibernate：hibernateTransactionManagerjdbc：DataSourceTransactionManager事务管理器接口Platfo...
Spring_MVC(5)业务层处理
哦嘛咪嘛咪哄~~~
04-24 227
这里将用到以下几个包： 引用 aopalliance-1.0.jar commons-collections.jar commons-dbcp.jar commons-logging-1.1.1.jar commons-pool.jar jstl.jar log4j-1.2.15.jar mysql-connector-java-5.1.6-bin.jar spring-aop-2.5.6....
@Transactional参数学习笔记
wyyanhxbl的博客
07-16 600
propagation 属性 REQUIRED：如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。 REPEATABLE_READ：这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读) SUPPORTS：如果当前存在事务，则加入该事务；如果当前不存在事务，则以非事务的方式继...
spring事务配置是在业务逻辑层还是dao层？
Shirley's IT life!
06-12 697
spring事务配置是在业务逻辑层还是dao层？ 业务逻辑层和dao层都可以配置事务处理，如果一个service调用多个dao，它们如果是一个事务，那么事务应该配置业务逻辑层，否则配置在dao层就可以了。 配置到dao层 PROPAGATION_REQUIRED PRO...
Spring 使用注解方式进行事务管理配置方式
08-30
Spring框架的注解式事务管理是一种便捷的方式来控制事务在应用程序中的行为，特别是在JavaEE开发中。这种方式使得开发者可以在不修改大量XML配置的情况下，通过在类或方法上添加注解来实现事务管理。以下是对Spring...
Spring事务@Transactional标签深入学习
weixin_34280237的博客
04-15 254
事务管理是应用系统开发中必不可少的一部分.Spring为事务管理提供了丰富的功能支持.Spring事务管理分为编码式和声明式两种方式.编码式事务指的是通过编码方式实现事务;声明式事务基于AOP,将具体业务逻辑与事务处理解耦.声明式事务管理使业务代码逻辑不受污染,因此在实际使用中声明式事务用的比较多.声明式事务有两种方式,一种是在配置文件(xml)中做相关事务规则声明,另一种是基于@Transact...
Spring4深入理解----事务（声明式事务和xml配置事务，事务传播属性，事务其他属性(隔离级别&回滚&只读&过期)）
ChangWen的博客
09-17 5541
参考代码下载github:https://github.com/changwensir/java-ee/tree/master/spring4   •事务管理是企业级应用程序开发中必不可少的技术,  用来确保数据的完整性和一致性.   •事务就是一系列的动作,它们被当做一个单独的工作单元.这些动作要么全部完成,要么全部不起作用   •事务的四个关键属性(ACID)     –原子性(
spring源码学习之aop事务标签解析
lihuayong的专栏
08-05 1374
在使用spring事物对数据操作的时候，经常使用到aop、tx等标签，spring使用aop面向切面编程，来实现对事物的控制，那么srping是怎么解析这些标签的呢？解析的入口在哪里呢？ spring版本：4.2.0.RELEASE 简单实例 一个简单的例子开始，对数据库进行事物操作，bean.xml的配置如下： <?xml version="1.0" encoding="UTF-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值