【一起学设计模式】命令模式+模板方法+工厂方法实战: 如何优雅的更新商品库存......

前言

之前在我的博客(一枝花算不算浪漫)中已经更新过两篇设计模式相关的内容

• 【一起学设计模式】策略模式实战一：基于消息发送的策略模式实战
• 【一起学习设计模式】策略模式实战二：配合注解 干掉业务代码中冗余的if else...
• 【一起学设计模式】访问者模式实战：权限管理树删除节点操作

上面内容都是基于真实业务场景精简后的设计(工作中真实场景使用到的)。

之前为了学习设计模式，看过网上很多相关博客讲解，大都是画下UML类图，举例几个毫不相干的demo，看了几遍仍然是云里雾里。

学习设计模式只有在真正的业务场景去使用才会更好的理解其精髓。这里举例自己工作中电商的业务场景，然后配合一些业务功能的实现，来学会设计模式，使自己的代码更优雅。

业务背景

在一个电商或者进销存业务中，我们都有库存的概念。
更新库存又分为很多种场景：购买、退货、下单、取消订单、加购物车等等

当然，我们之前也见过策略模式，这种业务可以抽象为每个策略去做。但是这里我们使用新的设计模式来尝试完成它。

1. 命令模式command
   设置一系列的command命令，我们将不同类型的库存更新逻辑，封装了不同的库存更新命令。

   命令模式还有一个很经典的场景，就是做这个命令撤销。如果我们在执行这个命令的过程中，发现命令中的某个步骤失败了，我们可以在command里面实现一套cancel的逻辑，撤销这个命令之前做的所有操作，对已经完成的好做执行反步骤。

2. 模板方法模式
   将一些通用的步骤抽取到抽象基类，另外一个基于模板的模式限定了每个库存更新的过程都是一样的，按照一样的步骤和顺序走，很清晰。后面如果要修改更新库存的逻辑，或者hi新增一种库存更新的逻辑，都是按照一样的步骤和顺序去走。

3. 工厂方法模式
   工厂方法模式，就是将工厂模式和模板方法模式，结合起来。
   就是说，可能我们需要的不是一个工厂，不同的工厂创建不同的产品，但是这些工厂之间有一些通用的逻辑，可以抽取到父工厂里面去，子工厂就专注于自己的事情就可以了。

类图

代码实现

• 商品库存更新命令接口
  这里采用的command命令模式

/**
 * 商品库存更新命令的接口
 *
 * @author wangmeng
 * @blog https://www.cnblogs.com/wang-meng/
 * @create 2019-12-05 06:42
 **/
public interface StockUpdater {

	/**
	 * 更新商品库存
	 * @return 处理结果
	 */
	Boolean updateGoodsStock();
}

• 创建更新命令command的工厂接口
  这里采用的是工厂方法模式

/**
 * 库存更新命令工厂接口
 *
 * @author wangmeng
 * @blog https://www.cnblogs.com/wang-meng/
 * @create 2019-12-05 06:42
 **/
public interface StockUpdaterFactory<T> {

	/**
	 * 创建一个库存更新命令
	 *
	 * @param parameter 参数对象
	 * @return 库存更新命令
	 */
	StockUpdater create(T parameter);
}

• 商品库存更新命令的抽象基类

/**
 * 商品库存更新命令的抽象基类
 * 
 * @author wangmeng
 * @blog https://www.cnblogs.com/wang-meng/
 * @create 2019-12-05 06:44
 **/
@Slf4j
public abstract class AbstractStockUpdater implements StockUpdater{

	/**
	 * 商品库存对象集合
	 */
	protected List<InventoryGoodsStock> goodsStockList;

	/**
	 * 商品库存管理模块service
	 */
	protected InventoryGoodsStockService goodsStockService;

	public AbstractStockUpdater(List<InventoryGoodsStock> goodsStockList, InventoryGoodsStockService goodsStockService) {
		this.goodsStockList = goodsStockList;
		this.goodsStockService = goodsStockService;
	}

	/**
	 * 更新商品库存
	 * @return
	 */
	@Override
	public Boolean updateGoodsStock() {
		try {
			updateSaleStockQuantity();
			updateLockedStockQuantity();
			updateSaledStockQuantity();
			updateStockStatus();
			updateGmtModified();
			executeUpdateGoodsStock();
		} catch (Exception e) {
			log.error("error", e);
		}
		return true;
	}

	/**
	 * 更新商品的销售库存
	 * @throws Exception
	 */
	protected abstract void updateSaleStockQuantity() throws Exception;

	/**
	 * 更新商品的锁定库存
	 * @throws Exception
	 */
	protected abstract void updateLockedStockQuantity() throws Exception;

	/**
	 * 更新商品的已销售库存
	 * @throws Exception
	 */
	protected abstract void updateSaledStockQuantity() throws Exception;

	/**
	 * 更新商品的库存状态
	 */
	private void updateStockStatus() throws Exception {
		for(InventoryGoodsStock goodsStockDO : goodsStockList) {
			if(goodsStockDO.getSaleStockQuantity() > 0L) {
				goodsStockDO.setStockStatus(StockStatus.IN_STOCK);
			} else {
				goodsStockDO.setStockStatus(StockStatus.NOT_IN_STOCK);
			}
		}
	}

	/**
	 * 更新商品库存的修改时间
	 */
	private void updateGmtModified() throws Exception {
		Date current = new Date();
		for(InventoryGoodsStock goodsStockDO : goodsStockList) {
			goodsStockDO.setGmtModified(current);
		}
	}

	/**
	 * 实际执行更新商品库存的操作
	 * @throws Exception
	 */
	private void executeUpdateGoodsStock() throws Exception {
		for(InventoryGoodsStock goodsStockDO : goodsStockList) {
			goodsStockService.updateById(goodsStockDO);
		}
	}
}

• 抽象创建command的工厂类

/**
 * @author wangmeng
 * @blog https://www.cnblogs.com/wang-meng/
 * @create 2019-12-05 06:56
 **/
@Slf4j
public abstract class AbstractStockUpdaterFactory<T> implements StockUpdaterFactory<T> {

	protected InventoryGoodsStockService stockService;

	public AbstractStockUpdaterFactory(InventoryGoodsStockService stockService) {
		this.stockService = stockService;
	}

	@Override
	public StockUpdater create(T parameter) {
		try {
			List<Long> goodsSkuIds = getGoodsSkuIds(parameter);
			List<InventoryGoodsStock> goodsStockDOs = createGoodsStockList(goodsSkuIds);
			return create(goodsStockDOs, parameter);
		} catch (Exception e) {
			log.error("error", e);
		}
		return null;
	}

	/**
	 * 获取商品sku id集合
	 * @param parameter 参数
	 * @return 商品sku id集合
	 * @throws Exception
	 */
	protected abstract List<Long> getGoodsSkuIds(T parameter) throws Exception;

	/**
	 * 创建库存更新命令
	 * @param parameter 参数
	 * @param goodsStockDOs 商品库存DO对象集合
	 * @return 库存更新命令
	 * @throws Exception
	 */
	protected abstract StockUpdater create(
			List<InventoryGoodsStock> goodsStockDOs, T parameter) throws Exception;

	/**
	 * 创建商品库存DO对象集合
	 *
	 * @param goodsSkuIds 商品sku id集合
	 * @return 商品库存对象集合
	 */
	private List<InventoryGoodsStock> createGoodsStockList(List<Long> goodsSkuIds) throws Exception {
		List<InventoryGoodsStock> goodsStocks = new ArrayList<>(goodsSkuIds.size());
		EntityWrapper<InventoryGoodsStock> wrapper = new EntityWrapper<>();
		wrapper.in("goods_sku_id", goodsSkuIds);
		List<InventoryGoodsStock> goodsStockList = stockService.selectList(wrapper);
		Map<Long, InventoryGoodsStock> stockMap = new HashMap<>();
		if (!CollectionUtils.isEmpty(goodsStockList)) {
			stockMap = goodsStockList.stream().collect(Collectors.toMap(InventoryGoodsStock::getGoodsSkuId, Function.identity()));
		}
		for (Long goodsSkuId : goodsSkuIds) {
			InventoryGoodsStock inventoryGoodsStock = stockMap.get(goodsSkuId);
			if (inventoryGoodsStock == null) {
				inventoryGoodsStock = createGoodsStock(goodsSkuId);
				// 不建议循环中操作sql，这里只做演示作用，实际可以批量操作sql
				stockService.insert(inventoryGoodsStock);
			}

			goodsStocks.add(inventoryGoodsStock);
		}

		return goodsStocks;
	}

	/**
	 * 创建商品库存DO对象
	 * @param goodsSkuId 商品sku id
	 * @return 商品库存DO对象
	 */
	private InventoryGoodsStock createGoodsStock(Long goodsSkuId) {
		InventoryGoodsStock goodsStockDO = new InventoryGoodsStock();
		goodsStockDO.setGoodsSkuId(goodsSkuId);
		goodsStockDO.setSaleStockQuantity(0L);
		goodsStockDO.setLockedStockQuantity(0L);
		goodsStockDO.setSaledStockQuantity(0L);
		goodsStockDO.setStockStatus(StockStatus.NOT_IN_STOCK);
		goodsStockDO.setGmtCreate(new Date());
		goodsStockDO.setGmtModified(new Date());
		return goodsStockDO;
	}
}

• 采购入库库存更新命令的工厂

/**
 * @author wangmeng
 * @blog https://www.cnblogs.com/wang-meng/
 * @create 2019-12-05 06:56
 **/
@Slf4j
public abstract class AbstractStockUpdaterFactory<T> implements StockUpdaterFactory<T> {

	protected InventoryGoodsStockService stockService;

	public AbstractStockUpdaterFactory(InventoryGoodsStockService stockService) {
		this.stockService = stockService;
	}

	@Override
	public StockUpdater create(T parameter) {
		try {
			List<Long> goodsSkuIds = getGoodsSkuIds(parameter);
			List<InventoryGoodsStock> goodsStockDOs = createGoodsStockList(goodsSkuIds);
			return create(goodsStockDOs, parameter);
		} catch (Exception e) {
			log.error("error", e);
		}
		return null;
	}

	/**
	 * 获取商品sku id集合
	 * @param parameter 参数
	 * @return 商品sku id集合
	 * @throws Exception
	 */
	protected abstract List<Long> getGoodsSkuIds(T parameter) throws Exception;

	/**
	 * 创建库存更新命令
	 * @param parameter 参数
	 * @param goodsStockDOs 商品库存DO对象集合
	 * @return 库存更新命令
	 * @throws Exception
	 */
	protected abstract StockUpdater create(
			List<InventoryGoodsStock> goodsStockDOs, T parameter) throws Exception;

	/**
	 * 创建商品库存DO对象集合
	 *
	 * @param goodsSkuIds 商品sku id集合
	 * @return 商品库存对象集合
	 */
	private List<InventoryGoodsStock> createGoodsStockList(List<Long> goodsSkuIds) throws Exception {
		List<InventoryGoodsStock> goodsStocks = new ArrayList<>(goodsSkuIds.size());
		EntityWrapper<InventoryGoodsStock> wrapper = new EntityWrapper<>();
		wrapper.in("goods_sku_id", goodsSkuIds);
		List<InventoryGoodsStock> goodsStockList = stockService.selectList(wrapper);
		Map<Long, InventoryGoodsStock> stockMap = new HashMap<>();
		if (!CollectionUtils.isEmpty(goodsStockList)) {
			stockMap = goodsStockList.stream().collect(Collectors.toMap(InventoryGoodsStock::getGoodsSkuId, Function.identity()));
		}
		for (Long goodsSkuId : goodsSkuIds) {
			InventoryGoodsStock inventoryGoodsStock = stockMap.get(goodsSkuId);
			if (inventoryGoodsStock == null) {
				inventoryGoodsStock = createGoodsStock(goodsSkuId);/**
 * 采购入库库存更新命令的工厂
 * @author wangmeng
 *
 */
@Component
public class PurchaseInputStockUpdaterFactory<T> 
		extends AbstractStockUpdaterFactory<T> {

	/**
	 * 构造函数
	 * @param stockService 商品库存管理模块的service组件
	 */
	@Autowired
	public PurchaseInputStockUpdaterFactory(InventoryGoodsStockService stockService) {
		super(stockService);
	}

	/**
	 * 获取商品sku id集合
	 * @return 商品sku id集合
	 * @throws Exception
	 */
	@Override
	protected List<Long> getGoodsSkuIds(T parameter) throws Exception {		
		PurchaseInputOrderDTO purchaseInputOrderDTO = (PurchaseInputOrderDTO) parameter;
		List<PurchaseInputOrderItemDTO> purchaseInputOrderItemDTOs =
				purchaseInputOrderDTO.getItems();
		
		if(purchaseInputOrderItemDTOs == null || purchaseInputOrderItemDTOs.size() == 0) {
			return new ArrayList<>();
		}
		
		List<Long> goodsSkuIds = new ArrayList<Long>(purchaseInputOrderItemDTOs.size());
		for(PurchaseInputOrderItemDTO purchaseInputOrderItemDTO : purchaseInputOrderItemDTOs) {
			goodsSkuIds.add(purchaseInputOrderItemDTO.getGoodsSkuId());
		}
		
		return goodsSkuIds;
	}

	/**
	 * 创建库存更新命令
	 * @param goodsStockDOs 商品库存DO对象集合
	 * @return 库存更新命令
	 * @throws Exception
	 */
	@Override
	protected StockUpdater create(List<InventoryGoodsStock> goodsStockDOs, T parameter) throws Exception {
		PurchaseInputOrderDTO purchaseInputOrderDTO = (PurchaseInputOrderDTO) parameter;
		List<PurchaseInputOrderItemDTO> purchaseInputOrderItemDTOs = purchaseInputOrderDTO.getItems();
		Map<Long, PurchaseInputOrderItemDTO> purchaseInputOrderItemDTOMap = new HashMap<>();
		if(purchaseInputOrderItemDTOs != null && purchaseInputOrderItemDTOs.size() > 0) {
			for(PurchaseInputOrderItemDTO purchaseInputOrderItemDTO : purchaseInputOrderItemDTOs) {
				purchaseInputOrderItemDTOMap.put(purchaseInputOrderItemDTO.getGoodsSkuId(), 
						purchaseInputOrderItemDTO);
			}
		}
		
		return new PurchaseInputStockUpdater(goodsStockDOs, stockService, purchaseInputOrderItemDTOMap);
	}

}
				// 不建议循环中操作sql，这里只做演示作用，实际可以批量操作sql
				stockService.insert(inventoryGoodsStock);
			}

			goodsStocks.add(inventoryGoodsStock);
		}

		return goodsStocks;
	}

	/**
	 * 创建商品库存DO对象
	 * @param goodsSkuId 商品sku id
	 * @return 商品库存DO对象
	 */
	private InventoryGoodsStock createGoodsStock(Long goodsSkuId) {
		InventoryGoodsStock goodsStockDO = new InventoryGoodsStock();
		goodsStockDO.setGoodsSkuId(goodsSkuId);
		goodsStockDO.setSaleStockQuantity(0L);
		goodsStockDO.setLockedStockQuantity(0L);
		goodsStockDO.setSaledStockQuantity(0L);
		goodsStockDO.setStockStatus(StockStatus.NOT_IN_STOCK);
		goodsStockDO.setGmtCreate(new Date());
		goodsStockDO.setGmtModified(new Date());
		return goodsStockDO;
	}
}

• 采购入库库存更新命令

/**
 * 采购入库库存更新命令
 * @author zhonghuashishan
 *
 */
public class PurchaseInputStockUpdater extends AbstractStockUpdater {

	/**
	 * 采购入库单条目DTO集合
	 */
	private Map<Long, PurchaseInputOrderItemDTO> purchaseInputOrderItemDTOMap;
	
	/**
	 * 构造函数
	 * @param goodsStockDOs 商品库存DO对象
	 * @param stockService 商品库存管理模块的service组件
	 */
	public PurchaseInputStockUpdater(
			List<InventoryGoodsStock> goodsStockDOs,
			InventoryGoodsStockService stockService,
			Map<Long, PurchaseInputOrderItemDTO> purchaseInputOrderItemDTOMap) {
		super(goodsStockDOs, stockService);
		this.purchaseInputOrderItemDTOMap = purchaseInputOrderItemDTOMap;
	}
	
	/**
	 * 更新销售库存
	 */
	@Override
	protected void updateSaleStockQuantity() throws Exception {
		for(InventoryGoodsStock goodsStockDO : goodsStockList) {
			PurchaseInputOrderItemDTO purchaseInputOrderItemDTO =
					purchaseInputOrderItemDTOMap.get(goodsStockDO.getGoodsSkuId());
			goodsStockDO.setSaleStockQuantity(goodsStockDO.getSaleStockQuantity() 
					+ purchaseInputOrderItemDTO.getArrivalCount()); 
		}
	}

	/**
	 * 更新锁定库存
	 */
	@Override
	protected void updateLockedStockQuantity() throws Exception {
		
	}

	/**
	 * 更新已销售库存
	 */
	@Override
	protected void updateSaledStockQuantity() throws Exception {
		
	}

}

• 实际流转调用代码

/**
 * <p>
 * 库存中心的商品库存表 服务实现类
 * </p>
 *
 * @author wangmeng
 * @since 2019-12-03
 */
@Service
@Slf4j
public class InventoryGoodsStockServiceImpl extends ServiceImpl<InventoryGoodsStockMapper, InventoryGoodsStock> implements InventoryGoodsStockService {

	/**
	 * 采购入库库存更新命令工厂
	 */
	@Autowired
	private PurchaseInputStockUpdaterFactory<PurchaseInputOrderDTO> purchaseInputStockUpdateCommandFactory;

	/**
	 * 通知库存中心，“采购入库完成”事件发生了
	 * @param purchaseInputOrderDTO 采购入库单DTO
	 * @return 处理结果
	 */
	@Override
	public Boolean informPurchaseInputFinished(
			PurchaseInputOrderDTO purchaseInputOrderDTO) {
		try {
			StockUpdater goodsStockUpdateCommand = purchaseInputStockUpdateCommandFactory.create(purchaseInputOrderDTO);
			goodsStockUpdateCommand.updateGoodsStock();
		} catch (Exception e) {
			log.error("error", e);
			return false;
		}
		return true;
	}
}

申明

本文章首发自本人博客：https://www.cnblogs.com/wang-meng 和公众号：壹枝花算不算浪漫，如若转载请标明来源!

感兴趣的小伙伴可关注个人公众号：壹枝花算不算浪漫