![](/img/trans.png)
[英]I am using the Interceptor in springboot , but there I am getting the error as
[英]Problem of using hibernate interceptor in springboot
我想在 Spring Boot 中使用 hibernate 攔截器,以便在事務提交后使用afterTransactionCompletion()
方法做一些事情。
我按照如何在 Spring Boot 中使用 Spring 管理的 Hibernate 攔截器進行配置(我只是在application.properties
添加spring.jpa.properties.hibernate.ejb.interceptor=com.lc.demo.inteceptor.MyInteceptor
)
攔截器可以工作,但是當我嘗試在方法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()
現在調用afterTransactionCompletion()
之前,
在擴展AbstractLogicalConnectionImplementor
org.hibernate.resource.jdbc.internal.LogicalConnectionProvidedImpl
中, 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>
如果您使用的是Spring事務,則可以利用TransactionSynchronization
並使用afterCommit()
默認void afterCommit()
事務提交后調用。 成功完成主要交易后,可以立即執行進一步的操作。
用法:
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization(){
void afterCommit(){
//do your thing
}
})
您還可以探索TransactionSynchronizationAdapter
以類似的方式可以實現自己的“ AfterCommitExecutor”,該實現實現Executor
接口並擴展TransactionSynchronizationAdapter並覆蓋afterCommit()
方法。
我使用了hovanessyan的答案,它很有效,現在讓我完整地描述一下我在這里所做的事情:
我正在嘗試將其他人的代碼遷移到springboot,代碼使用帶有persistence.xml的hibernate和攔截器使用threadlocal存儲事務中的所有實體,在提交事務后,選擇一個“最佳”實體給用戶發送電子郵件,否則不執行任何操作並清除threadlocal,代碼為:
public class MyInterceptor extends EmptyInterceptor {
private static final long serialVersionUID = -7992825362361127331L;
//The MyThreadLocal used to store all the entities in a transaction, when the transaction
//committed, the interceptor will choose the "best" entity to email user
private static MyThreadLocal myThreadLocal;
public static void setMyThreadLocal(MyThreadLocal mTL) {
MyInterceptor.myThreadLocal = mTL;
}
@Override
public void afterTransactionCompletion(Transaction tx) {
TransactionStatus status = tx.getStatus();
if (tx.getStatus() == COMMITTED) {
MyThreadLocal.selectTheBestEntityToEmailUser();
} else {
MyThreadLocal.clear();
}
}
@Override
public void beforeTransactionCompletion(Transaction tx) {
TransactionStatus status = tx.getStatus();
MyThreadLocal.beforeTransactionCompletion();
}
@Override
public boolean onSave(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types) {
MyThreadLocal.resourceAdded((Entity) entity);
return false;
}
@Override
public boolean onFlushDirty(Object entity, Serializable id, Object[] currentState, Object[] previousState, String[] propertyNames, Type[] types) {
Diff diff = new Diff(previousState, currentState, propertyNames);
MyThreadLocal.resourceUpdated((Entity) entity, diff);
return false;
}
@Override
public void onDelete(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types) {
MyThreadLocal.resourceRemoved((Entity) entity);
}
@Override
public void onCollectionUpdate(Object collection, Serializable key) throws CallbackException {
if (!(collection instanceof PersistentCollection)) {
LOGGER.e("Unsupported collection type: {}", collection.getClass());
return;
}
Entity owner = (Entity) ((PersistentCollection) collection).getOwner();
String role = ((PersistentCollection) collection).getRole();
MyThreadLocal.collectionResourceUpdated(owner, role);
}
}
但是在afterTransactionCompletion()方法中,事務狀態始終為NOT_ACTIVE,現在我使用TransactionSynchronization接口只是為了替換afterTransactionCompletion()方法:
public class MyInterceptor extends EmptyInterceptor implements TransactionSynchronization {
//the mothod of TransactionSynchronization interface
@Override
public void afterCompletion(int status) {
if (status == STATUS_COMMITTED) {
MyThreadLocal.selectTheBestEntityToEmailUser();
} else {
MyThreadLocal.clear();
}
}
//the old code which works not well
@Override
public void afterTransactionCompletion(Transaction tx) {
TransactionStatus status = tx.getStatus();
if (tx.getStatus() == COMMITTED) {
MyThreadLocal.selectTheBestEntityToEmailUser();
} else {
MyThreadLocal.clear();
}
}
...... other codes
}
而且新的接收器還需要由AOP全局配置:
@Component
@Aspect
public class InterceptorInit{
@Autowired
private MyInteceptor mI;
@Before("@annotation(org.springframework.transaction.annotation.Transactional)")
public void registerTransactionSyncrhonization() {
TransactionSynchronizationManager.registerSynchronization(mI);
}
}
現在看來一切正常,我將繼續測試。
雖然我也建議使用 Spring TransactionSynchronization。 如果不能使用(或不想使用),有兩件事需要注意:
beforeTransactionCompletion - “在提交事務之前(但不在回滾之前)調用。” - 這意味着該方法實際上可用於在提交之前識別事務是否正常,並將其保存在某個臨時(理想情況下為 ThreadLocal)狀態。
afterTransactionCompletion - 如果事務被回滾,事務的狀態不是“NOT_ACTIVE”而是“MARKED_ROLLBACK” - 因此狀態“NOT_ACTIVE”與實際調用的 beforeTransactionCompletion 相結合可用於確定事務是否成功。
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.