Spring配置事务的五种方式

最新推荐文章于 2022-03-25 16:20:58 发布
最新推荐文章于 2022-03-25 16:20:58 发布
阅读量1k 收藏 1
点赞数
分类专栏： spring 文章标签： spring hibernate 事务 注解 aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011545613/article/details/72861898
版权

Spring
1：对每一个服务层类Bean配置一个代理：
a.首先创建一个maven quick-start 项目，然后配置依赖包：
mysql-connector,spring-context,spring-orm,hibernate,
hibernate-core,dbcp2(数据源)
b.在test数据库中编写数据库脚本并执行，以及编写applicationContext.xml文件（在src目录下）：

DROP TABLE IF EXISTS account;  
CREATE TABLE account (  
accountId int primary key auto_increment,  
accountname varchar(20),  
money int not null  
);  

INSERT INTO ACCOUNT(ACCOUNTNAME,MONEY) VALUES('zhangsan',100);  
INSERT INTO ACCOUNT(ACCOUNTNAME,MONEY) VALUES('lisi',100);  
<?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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
  <bean id="dataSource"  
        class="org.apache.commons.dbcp2.BasicDataSource">  
        <property name="driverClassName"  
            value="com.mysql.jdbc.Driver">  
        </property>  
        <property name="url" value="jdbc:mysql://localhost:3306/test?characterEncoding=utf8&amp;serverTimezone=GMT"></property>  
        <property name="username" value="root"></property>  
        <property name="password" value="mysqladmin"></property>  
    </bean>  

    <bean id="sessionFactory"  
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
        <property name="dataSource">  
            <ref bean="dataSource" />  
        </property>  
        <property name="hibernateProperties">  
            <props>  
                <prop key="hibernate.dialect">  
                    org.hibernate.dialect.MySQLDialect  
                </prop>  
                <prop key="hibernate.show_sql">true</prop>  
            </props>  
        </property>  
        <property name="mappingResources">  
            <list>  
                <value>kai/SpringTransaction1/Account.hbm.xml</value>  
            </list>  
        </property>  
    </bean>  


    <!-- 定义事务管理器（声明式的事务） -->  
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <!-- 配置DAO和service -->
    <bean id="accountDAO" class="kai.SpringTransaction1.AccountDAO">
     <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    <bean id="accountServiceTarget" class="kai.SpringTransaction1.AccountService">
        <property name="accountDAO" ref="accountDAO" />
    </bean>
      <!-- 每个bean配置一个代理 -->
    <bean id="accountService"  
        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">  
           <!-- 配置事务管理器 -->  
           <property name="transactionManager" ref="transactionManager" />     
        <property name="target" ref="accountServiceTarget" />  
         <property name="proxyInterfaces" value="kai.SpringTransaction1.IAccountService" />
        <!-- 配置事务属性 -->  
        <property name="transactionAttributes">  
            <props>  
                <prop key="*">PROPAGATION_REQUIRED</prop>
            </props>  
        </property>  
    </bean>  
</beans>

c.编写Account类

package kai.SpringTransaction1;

public class Account implements java.io.Serializable {  

    /** 
     *  
     */  
    private static final long serialVersionUID = 909891879728703117L;  

    private Integer accountId;  
    private String accountname;  
    private Integer money;  

    // Property accessors  

    public Integer getAccountId() {  
        return this.accountId;  
    }  

    public void setAccountId(Integer accountId) {  
        this.accountId = accountId;  
    }  

    public String getAccountname() {  
        return this.accountname;  
    }  

    public void setAccountname(String accountname) {  
        this.accountname = accountname;  
    }  

    public Integer getMoney() {  
        return this.money;  
    }  

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

    // Constructors  

    /** default constructor */  
    public Account() {  
    }  

    /** full constructor */  
    public Account(String accountname, Integer money) {  
        this.accountname = accountname;  
        this.money = money;  
    }  

}

d.编写AccountDAO和IAccountService，AccountService和Account.hbm.xml，因为是基于代理的，因此服务层必须要有接口，即必须有IAccountService,不能直接代理AccountService。

package kai.SpringTransaction1;

import org.hibernate.SessionFactory;
public class AccountDAO  {  
      public SessionFactory sessionFactory;
      public void setSessionFactory(SessionFactory sessionFactory){
          this.sessionFactory=sessionFactory;
      }
    @SuppressWarnings("deprecation")
    public void addMoney(Integer accountId, int money) {  
        Account ac=(Account) sessionFactory.getCurrentSession().get(Account.class, accountId);
        ac.setMoney(money+ac.getMoney());
        sessionFactory.getCurrentSession().update(ac,accountId);
    }  

    public void subMoney(Integer accountId, int money) {  
        Account ac=(Account) sessionFactory.getCurrentSession().get(Account.class, accountId);
        ac.setMoney(ac.getMoney()-money);
        sessionFactory.getCurrentSession().update(ac,accountId); 
    }  
}  

package kai.SpringTransaction1;

public interface IAccountService {
     public void transfer(Integer fromAccountId, Integer toAccountId, int money) ;
}

package kai.SpringTransaction1;


public class AccountService implements IAccountService{   

    private AccountDAO accountDAO;   

    /**  
     * 通过 Spring 将 DAO 注入到 Service  
     *   
     * @param accountDAO  
     * 
     */  
    public void setAccountDAO(AccountDAO accountDAO) {   
        this.accountDAO = accountDAO;   
    }   

    /**  
     * 转账方法包括两个原子方法：转出方法和转入方法  
     *   
     * @param fromAccountId  
     * @param toAccountId  
     * @param money  
     */  
    public void transfer(Integer fromAccountId, Integer toAccountId, int money) {   
        accountDAO.subMoney(fromAccountId, money);   
        accountDAO.addMoney(toAccountId, money);   
    }   
}  

<?xml version="1.0" encoding="utf-8"?>  
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
<!--  
    Mapping file autogenerated by MyEclipse Persistence Tools 
-->  
<hibernate-mapping>  
    <class name="kai.SpringTransaction1.Account" table="account" catalog="test">  
        <id name="accountId" type="java.lang.Integer">  
            <column name="accountId" />  
            <generator class="native" />  
        </id>  
        <property name="accountname" type="java.lang.String">  
            <column name="accountname" length="20" />  
        </property>  
        <property name="money" type="java.lang.Integer">  
            <column name="money" length="20" />  
        </property>  
    </class>  
</hibernate-mapping>

e.编写测试类

package kai.SpringTransaction1;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        System.out.println( "Hello World!" );
        ApplicationContext act = new FileSystemXmlApplicationContext(   
                "src/applicationContext.xml");   
        IAccountService accountService = (IAccountService) act   
                .getBean("accountService");   
        try {   
            // 帐号1转账1元至帐号2   
            accountService.transfer(1, 2, 1);  
        } catch (Exception e) {   
            System.out.println("转账失败");   
        }   
    }
}

f.运行：查看数据库可知钱成功转账，若将测试类中改为从账户1转到不存在的张户2，则1的钱也不会减少。
2.对服务层所有bean配置同一个代理：
只需将1中的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"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
  <bean id="dataSource"  
        class="org.apache.commons.dbcp2.BasicDataSource">  
        <property name="driverClassName"  
            value="com.mysql.jdbc.Driver">  
        </property>  
        <property name="url" value="jdbc:mysql://localhost:3306/test?characterEncoding=utf8&amp;serverTimezone=GMT"></property>  
        <property name="username" value="root"></property>  
        <property name="password" value="mysqladmin"></property>  
    </bean>  

    <bean id="sessionFactory"  
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
        <property name="dataSource">  
            <ref bean="dataSource" />  
        </property>  
        <property name="hibernateProperties">  
            <props>  
                <prop key="hibernate.dialect">  
                    org.hibernate.dialect.MySQLDialect  
                </prop>  
                <prop key="hibernate.show_sql">true</prop>  
            </props>  
        </property>  
        <property name="mappingResources">  
            <list>  
                <value>kai/SpringTransaction1/Account.hbm.xml</value>  
            </list>  
        </property>  
    </bean>  


    <!-- 定义事务管理器（声明式的事务） -->  
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <!-- 配置DAO和service -->
    <bean id="accountDAO" class="kai.SpringTransaction1.AccountDAO">
     <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    <bean id="accountServiceTarget" class="kai.SpringTransaction1.AccountService">
        <property name="accountDAO" ref="accountDAO" />
    </bean>
    <!-- 配置所有服务层bean的共同代理-->  
       <bean id="transactionBase"  
            class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"  
            lazy-init="true" abstract="true">  
        <!-- 配置事务管理器 -->  
        <property name="transactionManager" ref="transactionManager" />  
        <!-- 配置事务属性 -->  
        <property name="transactionAttributes">  
            <props>  
                <prop key="*">PROPAGATION_REQUIRED</prop>  
            </props>  
        </property>  
    </bean>    
      <!-- 所有bean配置一个代理 -->
    <bean id="accountService" parent="transactionBase">  
        <property name="target" ref="accountServiceTarget" />  
    </bean>  
</beans>

3.基于拦截器的实现，也是只需要修改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"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
  <bean id="dataSource"  
        class="org.apache.commons.dbcp2.BasicDataSource">  
        <property name="driverClassName"  
            value="com.mysql.jdbc.Driver">  
        </property>  
        <property name="url" value="jdbc:mysql://localhost:3306/test?characterEncoding=utf8&amp;serverTimezone=GMT"></property>  
        <property name="username" value="root"></property>  
        <property name="password" value="mysqladmin"></property>  
    </bean>  

    <bean id="sessionFactory"  
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
        <property name="dataSource">  
            <ref bean="dataSource" />  
        </property>  
        <property name="hibernateProperties">  
            <props>  
                <prop key="hibernate.dialect">  
                    org.hibernate.dialect.MySQLDialect  
                </prop>  
                <prop key="hibernate.show_sql">true</prop>  
            </props>  
        </property>  
        <property name="mappingResources">  
            <list>  
                <value>kai/SpringTransaction1/Account.hbm.xml</value>  
            </list>  
        </property>  
    </bean>  


    <!-- 定义事务管理器（声明式的事务） -->  
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <!-- 配置DAO和service -->
    <bean id="accountDAO" class="kai.SpringTransaction1.AccountDAO">
     <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    <bean id="accountService" class="kai.SpringTransaction1.AccountService">
        <property name="accountDAO" ref="accountDAO" />
    </bean>
     <!-- 配置拦截器实现事务 -->  
    <bean id="transactionInterceptor"  
        class="org.springframework.transaction.interceptor.TransactionInterceptor">  
        <property name="transactionManager" ref="transactionManager" />  
        <!-- 配置事务属性 -->  
        <property name="transactionAttributes">  
            <props>  
                <prop key="*">PROPAGATION_REQUIRED</prop>  
            </props>  
        </property>  
    </bean>

    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">  
        <property name="beanNames">  
            <list>  
                <value>*Service</value>
            </list>  
        </property>  
        <property name="interceptorNames">  
            <list>  
                <value>transactionInterceptor</value>  
            </list>  
        </property>  
    </bean>  
</beans>

4.使用AOP方式实现：
在1的基础上修改applicationContext.xml文件以及引入依赖包：aspectj和aspectjweaver。

<?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-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
  <bean id="dataSource"  
        class="org.apache.commons.dbcp2.BasicDataSource">  
        <property name="driverClassName"  
            value="com.mysql.jdbc.Driver">  
        </property>  
        <property name="url" value="jdbc:mysql://localhost:3306/test?characterEncoding=utf8&amp;serverTimezone=GMT"></property>  
        <property name="username" value="root"></property>  
        <property name="password" value="mysqladmin"></property>  
    </bean>  

    <bean id="sessionFactory"  
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
        <property name="dataSource">  
            <ref bean="dataSource" />  
        </property>  
        <property name="hibernateProperties">  
            <props>  
                <prop key="hibernate.dialect">  
                    org.hibernate.dialect.MySQLDialect  
                </prop>  
                <prop key="hibernate.show_sql">true</prop>  
            </props>  
        </property>  
        <property name="mappingResources">  
            <list>  
                <value>kai/SpringTransaction1/Account.hbm.xml</value>  
            </list>  
        </property>  
    </bean>  


    <!-- 定义事务管理器（声明式的事务） -->  
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <!-- 配置DAO和service -->
    <bean id="accountDAO" class="kai.SpringTransaction1.AccountDAO">
     <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    <bean id="accountService" class="kai.SpringTransaction1.AccountService">
        <property name="accountDAO" ref="accountDAO" />
    </bean>
      <!-- 下面使用aop切面的方式来实现 事务控制-->  
    <tx:advice id="TestAdvice" transaction-manager="transactionManager">  
        <!--配置事务传播性，隔离级别以及超时回滚等问题 -->  
        <tx:attributes>  
            <tx:method name="save*" propagation="REQUIRED" />  
            <tx:method name="del*" propagation="REQUIRED" />  
            <tx:method name="update*" propagation="REQUIRED" />  
            <tx:method name="add*" propagation="REQUIRED" />  
            <tx:method name="*" propagation="REQUIRED" />  
        </tx:attributes>  
    </tx:advice>  
    <aop:config>  
        <!--配置事务切点 -->  
        <aop:pointcut id="services"  
            expression="execution(* kai.SpringTransaction1.AccountService.*(..))" />  
        <aop:advisor pointcut-ref="services" advice-ref="TestAdvice" />  
    </aop:config>  
</beans>

5.注解式事务：（这是我觉得最优雅的）：
修改applicationContext.xml文件同时在需要加事务控制的方法上加上@Transactional注解。此处即在AccountService的transfer方法上加上@Transactional注解。

<?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-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
  <bean id="dataSource"  
        class="org.apache.commons.dbcp2.BasicDataSource">  
        <property name="driverClassName"  
            value="com.mysql.jdbc.Driver">  
        </property>  
        <property name="url" value="jdbc:mysql://localhost:3306/test?characterEncoding=utf8&amp;serverTimezone=GMT"></property>  
        <property name="username" value="root"></property>  
        <property name="password" value="mysqladmin"></property>  
    </bean>  

    <bean id="sessionFactory"  
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
        <property name="dataSource">  
            <ref bean="dataSource" />  
        </property>  
        <property name="hibernateProperties">  
            <props>  
                <prop key="hibernate.dialect">  
                    org.hibernate.dialect.MySQLDialect  
                </prop>  
                <prop key="hibernate.show_sql">true</prop>  
            </props>  
        </property>  
        <property name="mappingResources">  
            <list>  
                <value>kai/SpringTransaction1/Account.hbm.xml</value>  
            </list>  
        </property>  
    </bean>  


    <!-- 定义事务管理器（声明式的事务） -->  
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <!-- 配置DAO和service -->
    <bean id="accountDAO" class="kai.SpringTransaction1.AccountDAO">
     <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    <bean id="accountService" class="kai.SpringTransaction1.AccountService">
        <property name="accountDAO" ref="accountDAO" />
    </bean>
      <!-- 下面使用全注解的方式来实现 事务控制-->  
 <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

补充说明：
1.@Transactional
（1）这个注解放在类上面，会对这个类中的所有public方法都起作用；
（2）放在方法上，只有当这个方法是public方法才起作用。
（3）事务的传播性：@Transactional(propagation=Propagation.REQUIRED)
（4）事务的隔离级别：@Transactional(isolation = Isolation.READ_UNCOMMITTED)
参考文章：
http://blog.csdn.net/it_man/article/details/5074371
http://blog.csdn.net/lifangshui/article/details/6324348
http://blog.csdn.net/qh_java/article/details/51811533

Promise_kk
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring 事务相关配置
流楚丶格念的博客
07-25 2357
但是对于编译器异常，Spring事务是不进行回滚的，所以需要使用rollbackFor来设置要回滚的异常。例如methodA方法调用methodB方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个新事务运行，这就是由methodB的事务传播行为决定的。但是对于编译器异常（例如IOException），Spring事务是不进行回滚的。虽然学会了使用Spring回滚事务，但是有一种异常Spring事务默认是不进行回滚的那就是编译器异常。......
Spring事务配置的五种方式.doc
最新发布
12-01
在这种方式中，每个Bean都需要配置事务代理，以实现事务的管理。下面是一个简单的配置示例： ```xml <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> ...
Spring事务的使用配置和详细介绍（ 编程式事务+声明式事务+隔离级别+传播行为+回滚机制）
m0_46193073的博客
01-16 2563
Spring框架中的事务 有很多人觉得我们有了Spring，就再也不需要去处理获得连接、事务提交、回滚和关闭连接等这些操作了，其实并不是这样的，事实上Spring并不是直接管理事务的，只是提供了多种事务管理器，让持久化机制所提供的平台框架的事务来实现事务管理。 Spring事务管理的三大接口底层的实现关系如图所示: 三者的关系非常清晰，TransactionDefinition 将 Tran...
Spring 事务的配置和使用详解（包括手动对事务的控制部分）
whbing1471的博客
01-05 1万+
最近项目中用到了spring的注解类的事务管理，所以特地学习和记录一下spring的配置和使用。项目中使用的是springMVC + mybatis + mysql。spring的版本是4.3.0.RELEASE。1. spring 注解事务的配置Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式
Spring事务管理的几种配置方式
qq_33912978的博客
06-21 267
事务原本是数据库中的概念，在Dao层。 但一般情况下，需要将事务提升到业务层，即Service层。 这样做为了能够使用事务的特性来管理具体的业务。 使用spring 的事务代理工厂管理事务。 使用spring的事务注解管理事务 使用AspectJ的AOP配置管理事务。 Spring事务管理API： 主要用到两个事务相关的接口。 （1）事务管理接口。 事务管理器是platformTransactionManager接口对象。 其主要用于完成事务的提交，回滚，以及获取事务的状态信息..
spring事务配置的五种方式
yygr的博客
03-25 3623
https://blog.csdn.net/m8396017/article/details/51615806 spring事务配置的五种方式 第一种方式：每个Bean都有一个代理 第二种方式：所有Bean共享一个代理基类 第三种方式：使用拦截器 第四种方式：使用tx标签配置的拦截器 第五种方式：全注解 前段时间对Spring的事务配置做了比较深入的研究，在此之间对Spring的事务配置虽说也配置过，但是一直没有一个清楚的认识。通过这次的学习发觉Spring的事务配置只..
spring配置事务五种方式.doc
11-09
本文将详细介绍Spring配置事务的五种方法，每种方法都基于相同的基本组件：DataSource、TransactionManager以及代理机制。理解这些配置方式有助于更好地控制事务在应用程序中的行为。 1. **每个Bean都有一个代理** ...
详解Spring配置事务的五种方式
09-02
本文将详细介绍Spring配置事务的五种方式，以便开发者们更好地理解和应用。 首先，Spring配置事务通常涉及三个关键组件： 1. **DataSource**：数据源，它是连接到数据库的桥梁，负责管理数据库连接。在使用...
Spring事务原理、Spring事务配置的五种方式
07-06
Spring事务原理是指Spring框架中的一种机制，用于管理事务，并提供了多种配置方式。事务是指一系列的操作，作为一个整体执行，如果其中某个操作失败，整个事务将回滚。Spring事务原理围绕着两个核心：...
Spring事务配置的五种方式
05-12
下面将详细介绍这五个主要的事务配置方式。 1. **每个Bean都有一个代理** 在这种配置方式中，每个需要事务管理的Bean都会有一个事务代理。通过`TransactionProxyFactoryBean`创建代理，每个业务逻辑方法都将在事务...
spring事务配置详解
03-07
spring事务配置详解 spring事务配置详解
Spring的事务配置
weixin_45506581的博客
11-05 296
事务:逻辑上的一组操作,组成这组操作的各个单元,要么全部成功,要么全部失败 特性:ACID 原子性:不能再次分割 一致性:事务之前与之后,数据保持一致 隔离性:多个事务之间相互隔离,不受影响 持久性:一旦提交后不可恢复 作用:执行增删改时,保持数据的一致、安全,不会出错了仍然提交 Spring的配置事务方式:声明式事务处理、注解方式的声明式事务管理 1.声明式事务处理 (1).在Spring核心配置文件中引入相关约束： <?xml version="1.0" en...
spring事务实现的几种方式
weixin_41979002的博客
07-26 1万+
spring事务处理 前言 1.、事务几种实现方式 （1）编程式事务管理对基于 POJO 的应用来说是唯一选择。我们需要在代码中调用beginTransaction()、commit()、rollback()等事务管理相关的方法，这就是编程式事务管理。 （2）基于 TransactionProxyFactoryBean的声明式事务管理 （3）基于 @Transactional 的声明式事务管理 （4）基于Aspectj AOP配置事务 编程式事务管理 第一：使用 TransactionTemplate 事务
Spring的事务
weixin_44895829的博客
03-14 9955
1.什么是事务 事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操 作都失败 （2）典型场景：银行转账 lucy 转账 100 元 给 mary lucy 少 100，mary 多 100 事务四个特性（ACID） （1）原子性 一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做 （2）一致性 事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。 （3）隔离性 一个事务的执行不能被其他事务干扰...
spring事物配置，声明式事务管理和基于@Transactional注解的使用
热门推荐
不学习就淘汰
12-04 30万+
事务管理对于企业应用来说是至关重要的，即使出现异常情况，它也可以保证数据的一致性。 spring支持编程式事务管理和声明式事务管理两种方式。 编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。  声明式事务管理建立在
Java - 如何配置事务增强？
了解➔熟悉➔掌握➔精通
03-20 3万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="...
Spring事物管理——五种配置方法
bear_wr的专栏
10-04 4496
前段时间对spring的事务配置做了比较深入的研究，在此之间对Spring的事务配置虽说也配置过，但是一直没有一个清楚的认识。通过这次的学习发觉Spring的事务配置只要把思路理清，还是比较好掌握的。总结如下： Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。D
Spring：声明式事务
adsdaas的博客
03-17 393
回顾事务 事务在项目开发过程非常重要，涉及到数据的一致性的问题，不容马虎！ 事务管理是企业级应用程序开发中必备技术，用来确保数据的完整性和一致性。     事务就是把一系列的动作当成一个独立的工作单元，这些动作要么全部完成，要么全部不起作用。     事务四个属性ACID 原子性（atomicity） 事务是原...
Spring中事物管理器配置
何阳的博客
06-13 1万+
Spring自带事物管理器，只需要配置一下，方法进行规范命名即可第一步：创建一个Spring事物管理器第二步：配置行为propagation="REQUIRED" 指如果当前有事物就在该事物中执行，如果没有，就开启一个新的事物（增删改查中）propagation="SUPPORTS" read-only="true"  指如果有就执行该事物，如果没有，就不会开启事物（查询中）第三步：配置AOP切面...
spring声明式事务配置方法.docx
04-16
TransactionProxyFactoryBean 方式是 Spring 中的一种声明式事务配置方法。这种方法通过使用 TransactionProxyFactoryBean 来生成代理对象，从而实现事务的管理。 在 Applicationcontext.xml 文件中，我们可以通过...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值