如何在Spring Boot JPA中实现父子实体的级联软删除

这个问题我帮不少开发者解决过，核心点在于JPA原生的cascade属性是针对物理删除设计的，软删除的级联逻辑得我们自己来实现。下面给你几个实用的方案，你可以根据项目的复杂度和需求来选：

方案一：手动递归处理子实体（适合小型项目/明确的关联关系） #

如果你的实体关联关系不复杂，可以在软删除逻辑里手动遍历并标记所有子实体的deleteFlag。

步骤1：定义软删除处理接口 #

先给所有需要级联软删的实体定义一个统一接口，方便递归处理：

public interface CascadableSoftDelete {
    void markAsDeletedWithChildren();
}

步骤2：父实体实现接口 #

在父实体里实现这个方法，递归标记自身和所有子实体的deleteFlag：

public class SomeParentTable extends BaseEntity implements CascadableSoftDelete {

    @OneToMany(mappedBy = "parent", cascade = CascadeType.MERGE)
    private List<SomeChildTable> children;

    @Override
    public void markAsDeletedWithChildren() {
        // 标记自身为已删除
        this.setDeleteFlag("Y");
        // 遍历子实体，递归标记
        if (children != null && !children.isEmpty()) {
            children.forEach(child -> {
                child.setDeleteFlag("Y");
                // 如果子实体还有下级关联，继续递归
                if (child instanceof CascadableSoftDelete) {
                    ((CascadableSoftDelete) child).markAsDeletedWithChildren();
                }
            });
        }
    }
}

步骤3：在Repository中实现级联软删方法 #

在你的BaseCrudRepository里添加默认方法，调用实体的递归删除逻辑：

public interface BaseCrudRepository<T extends BaseEntity & CascadableSoftDelete, ID extends Serializable> 
    extends JpaRepository<T, ID> {

    default void softDeleteWithCascade(ID id) {
        T entity = findById(id).orElseThrow(() -> new RuntimeException("Entity not found"));
        entity.markAsDeletedWithChildren();
        save(entity); // 因为配置了CascadeType.MERGE，子实体会被同步更新
    }
}

调用softDeleteWithCascade时，父实体和所有关联子实体的deleteFlag都会被设为Y。

方案二：使用实体监听器+自定义注解（优雅的通用方案） #

如果项目中有很多实体需要级联软删，可以用JPA的实体监听器配合自定义注解，实现自动级联逻辑，不用每个实体写递归代码。

步骤1：定义级联软删注解 #

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CascadeSoftDelete {
}

步骤2：编写实体监听器 #

在监听器中监听实体的更新事件，当父实体被标记为删除时，自动处理所有带注解的子集合：

public class SoftDeleteCascadeListener {

    @PreUpdate
    public void handleCascadeSoftDelete(Object entity) {
        if (!(entity instanceof BaseEntity)) {
            return;
        }

        BaseEntity baseEntity = (BaseEntity) entity;
        // 只有当实体被标记为删除时，才触发级联
        if ("Y".equals(baseEntity.getDeleteFlag())) {
            // 遍历实体的所有字段
            Field[] fields = entity.getClass().getDeclaredFields();
            for (Field field : fields) {
                if (field.isAnnotationPresent(CascadeSoftDelete.class) && Collection.class.isAssignableFrom(field.getType())) {
                    field.setAccessible(true);
                    try {
                        Collection<?> children = (Collection<?>) field.get(entity);
                        if (children != null) {
                            for (Object child : children) {
                                if (child instanceof BaseEntity) {
                                    BaseEntity childEntity = (BaseEntity) child;
                                    childEntity.setDeleteFlag("Y");
                                    // 递归处理子实体的子实体
                                    handleCascadeSoftDelete(child);
                                }
                            }
                        }
                    } catch (IllegalAccessException e) {
                        throw new RuntimeException("Failed to apply cascade soft delete", e);
                    }
                }
            }
        }
    }
}

步骤3：给BaseEntity绑定监听器 #

@MappedSuperclass
@EntityListeners(SoftDeleteCascadeListener.class)
@Where(clause = "delete_flag = 'N'") // 自动过滤已删除实体，避免查询到软删数据
public class BaseEntity {
    private Long id;
    private String deleteFlag = "N";
    // 其他公共字段、getter/setter
}

步骤4：给父实体的子集合添加注解 #

public class SomeParentTable extends BaseEntity {

    @OneToMany(mappedBy = "parent", cascade = CascadeType.MERGE)
    @CascadeSoftDelete // 标记这个集合需要级联软删
    private List<SomeChildTable> children;

    // 其他字段和方法
}

现在只要你更新父实体的deleteFlag为Y并保存，监听器会自动处理所有子实体的软删，包括多层嵌套的子实体。

方案三：批量JPQL更新（适合单层简单关联） #

如果只是单层父子关系，没有嵌套子实体，可以直接写两个JPQL语句，分别更新父实体和子实体：

public interface SomeParentTableRepository extends BaseCrudRepository<SomeParentTable, Long> {

    @Modifying
    @Transactional
    @Query("update SomeParentTable p set p.deleteFlag = 'Y' where p.id = :id")
    void softDeleteParent(@Param("id") Long id);

    @Modifying
    @Transactional
    @Query("update SomeChildTable c set c.deleteFlag = 'Y' where c.parent.id = :parentId")
    void softDeleteChildren(@Param("parentId") Long parentId);

    // 组合两个方法，实现级联软删
    default void softDeleteWithChildren(Long id) {
        softDeleteParent(id);
        softDeleteChildren(id);
    }
}

这种方式简单直接，但如果有多层嵌套，就需要写多个JPQL语句，维护成本会变高。

注意事项 #

1. 事务管理：所有软删方法都需要加上@Transactional注解，确保父实体和子实体的更新在同一个事务中；
2. 懒加载处理：如果子集合是懒加载的，要确保在事务内初始化集合（比如调用children.size()），避免懒加载异常；
3. 查询过滤：一定要在BaseEntity上添加@Where(clause = "delete_flag = 'N'")，这样JPA的默认查询方法（findAll、findById等）会自动过滤已软删的实体，避免业务代码查询到无效数据。

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