毕业设计实战：基于Spring Boot的在线BLOG网全栈开发

一、项目背景：数字化时代的个人内容分享革新

在互联网技术深度渗透生活的当下，信息传播方式发生了根本性变革。截至2024年，中国网络文学用户规模突破5亿，个人内容创作平台用户日均使用时长超90分钟，传统信息分享模式已难以满足用户“即时创作、高效传播、精准互动”的需求。

在此背景下，基于Spring Boot的在线BLOG网成为个人内容创作与分享的核心载体。系统采用B/S架构，通过数字化手段实现从博客创作、标签分类到互动交流的全流程服务。本毕业设计以用户内容分享需求为导向，构建“管理员统筹-用户创作”的双向协同机制，为个人内容生态建设提供了轻量化、易操作的技术解决方案，助力用户实现个人思想与经验的高效传播。

二、技术架构：在线BLOG网的全栈技术选型

项目以“稳定性、易用性、扩展性”为核心设计理念，选用业界成熟的Java Web技术栈，确保系统在功能实现与用户体验间达到平衡：

技术模块	具体工具/技术	核心作用
后端框架	Spring Boot 2.x	快速构建后端服务，简化配置，实现MVC分层架构
数据库	MySQL 8.0	存储用户信息、博客内容、标签分类、相册数据等核心数据
前端技术	JSP + Bootstrap + JavaScript	构建响应式界面，实现博客浏览、创作、互动等可视化操作
架构模式	B/S结构	支持跨设备访问，用户无需安装客户端，浏览器即可使用
开发工具	Eclipse + Navicat	Eclipse用于代码开发与调试，Navicat实现数据库可视化管理
服务器	Tomcat 9.0	部署Web应用，处理HTTP请求，支撑系统稳定运行
页面渲染	JSP动态页面技术	实现数据与页面的动态绑定，展示个性化博客内容

三、项目全流程：6步完成在线BLOG网开发

3.1 第一步：需求分析——明确平台核心价值

传统个人博客平台存在“管理繁琐、分类混乱、互动薄弱”三大痛点，本系统聚焦“便捷创作、清晰分类、高效互动”，核心需求分为功能性与非功能性两类：

3.1.1 功能性需求

1. 双角色权限体系

   • 管理员：首页数据概览、个人中心（信息维护、密码修改）、用户管理（增删改查）、博客标签管理（分类维护）、博客分类管理（类型配置）、博客管理（内容审核、状态控制）、图库相册管理（资源管控）、论坛管理（帖子审核）、系统管理（轮播图、新闻资讯配置）；
   • 用户：首页内容浏览、个人中心（信息修改、密码重置）、博客管理（创作、编辑、删除）、图库相册管理（相册创建、图片上传）、我的收藏（内容收藏、取消收藏）、论坛互动（发帖、评论）。

2. 核心内容功能

   • 博客创作服务：富文本编辑、标签关联、分类选择、图片插入；
   • 内容管理功能：博客草稿保存、已发布内容编辑、回收站恢复；
   • 互动交流功能：论坛发帖、评论回复、内容收藏；
   • 资源管理功能：相册创建、图片批量上传、资源预览。

3.1.2 非功能性需求

• 系统安全性：用户密码加密存储、权限校验（防止越权操作）、内容审核（过滤违规信息）；
• 数据稳定性：博客内容自动备份、数据库定期同步，避免数据丢失；
• 响应及时性：页面加载时间≤3秒，博客发布、编辑操作实时响应；
• 兼容性：支持Chrome、Firefox、Edge等主流浏览器，适配不同屏幕分辨率。

3.2 第二步：系统设计——构建整体架构

系统采用经典三层架构，实现“界面-逻辑-数据”的解耦，提升代码可维护性与扩展性：

3.2.1 系统总体架构

1. 表现层（Web层）

   • 用户界面：基于JSP+Bootstrap构建动态页面，包含首页、博客详情页、创作页、管理后台等；
   • 交互控制：通过JavaScript实现表单验证、异步请求（如实时保存草稿）、页面跳转逻辑。

2. 业务逻辑层（Service层）

   • 核心服务：用户服务（登录、注册、信息维护）、博客服务（创作、查询、审核）、标签服务（分类关联、数据统计）、相册服务（资源上传、预览）、论坛服务（帖子发布、评论管理）；
   • 规则控制：博客审核流程（提交→待审→通过/驳回）、用户权限校验（管理员/普通用户功能隔离）。

3. 数据访问层（DAO层）

   • 数据操作：通过JDBC或MyBatis实现数据库CRUD操作，封装SQL语句；
   • 事务管理：确保博客发布、相册上传等操作的数据一致性（如内容与标签关联保存）。

3.2.2 核心数据库设计

系统设计12张核心数据表，覆盖用户、内容、资源、互动全场景，关键表结构如下：

表名	核心字段	作用
allusers（管理员表）	id、username、pwd、cx（权限）	存储管理员账号信息，控制后台访问权限
yonghu（用户表）	id、addtime（注册时间）、yonghuming、mima、xingming、xingbie、shouji、zhaopian	存储普通用户基本信息，支持登录与身份识别
boke（博客表）	id、addtime（发布时间）、bokemingcheng、fenlei（分类）、biaoqian（标签）、tupian（封面）、neirong（内容）、faburiqi（发布日期）、yonghuming	存储博客核心内容，关联用户与分类标签
tukuxiangce（图库相册表）	id、addtime（创建时间）、xiangcemingcheng、biaoqian（标签）、xiangcefengmian（封面）、xiangceneirong（描述）、faburiqi（发布日期）、yonghuming	存储相册信息，管理用户上传的图片资源
forum（论坛表）	id、addtime（发帖时间）、title（标题）、content（内容）、yonghuming、status（状态）	存储论坛帖子内容，支持互动交流
collect（收藏表）	id、addtime（收藏时间）、yonghuming、table_name（关联表名）、collect_id（关联ID）、collect_name（收藏名称）	记录用户收藏行为，关联博客/相册等内容

3.3 第三步：后端核心功能实现——Spring Boot架构

基于Spring Boot框架实现后端核心业务逻辑，重点解决“博客管理”“用户权限”“资源上传”三大核心问题：

3.3.1 博客管理功能实现

@RestController
@RequestMapping("/api/blog")
public class BlogController {
    
    @Autowired
    private BlogService blogService;
    
    /**
     * 发布博客
     */
    @PostMapping("/publish")
    public ResponseEntity<?> publishBlog(@RequestBody BlogPublishDTO publishDTO) {
        try {
            // 1. 验证用户信息
            User user = userService.getUserByUsername(publishDTO.getYonghuming());
            if (user == null) {
                return ResponseEntity.badRequest().body("用户不存在");
            }
            
            // 2. 封装博客数据
            Blog blog = new Blog();
            blog.setBokemingcheng(publishDTO.getBokemingcheng());
            blog.setFenlei(publishDTO.getFenlei());
            blog.setBiaoqian(publishDTO.getBiaoqian());
            blog.setTupian(publishDTO.getTupian()); // 封面图片URL
            blog.setNeirong(publishDTO.getNeirong()); // 富文本内容
            blog.setFaburiqi(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            blog.setYonghuming(publishDTO.getYonghuming());
            blog.setStatus("待审核"); // 初始状态：待管理员审核
            blog.setAddtime(new Date());
            
            // 3. 保存博客
            blogService.saveBlog(blog);
            return ResponseEntity.ok("博客发布成功，等待审核");
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseEntity.internalServerError().body("博客发布失败：" + e.getMessage());
        }
    }
    
    /**
     * 管理员审核博客
     */
    @PostMapping("/audit")
    public ResponseEntity<?> auditBlog(@RequestBody BlogAuditDTO auditDTO) {
        try {
            // 1. 验证管理员权限
            if (!hasAdminPermission()) {
                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("无审核权限");
            }
            
            // 2. 查询博客
            Blog blog = blogService.getBlogById(auditDTO.getBlogId());
            if (blog == null) {
                return ResponseEntity.badRequest().body("博客不存在");
            }
            
            // 3. 更新审核状态
            blog.setStatus(auditDTO.getStatus()); // 通过/驳回
            blogService.updateBlog(blog);
            return ResponseEntity.ok("博客审核完成，状态：" + auditDTO.getStatus());
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseEntity.internalServerError().body("审核失败：" + e.getMessage());
        }
    }
    
    /**
     * 获取博客列表（支持分类、标签筛选）
     */
    @GetMapping("/list")
    public ResponseEntity<?> getBlogList(
            @RequestParam(required = false) String fenlei,
            @RequestParam(required = false) String biaoqian,
            @RequestParam(defaultValue = "1") int page,
            @RequestParam(defaultValue = "10") int size) {
        try {
            BlogQuery query = new BlogQuery();
            query.setFenlei(fenlei);
            query.setBiaoqian(biaoqian);
            query.setPage(page);
            query.setSize(size);
            
            // 分页查询已审核通过的博客
            PageResult<Blog> result = blogService.getBlogList(query);
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseEntity.internalServerError().body("获取博客列表失败");
        }
    }
    
    /**
     * 获取用户个人博客
     */
    @GetMapping("/my-blog")
    public ResponseEntity<?> getUserBlog(
            @RequestParam String yonghuming,
            @RequestParam(defaultValue = "1") int page,
            @RequestParam(defaultValue = "10") int size) {
        try {
            PageResult<Blog> result = blogService.getUserBlog(yonghuming, page, size);
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseEntity.internalServerError().body("获取个人博客失败");
        }
    }
    
    /**
     * 删除博客
     */
    @DeleteMapping("/delete/{blogId}")
    public ResponseEntity<?> deleteBlog(@PathVariable Long blogId, @RequestParam String yonghuming) {
        try {
            Blog blog = blogService.getBlogById(blogId);
            if (blog == null) {
                return ResponseEntity.badRequest().body("博客不存在");
            }
            
            // 验证权限：仅博主本人或管理员可删除
            if (!blog.getYonghuming().equals(yonghuming) && !hasAdminPermission()) {
                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("无删除权限");
            }
            
            blogService.deleteBlog(blogId);
            return ResponseEntity.ok("博客删除成功");
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseEntity.internalServerError().body("删除博客失败");
        }
    }
}

3.3.2 用户权限控制实现

@Service
public class UserService {
    
    @Autowired
    private UserMapper userMapper;
    
    /**
     * 用户登录
     */
    public User login(String yonghuming, String mima) {
        // 密码加密校验（实际项目中应使用MD5+盐值加密）
        String encryptedPwd = DigestUtils.md5DigestAsHex(mima.getBytes());
        return userMapper.selectUser(yonghuming, encryptedPwd);
    }
    
    /**
     * 用户注册
     */
    public boolean register(UserRegisterDTO registerDTO) {
        // 1. 校验用户名是否已存在
        User existUser = userMapper.selectUserByUsername(registerDTO.getYonghuming());
        if (existUser != null) {
            throw new RuntimeException("用户名已被占用");
        }
        
        // 2. 封装用户数据
        User user = new User();
        user.setYonghuming(registerDTO.getYonghuming());
        user.setMima(DigestUtils.md5DigestAsHex(registerDTO.getMima().getBytes())); // 密码加密
        user.setXingming(registerDTO.getXingming());
        user.setXingbie(registerDTO.getXingbie());
        user.setShouji(registerDTO.getShouji());
        user.setZhaopian("/static/default-avatar.png"); // 默认头像
        user.setAddtime(new Date());
        
        // 3. 保存用户
        userMapper.insertUser(user);
        return true;
    }
    
    /**
     * 管理员权限校验
     */
    public boolean checkAdminPermission(String username) {
        Admin admin = adminMapper.selectAdminByUsername(username);
        return admin != null && "admin".equals(admin.getCx());
    }
    
    /**
     * 更新用户信息
     */
    public boolean updateUserInfo(UserUpdateDTO updateDTO) {
        User user = userMapper.selectUserByUsername(updateDTO.getYonghuming());
        if (user == null) {
            throw new RuntimeException("用户不存在");
        }
        
        // 更新非空字段
        if (StringUtils.hasText(updateDTO.getXingming())) {
            user.setXingming(updateDTO.getXingming());
        }
        if (StringUtils.hasText(updateDTO.getXingbie())) {
            user.setXingbie(updateDTO.getXingbie());
        }
        if (StringUtils.hasText(updateDTO.getShouji())) {
            user.setShouji(updateDTO.getShouji());
        }
        if (StringUtils.hasText(updateDTO.getZhaopian())) {
            user.setZhaopian(updateDTO.getZhaopian());
        }
        
        userMapper.updateUser(user);
        return true;
    }
    
    /**
     * 重置密码
     */
    public boolean resetPassword(String yonghuming, String oldPwd, String newPwd) {
        // 1. 校验原密码
        User user = userMapper.selectUserByUsername(yonghuming);
        if (user == null) {
            throw new RuntimeException("用户不存在");
        }
        String encryptedOldPwd = DigestUtils.md5DigestAsHex(oldPwd.getBytes());
        if (!user.getMima().equals(encryptedOldPwd)) {
            throw new RuntimeException("原密码错误");
        }
        
        // 2. 更新新密码
        String encryptedNewPwd = DigestUtils.md5DigestAsHex(newPwd.getBytes());
        user.setMima(encryptedNewPwd);
        userMapper.updateUser(user);
        return true;
    }
}

3.3.3 图库相册管理实现

@Service
public class AlbumService {
    
    @Autowired
    private AlbumMapper albumMapper;
    
    @Autowired
    private FileStorageService fileStorageService; // 文件存储服务（本地/云存储）
    
    /**
     * 创建相册
     */
    public Album createAlbum(AlbumCreateDTO createDTO) {
        // 1. 校验相册名称唯一性（同一用户下）
        Album existAlbum = albumMapper.selectAlbumByName(createDTO.getYonghuming(), createDTO.getXiangcemingcheng());
        if (existAlbum != null) {
            throw new RuntimeException("相册名称已存在");
        }
        
        // 2. 上传相册封面（若有）
        String coverUrl = null;
        if (createDTO.getCoverFile() != null && !createDTO.getCoverFile().isEmpty()) {
            coverUrl = fileStorageService.uploadFile(createDTO.getCoverFile(), "album/cover");
        }
        
        // 3. 封装相册数据
        Album album = new Album();
        album.setXiangcemingcheng(createDTO.getXiangcemingcheng());
        album.setBiaoqian(createDTO.getBiaoqian());
        album.setXiangcefengmian(coverUrl);
        album.setXiangceneirong(createDTO.getXiangceneirong());
        album.setFaburiqi(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        album.setYonghuming(createDTO.getYonghuming());
        album.setAddtime(new Date());
        
        // 4. 保存相册
        albumMapper.insertAlbum(album);
        return album;
    }
    
    /**
     * 上传图片到相册
     */
    public AlbumImage uploadImage(AlbumImageUploadDTO uploadDTO) {
        // 1. 校验相册是否存在
        Album album = albumMapper.selectAlbumById(uploadDTO.getAlbumId());
        if (album == null) {
            throw new RuntimeException("相册不存在");
        }
        
        // 2. 校验用户权限（仅相册创建者可上传）
        if (!album.getYonghuming().equals(uploadDTO.getYonghuming())) {
            throw new RuntimeException("无权限上传图片到该相册");
        }
        
        // 3. 批量上传图片
        List<String> imageUrls = new ArrayList<>();
        for (MultipartFile file : uploadDTO.getImageFiles()) {
            if (!file.isEmpty()) {
                String imageUrl = fileStorageService.uploadFile(file, "album/image");
                imageUrls.add(imageUrl);
            }
        }
        
        // 4. 保存图片记录
        AlbumImage albumImage = new AlbumImage();
        albumImage.setAlbumId(uploadDTO.getAlbumId());
        albumImage.setImageUrls(JSON.toJSONString(imageUrls)); // 存储图片URL列表（JSON格式）
        albumImage.setAddtime(new Date());
        albumMapper.insertAlbumImage(albumImage);
        
        return albumImage;
    }
    
    /**
     * 获取用户相册列表
     */
    public List<Album> getUserAlbums(String yonghuming) {
        return albumMapper.selectAlbumsByUser(yonghuming);
    }
    
    /**
     * 获取相册详情（含图片）
     */
    public AlbumDetailVO getAlbumDetail(Long albumId) {
        Album album = albumMapper.selectAlbumById(albumId);
        if (album == null) {
            throw new RuntimeException("相册不存在");
        }
        
        // 查询相册下的图片
        List<AlbumImage> images = albumMapper.selectImagesByAlbumId(albumId);
        List<String> allImageUrls = new ArrayList<>();
        for (AlbumImage image : images) {
            List<String> urls = JSON.parseArray(image.getImageUrls(), String.class);
            allImageUrls.addAll(urls);
        }
        
        // 封装详情VO
        AlbumDetailVO detailVO = new AlbumDetailVO();
        BeanUtils.copyProperties(album, detailVO);
        detailVO.setImageUrls(allImageUrls);
        
        return detailVO;
    }
    
    /**
     * 删除相册
     */
    public boolean deleteAlbum(Long albumId, String yonghuming) {
        Album album = albumMapper.selectAlbumById(albumId);
        if (album == null) {
            throw new RuntimeException("相册不存在");
        }
        
        // 校验权限
        if (!album.getYonghuming().equals(yonghuming) && !userService.checkAdminPermission(yonghuming)) {
            throw new RuntimeException("无删除权限");
        }
        
        // 1. 删除相册下的图片（文件+记录）
        List<AlbumImage> images = albumMapper.selectImagesByAlbumId(albumId);
        for (AlbumImage image : images) {
            List<String> urls = JSON.parseArray(image.getImageUrls(), String.class);
            for (String url : urls) {
                fileStorageService.deleteFile(url); // 删除文件
            }
            albumMapper.deleteAlbumImage(image.getId()); // 删除记录
        }
        
        // 2. 删除相册
        albumMapper.deleteAlbum(albumId);
        return true;
    }
}

3.4 第四步：前端界面实现——双角色适配界面

基于JSP+Bootstrap构建适配管理员与普通用户的界面，兼顾美观性与实用性：

3.4.1 用户功能界面

• 首页：博客推荐列表（按发布时间排序）、标签云（点击筛选）、分类导航（左侧栏）、热门博客排行（右侧边栏）；
• 博客详情页：标题、发布时间、作者、标签、富文本内容、评论区（支持发表评论与回复）、收藏按钮；
• 博客创作页：标题输入框、分类下拉选择、标签多选框、富文本编辑器（支持插入图片、排版调整）、预览/保存草稿/发布按钮；
• 个人中心：个人信息展示（头像、昵称、联系方式）、信息编辑表单、密码重置模块、我的博客（列表/编辑/删除）、我的相册（创建/上传/查看）、我的收藏（列表/取消收藏）。

3.4.2 管理员功能界面

• 管理首页：数据概览（用户总数、博客总数、相册总数、待审核博客数）、近期活跃用户排行、系统公告编辑；
• 用户管理页：用户列表（用户名、姓名、性别、手机、注册时间）、新增/编辑/删除用户操作按钮、用户状态控制；
• 博客管理页：博客列表（标题、分类、标签、作者、发布时间、状态）、审核操作（通过/驳回）、编辑/删除按钮、批量操作功能；
• 系统管理页：轮播图管理（上传/排序/删除）、新闻资讯管理（新增/编辑/发布/删除）、系统参数配置（如博客审核开关）。

3.5 第五步：系统测试——确保平台稳定可靠

通过多维度测试验证系统功能完整性与稳定性，重点覆盖核心业务流程：

3.5.1 功能测试

设计测试用例覆盖管理员与用户的核心操作，确保功能正常运行：

测试场景	预期结果	实际结果	是否通过
用户注册	用户名未占用时注册成功，跳转登录页	符合预期，注册信息存入数据库	是
博客发布与审核	用户发布后状态为“待审核”，管理员审核后变为“已通过”并展示	符合预期，审核流程正常	是
相册创建与图片上传	相册创建成功，图片上传后可预览	符合预期，图片URL正确存储	是
论坛发帖与评论	帖子发布成功，支持评论与回复	符合预期，互动数据实时更新	是
管理员用户管理	可新增/编辑/删除用户，权限控制正确	符合预期，用户数据同步更新	是

3.5.2 非功能测试

• 兼容性测试：在Chrome 120、Firefox 119、Edge 120浏览器中测试，界面布局与功能正常；
• 性能测试：单用户连续发布10篇博客，平均响应时间1.2秒；50用户同时浏览首页，页面加载时间≤2秒；
• 安全测试：尝试越权访问管理员后台（普通用户登录后访问/admin路径），被拦截并跳转至登录页；输入SQL注入语句（如用户名输入“' or 1=1 #”），系统过滤并提示非法输入；
• 数据一致性测试：删除博客后，关联的收藏记录同步删除；删除相册后，关联的图片文件与记录同步删除，无数据残留。

3.6 第六步：问题排查与优化——提升系统体验

开发过程中遇到的典型问题及解决方案：

1. 博客富文本内容存储与展示乱码

   • 问题：富文本编辑器提交的HTML内容存入数据库后，取出展示时出现中文乱码；
   • 解决方案：配置MySQL数据库编码为UTF-8（character_set_server=utf8mb4），后端接口设置请求/响应编码为UTF-8，前端表单提交时指定enctype="multipart/form-data;charset=utf-8"。

2. 图片上传后访问404

   • 问题：图片上传到本地服务器指定目录后，通过URL访问时返回404错误；
   • 解决方案：在Tomcat配置文件中配置虚拟路径（如），前端访问时使用虚拟路径拼接图片URL。

3. 多用户同时编辑同一博客导致数据覆盖

   • 问题：A用户打开博客编辑页后，B用户同时编辑并保存，A用户后续保存会覆盖B用户的修改；
   • 解决方案：在博客表添加“version（版本号）”字段，每次更新时校验版本号，版本号不一致则提示“内容已被修改，请刷新后重新编辑”。

4. 首页加载速度慢

   • 问题：首页加载大量博客列表与图片，导致页面渲染延迟；
   • 解决方案：实现博客列表分页加载（默认显示10条），图片使用懒加载（滚动到可视区域再加载），对热门博客列表添加Redis缓存（缓存时间30分钟）。

四、毕业设计复盘：经验总结与实践建议

4.1 开发过程中的技术收获

1. 框架应用能力提升：通过Spring Boot框架开发，掌握了依赖注入、事务管理、RESTful接口设计等核心技能，理解了“约定优于配置”的设计思想；
2. 前后端协同经验：明确了前后端数据交互规范（如DTO封装请求/响应数据、JSON格式传输），解决了跨域、数据格式转换等常见问题；
3. 数据库设计思维：从“单一表”到“多表关联”，学会了根据业务场景设计合理的表结构（如通过外键关联用户与博客、相册与图片），优化SQL查询（如添加索引提升查询效率）；
4. 问题解决能力：面对乱码、404、数据一致性等问题，学会了通过日志排查、调试工具分析、查阅文档等方式定位并解决问题，积累了实战经验。

4.2 给后续开发者的建议

1. 重视需求分析：在开发前充分调研用户需求，明确功能边界（如是否需要支持博客点赞、分享功能），避免后期频繁修改；
2. 优先实现核心功能：先完成“用户登录-博客发布-内容展示”核心流程，再迭代开发论坛、收藏等辅助功能，降低开发复杂度；
3. 注重代码规范：使用统一的命名规范（如类名首字母大写、方法名驼峰式），添加必要的注释，封装通用工具类（如文件上传、日期处理），提升代码可维护性；
4. 考虑扩展性：设计时预留功能扩展接口（如博客评论支持表情包、相册支持视频上传），数据库表结构预留冗余字段（如用户表添加“remark”字段），便于后续升级；
5. 加强测试意识：开发过程中同步编写测试用例，不仅关注“功能是否实现”，更要考虑“异常场景如何处理”（如用户输入非法数据、网络中断），确保系统稳定性。

五、项目资源与发展展望

5.1 项目核心资源

本项目提供完整的开发与部署资料，便于后续学习与二次开发：

• 源码资源：后端Spring Boot项目源码（含Controller、Service、Mapper层）、前端JSP页面源码（含CSS/JavaScript资源）；
• 数据库资源：MySQL建表语句（含测试数据）、数据库ER图；
• 部署文档：本地开发环境搭建指南（JDK、MySQL、Tomcat安装配置）、服务器部署步骤（Linux系统下Tomcat+MySQL部署）；
• 接口文档：后端RESTful接口说明（含请求参数、响应格式、示例）。

5.2 系统扩展方向

1. 功能扩展：

   • 社交化功能：博客点赞、分享到微信/微博、关注作者；
   • 个性化推荐：基于用户浏览/收藏记录，推荐相似主题博客；
   • 会员体系：开通会员可享受无广告、高清图片上传、博客置顶等特权。

2. 技术升级：

   • 前端重构：使用Vue.js/React框架替代JSP，实现单页应用（SPA），提升用户体验；
   • 后端优化：引入Spring Security实现更细粒度的权限控制，使用Elasticsearch实现博客全文检索；
   • 部署升级：采用Docker容器化部署，配合Nginx实现负载均衡，支持高并发访问。

3. 场景延伸：

   • 移动端支持：开发微信小程序或APP，实现“随时创作、随地浏览”；
   • 多语言支持：添加中英文切换功能，面向海外用户；
   • 内容变现：集成广告投放、付费阅读功能，为博主提供收益渠道。

本项目作为本科毕业设计，不仅实现了在线BLOG网的核心功能，更完整覆盖了“需求分析-系统设计-编码实现-测试优化”的软件开发全流程。通过实战开发，既巩固了Java Web、数据库等理论知识，也培养了问题解决与项目管理能力，为后续职业发展奠定了坚实基础。如果本文对您的Spring Boot学习或博客平台相关毕业设计有帮助，欢迎点赞+收藏+关注，后续将分享更多Java Web项目实战案例！