软件编程综合实践 - 外卖平台设计

一、项目开发计划书

1.概述

1.1项目的目的与目标

• 项目目的
  1. 提升服务效率与便利性：构建一个易于使用的在线订餐平台，使顾客能够快速方便地下单，同时帮助饭店餐厅提升订单处理效率。
  2. 促进餐饮业数字化：通过在线平台，促进餐饮业的信息化和网络化，提高整体服务水平。
  3. 增强用户体验：通过用户反馈和评价机制，使餐馆能够及时改进，增强顾客的用餐体验。
  4. 数据驱动的决策支持：为饭店管理员(老板)提供数据分析工具，以便更好地管理饭馆和制定促销策略。
  5. 数据分析与管理：利用数据分析工具，为饭店提供有效的经营决策支持。
• 项目目标
  1. 用户友好的界面设计：设计一个直观、易于操作的用户界面，确保用户能够轻松上手。
  2. 高效的订单处理机制：确保订单从下单到配送的全过程高效顺畅。
  3. 实现饭店的认证和设置菜品： 通过认证后，饭店可以登陆平台，自行设置菜品种类和菜品价格以及优惠力度。饭店可以根据菜品销量和用户评价进行调整，提供更符合市场需求的菜品选择。
  4. 实现顾客的注册、点餐和支付： 顾客可以实名制注册登陆平台，完成菜品的网上点餐和支付，实现方便快捷的外卖订餐服务。
  5. 实现外卖配送： 系统能匹配相应外卖快递人员送菜品到顾客家，保证及时的送达服务。
  6. 实现用户评价和统计功能： 顾客可以对外卖人员的服务以及饭店的菜品质量进行评价打分，帮助饭店改进和提升服务质量。饭店管理员(老板)可以统计某个时期内平台的收入和销售额，统计某个时期内的销售额和最受欢迎的菜品，顾客可以查询和统计自己的外卖订单，提供数据支持和分析。
  7. 提高用户生活质量和餐饮行业的进步： 通过方便的外卖订餐服务，提供更好的用餐体验和生活便利。同时通过用户评价和统计数据的反馈，帮助饭店改进提升，为餐饮行业的长足进步贡献力量。
• 基本架构设计
  • 前端：使用HTML5、Vue.js、ElementUI等技术，构建响应式网页，兼容多种设备。在移动端, 用户也需要登录后使用APP进行点餐
  • 后端：采用Node.js、SpringBoot等后端技术，实现数据处理和业务逻辑。
  • 数据库：使用MySQL数据库管理系统，存储用户数据、订单数据等。
  • API接口：构建RESTful API，实现前后端分离。
  • 构建工具：Maven
  • 安全性：实施HTTPS、数据加密和用户认证机制，保障用户数据安全。

1.2 系统功能范围及过程规划

1.2.1系统功能范围

• 管理员模块

  • 登陆管理

• 商家模块

  • 登录管理：内部餐厅员工必须登录后,才可以访问系统管理后台。

  • 分类管理：主要对当前餐厅经营的 菜品分类 或 套餐分类 进行管理维护， 包含查询、新增、修改、删除等功能。

  • 菜品管理：主要维护各个分类下的菜品信息，包含查询、新增、修改、删除、启售、停售等功能。

  • 订单明细：主要维护用户在移动端下的订单信息，包含查询、取消、派送、完成，以及订单报表下载等功能。

  • 店铺信息设置：上传或修改商铺基本信息。

• 顾客模块

  • 账户注册与登录：在移动端, 用户也需要登录后使用APP进行点餐。

  • 查看餐厅：查找餐厅，选择商铺进行选购。

  • 点餐下单：查看菜品，选择配送地址，修改购物车后进行下单。

  • 查看订单：查看订单记录。

  • 设置个人信息：上传或修改个人基本信息。

1.2.2过程规划

1. 需求分析阶段：

   • 确定目标用户群（顾客、饭店、管理员）。
   • 分析用户需求和市场趋势。
   • 制定详细的功能列表和系统需求。

2. 设计阶段：

   • 界面设计：构建用户友好的界面，包括布局、颜色和图标等。
   • 系统架构设计：确定技术栈、数据库以及所用数据结构、API设计等。
   • 安全性设计：制定数据保护和安全协议。

3. 开发阶段：

   • 分模块开发：按照功能模块分配开发任务。
   • 迭代开发：采用敏捷开发模式，进行快速迭代。
   • 持续集成与测试：确保代码质量，进行功能和性能测试。

4. 部署与上线：

   • 服务器部署：选择了阿里云服务提供商和服务器配置。
   • 上线测试：在模拟实际外卖环境中进行测试，包括负载测试和用户测试。
   • 正式上线：发布系统，开放用户注册和使用。

5. 运维与支持：

   • 监控系统性能：实时监控服务器和应用性能。
   • 用户支持：提供用户帮助和技术支持。
   • 持续更新：根据用户反馈和市场变化，定期更新系统功能。

6. 市场推广：

   • 制定市场推广计划，包括在线广告、社交媒体营销等。
   • 合作伙伴关系建立，如与当地餐厅和配送服务商建立合作。
   • 用户反馈收集，以不断优化推广策略和服务。

2 .可行性分析

2.1 社会可行性

1. 市场需求：随着生活节奏的加快，越来越多的人选择外卖作为日常饮食的重要方式。这一趋势表明，外卖订餐系统符合当下社会的需求。
2. 用户接受度：数字化生活方式已深入人心，消费者普遍接受在线订餐的模式，尤其是年轻人群体。
3. 社会影响：提高餐饮业的效率和服务水平，对提升整体生活质量有积极影响。同时，为饭店和个体经营者提供了新的商业机会。
4. 环境适应性：考虑到环保趋势，外卖订餐系统需要鼓励使用环保包装，减少塑料等不可降解材料的使用。

2.2 经济可行性

1. 初期投资：需要资金支持系统的设计、开发和市场推广。这包括人力成本、技术采购、服务器费用等。
2. 运营成本：主要包括服务器维护、客服支持、市场营销和平台升级等。
3. 收益预测：通过平台抽成、广告、合作伙伴关系等多种渠道实现盈利。预计随着用户基数的增加，收益将持续增长。
4. 成本回收期：根据市场响应和用户增长速度预估，初期投资的回收期可以在几年内实现。

2.3 技术可行性

1. 技术成熟度：目前市场上已有许多成熟的技术可供选择，包括前端和后端开发框架、数据库管理系统、支付网关等。
2. 开发能力：开发团队已具备相关的技术知识和经验。
3. 可扩展性和维护性：系统设计考虑了未来的扩展性，能够适应不断增长的用户量和业务需求。同时，系统的维护和更新应当简便高效。
4. 安全性：考虑到了交易安全和个人信息保护，需要采用高标准的安全措施，如数据加密、安全支付等。

3.方案选择

​ 为了实现外卖订餐系统，我们将比较两个主要方案：自主开发方案和第三方服务集成方案。每个方案都有其独特的优势和局限性，需要根据可行性分析进行综合考虑。

3.1自主开发方案

• 系统架构与技术

  • 前端：React或Vue.js，以创建动态和响应式的用户界面。

  • 后端：Node.js或Java Spring Boot，提供强大的后台服务。

  • 数据库：MySQL，保障数据的稳定存储和高效检索。

  • 安全：使用OAuth 2.0标准进行用户认证和授权。

  • 云服务：阿里云，提供可靠的服务器和数据存储服务。

• 构建工具与开发平台

  • 构建工具：使用Maven进行项目管理，Git进行版本控制。

  • 开发平台：IDEA2022.1

• 系统检验方案

  • 功能测试：采用单元测试和集成测试确保功能正确实现。

  • 性能测试：使用LoadRunner等工具进行负载测试。

• 应对方案

  • 技术变化：持续关注技术趋势，定期进行技术栈评估和更新。

  • 安全风险：实施定期的安全审计和漏洞扫描。

• 优势与局限

  • 优势：完全自主控制，灵活性和定制性强。

  • 局限：开发成本和时间较高，技术风险自担。

3.2第三方服务集成方案

• 系统架构与技术

  • 前端：使用现成的模板和框架快速搭建。

  • 后端：集成第三方云服务，如Firebase或AWS Lambda。

  • 数据库：使用云数据库服务，如AWS RDS。

  • 支付：集成第三方支付服务，如Stripe或PayPal。

• CASE工具与开发平台

  • CASE工具：利用Trello进行项目协调，GitHub进行代码管理。

  • 开发平台：依赖第三方云平台的开发环境。

• 系统检验方案

  • 用户体验测试：重点关注用户界面和交互的流畅度。

  • 安全合规性测试：确保集成服务符合行业安全标准。

• 应对方案

  • 服务依赖：定期评估服务供应商的可靠性和性能。

  • 成本控制：监控服务费用，避免预算超支。

• 优势与局限

  • 优势：快速部署，成本相对较低，减少技术维护工作。

  • 局限：依赖第三方服务，灵活性和自主性受限。

3.3综合比较

• 功能性：自主开发方案在功能定制方面更为灵活，第三方服务集成方案在快速实现标准功能方面不灵活但有些优势。

• 技术挑战：自主开发需要更强的技术团队和维护能力，而我们正好有。第三方服务集成降低了技术难度，我们可作为参考。

• 社会约束：自主开发更容易适应特定市场的需求和法规要求，第三方服务可能在某些区域面临限制。

  基于此，我们选择自主开发方案。

4.项目进度计划

4.1任务分解与依赖关系

• 需求分析与规划：

  • 调研市场需求
  • 定义功能需求
  • 制定初步项目计划

• 系统设计：

  • 界面设计
  • 系统架构设计
  • 数据库设计
  • 安全规划

• 系统开发：

  • 前端开发
  • 后端开发
  • 数据库实现
  • 安全机制实现

• 测试与部署：

  • 功能测试
  • 性能测试
  • 用户验收测试
  • 系统部署

• 维护与升级：

  • 收集用户反馈
  • 系统维护
  • 功能更新

4.2活动网络图

关键路径：需求分析 → 系统设计 → 系统开发 → 测试与部署

这条路径上的任务是项目成功的关键，任何延误都将直接影响项目整体进度。

4.3甘特图

5.人员组织计划

二、需求规格说明书

1.系统功能需求

1.1 用户需求描述

1.1.1功能需求

• 管理员模块

  • 登陆管理

• 商家模块

  • 登录管理：内部餐厅员工必须登录后,才可以访问系统管理后台。

  • 分类管理：主要对当前餐厅经营的 菜品分类 或 套餐分类 进行管理维护， 包含查询、新增、修改、删除等功能。

  • 菜品管理：主要维护各个分类下的菜品信息，包含查询、新增、修改、删除、启售、停售等功能。

  • 订单明细：主要维护用户在移动端下的订单信息，包含查询、取消、派送、完成，以及订单报表下载等功能。

  • 店铺信息设置：上传或修改商铺基本信息。

• 顾客模块

  • 账户注册与登录：在移动端, 用户也需要登录后使用APP进行点餐。

  • 查看餐厅：查找餐厅，选择商铺进行选购。

  • 点餐下单：查看菜品，选择配送地址，修改购物车后进行下单。

  • 查看订单：查看订单记录。

  • 设置个人信息：上传或修改个人基本信息。

1.1.2约束条件

• 性能约束：

  • 系统能承受高峰时段的访问压力，保证快速响应。
  • 订单处理和支付系统需实时响应，减少用户等待时间。

• 安全性与隐私：

  • 用户数据（包括个人信息和支付信息）加密存储。
  • 系统符合数据保护法规。

• 可用性：

  • 系统具有高可用性，减少停机时间。
  • 用户界面友好，易于导航和操作。

• 可扩展性：

  • 系统设计考虑未来扩展，包括用户量增加和功能更新。

• 法律合规性：

  • 系统符合所有相关法律法规，包括食品安全标准和在线支付规定。

• 维护与支持：

  • 系统便于维护和升级。
  • 提供用户帮助和技术支持服务。

1.2 初始功能提取

1.3 系统需求描述

1.3.1用例模型

• 用户注册

  图2-2. 用户注册活动图表2-2. 用户注册用例表

• 用户登录

  图2-3. 用户登录活动图表2-3. 用户登录用例表

• 点餐下单

  图2-4. 点餐下单活动图表2-4. 点餐下单用例表

• 查看订单

  图2-5. 查看订单活动图表2-5. 查看订单用例表

• 查看餐厅

  图2-6. 查看餐厅活动图表2-6. 查看餐厅用例表

• 设置个人信息

  图2-7. 设置个人信息活动图表2-7. 设置个人信息用例表

• 分类管理

  图2-8. 分类管理活动图表2-8. 分类管理用例表

• 登录管理

  图2-9. 登录管理活动图表2-9. 登录管理用例表

• 菜品管理

  图2-10. 菜品管理活动图表2-10. 菜品管理用例表

• 订单明细

  图2-11. 订单明细活动图表2-11. 订单明细用例表

• 店铺信息设置

  图2-12. 店铺信息设置活动图表2-12. 店铺信息设置用例表

1.3.2分析类模型

• CRC卡

  • 用户类 (User)

    职责 (Responsibilities)	协作 (Collaborations)
    注册用户账号	地址类、订单类、购物车类
    用户登录	地址类、订单类、购物车类
    更新个人信息	地址类
    查看购物车	购物车类

  • 地址类 (Address)

    职责 (Responsibilities)	协作 (Collaborations)
    添加地址	用户类
    更新地址	用户类

  • 订单类 (Orders)

    职责 (Responsibilities)	协作 (Collaborations)
    创建订单	用户类、餐厅类、订单详情类
    更新订单状态	用户类
    查看订单详情	订单详情类

  • 餐厅类 (Restaurant)

    职责 (Responsibilities)	协作 (Collaborations)
    更新餐厅信息	类别类、菜品类
    管理菜品	类别类、菜品类

  • 类别类 (Category)

    职责 (Responsibilities)	协作 (Collaborations)
    添加类别	餐厅类、菜品类
    更新类别	餐厅类、菜品类

  • 菜品类 (Dish)

    职责 (Responsibilities)	协作 (Collaborations)
    添加菜品	类别类、餐厅类、订单详情类
    更新菜品	类别类、餐厅类、订单详情类

  • 订单详情类 (Orderdetail)

    职责 (Responsibilities)	协作 (Collaborations)
    添加订单详情	订单类、菜品类
    更新订单详情	订单类、菜品类

• ​ 域模型

• 用户类

  属性

  • 用户名 : 字符串类型，存储用户的姓名。
  • 电话 : 字符串类型，存储用户的联系方式，如电子邮件或电话号码。
  • 密码 : 字符串类型，存储用户登录的密码。
  • 头像 : 字符串类型，存储用户头像的链接或路径。
  • 注册时间 : 时间戳类型，存储用户注册的时间。

  方法

  • 注册 : 接收用户信息（如姓名、联系方式、地址和登录凭证），在系统中创建新用户。
  • 登录 : 接收用户名和密码，验证用户身份。
  • 浏览菜单 : 允许用户查看餐厅的菜单和菜品。
  • 创建订单 : 允许用户创建新的订单。
  • 查看订单 : 允许用户查看自己的订单历史记录。
  • 更新个人信息 : 允许用户更新自己的个人信息，如联系方式或地址。

  订单类

  属性

  • 订单号 : 整型或字符串类型，唯一标识一个订单。
  • 顾客id : 结构/对象类型，存储下订单的用户信息。
  • 地址id : 整型或字符串类型，存储订单的收货地址。
  • 总价 : 浮点型，存储订单的总价。
  • 创建时间 : 时间戳类型，存储订单的创建时间。
  • 评论 : 字符串类型，存储用户对订单的评论或反馈。
  • 饭店id : 结构/对象类型，存储订单所属的饭店信息。
  • 订单状态 : 字符串类型，表示订单的当前状态（如“待处理”、“配送中”、“已完成”）。

  方法

  • 创建订单 : 创建新订单，记录顾客信息、饭店信息和菜品列表。
  • 更新状态 : 更新订单的当前状态。

  餐厅类

  属性

  • 名称 : 字符串类型，饭店的名称。
  • 地址 : 字符串类型，饭店的地址。
  • 电话 : 字符串类型，饭店的联系电话或电子邮箱。
  • 公告 : 字符串类型，存储饭店的公告或促销信息。
  • 封面图片 : 字符串类型，存储饭店封面图片的链接或路径。
  • 销量 : 整型，存储饭店的总销量。
  • 评分 : 浮点型，存储饭店的平均评分。
  • 注册时间 : 时间戳类型，存储饭店注册的时间。
  • 状态 : 字符串类型，表示饭店的当前状态（如“营业中”、“休息中”、“已关闭”）。

  方法

  • 注册 : 接收饭店的基本信息并在系统中注册。
  • 登录 : 饭店使用注册信息登录系统。
  • 更新信息 : 更新或添加菜单中的菜品。
  • 管理菜品 : 接收并处理来自顾客的订单。

  菜品类

  属性

  • 名称 : 字符串类型，菜品的名称。
  • 类别id : 整型或字符串类型，存储菜品所属的类别。
  • 封面图片 : 字符串类型，存储菜品图片的链接或路径。
  • 描述 : 字符串类型，菜品的描述。
  • 价格 : 浮点型，菜品的价格。
  • 状态 : 字符串类型，表示菜品的当前状态（如“正常销售”、“下架”）。

  方法

  • 添加菜品 : 将新菜品添加到菜单中。
  • 更新菜品信息 : 更新现有菜品的信息，如描述、价格或图片。
  • 删除菜品 : 从菜单中删除菜品。

  地址类

  属性

  • 用户id : 整型或字符串类型，存储地址所属的用户。
  • 姓名 : 字符串类型，存储收货人的姓名。
  • 电话 : 字符串类型，存储收货人的联系电话。
  • 详细地址 : 字符串类型，存储收货人的详细地址。
  • 状态 : 字符串类型，表示地址的当前状态（如“默认地址”、“备用地址”）。

  方法

  • 添加地址 : 将新地址添加到用户的地址列表中。
  • 更新地址 : 更新现有地址的信息，如收货人姓名、电话或详细地址。
  • 删除地址 : 从用户的地址列表中删除地址。

  类别类

  属性

  • 名称 : 字符串类型，类别的名称。
  • 餐厅id : 整型或字符串类型，存储类别所属的餐厅。
  • 状态 : 字符串类型，表示类别的当前状态（如“正常”、“隐藏”）。

  方法

  • 添加类别 : 将新类别添加到菜单中。
  • 更新类别信息 : 更新现有类别的信息，如名称或状态。
  • 删除类别 : 从菜单中删除类别。

  订单详情类

  属性

  • 订单id : 整型或字符串类型，存储订单详情所属的订单。
  • 菜品id : 整型或字符串类型，存储订单详情中的菜品。
  • 价格 : 浮点型，存储菜品的单价。
  • 数量 : 整型，存储菜品的数量。
  • 评分 : 浮点型，存储用户对菜品的评分。

  方法

  • 添加订单详情 : 将新的订单详情添加到订单中。
  • 更新订单详情 : 更新现有订单详情的信息，如菜品数量或评分。
  • 删除订单详情 : 从订单中删除订单详情。

2.系统性能需求

3.系统界面与接口需求

3.1 界面需求

• 界面原则要求

1. 方便性：界面设计简单直观，易于新用户理解和操作。
2. 简洁性：避免了复杂或不必要的元素，确保用户能快速找到所需功能。
3. 美观性：采用了现代化的设计风格，提供视觉上的舒适感。
4. 一致性：整个系统的界面风格保持了一致，确保用户体验的连贯性。

• 系统界面风格定义

1. 风格统一：采用了扁平化设计，使用统一的颜色方案和字体样式。
2. 图标清晰：所有图标简洁、明确，易于理解其功能。
3. 布局合理：界面元素布局合理，确保了信息的层次清晰。

• 功能模块的特殊界面要求

1. 订单管理界面：

   • 显示方式：列表形式展示了订单，包含了订单详情的弹出窗口。
   • 特殊要求：提供了搜索和筛选功能，方便用户快速找到特定订单。

2. 用户账户界面：

   • 显示方式：清晰展示了用户信息，包括了订单历史和个人资料。
   • 特殊要求：确保了个人信息的安全性，提供易于理解的编辑选项。

3. 支付界面：

   • 显示方式：简化支付流程，明确显示支付信息和状态。
   • 特殊要求：集成多种支付方式，确保支付过程的安全性和稳定性。

• 硬件支持

1. 输入设备：

   • 支持键盘和鼠标操作。
   • 移动端优化了触摸屏操作体验。
   • 可以集成扫描仪或条码扫描器以便于饭店管理。

2. 输出设备：

   • 显示器：界面在多种分辨率下保持清晰。
   • 打印机：支持标准的订单打印格式。

• 显示风格和显示方式

1. 显示风格：

   • 主要采用图形界面。

2. 显示方式：

   • 适配常见的显示分辨率，确保在不同设备上的可视性和可用性。

• 输出格式

1. 显示布局：

   • 主页和菜单页面便于导航，信息分类清晰。
   • 订单和支付页面的布局突出重点信息，如价格、订单状态。

2. 打印格式：

   • 订单打印包括所有关键信息，布局清晰，易于阅读。

3.2 接口需求

4.目标系统假设与约束条件

• 法律、法规和政策方面的限制

• 数据保护法规：系统符合当地数据保护法规，特别是在处理个人和支付信息时。

• 食品安全和卫生法规：系统内的饭店必须遵守当地食品安全和卫生标准。

• 电子商务法律：系统运营必须符合电子商务相关的法律法规，包括但不限于在线支付、消费者权益保护等。

• 硬件、软件、运行环境和开发环境方面的条件和限制

• 硬件限制：系统设计适应多种硬件设备，包括不同性能级别的服务器、多种类型和尺寸的显示设备。

• 软件限制：系统兼容主流操作系统和浏览器，如Windows、macOS、Linux，以及Chrome、Firefox、Safari等。

• 开发环境限制：团队需要适应敏捷开发环境和持续集成/持续部署（CI/CD）流程。

• 运行环境限制：系统能在云环境中稳定运行，需考虑到云服务提供商的可用性和性能限制。

• 可利用的信息和资源

  • 市场调研：系统设计基于详细的市场调研，包括目标用户群的需求和行为模式。

  • 技术资源：可利用的技术资源包括开源框架、API、开发工具和云平台服务。

  • 财务资源：项目预算应覆盖开发、测试、部署、运营和市场推广的成本。

• 系统投入使用的最晚日期

  • 上线时间：系统最晚于2023.1.5前完成，以便于最后答辩，教师检查。

  • 阶段性目标：项目的每个阶段（如，需求分析、设计、开发、测试、部署）已有明确的时间节点，确保了整体项目按时完成。

三、设计规格说明书

1.引言

1.1 命名规则

1.1.1变量对象命名规则

1. 全局变量：

   • 使用全大写字母和下划线分隔，例如：GLOBAL_CONFIG。
   • 名称反映其功能或用途，例如：MAX_RETRY_COUNT。
   • 在声明处附有详细注释说明其用途。

2. 局部变量：

   • 使用小写字母，多个单词之间使用驼峰式命名，例如：localCounter。
   • 名称具体且有描述性，如：currentPageIndex。
   • 对于循环迭代变量，使用简单字符，如i、j。

3. 对象：

   • 类名使用大写字母开头的驼峰式命名，例如：OrderDetail。
   • 方法名使用小写字母开头的驼峰式命名，例如：calculateTotalPrice。
   • 对于私有属性和方法，使用下划线作为前缀，例如：_internalMethod。

1.1.2数据库对象命名规则

1. 数据库表名：

   • 使用全小写字母，多个单词之间使用下划线分隔，例如：user_account。
   • 名称直观反映表的内容，例如：order_history。

2. 字段名：

   • 同样使用全小写字母和下划线分隔，例如：creation_date。
   • 精确描述字段含义，避免使用缩写，除非非常通用。

3. 索引名：

   • 命名格式为：表名_字段名_idx，例如：user_account_email_idx。
   • 清晰表明索引的用途。

4. 视图名：

   • 使用全小写字母，多个单词使用下划线分隔，例如：view_user_details。
   • 名称清楚地描述视图的内容和用途。

1.2 术语定义

1.3 相关文档

1. 项目需求文档：

   • 描述项目的功能需求、性能需求、界面需求、接口需求等。
   • 任何功能的增加、删除或修改都需要在此文档中反映。

2. 设计文档：

   • 包括系统架构设计、数据库设计、界面设计等。
   • 设计文档需根据需求变更进行相应的调整。

3. 技术规范文档：

   • 描述技术实现的具体细节，如编码规范、命名规则、开发工具和环境等。
   • 需要更新以反映新的技术选择或方法。

4. 测试计划和测试案例：

   • 包含测试策略、测试场景、测试用例和测试脚本。
   • 任何需求的变更都需要更新测试计划和测试案例，以确保测试覆盖所有功能。

5. 用户手册：

   • 提供系统的使用说明，帮助用户理解和使用系统。
   • 随着系统功能的变更，用户手册需相应更新。

6. 部署和维护指南：

   • 包括系统部署的步骤、配置方法以及维护和故障排除指导。
   • 随着系统环境和配置的变更，这些文档需要被更新。

7. 项目进度计划：

   • 描述项目的时间线、阶段性目标和关键里程碑。
   • 变更可能会影响项目的交付时间和阶段性目标，需要更新进度计划。

8. 风险评估报告：

   • 评估项目的潜在风险及其影响。
   • 需要根据项目变更重新评估风险。

9. 变更管理文档：

   • 记录项目变更的详细信息，包括变更的内容、影响、实施计划和批准信息。
   • 每次项目变更都需要更新此文档。

2.系统设计

2.1 体系结构设计

2.1.1逻辑模型 - 包图

2.1.2物理模型 - 部署图

• CDN加速：通过CDN分发静态资源，减少网络延迟，提高用户访问速度。CDN节点遍布多个地理位置，可以根据用户位置提供最近的数据源。
• Nginx反向代理：Nginx服务器作为入口，统一处理用户请求。配置反向代理以转发特定前缀（如/api）的请求，同时解决CORS跨域问题。为保证安全，Nginx会添加特定的请求头进行身份校验。
• 轮询负载均衡：请求通过轮询策略均匀分配到多个Tomcat服务器上，以均衡负载并提高系统的处理能力。
• Spring Cloud网关：所有服务请求首先经过Spring Cloud网关，它根据路由规则将请求分发到相应的微服务。网关还负责JWT的权限校验，确保每个请求都是合法和安全的。
• 缓存策略：使用Spring Cache和Redis来缓存频繁访问的数据，减少数据库查询，提高响应速度。合理的数据淘汰策略确保缓存的数据是最新的，同时减轻MySQL的压力。
• RabbitMQ中间件：RabbitMQ用于不同模块间的异步通信，提高系统的响应性和可扩展性。
• Spring Boot Admin监控：使用Spring Boot Admin对系统的健康状况和性能指标进行监控，及时发现并解决问题。
• MySQL优化：MySQL数据库采用主从复制和读写分离策略。主库处理写操作，从库处理读操作。这不仅提高了数据库的查询效率，还增加了数据的安全性。
• Sharding-JDBC分库分表：通过Sharding-JDBC对数据库进行分库分表处理，进一步提高数据处理能力，保证大规模数据操作的效率。

2.2 类设计

1.点餐下单

2.查看订单

3.查看餐厅

4.分类管理

5.菜品管理

6.订单明细

类之间的关系:

1. 用户类 (User) 与 地址类 (Address) 的关联：
   • 关联重数 (Multiplicity): 1对多 (一个用户可以有多个地址，但一个地址只属于一个用户)
   • 关联方向 (Direction): 双向关联 (用户可以访问其地址列表，地址可以知道所属用户)
   • 关联类 (Associated Classes): User 类与 Address 类之间存在关联
2. 用户类 (User) 与 订单类 (Orders) 的关联：
   • 关联重数 (Multiplicity): 1对多 (一个用户可以有多个订单，但一个订单只属于一个用户)
   • 关联方向 (Direction): 双向关联 (用户可以访问其订单列表，订单可以知道所属用户)
   • 关联类 (Associated Classes): User 类与 Orders 类之间存在关联
3. 餐厅类 (Restaurant) 与 订单类 (Orders)的关联：
   • 关联重数 (Multiplicity): 1对多 (一个餐厅可以有多个订单项，但一个订单项只属于一个餐厅)
   • 关联方向 (Direction): 双向关联 (餐厅可以访问其订单列表，订单项可以知道所属餐厅)
   • 关联类 (Associated Classes): Restaurant类与 Orders类之间存在关联
4. 地址类 (Address) 与 订单类 (Orders) 的关联：
   • 关联重数 (Multiplicity): 1对多 (一个地址可以有多个订单，但一个订单只有一个地址)
   • 关联方向 (Direction): 双向关联 (地址可以访问其订单列表，订单可以知道所属地址)
   • 关联类 (Associated Classes): Address 类与 Orders 类之间存在关联
5. 餐厅类 (Restaurant) 与 类别类 (Category) 的关联：
   • 关联重数 (Multiplicity): 1对多 (一个餐厅可以有多个类别，但一个类别只属于一个餐厅)
   • 关联方向 (Direction): 双向关联 (餐厅可以访问其类别列表，类别可以知道所属餐厅)
   • 关联类 (Associated Classes): Restaurant 类与 Category 类之间存在关联
6. 类别类 (Category) 与 菜品类 (Dish) 的关联：
   • 关联重数 (Multiplicity): 1对多 (一个类别可以有多个菜品，但一个菜品只属于一个类别)
   • 关联方向 (Direction): 双向关联 (类别可以访问其菜品列表，菜品可以知道所属类别)
   • 关联类 (Associated Classes): Category 类与 Dish 类之间存在关联
7. 餐厅类 (Restaurant) 与 菜品类 (Dish) 的关联：
   • 关联重数 (Multiplicity): 1对多 (一个餐厅可以有多个菜品，但一个菜品只属于一个餐厅)
   • 关联方向 (Direction): 双向关联 (餐厅可以访问其菜品列表，菜品可以知道所属餐厅)
   • 关联类 (Associated Classes): Restaurant 类与 Dish 类之间存在关联
8. 订单类 (Orders) 与 订单详情类 (Orderdetail) 的关联：
   • 关联重数 (Multiplicity): 1对多 (一个订单可以有多个订单详情，但一个订单详情只属于一个订单)
   • 关联方向 (Direction): 双向关联 (订单可以访问其订单详情列表，订单详情可以知道所属订单)
   • 关联类 (Associated Classes): Orders 类与 Orderdetail 类之间存在关联

2.3 类说明

• 用户类

  • 属性

    • 用户名 : 字符串类型，存储用户的姓名。

    • 电话 : 字符串类型，存储用户的联系方式，如电子邮件或电话号码。

    • 密码 : 字符串类型，存储用户登录的密码。

    • 头像 : 字符串类型，存储用户头像的链接或路径。

    • 注册时间 : 时间戳类型，存储用户注册的时间。

  • 方法

    • 注册 : 接收用户信息（如姓名、联系方式、地址和登录凭证），在系统中创建新用户。

    • 登录 : 接收用户名和密码，验证用户身份。

    • 浏览菜单 : 允许用户查看餐厅的菜单和菜品。

    • 创建订单 : 允许用户创建新的订单。

    • 查看订单 : 允许用户查看自己的订单历史记录。

    • 更新个人信息 : 允许用户更新自己的个人信息，如联系方式或地址。

• 订单类

  • 属性

    • 订单号 : 整型或字符串类型，唯一标识一个订单。

    • 顾客id : 结构/对象类型，存储下订单的用户信息。

    • 地址id : 整型或字符串类型，存储订单的收货地址。

    • 总价 : 浮点型，存储订单的总价。

    • 创建时间 : 时间戳类型，存储订单的创建时间。

    • 评论 : 字符串类型，存储用户对订单的评论或反馈。

    • 饭店id : 结构/对象类型，存储订单所属的饭店信息。

    • 订单状态 : 字符串类型，表示订单的当前状态（如“待处理”、“配送中”、“已完成”）。

  • 方法

    • 创建订单 : 创建新订单，记录顾客信息、饭店信息和菜品列表。

    • 更新状态 : 更新订单的当前状态。

• 餐厅类

  • 属性

    • 名称 : 字符串类型，饭店的名称。

    • 地址 : 字符串类型，饭店的地址。

    • 电话 : 字符串类型，饭店的联系电话或电子邮箱。

    • 公告 : 字符串类型，存储饭店的公告或促销信息。

    • 封面图片 : 字符串类型，存储饭店封面图片的链接或路径。

    • 销量 : 整型，存储饭店的总销量。

    • 评分 : 浮点型，存储饭店的平均评分。

    • 注册时间 : 时间戳类型，存储饭店注册的时间。

    • 状态 : 字符串类型，表示饭店的当前状态（如“营业中”、“休息中”、“已关闭”）。

  • 方法

    • 注册 : 接收饭店的基本信息并在系统中注册。

    • 登录 : 饭店使用注册信息登录系统。

    • 更新信息 : 更新或添加菜单中的菜品。

    • 管理菜品 : 接收并处理来自顾客的订单。

• 菜品类

  • 属性

    • 名称 : 字符串类型，菜品的名称。

    • 类别id : 整型或字符串类型，存储菜品所属的类别。

    • 封面图片 : 字符串类型，存储菜品图片的链接或路径。

    • 描述 : 字符串类型，菜品的描述。

    • 价格 : 浮点型，菜品的价格。

    • 状态 : 字符串类型，表示菜品的当前状态（如“正常销售”、“下架”）。

  • 方法

    • 添加菜品 : 将新菜品添加到菜单中。

    • 更新菜品信息 : 更新现有菜品的信息，如描述、价格或图片。

    • 删除菜品 : 从菜单中删除菜品。

• 地址类

  • 属性

    • 用户id : 整型或字符串类型，存储地址所属的用户。

    • 姓名 : 字符串类型，存储收货人的姓名。

    • 电话 : 字符串类型，存储收货人的联系电话。

    • 详细地址 : 字符串类型，存储收货人的详细地址。

    • 状态 : 字符串类型，表示地址的当前状态（如“默认地址”、“备用地址”）。

  • 方法

    • 添加地址 : 将新地址添加到用户的地址列表中。

    • 更新地址 : 更新现有地址的信息，如收货人姓名、电话或详细地址。

    • 删除地址 : 从用户的地址列表中删除地址。

• 类别类

  • 属性

    • 名称 : 字符串类型，类别的名称。

    • 餐厅id : 整型或字符串类型，存储类别所属的餐厅。

    • 状态 : 字符串类型，表示类别的当前状态（如“正常”、“隐藏”）。

  • 方法

    • 添加类别 : 将新类别添加到菜单中。

    • 更新类别信息 : 更新现有类别的信息，如名称或状态。

    • 删除类别 : 从菜单中删除类别。

• 订单详情类

  • 属性

    • 订单id : 整型或字符串类型，存储订单详情所属的订单。

    • 菜品id : 整型或字符串类型，存储订单详情中的菜品。

    • 价格 : 浮点型，存储菜品的单价。

    • 数量 : 整型，存储菜品的数量。

    • 评分 : 浮点型，存储用户对菜品的评分。

  • 方法

    • 添加订单详情 : 将新的订单详情添加到订单中。

    • 更新订单详情 : 更新现有订单详情的信息，如菜品数量或评分。

    • 删除订单详情 : 从订单中删除订单详情。

3.数据结构设计

3.1持久类分析

1. Address（地址）：
   • 描述：用于存储用户地址信息。
   • 属性：ID、用户ID（uid）、姓名、电话、详细地址、状态。
   • 数据库映射：映射到一个地址表，每个字段对应一个列。
2. Category（分类）：
   • 描述：代表菜品或商品的类别。
   • 属性：ID、餐厅ID（rid）、名称、状态。
   • 数据库映射：对应一个分类表，包含各种菜品或商品分类。
3. Deliver（配送员）：
   • 描述：存储配送员的信息。
   • 属性：ID、姓名、电话、密码、头像、状态。
   • 数据库映射：映射到一个配送员信息表。
4. Dish（菜品）：
   • 描述：代表菜单上的一个菜品。
   • 属性：ID、分类ID（cid）、餐厅ID（rid）、名称、描述、价格、折扣、封面图片、状态。
   • 数据库映射：映射到一个菜品表，包含各种菜品的详细信息。
5. OrderDetail（订单详情）：
   • 描述：存储关于订单中具体菜品的信息。
   • 属性：ID、订单ID（oid）、菜品ID（did）、菜品对象、价格、评分、数量。
   • 数据库映射：映射到一个订单详情表，包含订单中每个菜品的信息。
6. Orders（订单）：
   • 描述：代表用户的一个订单。
   • 属性：ID、用户ID（uid）、地址ID（aid）、餐厅ID（rid）、总价格、创建时间、评论、状态。
   • 数据库映射：映射到一个订单表，记录用户的订单信息。
7. Restaurant（餐厅）：
   • 描述：存储餐厅的信息。
   • 属性：ID、名称、电话、密码、公告、地址、封面、销量、评分、评分百分比、注册时间、状态。
   • 数据库映射：映射到一个餐厅信息表。
8. ShopCar（购物车）：
   • 描述：用户的购物车信息。
   • 属性：ID、用户ID（uid）、菜品ID（did）、餐厅ID（rid）、数量。
   • 数据库映射：可能映射到一个购物车表，记录用户添加到购物车的菜品。
9. User（用户）：
   • 描述：存储用户的基本信息。
   • 属性：ID、用户名、电话、密码、头像、注册时间、状态。
   • 数据库映射：映射到一个用户信息表。

这些类共同构成了此外卖系统的后端数据模型，涵盖了用户、订单、菜品、餐厅等核心功能的数据结构。

3.2 数据库表名清单

3.3 数据库表之间关系

3.4 数据库表的详细清单

• Address 表（地址表）

  表3-3. 地址表

  序号	字段中文名	字段英文名	类型、宽度、精度	取值约束	空否	默认值	主键/外键	索引否
  1	编号	id	bigint		否		主键	是
  2	用户ID	uid	bigint		是		外键	是
  3	姓名	name	varchar(255)		是
  4	电话	phone	varchar(255)		是
  5	详细地址	detail	varchar(255)		是
  6	状态	status	bigint		否	‘1’

• Category 表（类别表）

  表3-4. 类别表

  序号	字段中文名	字段英文名	类型、宽度、精度	取值约束	空否	默认值	主键/外键	索引否
  1	编号	id	bigint		否		主键	是
  2	餐厅ID	rid	bigint		否		外键	是
  3	名称	name	varchar(255)		否
  4	状态	status	int	0,1,2,3,4,5	是

• Deliver 表（配送员表）

  表3-5. 配送员表

  序号	字段中文名	字段英文名	类型、宽度、精度	取值约束	空否	默认值	主键/外键	索引否
  1	编号	id	bigint		否		主键	是
  2	姓名	name	varchar(255)		否
  3	电话	phone	varchar(255)		否
  4	密码	password	varchar(255)		否
  5	头像	avatar	varchar(255)		否
  6	状态	status	int		否

• Dish 表（菜品表）

  表3-6. 菜品表

  序号	字段中文名	字段英文名	类型、宽度、精度	取值约束	空否	默认值	主键/外键	索引否
  1	编号	id	bigint		否		主键	是
  2	类别ID	cid	bigint		否		外键	是
  3	名称	name	varchar(255)		否
  4	描述	descr	varchar(255)		是
  5	价格	price	decimal(6,2)		否
  6	折扣	discount	decimal(4,2)		否	0.00
  7	封面图片	cover	varchar(255)		是
  8	状态	status	int	0,1,2,3,4,5	是
  9	餐厅ID	rid	bigint		是		外键	是

• Domap 表（骑手订单表）

  表3-7. 骑手订单表

  序号	字段中文名	字段英文名	类型、宽度、精度	取值约束	空否	默认值	主键/外键	索引否
  1	菜品ID	did	bigint		否
  2	订单ID	oid	bigint		否
  3	评论	comment	varchar(255)		是

• Orderdetail 表（订单详情表）

  表3-8. 订单详情表

  序号	字段中文名	字段英文名	类型、宽度、精度	取值约束	空否	默认值	主键/外键	索引否
  1	编号	id	bigint		否		主键	是
  2	订单ID	oid	bigint		是		外键	是
  3	菜品ID	did	bigint		是		外键	是
  4	价格	price	decimal(6,2)		是
  5	评分	mark	int	0至5	是	‘0’
  6	数量	quantity	int		否	‘1’

• Orders 表（订单表）

  表3-9. 订单表

  序号	字段中文名	字段英文名	类型、宽度、精度	取值约束	空否	默认值	主键/外键	索引否
  1	编号	id	bigint		否		主键	是
  2	用户ID	uid	bigint		是		外键	是
  3	地址ID	aid	bigint		是		外键	是
  4	总价	totalprice	decimal(8,2)		是
  5	创建时间	create_time	datetime		否	当前时间
  6	评论	comment	varchar(255)		是
  7	状态	status	int	0至5	是
  8	餐厅ID	rid	bigint		否		外键	是

• Restaurant 表（餐厅表）

  表3-10. 餐厅表

  序号	字段中文名	字段英文名	类型、宽度、精度	取值约束	空否	默认值	主键/外键	索引否
  1	编号	id	bigint		否		主键	是
  2	名称	name	varchar(255)		否
  3	电话	phone	varchar(255)		否			是
  4	密码	password	varchar(255)		否
  5	公告	announce	varchar(255)		是
  6	地址	address	varchar(255)		是
  7	封面图片	cover	varchar(255)		是
  8	销量	sale	bigint		否	‘0’
  9	评分	mark	decimal(2,1)	1至5	是
  10	抽成比例	percent	decimal(4,2)		否	10.00
  11	注册时间	regtime	datetime		是	当前时间
  12	状态	status	int	0至5	是	‘0’

• Shopcar 表（购物车表）

  表3-11. 购物车表

  序号	字段中文名	字段英文名	类型、宽度、精度	取值约束	空否	默认值	主键/外键	索引否
  1	编号	id	bigint		否		主键	是
  2	用户ID	uid	bigint		否		外键	是
  3	菜品ID	did	bigint		否		外键	是
  4	数量	quantity	int		否	‘1’
  5	餐厅ID	rid	bigint		是			是

• User 表（用户表）

  表3-12. 用户表

  序号	字段中文名	字段英文名	类型、宽度、精度	取值约束	空否	默认值	主键/外键	索引否
  1	编号	id	bigint		否		主键	是
  2	用户名	username	varchar(255)		否
  3	电话	phone	varchar(255)		否			是
  4	密码	password	varchar(255)		否
  5	头像	avatar	varchar(255)		是
  6	注册时间	regtime	datetime		否	当前时间
  7	状态	status	int	0至5	否	‘0’

3.5视图设计

• 视图1: 用户订单详情视图

  • 中文名: 用户订单详情

  • 英文名: UserOrderDetails

  • 列定义

    1. 中文列名: 用户名

       • 英文列名: UserName
       • 类型、宽度、精度: varchar(255)
       • 算法: 直接引用 user 表的 username
       • 基本表名: user

    2. 中文列名: 菜品名称

       • 英文列名: DishName
       • 类型、宽度、精度: varchar(255)
       • 算法: 直接引用 dish 表的 name
       • 基本表名: dish

    3. 中文列名: 订单创建时间

       • 英文列名: OrderCreateTime
       • 类型、宽度、精度: datetime
       • 算法: 直接引用 orders 表的 create_time
       • 基本表名: orders

    4. 中文列名: 总价

       • 英文列名: TotalPrice
       • 类型、宽度、精度: decimal(8,2)
       • 算法: orderdetail 表的 price 乘以 quantity
       • 基本表名: orderdetail

• 视图2: 餐厅菜品销量视图

  • 中文名: 餐厅菜品销量

  • 英文名: RestaurantDishSales

  • 列定义

    1. 中文列名: 餐厅名称

       • 英文列名: RestaurantName
    • 类型、宽度、精度: varchar(255)
      • 算法: 直接引用 restaurant 表的 name
    • 基本表名: restaurant

    2. 中文列名: 菜品名称

       • 英文列名: DishName
    • 类型、宽度、精度: varchar(255)
      • 算法: 直接引用 dish 表的 name
    • 基本表名: dish

  3. 中文列名: 销售数量

     • 英文列名: SalesQuantity
     • 类型、宽度、精度: int
     • 算法: 汇总 orderdetail 表中的 quantity
     • 基本表名: orderdetail

• 视图3: 用户地址信息视图

  • 中文名: 用户地址信息

  • 英文名: UserAddressInfo

  • 列定义

    1. 中文列名: 用户名

       • 英文列名: UserName

  • 类型、宽度、精度: varchar(255)

    • 算法: 直接引用 user 表的 username

  • 基本表名: user

  2. 中文列名: 地址详情

     • 英文列名: AddressDetail
  • 类型、宽度、精度: varchar(255)
    • 算法: 直接引用 address 表的 detail
  • 基本表名: address

3.6存储过程与触发器设计

​ 由于springboot提供了完备的业务解决方案，java代码和事务可以完成此工作，为了防止管理混乱，统一使用java代码完成所有业务逻辑

四、系统实现及测试报告

1.系统界面

1.1 商家端页面

• 登录界面

  

  图4-1. 登录界面

• 分类管理

  

  图4-2. 分类管理界面

  

  图4-3. 分类管理界面

• 菜品管理

  

  图4-4. 菜品管理界面

  

  图4-5. 菜品管理界面

• 订单明细

  

  图4-6. 订单明细界面

  

  图4-7. 订单明细界面

• 店铺设置

  

  图4-8. 店铺设置界面

• 数据统计

  

  图4-9. 数据统计界面

1.2 用户端界面

• 登录

  图4-10. 登录界面

• 浏览餐厅

  图4-11. 浏览餐厅界面

• 搜索餐厅

  图4-12. 搜索餐厅界面

• 选购菜品

  图4-13. 选购菜品界面

• 购物车

  图4-14. 购物车界面

• 选择地址

  图4-15. 选择地址界面

• 添加地址

  图4-16. 添加地址界面

• 订单记录

  图4-17. 订单记录界面

• 用户信息管理

  图4-18. 用户管理界面

2.系统实现模块说明

2.1 用户登录注册

• 描述

  • 用户登录和自动注册: 在用户登录时，首先根据手机号查询用户是否已注册。如果未注册，则自动为用户生成一个用户名，并进行注册。如果已注册，则验证密码。无论是自动注册还是登录，最终都会生成一个包含用户ID、手机号和token的信息返回给客户端。

  • 用户登出: 提供用户登出的接口，但目前实际执行的操作尚未完成，仅打印了当前用户的ID和手机号。

• 主要代码

  /**
   * 用户注册, 无则注册, 有则登陆
   *
   * @param user
   * @return
   */
  @PostMapping("/login")
  public ApiResponse<Map<String, String>> login(@RequestBody User user) {
      System.out.println("用户请求登录: " + user);
      // 最终返回的数据
      Map<String, String> infoMap = new HashMap<>();
      // 判断用户名和密码是否正确
      LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
      wrapper.eq(User::getPhone, user.getPhone());
      if (userService.getOne(wrapper) == null) {
          // 用户未注册
          // 组装username
          user.setUsername("用户_" + StringUtil.generateRandomString(5));
          user.setStatus(EntityStatus.NORMAL.intValue());
          userService.save(user);
          HashMap<String, Object> map = new HashMap<>();
          map.put("id", user.getId());
          map.put("phone", user.getPhone());
          infoMap.put("id", user.getId().toString());
          infoMap.put("phone", user.getPhone());
          infoMap.put("token", JwtUtil.generateToken(map));
          log.info("用户注册: {}", user.getId());
          return ApiResponse.success(infoMap, "初次登陆,自动注册!");
      }
      LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
      queryWrapper.eq(User::getPhone, user.getPhone()).eq(User::getPassword, user.getPassword());
      User one = userService.getOne(queryWrapper);
      if (one == null) {
          // 账号或密码错误
          return ApiResponse.error(200, "用户账号或密码错误");
      }
      // 登录成功
      HashMap<String, Object> map = new HashMap<>();
      map.put("id", one.getId());
      map.put("phone", one.getPhone());
      log.info("用户登陆: {}", one.getId());
  
      infoMap.put("id", one.getId().toString());
      infoMap.put("phone", one.getPhone());
      infoMap.put("token", JwtUtil.generateToken(map));
      return ApiResponse.success(infoMap, "用户登录成功!");
  }
  
  /**
   * 用户登出
   *
   * @return
   */
  @PostMapping("/logout")
  public ApiResponse<Boolean> logout() {
      Map<String, Object> map = ThreadLocalUtil.get();
      System.out.println(map.get("id"));
      System.out.println(map.get("phone"));
      return null;
  }
  

2.2 查找餐厅

1. 分页查询商户:根据页码、每页数量和查询关键字，分页查询商户信息。

   /**
    * 分页查询商户
    *
    * @param page 页码
    * @param size 每页的数量
    * @param key  查询关键字
    * @return 查询出来的商户
    */
   @GetMapping("/page")
   public ApiResponse<Object> getAllRests(@RequestParam(value = "page", required = false) Integer page,
                                          @RequestParam(value = "size", required = false) Integer size,
                                          @RequestParam(value = "key", required = false) String key) {
       LambdaQueryWrapper<Restaurant> queryWrapper = new LambdaQueryWrapper<>();
       queryWrapper.like(Restaurant::getName, key == null ? "" : key);
       if (page == null || size == null) {
           return ApiResponse.success(restaurantService.list(queryWrapper), "关键字查询");
       }
       IPage iPage = new Page(page, size);
       return ApiResponse.success(restaurantService.page(iPage, queryWrapper), "分页查询");
   }
   

2. 获取商户信息:根据商户ID获取商户的详细信息。

       @GetMapping("/info")
       public ApiResponse<Restaurant> getRestaurantById(@RequestParam(value = "id", required = false) Long id) {
           return ApiResponse.success(restaurantService.getById(id == null ? ThreadLocalUtil.getId() : id), "获取成功" + id);
       }
   

2.3 点餐下单

1. **查看菜品分类列表：**用户根据餐厅ID获取该餐厅的分类列表。只返回状态为NORMAL的分类，即过滤掉已删除或非活动的分类。

   /**
    * 用户获取餐厅分类列表
    *
    * @param rid 餐厅id
    * @return
    */
   @GetMapping("/user/list")
   public ApiResponse<List<Category>> getCategoryListUser(@RequestParam("rid") Long rid) {
       LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper<>();
       // 返回启用的分类
       queryWrapper.eq(Category::getRid, rid)
               .eq(Category::getStatus, EntityStatus.NORMAL);
       return ApiResponse.success(categoryService.list(queryWrapper), "用户获取饭店分类列表成功!");
   }
   

2. **查看菜品列表：**允许用户根据餐厅ID和分类ID获取菜品列表，同时支持分页功能。

       @GetMapping("/user/list")
       public ApiResponse<IPage> getDishListUser(@RequestParam(value = "rid", required = false) Long rid, @RequestParam("cid") Long cid,
                                                 @RequestParam(value = "page", required = false) Integer page,
                                                 @RequestParam(value = "size", required = false) Integer size) {
           IPage iPage;
           if (page == null || size == null) {
               iPage = new Page(1, 10000);
           } else {
               iPage = new Page(page, size);
           }
           LambdaQueryWrapper<Dish> dishWrapper = new LambdaQueryWrapper<>();
           // 返回正常的菜品
           dishWrapper.eq(Dish::getCid, cid);
           return ApiResponse.success(dishService.page(iPage, dishWrapper), "用户获取分页菜品成功!");
       }
   

3. 获取用户购物车内容:根据用户ID和餐厅ID获取用户在当前餐厅的购物车内容。

   /**
    * 获取用户在当前餐厅中购物车内容
    *
    * @param rid 当前餐厅
    * @return
    */
   @GetMapping("/list")
   public ApiResponse<List<Map>> getUserShopCar(@RequestParam("rid") Long rid) {
       Long uid = ThreadLocalUtil.getId();
       log.info("请求购物车,用户uid: {}", uid);
       List<Map> dataMaps = new ArrayList<>();
       LambdaQueryWrapper<ShopCar> queryWrapper = new LambdaQueryWrapper<>();
       // 获取用户在当前餐厅的购物车
       queryWrapper.eq(ShopCar::getUid, uid)
               .eq(ShopCar::getRid, rid);
       List<ShopCar> shopCars = shopCarService.list(queryWrapper);
       for (ShopCar shopCar : shopCars) {
           LambdaQueryWrapper<Dish> dishWrapper = new LambdaQueryWrapper<>();
           Map<String, Object> dataMap = new HashMap<>();
           dishWrapper.eq(Dish::getId, shopCar.getDid());
           // 组装数据
           Dish dish = dishService.getOne(dishWrapper);
           dataMap.put("id", shopCar.getId());
           dataMap.put("name", dish.getName());
           dataMap.put("quantity", shopCar.getQuantity());
           dataMap.put("cover", dish.getCover());
           dataMap.put("price", dish.getPrice());
           dataMap.put("discount", dish.getDiscount());
           dataMap.put("descr", dish.getDescr());
           dataMap.put("dish", dish);
           dataMaps.add(dataMap);
       }
       return ApiResponse.success(dataMaps, "获取用户购物车成功!");
   }
   

4. 更新用户购物车:根据用户ID更新购物车信息，包括添加、删除和更新购物车中的菜品。

       /**
        * 更新用户购物车
        *
        * @param shopCars
        * @return
        */
       @PostMapping("/update")
       @Transactional
       public ApiResponse<Boolean> addShopCar(@RequestBody List<ShopCar> shopCars) {
           Long uid = ThreadLocalUtil.getId();
           for (ShopCar shopCar : shopCars) {
               shopCar.setUid(uid);
               log.info("更新购物车信息: {}", shopCar);
               if (shopCar.getQuantity() == null || shopCar.getQuantity() == 0) {
                   // 删除此记录
                   boolean remove = shopCarService.removeById(shopCar.getId());
               }
               // 无则添加
               if (shopCar.getId() == null) {
                   boolean save = shopCarService.save(shopCar);
   //                return save ? ApiResponse.success(Boolean.TRUE, "添加成功!") : ApiResponse.error(ResponseStatus.ERROR, "添加失败");
               }
               // 有则更新
               boolean update = shopCarService.updateById(shopCar);
   //            return update ? ApiResponse.success(update, "更新成功") : ApiResponse.error("保存失败!");
           }
           return ApiResponse.success(Boolean.TRUE, "操作成功");
       }
   

5. 用户提交订单：用户从购物车中创建新订单，并生成相应的订单详情。

       /**
        * 用户下单, 从购物车查询出, 创建新订单, 创建对应的订单详情
        *
        * @return
        */
       @PostMapping("/submit")
       @Transactional
       public ApiResponse<Boolean> submitOrder(@RequestBody SubmitOrder submitOrder) {
           if (submitOrder == null || submitOrder.getCart() == null || submitOrder.getCart().size() == 0) {
               return ApiResponse.error(0, "数据体异常!");
           }
           Long uid = ThreadLocalUtil.getId();
           Long[] scids = submitOrder.getCart().toArray(new Long[0]);
           Long aid = submitOrder.getAid();
           Long rid = submitOrder.getRid();
           String comment = submitOrder.getComment();
           if (scids == null || scids.length == 0) {
               return ApiResponse.error(ResponseStatus.ERROR, "购物车id为空!");
           }
   //        LambdaQueryWrapper<ShopCar> shopCarWrapper = new LambdaQueryWrapper<>();
   //        shopCarWrapper.eq(ShopCar::getUid, uid);
           List<ShopCar> shopCars = shopCarService.listByIds(Arrays.asList(scids));
           if (shopCars.size() == 0) {
               return ApiResponse.error(0, "购物车为空!");
           }
           // 创建新订单
           Orders orders = new Orders();
           orders.setStatus(0L);
           orders.setAid(aid);
           orders.setUid(uid);
           orders.setRid(rid);
           orders.setComment(comment);
           ordersService.save(orders);
           List<OrderDetail> details = new ArrayList<>();
           for (ShopCar shopCar : shopCars) {
               // 创建每一个订单详情
               OrderDetail orderDetail = new OrderDetail();
               orderDetail.setOid(orders.getId());
               orderDetail.setDid(shopCar.getDid());
               orderDetail.setQuantity(shopCar.getQuantity().intValue());
               log.error("did: {}, quantity: {}", orderDetail.getDid(), orderDetail.getQuantity());
               // 创建dish查询
               LambdaQueryWrapper<Dish> dishWrapper = new LambdaQueryWrapper<>();
               dishWrapper.eq(Dish::getId, orderDetail.getDid());
               Dish dish = dishService.getOne(dishWrapper);
               // 计算订单详情价格
               orderDetail.setPrice(BigDecimal.valueOf((dish.getPrice().doubleValue() * (1 - dish.getDiscount().doubleValue() / 10)) * shopCar.getQuantity()));
               details.add(orderDetail);
           }
           // 保存orderDetail
           boolean orderDetailFlag = orderDetailService.saveBatch(details);
           // 清空购物车
   //        boolean removeFlag = shopCarService.remove(shopCarWrapper);
           boolean removeFlag = shopCarService.removeByIds(Arrays.asList(scids));
           return orderDetailFlag && removeFlag ? ApiResponse.success(Boolean.TRUE, "提交成功!") : ApiResponse.error(0, "提交失败!");
       }
   

6. 更新订单状态:根据传入的订单对象更新订单状态，例如支付、发货、完成或退款。

   /**
    * 更新订单
    *
    * @param order 传入的订单
    * @return
    */
   @PostMapping("/rest/update")
   public ApiResponse<Boolean> update(@RequestBody Orders order) {
       // 留作扩展，根据订单状态执行对应的逻辑
       if (order.getStatus() == OrdersStatus.ORDER_STATUS_PAY) {
   
       }
       if (order.getStatus() == OrdersStatus.ORDER_STATUS_DELIVER) {
   
       }
       if (order.getStatus() == OrdersStatus.ORDER_STATUS_COMPLETE) {
   
       }
       if (order.getStatus() == OrdersStatus.ORDER_STATUS_REFUND) {
   
       }
       boolean update = ordersService.updateById(order);
       return update ? ApiResponse.success(update, "更新成功") : ApiResponse.error(0, "更新失败");
   }
   

2.4 地址管理

1. 获取用户地址列表：

   @GetMapping("/list")
   public ApiResponse<List<Address>> getUserAddress() {
       Long uid = ThreadLocalUtil.getId();
       LambdaQueryWrapper<Address> queryWrapper = new LambdaQueryWrapper<>();
       queryWrapper.eq(Address::getUid, uid)
                   .eq(Address::getStatus, EntityStatus.NORMAL);
       return ApiResponse.success(addressService.list(queryWrapper), "用户获取地址成功!");
   }
   

2. 新增或更新地址：

       /**
        * 新增或更新地址, 有则更新, 无则添加
        *
        * @param address
        * @return
        */
       @PostMapping("/update")
       public ApiResponse<Boolean> addAddress(@RequestBody Address address) {
           Long uid = ThreadLocalUtil.getId();
           address.setUid(uid);
           if (address.getId() == null) {
               // 新增地址
               log.info("新增地址信息: {}", address);
               boolean save = addressService.save(address);
               return save ? ApiResponse.success(save, "新增地址成功") : ApiResponse.error(0, "新增地址失败!");
   
           }
           // 更新地址
           boolean update = addressService.updateById(address);
           return update ? ApiResponse.success(update, "更新地址成功!") : ApiResponse.error(0, "更新地址失败");
       }
   

2.5 查看订单记录

1. 获取用户的订单（分页功能）:允许用户获取自己的订单列表，支持分页功能。

   @GetMapping("/user")
   public ApiResponse<IPage> getUserOrders(@RequestParam(value = "page", required = false) Integer page,
                                           @RequestParam(value = "size", required = false) Integer size,
                                           @RequestParam(value = "status", required = false) String status) {
       Map map = ThreadLocalUtil.get();
       Long uid = (Long) map.get("id");
       log.info("请求订单,用户uid: {}", uid);
       LambdaQueryWrapper<Orders> queryWrapper = new LambdaQueryWrapper<>();
       queryWrapper.eq(Orders::getUid, uid);
       if (page == null || size == null) {
           // 返回全部订单
           return ApiResponse.success(ordersService.page(new Page<>(1, 100000), queryWrapper), "返回用户全部订单");
       }
       IPage iPage = new Page(page, size);
       return ApiResponse.success(ordersService.page(iPage, queryWrapper), "返回用户订单" + page + "," + size);
   }
   

2. 获取用户的订单列表并展示订单详情:显示用户订单列表的详细信息，包括订单中的餐厅、地址、用户信息等。

   /**
    * 获取用户订单列表
    * @param page
    * @param size
    * @return
    */
   @GetMapping("/user/list")
   public ApiResponse<IPage> getUserOrders(@RequestParam(value = "page", required = false) Integer page,
                                           @RequestParam(value = "size", required = false) Integer size) {
       // 存放结果的ipage
       IPage<Map<String, Object>> resultIPage = new Page();
       // 存放拼装好的map结果
       List<Map<String, Object>> resultInfos = new ArrayList<>();
       // 获取用户uid
       Long uid = ThreadLocalUtil.getId();
       // 根据用户uid查询订单
       LambdaQueryWrapper<Orders> ordersWrapper = new LambdaQueryWrapper<>();
       ordersWrapper.eq(Orders::getUid, uid);
       // 判断分页
       IPage<Orders> iPage;
       if (page == null || size == null) {
           iPage = new Page<>(1, 10000);
       } else {
           iPage = new Page<>(page, size);
       }
       // 执行分页查询
       IPage<Orders> ordersIPage = ordersService.page(iPage, ordersWrapper);
       for (Orders orders : ordersIPage.getRecords()) {
           // 查询对应的餐厅
           LambdaQueryWrapper<Restaurant> restaurantLambdaQueryWrapper = new LambdaQueryWrapper<>();
           restaurantLambdaQueryWrapper.eq(Restaurant::getId, orders.getRid());
           Restaurant restaurant = restaurantService.getOne(restaurantLambdaQueryWrapper);
           // 查询对应的地址信息
           LambdaQueryWrapper<Address> addressLambdaQueryWrapper = new LambdaQueryWrapper<>();
           addressLambdaQueryWrapper.eq(Address::getId, orders.getAid());
           Address address = addressService.getOne(addressLambdaQueryWrapper);
           // 查询对应的用户信息
           LambdaQueryWrapper<User> userLambdaQueryWrapper = new LambdaQueryWrapper<>();
           userLambdaQueryWrapper.eq(User::getId, orders.getUid());
           User user = userService.getOne(userLambdaQueryWrapper);
           // 组装数据
           Map resultInfo = new HashMap();
           resultInfo.put("id",  orders.getId());
           resultInfo.put("restaurant", restaurant);
           resultInfo.put("address", address);
           resultInfo.put("user", user);
           resultInfo.put("status", orders.getStatus());
           resultInfo.put("totalprice", orders.getTotalprice());
           resultInfo.put("create_time", orders.getCreateTime());
           resultInfo.put("comment", orders.getComment());
           resultInfos.add(resultInfo);
       }
       // 组装ipage
       resultIPage.setRecords(resultInfos);
       resultIPage.setTotal(iPage.getTotal());
       resultIPage.setSize(iPage.getSize());
       resultIPage.setCurrent(iPage.getCurrent());
       resultIPage.setPages(iPage.getPages());
       return ApiResponse.success(resultIPage, "用户获取订单列表成功!");
   }
   

3. 评价订单详情:允许用户对订单详情进行评分。用户提供订单详情的ID（odid）和评分（mark），然后系统会更新对应的订单详情记录。

   /**
    * 对订单详情进行评分
    *
    * @param odid 要评价的orderDetail id
    * @param mark 给出的评分
    * @return
    */
   @GetMapping("/evaluate")
   public ApiResponse<Boolean> evaluate(@RequestParam("odid") Long odid, @RequestParam("mark") Double mark) {
       OrderDetail orderDetail = orderDetailService.getById(odid);
       orderDetail.setMark(mark);
       boolean update = orderDetailService.updateById(orderDetail);
       return update ? ApiResponse.success(Boolean.TRUE, "评价成功!") : ApiResponse.error("评价失败!");
   }