Spring事务管理——手动编码方式

文章摘要:
演示Spring的事务管理,使用手动编码方式。
未启用事务管理时,事务不会自动回滚;启用事务之后,当发生异常时,事务回滚。

开发环境:
Spring 3.2.0
Oracle 11.2.0.1.0
MyEclipse 10.7

一、环境准备
不使用客户端,直接使用cmd工具的情况下,开启自动提交:

1
2
SHOW auto;
SET auto ON;

创建表:

1
2
3
4
CREATE TABLE account(
name Varchar2(60),
money DOUBLE
)

插入两条数据

1
2
INSERT INTO account VALUES("aaa",1000);
INSERT INTO account VALUES("bbb",1000);

二、jar包与配置文件

1、jar包

Transaction_jars

Spring事务管理相关jar包

2、jdbc配置

1
2
3
4
jdbc.driver = oracle.jdbc.driver.OracleDriver
jdbc.url = jdbc:oracle:thin:@127.0.0.1:1521:orcl
jdbc.user = orcl
jdbc.password =orcl

3、applicationContext.xml配置

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
<?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.user}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
   
    <!-- 业务层类 -->
    <bean id="accountService" class="cn.jianyu.spring3.demo1.AccountServiceImpl">
        <!-- 在业务层注入Dao -->
        <property name="accountDao" ref="accountDao" ></property>
        <!-- 在业务层注入事务管理模板 -->
        <property name="transactionTemplate" ref="transactionTemplate"></property>
    </bean>
   
    <!-- 持久层类 -->
    <bean id="accountDao" class="cn.jianyu.spring3.demo1.AccountDaoImpl">
        <!-- 注入连接池的对象,通过连接创建对象模板 -->
        <property name="dataSource" ref="dataSource" ></property>
    </bean>
   
    <!-- 事务管理的模板 -->
    <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
        <property name="transactionManager" ref="transactionManager"></property>
    </bean>
   
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 需要注入连接池,通过连接池获得连接 -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
</beans>

4、log4j配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###
log4j.rootLogger=info, stdout

三、编写Java类
AccountDao.java —— DAO接口,定义in、out方法
AccountDaoImpl.java —— 实现Dao接口,实现in和out方法
AccountService.java —— Service接口,定义transfer方法
AccountServiceImpl.java —— 实现Service,调用in和out方法
SpringTest1.java —— 测试方法

AccountDao.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package cn.jianyu.spring3.demo1;

public interface AccountDao {
    /**
     * 转出方法
     * @param from
     * @param money
     */

    public void out(String from ,Double money);
    /**
     * 转入方法
     * @param to
     * @param money
     */

    public void in(String to,Double money);
}

AccountDaoImpl.java

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
package cn.jianyu.spring3.demo1;

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

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao{
    /**
     * 转出方法
     * @param from
     * @param money
     */

    public void out(String from, Double money) {
        String sql = "update account set money = money - ? where name = ?";
        this.getJdbcTemplate().update(sql, money, from);
        System.out.println("转出方法已执行");
    }
    /**
     * 转入方法
     * @param to
     * @param money
     */

    public void in(String to, Double money) {
        String sql = "update account set money = money + ? where name = ?";
        this.getJdbcTemplate().update(sql, money,to);
        System.out.println("转入方法已执行");
    }
   
}

AccountService.java

1
2
3
4
5
6
7
8
9
10
11
12
package cn.jianyu.spring3.demo1;

public interface AccountService {
    /**
     * 转账的方法
     * @param from 转出账户
     * @param to 转入账户
     * @param money 转账金额
     */

    public void transfer(String from, String to ,Double money);
   
}

AccountServiceImpl.java

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
package cn.jianyu.spring3.demo1;

import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;
    /*事务管理*/
    private TransactionTemplate transactionTemplate;
   
    /**
     * 转账的方法
     * @param from 转出账户
     * @param to 转入账户
     * @param money 转账金额
     */

    public void transfer(final String from, final String to, final Double money) {
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus arg0) {
                accountDao.out(from, money);
                double  i = 1/0;
                accountDao.in(to, money);
            }
        });
    }
   
    public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
        this.transactionTemplate = transactionTemplate;
    }
   
    /*通过setter方法注入*/
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
}

SpringTest1.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package cn.jianyu.spring3.demo1;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest1 {
    @Autowired
    @Qualifier("accountService")
    private AccountService accountService;
   
    @Test
    public void demo1(){
        //完成转账
        accountService.transfer("aaa", "bbb", 100d);
    }
}

最后,工程的源码:
https://github.com/baijy/springwork/tree/master/spring3_day03_transaction