问答首页 悬赏问题 未解决 已解决 标签 专家问答 光荣榜 C币充值 我要提问
问答帮助
事务方法调用spring框架的方法，框架的方法也会加入到当前事务吗？ 5C

sevice层的一个事务方法A（），
在A（）方法里面调用了spring框架中某个类的一个方法B（），
问题是，方法B（）会加入到A（）方法的事务当中吗？

如果是的话，是不是在项目启动时，spring就定义好了框架中每个方法的事务配置？

还有就是这些与spring的事务的传播属性有没有关系？

希望有大神能够从spring的原理去解释。

传播属性 spring 事务

6个回答

按赞数排序

“事务”是对一个封闭的系统的原子化来说的，通常是指数据库。你随便写一个方法B，它没有可逆的操作，那么会破坏事务的完整性。

一个极端的例子，你的B()的代码是调用支付宝向另一个账户付款，你还能指望这个操作成功之后取消操作，再把钱返回来么？显然不行。

我感觉你想做的是嵌套事务，有关这个，参考：https://www.cnblogs.com/jimmy-muyuan/p/5722708.html

zcl_love_wx
zcl_love_wx 业务场景是这样的。B方法是spring框架中维护自增主键的方法，然后我将其重写成从数据库的主键表里查回来新的主键，如果系统缓存里的主键大于等于主键表里的时候，就在B方法中更新主键表。 问题来了，当A方法回滚的时候，B方法也跟着回滚了。照理说，B方法属于框架的方法，不在事务配置范围内，应当以非事务方法执行而自动提交的呀。说明一下，是在调用了B方法后再在A方法中回滚的。
一年多之前 回复

spring管理事务是管理到方法级别的，就是根据传播属性控制的

方法B是否回滚，应该看你的spring配置了，可以配置回滚，也可以配置不回滚。

spring配置很灵活的，方法A，B可以配置到1个事务，同时回滚；也可以配置到2个事务，分别管理回滚，也可以配置一个支持一个不支持事务。

参考下：https://blog.csdn.net/mawming/article/details/52277431

zcl_love_wx
zcl_love_wx 回复a718089112: jdbcHelper类里用的是JdbcTemplate，而JdbcTemplate在配置里配置过，我在评论里发布一下配置文件代码
一年多之前 回复
a718089112
a718089112 应该是有事务控制的，没有是不会回滚的。你可以写一个测试的实验一下
一年多之前 回复
a718089112
a718089112 1，你看一下你们整体的事物配置是否把getNextBlock这个方法加事务了；2，查看一下：this.jdbcHelper = new JdbcHelper(new JdbcTemplate(dataSource)); jdbcHelper有没有进行事务相关处理
一年多之前 回复
zcl_love_wx
zcl_love_wx 回复a718089112:我把代码都上上来。下面的代码从上往下调用：
一年多之前 回复
a718089112
a718089112 贴一下B方法是啥啊 sping应该不提供直接操作数据库的方法，spring主要管理java类对象的框架
一年多之前 回复
a718089112
a718089112 方法B支持事务吗？ 方法B如果是操作数据库方面的 肯定也能配置事务啊 你查一下
一年多之前 回复
zcl_love_wx
zcl_love_wx 关键是：方法B（）是spring框架自己的方法
一年多之前 回复

事务的保障为整体操作的原子性，关于保障多个方法执行之间的原子性 ，你应该保持合理的持久化上下文。如果你用的是JPA或者Hibernate,那么你最好将
所有的查询方法放在前面，最后将更改数据的方法放在后面。然后手动刷新。

事务回滚本质依赖于数据库的事务回滚方法，当方法回滚时，数据库只会回滚此次事务进行的写操作。而数据库主键不会因此减小，因为它内部是一个自增数。
所以，在不影响业务逻辑的情况下，不用考虑主键恢复。这是数据库的基础设施

这个问题的关键在于事务的传播机制，如果没有事务，就新建事务，如果当前连接中已经开启了事务，就加入这个事务中。
PROPAGATION_REQUIRED，了解一下。

下面的方法是CrudService类的，它是加入到了已经开启的事务中的

 public void insert(T entity) {
        Validate.isTrue(entity.getId() == null);
        preInsert(entity);
        dao.insert(entity);
    }

以下是SysCrudService类里的方法，继承了上面的CrudService类
preInsert方法没有配置事务

@Override
    protected void preInsert(T entity) {
        DataFieldMaxValueIncrementer incrementer = sequenceFactory.name(getSequenceName(entity));
        entity.setId(incrementer.nextLongValue());
        entity.setCreateDate(new Date());
        entity.setUpdateDate(entity.getCreateDate());
        entity.setDelFlag(AuditEntity.DEL_FLAG_NORMAL);
        User user = UserContext.getCurrentUser();
        if (user != null) {
            entity.setCreateBy(user.getId());
            entity.setUpdateBy(user.getId());
        } else {
            entity.setCreateBy(0L);
            entity.setUpdateBy(0L);
        }
    }

上面方法中的DataFieldMaxValueIncrementer对象incrementer调用的nextLongValue（）方法里调用了一个自身的一个抽象方法getNextKey()，这个抽象方法又被SequenceGenerator类重写了，代码如下:


public class SequenceGenerator extends AbstractDataFieldMaxValueIncrementer {
    private static String SELECT_SEQ = "select name,nextid,increment,padding,prefix from %s where name=?";
    private static String UPDATE_SEQ = "update %s set nextid=? where name=? and nextid=?";
    private static String INSERT_SEQ = "insert into %s (name,nextid,increment,padding,prefix) value (?, ?, ?, ?, ?)";

    private long maxID;
    private long currentID = 0l;
    private JdbcHelper jdbcHelper;

    private int increment = 5;

    private String selectSql;
    private String updateSql;
    private String insertSql;

    /** The name of the rowId for this sequence */
    private String rowId;
    private String prefix;

    public SequenceGenerator() {
        this.maxID = 0L;
        this.currentID = 0L;
    }

    public SequenceGenerator(DataSource dataSource, String incrementerName, String rowId, int increment) {
        super(dataSource, incrementerName);
        this.maxID = 0L;
        this.currentID = 0L;
        this.increment = increment;
        this.jdbcHelper = new JdbcHelper(new JdbcTemplate(dataSource));
        this.setRowId(rowId);
        this.setIncrementerName(incrementerName);
    }

    @Override
    protected long getNextKey() {
        return nextUniqueID();
    }


    /**
     * Returns the next available unique ID. Essentially this provides for the
     * functionality of an auto-increment database field.
     */
    public synchronized long nextUniqueID() {
        if (!(currentID < maxID)) {
            // Get next block -- make 5 attempts at maximum.
            getNextBlock(5);
        }
        long id = currentID;
        currentID++;
        return id;
    }

    private void getNextBlock(int count) {
        if (count == 0) {
            LogFactory.getLog(SequenceGenerator.class).error("Failed at last attempt to obtain an ID, aborting...");
            return;
        }
        boolean success = false;
        try {

            Sequence sequence = this.jdbcHelper.directQueryForObject(Sequence.class, this.selectSql, this.rowId);
            if (sequence == null) {
                sequence = new Sequence(this.increment);
                sequence.setNextid(1L);
                sequence.setName(this.rowId);
                this.jdbcHelper.directExecuteUpdate(this.insertSql, //
                        sequence.getName(), //
                        sequence.getNextid(), //
                        sequence.getIncrement(), sequence.getPadding(), sequence.getPrefix());
            }
            this.prefix = sequence.getPrefix();
            this.currentID = sequence.getNextid();
            long newID = this.currentID + sequence.getIncrement();
            sequence.setCurrid(currentID);
            sequence.setNextid(newID);
            int occurs = this.jdbcHelper.directExecuteUpdate(this.updateSql,//
                    sequence.getNextid(), //
                    sequence.getName(), //
                    sequence.getCurrid());//

            this.setPaddingLength(sequence.getPadding());

            success = occurs == 1;
            if (success) {
                this.maxID = newID;
            }
        } catch (Exception ex) {
            LogFactory.getLog(SequenceGenerator.class).error(ex.getMessage());
        } finally {
        }
        if (!success) {
            LogFactory.getLog(SequenceGenerator.class).error("WARNING: failed to obtain next ID block due to thread contention. Trying again...");
            // Call this method again, but sleep briefly to try to avoid thread
            // contention.
            try {
                Thread.sleep(75);
            } catch (InterruptedException ie) {
            }
            getNextBlock(count - 1);
        }
    }



}

private void getNextBlock(int count) 方法里，有一个更新SQL语句。
我遇到的问题是，当最上面的insert方法的父级事务遇到了一个回滚的时候，更新SQL语句居然也跟着回滚了。照理说getNextBlock方法都不受事务的控制的，SQL语句就不会回滚的啊。

难道是只要父级调用方法开启了事务，那么里面不管有多少层的嵌套调用都是在一个事务中？所以才会跟着回滚的？

配置文件里的jdbcTemplate和mybatis都用一个数据源，而数据源的事务配置里没有扫描到getNextBlock方法，所以该方法是没有事务的。

 <?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:jdbc="http://www.springframework.org/schema/jdbc" xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:util="http://www.springframework.org/schema/util"
    xmlns:task="http://www.springframework.org/schema/task" xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.0.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"
    default-lazy-init="true">

    <description>Spring Configuration主启动文件</description>

    <!-- 加载配置属性文件 -->
    <context:property-placeholder
        ignore-unresolvable="true" location="classpath:config.properties" />

    <!-- 必须定义 lazy-init="false" 否则 SpringContextHolde的方法将失效 -->
    <bean class="com.pds.j2ee.context.SpringContextHolder" lazy-init="false">
    </bean>

    <!-- 定义默认数据源配置, 使用 Druid 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
        init-method="init" destroy-method="close">
        <!-- 数据源驱动类可不写，Druid默认会自动根据URL识别DriverClass -->
        <property name="driverClassName" value="${jdbc.driver}" />

        <!-- 基本属性 url、user、password -->
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />

        <!-- 配置初始化大小、最小、最大 -->
        <property name="initialSize" value="${jdbc.pool.init}" />
        <property name="minIdle" value="${jdbc.pool.minIdle}" />
        <property name="maxActive" value="${jdbc.pool.maxActive}" />

        <!-- 配置获取连接等待超时的时间 -->
        <property name="maxWait" value="60000" />

        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="60000" />

        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="300000" />

        <property name="validationQuery" value="${jdbc.testSql}" />
        <property name="testWhileIdle" value="true" />
        <property name="testOnBorrow" value="false" />
        <property name="testOnReturn" value="false" />

        <!-- 打开PSCache，并且指定每个连接上PSCache的大小（Oracle使用） <property name="poolPreparedStatements" 
            value="true" /> <property name="maxPoolPreparedStatementPerConnectionSize" 
            value="20" /> -->

        <!-- 配置监控统计拦截的filters -->
        <property name="filters" value="stat" />
    </bean>

    <!-- 定义事务 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>


    <!-- service 事务通知 -->
    <tx:advice id="serviceTxAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="delete*" propagation="REQUIRED" read-only="false"
                rollback-for="java.lang.Exception" />
            <tx:method name="save*" propagation="REQUIRED" read-only="false"
                rollback-for="java.lang.Exception" />
            <tx:method name="add*" propagation="REQUIRED" read-only="false"
                rollback-for="java.lang.Exception" />
            <tx:method name="submit*" propagation="REQUIRED" read-only="false"
                rollback-for="java.lang.Exception" />
            <tx:method name="create*" propagation="REQUIRED" read-only="false"
                rollback-for="java.lang.Exception" />
            <tx:method name="imp*" propagation="REQUIRED" read-only="false"
                rollback-for="java.lang.Exception" />
            <tx:method name="insert*" propagation="REQUIRED" read-only="false"
                rollback-for="java.lang.Exception" />
            <tx:method name="update*" propagation="REQUIRED" read-only="false"
                rollback-for="java.lang.Exception" />
            <tx:method name="set*" propagation="SUPPORTS" read-only="false"
                rollback-for="java.lang.Exception" />
            <tx:method name="remove*" propagation="REQUIRED" read-only="false"
                rollback-for="java.lang.Exception" />
            <tx:method name="assign*" propagation="REQUIRED" read-only="false"
                rollback-for="java.lang.Exception" />
            <tx:method name="complete*" propagation="REQUIRED" read-only="false"
                rollback-for="java.lang.Exception" />
            <tx:method name="sign*" propagation="REQUIRED" read-only="false"
                rollback-for="java.lang.Exception" />
            <tx:method name="destroy*" propagation="REQUIRED" read-only="false"
                rollback-for="java.lang.Exception" />
            <tx:method name="find*" propagation="SUPPORTS" />
            <tx:method name="get*" propagation="SUPPORTS" />
            <tx:method name="select*" propagation="SUPPORTS" />
        </tx:attributes>
    </tx:advice>


    <!-- aop自动事务 -->
    <aop:config>
        <aop:pointcut id="serviceTx" expression="execution(public * com..*.service..*.*(..))" />
        <aop:advisor pointcut-ref="serviceTx" advice-ref="serviceTxAdvice" />
    </aop:config>


    <!-- 依据特定的项目设置base-package，指定自己项目的包 -->
    <context:component-scan base-package="com.argi,com.pds.modules,com.znph.saas.sys">
        <context:exclude-filter type="annotation"
            expression="org.springframework.stereotype.Controller" />
    </context:component-scan>

    <!-- 配置 Annotation 驱动，扫描@Transactional注解的类定义事务 -->
    <tx:annotation-driven proxy-target-class="true" />

    <!-- 配置DatabaseProble：主要配置增长序列 -->
    <bean class="com.pds.j2ee.persistence.DatabaseProble">
        <property name="defaultDatasource" ref="dataSource" />
    </bean>

    <!-- JDBC模板 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource">
            <ref bean="dataSource" />
        </property>
    </bean>

    <bean id="namedParameterJdbcTemplate"
        class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
        <constructor-arg index="0">
            <ref bean="jdbcTemplate" />
        </constructor-arg>
    </bean>

    <!-- * <pre> * CREATE TABLE sys_sequence ( 
        name VARCHAR(50), nextid 
        BIGINT UNSIGNED, increment TINYINT UNSIGNED, 
        padding VARCHAR(10), prefix 
        VARCHAR(10) ) ENGINE=MyISAM * </pre> */ -->
    <bean id="cachedSequenceFactory" class="com.pds.jdbc.pk.SequenceFactory">
        <property name="dataSource" ref="dataSource" />
        <property name="incrementerName" value="sys_sequence" />
        <property name="increment" value="5"></property>
    </bean>
    <bean id="serialSequenceFactory" class="com.pds.jdbc.pk.SequenceFactory">
        <property name="dataSource" ref="dataSource" />
        <property name="incrementerName" value="sys_sequence" />
        <property name="increment" value="1"></property>
    </bean>


    <!-- 缓存配置 -->
    <bean id="cacheManager"
        class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
        <property name="configLocation" value="classpath:${ehcache.configFile}" />
    </bean>

    <!-- 

    drop table `sys_lock`;
CREATE TABLE `sys_lock` (
  `lock_name` varchar(100) DEFAULT NULL,
   KEY `lock_key` (`lock_name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8
     -->
    <bean class="com.pds.jdbc.lock.JdbcSemaphore">
        <property name="dataSource" ref="dataSource" />
        <property name="tableName" value="sys_lock" />
        <property name="columnName" value="lock_name" />
    </bean>

    <bean id="defaultDb" class="com.pds.jdbc.ar.DB">
        <constructor-arg index="0">
            <ref bean="dataSource" />
        </constructor-arg>
        <constructor-arg index="1">
            <ref bean="cachedSequenceFactory" />
        </constructor-arg>
    </bean>

</beans>
Csdn user default icon
插入链接
本地上传 网络图片
上传中...
上传图片
插入图片
抄袭、复制答案，以达到刷声望分或其他目的的行为，在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了！
我要提问

相似问题

1
spring cloud feign 启用hystrix引发的调用问题
0
java反射，自动调用方法，方法的返回值类型是不一定的，怎么得到方法的返回值类型的原来的类型！
2
spring-boot+mybatis @Transactional事务管理不起作用
2
同一事务中，先查询，再做查询更新，第一次查询的数据会被更新，为什么？
0
Spring Cloud Feign模块之间调用。A验证登录权限后，开始调用B,A的Authorization和B是共享的吗？
2
如何调用GPU跑程序（keras框架）
1
java中静态方法为什么无法调用非静态变量或者方法
2
为什么同一个service下的synchronized方法调用另一个@Transaction方法，并发还会产生脏读，错误数据？
3
java中使用报文调用其它子系统方法如何实现事务回滚
3
在事务覆盖的一个类里，如果中途发生异常，那么那些调用过第三方通知的方法会被回滚吗？
2
@configuration类下的@Bean方法何时被调用？
1
Java MVC开发模式中, service层或者controller层调用的普通方法应该写在哪里?
3
Java在抽象类中定义抽象方法后 再定义static 方法去调用抽象方法的意义是什么
4
Java的静态方法里是不能调用非静态方法的，但为什么可以调用构造方法？
2
vb6调用java spring集成cxf发布的webservice报错
0
spring的声明式事务失效
4
为何我无法在一个方法中调用另外一个方法的成员？
3
如何在service层中，进行异步操作？为什么CompletableFuture.runAsync这个方法调用的方法没执行？
3
String类的valueOf(Object obj)方法内部是调用谁的toString方法
0
react 调用函数组件内部方法