★★★★★
★★★★★
★★★★★
★★★★
★★★★★
Mono.fromCallable(() -> dbQuery()) // 在subscribeOn指定的线程执行
.publishOn(Schedulers.parallel()) // 切换到parallel线程池
.map(data -> transform(data)) // 在parallel线程池执行
.subscribeOn(Schedulers.boundedElastic()) // 数据源在boundedElastic执行
★★★★
★★★★
flux.retryWhen(Retry.backoff(3, Duration.ofSeconds(1))
.maxBackoff(Duration.ofSeconds(10))
.filter(e -> e instanceof TimeoutException))
★★★★
★★★★★
★★★★
@RestController
@RequestMapping("/api/users")
public class UserController {
@Autowired UserService userService;
@GetMapping("/{id}")
public Mono<User> getUser(@PathVariable String id) {
return userService.findById(id);
}
@GetMapping
public Flux<User> listUsers() {
return userService.findAll();
}
@PostMapping
public Mono<User> createUser(@RequestBody User user) {
return userService.save(user);
}
}
★★★★★
WebClient webClient = WebClient.create("http://order-service");
Mono<Order> order = webClient.get()
.uri("/api/orders/{id}", orderId)
.header("Authorization", token)
.retrieve()
.bodyToMono(Order.class)
.onErrorResume(e -> Mono.just(new Order(-1L, "降级")));
★★★★
@Component
@Order(-2)
public class GlobalExceptionHandler implements WebExceptionHandler {
@Override
public Mono<Void> handle(ServerWebExchange exchange, Throwable ex) {
if (ex instanceof BusinessException) {
exchange.getResponse().setStatusCode(HttpStatus.BAD_REQUEST);
return exchange.getResponse().writeWith(
Mono.just(exchange.getResponse().bufferFactory()
.wrap(("{\"error\":\"" + ex.getMessage() + "\"}").getBytes())));
}
return Mono.error(ex);
}
}
★★★★
@Component
public class AuthWebFilter implements WebFilter {
@Override
public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
String token = exchange.getRequest().getHeaders().getFirst("Authorization");
if (token == null) {
exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
return exchange.getResponse().setComplete();
}
return chain.filter(exchange);
}
}
★★★★
@GetMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<ServerSentEvent<ChatMessage>> streamChat() {
return Flux.interval(Duration.ofMillis(100))
.map(seq -> ServerSentEvent.<ChatMessage>builder()
.id(String.valueOf(seq))
.event("message")
.data(new ChatMessage("AI", "Response " + seq))
.build());
}
★★★★
@Component
public class ChatHandler implements WebSocketHandler {
@Override
public Mono<Void> handle(WebSocketSession session) {
Flux<String> input = session.receive().map(msg -> msg.getPayloadAsText());
Flux<WebSocketMessage> output = input.map(msg ->
session.textMessage("Echo: " + msg));
return session.send(output);
}
}
★★★★
Mono<Authentication> auth = ReactiveSecurityContextHolder.getContext()
.map(SecurityContext::getAuthentication);
@Bean
SecurityWebFilterChain springSecurity(ServerHttpSecurity http) {
http.csrf().disable()
.authorizeExchange(ex -> ex.pathMatchers("/api/public/**").permitAll()
.anyExchange().authenticated())
.oauth2ResourceServer(ServerHttpSecurity.OAuth2ResourceServerSpec::jwt);
return http.build();
}
★★★★
★★★★
★★★★
★★★★
public interface UserRepository extends ReactiveCrudRepository<User, Long> {
Mono<User> findByUsername(String username);
Flux<User> findByAgeGreaterThan(int age);
}
@Service
public class UserService {
@Autowired UserRepository repo;
public Mono<User> getUser(Long id) { return repo.findById(id); }
public Flux<User> listUsers() { return repo.findAll(); }
public Mono<User> save(User user) { return repo.save(user); }
}
★★★
@Autowired TransactionalOperator txOp;
public Mono<Void> transferMoney() {
return accountRepo.debit(fromId, amount)
.then(accountRepo.credit(toId, amount))
.as(txOp::transactional);
}
★★★★
★★★
spring:
r2dbc:
url: r2dbc:postgresql://localhost:5432/mydb
pool:
enabled: true
max-size: 20
min-idle: 5
max-idle-time: 30m
★★★★
@Autowired ReactiveRedisTemplate<String, String> redisTemplate;
public Mono<String> getValue(String key) {
return redisTemplate.opsForValue().get(key);
}
public Mono<Boolean> setValue(String key, String value) {
return redisTemplate.opsForValue().set(key, value, Duration.ofMinutes(30));
}
★★★★
public interface OrderRepository extends ReactiveMongoRepository<Order, String> {
Flux<Order> findByUserId(String userId);
}
@Autowired ReactiveMongoTemplate mongoTemplate;
public Flux<Order> findOrders(String userId) {
Query query = Query.query(Criteria.where("userId").is(userId));
return mongoTemplate.find(query, Order.class);
}
★★★★★
| 维度 | Spring MVC | Spring WebFlux |
|---|---|---|
| 线程模型 | 线程池(Tomcat 200线程) | 事件循环(Netty,CPU×2线程) |
| 阻塞 | 允许阻塞操作 | 不能阻塞EventLoop |
| 吞吐 | 受线程数限制 | 理论无限(IO等待不占线程) |
| 调试 | 简单(同步调用栈) | 困难(异步调用栈不连续) |
| 生态 | 完善成熟 | 相对不成熟 |
| 适用 | 通用业务系统 | IO密集高并发 |
★★★★★
Mono.fromCallable(() -> blockingDbQuery())
.subscribeOn(Schedulers.boundedElastic())
★★★★
flux.map(this::transform)
.log("transform.stage")
.checkpoint("after-transform")
.subscribe();
★★★★
Flux.fromIterable(urls)
.flatMap(url -> webClient.get().uri(url).retrieve().bodyToMono(String.class), 10)
flatMap的第二个参数10表示最多10个并发请求。
★★★
@PostMapping("/upload")
public Mono<String> upload(@RequestPart FilePart file) {
return file.transferTo(Paths.get("/uploads/" + file.filename()))
.thenReturn("uploaded: " + file.filename());
}
@GetMapping("/download/{name}")
public Mono<Void> download(@PathVariable String name, ServerHttpResponse response) {
response.getHeaders().setContentDisposition(ContentDisposition.parse("attachment; filename=" + name));
return response.writeWith(DataBufferUtils.read(Paths.get("/files/" + name),
response.bufferFactory(), 8192));
}
★★★★
@PostMapping
public Mono<String> handle(ServerRequest request) {
return request.bodyToMono(String.class);
}
★★★★
@Autowired WebTestClient webTestClient;
@Test
void testGetUser() {
webTestClient.get().uri("/api/users/1")
.exchange()
.expectStatus().isOk()
.expectBody(User.class)
.isEqualTo(new User(1L, "Alice"));
}
StepVerifier.create(userService.findById("1"))
.expectNext(new User("1", "Alice"))
.verifyComplete();
★★★
Mono<User> cached = userService.findById(id).cache(Duration.ofMinutes(5));
public Mono<User> getUser(String id) {
return redisTemplate.opsForValue().get("user:" + id)
.switchIfEmpty(userRepository.findById(id)
.flatMap(user -> redisTemplate.opsForValue()
.set("user:" + id, user, Duration.ofMinutes(30))
.thenReturn(user)));
}
★★★
★★★★★
★★★★
★★★★
@Autowired ReactiveDiscoveryClient discoveryClient;
@Autowired ReactiveLoadBalancer.Factory<ServiceInstance> loadBalancerFactory;
public Mono<Order> callOrderService(String orderId) {
return Mono.fromCallable(() ->
loadBalancerFactory.getInstance("order-service").choose().getServer())
.subscribeOn(Schedulers.boundedElastic())
.flatMap(instance -> webClient.get()
.uri("http://" + instance.getHost() + ":" + instance.getPort() + "/api/orders/" + orderId)
.retrieve().bodyToMono(Order.class));
}
★★★★★
@GetMapping(value = "/chat/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<String> streamChat(@RequestParam String message) {
return chatClient.prompt().user(message).stream()
.chatResponse()
.map(response -> response.getResult().getOutput().getText());
}
★★★★
CircuitBreaker cb = CircuitBreaker.ofDefaults("orderService");
Mono<Order> result = webClient.get().uri("/orders/1")
.retrieve().bodyToMono(Order.class)
.transform(CircuitBreakerOperator.of(cb))
.onErrorResume(e -> Mono.just(new Order(-1L, "降级")));
★★★
★★★★★
@RestController
@RequestMapping("/api/chat")
public class ChatController {
@Autowired ChatClient chatClient;
@GetMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<ServerSentEvent<String>> streamChat(@RequestParam String message) {
return chatClient.prompt().user(message).stream()
.chatResponse()
.map(resp -> ServerSentEvent.<String>builder()
.data(resp.getResult().getOutput().getText())
.build())
.concatWith(Flux.just(ServerSentEvent.<String>builder().event("[DONE]").build()));
}
}
★★★★
public Flux<String> ragStream(String query) {
return Mono.fromCallable(() -> vectorStore.similaritySearch(query))
.subscribeOn(Schedulers.boundedElastic())
.flatMapMany(docs -> {
String context = docs.stream().map(Document::getText).collect(joining("\n"));
String prompt = "基于以下内容回答问题:\n" + context + "\n问题:" + query;
return chatClient.prompt().user(prompt).stream()
.chatResponse()
.map(resp -> resp.getResult().getOutput().getText());
});
}
★★★★
public Flux<String> chatWithTools(String message) {
return chatClient.prompt().user(message).functions("getWeather").stream()
.chatResponse()
.map(resp -> resp.getResult().getOutput().getText());
}
★★★★
@Component
public class ChatWebSocketHandler implements WebSocketHandler {
@Autowired ChatClient chatClient;
@Override
public Mono<Void> handle(WebSocketSession session) {
Flux<WebSocketMessage> output = session.receive()
.map(msg -> msg.getPayloadAsText())
.flatMap(query -> chatClient.prompt().user(query).stream()
.chatResponse()
.map(resp -> resp.getResult().getOutput().getText()))
.map(session::textMessage);
return session.send(output);
}
}
★★★★
★★★★
public Flux<AgentStep> agentLoop(String query) {
return Flux.defer(() -> {
// Step 1: LLM决策
return chatClient.prompt().user(query).stream()
.chatResponse()
.map(resp -> parseAction(resp))
.flatMap(action -> {
if (action.isFinish()) return Flux.just(new AgentStep("final", action.getAnswer()));
// Step 2: 执行Tool
return Mono.fromCallable(() -> toolExecutor.execute(action))
.subscribeOn(Schedulers.boundedElastic())
.flatMapMany(result -> {
// Step 3: 将Tool结果反馈给LLM
return agentLoop(query + "\nTool结果: " + result);
});
});
});
}
★★★★
public interface ConversationRepository extends ReactiveCrudRepository<Conversation, Long> {
Flux<Conversation> findBySessionIdOrderByCreatedAt(String sessionId);
}
public Mono<String> chat(String sessionId, String message) {
return conversationRepo.findBySessionIdOrderByCreatedAt(sessionId)
.collectList()
.flatMap(history -> {
String fullPrompt = buildPrompt(history, message);
return chatClient.prompt().user(fullPrompt).call()
.chatResponse().map(resp -> resp.getResult().getOutput().getText())
.flatMap(answer -> conversationRepo.saveAll(List.of(
new Conversation(sessionId, "user", message),
new Conversation(sessionId, "assistant", answer)
)).then(Mono.just(answer)));
});
}
★★★★
public Mono<Boolean> checkRateLimit(String userId) {
String key = "rate_limit:" + userId;
return reactiveRedisTemplate.opsForValue().increment(key)
.flatMap(count -> {
if (count == 1) {
return reactiveRedisTemplate.expire(key, Duration.ofMinutes(1)).thenReturn(true);
}
return Mono.just(count <= 100);
});
}
★★★★
chatClient.prompt().user(query).stream()
.chatResponse()
.doOnNext(resp -> {
Usage usage = resp.getMetadata().getUsage();
meterRegistry.counter("ai.tokens.input").increment(usage.getPromptTokens());
meterRegistry.counter("ai.tokens.output").increment(usage.getGenerationTokens());
})
★★★★★