第6章：技术架构演进史

美团架构演进路线图
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
2010-2011: 单体应用时代
    └─> LAMP架构，所有功能在一个应用中

2012-2013: 垂直拆分时代  
    └─> 按业务线拆分，独立部署

2014-2015: 服务化时代
    └─> SOA架构，服务解耦

2016-2017: 微服务时代
    └─> 微服务架构，服务原子化

2018-2019: 云原生时代
    └─> 容器化、Service Mesh

2020-2021: 中台化时代
    └─> 业务中台、技术中台、数据中台

2022-至今: 智能化时代
    └─> AI驱动、自动化运维、智能调度
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

系统复杂度指标变化
┌──────────────┬──────┬──────┬──────┬──────┬──────┐
│    指标      │ 2010 │ 2013 │ 2016 │ 2019 │ 2024 │
├──────────────┼──────┼──────┼──────┼──────┼──────┤
│ 服务数量     │  1   │  20  │ 200  │ 3000 │ 5000+│
│ 数据库实例   │  2   │  50  │ 500  │ 5000 │10000+│
│ 消息队列主题 │  0   │  10  │ 100  │ 2000 │ 5000+│
│ 日志量/天    │ 1GB  │100GB │ 1TB  │ 10TB │100TB+│
│ 监控指标数   │ 100  │ 1万  │ 10万 │100万 │1000万│
└──────────────┴──────┴──────┴──────┴──────┴──────┘

// 早期单体应用代码结构
class MeituanApp {
    // 所有业务逻辑在一个应用中

    public function handleRequest($request) {
        $controller = $this->routeRequest($request);

        switch($controller) {
            case 'deal':
                return $this->dealController->handle($request);
            case 'order':
                return $this->orderController->handle($request);
            case 'user':
                return $this->userController->handle($request);
            default:
                return $this->notFound();
        }
    }

    // 所有数据访问在一个数据库
    private function getDatabase() {
        return new PDO('mysql:host=localhost;dbname=meituan');
    }
}

垂直拆分架构
┌──────────┐ ┌──────────┐ ┌──────────┐
│  团购系统 │ │  用户系统 │ │  商家系统 │
├──────────┤ ├──────────┤ ├──────────┤
│  团购DB  │ │  用户DB  │ │  商家DB  │
└──────────┘ └──────────┘ └──────────┘
     ↑            ↑            ↑
     └────────────┼────────────┘
              统一接入层

// 服务化架构示例
@Service
public class OrderService {

    @Reference // Dubbo服务引用
    private UserService userService;

    @Reference
    private InventoryService inventoryService;

    @Reference
    private PaymentService paymentService;

    public Order createOrder(OrderRequest request) {
        // 调用用户服务
        User user = userService.getUser(request.getUserId());

        // 调用库存服务
        boolean available = inventoryService.checkAndLock(
            request.getProductId(), 
            request.getQuantity()
        );

        if (!available) {
            throw new InsufficientInventoryException();
        }

        // 创建订单
        Order order = new Order();
        order.setUserId(user.getId());
        order.setProductId(request.getProductId());

        // 调用支付服务
        PaymentResult result = paymentService.pay(order);

        return order;
    }
}

美团微服务拆分策略
┌─────────────────────────────────────┐
│         拆分原则                     │
├─────────────────────────────────────┤
│ 1. 业务边界清晰                     │
│ 2. 数据独立性                       │
│ 3. 技术异构性                       │
│ 4. 团队独立性                       │
│ 5. 发布独立性                       │
└─────────────────────────────────────┘
           │
           ▼
┌─────────────────────────────────────┐
│      拆分粒度控制                    │
├─────────────────────────────────────┤
│ • 服务规模：100-1000行核心代码      │
│ • 团队规模：2-8人                   │
│ • 发布频率：每周1-5次               │
│ • 接口数量：5-20个                  │
└─────────────────────────────────────┘

// OCTO服务治理能力
@OCTOService(
    name = "user-service",
    version = "2.0",
    group = "production"
)
public class UserServiceImpl implements UserService {

    @OCTOMethod(
        timeout = 3000,        // 超时控制
        retries = 2,          // 重试次数
        loadbalance = "random", // 负载均衡
        cache = true,         // 结果缓存
        circuitBreaker = @CircuitBreaker(
            threshold = 0.5,   // 熔断阈值
            duration = 10000   // 熔断时长
        )
    )
    public User getUser(Long userId) {
        // 业务逻辑
        return userRepository.findById(userId);
    }
}

# Service Mesh配置示例
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: user-service
spec:
  hosts:

  - user-service
  http:

  - match:
    - headers:
        x-user-type:
          exact: vip
    route:

    - destination:
        host: user-service
        subset: v2
      weight: 100

  - route:
    - destination:
        host: user-service
        subset: v1
      weight: 90

    - destination:
        host: user-service
        subset: v2
      weight: 10  # 灰度发布

美团中间件技术栈
┌────────────────────────────────────────┐
│            应用层中间件                 │
│  ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ │
│  │Zebra │ │Crane │ │Lion  │ │Shield│ │
│  │数据库│ │消息  │ │配置  │ │安全  │ │
│  └──────┘ └──────┘ └──────┘ └──────┘ │
├────────────────────────────────────────┤
│            通信层中间件                 │
│  ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ │
│  │OCTO  │ │MTMQ  │ │Tair  │ │Cellar│ │
│  │RPC   │ │消息  │ │缓存  │ │KV存储│ │
│  └──────┘ └──────┘ └──────┘ └──────┘ │
├────────────────────────────────────────┤
│            基础层中间件                 │
│  ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ │
│  │CAT   │ │Falcon│ │MTrace│ │Rhino │ │
│  │监控  │ │告警  │ │链路  │ │日志  │ │
│  └──────┘ └──────┘ └──────┘ └──────┘ │
└────────────────────────────────────────┘

// Zebra分库分表示例
@Repository
public class OrderRepository {

    @Autowired
    private ZebraDataSource dataSource;

    public void saveOrder(Order order) {
        // 根据用户ID分库分表
        String sql = "INSERT INTO order_? (id, user_id, amount) VALUES (?, ?, ?)";

        // Zebra自动路由到正确的库表
        int tableIndex = ShardingUtils.getTableIndex(order.getUserId());

        jdbcTemplate.update(
            sql.replace("?", String.valueOf(tableIndex)),
            order.getId(),
            order.getUserId(),
            order.getAmount()
        );
    }

    @ZebraSharding(
        shardingColumn = "user_id",
        shardingAlgorithm = "hash"
    )
    public List<Order> getUserOrders(Long userId) {
        // Zebra自动聚合多个分片的结果
        return jdbcTemplate.query(
            "SELECT * FROM order WHERE user_id = ?",
            new OrderRowMapper(),
            userId
        );
    }
}

# MTMQ使用示例
from mtmq import Producer, Consumer

class OrderEventProducer:
    def __init__(self):
        self.producer = Producer(
            topic='order-events',
            cluster='production'
        )

    def send_order_created(self, order):
        message = {
            'event_type': 'ORDER_CREATED',
            'order_id': order.id,
            'user_id': order.user_id,
            'amount': order.amount,
            'timestamp': time.time()
        }

        # 发送消息，支持事务消息
        self.producer.send_transactional(
            message,
            transaction_id=order.id,
            callback=self.on_send_result
        )

class OrderEventConsumer:
    def __init__(self):
        self.consumer = Consumer(
            topic='order-events',
            group='inventory-service',
            parallelism=10  # 并发消费
        )

    def consume(self):
        @self.consumer.on_message
        def handle_message(message):
            if message['event_type'] == 'ORDER_CREATED':
                # 处理订单创建事件
                self.update_inventory(message['order_id'])

            # 消息确认
            return ConsumeResult.SUCCESS

容器化进程
2015: Docker试点
├─ 10%服务容器化
└─ 开发测试环境

2017: Kubernetes引入
├─ 50%服务容器化
└─ 生产环境部署

2019: 全面容器化
├─ 90%服务容器化
└─ 自研Kubernetes发行版

2021: Serverless探索
├─ FaaS平台建设
└─ 事件驱动架构

2023: 云原生成熟
├─ 100%容器化
└─ 多云部署能力

# 美团Kubernetes平台特性
apiVersion: meituan.io/v1
kind: WorkloadOptimizer
metadata:
  name: auto-scaling
spec:
  # 自动扩缩容
  autoScaling:
    minReplicas: 3
    maxReplicas: 100
    metrics:

    - type: QPS
      targetValue: 1000

    - type: CPU
      targetAverageUtilization: 70

    - type: Memory
      targetAverageUtilization: 80
    # 预测性扩容
    predictive:
      enabled: true
      algorithm: lstm
      lookbackWindow: 7d

  # 资源优化
  resourceOptimization:
    enabled: true
    # 根据历史数据自动调整资源配置
    autoAdjust: true
    # 混部调度
    colocation:
      enabled: true
      onlineOfflineRatio: 7:3

// 自研Service Mesh数据平面
type MeituanProxy struct {
    inboundHandlers  []Handler
    outboundHandlers []Handler
    loadBalancer     LoadBalancer
    circuitBreaker   CircuitBreaker
}

func (p *MeituanProxy) HandleInbound(req *Request) *Response {
    // 入站请求处理链
    for _, handler := range p.inboundHandlers {
        if err := handler.Handle(req); err != nil {
            return errorResponse(err)
        }
    }

    // 路由到本地服务
    return p.routeToLocal(req)
}

func (p *MeituanProxy) HandleOutbound(req *Request) *Response {
    // 服务发现
    endpoints := p.serviceDiscovery(req.Service)

    // 负载均衡
    endpoint := p.loadBalancer.Select(endpoints)

    // 熔断检查
    if p.circuitBreaker.IsOpen(endpoint) {
        return p.fallback(req)
    }

    // 出站请求处理链
    for _, handler := range p.outboundHandlers {
        req = handler.Process(req)
    }

    // 发送请求
    resp := p.send(endpoint, req)

    // 更新熔断器状态
    p.circuitBreaker.RecordResult(endpoint, resp)

    return resp
}

美团数据架构（2024）
┌────────────────────────────────────────┐
│            实时应用层                   │
│   在线服务│实时大屏│实时推荐│实时风控   │
└──────────────┬─────────────────────────┘
               │
┌──────────────▼─────────────────────────┐
│            计算层                       │
│  ┌────────────────┬────────────────┐  │
│  │   离线计算      │    实时计算     │  │
│  │  Spark/Hive    │  Flink/Storm   │  │
│  └────────────────┴────────────────┘  │
└──────────────┬─────────────────────────┘
               │
┌──────────────▼─────────────────────────┐
│            存储层                       │
│  ┌─────┬─────┬─────┬─────┬─────┐     │
│  │HDFS │HBase│MySQL│Redis│ES   │     │
│  └─────┴─────┴─────┴─────┴─────┘     │
└──────────────┬─────────────────────────┘
               │
┌──────────────▼─────────────────────────┐
│            采集层                       │
│    Binlog│Flume│SDK│Kafka│Agent       │
└────────────────────────────────────────┘

# Flink流批一体处理
class OrderAnalyticsJob:
    def __init__(self):
        self.env = StreamExecutionEnvironment.get_execution_environment()

    def run(self):
        # 实时流处理
        stream = self.env.add_source(
            KafkaSource()
            .topic("order-events")
            .build()
        )

        # 实时指标计算
        metrics = stream \
            .key_by(lambda x: x.merchant_id) \
            .window(TumblingWindow.of(Time.minutes(1))) \
            .aggregate(
                OrderMetricsAggregator(),
                OrderMetricsWindowFunction()
            )

        # 输出到多个目标
        metrics.add_sink(RedisS sink())  # 实时查询
        metrics.add_sink(HBaseSink())   # 历史存储
        metrics.add_sink(KafkaSink())   # 下游消费

        # 批处理补算
        if self.is_batch_mode():
            batch = self.env.read_text_file("hdfs://historical-orders")
            batch_metrics = batch \
                .map(parse_order) \
                .key_by(lambda x: x.merchant_id) \
                .reduce(aggregate_metrics)

            batch_metrics.write_as_text("hdfs://output")

        self.env.execute("Order Analytics Job")

-- 湖仓一体查询示例
-- 统一查询接口，自动路由到数据湖或数据仓库

-- 查询实时数据（数据湖）
SELECT 
    merchant_id,
    COUNT(*) as order_count,
    SUM(amount) as total_amount
FROM 
    lakehouse.realtime.orders
WHERE 
    order_time >= CURRENT_TIMESTAMP - INTERVAL '1' HOUR
GROUP BY 
    merchant_id;

-- 查询历史数据（数据仓库）
SELECT 
    date_trunc('day', order_time) as order_date,
    merchant_category,
    SUM(amount) as daily_amount
FROM 
    lakehouse.warehouse.order_facts
WHERE 
    order_time >= '2024-01-01'
GROUP BY 
    1, 2;

-- 联合查询（自动优化）
WITH realtime_orders AS (
    SELECT * FROM lakehouse.realtime.orders
    WHERE order_time >= CURRENT_DATE
),
historical_orders AS (
    SELECT * FROM lakehouse.warehouse.order_facts
    WHERE order_time < CURRENT_DATE
)
SELECT * FROM realtime_orders
UNION ALL
SELECT * FROM historical_orders;

零信任网络架构
┌────────────────────────────────────────┐
│           零信任网关                    │
│    (身份验证/设备验证/风险评估)          │
└──────────────┬─────────────────────────┘
               │
┌──────────────▼─────────────────────────┐
│           策略决策点                    │
│    (访问控制/权限判定/审计)             │
└──────────────┬─────────────────────────┘
               │
┌──────────────▼─────────────────────────┐
│           微隔离网络                    │
│  ┌──────┐ ┌──────┐ ┌──────┐          │
│  │服务A │ │服务B │ │服务C │          │
│  └──────┘ └──────┘ └──────┘          │
│     ↕        ↕        ↕               │
│  [加密通信] [证书认证] [访问控制]      │
└────────────────────────────────────────┘

class SecurityGateway:
    """
    统一安全网关
    """

    def __init__(self):
        self.waf = WebApplicationFirewall()
        self.ddos_protector = DDoSProtector()
        self.bot_detector = BotDetector()
        self.threat_intelligence = ThreatIntelligence()

    def process_request(self, request):
        # 多层防护
        checks = [
            self.check_blacklist,
            self.check_ddos,
            self.check_waf,
            self.check_bot,
            self.check_threat
        ]

        for check in checks:
            result = check(request)
            if not result.passed:
                return self.block_request(request, result.reason)

        # 请求通过，添加安全头
        request.add_header('X-Security-Token', self.generate_token())

        return request

    def check_waf(self, request):
        """
        Web应用防火墙检查
        """
        # SQL注入检测
        if self.waf.detect_sql_injection(request):
            return CheckResult(False, "SQL Injection detected")

        # XSS检测
        if self.waf.detect_xss(request):
            return CheckResult(False, "XSS detected")

        # 路径遍历检测
        if self.waf.detect_path_traversal(request):
            return CheckResult(False, "Path traversal detected")

        return CheckResult(True)

性能优化体系
┌────────────────────────────────────────┐
│           前端优化                      │
│   CDN│压缩│懒加载│预加载│缓存          │
├────────────────────────────────────────┤
│           网关优化                      │
│   连接池│限流│缓存│压缩│路由          │
├────────────────────────────────────────┤
│           服务优化                      │
│   并发│异步│批处理│缓存│索引          │
├────────────────────────────────────────┤
│           数据库优化                    │
│   索引│分区│读写分离│连接池│SQL优化    │
└────────────────────────────────────────┘

// 全链路性能监控
@Component
public class PerformanceMonitor {

    @Around("@annotation(MonitorPerformance)")
    public Object monitor(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().getName();

        // 记录开始时间
        long startTime = System.currentTimeMillis();

        // 记录方法调用前的状态
        SystemMetrics beforeMetrics = collectSystemMetrics();

        try {
            // 执行方法
            Object result = joinPoint.proceed();

            // 记录成功指标
            recordSuccess(methodName, startTime);

            return result;

        } catch (Exception e) {
            // 记录失败指标
            recordFailure(methodName, startTime, e);
            throw e;

        } finally {
            // 记录方法调用后的状态
            SystemMetrics afterMetrics = collectSystemMetrics();

            // 分析性能
            analyzePerformance(methodName, beforeMetrics, afterMetrics);

            // 上报监控数据
            reportMetrics(methodName, System.currentTimeMillis() - startTime);
        }
    }

    private SystemMetrics collectSystemMetrics() {
        return SystemMetrics.builder()
            .cpuUsage(getCpuUsage())
            .memoryUsage(getMemoryUsage())
            .threadCount(Thread.activeCount())
            .gcCount(getGcCount())
            .build();
    }
}

美团架构决策原则
┌────────────────────────────────────┐
│      业务优先原则                   │
│   架构服务于业务，不过度设计        │
├────────────────────────────────────┤
│      演进式架构                     │
│   小步快跑，逐步演进，避免大爆炸    │
├────────────────────────────────────┤
│      数据驱动决策                   │
│   用数据说话，量化架构价值         │
├────────────────────────────────────┤
│      技术债务管理                   │
│   持续偿还债务，保持架构健康       │
└────────────────────────────────────┘