SpringBoot+Vue小说阅读平台毕业设计实战指南

1. 项目概述

作为一名有10年Java开发经验的程序员，我经常被问到如何选择一个合适的毕业设计项目。基于SpringBoot的小说阅读平台是一个非常适合计算机专业学生作为毕业设计的选题。这个项目不仅涵盖了Web开发的完整技术栈，还包含了丰富的业务逻辑，能够全面展示学生的技术能力。

小说阅读平台本质上是一个内容管理系统(CMS)，它需要处理用户注册登录、小说分类管理、章节内容展示、阅读记录跟踪等核心功能。选择这个项目作为毕设有几个明显优势：

1. 技术栈主流且完整：SpringBoot+Vue+MySQL的组合是目前企业开发中最常用的技术方案
2. 业务逻辑清晰但又不失复杂度：既有CRUD操作，也有阅读进度跟踪等特色功能
3. 可扩展性强：可以轻松添加推荐系统、评论互动等高级功能
4. 参考资料丰富：网上有大量类似项目的实现思路和解决方案

这个项目特别适合已经掌握Java基础和Web开发基础的同学。如果你对Spring框架有一定了解，但还没有完整的项目经验，这个项目能帮助你快速提升实战能力。

2. 系统架构设计

2.1 技术选型分析

在开始编码前，我们需要对技术栈做出合理的选择。经过对各种技术方案的比较，我最终确定了以下技术组合：

后端技术栈：

• Spring Boot 2.7.x：简化Spring应用的初始搭建和开发过程
• MyBatis-Plus 3.5.x：增强型ORM框架，简化数据库操作
• Shiro 1.10.x：负责认证和授权管理
• Lombok：通过注解减少样板代码
• Swagger：API文档生成工具

前端技术栈：

• Vue 3.x：渐进式JavaScript框架
• Element Plus：基于Vue 3的组件库
• Axios：HTTP客户端
• Vue Router：路由管理

数据库：

• MySQL 8.0：关系型数据库
• Redis：缓存用户会话和热门内容

这个技术组合的选择主要基于以下几点考虑：

1. 成熟稳定：所有技术都有广泛的社区支持和长期维护
2. 学习曲线平缓：每个技术都有丰富的学习资源
3. 性能良好：能够支撑中小规模的用户访问
4. 扩展性强：方便后续添加新功能

2.2 系统架构模式

系统采用经典的三层架构，分为表示层、业务逻辑层和数据访问层：

1. 表示层：使用Vue构建的用户界面，通过RESTful API与后端交互
2. 业务逻辑层：Spring Boot应用，处理核心业务逻辑
3. 数据访问层：MyBatis-Plus操作MySQL数据库

这种分层架构的优势在于：

• 职责分离：各层专注于自己的功能
• 可维护性高：修改某一层不会直接影响其他层
• 可测试性强：可以单独测试每一层的功能

2.3 数据库设计

数据库设计遵循第三范式，主要包含以下核心表：

1. 用户表(user)：存储用户基本信息

   sql复制CREATE TABLE `user` (
     `id` bigint NOT NULL AUTO_INCREMENT,
     `username` varchar(50) NOT NULL COMMENT '用户名',
     `password` varchar(100) NOT NULL COMMENT '密码',
     `nickname` varchar(50) DEFAULT NULL COMMENT '昵称',
     `avatar` varchar(255) DEFAULT NULL COMMENT '头像',
     `email` varchar(100) DEFAULT NULL COMMENT '邮箱',
     `phone` varchar(20) DEFAULT NULL COMMENT '手机号',
     `status` tinyint DEFAULT '1' COMMENT '状态：0-禁用，1-正常',
     `create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
     `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
     PRIMARY KEY (`id`),
     UNIQUE KEY `idx_username` (`username`)
   ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';
   

2. 小说表(novel)：存储小说基本信息

   sql复制CREATE TABLE `novel` (
     `id` bigint NOT NULL AUTO_INCREMENT,
     `title` varchar(100) NOT NULL COMMENT '小说标题',
     `author` varchar(50) NOT NULL COMMENT '作者',
     `cover` varchar(255) DEFAULT NULL COMMENT '封面图',
     `description` text COMMENT '简介',
     `category_id` bigint DEFAULT NULL COMMENT '分类ID',
     `word_count` int DEFAULT '0' COMMENT '字数',
     `status` tinyint DEFAULT '0' COMMENT '状态：0-连载中，1-已完结',
     `create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
     `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
     PRIMARY KEY (`id`),
     KEY `idx_category` (`category_id`)
   ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='小说表';
   

3. 章节表(chapter)：存储小说章节内容

   sql复制CREATE TABLE `chapter` (
     `id` bigint NOT NULL AUTO_INCREMENT,
     `novel_id` bigint NOT NULL COMMENT '小说ID',
     `title` varchar(100) NOT NULL COMMENT '章节标题',
     `content` longtext COMMENT '章节内容',
     `word_count` int DEFAULT '0' COMMENT '字数',
     `chapter_order` int DEFAULT '0' COMMENT '章节顺序',
     `create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
     `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
     PRIMARY KEY (`id`),
     KEY `idx_novel` (`novel_id`)
   ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='章节表';
   

4. 阅读记录表(reading_history)：记录用户阅读进度

   sql复制CREATE TABLE `reading_history` (
     `id` bigint NOT NULL AUTO_INCREMENT,
     `user_id` bigint NOT NULL COMMENT '用户ID',
     `novel_id` bigint NOT NULL COMMENT '小说ID',
     `chapter_id` bigint NOT NULL COMMENT '章节ID',
     `progress` int DEFAULT '0' COMMENT '阅读进度(百分比)',
     `last_read_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '最后阅读时间',
     PRIMARY KEY (`id`),
     UNIQUE KEY `idx_user_novel` (`user_id`,`novel_id`)
   ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='阅读记录表';
   

数据库设计时特别注意了以下几点：

1. 合理设置索引提高查询效率
2. 为字段添加注释便于维护
3. 使用utf8mb4字符集支持完整的Unicode字符
4. 添加create_time和update_time字段便于追踪数据变化

3. 核心功能实现

3.1 用户认证模块

用户认证是系统的门户，我们采用Shiro框架实现安全的认证和授权机制。下面是核心实现代码：

1. Shiro配置类

java复制@Configuration
public class ShiroConfig {
    
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager securityManager) {
        ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
        factoryBean.setSecurityManager(securityManager);
        
        // 设置登录页面
        factoryBean.setLoginUrl("/login");
        // 设置未授权页面
        factoryBean.setUnauthorizedUrl("/unauthorized");
        
        // 定义过滤器链
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        filterChainDefinitionMap.put("/static/**", "anon");
        filterChainDefinitionMap.put("/login", "anon");
        filterChainDefinitionMap.put("/register", "anon");
        filterChainDefinitionMap.put("/**", "authc");
        
        factoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return factoryBean;
    }
    
    @Bean
    public DefaultWebSecurityManager securityManager(Realm realm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(realm);
        return securityManager;
    }
    
    @Bean
    public Realm realm() {
        return new CustomRealm();
    }
}

2. 自定义Realm

java复制public class CustomRealm extends AuthorizingRealm {
    
    @Autowired
    private UserService userService;
    
    // 授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        String username = (String) principals.getPrimaryPrincipal();
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        // 这里可以添加角色和权限
        return authorizationInfo;
    }
    
    // 认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        String username = (String) token.getPrincipal();
        User user = userService.findByUsername(username);
        
        if (user == null) {
            throw new UnknownAccountException("用户不存在");
        }
        
        if (user.getStatus() == 0) {
            throw new LockedAccountException("账号已被禁用");
        }
        
        return new SimpleAuthenticationInfo(
            user.getUsername(),
            user.getPassword(),
            ByteSource.Util.bytes(user.getSalt()),
            getName()
        );
    }
}

3. 用户注册逻辑

java复制@Service
public class UserServiceImpl implements UserService {
    
    @Autowired
    private UserMapper userMapper;
    
    @Override
    public void register(UserRegisterDTO dto) {
        // 检查用户名是否已存在
        if (userMapper.existsByUsername(dto.getUsername())) {
            throw new BusinessException("用户名已存在");
        }
        
        // 生成随机盐
        String salt = UUID.randomUUID().toString().replaceAll("-", "").substring(0, 20);
        
        // 加密密码
        String encryptedPassword = new SimpleHash(
            "MD5",
            dto.getPassword(),
            ByteSource.Util.bytes(salt),
            2
        ).toHex();
        
        // 创建用户
        User user = new User();
        user.setUsername(dto.getUsername());
        user.setPassword(encryptedPassword);
        user.setSalt(salt);
        user.setNickname(dto.getNickname());
        user.setEmail(dto.getEmail());
        user.setStatus(1);
        
        userMapper.insert(user);
    }
}

在实现用户认证模块时，有几个关键点需要注意：

1. 密码必须加盐哈希存储，绝对不能明文保存
2. 注册时要检查用户名唯一性
3. 登录失败要有友好的错误提示但不泄露系统信息
4. 会话管理要合理设置超时时间

3.2 小说管理模块

小说管理模块主要包括小说的CRUD操作和章节管理。下面是核心实现：

1. 小说分页查询

java复制@RestController
@RequestMapping("/api/novel")
public class NovelController {
    
    @Autowired
    private NovelService novelService;
    
    @GetMapping
    public PageResult<NovelVO> list(
        @RequestParam(defaultValue = "1") Integer page,
        @RequestParam(defaultValue = "10") Integer size,
        @RequestParam(required = false) String keyword,
        @RequestParam(required = false) Long categoryId
    ) {
        QueryWrapper<Novel> wrapper = new QueryWrapper<>();
        
        if (StringUtils.isNotBlank(keyword)) {
            wrapper.like("title", keyword).or().like("author", keyword);
        }
        
        if (categoryId != null) {
            wrapper.eq("category_id", categoryId);
        }
        
        wrapper.orderByDesc("update_time");
        
        IPage<Novel> novelPage = novelService.page(new Page<>(page, size), wrapper);
        
        List<NovelVO> novelVOs = novelPage.getRecords().stream()
            .map(this::convertToVO)
            .collect(Collectors.toList());
            
        return new PageResult<>(
            novelVOs,
            novelPage.getTotal(),
            novelPage.getSize(),
            novelPage.getCurrent()
        );
    }
    
    private NovelVO convertToVO(Novel novel) {
        NovelVO vo = new NovelVO();
        BeanUtils.copyProperties(novel, vo);
        // 补充其他字段
        return vo;
    }
}

2. 章节添加与更新

java复制@Service
public class ChapterServiceImpl implements ChapterService {
    
    @Autowired
    private ChapterMapper chapterMapper;
    
    @Autowired
    private NovelMapper novelMapper;
    
    @Transactional
    @Override
    public void saveChapter(ChapterDTO dto) {
        Chapter chapter;
        
        if (dto.getId() != null) {
            // 更新章节
            chapter = chapterMapper.selectById(dto.getId());
            if (chapter == null) {
                throw new BusinessException("章节不存在");
            }
            
            chapter.setTitle(dto.getTitle());
            chapter.setContent(dto.getContent());
            chapterMapper.updateById(chapter);
        } else {
            // 新增章节
            chapter = new Chapter();
            chapter.setNovelId(dto.getNovelId());
            chapter.setTitle(dto.getTitle());
            chapter.setContent(dto.getContent());
            chapter.setChapterOrder(getNextChapterOrder(dto.getNovelId()));
            chapterMapper.insert(chapter);
            
            // 更新小说字数统计
            updateNovelWordCount(dto.getNovelId());
        }
    }
    
    private int getNextChapterOrder(Long novelId) {
        Integer maxOrder = chapterMapper.selectMaxChapterOrder(novelId);
        return maxOrder == null ? 1 : maxOrder + 1;
    }
    
    private void updateNovelWordCount(Long novelId) {
        Integer totalWords = chapterMapper.selectSumWordCount(novelId);
        Novel novel = new Novel();
        novel.setId(novelId);
        novel.setWordCount(totalWords);
        novelMapper.updateById(novel);
    }
}

在实现小说管理模块时，有几个经验值得分享：

1. 分页查询要处理好排序和筛选条件
2. 章节顺序要自动管理，避免手动设置出错
3. 小说字数要实时统计更新
4. 内容字段使用longtext类型以适应大文本存储
5. 事务管理要合理，确保数据一致性

4. 阅读功能实现

4.1 章节阅读接口

阅读功能是系统的核心，需要处理好以下几个关键点：

1. 章节内容的分页加载
2. 阅读进度的记录
3. 上一章/下一章的导航

下面是核心实现代码：

java复制@RestController
@RequestMapping("/api/read")
public class ReadController {
    
    @Autowired
    private ChapterService chapterService;
    
    @Autowired
    private ReadingHistoryService readingHistoryService;
    
    @GetMapping("/chapter/{chapterId}")
    public Result<ChapterReadVO> readChapter(
        @PathVariable Long chapterId,
        @RequestParam(defaultValue = "0") int page,
        @RequestParam(defaultValue = "2000") int size
    ) {
        // 获取章节信息
        Chapter chapter = chapterService.getById(chapterId);
        if (chapter == null) {
            throw new BusinessException("章节不存在");
        }
        
        // 分页处理内容
        String content = chapter.getContent();
        int totalPages = (int) Math.ceil((double) content.length() / size);
        page = Math.min(page, totalPages - 1);
        int start = page * size;
        int end = Math.min(start + size, content.length());
        String pageContent = content.substring(start, end);
        
        // 获取相邻章节
        Chapter prevChapter = chapterService.getPrevChapter(chapterId, chapter.getNovelId());
        Chapter nextChapter = chapterService.getNextChapter(chapterId, chapter.getNovelId());
        
        // 记录阅读进度
        Long userId = SecurityUtils.getCurrentUserId();
        if (userId != null) {
            readingHistoryService.recordReadingProgress(
                userId, 
                chapter.getNovelId(), 
                chapterId,
                (int) ((double) start / content.length() * 100)
            );
        }
        
        // 构建返回对象
        ChapterReadVO vo = new ChapterReadVO();
        vo.setChapterId(chapterId);
        vo.setTitle(chapter.getTitle());
        vo.setContent(pageContent);
        vo.setCurrentPage(page);
        vo.setTotalPages(totalPages);
        vo.setPrevChapterId(prevChapter != null ? prevChapter.getId() : null);
        vo.setNextChapterId(nextChapter != null ? nextChapter.getId() : null);
        
        return Result.success(vo);
    }
}

4.2 阅读进度记录

阅读进度记录需要考虑并发更新问题，下面是优化后的实现：

java复制@Service
public class ReadingHistoryServiceImpl implements ReadingHistoryService {
    
    @Autowired
    private ReadingHistoryMapper readingHistoryMapper;
    
    @Override
    public void recordReadingProgress(Long userId, Long novelId, Long chapterId, int progress) {
        // 使用MySQL的ON DUPLICATE KEY UPDATE处理并发
        readingHistoryMapper.insertOrUpdateProgress(
            userId,
            novelId,
            chapterId,
            progress,
            new Date()
        );
    }
}

// Mapper中的SQL
@Insert({
    "INSERT INTO reading_history(user_id, novel_id, chapter_id, progress, last_read_time) ",
    "VALUES(#{userId}, #{novelId}, #{chapterId}, #{progress}, #{lastReadTime}) ",
    "ON DUPLICATE KEY UPDATE ",
    "chapter_id = VALUES(chapter_id), ",
    "progress = VALUES(progress), ",
    "last_read_time = VALUES(last_read_time)"
})
void insertOrUpdateProgress(
    @Param("userId") Long userId,
    @Param("novelId") Long novelId,
    @Param("chapterId") Long chapterId,
    @Param("progress") int progress,
    @Param("lastReadTime") Date lastReadTime
);

4.3 阅读界面实现

前端阅读界面使用Vue实现，核心代码如下：

vue复制<template>
  <div class="reader-container">
    <div class="reader-header">
      <h2>{{ chapter.title }}</h2>
      <div class="chapter-nav">
        <button 
          @click="goToChapter(prevChapterId)" 
          :disabled="!prevChapterId"
        >
          上一章
        </button>
        <span>第 {{ currentPage + 1 }} 页/共 {{ totalPages }} 页</span>
        <button 
          @click="goToChapter(nextChapterId)" 
          :disabled="!nextChapterId"
        >
          下一章
        </button>
      </div>
    </div>
    
    <div class="reader-content" ref="content">
      {{ chapter.content }}
    </div>
    
    <div class="reader-footer">
      <input 
        type="range" 
        v-model="currentPage" 
        :max="totalPages - 1" 
        @change="loadPage"
      >
    </div>
  </div>
</template>

<script>
import { getChapter } from '@/api/read';

export default {
  data() {
    return {
      chapterId: null,
      chapter: {
        title: '',
        content: ''
      },
      currentPage: 0,
      totalPages: 1,
      prevChapterId: null,
      nextChapterId: null
    };
  },
  methods: {
    async loadChapter(chapterId, page = 0) {
      try {
        const res = await getChapter(chapterId, page);
        this.chapterId = chapterId;
        this.chapter.title = res.data.title;
        this.chapter.content = res.data.content;
        this.currentPage = res.data.currentPage;
        this.totalPages = res.data.totalPages;
        this.prevChapterId = res.data.prevChapterId;
        this.nextChapterId = res.data.nextChapterId;
        
        // 滚动到顶部
        this.$refs.content.scrollTop = 0;
      } catch (error) {
        console.error(error);
      }
    },
    loadPage() {
      this.loadChapter(this.chapterId, this.currentPage);
    },
    goToChapter(chapterId) {
      if (chapterId) {
        this.$router.push({
          path: `/read/${chapterId}`
        });
      }
    }
  },
  created() {
    this.chapterId = this.$route.params.chapterId;
    this.loadChapter(this.chapterId);
  },
  watch: {
    '$route.params.chapterId'(newVal) {
      this.loadChapter(newVal);
    }
  }
};
</script>

在实现阅读功能时，有几个实用技巧：

1. 内容分页可以减轻服务器压力，提升用户体验
2. 使用CSS media query实现响应式布局，适配不同设备
3. 阅读进度记录要考虑性能，避免频繁更新
4. 章节导航要处理好边界情况（第一章和最后一章）
5. 可以使用localStorage缓存已读章节内容

5. 系统部署与优化

5.1 项目打包部署

SpringBoot项目打包部署非常简单，以下是标准流程：

1. 打包应用

bash复制mvn clean package -DskipTests

2. 部署到服务器

bash复制# 上传jar包到服务器
scp target/novel-platform-1.0.0.jar user@server:/path/to/app

# 启动应用
nohup java -jar novel-platform-1.0.0.jar --spring.profiles.active=prod > app.log 2>&1 &

3. 配置Nginx反向代理

nginx复制server {
    listen 80;
    server_name yourdomain.com;
    
    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
    
    location /static/ {
        alias /path/to/static/files/;
        expires 30d;
    }
}

5.2 性能优化建议

1. 数据库优化

   • 为常用查询字段添加索引
   • 合理设计表结构，避免过度规范化
   • 使用连接池控制数据库连接数

2. 缓存策略

   • 使用Redis缓存热门小说和章节内容
   • 实现多级缓存：本地缓存+分布式缓存
   • 合理设置缓存过期时间

3. 前端优化

   • 使用CDN分发静态资源
   • 实现懒加载和分页
   • 压缩JavaScript和CSS文件

4. JVM调优

   • 根据服务器配置调整堆内存大小
   • 选择合适的垃圾收集器
   • 启用JVM性能监控

5.3 监控与日志

完善的监控和日志系统对生产环境至关重要：

1. Spring Boot Actuator

xml复制<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

2. Prometheus + Grafana监控

yaml复制management:
  endpoints:
    web:
      exposure:
        include: "*"
  metrics:
    export:
      prometheus:
        enabled: true

3. 日志配置

xml复制<dependency>
    <groupId>net.logstash.logback</groupId>
    <artifactId>logstash-logback-encoder</artifactId>
    <version>6.6</version>
</dependency>

xml复制<!-- logback-spring.xml -->
<configuration>
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/application.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>logs/application.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>30</maxHistory>
        </rollingPolicy>
        <encoder class="net.logstash.logback.encoder.LogstashEncoder"/>
    </appender>
    
    <root level="INFO">
        <appender-ref ref="FILE"/>
    </root>
</configuration>

6. 常见问题与解决方案

在实际开发过程中，我遇到了不少问题，以下是几个典型问题及其解决方案：

6.1 分页查询性能问题

问题描述：当小说数量达到10万级别时，分页查询变慢，特别是跳转到靠后的页码时。

解决方案：

1. 使用基于游标的分页代替传统的LIMIT offset, size
2. 添加合适的索引
3. 实现优化后的分页SQL：

sql复制-- 传统分页（性能差）
SELECT * FROM novel ORDER BY id DESC LIMIT 100000, 20;

-- 优化后的分页（性能好）
SELECT * FROM novel WHERE id < ? ORDER BY id DESC LIMIT 20;

6.2 大文本内容处理

问题描述：某些章节内容非常大（超过1MB），直接加载影响性能。

解决方案：

1. 实现分段加载，前端每次只请求部分内容
2. 使用压缩算法减少传输体积
3. 对大文本内容单独存储，必要时使用文件存储

6.3 并发更新阅读进度

问题描述：多个设备同时更新阅读进度时可能出现覆盖问题。

解决方案：

1. 使用ON DUPLICATE KEY UPDATE语法
2. 添加乐观锁控制
3. 实现最终一致性，允许短暂的不一致

6.4 敏感词过滤

问题描述：用户上传的内容可能包含敏感词汇。

解决方案：

1. 使用DFA算法实现高效敏感词过滤
2. 定期更新敏感词库
3. 实现异步审核机制

java复制@Service
public class SensitiveWordFilter {
    
    private static final String SENSITIVE_WORDS = "敏感词1,敏感词2,敏感词3";
    private Set<String> sensitiveWords;
    private Map<String, String> sensitiveWordMap;
    
    @PostConstruct
    public void init() {
        sensitiveWords = Arrays.stream(SENSITIVE_WORDS.split(","))
            .collect(Collectors.toSet());
            
        sensitiveWordMap = new HashMap<>();
        for (String word : sensitiveWords) {
            sensitiveWordMap.put(word, "*".repeat(word.length()));
        }
    }
    
    public String filter(String text) {
        if (StringUtils.isBlank(text)) {
            return text;
        }
        
        String result = text;
        for (Map.Entry<String, String> entry : sensitiveWordMap.entrySet()) {
            result = result.replaceAll(entry.getKey(), entry.getValue());
        }
        
        return result;
    }
}

7. 项目扩展方向

完成基础功能后，可以考虑以下几个扩展方向提升项目价值：

7.1 推荐系统

1. 基于内容的推荐：根据用户阅读历史推荐相似小说
2. 协同过滤推荐：根据相似用户的喜好推荐小说
3. 热门推荐：展示全站或分类下的热门小说

7.2 社交功能

1. 评论系统：允许用户对小说发表评论
2. 书友圈：建立读者社区，分享阅读心得
3. 打赏功能：支持读者向作者打赏

7.3 作者后台

1. 写作工具：提供Markdown编辑器辅助创作
2. 数据统计：展示小说阅读量、订阅量等数据
3. 收入管理：管理稿费和打赏收入

7.4 移动端适配

1. PWA应用：实现渐进式Web应用，支持离线阅读
2. 响应式设计：优化移动端阅读体验
3. APP封装：使用WebView封装成原生APP

实现这些扩展功能时，建议采用模块化开发方式，逐步迭代完善系统。每个新功能都应该有明确的需求分析和设计文档，确保系统架构不会因为功能增加而变得混乱。