Spring + 事务管理

最新推荐文章于 2024-07-24 11:50:14 发布
最新推荐文章于 2024-07-24 11:50:14 发布
阅读量178 收藏
点赞数
分类专栏： JAVA # j 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZHHX666/article/details/124518418
版权

文章目录

1. 先用原始的JDBC实现转账操作

在这里插入图片描述

2. 给Service层加上事务管理

service层需要控制事务，开启、提交、回滚、

因为要保证使用同一个连接，所以要在service层创建连接传给dao层

package service.impl;

import dao.AccountDao;
import service.AccountService;
import util.JDBCUtil;

import java.sql.Connection;
import java.sql.SQLException;

public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao = new AccountDao();

    public void transfer(String from, String to, double money) throws SQLException {

        //连接从dao层提到service层
        Connection connection = JDBCUtil.getConnection();

        try {
            //关闭自动提交,开启事务.
            connection.setAutoCommit(false);

            //业务处理
            accountDao.sub(connection,from, money);
            accountDao.add(connection,to, money);

            //都执行成功，则提交事务
            connection.commit();
        } catch (RuntimeException e) {
            //失败,回滚
            connection.rollback();
            throw new SQLException("转账失败");
        } finally {
            //释放资源
            connection.close();
        }
    }
}

3. 将Connetion通过线程上下文传给Dao层

package service.impl;

import dao.AccountDao;
import service.AccountService;
import util.JDBCUtil;

import java.sql.Connection;
import java.sql.SQLException;

public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao = new AccountDao();

    //使用ThreadLocal来将连接放入当前线程中。
    //由于ThreadLocal实现的约束,谁放的只能谁来拿,因此设为常量让dao能直接访问它。
    public static final ThreadLocal<Connection> CONNECTION_THREAD_LOCAL = new ThreadLocal<>();

    public void transfer(String from, String to, double money) throws SQLException {

        //连接从dao层提到service层
        Connection connection = JDBCUtil.getConnection();

        try {
            //关闭自动提交,开启事务.
            connection.setAutoCommit(false);
            
            //将连接放入当前线程中
            CONNECTION_THREAD_LOCAL.set(connection);

            //业务处理
            accountDao.sub(from, money);
            accountDao.add(to, money);

            //都执行成功，则提交事务
            connection.commit();
        } catch (RuntimeException e) {
            //失败,回滚
            connection.rollback();
            throw new SQLException("转账失败");
        } finally {
            //释放资源
            connection.close();
        }
    }
}


package dao;

import service.impl.AccountServiceImpl;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class AccountDao {

    //增加
    public void add(String name, double money) throws SQLException {
        //从当前线程中取出
        Connection connection = AccountServiceImpl.CONNECTION_THREAD_LOCAL.get();
        //预编译sql
        PreparedStatement preparedStatement = connection.prepareStatement("update account set money = money + ? where name = ?");
        //给参数赋值
        preparedStatement.setObject(1, money);
        preparedStatement.setObject(2, name);
        //执行sql
        preparedStatement.execute();
        //关闭资源
        preparedStatement.close();
    }

    //减少
    public void sub(String name, double money) throws SQLException {
        //从当前线程中取出
        Connection connection = AccountServiceImpl.CONNECTION_THREAD_LOCAL.get();
        //预编译sql
        PreparedStatement preparedStatement = connection.prepareStatement("update account set money = money - ? where name = ?");
        //给参数赋值
        preparedStatement.setObject(1, money);
        preparedStatement.setObject(2, name);
        //执行sql
        preparedStatement.execute();
        //关闭资源
        preparedStatement.close();
    }
}

将事务管理从service层提取出来，封装成工具类

package util;

import com.sun.org.apache.bcel.internal.generic.ACONST_NULL;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.ConcurrentModificationException;

/**
 * @Date: 2022/4/30 22:09
 * @author: ZHX
 * @Description:
 */
public class TransactionManager {

    //使用ThreadLocal来将连接放入当前线程中。
    //由于ThreadLocal实现的约束,谁放的只能谁来拿,因此设为常量让dao能直接访问它。
    public static final ThreadLocal<Connection> CONNECTION_THREAD_LOCAL = new ThreadLocal<>();

    public static void start() throws SQLException {
        Connection connection = JDBCUtil.getConnection();
        connection.setAutoCommit(false);
        CONNECTION_THREAD_LOCAL.set(connection);
    }

    public static void commit() throws SQLException {
        CONNECTION_THREAD_LOCAL.get().commit();
    }

    public static void rollback() throws SQLException {
        CONNECTION_THREAD_LOCAL.get().rollback();
    }

    public static void close() throws SQLException {
        CONNECTION_THREAD_LOCAL.get().close();
        CONNECTION_THREAD_LOCAL.remove();
    }

}


package service.impl;

import dao.AccountDao;
import service.AccountService;
import util.TransactionManager;

import java.sql.SQLException;

public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao = new AccountDao();

    public void transfer(String from, String to, double money) throws SQLException {

        try {
            //开启事务
            TransactionManager.start();

            //业务处理
            accountDao.sub(from, money);
            accountDao.add(to, money);

            //提交事务
            TransactionManager.commit();
        } catch (RuntimeException e) {
            //回滚
            TransactionManager.rollback();
            e.printStackTrace();
        } finally {
            //释放资源
            TransactionManager.close();
        }
    }
}

4. 用动态代理实现普遍的事务管理

package controller;

import service.AccountService;
import service.impl.AccountServiceImpl;
import util.ServiceTransactionProxy;

import java.lang.reflect.Proxy;
import java.sql.SQLException;

public class AccountController {

    private AccountService accountService = (AccountService) Proxy.newProxyInstance(AccountController.class.getClassLoader(), new Class[]{AccountService.class}, new TransactionProxy(new AccountServiceImpl()));

    public void transfer() throws SQLException {

        //模拟前端传来的数据
        String from = "张三";
        String to = "赵丽颖";
        double money = 500.0;

        //调Service层进行业务处理。
        accountService.transfer(from, to, money);
    }
}


package util;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * @Date: 2022/4/30 22:26
 * @author: ZHX
 * @Description:
 */
public class TransactionProxy implements InvocationHandler {
    private Object origin;

    public ServiceTransactionProxy(Object origin) {
        this.origin = origin;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        try {
            //开启事务
            TransactionManager.start();

            //业务处理
            result = method.invoke(origin, args);

            //提交事务
            TransactionManager.commit();
        } catch (RuntimeException e) {
            //回滚
            TransactionManager.rollback();
            e.printStackTrace();
        } finally {
            //释放资源
            TransactionManager.close();
        }
        return result;
    }
}


package service.impl;

import dao.AccountDao;
import service.AccountService;

import java.sql.SQLException;

public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao = new AccountDao();

    public void transfer(String from, String to, double money) throws SQLException {
        //业务处理
        accountDao.sub(from, money);
        accountDao.add(to, money);
    }
}

5. 使用Spring的AOP实现事务管理

设置方法拦截器，环绕式

package aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class Transaction {

    @Autowired
    private TransactionManager transactionManager;

    @Around("execution(* service..*.*(..))")
    public Object around(ProceedingJoinPoint pjp) {
        Object result = null;
        try {
            transactionManager.start();
            result = pjp.proceed();
            transactionManager.commit();
        } catch (Throwable e) {
            transactionManager.rollback();
            e.printStackTrace();
        } finally {
            transactionManager.close();
        }
        return result;
    }

}

事务工具类

package aspect;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

@Component
public class TransactionManager {

    @Autowired
    private DataSource dataSource;

    public static final ThreadLocal<Connection> CONNECTION_THREAD_LOCAL = new ThreadLocal<>();

    public void start() throws SQLException {

        Connection connection = dataSource.getConnection();

        connection.setAutoCommit(false);

        CONNECTION_THREAD_LOCAL.set(connection);
    }

    public void commit() throws SQLException {
        CONNECTION_THREAD_LOCAL.get().commit();
    }

    public void rollback() {
        try {
            CONNECTION_THREAD_LOCAL.get().rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void close() {
        try {
            CONNECTION_THREAD_LOCAL.get().close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        CONNECTION_THREAD_LOCAL.remove();
    }
}

注解配置Spring

package config;

import com.alibaba.druid.pool.DruidDataSource;
import com.sun.media.jfxmediaimpl.platform.PlatformManager;
import org.springframework.context.annotation.*;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

@Configuration
@ComponentScan({"controller", "service", "dao","aspect"})
@EnableAspectJAutoProxy  //开启AspectJ代理检测
public class SpringConfig {

    @Bean("dataSource")
    public DataSource dataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        druidDataSource.setUrl("jdbc:mysql://localhost:3306/xin?useSSL=false&characterEncoding=utf8&serverTimezone=UTC");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("123456");
        return druidDataSource;
    }
}

6. Spring提供的事务管理，不用自己封装了。

导入依赖坐标

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

Spring提供的事务管理

package config;

import com.alibaba.druid.pool.DruidDataSource;
import com.sun.media.jfxmediaimpl.platform.PlatformManager;
import org.springframework.context.annotation.*;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

@Configuration
@ComponentScan({"controller", "service", "dao"})
@EnableAspectJAutoProxy
@EnableTransactionManagement //开启事务管理
public class SpringConfig {

    //使用Spring提供的事务管理器.
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }

    @Bean("dataSource")
    public DataSource dataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        druidDataSource.setUrl("jdbc:mysql://localhost:3306/xin?useSSL=false&characterEncoding=utf8&serverTimezone=UTC");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("123456");
        return druidDataSource;
    }
}

Service

package service.impl;

import dao.AccountDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import service.AccountService;

@Service
@Transactional//给该类所有方法都加事务管理
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    @Override
    @Transactional//给该方法加事务管理
    public void transfer(String from, String to, double money) {
        //业务处理
        accountDao.add(from, money);
        accountDao.sub(to, money);
    }
}

7. 将Mybatis整合进来

引入依赖坐标

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.9</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.7</version>
        </dependency>

Mybatis整合

package config;

import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import javax.sql.DataSource;
import java.io.IOException;

public class MybatisConfig {

    //Mybatis提供的整合到Spring的工具
    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) {

        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();

        //数据库连接池
        sqlSessionFactoryBean.setDataSource(dataSource);

        //设置别名
        //sqlSessionFactoryBean.setTypeAliasesPackage("pojo");

        //根据通配符  找到所有的mapper.xml文件
        PathMatchingResourcePatternResolver patternResolver = new PathMatchingResourcePatternResolver();
        try {
            Resource[] resources = patternResolver.getResources("mappers/*.xml");
            sqlSessionFactoryBean.setMapperLocations(resources);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return sqlSessionFactoryBean;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer() {
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setBasePackage("dao");
        return mapperScannerConfigurer;
    }
}

mapper.xml文件

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

<mapper namespace="dao.AccountDao">

    <update id="add">
        update account
        set money= money + #{money}
        where name = #{name}
    </update>

    <update id="sub">
        update account
        set money= money - #{money}
        where name = #{name}
    </update>
</mapper>

Spring注解配置文件导入Mybatis配置文件

@Import(MybatisConfig.class)//整合Mybatis

8. 参考资料

黑马视频

从零开始的JAVA世界
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring整合mybatis事务管理
qq_61648985的博客
03-26 2485
1.mybatis独立管理事务 通过xml配置文件来配置事务 2.mybatis框架初始化： （1）对加载读取xml配置文件的过程， （2）mybatis初始化就是创建configuration对象过程， （3）使用Configuration对象创建SqlSessionFactory （4）使用MyBatis 只有执行sqlsession.commit()方法才会执行事务，否则在未提交之前都会进行事务回滚： 如果不执行sqlSession.commit()操作，直接执行sqlSession.
Spring JDBC事务管理
weixin_55558933的博客
04-20 1321
1.Spring JDBC的配置与JDBCTemplate对象 2.声明事务的配置方式 3.声明式事务的七种传播行为 1、Spring JDBC Spring JDBC是Spring框架用于处理关系型数据库的模块 Spring JDBC对JDBC aPI 进行封装，极大简化开发工作量 JDBCTemplate是Spring JDBC的核心类，提供数据的CRUD方法 为什么有了Mybatis还需要Spring JDBC? 答：Mybatis对JDBC的封装程度较高，Spring JD.
Spring-事务管理
汤键的博客
09-25 2489
Spring-事务管理
Spring事务管理详解
java123456111的博客
05-24 9735
什么是事务 事务是逻辑上的一组操作，要么都执行，要么都不执行。 需要注意的是：事务能否生效数据库引擎是否支持事务是关键。比如常用的 MySQL 数据库默认使用支持事务的 innodb引擎。但是，如果把数据库引擎变为 myisam，那么程序也就不再支持事务了！ 事务的特性（ACID） 原子性：一个事务（transaction）中的所有操作，或者全部完成，或者全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。即，事务
手把手教你整合最优雅SSM框架：SpringMVC + Spring + MyBatis
热门推荐
小疯的代码健身房
05-08 61万+
小疯手把手带你整合SpringMVC+Spring+MyBatis三大框架，俗称SSM，用它完全代替传统的SSH框架，把它们最优雅的一面发挥出来。整合配置结束后，会有一个应用实例“图书管理系统”带给大家，希望能快速上手这个框架！
Spring 的事务管理
ChineseSoftware的博客
01-18 2042
Spring 事务的隔离级别和传播行为 try catch 对 Spring 事务的影响 一、Spring 事务管理的两种方式 1️⃣编程式事务侵入到了业务代码里面，但是提供了更加详细的事务管理。编程式事务使用 TransactionTemplate 或者直接使用底层的 PlatformTransactionManager。对于编程式事务管理，Spring 推荐使用 TransactionTemplate。 2️⃣声明式事务基于 AOP，既能管理事务，又不影响业务代码。本质是对方法前后进行拦截，然后在目标方
Spring中的事务管理
qq_40834643的博客
09-28 2028
Spring中的事务管理，①基于xml配置文件和注解的混合方式，②基于完全xml配置文件的方式，③基于完全注解的方式。
【Spring】— Spring的事务管理
衍生星球的博客
05-06 2626
Spring的事务管理简化了传统的事务管理流程，并且在一定程度上减少了开发者的工作量。
Spring Data JPA事务管理
春风化雨
05-27 2万+
1、事务基础概念_四大特性 　数据库中事务的四大特性（ACID），如果一个数据库声称支持事务的操作，那么该数据库必须要具备以下四个特性： 　⑴ 原子性（Atomicity） 　　原子性，是指事务包含的所有操作，要么全部成功，要么全部失败回滚。因此，事务的操作如果成功就必须要完全持久化到数据库，如果操作失败则不能对数据库有任何影响。 　⑵ 一致性（Consistency） 　　一致性，是指...
Spring 事务管理简介
qq_65249767的博客
05-04 2803
Spring 事务管理简介
编程语言+JAVAspring+事务管理+数据一致性
03-01
编程语言+JAVAspring+事务管理+数据一致性**：这是一个关于JAVAspring编程语言的事务管理的数据一致性的资源，适合有一定JAVAspring基础的开发者。它介绍了JAVAspring的事务管理的概念、原理和作用，以及如何使用...
Maven + spring + mybatis + mysql + 事务管理
08-31
在企业级Java开发中，"Maven + Spring + MyBatis + MySQL + 事务管理"是一个常见的技术栈组合，它们各自扮演着不同的角色，构建出高效、稳定的后端系统。 **Maven** 是一个项目管理和综合工具，它帮助开发者管理...
Spring+Hibernate事务管理
10-14
Spring将事务管理分成了两类: * 编程式事务管理 * 手动编写代码进行事务管理.(很少使用) * 声明式事务管理: * 基于TransactionProxyFactoryBean的方式.(很少使用) * 需要为每个进行事务管理的类,配置一个...
Spring中的事务管理如何配置
08-25
Spring中的事务管理如何配置 事务管理是Spring框架中一个非常重要的概念，它能够确保数据库操作的原子性和一致性。事务管理可以让开发者更加方便地管理数据库操作，减少编码的复杂性，并且提高系统的可靠性。 在...
spring事务管理
10-27
### Spring事务管理详解 #### 一、Spring事务管理概述 Spring框架提供了强大的事务管理功能，使得开发者能够更方便地管理应用程序中的事务。Spring事务管理主要包括两种类型：编程式事务管理和声明式事务管理。 -...
【SpringBoot】Web开发之URL映射
Jacker
07-24 309
46如果URL中的参数名称与方法中的参数名称一致，则可以简化为：}49}52}58。
Spring 高级解析 07
程序员进阶之路
07-24 1091
Spring 是分层的 full-stack（全栈） 轻量级开源框架，以 IoC 和 AOP 为内核，提供了展现层 Spring MVC 和业务层事务管理等众多的企业级应⽤技术，还能整合开源世界众多著名的第三⽅框架和类库，已 经成为使⽤最多的 Java EE 企业应⽤开源框架。
SpringBoot3 使用虚拟线程
最新发布
yaobo2816的专栏
07-24 687
用最简单的方式使用虚拟线程
springboot整合 knife4j 接口文档
m0_60873265的博客
07-24 403
第三步：启动项目——访问地址 http://ip:端口号/doc.html#/
Spring事务管理详解与实例
"这篇博客详细介绍了Spring事务管理的相关知识，包括初步理解、事务的ACID特性、传播行为和事务配置等内容，并提供了实例分析。作者在撰写前参考了《spring in action》和其他网络资源，旨在全面解析Spring事务管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值