事务是逻辑上的一组操作，这组操作要么全部成功，要么全部失败，最为典型的就是银行转账的案例：

A要向B转账，现在A，B各自账户中有1000元，A要给B转200元，那么这个转账就必须保证是一个事务，防止中途因为各种原因导致A账户资金减少而B账户资金未添加，或者B账户资金添加而A账户资金未减少，这样不是用户有损失就是银行有损失，为了保证转账前后的一致性就必须保证转账操作是一个事务。

事务具有的ACID特性，参考wikipedia。

首先，这篇文章先提及一些Spring中事务有关的API，然后分别实现编程式事务管理和声明式事务管理，其中声明式事务管理分别使用基于TransactionProxyFactoryBean的方式、基于AspectJ的XML方式、基于注解方式进行实现。

首先，我们简单看一下Spring事务管理需要提及的接口，Spring事务管理高层抽象主要包括3个接口

PlatformTransactionManager :事务管理器(用来管理事务，包含事务的提交，回滚) 
TransactionDefinition :事务定义信息(隔离，传播，超时，只读) 
TransactionStatus :事务具体运行状态

Spring根据事务定义信息(TransactionDefinition)由平台事务管理器(PlatformTransactionManager)真正进行事务的管理，在进行事务管理的过程中，事务会产生运行状态，状态保存在TransactionStatus中

PlatformTransactionManager:

Spring为不同的持久化框架提供了不同的PlatformTransactionManager如: 
在使用Spring JDBC或iBatis进行持久化数据时，采用DataSourceTransactionManager 
在使用Hibernate进行持久化数据时使用HibernateTransactionManager

TransactionDefinition:

TransactionDefinition接口中定义了一组常量，包括事务的隔离级别，事务的传播行为，超时信息，其中还定义了一些方法，可获得事务的隔离级别，超时信息，是否只读。

传播行为主要解决业务层方法之间的相互调用产生的事务应该如何传递的问题。

TransactionDefinition中定义的属性常量如下：

Field(属性) Description(描述)
ISOLATION_DEFAULT 使用底层数据存储的默认隔离级别
ISOLATION_READ_COMMITTED 表示防止脏读;可能会发生不可重复的读取和幻像读取
ISOLATION_READ_UNCOMMITTED 表示可能会发生脏读，不可重复的读取和幻像读取
ISOLATION_REPEATABLE_READ 表示禁止脏读和不可重复读;可以发生幻影读取
ISOLATION_SERIALIZABLE 表示可以防止脏读，不可重复的读取和幻像读取
PROPAGATION_MANDATORY 支持当前交易;如果不存在当前事务，则抛出异常
PROPAGATION_NESTED 如果当前事务存在，则在嵌套事务中执行，其行为类似于PROPAGATION_REQUIRED
PROPAGATION_NEVER 不支持当前交易;如果当前事务存在，则抛出异常
PROPAGATION_NOT_SUPPORTED 不支持当前交易;而是总是非事务地执行
PROPAGATION_REQUIRED 支持当前交易;如果不存在，创建一个新的
PROPAGATION_REQUIRES_NEW 创建一个新的事务，挂起当前事务（如果存在）
PROPAGATION_SUPPORTS 支持当前交易;如果不存在，则执行非事务性的
TIMEOUT_DEFAULT 使用底层事务系统的默认超时，如果不支持超时，则为none

TransationStatus:

在该接口中提供了一些方法:

Method Description
flush() 将基础会话刷新到数据存储（如果适用）：例如，所有受影响的Hibernate / JPA会话
hasSavepoint() 返回此事务是否内部携带保存点，也就是基于保存点创建为嵌套事务
isCompleted() 返回此事务是否完成，即是否已经提交或回滚
isNewTransaction() 返回当前交易是否是新的（否则首先参与现有交易，或者潜在地不会在实际交易中运行）
isRollbackOnly() 返回事务是否已被标记为仅回滚（由应用程序或由事务基础结构）
setRollbackOnly() 设置事务回滚

了解了上述接口，接下来我们通过转账案例来实现Spring的事务管理：

数据库中account表如下： 

1.编程式事务管理实现：

AccountDao.java:

package com.spring.demo1;

/**

 * Created by zhuxinquan on 17-4-27.

 */

public interface AccountDao {

    public void outMoney(String out, Double money);

    public void inMoney(String in, Double money);

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

AccountDaoImp.java

package com.spring.demo1;

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

/**

 * Created by zhuxinquan on 17-4-27.

 */

public class AccountDaoImp extends JdbcDaoSupport implements AccountDao {

    public void outMoney(String out, Double money) {

        String sql = "update account set money = money - ? where name = ?";

        this.getJdbcTemplate().update(sql, money, out);

    }

    public void inMoney(String in, Double money) {

        String sql = "update account set money = money + ? where name = ?";

        this.getJdbcTemplate().update(sql, money, in);

    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

AccountService.java

package com.spring.demo1;

/**

 * Created by zhuxinquan on 17-4-27.

 */

public interface AccountService {

    public void transfer(String out, String in, Double money);

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

AccountServiceImp.java

package com.spring.demo1;

import org.springframework.transaction.TransactionStatus;

import org.springframework.transaction.support.TransactionCallbackWithoutResult;

import org.springframework.transaction.support.TransactionTemplate;

/**

 * Created by zhuxinquan on 17-4-27.

 */

public class AccountServiceImp implements AccountService{

    private AccountDao accountDao;

    //    注入事务管理的模板

    private TransactionTemplate transactionTemplate;

    public void setTransactionTemplate(TransactionTemplate transactionTemplate) {

        this.transactionTemplate = transactionTemplate;

    }

    public void setAccountDao(AccountDao accountDao) {

        this.accountDao = accountDao;

    }

    public void transfer(final String out, final String in, final Double money) {

        transactionTemplate.execute(new TransactionCallbackWithoutResult() {

            @Override

            protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {

                accountDao.outMoney(out, money);

                //此处除0模拟转账发生异常

                int i = 1 / 0;

                accountDao.inMoney(in, money);

            }

        });

    }

}package com.spring.demo1;

import org.springframework.transaction.TransactionStatus;

import org.springframework.transaction.support.TransactionCallbackWithoutResult;

import org.springframework.transaction.support.TransactionTemplate;

/**

 * Created by zhuxinquan on 17-4-27.

 */

public class AccountServiceImp implements AccountService{

    private AccountDao accountDao;

    //    注入事务管理的模板

    private TransactionTemplate transactionTemplate;

    public void setTransactionTemplate(TransactionTemplate transactionTemplate) {

        this.transactionTemplate = transactionTemplate;

    }

    public void setAccountDao(AccountDao accountDao) {

        this.accountDao = accountDao;

    }

    public void transfer(final String out, final String in, final Double money) {

        transactionTemplate.execute(new TransactionCallbackWithoutResult() {

            @Override

            protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {

                accountDao.outMoney(out, money);

                int i = 1 / 0;

                accountDao.inMoney(in, money);

            }

        });

    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70

创建Spring配置文件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.USERNAME}"/>

        <property name="password" value="${jdbc.PASSWD}"/>

    </bean>

    <!--配置业务层类-->

    <bean id="accountService" class="com.spring.demo1.AccountServiceImp">

        <property name="accountDao" ref="accountDao"/>

        <property name="transactionTemplate" ref="transactionTemplate"/>

    </bean>

    <!--配置Dao的类-->

    <bean id="accountDao" class="com.spring.demo1.AccountDaoImp">

        <property name="dataSource" ref="dataSource"/>

    </bean>

    <!--配置事务管理器-->

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

        <property name="dataSource" ref="dataSource"/>

    </bean>

    <!--配置事务管理模板,Spring为了简化事务管理的代码而提供的类-->

    <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">

        <property name="transactionManager" ref="transactionManager"/>

    </bean>

</beans>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

编写测试类如下： 
SpringDemoTest1.java

import com.spring.demo1.AccountService;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.context.annotation.Configuration;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

/**

 * Created by zhuxinquan on 17-4-27.

 * Spring编程式事务管理

 */

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext.xml")

public class SpringDemoTest1 {

    @Resource(name = "accountService")

    private AccountService accountService;

    @Test

    public void demo1(){

        accountService.transfer("aaa", "bbb", 200d);

    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

2.基于TransactionProxyFactoryBean的声明式事务管理

Dao与Service代码与1中相同，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.USERNAME}"/>

        <property name="password" value="${jdbc.PASSWD}"/>

    </bean>

    <!--配置业务层类-->

    <bean id="accountService" class="com.spring.demo2.AccountServiceImp">

        <property name="accountDao" ref="accountDao"/>

    </bean>

    <!--配置Dao的类-->

    <bean id="accountDao" class="com.spring.demo2.AccountDaoImp">

        <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格式

                    * PROPAGATION   :事务的传播行为

                    * ISOLATION     :事务的隔离级别

                    * readOnly      :只读(不可以进行修改，插入，删除的操作)

                    * -Exception    :发生哪些异常回滚事务

                    * +Exception    :发生哪些异常不回滚事务

                -->

                <prop key="transfer">PROPAGATION_REQUIRED</prop>

                <!--<prop key="transfer">PROPAGATION_REQUIRED,readOnly</prop>-->

                <!--<prop key="transfer">PROPAGATION_REQUIRED, +java.lang.ArithmeticException</prop>-->

            </props>

        </property>

    </bean>

</beans>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55

此时注入时需要选择代理类，因为在代理类中进行增强操作，测试代码如下： 
SpringDemoTest2.java

import com.spring.demo2.AccountService;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

/**

 * Created by zhuxinquan on 17-4-27.

 * Spring声明式事务管理:基于TransactionProxyFactoryBean的方式

 */

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext2.xml")

public class SpringDemoTest2 {

    /*

    此时需要注入代理类：因为代理类进行增强操作

     */

//    @Resource(name = "accountService")

    @Resource(name = "accountServiceProxy")

    private AccountService accountService;

    @Test

    public void demo1(){

        accountService.transfer("aaa", "bbb", 200d);

    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

3.基于AspectJ的XML声明式事务管理

在这种方式下Dao和Service的代码也没有改变，applicationContext3.xml如下： 
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"

       xmlns:task="http://www.springframework.org/schema/task"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

       http://www.springframework.org/schema/beans/spring-beans-3.1.xsd

       http://www.springframework.org/schema/context

       http://www.springframework.org/schema/context/spring-context-3.1.xsd

       http://www.springframework.org/schema/aop

       http://www.springframework.org/schema/aop/spring-aop-3.1.xsd

       http://www.springframework.org/schema/tx

       http://www.springframework.org/schema/tx/spring-tx-3.1.xsd

       http://www.springframework.org/schema/task

       http://www.springframework.org/schema/task/spring-task-3.1.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.USERNAME}"/>

        <property name="password" value="${jdbc.PASSWD}"/>

    </bean>

    <!--配置业务层类-->

    <bean id="accountService" class="com.spring.demo3.AccountServiceImp">

        <property name="accountDao" ref="accountDao"/>

    </bean>

    <!--配置Dao的类-->

    <bean id="accountDao" class="com.spring.demo3.AccountDaoImp">

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

        <tx:attributes>

            <!--

                propagation     :事务传播行为

                isolation       :事务的隔离级别

                read-only       :只读

                rollback-for    :发生哪些异常回滚

                no-rollback-for :发生哪些异常不回滚

                timeout         :过期信息

            -->

            <tx:method name="transfer" propagation="REQUIRED"/>

        </tx:attributes>

    </tx:advice>

    <!--配置切面-->

    <aop:config>

        <!--配置切入点-->

        <aop:pointcut id="pointcut1" expression="execution(* com.spring.demo3.AccountService+.*(..))"/>

        <!--配置切面-->

        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>

    </aop:config>

</beans>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66

测试类与1中相同，增强是动态织入的，所以此时注入的还是accountService。

4.基于注解的声明式事务管理

基于注解的方式需要在业务层上添加一个@Transactional的注解。 
如下： 
AccountServiceImp.java

package com.spring.demo4;

import org.springframework.transaction.annotation.Propagation;

import org.springframework.transaction.annotation.Transactional;

/**

 * Created by zhuxinquan on 17-4-27.

 * propagation  :事务的传播行为

 * isolation    :事务的隔离级别

 * readOnly     :只读

 * rollbackFor  :发生哪些异常回滚

 */

@Transactional(propagation = Propagation.REQUIRED)

public class AccountServiceImp implements AccountService {

    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {

        this.accountDao = accountDao;

    }

    public void transfer(String out, String in, Double money) {

        accountDao.outMoney(out, money);

        int i = 1 / 0;

        accountDao.inMoney(in, money);

    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

此时需要在Spring配置文件中开启注解事务，打开事务驱动 
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"

       xmlns:task="http://www.springframework.org/schema/task"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

       http://www.springframework.org/schema/beans/spring-beans-3.1.xsd

       http://www.springframework.org/schema/context

       http://www.springframework.org/schema/context/spring-context-3.1.xsd

       http://www.springframework.org/schema/aop

       http://www.springframework.org/schema/aop/spring-aop-3.1.xsd

       http://www.springframework.org/schema/tx

       http://www.springframework.org/schema/tx/spring-tx-3.1.xsd

       http://www.springframework.org/schema/task

       http://www.springframework.org/schema/task/spring-task-3.1.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.USERNAME}"/>

        <property name="password" value="${jdbc.PASSWD}"/>

    </bean>

    <!--配置业务层类-->

    <bean id="accountService" class="com.spring.demo4.AccountServiceImp">

        <property name="accountDao" ref="accountDao"/>

    </bean>

    <!--配置Dao的类-->

    <bean id="accountDao" class="com.spring.demo4.AccountDaoImp">

        <property name="dataSource" ref="dataSource"/>

    </bean>

    <!--配置事务管理器-->

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

        <property name="dataSource" ref="dataSource"/>

    </bean>

    <!--开启注解事务  打开事务驱动-->

    <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46

测试类与1中相同

以上所有的代码可在这里进行下载，需要注意的是这里使用到了log4j，所以需要log4j的资源文件，同时，数据库的配置也是使用了资源文件的方式，还有需要注意的就是在Spring的配置中，我们需要注意配置文件的约束信息，再起次就是要注意jar包的导入了。

参考链接：https://blog.csdn.net/zhuxinquan61/article/details/71075051

Spring事务管理的demo的更多相关文章

  1. Spring 事务管理案例

    事务管理简介   Spring 事务管理有两种方式:一种是编程式事务管理,即通过编写代码实现事物管理,包括定义事务的开始,程序正常执行后的事物提交,异常时进行的事务回滚.另一种是基于AOP技术实现的声 ...

  2. 2017.4.18 慕课网-spring事务管理总结

    1.课程目标 事务回顾 spring中的事务管理的api spring中编程式事务管理 spring中声明式事务管理 2.事务回顾 2.1 事务的概念 事务是指逻辑上的一组操作,要么全成功,要么全失败 ...

  3. 【Java EE 学习 52】【Spring学习第四天】【Spring与JDBC】【JdbcTemplate创建的三种方式】【Spring事务管理】【事务中使用dbutils则回滚失败！！！？？】

    一.JDBC编程特点 静态代码+动态变量=JDBC编程. 静态代码:比如所有的数据库连接池 都实现了DataSource接口,都实现了Connection接口. 动态变量:用户名.密码.连接的数据库. ...

  4. spring事务管理器设计思想（二）

    上文见<spring事务管理器设计思想(一)> 对于第二个问题,涉及到事务的传播级别,定义如下: PROPAGATION_REQUIRED-- 如果当前没有事务,就新建一个事务.这是最常见 ...

  5. spring事务管理器设计思想（一）

    在最近做的一个项目里面,涉及到多数据源的操作,比较特殊的是,这多个数据库的表结构完全相同,由于我们使用的ibatis框架作为持久化层,为了防止每一个数据源都配置一套规则,所以重新实现了数据源,根据线程 ...

  6. 事务管理(下) 配置spring事务管理的几种方式(声明式事务)

    配置spring事务管理的几种方式(声明式事务) 概要: Spring对编程式事务的支持与EJB有很大的区别.不像EJB和Java事务API(Java Transaction API, JTA)耦合在 ...

  7. Spring事务管理器的应对

    Spring抽象的DAO体系兼容多种数据访问技术,它们各有特色,各有千秋.像Hibernate是非常优秀的ORM实现方案,但对底层SQL的控制不太方便:而iBatis则通过模板化技术让你方便地控制SQ ...

  8. Spring事务管理（转）

    1 初步理解 理解事务之前,先讲一个你日常生活中最常干的事:取钱. 比如你去ATM机取1000块钱,大体有两个步骤:首先输入密码金额,银行卡扣掉1000元钱:然后ATM出1000元钱.这两个步骤必须是 ...

  9. [Spring框架]Spring 事务管理基础入门总结.

    前言:在之前的博客中已经说过了数据库的事务, 不过那里面更多的是说明事务的一些锁机制, 今天来说一下Spring管理事务的一些基础知识. 之前的文章: [数据库事务与锁]详解一: 彻底理解数据库事务一 ...

随机推荐

  1. 【mybatis源码学习】mybtias扩展点

    [1]org.apache.ibatis.reflection.ReflectorFactory 该扩展点,主要是对javaBean对象,进行反射操作. org.apache.ibatis.refle ...

  2. madlib 集成 hasura graphql-engine 试用

    madlib 可以让我们直接在sql 中进行机器学习,集成了强大的sql 能力,以及分析能力,后边会尝试 集成graphql engine ,让功能更强大 docker 镜像准备 使用了一个别人的写好 ...

  3. 03C++语言对C的增强——实用性、变量检测、struct类型、C++中所有变量和函数都必须有类型、bool类型、三目运算符

    1.“实用性”增强 C语言中的变量都必须在作用域开始的位置定义,C++中更强调语言的“实用性”,所有的变量都可以在需要使用时再定义. 2.C++对c语言register的增强 register关键字 ...

  4. CloudStack学习-3

    此次试验主要是CloudStack结合openvswitch 背景介绍 之所以引入openswitch,是因为如果按照之前的方式,一个网桥占用一个vlan,假如一个zone有20个vlan,那么岂不是 ...

  5. Quartz学习总结

    一.基本介绍: Quartz 是 OpenSymphony 开源组织在任务调度领域的一个开源项目,完全基于 Java 实现.该项目于 2009 年被 Terracotta 收购,目前是 Terraco ...

  6. 查看hp小型机命令集

    查看HP小型机的信息的命令集(一) 1.机型 #model 9000/800/L2000-44 注意:其中44是指每个cpu有440MHZ. 2.cpu个数 #top CPU LOAD USER NI ...

  7. create-react-app-typescript 知识点

    github:https://github.com/wmonk/create-react-app-typescript 报错:Import sources within a group must be ...

  8. redis实现与分析-单机数据库实现

    数据库 1,1个数据库数据结构和上面一样,两个字典,一个包含所有的键,一个包含了键的过期时间 2,redis删除过期键策略:定期+惰性 定期:一段时间开始删,删不全下次继续删 惰性:使用键的时候检察 ...

  9. mysql 主从复制参数slave_net_timeout

    slave_net_timeout slave_net_timeout表示slave在slave_net_timeout时间之内没有收到master的任何数据(包括binlog,heartbeat), ...

  10. SparkStreaming整合kafka编程

    1.下载spark-streaming-kafka插件包 由于Linux集群环境我使用spark是spark-2.1.1-bin-hadoop2.7,kafka是kafka_2.11-0.8.2.1, ...