Spring Boot应用中删除数据库实体时同步清理本地文件

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Optional;

@Service
public class ChannelService {

    private final ChannelRepository channelRepository; // 假设有一个ChannelRepository
    private final String uploadDir; // 文件上传根目录

    public ChannelService(ChannelRepository channelRepository,
                          @Value("${app.avatar.upload-dir}") String uploadDir) {
        this.channelRepository = channelRepository;
        this.uploadDir = uploadDir;
    }

    /**
     * 删除频道实体及其关联的本地头像文件。
     * 该操作在事务中执行，确保数据库和文件操作的原子性。
     *
     * @param channelId 要删除的频道ID
     * @throws EntityNotFoundException 如果找不到对应的频道实体
     */
    @Transactional
    public void deleteChannelAndAvatar(Long channelId) {
        Optional<Channel> optionalChannel = channelRepository.findById(channelId);

        if (optionalChannel.isEmpty()) {
            throw new EntityNotFoundException("Channel with ID " + channelId + " not found.");
        }

        Channel channel = optionalChannel.get();
        String avatarRelativePath = channel.getAvatarPath(); // 假设Channel实体有getAvatarPath()方法

        // 1. 先删除数据库实体
        channelRepository.delete(channel);
        System.out.println("Deleted Channel entity with ID: " + channelId);

        // 2. 后删除本地文件
        if (avatarRelativePath != null && !avatarRelativePath.isEmpty()) {
            try {
                Path filePath = Paths.get(uploadDir, avatarRelativePath);
                if (Files.exists(filePath)) {
                    Files.delete(filePath);
                    System.out.println("Deleted local avatar file: " + filePath);
                } else {
                    System.out.println("Local avatar file not found, skipping deletion: " + filePath);
                }
            } catch (IOException e) {
                // 文件删除失败，记录日志。由于事务已开启，此处抛出RuntimeException会导致事务回滚。
                // 如果希望数据库删除成功但文件删除失败时不回滚，则需要更复杂的异常处理或补偿机制。
                // 在此示例中，我们假设文件删除失败是严重问题，应回滚。
                System.err.println("Failed to delete local avatar file: " + avatarRelativePath + ", Error: " + e.getMessage());
                throw new RuntimeException("Failed to delete local avatar file: " + avatarRelativePath, e);
            }
        }
    }
}

// 假设的Channel实体和Repository接口
// @Entity
// public class Channel {
//     @Id
//     @GeneratedValue(strategy = GenerationType.IDENTITY)
//     private Long id;
//     private String name;
//     private String avatarPath; // 存储头像的相对路径
//     // ... getters and setters
// }
//
// public interface ChannelRepository extends JpaRepository<Channel, Long> {
//     // ...
// }

import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@Component
public class OrphanedFileCleanupScheduler {

    private final ChannelRepository channelRepository;
    private final String uploadDir;

    public OrphanedFileCleanupScheduler(ChannelRepository channelRepository,
                                        @Value("${app.avatar.upload-dir}") String uploadDir) {
        this.channelRepository = channelRepository;
        this.uploadDir = uploadDir;
    }

    /**
     * 定时清理本地磁盘上的孤儿头像文件。
     * 每天凌晨2点执行一次。
     */
    @Scheduled(cron = "0 0 2 * * ?") // 每天凌晨2点执行
    public void cleanupOrphanedAvatars() {
        System.out.println("Starting orphaned avatar cleanup task...");
        try {
            Path directory = Paths.get(uploadDir);
            if (!Files.exists(directory) || !Files.isDirectory(directory)) {
                System.err.println("Upload directory does not exist or is not a directory: " + uploadDir);
                return;
            }

            // 1. 获取数据库中所有有效的头像路径
            // 假设ChannelRepository有一个方法来获取所有avatarPath
            List<String> activeAvatarPathsList = channelRepository.findAllAvatarPaths();
            Set<String> activeAvatarPaths = activeAvatarPathsList.stream()
                                                                .collect(Collectors.toSet());

            // 2. 遍历本地文件系统中的所有文件
            try (Stream<Path> walk = Files.walk(directory)) {
                walk.filter(Files::isRegularFile)
                    .forEach(filePath -> {
                        String relativePath = directory.relativize(filePath).toString();
                        // 3. 比对并删除孤儿文件
                        if (!activeAvatarPaths.contains(relativePath)) {
                            // 考虑竞态条件：如果文件是最近上传的，但数据库实体尚未创建，可能会被误删。
                            // 引入宽限期是一个好的实践。例如，只删除修改时间超过N小时的文件。
                            try {
                                // 示例：只删除2小时前修改的文件，给新上传的文件一个宽限期
                                long twoHoursAgo = System.currentTimeMillis() - (2 * 60 * 60 * 1000);
                                if (Files.getLastModifiedTime(filePath).toMillis() < twoHoursAgo) {
                                    Files.delete(filePath);
                                    System.out.println("Deleted orphaned file: " + filePath);
                                } else {
                                    System.out.println("Skipping recently modified file (within grace period): " + filePath);
                                }
                            } catch (IOException e) {
                                System.err.println("Failed to delete orphaned file: " + filePath + ", Error: " + e.getMessage());
                            }
                        }
                    });
            }
            System.out.println("Orphaned avatar cleanup task finished.");
        } catch (IOException e) {
            System.err.println("Error during orphaned avatar cleanup task: " + e.getMessage());
        }
    }
}

// 假设ChannelRepository接口有一个方法来获取所有头像路径
// public interface ChannelRepository extends JpaRepository<Channel, Long> {
//     @Query("SELECT c.avatarPath FROM Channel c WHERE c.avatarPath IS NOT NULL")
//     List<String> findAllAvatarPaths();
// }