Spring Boot缓存中数据验证与缺失键处理策略

@Cacheable("Students")
List<Student> findByIds(Set<Integer> ids) {
  // ...
  return repository.findByIds(ids);
}

缓存键          | 缓存值
----------------|--------------
Set<Integer>    | List<Student>

Cache cache = cacheManager.getCache("Students");
Student student = cache.get(id, Student.class); // 逐个获取

import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

@Service
public class StudentService {

    private final StudentRepository studentRepository;
    private final Cache studentsCache; // 直接获取特定缓存实例

    public StudentService(StudentRepository studentRepository, CacheManager cacheManager) {
        this.studentRepository = studentRepository;
        this.studentsCache = cacheManager.getCache("Students"); // 假设缓存名为"Students"
    }

    /**
     * 根据给定的学生ID集合，从缓存或数据库中获取学生信息。
     * 优先从缓存获取，缺失部分再从数据库查询并更新缓存。
     *
     * @param studentIds 待查询的学生ID集合
     * @return 匹配的学生列表
     */
    public List<Student> findStudentsByIds(Set<Integer> studentIds) {
        List<Student> result = new ArrayList<>();
        Set<Integer> idsToQueryDb = new HashSet<>(studentIds); // 存储需要从数据库查询的ID

        // 1. 尝试从缓存中加载学生数据
        // 注意：这里是逐个ID查询缓存，可能存在性能瓶颈
        for (Integer id : studentIds) {
            Cache.ValueWrapper valueWrapper = studentsCache.get(id);
            if (valueWrapper != null) {
                Object cachedObject = valueWrapper.get();
                if (cachedObject instanceof Student) {
                    result.add((Student) cachedObject);
                    idsToQueryDb.remove(id); // 从待查询数据库的ID集合中移除已缓存的ID
                }
            }
        }

        // 2. 查询数据库获取缓存中缺失的学生数据
        if (!idsToQueryDb.isEmpty()) {
            List<Student> studentsFromDb = studentRepository.findByIdIn(idsToQueryDb);

            // 3. 将从数据库获取的数据存入缓存，并添加到结果列表
            for (Student student : studentsFromDb) {
                studentsCache.put(student.getId(), student); // 缓存单个学生
                result.add(student);
            }
        }

        // 确保返回的结果只包含请求的ID，并且顺序不固定
        // 如果需要特定顺序，可能需要额外处理，例如按原始 studentIds 排序
        return result.stream()
                .filter(s -> studentIds.contains(s.getId())) // 过滤掉可能存在的意外数据
                .collect(Collectors.toList());
    }

    // 示例：StudentRepository 接口
    public interface StudentRepository {
        List<Student> findByIdIn(Set<Integer> ids);
    }

    // 示例：Student 实体类
    public static class Student {
        private int id;
        private String name;

        public Student(int id, String name) {
            this.id = id;
            this.name = name;
        }

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Student student = (Student) o;
            return id == student.id;
        }

        @Override
        public int hashCode() {
            return Objects.hash(id);
        }
    }
}