test00

BusinessDataVO.java

@@ -0,0 +1,30 @@
+package com.sky.vo; // 定义了类的包名，通常用于组织和管理类文件
+
+import lombok.AllArgsConstructor; // 导入 Lombok 库提供的 @AllArgsConstructor 注解，用于生成全参数的构造方法
+import lombok.Builder; // 导入 Lombok 库提供的 @Builder 注解，用于生成 Builder 模式的链式构造方法
+import lombok.Data; // 导入 Lombok 库提供的 @Data 注解，用于生成 getter/setter 方法以及 toString、equals 和 hashCode 方法
+import lombok.NoArgsConstructor; // 导入 Lombok 库提供的 @NoArgsConstructor 注解，用于生成无参的构造方法
+
+import java.io.Serializable; // 导入 Java 序列化接口，用于将对象序列化成字节流
+
+/**
+ * 数据概览
+ */ // 类的文档注释，描述了这个类的作用
+
+@Data // 使用 Lombok 的 @Data 注解，自动生成 getter/setter 方法以及 toString、equals 和 hashCode 方法
+@Builder // 使用 Lombok 的 @Builder 注解，自动生成 Builder 模式的链式构造方法
+@NoArgsConstructor // 使用 Lombok 的 @NoArgsConstructor 注解，自动生成无参的构造方法
+@AllArgsConstructor // 使用 Lombok 的 @AllArgsConstructor 注解，自动生成全参数的构造方法
+public class BusinessDataVO implements Serializable { // 声明了一个名为 BusinessDataVO 的类，实现了 Serializable 接口，用于对象的序列化
+
+    private Double turnover; // 成员变量，表示营业额，类型为 Double
+
+    private Integer validOrderCount; // 成员变量，表示有效订单数，类型为 Integer
+
+    private Double orderCompletionRate; // 成员变量，表示订单完成率，类型为 Double
+
+    private Double unitPrice; // 成员变量，表示平均客单价，类型为 Double
+
+    private Integer newUsers; // 成员变量，表示新增用户数，类型为 Integer
+
+} // 类定义结束

DishItemVO.java

@@ -0,0 +1,28 @@
+package com.sky.vo; // 定义了类的包名，通常用于组织和管理类文件
+
+import lombok.AllArgsConstructor; // 导入 Lombok 库提供的 @AllArgsConstructor 注解，用于生成全参数的构造方法
+import lombok.Builder; // 导入 Lombok 库提供的 @Builder 注解，用于生成 Builder 模式的链式构造方法
+import lombok.Data; // 导入 Lombok 库提供的 @Data 注解，用于生成 getter/setter 方法以及 toString、equals 和 hashCode 方法
+import lombok.NoArgsConstructor; // 导入 Lombok 库提供的 @NoArgsConstructor 注解，用于生成无参的构造方法
+
+import java.io.Serializable; // 导入 Java 序列化接口，用于将对象序列化成字节流
+
+@Data // 使用 Lombok 的 @Data 注解，自动生成 getter/setter 方法以及 toString、equals 和 hashCode 方法
+@Builder // 使用 Lombok 的 @Builder 注解，自动生成 Builder 模式的链式构造方法
+@NoArgsConstructor // 使用 Lombok 的 @NoArgsConstructor 注解，自动生成无参的构造方法
+@AllArgsConstructor // 使用 Lombok 的 @AllArgsConstructor 注解，自动生成全参数的构造方法
+public class DishItemVO implements Serializable { // 声明了一个名为 DishItemVO 的类，实现了 Serializable 接口，用于对象的序列化
+
+    //菜品名称
+    private String name; // 成员变量，表示菜品的名称，类型为 String
+
+    //份数
+    private Integer copies; // 成员变量，表示菜品的份数，类型为 Integer
+
+    //菜品图片
+    private String image; // 成员变量，表示菜品的图片链接，类型为 String
+
+    //菜品描述
+    private String description; // 成员变量，表示菜品的描述信息，类型为 String
+
+} // 类定义结束

DishOverViewVO.java

@@ -0,0 +1,25 @@
+package com.sky.vo; // 定义了类的包名，用于组织和管理类文件
+
+import lombok.AllArgsConstructor; // 导入 Lombok 库提供的 @AllArgsConstructor 注解，用于生成包含所有属性的构造函数
+import lombok.Builder; // 导入 Lombok 库提供的 @Builder 注解，用于生成建造者模式的构造函数
+import lombok.Data; // 导入 Lombok 库提供的 @Data 注解，用于自动生成 getter、setter、equals、hashCode 和 toString 方法
+import lombok.NoArgsConstructor; // 导入 Lombok 库提供的 @NoArgsConstructor 注解，用于生成无参构造函数
+
+import java.io.Serializable; // 导入 Java 序列化接口，使得对象可以被序列化和反序列化
+
+/**
+ * 菜品总览
+ */ // 类的文档注释，描述了这个类的作用和功能
+@Data // 使用 Lombok 的 @Data 注解，自动为类生成 getter、setter、equals、hashCode 和 toString 方法
+@Builder // 使用 Lombok 的 @Builder 注解，自动为类生成建造者模式的链式构造方法
+@NoArgsConstructor // 使用 Lombok 的 @NoArgsConstructor 注解，自动为类生成无参构造方法
+@AllArgsConstructor // 使用 Lombok 的 @AllArgsConstructor 注解，自动为类生成包含所有属性的构造方法
+public class DishOverViewVO implements Serializable { // 声明了一个名为 DishOverViewVO 的类，实现了 Serializable 接口，用于对象的序列化
+
+    // 已启售数量
+    private Integer sold; // 成员变量，表示已经启售的菜品数量，类型为 Integer
+
+    // 已停售数量
+    private Integer discontinued; // 成员变量，表示已经停售的菜品数量，类型为 Integer
+
+} // 类定义结束

DishVO.java

@@ -0,0 +1,41 @@
+package com.sky.vo; // 定义了类的包名，用于组织和管理类文件
+
+import com.sky.entity.DishFlavor; // 导入 DishFlavor 实体类，用于表示菜品的口味信息
+import lombok.AllArgsConstructor; // 导入 Lombok 库提供的 @AllArgsConstructor 注解，用于生成包含所有属性的构造函数
+import lombok.Builder; // 导入 Lombok 库提供的 @Builder 注解，用于生成建造者模式的构造函数
+import lombok.Data; // 导入 Lombok 库提供的 @Data 注解，用于自动生成 getter、setter、equals、hashCode 和 toString 方法
+import lombok.NoArgsConstructor; // 导入 Lombok 库提供的 @NoArgsConstructor 注解，用于生成无参构造函数
+import java.io.Serializable; // 导入 Java 序列化接口，使得对象可以被序列化和反序列化
+import java.math.BigDecimal; // 导入 BigDecimal 类，用于精确表示货币等数值
+import java.time.LocalDateTime; // 导入 LocalDateTime 类，用于表示日期和时间
+import java.util.ArrayList; // 导入 ArrayList 类，用于创建动态数组
+import java.util.List; // 导入 List 接口，用于表示元素集合
+
+@Data // 使用 Lombok 的 @Data 注解，自动为类生成 getter、setter、equals、hashCode 和 toString 方法
+@Builder // 使用 Lombok 的 @Builder 注解，自动为类生成建造者模式的链式构造方法
+@NoArgsConstructor // 使用 Lombok 的 @NoArgsConstructor 注解，自动为类生成无参构造方法
+@AllArgsConstructor // 使用 Lombok 的 @AllArgsConstructor 注解，自动为类生成包含所有属性的构造方法
+public class DishVO implements Serializable { // 声明了一个名为 DishVO 的类，实现了 Serializable 接口，用于对象的序列化
+
+    private Long id; // 成员变量，表示菜品的唯一标识符，类型为 Long
+    //菜品名称
+    private String name; // 成员变量，表示菜品的名称，类型为 String
+    //菜品分类id
+    private Long categoryId; // 成员变量，表示菜品所属分类的唯一标识符，类型为 Long
+    //菜品价格
+    private BigDecimal price; // 成员变量，表示菜品的价格，类型为 BigDecimal，用于精确表示价格
+    //图片
+    private String image; // 成员变量，表示菜品的图片链接，类型为 String
+    //描述信息
+    private String description; // 成员变量，表示菜品的描述信息，类型为 String
+    //0 停售 1 起售
+    private Integer status; // 成员变量，表示菜品的上架状态，0表示停售，1表示起售
+    //更新时间
+    private LocalDateTime updateTime; // 成员变量，表示菜品信息的最后更新时间，类型为 LocalDateTime
+    //分类名称
+    private String categoryName; // 成员变量，表示菜品所属分类的名称，类型为 String
+    //菜品关联的口味
+    private List<DishFlavor> flavors = new ArrayList<>(); // 成员变量，表示菜品关联的口味列表，初始为空的 ArrayList
+
+    //private Integer copies; // 被注释掉的成员变量，可能表示菜品的份数，类型为 Integer，当前未被使用
+} // 类定义结束

EmployeeLoginVO.java

@@ -0,0 +1,31 @@
+package com.sky.vo; // 定义了类的包名，用于组织和管理类文件
+
+import io.swagger.annotations.ApiModel; // 导入 Swagger 的 @ApiModel 注解，用于描述模型信息
+import io.swagger.annotations.ApiModelProperty; // 导入 Swagger 的 @ApiModelProperty 注解，用于描述模型属性信息
+import lombok.AllArgsConstructor; // 导入 Lombok 库提供的 @AllArgsConstructor 注解，用于生成包含所有属性的构造函数
+import lombok.Builder; // 导入 Lombok 库提供的 @Builder 注解，用于生成建造者模式的构造函数
+import lombok.Data; // 导入 Lombok 库提供的 @Data 注解，用于自动生成 getter、setter、equals、hashCode 和 toString 方法
+import lombok.NoArgsConstructor; // 导入 Lombok 库提供的 @NoArgsConstructor 注解，用于生成无参构造函数
+
+import java.io.Serializable; // 导入 Java 序列化接口，使得对象可以被序列化和反序列化
+
+@Data // 使用 Lombok 的 @Data 注解，自动为类生成 getter、setter、equals、hashCode 和 toString 方法
+@Builder // 使用 Lombok 的 @Builder 注解，自动为类生成建造者模式的链式构造方法
+@NoArgsConstructor // 使用 Lombok 的 @NoArgsConstructor 注解，自动为类生成无参构造方法
+@AllArgsConstructor // 使用 Lombok 的 @AllArgsConstructor 注解，自动为类生成包含所有属性的构造方法
+@ApiModel(description = "员工登录返回的数据格式") // 使用 Swagger 的 @ApiModel 注解，描述这个 VO 对象是员工登录返回的数据格式
+public class EmployeeLoginVO implements Serializable { // 声明了一个名为 EmployeeLoginVO 的类，实现了 Serializable 接口，用于对象的序列化
+
+    @ApiModelProperty("主键值") // 使用 Swagger 的 @ApiModelProperty 注解，描述这个属性是主键值
+    private Long id; // 成员变量，表示员工的唯一标识符，类型为 Long
+
+    @ApiModelProperty("用户名") // 使用 Swagger 的 @ApiModelProperty 注解，描述这个属性是用户名
+    private String userName; // 成员变量，表示员工的用户名，类型为 String
+
+    @ApiModelProperty("姓名") // 使用 Swagger 的 @ApiModelProperty 注解，描述这个属性是姓名
+    private String name; // 成员变量，表示员工的姓名，类型为 String
+
+    @ApiModelProperty("jwt令牌") // 使用 Swagger 的 @ApiModelProperty 注解，描述这个属性是 JWT 令牌
+    private String token; // 成员变量，表示员工登录后获得的 JWT 令牌，类型为 String
+
+} // 类定义结束

OrderOverViewVO.java

@@ -0,0 +1,34 @@
+package com.sky.vo; // 定义了类的包名，用于组织和管理类文件
+
+import lombok.AllArgsConstructor; // 导入 Lombok 库提供的 @AllArgsConstructor 注解，用于生成包含所有属性的构造函数
+import lombok.Builder; // 导入 Lombok 库提供的 @Builder 注解，用于生成建造者模式的构造函数
+import lombok.Data; // 导入 Lombok 库提供的 @Data 注解，用于自动生成 getter、setter、equals、hashCode 和 toString 方法
+import lombok.NoArgsConstructor; // 导入 Lombok 库提供的 @NoArgsConstructor 注解，用于生成无参构造函数
+
+import java.io.Serializable; // 导入 Java 序列化接口，使得对象可以被序列化和反序列化
+
+/**
+ * 订单概览数据
+ */ // 类的文档注释，描述了这个类的作用和功能
+@Data // 使用 Lombok 的 @Data 注解，自动为类生成 getter、setter、equals、hashCode 和 toString 方法
+@Builder // 使用 Lombok 的 @Builder 注解，自动为类生成建造者模式的链式构造方法
+@NoArgsConstructor // 使用 Lombok 的 @NoArgsConstructor 注解，自动为类生成无参构造方法
+@AllArgsConstructor // 使用 Lombok 的 @AllArgsConstructor 注解，自动为类生成包含所有属性的构造方法
+public class OrderOverViewVO implements Serializable { // 声明了一个名为 OrderOverViewVO 的类，实现了 Serializable 接口，用于对象的序列化
+
+    //待接单数量
+    private Integer waitingOrders; // 成员变量，表示待接单的数量，类型为 Integer
+
+    //待派送数量
+    private Integer deliveredOrders; // 成员变量，表示待派送的数量，类型为 Integer
+
+    //已完成数量
+    private Integer completedOrders; // 成员变量，表示已完成的数量，类型为 Integer
+
+    //已取消数量
+    private Integer cancelledOrders; // 成员变量，表示已取消的数量，类型为 Integer
+
+    //全部订单
+    private Integer allOrders; // 成员变量，表示全部订单的数量，类型为 Integer
+
+} // 类定义结束

OrderPaymentVO.java

@@ -0,0 +1,28 @@
+package com.sky.vo; // 定义了类的包名，用于组织和管理类文件
+
+import lombok.AllArgsConstructor; // 导入 Lombok 库提供的 @AllArgsConstructor 注解，用于生成包含所有属性的构造函数
+import lombok.Builder; // 导入 Lombok 库提供的 @Builder 注解，用于生成建造者模式的构造函数
+import lombok.Data; // 导入 Lombok 库提供的 @Data 注解，用于自动生成 getter、setter、equals、hashCode 和 toString 方法
+import lombok.NoArgsConstructor; // 导入 Lombok 库提供的 @NoArgsConstructor 注解，用于生成无参构造函数
+
+import java.io.Serializable; // 导入 Java 序列化接口，使得对象可以被序列化和反序列化
+import java.time.LocalDateTime; // 导入 Java 8 的日期时间类，用于处理日期和时间
+
+@Data // 使用 Lombok 的 @Data 注解，自动为类生成 getter、setter、equals、hashCode 和 toString 方法
+@Builder // 使用 Lombok 的 @Builder 注解，自动为类生成建造者模式的链式构造方法
+@NoArgsConstructor // 使用 Lombok 的 @NoArgsConstructor 注解，自动为类生成无参构造方法
+@AllArgsConstructor // 使用 Lombok 的 @AllArgsConstructor 注解，自动为类生成包含所有属性的构造方法
+public class OrderPaymentVO implements Serializable { // 声明了一个名为 OrderPaymentVO 的类，实现了 Serializable 接口，用于对象的序列化
+
+    private String nonceStr; // 成员变量，表示随机字符串，用于支付过程中的随机性保护
+    //随机字符串
+    private String paySign; // 成员变量，表示签名，用于验证支付请求的安全性
+    //签名
+    private String timeStamp; // 成员变量，表示时间戳，用于记录支付请求的时间
+    //时间戳
+    private String signType; // 成员变量，表示签名算法，用于指定签名的加密方式
+    //签名算法
+    private String packageStr; // 成员变量，表示统一下单接口返回的 prepay_id 参数值，用于后续支付流程
+    //统一下单接口返回的 prepay_id 参数值
+
+} // 类定义结束

OrderReportVO.java

@@ -0,0 +1,34 @@
+package com.sky.vo; // 定义了类的包名，用于组织和管理类文件
+
+import lombok.AllArgsConstructor; // 导入 Lombok 库提供的 @AllArgsConstructor 注解，用于生成包含所有属性的构造函数
+import lombok.Builder; // 导入 Lombok 库提供的 @Builder 注解，用于生成建造者模式的构造函数
+import lombok.Data; // 导入 Lombok 库提供的 @Data 注解，用于自动生成 getter、setter、equals、hashCode 和 toString 方法
+import lombok.NoArgsConstructor; // 导入 Lombok 库提供的 @NoArgsConstructor 注解，用于生成无参构造函数
+
+import java.io.Serializable; // 导入 Java 序列化接口，使得对象可以被序列化和反序列化
+
+@Data // 使用 Lombok 的 @Data 注解，自动为类生成 getter、setter、equals、hashCode 和 toString 方法
+@Builder // 使用 Lombok 的 @Builder 注解，自动为类生成建造者模式的链式构造方法
+@NoArgsConstructor // 使用 Lombok 的 @NoArgsConstructor 注解，自动为类生成无参构造方法
+@AllArgsConstructor // 使用 Lombok 的 @AllArgsConstructor 注解，自动为类生成包含所有属性的构造方法
+public class OrderReportVO implements Serializable { // 声明了一个名为 OrderReportVO 的类，实现了 Serializable 接口，用于对象的序列化
+
+    //日期，以逗号分隔，例如：2022-10-01,2022-10-02,2022-10-03
+    private String dateList; // 成员变量，表示一系列日期，格式为 "YYYY-MM-DD"，日期之间用逗号分隔
+
+    //每日订单数，以逗号分隔，例如：260,210,215
+    private String orderCountList; // 成员变量，表示每天的订单数量，数字之间用逗号分隔
+
+    //每日有效订单数，以逗号分隔，例如：20,21,10
+    private String validOrderCountList; // 成员变量，表示每天的有效订单数量，数字之间用逗号分隔
+
+    //订单总数
+    private Integer totalOrderCount; // 成员变量，表示订单的总数
+
+    //有效订单数
+    private Integer validOrderCount; // 成员变量，表示有效订单的总数
+
+    //订单完成率
+    private Double orderCompletionRate; // 成员变量，表示订单完成率，以小数形式表示
+
+} // 类定义结束

OrderStatisticsVO.java

@@ -0,0 +1,18 @@
+package com.sky.vo; // 定义了类的包名，用于组织和管理类文件
+
+import lombok.Data; // 导入 Lombok 库提供的 @Data 注解，用于自动生成 getter、setter、equals、hashCode 和 toString 方法
+import java.io.Serializable; // 导入 Java 序列化接口，使得对象可以被序列化和反序列化
+
+@Data // 使用 Lombok 的 @Data 注解，自动为类生成 getter、setter、equals、hashCode 和 toString 方法
+public class OrderStatisticsVO implements Serializable { // 声明了一个名为 OrderStatisticsVO 的类，实现了 Serializable 接口，用于对象的序列化
+
+    //待接单数量
+    private Integer toBeConfirmed; // 成员变量，表示待接单的数量，类型为 Integer
+
+    //待派送数量
+    private Integer confirmed; // 成员变量，表示已经确认但尚未开始派送的订单数量，类型为 Integer
+
+    //派送中数量
+    private Integer deliveryInProgress; // 成员变量，表示正在派送中的订单数量，类型为 Integer
+
+} // 类定义结束

OrderSubmitVO.java

@@ -0,0 +1,30 @@
+package com.sky.vo; // 定义了类的包名，用于组织和管理类文件
+
+import lombok.AllArgsConstructor; // 导入 Lombok 库提供的 @AllArgsConstructor 注解，用于生成包含所有属性的构造函数
+import lombok.Builder; // 导入 Lombok 库提供的 @Builder 注解，用于生成建造者模式的构造函数
+import lombok.Data; // 导入 Lombok 库提供的 @Data 注解，用于自动生成 getter、setter、equals、hashCode 和 toString 方法
+import lombok.NoArgsConstructor; // 导入 Lombok 库提供的 @NoArgsConstructor 注解，用于生成无参构造函数
+
+import java.io.Serializable; // 导入 Java 序列化接口，使得对象可以被序列化和反序列化
+import java.math.BigDecimal; // 导入 BigDecimal 类，用于精确表示货币等数值
+import java.time.LocalDateTime; // 导入 LocalDateTime 类，用于表示日期和时间
+
+@Data // 使用 Lombok 的 @Data 注解，自动为类生成 getter、setter、equals、hashCode 和 toString 方法
+@Builder // 使用 Lombok 的 @Builder 注解，自动为类生成建造者模式的链式构造方法
+@NoArgsConstructor // 使用 Lombok 的 @NoArgsConstructor 注解，自动为类生成无参构造方法
+@AllArgsConstructor // 使用 Lombok 的 @AllArgsConstructor 注解，自动为类生成包含所有属性的构造方法
+public class OrderSubmitVO implements Serializable { // 声明了一个名为 OrderSubmitVO 的类，实现了 Serializable 接口，用于对象的序列化
+
+    //订单id
+    private Long id; // 成员变量，表示订单的唯一标识符，类型为 Long
+
+    //订单号
+    private String orderNumber; // 成员变量，表示订单的编号，类型为 String
+
+    //订单金额
+    private BigDecimal orderAmount; // 成员变量，表示订单的金额，类型为 BigDecimal，用于精确表示金额
+
+    //下单时间
+    private LocalDateTime orderTime; // 成员变量，表示下单的时间，类型为 LocalDateTime
+
+} // 类定义结束

OrderVO.java

@@ -0,0 +1,23 @@
+package com.sky.vo; // 定义了类的包名，用于组织和管理类文件
+
+import com.sky.entity.OrderDetail; // 导入 OrderDetail 实体类，用于表示订单中的具体菜品详情
+import com.sky.entity.Orders; // 导入 Orders 实体类，OrderVO 将继承这个类
+import lombok.AllArgsConstructor; // 导入 Lombok 库提供的 @AllArgsConstructor 注解，用于生成包含所有属性的构造函数
+import lombok.Data; // 导入 Lombok 库提供的 @Data 注解，用于自动生成 getter、setter、equals、hashCode 和 toString 方法
+import lombok.NoArgsConstructor; // 导入 Lombok 库提供的 @NoArgsConstructor 注解，用于生成无参构造函数
+
+import java.io.Serializable; // 导入 Java 序列化接口，使得对象可以被序列化和反序列化
+import java.util.List; // 导入 Java 集合框架中的 List 接口，用于表示元素列表
+
+@Data // 使用 Lombok 的 @Data 注解，自动为类生成 getter、setter、equals、hashCode 和 toString 方法
+@NoArgsConstructor // 使用 Lombok 的 @NoArgsConstructor 注解，自动为类生成无参构造方法
+@AllArgsConstructor // 使用 Lombok 的 @AllArgsConstructor 注解，自动为类生成包含所有属性的构造方法
+public class OrderVO extends Orders implements Serializable { // 声明了一个名为 OrderVO 的类，继承自 Orders 类，并实现了 Serializable 接口，用于对象的序列化
+
+    //订单菜品信息
+    private String orderDishes; // 成员变量，表示订单中包含的菜品信息，类型为 String
+
+    //订单详情
+    private List<OrderDetail> orderDetailList; // 成员变量，表示订单中每个菜品的详细列表，类型为 OrderDetail 对象的 List
+
+} // 类定义结束

README.md

@@ -1,2 +0,0 @@
-# WMS-2024-001
-

SalesTop10ReportVO.java

@@ -0,0 +1,22 @@
+package com.sky.vo; // 定义了类的包名，用于组织和管理类文件
+
+import lombok.AllArgsConstructor; // 导入 Lombok 库提供的 @AllArgsConstructor 注解，用于生成包含所有属性的构造函数
+import lombok.Builder; // 导入 Lombok 库提供的 @Builder 注解，用于生成建造者模式的构造函数
+import lombok.Data; // 导入 Lombok 库提供的 @Data 注解，用于自动生成 getter、setter、equals、hashCode 和 toString 方法
+import lombok.NoArgsConstructor; // 导入 Lombok 库提供的 @NoArgsConstructor 注解，用于生成无参构造函数
+
+import java.io.Serializable; // 导入 Java 序列化接口，使得对象可以被序列化和反序列化
+
+@Data // 使用 Lombok 的 @Data 注解，自动为类生成 getter、setter、equals、hashCode 和 toString 方法
+@Builder // 使用 Lombok 的 @Builder 注解，自动为类生成建造者模式的链式构造方法
+@NoArgsConstructor // 使用 Lombok 的 @NoArgsConstructor 注解，自动为类生成无参构造方法
+@AllArgsConstructor // 使用 Lombok 的 @AllArgsConstructor 注解，自动为类生成包含所有属性的构造方法
+public class SalesTop10ReportVO implements Serializable { // 声明了一个名为 SalesTop10ReportVO 的类，实现了 Serializable 接口，用于对象的序列化
+
+    //商品名称列表，以逗号分隔，例如：鱼香肉丝,宫保鸡丁,水煮鱼
+    private String nameList; // 成员变量，表示商品名称的列表，多个名称以逗号分隔，类型为 String
+
+    //销量列表，以逗号分隔，例如：260,215,200
+    private String numberList; // 成员变量，表示对应商品的销量列表，多个销量数值以逗号分隔，类型为 String
+
+} // 类定义结束

SetmealOverViewVO.java

@@ -0,0 +1,25 @@
+package com.sky.vo; // 定义了类的包名，用于组织和管理类文件
+
+import lombok.AllArgsConstructor; // 导入 Lombok 库提供的 @AllArgsConstructor 注解，用于生成包含所有属性的构造函数
+import lombok.Builder; // 导入 Lombok 库提供的 @Builder 注解，用于生成建造者模式的构造函数
+import lombok.Data; // 导入 Lombok 库提供的 @Data 注解，用于自动生成 getter、setter、equals、hashCode 和 toString 方法
+import lombok.NoArgsConstructor; // 导入 Lombok 库提供的 @NoArgsConstructor 注解，用于生成无参构造函数
+
+import java.io.Serializable; // 导入 Java 序列化接口，使得对象可以被序列化和反序列化
+
+/**
+ * 套餐总览
+ */ // 类的文档注释，描述了这个类的作用和功能，即提供套餐的总览信息
+@Data // 使用 Lombok 的 @Data 注解，自动为类生成 getter、setter、equals、hashCode 和 toString 方法
+@Builder // 使用 Lombok 的 @Builder 注解，自动为类生成建造者模式的链式构造方法
+@NoArgsConstructor // 使用 Lombok 的 @NoArgsConstructor 注解，自动为类生成无参构造方法
+@AllArgsConstructor // 使用 Lombok 的 @AllArgsConstructor 注解，自动为类生成包含所有属性的构造方法
+public class SetmealOverViewVO implements Serializable { // 声明了一个名为 SetmealOverViewVO 的类，实现了 Serializable 接口，用于对象的序列化
+
+    // 已启售数量
+    private Integer sold; // 成员变量，表示已经启售的套餐数量，类型为 Integer
+
+    // 已停售数量
+    private Integer discontinued; // 成员变量，表示已经停售的套餐数量，类型为 Integer
+
+} // 类定义结束

SetmealVO.java

@@ -0,0 +1,50 @@
+package com.sky.vo; // 定义了类的包名，用于组织和管理类文件
+
+import com.sky.entity.SetmealDish; // 导入 SetmealDish 实体类，用于表示套餐与菜品的关联关系
+import lombok.AllArgsConstructor; // 导入 Lombok 库提供的 @AllArgsConstructor 注解，用于生成包含所有属性的构造函数
+import lombok.Builder; // 导入 Lombok 库提供的 @Builder 注解，用于生成建造者模式的构造函数
+import lombok.Data; // 导入 Lombok 库提供的 @Data 注解，用于自动生成 getter、setter、equals、hashCode 和 toString 方法
+import lombok.NoArgsConstructor; // 导入 Lombok 库提供的 @NoArgsConstructor 注解，用于生成无参构造函数
+
+import java.io.Serializable; // 导入 Java 序列化接口，使得对象可以被序列化和反序列化
+import java.math.BigDecimal; // 导入 BigDecimal 类，用于精确表示货币等数值
+import java.time.LocalDateTime; // 导入 LocalDateTime 类，用于表示日期和时间
+import java.util.ArrayList; // 导入 ArrayList 类，用于创建动态数组
+import java.util.List; // 导入 List 接口，用于表示元素集合
+
+@Data // 使用 Lombok 的 @Data 注解，自动为类生成 getter、setter、equals、hashCode 和 toString 方法
+@Builder // 使用 Lombok 的 @Builder 注解，自动为类生成建造者模式的链式构造方法
+@NoArgsConstructor // 使用 Lombok 的 @NoArgsConstructor 注解，自动为类生成无参构造方法
+@AllArgsConstructor // 使用 Lombok 的 @AllArgsConstructor 注解，自动为类生成包含所有属性的构造方法
+public class SetmealVO implements Serializable { // 声明了一个名为 SetmealVO 的类，实现了 Serializable 接口，用于对象的序列化
+
+    private Long id; // 成员变量，表示套餐的唯一标识符，类型为 Long
+
+    //分类id
+    private Long categoryId; // 成员变量，表示套餐所属分类的唯一标识符，类型为 Long
+
+    //套餐名称
+    private String name; // 成员变量，表示套餐的名称，类型为 String
+
+    //套餐价格
+    private BigDecimal price; // 成员变量，表示套餐的价格，类型为 BigDecimal，用于精确表示价格
+
+    //状态 0:停用 1:启用
+    private Integer status; // 成员变量，表示套餐的状态，0 表示停用，1 表示启用
+
+    //描述信息
+    private String description; // 成员变量，表示套餐的描述信息，类型为 String
+
+    //图片
+    private String image; // 成员变量，表示套餐的图片链接，类型为 String
+
+    //更新时间
+    private LocalDateTime updateTime; // 成员变量，表示套餐信息的最后更新时间，类型为 LocalDateTime
+
+    //分类名称
+    private String categoryName; // 成员变量，表示套餐所属分类的名称，类型为 String
+
+    //套餐和菜品的关联关系
+    private List<SetmealDish> setmealDishes = new ArrayList<>(); // 成员变量，表示套餐与菜品的关联关系列表，初始为空的 ArrayList
+
+} // 类定义结束

TurnoverReportVO.java

@@ -0,0 +1,22 @@
+package com.sky.vo; // 定义了类的包名，用于组织和管理类文件
+
+import lombok.AllArgsConstructor; // 导入 Lombok 库提供的 @AllArgsConstructor 注解，用于生成包含所有属性的构造函数
+import lombok.Builder; // 导入 Lombok 库提供的 @Builder 注解，用于生成建造者模式的构造函数
+import lombok.Data; // 导入 Lombok 库提供的 @Data 注解，用于自动生成 getter、setter、equals、hashCode 和 toString 方法
+import lombok.NoArgsConstructor; // 导入 Lombok 库提供的 @NoArgsConstructor 注解，用于生成无参构造函数
+
+import java.io.Serializable; // 导入 Java 序列化接口，使得对象可以被序列化和反序列化
+
+@Data // 使用 Lombok 的 @Data 注解，自动为类生成 getter、setter、equals、hashCode 和 toString 方法
+@Builder // 使用 Lombok 的 @Builder 注解，自动为类生成建造者模式的链式构造方法
+@NoArgsConstructor // 使用 Lombok 的 @NoArgsConstructor 注解，自动为类生成无参构造方法
+@AllArgsConstructor // 使用 Lombok 的 @AllArgsConstructor 注解，自动为类生成包含所有属性的构造方法
+public class TurnoverReportVO implements Serializable { // 声明了一个名为 TurnoverReportVO 的类，实现了 Serializable 接口，用于对象的序列化
+
+    //日期，以逗号分隔，例如：2022-10-01,2022-10-02,2022-10-03
+    private String dateList; // 成员变量，表示一系列日期，格式为 "YYYY-MM-DD"，日期之间用逗号分隔
+
+    //营业额，以逗号分隔，例如：406.0,1520.0,75.0
+    private String turnoverList; // 成员变量，表示对应日期的营业额列表，营业额数值之间用逗号分隔
+
+} // 类定义结束

UserLoginVO.java

@@ -0,0 +1,20 @@
+package com.sky.vo; // 定义了类的包名，用于组织和管理类文件
+
+import lombok.AllArgsConstructor; // 导入 Lombok 库提供的 @AllArgsConstructor 注解，用于生成包含所有属性的构造函数
+import lombok.Builder; // 导入 Lombok 库提供的 @Builder 注解，用于生成建造者模式的构造函数
+import lombok.Data; // 导入 Lombok 库提供的 @Data 注解，用于自动生成 getter、setter、equals、hashCode 和 toString 方法
+import lombok.NoArgsConstructor; // 导入 Lombok 库提供的 @NoArgsConstructor 注解，用于生成无参构造函数
+
+import java.io.Serializable; // 导入 Java 序列化接口，使得对象可以被序列化和反序列化
+
+@Data // 使用 Lombok 的 @Data 注解，自动为类生成 getter、setter、equals、hashCode 和 toString 方法
+@Builder // 使用 Lombok 的 @Builder 注解，自动为类生成建造者模式的链式构造方法
+@NoArgsConstructor // 使用 Lombok 的 @NoArgsConstructor 注解，自动为类生成无参构造方法
+@AllArgsConstructor // 使用 Lombok 的 @AllArgsConstructor 注解，自动为类生成包含所有属性的构造方法
+public class UserLoginVO implements Serializable { // 声明了一个名为 UserLoginVO 的类，实现了 Serializable 接口，用于对象的序列化
+
+    private Long id; // 成员变量，表示用户的唯一标识符，类型为 Long
+    private String openid; // 成员变量，表示用户的 openid，通常用于标识第三方平台的用户，类型为 String
+    private String token; // 成员变量，表示用户的登录令牌，用于身份验证和授权，类型为 String
+
+} // 类定义结束

UserReportVO.java

@@ -0,0 +1,25 @@
+package com.sky.vo; // 定义了类的包名，用于组织和管理类文件
+
+import lombok.AllArgsConstructor; // 导入 Lombok 库提供的 @AllArgsConstructor 注解，用于生成包含所有属性的构造函数
+import lombok.Builder; // 导入 Lombok 库提供的 @Builder 注解，用于生成建造者模式的构造函数
+import lombok.Data; // 导入 Lombok 库提供的 @Data 注解，用于自动生成 getter、setter、equals、hashCode 和 toString 方法
+import lombok.NoArgsConstructor; // 导入 Lombok 库提供的 @NoArgsConstructor 注解，用于生成无参构造函数
+
+import java.io.Serializable; // 导入 Java 序列化接口，使得对象可以被序列化和反序列化
+
+@Data // 使用 Lombok 的 @Data 注解，自动为类生成 getter、setter、equals、hashCode 和 toString 方法
+@Builder // 使用 Lombok 的 @Builder 注解，自动为类生成建造者模式的链式构造方法
+@NoArgsConstructor // 使用 Lombok 的 @NoArgsConstructor 注解，自动为类生成无参构造方法
+@AllArgsConstructor // 使用 Lombok 的 @AllArgsConstructor 注解，自动为类生成包含所有属性的构造方法
+public class UserReportVO implements Serializable { // 声明了一个名为 UserReportVO 的类，实现了 Serializable 接口，用于对象的序列化
+
+    //日期，以逗号分隔，例如：2022-10-01,2022-10-02,2022-10-03
+    private String dateList; // 成员变量，表示一系列日期，格式为 "YYYY-MM-DD"，日期之间用逗号分隔
+
+    //用户总量，以逗号分隔，例如：200,210,220
+    private String totalUserList; // 成员变量，表示每天的用户总量，数字之间用逗号分隔
+
+    //新增用户，以逗号分隔，例如：20,21,10
+    private String newUserList; // 成员变量，表示每天新增的用户数量，数字之间用逗号分隔
+
+} // 类定义结束

sky-take-out-main/sky-take-out-main/springcache-demo/.idea/.gitignore

@@ -1,10 +0,0 @@
-# 默认忽略的文件
-/shelf/
-/workspace.xml
-# 基于编辑器的 HTTP 客户端请求
-/httpRequests/
-# Datasource local storage ignored files
-/dataSources/
-/dataSources.local.xml
-# Zeppelin 忽略的文件
-/ZeppelinRemoteNotebooks/

sky-take-out-main/sky-take-out-main/springcache-demo/.idea/compiler.xml

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CompilerConfiguration">
-    <annotationProcessing>
-      <profile name="Maven default annotation processors profile" enabled="true">
-        <sourceOutputDir name="target/generated-sources/annotations" />
-        <sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
-        <outputRelativeToContentRoot value="true" />
-        <module name="springcache-demo" />
-      </profile>
-    </annotationProcessing>
-  </component>
-  <component name="JavacSettings">
-    <option name="ADDITIONAL_OPTIONS_OVERRIDE">
-      <module name="springcache-demo" options="-parameters" />
-    </option>
-  </component>
-</project>

sky-take-out-main/sky-take-out-main/springcache-demo/.idea/encodings.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="Encoding">
-    <file url="file://$PROJECT_DIR$/src/main/java" charset="UTF-8" />
-  </component>
-</project>

sky-take-out-main/sky-take-out-main/springcache-demo/.idea/jarRepositories.xml

@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="RemoteRepositoriesConfiguration">
-    <remote-repository>
-      <option name="id" value="central" />
-      <option name="name" value="Central Repository" />
-      <option name="url" value="https://repo.maven.apache.org/maven2" />
-    </remote-repository>
-    <remote-repository>
-      <option name="id" value="central" />
-      <option name="name" value="Maven Central repository" />
-      <option name="url" value="https://repo1.maven.org/maven2" />
-    </remote-repository>
-    <remote-repository>
-      <option name="id" value="jboss.community" />
-      <option name="name" value="JBoss Community repository" />
-      <option name="url" value="https://repository.jboss.org/nexus/content/repositories/public/" />
-    </remote-repository>
-  </component>
-</project>

sky-take-out-main/sky-take-out-main/springcache-demo/.idea/misc.xml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ExternalStorageConfigurationManager" enabled="true" />
-  <component name="MavenProjectsManager">
-    <option name="originalFiles">
-      <list>
-        <option value="$PROJECT_DIR$/pom.xml" />
-      </list>
-    </option>
-  </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK" />
-</project>

sky-take-out-main/sky-take-out-main/springcache-demo/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
-  </component>
-</project>

sky-take-out-main/sky-take-out-main/springcache-demo/pom.xml

@@ -1,115 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 定义Maven项目对象模型（POM）的根元素，遵循Maven 4.0.0规范 -->
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0  http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <!-- 指定POM的版本为4.0.0 -->
-    <modelVersion>4.0.0</modelVersion>
-    <!-- 继承父项目 -->
-    <parent>
-        <!-- 指定父项目的groupId、artifactId和version -->
-        <groupId>org.springframework.boot</groupId>
-        <artifactId>spring-boot-starter-parent</artifactId>
-        <version>2.7.3</version>
-        <!-- 相对路径，这里为空，表示查找父POM时不使用相对路径 -->
-        <relativePath/>
-    </parent>
-    <!-- 定义项目的groupId、artifactId和version -->
-    <groupId>com.itheima</groupId>
-    <artifactId>springcache-demo</artifactId>
-    <version>1.0-SNAPSHOT</version>
-
-    <!-- 定义项目属性 -->
-    <properties>
-        <!-- 设置编译的Java版本为11 -->
-        <maven.compiler.source>11</maven.compiler.source>
-        <maven.compiler.target>11</maven.compiler.target>
-    </properties>
-
-    <!-- 定义项目依赖 -->
-    <dependencies>
-        <!-- Spring Boot Web启动器依赖 -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-web</artifactId>
-            <scope>compile</scope>
-        </dependency>
-        <!-- Lombok依赖，用于简化Java对象的getter、setter等方法的编写 -->
-        <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-            <version>1.18.20</version>
-        </dependency>
-
-        <!-- Alibaba Fastjson依赖，用于JSON处理 -->
-        <dependency>
-            <groupId>com.alibaba</groupId>
-            <artifactId>fastjson</artifactId>
-            <version>1.2.76</version>
-        </dependency>
-
-        <!-- Apache Commons Lang依赖，提供一些常用的工具类 -->
-        <dependency>
-            <groupId>commons-lang</groupId>
-            <artifactId>commons-lang</artifactId>
-            <version>2.6</version>
-        </dependency>
-        <!-- Spring Boot缓存启动器依赖 -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-cache</artifactId>
-        </dependency>
-
-        <!-- Spring Boot Redis启动器依赖 -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-data-redis</artifactId>
-        </dependency>
-
-        <!-- MySQL JDBC驱动依赖 -->
-        <dependency>
-            <groupId>mysql</groupId>
-            <artifactId>mysql-connector-java</artifactId>
-            <scope>runtime</scope>
-        </dependency>
-
-        <!-- MyBatis Spring Boot启动器依赖 -->
-        <dependency>
-            <groupId>org.mybatis.spring.boot</groupId>
-            <artifactId>mybatis-spring-boot-starter</artifactId>
-            <version>2.2.0</version>
-        </dependency>
-
-        <!-- Druid Spring Boot启动器依赖，用于数据库连接池 -->
-        <dependency>
-            <groupId>com.alibaba</groupId>
-            <artifactId>druid-spring-boot-starter</artifactId>
-            <version>1.2.1</version>
-        </dependency>
-
-        <!-- Knife4j Spring Boot启动器依赖，用于API文档生成 -->
-        <dependency>
-            <groupId>com.github.xiaoymin</groupId>
-            <artifactId>knife4j-spring-boot-starter</artifactId>
-            <version>3.0.2</version>
-        </dependency>
-
-        <!-- Spring Boot测试启动器依赖 -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-test</artifactId>
-        </dependency>
-    </dependencies>
-    <!-- 构建配置 -->
-    <build>
-        <!-- 定义Maven插件 -->
-        <plugins>
-            <!-- Spring Boot Maven插件，用于打包Spring Boot应用 -->
-            <plugin>
-                <groupId>org.springframework.boot</groupId>
-                <artifactId>spring-boot-maven-plugin</artifactId>
-                <version>2.7.3</version>
-            </plugin>
-        </plugins>
-    </build>
-</project>

sky-take-out-main/sky-take-out-main/springcache-demo/springcachedemo.sql

@@ -1,14 +0,0 @@
--- 如果存在名为`user`的表，则删除它
-DROP TABLE IF EXISTS `user`;
-
--- 创建一个名为`user`的新表
-CREATE TABLE `user` (
-    -- 定义一个名为`id`的列，类型为bigint，不允许为空，并且自增
-                        `id` bigint NOT NULL AUTO_INCREMENT,
-    -- 定义一个名为`name`的列，类型为varchar(45)，允许为空
-                        `name` varchar(45) DEFAULT NULL,
-    -- 定义一个名为`age`的列，类型为int，允许为空
-                        `age` int DEFAULT NULL,
-    -- 将`id`列设置为表的主键
-                        PRIMARY KEY (`id`)
-);

sky-take-out-main/sky-take-out-main/springcache-demo/src/main/java/com/itheima/CacheDemoApplication.java

@@ -1,27 +0,0 @@
-// 定义包名
-package com.itheima;
-
-// 导入lombok提供的@Slf4j注解，用于日志记录
-import lombok.extern.slf4j.Slf4j;
-// 导入SpringApplication类，用于启动Spring Boot应用
-import org.springframework.boot.SpringApplication;
-// 导入SpringBootApplication注解，标识这是一个Spring Boot应用
-import org.springframework.boot.autoconfigure.SpringBootApplication;
-// 导入EnableCaching注解，用于开启缓存支持
-import org.springframework.cache.annotation.EnableCaching;
-
-// 使用@Slf4j注解自动注入日志对象
-@Slf4j
-// 使用@SpringBootApplication注解，标识这是一个Spring Boot自动配置的应用
-@SpringBootApplication
-// 使用@EnableCaching注解，开启缓存功能
-@EnableCaching
-public class CacheDemoApplication {
-    // 定义main方法，作为程序的入口点
-    public static void main(String[] args) {
-        // 调用SpringApplication的run方法启动Spring Boot应用
-        SpringApplication.run(CacheDemoApplication.class, args);
-        // 使用注入的日志对象记录项目启动成功的信息
-        log.info("项目启动成功...");
-    }
-}

sky-take-out-main/sky-take-out-main/springcache-demo/src/main/java/com/itheima/config/WebMvcConfiguration.java

@@ -1,53 +0,0 @@
-package com.itheima.config;
-
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
-import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
-import springfox.documentation.builders.ApiInfoBuilder;
-import springfox.documentation.builders.PathSelectors;
-import springfox.documentation.builders.RequestHandlerSelectors;
-import springfox.documentation.service.ApiInfo;
-import springfox.documentation.spi.DocumentationType;
-import springfox.documentation.spring.web.plugins.Docket;
-
-@Configuration
-@Slf4j
-public class WebMvcConfiguration extends WebMvcConfigurationSupport {
-
-    /**
-     * 生成接口文档配置
-     * @return
-     */
-    @Bean
-    public Docket docket(){
-        log.info("准备生成接口文档...");
-
-        ApiInfo apiInfo = new ApiInfoBuilder()
-                .title("接口文档")
-                .version("2.0")
-                .description("接口文档")
-                .build();
-
-        Docket docket = new Docket(DocumentationType.SWAGGER_2)
-                .apiInfo(apiInfo)
-                .select()
-                //指定生成接口需要扫描的包
-                .apis(RequestHandlerSelectors.basePackage("com.itheima.controller"))
-                .paths(PathSelectors.any())
-                .build();
-
-        return docket;
-    }
-
-    /**
-     * 设置静态资源映射
-     * @param registry
-     */
-    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
-        log.info("开始设置静态资源映射...");
-        registry.addResourceHandler("/doc.html").addResourceLocations("classpath:/META-INF/resources/");
-        registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
-    }
-}

sky-take-out-main/sky-take-out-main/springcache-demo/src/main/java/com/itheima/controller/UserController.java

@@ -1,83 +0,0 @@
-// 定义包名
-        package com.itheima.controller;
-
-// 导入User实体类
-import com.itheima.entity.User;
-// 导入UserMapper接口
-import com.itheima.mapper.UserMapper;
-// 导入Lombok提供的@Slf4j注解，用于日志记录
-import lombok.extern.slf4j.Slf4j;
-// 导入Spring框架的Autowired注解，用于自动注入依赖
-import org.springframework.beans.factory.annotation.Autowired;
-// 导入Spring框架的缓存注解
-import org.springframework.cache.annotation.CacheEvict;
-import org.springframework.cache.annotation.CachePut;
-import org.springframework.cache.annotation.Cacheable;
-// 导入Spring框架的Web注解
-import org.springframework.web.bind.annotation.*;
-
-// 使用RestController注解标识这是一个控制器，并且返回的数据直接作为响应体
-@RestController
-// 使用RequestMapping注解设置这个控制器的基础路径
-@RequestMapping("/user")
-// 使用@Slf4j注解自动注入日志对象
-@Slf4j
-public class UserController {
-
-    // 使用Autowired注解自动注入UserMapper
-    @Autowired
-    private UserMapper userMapper;
-
-    /**
-     * 保存用户信息，并更新缓存
-     * @param user 用户对象
-     * @return 保存后的用户对象
-     */
-    @PostMapping
-    // 使用CachePut注解，指定在保存用户信息后更新缓存，key为用户ID
-    @CachePut(cacheNames = "userCache",key = "#user.id")
-    public User save(@RequestBody User user){
-        // 调用UserMapper的insert方法保存用户信息
-        userMapper.insert(user);
-        // 返回保存后的用户对象
-        return user;
-    }
-
-    /**
-     * 根据ID删除用户信息，并清除缓存中对应的数据
-     */
-    @DeleteMapping
-    // 使用CacheEvict注解，指定在删除用户信息后清除缓存中对应的数据，key为用户ID
-    @CacheEvict(cacheNames = "userCache",key = "#id")
-    public void deleteById(Long id){
-        // 调用UserMapper的deleteById方法删除用户信息
-        userMapper.deleteById(id);
-    }
-
-    /**
-     * 删除所有用户信息，并清除缓存中的所有数据
-     */
-    @DeleteMapping("/delAll")
-    // 使用CacheEvict注解，指定在删除所有用户信息后清除缓存中的所有数据
-    @CacheEvict(cacheNames = "userCache",allEntries = true)
-    public void deleteAll(){
-        // 调用UserMapper的deleteAll方法删除所有用户信息
-        userMapper.deleteAll();
-    }
-
-    /**
-     * 根据ID获取用户信息，如果缓存中有则直接返回缓存中的数据
-     * @param id 用户ID
-     * @return 用户对象
-     */
-    @GetMapping
-    // 使用Cacheable注解，指定在获取用户信息时，如果缓存中有则直接返回缓存中的数据，key为用户ID
-    @Cacheable(cacheNames = "userCache",key = "#id")
-    public User getById(Long id){
-        // 调用UserMapper的getById方法获取用户信息
-        User user = userMapper.getById(id);
-        // 返回用户对象
-        return user;
-    }
-
-}

sky-take-out-main/sky-take-out-main/springcache-demo/src/main/java/com/itheima/entity/User.java

@@ -1,26 +0,0 @@
-// 定义包名
-package com.itheima.entity;
-
-// 导入lombok提供的@Data注解，用于简化Java对象的getter、setter、toString等方法的编写
-import lombok.Data;
-// 导入Serializable接口，用于实现对象的序列化
-import java.io.Serializable;
-
-// 使用@Data注解，自动为类生成getter、setter、toString等方法
-@Data
-// 声明User类实现Serializable接口，以便可以被序列化
-public class User implements Serializable {
-
-    // 声明serialVersionUID，用于在序列化和反序列化过程中保持版本的一致性
-    private static final long serialVersionUID = 1L;
-
-    // 声明id属性，用于存储用户的唯一标识
-    private Long id;
-
-    // 声明name属性，用于存储用户的姓名
-    private String name;
-
-    // 声明age属性，用于存储用户的年龄
-    private int age;
-
-}

sky-take-out-main/sky-take-out-main/springcache-demo/src/main/java/com/itheima/mapper/UserMapper.java

@@ -1,21 +0,0 @@
-package com.itheima.mapper;
-
-import com.itheima.entity.User;
-import org.apache.ibatis.annotations.*;
-
-@Mapper
-public interface UserMapper{
-
-    @Insert("insert into user(name,age) values (#{name},#{age})")
-    @Options(useGeneratedKeys = true,keyProperty = "id")
-    void insert(User user);
-
-    @Delete("delete from user where id = #{id}")
-    void deleteById(Long id);
-
-    @Delete("delete from user")
-    void deleteAll();
-
-    @Select("select * from user where id = #{id}")
-    User getById(Long id);
-}

sky-take-out-main/sky-take-out-main/springcache-demo/src/main/resources/application.yml

@@ -1,39 +0,0 @@
-# 定义服务的配置项
-server:
-  # 设置服务的端口号为8888
-  port: 8888
-spring:
-  # 数据源配置
-  datasource:
-    # 配置Druid连接池
-    druid:
-      # 指定JDBC驱动类名
-      driver-class-name: com.mysql.cj.jdbc.Driver
-      # 指定数据库连接URL
-      url: jdbc:mysql://localhost:3306/spring_cache_demo?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
-      # 指定数据库用户名
-      username: root
-      # 指定数据库密码
-      password: root
-  # Redis配置
-  redis:
-    # 指定Redis服务器地址
-    host: localhost
-    # 指定Redis服务器端口
-    port: 6379
-    # 指定Redis密码
-    password: 123456
-    # 指定Redis数据库索引
-    database: 1
-# 日志配置
-logging:
-  # 设置日志级别
-  level:
-    # 设置com.itheima包下的mapper日志级别为debug
-    com:
-      itheima:
-        mapper: debug
-        # 设置com.itheima包下的service日志级别为info
-        service: info
-        # 设置com.itheima包下的controller日志级别为info
-        controller: info

sky-take-out-main/sky-take-out-main/springcache-demo/target/classes/application.yml

@@ -1,21 +0,0 @@
-server:
-  port: 8888
-spring:
-  datasource:
-    druid:
-      driver-class-name: com.mysql.cj.jdbc.Driver
-      url: jdbc:mysql://localhost:3306/spring_cache_demo?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
-      username: root
-      password: root
-  redis:
-    host: localhost
-    port: 6379
-    password: 123456
-    database: 1
-logging:
-  level:
-    com:
-      itheima:
-        mapper: debug
-        service: info
-        controller: info

sky-take-out/sky-server/pom.xml

@@ -0,0 +1,129 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>sky-take-out</artifactId>
+        <groupId>com.sky</groupId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>sky-server</artifactId>
+    <dependencies>
+
+        <dependency>
+            <groupId>com.sky</groupId>
+            <artifactId>sky-common</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.sky</groupId>
+            <artifactId>sky-pojo</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.mybatis.spring.boot</groupId>
+            <artifactId>mybatis-spring-boot-starter</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>fastjson</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>druid-spring-boot-starter</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.github.pagehelper</groupId>
+            <artifactId>pagehelper-spring-boot-starter</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.aspectj</groupId>
+            <artifactId>aspectjrt</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.aspectj</groupId>
+            <artifactId>aspectjweaver</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.github.xiaoymin</groupId>
+            <artifactId>knife4j-spring-boot-starter</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-cache</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-websocket</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>javax.xml.bind</groupId>
+            <artifactId>jaxb-api</artifactId>
+        </dependency>
+
+        <!-- poi -->
+        <dependency>
+            <groupId>org.apache.poi</groupId>
+            <artifactId>poi</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.poi</groupId>
+            <artifactId>poi-ooxml</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

sky-take-out/sky-server/src/main/java/com/sky/SkyApplication.java

@@ -0,0 +1,36 @@
+package com.sky;
+
+// 导入lombok日志工具类，提供日志记录功能
+import lombok.extern.slf4j.Slf4j;
+// 导入Spring Boot应用程序类，用于启动应用
+import org.springframework.boot.SpringApplication;
+// 导入Spring Boot的自动配置注解，启动Spring Boot应用
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+// 导入Spring的缓存注解，启用缓存功能
+import org.springframework.cache.annotation.EnableCaching;
+// 导入Spring的定时任务注解，启用定时任务功能
+import org.springframework.scheduling.annotation.EnableScheduling;
+// 导入Spring的事务管理注解，启用事务管理
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+/**
+ * Spring Boot 启动类，配置应用的各项功能
+ */
+@SpringBootApplication  // 启动Spring Boot应用，自动配置、组件扫描等
+@EnableTransactionManagement  // 启用Spring的注解方式的事务管理
+@Slf4j  // 启用Lombok的日志功能，自动生成log对象
+@EnableCaching  // 启用Spring的缓存功能
+@EnableScheduling  // 启用Spring的定时任务功能
+public class SkyApplication {
+
+    /**
+     * 应用程序启动入口
+     */
+    public static void main(String[] args) {
+        // 启动Spring Boot应用
+        SpringApplication.run(SkyApplication.class, args);
+
+        // 打印日志，表示应用已启动
+        log.info("server started");
+    }
+}

sky-take-out/sky-server/src/main/java/com/sky/service/impl/ReportServiceImpl.java

@@ -0,0 +1,331 @@
+package com.sky.service.impl;
+// 导入所需包，提供服务实现
+
+import com.sky.dto.GoodsSalesDTO;
+import com.sky.entity.Orders;
+import com.sky.mapper.OrderMapper;
+import com.sky.mapper.UserMapper;
+import com.sky.service.ReportService;
+import com.sky.service.WorkspaceService;
+import com.sky.vo.*;
+import io.swagger.models.auth.In;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.poi.xssf.usermodel.XSSFRow;
+import org.apache.poi.xssf.usermodel.XSSFSheet;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import javax.servlet.ServletOutputStream;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.InputStream;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@Service
+@Slf4j
+public class ReportServiceImpl implements ReportService {  // 实现ReportService接口，用于提供报告服务
+
+    @Autowired
+    private OrderMapper orderMapper;
+    // 注入订单数据访问对象
+
+    @Autowired
+    private UserMapper userMapper;
+    // 注入用户数据访问对象
+
+    @Autowired
+    private WorkspaceService workspaceService;
+    // 注入工作区服务，用于获取业务数据
+
+    /**
+     * 根据时间区间统计营业额
+     *
+     * @param begin 开始日期
+     * @param end 结束日期
+     * @return 返回营业额报告
+     */
+    @Override
+    public TurnoverReportVO getTurnover(LocalDate begin, LocalDate end) {
+        List<LocalDate> dateList = new ArrayList<>();
+        // 创建日期列表，用于存储每一天的日期
+        dateList.add(begin);
+        // 添加开始日期
+
+        while (!begin.equals(end)) {
+            begin = begin.plusDays(1);  // 日期加1天
+            dateList.add(begin);  // 将计算出的日期加入列表
+        }
+
+        List<Double> turnoverList = new ArrayList<>();
+        // 存储每一天的营业额
+        for (LocalDate date : dateList) {
+            LocalDateTime beginTime = LocalDateTime.of(date, LocalTime.MIN);
+            // 获取当前日期的开始时间
+            LocalDateTime endTime = LocalDateTime.of(date, LocalTime.MAX);
+            // 获取当前日期的结束时间
+            Map map = new HashMap();
+            map.put("status", Orders.COMPLETED);
+            // 设置订单状态为已完成
+            map.put("begin", beginTime);
+            map.put("end", endTime);
+            // 设置查询时间区间
+
+            // 根据动态条件统计营业额
+            Double turnover = orderMapper.sumByMap(map);
+            turnover = turnover == null ? 0.0 : turnover;
+            // 如果营业额为空，则设置为0
+            turnoverList.add(turnover);
+            // 将营业额添加到列表
+        }
+
+        // 数据封装为返回的报告对象
+        return TurnoverReportVO.builder()
+                .dateList(StringUtils.join(dateList, ","))
+                // 将日期列表转为逗号分隔的字符串
+                .turnoverList(StringUtils.join(turnoverList, ","))
+                // 将营业额列表转为逗号分隔的字符串
+                .build();
+    }
+
+    /**
+     * 根据时间区间统计用户数量
+     *
+     * @param begin 开始日期
+     * @param end 结束日期
+     * @return 返回用户统计报告
+     */
+    @Override
+    public UserReportVO getUserStatistics(LocalDate begin, LocalDate end) {
+        ArrayList<LocalDate> dateList = new ArrayList<>();
+        // 创建日期列表
+        dateList.add(begin);
+        // 添加开始日期
+
+        while (!begin.equals(end)) {
+            begin = begin.plusDays(1);
+            dateList.add(begin);
+        }
+
+        ArrayList<Integer> newUserList = new ArrayList<>();
+        // 存储每一天新增用户数
+        ArrayList<Integer> totalUserList = new ArrayList<>();
+        // 存储每一天总用户数
+
+        dateList.forEach(date -> {
+            LocalDateTime beginTime = LocalDateTime.of(date, LocalTime.MIN);
+            // 获取当天的开始时间
+            LocalDateTime endTime = LocalDateTime.of(date, LocalTime.MAX);
+            // 获取当天的结束时间
+
+            Integer newUser = getUserCount(beginTime, endTime);
+            // 获取当天新增用户数量
+            Integer totalUser = getUserCount(null, endTime);
+            // 获取当天总用户数量
+
+            newUserList.add(newUser);
+            // 将新增用户数量添加到列表
+            totalUserList.add(totalUser);
+            // 将总用户数量添加到列表
+        });
+
+        // 返回封装后的用户统计报告对象
+        return UserReportVO.builder()
+                .dateList(StringUtils.join(dateList, ","))
+                // 将日期列表转为字符串
+                .newUserList(StringUtils.join(newUserList, ","))
+                // 将新增用户列表转为字符串
+                .totalUserList(StringUtils.join(totalUserList, ","))
+                // 将总用户列表转为字符串
+                .build();
+    }
+
+    /**
+     * 根据时间区间统计订单数量
+     *
+     * @param begin 开始日期
+     * @param end 结束日期
+     * @return 返回订单统计报告
+     */
+    @Override
+    public OrderReportVO getOrderStatistics(LocalDate begin, LocalDate end) {
+        ArrayList<LocalDate> dateList = new ArrayList<>();
+        dateList.add(begin);
+
+        while (!begin.equals(end)) {
+            begin = begin.plusDays(1);
+            dateList.add(begin);
+        }
+
+        // 每天订单总数集合
+        ArrayList<Integer> orderCountList = new ArrayList<>();
+
+        // 每天有效订单数集合
+        ArrayList<Integer> validOrderCountList = new ArrayList<>();
+
+        dateList.forEach(date -> {
+            LocalDateTime beginTime = LocalDateTime.of(date, LocalTime.MIN);
+            LocalDateTime endTime = LocalDateTime.of(date, LocalTime.MAX);
+
+            // 查询每天总订单数
+            Integer orderCount = getOrderCount(beginTime, endTime, null);
+            // 查询每天有效订单数
+            Integer validOrderCount = getOrderCount(beginTime, endTime, Orders.COMPLETED);
+
+            orderCountList.add(orderCount);
+            // 将总订单数添加到列表
+            validOrderCountList.add(validOrderCount);
+            // 将有效订单数添加到列表
+        });
+
+        // 计算区间内的总订单数
+        Integer totalOrderCount = orderCountList.stream().reduce(Integer::sum).get();
+
+        // 计算区间内有效订单数
+        Integer validOrderCount = validOrderCountList.stream().reduce(Integer::sum).get();
+
+        // 计算订单完成率
+        Double orderCompletionRate = 0.0;
+        if (totalOrderCount != 0) {
+            orderCompletionRate = validOrderCount.doubleValue() / totalOrderCount;
+            // 如果总订单数不为0，计算订单完成率
+        }
+
+        // 返回封装后的订单统计报告对象
+        return OrderReportVO.builder()
+                .dateList(StringUtils.join(dateList, ","))
+                .orderCountList(StringUtils.join(orderCountList, ","))
+                .validOrderCountList(StringUtils.join(validOrderCountList, ","))
+                .totalOrderCount(totalOrderCount)
+                .validOrderCount(validOrderCount)
+                .orderCompletionRate(orderCompletionRate)
+                .build();
+    }
+
+    /**
+     * 查询指定时间区间内的销量排名top10
+     *
+     * @param begin 开始日期
+     * @param end 结束日期
+     * @return 返回销量排名报告
+     */
+    @Override
+    public SalesTop10ReportVO getSalesTop10(LocalDate begin, LocalDate end) {
+        LocalDateTime beginTime = LocalDateTime.of(begin, LocalTime.MIN);
+        LocalDateTime endTime = LocalDateTime.of(end, LocalTime.MAX);
+
+        List<GoodsSalesDTO> goodsSalesDTOList = orderMapper.getSalesTop10(beginTime, endTime);
+        // 获取指定时间区间内销量排名前10的商品
+
+        String nameList = StringUtils.join(goodsSalesDTOList.stream().map(GoodsSalesDTO::getName).collect(Collectors.toList()), ",");
+        // 将商品名称转为字符串
+        String numberList = StringUtils.join(goodsSalesDTOList.stream().map(GoodsSalesDTO::getNumber).collect(Collectors.toList()), ",");
+        // 将商品数量转为字符串
+
+        return SalesTop10ReportVO.builder().nameList(nameList).numberList(numberList).build();
+        // 返回销量前10的商品报告对象
+    }
+
+    /**
+     * 导出近30天的运营数据报表
+     * @param response HttpServletResponse响应对象，用于导出数据
+     */
+    @Override
+    public void exportBusinessData(HttpServletResponse response) {
+        LocalDate begin = LocalDate.now().minusDays(30);
+        // 获取30天前的日期
+        LocalDate end = LocalDate.now().minusDays(1);
+        // 获取昨天的日期
+
+        // 查询近30天的业务数据
+        BusinessDataVO businessData = workspaceService.getBusinessData(LocalDateTime.of(begin,LocalTime.MIN), LocalDateTime.of(end, LocalTime.MAX));
+
+        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("template/运营数据报表模板.xlsx");
+        // 加载Excel模板
+
+        try {
+            // 基于提供的模板文件创建新的Excel对象
+            XSSFWorkbook excel = new XSSFWorkbook(inputStream);
+            XSSFSheet sheet = excel.getSheet("Sheet1");
+            // 获取Excel中的第一个工作表
+
+            sheet.getRow(1).getCell(1).setCellValue(begin + "至" + end);
+            // 设置报表日期区间
+            XSSFRow row = sheet.getRow(3);
+            row.getCell(2).setCellValue(businessData.getTurnover());
+            // 设置营业额数据
+            row.getCell(4).setCellValue(businessData.getOrderCompletionRate());
+            // 设置订单完成率
+            row.getCell(6).setCellValue(businessData.getNewUsers());
+            // 设置新增用户数
+            row = sheet.getRow(4);
+            row.getCell(2).setCellValue(businessData.getValidOrderCount());
+            // 设置有效订单数
+            row.getCell(4).setCellValue(businessData.getUnitPrice());
+            // 设置单价
+            for (int i = 0; i < 30; i++) {
+                LocalDate date = begin.plusDays(i);
+                // 获取每天的数据
+                businessData = workspaceService.getBusinessData(LocalDateTime.of(date,LocalTime.MIN), LocalDateTime.of(date, LocalTime.MAX));
+                row = sheet.getRow(7 + i);
+                row.getCell(1).setCellValue(date.toString());
+                // 设置日期
+                row.getCell(2).setCellValue(businessData.getTurnover());
+                row.getCell(3).setCellValue(businessData.getValidOrderCount());
+                row.getCell(4).setCellValue(businessData.getOrderCompletionRate());
+                row.getCell(5).setCellValue(businessData.getUnitPrice());
+                row.getCell(6).setCellValue(businessData.getNewUsers());
+            }
+
+            // 将Excel写入响应流，导出文件
+            ServletOutputStream out = response.getOutputStream();
+            excel.write(out);
+            out.flush();
+            out.close();
+            excel.close();
+
+        }catch (IOException e){
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * 根据时间区间统计指定状态的订单数量
+     *
+     * @param beginTime 开始时间
+     * @param endTime 结束时间
+     * @param status 订单状态
+     * @return 返回订单数量
+     */
+    private Integer getOrderCount(LocalDateTime beginTime, LocalDateTime endTime, Integer status) {
+        Map map = new HashMap();
+        map.put("status", status);
+        map.put("begin", beginTime);
+        map.put("end", endTime);
+        return orderMapper.countByMap(map);
+        // 查询并返回订单数量
+    }
+
+    /**
+     * 根据时间区间统计用户数量
+     *
+     * @param beginTime 开始时间
+     * @param endTime 结束时间
+     * @return 返回用户数量
+     */
+    private Integer getUserCount(LocalDateTime beginTime, LocalDateTime endTime) {
+        Map map = new HashMap();
+        map.put("begin", beginTime);
+        map.put("end", endTime);
+        return userMapper.countByMap(map);
+        // 查询并返回用户数量
+    }
+}

sky-take-out/sky-server/src/main/java/com/sky/service/impl/SetmealServiceImpl.java

@@ -0,0 +1,284 @@
+package com.sky.service.impl;
+
+import com.github.pagehelper.Page;
+// Page class from PageHelper, used for pagination results.
+
+import com.github.pagehelper.PageHelper;
+// PageHelper class, used to start pagination by configuring the page size and number.
+
+import com.sky.constant.MessageConstant;
+// MessageConstant holds predefined messages like error messages.
+
+import com.sky.constant.StatusConstant;
+// StatusConstant defines the status values such as ENABLE and DISABLE for different entities.
+
+import com.sky.dto.SetmealDTO;
+// SetmealDTO is a Data Transfer Object used for handling Setmeal data during creation or updates.
+
+import com.sky.dto.SetmealPageQueryDTO;
+// SetmealPageQueryDTO holds the query parameters required for paging through the setmeal records.
+
+import com.sky.entity.Dish;
+// Dish entity represents a dish in the system, typically part of a setmeal.
+
+import com.sky.entity.Setmeal;
+// Setmeal entity represents the main set meal item in the system.
+
+import com.sky.entity.SetmealDish;
+// SetmealDish represents the many-to-many relationship between Setmeal and Dish entities.
+
+import com.sky.exception.DeletionNotAllowedException;
+// Custom exception thrown when deletion of a setmeal is not allowed.
+
+import com.sky.exception.SetmealEnableFailedException;
+// Custom exception thrown when enabling a setmeal fails due to the status of its associated dishes.
+
+import com.sky.mapper.DishMapper;
+// DishMapper interface for accessing Dish-related database operations.
+
+import com.sky.mapper.SetmealDishMapper;
+// SetmealDishMapper interface for accessing Setmeal-Dish relationship database operations.
+
+import com.sky.mapper.SetmealMapper;
+// SetmealMapper interface for accessing Setmeal-related database operations.
+
+import com.sky.result.PageResult;
+// PageResult is a helper class used to encapsulate paginated results.
+
+import com.sky.service.SetmealService;
+// SetmealService interface that defines business logic for managing setmeals.
+
+import com.sky.vo.DishItemVO;
+// DishItemVO represents a view object for dish details in a setmeal.
+
+import com.sky.vo.SetmealVO;
+// SetmealVO represents a view object for setmeal details including associated dishes.
+
+import lombok.extern.slf4j.Slf4j;
+// Lombok annotation to enable logging in the class.
+
+import org.springframework.beans.BeanUtils;
+// BeanUtils is used to copy properties between beans or DTOs and entities.
+
+import org.springframework.beans.factory.annotation.Autowired;
+// Autowired annotation is used for dependency injection of required beans.
+
+import org.springframework.stereotype.Service;
+// Service annotation marks this class as a service component in Spring's context.
+
+import org.springframework.transaction.annotation.Transactional;
+// Transactional annotation ensures that methods are executed within a transaction context.
+
+import java.util.List;
+// Importing List, a collection type that holds a list of items.
+
+@Service
+@Slf4j
+// Marks this class as a service in the Spring context and enables logging.
+
+public class SetmealServiceImpl implements SetmealService {
+// Implementation of the SetmealService interface where business logic related to setmeals is defined.
+
+    @Autowired
+    private SetmealMapper setmealMapper;
+    // Automatically injects the SetmealMapper to handle database operations related to Setmeal.
+
+    @Autowired
+    private SetmealDishMapper setmealDishMapper;
+    // Automatically injects the SetmealDishMapper to handle database operations related to Setmeal-Dish relationships.
+
+    @Autowired
+    private DishMapper dishMapper;
+    // Automatically injects the DishMapper to handle database operations related to dishes.
+
+    /**
+     * 新增套餐
+     * @param setmealDTO
+     * The method to add a new Setmeal along with associated dishes.
+     */
+    @Override
+    @Transactional
+    // The @Transactional annotation ensures the method runs within a transaction, so all operations are committed or rolled back together.
+    public void saveWithDish(SetmealDTO setmealDTO) {
+        Setmeal setmeal = new Setmeal();
+        // Creates a new instance of Setmeal entity to store the incoming setmeal data.
+
+        BeanUtils.copyProperties(setmealDTO, setmeal);
+        // Copies the properties from SetmealDTO to the Setmeal entity.
+
+        setmealMapper.insert(setmeal);
+        // Inserts the new Setmeal into the database using the setmealMapper.
+
+        Long id = setmeal.getId();
+        // Retrieves the id of the newly inserted Setmeal (auto-generated by the database).
+
+        List<SetmealDish> setmealDishes = setmealDTO.getSetmealDishes();
+        // Retrieves the list of SetmealDish objects (dishes associated with the setmeal).
+
+        setmealDishes.forEach(setmealDish -> setmealDish.setSetmealId(id));
+        // Sets the Setmeal ID for each SetmealDish to associate the dishes with the newly created setmeal.
+
+        setmealDishMapper.insertBatch(setmealDishes);
+        // Inserts the list of SetmealDish entities in a batch into the Setmeal-Dish relationship table.
+    }
+
+    /**
+     * 分页查询
+     * @param setmealPageQueryDTO
+     * The method to query Setmeals with pagination.
+     */
+    @Override
+    public PageResult pageQuery(SetmealPageQueryDTO setmealPageQueryDTO) {
+        PageHelper.startPage(setmealPageQueryDTO.getPage(), setmealPageQueryDTO.getPageSize());
+        // Configures PageHelper to handle pagination by starting the page with the given page number and page size.
+
+        Page<SetmealVO> page = setmealMapper.pageQuery(setmealPageQueryDTO);
+        // Executes the query for setmeals using the SetmealMapper, applying pagination.
+
+        return new PageResult(page.getTotal(), page.getResult());
+        // Returns the paginated result, including total count and the current page's results.
+    }
+
+    /**
+     * 批量删除套餐
+     * @param ids
+     * The method to delete a batch of Setmeals by their IDs.
+     */
+    @Override
+    public void deleteBatch(List<Long> ids) {
+        // Iterates over the list of ids to check if any of the Setmeals are currently enabled.
+        ids.forEach(id -> {
+            Setmeal setmeal = setmealMapper.getById(id);
+            // Retrieves the Setmeal by its ID to check its status.
+
+            if (StatusConstant.ENABLE == setmeal.getStatus()) {
+                // If the Setmeal is enabled, throw an exception because enabled setmeals cannot be deleted.
+                throw new DeletionNotAllowedException(MessageConstant.SETMEAL_ON_SALE);
+            }
+        });
+
+        // If the Setmeals are not enabled, proceed to delete them.
+        ids.forEach(id -> {
+            setmealMapper.deleteById(id);
+            // Deletes the Setmeal from the Setmeal table by its ID.
+
+            setmealDishMapper.deleteBySetmaleId(id);
+            // Deletes the relationship between the Setmeal and its dishes from the Setmeal-Dish relationship table.
+        });
+    }
+
+    /**
+     * 根据id查询套餐
+     * @param id
+     * The method to retrieve a Setmeal by its ID along with its associated dishes.
+     */
+    @Override
+    public SetmealVO getByIdWithDish(Long id) {
+        SetmealVO setmealVO = new SetmealVO();
+        // Creates a new SetmealVO to store the retrieved setmeal data.
+
+        Setmeal setmeal = setmealMapper.getById(id);
+        // Retrieves the Setmeal entity by its ID from the database.
+
+        BeanUtils.copyProperties(setmeal, setmealVO);
+        // Copies the properties of the Setmeal entity into the SetmealVO.
+
+        List<SetmealDish> setmealDishList = setmealDishMapper.getBySetmealId(id);
+        // Retrieves the list of SetmealDish entities that associate dishes with this Setmeal.
+
+        setmealVO.setSetmealDishes(setmealDishList);
+        // Sets the list of associated dishes in the SetmealVO.
+
+        return setmealVO;
+        // Returns the SetmealVO with both setmeal and its associated dishes.
+    }
+
+    /**
+     * 修改套餐
+     * @param setmealDTO
+     * The method to update an existing Setmeal and its associated dishes.
+     */
+    @Override
+    public void update(SetmealDTO setmealDTO) {
+        Setmeal setmeal = new Setmeal();
+        // Creates a new Setmeal entity to store the updated data.
+
+        BeanUtils.copyProperties(setmealDTO, setmeal);
+        // Copies the updated properties from the SetmealDTO to the Setmeal entity.
+
+        setmealMapper.update(setmeal);
+        // Updates the Setmeal record in the database with the new data.
+
+        Long id = setmealDTO.getId();
+        // Retrieves the Setmeal ID from the DTO.
+
+        setmealDishMapper.deleteBySetmaleId(id);
+        // Deletes the previous relationships between the Setmeal and its dishes from the Setmeal-Dish table.
+
+        List<SetmealDish> setmealDishes = setmealDTO.getSetmealDishes();
+        // Retrieves the updated list of SetmealDish entities from the DTO.
+
+        setmealDishes.forEach(setmealDish -> setmealDish.setSetmealId(id));
+        // Sets the Setmeal ID for each SetmealDish to associate them with the updated Setmeal.
+
+        setmealDishMapper.insertBatch(setmealDishes);
+        // Inserts the updated SetmealDish records into the Setmeal-Dish relationship table.
+    }
+
+    /**
+     * 套餐起售停售
+     * @param status
+     * @param id
+     * The method to enable or disable a Setmeal.
+     */
+    @Override
+    public void startOrStop(Integer status, Long id) {
+        if (status == StatusConstant.ENABLE) {
+            // If the status is ENABLE, we need to ensure that all dishes in the setmeal are enabled.
+
+            List<Dish> dishList = dishMapper.getBySetmealId(id);
+            // Retrieves the list of dishes associated with the setmeal.
+
+            if (dishList != null && !dishList.isEmpty()) {
+                // If there are dishes associated with the setmeal.
+                dishList.forEach(dish -> {
+                    if (StatusConstant.DISABLE == dish.getStatus()) {
+                        // If any dish is disabled, throw an exception.
+                        throw new SetmealEnableFailedException(MessageConstant.SETMEAL_ENABLE_FAILED);
+                    }
+                });
+            }
+        }
+
+        Setmeal setmeal = Setmeal.builder()
+                .id(id)
+                .status(status)
+                .build();
+        // Builds a Setmeal object with the provided ID and status.
+
+        setmealMapper.update(setmeal);
+        // Updates the Setmeal record in the database to reflect the new status (enabled or disabled).
+    }
+
+    /**
+     * 条件查询
+     * @param setmeal
+     * The method to query Setmeals based on certain criteria.
+     */
+    @Override
+    public List<Setmeal> list(Setmeal setmeal) {
+        return setmealMapper.list(setmeal);
+        // Returns a list of Setmeals that match the given criteria.
+    }
+
+    /**
+     * 根据id查询菜品选项
+     * @param id
+     * The method to get dish options associated with a Setmeal.
+     */
+    @Override
+    public List<DishItemVO> getDishItemById(Long id) {
+        return setmealMapper.getDishItemBySetmealId(id);
+        // Retrieves the list of dish items associated with the given Setmeal ID.
+    }
+}

sky-take-out/sky-server/src/main/java/com/sky/service/impl/ShoppingCartServiceImpl.java

@@ -0,0 +1,198 @@
+package com.sky.service.impl;
+// 包声明，表示该类属于com.sky.service.impl包
+
+import com.sky.context.BaseContext;
+// 导入BaseContext类，获取当前用户的ID等上下文信息
+
+import com.sky.dto.ShoppingCartDTO;
+// 导入ShoppingCartDTO类，表示购物车数据传输对象
+
+import com.sky.entity.Dish;
+// 导入Dish实体类，表示菜品信息
+
+import com.sky.entity.Setmeal;
+// 导入Setmeal实体类，表示套餐信息
+
+import com.sky.entity.ShoppingCart;
+// 导入ShoppingCart实体类，表示购物车数据
+
+import com.sky.mapper.DishMapper;
+// 导入DishMapper接口，负责与Dish实体相关的数据库操作
+
+import com.sky.mapper.SetmealMapper;
+// 导入SetmealMapper接口，负责与Setmeal实体相关的数据库操作
+
+import com.sky.mapper.ShoppingCartMapper;
+// 导入ShoppingCartMapper接口，负责与ShoppingCart实体相关的数据库操作
+
+import com.sky.service.ShoppingCartService;
+// 导入ShoppingCartService接口，定义购物车服务层的操作
+
+import org.springframework.beans.BeanUtils;
+// 导入BeanUtils类，用于简化对象属性的复制
+
+import org.springframework.beans.factory.annotation.Autowired;
+// 导入@Autowired注解，用于自动注入依赖对象
+
+import org.springframework.stereotype.Service;
+// 导入Service注解，标识该类为服务层组件
+
+import java.time.LocalDateTime;
+// 导入LocalDateTime类，表示日期时间
+
+import java.util.List;
+// 导入List接口，表示列表类型
+
+@Service
+public class ShoppingCartServiceImpl implements ShoppingCartService {
+// 标识该类为服务层组件，处理购物车相关的业务逻辑
+
+    @Autowired
+    private ShoppingCartMapper shoppingCartMapper;
+    // 自动注入ShoppingCartMapper，负责与购物车表交互
+
+    @Autowired
+    private DishMapper dishMapper;
+    // 自动注入DishMapper，负责与菜品表交互
+
+    @Autowired
+    private SetmealMapper setmealMapper;
+    // 自动注入SetmealMapper，负责与套餐表交互
+
+    /**
+     * 添加购物车
+     * @param shoppingCartDTO
+     * 用于传输购物车数据的DTO对象
+     */
+    @Override
+    public void addShoppingCart(ShoppingCartDTO shoppingCartDTO) {
+        ShoppingCart shoppingCart = new ShoppingCart();
+        // 创建一个ShoppingCart对象用于保存购物车数据
+
+        BeanUtils.copyProperties(shoppingCartDTO, shoppingCart);
+        // 将购物车DTO中的数据复制到ShoppingCart对象
+
+        // 只能查询自己的购物车数据
+        shoppingCart.setUserId(BaseContext.getCurrentId());
+        // 设置当前登录用户的ID为购物车数据的用户ID
+
+        // 判断当前商品是否在购物车中
+        List<ShoppingCart> shoppingCartsList = shoppingCartMapper.list(shoppingCart);
+        // 查询当前用户的购物车数据，检查是否已有该商品
+
+        if (shoppingCartsList != null && shoppingCartsList.size() > 0) {
+            // 如果购物车中已存在该商品
+            shoppingCart = shoppingCartsList.get(0);
+            // 获取购物车中的第一个商品数据
+
+            shoppingCart.setNumber(shoppingCart.getNumber() + 1);
+            // 将商品数量+1
+
+            shoppingCartMapper.updateNumberById(shoppingCart);
+            // 更新购物车中商品的数量
+        } else {
+            // 如果购物车中没有该商品
+            Long dishId = shoppingCartDTO.getDishId();
+            // 获取菜品ID
+
+            if (dishId != null) {
+                // 如果添加到购物车的是菜品
+                Dish dish = dishMapper.getById(dishId);
+                // 根据菜品ID查询菜品信息
+
+                shoppingCart.setName(dish.getName());
+                // 设置菜品名称
+
+                shoppingCart.setImage(dish.getImage());
+                // 设置菜品图片
+
+                shoppingCart.setAmount(dish.getPrice());
+                // 设置菜品价格
+            } else {
+                // 如果添加到购物车的是套餐
+                Setmeal setmeal = setmealMapper.getById(shoppingCartDTO.getSetmealId());
+                // 根据套餐ID查询套餐信息
+
+                shoppingCart.setName(setmeal.getName());
+                // 设置套餐名称
+
+                shoppingCart.setImage(setmeal.getImage());
+                // 设置套餐图片
+
+                shoppingCart.setAmount(setmeal.getPrice());
+                // 设置套餐价格
+            }
+            shoppingCart.setNumber(1);
+            // 设置商品数量为1
+
+            shoppingCart.setCreateTime(LocalDateTime.now());
+            // 设置商品添加时间为当前时间
+
+            shoppingCartMapper.insert(shoppingCart);
+            // 将商品添加到购物车表
+        }
+    }
+
+    /**
+     * 查看购物车
+     * @return
+     * 返回当前用户的购物车数据列表
+     */
+    @Override
+    public List<ShoppingCart> showShoppingCart() {
+        return shoppingCartMapper.list(ShoppingCart.builder().userId(BaseContext.getCurrentId()).build());
+        // 查询当前用户的购物车数据，并返回购物车列表
+    }
+
+    /**
+     * 清空购物车商品
+     */
+    @Override
+    public void cleanShoppingCart() {
+        shoppingCartMapper.deleteByUserId(BaseContext.getCurrentId());
+        // 删除当前用户的所有购物车数据
+    }
+
+    /**
+     * 删除购物车中一个商品
+     * @param shoppingCartDTO
+     * 用于传输购物车商品数据的DTO对象
+     */
+    @Override
+    public void subShoppingCart(ShoppingCartDTO shoppingCartDTO) {
+        ShoppingCart shoppingCart = new ShoppingCart();
+        // 创建一个ShoppingCart对象用于保存商品数据
+
+        BeanUtils.copyProperties(shoppingCartDTO, shoppingCart);
+        // 将DTO中的数据复制到ShoppingCart对象
+
+        // 设置查询条件，查询当前登录用户的购物车数据
+        shoppingCart.setUserId(BaseContext.getCurrentId());
+        // 设置当前登录用户的ID为购物车查询条件
+
+        List<ShoppingCart> list = shoppingCartMapper.list(shoppingCart);
+        // 查询当前用户购物车中是否有该商品
+
+        if (list != null && list.size() > 0) {
+            // 如果购物车中有该商品
+            shoppingCart = list.get(0);
+            // 获取购物车中的商品数据
+
+            Integer number = shoppingCart.getNumber();
+            // 获取商品数量
+
+            if (number == 1) {
+                // 如果当前商品在购物车中的数量为1
+                shoppingCartMapper.deleteById(shoppingCart.getId());
+                // 删除购物车中的该商品
+            } else {
+                // 如果当前商品数量大于1
+                shoppingCart.setNumber(shoppingCart.getNumber() - 1);
+                // 将商品数量减1
+
+                shoppingCartMapper.updateNumberById(shoppingCart);
+                // 更新购物车中商品的数量
+            }
+        }
+    }
+}

sky-take-out/sky-server/src/main/java/com/sky/service/impl/UserServiceImpl.java

@@ -0,0 +1,144 @@
+package com.sky.service.impl;
+// 包声明，表示该类属于com.sky.service.impl包
+
+import com.alibaba.fastjson.JSON;
+// 导入FastJSON的JSON类，用于处理JSON数据
+
+import com.alibaba.fastjson.JSONObject;
+// 导入FastJSON的JSONObject类，用于解析JSON对象
+
+import com.sky.constant.MessageConstant;
+// 导入MessageConstant类，包含系统中常用的消息常量
+
+import com.sky.dto.UserLoginDTO;
+// 导入UserLoginDTO类，用于封装用户登录时的请求数据
+
+import com.sky.entity.User;
+// 导入User实体类，表示系统中的用户
+
+import com.sky.exception.LoginFailedException;
+// 导入LoginFailedException异常类，用于处理登录失败的情况
+
+import com.sky.mapper.UserMapper;
+// 导入UserMapper接口，用于与用户表进行数据库交互
+
+import com.sky.properties.WeChatProperties;
+// 导入WeChatProperties类，用于读取微信小程序的配置信息
+
+import com.sky.service.UserService;
+// 导入UserService接口，定义了用户相关的服务方法
+
+import com.sky.utils.HttpClientUtil;
+// 导入HttpClientUtil工具类，用于发送HTTP请求
+
+import lombok.extern.slf4j.Slf4j;
+// 导入Slf4j日志注解，便于记录日志
+
+import org.springframework.beans.factory.annotation.Autowired;
+// 导入@Autowired注解，用于自动注入依赖
+
+import org.springframework.stereotype.Service;
+// 导入Service注解，标识这是一个Spring的服务层类
+
+import java.time.LocalDateTime;
+// 导入LocalDateTime类，用于处理日期和时间
+
+import java.util.HashMap;
+// 导入HashMap类，用于构建微信API请求参数
+
+import java.util.Map;
+// 导入Map接口，用于存储微信API请求的键值对参数
+@Service
+@Slf4j
+public class UserServiceImpl implements UserService {
+// 使用@Service注解标记该类为Spring服务组件，@Slf4j注解为该类生成日志记录器
+
+    public static final String WX_LOGIN = "https://api.weixin.qq.com/sns/jscode2session";
+    // 定义常量，存储微信API登录接口的URL
+
+    @Autowired
+    private WeChatProperties weChatProperties;
+    // 自动注入WeChatProperties类，获取微信配置（appId和secret）
+
+    @Autowired
+    private UserMapper userMapper;
+    // 自动注入UserMapper类，用于访问数据库中的用户表
+
+    /**
+     * 微信登录
+     * @param userLoginDTO 用户登录请求数据传输对象
+     * @return 返回登录成功的用户对象
+     */
+    @Override
+    public User wxLogin(UserLoginDTO userLoginDTO) {
+        // 实现微信登录逻辑
+
+        // 调用微信接口服务，获取当前微信用户的Openid
+        String openid = getOpenid(userLoginDTO.getCode());
+        // 使用用户提供的code获取微信返回的openid
+
+        // 判断openid是否为空，如果为空标识登录失败，抛出业务异常
+        if (openid == null) {
+            throw new LoginFailedException(MessageConstant.LOGIN_FAILED);
+            // 如果openid为空，则说明登录失败，抛出登录失败异常
+        }
+
+        // 判断当前用户是否为新用户
+        User user = userMapper.getByOpenId(openid);
+        // 查询数据库中是否存在此openid的用户
+
+        // 如果是新用户,自动完成注册
+        if (user == null) {
+            user = User.builder()
+                    .openid(openid)
+                    .createTime(LocalDateTime.now())  // 设置用户创建时间为当前时间
+                    .build();
+            // 如果用户不存在，表示是新用户，创建一个新的用户对象
+
+            userMapper.insert(user);
+            // 将新用户信息插入数据库
+        }
+
+        // 返回这个用户对象
+        return user;
+        // 返回当前登录的用户对象，可能是已注册用户，也可能是刚注册的用户
+    }
+
+    /**
+     * 调用微信接口服务，获取微信用户的openid
+     * @param code 用户登录时从前端获取的微信临时登录凭证
+     * @return 返回微信用户的openid
+     */
+    private String getOpenid(String code) {
+        // 私有方法，用于根据code获取微信用户的openid
+
+        // 调用微信接口服务，获得当前微信用户的openid
+        Map<String, String> map = new HashMap<>();
+        // 创建一个HashMap，存储微信API请求的参数
+
+        map.put("appid", weChatProperties.getAppid());
+        // 设置小程序的appId（从配置文件中读取）
+
+        map.put("secret", weChatProperties.getSecret());
+        // 设置小程序的appSecret（从配置文件中读取）
+
+        map.put("js_code", code);
+        // 设置用户登录凭证（code）
+
+        map.put("grant_type", "authorization_code");
+        // 设置授权类型为“授权码”
+
+        // 发送HTTP请求，调用微信API接口，获取返回的JSON字符串
+        String json = HttpClientUtil.doGet(WX_LOGIN, map);
+        // 使用HttpClientUtil工具类发送GET请求，获取JSON格式的响应
+
+        JSONObject jsonObject = JSON.parseObject(json);
+        // 将返回的JSON字符串解析为JSONObject对象
+
+        String openid = jsonObject.getString("openid");
+        // 从JSON对象中提取openid字段
+
+        return openid;
+        // 返回openid
+    }
+}

sky-take-out/sky-server/src/main/java/com/sky/service/impl/WorkspaceServiceImpl.java

@@ -0,0 +1,224 @@
+package com.sky.service.impl;
+
+import com.sky.constant.StatusConstant;
+// 导入StatusConstant类，包含启用和禁用状态常量
+
+import com.sky.entity.Orders;
+// 导入Orders类，表示订单实体
+
+import com.sky.mapper.DishMapper;
+// 导入DishMapper接口，用于操作菜品相关的数据
+
+import com.sky.mapper.OrderMapper;
+// 导入OrderMapper接口，用于操作订单相关的数据
+
+import com.sky.mapper.SetmealMapper;
+// 导入SetmealMapper接口，用于操作套餐相关的数据
+
+import com.sky.mapper.UserMapper;
+// 导入UserMapper接口，用于操作用户相关的数据
+
+import com.sky.service.WorkspaceService;
+// 导入WorkspaceService接口，定义了工作台相关的服务方法
+
+import com.sky.vo.BusinessDataVO;
+// 导入BusinessDataVO类，用于封装营业数据的返回对象
+
+import com.sky.vo.DishOverViewVO;
+// 导入DishOverViewVO类，用于封装菜品总览的返回对象
+
+import com.sky.vo.OrderOverViewVO;
+// 导入OrderOverViewVO类，用于封装订单总览的返回对象
+
+import com.sky.vo.SetmealOverViewVO;
+// 导入SetmealOverViewVO类，用于封装套餐总览的返回对象
+
+import lombok.extern.slf4j.Slf4j;
+// 导入Slf4j注解，提供日志记录功能
+
+import org.springframework.beans.factory.annotation.Autowired;
+// 导入@Autowired注解，用于自动注入依赖
+
+import org.springframework.stereotype.Service;
+// 导入@Service注解，将该类标记为Spring服务层组件
+
+import java.time.LocalDateTime;
+// 导入LocalDateTime类，表示日期时间
+
+import java.time.LocalTime;
+// 导入LocalTime类，表示时间
+
+import java.util.HashMap;
+// 导入HashMap类，用于构建查询参数
+
+import java.util.Map;
+// 导入Map接口，用于存储查询参数
+@Service
+@Slf4j
+public class WorkspaceServiceImpl implements WorkspaceService {
+    // 使用@Service注解表示这是一个Spring服务类，@Slf4j提供日志记录功能
+
+    @Autowired
+    private OrderMapper orderMapper;
+    // 自动注入OrderMapper接口，操作订单数据
+
+    @Autowired
+    private UserMapper userMapper;
+    // 自动注入UserMapper接口，操作用户数据
+
+    @Autowired
+    private DishMapper dishMapper;
+    // 自动注入DishMapper接口，操作菜品数据
+
+    @Autowired
+    private SetmealMapper setmealMapper;
+    // 自动注入SetmealMapper接口，操作套餐数据
+
+    /**
+     * 根据时间段统计营业数据
+     * @param begin 起始时间
+     * @param end 结束时间
+     * @return 返回营业数据的封装对象
+     */
+    public BusinessDataVO getBusinessData(LocalDateTime begin, LocalDateTime end) {
+        // 定义方法，统计指定时间段内的营业数据
+
+        // 创建查询参数Map，包含开始时间和结束时间
+        Map map = new HashMap();
+        map.put("begin", begin);
+        map.put("end", end);
+
+        // 查询总订单数
+        Integer totalOrderCount = orderMapper.countByMap(map);
+        // 查询指定时间段内的总订单数
+
+        map.put("status", Orders.COMPLETED);
+        // 设置查询条件，订单状态为已完成
+
+        // 查询营业额
+        Double turnover = orderMapper.sumByMap(map);
+        turnover = turnover == null ? 0.0 : turnover;
+        // 查询指定时间段内的总营业额，如果没有数据，则设为0
+
+        // 查询有效订单数
+        Integer validOrderCount = orderMapper.countByMap(map);
+        // 查询指定时间段内的有效订单数
+
+        Double unitPrice = 0.0;
+        // 定义每单的平均消费金额（客单价）
+
+        Double orderCompletionRate = 0.0;
+        // 定义订单完成率
+
+        if (totalOrderCount != 0 && validOrderCount != 0) {
+            // 计算订单完成率和平均客单价
+            orderCompletionRate = validOrderCount.doubleValue() / totalOrderCount;
+            // 订单完成率 = 有效订单数 / 总订单数
+
+            unitPrice = turnover / validOrderCount;
+            // 平均客单价 = 营业额 / 有效订单数
+        }
+
+        // 查询新增用户数
+        Integer newUsers = userMapper.countByMap(map);
+        // 查询指定时间段内新增的用户数
+
+        // 返回封装的营业数据
+        return BusinessDataVO.builder()
+                .turnover(turnover)
+                .validOrderCount(validOrderCount)
+                .orderCompletionRate(orderCompletionRate)
+                .unitPrice(unitPrice)
+                .newUsers(newUsers)
+                .build();
+    }
+
+    /**
+     * 查询订单管理数据
+     * @return 返回订单管理数据的封装对象
+     */
+    public OrderOverViewVO getOrderOverView() {
+        // 定义方法，查询当前订单管理的概览数据
+
+        Map map = new HashMap();
+        map.put("begin", LocalDateTime.now().with(LocalTime.MIN));
+        // 查询今天的订单，从今天的最小时间开始（即00:00:00）
+
+        map.put("status", Orders.TO_BE_CONFIRMED);
+        // 设置查询条件，订单状态为待接单
+
+        // 待接单订单数量
+        Integer waitingOrders = orderMapper.countByMap(map);
+
+        // 待派送订单数量
+        map.put("status", Orders.CONFIRMED);
+        Integer deliveredOrders = orderMapper.countByMap(map);
+
+        // 已完成订单数量
+        map.put("status", Orders.COMPLETED);
+        Integer completedOrders = orderMapper.countByMap(map);
+
+        // 已取消订单数量
+        map.put("status", Orders.CANCELLED);
+        Integer cancelledOrders = orderMapper.countByMap(map);
+
+        // 查询全部订单数量
+        map.put("status", null);
+        Integer allOrders = orderMapper.countByMap(map);
+
+        // 返回封装的订单总览数据
+        return OrderOverViewVO.builder()
+                .waitingOrders(waitingOrders)
+                .deliveredOrders(deliveredOrders)
+                .completedOrders(completedOrders)
+                .cancelledOrders(cancelledOrders)
+                .allOrders(allOrders)
+                .build();
+    }
+
+    /**
+     * 查询菜品总览
+     * @return 返回菜品总览的封装对象
+     */
+    public DishOverViewVO getDishOverView() {
+        // 定义方法，查询菜品管理的概览数据
+
+        Map map = new HashMap();
+        map.put("status", StatusConstant.ENABLE);
+        // 查询启用状态的菜品数量
+        Integer sold = dishMapper.countByMap(map);
+
+        map.put("status", StatusConstant.DISABLE);
+        // 查询禁用状态的菜品数量
+        Integer discontinued = dishMapper.countByMap(map);
+
+        // 返回封装的菜品总览数据
+        return DishOverViewVO.builder()
+                .sold(sold)
+                .discontinued(discontinued)
+                .build();
+    }
+
+    /**
+     * 查询套餐总览
+     * @return 返回套餐总览的封装对象
+     */
+    public SetmealOverViewVO getSetmealOverView() {
+        // 定义方法，查询套餐管理的概览数据
+
+        Map map = new HashMap();
+        map.put("status", StatusConstant.ENABLE);
+        // 查询启用状态的套餐数量
+        Integer sold = setmealMapper.countByMap(map);
+
+        map.put("status", StatusConstant.DISABLE);
+        // 查询禁用状态的套餐数量
+        Integer discontinued = setmealMapper.countByMap(map);
+
+        // 返回封装的套餐总览数据
+        return SetmealOverViewVO.builder()
+                .sold(sold)
+                .discontinued(discontinued)
+                .build();
+    }
+}

sky-take-out/sky-server/src/main/java/com/sky/task/MyTask.java

@@ -0,0 +1,25 @@
+package com.sky.task;
+// 导入日志工具，记录日志
+import lombok.extern.slf4j.Slf4j;
+// 导入定时任务调度相关的类
+import org.springframework.scheduling.annotation.Scheduled;
+// 导入Spring组件注解
+import org.springframework.stereotype.Component;
+// 导入Date类，获取当前时间
+import java.util.Date;
+
+/**
+ * 自定义定时任务类，用于执行定时任务的逻辑
+ */
+@Component  // 标记该类为Spring的组件，会被自动扫描并管理
+@Slf4j  // 引入日志功能，便于在任务执行时记录日志
+public class MyTask {
+
+    /**
+     * 定时任务，每隔5秒触发一次
+     */
+    @Scheduled(cron = "0/5 * * * * ?")  // 使用Cron表达式设置定时任务的执行频率，这里是每隔5秒执行一次
+    public void executeTask(){  // 定义任务的方法
+        log.info("定时任务开始执行：{}", new Date());  // 记录任务执行的时间，使用占位符{}打印当前时间
+    }
+}

sky-take-out/sky-server/src/main/java/com/sky/task/OrderTask.java

@@ -0,0 +1,78 @@
+package com.sky.task;
+// 导入日志工具，记录日志
+import lombok.extern.slf4j.Slf4j;
+// 导入订单实体类
+import com.sky.entity.Orders;
+// 导入订单数据库操作接口
+import com.sky.mapper.OrderMapper;
+// 导入Spring的自动注入注解
+import org.springframework.beans.factory.annotation.Autowired;
+// 导入定时任务调度相关的类
+import org.springframework.scheduling.annotation.Scheduled;
+// 导入Spring的组件注解，标记该类为Spring管理的组件
+import org.springframework.stereotype.Component;
+// 导入时间类，用于处理时间
+import java.time.LocalDateTime;
+// 导入日期类，用于记录任务执行时间
+import java.util.Date;
+// 导入订单实体类的列表
+import java.util.List;
+
+/**
+ * 自定义定时任务，实现订单状态定时处理
+ */
+@Component  // 将该类标记为Spring管理的Bean
+@Slf4j  // 通过Lombok引入日志功能，自动提供一个名为 log 的日志记录器
+public class OrderTask {
+
+    @Autowired  // 自动注入 OrderMapper，用于操作订单数据
+    private OrderMapper orderMapper;
+
+    /**
+     * 处理支付超时订单的定时任务
+     * 每分钟执行一次
+     */
+    @Scheduled(cron = "0 * * * * ?")  // 定时任务Cron表达式：每分钟执行一次
+    public void processTimeoutOrder() {
+        log.info("处理支付超时订单：{}", new Date());  // 打印日志，记录任务执行时间
+
+        // 获取当前时间，减去15分钟，用于判断支付是否超时
+        LocalDateTime time = LocalDateTime.now().plusMinutes(-15);
+
+        // 从数据库中查询所有支付状态为“待支付”且超过15分钟未支付的订单
+        List<Orders> ordersList = orderMapper.getByStatusAndOrderTime(Orders.PENDING_PAYMENT, time);
+
+        // 如果查询到支付超时的订单，进行状态更新
+        if (ordersList != null && ordersList.size() > 0) {
+            ordersList.forEach(orders -> {
+                orders.setStatus(Orders.CANCELLED);  // 将订单状态设置为已取消
+                orders.setCancelReason("支付超时，自动取消");  // 设置取消原因
+                orders.setCancelTime(LocalDateTime.now());  // 设置取消时间为当前时间
+                orderMapper.update(orders);  // 更新订单状态
+            });
+        }
+    }
+
+    /**
+     * 处理“派送中”状态的订单
+     * 每天凌晨1点执行一次
+     */
+    @Scheduled(cron = "0 0 1 * * ?")  // 定时任务Cron表达式：每天凌晨1点执行一次
+    public void processDeliveryOrder(){
+        log.info("处理派送中订单：{}", new Date());  // 打印日志，记录任务执行时间
+
+        // 获取当前时间，减去60分钟，用于判断派送是否超时
+        LocalDateTime time = LocalDateTime.now().plusMinutes(-60);
+
+        // 从数据库中查询所有状态为“派送中”的订单，且超过60分钟
+        List<Orders> ordersList = orderMapper.getByStatusAndOrderTime(Orders.DELIVERY_IN_PROGRESS, time);
+
+        // 如果查询到派送中且超时的订单，进行状态更新
+        if (ordersList != null && ordersList.size() > 0) {
+            ordersList.forEach(orders -> {
+                orders.setStatus(Orders.COMPLETED);  // 将订单状态设置为已完成
+                orderMapper.update(orders);  // 更新订单状态
+            });
+        }
+    }
+}

sky-take-out/sky-server/src/main/java/com/sky/task/WebSocketTask.java

@@ -0,0 +1,34 @@
+package com.sky.task;
+
+// 导入WebSocketServer类，用于与客户端进行WebSocket通信
+import com.sky.websocket.WebSocketServer;
+// 导入Spring的自动注入注解
+import org.springframework.beans.factory.annotation.Autowired;
+// 导入定时任务调度相关的类
+import org.springframework.scheduling.annotation.Scheduled;
+// 导入Spring的组件注解，标记该类为Spring管理的组件
+import org.springframework.stereotype.Component;
+// 导入时间类，处理时间格式化
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+/**
+ * WebSocket定时任务类，定时向客户端发送消息
+ */
+@Component  // 将该类标记为Spring管理的Bean
+public class WebSocketTask {
+
+    // 自动注入WebSocketServer，用于实现WebSocket通信
+    @Autowired
+    private WebSocketServer webSocketServer;
+
+    /**
+     * 每隔5秒钟，通过WebSocket向所有客户端发送当前时间的消息
+     */
+    @Scheduled(cron = "0/5 * * * * ?")  // 定时任务的Cron表达式：每隔5秒执行一次
+    public void sendMessageToClient() {
+        // 向所有连接的客户端发送消息，消息内容是当前时间（格式为HH:mm:ss）
+        webSocketServer.sendToAllClient("这是来自服务端的消息：" +
+                DateTimeFormatter.ofPattern("HH:mm:ss").format(LocalDateTime.now()));
+    }
+}

sky-take-out/sky-server/src/main/java/com/sky/websocket/WebSocketServer.java

@@ -0,0 +1,70 @@
+package com.sky.websocket;
+
+import org.springframework.stereotype.Component;
+
+import javax.websocket.OnClose;
+import javax.websocket.OnMessage;
+import javax.websocket.OnOpen;
+import javax.websocket.Session;
+import javax.websocket.server.PathParam;
+import javax.websocket.server.ServerEndpoint;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * WebSocket服务
+ */
+@Component
+@ServerEndpoint("/ws/{sid}")
+public class WebSocketServer {
+    //存放会话对象
+    private static Map<String, Session> sessionMap = new HashMap();
+
+    /**
+     * 连接建立成功调用的方法
+     */
+    @OnOpen
+    public void onOpen(Session session, @PathParam("sid") String sid) {
+        System.out.println("客户端：" + sid + "建立连接");
+        sessionMap.put(sid, session);
+    }
+
+    /**
+     * 收到客户端消息后调用的方法
+     *
+     * @param message 客户端发送过来的消息
+     */
+    @OnMessage
+    public void onMessage(String message, @PathParam("sid") String sid) {
+        System.out.println("收到来自客户端：" + sid + "的信息:" + message);
+    }
+
+    /**
+     * 连接关闭调用的方法
+     *
+     * @param sid
+     */
+    @OnClose
+    public void onClose(@PathParam("sid") String sid) {
+        System.out.println("连接断开:" + sid);
+        sessionMap.remove(sid);
+    }
+
+    /**
+     * 群发
+     *
+     * @param message
+     */
+    public void sendToAllClient(String message) {
+        Collection<Session> sessions = sessionMap.values();
+        for (Session session : sessions) {
+            try {
+                //服务器向客户端发送消息
+                session.getBasicRemote().sendText(message);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}