手动编程事务

最新推荐文章于 2023-11-07 16:24:23 发布
最新推荐文章于 2023-11-07 16:24:23 发布
阅读量228 收藏
点赞数
分类专栏： 事务编程框架 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mingyjy/article/details/104669132
版权

事务是spring框架中一个核心的模块，事务的ACID特性想必对于学习java的同学来说都不陌生，对于spring，实现事务的底层原理其实很简单，就是通过AOP代理进行实现，而实现spring的AOP更底层的，就是使用反射机制完成的；

举例来说，当你的方法上标注了@Service之后，spring怎么知道你这个类会被纳入到整个bean的容器中进行管理呢？如果在这个类下面的某个方法上面加了@Transactionnal注解，spring怎么知道要为你的这个方法开启一个事务管理器呢？说到底，反射在这里就派上用场了，总体来说，就是通过反射，匹配类上的注解，再去匹配方法上的注解，只要找到了相应的注解，就开启相应的特性，就是这么简单，

关于spring事务，常见的有两种，一种是编程式事务，比如java代码使用Jdbc进行数据库操作而没有引入其他框架时，就需要通过手动编写事务进行处理，另一种就是我们熟知的使用spring框架，帮助我们管理事务，比如像我们在xml配置文件中，通过配置扫描包和事务管理器，就可以对相关的类进行事务管理了，下面来演示一下采用编程式事务来学习一下spring的事务特性，了解了编程式事务，xml的事务就不是难事了。

目录结构如下
在这里插入图片描述
maven配置：

 <properties>

        <spring.version>5.1.2.RELEASE</spring.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</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-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.6.1</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.2</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/cglib/cglib -->
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.2.10</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.40</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/dom4j/dom4j -->
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>

    </dependencies>

spring配置：


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:cache="http://www.springframework.org/schema/cache" xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.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/cache
    http://www.springframework.org/schema/cache/spring-cache.xsd">


    <!-- 自动扫描 -->
    <context:component-scan base-package="com.jiaxing"></context:component-scan>

    <!-- 开启事务注解 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    <aop:config proxy-target-class="true"></aop:config>

    <!--数据库连接池配置 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver" />
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test" />
        <property name="user" value="test" />
        <property name="password" value="123456" />
    </bean>


    <!-- 2. JdbcTemplate工具类实例 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 事务管理器 -->
    <bean id="dataSourceTransactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>

    <!-- 开启注解事务 -->
    <tx:annotation-driven transaction-manager="dataSourceTransactionManager" />


</beans>

编写接口：

package com.jiaxing.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

/**
 * Description: 
 * Author: wgm
 * Date: 2020-03-05
 */
@Repository
public class UserDao {


    @Autowired
    private JdbcTemplate jdbcTemplate;


    public void add(int id, String name) {
        String sql = "insert into a(id,name) values(?,?)";
        jdbcTemplate.update(sql, id, name);
    }


}


package com.jiaxing.service;

import com.jiaxing.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * Description: 
 * Author: wgm
 * Date: 2020-03-05
 */
@Service
public class UserService {


    @Autowired
    private UserDao userDao;


    public void add() {
        userDao.add(1, "张三");
       // int i=1/0;
        System.out.println("添加成功+++++++++++++");
        userDao.add(2, "李四");
        System.out.println("添加成功+++++++++++++");
    }


}

使用AOP管理事务：

package com.jiaxing.config;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.interceptor.DefaultTransactionAttribute;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

/**
 * Description: 
 * Author: wgm
 * Date: 2020-03-05
 */
@Component
@Aspect
public class TransactionManagerUtils {

    @Autowired
    private DataSourceTransactionManager dataSourceTransactionManager;


    @Pointcut("execution(* com.jiaxing..*(..))")
    private void pointcut() {
    }

    //开启事务
    public TransactionStatus begin() {
        TransactionStatus status = dataSourceTransactionManager.getTransaction(new DefaultTransactionAttribute());
        return status;
    }

    //提交事务
    public void commit(TransactionStatus status) {
        dataSourceTransactionManager.commit(status);
    }

    //事务回滚
    public void rollback(TransactionStatus status) {
        dataSourceTransactionManager.rollback(status);
    }


    @Around("pointcut()")
    private void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        TransactionStatus status = begin();
        proceedingJoinPoint.proceed();
        commit(status);
    }

    @AfterThrowing("pointcut()")
    private void error() {
        System.out.println("进入了异常通知++++++++++++++");
        TransactionStatus transactionStatus = TransactionAspectSupport.currentTransactionStatus();
        dataSourceTransactionManager.rollback(transactionStatus);
    }


}

最后编写测试方法

public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicayionContext.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
        System.out.println("连接成功");

    }

需要注意的是,业务逻辑层如果使用了异常通知的话，不需要处理异常，只要向往抛出异常即可，如果处理了异常，遇到错误时，是不会进入异常通知方法，导致无法回滚事务，这时需要在catch里手动的回滚事务。

mingyjy
关注
专栏目录
springboot中手动管理事务（编程式事务）
蔡定努
03-27 1450
【代码】springboot中手动管理事务（编程式事务）
springboot Transaction事务的手动版(编程式事务)和自动版(声明式事务)
架构路上的博客
02-03 1677
1.spring管理的 自动 @Transaction() 声明式事务 @Transaction(rollback=Exception.class) public synchronized void test(){ // 查询订单数量 queryProductCount(); // 判断订单是否>0 if(){ throw Exception(); } // 更新库存 update(); // 插入一条订单数据 insert(); } CountDownLatch countDo
手动实现事务
weixin_33881041的博客
07-09 473
2019独角兽企业重金招聘Python工程师标准>>> ...
手动实现 spring 事务
yangsen159的博客
07-04 734
手动实现 spring 事务 手动实现 spring 事务替换 @Transactional ## 自定义注解 @Target({ ElementType.METHOD }) @Retention(RetentionPolicy.RUNTIME) public @interface ExtTransaction { } TransactionUtils // 编程事务（需要手动begin 手动回滚 手都提交） @Component @Scope("prototype") // 每个事务都是新的实例 目的
在spring中手动编写事务
weixin_30239339的博客
10-16 497
利用事务模板TransactionTemplate来手动添加事务 public void addRant(Rant rant) { transactionTemplate.execute(-?transactionTemplate是注入transactionManager得到的 new TransactionCallback() {-? TransactionCa...
手动实现自己的spring事务注解
weixin_30426065的博客
09-01 88
　　spring事务是基于同一个数据连接来实现的，认识到这一点是spring事务的关键，spring事务的关键点便在于在事务中不管执行几次db操作，始终使用的是同一个数据库连接。通过查看源码，我们可以看到spring事务实现思路如下 　　这其中的关键点就在于如何保证在事务内获取的数据库连接为同一个以及通过aop来代理数据库连接的提交、回滚。代码如下 　　构建自己的事务管理器...
手动实现IOC与事务控制-基于JDBC-1
小城我家
06-24 226
手动实现IOC与事务控制基于JDBC sql DROP TABLE IF EXISTS `account`; CREATE TABLE `account` ( `name` varchar(50) NOT NULL COMMENT ' 姓名', `cardNo` varchar(50) NOT NULL COMMENT '卡号', `money` int(11) NOT NULL COMMENT '金额' ) ENGINE=InnoDB DEFAULT CHARSET=utf8; -- --
详解Spring学习之编程式事务管理
08-29
然而，编程式事务管理的缺点是需要手动编写事务管理的代码，这可能会增加开发的难度和时间。 编程式事务管理提供了一种灵活的方式来管理事务，可以根据需要自定义事务管理的逻辑。但是，需要手动编写事务管理的代码...
spring 自定义事务管理器，编程式事务，声明式事务@Transactional使用
07-13
**编程式事务管理** 是通过调用`PlatformTransactionManager`接口提供的方法来手动控制事务的开始、提交、回滚。例如，你可以使用`TransactionTemplate`或直接调用`TransactionDefinition`和`TransactionStatus`来...
spring声明事务，编程事务实现
11-07
Spring 声明事务、编程事务实现 Spring 声明事务是指使用 Spring 框架来管理事务，实现事务控制。声明式事务管理是建立在 AOP 之上的，它的本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务...
spring事务（一）之编程式事务
xichengxml的博客
02-14 1320
编程式事务管理： 通过Transaction Template手动管理事务，实际应用中很少使用 项目目录结构（采用springboot+maven构建项目）： 为测试方便，省略了service层和dao层接口 导包 &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;mysql&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;m
springboot项目中手动提交事务
老照片
11-07 5158
springboot项目中手动提交事务
深入理解spring事务原理，手动实现事务提交和回滚
JavaUpgrade
03-03 9497
@[TOC] 目录 NO1.框架自动提交事务与异常回滚 NO2.控制框架的提交和事务回滚 NO3.AOP+注解实现事务的提交和回滚 NO4.spring事务源码解读
spring手动控制事务
lockie的博客
10-15 4545
实际项目中要实现spring的事务大多数我们都是使用 @Transactional(rollbackFor = Exception.class) 注解即可，但是有些业务场景需要我们手动处理事务我们就可以这样： //开启事务 DefaultTransactionDefinition defaultTransactionDefinition = new DefaultTransactionDefinition(); // 嵌套事务 defaultTransactionDefinition.setPropag
Spring的事务管理:手动编码的方式
琦彦
10-30 6519
需要事务管理器：真正管理事务对象. * Spring提供了事务管理的模板(工具类.)   第一步:注册事务管理器:    配置事务管理器  &lt;!-- 配置事务管理器 --&gt; &lt;bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionM...
手动事务的几个类
qq_40813329的博客
06-23 719
TransactionManager PlatformTransactionManager TransactionStatusTransactionDefinition，TransactionTemplate 创建一个控制事务的工具类，并交给spring管理 在需要使用到事务的类中注入该工具类,并使用 注解事务 @Transactional springboot 的话可以直接在方法上使用注释自动开启事务，，但是，需要，具体操作如下 参考 Spring 事务 手动事务及多线程事务......
手动事务及多线程事务
阳宗德的博客
05-18 3912
文章目录1. 什么是事务？2.事务的特性（ACID）3.Spring 支持两种方式的事务管理1).编程式事务管理2)声明式事务管理多线程事务解决1）定义线程外集合，将线程处理结果放入集合，由外部线程处理2）定义线程外手动事务集合，将线程事务放入集合，由外部线程处理事务 1. 什么是事务？ 事务是逻辑上的一组操作，要么都执行，要么都不执行。 另外，需要格外注意的是：事务能否生效数据库引擎是否支持事务是关键。比如常用的 MySQL 数据库默认使用支持事务的innodb引擎。但是，如果把数据库引擎变为 myisa
手动提交事务和在for循环里进行事务控制及声明式事务的使用实例！
热门推荐
whxwkb的博客
04-04 1万+
事务场景：需要做一个跑批进行一个流程的实现，0.获取异常数据（多条），for循环对单条数据进行下面三个操作：1）.调用别的系统进行查询，2）.查询自己的库中数据，3）更改自己数据库中的数据状态。此时就需要对单条数据操作的3步骤进行事务控制，使用的过程中发现两个解决办法：第一：在controller层进数据的获取，for循环处理单条数据时调用service层进行事务的控制.第二：在service层进...
spring手动回滚事务
最新发布
10-10
2. **编程式事务**：如果你更倾向于在代码层面控制事务，可以创建`JdbcTemplate`, `HibernateTemplate`等具体的模板，并显式开启和管理事务。 ```java TransactionDefinition def = new ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值