最近在开发一个视频内容管理系统时，遇到了一个典型的业务场景：如何高效地管理剧集内容，并实现灵活的观看权限控制？例如，一个名为“寒渊渡骨・晚香如梦”的系列剧，其第10集可能需要满足“投币200转免”的复杂规则。这背后涉及到的不仅仅是简单的CRUD，更考验我们对数据结构设计、业务逻辑封装和状态机流转的理解。
本文将从一个实战项目出发，完整拆解如何设计并实现一个具备剧集管理、观看规则引擎和用户交互功能的后端系统。我们将使用主流的Spring Boot框架，结合清晰的分层架构，从数据库表设计到核心接口实现，一步步构建出可运行、易扩展的代码。无论你是想学习如何将复杂业务需求转化为清晰的技术方案，还是希望获得一个可直接复用的内容管理模块，这篇文章都能为你提供详尽的参考。
1. 核心业务概念与需求分析
在开始编码之前，我们必须彻底理解我们要解决的问题。本项目的核心是围绕“剧集”这一实体，构建一套包含状态管理和规则验证的内容服务体系。
1.1 业务实体定义
首先，我们需要明确系统中的几个关键实体及其关系：
- 剧集（Episode）：内容的核心单元。每个剧集有唯一的标识、标题、所属系列、播放地址等基础信息。更重要的是，它关联着一套观看规则（WatchRule），用于决定用户能否观看。
- 观看规则（WatchRule）：这是一个策略模式（Strategy Pattern）的典型应用场景。规则定义了解锁剧集的条件，例如：
- 免费（FREE）：无需任何条件即可观看。
- 会员专享（VIP_ONLY）：仅限VIP会员观看。
- 积分兑换（COIN_REQUIRED）：如标题中的“投币200转免”，即需要消耗200积分（或虚拟币）才能解锁观看。
- 任务解锁（TASK_REQUIRED）：完成指定任务（如分享、评论）后解锁。
- 用户（User）：系统的使用者，拥有积分余额、会员状态等属性。
- 用户观看记录（UserWatchRecord）：记录用户对某个剧集的解锁状态、解锁时间、消耗的积分等。这是实现“转免”（即一次付费，永久观看）的关键。
1.2 “投币200转免”规则详解
以标题中的规则为例，它包含了多层逻辑：
- 条件判断：用户观看前，系统需检查该剧集规则是否为
COIN_REQUIRED，且所需积分数为200。 - 资源检查：检查用户当前积分余额是否大于等于200。
- 状态验证：检查用户是否已经通过本规则或其他途径（如已购买）解锁了该剧集。如果
UserWatchRecord中已有有效记录，则直接允许观看，无需再次扣费。 - 事务操作：若需解锁，则在一个数据库事务中完成：扣除用户200积分，并创建一条
UserWatchRecord记录，记录解锁方式为“积分兑换”。 - 状态同步：此后，该用户对此剧集的任何访问，都将直接通过查询
UserWatchRecord表来授权，实现“转免”。
1.3 系统架构概览
我们将采用经典的三层架构：
- 控制层（Controller）：接收HTTP请求，进行参数校验，返回统一格式的响应。
- 服务层（Service）：封装核心业务逻辑，如规则验证、积分扣减、观看记录生成。
- 数据访问层（Repository/Mapper）：基于Spring Data JPA或MyBatis-Plus与数据库交互。
- 实体层（Entity）：定义与数据库表映射的Java对象。
此外，我们会引入规则引擎的设计思想，将每种观看规则抽象为一个独立的处理器（Handler），便于未来扩展新的规则类型。
2. 开发环境与项目初始化
2.1 环境与工具准备
- JDK: 版本 11 或 17（推荐17，本文示例基于17）
- 构建工具: Maven 3.6+ 或 Gradle
- IDE: IntelliJ IDEA 或 Eclipse
- 数据库: MySQL 8.0（也可适配PostgreSQL等）
- 依赖管理: Spring Boot 2.7+ 或 3.x（本文示例基于Spring Boot 3.1.5）
2.2 创建Spring Boot项目
使用 Spring Initializr 或IDE的创建向导，生成一个基础项目，选择以下依赖：
- Spring Web(用于构建Web接口)
- Spring Data JPA(用于数据持久化，也可选MyBatis-Plus)
- MySQL Driver(数据库驱动)
- Lombok(简化实体类代码)
生成后的pom.xml核心依赖如下：
<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>com.mysql</groupId> <artifactId>mysql-connector-j</artifactId> <scope>runtime</scope> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies>2.3 数据库与基础配置
在src/main/resources/application.yml中配置数据库连接和应用端口：
server: port: 8080 spring: datasource: url: jdbc:mysql://localhost:3306/video_content_db?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai username: your_username password: your_password driver-class-name: com.mysql.cj.jdbc.Driver jpa: hibernate: ddl-auto: update # 开发环境可用update，生产环境建议使用validate或none，配合SQL脚本 show-sql: true properties: hibernate: format_sql: true在MySQL中创建数据库：
CREATE DATABASE IF NOT EXISTS video_content_db CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;3. 数据库设计与实体类实现
清晰的数据模型是业务逻辑的基石。我们根据1.1的分析来设计表结构。
3.1 实体类与JPA映射
1. 剧集实体（Episode）
// 文件路径：src/main/java/com/example/video/entity/Episode.java package com.example.video.entity; import jakarta.persistence.*; import lombok.Data; import java.time.LocalDateTime; @Entity @Table(name = "episode") @Data public class Episode { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(nullable = false) private String title; // 剧集标题，如“寒渊渡骨・晚香如梦 第10集” @Column(name = "series_id") private Long seriesId; // 所属系列ID @Column(name = "video_url") private String videoUrl; // 视频播放地址 @Enumerated(EnumType.STRING) @Column(name = "watch_rule_type", nullable = false) private WatchRuleType watchRuleType; // 观看规则类型 @Column(name = "rule_parameter") private String ruleParameter; // 规则参数，如积分数量“200”，JSON格式存储扩展参数 private Integer duration; // 时长（秒） private Integer sortOrder; // 集数排序 @Column(name = "is_online") private Boolean isOnline = true; // 是否上架 @Column(name = "created_at", updatable = false) private LocalDateTime createdAt; @Column(name = "updated_at") private LocalDateTime updatedAt; @PrePersist protected void onCreate() { createdAt = LocalDateTime.now(); updatedAt = LocalDateTime.now(); } @PreUpdate protected void onUpdate() { updatedAt = LocalDateTime.now(); } }2. 观看规则类型枚举（WatchRuleType）
// 文件路径：src/main/java/com/example/video/enums/WatchRuleType.java package com.example.video.enums; public enum WatchRuleType { FREE, // 免费 VIP_ONLY, // 会员专享 COIN_REQUIRED, // 积分兑换 TASK_REQUIRED // 任务解锁 // 未来可扩展更多类型，如：TIME_LIMITED（限时免费） }3. 用户实体（User）
// 文件路径：src/main/java/com/example/video/entity/User.java package com.example.video.entity; import jakarta.persistence.*; import lombok.Data; import java.time.LocalDateTime; @Entity @Table(name = "user") @Data public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(unique = true, nullable = false) private String username; private String nickname; private String avatar; @Column(name = "coin_balance") private Integer coinBalance = 0; // 积分余额 @Column(name = "is_vip") private Boolean isVip = false; // 是否是VIP @Column(name = "vip_expire_at") private LocalDateTime vipExpireAt; // VIP过期时间 @Column(name = "created_at", updatable = false) private LocalDateTime createdAt; @PrePersist protected void onCreate() { createdAt = LocalDateTime.now(); } }4. 用户观看记录实体（UserWatchRecord）
// 文件路径：src/main/java/com/example/video/entity/UserWatchRecord.java package com.example.video.entity; import jakarta.persistence.*; import lombok.Data; import java.time.LocalDateTime; @Entity @Table(name = "user_watch_record", uniqueConstraints = { @UniqueConstraint(columnNames = {"user_id", "episode_id"}) // 唯一约束，一个用户对一个剧集只有一条有效记录 }) @Data public class UserWatchRecord { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name = "user_id", nullable = false) private Long userId; @Column(name = "episode_id", nullable = false) private Long episodeId; @Enumerated(EnumType.STRING) @Column(name = "unlock_type", nullable = false) private WatchRuleType unlockType; // 通过何种方式解锁 @Column(name = "cost_coins") private Integer costCoins = 0; // 解锁消耗的积分 @Column(name = "is_valid") private Boolean isValid = true; // 记录是否有效（可用于实现退款后失效） @Column(name = "unlocked_at", nullable = false) private LocalDateTime unlockedAt; @PrePersist protected void onCreate() { unlockedAt = LocalDateTime.now(); } }3.2 表结构关系说明
episode表：存储剧集核心信息，watch_rule_type和rule_parameter共同定义了观看规则。user表：存储用户信息，重点是coin_balance和is_vip，它们是规则验证的基础。user_watch_record表：核心的“转免”实现表。通过(user_id, episode_id)的唯一约束，确保一个用户对一个剧集只保留一条最新的有效解锁记录。查询用户是否有权观看时，优先查此表。
4. 规则引擎与核心服务层实现
我们将观看规则的验证逻辑抽象成规则处理器，并使用简单工厂模式进行管理。
4.1 规则处理器接口
首先定义一个统一的处理器接口：
// 文件路径：src/main/java/com/example/video/service/rule/WatchRuleHandler.java package com.example.video.service.rule; import com.example.video.entity.Episode; import com.example.video.entity.User; /** * 观看规则处理器接口 */ public interface WatchRuleHandler { /** * 判断当前处理器是否支持处理此规则类型 */ boolean supports(WatchRuleType ruleType); /** * 验证用户是否有权观看 * @param user 用户 * @param episode 剧集 * @return 验证结果 */ ValidationResult validate(User user, Episode episode); /** * 执行解锁操作（如扣积分） * @param user 用户 * @param episode 剧集 * @return 执行结果，包含消耗的资源等信息 */ UnlockResult unlock(User user, Episode episode); } // 验证结果类 @Data class ValidationResult { private boolean passed; // 是否通过 private String message; // 未通过的原因 private boolean needUnlock; // 是否需要执行解锁操作（例如，有记录则直接通过且无需解锁） } // 解锁结果类 @Data class UnlockResult { private boolean success; private String message; private Integer coinsCost; // 消耗的积分 }4.2 具体规则处理器实现
以“积分兑换”规则为例：
// 文件路径：src/main/java/com/example/video/service/rule/impl/CoinRequiredRuleHandler.java package com.example.video.service.rule.impl; import com.example.video.entity.Episode; import com.example.video.entity.User; import com.example.video.entity.UserWatchRecord; import com.example.video.enums.WatchRuleType; import com.example.video.repository.UserWatchRecordRepository; import com.example.video.service.rule.UnlockResult; import com.example.video.service.rule.ValidationResult; import com.example.video.service.rule.WatchRuleHandler; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Component; import org.springframework.transaction.annotation.Transactional; import java.util.Optional; @Component @RequiredArgsConstructor @Slf4j public class CoinRequiredRuleHandler implements WatchRuleHandler { private final UserWatchRecordRepository recordRepository; @Override public boolean supports(WatchRuleType ruleType) { return WatchRuleType.COIN_REQUIRED.equals(ruleType); } @Override public ValidationResult validate(User user, Episode episode) { ValidationResult result = new ValidationResult(); // 1. 检查是否已有有效观看记录（“转免”核心） Optional<UserWatchRecord> existingRecord = recordRepository .findByUserIdAndEpisodeIdAndIsValidTrue(user.getId(), episode.getId()); if (existingRecord.isPresent()) { result.setPassed(true); result.setNeedUnlock(false); // 已有记录，无需再次解锁 result.setMessage("您已解锁本剧集，可免费观看"); return result; } // 2. 解析规则参数（所需积分） int requiredCoins; try { requiredCoins = Integer.parseInt(episode.getRuleParameter()); } catch (NumberFormatException e) { log.error("剧集 {} 的积分规则参数解析失败: {}", episode.getId(), episode.getRuleParameter()); result.setPassed(false); result.setMessage("观看规则配置错误"); return result; } // 3. 检查用户积分是否足够 if (user.getCoinBalance() < requiredCoins) { result.setPassed(false); result.setNeedUnlock(true); // 需要解锁，但条件不满足 result.setMessage(String.format("观看需要 %d 积分，您的积分不足", requiredCoins)); return result; } // 4. 积分足够，可以解锁 result.setPassed(true); result.setNeedUnlock(true); result.setMessage(String.format("可消耗 %d 积分解锁观看", requiredCoins)); return result; } @Override @Transactional(rollbackFor = Exception.class) public UnlockResult unlock(User user, Episode episode) { UnlockResult result = new UnlockResult(); // 再次验证（防止并发问题） ValidationResult validationResult = this.validate(user, episode); if (!validationResult.isPassed() || !validationResult.isNeedUnlock()) { result.setSuccess(false); result.setMessage(validationResult.getMessage()); return result; } int requiredCoins = Integer.parseInt(episode.getRuleParameter()); // 扣减用户积分 user.setCoinBalance(user.getCoinBalance() - requiredCoins); // 注意：此处user需要被持久化，通常由调用方（如UserService）在事务中统一保存 // 创建观看记录 UserWatchRecord record = new UserWatchRecord(); record.setUserId(user.getId()); record.setEpisodeId(episode.getId()); record.setUnlockType(WatchRuleType.COIN_REQUIRED); record.setCostCoins(requiredCoins); recordRepository.save(record); result.setSuccess(true); result.setMessage("解锁成功"); result.setCoinsCost(requiredCoins); log.info("用户 {} 消耗 {} 积分解锁剧集 {}", user.getId(), requiredCoins, episode.getId()); return result; } }其他规则处理器（如VipOnlyRuleHandler,FreeRuleHandler）结构类似，实现各自的validate和unlock逻辑。FreeRuleHandler的validate始终返回通过且无需解锁。
4.3 规则处理器工厂
工厂负责根据剧集规则类型，返回对应的处理器。
// 文件路径：src/main/java/com/example/video/service/rule/WatchRuleHandlerFactory.java package com.example.video.service.rule; import com.example.video.enums.WatchRuleType; import lombok.RequiredArgsConstructor; import org.springframework.stereotype.Component; import java.util.List; @Component @RequiredArgsConstructor public class WatchRuleHandlerFactory { private final List<WatchRuleHandler> handlers; // Spring会自动注入所有实现WatchRuleHandler的Bean public WatchRuleHandler getHandler(WatchRuleType ruleType) { return handlers.stream() .filter(handler -> handler.supports(ruleType)) .findFirst() .orElseThrow(() -> new IllegalArgumentException("不支持的观看规则类型: " + ruleType)); } }4.4 核心剧集服务
服务层整合规则引擎，提供完整的剧集观看业务流程。
// 文件路径：src/main/java/com/example/video/service/EpisodeService.java package com.example.video.service; import com.example.video.entity.Episode; import com.example.video.entity.User; import com.example.video.enums.WatchRuleType; import com.example.video.repository.EpisodeRepository; import com.example.video.service.rule.UnlockResult; import com.example.video.service.rule.ValidationResult; import com.example.video.service.rule.WatchRuleHandler; import com.example.video.service.rule.WatchRuleHandlerFactory; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @Service @RequiredArgsConstructor @Slf4j public class EpisodeService { private final EpisodeRepository episodeRepository; private final UserService userService; // 假设有一个UserService用于操作用户数据 private final WatchRuleHandlerFactory ruleHandlerFactory; /** * 获取剧集播放权限状态 * @param episodeId 剧集ID * @param userId 用户ID * @return 是否可播放及原因 */ public WatchStatus getWatchStatus(Long episodeId, Long userId) { Episode episode = episodeRepository.findById(episodeId) .orElseThrow(() -> new RuntimeException("剧集不存在")); User user = userService.getUserById(userId); WatchRuleHandler handler = ruleHandlerFactory.getHandler(episode.getWatchRuleType()); ValidationResult validationResult = handler.validate(user, episode); WatchStatus status = new WatchStatus(); status.setCanWatch(validationResult.isPassed() && !validationResult.isNeedUnlock()); status.setMessage(validationResult.getMessage()); status.setNeedUnlock(validationResult.isNeedUnlock()); status.setEpisodeTitle(episode.getTitle()); // 可以附加更多信息，如所需积分数量 return status; } /** * 解锁剧集（例如，用户点击“投币观看”） * @param episodeId 剧集ID * @param userId 用户ID * @return 解锁结果 */ @Transactional(rollbackFor = Exception.class) public UnlockResult unlockEpisode(Long episodeId, Long userId) { Episode episode = episodeRepository.findById(episodeId) .orElseThrow(() -> new RuntimeException("剧集不存在")); User user = userService.getUserById(userId); // 获取可持久化的User实体 WatchRuleHandler handler = ruleHandlerFactory.getHandler(episode.getWatchRuleType()); UnlockResult unlockResult = handler.unlock(user, episode); if (unlockResult.isSuccess()) { // 如果解锁过程中修改了user（如扣积分），需要保存 userService.saveUser(user); } return unlockResult; } // 内部状态类，用于接口返回 @Data public static class WatchStatus { private boolean canWatch; private String message; private boolean needUnlock; private String episodeTitle; } }5. 控制层接口与统一响应
提供RESTful API供前端调用。
5.1 统一响应封装
// 文件路径：src/main/java/com/example/video/vo/ApiResponse.java package com.example.video.vo; import lombok.Data; @Data public class ApiResponse<T> { private Integer code; private String message; private T data; public static <T> ApiResponse<T> success(T data) { ApiResponse<T> response = new ApiResponse<>(); response.setCode(200); response.setMessage("success"); response.setData(data); return response; } public static <T> ApiResponse<T> error(Integer code, String message) { ApiResponse<T> response = new ApiResponse<>(); response.setCode(code); response.setMessage(message); return response; } }5.2 剧集观看控制器
// 文件路径：src/main/java/com/example/video/controller/EpisodeController.java package com.example.video.controller; import com.example.video.service.EpisodeService; import com.example.video.service.rule.UnlockResult; import com.example.video.vo.ApiResponse; import lombok.RequiredArgsConstructor; import org.springframework.web.bind.annotation.*; @RestController @RequestMapping("/api/episode") @RequiredArgsConstructor public class EpisodeController { private final EpisodeService episodeService; /** * 检查剧集观看状态 * GET /api/episode/{episodeId}/watch-status?userId=123 */ @GetMapping("/{episodeId}/watch-status") public ApiResponse<?> getWatchStatus(@PathVariable Long episodeId, @RequestParam Long userId) { try { EpisodeService.WatchStatus status = episodeService.getWatchStatus(episodeId, userId); return ApiResponse.success(status); } catch (Exception e) { return ApiResponse.error(500, e.getMessage()); } } /** * 解锁剧集 * POST /api/episode/{episodeId}/unlock * 请求体: {"userId": 123} */ @PostMapping("/{episodeId}/unlock") public ApiResponse<?> unlockEpisode(@PathVariable Long episodeId, @RequestBody UnlockRequest request) { try { UnlockResult result = episodeService.unlockEpisode(episodeId, request.getUserId()); if (result.isSuccess()) { return ApiResponse.success(result); } else { return ApiResponse.error(400, result.getMessage()); } } catch (Exception e) { return ApiResponse.error(500, "解锁失败: " + e.getMessage()); } } // 解锁请求DTO @Data static class UnlockRequest { private Long userId; } }6. 系统测试与验证
6.1 数据准备与接口测试
插入测试数据：通过SQL或编写一个简单的初始化脚本，插入用户、剧集等数据。
-- 插入一个用户，拥有300积分 INSERT INTO `user` (username, nickname, coin_balance) VALUES ('test_user', '测试用户', 300); -- 插入一个剧集，规则为“积分兑换”，参数为200 INSERT INTO `episode` (title, series_id, watch_rule_type, rule_parameter) VALUES ('寒渊渡骨・晚香如梦 第10集', 1, 'COIN_REQUIRED', '200');测试流程：
- 步骤一：查询观看状态。调用
GET /api/episode/1/watch-status?userId=1。预期返回：canWatch: false, needUnlock: true, message: “可消耗 200 积分解锁观看”。 - 步骤二：执行解锁。调用
POST /api/episode/1/unlock，Body为{"userId": 1}。预期返回成功，并提示消耗200积分。 - 步骤三：再次查询观看状态。调用相同的状态查询接口。预期返回：
canWatch: true, needUnlock: false, message: “您已解锁本剧集，可免费观看”。同时检查数据库，用户积分应变为100，user_watch_record表应新增一条记录。
- 步骤一：查询观看状态。调用
6.2 核心逻辑验证点
- “转免”逻辑：首次解锁后，再次查询状态应直接通过，且不会触发二次扣费。
- 积分不足：将用户积分改为100，再次尝试解锁，应返回失败信息。
- 并发安全：考虑在
unlock方法中，对“查询-校验-扣款”流程加锁或使用乐观锁，防止超额扣款。 - 规则扩展：新增一个
TASK_REQUIRED规则，实现TaskRequiredRuleHandler，并在工厂中注册。验证系统是否能无缝接入新规则。
7. 常见问题与排查思路
在实际开发和部署中，你可能会遇到以下问题：
| 问题现象 | 可能原因 | 排查步骤与解决方案 |
|---|---|---|
| 接口返回“不支持的观看规则类型” | 1. 数据库中的watch_rule_type字段值不在枚举WatchRuleType中。2. 新增了规则类型，但未实现对应的 WatchRuleHandler。 | 1. 检查数据库数据一致性。 2. 确保每个枚举值都有对应的、被Spring管理的 @Component处理器。 |
| 解锁成功但用户积分未扣减 | 1. 在unlock方法中修改了User实体，但未调用userRepository.save()。2. 事务未生效或异常被捕获未回滚。 | 1. 确保在事务方法中，实体状态变更被持久化。 2. 检查 @Transactional注解是否生效，确保异常被抛出以触发回滚。 |
| 用户已解锁仍被要求再次解锁 | user_watch_record表查询逻辑有误，或is_valid字段状态不对。 | 1. 检查UserWatchRecordRepository中findByUserIdAndEpisodeIdAndIsValidTrue方法是否正确。2. 调试验证阶段，查看 validate方法中查询到的记录。 |
| 高并发下积分被多次扣除 | 存在并发漏洞，多个请求同时通过积分校验。 | 1.悲观锁：在unlock方法查询用户时使用SELECT ... FOR UPDATE。2.乐观锁：为 User实体增加version字段，使用@Version注解。3.分布式锁：在集群环境下，使用Redis等实现分布式锁，锁住 用户+剧集这个资源。 |
| 规则参数解析错误（如NumberFormatException） | 1.rule_parameter字段为空或格式非数字。2. 规则处理器未对参数做健壮性校验。 | 1. 在Episode实体创建或更新时加强参数校验。2. 在处理器 validate方法中，对参数进行更完善的异常处理，并返回友好的错误信息。 |
8. 最佳实践与进阶优化建议
一个基础系统搭建完成后，可以考虑以下方向进行深化和优化，使其更健壮、易用。
8.1 工程结构优化
- DTO与VO分离：控制器接收
RequestDTO，返回ResponseVO，与实体（Entity）解耦，避免暴露数据库细节和循环依赖。 - 统一异常处理：使用
@ControllerAdvice或@RestControllerAdvice创建全局异常处理器，将业务异常（如积分不足、剧集不存在）转换为友好的API错误码和消息，而不是直接抛出RuntimeException。 - 参数校验：在DTO上使用
javax.validation或Jakarta Validation注解（如@NotNull,@Min）进行声明式校验。
8.2 业务逻辑增强
- 规则参数复杂化：当前
rule_parameter是字符串，对于复杂规则（如“前5分钟免费，后部分需VIP”）支撑不足。可将其改为JSON格式，存储结构化数据，并在处理器中解析。 - 组合规则：实现“或”、“与”等逻辑组合。例如，“VIP或积分大于300可看”。可以设计一个
CompositeRuleHandler，内部管理多个子规则处理器。 - 观看记录过期：为
UserWatchRecord增加expire_at字段，实现限时观看。在validate时增加有效期判断。 - 异步任务与消息队列：解锁成功后，可以发送MQ消息，用于触发积分变更通知、用户行为分析等下游业务，提升主流程响应速度。
8.3 性能与安全
- 缓存策略：
- 用户积分、VIP状态等变更频率较低的数据，可放入Redis缓存，减少数据库查询。
- 用户对剧集的解锁状态（
canWatch）是高频查询，且一旦解锁很少变化，非常适合缓存。缓存Key可为user:watch:${userId}:${episodeId}，设置一个较长的过期时间。
- 防刷与限流：
- 在解锁接口上增加限流（如使用Guava RateLimiter或Spring Cloud Gateway），防止恶意刷接口消耗积分。
- 对关键业务操作（如扣积分）进行日志审计，便于事后追溯。
- 数据一致性：涉及积分扣减和记录创建，必须保证事务性。对于跨服务的分布式事务（如积分服务独立），需要考虑使用Seata或最终一致性方案（如本地消息表）。
8.4 监控与运维
- 关键指标埋点：记录不同规则类型的解锁次数、成功率、平均耗时。监控积分消耗总量。
- 告警设置：当积分扣除失败率异常升高，或某个剧集解锁请求量激增时，触发告警。
- 配置化管理：将积分兑换比率、VIP权益等可能变化的参数，抽取到配置中心（如Apollo、Nacos），实现动态刷新，避免重启服务。
通过以上步骤，我们不仅实现了一个支持“投币200转免”的剧集观看系统，更构建了一个高度可扩展的规则引擎框架。后续新增任何观看规则，都只需实现对应的WatchRuleHandler并在工厂中注册即可，业务服务EpisodeService的代码无需修改，这很好地符合了开闭原则（OCP）。这套设计思路可以广泛应用于需要复杂策略判断的业务场景，如优惠券系统、权限管理系统、风控系统等。
