时间戳

首页 > 解决方案 > springboot中使用hibernate拦截器的问题

java - springboot中使用hibernate拦截器的问题

问题描述

我想在spring boot中使用hibernate拦截器，以便afterTransactionCompletion()在事务提交后使用该方法做某事。

我按照如何在 Spring Boot 中使用 Spring 管理的 Hibernate 拦截器进行配置（我只是添加spring.jpa.properties.hibernate.ejb.interceptor=com.lc.demo.inteceptor.MyInteceptor）application.properties

拦截器有效，但是当我尝试在方法中获取事务状态时仍然存在问题afterTransactionCompletion()，它总是NOT_ACTIVE（我希望它可以COMMITTED）：

import static org.hibernate.resource.transaction.spi.TransactionStatus.COMMITTED;

import org.hibernate.EmptyInterceptor;
import org.hibernate.Transaction;
import org.hibernate.resource.transaction.spi.TransactionStatus;
import org.springframework.stereotype.Component;


@Component
public class MyInteceptor extends EmptyInterceptor{

    private static final long serialVersionUID = -7992825362361127331L;

    @Override
    public void afterTransactionCompletion(Transaction tx) {
        //The status is always NOT_ACTIVE
        TransactionStatus status = tx.getStatus(); //
        if (tx.getStatus() == COMMITTED) {
            System.out.println("This is what I want to do");
        } else {
            System.out.println("This is what I do not want");
        }
    }

    @Override
    public void beforeTransactionCompletion(Transaction tx) {
        // The status is ACTIVE
        TransactionStatus status = tx.getStatus();
        System.out.println(status);
    }
}

我尝试调试它并发现在afterTransactionCompletion()调用之前，

其中org.hibernate.resource.jdbc.internal.LogicalConnectionProvidedImplextends AbstractLogicalConnectionImplementor，commit()方法调用afterCompletion()调用resetConnection(boolean initiallyAutoCommit)设置事务状态的方法NOT_ACTIVE：

    /*
 * Hibernate, Relational Persistence for Idiomatic Java
 *
 * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
 * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
 */
package org.hibernate.resource.jdbc.internal;

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

import org.hibernate.TransactionException;
import org.hibernate.resource.jdbc.ResourceRegistry;
import org.hibernate.resource.jdbc.spi.LogicalConnectionImplementor;
import org.hibernate.resource.jdbc.spi.PhysicalJdbcTransaction;
import org.hibernate.resource.transaction.spi.TransactionStatus;

import org.jboss.logging.Logger;

/**
 * @author Steve Ebersole
 */
public abstract class AbstractLogicalConnectionImplementor implements LogicalConnectionImplementor, PhysicalJdbcTransaction {
    private static final Logger log = Logger.getLogger( AbstractLogicalConnectionImplementor.class );

    private TransactionStatus status = TransactionStatus.NOT_ACTIVE;
    protected ResourceRegistry resourceRegistry;

    @Override
    public PhysicalJdbcTransaction getPhysicalJdbcTransaction() {
        errorIfClosed();
        return this;
    }

    protected void errorIfClosed() {
        if ( !isOpen() ) {
            throw new IllegalStateException( this.toString() + " is closed" );
        }
    }

    @Override
    public ResourceRegistry getResourceRegistry() {
        return resourceRegistry;
    }

    @Override
    public void afterStatement() {
        log.trace( "LogicalConnection#afterStatement" );
    }

    @Override
    public void afterTransaction() {
        log.trace( "LogicalConnection#afterTransaction" );

        resourceRegistry.releaseResources();
    }

    // PhysicalJdbcTransaction impl ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    protected abstract Connection getConnectionForTransactionManagement();

    @Override
    public void begin() {
        try {
            if ( !doConnectionsFromProviderHaveAutoCommitDisabled() ) {
                log.trace( "Preparing to begin transaction via JDBC Connection.setAutoCommit(false)" );
                getConnectionForTransactionManagement().setAutoCommit( false );
                log.trace( "Transaction begun via JDBC Connection.setAutoCommit(false)" );
            }
            status = TransactionStatus.ACTIVE;
        }
        catch( SQLException e ) {
            throw new TransactionException( "JDBC begin transaction failed: ", e );
        }
    }

    @Override
    public void commit() {
        try {
            log.trace( "Preparing to commit transaction via JDBC Connection.commit()" );
            getConnectionForTransactionManagement().commit();
            status = TransactionStatus.COMMITTED;
            log.trace( "Transaction committed via JDBC Connection.commit()" );
        }
        catch( SQLException e ) {
            status = TransactionStatus.FAILED_COMMIT;
            throw new TransactionException( "Unable to commit against JDBC Connection", e );
        }

        afterCompletion();
    }

    protected void afterCompletion() {
        // by default, nothing to do
    }

    protected void resetConnection(boolean initiallyAutoCommit) {
        try {
            if ( initiallyAutoCommit ) {
                log.trace( "re-enabling auto-commit on JDBC Connection after completion of JDBC-based transaction" );
                getConnectionForTransactionManagement().setAutoCommit( true );
                status = TransactionStatus.NOT_ACTIVE;
            }
        }
        catch ( Exception e ) {
            log.debug(
                    "Could not re-enable auto-commit on JDBC Connection after completion of JDBC-based transaction : " + e
            );
        }
    }

    @Override
    public void rollback() {
        try {
            log.trace( "Preparing to rollback transaction via JDBC Connection.rollback()" );
            getConnectionForTransactionManagement().rollback();
            status = TransactionStatus.ROLLED_BACK;
            log.trace( "Transaction rolled-back via JDBC Connection.rollback()" );
        }
        catch( SQLException e ) {
            status = TransactionStatus.FAILED_ROLLBACK;
            throw new TransactionException( "Unable to rollback against JDBC Connection", e );
        }

        afterCompletion();
    }

    protected static boolean determineInitialAutoCommitMode(Connection providedConnection) {
        try {
            return providedConnection.getAutoCommit();
        }
        catch (SQLException e) {
            log.debug( "Unable to ascertain initial auto-commit state of provided connection; assuming auto-commit" );
            return true;
        }
    }

    @Override
    public TransactionStatus getStatus(){
        return status;
    }

    protected boolean doConnectionsFromProviderHaveAutoCommitDisabled() {
        return false;
    }
}

有人可以帮我解决这个问题吗？非常感谢。这是我的pom.xml：

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.lc</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

标签： javahibernatespring-bootinterceptor

解决方案

如果您使用 Spring 事务，您可以利用TransactionSynchronization和使用afterCommit()

默认无效 afterCommit()

在事务提交后调用。可以在主事务成功提交后立即执行进一步的操作。

用法：

TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization(){
           void afterCommit(){
                //do your thing
           }
})

您还可以探索TransactionSynchronizationAdapter- 以类似的方式，您可以实现自己的“AfterCommitExecutor”，它实现Executor接口并扩展 TransactionSynchronizationAdapter 并覆盖该afterCommit()方法。

推荐阅读