Spring Ai

一、前期准备

1. 准备DeepSeek的api-key

进入官网

然后登录，创建api-key

再进行充值

二、快速开始

配置依赖

<?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;

    }

}

测试结果

三、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<AddOperation,Integer>
     */
    @Bean
    @Description("加法运算函数")
    public Function<AddOperation,Integer> addOperation() {

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

    }

    /**
     * 进行函数注册，将乘法函数进行注册
     * @return Function<MulOperation,Integer>
     */
    @Bean
    @Description("乘法运算函数")
    public Function<MulOperation,Integer> 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<String> 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

2. 配置ollama系统环境变量

3. 安装ollama

直接安装即可

4. 拉取大模型

查看大模型网址
- https://ollama.com/search
拉去模型
- 指令
```
ollama pull deepseek-r1:1.5b
```
运行大模型
- 指令
```
ollama run deepseek-r1:1.5b
```

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
进行登录
选择模型创建api-key

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<Document> 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<String>
     */
    @GetMapping(value = "/chat",produces = "text/html;charset=utf-8")
    public Flux<String> 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<Document> 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<RecruitServiceFunction.Request, RecruitServiceFunction.Response> {

    /**
     * 此函数用来判断面试者是否符合面试条件
     * @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<RecruitServiceFunction.Request, RecruitServiceFunction.Response>
     */
    @Bean
    @Description("判断某人是否符合面试要求")
    public Function<RecruitServiceFunction.Request, RecruitServiceFunction.Response> 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<Document> 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);
    }

}

Share

Spring Ai

Spring Ai

一、前期准备

1. 准备DeepSeek的api-key

二、快速开始

三、Spring AI之chat模型

1. ChatClient接口的使用

2. ChatModel接口的使用

四、Spring AI函数调用

1. 函数调用的核心流程

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

五、Spring AI调用ollama

1. 下载ollama

2. 配置ollama系统环境变量

3. 安装ollama

4. 拉取大模型

5. Spring AI 调用ollama

六、Spring AI Alibaba

1. 登录阿里云通义千问

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

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

1. 图像处理模型

2. 音频处理模型

八、Spring AI 调用RAG

1. RAG执行流程

2. Spring AI实现调用RAG

九、综合案例演示

1. 实现步骤

2. 实现案例

Comment