如何让Hibernate不追踪加密模块EventListener中的实体变更？

一、针对EventListener方案的修复（不推荐，仅作应急） #

如果必须继续使用EventListener，核心是在解密后手动清除Hibernate的脏标记，让它认为字段没有被修改：

1. 清除实体/属性的脏状态
   在postLoad和postInsert解密完成后，通过Hibernate内部API标记实体或属性为非脏：

   // 解密操作完成后执行
   if (event.getSession() instanceof SessionImpl sessionImpl) {
       Object entity = event.getEntity();
       EntityEntry entry = sessionImpl.getPersistenceContext().getEntry(entity);
       if (entry != null) {
           // 方式1：清除整个实体的脏标记
           entry.setDirty(false);
           entry.getDirtyProperties().clear();
   
           // 方式2：仅清除指定加密字段的脏状态（更精准）
           // 获取字段在实体中的索引（需提前通过元数据获取，比如针对User实体的email字段）
           int propertyIndex = entry.getPersister().getPropertyIndex("email");
           // 重置快照值为解密后的值，避免脏检查时对比不一致
           entry.getPersister().setPropertyValue(entity, propertyIndex, decryptedValue);
       }
   }
   

2. 避免监听循环触发
   在实体中添加一个瞬态标记，区分解密操作和用户主动修改：

   @Entity
   public class User {
       @Transient
       private boolean isDecrypting = false;
   
       // 其他字段、getter/setter
   }
   

   解密时设置isDecrypting = true，在preUpdate监听中判断：

   @Override
   public boolean onPreUpdate(PreUpdateEvent event) {
       User user = (User) event.getEntity();
       if (user.isDecrypting()) {
           user.setDecrypting(false);
           return false; // 跳过本次更新监听
       }
       // 处理用户主动修改的加密逻辑
       return true;
   }
   

二、更优方案：使用Hibernate官方推荐的字段转换机制 #

EventListener本质是侵入式修改实体状态，容易和Hibernate的持久化上下文冲突，更推荐以下两种官方方案：

1. AttributeConverter（推荐，简单易用） #

实现AttributeConverter接口，让Hibernate自动处理加密解密，完全透明，不会触发不必要的脏检查：

@Converter(autoApply = false) // 按需应用，而非全局自动
public class EncryptedStringConverter implements AttributeConverter<String, String> {

    private final EncryptionService encryptionService;

    // 构造注入加密服务（Spring环境下自动注入）
    public EncryptedStringConverter(EncryptionService encryptionService) {
        this.encryptionService = encryptionService;
    }

    @Override
    public String convertToDatabaseColumn(String plainText) {
        return plainText == null ? null : encryptionService.encrypt(plainText);
    }

    @Override
    public String convertToEntityAttribute(String encryptedText) {
        return encryptedText == null ? null : encryptionService.decrypt(encryptedText);
    }
}

在实体字段上标注应用：

@Entity
public class User {
    @Convert(converter = EncryptedStringConverter.class)
    private String email;

    // 其他字段
}

原理：Hibernate会在加载时自动解密、保存时自动加密，快照中存储的是解密后的明文，脏检查时对比实体当前值和快照值，用户未修改则不会触发更新。

2. Hibernate UserType（适合复杂场景） #

如果需要处理更复杂的类型（比如自定义对象），可以实现UserType接口：

public class EncryptedStringType implements UserType {

    private final EncryptionService encryptionService;

    public EncryptedStringType(EncryptionService encryptionService) {
        this.encryptionService = encryptionService;
    }

    @Override
    public int[] sqlTypes() {
        return new int[]{Types.VARCHAR};
    }

    @Override
    public Class<?> returnedClass() {
        return String.class;
    }

    @Override
    public boolean equals(Object x, Object y) {
        return Objects.equals(x, y);
    }

    @Override
    public int hashCode(Object x) {
        return x != null ? x.hashCode() : 0;
    }

    @Override
    public Object nullSafeGet(ResultSet rs, String[] names, SharedSessionContractImplementor session, Object owner) throws SQLException {
        String encrypted = rs.getString(names[0]);
        return rs.wasNull() ? null : encryptionService.decrypt(encrypted);
    }

    @Override
    public void nullSafeSet(PreparedStatement st, Object value, int index, SharedSessionContractImplementor session) throws SQLException {
        if (value == null) {
            st.setNull(index, Types.VARCHAR);
            return;
        }
        st.setString(index, encryptionService.encrypt((String) value));
    }

    // 实现其他必要方法：deepCopy返回原值，isMutable返回true，disassemble/assemble处理序列化等
    @Override
    public Object deepCopy(Object value) {
        return value;
    }

    @Override
    public boolean isMutable() {
        return true;
    }

    @Override
    public Serializable disassemble(Object value) {
        return (Serializable) value;
    }

    @Override
    public Object assemble(Serializable cached, Object owner) {
        return cached;
    }

    @Override
    public Object replace(Object original, Object target, Object owner) {
        return original;
    }
}

在实体字段上标注：

@Entity
public class User {
    @Type(type = "com.example.EncryptedStringType")
    private String email;

    // 其他字段
}

三、为什么EventListener不是最佳选择？ #

EventListener是针对实体生命周期事件的钩子，设计目的是扩展业务逻辑（比如审计），而非修改实体的持久化状态。直接在监听中修改实体字段会干扰Hibernate的快照机制，导致脏检查误判、循环触发监听甚至并发异常，属于hack式实现，维护成本高。

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