苍穹外卖 数据可视化

        将业务额、用户数据、订单数据、商品销量top10数据全部利用Apache Echarts可视化，显现在前端，后端只须要按照须要的格式，为前端提供数据即可。
        ReportController

2. package com.sky.controller.admin;
4. import com.sky.result.Result;
5. import com.sky.service.ReportService;
6. import com.sky.vo.OrderReportVO;
7. import com.sky.vo.SalesTop10ReportVO;
8. import com.sky.vo.TurnoverReportVO;
9. import com.sky.vo.UserReportVO;
10. import io.swagger.annotations.Api;
11. import io.swagger.annotations.ApiOperation;
12. import lombok.extern.slf4j.Slf4j;
13. import org.springframework.beans.factory.annotation.Autowired;
14. import org.springframework.format.annotation.DateTimeFormat;
15. import org.springframework.web.bind.annotation.GetMapping;
16. import org.springframework.web.bind.annotation.RequestMapping;
17. import org.springframework.web.bind.annotation.RestController;
19. import java.time.LocalDate;
21. @RestController
22. @RequestMapping("/admin/report")
23. @Slf4j
24. @Api(tags = "统计报表相关接口")
25. public class ReportController {
26.     // Apache Echarts
27.     // Apache Echarts是一个基于JavaScript的数据可视化图标库，提供直观、生动、可交互的数据可视化图表
28.     // 无论是什么形式的图形，其本质上是数据，ApacheEcharts就是对数据的可视化展示
30.     // 但是Apache Echarts是前端需要使用的东西，后端只需要按照和前端的约定，为其提供数据即可
32.     @Autowired
33.     private ReportService reportService;
35.     /**
36.      * 营业额数据统计
37.      *
38.      * @param begin
39.      * @param end
40.      * @return
41.      */
42.     // 查询一段时间内的营业额，前端给后端传递开始时间和结束时间，后端需要查询这段时间内的营业额，并封装到VO中、
43.     // 约定好VO中封装两个字符串，时间和对应的营业额，用","分隔
44.     @GetMapping("/turnoverStatistics")
45.     @ApiOperation("营业额数据统计")
46.     // 使用@DateTimeFormat限定前端传递的时间的格式
47.     public Result<TurnoverReportVO> turnoverStatistics(@DateTimeFormat(pattern = "yyyy-MM-dd")
48.                                                        LocalDate begin,
49.                                                        @DateTimeFormat(pattern = "yyyy-MM-dd")
50.                                                        LocalDate end) {
51.         return Result.success(reportService.getTurnoverStatistics(begin, end));
52.     }
54.     /**
55.      * 用户数据统计
56.      *
57.      * @param begin
58.      * @param end
59.      * @return
60.      */
61.     // 用户数据统计分为两个部分：用户总量和新增用户；用户总量很好理解————
62.     // 而新增用户可以理解为：假如是今天是11.11日，
63.     // 那么在11.11日最小时间（00:00:00）————11.11日最大时间（23:59:59）创建的用户都是这一天的新用户
64.     @GetMapping("/userStatistics")
65.     @ApiOperation("用户数据统计")
66.     public Result<UserReportVO> userStatistics(@DateTimeFormat(pattern = "yyyy-MM-dd")
67.                                                LocalDate begin,
68.                                                @DateTimeFormat(pattern = "yyyy-MM-dd")
69.                                                LocalDate end) {
70.         return Result.success(reportService.getUserStatistics(begin, end));
71.     }
73.     /**
74.      * 订单数据统计
75.      *
76.      * @param begin
77.      * @param end
78.      * @return
79.      */
80.     // 订单数据统计需要查询当天的所有订单和完成了的有效订单，并根据这两个数据计算出订单总数、有效订单总数、订单完成率
81.     @GetMapping("/ordersStatistics")
82.     @ApiOperation("订单数据统计")
83.     public Result<OrderReportVO> ordersStatistics(@DateTimeFormat(pattern = "yyyy-MM-dd")
84.                                                   LocalDate begin,
85.                                                   @DateTimeFormat(pattern = "yyyy-MM-dd")
86.                                                   LocalDate end) {
87.         return Result.success(reportService.getOrdersStatistics(begin, end));
88.     }
90.     /**
91.      * top10畅销商品统计
92.      *
93.      * @param begin
94.      * @param end
95.      * @return
96.      */
97.     @GetMapping("top10")
98.     @ApiOperation("top10畅销商品统计")
99.     public Result<SalesTop10ReportVO> top10Statistics(@DateTimeFormat(pattern = "yyyy-MM-dd")
100.                                                       LocalDate begin,
101.                                                       @DateTimeFormat(pattern = "yyyy-MM-dd")
102.                                                       LocalDate end) {
103.         return Result.success(reportService.getSalesTop10Statistics(begin, end));
104.     }
105. }

复制代码

        ReportService

2. package com.sky.service;
4. import com.sky.vo.OrderReportVO;
5. import com.sky.vo.SalesTop10ReportVO;
6. import com.sky.vo.TurnoverReportVO;
7. import com.sky.vo.UserReportVO;
8. import org.springframework.stereotype.Service;
10. import java.time.LocalDate;
12. @Service
13. public interface ReportService {
15.     /**
16.      * 根据时间区间统计营业额数据
17.      *
18.      * @param begin
19.      * @param end
20.      * @return
21.      */
22.     TurnoverReportVO getTurnoverStatistics(LocalDate begin, LocalDate end);
24.     /**
25.      * 根据时间区间统计用户数量
26.      *
27.      * @param begin
28.      * @param end
29.      * @return
30.      */
31.     UserReportVO getUserStatistics(LocalDate begin, LocalDate end);
33.     /**
34.      * 根据时间区间统计订单数据
35.      *
36.      * @param begin
37.      * @param end
38.      * @return
39.      */
40.     OrderReportVO getOrdersStatistics(LocalDate begin, LocalDate end);
42.     /**
43.      * 根据时间区间统计畅销top10商品
44.      *
45.      * @param begin
46.      * @param end
47.      * @return
48.      */
49.     SalesTop10ReportVO getSalesTop10Statistics(LocalDate begin, LocalDate end);
50. }

复制代码

        实现类

2. package com.sky.service.impl;
4. import com.sky.dto.GoodsSalesDTO;
5. import com.sky.entity.Orders;
6. import com.sky.mapper.OrderMapper;
7. import com.sky.mapper.UserMapper;
8. import com.sky.service.ReportService;
9. import com.sky.vo.OrderReportVO;
10. import com.sky.vo.SalesTop10ReportVO;
11. import com.sky.vo.TurnoverReportVO;
12. import com.sky.vo.UserReportVO;
13. import lombok.extern.slf4j.Slf4j;
14. import org.apache.commons.lang.StringUtils;
15. import org.springframework.beans.factory.annotation.Autowired;
16. import org.springframework.stereotype.Service;
18. import java.time.LocalDate;
19. import java.time.LocalDateTime;
20. import java.time.LocalTime;
21. import java.util.*;
22. import java.util.stream.Collectors;
24. @Service
25. @Slf4j
26. public class ReportServiceImpl implements ReportService {
28.     @Autowired
29.     private OrderMapper orderMapper;
30.     @Autowired
31.     private UserMapper userMapper;
33.     /**
34.      * 抽取方法：根据begin————end时间区间创建日期集合
35.      *
36.      * @param begin
37.      * @param end
38.      * @return
39.      */
40.     private List<LocalDate> createTimeList (LocalDate begin, LocalDate end) {
41.         // 创建一个集合，用于存储从begin-end时间内的所有日期，用于查找对应的营业额
42.         List<LocalDate> dateList = new ArrayList<>();
43.         // 先加入起始日期
44.         dateList.add(begin);
45.         // 若还没有加入到最后一个日期，就一直加入
46.         while (!begin.equals(end)) {
47.             // 每次都将begin日期后延1天，直到begin = end
48.             begin = begin.plusDays(1);
49.             // 加入集合
50.             dateList.add(begin);
51.         }
52.         return dateList;
53.     }
55.     /**
56.      * 根据时间区间查询营业额数据
57.      *
58.      * @param begin
59.      * @param end
60.      * @return
61.      */
62.     @Override
63.     public TurnoverReportVO getTurnoverStatistics(LocalDate begin, LocalDate end) {
64.         // 通过抽取的方法创建时间区间的日期集合
65.         List<LocalDate> dateList = createTimeList(begin, end);
66.         // 创建营业额集合，用于存储每天的营业额
67.         List<Double> turnoverList = new ArrayList<>();
68.         // 遍历日期集合，按照每一天进行逻辑处理
69.         for (LocalDate date : dateList) {
70.             // 因为表中的订单的时间是LocalDateTime类型的，所以说要将日期集合中的LocalDate封装为LocalDateTime
71.             // 当天的营业额是大于当天的最小时间（00:00:00），小于当天的最大时间的（23:59:59），所以说可以将日期集合中的元素对应的
72.             // 那天的beginTime设置为当天最小时间；endTime设置为当天的最大时间
73.             LocalDateTime beginTime = LocalDateTime.of(date, LocalTime.MIN);
74.             LocalDateTime endTime = LocalDateTime.of(date, LocalTime.MAX);
75.             // 用Map来封装查询的条件
76.             Map<Object, Object> map = new HashMap<>();
77.             // 要统计当天的营业额，只统计已经完成了的订单
78.             map.put("status", Orders.COMPLETED);
79.             // 封装查询的时间（时间为当天）
80.             map.put("begin", beginTime);
81.             map.put("end", endTime);
82.             Double turnover = orderMapper.sumAmount(map);
83.             // 判断当天是否有营业额，若没有营业额则turnover为空，但是这不符合前端展示的逻辑，需要对其检查，若没有营业额，那么营业额是0.0
84.             turnover = turnover == null ? 0.0 : turnover;
85.             // 将当前date对应的营业额加入turnover集合
86.             turnoverList.add(turnover);
87.         }
88.         // 处理数据返回
89.         // 使用StringUtils进行数据封装，封装为前端需要的格式返回。StringUtils是Apache的
90.         return TurnoverReportVO.builder()
91.                 .dateList(StringUtils.join(dateList, ","))
92.                 .turnoverList(StringUtils.join(turnoverList, ","))
93.                 .build();
94.     }
96.     /**
97.      * 根据时间区间查询用户数据
98.      *
99.      * @param begin
100.      * @param end
101.      * @return
102.      */
103.     @Override
104.     public UserReportVO getUserStatistics(LocalDate begin, LocalDate end) {
105.         // 通过抽取的方法创建时间区间的日期集合
106.         List<LocalDate> dateList = createTimeList(begin, end);
107.         // 新增用户集合
108.         List<Integer> newUserList = new ArrayList<>();
109.         // 总用户集合
110.         List<Integer> totalUserList = new ArrayList<>();
111.         for (LocalDate date : dateList) {
112.             LocalDateTime beginTime = LocalDateTime.of(date, LocalTime.MIN);
113.             LocalDateTime endTime = LocalDateTime.of(date, LocalTime.MAX);
114.             // 总用户，只要在目标时间之前创建的用户都算是当前时间的总用户
115.             // 建议先查询总用户数，因为查询条件更加简单
116.             Integer totalUser = getUserCount(null, endTime);
117.             // 新增用户可以理解为：假如是今天是11.11日，
118.             // 那么在11.11日最小时间（00:00:00）————11.11日最大时间（23:59:59）创建的用户都是这一天的新用户
119.             Integer newUser = getUserCount(beginTime, endTime);
120.             // 进行前端逻辑处理，将null变为0
121.             totalUser = totalUser == null ? 0 : totalUser;
122.             newUser = newUser == null ? 0 : newUser;
123.             // 加入对应集合
124.             totalUserList.add(totalUser);
125.             newUserList.add(newUser);
126.         }
127.         // 封装数据返回
128.         return UserReportVO.builder()
129.                 .dateList(StringUtils.join(dateList, ","))
130.                 .newUserList(StringUtils.join(newUserList, ","))
131.                 .totalUserList(StringUtils.join(totalUserList, ","))
132.                 .build();
133.     }
135.     /**
136.      * 根据时间区间统计用户数量
137.      *
138.      * @param beginTime
139.      * @param endTime
140.      * @return
141.      */
142.     private Integer getUserCount(LocalDateTime beginTime, LocalDateTime endTime) {
143.         // 将开始时间和结束时间封装为map再在数据库中进行查询
144.         Map<Object, Object> map = new HashMap<>();
145.         map.put("begin", beginTime);
146.         map.put("end", endTime);
147.         return userMapper.countUsersByTime(map);
148.     }
150.     /**
151.      * 根据时间区间查询订单数据
152.      *
153.      * @param begin
154.      * @param end
155.      * @return
156.      */
157.     @Override
158.     public OrderReportVO getOrdersStatistics(LocalDate begin, LocalDate end) {
159.         // 通过抽取的方法创建时间区间的日期集合
160.         List<LocalDate> dateList = createTimeList(begin, end);
162.         // 总订单集合
163.         List<Integer> totalOrdersList = new ArrayList<>();
164.         // 有效订单集合 valid   adj.有效的
165.         List<Integer> validOrdersList = new ArrayList<>();
167.         for (LocalDate date : dateList) {
168.             LocalDateTime beginTime = LocalDateTime.of(date, LocalTime.MIN);
169.             LocalDateTime endTime = LocalDateTime.of(date, LocalTime.MAX);
171.             // 查询总订单
172.             Integer totalOrders = getOrdersCount(beginTime, endTime, null);
173.             // 查询有效订单
174.             Integer validOrders = getOrdersCount(beginTime, endTime, Orders.COMPLETED);
175.             // 进行前端逻辑处理，将null变为0
176.             totalOrders = totalOrders == null ? 0 : totalOrders;
177.             // TODO 细心！细心！细心！不要再犯这种傻逼错误
178.             validOrders = validOrders == null ? 0 : validOrders;
179.             // 将其加入对应的集合
180.             totalOrdersList.add(totalOrders);
181.             validOrdersList.add(validOrders);
182.         }
184.         // 计算总订单数量
185.         Integer totalOrdersCount = 0;
186.         for (Integer order : totalOrdersList) {
187.             totalOrdersCount += order;
188.         }
189.         // 计算总有效订单数量
190.         Integer validOrdersCount = 0;
191.         for (Integer order : validOrdersList) {
192.             validOrdersCount += order;
193.         }
194.         // 计算完单率
195.         // 如果没有订单，完单率就是0
196.         Double orderCompletionRate = 0.0;
197.         if (totalOrdersCount != 0) {
198.             // 只有存在订单，才计算完单率
199.          orderCompletionRate = validOrdersCount.doubleValue() / totalOrdersCount;
200.         }
202.         return OrderReportVO.builder()
203.                 .dateList(StringUtils.join(dateList, ","))
204.                 .orderCountList(StringUtils.join(totalOrdersList, ","))
205.                 .validOrderCountList(StringUtils.join(validOrdersList, ","))
206.                 .totalOrderCount(totalOrdersCount)
207.                 .validOrderCount(validOrdersCount)
208.                 .orderCompletionRate(orderCompletionRate)
209.                 .build();
210.     }
212.     /**
213.      * 根据时间区间和订单状态查询订单数据
214.      *
215.      * @param beginTime
216.      * @param endTime
217.      * @param status
218.      * @return
219.      */
220.     private Integer getOrdersCount(LocalDateTime beginTime, LocalDateTime endTime, Integer status) {
221.         // 将时间和状态封装为map进行查询
222.         // 在SQL中先根据status查询，若status不对，那么就可以不用比对后面的属性，提高效率
223.         Map<Object, Object> map = new HashMap<>();
224.         map.put("status", status);
225.         map.put("begin", beginTime);
226.         map.put("end", endTime);
227.         return orderMapper.statisticsOrders(map);
228.     }
230.     /**
231.      * 根据时间区间统计畅销top10商品
232.      *
233.      * @param begin
234.      * @param end
235.      * @return
236.      */
237.     @Override
238.     public SalesTop10ReportVO getSalesTop10Statistics(LocalDate begin, LocalDate end) {
239.         // 因为不需要统计每一天的销量，只需要统计在这段时间之内的销量，所以说不需要遍历每一天的销量，可以直接使用begin和end
240.         LocalDateTime beginTime = LocalDateTime.of(begin, LocalTime.MIN);
241.         LocalDateTime endTime = LocalDateTime.of(end, LocalTime.MAX);
243.         // 查询销量前10的商品，并封装在GoodsSalesDTO中（商品名和销量）
244.         List<GoodsSalesDTO> goodsSalesDTOList = orderMapper.getSalesTop10(beginTime, endTime);
246.         // 处理goodsSalesDTOList中数据
247.         String nameList = StringUtils.join(goodsSalesDTOList.stream().map(GoodsSalesDTO::getName)
248.                 .collect(Collectors.toList()), ",");
250.         String numberList = StringUtils.join(goodsSalesDTOList.stream().map(GoodsSalesDTO::getNumber)
251.                 .collect(Collectors.toList()), ",");
253.         // 封装成对应的VO返回
254.         return SalesTop10ReportVO.builder()
255.                 .nameList(nameList)
256.                 .numberList(numberList)
257.                 .build();
258.     }
260. }

复制代码

        Mapper相对简单，这里不外多赘述。