package cn.net.dev.springai.controller;  
  
import org.springframework.ai.chat.client.ChatClient;  
import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.RequestParam;  
import org.springframework.web.bind.annotation.RestController;  
import reactor.core.publisher.Flux;  
  
@RestController  
public class ChatController {  
  
    private final ChatClient chatClient;  
    // 使用构造器自动注入
    public ChatController(ChatClient.Builder builder) {  
        this.chatClient = builder  
                .defaultSystem("你是一个个专业的Java技术顾问，回答问题简洁准确")  
                .build();  
    }  
    
/**  
 * 普通模式  
 * @param message  
 * @return  
 */  
    @RequestMapping("/chat")    
    public String chat(@RequestParam String message) {  
        return chatClient
        .prompt()  // 提示词
        .user(message)  // 用户输入的内容
        .call()  // 调用模型
        .content();   // 返回数据
    }  
  
/**  
 * 流式  
 * @param message  
 * @return  
 */
    @GetMapping(value = "/stream", produces = "text/event-stream;charset=UTF-8")  
    public Flux<String> streamChat(@RequestParam String message) {  
        return chatClient.prompt().user(message).stream().content();  
    }  
}

record Product(  
        String name,  
        List<String> prop,  
        List<String> cons,  
        int score,  
        String recommendation  
) {  
}  
  
@GetMapping("/analyze")  
public Product analyzeProduct(@RequestParam String productName) {  
    return chatClient.prompt()  
            .user("分析产品：" + productName + ",给出优缺点和推荐指数")  
            .call()  
            .entity(Product.class);  
}

record Menu(  
        String  name,  
        String ingredient,  
        String calories  
){}  
  
@RequestMapping("/menu")  
public List<Menu> recommendMenu(@RequestParam String scene) {  
    return chatClient.prompt()  
            .user("为以下人群推荐5种菜谱：" + scene)  
            .call()  
            .entity(new ParameterizedTypeReference<List<Menu>>() {  
            });  
}

package cn.net.dev.springai.service;  
  
import lombok.extern.slf4j.Slf4j;  
import org.springframework.stereotype.Service;  
  
@Slf4j  
@Service  
public class WeatherService {  
    public String getWeather(String cityName) {  
        log.info("大模型调用本工具........");  
        return """  
                🌍 城市: %s (%s)  
                ☁️ 天气数据: %s  
                """.formatted("北京", "中国", "晴");  
    }  
}
service/EmailService.java
package cn.net.dev.springai.service;  
  
import lombok.extern.slf4j.Slf4j;  
import org.springframework.stereotype.Service;  
  
@Slf4j  
@Service  
public class EmailService {  
  
    public String send(String destEmail, String subject, String body) {  
        log.info("大模型调用发送邮件工具...");  
        log.info("Subject " + subject + " body " + body);  
        return "邮件已发送给" + destEmail;  
    }  
}

package cn.net.dev.springai.tools;  
  
import cn.net.dev.springai.service.EmailService;  
import cn.net.dev.springai.service.WeatherService;  
import org.springframework.ai.tool.annotation.Tool;  
import org.springframework.ai.tool.annotation.ToolParam;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Component;  
  
@Component  
public class MyTools {  
  
    @Autowired  
    private WeatherService weatherService;  
  
    @Autowired  
    private EmailService emailService;  
  
    @Tool(description = "查询指定城市的实时天气信息")  
    public String getWeather(@ToolParam(description = "城市名称，例如：北京") String cityName) {  
        System.out.println(cityName);  
        ;  
        return weatherService.getWeather(cityName);  
    }  
  
    @Tool(description = "发送邮件")  
    public String sendMail(@ToolParam(description = "收件人邮箱") String destEmail,  
                           @ToolParam(description = "邮件标题") String subject,  
                           @ToolParam(description = "邮件内容") String body) {  
        return emailService.send(destEmail, subject, body);  
  
    }  
}

private final ChatClient chatClient;  
  
private MyTools tools;  
  
public ChatController(ChatClient.Builder builder,MyTools tools) {  
    this.chatClient = builder  
            .defaultSystem("你是一个个专业的Java技术顾问，回答问题简洁准确")  
            .build();  
  
    this.tools = tools;  
}

@RequestMapping("/testTools")  
public String testTools(@RequestParam String question) {  
    return chatClient  
            .prompt()  
            .user(question)  
            .tools(tools) // 注册工具类，由模型判断是否调用  
            .call().content();  
}

controller/DocumentIngestionController
package cn.net.dev.springai.controller;  
  
import org.springframework.ai.document.Document;  
import org.springframework.ai.transformer.splitter.TokenTextSplitter;  
import org.springframework.ai.vectorstore.VectorStore;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.web.bind.annotation.PostMapping;  
import org.springframework.web.bind.annotation.RestController;  
  
import java.util.List;  
  
@RestController  
public class DocumentIngestionController {  
  
    @Autowired  
    private VectorStore vectorStore;  
  
    @Autowired  
    private TokenTextSplitter tokenTextSplitter;  
  
    @PostMapping("/load")  
    public String loadDocument() {  
        // 模拟读取文档  
        var doc1 = new Document("Spring AI 2.0 与 2026年7月31日正式发布，支持Java 25 和虚拟线程");  
        var doc2 = new Document("詹姆斯高斯林最喜欢的语言是Go语言");  
  
        // 文本切分、将长文档切分成适合模型处理的快  
        List<Document> splitDocs = tokenTextSplitter.apply(List.of(doc1, doc2));  
// 向量化存储：将每个文本块转换为向量并存入向量数据库  
        vectorStore.add(splitDocs);  
        return "%d 个文档已经存入向量数据库pgvector".formatted(splitDocs.size());  
    }  
}

package cn.net.dev.springai.controller;  
  
import org.springframework.ai.chat.client.ChatClient;  
import org.springframework.ai.chat.client.advisor.vectorstore.QuestionAnswerAdvisor;  
import org.springframework.ai.vectorstore.SearchRequest;  
import org.springframework.ai.vectorstore.VectorStore;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.RestController;  
  
@RestController  
public class RagController {  
  
  
    private final ChatClient chatClient;  
    @Autowired  
    private VectorStore vectorStore;  
  
    public RagController(final ChatClient.Builder builder) {  
        this.chatClient = builder.build();  
    }  
  
    @GetMapping("/ask")  
    public String askRagQuestion(String question) {  
  
        var qaAdvisor = QuestionAnswerAdvisor.builder(vectorStore)  
                .searchRequest(SearchRequest.builder().topK(3).similarityThreshold(0.7).build())  
                .build();  
  
        return chatClient.prompt().user(question)  
                .advisors(qaAdvisor)  
                .call()  
                .content();  
  
    }  
}

component/AuditAdvisor.java
package cn.net.dev.springai.compoent;  
  
import cn.net.dev.springai.repository.AuditLogRepository;  
import lombok.extern.slf4j.Slf4j;  
import org.springframework.ai.chat.client.ChatClientRequest;  
import org.springframework.ai.chat.client.ChatClientResponse;  
import org.springframework.ai.chat.client.advisor.api.CallAdvisor;  
import org.springframework.ai.chat.client.advisor.api.CallAdvisorChain;  
import org.springframework.core.Ordered;  
import org.springframework.stereotype.Component;  
  
import java.util.Objects;  
import java.util.UUID;  
  
@Slf4j  
@Component  
public class AuditAdvisor implements CallAdvisor {  
  
    private final AuditLogRepository auditLog;  
  
    public AuditAdvisor(AuditLogRepository auditLog) {  
        this.auditLog = auditLog;  
    }  
  
    @Override  
    public ChatClientResponse adviseCall(ChatClientRequest chatClientRequest, CallAdvisorChain callAdvisorChain) {  
        log.info("====== AuditAdvisor ======");  
        // 前置请求  
        String requestId = UUID.randomUUID().toString();  
        auditLog.logRequest(requestId, chatClientRequest.prompt().toString());  
        // 执行链中的下一个Advisor  
        ChatClientResponse chatClientResponse = callAdvisorChain.nextCall(chatClientRequest);  
  
        if (chatClientResponse.chatResponse() != null) {  
            // 后置：记录响应  
            auditLog.logResponse(requestId, Objects.requireNonNull(chatClientResponse.chatResponse().getResult()).getOutput().getText());  
        }  
        return chatClientResponse;  
    }  
  
    @Override  
    public String getName() {  
        return "AuditAdvisor";  
    }  
  
    @Override  
    public int getOrder() {  
        // 最先执行  
        return Ordered.HIGHEST_PRECEDENCE;  
    }  
}

config/ChatClientConfig.java
package cn.net.dev.springai.config;  
  
import cn.net.dev.springai.compoent.AuditAdvisor;  
import org.springframework.ai.chat.client.ChatClient;  
import org.springframework.ai.chat.client.advisor.MessageChatMemoryAdvisor;  
import org.springframework.ai.chat.client.advisor.vectorstore.QuestionAnswerAdvisor;  
import org.springframework.ai.chat.memory.ChatMemory;  
import org.springframework.ai.chat.memory.InMemoryChatMemoryRepository;  
import org.springframework.ai.chat.memory.MessageWindowChatMemory;  
import org.springframework.ai.vectorstore.SearchRequest;  
import org.springframework.ai.vectorstore.VectorStore;  
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
  
@Configuration  
public class ChatClientConfig {  
  
    @Bean  
    public ChatClient chatClientWithMemory(  
            ChatClient.Builder builder,  
            VectorStore vectorStore,
            // 注入自己定义的Advisor  
            AuditAdvisor auditAdvisor  
    ) {  
        ChatMemory chatMemory = MessageWindowChatMemory.builder().maxMessages(20).build();  
        return builder.defaultAdvisors(  
                // 别忘了注入进来  
                auditAdvisor,  
                MessageChatMemoryAdvisor.builder(chatMemory).build(),  
                QuestionAnswerAdvisor.builder(vectorStore)  
                        .searchRequest(SearchRequest.builder().topK(5).build()  
                        ).build()  
        ).defaultSystem("我是李大爷，一名专业摸鱼工程师").build();  
    }  
  
}

package cn.net.dev.springai.repository;  
  
public interface AuditLogRepository {  
    void logRequest(String requestId, String content);  
    void logResponse(String requestId, String content);  
}

package cn.net.dev.springai.repository;  
  
import org.springframework.stereotype.Component;  
  
@Component  
public class InMemoryAuditLogRepository implements AuditLogRepository {  
    @Override  
    public void logRequest(String requestId, String content) {  
        System.out.println("[REQUEST][" + requestId + "] " + content);  
    }  
  
    @Override  
    public void logResponse(String requestId, String content) {  
        System.out.println("[RESPONSE][" + requestId + "] " + content);  
    }  
}

package cn.net.dev.springai.controller;  
  
import cn.net.dev.springai.tools.MyTools;  
import jakarta.servlet.ServletRequest;  
import jakarta.servlet.http.HttpServletRequest;  
import org.springframework.ai.chat.client.ChatClient;  
import org.springframework.ai.chat.memory.ChatMemory;  
import org.springframework.core.ParameterizedTypeReference;  
import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.RequestParam;  
import org.springframework.web.bind.annotation.RestController;  
import reactor.core.publisher.Flux;  
  
import java.util.List;  
  
@RestController  
public class ChatController {  
  
    private final ChatClient chatClient;  
  
    // 这里必须用刚才配置的，否则不生效
    private final ChatClient memoryChatClient;  
  
    private MyTools tools;  
  
    public ChatController(ChatClient.Builder builder, MyTools tools, ChatClient memoryChatClient) {  
        // 相当于重新创建的
        this.chatClient = builder  
                .defaultSystem("你是一个个专业的Java技术顾问，回答问题简洁准确")  
                .build();  
  
        this.tools = tools;  
        // 注入ChatClientConfig定义的
        this.memoryChatClient = memoryChatClient;  
    }  
  
    /**  
     * 普通模式  
     *  
     * @param message  
     * @return  
     */  
    @GetMapping("/chat")  
    public String chat(@RequestParam String message, HttpServletRequest request) {  
        String sessionId = request.getSession().getId();  
        // return chatClient.prompt().user(message).call().content();  
        return memoryChatClient.prompt().user(message)  
                .advisors(a -> a.param(  
                        ChatMemory.CONVERSATION_ID,  
                        sessionId  
                ))  
                .call().content();  
    }  
  
    /**  
     * 流式  
     *  
     * @param message  
     * @return  
     */  
    @GetMapping(value = "/stream", produces = "text/event-stream;charset=UTF-8")  
    public Flux<String> streamChat(@RequestParam String message) {  
        return chatClient.prompt().user(message).stream().content();  
    }  
  
  
    record Product(  
            String name,  
            List<String> prop,  
            List<String> cons,  
            int score,  
            String recommendation  
    ) {  
    }  
    @GetMapping("/analyze")  
    public Product analyzeProduct(@RequestParam String productName) {  
        return chatClient.prompt()  
                .user("分析产品：" + productName + ",给出优缺点和推荐指数")  
                .call()  
                .entity(Product.class);  
    }  
  
    record Menu(  
            String name,  
            String ingredient,  
            String calories  
    ) {  
    }  
    @RequestMapping("/menu")  
    public List<Menu> recommendMenu(@RequestParam String scene) {  
        return chatClient.prompt()  
                .user("为以下人群推荐5种菜谱：" + scene)  
                .call()  
                .entity(new ParameterizedTypeReference<List<Menu>>() {  
                });  
    }  
  
    @RequestMapping("/testTools")  
    public String testTools(@RequestParam String question) {  
        return chatClient  
                .prompt()  
                .user(question)  
                .tools(tools) // 注册工具类，由模型判断是否调用  
                .call().content();  
    }  
}