订单服务业务逻辑及异步消息通知（八）

最新推荐文章于 2024-04-10 10:02:18 发布
最新推荐文章于 2024-04-10 10:02:18 发布
阅读量727 收藏 2
点赞数
分类专栏： springcloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43054590/article/details/106022604
版权

一、服务提供者product

1.1、ProductService新增两个接口

1、ProductService接口
  • 通过一组商品id查询商品列表和商品扣库存这两个接口是需要提供给Order服务调用的
/**
 * 商品业务接口：主要关注于具体与商品相关的业务逻辑的编写，忽略数据库操作
 */
public interface ProductService {

    /**
     * 查询所有在架商品
     *
     * @return
     */
    List<ProductCategoryVo> getUpAllProductCategoryVo();

    /**
     * 通过一组商品id查询商品列表
     * @param productIds
     * @return
     */
    List<ProductInfoVo> getListByProductIds(List<String> productIds);

    /**
     * 商品扣库存
     */
    void decreaseStock(List<OrderCar> orderCars);

}
2、ProductService实现上面两个接口
  • 扣库存：扣库存成功以后还要使用rabbitmq将该商品的基本信息（剩余库存量）异步写入productExchange中，方便order端查看
/**
     * 通过一组商品id查询商品列表
     *
     * @param productIds
     * @return
     */
    @Override
    public List<ProductInfoVo> getListByProductIds(List<String> productIds) {
        List<ProductInfo> productInfoList = iProductService.findAllByProductIds(productIds);
        if (productInfoList.size() == 0) {
            throw new MyException(ResultEnum.UP_PRODUCT_LIST_NOT_EXIST);
        }
        List<ProductInfoVo> productInfoVoList = new ArrayList<>();
        for (ProductInfo productInfo : productInfoList) {
            ProductInfoVo productInfoVo = new ProductInfoVo();
            BeanUtils.copyProperties(productInfo, productInfoVo);
            productInfoVoList.add(productInfoVo);
        }
        return productInfoVoList;
    }

    /**
     * 商品扣库存
     */
    @Override
    public void decreaseStock(List<OrderCar> orderCars) {
        //執行扣庫存工作
        List<ProductInfoOutput> productInfoOutputList = getOutputsByDecrease(orderCars);
        //mq发布更新商品最新剩余的库存量
        amqpTemplate.convertAndSend("productExchange", "productInfo", FastJsonUtil.objectToJSON(productInfoOutputList));
    }

    /**
     * 通信服务：获取商品扣库存后的商品信息
     * @param orderCars
     * @return
     */
    @Transactional //事务就是要么全部成功（提交），要么全部失败（回滚），就算成功一部分也要（回滚）
    public List<ProductInfoOutput> getOutputsByDecrease(List<OrderCar> orderCars){
        List<ProductInfoOutput> productInfoOutputs = new ArrayList<>();
        for (OrderCar orderCar : orderCars) {
            //查询商品是否存在
            Optional<ProductInfo> productInfoOptional = productInfoRepository.findById(orderCar.getProductId());
            if (!productInfoOptional.isPresent()) {
                throw new MyException("订单中商品信息不存在");
            }
            ProductInfo productInfo = productInfoOptional.get();
            //检测商品库存是否足够
            int newProductStock = productInfo.getProductStock() - orderCar.getProductQuantity();
            if (newProductStock < 0) {
                throw new MyException(productInfo.getProductName()+"库存不足");
            }
            //将新的库存存入商品表中
            productInfo.setProductStock(newProductStock);
            productInfoRepository.save(productInfo);
            ProductInfoOutput productInfoOutput = new ProductInfoOutput();
            BeanUtils.copyProperties(productInfo,productInfoOutput);
            productInfoOutputs.add(productInfoOutput);
        }
        return  productInfoOutputs;
    }

1.2、编写product服务通信接口

@RestController
@RequestMapping("/productClient")
public class ProductClientController {

    @Autowired
    private ProductService productService;

    @PostMapping("/providerList")
    public List<ProductInfoVo> providerProductList(@RequestBody List<String> productIds) {
        //调用时给一个2s的线程睡眠时间
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return productService.getListByProductIds(productIds);
    }

    @PostMapping("/decreaseStock")
    public void decreaseStock(@RequestBody List<OrderCar> orderCars) {
        productService.decreaseStock(orderCars);
    }
}

二、服务消费者order

2.1、创建订单

1、编写服务通信接口获取product提供的controller方法
/**
 * 订单订阅商品服务通信接口：用于订单模块接受商品模块提供的服务
 */
@FeignClient("product")
public interface Product2OrderFeign {

    /**
     * 商品服务：获取商品信息列表
     * @param productIds
     * @return
     */
    @PostMapping("/productClient/providerList")
    public List<ProductInfoVo> getProducts(List<String> productIds);

    /**
     * 商品服务：扣库存
     * @param orderCars
     */
    @PostMapping("/productClient/decreaseStock")
    public void decreaseProductStock(List<OrderCar> orderCars);

}
2、创建订单接口
/**
 * 订单业务接口
 */
public interface OrderService {

    /**
     * 创建订单
     *
     * @param orderDto
     * @return
     */
    String createOrder(OrderDto orderDto);

}
3、方法实现
   @Autowired
    private Product2OrderFeign product2OrderFeign;

    @Autowired
    private OrderMasterMapper orderMasterMapper;

    @Autowired
    private OrderDetailMapper orderDetailMapper;

    /**
     * 创建订单
     * 1、参数校验（判断订单是否有商品）
     * 2、根据id查询相应的商品信息（调用product-server的服务）
     * 3、计算订单总金额
     * 4、扣库存（调用product-server的服务）
     * 5、订单入库：OrderMaster入库，OrderDetail入库
     */
    @Override
    public String createOrder(OrderDto orderDto) {
        if (orderDto.getItems().size() == 0) {
            throw new MyException("创建订单请先选择商品");
        }
        OrderMaster orderMaster = OrderConvert.orderDto2OrderMaster(orderDto);
        String orderId = BaseDataKeyUtils.keyByCurrentTime();
        orderMaster.setOrderId(orderId);
        orderMaster.setOrderStatus(OrderStatusEnum.NEW.getCode());
        orderMaster.setPayStatus(OrderPayStatusEnum.UN_PAID.getCode());
        orderMaster.setDeleteStatus(DeleteStatusEnum.ON_USE.getCode());
        //1、根据商品id查询商品列表
        List<OrderCar> orderCars = orderDto.getItems();
        List<String> productIds = new ArrayList<>();
        for (OrderCar orderCar : orderCars) {
            productIds.add(orderCar.getProductId());
        }
        List<ProductInfoVo> products = product2OrderFeign.getProducts(productIds);
        //2、计算订单总金额
        BigDecimal orderAmount = new BigDecimal(BigInteger.ZERO);
        for (OrderCar orderCar : orderCars) {
            for (ProductInfoVo product : products) {
                if (orderCar.getProductId().equals(product.getProductId())) {
                    orderAmount = orderAmount.add(product.getProductPrice().multiply(new BigDecimal(orderCar.getProductQuantity())));
                    //订单入库：OrderDetail
                    OrderDetail orderDetail = new OrderDetail();
                    BeanUtils.copyProperties(product, orderDetail);
                    orderDetail.setDetailId(BaseDataKeyUtils.keyByCurrentTime());
                    orderDetail.setOrderId(orderId);
                    orderDetail.setDeleteStatus(DeleteStatusEnum.ON_USE.getCode());
                    orderDetail.setProductQuantity(orderCar.getProductQuantity());
                    //todo 可以做成批量插入
                    orderDetailMapper.insertSelective(orderDetail);
                }
            }
        }
        //3、扣库存
        product2OrderFeign.decreaseProductStock(orderCars);
        //4、订单入库：OrderMaster
        orderMaster.setOrderAmount(orderAmount);
        orderMasterMapper.insertSelective(orderMaster);
        return orderMaster.getOrderId();
    }
4、order端接收创建订单之后商品的rabbitmq异步通知
  • 将商品库存打印出来并且写入redis缓存中
@Slf4j
@Component
public class ProductInfoReceiver {

    @Autowired
    private StringRedisTemplate redisTemplate;

    private static final String  productStockKey = "商品_%s_%s库存";

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue("productQueue"),
            key = "productInfo",
            exchange = @Exchange("productExchange")
    ))
    public void processStockChange(String message){
        List<ProductInfoOutput> productInfoOutputs = FastJsonUtil.toList(message, ProductInfoOutput.class);
        for (ProductInfoOutput productInfoOutput : productInfoOutputs) {
            log.info("商品_{}_{}的库存剩余 = {}",productInfoOutput.getProductName(),productInfoOutput.getProductId(),productInfoOutput.getProductStock());
            //将商品剩余库存存入redis中
            redisTemplate.opsForValue().set(String.format(productStockKey,productInfoOutput.getProductName(),productInfoOutput.getProductId()),
                    String.valueOf(productInfoOutput.getProductStock()));
        }
    }

}

2.2、完结订单

1、接口方法
 /**
     * 完结订单
     * @return
     */
    OrderMasterPojo finishOrder(String orderId);
2、实现finishOrder方法
@Override
    @Transactional
    public OrderMasterPojo finishOrder(String orderId) {
        //1、查询此订单是否存在
        OrderMaster orderMaster = orderMasterMapper.selectByPrimaryKey(orderId);
        if (orderMaster == null){
            throw  new MyException(ResultEnum.ORDER_NOT_EXIST);
        }
        //2、查询此订单是否为新订单
        if(orderMaster.getOrderStatus() != OrderStatusEnum.NEW.getCode()){
            throw new MyException(ResultEnum.ORDER_STATUS_NOT_NEW);
        }
        //3、查询此订单是否已支付
        if (orderMaster.getPayStatus() != OrderPayStatusEnum.PAID.getCode()){
            //如果当前订单不是已经支付状态，不能够执行完结操作
            throw new MyException(ResultEnum.ORDER_PAID_ERROR);
        }

        //4、修改订单完结状态
        orderMaster.setOrderStatus(OrderStatusEnum.FINISH.getCode());
        orderMasterMapper.updateByPrimaryKeySelective(orderMaster);
        //5、查询订单详情信息
        Example example = new Example(OrderDetail.class);
        example.createCriteria().andEqualTo("orderId",orderMaster.getOrderId());
        List<OrderDetail> orderDetailList = orderDetailMapper.selectByExample(example);
        if (CollectionUtils.isEmpty(orderDetailList)){
            throw new MyException(ResultEnum.ORDER_DETAIL_MSG_ERROR);
        }
        //6、拼接返回消息体
        OrderMasterPojo orderMasterPojo = new OrderMasterPojo();
        List<OrderDetailPojo> orderDetailPojoList = new ArrayList<>();
        for (OrderDetail orderDetail : orderDetailList) {
            OrderDetailPojo orderDetailPojo = new OrderDetailPojo();
            BeanUtils.copyProperties(orderDetail,orderDetailPojo);
            orderDetailPojoList.add(orderDetailPojo);
        }
        BeanUtils.copyProperties(orderMaster,orderMasterPojo);
        orderMasterPojo.setOrderDetailList(orderDetailList);

        return orderMasterPojo;
    }

2.3、取消订单

1、接口方法
 /**
     * 取消订单
     * @param orderId
     * @return
     */
    OrderMasterPojo cancelOrder(String orderId);
2、实现cancelOrder方法
@Override
    public OrderMasterPojo cancelOrder(String orderId) {
        //1、查询此订单是否存在
        OrderMaster orderMaster = orderMasterMapper.selectByPrimaryKey(orderId);
        if (orderMaster == null){
            throw  new MyException(ResultEnum.ORDER_NOT_EXIST);
        }
        //2、查询此订单是否为新订单
        if(orderMaster.getOrderStatus() != OrderStatusEnum.NEW.getCode()){
            throw new MyException(ResultEnum.ORDER_STATUS_NOT_NEW);
        }
        //3、查询此订单是否已支付
        if (orderMaster.getPayStatus() == OrderPayStatusEnum.PAID.getCode()){
            //如果当前订单是已经支付状态，不能够执行取消操作
            throw new MyException(ResultEnum.ORDER_PAID_ERROR);
        }

        //4、修改订单为已取消状态
        orderMaster.setOrderStatus(OrderStatusEnum.CANCEL.getCode());
        orderMasterMapper.updateByPrimaryKeySelective(orderMaster);
        //5、查询订单详情信息
        Example example = new Example(OrderDetail.class);
        example.createCriteria().andEqualTo("orderId",orderMaster.getOrderId());
        List<OrderDetail> orderDetailList = orderDetailMapper.selectByExample(example);
        if (CollectionUtils.isEmpty(orderDetailList)){
            throw new MyException(ResultEnum.ORDER_DETAIL_MSG_ERROR);
        }
        //6、拼接返回消息体
        OrderMasterPojo orderMasterPojo = new OrderMasterPojo();
        List<OrderDetailPojo> orderDetailPojoList = new ArrayList<>();
        for (OrderDetail orderDetail : orderDetailList) {
            OrderDetailPojo orderDetailPojo = new OrderDetailPojo();
            BeanUtils.copyProperties(orderDetail,orderDetailPojo);
            orderDetailPojoList.add(orderDetailPojo);
        }
        BeanUtils.copyProperties(orderMaster,orderMasterPojo);
        orderMasterPojo.setOrderDetailList(orderDetailList);

        return orderMasterPojo;
    }

2.4、支付订单

1、支付订单接口方法
/**
     * 支付订单
     * @param orderId
     * @return
     */
    OrderMasterPojo paid(String orderId);
2、实现paid方法
 @Override
    public OrderMasterPojo paid(String orderId) {
        //1、查询此订单是否存在
        OrderMaster orderMaster = orderMasterMapper.selectByPrimaryKey(orderId);
        if (orderMaster == null){
            throw  new MyException(ResultEnum.ORDER_NOT_EXIST);
        }
        //2、查询此订单是否为新订单
        if(orderMaster.getOrderStatus() != OrderStatusEnum.NEW.getCode()){
            throw new MyException(ResultEnum.ORDER_STATUS_NOT_NEW);
        }
        //3、查询此订单是否已支付
        if (orderMaster.getPayStatus() == OrderPayStatusEnum.PAID.getCode()){
            //如果当前订单是已经支付状态，不能够执行支付操作
            throw new MyException(ResultEnum.ORDER_PAID_ERROR);
        }
        //todo 微信支付和支付宝支付的具体逻辑：需要商户账号才行

        //4、修改订单已经支付状态
        orderMaster.setPayStatus(OrderPayStatusEnum.PAID.getCode());
        orderMasterMapper.updateByPrimaryKeySelective(orderMaster);
        //5、查询订单详情信息
        Example example = new Example(OrderDetail.class);
        example.createCriteria().andEqualTo("orderId",orderMaster.getOrderId());
        List<OrderDetail> orderDetailList = orderDetailMapper.selectByExample(example);
        if (CollectionUtils.isEmpty(orderDetailList)){
            throw new MyException(ResultEnum.ORDER_DETAIL_MSG_ERROR);
        }
        //6、拼接返回消息体
        OrderMasterPojo orderMasterPojo = new OrderMasterPojo();
        List<OrderDetailPojo> orderDetailPojoList = new ArrayList<>();
        for (OrderDetail orderDetail : orderDetailList) {
            OrderDetailPojo orderDetailPojo = new OrderDetailPojo();
            BeanUtils.copyProperties(orderDetail,orderDetailPojo);
            orderDetailPojoList.add(orderDetailPojo);
        }
        BeanUtils.copyProperties(orderMaster,orderMasterPojo);
        orderMasterPojo.setOrderDetailList(orderDetailList);

        return orderMasterPojo;
    }
2.5、OrderController
@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private OrderService orderService;

    @PostMapping("/buyer/create")
    public ResultVo createOrder(@RequestBody OrderDto orderDto) {
        ResultVo resultVo = new ResultVo();
        try {
            String orderId = orderService.createOrder(orderDto);
            resultVo = ResultVOUtils.success(orderId);
        } catch (MyException e) {
            resultVo = ResultVOUtils.error(e.getCode(), e.getMessage());
        }
        return resultVo;
    }

    @PostMapping("/seller/finish")
    public ResultVo finishOrder(@RequestParam("orderId") String orderId){
        ResultVo resultVo = new ResultVo();
        try {
            OrderMasterPojo orderMasterPojo = orderService.finishOrder(orderId);
            resultVo = ResultVOUtils.success(orderMasterPojo);
        } catch (MyException e) {
            resultVo = ResultVOUtils.error(e.getCode(), e.getMessage());
        }
        return resultVo;
    }

    @PostMapping("/buyer/cancel")
    public ResultVo cancelOrder(@RequestParam("orderId") String orderId){
        ResultVo resultVo = new ResultVo();
        try {
            OrderMasterPojo orderMasterPojo = orderService.cancelOrder(orderId);
            resultVo = ResultVOUtils.success(orderMasterPojo);
        } catch (MyException e) {
            resultVo = ResultVOUtils.error(e.getCode(), e.getMessage());
        }
        return resultVo;
    }

    @PostMapping("/buyer/paid")
    public ResultVo paid(@RequestParam("orderId") String orderId){
        ResultVo resultVo = new ResultVo();
        try {
            OrderMasterPojo orderMasterPojo = orderService.paid(orderId);
            resultVo = ResultVOUtils.success(orderMasterPojo);
        } catch (MyException e) {
            resultVo = ResultVOUtils.error(e.getCode(), e.getMessage());
        }
        return resultVo;
    }


}

三、Order和Product配置

1.1、本地application配置

1、product服务
server:
  port: 8083
spring:
  application:
    name: product
  cloud:
    config:
      discovery:
        enabled: true
        service-id: CONFIG
      profile: local
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
vcap:
  application:
    instance_index: ${spring.cloud.config.profile}
2、order服务
server:
  port: 8082
spring:
  application:
    name: order
  cloud:
    config:
      discovery:
        enabled: true
        service-id: CONFIG
      profile: dev
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
  redis:
    host: localhost
    port: 6379
    password: 123456
    database: 3
vcap:
  application:
    instance_index: ${spring.cloud.config.profile}
hystrix:
  command:
    default:
      # 断路器相关配置
      circuitBreaker:
        # 是否开启断路器
        enabled: true
        # 滑动窗口的大小，默认为20
        requestVolumeThreshold: 10
        # 过多长时间，熔断器再次检测是否开启，默认为5000，即5s钟
        sleepWindowInMilliseconds: 10000
        # 错误率，默认50%
        errorThresholdPercentage: 60
      execution:
        isolation:
          thread:
            # 配置超时时间：单位ms;默认是1000ms
            timeoutInMilliseconds: 3000
    getProducts:
      execution:
        isolation:
          thread:
            # 配置超时时间：单位ms
            timeoutInMilliseconds: 1200
management:
  endpoints:
    web:
      exposure:
        include: 'hystrix.stream'

1.2、git远程配置

1、order服务
spring:
  devtools:
    remote:
      restart:
        enabled: true
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mall-order?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true& serverTimezone=UTC
    username: root
    password: 123456
  jpa:
    show-sql: true

  freemarker:
    cache: false
mybatis:
  mapper-locations: classpath:mappers/*.xml

logging:
  level:
    com:
      mall:
        dao: debug

user:
  name: zhangsan
  age: 250
2、product服务
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
spring:
  devtools:
    remote:
      restart:
        enabled: true

  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mall-product?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true& serverTimezone=UTC
    username: root
    password: 123456
  jpa:
    show-sql: true

  freemarker:
    cache: false
user:
  name: lisi
  age: 260

1.3、config-server配置

1、本地配置
spring:
  application:
    name: config
  cloud:
    config:
      server:
        git:
          uri: https://github.com/achuanxiang/amall-config.git
          search-paths: local
          default-label: master
          username: 2415013993@qq.com
          password: xxc13762694142
          basedir: E:\study_project\cloud_projects\a-mall\git-config
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
management:
  endpoints:
    web:
      exposure:
        include: "*"
server:
  port: 8081
2、git远程仓库配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
阿川xiang
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
订单系统：从0到1设计思路
09-11 4889
https://baijiahao.baidu.com/s?id=1611220684816408868&wfr=spider&for=pc 概述 本文主要讲述了在传统电商企业中，订单系统应承载的角色，就订单系统所包含的主要功能模块梳理了设计思路，并对订单系统未来的发展做了一些思考。 1. 订单系统在企业中的角色 在搭建企业订单系统之前，需要先梳理企业...
订单业务逻辑设计
weixin_43272286的博客
03-01 1997
订单业务逻辑 订单的常见功能： 创建订单功能、查看订单列表、根据订单id查询订单的详细信息、订单修改、订单取消、订单状态、订单评价等功能的实现 数据库表的设计 tb_order(订单信息表) tb_order_item（订单详情表） tb_order_shipping（订单配送表） ...
订单模块的业务逻辑
最新发布
2301_80432558的博客
04-10 454
订单模块的业务逻辑通常涵盖了从订单创建到订单完成的整个生命周期。以上是订单模块的一般业务逻辑，具体实现会根据具体业务需求和系统设计进行调整和扩展。
用户下订单业务逻辑
qq_41858479的博客
05-30 5302
涉及到的基本对象有哪些？ 答：用户类，订单主表类、订单详情类、枚举类、异常类、数据传输DTO类、前端视图VO类、对象转换类工具类等。 为什么需要这些类？ 用户类：作为用户订单中的主角，不可省略。 订单主表类：主要存放一些关于订单的内置属性。例如：订单状态、支付状态、用户的各种信息、订单总价等。 订单详情表：主要存放在一个订单中用所购买的商品信息。例如：商品名称、商品单价、商品数量等。 ...
订单服务-----功能实现逻辑
骚戴的博客
12-07 1165
订单服务-----功能实现逻辑
支付宝支付配置及同步、异步回调和业务处理.rar
05-04
开发者需要设置一个专门的异步回调接口，同样需要验证签名并处理业务逻辑，例如更新库存、发货等。 最后，**业务处理**涉及支付后的各种操作，如： 1. 订单状态管理：根据支付宝返回的结果，更新订单的状态，如待...
taobao调用异步接口下载订单,自动解压与转换
12-02
使用Java的CSV库（如OpenCSV）或者其他数据处理框架（如Apache POI、Jackson等）将数据转换成Java对象，便于后续的业务逻辑处理。 在整个过程中，需要注意的是安全性和性能优化。例如，确保AccessToken的安全存储，...
business:创建和管理业务对象的应用程序逻辑
05-01
例如，我们可以创建一个`OrderService`模块来处理订单相关的业务逻辑： ```javascript // orderService.js const Order = require('./order'); // 假设我们有一个Order构造函数 class OrderService { createOrder...
22-02-10-025_Nop_4.40.4(业务流消息服务相关定义实现)
03-03
在NopCommerce 4.40.4中，这一服务的优化使得复杂的业务逻辑得以更高效地执行，同时减少了对用户界面的影响，提高了系统的整体性能。 二、消息队列的引入与工作原理 1. 消息队列的引入：NopCommerce 4.40.4采用...
【ssm项目源码】订单管理系统.zip
02-22
这需要处理支付接口调用、异步通知处理等相关逻辑。 8. **异常处理**：在系统开发中，良好的异常处理机制能够提供更好的用户体验。订单管理系统的源码中，可以看到如何优雅地捕获和处理可能出现的异常。 9. **单元...
springboot 订单模块逻辑
weixin_43837268的博客
08-18 505
【代码】springboot 订单模块逻辑。
电商订单中心业务梳理
独行侠梦的博客
10-18 752
订单中心是一个电商后台系统的枢纽，在这订单这一环节上需要读取多个模块的数据和信息进行加工处理，并流向下一环节；因此订单模块对一电商系统来说，重要性不言而喻。同时，订单是一个公司生存甚至盈利...
聊聊「订单」业务的设计与实现
BASK2311的博客
03-17 607
订单业务一直都是系统研发中的核心模块，订单的产生过程，与系统中的很多模块都会高度关联，比如账户体系、支付中心、运营管理等，即便单看订单本身，也足够的复杂；业务在发展的过程中，必然会导致订单量的持续增加，订单自身、数据体量、实现流程，都需要不断的迭代更新，如果在订单流程的研发初期，没有相对全面的考量，那么很有可能导致中后期的重构；建议过度设计，轻量级分步实现；
订单模块业务处理流程梳理记录
weixin_46066254的博客
11-07 563
订单业务笔记流程梳理记录
电商系列：订单中心业务梳理
JAVA高级架构
09-16 968
订单中心是一个电商后台系统的枢纽，在这订单这一环节上需要读取多个模块的数据和信息进行加工处理，并流向下一环节；因此订单模块对一电商系统来说，重要性不言而喻。同时，订单是一个公司生存甚至盈利...
mq-订单创建流程通知
maikelsong的专栏
07-14 2073
图解：订单系统从0到1设计思路
石杉的架构笔记
04-05 738
文章来源：https://sourl.cn/nXqrVQ|| 目录概述订单系统核心功能订单系统的发展最后1概 述本文主要讲述了在传统电商企业中，订单系统应承载的角色，就订单系统所包含的主要功能模块梳理了设计思路，并对订单系统未来的发展做了一些思考。1. 订单系统在企业中的角色在搭建企业订单系统之前，需要先梳理企业整体业务系统之间的关系和订单系统上下游关系，只有划分清业务...
秒杀系统实战（五）| 如何优雅的实现订单异步处理
weixin_47303690的博客
04-02 2185
秒杀系统实战（五）| 如何优雅的实现订单异步处理 前言我回来啦，前段时间忙得不可开交。这段时间终于能喘口气了，继续把之前挖的坑填起来。写完上一篇秒杀系统（四）：数据库与缓存双写一致性深入分析后，感觉文章深度一下子被我抬高了一些，现在构思新文章的时候，反而畏手畏脚，不敢随便写了。对于未来文章内容的想法，我写在了本文的末尾。本文我们来聊聊秒杀系统中的订单异步处理。本篇文...
Java后端购物车Service层业务逻辑
06-10
5. 支付管理：包括支付宝、微信支付的集成、支付结果的异步通知等。 在实现上述业务逻辑时，需要考虑以下几个方面： 1. 业务逻辑的正确性和合法性：需要对用户的输入进行校验，防止非法输入和恶意攻击； 2. 事务...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值