学静思语

Menu

学静思语
Published on 2025-06-17 / 22 Visits
0
0

Spring Ai学习笔记

#Spring AI

Spring Ai学习笔记

一、前期准备

1. 准备DeepSeek的api-key

  • 进入官网

image-20250618213819948

  • 然后登录，创建api-key

image-20250618214010197

image-20250618214035798

  • 再进行充值

image-20250618214127943

二、快速开始

  • 配置依赖

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <!--配置spring boot依赖-->
  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>3.3.8</version>
      <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <groupId>com.leon.rabbitmq_study</groupId>
  <artifactId>spring-ai</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>
  <modules>
      <module>spring_ai_qucik_start</module>
      <module>spring-ai-chat</module>
      <module>springai_function</module>
      <module>springai-ollama</module>
  </modules>

  <properties>
      <maven.compiler.source>17</maven.compiler.source>
      <maven.compiler.target>17</maven.compiler.target>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <!--设置spring ai 的版本号-->
      <spring-ai.version>1.0.0-M5</spring-ai.version>
  </properties>

  <dependencies>
      <!--导入spring boot web场景依赖-->
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <!--导入spring ai依赖-->
      <dependency>
          <groupId>org.springframework.ai</groupId>
          <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
      </dependency>
      <!--导入spring boot test场景依赖-->
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-test</artifactId>
          <scope>test</scope>
      </dependency>
  </dependencies>
  <!--配置spring-ai-bom管理 -->
  <dependencyManagement>
      <dependencies>
          <dependency>
              <groupId>org.springframework.ai</groupId>
              <artifactId>spring-ai-bom</artifactId>
              <version>${spring-ai.version}</version>
              <type>pom</type>
              <scope>import</scope>
          </dependency>
      </dependencies>
  </dependencyManagement>

</project>

  • 配置文件

    # 配置端口
server:
port: 8080
# 配置服务名称
spring:
application:
  name: spring-ai-application
# 配置spring ai
ai:
  # 配置openai
  openai:
    # 配置ai调用的key
    api-key: api-key
    # 配置ai路径
    base-url: https://api.deepseek.com
    chat:
      options:
        # 配置模型
        model: deepseek-chat
        # 用于控制生成文本的多样性
        # 值越高，生成的文本就越多样化，但是可能包含更多的随机性和不可预测的内容
        # 值越低，生成的文本就越接近于确定性的结果，即生成的文本会更加一致和可预测
        temperature: 0.7

  • 创建启动类

    package com.springai.study;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**

  • @date 2025/6/17

  • @author: l
    */
    @SpringBootApplication
    public class SpringAiStartApplication {

    public static void main(String[] args){

      SpringApplication.run(SpringAiStartApplication.class,args);

    }
    }

  • 创建controller，然后实现SpringAI调用

    package com.springai.study.controller;

import org.springframework.ai.chat.model.ChatModel;
import org.springframework.beans.factory.annotation.Autowired;
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;

/**

  • @date 2025/6/17

  • @author: l
    */
    @RestController
    @RequestMapping(“/deepseek”)
    public class ChatDeepSeekController {

    @Autowired
    private ChatModel chatModel;

    /**

    • 测试接口，测试该接口是否连通deep seek

    • @param message

    • @return String
      */
      @GetMapping(“/chat”)
      public String chat(@RequestParam(value = “msg”,defaultValue = “请问你是谁”) String message){
      // 进行对话
      String call = chatModel.call(message);
      // 打印结果
      System.out.println(call);

      return call;

      }

    }

  • 测试结果

image-20250618214902312

三、Spring AI之chat模型

  • 配置依赖

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <!--配置spring boot依赖-->
  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>3.3.8</version>
      <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <groupId>com.leon.rabbitmq_study</groupId>
  <artifactId>spring-ai</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>
  <modules>
      <module>spring_ai_qucik_start</module>
      <module>spring-ai-chat</module>
      <module>springai_function</module>
      <module>springai-ollama</module>
  </modules>

  <properties>
      <maven.compiler.source>17</maven.compiler.source>
      <maven.compiler.target>17</maven.compiler.target>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <!--设置spring ai 的版本号-->
      <spring-ai.version>1.0.0-M5</spring-ai.version>
  </properties>

  <dependencies>
      <!--导入spring boot web场景依赖-->
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <!--导入spring ai依赖-->
      <dependency>
          <groupId>org.springframework.ai</groupId>
          <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
      </dependency>
      <!--导入spring boot test场景依赖-->
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-test</artifactId>
          <scope>test</scope>
      </dependency>
  </dependencies>
  <!--配置spring-ai-bom管理 -->
  <dependencyManagement>
      <dependencies>
          <dependency>
              <groupId>org.springframework.ai</groupId>
              <artifactId>spring-ai-bom</artifactId>
              <version>${spring-ai.version}</version>
              <type>pom</type>
              <scope>import</scope>
          </dependency>
      </dependencies>
  </dependencyManagement>

</project>

  • 配置配置文件

    # 配置端口
server:
port: 8080
# 配置服务名称
spring:
application:
  name: spring-ai-application
# 配置spring ai
ai:
  # 配置openai
  openai:
    # 配置ai调用的key
    api-key: api-key
    # 配置ai路径
    base-url: https://api.deepseek.com
    chat:
      options:
        # 配置模型
        model: deepseek-chat
        # 用于控制生成文本的多样性
        # 值越高，生成的文本就越多样化，但是可能包含更多的随机性和不可预测的内容
        # 值越低，生成的文本就越接近于确定性的结果，即生成的文本会更加一致和可预测
        temperature: 0.7

  • 创建启动类

    package com.springai;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**

  • @date 2025/6/17

  • @author: l
    */
    @SpringBootApplication
    public class SpringAiChatApplication {

    public static void main(String[] args) {

      SpringApplication.run(SpringAiChatApplication.class,args);

    }
    }

1. ChatClient接口的使用

  • 创建controller对象，使用构造器的方式注入依赖

    package com.springai.study.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;

/**

  • @date 2025/6/17

  • @author: l
    */
    @RestController
    @RequestMapping(“/chatClient”)
    public class ChatClientController {

    private final ChatClient chatClient;

    /**

    • 通过过构造器实现依赖注入

    • @param chatClientBuilder ChatClient的内部Builder接口
      */
      public ChatClientController(ChatClient.Builder chatClientBuilder) {
      // 通过ChatClient的内部Builder接口创建一个ChatClient对象
      this.chatClient = chatClientBuilder.build();

      }

      /**

    • 使用ChatClient接口实现简单对话

    • @param message 用户输入的信息

    • @return String
      */
      @GetMapping(“/chat”)
      public String chat(@RequestParam(value = “msg”,defaultValue = “请问你是谁”) String message) {

      return chatClient.prompt() // 提示词

           .user(message) // 传入用户输入信息
     .call() // 使用大模型
     .content(); // 获取返回的内容

      }
      }

  • 通过配置类的方式将ChatClient注入到容器中，还可以角色预设

  • 注意：其实通过构造器实现依赖注入时，也可以实现角色预设

    package com.springai.study.config;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**

  • @date 2025/6/17

  • @author: l
    */
    @Configuration
    public class AiConfig {

    /**

    • 通过配置类的方式将ChatClient注入到容器中，实现角色预设

    • @param builder ChatClient中的内部接口

    • @return ChatClient
      */
      @Bean
      public ChatClient chatClient(ChatClient.Builder builder) {

      // 配置默认角色
      return builder.defaultSystem(“你是一名Java高级工程师，你精通Java，你的名字是学思语”).build();

      }

    }

  • 在controller中直接使用注解方式实现依赖注入

       @Autowired
    private ChatClient chatClient;

    /**
     * 使用角色预设，来进行测试
     * @param message 用户输入的信息
     * @return String
     */
    @GetMapping("/chat")
    public String chat(@RequestParam(value = "msg",defaultValue = "你是谁") String message) {
        // 与AI进行对话
        return  chatClient.prompt().user(message).call().content();

    }

  • 为了提高用户使用效果，可以使用流式输出

    /**
     *  使用流式输出，来进行测试
     * @param message 用户输入的信息
     * @return Flux<String>
     */
    @GetMapping(value = "/stream",produces = "text/html;charset=utf-8")
    public Flux<String> stream(@RequestParam(value = "msg",defaultValue = "请问你是谁") String message){

        return chatClient.prompt() // 提示词
                .user(message) // 用户输入信息
                .stream() // 使用流式输出
                .content(); // 获取返回信息

    }

  • 总结：

    • 非流式输出（call）：一次性将结果直接返回给用户，用户需要等待一定的时间。
    • 流式输出（stream）：逐个字的输出，这种方式体现了大模型的本质，在网路情况不好时也能提升用户体验

2. ChatModel接口的使用

  • 创建controller接口，使用call(String)与模型进行沟通

    @Autowired
 private ChatModel chatModel;

 /**
  *  使用ChatModel进行AI对话
  * @param message 用户输入的信息
  * @return String
  */
 @GetMapping("/chat")
 public String chat(@RequestParam(value = "msg",defaultValue = "你是谁") String message) {
    // 使用默认方式进行AI对话
    return chatModel.call(message);

 }

  • 使用重载方法call(Prompt)方法进于模型进行沟通

    /**
  * 使用重载方法进行AI对话
  * @param message 用户输入的信息
  * @return String
  */
 @GetMapping("/openAI")
 public String openAI(@RequestParam(value = "msg",defaultValue = "你是谁") String message) {
    // 设参数并进行对话
    ChatResponse call = chatModel.call(new Prompt(message, // 用户输入的信息
            OpenAiChatOptions.builder()
            .model("deepseek-chat") // 选择Ai大模型
            .temperature(0.8) //设置文本的多样性
            .build()));
    // 获取返回结果
    return call.getResult().getOutput().getContent();
 }

  • 自定义提示词

    /**
  * 自定义提示词
  * @param name 提示词中的名称
  * @param voice 提示词中的饮食习惯
  * @return String
  */
 @GetMapping("/prompt")
 public String prompt(@RequestParam(value = "name",defaultValue = "张三") String name,
                      @RequestParam(value = "voice",defaultValue = "实惠") String voice) {

    // 设置用户信息
    String userText = """
            请给我推荐深圳的美食
            """;
    // 创建用户信息对象
    UserMessage userMessage = new UserMessage(userText);
    // 设置提示词
    String systemText= """
            你是一个美食咨询助手，可以帮人们查询需要的美食信息，
            你的名字是{name}，
            你应该用你的名字和{voice}的饮食习惯回复用户的请求。
            """;
    // 创建提示词对象
    SystemPromptTemplate systemPromptTemplate = new SystemPromptTemplate(systemText);
    // 替换文字
    Message systemMessage = systemPromptTemplate.createMessage(Map.of("name", name, "voice", voice));
    // 使用提示词
    Prompt prompt = new Prompt(List.of(userMessage, systemMessage));
    // 进行对话
    ChatResponse chatResponse = chatModel.call(prompt);

   return chatResponse.getResults() // 获取返回结果
           .stream() // 装换成Stream流程
           .map(g -> g.getOutput().getContent()) // 获取返回的结果
           .collect(Collectors.joining("")); // 收集


 }

四、Spring AI函数调用

1. 函数调用的核心流程

  • 定义函数：声明可供模型调用的函数。（名称、描述、参数结构）
  • 模型交互：将函数信息与用户输入一起发送给模型，由模型决定是否使用函数。
  • 执行函数：解析模型的函数调用请求，执行对应对的业务逻辑
  • 返回结果：将函数计算的结果返回给模型，生成最终的结果

2. 实现Spring AI调用自定义函数

  • 配置依赖

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <!--配置spring boot依赖-->
  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>3.3.8</version>
      <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <groupId>com.leon.rabbitmq_study</groupId>
  <artifactId>spring-ai</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>
  <modules>
      <module>spring_ai_qucik_start</module>
      <module>spring-ai-chat</module>
      <module>springai_function</module>
      <module>springai-ollama</module>
  </modules>

  <properties>
      <maven.compiler.source>17</maven.compiler.source>
      <maven.compiler.target>17</maven.compiler.target>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <!--设置spring ai 的版本号-->
      <spring-ai.version>1.0.0-M5</spring-ai.version>
  </properties>

  <dependencies>
      <!--导入spring boot web场景依赖-->
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <!--导入spring ai依赖-->
      <dependency>
          <groupId>org.springframework.ai</groupId>
          <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
      </dependency>
      <!--导入spring boot test场景依赖-->
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-test</artifactId>
          <scope>test</scope>
      </dependency>
  </dependencies>
  <!--配置spring-ai-bom管理 -->
  <dependencyManagement>
      <dependencies>
          <dependency>
              <groupId>org.springframework.ai</groupId>
              <artifactId>spring-ai-bom</artifactId>
              <version>${spring-ai.version}</version>
              <type>pom</type>
              <scope>import</scope>
          </dependency>
      </dependencies>
  </dependencyManagement>

</project>

  • 配置配置文件

    # 配置端口
server:
port: 8080
# 配置服务名称
spring:
application:
  name: spring-ai-application
# 配置spring ai
ai:
  # 配置openai
  openai:
    # 配置ai调用的key
    api-key: api-key
    # 配置ai路径
    base-url: https://api.deepseek.com
    chat:
      options:
        # 配置模型
        model: deepseek-chat
        # 用于控制生成文本的多样性
        # 值越高，生成的文本就越多样化，但是可能包含更多的随机性和不可预测的内容
        # 值越低，生成的文本就越接近于确定性的结果，即生成的文本会更加一致和可预测
        temperature: 0.7

  • 创建配置类

  • 配置ChatClient的配置

    package com.springai.function.study.config;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**

  • @date 2025/6/18

  • @author: l
    */
    @Configuration
    public class ChatClientConfig {

    /**

    • 通过配置方式，注入ChatClient

    • 未进行角色预设

    • @param chatClientBuilder ChatClient的内部接口

    • @return ChatClient
      */
      @Bean
      public ChatClient chatClient(ChatClient.Builder chatClientBuilder) {

      // 创建ChatClient对象，未进行角色预设
      return chatClientBuilder.build();

      }

    }

  • 配置自定义函数

    package com.springai.function.study.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Description;

import java.util.function.Function;

/**

  • @date 2025/6/18

  • @author: l
    /
    @Configuration
    public class FunctionConfig {
    /    *

    • 创建一个Record的特殊类，用于加法操作

    • @param a

    • @param b
      */
      public record AddOperation(int a,int b){}

      /**

    • 创建一个Record的特殊类，用于乘法操作

    • @param m

    • @param n
      */
      public record MulOperation(int m,int n){}

      /**

    • 进行函数注册，将加法函数实现注册

    • @return Function
      */
      @Bean
      @Description(“加法运算函数”)
      public Function addOperation() {

      return addOperation -> addOperation.a + addOperation.b;

      }

      /**

    • 进行函数注册，将乘法函数进行注册

    • @return Function
      */
      @Bean
      @Description(“乘法运算函数”)
      public Function mulOperation() {

      return (mulOperation) -> mulOperation.m + mulOperation.n;

      }

    }

  • 创建启动类

    package com.springai.function.study;

import org.apache.catalina.core.ApplicationContext;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**

  • @date 2025/6/18

  • @author: l
    */
    @SpringBootApplication
    public class SpringAiFunctionApplication {

    public static void main(String[] args) {

      SpringApplication.run(SpringAiFunctionApplication.class,args);



  System.out.println("Hello World!");

    }

    }

  • 创建controller接口，实现Spring AI调用自定义函数

    package com.springai.function.study.controller;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
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;


/**

  • @date 2025/6/18

  • @author: l
    */
    @RestController
    @RequestMapping(“/function”)
    public class FunctionController {

    @Autowired
    private ChatClient chatClient;

    @Autowired
    private ChatModel chatModel;

    /**

    • 进行Spring Ai函数调用
      *

    • @param message 用户传递过来的信息

    • @return String
      */
      @GetMapping(value = “/chat”,produces = {“text/html;charset=utf-8”})
      public Flux chat(@RequestParam(value = “msg”, defaultValue = “20加30等于多少”) String message) {

      return ChatClient.builder(chatModel).build().prompt()

            .system("""
              您是算术计算器的代理。
              您能够支持加法运算、乘法运算等操作，其余功能将在后续版本中添加，如果用户问的问题不支持请告知详情。
              在提供加法运算、乘法运算等操作之前，您必须从用户处获取如下信息：两个数字，运算类型。
              请调用自定义函数执行加法运算、乘法运算。
              请讲中文。
              """)
      .user(message) // 设置用户消息
      .functions("addOperation","mulOperation") // 设置函数
      .stream() // 使用流式输出
      .content(); // 获取返回的内容

      }

    }

五、Spring AI调用ollama

1. 下载ollama

  • 官方网址：https://ollama.com

image-20250618222028542

image-20250618222107530

2. 配置ollama系统环境变量

  • 说明

  • 配置大模型下载目录

    image-20250618222306745

3. 安装ollama

  • 直接安装即可

4. 拉取大模型

  • 查看大模型网址

  • https://ollama.com/search

    image-20250618222554621

    image-20250618222734934

  • 拉去模型

  • 指令

    ollama pull deepseek-r1:1.5b

    image-20250618222853949

  • 运行大模型

  • 指令

    ollama run deepseek-r1:1.5b

    image-20250618223018886

5. Spring AI 调用ollama

  • 配置依赖

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>3.3.8</version>
      <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <artifactId>springai-ollama</artifactId>

  <properties>
      <maven.compiler.source>17</maven.compiler.source>
      <maven.compiler.target>17</maven.compiler.target>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <spring-ai.version>1.0.0-M5</spring-ai.version>
  </properties>


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

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

      <dependency>
          <groupId>org.springframework.ai</groupId>
          <artifactId>spring-ai-ollama-spring-boot-starter</artifactId>
          <version>1.0.0-SNAPSHOT</version>
      </dependency>
  </dependencies>
  <dependencyManagement>
      <dependencies>
          <dependency>
              <groupId>org.springframework.ai</groupId>
              <artifactId>spring-ai-bom</artifactId>
              <version>${spring-ai.version}</version>
              <type>pom</type>
              <scope>import</scope>
          </dependency>
      </dependencies>
  </dependencyManagement>

  <!--下载spring-ai相关包需要用到的仓库地址-->
  <repositories>
      <repository>
          <id>spring-milestones</id>
          <name>Spring Milestones</name>
          <url>https://repo.spring.io/milestone</url>
          <snapshots>
              <enabled>false</enabled>
          </snapshots>
      </repository>
      <repository>
          <id>spring-snapshots</id>
          <name>Spring Snapshots</name>
          <url>https://repo.spring.io/snapshot</url>
          <releases>
              <enabled>false</enabled>
          </releases>
      </repository>
  </repositories>


</project>

  • 配置文件

    server:
# 配置端口号
port: 8080
spring:
application:
  # 服务名称
  name: spring-ai-application
ai:
  ollama:
    # 配置连接地址
    base-url: http://localhost:11434
    chat:
      options:
        # 配置模型
        model: deepseek-r1:1.5b
        # 配置文本的多样性
        temperature: 0.7

  • 创建启动类

    package com.springai.ollama.study;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**

  • @date 2025/6/18

  • @author: l
    */
    @SpringBootApplication
    public class SpringAiOllamaApplication {

    public static void main(String[] args) {

      SpringApplication.run(SpringAiOllamaApplication.class,args);

    }
    }

  • 创建controller，实现Spring AI调用ollama

    package com.springai.ollama.study.controller;

import org.springframework.ai.ollama.OllamaChatModel;
import org.springframework.beans.factory.annotation.Autowired;
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;

/**

  • @date 2025/6/18

  • @author: l
    */
    @RestController
    @RequestMapping(“/ollama”)
    public class OllamaController {

    @Autowired
    private OllamaChatModel ollamaChatModel;

    /**

    • Spring AI连接ollama测试

    • @param message 用户输入的信息

    • @return String
      */
      @GetMapping(“/chat”)
      public String chat(@RequestParam(value = “msg”,defaultValue = “你是谁”) String message) {
      // 进行对话并返回结果
      return ollamaChatModel.call(message);

      }

    }

六、Spring AI Alibaba

1. 登录阿里云通义千问

  • 官方网址：https://www.aliyun.com/product/tongyi

    image-20250618223733302

  • 进行登录

    image-20250618223814089

  • 选择模型创建api-key

    image-20250618224002019

2. 实现Spring AI Alibaba 调用大模型

  • 配置依赖

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.leon.rabbitmq_study</groupId>
  <artifactId>spring_ai_alibaba</artifactId>
  <version>1.0-SNAPSHOT</version>

  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>3.2.5</version>
      <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <properties>
      <maven.compiler.source>17</maven.compiler.source>
      <maven.compiler.target>17</maven.compiler.target>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

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

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

      <dependency>
          <groupId>com.alibaba.cloud.ai</groupId>
          <artifactId>spring-ai-alibaba-starter</artifactId>
          <version>1.0.0-M5.1</version>
      </dependency>
  </dependencies>

  <repositories>
      <repository>
          <id>spring-milestones</id>
          <name>Spring Milestones</name>
          <url>https://repo.spring.io/milestone</url>
          <snapshots>
              <enabled>false</enabled>
          </snapshots>
      </repository>
  </repositories>

</project>

  • 配置配置文件

    server:
port: 8080
spring:
application:
  name: spring-ai-alibaba-application
ai:
  # 配置api-key 
  dashscope:
    api-key: api-key

  • 创建启动类

    package com.springaialibaba.study;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**

  • @date 2025/6/18

  • @author: l
    */
    @SpringBootApplication
    public class SpringAiAlibabaApplication {

    public static void main(String[] args) {

      SpringApplication.run(SpringAiAlibabaApplication.class, args);

    }
    }

  • 创建controller，实现Spring AI Alibaba调用大模型

    package com.springaialibaba.study.controller;

import com.alibaba.cloud.ai.dashscope.chat.DashScopeChatModel;
import com.alibaba.cloud.ai.dashscope.chat.DashScopeChatOptions;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.advisor.MessageChatMemoryAdvisor;
import org.springframework.ai.chat.client.advisor.SimpleLoggerAdvisor;
import org.springframework.ai.chat.memory.InMemoryChatMemory;
import org.springframework.beans.factory.annotation.Autowired;
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;

/**

  • @date 2025/6/18

  • @author: l
    */
    @RestController
    @RequestMapping(“/springaialibaba”)
    public class SpringAiAlibabaController {

    private ChatClient dashScopeChatClient;

    /**

    • 通过构造器注入依赖

    • @param dashScopeChatClientBuilder
      */
      public SpringAiAlibabaController(ChatClient.Builder dashScopeChatClientBuilder) {

      this.dashScopeChatClient = dashScopeChatClientBuilder

            // 设置默认系统提示词
      .defaultSystem("你是一个博学的智能聊天助手，请根据用户提问回答！")
      // 实现Chat Memory的Advisor
      // 使用Chat Memory时需要使用对话id，以变Spring Ai处理上下文
      .defaultAdvisors(new MessageChatMemoryAdvisor(new InMemoryChatMemory()))
      // 实现Logger的Advisor
      .defaultAdvisors(new SimpleLoggerAdvisor())
      // 设置ChatClient中的ChatModel的Options参数
      .defaultOptions(DashScopeChatOptions
              .builder()
              .withTopP(0.7)
              .build())
      .build();

      }

      /**

    • 使用Spring AI Alibaba 与Ai对话

    • @param message 用户输入信息

    • @return String
      */
      @GetMapping(“/chat”)
      public String chat(@RequestParam(value = “msg”,defaultValue = “你是谁”) String message) {

      return dashScopeChatClient.prompt(message).call().content();

      }

    }

七、Spring AI其它模型（使用Spring AI Alibaba）

  • 配置依赖

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.leon.rabbitmq_study</groupId>
  <artifactId>spring_ai_other</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>


  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>3.2.5</version>
      <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <properties>
      <maven.compiler.source>17</maven.compiler.source>
      <maven.compiler.target>17</maven.compiler.target>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

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

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

      <dependency>
          <groupId>com.alibaba.cloud.ai</groupId>
          <artifactId>spring-ai-alibaba-starter</artifactId>
          <version>1.0.0-M5.1</version>
      </dependency>
  </dependencies>

  <repositories>
      <repository>
          <id>spring-milestones</id>
          <name>Spring Milestones</name>
          <url>https://repo.spring.io/milestone</url>
          <snapshots>
              <enabled>false</enabled>
          </snapshots>
      </repository>
  </repositories>

</project>

  • 配置配置文件

    server:
port: 8080
spring:
application:
  name: spring-ai-alibaba-application
ai:
  dashscope:
    api-key: api-key

  • 创建启动类

    package com.springaialibaba.study;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**

  • @date 2025/6/18

  • @author: l
    */
    @SpringBootApplication
    public class SpringAiOtherApplication {

    public static void main(String[] args) {

      SpringApplication.run(SpringAiOtherApplication.class, args);

    }

    }

1. 图像处理模型

  • 创建controller层，实现图像处理模型的调用

    package com.springaialibaba.study.controller;

import com.alibaba.cloud.ai.dashscope.api.DashScopeImageApi;
import com.alibaba.cloud.ai.dashscope.image.DashScopeImageModel;
import com.alibaba.cloud.ai.dashscope.image.DashScopeImageOptions;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.ai.image.ImagePrompt;
import org.springframework.ai.image.ImageResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
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 java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.URL;

/**

  • @date 2025/6/18

  • @author: l
    */
    @RestController
    @RequestMapping(“/image”)
    public class ImagesController {

    @Autowired
    private DashScopeImageModel dashScopeImageModel;

    /**

    • 使用Spring Ai Alibaba与图像模型进行对话

    • @param msg 用户输入的信息

    • @param response 响应对象
      */
      @GetMapping(“/chat”)
      public void chat(@RequestParam(value = “msg”,defaultValue = “请帮我画一只可爱的小猫”) String msg, HttpServletResponse response){

      ImageResponse imageResponse = dashScopeImageModel.call(new ImagePrompt(msg, // 传入用户输入的信息

            DashScopeImageOptions.builder() // 设置Option对象
              .withModel(DashScopeImageApi.DEFAULT_IMAGE_MODEL) // 设置生成图像的模型
              .withHeight(1024) // 设置图片高度
              .withWidth(1024) // 设置图片宽度
              .withN(1) //生成图片的数量
              .build()));

      // 获取生成的图片
      String imageUrl = imageResponse.getResult().getOutput().getUrl();

      InputStream inputStream = null;

      try {

        // 转换成图片路径
  URL  url = URI.create(imageUrl).toURL();
  // 将图片转换成流
  inputStream = url.openStream();
  // 设置响应头
  response.setHeader("content-Type", MediaType.IMAGE_PNG_VALUE);
  // 输出图片
  response.getOutputStream().write(inputStream.readAllBytes());
  // 进行刷新
  response.getOutputStream().flush();

      } catch (Exception e) {

        throw new RuntimeException(e);

      }finally {

        if (inputStream != null) {
      try {
          inputStream.close();
      } catch (IOException e) {
          throw new RuntimeException(e);
      }
  }

      }

      }

    }

2. 音频处理模型

  • 创建controller层，实现音频处理模型的调用

    package com.springaialibaba.study.controller;

import com.alibaba.cloud.ai.dashscope.audio.DashScopeSpeechSynthesisModel;
import com.alibaba.cloud.ai.dashscope.audio.DashScopeSpeechSynthesisOptions;
import com.alibaba.cloud.ai.dashscope.audio.synthesis.SpeechSynthesisPrompt;
import com.alibaba.cloud.ai.dashscope.audio.synthesis.SpeechSynthesisResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;

/**

  • @date 2025/6/18

  • @author: l
    */
    @RestController
    @RequestMapping(“/audio”)
    public class AudioController {

    @Autowired
    private DashScopeSpeechSynthesisModel dashScopeSpeechSynthesisModel;

    /**

    • 使用Spring Ai Alibaba对接语音模型
      */
      @GetMapping(“/chat”)
      public void chat() {

      final String TEXT = “床前明月光， 疑是地上霜。 举头望明月， 低头思故乡。“;
      // 进行模型对话
      SpeechSynthesisResponse synthesisResponse = dashScopeSpeechSynthesisModel.call(

            new SpeechSynthesisPrompt(TEXT, DashScopeSpeechSynthesisOptions.builder()
              .withSpeed(1.0) // 设置语速
              .withPitch(1.0) // 设置音调
              .withVolume(60) // 设置音量
              .build()));

      // 创建文件对象
      File file = new File(“C:\software\javacodelibrary\spring-ai\spring_ai_other\src\main\resources” + “\output.mp3”);

      // 文件保存在本地
      try (FileOutputStream fileOutputStream = new FileOutputStream(file)){

        // 获取结果
  ByteBuffer audio = synthesisResponse.getResult().getOutput().getAudio();
  // 保存文件
  fileOutputStream.write(audio.array());

      } catch (Exception e) {

        throw new RuntimeException(e);

      }

      }

    }

八、Spring AI 调用RAG

1. RAG执行流程

  • 用户输入问题
  • 问题向量化
  • 向量数据库检索
  • 构建上下文（含系统提示词）
  • 携带检索内容，调用大模型进行回答
  • 返回最终答案给用户

2. Spring AI实现调用RAG

  • 配置依赖

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.leon.rabbitmq_study</groupId>
  <artifactId>spring_ai_rag</artifactId>
  <version>1.0-SNAPSHOT</version>

  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>3.2.5</version>
      <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <properties>
      <maven.compiler.source>17</maven.compiler.source>
      <maven.compiler.target>17</maven.compiler.target>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

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

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

      <dependency>
          <groupId>com.alibaba.cloud.ai</groupId>
          <artifactId>spring-ai-alibaba-starter</artifactId>
          <version>1.0.0-M5.1</version>
      </dependency>
  </dependencies>

  <repositories>
      <repository>
          <id>spring-milestones</id>
          <name>Spring Milestones</name>
          <url>https://repo.spring.io/milestone</url>
          <snapshots>
              <enabled>false</enabled>
          </snapshots>
      </repository>
  </repositories>

</project>

  • 配置配置文件

    server:
port: 8080
spring:
application:
  name: spring-ai-alibaba-application
ai:
  dashscope:
    api-key: api-key

  • 创建配置类

  • 配置ChatClient和向量化数据

    package com.springaialibaba.rag.study.config;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.document.Document;
import org.springframework.ai.embedding.EmbeddingModel;
import org.springframework.ai.vectorstore.SimpleVectorStore;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.List;

/**

  • @date 2025/6/18

  • @author: l
    */
    @Configuration
    public class RagConfig {

    /**

    • 设置角色

    • @param builder ChatClient内部接口

    • @return ChatClient
      */
      @Bean
      public ChatClient chatClient(ChatClient.Builder builder) {

      return builder.defaultSystem(“你将作为一名Java开发语言的专家，对于用户的使用需求作出解答”).build();

      }

      /**

    • 设置VectorStore对象

    • @param embeddingModel

    • @return VectorStore
      */
      @Bean
      public VectorStore vectorStore(EmbeddingModel embeddingModel) {

      // 创建SimpleVectorStore对象
      SimpleVectorStore simpleVectorStore = SimpleVectorStore.builder(embeddingModel).build();
      // 创建document对象集合
      List documents = List.of(new Document(“产品说明:名称：Java开发语言\n” +

            "产品描述：Java是一种面向对象开发语言。\n" +
      "特性：\n" +
      "1. 封装\n" +
      "2. 继承\n" +
      "3. 多态\n"));

      // 添加document对象
      simpleVectorStore.add(documents);

      return simpleVectorStore;

      }
      }

  • 创建启动类

    package com.springaialibaba.rag.study;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**

  • @date 2025/6/18

  • @author: l
    */
    @SpringBootApplication
    public class SpringAiRagApplication {

    public static void main(String[] args) {

      SpringApplication.run(SpringAiRagApplication.class, args);

    }

    }

  • 创建controller实现Spring AI调用RAG

    package com.springaialibaba.rag.study.controller;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.advisor.QuestionAnswerAdvisor;
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.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;

/**

  • @date 2025/6/18

  • @author: l
    */
    @RestController
    @RequestMapping(“/rag”)
    public class RagController {

    @Autowired
    private ChatClient chatClient;

    @Autowired
    private VectorStore vectorStore;

    /**

    • Spring Ai 调用rag

    • @param message 用户输入的信息

    • @return Flux
      */
      @GetMapping(value = “/chat”,produces = “text/html;charset=utf-8”)
      public Flux chat(@RequestParam(value = “msg”,defaultValue = “请问Java有什么特性”) String message) {
      // 进行对话
      return chatClient.prompt().user(message).advisors(new QuestionAnswerAdvisor(vectorStore)).stream().content();

      }

    }

九、综合案例演示

1. 实现步骤

  • 创建项目，导入依赖
  • 创建RAG知识库
  • 创建工具类
  • 设置应用人设
  • 实现接口进行测试

2. 实现案例

  • 配置依赖

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.leon.rabbitmq_study</groupId>
  <artifactId>spring_ai_summary</artifactId>
  <version>1.0-SNAPSHOT</version>

  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>3.2.5</version>
      <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <properties>
      <maven.compiler.source>17</maven.compiler.source>
      <maven.compiler.target>17</maven.compiler.target>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

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

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

      <dependency>
          <groupId>com.alibaba.cloud.ai</groupId>
          <artifactId>spring-ai-alibaba-starter</artifactId>
          <version>1.0.0-M5.1</version>
      </dependency>
  </dependencies>

  <repositories>
      <repository>
          <id>spring-milestones</id>
          <name>Spring Milestones</name>
          <url>https://repo.spring.io/milestone</url>
          <snapshots>
              <enabled>false</enabled>
          </snapshots>
      </repository>
  </repositories>

</project>

  • 配置配置文件

    server:
port: 8080
spring:
application:
  name: spring-ai-alibaba-application
ai:
  dashscope:
    api-key: api-key

  • 准备数据

    教育经历
北京大学 软件工程 本科 2005.09 - 2009.06
主修课程：Java语言开发、C语言开发、操作系统、编译原理、计算机网络、算法导论、电商商务、电子基础、高等数学、概率论与统计、离散数学。
工作经验
阿里巴巴有限公司 算法工程师
2009-7-1 - 2015-7-10
拥有五年以上的算法工程师经验，熟悉各种开发语言的使用，比如Java、C++、C#等，熟练使用各种主流深度学习框架，能独立开发出高质量、高性能的算法模型，精通数据结构、算法及机器学习模型的实现与优化，在多个项目中负责算法模型的设计与开发，包括基于深度学习的图像识别、语音识别及自然语言处理等方向。。
小米科技有限公司 算法工程师
2015-8-1 - 2020-3-1
担任小米科技有限公司算法工程师，负责参与开发高性能机器学习算法。在项目中，我使用Python和MATLAB编写了多种算法模型，并且实现了GPU加速计算，使得算法在处理大规模复杂数据时表现优异。
就职于小米科技有限公司，作为算法工程师，全程参与了一款自动驾驶系统的开发。在项目中，我主要通过深度学习、目标检测等技术，实现了车辆识别、道路分割等多项技术难点，使得系统在真实道路环境下表现出了较高的稳定性和可靠性。
在小米科技有限公司，我作为算法工程师负责了一项推荐系统的研发。该系统基于用户行为数据，使用协同过滤和深度学习技术，为用户推荐最优质的内容。在项目中，我优化了多种推荐算法，优化推荐精度达到了90%以上。

  • 创建RAG知识库

  • 通过配置类的方式

    package com.springai.summary.config;

import org.springframework.ai.document.Document;
import org.springframework.ai.embedding.EmbeddingModel;
import org.springframework.ai.reader.TextReader;
import org.springframework.ai.transformer.splitter.TokenTextSplitter;
import org.springframework.ai.vectorstore.SimpleVectorStore;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


import java.util.List;

/**

  • @date 2025/6/18

  • @author: l
    */
    @Configuration
    public class RagConfig {

    /**

    • 将数据向量化

    • @param embeddingModel

    • @return VectorStore
      */
      @Bean
      public VectorStore vectorStore(EmbeddingModel embeddingModel) {
      // 创建SimpleVectorStore对象
      SimpleVectorStore simpleVectorStore = SimpleVectorStore.builder(embeddingModel).build();

      // 创建文件路径
      String filePath = “张三简历.txt”;
      // 提取文本内容
      TextReader textReader = new TextReader(filePath);

      textReader.getCustomMetadata().put(“filePath”, filePath);
      // 将document保存在集合中
      List documents = textReader.get();

      // 将文本进行切分段落
      TokenTextSplitter tokenTextSplitter =

            new TokenTextSplitter(1200, 350, 5, 100, true);

      // 进行切分
      tokenTextSplitter.apply(documents);
      // 将document对象集合添加进VectorStore中
      simpleVectorStore.add(documents);

      return simpleVectorStore;

      }

    }

  • 创建工具类

  • 函数工具类

    package com.springai.summary.utils;

import java.util.function.Function;

/**

  • @date 2025/6/18

  • @author: l
    */
    public class RecruitServiceFunction implements Function {

    /**

    • 此函数用来判断面试者是否符合面试条件

    • @param request 过来面试的人

    • @return Response 是否合适
      */
      @Override
      public Response apply(Request request) {

      String result = “不合适”;

      if(request.name.equals(“张三”)){

        result = "算法工程师";

      }

      return new Response(result);
      }

      /**

    • 请求者

    • @param name 名字
      */
      public record Request(String name){};

      /**

    • 响应

    • @param result 结果
      */
      public record Response(String result){}

    }

  • 将函数注入到容器中

    • 通过配置类的方式注入
    package com.springai.summary.config;

import com.springai.summary.utils.RecruitServiceFunction;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Description;

import java.util.function.Function;

/**

  • @date 2025/6/18

  • @author: l
    */
    @Configuration
    public class FunctionConfig {

    /**

    • 将函数注入到容器中

    • @return Function
      */
      @Bean
      @Description(“判断某人是否符合面试要求”)
      public Function recruitServiceFunction() {

      return new RecruitServiceFunction();

      }

    }

  • 实现controller层，设置人设并调用大模型

    package com.springai.summary.controller;

import com.alibaba.cloud.ai.dashscope.chat.DashScopeChatOptions;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.SystemMessage;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.ai.chat.model.Generation;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.prompt.PromptTemplate;
import org.springframework.ai.document.Document;
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.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**

  • @date 2025/6/18

  • @author: l
    */
    @RestController
    @RequestMapping(“/summery”)
    public class SummeryController {

    @Autowired
    private ChatModel chatModel;

    @Autowired
    private VectorStore vectorStore;

    /**

    • 整合之前的模型，使用RAG加上函数实现一个面试助手

    • @param message 用户输入的信息

    • @return String
      */
      @GetMapping(“/ai”)
      public String summery(@RequestParam(value = “msg”) String message) {
      // 检索数据
      List documents = vectorStore.similaritySearch(message);

      // 提取相关信息
      String info = ““;

      // 判断是否有数据
      if (documents.size() > 0) {

        info = documents.get(0).getText();

      }

      // 构造系统提示词
      String systemPrompt = ““”

            角色与目标：你是一个招聘助手，会针对用户的问题，结合候选人经历，岗位匹配度等专业知识，给用户提供指导。
      指导原则：你需要确保给出的建议合理科学，不会对候选人的表现有言论侮辱。
      限制：在提供建议时，需要强调在个性建议方面用户仍然需要线下寻求专业咨询。
      澄清：在与用户交互过程中，你需要明确回答用户关于招聘方面的问题，对于非招聘方面的问题，你的回应是‘我只是一个招聘助手，不能回答这个问题哦’。
      个性化：在回答时，你需要以专业可靠的预期回答，偶尔可以带点幽默感。调节气氛。
      给你提供一个数据参考，并且给你调用岗位投递检索公户
      请你跟进数据参考与工具返回结果回复用户的请求。
      """;

      // 构造用户提示你词
      String userPrompt = ““”

            给你提供一些数据参考：{info},请回答我的问题：{message}。
      请你跟进数据参考与工具返回结果回复用户的请求。
      """;

      // 设置系统提示词
      SystemMessage systemMessage = new SystemMessage(systemPrompt);
      // 设置角色提示词
      PromptTemplate promptTemplate = new PromptTemplate(userPrompt);
      // 构建提示词消息对象
      Message templateMessage = promptTemplate.createMessage(Map.of(“info”, info, “message”, message));
      // 生成提示词对象
      Prompt prompt = new Prompt(List.of(templateMessage,systemMessage),

            DashScopeChatOptions.builder().withFunction("recruitServiceFunction").build());

      // 进行对话，然后获取结果
      return chatModel.call(prompt).getResults() // 获取结果

            .stream() // 装换成流
      .map(g -> g.getOutput().getContent()) // 获取结果
      .collect(Collectors.joining()); // 进行拼接

      }

    }

  • 创建启动类

    package com.springai.summary;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**

  • @date 2025/6/18

  • @author: l
    */
    @SpringBootApplication
    public class SpringAiSummaryApplication {

    public static void main(String[] args) {

      SpringApplication.run(SpringAiSummaryApplication.class, args);

    }

    }

LangChain4j学习笔记
前端框架（Vue.js）

Comment