电商项目-订单

已于 2024-05-22 20:17:45 修改
阅读量606 收藏 27
点赞数 13
分类专栏： 电商项目 文章标签： java
于 2024-05-05 21:00:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ToBewhatyouwannabe/article/details/138473817
版权

service层

package com.imooc.mall.service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.imooc.mall.dao.OrderItemMapper;
import com.imooc.mall.dao.OrderMapper;
import com.imooc.mall.dao.ProductMapper;
import com.imooc.mall.dao.ShippingMapper;
import com.imooc.mall.enums.OrderStatusEnum;
import com.imooc.mall.enums.PaymentTypeEnum;
import com.imooc.mall.enums.ProductStatusEnum;
import com.imooc.mall.enums.ResponseEnum;
import com.imooc.mall.pojo.*;
import com.imooc.mall.service.ICartService;
import com.imooc.mall.service.IOrderService;
import com.imooc.mall.vo.OrderItemVo;
import com.imooc.mall.vo.OrderVo;
import com.imooc.mall.vo.ResponseVo;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;


@Service
public class OrderServiceImpl implements IOrderService {

	@Autowired
	private ShippingMapper shippingMapper;

	@Autowired
	private ICartService cartService;

	@Autowired
	private ProductMapper productMapper;

	@Autowired
	private OrderMapper orderMapper;

	@Autowired
	private OrderItemMapper orderItemMapper;

	@Override
	@Transactional
	public ResponseVo<OrderVo> create(Integer uid, Integer shippingId) {
		//收货地址校验（总之要查出来的）
		Shipping shipping = shippingMapper.selectByUidAndShippingId(uid, shippingId);
		if (shipping == null) {
			return ResponseVo.error(ResponseEnum.SHIPPING_NOT_EXIST);
		}

		//获取购物车，校验（是否有商品、库存）
		List<Cart> cartList = cartService.listForCart(uid).stream()
				.filter(Cart::getProductSelected)
				.collect(Collectors.toList());
		if (CollectionUtils.isEmpty(cartList)) {
			return ResponseVo.error(ResponseEnum.CART_SELECTED_IS_EMPTY);
		}

		//获取cartList里的productIds
		Set<Integer> productIdSet = cartList.stream()
				.map(Cart::getProductId)
				.collect(Collectors.toSet());
		List<Product> productList = productMapper.selectByProductIdSet(productIdSet);
		Map<Integer, Product> map  = productList.stream()
				.collect(Collectors.toMap(Product::getId, product -> product));

		List<OrderItem> orderItemList = new ArrayList<>();
		Long orderNo = generateOrderNo();
		for (Cart cart : cartList) {
			//根据productId查数据库
			Product product = map.get(cart.getProductId());
			//是否有商品
			if (product == null) {
				return ResponseVo.error(ResponseEnum.PRODUCT_NOT_EXIST,
						"商品不存在. productId = " + cart.getProductId());
			}
			//商品上下架状态
			if (!ProductStatusEnum.ON_SALE.getCode().equals(product.getStatus())) {
				return ResponseVo.error(ResponseEnum.PRODUCT_OFF_SALE_OR_DELETE,
						"商品不是在售状态. " + product.getName());
			}

			//库存是否充足
			if (product.getStock() < cart.getQuantity()) {
				return ResponseVo.error(ResponseEnum.PROODUCT_STOCK_ERROR,
						"库存不正确. " + product.getName());
			}

			OrderItem orderItem = buildOrderItem(uid, orderNo, cart.getQuantity(), product);
			orderItemList.add(orderItem);

			//减库存
			product.setStock(product.getStock() - cart.getQuantity());
			int row = productMapper.updateByPrimaryKeySelective(product);
			if (row <= 0) {
				return ResponseVo.error(ResponseEnum.ERROR);
			}
		}

		//计算总价，只计算选中的商品
		//生成订单，入库：order和order_item，事务
		Order order = buildOrder(uid, orderNo, shippingId, orderItemList);

		int rowForOrder = orderMapper.insertSelective(order);
		if (rowForOrder <= 0) {
			return ResponseVo.error(ResponseEnum.ERROR);
		}

		int rowForOrderItem = orderItemMapper.batchInsert(orderItemList);
		if (rowForOrderItem <= 0) {
			return ResponseVo.error(ResponseEnum.ERROR);
		}

		//更新购物车（选中的商品）
		//Redis有事务(打包命令)，不能回滚
		for (Cart cart : cartList) {
			cartService.delete(uid, cart.getProductId());
		}

		//构造orderVo
		OrderVo orderVo = buildOrderVo(order, orderItemList, shipping);
		return ResponseVo.success(orderVo);
	}

	@Override
	public ResponseVo<PageInfo> list(Integer uid, Integer pageNum, Integer pageSize) {
		PageHelper.startPage(pageNum, pageSize);
		List<Order> orderList = orderMapper.selectByUid(uid);

		Set<Long> orderNoSet = orderList.stream()
				.map(Order::getOrderNo)
				.collect(Collectors.toSet());
		List<OrderItem> orderItemList = orderItemMapper.selectByOrderNoSet(orderNoSet);
		Map<Long, List<OrderItem>> orderItemMap = orderItemList.stream()
				.collect(Collectors.groupingBy(OrderItem::getOrderNo));

		Set<Integer> shippingIdSet = orderList.stream()
				.map(Order::getShippingId)
				.collect(Collectors.toSet());
		List<Shipping> shippingList = shippingMapper.selectByIdSet(shippingIdSet);
		Map<Integer, Shipping> shippingMap = shippingList.stream()
				.collect(Collectors.toMap(Shipping::getId, shipping -> shipping));

		List<OrderVo> orderVoList = new ArrayList<>();
		for (Order order : orderList) {
			OrderVo orderVo = buildOrderVo(order,
					orderItemMap.get(order.getOrderNo()),
					shippingMap.get(order.getShippingId()));
			orderVoList.add(orderVo);
		}
		PageInfo pageInfo = new PageInfo<>(orderList);
		pageInfo.setList(orderVoList);

		return ResponseVo.success(pageInfo);
	}

	@Override
	public ResponseVo<OrderVo> detail(Integer uid, Long orderNo) {
		Order order = orderMapper.selectByOrderNo(orderNo);
		if (order == null || !order.getUserId().equals(uid)) {
			return ResponseVo.error(ResponseEnum.ORDER_NOT_EXIST);
		}
		Set<Long> orderNoSet = new HashSet<>();
		orderNoSet.add(order.getOrderNo());
		List<OrderItem> orderItemList = orderItemMapper.selectByOrderNoSet(orderNoSet);

		Shipping shipping = shippingMapper.selectByPrimaryKey(order.getShippingId());

		OrderVo orderVo = buildOrderVo(order, orderItemList, shipping);
		return ResponseVo.success(orderVo);
	}

	@Override
	public ResponseVo cancel(Integer uid, Long orderNo) {
		Order order = orderMapper.selectByOrderNo(orderNo);
		if (order == null || !order.getUserId().equals(uid)) {
			return ResponseVo.error(ResponseEnum.ORDER_NOT_EXIST);
		}
		//只有[未付款]订单可以取消，看自己公司业务
		if (!order.getStatus().equals(OrderStatusEnum.NO_PAY.getCode())) {
			return ResponseVo.error(ResponseEnum.ORDER_STATUS_ERROR);
		}

		order.setStatus(OrderStatusEnum.CANCELED.getCode());
		order.setCloseTime(new Date());
		int row = orderMapper.updateByPrimaryKeySelective(order);
		if (row <= 0) {
			return ResponseVo.error(ResponseEnum.ERROR);
		}

		return ResponseVo.success();
	}

	@Override
	public void paid(Long orderNo) {
		Order order = orderMapper.selectByOrderNo(orderNo);
		if (order == null) {
			throw new RuntimeException(ResponseEnum.ORDER_NOT_EXIST.getDesc() + "订单id:" + orderNo);
		}
		//只有[未付款]订单可以变成[已付款]，看自己公司业务
		if (!order.getStatus().equals(OrderStatusEnum.NO_PAY.getCode())) {
			throw new RuntimeException(ResponseEnum.ORDER_STATUS_ERROR.getDesc() + "订单id:" + orderNo);
		}

		order.setStatus(OrderStatusEnum.PAID.getCode());
		order.setPaymentTime(new Date());
		int row = orderMapper.updateByPrimaryKeySelective(order);
		if (row <= 0) {
			throw new RuntimeException("将订单更新为已支付状态失败，订单id:" + orderNo);
		}
	}

	private OrderVo buildOrderVo(Order order, List<OrderItem> orderItemList, Shipping shipping) {
		OrderVo orderVo = new OrderVo();
		BeanUtils.copyProperties(order, orderVo);

		List<OrderItemVo> OrderItemVoList = orderItemList.stream().map(e -> {
			OrderItemVo orderItemVo = new OrderItemVo();
			BeanUtils.copyProperties(e, orderItemVo);
			return orderItemVo;
		}).collect(Collectors.toList());
		orderVo.setOrderItemVoList(OrderItemVoList);

		if (shipping != null) {
			orderVo.setShippingId(shipping.getId());
			orderVo.setShippingVo(shipping);
		}

		return orderVo;
	}

	private Order buildOrder(Integer uid,
							 Long orderNo,
							 Integer shippingId,
							 List<OrderItem> orderItemList
							 ) {
		BigDecimal payment = orderItemList.stream()
				.map(OrderItem::getTotalPrice)
				.reduce(BigDecimal.ZERO, BigDecimal::add);

		Order order = new Order();
		order.setOrderNo(orderNo);
		order.setUserId(uid);
		order.setShippingId(shippingId);
		order.setPayment(payment);
		order.setPaymentType(PaymentTypeEnum.PAY_ONLINE.getCode());
		order.setPostage(0);
		order.setStatus(OrderStatusEnum.NO_PAY.getCode());
		return order;
	}

	/**
	 * 企业级：分布式唯一id/主键
	 * @return
	 */
	private Long generateOrderNo() {
		return System.currentTimeMillis() + new Random().nextInt(999);
	}

	private OrderItem buildOrderItem(Integer uid, Long orderNo, Integer quantity, Product product) {
		OrderItem item = new OrderItem();
		item.setUserId(uid);
		item.setOrderNo(orderNo);
		item.setProductId(product.getId());
		item.setProductName(product.getName());
		item.setProductImage(product.getMainImage());
		item.setCurrentUnitPrice(product.getPrice());
		item.setQuantity(quantity);
		item.setTotalPrice(product.getPrice().multiply(BigDecimal.valueOf(quantity)));
		return item;
	}
}

代码解释：
这段代码是一个典型的Java实现，属于一个在线商城系统中处理订单服务（IOrderService）的实现类 (OrderServiceImpl)。它包含了创建订单、查询订单列表、查询订单详情、取消订单以及标记订单为已支付等核心功能。下面是对关键部分的分析与说明：

创建订单 (create 方法)

  1. 校验收货地址：首先通过用户ID和收货地址ID查询收货地址是否存在。
  2. 获取购物车中待结算的商品：仅筛选出被选中的商品，并进行非空检查。
  3. 商品信息校验：包括商品是否存在、是否在售、库存是否足够，并准备批量减少库存的操作。
  4. 构建订单项 (OrderItem)：对于每个购物车中的商品，创建相应的订单项并计算总价。
  5. 生成订单 (Order)：整合所有订单项信息，生成订单实体，并插入到数据库中。
  6. 更新购物车：删除已结算的商品记录。
  7. 事务处理：确保上述操作在一个事务中执行，保证数据一致性。
  8. 构造响应Vo：将订单信息包装成Vo对象返回前端。

查询订单列表 (list 方法)

  • 使用分页插件 PageHelper 进行分页查询，然后转换查询结果为Vo对象列表。

订单详情 (detail 方法)

  • 根据用户ID和订单号查询订单详情，包括订单项和物流信息。

取消订单 (cancel 方法)

  • 检查订单状态，仅允许未付款的订单被取消，并更新订单状态。

标记订单为已支付 (paid 方法)

  • 更新指定订单号的订单状态为已支付，并设置支付时间。

辅助方法

  • generateOrderNo 生成一个基于当前时间戳和随机数的订单号，用于唯一标识订单。
  • buildOrderVo 将订单数据转换为视图对象供前端展示。
  • buildOrder 构建订单实体，计算总金额等。
  • buildOrderItem 构建订单项，记录订单中的每个商品详情。

技术点与设计模式

  • 事务管理：使用了Spring的@Transactional注解来确保操作的原子性。
  • 数据访问：通过Mapper接口与数据库交互，体现了MyBatis的使用。
  • 流式处理：在处理购物车商品和订单项时，利用了Java 8的Stream API进行集合操作，如过滤、映射和聚合。
  • 领域模型设计：通过Order、OrderItem、Product、Shipping等实体类清晰地定义了业务领域的对象及其关系。
  • 分层架构：实现了业务逻辑层（Service）、数据访问层（Mapper）的分层，符合典型的MVC或三层架构设计。

此代码片段展示了电商系统中订单模块的核心逻辑处理，体现了面向对象设计原则和良好的编程实践。

controller层

package com.imooc.mall.controller;

import com.github.pagehelper.PageInfo;
import com.imooc.mall.consts.MallConst;
import com.imooc.mall.form.OrderCreateForm;
import com.imooc.mall.pojo.User;
import com.imooc.mall.service.IOrderService;
import com.imooc.mall.vo.OrderVo;
import com.imooc.mall.vo.ResponseVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpSession;
import javax.validation.Valid;

/**

 */
@RestController
public class OrderController {

	@Autowired
	private IOrderService orderService;

	@PostMapping("/orders")
	public ResponseVo<OrderVo> create(@Valid @RequestBody OrderCreateForm form,
									  HttpSession session) {
		User user = (User) session.getAttribute(MallConst.CURRENT_USER);
		return orderService.create(user.getId(), form.getShippingId());
	}

	@GetMapping("/orders")
	public ResponseVo<PageInfo> list(@RequestParam Integer pageNum,
									 @RequestParam Integer pageSize,
									 HttpSession session) {
		User user = (User) session.getAttribute(MallConst.CURRENT_USER);
		return orderService.list(user.getId(), pageNum, pageSize);
	}

	@GetMapping("/orders/{orderNo}")
	public ResponseVo<OrderVo> detail(@PathVariable Long orderNo,
									  HttpSession session) {
		User user = (User) session.getAttribute(MallConst.CURRENT_USER);
		return orderService.detail(user.getId(), orderNo);
	}

	@PutMapping("/orders/{orderNo}")
	public ResponseVo cancel(@PathVariable Long orderNo,
							 HttpSession session) {
		User user = (User) session.getAttribute(MallConst.CURRENT_USER);
		return orderService.cancel(user.getId(), orderNo);
	}
}

代码解释：
这段代码定义了一个名为OrderController的RESTful Web控制器，负责处理与订单相关的HTTP请求。使用了Spring框架的@RestController注解，表明这是一个控制器类，其所有方法的返回值都将直接被序列化为JSON等格式返回给前端。下面是各方法的简要说明：

创建订单 (create 方法)

  • 请求方式: POST
  • 路径: /orders
  • 参数:
    • @Valid @RequestBody OrderCreateForm form: 通过请求体接收表单数据，且进行数据校验。
    • HttpSession session: 从Session中获取当前登录的用户信息。
  • 功能: 根据用户ID和传入的收货地址ID创建订单。使用了@Valid注解对传入的订单创建表单数据进行验证，确保数据的有效性。

查询订单列表 (list 方法)

  • 请求方式: GET
  • 路径: /orders
  • 参数:
    • @RequestParam Integer pageNum, @RequestParam Integer pageSize: 分页查询参数。
    • HttpSession session: 获取当前用户信息。
  • 功能: 根据用户ID和分页参数查询并返回用户的订单列表。

查询订单详情 (detail 方法)

  • 请求方式: GET
  • 路径: /orders/{orderNo}
  • 参数:
    • @PathVariable Long orderNo: 通过路径变量接收订单号。
    • HttpSession session: 获取当前用户信息。
  • 功能: 根据用户ID和订单号查询并返回订单详情。

取消订单 (cancel 方法)

  • 请求方式: PUT
  • 路径: /orders/{orderNo}
  • 参数:
    • @PathVariable Long orderNo: 通过路径变量接收订单号。
    • HttpSession session: 获取当前用户信息。
  • 功能: 允许用户取消指定的订单，仅当订单处于未支付状态时允许取消。

此控制器通过与IOrderService服务层交互，实现了订单相关的业务逻辑，包括创建、查询列表、查询详情和取消订单，体现了前后端分离的架构风格以及RESTful API的设计原则。用户身份验证通过Session来实现，确保了操作的安全性。

listener：

package com.imooc.mall.listener;

import com.google.gson.Gson;
import com.imooc.mall.pojo.PayInfo;
import com.imooc.mall.service.IOrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 关于PayInfo，正确姿势：pay项目提供client.jar, mall项目引入jar包

 */
@Component
@RabbitListener(queues = "payNotify")
@Slf4j
public class PayMsgListener {

	@Autowired
	private IOrderService orderService;

	@RabbitHandler
	public void process(String msg) {
		log.info("【接收到消息】=> {}", msg);

		PayInfo payInfo = new Gson().fromJson(msg, PayInfo.class);
		if (payInfo.getPlatformStatus().equals("SUCCESS")) {
			//修改订单里的状态
			orderService.paid(payInfo.getOrderNo());
		}
	}
}

这段代码展示了一个使用Spring AMQP的消息监听器（Message Listener），用于监听名为payNotify的RabbitMQ队列。当队列中有消息时，这个监听器会被触发，进而执行消息处理逻辑。以下是该代码段的关键解析：

  • 消息监听器组件：通过@Component注解标记为Spring组件，使其能够被Spring容器管理。
  • 消息队列监听配置：使用@RabbitListener(queues = "payNotify")注解声明该类监听名为payNotify的队列。
  • 日志记录：通过@Slf4j注解引入日志记录功能，方便记录消息处理过程中的日志信息。
  • 消息处理器方法：@RabbitHandler注解标记的process方法是实际处理队列中消息的方法。当队列中有消息时，RabbitMQ客户端会将消息内容（字符串形式）传递给此方法。
  • 消息解析与处理：
    • 首先，使用Gson库将接收到的JSON格式的消息字符串转换为PayInfo对象。
    • 然后，检查PayInfo对象中的支付平台状态（platformStatus），如果状态为"SUCCESS"，则调用orderService.paid(payInfo.getOrderNo())方法，实现订单的支付状态更新逻辑。

这个监听器的作用在于异步接收来自支付系统的支付结果通知，根据通知内容决定是否需要更新订单状态为已支付，这样的设计有助于提升系统的响应速度和解耦支付系统与订单系统的直接依赖。通过消息队列作为中间件，实现了高度解耦和灵活的异步处理机制。

订单模块的代码是在一个Spring Boot应用中使用@Autowired注解来注入依赖的Mapper和Service对象。具体来说：

ShippingMapper、ProductMapper、OrderMapper、OrderItemMapper 是用来与数据库进行交互的 Mapper 接口，通过它们可以执行相应的数据库操作，如查询、插入、更新等。
ICartService 是购物车相关的服务接口，通过该接口可以操作购物车，如添加商品到购物车、从购物车移除商品等。
这些依赖的注入使得在 OrderServiceImpl 类中可以方便地使用这些对象来完成订单相关的业务逻辑。

	@Transactional
	public ResponseVo<OrderVo> create(Integer uid, Integer shippingId) {
		//收货地址校验（总之要查出来的）
		Shipping shipping = shippingMapper.selectByUidAndShippingId(uid, shippingId);
		if (shipping == null) {
			return ResponseVo.error(ResponseEnum.SHIPPING_NOT_EXIST);
		}

		//获取购物车，校验（是否有商品、库存）
		List<Cart> cartList = cartService.listForCart(uid).stream()
				.filter(Cart::getProductSelected)
				.collect(Collectors.toList());
		if (CollectionUtils.isEmpty(cartList)) {
			return ResponseVo.error(ResponseEnum.CART_SELECTED_IS_EMPTY);
		}

		//获取cartList里的productIds
		Set<Integer> productIdSet = cartList.stream()
				.map(Cart::getProductId)
				.collect(Collectors.toSet());
		List<Product> productList = productMapper.selectByProductIdSet(productIdSet);
		Map<Integer, Product> map  = productList.stream()
				.collect(Collectors.toMap(Product::getId, product -> product));

		List<OrderItem> orderItemList = new ArrayList<>();
		Long orderNo = generateOrderNo();
		for (Cart cart : cartList) {
			//根据productId查数据库
			Product product = map.get(cart.getProductId());
			//是否有商品
			if (product == null) {
				return ResponseVo.error(ResponseEnum.PRODUCT_NOT_EXIST,
						"商品不存在. productId = " + cart.getProductId());
			}
			//商品上下架状态
			if (!ProductStatusEnum.ON_SALE.getCode().equals(product.getStatus())) {
				return ResponseVo.error(ResponseEnum.PRODUCT_OFF_SALE_OR_DELETE,
						"商品不是在售状态. " + product.getName());
			}

			//库存是否充足
			if (product.getStock() < cart.getQuantity()) {
				return ResponseVo.error(ResponseEnum.PRODUCT_STOCK_ERROR,
						"库存不正确. " + product.getName());
			}

			OrderItem orderItem = buildOrderItem(uid, orderNo, cart.getQuantity(), product);
			orderItemList.add(orderItem);

			//减库存
			product.setStock(product.getStock() - cart.getQuantity());
			int row = productMapper.updateByPrimaryKeySelective(product);
			if (row <= 0) {
				return ResponseVo.error(ResponseEnum.ERROR);
			}
		}

		//计算总价，只计算选中的商品
		//生成订单，入库：order和order_item，事务
		Order order = buildOrder(uid, orderNo, shippingId, orderItemList);

		int rowForOrder = orderMapper.insertSelective(order);
		if (rowForOrder <= 0) {
			return ResponseVo.error(ResponseEnum.ERROR);
		}

		int rowForOrderItem = orderItemMapper.batchInsert(orderItemList);
		if (rowForOrderItem <= 0) {
			return ResponseVo.error(ResponseEnum.ERROR);
		}

		//更新购物车（选中的商品）
		//Redis有事务(打包命令)，不能回滚
		for (Cart cart : cartList) {
			cartService.delete(uid, cart.getProductId());
		}

		//构造orderVo
		OrderVo orderVo = buildOrderVo(order, orderItemList, shipping);
		return ResponseVo.success(orderVo);
	}

这段代码是创建订单的方法实现。让我逐步解释它：

  1. 开启了事务注解 @Transactional，表示该方法中的数据库操作应当在一个事务中执行，确保数据的一致性。

  2. 根据用户ID和收货地址ID从数据库中查询收货地址信息 Shipping。

  3. 如果查询不到对应的收货地址，则返回一个表示收货地址不存在的错误信息。

  4. 调用购物车服务的 listForCart 方法获取用户购物车中的商品列表，并筛选出选中的商品。

  5. 如果购物车中没有选中的商品，则返回一个表示购物车为空的错误信息。

  6. 遍历购物车中选中的商品列表，获取每个商品的信息，包括商品是否存在、是否在售、库存是否充足等。

  7. 对于每个商品，如果存在问题（如商品不存在、不在售、库存不足），则返回相应的错误信息。

  8. 构建订单项 OrderItem，并添加到订单项列表 orderItemList 中。

  9. 根据订单项列表、用户ID、收货地址ID等信息构建订单对象 Order。

  10. 将订单信息插入到数据库中，包括订单表和订单项表。

  11. 更新购物车，将购物车中已选中的商品移除。

  12. 构建订单视图对象 OrderVo，包括订单信息、订单项信息、收货地址信息等。

  13. 最后，返回一个表示订单创建成功的响应信息，包含订单视图对象。

这段代码中涉及了订单的创建、库存的扣除、购物车的更新等操作，确保了订单创建的完整性和准确性。

	@Override
	public ResponseVo<PageInfo> list(Integer uid, Integer pageNum, Integer pageSize) {
		PageHelper.startPage(pageNum, pageSize);
		List<Order> orderList = orderMapper.selectByUid(uid);

		Set<Long> orderNoSet = orderList.stream()
				.map(Order::getOrderNo)
				.collect(Collectors.toSet());
		List<OrderItem> orderItemList = orderItemMapper.selectByOrderNoSet(orderNoSet);
		Map<Long, List<OrderItem>> orderItemMap = orderItemList.stream()
				.collect(Collectors.groupingBy(OrderItem::getOrderNo));

		Set<Integer> shippingIdSet = orderList.stream()
				.map(Order::getShippingId)
				.collect(Collectors.toSet());
		List<Shipping> shippingList = shippingMapper.selectByIdSet(shippingIdSet);
		Map<Integer, Shipping> shippingMap = shippingList.stream()
				.collect(Collectors.toMap(Shipping::getId, shipping -> shipping));

		List<OrderVo> orderVoList = new ArrayList<>();
		for (Order order : orderList) {
			OrderVo orderVo = buildOrderVo(order,
					orderItemMap.get(order.getOrderNo()),
					shippingMap.get(order.getShippingId()));
			orderVoList.add(orderVo);
		}
		PageInfo pageInfo = new PageInfo<>(orderList);
		pageInfo.setList(orderVoList);

		return ResponseVo.success(pageInfo);
	}

这段代码是用于列出用户的订单列表的方法实现。让我解释一下它的主要步骤：

  1. 使用 PageHelper.startPage 方法开始分页，指定页码 pageNum 和每页大小 pageSize。

  2. 调用 orderMapper.selectByUid 方法查询数据库，获取该用户的订单列表 orderList。

  3. 从订单列表中提取订单号组成一个 Set 集合 orderNoSet。

  4. 调用 orderItemMapper.selectByOrderNoSet 方法查询数据库，获取所有订单号在 orderNoSet 中的订单项列表 orderItemList。

  5. 将订单项列表按订单号分组，形成一个 Map 结构 orderItemMap，键为订单号，值为对应订单号的订单项列表。

  6. 从订单列表中提取收货地址ID组成一个 Set 集合 shippingIdSet。

  7. 调用 shippingMapper.selectByIdSet 方法查询数据库，获取所有收货地址ID在 shippingIdSet 中的收货地址列表 shippingList。

  8. 将收货地址列表按ID映射成一个 Map 结构 shippingMap，键为收货地址ID，值为对应的收货地址对象。

  9. 遍历订单列表 orderList，构建每个订单的订单视图对象 OrderVo，并添加到订单视图列表 orderVoList 中。

  10. 将订单列表和订单视图列表封装到 PageInfo 对象中，并设置到 PageInfo 对象中。

  11. 最后，返回一个表示成功的响应对象，包含了订单列表的分页信息。

这段代码主要是查询用户的订单列表，并将订单列表中的订单信息和订单项信息整合到订单视图对象中，以便于前端展示。

	@Override
	public ResponseVo<OrderVo> detail(Integer uid, Long orderNo) {
		Order order = orderMapper.selectByOrderNo(orderNo);
		if (order == null || !order.getUserId().equals(uid)) {
			return ResponseVo.error(ResponseEnum.ORDER_NOT_EXIST);
		}
		Set<Long> orderNoSet = new HashSet<>();
		orderNoSet.add(order.getOrderNo());
		List<OrderItem> orderItemList = orderItemMapper.selectByOrderNoSet(orderNoSet);

		Shipping shipping = shippingMapper.selectByPrimaryKey(order.getShippingId());

		OrderVo orderVo = buildOrderVo(order, orderItemList, shipping);
		return ResponseVo.success(orderVo);
	}

这段代码是用于获取订单详情的方法实现。让我解释一下它的主要步骤：

  1. 调用 orderMapper.selectByOrderNo 方法根据订单号查询数据库，获取对应的订单对象 order。

  2. 首先检查获取到的订单对象是否为空，或者订单的用户ID是否与传入的用户ID匹配，如果不匹配，则返回一个表示订单不存在的错误信息。

  3. 如果订单存在且用户ID匹配，则构建一个只包含当前订单号的 Set 集合 orderNoSet，并调用 orderItemMapper.selectByOrderNoSet 方法查询数据库，获取该订单号对应的订单项列表 orderItemList。

  4. 调用 shippingMapper.selectByPrimaryKey 方法根据订单中的收货地址ID查询数据库，获取对应的收货地址信息 shipping。

  5. 调用 buildOrderVo 方法构建订单视图对象 OrderVo，将订单信息、订单项信息和收货地址信息整合到一个对象中。

  6. 最后，返回一个表示成功的响应对象，包含了订单详情的订单视图对象。

这段代码主要是根据订单号获取订单详情，并将订单信息、订单项信息和收货地址信息整合到一个对象中，以便于前端展示。

	@Override
	public ResponseVo cancel(Integer uid, Long orderNo) {
		Order order = orderMapper.selectByOrderNo(orderNo);
		if (order == null || !order.getUserId().equals(uid)) {
			return ResponseVo.error(ResponseEnum.ORDER_NOT_EXIST);
		}
		//只有[未付款]订单可以取消，看自己公司业务
		if (!order.getStatus().equals(OrderStatusEnum.NO_PAY.getCode())) {
			return ResponseVo.error(ResponseEnum.ORDER_STATUS_ERROR);
		}

		order.setStatus(OrderStatusEnum.CANCELED.getCode());
		order.setCloseTime(new Date());
		int row = orderMapper.updateByPrimaryKeySelective(order);
		if (row <= 0) {
			return ResponseVo.error(ResponseEnum.ERROR);
		}

		return ResponseVo.success();
	}

这段代码是用于取消订单的方法实现。让我解释一下它的主要步骤：

  1. 调用 orderMapper.selectByOrderNo 方法根据订单号查询数据库，获取对应的订单对象 order。

  2. 首先检查获取到的订单对象是否为空，或者订单的用户ID是否与传入的用户ID匹配，如果不匹配，则返回一个表示订单不存在的错误信息。

  3. 检查订单的状态是否为“未付款”。根据注释提示，这里的取消订单规则是只有未付款的订单才能被取消，如果订单状态不是“未付款”，则返回一个表示订单状态错误的错误信息。

  4. 如果订单存在且满足取消条件，则将订单状态修改为“已取消”，同时记录订单关闭时间为当前时间。

  5. 调用 orderMapper.updateByPrimaryKeySelective 方法更新订单状态，将修改后的订单信息更新到数据库中。

  6. 检查更新是否成功，如果更新失败，则返回一个表示更新错误的错误信息。

  7. 最后，返回一个表示成功的响应对象。

这段代码主要是根据订单号取消订单，并更新订单状态到数据库中。

	@Override
	public void paid(Long orderNo) {
		Order order = orderMapper.selectByOrderNo(orderNo);
		if (order == null) {
			throw new RuntimeException(ResponseEnum.ORDER_NOT_EXIST.getDesc() + "订单id:" + orderNo);
		}
		//只有[未付款]订单可以变成[已付款]，看自己公司业务
		if (!order.getStatus().equals(OrderStatusEnum.NO_PAY.getCode())) {
			throw new RuntimeException(ResponseEnum.ORDER_STATUS_ERROR.getDesc() + "订单id:" + orderNo);
		}

		order.setStatus(OrderStatusEnum.PAID.getCode());
		order.setPaymentTime(new Date());
		int row = orderMapper.updateByPrimaryKeySelective(order);
		if (row <= 0) {
			throw new RuntimeException("将订单更新为已支付状态失败，订单id:" + orderNo);
		}
	}

这段代码是用于标记订单已支付的方法实现。让我解释一下它的主要步骤：

  1. 调用 orderMapper.selectByOrderNo 方法根据订单号查询数据库，获取对应的订单对象 order。

  2. 首先检查获取到的订单对象是否为空，如果订单对象为空，则抛出一个运行时异常，表示订单不存在。

  3. 检查订单的状态是否为“未付款”。根据注释提示，这里的逻辑是只有未付款的订单才能被标记为已支付，如果订单状态不是“未付款”，则抛出一个运行时异常，表示订单状态错误。

  4. 如果订单存在且满足标记支付条件，则将订单状态修改为“已支付”，同时记录订单支付时间为当前时间。

  5. 调用 orderMapper.updateByPrimaryKeySelective 方法更新订单状态，将修改后的订单信息更新到数据库中。

  6. 检查更新是否成功，如果更新失败，则抛出一个运行时异常，表示将订单更新为已支付状态失败。

这段代码主要是用于将订单状态标记为已支付，并更新订单状态到数据库中。

	private OrderVo buildOrderVo(Order order, List<OrderItem> orderItemList, Shipping shipping) {
		OrderVo orderVo = new OrderVo();
		BeanUtils.copyProperties(order, orderVo);

		List<OrderItemVo> OrderItemVoList = orderItemList.stream().map(e -> {
			OrderItemVo orderItemVo = new OrderItemVo();
			BeanUtils.copyProperties(e, orderItemVo);
			return orderItemVo;
		}).collect(Collectors.toList());
		orderVo.setOrderItemVoList(OrderItemVoList);

		if (shipping != null) {
			orderVo.setShippingId(shipping.getId());
			orderVo.setShippingVo(shipping);
		}

		return orderVo;
	}

这段代码是用于构建订单视图对象 OrderVo 的方法。让我解释一下它的主要步骤：

  1. 首先创建一个空的订单视图对象 OrderVo。

  2. 使用 BeanUtils.copyProperties 方法将订单对象 order 的属性复制到订单视图对象 orderVo 中。这样可以快速地复制相同属性的值，避免手动设置。

  3. 遍历订单项列表 orderItemList，将每个订单项 OrderItem 转换为订单项视图对象 OrderItemVo。这里使用了 Java 8 的 Stream API 和 lambda 表达式，通过映射操作将订单项转换为订单项视图对象，并收集到列表中。

  4. 将转换后的订单项视图对象列表设置到订单视图对象的属性 orderItemVoList 中。

  5. 如果收货地址对象 shipping 不为空，则将其收货地址ID设置到订单视图对象的属性 shippingId 中，并将收货地址对象设置到订单视图对象的属性 shippingVo 中。

  6. 最后，返回构建好的订单视图对象 orderVo。

这段代码主要是用于将订单信息、订单项信息和收货地址信息整合到一个订单视图对象中，以便于前端展示。

	private Order buildOrder(Integer uid,
							 Long orderNo,
							 Integer shippingId,
							 List<OrderItem> orderItemList
							 ) {
		BigDecimal payment = orderItemList.stream()
				.map(OrderItem::getTotalPrice)
				.reduce(BigDecimal.ZERO, BigDecimal::add);

		Order order = new Order();
		order.setOrderNo(orderNo);
		order.setUserId(uid);
		order.setShippingId(shippingId);
		order.setPayment(payment);
		order.setPaymentType(PaymentTypeEnum.PAY_ONLINE.getCode());
		order.setPostage(0);
		order.setStatus(OrderStatusEnum.NO_PAY.getCode());
		return order;
	}

这段代码是用于构建订单对象 Order 的方法。让我解释一下它的主要步骤：

  1. 首先，计算订单的总金额 payment。使用 Stream API 遍历订单项列表 orderItemList，提取每个订单项的总价 totalPrice，并将所有订单项的总价相加得到订单的总金额。如果订单项列表为空，则订单的总金额默认为 0。

  2. 创建一个新的订单对象 order。

  3. 设置订单号 orderNo、用户ID uid、收货地址ID shippingId、支付方式 PAY_ONLINE、邮费 0、订单状态为待支付 NO_PAY。

  4. 将计算得到的总金额 payment 设置到订单对象的支付金额属性 payment 中。

  5. 最后，返回构建好的订单对象 order。

这段代码主要是用于根据用户ID、订单号、收货地址ID和订单项列表构建订单对象，其中订单的总金额通过计算订单项列表中所有订单项的总价得到。

	/**
	 * 企业级：分布式唯一id/主键
	 * @return
	 */
	private Long generateOrderNo() {
		return System.currentTimeMillis() + new Random().nextInt(999);
	}

	private OrderItem buildOrderItem(Integer uid, Long orderNo, Integer quantity, Product product) {
		OrderItem item = new OrderItem();
		item.setUserId(uid);
		item.setOrderNo(orderNo);
		item.setProductId(product.getId());
		item.setProductName(product.getName());
		item.setProductImage(product.getMainImage());
		item.setCurrentUnitPrice(product.getPrice());
		item.setQuantity(quantity);
		item.setTotalPrice(product.getPrice().multiply(BigDecimal.valueOf(quantity)));
		return item;
	}

这两个方法是用于生成订单号和构建订单项对象的方法。让我简要说明一下它们的作用：

  1. generateOrderNo 方法用于生成一个唯一的订单号。它首先获取当前系统时间的毫秒数，然后加上一个随机数，以确保生成的订单号在一定程度上是唯一的。在企业级应用中，可能会使用更加复杂的方式来生成唯一的订单号，比如基于分布式系统的 ID 生成器或者分布式锁等。

  2. buildOrderItem 方法用于根据用户ID、订单号、数量和商品信息构建一个订单项对象。它首先创建一个新的订单项对象，并设置订单项的属性，包括用户ID、订单号、商品ID、商品名称、商品图片、当前单价、数量和总价。订单项的总价通过计算当前单价乘以数量得到。

这两个方法都是用于订单模块的辅助方法，在订单创建时会被调用，用于生成订单号和构建订单项对象。

在提供的代码片段中，虽然没有直接展示AOP（面向切面编程）的代码实现，但我们可以看到几个方面体现了IOC（控制反转）的概念，这是通过Spring框架实现的。以下是对这两个概念在代码中的体现的分析：

IOC（控制反转）

  1. 依赖注入（Dependency Injection）:

    • 使用@Autowired注解自动装配bean，这减少了代码间的紧耦合。例如，在OrderController和OrderServiceImpl类中，通过@Autowired注解自动注入了IOrderService服务实例。这样，Spring容器负责管理这些bean的生命周期和依赖关系，而不是在类内部手动创建依赖对象。

  2. Spring管理Bean的生命周期:

    • 类上的@Service和@Component注解标记了它们作为Spring管理的bean，使得Spring容器知道需要创建这些类的实例并管理它们。例如，OrderServiceImpl被标记为一个服务bean，由Spring容器初始化和管理。

  3. 事务管理:

    • 虽然直接的事务管理代码未展示，但提到的@Transactional注解（在OrderServiceImpl类的注释中提及）是IOC的一个重要应用，它体现了通过声明式事务管理，将事务控制的逻辑从业务代码中抽离出来，由Spring框架在运行时自动管理事务边界。

AOP（面向切面编程）

虽然代码片段中没有直接展示AOP的实现细节，但基于对Spring框架的了解，以及@Transactional注解的提及，我们可以推断AOP在如下方面应用：

  • 事务管理:

    • @Transactional注解是一个典型的AOP应用场景，它代表了一个切面，用于处理事务逻辑。当标记了这个注解的方法被调用时，Spring会在方法执行前后自动应用事务管理的逻辑，包括开始事务、提交或回滚事务等，而无需在业务代码中显式编写这些逻辑。

  • 日志记录、安全检查等横切关注点:

    • 虽然未直接展示，但AOP常用于处理如日志记录、权限验证等跨多个模块的功能，这些被称为横切关注点。通过定义切面，可以将这类逻辑集中管理，减少代码重复，并保持业务逻辑的纯净。

综上，代码片段通过使用Spring框架的特性间接体现了IOC和AOP的设计理念，尤其是在依赖管理和事务处理方面。AOP的具体实现细节可能在其他配置类或切面定义中，而IOC则通过注解和依赖注入的方式广泛应用于代码中。

集合的应用

在提供的代码片段中，集合主要被用来处理和操作一系列的对象，特别是在处理订单、商品和购物车条目等场景中。这里有几个集合使用的例子：

  1. 过滤和转换购物车商品:
    在create方法中，通过流(Stream API)从购物车中筛选出被选中的商品(filter(Cart::getProductSelected)), 然后收集这些被选中的购物车项到一个新的列表中(collect(Collectors.toList()))。这演示了如何使用集合的流式API进行条件过滤和转换操作。

  2. 创建集合以进行集合操作:
    为了进行商品ID的集合操作，如去重和后续的查询，代码创建了一个Set<Integer>来保存所有被选中购物车商品的ID(map(Cart::getProductId)), 然后通过collect(Collectors.toSet())转换为无重复元素的集合。集合Set的特点是不允许重复元素，适合用于去重场景。

  3. 使用Map来关联对象:
    在处理商品信息时，代码使用了Map<Integer, Product>来关联商品ID和商品对象。通过收集器Collectors.toMap(Product::getId, product -> product)，将商品列表转换为以商品ID为键、商品对象为值的映射关系。这种方式便于后续快速根据商品ID查找对应的商品信息。

  4. 批量操作和聚合计算:
    在计算总价和处理订单项时，使用集合的遍历和聚合功能。例如，通过遍历orderItemList来累加每个订单项的总价(reduce(BigDecimal.ZERO, BigDecimal::add)), 实现了对订单总价的计算。此外，集合还用于批量插入数据库操作，如orderItemMapper.batchInsert(orderItemList)，展示了集合作为数据批量操作的载体。

  5. 分组和关联数据:
    在构建订单列表页面时，使用了集合的分组操作来关联订单项和订单(groupingBy(OrderItem::getOrderNo)), 以及按Shipping的ID进行分组(groupingBy(Shipping::getId)), 这样可以高效地将相关联的数据组织在一起，便于构建最终的展示对象。

通过这些例子可以看出，集合在代码中扮演了数据组织、过滤、转换、聚合和操作的核心角色，是实现复杂业务逻辑不可或缺的一部分。集合框架的灵活性和强大的功能帮助简化了许多数据处理任务，提高了代码的可读性和效率。

ToBeWhatYouWannaBe.
关注
  • 13
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
电商项目-订单模块
zhyue28的博客
07-17 8014
72. 显示确认订单信息页 显示“确认订单信息”页面中，需要显示2种数据：当前用户的所有收货地址列表；用户在前序页面中选择的购物车中的商品。 首先，完成“显示当前用户的所有收货地址的列表”，在此前开发“收货地址”相关功能时，已经可以通过/addresses/这个URL获取收货地址列表！则直接在orderConfirm.html中通过$.ajax()获取数据并显示即可！ 接下来，应该“显示用户在前序...
SpringCloud电商项目-qibai
lin77c的博客
03-12 173
前台后台。
电商项目-简历描述篇
热门推荐
04-11 2万+
1.项目名称 XXX新零售电商平台 2.项目描述 该项目是基于SpringBoot/SpringCloud为重庆澳欧惠品构建的一款本地B2C新零售电商平台，客户通过前台浏览和购买商品，管理员通过后台对平台、商品、用户进行管理。主要出售日常百货，地区特产项目使用分布式框架,涉及后台管理员服务、地址服务、物流服务、广告服务、商品服务、商品类别服务、品牌服务、订单服务 、购物车服务、首页频道服务、公告服务、留言服务、搜索服务、会员服务等。 3.技术栈 Springboot+SpringCloud+RabbitMQ
【愚公系列】2022年11月 微信小程序-优购电商项目-订单列表页面
时光隧道
11-06 8352
订单列表页面对于用户来说具备以下两个方面的作用：1.交易凭证：售后、维权、发票都有据可循；针对买卖双方的争议，提供一条依据。2.状态跟踪：交易链条较长的订单有跟踪订单状态的需求，譬如通过淘宝购买一件产品，长时间未收到货物，用户希望能看到订单及物流状态。如，待下单、待支付、运输中（相关物流信息查询）待收货、待评价等等。
电商--订单支付中存在的问题以及思考
SO_zxn的博客
05-03 937
订单支付注意细节
电商-----测试用例
Sk_Ya的博客
06-01 6234
电商项目 - 用户订单确认及下订单操作
java123456111的博客
07-29 2573
同样是使用ThreadLocal来存储用户的登录信息，从请求的request中获取登录信息。
django电商项目---Day01
u_525978的博客
04-04 4720
1、项目目标：在已巩固django基础之上进一步了解web开发流程，学习传统电商项目开发流程及思想
java电商项目搭建-------订单模块
magic_guo的博客
10-14 3212
努力好了，时间会给你答案。--------magic_guo 订单模块的流程以及用户操作如下： 1.当用户选定购物车需要结算的商品并单击结算按钮时，会跳转到订单页面，此时会将选定的购物车信息展示在订单界面，并且还会显示用户的地址信息以供用户选择； 2.用户选择了地址，点击提交订单按钮，此时生成订单数据，并将插入数据库，同时清除购物车信息，然后跳转到支付页面； 3.根据订单id查询订单 5.根据用户id查询所有订单； 6.更新订单状态的操作； 7.取消订单，用户跳转到支付页面而未支付；此时订单处于待支付状态；
电商项目之订单模块
懒起来
10-03 1848
电商项目之订单模块
大型电商项目-Mall.zip
11-06
《大型电商项目-Mall：构建全面的在线购物平台》 在现代互联网时代，电商项目已经成为了商业领域不可或缺的一部分。"大型电商项目-Mall"是一个专为实现高效、安全且用户体验优秀的在线购物平台而设计的开源项目。这...
电商项目-基于SSM框架的Java电商项目实战
11-11
在电商项目中，Mybatis用于操作数据库，如商品信息、订单数据等的增删改查。 4. **Redis**：Redis是一个高性能的键值存储系统，常用于缓存。在电商项目中，它可以缓存热门商品信息、用户会话、购物车数据等，提高...
电商项目--emall.zip
11-01
【电商项目--emall.zip】是一个包含电商系统源代码的压缩包，命名为"emall-master"，这通常意味着它是一个开源电商项目的主分支版本。在这个项目中，我们可以预期找到实现电商平台核心功能的各种代码、配置文件以及...
尚硅谷电商项目--gmall-0529.zip
11-01
【尚硅谷电商项目--gmall-0529】是一个典型的电商系统开发案例，它涵盖了电商领域的多个核心功能模块，是学习和实践Java Web技术、Spring Boot、MyBatis等框架的理想项目。该项目的主要目标是提供一个完整的电商解决...
电商项目-dianshang.zip
11-07
1. **电商平台架构**：一个典型的电商项目通常包括用户端、商家端、管理员端，以及支付系统、库存管理、订单处理、物流跟踪等模块。该项目可能采用了MVC（Model-View-Controller）架构，将业务逻辑、数据模型和用户...
JAVA进阶补充
最新发布
2301_80150315的博客
08-15 544
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
进程间通信 ---共享内存
BUG制造机的博客
08-14 869
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 537
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 246
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
电商项目生成订单怎么测试
05-12
电商项目生成订单的测试可以分为以下几个方面： 1. 功能测试：测试订单生成的流程是否正常，包括选择商品、填写收货地址、选择支付方式、确认订单等步骤是否正常，是否能够生成订单。 2. 数据测试：测试订单生成后...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值