互联网大厂Java面试实录：当严肃面试官遇上搞笑程序员谢飞机

互联网大厂Java面试实录：当严肃面试官遇上搞笑程序员谢飞机

面试场景设定

面试官 ：张总，某互联网大厂资深技术专家，10年Java开发经验 面试者 ：谢飞机，3年Java开发经验，自称"全栈工程师" 面试岗位 ：Java高级开发工程师 公司背景：某头部电商平台

---

第一轮：基础与电商场景

问题1：电商库存扣减

面试官：谢飞机，你好。我们公司是做电商平台的，首先问一个基础问题。在秒杀活动中，如何保证库存扣减的准确性？

谢飞机：这个简单！用Redis的decrement命令啊，Redis是单线程的，不会出现并发问题！

面试官：（微笑）思路不错，但不够全面。Redis确实是常用方案，但需要考虑更多细节。

问题2：分布式锁实现

面试官：那如果要用Redis实现分布式锁，你会怎么做？

谢飞机：用setnx命令啊！setnx key value，成功了就拿到锁了！

面试官：考虑过锁过期时间吗？如果业务执行时间超过锁过期时间怎么办？

谢飞机：呃...这个...设置长一点的时间？

问题3：消息队列应用

面试官：在订单创建成功后，需要通知库存系统、物流系统、营销系统等多个系统，你会怎么设计？

谢飞机：一个一个调用接口呗，用HTTP请求！

面试官：这样会有性能问题和一致性问题。我们继续下一轮。

---

第二轮：支付与微服务场景

问题4：支付系统设计

面试官：现在转到支付场景。支付系统需要保证数据一致性，你会如何设计支付流水和账户余额的更新？

谢飞机：用数据库事务啊！begin transaction，更新两个表，然后commit！

面试官：如果支付系统和账户系统是独立的微服务呢？

谢飞机：啊...那就...那就用HTTP调用，失败了就重试！

问题5：分布式事务

面试官：跨服务的分布式事务，你知道有哪些解决方案吗？

谢飞机：听说过2PC、3PC，但具体没怎么用过...

面试官：那了解过TCC、Saga或者消息队列最终一致性吗？

谢飞机：TCC是不是那个Try-Confirm-Cancel？具体怎么实现不太清楚...

问题6：服务熔断降级

面试官：在支付高峰期，如果某个依赖服务响应缓慢，如何保证支付主流程的可用性？

谢飞机：加个超时时间？超时就返回失败？

面试官：这样用户体验不好。我们看看下一轮。

---

第三轮：高并发与架构设计

问题7：缓存穿透问题

面试官：在商品详情页，如果查询一个不存在的商品ID，每次都会打到数据库，这就是缓存穿透。如何解决？

谢飞机：查不到就缓存空值！

面试官：（点头）这个回答不错！还有布隆过滤器也可以解决。

问题8：热点数据问题

面试官：双十一期间，某些爆款商品的访问量极大，缓存服务器可能扛不住，怎么办？

谢飞机：加机器！多部署几台Redis！

面试官：思路对，但具体怎么实现缓存集群？了解Redis Cluster或者Codis吗？

谢飞机：听说过Redis Cluster，但没实际部署过...

问题9：系统监控

面试官：最后，如何监控系统的健康状态？比如发现慢SQL、服务调用链追踪等。

谢飞机：看日志？用ELK？

面试官：ELK是日志收集，还需要更实时的监控。了解Prometheus+Grafana或者SkyWalking、Zipkin吗？

谢飞机：听说过，但没实际用过...

---

面试结束

面试官：好的，今天的面试就到这里。你的基础还不错，但在分布式系统和高并发场景下的经验还需要加强。我们会综合评估，有结果了HR会通知你。

谢飞机：谢谢张总！我会继续学习的！

---

问题详细解答与技术解析

问题1：电商库存扣减的准确性保障

业务场景

在秒杀、大促等场景下，同一商品可能被成千上万的用户同时抢购，必须保证：

1. 库存不会超卖
2. 扣减操作要快
3. 系统要能承受高并发

技术方案

方案一：数据库乐观锁

// 使用版本号控制
UPDATE product_stock 
SET stock = stock - 1, version = version + 1 
WHERE product_id = ? AND stock > 0 AND version = ?

方案二：Redis原子操作

// Lua脚本保证原子性
String script = "if redis.call('get', KEYS[1]) > '0' then " +
               "return redis.call('decr', KEYS[1]) " +
               "else return -1 end";
Long result = redisTemplate.execute(
    new DefaultRedisScript<>(script, Long.class),
    Collections.singletonList("stock:" + productId)
);

方案三：队列削峰 将请求放入消息队列（如Kafka），后台服务顺序处理，保证最终一致性。

问题2：Redis分布式锁完整实现

正确实现要点

1. 设置过期时间：防止死锁
2. 设置唯一值：防止误删其他线程的锁
3. 原子性操作：setnx和expire要原子执行
4. 锁续期：业务执行时间长时要自动续期

Redisson实现示例

RLock lock = redissonClient.getLock("order_lock:" + orderId);
try {
    // 尝试加锁，最多等待100秒，上锁后30秒自动解锁
    boolean isLock = lock.tryLock(100, 30, TimeUnit.SECONDS);
    if (isLock) {
        // 执行业务逻辑
    }
} finally {
    lock.unlock();
}

问题3：订单事件通知设计

事件驱动架构

使用消息队列实现事件驱动：

// 订单创建后发布事件
@Component
public class OrderEventPublisher {
    @Autowired
    private KafkaTemplate<String, Object> kafkaTemplate;
    
    public void publishOrderCreated(OrderCreatedEvent event) {
        kafkaTemplate.send("order-created-topic", event);
    }
}

// 库存系统消费事件
@KafkaListener(topics = "order-created-topic")
public void handleOrderCreated(OrderCreatedEvent event) {
    inventoryService.deductStock(event.getProductId(), event.getQuantity());
}

优势

1. 解耦：订单系统不直接依赖其他系统
2. 异步：提高响应速度
3. 削峰：流量高峰时消息队列可以缓冲
4. 重试机制：消费失败可以重试

问题4：支付系统分布式事务

TCC模式实现

Try阶段：预留资源

public boolean tryPayment(String orderId, BigDecimal amount) {
    // 冻结账户余额
    accountService.freezeBalance(userId, amount);
    // 创建支付预记录
    paymentService.createPrePayment(orderId, amount);
    return true;
}

Confirm阶段：确认执行

public boolean confirmPayment(String orderId) {
    // 扣减已冻结的余额
    accountService.deductBalance(userId, orderId);
    // 更新支付状态为成功
    paymentService.confirmPayment(orderId);
    return true;
}

Cancel阶段：取消回滚

public boolean cancelPayment(String orderId) {
    // 解冻账户余额
    accountService.unfreezeBalance(userId, orderId);
    // 更新支付状态为失败
    paymentService.cancelPayment(orderId);
    return true;
}

问题5：服务熔断降级

Resilience4j实现

// 定义熔断器配置
CircuitBreakerConfig config = CircuitBreakerConfig.custom()
    .failureRateThreshold(50) // 失败率阈值
    .waitDurationInOpenState(Duration.ofMillis(1000)) // 熔断后等待时间
    .slidingWindowSize(10) // 滑动窗口大小
    .build();

CircuitBreaker circuitBreaker = CircuitBreaker.of("paymentService", config);

// 使用熔断器调用服务
Supplier<String> decoratedSupplier = CircuitBreaker
    .decorateSupplier(circuitBreaker, () -> {
        // 调用支付服务
        return paymentService.pay(order);
    });

// 添加降级逻辑
try {
    return decoratedSupplier.get();
} catch (Exception e) {
    // 熔断或异常时执行降级逻辑
    return fallbackPayment(order);
}

问题6：缓存穿透解决方案

方案一：缓存空值

public Product getProduct(String productId) {
    // 先从缓存查询
    Product product = redisTemplate.opsForValue().get("product:" + productId);
    
    if (product != null) {
        // 如果是空值标记
        if (product.getId() == null) {
            return null; // 直接返回null，不查数据库
        }
        return product;
    }
    
    // 缓存不存在，查数据库
    product = productDao.findById(productId);
    
    if (product == null) {
        // 数据库不存在，缓存空值（设置较短过期时间）
        Product emptyProduct = new Product();
        redisTemplate.opsForValue().set(
            "product:" + productId, 
            emptyProduct, 
            5, TimeUnit.MINUTES
        );
        return null;
    }
    
    // 缓存真实数据
    redisTemplate.opsForValue().set(
        "product:" + productId, 
        product, 
        30, TimeUnit.MINUTES
    );
    return product;
}

方案二：布隆过滤器

// 初始化布隆过滤器
BloomFilter<String> bloomFilter = BloomFilter.create(
    Funnels.stringFunnel(Charset.defaultCharset()),
    1000000, // 预期元素数量
    0.01 // 误判率
);

// 预热：将所有有效商品ID加入布隆过滤器
List<String> allProductIds = productDao.getAllProductIds();
for (String id : allProductIds) {
    bloomFilter.put(id);
}

// 查询时先检查布隆过滤器
public Product getProductWithBloomFilter(String productId) {
    if (!bloomFilter.mightContain(productId)) {
        return null; // 肯定不存在
    }
    
    // 可能存在，继续查缓存和数据库
    return getProduct(productId);
}

问题7：热点数据缓存方案

Redis Cluster部署

架构设计：

1. 分片存储：数据分散在多个节点
2. 主从复制：每个分片有主从节点
3. 自动故障转移：主节点故障时从节点升级

本地缓存+Redis多级缓存

// 使用Caffeine作为本地缓存
LoadingCache<String, Product> localCache = Caffeine.newBuilder()
    .maximumSize(10000) // 最大缓存数量
    .expireAfterWrite(10, TimeUnit.SECONDS) // 写入后过期时间
    .build(key -> {
        // 本地缓存未命中时，查询Redis
        return getFromRedis(key);
    });

public Product getProductWithMultiLevelCache(String productId) {
    // 1. 先查本地缓存
    Product product = localCache.get(productId);
    
    if (product == null || product.getId() == null) {
        // 2. 本地缓存未命中，查Redis
        product = redisTemplate.opsForValue().get("product:" + productId);
        
        if (product == null) {
            // 3. Redis未命中，查数据库
            product = productDao.findById(productId);
            if (product != null) {
                // 回填Redis
                redisTemplate.opsForValue().set(
                    "product:" + productId, 
                    product, 
                    5, TimeUnit.MINUTES
                );
            }
        }
        
        // 回填本地缓存
        if (product != null) {
            localCache.put(productId, product);
        }
    }
    
    return product;
}

问题8：系统监控方案

Spring Boot + Prometheus + Grafana

1. 添加依赖

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

2. 配置application.yml

management:
  endpoints:
    web:
      exposure:
        include: health,info,prometheus,metrics
  metrics:
    export:
      prometheus:
        enabled: true

3. 自定义指标

@Component
public class OrderMetrics {
    private final MeterRegistry meterRegistry;
    private final Counter orderCounter;
    
    public OrderMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.orderCounter = Counter.builder("order.created")
            .description("Number of orders created")
            .tag("application", "order-service")
            .register(meterRegistry);
    }
    
    public void incrementOrderCount() {
        orderCounter.increment();
    }
}

4. 链路追踪 - SkyWalking配置

# agent.config
agent.service_name=${SW_AGENT_NAME:order-service}
collector.backend_service=${SW_AGENT_COLLECTOR_BACKEND_SERVICES:127.0.0.1:11800}

总结

通过这次面试对话，我们可以看到：

面试考察重点

1. 基础扎实：对Java核心、Spring框架的掌握程度
2. 场景理解：能否将技术与业务场景结合
3. 架构思维：面对复杂问题的系统设计能力
4. 学习能力：对新技术的了解和学习意愿

技术成长建议

1. 深入理解原理：不要只停留在使用层面
2. 多实践：理论知识要通过项目实践巩固
3. 关注架构：从单机应用到分布式系统的思维转变
4. 持续学习：技术更新快，要保持学习热情

希望这篇文章能帮助Java开发者更好地准备互联网大厂的技术面试！