Spring Boot中使用AOP保存实体历史数据至审计表的问题

问题核心原因 #

你遇到的问题本质是EntityManager一级缓存干扰+切面执行时机特性导致新旧实体数据一致：

1. 当修改已处于托管状态的实体（比如从数据库查询出的Appointment）后，实体的变更会被EntityManager跟踪，此时调用entityManager.find()会直接返回内存中已修改的实例，而非从数据库加载原始数据。
2. 即便使用@Before切面，业务代码逻辑是先修改实体再调用save()，切面触发时拿到的entity已经是修改后的状态，从缓存中获取的"旧实体"自然也是修改后的版本。

解决方案 #

方案一：优化AOP切面，绕过一级缓存获取原始数据 #

修改findExistingEntity方法，先将当前实体从持久化上下文分离，避免缓存干扰，再从数据库加载原始数据，最后重新合并实体保证后续save操作正常执行：

private Optional<Object> findExistingEntity(Object entity) {
    try {
        Object entityId = getEntityId(entity);
        // 先将当前实体从持久化上下文分离，绕过一级缓存
        if (entityManager.contains(entity)) {
            entityManager.detach(entity);
        }
        // 从数据库加载原始状态的实体
        Object existingEntity = entityManager.find(entity.getClass(), entityId);
        // 将修改后的实体重新合并到持久化上下文，不影响后续save操作
        if (existingEntity != null) {
            entityManager.merge(entity);
        }
        return Optional.ofNullable(existingEntity);
    } catch (Exception e) {
        log.error("Failed to find existing entity", e);
        return Optional.empty();
    }
}

方案二：改用JPA生命周期回调（更可靠） #

放弃AOP，直接使用JPA的生命周期注解，精准捕获实体状态变更时机，彻底避免缓存问题：

1. 创建审计监听器

@Slf4j
@Component
public class AuditListener {

    private final AuditDetailsRepository auditRepository;
    private final ObjectMapper objectMapper;
    private final EntityManager entityManager;

    @Autowired
    public AuditListener(AuditDetailsRepository auditRepository, EntityManager entityManager) {
        this.auditRepository = auditRepository;
        this.entityManager = entityManager;
        this.objectMapper = new ObjectMapper();
        this.objectMapper.registerModule(new JavaTimeModule());
    }

    @PreUpdate
    public void preUpdate(Object entity) {
        if (shouldLogAudit(entity)) {
            Object entityId = getEntityId(entity);
            // 从数据库加载原始实体（此时实体尚未被flush，数据库中还是旧数据）
            Object oldEntity = entityManager.find(entity.getClass(), entityId);
            saveAudit("UPDATE", oldEntity, entity);
        }
    }

    @PreRemove
    public void preRemove(Object entity) {
        if (shouldLogAudit(entity)) {
            saveAudit("DELETE", entity, null);
        }
    }

    @PrePersist
    public void prePersist(Object entity) {
        if (shouldLogAudit(entity)) {
            saveAudit("CREATE", null, entity);
        }
    }

    private String getEntityId(Object entity) {
        try {
            return entity.getClass().getMethod("getId").invoke(entity).toString();
        } catch (Exception e) {
            throw new RuntimeException("Failed to get entity ID", e);
        }
    }

    private boolean shouldLogAudit(Object entity) {
        return !(entity instanceof AuditDetails);
    }

    private void saveAudit(String action, Object oldEntity, Object newEntity) {
        try {
            Map<String, Object> oldData = oldEntity != null ? extractData(oldEntity) : null;
            Map<String, Object> newData = newEntity != null ? extractData(newEntity) : null;
            String oldDetails = oldData != null ? objectMapper.writeValueAsString(oldData) : null;
            String newDetails = newData != null ? objectMapper.writeValueAsString(newData) : null;

            AuditDetails auditDetails = AuditDetails.builder()
                    .action(action)
                    .oldDetails(oldDetails)
                    .details(newDetails)
                    .entityType(newEntity != null ? newEntity.getClass().getName() : oldEntity.getClass().getName())
                    .entityId(newEntity != null ? getEntityId(newEntity) : getEntityId(oldEntity))
                    .time(LocalDateTime.now())
                    .build();
            auditRepository.save(auditDetails);
        } catch (Exception e) {
            throw new RuntimeException("Failed to save audit details", e);
        }
    }

    private Map<String, Object> extractData(Object entity) throws IllegalAccessException {
        Map<String, Object> data = new HashMap<>();
        if (entity == null) return data;

        for (Field field : entity.getClass().getDeclaredFields()) {
            field.setAccessible(true);

            if (field.isAnnotationPresent(ManyToMany.class)) {
                continue;
            }

            if (field.isAnnotationPresent(ManyToOne.class) || field.isAnnotationPresent(OneToOne.class)) {
                Object associatedEntity = field.get(entity);
                if (associatedEntity != null) {
                    try {
                        Field associatedIdField = associatedEntity.getClass().getDeclaredField("id");
                        associatedIdField.setAccessible(true);
                        Object associatedId = associatedIdField.get(associatedEntity);
                        data.put(field.getName() + "Id", associatedId != null ? associatedId.toString() : null);
                    } catch (Exception e) {
                        log.error("extractData: Error extracting ID for associated entity", e);
                    }
                }
            } else {
                Object value = field.get(entity);
                if (value != null) {
                    data.put(field.getName(), value);
                }
            }
        }
        return data;
    }
}

2. 在需要审计的实体上添加监听器

@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
@SuperBuilder
@EntityListeners(AuditListener.class) // 添加监听器注解
public class Appointment extends MultiTenantManager {
    // 原有代码保持不变
}

内容的提问来源于stack exchange，提问作者Kushani Hansika