Spring Boot中实现带级联DELETE类型的软删除及关联实体处理问题

Hey there! Let's work through how to handle cascading soft deletes for your "Ma-" prefixed associated entity alongside your existing Program soft delete setup. Here's a step-by-step solution tailored to your Spring Boot setup:

First, make sure your "Ma-" entity (let's call it Machine for example) also has a soft delete flag, just like your Program entity:

public class Machine {
    // Other properties
    private boolean deletedFlag;

    // Association to Program (adjust mapping based on your actual relationship: @ManyToOne/@OneToMany)
    @ManyToOne
    private Program program;

    // Getters and Setters
}

You've got a few solid options to handle the cascading logic—pick the one that fits your code style best:

Option 1: Manual Cascading in Service Layer #

This is straightforward and gives you full control. Update your service method to soft delete both the Program and its associated "Ma-" entities:

@Service
@Transactional // Critical to ensure all updates happen in a single transaction
public class ProgramService {

    @Autowired
    private ProgramRepository programRepo;
    @Autowired
    private MachineRepository machineRepo; // Your "Ma-" entity's repository

    public void softDeleteProgram(Long programId) {
        // Soft delete the Program
        Program program = programRepo.findById(programId)
                .orElseThrow(() -> new RuntimeException("Program not found"));
        program.setDeletedFlag(true);
        programRepo.save(program);

        // Soft delete all associated "Ma-" entities
        List<Machine> relatedEntities = machineRepo.findByProgramId(programId);
        relatedEntities.forEach(entity -> {
            entity.setDeletedFlag(true);
            machineRepo.save(entity);
        });
    }
}

Don't forget to add the required query method to your "Ma-" entity's repository:

public interface MachineRepository extends JpaRepository<Machine, Long> {
    List<Machine> findByProgramId(Long programId);
    // Add your default active entity query too
    List<Machine> findByDeletedFlagFalse();
}

Option 2: Use JPA Entity Listeners for Automatic Cascading #

If you prefer to keep the cascading logic tied to the entity lifecycle, use an entity listener:

1. Create a listener class to handle the cascade:

public class SoftDeleteCascadeListener {

    @Autowired
    private MachineRepository machineRepo;

    @PostUpdate
    public void cascadeSoftDelete(Program program) {
        // Trigger cascade only when Program is marked as deleted
        if (program.isDeletedFlag()) {
            List<Machine> relatedEntities = machineRepo.findByProgramId(program.getId());
            relatedEntities.forEach(entity -> {
                entity.setDeletedFlag(true);
                machineRepo.save(entity);
            });
        }
    }
}

2. Attach the listener to your Program entity:

@Entity
@EntityListeners(SoftDeleteCascadeListener.class)
public class Program {
    // Your existing properties and methods
    private boolean deletedFlag;

    // Optional: If it's a one-to-many relationship, add the collection
    @OneToMany(mappedBy = "program")
    private List<Machine> machines;
}

Option 3: Use Custom JPQL Queries for Bulk Updates #

For performance (especially with large datasets), use bulk update queries in your repository:

public interface ProgramRepository extends JpaRepository<Program, Long> {
    Program findByDeletedFlagFalse();

    @Modifying
    @Query("UPDATE Program p SET p.deletedFlag = true WHERE p.id = :id")
    void softDeleteById(Long id);

    // Bulk update for associated "Ma-" entities
    @Modifying
    @Query("UPDATE Machine m SET m.deletedFlag = true WHERE m.program.id = :programId")
    void softDeleteRelatedMachines(Long programId);
}

Then call both methods in your service (with @Transactional):

@Transactional
public void softDeleteProgram(Long programId) {
    programRepo.softDeleteById(programId);
    programRepo.softDeleteRelatedMachines(programId);
}

• Remove CascadeType.DELETE: Make sure you don't have cascade = CascadeType.DELETE on your entity associations—this triggers physical deletion, which conflicts with soft delete logic.
• Default Active Queries: To avoid accidentally fetching deleted entities, consider creating a base repository with a default "find all active" method that filters out deletedFlag = true records, then have all your repositories inherit from it.
• Transaction Safety: Always wrap soft delete operations in a transaction to ensure partial updates don't leave your data in an inconsistent state.

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