Spring Boot 缓存高级实践：优化批量数据查询的缓存与数据库协同机制

public class Student {
    private int id;
    private String name;

    // Getters and Setters
    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 String toString() {
        return "Student{" + "id=" + id + ", name='" + name + '\'' + '}';
    }
}

SELECT name FROM Student WHERE id IN (:ids);

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Set;

@Service
public class StudentService {

    // 假设这是与数据库交互的Repository
    private StudentRepository studentRepository;

    public StudentService(StudentRepository studentRepository) {
        this.studentRepository = studentRepository;
    }

    @Cacheable(value = "students")
    public List<Student> findStudentsByIds(Set<Integer> ids) {
        System.out.println("从数据库查询学生信息，IDs: " + ids);
        return studentRepository.findByIdIn(ids);
    }
}

缓存键 (Set<Integer>)  |  缓存值 (List<Student>)
----------------------|-----------------------
{1, 2, 3}             |  [Student(id=1), Student(id=2), Student(id=3)]
{4, 5}                |  [Student(id=4), Student(id=5)]

缓存键 (Integer) | 缓存值 (Student)
-----------------|-----------------
1                | Student(id=1, name='Jon Doe')
2                | Student(id=2, name='Jane Doe')
3                | Student(id=3, name='Pie Doe')

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 OptimizedStudentService {

    private final StudentRepository studentRepository;
    private final Cache studentsCache; // 直接引用Cache实例

    public OptimizedStudentService(StudentRepository studentRepository, CacheManager cacheManager) {
        this.studentRepository = studentRepository;
        // 获取名为 "students" 的缓存实例
        this.studentsCache = cacheManager.getCache("students");
        if (this.studentsCache == null) {
            throw new IllegalStateException("Cache 'students' not found. Please configure it.");
        }
    }

    /**
     * 根据一组ID查询学生信息，优先从缓存获取，缺失部分从数据库查询。
     *
     * @param studentIds 需要查询的学生ID集合
     * @return 匹配的学生列表
     */
    public List<Student> findStudentsWithPartialCache(Set<Integer> studentIds) {
        List<Student> result = new ArrayList<>();
        Set<Integer> idsToQueryDb = new HashSet<>(studentIds); // 初始所有ID都需要查询

        // 步骤 1: 尝试从缓存中获取数据
        // 注意：这里是单键循环访问缓存，可能存在性能瓶颈，见后续优化章节
        for (Integer id : studentIds) {
            Cache.ValueWrapper valueWrapper = studentsCache.get(id);
            if (valueWrapper != null) {
                Object cachedObject = valueWrapper.get();
                if (cachedObject instanceof Student) {
                    Student student = (Student) cachedObject;
                    result.add(student);
                    idsToQueryDb.remove(id); // 从待查询数据库的ID集合中移除已缓存的ID
                }
            }
        }

        // 步骤 2: 识别出需要从数据库查询的缺失ID
        // idsToQueryDb 现在包含了所有缓存中未找到的ID

        // 步骤 3: 针对缺失的ID发起数据库查询
        if (!idsToQueryDb.isEmpty()) {
            System.out.println("从数据库查询缺失学生信息，IDs: " + idsToQueryDb);
            List<Student> dbStudents = studentRepository.findByIdIn(idsToQueryDb);

            // 步骤 4: 将数据库查询结果存入缓存
            for (Student student : dbStudents) {
                studentsCache.put(student.getId(), student);
                result.add(student); // 将新查询到的数据也添加到结果集
            }
        }

        // 步骤 5: 合并并返回所有数据
        // 确保返回的列表是去重且包含所有请求ID的数据（如果存在）
        // 实际场景可能需要根据业务逻辑对结果进行排序或进一步处理
        return result.stream()
                     .distinct() // 去重，以防万一
                     .collect(Collectors.toList());
    }
}

import com.hazelcast.map.IMap;
// ... 其他导入

@Service
public class OptimizedStudentService {
    // ... 构造函数不变

    public List<Student> findStudentsWithPartialCacheOptimized(Set<Integer> studentIds) {
        List<Student> result = new ArrayList<>();
        Set<Integer> idsToQueryDb = new HashSet<>(studentIds);

        // 尝试获取原生缓存对象
        Object nativeCache = studentsCache.getNativeCache();

        if (nativeCache instanceof IMap) { // 如果是Hazelcast IMap
            IMap<Integer, Student> hazelcastMap = (IMap<Integer, Student>) nativeCache;
            // 批量从Hazelcast缓存获取数据
            Map<Integer, Student> cachedStudentsMap = hazelcastMap.getAll(studentIds);

            for (Map.Entry<Integer, Student> entry : cachedStudentsMap.entrySet()) {
                result.add(entry.getValue());
                idsToQueryDb.remove(entry.getKey()); // 移除已缓存的ID
            }
        } else {
            // 如果不是IMap，或者不确定原生缓存类型，退回到单键循环访问
            for (Integer id : studentIds) {
                Cache.ValueWrapper valueWrapper = studentsCache.get(id);
                if (valueWrapper != null && valueWrapper.get() instanceof Student) {
                    Student student = (Student) valueWrapper.get();
                    result.add(student);
                    idsToQueryDb.remove(id);
                }
            }
        }

        // ... 后续数据库查询和缓存更新逻辑与之前相同
        if (!idsToQueryDb.isEmpty()) {
            System.out.println("从数据库查询缺失学生信息 (优化版)，IDs: " + idsToQueryDb);
            List<Student> dbStudents = studentRepository.findByIdIn(idsToQueryDb);
            for (Student student : dbStudents) {
                studentsCache.put(student.getId(), student);
                result.add(student);
            }
        }

        return result.stream().distinct().collect(Collectors.toList());
    }
}