📚 第十章：性能优化与生产实践

10.1 性能优化概述

10.1.1 性能优化策略

graph TB
    A[性能优化] --> B[JVM 调优]
    A --> C[原生镜像优化]
    A --> D[应用层优化]
    A --> E[数据库优化]
    A --> F[缓存策略]
    A --> G[网络优化]
    
    B --> B1[堆内存调优]
    B --> B2[垃圾回收优化]
    B --> B3[JIT 编译优化]
    
    C --> C1[构建时优化]
    C --> C2[反射配置]
    C --> C3[资源包含]
    
    D --> D1[代码优化]
    D --> D2[异步处理]
    D --> D3[连接池优化]
    
    E --> E1[查询优化]
    E --> E2[索引策略]
    E --> E3[连接池配置]
    
    F --> F1[本地缓存]
    F --> F2[分布式缓存]
    F --> F3[缓存策略]

10.1.2 性能监控指标

• 响应时间：P50、P95、P99 延迟
• 吞吐量：每秒请求数（RPS）
• 资源使用：CPU、内存、网络、磁盘
• 错误率：4xx、5xx 错误比例
• 可用性：服务正常运行时间

10.2 JVM 调优

10.2.1 堆内存优化

JVM 参数配置

# application.properties - JVM 调优配置

# 堆内存设置
quarkus.native.additional-build-args=-J-Xmx4g,-J-Xms2g

# 新生代配置
quarkus.native.additional-build-args=-J-XX:NewRatio=3
quarkus.native.additional-build-args=-J-XX:SurvivorRatio=8

# 垃圾回收器选择
quarkus.native.additional-build-args=-J-XX:+UseG1GC
quarkus.native.additional-build-args=-J-XX:MaxGCPauseMillis=200

# GC 日志配置
quarkus.native.additional-build-args=-J-XX:+PrintGC
quarkus.native.additional-build-args=-J-XX:+PrintGCDetails
quarkus.native.additional-build-args=-J-XX:+PrintGCTimeStamps

JVM 监控服务

@ApplicationScoped
public class JvmMonitoringService {
    
    private static final Logger logger = LoggerFactory.getLogger(JvmMonitoringService.class);
    
    private final MemoryMXBean memoryBean;
    private final List<GarbageCollectorMXBean> gcBeans;
    private final ThreadMXBean threadBean;
    
    public JvmMonitoringService() {
        this.memoryBean = ManagementFactory.getMemoryMXBean();
        this.gcBeans = ManagementFactory.getGarbageCollectorMXBeans();
        this.threadBean = ManagementFactory.getThreadMXBean();
    }
    
    @Scheduled(every = "30s")
    public void logJvmMetrics() {
        logMemoryUsage();
        logGarbageCollection();
        logThreadInfo();
    }
    
    private void logMemoryUsage() {
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
        MemoryUsage nonHeapUsage = memoryBean.getNonHeapMemoryUsage();
        
        logger.info("Heap Memory - Used: {}MB, Max: {}MB, Usage: {:.2f}%",
            heapUsage.getUsed() / 1024 / 1024,
            heapUsage.getMax() / 1024 / 1024,
            (double) heapUsage.getUsed() / heapUsage.getMax() * 100);
            
        logger.info("Non-Heap Memory - Used: {}MB, Max: {}MB",
            nonHeapUsage.getUsed() / 1024 / 1024,
            nonHeapUsage.getMax() / 1024 / 1024);
    }
    
    private void logGarbageCollection() {
        for (GarbageCollectorMXBean gcBean : gcBeans) {
            logger.info("GC {} - Collections: {}, Time: {}ms",
                gcBean.getName(),
                gcBean.getCollectionCount(),
                gcBean.getCollectionTime());
        }
    }
    
    private void logThreadInfo() {
        logger.info("Threads - Active: {}, Peak: {}, Total Started: {}",
            threadBean.getThreadCount(),
            threadBean.getPeakThreadCount(),
            threadBean.getTotalStartedThreadCount());
    }
    
    public JvmMetrics getJvmMetrics() {
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
        
        return JvmMetrics.builder()
            .heapUsed(heapUsage.getUsed())
            .heapMax(heapUsage.getMax())
            .heapUsagePercent((double) heapUsage.getUsed() / heapUsage.getMax() * 100)
            .activeThreads(threadBean.getThreadCount())
            .gcCollections(gcBeans.stream()
                .mapToLong(GarbageCollectorMXBean::getCollectionCount)
                .sum())
            .gcTime(gcBeans.stream()
                .mapToLong(GarbageCollectorMXBean::getCollectionTime)
                .sum())
            .build();
    }
}

10.3 原生镜像优化

10.3.1 构建时优化

原生镜像配置

# application.properties - 原生镜像优化

# 构建时优化
quarkus.native.enable-http-url-handler=true
quarkus.native.enable-https-url-handler=true
quarkus.native.enable-all-security-services=false
quarkus.native.enable-isolated-namespaces=false

# 资源包含
quarkus.native.resources.includes=**/*.properties,**/*.json,**/*.xml
quarkus.native.resources.excludes=**/*.class

# 反射配置
quarkus.native.additional-build-args=--initialize-at-build-time=org.slf4j
quarkus.native.additional-build-args=--initialize-at-run-time=io.netty

# 内存优化
quarkus.native.additional-build-args=-H:+RemoveSaturatedTypeFlows
quarkus.native.additional-build-args=-H:+ReportExceptionStackTraces
quarkus.native.additional-build-args=-H:+PrintAnalysisCallTree

# 压缩优化
quarkus.native.compression.level=2
quarkus.native.compression.additional-args=--gc=G1

10.4 应用层优化

10.4.1 异步处理优化

@RestController
@RequestMapping("/api/async")
public class AsyncController {
    
    @Inject
    UserService userService;
    
    @Inject
    OrderService orderService;
    
    @Inject
    NotificationService notificationService;
    
    // 异步处理用户注册
    @POST
    public Uni<ResponseEntity<UserDto>> createUserAsync(@RequestBody CreateUserRequest request) {
        return userService.createUserAsync(request)
            .onItem().transform(user -> {
                // 异步发送欢迎邮件
                notificationService.sendWelcomeEmailAsync(user.getEmail())
                    .subscribe().with(
                        success -> logger.info("Welcome email sent to {}", user.getEmail()),
                        failure -> logger.error("Failed to send welcome email", failure)
                    );
                
                return ResponseEntity.ok(UserDto.from(user));
            })
            .onFailure().recoverWithItem(throwable -> {
                logger.error("Failed to create user", throwable);
                return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
            });
    }
    
    // 并行处理多个请求
    @GET
    public Uni<ResponseEntity<UserDashboard>> getUserDashboard(@PathVariable Long userId) {
        Uni<User> userUni = userService.findByIdAsync(userId);
        Uni<List<Order>> ordersUni = orderService.findByUserIdAsync(userId);
        Uni<List<Notification>> notificationsUni = notificationService.findByUserIdAsync(userId);
        
        return Uni.combine().all().unis(userUni, ordersUni, notificationsUni)
            .asTuple()
            .onItem().transform(tuple -> {
                User user = tuple.getItem1();
                List<Order> orders = tuple.getItem2();
                List<Notification> notifications = tuple.getItem3();
                
                UserDashboard dashboard = UserDashboard.builder()
                    .user(UserDto.from(user))
                    .recentOrders(orders.stream()
                        .map(OrderDto::from)
                        .collect(Collectors.toList()))
                    .notifications(notifications.stream()
                        .map(NotificationDto::from)
                        .collect(Collectors.toList()))
                    .build();
                    
                return ResponseEntity.ok(dashboard);
            })
            .onFailure().recoverWithItem(throwable -> {
                logger.error("Failed to load user dashboard", throwable);
                return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
            });
    }
}

10.5 本章小结

10.5.1 核心概念回顾

• 性能优化策略：JVM 调优、原生镜像优化、应用层优化
• 监控指标：响应时间、吞吐量、资源使用率
• 生产实践：配置管理、健康检查、部署策略

10.5.2 技术要点总结

1. JVM 调优：堆内存配置、垃圾回收器选择、监控指标
2. 原生镜像：构建时优化、反射配置、资源管理
3. 异步处理：响应式编程、并行处理、流式数据
4. 生产部署：配置管理、健康检查、监控告警

10.5.3 最佳实践

• 建立完善的监控和告警体系
• 实施渐进式部署和回滚策略
• 定期进行性能测试和调优
• 配置合适的资源限制和健康检查

10.5.4 Quarkus 教程总结

通过本教程的学习，你已经全面掌握了 Quarkus 框架的核心特性和最佳实践：

1. 基础知识：环境搭建、依赖注入、配置管理
2. Web 开发：RESTful API、数据持久化、微服务通信
3. 企业特性：安全认证、监控日志、测试策略
4. 云原生：容器化部署、性能优化、生产实践

Quarkus 作为下一代 Java 框架，为云原生和微服务架构提供了完美的解决方案。希望本教程能帮助你在实际项目中充分发挥 Quarkus 的优势，构建高性能、可扩展的现代 Java 应用。

继续学习建议： - 深入研究 GraalVM 原生镜像技术 - 探索 Quarkus 扩展开发 - 实践微服务架构模式 - 学习云原生技术栈（Kubernetes、Istio 等） - 关注 Quarkus 社区最新发展

---

下一步：开始 Helm 教程学习