SpringBoot性能优化之从启动加速到运行时调优的实战指南

flowchart TD
  A["压测发现指标异常"] --> B{"瓶颈在哪一层"}
  B -->|"CPU 高、GC 频繁"| C["JVM 层：堆大小 / GC 选型"]
  B -->|"线程阻塞、连接等待"| D["资源层：连接池 / 线程池"]
  B -->|"SQL 慢、锁等待"| E["数据库层：慢 SQL / 索引"]
  B -->|"启动慢、内存占用高"| F["应用层：扫描范围 / 自动配置"]
  C --> G["针对性优化"]
  D --> G
  E --> G
  F --> G
  G --> H["回归压测验证"]

// 不推荐：扫描范围过大
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// 推荐：显式限定扫描范围
@SpringBootApplication(scanBasePackages = {
        "com.example.order",
        "com.example.common"
})
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

spring:
  main:
    lazy-initialization: true

@SpringBootApplication(exclude = {
        DataSourceAutoConfiguration.class,
        SecurityAutoConfiguration.class,
        MailSenderAutoConfiguration.class
})
public class Application {
}

spring:
  autoconfigure:
    exclude:
      - org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration
      - org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration

flowchart TD
  A["Spring Boot 启动慢"] --> B["减少扫描范围"]
  A --> C["减少自动配置加载"]
  A --> D["推迟 Bean 创建"]
  B --> B1["scanBasePackages 限定包路径"]
  B --> B2["检查 @EntityScan / @EnableJpaRepositories"]
  C --> C1["--debug 查看条件评估报告"]
  C --> C2["exclude 排除无用自动配置"]
  D --> D1["lazy-initialization 全局延迟"]
  D --> D2["@Lazy(false) 排除关键 Bean"]
  B1 --> E["启动耗时下降"]
  B2 --> E
  C1 --> E
  C2 --> E
  D1 --> E
  D2 --> E

spring:
  datasource:
    hikari:
      maximum-pool-size: 20
      minimum-idle: 10
      connection-timeout: 3000
      idle-timeout: 600000
      max-lifetime: 1800000
      leak-detection-threshold: 60000

连接数 ≈ CPU 核数 × 2 + 有效磁盘数

flowchart LR
  A["maximumPoolSize = 5"] --> B["逐步加压至 10 / 20 / 30"]
  B --> C{"QPS 是否继续上升"}
  C -->|"上升"| D["继续增大连接数"]
  C -->|"持平或下降"| E["拐点即数据库并发上限"]
  D --> B
  E --> F["取拐点略偏小的值作为配置"]

management:
  endpoints:
    web:
      exposure:
        include: health,metrics,prometheus
  metrics:
    tags:
      application: ${spring.application.name}

java -Xms4g -Xmx4g \
     -XX:MetaspaceSize=256m \
     -XX:MaxMetaspaceSize=512m \
     -XX:+HeapDumpOnOutOfMemoryError \
     -XX:HeapDumpPath=/data/dump \
     -jar app.jar

java -XX:MaxRAMPercentage=70.0 -XX:InitialRAMPercentage=70.0 -jar app.jar

-XX:+UseG1GC \
-XX:MaxGCPauseMillis=100 \
-XX:G1HeapRegionSize=8m \
-XX:InitiatingHeapOccupancyPercent=45

-XX:+UseZGC \
-XX:+ZGenerational \
-Xmx16g

flowchart TD
  A["确定堆大小与延迟目标"] --> B{"堆是否大于 16G"}
  B -->|"否"| C{"P99 对 GC 停顿是否敏感"}
  B -->|"是"| D["优先 ZGC"]
  C -->|"不敏感"| E["G1 + MaxGCPauseMillis"]
  C -->|"敏感"| D
  D --> F["JDK 17+ 开启 ZGC，JDK 21 用分代 ZGC"]
  E --> G["切换后重新压测验证"]
  F --> G

SET GLOBAL slow_query_log = 'ON';
SET GLOBAL long_query_time = 1;
SET GLOBAL log_queries_not_using_indexes = 'ON';

# application.yml
spring:
  datasource:
    driver-class-name: com.p6spy.engine.spy.P6SpyDriver
    url: jdbc:p6spy:mysql://localhost:3306/demo

public class RoutingDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.get();
    }
}

public class DataSourceContextHolder {
    private static final ThreadLocal<String> CONTEXT = new ThreadLocal<>();

    public static void set(String key) { CONTEXT.set(key); }
    public static String get() { return CONTEXT.get(); }
    public static void clear() { CONTEXT.remove(); }
}

flowchart TD
  A["业务方法调用"] --> B{"是否标注 @ReadOnly"}
  B -->|"是"| C["ThreadLocal 标记 slave"]
  B -->|"否"| D["ThreadLocal 标记 master"]
  C --> E["AbstractRoutingDataSource 路由"]
  D --> E
  E --> F["执行 SQL"]
  F --> G["方法结束清理 ThreadLocal"]
  G --> H{"是否写后立即读"}
  H -->|"是"| I["强制走主库，规避主从延迟"]
  H -->|"否"| J["正常返回"]

@Configuration
@EnableAsync
public class AsyncConfig {

    @Bean("bizExecutor")
    public Executor bizExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(8);
        executor.setMaxPoolSize(16);
        executor.setQueueCapacity(200);
        executor.setThreadNamePrefix("biz-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}

@Service
public class NotifyService {

    @Async("bizExecutor")
    public void sendAsync(Long userId, String msg) {
        // 发送通知
    }
}

sequenceDiagram
  participant C as "客户端"
  participant T as "Tomcat 工作线程"
  participant P as "业务线程池"
  participant D as "下游服务"
  C->>T: "发起请求"
  T->>P: "提交异步任务"
  T-->>C: "立即返回（或等待结果）"
  P->>D: "执行耗时逻辑"
  D-->>P: "返回结果"
  P-->>C: "回调 / 结果推送"

server:
  compression:
    enabled: true
    min-response-size: 2KB
    mime-types: application/json,application/xml,text/html,text/plain

@Bean
public RestTemplate restTemplate() {
    PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
    cm.setMaxTotal(200);
    cm.setDefaultMaxPerRoute(50);

    RequestConfig config = RequestConfig.custom()
            .setConnectTimeout(2000)
            .setSocketTimeout(5000)
            .setConnectionRequestTimeout(1000)
            .build();

    CloseableHttpClient client = HttpClients.custom()
            .setConnectionManager(cm)
            .setDefaultRequestConfig(config)
            .build();

    return new RestTemplate(new HttpComponentsClientHttpRequestFactory(client));
}

<configuration>
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/app.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>logs/app.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
            <maxFileSize>100MB</maxFileSize>
            <maxHistory>15</maxHistory>
            <totalSizeCap>5GB</totalSizeCap>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <appender name="ASYNC_FILE" class="ch.qos.logback.classic.AsyncAppender">
        <queueSize>1024</queueSize>
        <discardingThreshold>0</discardingThreshold>
        <neverBlock>true</neverBlock>
        <appender-ref ref="FILE"/>
    </appender>
    <root level="INFO">
        <appender-ref ref="ASYNC_FILE"/>
    </root>
</configuration>

// 错误：无论日志级别是否开启，字符串都会拼接
log.debug("user=" + userId + ", order=" + orderId);

// 正确：使用占位符，级别不满足时不会执行 toString
log.debug("user={}, order={}", userId, orderId);

// 需要复杂计算时用条件判断
if (log.isDebugEnabled()) {
    log.debug("detail={}", buildExpensiveDetail());
}

flowchart LR
  A["应用指标"] --> D["统一监控看板"]
  B["JVM 指标"] --> D
  C["数据库指标"] --> D
  A --> A1["QPS / P99 / 错误率"]
  B --> B1["堆使用率 / GC 次数 / GC 停顿"]
  C --> C1["慢 SQL / 连接数 / 锁等待"]