Spring事务两种方式（基于注解和XML配置）

最新推荐文章于 2023-02-10 19:25:11 发布

Luck_ZZ

最新推荐文章于 2023-02-10 19:25:11 发布

阅读量1.6k

点赞数 2

分类专栏： spring 文章标签： spring 事务注解 transactional xml

本文链接：https://blog.csdn.net/Luck_ZZ/article/details/100060323

版权

spring 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、添加依赖

在maven中添加spring依赖、spring aop依赖、spring数据库依赖、spring事务依赖、c3p0依赖、mysql依赖、spring测试依赖

Spring事务在业务逻辑上添加事务，容器中保存的是这个业务逻辑的代理对象，所有需要aop依赖（aop的实现是依靠动态代理，生成代理对象）

<properties>
    <spring.version>5.1.9.RELEASE</spring.version>
    <junit.version>4.12</junit.version>
    <mysql.version>8.0.15</mysql.version>
    <c3p0.version>0.9.1.2</c3p0.version>
</properties>

<dependencies>
    <!--spring依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <!--spring aop依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <!--spring数据库模块 -->
    <!--spring jdbc-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <!--spring orm-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <!--spring tx-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <!--c3p0依赖-->
    <dependency>
        <groupId>c3p0</groupId>
        <artifactId>c3p0</artifactId>
        <version>${c3p0.version}</version>
    </dependency>

    <!-- mysql -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.version}</version>
    </dependency>

    <!--spring test-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <!--junit依赖-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>${junit.version}</version>
    </dependency>
</dependencies>

二、配置文件

数据库连接配置

dbconfig.properties

jdbc.user=root
jdbc.password=123456
jdbc.jdbcUrl=jdbc:mysql://localhost:3306/jdbc_test
jdbc.driverClass=com.mysql.cj.jdbc.Driver

spring配置文件

spring-conf.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: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
            http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--扫描包-->
    <context:component-scan base-package="com.example.dao"/>
    <context:component-scan base-package="com.example.service"/>

    <!--引入外部文件-->
    <context:property-placeholder location="classpath:dbconfig.properties"/>

    <!--c3p0 dataSource-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${jdbc.user}" />
        <property name="password" value="${jdbc.password}" />
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}" />
        <property name="driverClass" value="${jdbc.driverClass}" />
    </bean>

    <!--jdbc template-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <constructor-arg name="dataSource" ref="dataSource"/>
    </bean>

    <!--事务控制 配置事务管理器-->
    <bean id="tm" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--控制住数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    
    <!--支持事务注解的（@Transactional）-->
    <tx:annotation-driven transaction-manager="tm"/>

</beans>

三、测试

1.数据库表：

bankuser有字段bid、balance

2.实体类：

Bankuser.java

public class Bankuser {

    private Integer bid;
    private Integer balance;

    public Bankuser() {

    }

    public Bankuser(Integer bid, Integer balance) {
        this.bid = bid;
        this.balance = balance;
    }

    @Override
    public String toString() {
        return "Bankuser{" +
                "bid=" + bid +
                ", balance=" + balance +
                '}';
    }
    //set、get方法
}

3.dao层

BankuserDao.java

@Repository
public class BankuserDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public int updateBalance(Integer bid, Integer money) {
        String sql = "update bankuser set balance=balance+? where bid = ?";
        int update = jdbcTemplate.update(sql, money, bid);
        return update;
    }

    public List<Bankuser> selectAll(){
        String sql = "select bid,balance from bankuser";
        List<Bankuser> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Bankuser.class));
        return list;
    }

}

4.service层

BankuserService.java

transfer()方法上添加事务

对id为1的用户banlance减100，id为2的用户减200；

如果方法上添加事务，1/0语句会发生异常，触发事务回滚；如果方法上没有添加事务，会造成第一个updateBalance()成功修改数据，第二个updateBalance()执行不到，没有修改数据

@Service
public class BankuserService {

    @Autowired
    private BankuserDao bankuserDao;

    @Transactional
    public void transfer(){
        bankuserDao.updateBalance(1,-100);
        int i = 1/0;
        bankuserDao.updateBalance(2,100);

    }

    public List<Bankuser> selectAll(){
        return bankuserDao.selectAll();
    }
}

5.测试类

有事务的业务逻辑，容器中保存的是这个业务逻辑的代理对象

@ContextConfiguration(locations = "classpath:spring-conf.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class MyTest {

    @Autowired
    private BankuserService bankuserService;

    @Test
    public void test01(){
        try {
            bankuserService.transfer();
            System.out.println("操作成功");
        } catch (Exception e) {
            System.out.println(String.format("操作失败:%s", e.getMessage()));
        }
        List<Bankuser> list = bankuserService.selectAll();
        list.forEach(System.out::println);
    }

    @Test
    public void test02(){
        List<Bankuser> list = bankuserService.selectAll();
        list.forEach(System.out::println);
    }

    @Test
    public void test03(){
        System.out.println(bankuserService.getClass());
    }
}

四、事务属性

只有@Transactional 注解应用到 public 方法，才能进行事务管理

1.timeout

默认值为-1

@Transactional(timeout = 3)，超时

事务超出指定执行时长后自动终止并回滚（单位为秒）

2.readOnly

默认值为 readOnly = false

@Transactional(readOnly = true)，设置事务为只读事务

可以进行事务优化，加快查询速度，只能用于查询

3.noRollbackFor、noRollbackForClassName

异常分为：运行时异常、编译时异常

运行时异常，可以处理，默认都回滚；编译时异常，try-catch或throws处理，默认不回滚

@Transactional(noRollbackFor = {ArithmeticException.class, NullPointerException.class})

哪些异常事务可以不回滚（原本运行时异常是回滚的）

4.rollbackFor、rollbackForClassName

@Transactional(rollbackFor = {FileNotFoundException.class})

哪些异常事务需要回滚（原本编译时异常是不回滚的）

5.isolation

默认值采用 DEFAULT

数据库事务并发问题：

1）脏读：A修改数据，B读取修改后的数据，A回滚，B属于脏读

2）不可重复读：A读数据，B修改数据，A再次读两次数据不一致

3）幻读：A读数据，B插入数据，A读数据多了几条数据

隔离级别：

1）读未提交：read uncommited，允许B读取A未提交的数据（会发生脏读）

2）读已提交：read commited，要求B只能读取A以提交的修改（避免脏读，会发生不可重复读，发生幻读）

3）可重复读：repeatable read，确保A可以多次从一个字段中读取到相同的值，即A执行期间禁止其它事务对这个字段进行更新

4）串行化：serializable，确保A可以多次从一个表中读取相同的行，在A执行期间，禁止其它事务对这个表进行添加、更新、删除操作，可以避免任何并发问题

mysql支持1）、2）、3）、4），oracle支持2）、4）

@Transactional(isolation = Isolation.READ_UNCOMMITTED)，设置隔离级别为读未提交

6.propagation

默认值为 Propagation.REQUIRED

事务传播行为：

required（当前方法需要事务，如果有事务，就用别人的事务）、required_new（开启一个新事务）

如果是如果是required事务的属性都是继承大事务的，而propagation=Propagation.REQUIRES_NEW可以调整

@Transactional(propagation = Propagation.REQUIRED) ，当前方法需要事务，如果有事务，就用别人的事务

五、基于XML的事务配置

spring-conf.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:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
       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
            http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--引入外部文件-->
    <context:property-placeholder location="classpath:dbconfig.properties"/>

    <!--c3p0 dataSource-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${jdbc.user}" />
        <property name="password" value="${jdbc.password}" />
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}" />
        <property name="driverClass" value="${jdbc.driverClass}" />
    </bean>

    <!--jdbc template-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <constructor-arg name="dataSource" ref="dataSource"/>
    </bean>


    <bean id="bankuserDao" class="com.example.dao.BankuserDao" >
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>

    <bean id="bankuserService" class="com.example.service.BankuserService">
        <property name="bankuserDao" ref="bankuserDao"/>
    </bean>


    <!--事务控制 配置事务管理器-->
    <bean id="tm" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--控制住数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--支持事务注解的（@Transactional）-->
    <!--<tx:annotation-driven transaction-manager="tm"/>-->

    <!--配置切面 aop-->
    <aop:config>
        <!--切入点表达式表明事务管理器切入哪些方法-->
        <aop:pointcut id="txPont" expression="execution(* com.example.service.*.*(..))"/>
        <!--事务建议-->
        <aop:advisor advice-ref="myAdvice" pointcut-ref="txPont"/>
    </aop:config>

    <!--transaction-manager指定配置哪个事务管理器-->
    <tx:advice id="myAdvice" transaction-manager="tm">
        <!--事务属性-->
        <tx:attributes>
            <!--指明哪些方法是事务方法-->
            <tx:method name="transfer" propagation="REQUIRED" timeout="3"/>
            <tx:method name="get" read-only="true"/>
        </tx:attributes>
    </tx:advice>

</beans>

测试类

public class MyMain {

    public static void main(String[] args) {
//        读取配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-conf.xml");
        BankuserService bankuserService = context.getBean("bankuserService", BankuserService.class);
        try{
            bankuserService.transfer();
        }catch (Exception e){

        }
        List<Bankuser> list = bankuserService.selectAll();
        for(Bankuser bankuser : list){
            System.out.println(bankuser);
        }
    }

}

Luck_ZZ

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
Spring事务两种方式（基于注解和XML配置）

一、添加依赖在maven中添加spring依赖、spring aop依赖、spring数据库依赖、spring事务依赖、c3p0依赖、mysql依赖、spring测试依赖Spring事务在业务逻辑上添加事务，容器中保存的是这个业务逻辑的代理对象，所有需要aop依赖（aop的实现是依靠动态代理，生成代理对象）<properties> <spring.version>5.1.9.RELEASE</spring.version> <junit
复制链接

扫一扫