10个模块实现《甜品店管理系统》：3步掌握Spring Boot+Vue+MySQL架构，毕设不再难|计算机毕业设计|Python

一、个人简介

• 💖💖作者：计算机编程果茶熊
• 💙💙个人简介：曾长期从事计算机专业培训教学，担任过编程老师，同时本人也热爱上课教学，擅长Java、微信小程序、Python、Golang、安卓Android等多个IT方向。会做一些项目定制化开发、代码讲解、答辩教学、文档编写、也懂一些降重方面的技巧。平常喜欢分享一些自己开发中遇到的问题的解决办法，也喜欢交流技术，大家有技术代码这一块的问题可以问我！
• 💛💛想说的话：感谢大家的关注与支持！
• 💕💕文末获取源码联系计算机编程果茶熊

二、前言

• 开发语言：Java+Python
• 数据库：MySQL
• 系统架构：B/S
• 后端框架：SpringBoot(Spring+SpringMVC+Mybatis)+Django
• 前端：Vue+HTML+CSS+JavaScript+jQuery
• 《甜品店管理系统》是一款基于B/S架构的综合性管理平台，采用Java/Python双版本开发支持，分别基于Spring Boot(Spring+SpringMVC+Mybatis)和Django框架构建后端服务，前端统一使用Vue+ElementUI+HTML技术栈，数据存储依托MySQL数据库。系统功能全面，包括系统首页、个人中心、用户管理、甜品信息管理、甜品类型管理、论坛交流管理、帖子类型管理、系统管理和订单管理九大模块，实现了甜品店铺从商品管理到订单处理的全流程数字化运营。通过该系统，甜品店管理者可以高效地进行商品分类与信息维护，实时监控订单状态，便捷地管理用户账户，同时为顾客提供论坛交流平台增强用户粘性，打造完整的甜品店线上运营生态。系统界面简洁美观，操作流程清晰，响应速度快，安全性高，适合各类规模的甜品店铺使用，是计算机专业学生理想的毕业设计选题，能够全面展示全栈开发能力和软件工程实践水平。

三、甜品店管理系统-视频解说

10个模块实现《甜品店管理系统》：3步掌握Spring Boot+Vue+MySQL架构，毕设不再难|基于SpringBoot+Vue的甜品店管理系统|毕业设计

四、甜品店管理系统-功能介绍

五、甜品店管理系统-代码展示

// 核心功能1: 甜品信息管理 @Service public class DessertServiceImpl implements DessertService {

@Autowired
private DessertMapper dessertMapper;

@Autowired
private DessertTypeMapper dessertTypeMapper;

@Override
public Result addDessert(Dessert dessert) {
    // 校验甜品信息完整性
    if (StringUtils.isBlank(dessert.getName()) || dessert.getPrice() == null || dessert.getTypeId() == null) {
        return Result.error("甜品信息不完整，请检查必填项");
    }
    
    // 校验甜品类型是否存在
    DessertType dessertType = dessertTypeMapper.selectById(dessert.getTypeId());
    if (dessertType == null) {
        return Result.error("所选甜品类型不存在");
    }
    
    // 检查甜品名称是否重复
    QueryWrapper<Dessert> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("name", dessert.getName());
    if (dessertMapper.selectCount(queryWrapper) > 0) {
        return Result.error("甜品名称已存在");
    }
    
    // 设置默认值
    dessert.setCreateTime(new Date());
    dessert.setSales(0);
    dessert.setStatus(1); // 1-上架状态
    
    // 保存甜品信息
    dessertMapper.insert(dessert);
    return Result.success("甜品添加成功");
}

@Override
public Result updateDessertStatus(Integer dessertId, Integer status) {
    // 参数校验
    if (dessertId == null || status == null) {
        return Result.error("参数错误");
    }
    
    // 查询甜品是否存在
    Dessert dessert = dessertMapper.selectById(dessertId);
    if (dessert == null) {
        return Result.error("甜品不存在");
    }
    
    // 检查状态值是否合法 (1-上架, 0-下架)
    if (status != 0 && status != 1) {
        return Result.error("状态值不合法");
    }
    
    // 如果甜品有未完成订单且要下架，给出警告
    if (status == 0) {
        int unfinishedOrders = dessertMapper.countUnfinishedOrdersByDessertId(dessertId);
        if (unfinishedOrders > 0) {
            return Result.error("该甜品有" + unfinishedOrders + "个未完成订单，下架可能影响订单处理");
        }
    }
    
    // 更新甜品状态
    Dessert updateDessert = new Dessert();
    updateDessert.setId(dessertId);
    updateDessert.setStatus(status);
    updateDessert.setUpdateTime(new Date());
    dessertMapper.updateById(updateDessert);
    
    return Result.success("甜品状态更新成功");
}

}

// 核心功能2: 订单管理 @Service public class OrderServiceImpl implements OrderService {

@Autowired
private OrderMapper orderMapper;

@Autowired
private OrderItemMapper orderItemMapper;

@Autowired
private DessertMapper dessertMapper;

@Override
@Transactional(rollbackFor = Exception.class)
public Result createOrder(OrderDTO orderDTO, Integer userId) {
    // 校验订单数据
    if (orderDTO == null || CollectionUtils.isEmpty(orderDTO.getOrderItems())) {
        return Result.error("订单数据不完整");
    }
    
    // 创建订单主表记录
    Order order = new Order();
    order.setUserId(userId);
    order.setOrderNo(generateOrderNo());
    order.setStatus(1); // 1-待支付
    order.setCreateTime(new Date());
    order.setAddress(orderDTO.getAddress());
    order.setPhone(orderDTO.getPhone());
    order.setReceiverName(orderDTO.getReceiverName());
    
    // 计算订单总金额
    BigDecimal totalAmount = new BigDecimal("0");
    List<OrderItem> orderItems = new ArrayList<>();
    
    for (OrderItemDTO itemDTO : orderDTO.getOrderItems()) {
        // 查询甜品信息
        Dessert dessert = dessertMapper.selectById(itemDTO.getDessertId());
        if (dessert == null) {
            throw new BusinessException("甜品不存在: " + itemDTO.getDessertId());
        }
        
        // 检查甜品是否已下架
        if (dessert.getStatus() != 1) {
            throw new BusinessException("甜品已下架: " + dessert.getName());
        }
        
        // 创建订单明细
        OrderItem orderItem = new OrderItem();
        orderItem.setDessertId(dessert.getId());
        orderItem.setDessertName(dessert.getName());
        orderItem.setDessertImage(dessert.getImage());
        orderItem.setPrice(dessert.getPrice());
        orderItem.setQuantity(itemDTO.getQuantity());
        orderItem.setAmount(dessert.getPrice().multiply(new BigDecimal(itemDTO.getQuantity())));
        
        orderItems.add(orderItem);
        totalAmount = totalAmount.add(orderItem.getAmount());
    }
    
    // 设置订单总金额
    order.setTotalAmount(totalAmount);
    
    // 保存订单主表
    orderMapper.insert(order);
    
    // 保存订单明细
    for (OrderItem item : orderItems) {
        item.setOrderId(order.getId());
        orderItemMapper.insert(item);
        
        // 更新甜品销量
        dessertMapper.increaseSales(item.getDessertId(), item.getQuantity());
    }
    
    // 返回订单信息
    Map<String, Object> result = new HashMap<>();
    result.put("orderId", order.getId());
    result.put("orderNo", order.getOrderNo());
    result.put("totalAmount", order.getTotalAmount());
    
    return Result.success("订单创建成功", result);
}

@Override
@Transactional(rollbackFor = Exception.class)
public Result updateOrderStatus(String orderNo, Integer status, Integer userId) {
    // 参数校验
    if (StringUtils.isBlank(orderNo) || status == null) {
        return Result.error("参数错误");
    }
    
    // 查询订单
    QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("order_no", orderNo);
    Order order = orderMapper.selectOne(queryWrapper);
    
    if (order == null) {
        return Result.error("订单不存在");
    }
    
    // 权限校验：只有订单所属用户或管理员可以操作
    if (!order.getUserId().equals(userId) && !isAdmin(userId)) {
        return Result.error("无权操作此订单");
    }
    
    // 订单状态流转校验
    if (!validateStatusTransition(order.getStatus(), status)) {
        return Result.error("订单状态流转不合法");
    }
    
    // 更新订单状态
    Order updateOrder = new Order();
    updateOrder.setId(order.getId());
    updateOrder.setStatus(status);
    updateOrder.setUpdateTime(new Date());
    
    // 如果是完成订单，设置完成时间
    if (status == 4) {
        updateOrder.setFinishTime(new Date());
    }
    
    // 如果是取消订单，需要恢复库存和销量
    if (status == 0 && (order.getStatus() == 1 || order.getStatus() == 2)) {
        List<OrderItem> orderItems = orderItemMapper.selectByOrderId(order.getId());
        for (OrderItem item : orderItems) {
            dessertMapper.decreaseSales(item.getDessertId(), item.getQuantity());
        }
    }
    
    orderMapper.updateById(updateOrder);
    return Result.success("订单状态更新成功");
}

}

// 核心功能3: 论坛交流管理 @Service public class ForumServiceImpl implements ForumService {

@Autowired
private PostMapper postMapper;

@Autowired
private CommentMapper commentMapper;

@Autowired
private PostTypeMapper postTypeMapper;

@Autowired
private UserMapper userMapper;

@Override
@Transactional(rollbackFor = Exception.class)
public Result publishPost(Post post, Integer userId) {
    // 参数校验
    if (post == null || StringUtils.isBlank(post.getTitle()) || StringUtils.isBlank(post.getContent())) {
        return Result.error("帖子标题和内容不能为空");
    }
    
    // 校验帖子类型
    if (post.getTypeId() != null) {
        PostType postType = postTypeMapper.selectById(post.getTypeId());
        if (postType == null) {
            return Result.error("帖子类型不存在");
        }
    }
    
    // 敏感词过滤
    String filteredTitle = sensitiveWordFilter(post.getTitle());
    String filteredContent = sensitiveWordFilter(post.getContent());
    
    if (!filteredTitle.equals(post.getTitle()) || !filteredContent.equals(post.getContent())) {
        return Result.error("帖子包含敏感词，请修改后重试");
    }
    
    // 设置帖子信息
    post.setUserId(userId);
    post.setCreateTime(new Date());
    post.setUpdateTime(new Date());
    post.setViewCount(0);
    post.setLikeCount(0);
    post.setCommentCount(0);
    post.setStatus(1); // 1-正常发布
    
    // 获取用户信息，设置发帖人昵称
    User user = userMapper.selectById(userId);
    if (user != null) {
        post.setAuthorName(user.getNickname());
        post.setAuthorAvatar(user.getAvatar());
    }
    
    // 保存帖子
    postMapper.insert(post);
    
    // 更新用户发帖数
    userMapper.increasePostCount(userId);
    
    // 如果有标签，处理帖子标签关系
    if (!CollectionUtils.isEmpty(post.getTags())) {
        for (String tag : post.getTags()) {
            postMapper.insertPostTag(post.getId(), tag);
        }
    }
    
    return Result.success("帖子发布成功", post.getId());
}

@Override
public Result addComment(Comment comment, Integer userId) {
    // 参数校验
    if (comment == null || comment.getPostId() == null || StringUtils.isBlank(comment.getContent())) {
        return Result.error("评论参数不完整");
    }
    
    // 查询帖子是否存在
    Post post = postMapper.selectById(comment.getPostId());
    if (post == null) {
        return Result.error("帖子不存在");
    }
    
    // 检查帖子状态是否正常
    if (post.getStatus() != 1) {
        return Result.error("帖子状态异常，无法评论");
    }
    
    // 敏感词过滤
    String filteredContent = sensitiveWordFilter(comment.getContent());
    if (!filteredContent.equals(comment.getContent())) {
        return Result.error("评论包含敏感词，请修改后重试");
    }
    
    // 设置评论信息
    comment.setUserId(userId);
    comment.setCreateTime(new Date());
    comment.setLikeCount(0);
    comment.setStatus(1); // 1-正常
    
    // 获取用户信息
    User user = userMapper.selectById(userId);
    if (user != null) {
        comment.setUserName(user.getNickname());
        comment.setUserAvatar(user.getAvatar());
    }
    
    // 处理回复评论
    if (comment.getParentId() != null) {
        Comment parentComment = commentMapper.selectById(comment.getParentId());
        if (parentComment == null) {
            return Result.error("回复的评论不存在");
        }
        comment.setReplyUserId(parentComment.getUserId());
        comment.setReplyUserName(parentComment.getUserName());
    }
    
    // 保存评论
    commentMapper.insert(comment);
    
    // 更新帖子评论数
    postMapper.increaseCommentCount(comment.getPostId());
    
    // 如果不是帖子作者自己评论，发送消息通知
    if (!userId.equals(post.getUserId())) {
        // 发送消息通知代码
        sendCommentNotification(post.getUserId(), userId, post.getId(), comment.getId(), post.getTitle());
    }
    
    return Result.success("评论成功", comment.getId());
}

@Override
@Transactional(rollbackFor = Exception.class)
public Result moderatePost(Integer postId, Integer status, String reason, Integer adminId) {
    // 参数校验
    if (postId == null || status == null) {
        return Result.error("参数错误");
    }
    
    // 查询帖子是否存在
    Post post = postMapper.selectById(postId);
    if (post == null) {
        return Result.error("帖子不存在");
    }
    
    // 检查状态值是否合法 (1-正常, 2-置顶, 0-禁用)
    if (status != 0 && status != 1 && status != 2) {
        return Result.error("状态值不合法");
    }
    
    // 更新帖子状态
    Post updatePost = new Post();
    updatePost.setId(postId);
    updatePost.setStatus(status);
    updatePost.setUpdateTime(new Date());
    
    // 如果是禁用，记录禁用原因
    if (status == 0) {
        if (StringUtils.isBlank(reason)) {
            return Result.error("禁用帖子需要提供原因");
        }
        updatePost.setModerateReason(reason);
        updatePost.setModerateTime(new Date());
        updatePost.setModerateUserId(adminId);
    }
    
    postMapper.updateById(updatePost);
    
    // 如果是禁用帖子，同时禁用该帖子下的所有评论
    if (status == 0) {
        commentMapper.batchUpdateStatusByPostId(postId, 0);
        
        // 发送通知给帖子作者
        User admin = userMapper.selectById(adminId);
        String adminName = admin != null ? admin.getNickname() : "管理员";
        sendPostModerateNotification(post.getUserId(), postId, post.getTitle(), reason, adminName);
    }
    
    return Result.success("帖子状态更新成功");
}

六、甜品店管理系统-文档展示

七、END

💕💕文末获取源码联系计算机编程果茶熊