重学SpringBoot3-异步编程完全指南

更多SpringBoot3内容请关注我的专栏：《SpringBoot3》

期待您的点赞👍收藏⭐评论✍

重学SpringBoot3-异步编程完全指南

[1. 简介](#1. 简介)
[2. @Async注解](#2. @Async注解)
- [2.1 基础配置](#2.1 基础配置)
- [2.2 基本使用](#2.2 基本使用)
- [2.3 自定义线程池](#2.3 自定义线程池)
[3. WebFlux响应式编程](#3. WebFlux响应式编程)
- [3.1 依赖配置](#3.1 依赖配置)
- [3.2 响应式Controller示例](#3.2 响应式Controller示例)
- [3.3 响应式Service实现](#3.3 响应式Service实现)
[4. CompletableFuture的使用](#4. CompletableFuture的使用)
- [4.1 基本操作](#4.1 基本操作)
- [4.2 组合操作](#4.2 组合操作)
[5. 事件驱动模型](#5. 事件驱动模型)
- [5.1 自定义事件](#5.1 自定义事件)
- [5.2 事件监听器](#5.2 事件监听器)
[6. 消息队列(MQ)异步处理](#6. 消息队列(MQ)异步处理)
- [6.1 RabbitMQ配置](#6.1 RabbitMQ配置)
- [6.2 消息队列配置类](#6.2 消息队列配置类)
- [6.3 消息生产者](#6.3 消息生产者)
- [6.4 消息消费者](#6.4 消息消费者)
- [6.5 消息确认机制](#6.5 消息确认机制)
[7. 最佳实践](#7. 最佳实践)
- [7.1 异常处理](#7.1 异常处理)
- [7.2 线程池配置](#7.2 线程池配置)
- [7.3 性能优化](#7.3 性能优化)
- [7.4 消息队列使用建议](#7.4 消息队列使用建议)
[8. 总结](#8. 总结)
参考资料

1. 简介

在现代应用程序开发中，异步编程已经成为提升应用性能和用户体验的重要手段。SpringBoot 3提供了多种异步编程的方式，本文将详细介绍这些实现方式及其最佳实践。

2. @Async注解

2.1 基础配置

首先需要在启动类或配置类上启用异步支持：

java 复制代码

@EnableAsync
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

2.2 基本使用

java 复制代码

@Service
public class EmailService {
    @Async
    public CompletableFuture<String> sendEmail(String to) {
        // 模拟发送邮件耗时
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return CompletableFuture.completedFuture("邮件发送成功：" + to);
    }
}

2.3 自定义线程池

java 复制代码

@Configuration
public class AsyncConfig implements AsyncConfigurer {
    
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(25);
        executor.setThreadNamePrefix("AsyncThread-");
        executor.initialize();
        return executor;
    }
    
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new SimpleAsyncUncaughtExceptionHandler();
    }
}

3. WebFlux响应式编程

3.1 依赖配置

xml 复制代码

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

3.2 响应式Controller示例

java 复制代码

@RestController
@RequestMapping("/api")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping("/users")
    public Flux<User> getAllUsers() {
        return userService.findAllUsers();
    }
    
    @GetMapping("/users/{id}")
    public Mono<User> getUser(@PathVariable String id) {
        return userService.findById(id);
    }
}

3.3 响应式Service实现

java 复制代码

@Service
public class UserService {
    
    public Flux<User> findAllUsers() {
        return Flux.fromIterable(users)
                   .delayElements(Duration.ofMillis(100));
    }
    
    public Mono<User> findById(String id) {
        return Mono.justOrEmpty(findUserById(id))
                   .delayElement(Duration.ofMillis(100));
    }
}

4. CompletableFuture的使用

4.1 基本操作

java 复制代码

@Service
public class OrderService {
    
    public CompletableFuture<Order> processOrder(Order order) {
        return CompletableFuture.supplyAsync(() -> {
            // 处理订单逻辑
            return order;
        });
    }
    
    public CompletableFuture<Order> validateOrder(Order order) {
        return CompletableFuture.supplyAsync(() -> {
            // 验证订单逻辑
            return order;
        });
    }
}

4.2 组合操作

java 复制代码

public CompletableFuture<Order> createOrder(Order order) {
    return validateOrder(order)
            .thenCompose(this::processOrder)
            .thenApply(processedOrder -> {
                // 更新订单状态
                return processedOrder;
            })
            .exceptionally(ex -> {
                // 异常处理
                log.error("订单处理失败", ex);
                return null;
            });
}

5. 事件驱动模型

5.1 自定义事件

java 复制代码

public class OrderCreatedEvent extends ApplicationEvent {
    private final Order order;
    
    public OrderCreatedEvent(Object source, Order order) {
        super(source);
        this.order = order;
    }
    
    public Order getOrder() {
        return order;
    }
}

5.2 事件监听器

java 复制代码

@Component
public class OrderEventListener {
    
    @Async
    @EventListener
    public void handleOrderCreatedEvent(OrderCreatedEvent event) {
        Order order = event.getOrder();
        // 异步处理订单逻辑
    }
}

6. 消息队列(MQ)异步处理

6.1 RabbitMQ配置

xml 复制代码

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

yaml 复制代码

spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest

6.2 消息队列配置类

java 复制代码

@Configuration
public class RabbitMQConfig {
    
    @Bean
    public Queue orderQueue() {
        return new Queue("order.queue", true);
    }
    
    @Bean
    public DirectExchange orderExchange() {
        return new DirectExchange("order.exchange");
    }
    
    @Bean
    public Binding orderBinding(Queue orderQueue, DirectExchange orderExchange) {
        return BindingBuilder.bind(orderQueue)
                .to(orderExchange)
                .with("order.routing.key");
    }
}

6.3 消息生产者

java 复制代码

@Service
@Slf4j
public class OrderProducer {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public void sendOrder(Order order) {
        try {
            rabbitTemplate.convertAndSend("order.exchange", "order.routing.key", order);
            log.info("订单消息发送成功: {}", order.getId());
        } catch (Exception e) {
            log.error("订单消息发送失败", e);
        }
    }
}

6.4 消息消费者

java 复制代码

@Component
@Slf4j
public class OrderConsumer {
    
    @RabbitListener(queues = "order.queue")
    public void processOrder(Order order) {
        try {
            log.info("收到订单消息: {}", order.getId());
            // 异步处理订单逻辑
            processOrderAsync(order);
        } catch (Exception e) {
            log.error("订单处理失败", e);
        }
    }
    
    private void processOrderAsync(Order order) {
        // 具体的订单处理逻辑
    }
}

6.5 消息确认机制

java 复制代码

@Configuration
public class RabbitMQConfirmConfig {
    
    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        
        // 消息发送到交换机确认
        rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
            if (!ack) {
                log.error("消息发送到交换机失败: {}", cause);
            }
        });
        
        // 消息从交换机路由到队列确认
        rabbitTemplate.setReturnsCallback(returned -> {
            log.error("消息从交换机路由到队列失败: {}", returned);
        });
        
        return rabbitTemplate;
    }
}

7. 最佳实践

7.1 异常处理

使用@Async时要注意异常处理
为异步方法返回Future或CompletableFuture以便跟踪执行状态
实现AsyncUncaughtExceptionHandler处理未捕获的异常
MQ消费者要做好消息重试和死信队列处理

7.2 线程池配置

根据业务需求合理配置线程池参数
为不同业务场景配置不同的线程池
监控线程池状态，避免资源耗尽

7.3 性能优化

合理使用响应式编程，避免过度使用
注意内存泄漏问题
实现优雅停机机制
MQ消息要控制大小，避免消息堆积

7.4 消息队列使用建议

选择合适的消息投递模式（同步/异步）
实现消息幂等性处理
合理设置消息过期时间
监控消息积压情况
实现消息追踪机制

8. 总结

SpringBoot 3提供了丰富的异步编程支持，从简单的@Async注解到响应式编程，再到事件驱动模型和消息队列，开发者可以根据具体需求选择合适的方案。在实际应用中，需要注意异常处理、资源管理和性能优化等方面的问题。

消息队列作为一种重要的异步处理方式，特别适合处理耗时操作、削峰填谷以及系统解耦。在使用时需要注意消息的可靠性投递、幂等性处理以及性能监控等方面的问题。

参考资料

Spring官方文档
Spring WebFlux文档
Java CompletableFuture API文档
Spring AMQP文档
RabbitMQ官方文档