Day09苍穹外卖代码解析以及深入分析
文章目录
- 前言
- 一、用户端
-
- 1.查看历史订单
- 2.查看订单详细信息
- 3.取消订单
- 4.再来一单
- 5.lambda、stream
- 二、服务端
-
- 1.后台订单搜索
- 2.统计各个状态订单
- 3.查看订单详情
- 4.商家接单
- 5.商家拒单
- 6.百度地图开放平台
- 总结
前言
Day09作业
本次遇到的最大的bug：<、>、& 等特殊字符直接写在 XML 内容中，需要转义为 <、>、& 等。
一、用户端
总的service接口：
OrderService:
public interface OrderService {
OrderSubmitVO submitOrder(OrdersSubmitDTO ordersSubmitDTO);
// 订单支付
OrderPaymentVO payment(OrdersPaymentDTO ordersPaymentDTO) throws Exception;
// 支付成功，修改订单状态
void paySuccess(String outTradeNo);
// 分页查询 用户订单信息
PageResult pageQueryUser(int page,int pageSize,Integer status);
// 用户查询订单详情
OrderVO details(Long id);
// 用户取消订单
void userCancelById(Long id) throws Exception;
// 用户再来一单
void repetition(Long id);
}
1.查看历史订单
用户可以查看历史订单，实际上是一个分页查询，有可能订单有很多，所以进行分页查询处理。
controller:
/**
* 用户查询历史订单
* 实际上是一个分页查询
* @param page
* @param pageSize
* @param status 订单状态 1待付款 2待接单 3已接单 4派送中 5已完成 6已取消
* @return
*/
@GetMapping("/historyOrders")
@ApiOperation("历史订单查询")
public Result<PageResult> page(int page, int pageSize, Integer status){
log.info("历史订单查询");
PageResult pageResult = orderService.pageQueryUser(page,pageSize,status);
return Result.success(pageResult);
}
serviceImpl:
由于我们需要返回OrderVO类型的pageResult，所以我们先从DTO读取了status和userId后，进行分页查询后返回page结果，再遍历这个page列表，将page列表里面的元素转换成VO对象，装入list后，返回即可。通常进行BeanUtils对象拷贝的时候需要手动传入id和与其他表关联的List，这里需要传入订单明细，所以这里也进行了手动赋值。
/**
* 分页查询 用户的订单信息
* @param pageNum
* @param pageSize
* @param status
* @return
*/
@Override
public PageResult pageQueryUser(int pageNum, int pageSize, Integer status) {
// 1.设置分页
PageHelper.startPage(pageNum, pageSize);
OrdersPageQueryDTO ordersPageQueryDTO = new OrdersPageQueryDTO();
ordersPageQueryDTO.setStatus(status);
ordersPageQueryDTO.setUserId(BaseContext.getCurrentId());
// 2.分页查询
Page<Orders> page = orderMapper.pageQuery(ordersPageQueryDTO);
List<OrderVO> list = new ArrayList<>();
// 3.查询订单明细 需要封装进orderVO里面 因为里面也需要用户订单明细的信息
if (page != null && page.getTotal() > 0) {
for (Orders orders : page) {
Long orderId = orders.getId(); // 订单id
// 4.查询订单明细
List<OrderDetail> orderDetails = orderDetailMapper.getByOrderId(orderId);
OrderVO orderVO = new OrderVO();
BeanUtils.copyProperties(orders, orderVO);
// 5.由于是浅拷贝需要单独赋值
orderVO.setOrderDetailList(orderDetails);
list.add(orderVO);
}
}
return new PageResult(page.getTotal(), list);
}
mapper:
这里进行了排序，新的订单会在上方出现。
<select id="pageQuery" resultType="Orders">
select * from orders
<where>
<if test="number != null and number!=''">
and number like concat('%',#{number},'%')
if>
<if test="phone != null and phone!=''">
and phone like concat('%',#{phone},'%')
if>
<if test="userId != null">
and user_id = #{userId}
if>
<if test="status != null">
and status = #{status}
if>
<if test="beginTime != null">
and order_time >= #{beginTime}
if>
<if test="endTime != null">
and order_time <= #{endTime}
if>
where>
order by order_time desc
select>
2.查看订单详细信息
controller:
/**
* 用户查询订单详情
*/
@GetMapping("/orderDetail/{id}")
@ApiOperation("查询订单详情")
public Result<OrderVO> details(@PathVariable("id") Long id){
log.info("用户查询订单详情");
OrderVO orderVO = orderService.details(id);
return Result.success(orderVO);
}
serviceImpl:
因为根据接口文档所以要返回VO对象，在根据id查到orders后，需要查询该订单对应的菜品信息，也就是order_detail，手动把关联的OrderDetailList赋值后装入VO对象进行返回即可。
/**
* 用户查询订单详情
* @param id
* @return
*/
@Override
public OrderVO details(Long id) {
// 1.根据id查询订单
Orders orders = orderMapper.getById(id);
// 2.查询该订单对应的菜品/套餐明细
List<OrderDetail> orderDetailList = orderDetailMapper.getByOrderId(orders.getId());
// 3.将该订单及其详情封装到OrderVO并返回
OrderVO orderVO = new OrderVO();
BeanUtils.copyProperties(orders, orderVO);
orderVO.setOrderDetailList(orderDetailList);
return orderVO;
}
OrderMapper:
/**
* 用户查询订单详情
*/
@Select("select * from orders where id = #{id}")
Orders getById(Long id);
OrderDetailMapper:
@Select("select * from order_detail where order_id = #{orderId}")
List<OrderDetail> getByOrderId(Long orderId);
3.取消订单
由于我们在下单后订单状态有很多种，所以我们需要分情况处理，但是这里做模糊处理，以后听老大的安排，再分情况处理，有这个概念就行了。由于我们调用了微信服务的接口，所以需要往上抛异常。
controller:
/**
* 用户取消订单
* 取消订单的时候就会分为几个情况
*/
@PutMapping("/cancel/{id}")
@ApiOperation("取消订单")
public Result cancel(@PathVariable("id") Long id) throws Exception{
log.info("用户取消订单");
orderService.userCancelById(id);
return Result.success();
}
serviceImpl:
为什么需要两个orders对象？
个人解析：因为我们要先验证该订单是否存在，而且我们需要进行修改orders，但是没必要去调用mapper层的动态sql，会增加开销，所以直接用副本进行添加状态、备注、理由等属性即可，验证完毕后再进行数据库(mapper层)的操作。
/**
* 用户取消订单 需要分为几个情况
* @param id
* 订单状态: 1待付款 2待接单 3已接单 4派送中 5已完成 6已取消
*/
@Override
public void userCancelById(Long id) throws Exception {
// 1.根据id先查询订单
Orders ordersDB = orderMapper.getById(id);
// 2.检验订单是否存在
if (ordersDB == null) {
throw new OrderBusinessException(MessageConstant.ORDER_NOT_FOUND);
}
// 3.判断订单的状态
if (ordersDB.getStatus() > 2) {
throw new OrderBusinessException(MessageConstant.ORDER_STATUS_ERROR);
}
Orders orders = new Orders();
orders.setId(ordersDB.getId());
// 4.订单处于待接单 == 2的状态下取消 需要进行退款
if(ordersDB.getStatus().equals(Orders.TO_BE_CONFIRMED)) {
// 调用微信服务的支付退款接口
weChatPayUtil.refund(
ordersDB.getNumber(), //商户订单号
ordersDB.getNumber(), //商户退款单号
new BigDecimal(0.01), //退款金额，单位 元
new BigDecimal(0.01) //原订单金额
);
// 退款后进行修改订单状态为 退款
orders.setPayStatus(Orders.REFUND);
}
// 5.更新订单状态 取消原因 取消时间
orders.setStatus(Orders.CANCELLED);
orders.setCancelReason("用户取消");
orders.setCancelTime(LocalDateTime.now());
orderMapper.update(orders);
}
4.再来一单
controller:
/**
* 再来一单
* @param id
* @return
*/
@PostMapping("/repetition/{id}")
@ApiOperation("再来一单")
public Result repetition(@PathVariable Long id) {
orderService.repetition(id);
return Result.success();
}
serviceImpl:
这里涉及到lambda表达式的知识，我带着大家来复习一遍。其实这里的逻辑就是根据用户的id查询对应的订单详细信息，将原订单里面的信息重新拷贝到新的购物车对象中，然后将新的拷贝后的购物车进行批量插入到数据库之中，用来更新用户购物车信息。说实话，我认为没必要使用较难的语法，我觉得可读性比代码简洁优先。
- orderDetailList.stream()
作用：将orderDetailList转换为一个 Stream 流，以便后续进行链式操作。 - .map(x -> { … })
作用：对 Stream 中的每个元素（OrderDetail 对象）进行映射转换，生成一个新的 ShoppingCart 对象。 - .collect(Collectors.toList())
作用：将 Stream 重新收集为一个 List。Stream 的操作是惰性的，必须通过 终止操作（如 collect）触发实际计算。这里将所有转换后的 ShoppingCart 对象合并成一个列表。
/**
* 用户再来一单
* @param id
*/
@Override
public void repetition(Long id) {
// 1.查询当前用户id
Long userId = BaseContext.getCurrentId();
// 2.根据订单id查询当前订单详情
List<OrderDetail> orderDetailList = orderDetailMapper.getByOrderId(id);
// 3.将订单详情对象转换为购物车对象
List<ShoppingCart> shoppingCartList = orderDetailList.stream().map(x -> {
ShoppingCart shoppingCart = new ShoppingCart();
// 4.将原订单详情里面的菜品信息重新复制到购物车对象中
BeanUtils.copyProperties(x, shoppingCart, "id");
shoppingCart.setUserId(userId);
shoppingCart.setCreateTime(LocalDateTime.now());
return shoppingCart;
}).collect(Collectors.toList());
// 5.将购物车对象批量添加到数据库
shoppingCartMapper.insertBatch(shoppingCartList);
}
另一个简单版本：
@Override
public void repetition(Long id) {
// 1. 获取当前用户ID
Long userId = BaseContext.getCurrentId();
// 2. 根据订单ID查询订单详情
List<OrderDetail> orderDetailList = orderDetailMapper.getByOrderId(id);
// 3. 创建购物车列表
List<ShoppingCart> shoppingCartList = new ArrayList<>();
// 4. 遍历订单详情，转换为购物车对象
for (OrderDetail orderDetail : orderDetailList) {
ShoppingCart shoppingCart = new ShoppingCart();
// 复制属性（排除 id）
BeanUtils.copyProperties(orderDetail, shoppingCart, "id");
shoppingCart.setUserId(userId);
shoppingCart.setCreateTime(LocalDateTime.now());
shoppingCartList.add(shoppingCart);
}
// 5. 批量插入购物车数据
shoppingCartMapper.insertBatch(shoppingCartList);
}
5.lambda、stream
这里只是简单的复习一下lambda与stream。
- lambda：lambda是一种匿名函数的简洁写法，能够减少代码量。
- 核心思想：用更少的代码实现接口中的抽象方法。其实就是重写。
- Stream：是 Java 8 引入的流式数据处理抽象。
二、服务端
后台service接口:
// 后台订单搜索
PageResult conditionSearch(OrdersPageQueryDTO ordersPageQueryDTO);
// 统计各个状态的订单
OrderStatisticsVO statistics();
// 后台接单
void confirm(OrdersConfirmDTO ordersConfirmDTO);
// 后台拒单
void rejection(OrdersRejectionDTO ordersRejectionDTO) throws Exception;
// 后台取消订单
void cancel(OrdersCancelDTO ordersCancelDTO) throws Exception;
// 派送配餐
void delivery(Long id);
// 完成配餐
void complete(Long id);
1.后台订单搜索
controller:
/**
* 订单搜索
*/
@GetMapping("/conditionSearch")
@ApiOperation("订单搜索")
public Result<PageResult> conditonSearch(OrdersPageQueryDTO ordersPageQueryDTO) {
log.info("订单搜索：ordersPageQueryDTO:{}", ordersPageQueryDTO);
PageResult pageResult = orderService.conditionSearch(ordersPageQueryDTO);
return Result.success(pageResult);
}
serviceImpl:
有可能搜索到的订单信息很多，所以使用分页查询的方式进行处理。这里实际上对将order对象转化为orderVO对象进行了封装，在前面我们没有进行封装，在这里我们进行了优化，进行了封装，同时vo对象里面需要一个String类型的描述字段，所以我们指定格式为菜品*数量的格式进行格式化字符串封装进orderVO对象里面。
/**
* 商家订单搜索
* @param ordersPageQueryDTO
* @return
*/
@Override
public PageResult conditionSearch(OrdersPageQueryDTO ordersPageQueryDTO) {
// 1.设置分页参数
PageHelper.startPage(ordersPageQueryDTO.getPage(), ordersPageQueryDTO.getPageSize());
// 2.获得分页查询结果
Page<Orders> page = orderMapper.pageQuery(ordersPageQueryDTO);
// 3.部分订单状态 需要额外返回订单菜品信息 将orders转化为ordervo
List<OrderVO> orderVOList = getOrderVOList(page);
return new PageResult(page.getTotal(), orderVOList);
}
/**
* 封装的接收page，将orders转换为ordersVO对象
* @param page
* @return
*/
public List<OrderVO> getOrderVOList(Page<Orders> page){
// 1.需要返回菜品信息 自定义OrderVO响应结果
List<OrderVO> orderVOList = new ArrayList<>();
List<Orders> ordersList = page.getResult();
// 2.进行转换
if(ordersList != null && ordersList.size() > 0) {
for (Orders orders : ordersList) {
OrderVO orderVO = new OrderVO();
BeanUtils.copyProperties(orders, orderVO);
String orderDishes = getOrderDishesStr(orders);
// 3.将订单菜品信息封装到orderVO中
orderVO.setOrderDishes(orderDishes);
orderVOList.add(orderVO);
}
}
return orderVOList;
}
这里使用了lambda表达式的形式进行遍历整个列表进行转换。
/**
* 根据订单id获取菜品信息字符串
* @param orders
* @return
*/
private String getOrderDishesStr(Orders orders) {
// 1.查询订单菜品详情信息（订单中的菜品和数量）
List<OrderDetail> orderDetailList = orderDetailMapper.getByOrderId(orders.getId());
// 2.将每一条订单菜品信息拼接为字符串（格式：宫保鸡丁*3；）
List<String> orderDishList = orderDetailList.stream().map(x -> {
String orderDish = x.getName() + "*" + x.getNumber() + ";";
return orderDish;
}).collect(Collectors.toList());
// 3.将该订单对应的所有菜品信息拼接在一起
return String.join("", orderDishList);
}
等价于：
private String getOrderDishesStr(Orders orders) {
// 1.查询订单菜品详情信息（订单中的菜品和数量）
List<OrderDetail> orderDetailList = orderDetailMapper.getByOrderId(orders.getId());
// 2.将每一条订单菜品信息拼接为字符串（格式：宫保鸡丁*3；）
StringBuilder sb = new StringBuilder();
for (OrderDetail orderDetail : orderDetailList) {
String orderDish = orderDetail.getName() + "*" + orderDetail.getNumber() + ";";
sb.append(orderDish);
}
// 3.将该订单对应的所有菜品信息拼接在一起
return sb.toString();
}
2.统计各个状态订单
controller:
/**
* 各个状态的订单数量统计算
* @return
*/
@GetMapping("/statistics")
@ApiOperation("各个状态的订单数量统计")
public Result<OrderStatisticsVO> statistics() {
log.info("各个状态的订单数量统计...");
OrderStatisticsVO orderStatisticsVO = orderService.statistics();
return Result.success(orderStatisticsVO);
}
serviceImpl:
/**
* 统计各个状态的订单
* @return
*/
@Override
public OrderStatisticsVO statistics() {
// 1.根据状态，分别查询出 待接单、待派送、派送中 的订单数量
Integer toBeConfirmed = orderMapper.countStatus(Orders.TO_BE_CONFIRMED);
Integer confirmed = orderMapper.countStatus(Orders.CONFIRMED);
Integer deliveryInProgress = orderMapper.countStatus(Orders.DELIVERY_IN_PROGRESS);
// 2.将查询出的数据封装到orderStatisticsVO中响应
OrderStatisticsVO orderStatisticsVO = new OrderStatisticsVO();
orderStatisticsVO.setToBeConfirmed(toBeConfirmed);
orderStatisticsVO.setConfirmed(confirmed);
orderStatisticsVO.setDeliveryInProgress(deliveryInProgress);
return orderStatisticsVO;
}
mapper:
注意既然是统计，自然而然想到了count()统计函数。我认为count(*)也行。
/**
* 根据状态统计订单数量
* @param status
*/
@Select("select count(id) from orders where status = #{status}")
Integer countStatus(Integer status);
3.查看订单详情
controller:
/**
* 订单详情
*
* @param id
* @return
*/
@GetMapping("/details/{id}")
@ApiOperation("查询订单详情")
public Result<OrderVO> details(@PathVariable("id") Long id) {
OrderVO orderVO = orderService.details(id);
return Result.success(orderVO);
}
serviceImpl:
用户和商家共用的接口。
/**
* 用户查询订单详情 商家也可以查询
* @param id
* @return
*/
@Override
public OrderVO details(Long id) {
// 1.根据id查询订单
Orders orders = orderMapper.getById(id);
// 2.查询该订单对应的菜品/套餐明细
List<OrderDetail> orderDetailList = orderDetailMapper.getByOrderId(orders.getId());
// 3.将该订单及其详情封装到OrderVO并返回
OrderVO orderVO = new OrderVO();
BeanUtils.copyProperties(orders, orderVO);
orderVO.setOrderDetailList(orderDetailList);
return orderVO;
}
4.商家接单
controller:
/**
* 商家接单
*
* @return
*/
@PutMapping("/confirm")
@ApiOperation("接单")
public Result confirm(@RequestBody OrdersConfirmDTO ordersConfirmDTO) {
orderService.confirm(ordersConfirmDTO);
return Result.success();
}
serviceImpl:
采用链式调用。实际上就是修改状态。
/**
* 商家接单 = 修改订单状态
* @param ordersConfirmDTO
*/
@Override
public void confirm(OrdersConfirmDTO ordersConfirmDTO) {
Orders orders = Orders.builder()
.id(ordersConfirmDTO.getId())
.status(Orders.CONFIRMED) // 已接单
.build();
orderMapper.update(orders);
}
5.商家拒单
controller:
/**
* 商家拒单
*
* @return
*/
@PutMapping("/rejection")
@ApiOperation("拒单")
public Result rejection(@RequestBody OrdersRejectionDTO ordersRejectionDTO) throws Exception {
orderService.rejection(ordersRejectionDTO);
return Result.success();
}
serviceImpl:
我们在书写用户的取消订单的时候，需要进行状态判断，同理，这里利用两份orders进行简单判断，实际上还是修改订单。
/**
* 商家拒单 = 修改订单状态 + 退款
* @param ordersRejectionDTO
* @throws Exception
*/
@Override
public void rejection(OrdersRejectionDTO ordersRejectionDTO) throws Exception {
// 1.根据id查询订单
Orders ordersDB = orderMapper.getById(ordersRejectionDTO.getId());
// 2.订单只有存在且状态为2（待接单）才可以拒单
if (ordersDB == null || !ordersDB.getStatus().equals(Orders.TO_BE_CONFIRMED)) {
throw new OrderBusinessException(MessageConstant.ORDER_STATUS_ERROR);
}
// 3.支付状态
Integer payStatus = ordersDB.getPayStatus();
if (payStatus == Orders.PAID) {
//用户已支付，需要退款
String refund = weChatPayUtil.refund(
ordersDB.getNumber(),
ordersDB.getNumber(),
new BigDecimal(0.01),
new BigDecimal(0.01));
System.out.println("退款金额为：" + refund);
}
// 4.拒单需要退款，根据订单id更新订单状态、拒单原因、取消时间
Orders orders = new Orders();
orders.setId(ordersDB.getId());
orders.setStatus(Orders.CANCELLED);
orders.setRejectionReason(ordersRejectionDTO.getRejectionReason());
orders.setCancelTime(LocalDateTime.now());
// 5.加入修改订单信息
orderMapper.update(orders);
}
还有后面的商家取消订单，完成订单不再赘述，实际上就是状态修改。
6.百度地图开放平台
在用户下单的时候我们需要定位用户，来判断是否能出餐。
- 在百度地图开放平台进行注册后获取ak，ak就不展示了，同时在项目中的application中配置相应信息，ak和address。
- 在orderImpl中利用springel表达式注入配置信息：
// SpringEL注入配置文件
@Value("${sky.shop.address}")
private String shopAddress;
@Value("${sky.baidu.ak}")
private String ak;
- 辅助验证函数 至于为什么这么写当然是需要看官方文档进行操作的。
百度地图
百度地图
/**
* 检查客户的收货地址是否超出配送范围
* @param address
*/
private void checkOutOfRange(String address) {
Map map = new HashMap();
map.put("address",shopAddress);
map.put("output","json");
map.put("ak",ak);
//获取店铺的经纬度坐标
String shopCoordinate = HttpClientUtil.doGet("https://api.map.baidu.com/geocoding/v3", map);
JSONObject jsonObject = JSON.parseObject(shopCoordinate);
if(!jsonObject.getString("status").equals("0")){
throw new OrderBusinessException("店铺地址解析失败");
}
//数据解析
JSONObject location = jsonObject.getJSONObject("result").getJSONObject("location");
String lat = location.getString("lat");
String lng = location.getString("lng");
//店铺经纬度坐标
String shopLngLat = lat + "," + lng;
map.put("address",address);
//获取用户收货地址的经纬度坐标
String userCoordinate = HttpClientUtil.doGet("https://api.map.baidu.com/geocoding/v3", map);
jsonObject = JSON.parseObject(userCoordinate);
if(!jsonObject.getString("status").equals("0")){
throw new OrderBusinessException("收货地址解析失败");
}
//数据解析
location = jsonObject.getJSONObject("result").getJSONObject("location");
lat = location.getString("lat");
lng = location.getString("lng");
//用户收货地址经纬度坐标
String userLngLat = lat + "," + lng;
map.put("origin",shopLngLat);
map.put("destination",userLngLat);
map.put("steps_info","0");
//路线规划
String json = HttpClientUtil.doGet("https://api.map.baidu.com/directionlite/v1/driving", map);
jsonObject = JSON.parseObject(json);
if(!jsonObject.getString("status").equals("0")){
throw new OrderBusinessException("配送路线规划失败");
}
//数据解析
JSONObject result = jsonObject.getJSONObject("result");
JSONArray jsonArray = (JSONArray) result.get("routes");
Integer distance = (Integer) ((JSONObject) jsonArray.get(0)).get("distance");
if(distance > 5000){
//配送距离超过5000米
throw new OrderBusinessException("超出配送范围");
}
}
- 在提交订单的方法中调用该验证函数。
// 1.处理地址是否为空 购物车是否为空
// 1.1 地址
AddressBook addressBook = addressBookMapper.getById(ordersSubmitDTO.getAddressBookId());
if (addressBook == null) {
throw new AddressBookBusinessException(MessageConstant.ADDRESS_BOOK_IS_NULL);
}
// 检查用户的收货地址是否超出配送范围 调用百度地图的服务接口
checkOutOfRange(addressBook.getCityName() + addressBook.getDistrictName() + addressBook.getDetail());
// 1.2 查询购物车
Long userId = BaseContext.getCurrentId();
ShoppingCart shoppingCart = new ShoppingCart();
shoppingCart.setUserId(userId);
List<ShoppingCart> list = shoppingCartMapper.list(shoppingCart);
if(list == null || list.size() == 0) {
throw new AddressBookBusinessException(MessageConstant.SHOPPING_CART_IS_NULL);
}
总结
Day09的作业，需要复习的其实就只有lambda和stream，count()函数