🚀 商城等高并发场景架构设计

1. 高并发挑战与设计原则

1.1 高并发场景的核心挑战

流量峰值：秒杀、促销活动导致瞬时流量激增（如双11达到54.4万笔/秒）
数据一致性：库存超卖、订单重复支付等业务一致性难题
系统可用性：99.99%高可用要求，故障自动恢复与降级
性能瓶颈：数据库IO、网络带宽、计算资源限制

1.2 架构设计原则

分层解耦：前端/网关/服务/数据层分离
冗余设计：多机房部署、集群化、无状态服务
弹性伸缩：基于流量预测的自动扩缩容
故障隔离：熔断、降级、限流机制

2. 分层架构设计

2.1 整体架构图

2.2 接入层设计

2.2.1 四层/七层负载均衡

// Nginx配置示例：加权轮询负载均衡
upstream mall_cluster {
    server 192.168.1.10:8000 weight=3;  // 权重配置
    server 192.168.1.11:8000 weight=2;
    server 192.168.1.12:8000 weight=1;
    
    // 健康检查配置
    check interval=3000 rise=2 fall=5 timeout=1000;
}

server {
    listen       80;
    server_name  mall.example.com;
    
    // 静态资源缓存
    location ~* \.(jpg|jpeg|png|gif|css|js)$ {
        expires 7d;
        add_header Cache-Control public;
    }
    
    // API反向代理
    location /api/ {
        proxy_pass http://mall_cluster;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

2.2.2 DNS智能解析

基于地理位置的DNS解析优化
故障自动切换：A记录健康检查

2.3 网关层设计

2.3.1 Spring Cloud Gateway配置

spring:
  cloud:
    gateway:
      routes:
        - id: product_route
          uri: lb://product-service
          predicates:
            - Path=/api/products/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 100  # 每秒令牌数
                redis-rate-limiter.burstCapacity: 200 # 最大突发流量
            - name: CircuitBreaker
              args:
                name: productCircuitBreaker
                fallbackUri: forward:/fallback/product

2.3.2 网关核心功能

身份认证：JWT令牌验证
流量控制：令牌桶限流算法
服务路由：动态路由配置
安全防护：SQL注入/XSS过滤

2.4 业务服务层

2.4.1 微服务拆分策略

2.4.2 服务通信设计

// Feign客户端声明式调用示例
@FeignClient(name = "inventory-service", 
             configuration = FeignConfig.class,
             fallback = InventoryServiceFallback.class)
public interface InventoryService {
    
    @PostMapping("/inventory/deduct")
    Response<Boolean> deductStock(@RequestBody StockDeductRequest request);
    
    @GetMapping("/inventory/{skuId}")
    Response<Integer> getStock(@PathVariable("skuId") String skuId);
}

// 熔断降级实现
@Component
public class InventoryServiceFallback implements InventoryService {
    @Override
    public Response<Boolean> deductStock(StockDeductRequest request) {
        // 降级逻辑：记录日志并返回默认值
        log.warn("库存服务降级，skuId: {}", request.getSkuId());
        return Response.fail("服务暂时不可用");
    }
}

3. 数据层架构

3.1 缓存架构设计

3.1.1 多级缓存体系

3.1.2 Redis集群配置

# Redis哨兵模式配置
spring:
  redis:
    sentinel:
      master: mall-master
      nodes: 
        - 192.168.1.20:26379
        - 192.168.1.21:26379
        - 192.168.1.22:26379
    lettuce:
      pool:
        max-active: 8
        max-wait: -1ms
        max-idle: 8
        min-idle: 0

3.1.3 缓存策略代码示例

@Service
public class ProductServiceImpl implements ProductService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    private static final String PRODUCT_CACHE_KEY = "product:";
    private static final long CACHE_EXPIRE = 3600; // 1小时
    
    @Cacheable(value = "products", key = "#productId")
    public Product getProductById(Long productId) {
        // 缓存穿透解决方案：布隆过滤器前置校验
        if (!bloomFilter.mightContain(productId)) {
            return null;
        }
        
        // 尝试从缓存获取
        String cacheKey = PRODUCT_CACHE_KEY + productId;
        Product product = (Product) redisTemplate.opsForValue().get(cacheKey);
        
        if (product != null) {
            return product;
        }
        
        // 缓存击穿解决方案：互斥锁
        String lockKey = "lock:" + cacheKey;
        try {
            if (redisTemplate.opsForValue().setIfAbsent(lockKey, "1", 30, TimeUnit.SECONDS)) {
                // 数据库查询
                product = productMapper.selectById(productId);
                if (product != null) {
                    // 写入缓存
                    redisTemplate.opsForValue().set(cacheKey, product, CACHE_EXPIRE, TimeUnit.SECONDS);
                } else {
                    // 缓存空值防止穿透
                    redisTemplate.opsForValue().set(cacheKey, null, 300, TimeUnit.SECONDS);
                }
                return product;
            } else {
                // 等待重试
                Thread.sleep(100);
                return getProductById(productId);
            }
        } finally {
            redisTemplate.delete(lockKey);
        }
    }
}

3.2 数据库架构

3.2.1 分库分表设计

-- 订单表分表策略（按用户ID哈希）
CREATE TABLE orders_0 (
    id BIGINT PRIMARY KEY,
    user_id BIGINT NOT NULL,
    order_no VARCHAR(32) NOT NULL,
    amount DECIMAL(10,2),
    -- 其他字段...
    INDEX idx_user_id(user_id)
) ENGINE=InnoDB PARTITION BY HASH(user_id % 16);

-- 分库分表中间件配置（ShardingSphere）
spring:
  shardingsphere:
    datasource:
      names: ds0,ds1
      ds0: ... # 数据源配置
      ds1: ...
    rules:
      sharding:
        tables:
          orders:
            actualDataNodes: ds${0..1}.orders_${0..15}
            tableStrategy:
              standard:
                shardingColumn: user_id
                shardingAlgorithmName: order_table_hash
        shardingAlgorithms:
          order_table_hash:
            type: INLINE
            props:
              algorithm-expression: orders_${user_id % 16}

3.2.2 读写分离配置

# MyBatis多数据源配置
@Configuration
@MapperScan(basePackages = "com.mall.mapper", sqlSessionTemplateRef = "sqlSessionTemplate")
public class DataSourceConfig {
    
    @Bean(name = "masterDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSource masterDataSource() {
        return DruidDataSourceBuilder.create().build();
    }
    
    @Bean(name = "slaveDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public DataSource slaveDataSource() {
        return DruidDataSourceBuilder.create().build();
    }
    
    @Bean(name = "dynamicDataSource")
    public DataSource dynamicDataSource() {
        DynamicDataSource dataSource = new DynamicDataSource();
        Map<Object, Object> dataSourceMap = new HashMap<>();
        dataSourceMap.put("master", masterDataSource());
        dataSourceMap.put("slave", slaveDataSource());
        dataSource.setTargetDataSources(dataSourceMap);
        dataSource.setDefaultTargetDataSource(masterDataSource());
        return dataSource;
    }
}

4. 高并发场景解决方案

4.1 秒杀系统设计

4.1.1 秒杀架构流程

4.1.2 秒杀核心代码

@Service
public class SecKillService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    private static final String STOCK_KEY = "secKill:stock:";
    private static final String USER_LIMIT_KEY = "secKill:user:";
    
    public SecKillResponse secKill(SecKillRequest request) {
        String userId = request.getUserId();
        String itemId = request.getItemId();
        
        // 1. 用户限频检查
        String userLimitKey = USER_LIMIT_KEY + itemId + ":" + userId;
        Long count = redisTemplate.opsForValue().increment(userLimitKey, 1);
        if (count != null && count > 1) {
            return SecKillResponse.fail("请勿重复提交");
        }
        redisTemplate.expire(userLimitKey, 5, TimeUnit.MINUTES);
        
        // 2. Redis原子减库存
        String stockKey = STOCK_KEY + itemId;
        Long remaining = redisTemplate.opsForValue().decrement(stockKey);
        if (remaining == null || remaining < 0) {
            // 库存恢复
            redisTemplate.opsForValue().increment(stockKey);
            return SecKillResponse.fail("库存不足");
        }
        
        // 3. 异步下单消息
        SecKillMessage message = new SecKillMessage(userId, itemId);
        rabbitTemplate.convertAndSend("secKill.exchange", "secKill.route", message);
        
        return SecKillResponse.success("秒杀成功，排队中");
    }
}

4.2 分布式事务解决方案

4.2.1 TCC事务模式

public interface OrderTccService {
    
    @Transactional(rollbackFor = Exception.class)
    @TccAction(confirmMethod = "confirmCreateOrder", cancelMethod = "cancelCreateOrder")
    boolean tryCreateOrder(Order order);
    
    boolean confirmCreateOrder(Order order);
    
    boolean cancelCreateOrder(Order order);
}

@Service
public class OrderTccServiceImpl implements OrderTccService {
    
    @Override
    public boolean tryCreateOrder(Order order) {
        // 1. 预留资源（冻结库存、预扣优惠券等）
        inventoryService.freezeStock(order.getItems());
        couponService.freezeCoupon(order.getUserId(), order.getCouponId());
        
        // 2. 生成预订单
        order.setStatus(OrderStatus.PRE_CREATE);
        orderMapper.insert(order);
        
        return true;
    }
    
    @Override
    public boolean confirmCreateOrder(Order order) {
        // 确认阶段：实际扣减资源
        inventoryService.deductStock(order.getItems());
        couponService.deductCoupon(order.getUserId(), order.getCouponId());
        
        // 更新订单状态
        order.setStatus(OrderStatus.CREATED);
        orderMapper.updateStatus(order.getId(), OrderStatus.CREATED);
        
        return true;
    }
    
    @Override
    public boolean cancelCreateOrder(Order order) {
        // 取消阶段：释放预留资源
        inventoryService.unfreezeStock(order.getItems());
        couponService.unfreezeCoupon(order.getUserId(), order.getCouponId());
        
        // 删除预订单
        orderMapper.delete(order.getId());
        
        return true;
    }
}

5. 监控与稳定性保障

5.1 全链路监控体系

# Prometheus监控配置
scrape_configs:
  - job_name: 'mall-app'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['192.168.1.10:8080', '192.168.1.11:8080']
        labels:
          application: 'mall-service'
          
  - job_name: 'redis'
    static_configs:
      - targets: ['192.168.1.20:9121']
        
  - job_name: 'mysql'
    static_configs:
      - targets: ['192.168.1.30:9104']

5.2 弹性伸缩策略

# AWS Auto Scaling配置
resource "aws_autoscaling_policy" "mall_scale_up" {
  name                   = "mall-scale-up"
  scaling_adjustment     = 2
  adjustment_type        = "ChangeInCapacity"
  cooldown               = 300
  autoscaling_group_name = aws_autoscaling_group.mall.name
}

resource "aws_cloudwatch_metric_alarm" "high_cpu" {
  alarm_name          = "mall-high-cpu"
  comparison_operator = "GreaterThanThreshold"
  evaluation_periods  = "2"
  metric_name         = "CPUUtilization"
  namespace           = "AWS/EC2"
  period              = "120"
  statistic           = "Average"
  threshold           = "70"
  
  dimensions = {
    AutoScalingGroupName = aws_autoscaling_group.mall.name
  }
  
  alarm_actions = [aws_autoscaling_policy.mall_scale_up.arn]
}