如何在Hibernate/JPA+Envers中实现类似SQLAlchemy inspect()的实体变更追踪

针对你的需求，结合Hibernate和Envers，这里提供几种简洁、通用的解决方案，无需大量重复代码：

核心问题解答 #

1. 单次方法调用获取变更：可以通过封装的泛型工具类，传入实体或实体ID即可单次调用获取变更映射
2. 内置方式提取新旧值：Hibernate本身没有直接返回新旧值的公开API，但可通过其内部状态追踪机制提取；Envers可通过版本对比获取变更
3. 跨实体通用方案：基于Hibernate元数据或反射实现泛型工具类，支持所有@Entity实体

方案一：保存前实时获取变更（基于Hibernate内部API） #

利用Hibernate的Session和实体状态追踪能力，在保存操作执行前直接提取变更的新旧值，适合业务逻辑中需要即时处理变更的场景。

通用变更检测工具类 #

import org.hibernate.Session
import org.hibernate.engine.spi.SessionImplementor
import org.hibernate.metamodel.model.domain.spi.PersistentEntityDescriptor
import javax.persistence.EntityManager

class EntityChangeDetector(private val entityManager: EntityManager) {

    fun <T : Any> getEntityChanges(entity: T): Map<String, Map<String, Any>> {
        val session = entityManager.unwrap(Session::class.java) as SessionImplementor
        val entityEntry = session.persistenceContext.getEntry(entity) ?: return emptyMap()
        
        val persistentEntity = entityEntry.persistentEntity as PersistentEntityDescriptor<T, *>
        val dirtyProperties = entityEntry.dirtyProperties ?: return emptyMap()
        
        val changes = mutableMapOf<String, Map<String, Any>>()
        
        dirtyProperties.forEach { propertyIndex ->
            val propertyName = persistentEntity.getPropertyNames()[propertyIndex]
            val oldValue = entityEntry.originalState[propertyIndex]
            val newValue = entityEntry.currentState[propertyIndex]
            
            if (oldValue != newValue) {
                changes[propertyName] = mapOf(
                    "oldValue" to (oldValue ?: "null"),
                    "newValue" to (newValue ?: "null")
                )
            }
        }
        
        return changes
    }
}

Service中使用示例 #

@Service
class PaymentLinkService(
    private val paymentLinkRepository: PaymentLinkRepository,
    private val entityChangeDetector: EntityChangeDetector
) {
    @Transactional
    fun updatePaymentLink(paymentLinkId: Long) {
        val paymentLink = paymentLinkRepository.findById(paymentLinkId).orElseThrow()
        
        // 更新字段
        paymentLink.amount = 200
        paymentLink.status = "updated"
        
        // 单次调用获取变更
        val changes = entityChangeDetector.getEntityChanges(paymentLink)
        println(changes) // 输出：{amount={oldValue=100, newValue=200}, status={oldValue=active, newValue=updated}}
        
        paymentLinkRepository.save(paymentLink)
    }
}

方案二：保存后通过Envers获取变更（基于审计数据） #

利用Envers的版本审计能力，在事务提交后对比当前版本与上一版本的实体属性，适合事后审计、日志记录场景，不依赖Hibernate内部API，稳定性更高。

Envers变更检测工具类 #

import org.hibernate.envers.AuditReaderFactory
import javax.persistence.EntityManager

class EnversChangeDetector(private val entityManager: EntityManager) {

    fun <T : Any> getEntityChangesAfterSave(entityClass: Class<T>, entityId: Long): Map<String, Map<String, Any>> {
        val auditReader = AuditReaderFactory.get(entityManager)
        val currentRevision = auditReader.getRevisionNumberForEntity(entityId, entityClass) ?: return emptyMap()
        val previousRevision = currentRevision - 1
        
        if (previousRevision < 1) return emptyMap()
        
        val currentEntity = auditReader.find(entityClass, entityId, currentRevision)
        val previousEntity = auditReader.find(entityClass, entityId, previousRevision)
        
        if (currentEntity == null || previousEntity == null) return emptyMap()
        
        val changes = mutableMapOf<String, Map<String, Any>>()
        
        // 反射遍历所有非ID属性对比
        entityClass.declaredFields
            .filter { !it.name.equals("id", ignoreCase = true) }
            .forEach { field ->
                field.isAccessible = true
                val oldValue = field.get(previousEntity)
                val newValue = field.get(currentEntity)
                if (oldValue != newValue) {
                    changes[field.name] = mapOf(
                        "oldValue" to (oldValue ?: "null"),
                        "newValue" to (newValue ?: "null")
                    )
                }
            }
        
        return changes
    }
}

Service中使用示例 #

@Service
class PaymentLinkService(
    private val paymentLinkRepository: PaymentLinkRepository,
    private val enversChangeDetector: EnversChangeDetector
) {
    @Transactional
    fun updatePaymentLink(paymentLinkId: Long) {
        val paymentLink = paymentLinkRepository.findById(paymentLinkId).orElseThrow()
        
        paymentLink.amount = 200
        paymentLink.status = "updated"
        
        paymentLinkRepository.save(paymentLink)
        
        // 保存后获取变更
        val changes = enversChangeDetector.getEntityChangesAfterSave(PaymentLink::class.java, paymentLinkId)
        println(changes)
    }
}

方案三：自动捕获变更（基于Hibernate事件监听器） #

如果需要在所有实体保存/更新时自动捕获变更（比如统一记录日志），可以通过Hibernate的事件监听器实现，无需在每个Service中手动调用。

自定义事件监听器 #

import org.hibernate.event.spi.PreUpdateEvent
import org.hibernate.event.spi.PreUpdateEventListener
import org.springframework.stereotype.Component

@Component
class EntityChangeEventListener(private val entityChangeDetector: EntityChangeDetector) : PreUpdateEventListener {
    override fun onPreUpdate(event: PreUpdateEvent): Boolean {
        val changes = entityChangeDetector.getEntityChanges(event.entity)
        // 这里可以执行日志记录、消息通知等操作
        println("实体 ${event.entity.javaClass.simpleName} (ID: ${event.id}) 变更：$changes")
        return false // 返回false不阻止更新操作
    }
}

配置监听器 #

在application.properties中添加：

spring.jpa.properties.hibernate.event.pre_update=com.yourpackage.EntityChangeEventListener

内容的提问来源于stack exchange，提问作者Kunj Bosamia