如何在更新操作中获取POJO旧对象实例以满足审计需求？

首先明确结论：不建议在Plan类中存储旧实例，这会污染数据模型的核心职责（POJO应仅封装业务数据，而非审计辅助逻辑），还可能引发序列化/反序列化的潜在问题（如循环引用）。以下是几种更合理的方案，按推荐优先级排序：

1. 利用请求上下文传递旧实例（推荐，适用于Spring等Web框架） #

既然反序列化时已经查询过旧实例，可在Controller层将旧实例存入请求上下文，再在update方法中取出：

步骤1：Controller层存储旧实例 #

@PutMapping("/api/v1/Plan/{id}")
public ResponseEntity<Plan> updatePlan(@PathVariable Long id, @RequestBody Plan newPlan) {
    // 这一步是你提到的反序列化阶段已执行的查询
    Plan oldPlan = planRepository.findById(id).orElseThrow(() -> new RuntimeException("Plan not found"));
    
    // 将旧实例存入请求上下文
    ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
    attributes.setAttribute("oldPlan", oldPlan, RequestAttributes.SCOPE_REQUEST);
    
    Plan updatedPlan = planService.update(newPlan);
    return ResponseEntity.ok(updatedPlan);
}

步骤2：update方法中取出旧实例 #

public Plan update(Plan newPlan) {
    // 从请求上下文获取旧实例
    ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
    Plan oldPlan = (Plan) attributes.getAttribute("oldPlan", RequestAttributes.SCOPE_REQUEST);
    
    // 调用审计服务
    auditService.recordChange(oldPlan, newPlan);
    
    // 执行持久化
    return planRepository.save(newPlan);
}

优点：完全不污染POJO，符合单一职责原则，无需修改update方法签名，也不会重复查询数据库。

2. 使用ThreadLocal临时存储（无Web框架依赖场景） #

如果不依赖Spring等Web框架的请求上下文，可通过ThreadLocal临时传递旧实例，注意使用后必须清理避免内存泄漏：

步骤1：定义ThreadLocal工具类 #

public class AuditContext {
    private static final ThreadLocal<Plan> OLD_PLAN_HOLDER = new ThreadLocal<>();
    
    public static void setOldPlan(Plan oldPlan) {
        OLD_PLAN_HOLDER.set(oldPlan);
    }
    
    public static Plan getOldPlan() {
        return OLD_PLAN_HOLDER.get();
    }
    
    public static void clear() {
        OLD_PLAN_HOLDER.remove();
    }
}

步骤2：Controller/请求处理层存储旧实例 #

public Plan handleUpdate(Long id, Plan newPlan) {
    Plan oldPlan = planDao.findById(id);
    AuditContext.setOldPlan(oldPlan);
    try {
        return planService.update(newPlan);
    } finally {
        // 必须清理，防止线程池复用导致数据残留
        AuditContext.clear();
    }
}

步骤3：update方法中取出旧实例 #

public Plan update(Plan newPlan) {
    Plan oldPlan = AuditContext.getOldPlan();
    auditService.recordChange(oldPlan, newPlan);
    return planDao.save(newPlan);
}

优点：不依赖Web框架，同样不污染POJO；注意点：必须在finally块中清理ThreadLocal，避免线程池中的线程复用导致数据泄露。

3. 自定义Jackson反序列化器（妥协方案） #

如果上述两种方式都不可行，可在Plan类中添加一个transient+@JsonIgnore的临时字段存储旧实例，尽量减少对POJO的污染：

步骤1：修改Plan类 #

public class Plan{
    private Long id;
    private String name;
    // other fields, getters, builder..
    
    // 临时存储旧实例，仅用于审计，不参与序列化/反序列化
    @JsonIgnore
    private transient Plan oldPlan;
    
    // getter和setter
    public Plan getOldPlan() { return oldPlan; }
    public void setOldPlan(Plan oldPlan) { this.oldPlan = oldPlan; }
}

步骤2：Controller层设置旧实例 #

public Plan handleUpdate(Long id, Plan newPlan) {
    Plan oldPlan = planDao.findById(id);
    newPlan.setOldPlan(oldPlan);
    return planService.update(newPlan);
}

步骤3：update方法中使用旧实例 #

public Plan update(Plan newPlan) {
    Plan oldPlan = newPlan.getOldPlan();
    auditService.recordChange(oldPlan, newPlan);
    
    // 持久化前清空临时字段，避免不必要的引用
    newPlan.setOldPlan(null);
    return planDao.save(newPlan);
}

优点：无需依赖上下文或ThreadLocal；缺点：仍给POJO增加了非业务相关的字段，属于妥协方案。

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