1. 项目概述与背景
在当今的Web应用开发中，高效的数据查询和展示是提升用户体验的关键因素。图书购买系统作为典型的电商类应用，经常面临热门图书列表频繁查询的性能挑战。传统直接查询数据库的方式在高并发场景下会导致性能瓶颈，而Redis作为内存数据库，其出色的读写性能使其成为缓存热门数据的理想选择。
本项目基于Spring Boot 3.x构建，使用Redis作为缓存层，实现了图书数据的分页展示功能。通过将热门图书数据存储在Redis的Sorted Set中，我们能够以O(log N + M)的时间复杂度完成分页查询（N为集合大小，M为页面大小），相比直接查询数据库或使用List结构的O(N)复杂度，性能提升显著。
2. 技术选型与架构设计
2.1 核心技术栈解析
Spring Boot 3.x：作为项目的基础框架，提供了自动配置、依赖管理等便利特性。选择最新的LTS版本确保了长期支持和技术先进性。
Redis：采用Redis 6.x及以上版本，主要基于以下考虑：
- 内存存储带来的极高读写性能
- 丰富的数据结构支持（本项目使用Sorted Set）
- 持久化机制保证数据安全
- 成熟的集群方案支持水平扩展
Spring Data Redis：作为Spring生态对Redis的封装，它提供了：
- 简化的Redis操作模板（RedisTemplate）
- 自动化的连接管理
- 与Spring Cache的无缝集成
2.2 数据结构设计决策
对于分页需求，Redis提供了多种可能的数据结构选择：
-
List：
- 优点：简单直观，使用LRANGE命令可分页
- 缺点：分页复杂度O(N)，大数据量性能差；排序需额外操作
-
Hash：
- 优点：适合存储对象
- 缺点：无法直接支持分页
-
Sorted Set：
- 优点：天然有序，ZRANGE命令分页效率高（O(log N + M)）
- 缺点：存储结构稍复杂
经过性能测试和实际需求分析，我们最终选择Sorted Set作为存储结构，主要基于：
- 分页查询的高效性
- 内置排序能力（通过score机制）
- 适合热点数据的存取模式
3. 环境准备与项目搭建
3.1 开发环境配置
Redis安装与配置：
- 开发环境推荐使用Docker快速部署：
bash复制
docker run -d --name redis -p 6379:6379 redis:6-alpine - 生产环境建议配置：
bash复制# 启用持久化 docker run -d --name redis -p 6379:6379 \ -v /path/to/redis/data:/data \ redis:6-alpine redis-server --appendonly yes
Spring Boot项目初始化：
-
使用Spring Initializr创建项目，选择：
- Spring Boot 3.2.x
- Java 17+
- 依赖：Spring Web, Spring Data Redis, Lombok
-
关键依赖说明（pom.xml）：
xml复制<dependencies>
<!-- Web支持 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Redis集成 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 连接池优化 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
<!-- 开发便利工具 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
3.2 Redis连接配置
基础配置（application.yml）：
yaml复制spring:
data:
redis:
host: localhost
port: 6379
# 生产环境建议配置连接池
lettuce:
pool:
max-active: 20
max-idle: 10
min-idle: 5
max-wait: 2000ms
自定义RedisTemplate配置：
java复制@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(
RedisConnectionFactory connectionFactory,
ObjectMapper objectMapper) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(connectionFactory);
// 使用Jackson序列化
GenericJackson2JsonRedisSerializer serializer =
new GenericJackson2JsonRedisSerializer(objectMapper);
// Key序列化
template.setKeySerializer(RedisSerializer.string());
template.setHashKeySerializer(RedisSerializer.string());
// Value序列化
template.setValueSerializer(serializer);
template.setHashValueSerializer(serializer);
return template;
}
@Bean
public ObjectMapper objectMapper() {
ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new JavaTimeModule());
mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
return mapper;
}
}
关键点说明：
- 使用Jackson进行JSON序列化，支持复杂对象存储
- 配置专门的ObjectMapper以正确处理Java 8日期时间类型
- String类型的key序列化更节省空间且可读性好
4. 核心业务实现
4.1 领域模型设计
图书实体（Book.java）：
java复制@Data
@AllArgsConstructor
@NoArgsConstructor
public class Book implements Serializable {
private static final long serialVersionUID = 1L;
private Long id;
private String title;
private String author;
private Double price;
private LocalDateTime createTime;
// 评分字段可用于Sorted Set的score
public Double getScore() {
return this.price; // 示例：使用价格作为排序依据
}
}
4.2 数据存储策略
BookService核心方法实现：
java复制@Service
@RequiredArgsConstructor
public class BookService {
private final RedisTemplate<String, Object> redisTemplate;
private static final String BOOKS_KEY = "books:sorted";
// 添加图书到Sorted Set
public void addBook(Book book) {
redisTemplate.opsForZSet().add(
BOOKS_KEY,
book,
book.getScore() // 使用价格作为score
);
}
// 批量添加
public void addBooks(List<Book> books) {
books.forEach(this::addBook);
}
// 分页查询
public Page<Book> getBooksByPage(int page, int size) {
// 计算分页范围
long start = (page - 1) * size;
long end = page * size - 1;
// 执行ZRANGE命令
Set<Object> booksSet = redisTemplate.opsForZSet()
.range(BOOKS_KEY, start, end);
// 类型转换
List<Book> books = booksSet.stream()
.map(obj -> (Book) obj)
.collect(Collectors.toList());
// 获取总数
long total = redisTemplate.opsForZSet().zCard(BOOKS_KEY);
return new PageImpl<>(books, PageRequest.of(page-1, size), total);
}
// 初始化测试数据
@PostConstruct
public void initSampleData() {
if (redisTemplate.opsForZSet().size(BOOKS_KEY) == 0) {
List<Book> sampleBooks = List.of(
new Book(1L, "Java编程思想", "Bruce Eckel", 99.0, LocalDateTime.now()),
new Book(2L, "Spring Boot实战", "Craig Walls", 89.0, LocalDateTime.now()),
// 更多测试数据...
);
addBooks(sampleBooks);
}
}
}
4.3 分页API设计
REST控制器实现：
java复制@RestController
@RequestMapping("/api/books")
@RequiredArgsConstructor
public class BookController {
private final BookService bookService;
@GetMapping
public ResponseEntity<PageResponse<Book>> getBooks(
@RequestParam(defaultValue = "1") int page,
@RequestParam(defaultValue = "10") int size) {
// 参数校验
if (page < 1) throw new IllegalArgumentException("页码必须大于0");
if (size < 1 || size > 100) throw new IllegalArgumentException("每页大小应在1-100之间");
Page<Book> bookPage = bookService.getBooksByPage(page, size);
return ResponseEntity.ok(PageResponse.from(bookPage));
}
}
// 统一分页响应结构
@Data
@NoArgsConstructor
@AllArgsConstructor
class PageResponse<T> {
private List<T> content;
private int currentPage;
private int totalPages;
private long totalElements;
public static <T> PageResponse<T> from(Page<T> page) {
return new PageResponse<>(
page.getContent(),
page.getNumber() + 1,
page.getTotalPages(),
page.getTotalElements()
);
}
}
5. 前端交互实现
5.1 基础HTML结构
html复制<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>图书列表 - Redis分页展示</title>
<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
<style>
.book-card {
transition: transform 0.2s;
}
.book-card:hover {
transform: translateY(-5px);
box-shadow: 0 10px 20px rgba(0,0,0,0.1);
}
</style>
</head>
<body>
<div class="container mt-4">
<h1 class="mb-4">热门图书推荐</h1>
<!-- 搜索过滤区域 -->
<div class="row mb-4">
<div class="col-md-6">
<div class="input-group">
<input type="text" id="searchInput" class="form-control" placeholder="搜索图书...">
<button class="btn btn-primary" id="searchBtn">搜索</button>
</div>
</div>
<div class="col-md-3">
<select id="pageSizeSelect" class="form-select">
<option value="5">每页5条</option>
<option value="10" selected>每页10条</option>
<option value="20">每页20条</option>
</select>
</div>
</div>
<!-- 图书列表展示区 -->
<div id="bookList" class="row row-cols-1 row-cols-md-3 g-4"></div>
<!-- 分页控件 -->
<nav class="mt-4">
<ul id="pagination" class="pagination justify-content-center"></ul>
</nav>
</div>
<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
<script src="app.js"></script>
</body>
</html>
5.2 JavaScript交互逻辑
javascript复制// app.js
class BookPagination {
constructor() {
this.currentPage = 1;
this.pageSize = 10;
this.totalPages = 1;
this.totalItems = 0;
this.initElements();
this.bindEvents();
this.loadBooks();
}
initElements() {
this.bookList = document.getElementById('bookList');
this.pagination = document.getElementById('pagination');
this.searchInput = document.getElementById('searchInput');
this.searchBtn = document.getElementById('searchBtn');
this.pageSizeSelect = document.getElementById('pageSizeSelect');
}
bindEvents() {
this.searchBtn.addEventListener('click', () => {
this.currentPage = 1;
this.loadBooks();
});
this.pageSizeSelect.addEventListener('change', () => {
this.pageSize = parseInt(this.pageSizeSelect.value);
this.currentPage = 1;
this.loadBooks();
});
}
async loadBooks() {
try {
const response = await fetch(
`/api/books?page=${this.currentPage}&size=${this.pageSize}`
);
if (!response.ok) {
throw new Error('网络响应不正常');
}
const data = await response.json();
this.totalItems = data.totalElements;
this.totalPages = data.totalPages;
this.renderBooks(data.content);
this.renderPagination();
} catch (error) {
console.error('加载图书失败:', error);
this.bookList.innerHTML = `
<div class="col-12">
<div class="alert alert-danger">加载图书失败，请刷新重试</div>
</div>
`;
}
}
renderBooks(books) {
if (books.length === 0) {
this.bookList.innerHTML = `
<div class="col-12">
<div class="alert alert-info">没有找到图书数据</div>
</div>
`;
return;
}
let html = '';
books.forEach(book => {
html += `
<div class="col">
<div class="card h-100 book-card">
<div class="card-body">
<h5 class="card-title">${book.title}</h5>
<h6 class="card-subtitle mb-2 text-muted">${book.author}</h6>
<p class="card-text">
<span class="badge bg-primary">¥${book.price.toFixed(2)}</span>
</p>
</div>
</div>
</div>
`;
});
this.bookList.innerHTML = html;
}
renderPagination() {
let html = '';
// 上一页按钮
html += `
<li class="page-item ${this.currentPage === 1 ? 'disabled' : ''}">
<a class="page-link" href="#" data-page="${this.currentPage - 1}">上一页</a>
</li>
`;
// 页码按钮
const startPage = Math.max(1, this.currentPage - 2);
const endPage = Math.min(this.totalPages, startPage + 4);
for (let i = startPage; i <= endPage; i++) {
html += `
<li class="page-item ${i === this.currentPage ? 'active' : ''}">
<a class="page-link" href="#" data-page="${i}">${i}</a>
</li>
`;
}
// 下一页按钮
html += `
<li class="page-item ${this.currentPage >= this.totalPages ? 'disabled' : ''}">
<a class="page-link" href="#" data-page="${this.currentPage + 1}">下一页</a>
</li>
`;
this.pagination.innerHTML = html;
// 绑定页码点击事件
this.pagination.querySelectorAll('.page-link').forEach(link => {
link.addEventListener('click', (e) => {
e.preventDefault();
const page = parseInt(link.dataset.page);
if (page !== this.currentPage) {
this.currentPage = page;
this.loadBooks();
}
});
});
}
}
// 初始化应用
document.addEventListener('DOMContentLoaded', () => {
new BookPagination();
});
6. 性能优化与生产建议
6.1 Redis性能调优
-
连接池配置：
yaml复制spring: redis: lettuce: pool: max-active: 50 # 根据实际负载调整 max-idle: 20 min-idle: 5 max-wait: 1000ms -
Pipeline批量操作：
对于批量插入场景，使用Pipeline可显著提升性能：java复制public void batchAddBooks(List<Book> books) { redisTemplate.executePipelined((RedisCallback<Object>) connection -> { for (Book book : books) { connection.zAdd( BOOKS_KEY.getBytes(), book.getScore(), redisTemplate.getValueSerializer().serialize(book) ); } return null; }); } -
内存优化：
- 对于大型集合，考虑使用Hash存储图书详情，Sorted Set只存储ID和score
- 启用Redis内存压缩：
bash复制redis-server --save "" --appendonly no --activerehashing yes --maxmemory 2gb --maxmemory-policy allkeys-lru
6.2 缓存策略进阶
-
多级缓存架构：
java复制@Service public class BookServiceWithMultiCache { private final BookRepository bookRepository; // JPA Repository private final RedisTemplate<String, Object> redisTemplate; private final CaffeineCache localCache; public Book getBook(Long id) { // 1. 检查本地缓存 Book book = localCache.get(id, () -> null); if (book != null) return book; // 2. 检查Redis缓存 String cacheKey = "book:" + id; book = (Book) redisTemplate.opsForValue().get(cacheKey); if (book != null) { localCache.put(id, book); // 回填本地缓存 return book; } // 3. 查询数据库 book = bookRepository.findById(id).orElseThrow(); // 写入缓存 redisTemplate.opsForValue().set(cacheKey, book, 1, TimeUnit.HOURS); localCache.put(id, book); return book; } } -
缓存预热策略：
java复制@Scheduled(cron = "0 0 3 * * ?") // 每天凌晨3点执行 public void preloadHotBooks() { List<Book> hotBooks = bookRepository.findHotBooks(100); redisTemplate.opsForZSet().add( "hot:books", hotBooks.stream() .map(b -> new DefaultTypedTuple<>(b, b.getScore())) .collect(Collectors.toSet()) ); }
7. 常见问题与解决方案
7.1 数据一致性问题
场景：当数据库中的图书信息更新时，Redis缓存可能过期
解决方案：
-
使用发布/订阅机制同步更新：
java复制@Transactional public Book updateBook(Long id, BookUpdateDTO dto) { Book book = bookRepository.findById(id).orElseThrow(); // 更新数据库 book.updateFromDTO(dto); bookRepository.save(book); // 发布更新事件 redisTemplate.convertAndSend("book.update", id); return book; } @EventListener public void handleBookUpdate(Long bookId) { // 从数据库获取最新数据 Book book = bookRepository.findById(bookId).orElseThrow(); // 更新Redis缓存 redisTemplate.opsForZSet().add( BOOKS_KEY, book, book.getScore() ); } -
设置合理的过期时间：
java复制// 添加图书时设置TTL public void addBookWithExpire(Book book, long timeout, TimeUnit unit) { redisTemplate.opsForZSet().add(BOOKS_KEY, book, book.getScore()); redisTemplate.expire(BOOKS_KEY, timeout, unit); }
7.2 大结果集分页优化
问题：当Sorted Set包含数百万条记录时，ZRANGE性能下降
优化方案：
-
使用游标分页：
java复制public Page<Book> getBooksByCursor(String cursor, int size) { // 使用ZSCAN命令实现游标分页 Cursor<ZSetOperations.TypedTuple<Object>> scanCursor = redisTemplate.opsForZSet() .scan(BOOKS_KEY, ScanOptions.scanOptions() .count(100) // 每次扫描数量 .match("*") // 匹配模式 .build()); // 实现游标逻辑... } -
数据分片：
java复制// 根据ID哈希分片 public String getShardKey(Long bookId) { int shard = (int) (bookId % 10); return "books:sorted:" + shard; }
8. 扩展思考与进阶方向
-
多维度排序：
通过组合score实现多条件排序：java复制public double getCompositeScore(Book book) { // 价格(40%) + 评分(30%) + 销量(30%) return book.getPrice() * 0.4 + book.getRating() * 30 * 0.3 + book.getSales() * 0.3; } -
实时排行榜功能：
利用Sorted Set的分数自动排序特性：java复制public void incrementBookScore(Long bookId, double delta) { // 原子性增加分数 redisTemplate.opsForZSet().incrementScore( "books:rank", bookId.toString(), delta ); } -
与数据库的协同工作：
java复制@Cacheable(value = "books", key = "#id") public Book getBookById(Long id) { return bookRepository.findById(id).orElseThrow(); } @CacheEvict(value = "books", key = "#book.id") public Book updateBook(Book book) { return bookRepository.save(book); }
在实际项目中，Redis分页方案特别适合读多写少的热点数据场景。对于需要复杂查询或频繁更新的数据，建议采用Redis+数据库的混合架构，充分发挥各自优势。