基于 SpringBoot 的图书购买系统 Redis 分页展示与前后端交互实现

1.3 接口规范与错误处理

1.3.1 状态码规范

• 200：请求成功
• -1：未登录，需要用户进行身份验证
• -2：请求失败，具体错误信息在 errorMessage 中说明

1.3.2 错误处理机制

所有接口在处理异常时，都会返回统一的错误响应格式。前端根据状态码进行相应的处理，如重定向到登录页面或弹出错误提示框。

2. 整体代码逻辑架构

2.1 系统架构概述

本模块采用典型的三层架构设计，结合 Redis 缓存层：

1. 表示层（前端）：负责用户界面的展示和交互。
2. 应用层（后端）：包含控制器、服务层和数据访问层。
3. 数据层：包含 MySQL 数据库和 Redis 缓存。

2.2 数据流向与处理流程

2.2.1 系统初始化流程

1. Spring 容器启动，DataInitService 实现 InitializingBean 接口。
2. afterPropertiesSet() 方法被调用，触发 DataSyncService 的 syncMysqlToRedis() 方法。
3. 从 MySQL 查询特价图书数据并批量存入 Redis，键名格式为 bookInfoId:{id}。

2.2.2 前端请求处理流程

1. 前端发送 AJAX 请求。
2. 控制器接收请求并校验参数。
3. 服务层处理业务逻辑（查询 Redis 或更新库存）。
4. 返回统一格式结果给前端渲染。

2.3 Redis 数据模型设计

1. 键名设计：bookInfoId:{id}。
2. 值类型：JSON 格式，使用 GenericJackson2JsonRedisSerializer 序列化。
3. 数据结构：字符串（String）类型存储单个图书对象。

2.4 缓存更新策略

1. 初始化加载：系统启动时将数据库数据加载到 Redis。
2. 实时更新：当图书状态变更或库存更新时，实时更新 Redis。
3. 过期策略：可根据实际需求设置过期时间。

3. Redis 配置详解

3.1 Redis 配置类实现

package org.example.booksmanagementsystem.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        
        redisTemplate.setKeySerializer(RedisSerializer.string());
        redisTemplate.setHashKeySerializer(RedisSerializer.string());
        redisTemplate.setValueSerializer(jsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jsonRedisSerializer);
        
        return redisTemplate;
    }
}

3.2 配置详解

• Key 的序列化：使用 RedisSerializer.string()。
• Value 的序列化：使用 GenericJackson2JsonRedisSerializer 转换为 JSON 格式。
• 连接工厂：由 Spring Boot 自动配置，直接注入使用。

3.3 Redis 配置优化要点

• 连接池配置：可通过 application.properties 自定义最大活跃连接数等参数。
• 超时时间配置：设置合适的超时时间避免等待无效连接。
• 数据库选择：可根据业务模块选择不同的 Redis 数据库索引。

4. 后端代码讲解

4.1 Controller 层实现

@Slf4j
@RequestMapping("/specialNormal")
@RestController
public class SpecialDealNormalController {
    @Autowired
    private SpecialDealNormalService specialDealNormalService;

    @RequestMapping("/getSpecialListByPage")
    public Result addSpecialBookInfo(PageRequest pageRequest, HttpSession session) {
        log.info("Controller--特价秒杀展示");
        if (pageRequest.getPageSize() < 1 || pageRequest.getCurrentPage() <= 0) {
            Result result = new Result();
            result.setStatus(ResultStatus.FAIL);
            result.setErrorMessage("参数验证失败");
            return result;
        }
        PageResult<BookInfo> pageResult = null;
        try {
            pageResult = specialDealNormalService.getSpecialBookListByPage(pageRequest);
        } catch (Exception e) {
            log.error("查询翻页信息错误：", e);
        }
        return Result.success(pageResult);
    }

    @RequestMapping("/buy")
    public Result buyBook(@RequestParam("bookId") Integer bookId) {
        log.info("Controller--购买图书，bookId:{}", bookId);
        try {
            boolean result = specialDealNormalService.buyBook(bookId);
            if (result) {
                return Result.success("购买成功");
            } else {
                return Result.fail("购买失败，库存不足");
            }
        } catch (Exception e) {
            log.error("购买图书异常：", e);
            return Result.fail("购买失败，系统异常");
        }
    }

    @RequestMapping("/noBuy")
    public Result noBuyBook(@RequestParam("bookId") Integer bookId) {
        log.info("Controller--取消购买，bookId:{}", bookId);
        try {
            boolean result = specialDealNormalService.noBuyBook(bookId);
            if (result) {
                return Result.success("已取消购买");
            } else {
                return Result.fail("取消购买失败");
            }
        } catch (Exception e) {
            log.error("取消购买异常：", e);
            return Result.fail("取消购买失败，系统异常");
        }
    }

    @RequestMapping("/batchPurchaseSpecialBook")
    public Result batchPurchase(@RequestParam("idList") String idList) {
        log.info("Controller--批量购买图书，idList:{}", idList);
        try {
            String[] ids = idList.split(",");
            List<Integer> bookIds = Arrays.stream(ids).map(Integer::parseInt).collect(Collectors.toList());
            boolean result = specialDealNormalService.batchPurchase(bookIds);
            if (result) {
                return Result.success("批量购买成功");
            } else {
                return Result.fail("批量购买失败，部分图书库存不足");
            }
        } catch (Exception e) {
            log.error("批量购买异常：", e);
            return Result.fail("批量购买失败，系统异常");
        }
    }
}

4.2 Service 和 Mapper 层实现

4.2.1 服务层实现

@Slf4j
@Service
public class SpecialDealNormalService {
    @Autowired
    private SpecialDealNormalMapper specialDealNormalMapper;
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public PageResult<BookInfo> getSpecialBookListByPage(PageRequest pageRequest) {
        if (pageRequest == null) {
            return null;
        }
        List<BookInfo> allBooks = getAllBookInfoFromRedis();
        int total = allBooks.size();
        List<BookInfo> pageData = getRequestPage(pageRequest, allBooks);
        for (BookInfo book : pageData) {
            book.setStatusCN(BookInfoStatusEnum.getNameByCode(book.getStatus()).getName());
        }
        return new PageResult<>(total, pageData, pageRequest);
    }

    private List<BookInfo> getRequestPage(PageRequest pageRequest, List<BookInfo> allBooks) {
        int offset = pageRequest.getOffset();
        int pageSize = pageRequest.getPageSize();
        int total = allBooks.size();
        int endIndex = Math.min(offset + pageSize, total);
        return allBooks.subList(offset, endIndex);
    }

    public List<BookInfo> getAllBookInfoFromRedis() {
        List<BookInfo> resultList = new ArrayList<>();
        String keyPattern = "bookInfoId:*";
        Set<String> keys = redisTemplate.keys(keyPattern);
        for (String key : keys) {
            BookInfo bookInfo = (BookInfo) redisTemplate.opsForValue().get(key);
            if (bookInfo != null && bookInfo.getStatus() == BookInfoStatusEnum.SPECIALDEAL.getCode()) {
                resultList.add(bookInfo);
            }
        }
        return resultList;
    }

    public boolean buyBook(Integer bookId) {
        log.info("Service--购买图书，bookId:{}", bookId);
        String key = "bookInfoId:" + bookId;
        BookInfo bookInfo = (BookInfo) redisTemplate.opsForValue().get(key);
        if (bookInfo == null) {
            log.error("图书不存在，bookId:{}", bookId);
            return false;
        }
        if (bookInfo.getCount() <= 0) {
            log.error("库存不足，bookId:{}", bookId);
            return false;
        }
        bookInfo.setCount(bookInfo.getCount() - 1);
        redisTemplate.opsForValue().set(key, bookInfo);
        log.info("购买成功，bookId:{}，剩余库存:{}", bookId, bookInfo.getCount());
        return true;
    }

    public boolean noBuyBook(Integer bookId) {
        log.info("Service--取消购买，bookId:{}", bookId);
        String key = "bookInfoId:" + bookId;
        BookInfo bookInfo = (BookInfo) redisTemplate.opsForValue().get(key);
        if (bookInfo == null) {
            log.error("图书不存在，bookId:{}", bookId);
            return false;
        }
        bookInfo.setCount(bookInfo.getCount() + 1);
        redisTemplate.opsForValue().set(key, bookInfo);
        log.info("取消购买成功，bookId:{}，当前库存:{}", bookId, bookInfo.getCount());
        return true;
    }

    public boolean batchPurchase(List<Integer> bookIds) {
        log.info("Service--批量购买图书，bookIds:{}", bookIds);
        for (Integer bookId : bookIds) {
            String key = "bookInfoId:" + bookId;
            BookInfo bookInfo = (BookInfo) redisTemplate.opsForValue().get(key);
            if (bookInfo == null || bookInfo.getCount() <= 0) {
                log.error("库存不足或不存在，bookId:{}", bookId);
                return false;
            }
        }
        for (Integer bookId : bookIds) {
            String key = "bookInfoId:" + bookId;
            BookInfo bookInfo = (BookInfo) redisTemplate.opsForValue().get(key);
            bookInfo.setCount(bookInfo.getCount() - 1);
            redisTemplate.opsForValue().set(key, bookInfo);
        }
        log.info("批量购买成功，bookIds:{}", bookIds);
        return true;
    }
}

4.3 相关类实现

4.3.1 枚举类实现

public enum BookInfoStatusEnum {
    DELETED(0, "已经删除"),
    NORMALL(1, "允许借阅"),
    FORBIDDEN(2, "禁止借阅"),
    SPECIALDEAL(3, "特价秒杀");

    private int code;
    private String name;

    BookInfoStatusEnum(int code, String name) {
        this.code = code;
        this.name = name;
    }

    public static BookInfoStatusEnum getNameByCode(int code) {
        switch (code) {
            case 0: return DELETED;
            case 1: return NORMALL;
            case 2: return FORBIDDEN;
            case 3: return SPECIALDEAL;
            default: return FORBIDDEN;
        }
    }

    public int getCode() { return code; }
    public String getName() { return name; }
}

4.3.2 分页相关类

public class PageRequest {
    private int currentPage = 1;
    private int pageSize = 10;
    private int offset;

    public PageRequest() {
        this.offset = (this.currentPage - 1) * this.pageSize;
    }

    public PageRequest(int currentPage) {
        this.currentPage = currentPage;
        this.offset = (this.currentPage - 1) * this.pageSize;
    }

    public PageRequest(int currentPage, int pageSize) {
        this.currentPage = currentPage;
        this.pageSize = pageSize;
        this.offset = (this.currentPage - 1) * this.pageSize;
    }

    public int getOffset() {
        return (this.currentPage - 1) * this.pageSize;
    }
    // getter and setter methods...
}

public class PageResult<T> {
    private int total;
    private List<T> bookInfoList;
    private PageRequest pageRequest;

    public PageResult(int count, List<T> bookInfoList, PageRequest pageRequest) {
        this.total = count;
        this.bookInfoList = bookInfoList;
        this.pageRequest = pageRequest;
    }
    // getter and setter methods...
}

5. 前端代码讲解

5.1 页面整体结构

特价秒杀模块的前端页面主要包含标题区域、操作区域、图书列表区域和分页区域。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>特价秒杀专区</title>
    <link rel="stylesheet" href="css/bootstrap.min.css">
    <script src="js/jquery.min.js"></script>
    <script src="js/bootstrap.min.js"></script>
    <script src="js/jq-paginator.js"></script>
</head>
<body>
<div class="bookContainer">
    <h2>特价秒杀专区</h2>
    <div class="navbar-justify-between">
        <button class="btn btn-outline-info" type="button" onclick="batchPurchaseBook()">批量购买</button>
        <button class="btn btn-outline-info" type="button" onclick="location.href='special_normal_shoppingtrolley.html'">特价购物车</button>
    </div>
    <table>
        <thead>
        <tr>
            <td>选择</td><td>图书 ID</td><td>书名</td><td>作者</td><td>数量</td><td>定价</td><td>出版社</td><td>状态</td><td>操作</td>
        </tr>
        </thead>
        <tbody></tbody>
    </table>
    <div class="demo"><ul id="pageContainer" class="pagination justify-content-center"></ul></div>
</div>
</body>
</html>

5.2 交互逻辑实现

5.2.1 数据获取与页面渲染

function getBookList() {
    $.ajax({
        url: "/specialNormal/getSpecialListByPage" + location.search,
        type: "get",
        success: function(result) {
            if (result.status === "FAIL" || result.status === "UNLOGIN") {
                location.href = "login.html";
            }
            var finalHtml = "";
            result = result.data;
            for (var book of result.bookInfoList) {
                finalHtml += '<tr>';
                finalHtml += '<td><input type="checkbox" name="selectBook' + book.id + '"></td>';
                finalHtml += '<td>' + book.id + '</td>';
                finalHtml += '<td>' + book.bookName + '</td>';
                finalHtml += '<td>' + book.author + '</td>';
                finalHtml += '<td>' + book.count + '</td>';
                finalHtml += '<td>' + book.price + '</td>';
                finalHtml += '<td>' + book.publish + '</td>';
                finalHtml += '<td>' + book.statusCN + '</td>';
                finalHtml += '<td><div>'; 
                finalHtml += '<button type="button" onclick="purchaseBook(' + book.id + ')">购买</button>';
                finalHtml += '<button type="button" onclick="cancelPurchase(' + book.id + ')">取消购买</button>';
                finalHtml += '</div></td></tr>';
            }
            $("tbody").html(finalHtml);
            $("#pageContainer").jqPaginator({
                totalCounts: result.total,
                pageSize: result.pageRequest.pageSize,
                visiblePages: 5,
                currentPage: result.pageRequest.currentPage,
                first: '<li><a>首页</a></li>',
                prev: '<li><a>上一页</a></li>',
                next: '<li><a>下一页</a></li>',
                last: '<li><a>最后一页</a></li>',
                page: '<li><a>{{page}}</a></li>',
                onPageChange: function(page, type) {
                    if (type === "change") {
                        location.href = "book_list_normal.html?currentPage=" + page;
                    }
                }
            });
        }
    });
}

6. 总结

本文介绍了基于 SpringBoot 和 Redis 的图书管理系统特价秒杀模块的实现。内容涵盖 Redis 配置、序列化策略、后端数据同步与缓存更新机制、前后端接口设计及分页逻辑。通过实例展示了如何利用 Redis 减轻数据库压力，提升系统响应速度，并实现了完整的库存管理与分页查询功能。

关键技术要点包括：

1. Redis 配置与优化：使用 RedisTemplate 进行 Redis 操作，合理配置序列化方式，系统启动时通过 InitializingBean 实现数据预加载。
2. 后端架构设计：采用三层架构设计，实现数据初始化和同步机制，保证 Redis 与数据库的数据一致性。
3. 前端交互实现：使用 Bootstrap 框架实现响应式页面设计，通过 AJAX 与后端接口进行数据交互。

后续改进方向可考虑缓存失效策略优化、并发控制增强（如分布式锁）、监控与告警机制以及多级缓存架构的构建。