12.2 应用性能监控

面试重要程度：⭐⭐⭐⭐⭐
常见提问方式： "如何搭建APM监控系统？" "链路追踪的实现原理？" "如何定位性能瓶颈？"
预计阅读时间：40分钟

🔍 APM工具选型与对比

主流APM工具分析

/**
 * APM工具选型分析
 */
public class APMToolComparison {
    
    /**
     * APM工具枚举
     */
    public enum APMTool {
        SKYWALKING("SkyWalking", "Apache开源", "Java生态友好，无侵入", "免费"),
        PINPOINT("Pinpoint", "Naver开源", "详细的调用链分析", "免费"),
        ZIPKIN("Zipkin", "Twitter开源", "轻量级，易部署", "免费"),
        JAEGER("Jaeger", "Uber开源", "云原生，CNCF项目", "免费"),
        NEW_RELIC("New Relic", "商业产品", "功能全面，易用性好", "付费"),
        DATADOG("Datadog", "商业产品", "多云支持，集成度高", "付费");
        
        private final String name;
        private final String vendor;
        private final String features;
        private final String pricing;
        
        APMTool(String name, String vendor, String features, String pricing) {
            this.name = name;
            this.vendor = vendor;
            this.features = features;
            this.pricing = pricing;
        }
    }
    
    /**
     * APM选型决策矩阵
     */
    public static APMTool recommend(ProjectRequirements requirements) {
        if (requirements.getBudget() == Budget.FREE) {
            if (requirements.getEcosystem() == Ecosystem.JAVA) {
                return APMTool.SKYWALKING;
            } else if (requirements.getDeployment() == Deployment.CLOUD_NATIVE) {
                return APMTool.JAEGER;
            } else {
                return APMTool.ZIPKIN;
            }
        } else {
            return requirements.getComplexity() == Complexity.HIGH ? 
                APMTool.NEW_RELIC : APMTool.DATADOG;
        }
    }
    
    public enum Budget { FREE, PAID }
    public enum Ecosystem { JAVA, POLYGLOT, MICROSERVICE }
    public enum Deployment { ON_PREMISE, CLOUD, CLOUD_NATIVE }
    public enum Complexity { LOW, MEDIUM, HIGH }
    
    public static class ProjectRequirements {
        private Budget budget;
        private Ecosystem ecosystem;
        private Deployment deployment;
        private Complexity complexity;
        
        public ProjectRequirements(Budget budget, Ecosystem ecosystem, 
                                 Deployment deployment, Complexity complexity) {
            this.budget = budget;
            this.ecosystem = ecosystem;
            this.deployment = deployment;
            this.complexity = complexity;
        }
        
        // Getters
        public Budget getBudget() { return budget; }
        public Ecosystem getEcosystem() { return ecosystem; }
        public Deployment getDeployment() { return deployment; }
        public Complexity getComplexity() { return complexity; }
    }
}

🕸️ SkyWalking集成实战

SkyWalking配置与集成

/**
 * SkyWalking集成配置
 */
@Configuration
@EnableConfigurationProperties(SkyWalkingProperties.class)
public class SkyWalkingConfig {
    
    /**
     * 自定义链路追踪注解
     */
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Trace {
        String operationName() default "";
        String tag() default "";
    }
    
    /**
     * 链路追踪切面
     */
    @Aspect
    @Component
    public static class TraceAspect {
        
        @Around("@annotation(trace)")
        public Object traceMethod(ProceedingJoinPoint joinPoint, Trace trace) throws Throwable {
            String operationName = trace.operationName().isEmpty() ? 
                joinPoint.getSignature().getName() : trace.operationName();
            
            // 创建Span
            Span span = Tracer.createLocalSpan(operationName);
            
            try {
                if (!trace.tag().isEmpty()) {
                    Tags.COMPONENT.set(span, trace.tag());
                }
                
                Object[] args = joinPoint.getArgs();
                if (args.length > 0) {
                    span.tag("args.count", String.valueOf(args.length));
                }
                
                Object result = joinPoint.proceed();
                
                if (result != null) {
                    span.tag("return.type", result.getClass().getSimpleName());
                }
                
                return result;
            } catch (Exception e) {
                span.errorOccurred();
                span.log(e);
                throw e;
            } finally {
                Tracer.stopSpan();
            }
        }
    }
    
    @ConfigurationProperties(prefix = "skywalking")
    public static class SkyWalkingProperties {
        private boolean enabled = true;
        private String serviceName = "spring-boot-app";
        private String collectorAddress = "http://skywalking-oap:12800";
        private double sampleRate = 1.0;
        
        // Getters and Setters
        public boolean isEnabled() { return enabled; }
        public void setEnabled(boolean enabled) { this.enabled = enabled; }
        public String getServiceName() { return serviceName; }
        public void setServiceName(String serviceName) { this.serviceName = serviceName; }
        public String getCollectorAddress() { return collectorAddress; }
        public void setCollectorAddress(String collectorAddress) { this.collectorAddress = collectorAddress; }
        public double getSampleRate() { return sampleRate; }
        public void setSampleRate(double sampleRate) { this.sampleRate = sampleRate; }
    }
}

SkyWalking Docker部署

# docker-compose.yml for SkyWalking
version: '3.8'

services:
  elasticsearch:
    image: elasticsearch:7.17.0
    container_name: skywalking-elasticsearch
    environment:
      - discovery.type=single-node
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    volumes:
      - elasticsearch-data:/usr/share/elasticsearch/data
    ports:
      - "9200:9200"

  skywalking-oap:
    image: apache/skywalking-oap-server:9.3.0
    container_name: skywalking-oap
    depends_on:
      - elasticsearch
    environment:
      SW_STORAGE: elasticsearch
      SW_STORAGE_ES_CLUSTER_NODES: elasticsearch:9200
      SW_HEALTH_CHECKER: default
      SW_TELEMETRY: prometheus
    ports:
      - "11800:11800"
      - "12800:12800"

  skywalking-ui:
    image: apache/skywalking-ui:9.3.0
    container_name: skywalking-ui
    depends_on:
      - skywalking-oap
    environment:
      SW_OAP_ADDRESS: http://skywalking-oap:12800
    ports:
      - "8080:8080"

volumes:
  elasticsearch-data:

🔗 分布式链路追踪实现

链路追踪核心实现

/**
 * 分布式链路追踪实现
 */
public class DistributedTracing {
    
    /**
     * 链路追踪上下文
     */
    public static class TraceContext {
        private static final ThreadLocal<SpanContext> CURRENT_SPAN = new ThreadLocal<>();
        
        public static void setCurrentSpan(SpanContext spanContext) {
            CURRENT_SPAN.set(spanContext);
        }
        
        public static SpanContext getCurrentSpan() {
            return CURRENT_SPAN.get();
        }
        
        public static void clear() {
            CURRENT_SPAN.remove();
        }
    }
    
    /**
     * Span上下文信息
     */
    public static class SpanContext {
        private final String traceId;
        private final String spanId;
        private final String parentSpanId;
        private final Map<String, String> baggage;
        private final long startTime;
        
        public SpanContext(String traceId, String spanId, String parentSpanId) {
            this.traceId = traceId;
            this.spanId = spanId;
            this.parentSpanId = parentSpanId;
            this.baggage = new ConcurrentHashMap<>();
            this.startTime = System.currentTimeMillis();
        }
        
        // Getters
        public String getTraceId() { return traceId; }
        public String getSpanId() { return spanId; }
        public String getParentSpanId() { return parentSpanId; }
        public long getStartTime() { return startTime; }
    }
    
    /**
     * HTTP请求链路追踪拦截器
     */
    @Component
    public static class TracingInterceptor implements HandlerInterceptor {
        
        private static final String TRACE_ID_HEADER = "X-Trace-Id";
        private static final String SPAN_ID_HEADER = "X-Span-Id";
        
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, 
                               Object handler) throws Exception {
            String traceId = request.getHeader(TRACE_ID_HEADER);
            if (traceId == null) {
                traceId = generateTraceId();
            }
            
            String spanId = generateSpanId();
            String parentSpanId = request.getHeader(SPAN_ID_HEADER);
            
            SpanContext spanContext = new SpanContext(traceId, spanId, parentSpanId);
            TraceContext.setCurrentSpan(spanContext);
            
            response.setHeader(TRACE_ID_HEADER, traceId);
            response.setHeader(SPAN_ID_HEADER, spanId);
            
            return true;
        }
        
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, 
                                  Object handler, Exception ex) throws Exception {
            TraceContext.clear();
        }
        
        private String generateTraceId() {
            return UUID.randomUUID().toString().replace("-", "");
        }
        
        private String generateSpanId() {
            return Long.toHexString(System.nanoTime());
        }
    }
}

📊 Prometheus + Grafana监控

Prometheus指标收集

/**
 * Prometheus指标收集
 */
@Configuration
public class MetricsConfig {
    
    /**
     * 业务指标计数器
     */
    @Bean
    public Counter businessOperationCounter() {
        return Counter.build()
            .name("business_operations_total")
            .help("Total number of business operations")
            .labelNames("operation", "status")
            .register();
    }
    
    /**
     * 请求处理时间直方图
     */
    @Bean
    public Histogram requestDurationHistogram() {
        return Histogram.build()
            .name("http_request_duration_seconds")
            .help("HTTP request duration in seconds")
            .labelNames("method", "endpoint", "status")
            .buckets(0.01, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0)
            .register();
    }
    
    /**
     * 指标收集切面
     */
    @Aspect
    @Component
    public static class MetricsAspect {
        
        private final Counter businessCounter;
        private final Histogram requestHistogram;
        
        public MetricsAspect(Counter businessOperationCounter,
                           Histogram requestDurationHistogram) {
            this.businessCounter = businessOperationCounter;
            this.requestHistogram = requestDurationHistogram;
        }
        
        @Around("@annotation(org.springframework.web.bind.annotation.RequestMapping)")
        public Object collectHttpMetrics(ProceedingJoinPoint joinPoint) throws Throwable {
            long startTime = System.currentTimeMillis();
            String status = "success";
            
            try {
                Object result = joinPoint.proceed();
                return result;
            } catch (Exception e) {
                status = "error";
                throw e;
            } finally {
                double duration = (System.currentTimeMillis() - startTime) / 1000.0;
                requestHistogram.labels("GET", "api", status).observe(duration);
                businessCounter.labels("http_request", status).inc();
            }
        }
    }
}

🚨 告警规则配置

Prometheus告警规则

# prometheus-alerts.yml
groups:
- name: application.rules
  rules:
  - alert: HighErrorRate
    expr: |
      (
        rate(http_request_duration_seconds_count{status="error"}[5m]) /
        rate(http_request_duration_seconds_count[5m])
      ) * 100 > 5
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: "High error rate detected"
      description: "Error rate is {{ $value }}%"

  - alert: HighResponseTime
    expr: |
      histogram_quantile(0.95,
        rate(http_request_duration_seconds_bucket[5m])
      ) > 1
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "High response time detected"
      description: "95th percentile response time is {{ $value }}s"

  - alert: HighMemoryUsage
    expr: |
      (
        jvm_memory_used_bytes{area="heap"} /
        jvm_memory_max_bytes{area="heap"}
      ) * 100 > 85
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: "High memory usage detected"
      description: "JVM heap memory usage is {{ $value }}%"

💡 面试常见问题解答

Q1: 如何选择合适的APM工具？

标准回答：

APM工具选择考虑因素：

技术因素：
- 语言支持：Java生态选SkyWalking/Pinpoint
- 部署方式：云原生选Jaeger，传统架构选Zipkin
- 性能开销：生产环境要求低开销
- 集成难度：无侵入式优先

业务因素：
- 预算：开源vs商业产品
- 团队技能：运维复杂度
- 功能需求：监控深度和广度

推荐方案：
- 小型项目：Zipkin
- Java微服务：SkyWalking
- 云原生：Jaeger
- 企业级：New Relic/Datadog

Q2: 分布式链路追踪的实现原理？

标准回答：

链路追踪核心概念：

Trace：完整的请求链路
Span：单个操作单元
SpanContext：跨进程传播的上下文信息

实现原理：
1. TraceId生成：请求入口生成全局唯一ID
2. SpanId传播：每个服务调用生成新的SpanId
3. 上下文传播：通过HTTP头/消息队列传递
4. 数据收集：Agent收集Span数据
5. 存储分析：存储到时序数据库

关键技术：
- ThreadLocal：线程内上下文传递
- 字节码增强：无侵入式埋点
- 异步处理：减少性能影响
- 采样策略：控制数据量

Q3: 如何设计有效的监控指标？

标准回答：

监控指标设计原则：

四个黄金信号：
- Latency：响应时间
- Traffic：请求量
- Errors：错误率
- Saturation：饱和度

指标类型：
- Counter：累计计数器（请求总数）
- Gauge：瞬时值（内存使用率）
- Histogram：分布统计（响应时间分布）
- Summary：分位数统计（P95响应时间）

业务指标：
- 核心业务流程指标
- 用户行为指标
- 收入相关指标

告警策略：
- 基于阈值的静态告警
- 基于趋势的动态告警
- 多维度组合告警

核心要点总结：