跳至主要內容

Java 面试精讲：价格同步与下单冲突的优雅处理方案

Corey2025/12/30大约 15 分钟面试题面试题

来源：Java 面试精讲：价格同步与下单冲突的优雅处理方案

在 Java 后端面试中，“分布式系统下的价格一致性” 与 “用户下单冲突处理” 是高频考点 —— 它既考察候选人对分布式数据一致性的技术理解，也检验业务与技术结合的落地能力。本文将从问题场景出发，拆解核心矛盾，结合 Java 技术栈（Spring Boot、Kafka、MyBatis 等）提供完整解决方案，包含关键代码实现与设计思路，助力面试通关。

一、问题场景与核心矛盾（面试题背景）

1.1 业务场景

某售票公司涉及两类价格管理角色：

  • 主站部门：维护商品官方基准价（如初始 100 元，旺季调整为 95 元），是价格体系的 “源头”；
  • 分销部门：对接美团等外部分销商，维护渠道专属分销价（如初始 98 元，同步调整为 93 元）；
  • 技术协作：主站与分销部通过内部微服务调用同步数据，分销部与美团通过 API 接口对接。

1.2 核心矛盾（面试题核心考点）

矛盾 1：价格同步的 “准” 与 “快”

主站修改官方价、分销部修改分销价后，需确保主站→分销部→外部分销商（美团） 三级节点价格一致，避免因同步延迟 / 错误导致 “用户看到旧价、下单价格混乱”。

矛盾 2：用户下单的价格冲突

用户在美团浏览时看到旧价（如 100 元），停留期间价格已更新（如 93 元），下单时如何平衡：

  • 不损害用户体验（避免 “下单即涨价”）；
  • 不损害企业利益（避免 “下单即降价导致亏损”）；
  • 不引发业务纠纷（清晰告知价格变化）。

image

二、价格同步的技术保障

价格同步的核心思路是 “内部强一致 + 外部最终一致”，结合 Java 技术栈实现 “不丢、不错、不延迟”。

2.1 内部同步：主站与分销部的实时协作

主站与分销部同属公司内部系统，采用 “事件驱动 + 幂等设计 + 微服务调用” 三重保障，确保价格变更实时同步。

2.1.1 技术选型

  • 消息队列：Kafka（异步通知，确保消息不丢失）；
  • 微服务框架：Spring Cloud（REST/gRPC 调用，实时兜底）；
  • 幂等保障：基于 “商品 ID + 价格版本号” 实现。

2.1.2 核心代码实现

① 定义价格变更事件（事件驱动的核心载体）
// 价格变更事件实体（Kafka消息体）
@Data
public class PriceChangeEvent implements Serializable {
    // 商品唯一标识
    private Long productId;
    // 新价格（主站官方价/分销价）
    private BigDecimal newPrice;
    // 价格类型：OFFICIAL(官方价)、DISTRIBUTION(分销价)
    private PriceType priceType;
    // 价格版本号（幂等核心：时间戳+随机数，确保唯一）
    private String priceVersion;
    // 变更时间
    private LocalDateTime changeTime;

    public enum PriceType {
        OFFICIAL, DISTRIBUTION
    }
}
② 主站发送价格变更事件（Kafka 生产者）

主站修改官方价后，通过 Kafka 异步通知分销部，避免同步调用阻塞主流程：

@Service
public class OfficialPriceService {
    @Autowired
    private KafkaTemplate<String, PriceChangeEvent> kafkaTemplate;
    @Autowired
    private OfficialPriceMapper officialPriceMapper;

    // 主站修改官方价并发送事件
    public void updateOfficialPrice(Long productId, BigDecimal newPrice) {
        // 1. 数据库更新官方价（MyBatis）
        OfficialPriceDO priceDO = new OfficialPriceDO();
        priceDO.setProductId(productId);
        priceDO.setOfficialPrice(newPrice);
        priceDO.setPriceVersion(generateVersion()); // 生成唯一版本号
        priceDO.setUpdateTime(LocalDateTime.now());
        officialPriceMapper.updateById(priceDO);

        // 2. 发送价格变更事件到Kafka（主题：price-change-topic）
        PriceChangeEvent event = new PriceChangeEvent();
        event.setProductId(productId);
        event.setNewPrice(newPrice);
        event.setPriceType(PriceChangeEvent.PriceType.OFFICIAL);
        event.setPriceVersion(priceDO.getPriceVersion());
        event.setChangeTime(LocalDateTime.now());
        
        kafkaTemplate.send("price-change-topic", productId.toString(), event);
        log.info("主站发送官方价变更事件：productId={}, newPrice={}", productId, newPrice);
    }

    // 生成唯一版本号：时间戳（毫秒）+ 3位随机数
    private String generateVersion() {
        return System.currentTimeMillis() + String.format("%03d", new Random().nextInt(1000));
    }
}
③ 分销部消费事件并处理（Kafka 消费者 + 幂等校验）

分销部接收事件后，需先校验版本号（避免重复处理），再更新本地分销价：

@Service
public class DistributionPriceConsumer {
    @Autowired
    private DistributionPriceMapper distributionPriceMapper;

    // 监听Kafka主题，消费主站价格变更事件
    @KafkaListener(topics = "price-change-topic", groupId = "distribution-group")
    public void consumePriceChangeEvent(ConsumerRecord<String, PriceChangeEvent> record) {
        PriceChangeEvent event = record.value();
        Long productId = event.getProductId();
        String newVersion = event.getPriceVersion();

        // 1. 幂等校验：查询当前分销价的版本号，仅处理新版本
        DistributionPriceDO currentDO = distributionPriceMapper.selectByProductId(productId);
        if (currentDO != null && newVersion.compareTo(currentDO.getOfficialPriceVersion()) <= 0) {
            log.warn("幂等校验不通过：事件版本{} <= 当前版本{}，忽略处理", newVersion, currentDO.getOfficialPriceVersion());
            return;
        }

        // 2. 更新分销价（基于官方价联动调整，如保持3元差价）
        BigDecimal newDistributionPrice = event.getNewPrice().subtract(new BigDecimal("3"));
        DistributionPriceDO updateDO = new DistributionPriceDO();
        updateDO.setProductId(productId);
        updateDO.setDistributionPrice(newDistributionPrice);
        updateDO.setOfficialPriceVersion(newVersion); // 关联官方价版本号
        updateDO.setUpdateTime(LocalDateTime.now());
        
        if (currentDO == null) {
            distributionPriceMapper.insert(updateDO);
        } else {
            updateDO.setId(currentDO.getId());
            distributionPriceMapper.updateById(updateDO);
        }

        // 3. 触发外部分销商同步（后续章节实现）
        syncToExternalPlatform(productId, newDistributionPrice, newVersion);
        log.info("分销部处理官方价变更：productId={}, 新分销价={}", productId, newDistributionPrice);
    }

    // 触发外部分销商同步（暂留接口，后续实现）
    private void syncToExternalPlatform(Long productId, BigDecimal price, String version) {
        // TODO: 调用美团API同步价格
    }
}
④ 微服务调用兜底（实时同步场景）

若需强实时同步（如促销活动紧急改价），可补充 Spring Cloud OpenFeign 调用，结合重试机制：

// 分销部提供的价格同步接口
@RestController
@RequestMapping("/api/distribution/price")
public class DistributionPriceController {
    @Autowired
    private DistributionPriceService distributionPriceService;

    // 主站通过Feign调用此接口，实时同步价格
    @PostMapping("/sync")
    public Result&lt;?> syncOfficialPrice(@RequestBody PriceSyncDTO syncDTO) {
        distributionPriceService.syncFromOfficial(syncDTO);
        return Result.success();
    }
}

// 主站Feign客户端（结合重试机制）
@FeignClient(name = "distribution-service", fallback = DistributionPriceFallback.class)
public interface DistributionPriceFeignClient {
    @PostMapping("/api/distribution/price/sync")
    Result&lt;?> syncOfficialPrice(@RequestBody PriceSyncDTO syncDTO);
}

// 重试配置（Spring Retry）
@Configuration
@EnableRetry
public class RetryConfig {
    @Bean
    public Retryer retryer() {
        // 重试3次，间隔1s、3s、5s递增
        return RetryerBuilder.newBuilder()
                .retryIfExceptionOfType(FeignException.class)
                .withWaitStrategy(WaitStrategies.incrementingWait(1, TimeUnit.SECONDS, 2, TimeUnit.SECONDS))
                .withStopStrategy(StopStrategies.stopAfterAttempt(3))
                .build();
    }
}

image

2.2 外部同步：分销部与外部分销商（美团）的最终一致

外部对接涉及跨公司系统，网络不稳定、接口故障概率高，需通过 “主动推送 + 定时补偿 + 版本控制” 实现最终一致。

2.2.1 技术选型

  • API 调用：RestTemplate（对接美团开放平台）；
  • 定时任务：Spring Schedule（定期对账）；
  • 数据存储：MySQL（记录同步状态，便于追溯）。

2.2.2 核心代码实现

① API 主动推送价格（分销部→美团）
@Service
public class MeiTuanSyncService {
    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private DistributionPriceSyncLogMapper syncLogMapper;

    // 美团开放平台接口地址
    private static final String MEITUAN_PRICE_UPDATE_URL = "https://open.meituan.com/api/v1/ticket/price/update";
    // 美团平台AppKey（实际从配置中心获取）
    private static final String MEITUAN_APP_KEY = "your-app-key";
    // 签名密钥（实际从配置中心获取）
    private static final String MEITUAN_SECRET = "your-secret";

    // 同步分销价到美团
    public void syncPriceToMeiTuan(Long productId, BigDecimal distributionPrice, String priceVersion) {
        // 1. 构建美团API请求参数（含签名，确保安全）
        MeiTuanPriceRequest request = new MeiTuanPriceRequest();
        request.setProductId(productId.toString());
        request.setPrice(distributionPrice.toString());
        request.setPriceVersion(priceVersion);
        request.setTimestamp(System.currentTimeMillis());
        request.setSign(generateSign(request)); // 生成签名，防止参数篡改

        // 2. 调用美团API（同步推送）
        try {
            ResponseEntity&lt;MeiTuanPriceResponse&gt; response = restTemplate.postForEntity(
                    MEITUAN_PRICE_UPDATE_URL,
                    request,
                    MeiTuanPriceResponse.class
            );

            // 3. 记录同步日志（成功/失败）
            DistributionPriceSyncLogDO logDO = buildSyncLog(productId, distributionPrice, priceVersion, request, response);
            syncLogMapper.insert(logDO);

            // 4. 处理失败场景（触发重试）
            if (response.getBody() == null || !"SUCCESS".equals(response.getBody().getCode())) {
                throw new RuntimeException("美团价格同步失败：" + response.getBody().getMsg());
            }
            log.info("美团价格同步成功：productId={}, 价格={}", productId, distributionPrice);
        } catch (Exception e) {
            // 记录失败日志，后续定时任务补偿
            DistributionPriceSyncLogDO failLog = buildFailSyncLog(productId, distributionPrice, priceVersion, request, e.getMessage());
            syncLogMapper.insert(failLog);
            log.error("美团价格同步失败：productId={}", productId, e);
            throw e; // 触发上游重试（如Feign fallback）
        }
    }

    // 生成美团API签名（按美团要求的签名算法）
    private String generateSign(MeiTuanPriceRequest request) {
        // 1. 参数按ASCII排序
        Map<String, String> paramMap = new TreeMap<>();
        paramMap.put("productId", request.getProductId());
        paramMap.put("price", request.getPrice());
        paramMap.put("priceVersion", request.getPriceVersion());
        paramMap.put("timestamp", request.getTimestamp().toString());
        paramMap.put("appKey", MEITUAN_APP_KEY);

        // 2. 拼接参数+密钥，MD5加密
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<String, String> entry : paramMap.entrySet()) {
            sb.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
        }
        sb.append("secret=").append(MEITUAN_SECRET);
        return DigestUtils.md5DigestAsHex(sb.toString().getBytes(StandardCharsets.UTF_8));
    }

    // 构建同步日志（省略buildSyncLog、buildFailSyncLog实现，核心记录参数、响应、状态）
}
② 定时任务对账补偿（确保最终一致）

每 5 分钟执行一次对账，对比分销部本地价格与美团当前价格，不一致则自动补同步：

@Service
public class PriceReconciliationService {
    @Autowired
    private DistributionPriceMapper distributionPriceMapper;
    @Autowired
    private MeiTuanSyncService meiTuanSyncService;
    @Autowired
    private RestTemplate restTemplate;

    // 美团价格查询接口
    private static final String MEITUAN_PRICE_QUERY_URL = "https://open.meituan.com/api/v1/ticket/price/query?productId={productId}&appKey={appKey}&sign={sign}";

    // 定时对账：每5分钟执行一次（Spring Schedule）
    @Scheduled(cron = "0 0/5 * * * ?")
    public void reconcilePriceWithMeiTuan() {
        log.info("开始美团价格对账任务");
        // 1. 查询所有分销商品（分页处理，避免数据量过大）
        PageHelper.startPage(1, 100);
        List&lt;DistributionPriceDO&gt; priceList = distributionPriceMapper.selectAll();

        for (DistributionPriceDO priceDO : priceList) {
            Long productId = priceDO.getProductId();
            BigDecimal localPrice = priceDO.getDistributionPrice();
            String localVersion = priceDO.getPriceVersion();

            try {
                // 2. 调用美团接口查询当前价格
                String sign = generateQuerySign(productId); // 生成查询签名（类似更新签名逻辑）
                ResponseEntity&lt;MeiTuanPriceQueryResponse&gt; response = restTemplate.getForEntity(
                        MEITUAN_PRICE_QUERY_URL,
                        MeiTuanPriceQueryResponse.class,
                        productId, MEITUAN_APP_KEY, sign
                );

                // 3. 对比本地价格与美团价格
                if (response.getBody() != null && "SUCCESS".equals(response.getBody().getCode())) {
                    BigDecimal meiTuanPrice = new BigDecimal(response.getBody().getPrice());
                    String meiTuanVersion = response.getBody().getPriceVersion();

                    // 价格不一致或版本落后，触发补同步
                    if (!localPrice.equals(meiTuanPrice) || !localVersion.equals(meiTuanVersion)) {
                        log.warn("价格对账不一致：productId={}, 本地价={}, 美团价={}", productId, localPrice, meiTuanPrice);
                        meiTuanSyncService.syncPriceToMeiTuan(productId, localPrice, localVersion);
                    }
                }
            } catch (Exception e) {
                log.error("价格对账失败：productId={}", productId, e);
                // 单个商品失败不影响整体任务，继续处理下一个
                continue;
            }
        }
        log.info("美团价格对账任务结束");
    }

    // 生成查询签名（逻辑同更新签名，省略实现）
    private String generateQuerySign(Long productId) { /* ... */ }
}
③ 缓存刷新（避免前端展示旧价）

主站、分销部、美团均可能存在价格缓存，改价后需主动刷新：

@Service
public class PriceCacheService {
    @Autowired
    private RedisTemplate<String, BigDecimal> redisTemplate;

    // 缓存Key前缀
    private static final String CACHE_KEY_PREFIX = "price:";

    // 删除主站/分销部旧缓存
    public void deletePriceCache(Long productId, PriceType priceType) {
        String cacheKey = CACHE_KEY_PREFIX + priceType.name().toLowerCase() + ":" + productId;
        redisTemplate.delete(cacheKey);
        log.info("删除价格缓存：key={}", cacheKey);
    }

    // 美团API请求时添加“强制刷新标识”
    public void addForceRefreshParam(Map<String, Object> paramMap) {
        paramMap.put("forceRefresh", "true"); // 美团接口根据此参数强制刷新缓存
    }

    public enum PriceType {
        OFFICIAL, DISTRIBUTION
    }
}

image

2.3 价格同步完整流程（整合内部 + 外部）

  1. 主站改价：运营修改官方价→生成价格变更事件→MQ 发送事件→删除主站缓存；
  2. 分销部接收：MQ 消费者消费事件→幂等校验→更新分销价→删除分销部缓存；
  3. 外部同步：分销部调用美团 API→推送新价格 + 版本号→记录同步日志；
  4. 对账补偿：定时任务查询美团价格→对比本地价格→不一致则补同步；
  5. 缓存兜底：美团接收 API 请求→强制刷新缓存→用户看到最新价。

image

三、下单冲突的优雅处理

用户下单冲突的核心思路是 “实时校验 + 用户透明 + 利益平衡”，在 Java 代码中需实现 “价格校验、动态调整、日志追溯” 三大能力。

3.1 实时价格校验（下单核心拦截）

用户在美团点击 “下单” 时，美团需调用分销部的价格校验接口，确保下单价格与最新价格一致。

核心代码实现（分销部价格校验接口）

@RestController
@RequestMapping("/api/distribution/order")
public class OrderPriceController {
    @Autowired
    private DistributionPriceMapper distributionPriceMapper;
    @Autowired
    private PriceCacheService priceCacheService;
    @Autowired
    private OrderPriceLogMapper orderPriceLogMapper;

    /**
     * 美团下单前价格校验接口
     * @param request 下单请求（含商品ID、用户看到的旧价）
     * @return 校验结果（是否通过、最新价格）
     */
    @PostMapping("/validatePrice")
    public Result&lt;PriceValidateResponse&gt; validatePrice(@RequestBody PriceValidateRequest request) {
        Long productId = request.getProductId();
        BigDecimal userSeePrice = request.getUserSeePrice();
        String meiTuanOrderNo = request.getMeiTuanOrderNo();

        // 1. 查询最新分销价（优先查缓存，缓存未命中查DB）
        String cacheKey = PriceCacheService.CACHE_KEY_PREFIX + "distribution:" + productId;
        BigDecimal latestPrice = redisTemplate.opsForValue().get(cacheKey);
        if (latestPrice == null) {
            DistributionPriceDO priceDO = distributionPriceMapper.selectByProductId(productId);
            if (priceDO == null) {
                return Result.fail("商品不存在");
            }
            latestPrice = priceDO.getDistributionPrice();
            // 缓存回写（设置5分钟过期，避免缓存与DB长期不一致）
            redisTemplate.opsForValue().set(cacheKey, latestPrice, 5, TimeUnit.MINUTES);
        }

        // 2. 记录价格校验日志（便于后续追溯）
        OrderPriceLogDO logDO = new OrderPriceLogDO();
        logDO.setMeiTuanOrderNo(meiTuanOrderNo);
        logDO.setProductId(productId);
        logDO.setUserSeePrice(userSeePrice);
        logDO.setLatestPrice(latestPrice);
        logDO.setValidateTime(LocalDateTime.now());
        orderPriceLogMapper.insert(logDO);

        // 3. 价格对比与处理逻辑
        PriceValidateResponse response = new PriceValidateResponse();
        int priceCompare = userSeePrice.compareTo(latestPrice);
        if (priceCompare == 0) {
            // 价格一致：允许下单
            response.setValid(true);
            response.setMessage("价格一致，可正常下单");
            response.setFinalPrice(latestPrice);
        } else if (priceCompare > 0) {
            // 用户看到旧价 > 最新价：自动按最新价下单（让利用户，提升体验）
            response.setValid(true);
            response.setMessage("价格已更新，为您节省" + userSeePrice.subtract(latestPrice) + "元");
            response.setFinalPrice(latestPrice);
        } else {
            // 用户看到旧价 < 最新价：拒绝下单，提示用户更新（避免企业亏损）
            response.setValid(false);
            response.setMessage("当前商品价格已调整为" + latestPrice + "元，请刷新页面后重新下单");
            response.setFinalPrice(latestPrice);
        }

        return Result.success(response);
    }

    // 请求/响应实体（省略getter/setter）
    @Data
    public static class PriceValidateRequest {
        private Long productId;
        private BigDecimal userSeePrice;
        private String meiTuanOrderNo; // 美团订单号（唯一标识）
    }

    @Data
    public static class PriceValidateResponse {
        private boolean valid; // 是否允许下单
        private String message; // 提示信息
        private BigDecimal finalPrice; // 最终价格（一致则为旧价，不一致则为最新价）
    }
}

image

3.2 分销部的优雅处理策略

除实时校验外，需通过 “价格补偿、订单回滚、日志追溯” 兜底，应对极端场景。

3.2.1 价格差异补偿（自动调整）

若用户已下单但价格不一致，通过订单状态机自动处理：

@Service
public class OrderCompensateService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private OrderPriceLogMapper orderPriceLogMapper;

    // 订单支付前的价格二次补偿
    @Transactional
    public void compensateOrderPrice(Long orderId) {
        // 1. 查询订单信息与最新价格
        OrderDO orderDO = orderMapper.selectById(orderId);
        if (orderDO == null || !"PENDING_PAY".equals(orderDO.getStatus())) {
            log.warn("订单无需补偿：orderId={}, 状态={}", orderId, orderDO.getStatus());
            return;
        }

        // 2. 查询最新分销价
        DistributionPriceDO priceDO = distributionPriceMapper.selectByProductId(orderDO.getProductId());
        BigDecimal latestPrice = priceDO.getDistributionPrice();
        BigDecimal orderPrice = orderDO.getPayAmount();

        // 3. 价格差异处理
        if (!orderPrice.equals(latestPrice)) {
            log.info("订单价格补偿：orderId={}, 原价格={}, 最新价={}", orderId, orderPrice, latestPrice);
            // 3.1 更新订单价格
            orderDO.setPayAmount(latestPrice);
            orderDO.setUpdateTime(LocalDateTime.now());
            orderMapper.updateById(orderDO);

            // 3.2 记录补偿日志
            OrderPriceLogDO logDO = new OrderPriceLogDO();
            logDO.setOrderId(orderId);
            logDO.setProductId(orderDO.getProductId());
            logDO.setUserSeePrice(orderPrice);
            logDO.setLatestPrice(latestPrice);
            logDO.setValidateTime(LocalDateTime.now());
            logDO.setCompensateFlag(1); // 标记为已补偿
            orderPriceLogMapper.insert(logDO);

            // 3.3 通知用户（如短信/推送：“您的订单价格已更新为XX元”）
            notifyUser(orderDO.getUserId(), orderId, latestPrice);
        }
    }

    // 通知用户（省略实现，可对接短信/推送服务）
    private void notifyUser(Long userId, Long orderId, BigDecimal latestPrice) { /* ... */ }
}

3.2.2 订单回滚（极端错误兜底）

若价格校验失败但订单已生成，通过事务回滚确保数据一致：

@Service
public class OrderRollbackService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private OrderItemMapper orderItemMapper;

    // 订单价格错误时回滚
    @Transactional(rollbackFor = Exception.class)
    public void rollbackOrder(Long orderId, String reason) {
        // 1. 查询订单状态（仅回滚未支付订单）
        OrderDO orderDO = orderMapper.selectById(orderId);
        if (orderDO == null || !"PENDING_PAY".equals(orderDO.getStatus())) {
            throw new RuntimeException("订单无法回滚：orderId=" + orderId + ", 状态=" + orderDO.getStatus());
        }

        // 2. 删除订单与订单项（或更新状态为“已取消”）
        orderItemMapper.deleteByOrderId(orderId);
        orderMapper.deleteById(orderId);

        // 3. 记录回滚日志
        OrderRollbackLogDO logDO = new OrderRollbackLogDO();
        logDO.setOrderId(orderId);
        logDO.setReason(reason);
        logDO.setRollbackTime(LocalDateTime.now());
        orderRollbackLogMapper.insert(logDO);

        log.info("订单回滚成功：orderId={}, 原因={}", orderId, reason);
    }
}

image

3.3 下单冲突完整流程

  1. 用户浏览：美团页面每 30 秒异步调用分销部接口刷新价格（前端优化）；
  2. 点击下单：美团前端先预校验价格，不一致则先更新页面；
  3. 实时校验：美团调用分销部validatePrice接口，获取最新价格与处理意见；
  4. 订单生成：价格一致则生成订单，不一致则提示用户；
  5. 支付兜底：支付前二次校验价格，差异则补偿或回滚；
  6. 日志追溯：所有操作记入日志，客服可快速查因。

image

四、方案总结与面试考点提炼

4.1 核心设计思路

问题类型
技术方案
核心目标

内部价格同步
事件驱动（Kafka）+ 幂等设计
实时、可靠、不重复

外部价格同步
API 回调 + 定时对账 + 版本控制
最终一致、故障补偿

用户下单冲突
实时校验 + 价格补偿 + 订单回滚
体验优先、利益平衡

缓存一致性
主动删除缓存 + 强制刷新标识
避免用户看到旧价

4.2 面试高频考点

  1. 幂等性实现：如何通过 “版本号 + 时间戳” 避免重复处理？（结合本文PriceChangeEvent的priceVersion字段）；
  2. 消息队列可靠性：Kafka 如何确保消息不丢失？（生产者确认、消费者手动提交 offset、消息持久化）；
  3. 分布式一致性：外部同步为何用 “最终一致” 而非 “强一致”？（跨公司系统无法实现强一致，需平衡性能与可靠性）；
  4. 异常处理：若美团 API 调用失败，如何兜底？（定时对账补偿、重试机制、日志记录）；
  5. 用户体验：如何避免 “下单即涨价” 引发投诉？（实时校验、透明提示、价格锁定可选方案）。

image

五、拓展思考（面试加分项）

  1. 价格锁定机制：促销场景下，可给用户浏览时的价格加 “5 分钟锁定”（Redis 设置过期时间），期间改价仍按锁定价下单；
  2. 流量控制：价格校验接口若被高频调用，可通过 Redis 缓存校验结果（短期有效），减少 DB 压力；
  3. 多渠道适配：若对接多个分销商（美团、携程），可抽象PriceSyncStrategy接口，按渠道实现不同同步逻辑（策略模式）。

通过本文的方案与代码实现，不仅能应对面试中的技术提问，更能在实际项目中落地 “价格一致性” 与 “下单冲突处理”，体现 Java 后端工程师的技术深度与业务思维。