Java使用WebFlux调用大模型实现智能对话

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

        </dependency>
         <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

@Data
public class AiPromptDto {
    /**
     * 大模型id
     */
    private String serviceId;
    /**
     * 用户输入
     */
    private String userInput;
    /**
     * sessionId
     */
    private String sessionId;
    /**
     * 请求id
     */
    private String requestId;
    /**
     * 获取token
     */
    private String token;
    }

@Data
@AllArgsConstructor
public class AnswerChunk {
    /**
     * 返回的内容
     */
    private String content;
    private String sessionId;
}

reactor:
  netty:
    response:
      buffer-size: 0

public interface AiService {
    /**
     * 根据请求获取流式返回的答案
     * @param request
     * @return
     */
    Flux<AnswerChunk>  processStream(AiPromptDto request);
    }

import org.springframework.web.reactive.function.client.WebClient;
@Service
public class AIServiceImpl implements AiService {
    private final WebClient webClient;
    //初始化webClient，并ssl校验，生产环境不要跳过
    public AIServiceImpl(WebClient.Builder webClientBuilder) {
        // 使用InsecureTrustManagerFactory来信任所有证书
        SslContextBuilder sslContextBuilder = SslContextBuilder.forClient()
                .trustManager(InsecureTrustManagerFactory.INSTANCE);
        HttpClient httpClient = HttpClient.create()
                .secure(sslContextSpec -> sslContextSpec.sslContext(sslContextBuilder))
                .responseTimeout(Duration.ofMinutes(timeout));
        this.webClient = webClientBuilder.clientConnector(
                new ReactorClientHttpConnector(httpClient)
        ).baseUrl(aiForceUrl).build();
    }
  @Override
    public Flux<AnswerChunk> processStream(AiPromptDto request) {
   String body = JSONUtil.toJsonStr(request);//参数都转化为json字符串
   return webClient.post()
                    .uri(aiForceUrl + "/aiforceplatformapi/openapi/llm/debugSse")//大模型地址
                    .bodyValue(body)//body参数
                    .header("token", request.getToken())//设置请求头
                    .header("Content-Type", "application/json")
                    .retrieve()//retrieve 方法会从服务器响应中提取数据
                    .bodyToFlux(String.class)//响应体解析为一个流式的 String 类型序列
                    .map(chunk -> {//解析数据以供存储
                        //System.out.println("chunk = " + chunk);
                        String content = "";
                        // 解析大模型返回数据
                        if (!chunk.contains("[DONE]")) {//结束标志
                            if (chunk.contains("inquiryList")) {//处理返回的关联查询列表
                                content = parseChunk(chunk);
                                finalAnswer[0].setQueryList(content);
                            }else if (chunk.contains("messageId")&&chunk.contains("messageContent")) {//处理返回提示message
                                parseMessage(chunk, messageMap);
                            }  else if (chunk.contains("data")) {//处理返回的问题答案
                                content = parseChunk(chunk);
                                redisTemplate.opsForValue().append(request.getRequestId() + "_result", content);
                            } else if (chunk.contains("question")) {//处理返回question
                                //先删除
                                questionService.deleteQuestionsByPreviousIdAndRequest(questionId, requestId);
                                //保存ai返回的question
                            } else if (chunk.contains("image")) {//处理图片
                                parseImages(chunk, imagesUrl);
                            } else if (chunk.contains("referenceInfo")) {//处理参照信息
                                parseReference(chunk, aiAnswerReferenceList);
                            }
                        } else {
                            // 处理结束
                            end.set("[DONE]")；
                            finalAnswer[0].setState("DONE");
                        }
                        if (StringUtils.isEmpty(chunk)) {
                            chunk = "";
                        }
                        return new AnswerChunk(chunk, request.getRequestId());
                    })
                    .doOnComplete(() -> {//答案都完成后存储对应数据到数据库中
                        String finalContent = redisTemplate.opsForValue().get(request.getRequestId() + "_result");
                        redisTemplate.delete(request.getRequestId());
                        //保存答案
                        String returnAnswer = "";
                        JSONObject answer1 = new JSONObject().putOnce("data", finalContent);
                        //具体实现
                    })
                    .onErrorResume(e -> {//错误情况处理
                        finalAnswer[0].setState("FAILED");
                        answerService.saveOrUpdate(finalAnswer[0]);
                        return Flux.error(e);
                    });
}
}

@RestController
@RequestMapping("/aiAgent")
public class AiForceController {
   /**
     * 获取内容
     *
     * @param request MediaType.TEXT_EVENT_STREAM_VALUE 流式输出，否则会一次返回
     *                charset=UTF-8 字符集，不设置会乱码
     *                注意：使用get会中文乱码
     * @return
     */
    @PostMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE + ";charset=UTF-8")
    public Flux<ServerSentEvent<String>> streamResponse(@RequestBody AiForcePromptDto request) {
        return aiService.processStream(request)
                .limitRate(100) // 限制每秒最大请求数
                .onBackpressureBuffer(100,//背压策略：缓冲区大小为 100
                buffer -> {
                    logger.warn("Backpressure buffer overflow, dropping {} items", buffer);
                }).publishOn(Schedulers.boundedElastic(),1) // 单线程调度确保顺序
                .flatMap(chunk -> { // 使用 flatMap 将一个异步流中的每个元素映射为另一个流，并将这些流合并为一个单一的流
                    String content = chunk.getContent();
                    if (StringUtils.isNotBlank(content)) {
                        String processedContent = content.replaceAll("`{3}", "\n```"); // 规范代码块格式
                        return Flux.just(ServerSentEvent.<String>builder()
                                .id(request.getRequestId())
                                .data(processedContent)
                                .build());
                    }
                    return Flux.empty();//如果内容为空，就返回空的flux
                }, 1) // 设置并发度为 1，确保逐条发送
                .doOnNext(event -> logger.info("Streaming chunk: {}", event.data())); // 日志记录每次发送的数据
    }
}
// Flux<ServerSentEvent<String>> 实现 SSE（Server-Sent Events），以便客户端可以实时接收服务器推送的消息