用 Spring Boot 3 构建高性能 RESTful API 的 10 个关键技巧

引言

随着微服务架构的普及和云原生应用的发展，构建高性能的 RESTful API 已成为现代软件开发的核心需求。Spring Boot 3 作为 Spring 生态系统的最新版本，带来了许多性能优化和新特性，为构建高性能 API 提供了强大的支持。

在本文中，我们将深入探讨 10 个关键技巧，这些技巧涵盖了从配置优化到代码实现的各个方面，帮助开发者构建出响应迅速、资源利用率高的 RESTful API。这些技巧不仅适用于新项目，也适用于现有项目的性能优化。

技巧 1：优化 Spring Boot 启动性能

Spring Boot 应用的启动时间直接影响开发效率和部署速度。通过合理的配置优化，我们可以显著减少应用启动时间。

application.properties
spring.main.banner-mode=off
spring.main.lazy-initialization=true
spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration
spring.context.bootstrap.classes=org.springframework.boot.test.mock.mockito.MockitoPostProcessor

禁用不必要的自动配置

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration,org.springframework.boot.actuate.autoconfigure.security.servlet.ManagementWebSecurityAutoConfiguration

@Configuration
public class PerformanceOptimizationConfig {
   
@Primary
public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
   
    PropertySourcesPlaceholderConfigurer configurer = new PropertySourcesPlaceholderConfigurer();
    configurer.setLocalOverride(true);
    return configurer;
}

@Bean
public static BeanFactoryPostProcessor beanFactoryPostProcessor() {
   
    return new BeanFactoryPostProcessor() {
   
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
   
            // 优化 Bean 工厂配置
        }
    };
}
}

通过延迟初始化和排除不必要的自动配置，我们可以将启动时间减少 30-50%。

技巧 2：合理配置连接池和数据库访问

数据库连接池是影响 API 性能的关键因素。Spring Boot 3 支持多种连接池，合理配置可以显著提升性能。
application.properties

spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.connection-timeout=20000
spring.datasource.hikari.idle-timeout=300000
spring.datasource.hikari.max-lifetime=1200000
spring.datasource.hikari.leak-detection-threshold=60000

JPA 优化配置

spring.jpa.properties.hibernate.jdbc.batch_size=25
spring.jpa.properties.hibernate.order_inserts=true
spring.jpa.properties.hibernate.order_updates=true
spring.jpa.properties.hibernate.jdbc.batch_versioned_data=true
spring.jpa.properties.hibernate.generate_statistics=false

@Configuration
@EnableJpaRepositories
public class DatabaseConfig {
   
@Bean
@Primary
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
   
    LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
    em.setDataSource(dataSource());
    em.setPackagesToScan("com.example.entity");

    JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
    em.setJpaVendorAdapter(vendorAdapter);

    Properties properties = new Properties();
    properties.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect");
    properties.setProperty("hibernate.hbm2ddl.auto", "validate");
    properties.setProperty("hibernate.jdbc.time_zone", "UTC");
    properties.setProperty("hibernate.cache.use_second_level_cache", "false");
    properties.setProperty("hibernate.cache.use_query_cache", "false");
    em.setJpaProperties(properties);

    return em;
}

@Bean
public PlatformTransactionManager transactionManager() {
   
    JpaTransactionManager transactionManager = new JpaTransactionManager();
    transactionManager.setEntityManagerFactory(entityManagerFactory().getObject());
    return transactionManager;
}

@Bean
public JdbcTemplate jdbcTemplate(DataSource dataSource) {
   
    JdbcTemplate template = new JdbcTemplate(dataSource);
    template.setFetchSize(1000); // 设置合理的 fetch size
    return template;
}
}

技巧 3：实现高效的缓存策略

缓存是提升 API 性能的重要手段。Spring Boot 3 提供了强大的缓存支持，合理使用缓存可以显著减少数据库访问。
application.properties

spring.cache.type=redis
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.timeout=2000ms
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0
spring.redis.lettuce.pool.max-wait=-1ms

@Configuration
@EnableCaching
public class CacheConfig extends CachingConfigurerSupport {
   
@Bean
public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
   
    RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(10))
            .serializeKeysWith(RedisSerializationContext.SerializationPair
                    .fromSerializer(new StringRedisSerializer()))
            .serializeValuesWith(RedisSerializationContext.SerializationPair
                    .fromSerializer(new GenericJackson2JsonRedisSerializer()));

    return RedisCacheManager.builder(connectionFactory)
            .cacheDefaults(config)
            .build();
}

@Bean
public KeyGenerator keyGenerator() {
   
    return (target, method, params) -> {
   
        StringBuilder sb = new StringBuilder();
        sb.append(target.getClass().getName());
        sb.append(method.getName());
        for (Object obj : params) {
   
            sb.append(obj.toString());
        }
        return sb.toString();
    };
}
}

@Service
public class UserService {
   
@Autowired
private UserRepository userRepository;

@Cacheable(value = "users", key = "#id")
public User findById(Long id) {
   
    return userRepository.findById(id).orElse(null);
}

@CacheEvict(value = "users", key = "#user.id")
public User update(User user) {
   
    return userRepository.save(user);
}

@Cacheable(value = "users", key = "#email")
public User findByEmail(String email) {
   
    return userRepository.findByEmail(email);
}

@CacheEvict(value = "users", allEntries = true)
public void clearUserCache() {
   
    // 清除所有用户缓存
}
}

技巧 4：优化 REST API 响应和序列化

JSON 序列化和反序列化是 API 性能的重要影响因素。通过优化 Jackson 配置，可以提升序列化性能。
application.properties

spring.jackson.serialization.write-dates-as-timestamps=false
spring.jackson.serialization.write-date-timestamps-as-nanoseconds=false
spring.jackson.serialization.fail-on-empty-beans=false
spring.jackson.deserialization.fail-on-unknown-properties=false
spring.jackson.property-naming-strategy=SNAKE_CASE
spring.jackson.default-property-inclusion=NON_NULL

@Configuration
public class JacksonConfig {
   
@Bean
@Primary
public ObjectMapper objectMapper() {
   
    ObjectMapper mapper = new ObjectMapper();
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    mapper.registerModule(new JavaTimeModule());
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

    // 自定义序列化器
    SimpleModule module = new SimpleModule();
    module.addSerializer(BigDecimal.class, new BigDecimalSerializer());
    module.addDeserializer(BigDecimal.class, new BigDecimalDeserializer());
    mapper.registerModule(module);

    return mapper;
}

public static class BigDecimalSerializer extends JsonSerializer<BigDecimal> {
   
    @Override
    public void serialize(BigDecimal value, JsonGenerator gen, SerializerProvider serializers) 
            throws IOException {
   
        gen.writeString(value.setScale(2, RoundingMode.HALF_UP).toString());
    }
}

public static class BigDecimalDeserializer extends JsonDeserializer<BigDecimal> {
   
    @Override
    public BigDecimal deserialize(JsonParser p, DeserializationContext ctxt) 
            throws IOException, JsonProcessingException {
   
        String value = p.getValueAsString();
        return value != null ? new BigDecimal(value) : null;
    }
}
}

public class ApiResponse {
   
private int code;
private String message;
private T data;
private long timestamp;
public ApiResponse(int code, String message, T data) {
   
    this.code = code;
    this.message = message;
    this.data = data;
    this.timestamp = System.currentTimeMillis();
}

public static <T> ApiResponse<T> success(T data) {
   
    return new ApiResponse<>(200, "Success", data);
}

public static <T> ApiResponse<T> error(String message) {
   
    return new ApiResponse<>(500, message, null);
}

// getters and setters
}

技巧 5：实现异步处理和响应

异步处理可以显著提升 API 的吞吐量，特别是在处理耗时操作时。

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
   
@Override
public Executor getAsyncExecutor() {
   
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(10);
    executor.setMaxPoolSize(50);
    executor.setQueueCapacity(100);
    executor.setThreadNamePrefix("async-");
    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    executor.initialize();
    return executor;
}

@Override
public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
   
    return new SimpleAsyncUncaughtExceptionHandler();
}
}

@Service
public class EmailService {
   
@Async
public CompletableFuture<String> sendEmail(String to, String subject, String body) {
   
    try {
   
        // 模拟发送邮件的耗时操作
        Thread.sleep(2000);
        System.out.println("Email sent to: " + to);
        return CompletableFuture.completedFuture("Email sent successfully");
    } catch (InterruptedException e) {
   
        Thread.currentThread().interrupt();
        throw new RuntimeException("Email sending failed", e);
    }
}
}

@RestController
public class NotificationController {
   
@Autowired
private EmailService emailService;

@PostMapping("/send-email")
public CompletableFuture<ApiResponse<String>> sendEmail(@RequestBody EmailRequest request) {
   
    return emailService.sendEmail(request.getTo(), request.getSubject(), request.getBody())
            .thenApply(result -> ApiResponse.success(result))
            .exceptionally(throwable -> ApiResponse.error(throwable.getMessage()));
}
}

技巧 6：实现高效的分页和查询优化

大数据量的查询是 API 性能的常见瓶颈。通过合理的分页和查询优化，可以显著提升性能。

public interface CustomPageableRepository<T, ID> extends JpaRepository<T, ID> {
   
@Query(value = "SELECT * FROM (SELECT t.*, ROW_NUMBER() OVER (ORDER BY id) as rn FROM table_name t) WHERE rn BETWEEN ?1 AND ?2", 
       nativeQuery = true)
Page<T> findWithRowNumber(int offset, int limit, Pageable pageable);

@Query(value = "SELECT t FROM #{#entityName} t WHERE t.status = :status")
Page<T> findByStatusWithProjection(@Param("status") String status, Pageable pageable);
}

public class QueryOptimizationService {
   
@Autowired
private EntityManager entityManager;

public Page<User> findUsersOptimized(String keyword, Pageable pageable) {
   
    String jpql = "SELECT u FROM User u WHERE u.name LIKE :keyword OR u.email LIKE :keyword";
    String countJpql = "SELECT COUNT(u) FROM User u WHERE u.name LIKE :keyword OR u.email LIKE :keyword";

    TypedQuery<User> query = entityManager.createQuery(jpql, User.class);
    TypedQuery<Long> countQuery = entityManager.createQuery(countJpql, Long.class);

    query.setParameter("keyword", "%" + keyword + "%");
    countQuery.setParameter("keyword", "%" + keyword + "%");

    query.setFirstResult((int) pageable.getOffset());
    query.setMaxResults(pageable.getPageSize());

    List<User> content = query.getResultList();
    Long total = countQuery.getSingleResult();

    return new PageImpl<>(content, pageable, total);
}

public List<UserProjection> findUserProjections(String keyword) {
   
    String jpql = "SELECT new com.example.dto.UserProjection(u.id, u.name, u.email) FROM User u WHERE u.name LIKE :keyword";
    TypedQuery<UserProjection> query = entityManager.createQuery(jpql, UserProjection.class);
    query.setParameter("keyword", "%" + keyword + "%");
    query.setMaxResults(1000); // 限制结果数量
    return query.getResultList();
}
}

public interface UserProjection {
   
Long getId();
String getName();
String getEmail();
}

技巧 7：实现 API 限流和熔断保护

API 限流和熔断保护是保证系统稳定性的关键措施。
application.properties

resilience4j.ratelimiter.instances.api.limit-for-period=100
resilience4j.ratelimiter.instances.api.limit-refresh-period=1s
resilience4j.ratelimiter.instances.api.timeout-duration=5s

resilience4j.circuitbreaker.instances.api.failure-rate-threshold=50
resilience4j.circuitbreaker.instances.api.wait-duration-in-open-state=10s
resilience4j.circuitbreaker.instances.api.permitted-number-of-calls-in-half-open-state=3

@Configuration
public class Resilience4jConfig {
   
@Bean
public RateLimiterConfig rateLimiterConfig() {
   
    return RateLimiterConfig.custom()
            .limitForPeriod(100)
            .limitRefreshPeriod(Duration.ofSeconds(1))
            .timeoutDuration(Duration.ofSeconds(1))
            .build();
}

@Bean
public CircuitBreakerConfig circuitBreakerConfig() {
   
    return CircuitBreakerConfig.custom()
            .failureRateThreshold(50)
            .waitDurationInOpenState(Duration.ofSeconds(10))
            .permittedNumberOfCallsInHalfOpenState(3)
            .slidingWindowType(SlidingWindowType.COUNT_BASED)
            .slidingWindowSize(100)
            .build();
}
}

@Service
public class ExternalApiService {
   
private final RateLimiter rateLimiter;
private final CircuitBreaker circuitBreaker;

public ExternalApiService(RateLimiterRegistry rateLimiterRegistry, 
                         CircuitBreakerRegistry circuitBreakerRegistry) {
   
    this.rateLimiter = rateLimiterRegistry.rateLimiter("api");
    this.circuitBreaker = circuitBreakerRegistry.circuitBreaker("api");
}

@RateLimiter(name = "api")
@CircuitBreaker(name = "api", fallbackMethod = "fallbackExternalCall")
public String callExternalApi(String data) {
   
    // 模拟外部 API 调用
    return restTemplate.postForObject("https://external-api.com/data", data, String.class);
}

public String fallbackExternalCall(String data, Exception ex) {
   
    return "Fallback response due to: " + ex.getMessage();
}
}

@RestController
public class RateLimitedController {
   
@Autowired
private ExternalApiService externalApiService;

@GetMapping("/external-data")
public ResponseEntity<ApiResponse<String>> getExternalData(@RequestParam String data) {
   
    try {
   
        String result = externalApiService.callExternalApi(data);
        return ResponseEntity.ok(ApiResponse.success(result));
    } catch (Exception e) {
   
        return ResponseEntity.status(500).body(ApiResponse.error(e.getMessage()));
    }
}
}

技巧 8：优化日志和监控配置

合理的日志和监控配置可以帮助我们及时发现和解决性能问题。
application.properties

logging.level.com.example=INFO
logging.level.org.springframework.web=DEBUG
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE

logging.pattern.console=%d{
   yyyy-MM-dd HH:mm:ss} - %msg%n
logging.pattern.file=%d{
   yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{
   36} - %msg%n
logging.file.name=logs/application.log
logging.file.max-size=10MB
logging.file.max-history=30

management.endpoints.web.exposure.include=health,info,metrics,prometheus
management.endpoint.health.show-details=always
management.metrics.export.prometheus.enabled=true

@Component
public class PerformanceMetricsAspect {
   
private final MeterRegistry meterRegistry;
private final Timer.Sample sample;

public PerformanceMetricsAspect(MeterRegistry meterRegistry) {
   
    this.meterRegistry = meterRegistry;
}

@Around("@annotation(MonitorPerformance)")
public Object monitorPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
   
    Timer.Sample sample = Timer.start(meterRegistry);

    try {
   
        Object result = joinPoint.proceed();
        sample.stop(Timer.builder("api.method.execution.time")
                .tag("method", joinPoint.getSignature().getName())
                .register(meterRegistry));
        return result;
    } catch (Throwable throwable) {
   
        sample.stop(Timer.builder("api.method.execution.time")
                .tag("method", joinPoint.getSignature().getName())
                .tag("error", "true")
                .register(meterRegistry));
        throw throwable;
    }
}
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MonitorPerformance {
   
}

@RestController
public class MetricsController {
   
@Autowired
private MeterRegistry meterRegistry;

@MonitorPerformance
@GetMapping("/users/{id}")
public ResponseEntity<User> getUser(@PathVariable Long id) {
   
    // 添加自定义指标
    Counter.builder("user.requests")
            .tag("endpoint", "/users/{id}")
            .register(meterRegistry)
            .increment();

    User user = userService.findById(id);
    return ResponseEntity.ok(user);
}
}

技巧 9：实现高效的异常处理和错误响应

统一的异常处理机制不仅可以提升 API 的健壮性，还能改善用户体验。

@ControllerAdvice
public class GlobalExceptionHandler {
   
private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);

@ExceptionHandler(EntityNotFoundException.class)
public ResponseEntity<ApiResponse<String>> handleEntityNotFound(EntityNotFoundException ex) {
   
    logger.warn("Entity not found: {}", ex.getMessage());
    return ResponseEntity.status(HttpStatus.NOT_FOUND)
            .body(ApiResponse.error("Resource not found: " + ex.getMessage()));
}

@ExceptionHandler(ValidationException.class)
public ResponseEntity<ApiResponse<String>> handleValidation(ValidationException ex) {
   
    logger.warn("Validation error: {}", ex.getMessage());
    return ResponseEntity.status(HttpStatus.BAD_REQUEST)
            .body(ApiResponse.error("Validation failed: " + ex.getMessage()));
}

@ExceptionHandler(Exception.class)
public ResponseEntity<ApiResponse<String>> handleGeneric(Exception ex) {
   
    logger.error("Unexpected error occurred", ex);
    return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body(ApiResponse.error("Internal server error occurred"));
}

@ExceptionHandler(MethodArgumentNotValidException.class)
public ResponseEntity<ApiResponse<Map<String, String>>> handleValidationErrors(
        MethodArgumentNotValidException ex) {
   
    Map<String, String> errors = new HashMap<>();
    ex.getBindingResult().getFieldErrors().forEach(error -> 
        errors.put(error.getField(), error.getDefaultMessage()));

    return ResponseEntity.status(HttpStatus.BAD_REQUEST)
            .body(ApiResponse.error("Validation failed", errors));
}
}

public class ValidationException extends RuntimeException {
   
public ValidationException(String message) {
   
super(message);
}
}

public class EntityNotFoundException extends RuntimeException {
   
public EntityNotFoundException(String message) {
   
super(message);
}
}

技巧 10：优化部署和容器化配置

合理的部署配置可以最大化应用性能。
application-prod.properties

server.tomcat.max-threads=200
server.tomcat.min-spare-threads=10
server.tomcat.accept-count=100
server.tomcat.connection-timeout=20000

spring.datasource.hikari.maximum-pool-size=50
spring.datasource.hikari.minimum-idle=10
spring.jpa.properties.hibernate.jdbc.batch_size=50

JVM 优化参数

-Xms2g -Xmx2g -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -XX:+UseStringDeduplication

性能对比和监控

通过实施这些优化技巧，我们可以显著提升 API 的性能表现：

总结

通过实施这 10 个关键技巧，我们可以构建出高性能的 Spring Boot 3 RESTful API。这些技巧涵盖了从底层配置到上层实现的各个方面，包括启动优化、数据库访问、缓存策略、序列化优化、异步处理、查询优化、限流保护、监控配置、异常处理和部署优化。

在实际项目中，我们应该根据具体的业务需求和性能要求，选择性地应用这些技巧。同时，持续的性能监控和优化是保持 API 高性能的关键。通过合理的架构设计和持续的性能调优，我们可以构建出既满足业务需求又具备优异性能的 RESTful API。