项目实战-多子集循环嵌套 更新时的处理逻辑

项目实战 多子集循环嵌套 更新时的处理逻辑

商品多子集循环嵌套 更新场景时的处理逻辑

场景背景：业务中，套餐下面有多个商品，每个商-品又有多个sku。目前分为套餐表、商品表、sku表，现在更新套餐时 商品和sku都有可能出现增删改的情况，代码里如何区分是新增 修改 和删除呢

假设我们是Spring Boot 项目，在处理套餐、商品、SKU 的增删改操作时，可以采用以下方案来区分并处理新增、修改和删除操作。

一、前端传递完整的数据结构

首先，前端应该将更新后的套餐数据完整地传递给后端，包括所有商品和 SKU 的详细信息。数据结构可能如下：

{
    "packageId": 1,
    "packageName": "套餐A",
    "items": [
        {
            "itemId": 1,  // 如果为null，则是新增
            "itemName": "商品 A",
            "skus": [
                {
                    "skuId": 1,  // 如果为null，则是新增
                    "skuName": "SKU A",
                    "price": 100
                },
                {
                    "skuId": 2,
                    "skuName": "SKU B",
                    "price": 200
                }
            ]
        },
        {
            "itemId": null,  // 新增商品
            "itemName": "商品 B",
            "skus": [
                {
                    "skuId": null,  // 新增 SKU
                    "skuName": "SKU C",
                    "price": 150
                }
            ]
        }
    ]
}

二、 后端处理逻辑

在后端，可以根据传入数据的 itemId 和 skuId 来区分新增、修改和删除。

2.1 新增操作

• 如果 itemId 或 skuId 为 null，表示这是一个新增的记录。

2.2 修改操作

• 如果 itemId 和 skuId 都存在，并且与数据库中的记录匹配，则表示这是一个修改操作。

2.3 删除操作

• 可以通过比较数据库中的数据和前端传递的数据，找出哪些商品和 SKU 在前端数据中没有出现，这些就是需要删除的项。

三. 代码实现示例

@Service
public class PackageService {

    @Autowired
    private PackageRepository packageRepository;

    @Autowired
    private ItemRepository itemRepository;

    @Autowired
    private SkuRepository skuRepository;

    @Transactional
    public void updatePackage(PackageDTO packageDTO) {
        // 1. 更新套餐信息
        PackageEntity packageEntity = packageRepository.findById(packageDTO.getPackageId())
                .orElseThrow(() -> new ResourceNotFoundException("该套餐不存在"+packageDTO.getPackageId()));

        packageEntity.setName(packageDTO.getPackageName());
        packageRepository.save(packageEntity);

        // 2. 更新商品信息
        List<ItemEntity> existingItems = itemRepository.findByPackageId(packageDTO.getPackageId());

        for (ItemDTO itemDTO : packageDTO.getItems()) {
            if (itemDTO.getItemId() == null) {
                // 新增商品
                ItemEntity newItem = new ItemEntity();
                newItem.setPackageId(packageEntity.getId());
                newItem.setName(itemDTO.getItemName());
                itemRepository.save(newItem);
                updateSkus(newItem.getId(), itemDTO.getSkus());
            } else {
                // 修改商品
                ItemEntity existingItem = itemRepository.findById(itemDTO.getItemId())
                        .orElseThrow(() -> new ResourceNotFoundException("该商品不存在"+itemDTO.getItemId()));
                existingItem.setName(itemDTO.getItemName());
                itemRepository.save(existingItem);
                updateSkus(existingItem.getId(), itemDTO.getSkus());
                existingItems.remove(existingItem);
            }
        }

        // 删除商品
        for (ItemEntity itemToDelete : existingItems) {
            skuRepository.deleteByItemId(itemToDelete.getId());
            itemRepository.delete(itemToDelete);
        }
    }

    private void updateSkus(Long itemId, List<SkuDTO> skus) {
        List<SkuEntity> existingSkus = skuRepository.findByItemId(itemId);

        for (SkuDTO skuDTO : skus) {
            if (skuDTO.getSkuId() == null) {
                // 新增 SKU
                SkuEntity newSku = new SkuEntity();
                newSku.setItemId(itemId);
                newSku.setName(skuDTO.getSkuName());
                newSku.setPrice(skuDTO.getPrice());
                skuRepository.save(newSku);
            } else {
                // 修改 SKU
                SkuEntity existingSku = skuRepository.findById(skuDTO.getSkuId())
                        .orElseThrow(() -> new ResourceNotFoundException("该SKU规格不存在"+skuDTO.getSkuId()));
                existingSku.setName(skuDTO.getSkuName());
                existingSku.setPrice(skuDTO.getPrice());
                skuRepository.save(existingSku);
                existingSkus.remove(existingSku);
            }
        }

        // 删除 SKU
        for (SkuEntity skuToDelete : existingSkus) {
            skuRepository.delete(skuToDelete);
        }
    }
}

四. 总结

• 新增： 通过判断 id 是否为 null 来判断是否为新增操作。
• 修改： 如果 id 存在且匹配，视为修改操作。
• 删除： 通过比较现有数据库记录与传入数据来判断需要删除的项。

这种方案能够有效处理复杂的增删改操作，确保数据的一致性。当然也可以结合算法进行处理，欢迎评论区讨论。
为了接口性能以及接口响应时间，减少对数据库的读写次数，可以考虑进行批量更新、批量新增处理。具体的可以根据实际业务场景进行分析，也欢迎一起交流讨论。关注我，为程序员职业生涯储能！！