Spring AI 深度解析：Spring生态的AI集成框架

2025-04-26
Spring AI Java 后端框架

Spring AI 深度解析：Spring生态的AI集成框架

什么是Spring AI？

Spring AI是Spring生态系统中的AI集成框架，旨在简化AI功能的集成和使用。它提供了统一的API来与各种AI服务（如OpenAI、Anthropic、DeepSeek等）进行交互，让开发者能够轻松地在Spring应用中集成AI能力。

核心特性

1. 统一的AI抽象层

Spring AI提供了统一的抽象接口，屏蔽了不同AI服务商的差异：

1
// 统一的AI客户端接口
2
public interface AiClient {
3
    AiResponse generate(AiRequest request);
4
    AiResponse chat(AiRequest request);
5
}

2. 向量数据库集成

内置对主流向量数据库的支持：

1
// Pinecone集成示例
2
@Configuration
3
public class VectorConfig {
4
    @Bean
5
    public VectorStore pineconeVectorStore() {
6
        return new PineconeVectorStore(
7
            PineconeApi.builder()
8
                .apiKey(apiKey)
9
                .environment(environment)
10
                .build()
11
        );
12
    }
13
}

3. 提示工程支持

提供强大的提示模板和工程工具：

1
// 提示模板示例
2
@Component
3
public class CodeReviewPromptTemplate {
4
    private final PromptTemplate template = new PromptTemplate("""
5
        你是一个经验丰富的代码审查专家。
6
        请审查以下代码并提供改进建议：
7

8
        代码语言：{language}
9
        代码内容：
10
        {code}
11

12
        请从以下方面进行审查：
13
        1. 代码质量和可读性
14
        2. 性能优化
15
        3. 安全性考虑
16
        4. 最佳实践建议
17
        """);
18
}

4. Spring Boot自动配置

开箱即用的自动配置支持：

1
spring:
2
  ai:
3
    openai:
4
      api-key: ${OPENAI_API_KEY}
5
      base-url: https://api.openai.com/v1
6
      chat:
7
        options:
8
          model: gpt-4
9
          temperature: 0.7
10
          max-tokens: 2000
11
    anthropic:
12
      api-key: ${ANTHROPIC_API_KEY}
13
      chat:
14
        options:
15
          model: claude-3-sonnet-20240229
16
          temperature: 0.7
17
          max-tokens: 2000
18
    deepseek:
19
      api-key: ${DEEPSEEK_API_KEY}
20
      base-url: https://api.deepseek.com/v1
21
      chat:
22
        options:
23
          model: deepseek-chat
24
          temperature: 0.7
25
          max-tokens: 2000

5. 多模型支持

支持动态切换不同的AI模型：

1
// 模型枚举
2
public enum AiModel {
3
    GPT_4("gpt-4", "OpenAI"),
4
    GPT_3_5_TURBO("gpt-3.5-turbo", "OpenAI"),
5
    CLAUDE_3_SONNET("claude-3-sonnet-20240229", "Anthropic"),
6
    CLAUDE_3_HAIKU("claude-3-haiku-20240307", "Anthropic"),
7
    DEEPSEEK_CHAT("deepseek-chat", "DeepSeek"),
8
    DEEPSEEK_CODER("deepseek-coder", "DeepSeek");
9

10
    private final String modelName;
11
    private final String provider;
12

13
    AiModel(String modelName, String provider) {
14
        this.modelName = modelName;
15
        this.provider = provider;
16
    }
17

18
    // getters...
19
}

不同模型的 ChatClient 配置实践

在实际项目中，通常需要根据不同的 AI 服务商（如 OpenAI、Anthropic、DeepSeek）分别配置 ChatClient，以便灵活切换和独立管理参数。下面详细介绍如何实现这一目标。

1. 配置文件分离

在 application.yml 中为每个模型单独配置参数：

1
spring:
2
  ai:
3
    openai:
4
      api-key: ${OPENAI_API_KEY}
5
      base-url: https://api.openai.com/v1
6
      chat:
7
        options:
8
          model: gpt-4
9
          temperature: 0.7
10
          max-tokens: 2000
11
    anthropic:
12
      api-key: ${ANTHROPIC_API_KEY}
13
      base-url: https://api.anthropic.com/v1
14
      chat:
15
        options:
16
          model: claude-3-sonnet-20240229
17
          temperature: 0.7
18
          max-tokens: 2000
19
    deepseek:
20
      api-key: ${DEEPSEEK_API_KEY}
21
      base-url: https://api.deepseek.com/v1
22
      chat:
23
        options:
24
          model: deepseek-chat
25
          temperature: 0.7
26
          max-tokens: 2000

2. Java 配置类细化

为每个模型注册独立的 ChatClient Bean，分别注入各自的配置：

1
@Configuration
2
public class AiConfig {
3

4
    @Bean("openaiChatClient")
5
    public ChatClient openaiChatClient(OpenAiChatClientProperties properties) {
6
        return ChatClient.builder()
7
            .baseUrl(properties.getBaseUrl())
8
            .apiKey(properties.getApiKey())
9
            .model(properties.getChat().getOptions().getModel())
10
            .temperature(properties.getChat().getOptions().getTemperature())
11
            .maxTokens(properties.getChat().getOptions().getMaxTokens())
12
            .build();
13
    }
14

15
    @Bean("anthropicChatClient")
16
    public ChatClient anthropicChatClient(AnthropicChatClientProperties properties) {
17
        return ChatClient.builder()
18
            .baseUrl(properties.getBaseUrl())
19
            .apiKey(properties.getApiKey())
20
            .model(properties.getChat().getOptions().getModel())
21
            .temperature(properties.getChat().getOptions().getTemperature())
22
            .maxTokens(properties.getChat().getOptions().getMaxTokens())
23
            .build();
24
    }
25

26
    @Bean("deepseekChatClient")
27
    public ChatClient deepseekChatClient(DeepSeekChatClientProperties properties) {
28
        return ChatClient.builder()
29
            .baseUrl(properties.getBaseUrl())
30
            .apiKey(properties.getApiKey())
31
            .model(properties.getChat().getOptions().getModel())
32
            .temperature(properties.getChat().getOptions().getTemperature())
33
            .maxTokens(properties.getChat().getOptions().getMaxTokens())
34
            .build();
35
    }
36
}

说明：
OpenAiChatClientProperties、AnthropicChatClientProperties、DeepSeekChatClientProperties 是类型安全的配置类，分别映射到 spring.ai.openai、spring.ai.anthropic、spring.ai.deepseek 配置。你可以用 @ConfigurationProperties 注解实现自动绑定。

3. Service 层动态选择

在 Service 层通过 @Qualifier 注入不同的 ChatClient，实现动态切换：

1
@Service
2
public class AiService {
3

4
    private final Map<String, ChatClient> modelClients;
5

6
    public AiService(
7
        @Qualifier("openaiChatClient") ChatClient openaiClient,
8
        @Qualifier("anthropicChatClient") ChatClient anthropicClient,
9
        @Qualifier("deepseekChatClient") ChatClient deepseekClient
10
    ) {
11
        this.modelClients = Map.of(
12
            "openai", openaiClient,
13
            "anthropic", anthropicClient,
14
            "deepseek", deepseekClient
15
        );
16
    }
17

18
    public String chat(String message, String model) {
19
        ChatClient client = modelClients.getOrDefault(model, modelClients.get("openai"));
20
        // 组装 Prompt 并调用 client ...
21
    }
22
}

4. 配置属性类建议

以 OpenAI 为例：

1
@ConfigurationProperties(prefix = "spring.ai.openai")
2
public class OpenAiChatClientProperties {
3
    private String apiKey;
4
    private String baseUrl;
5
    private Chat chat;
6
    // getter/setter
7

8
    public static class Chat {
9
        private Options options;
10
        // getter/setter
11

12
        public static class Options {
13
            private String model;
14
            private double temperature;
15
            private int maxTokens;
16
            // getter/setter
17
        }
18
    }
19
}

其他模型同理，分别建配置类。

实践总结

每个模型单独配置参数，灵活独立。
每个模型单独注册 ChatClient Bean。
Service 层通过 Map 动态选择 ChatClient。
配置类用 @ConfigurationProperties 类型安全绑定。

通过这种方式，可以实现真正的多模型独立配置和灵活切换，满足企业级应用对多 AI 服务商集成的需求。

项目结构示例

1
spring-ai-demo/
2
├── pom.xml
3
├── src/
4
│   ├── main/
5
│   │   ├── java/
6
│   │   │   └── com/example/springai/
7
│   │   │       ├── SpringAiApplication.java
8
│   │   │       ├── config/
9
│   │   │       │   ├── AiConfig.java
10
│   │   │       │   └── VectorConfig.java
11
│   │   │       ├── service/
12
│   │   │       │   ├── AiService.java
13
│   │   │       │   └── CodeReviewService.java
14
│   │   │       ├── controller/
15
│   │   │       │   └── AiController.java
16
│   │   │       └── model/
17
│   │   │           ├── ChatRequest.java
18
│   │   │           └── ChatResponse.java
19
│   │   └── resources/
20
│   │       ├── application.yml
21
│   │       └── prompts/
22
│   │           └── code-review.st
23
│   └── test/
24
│       └── java/
25
│           └── com/example/springai/
26
│               └── AiServiceTest.java
27
└── docker-compose.yml

Maven依赖配置

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

8
    <parent>
9
        <groupId>org.springframework.boot</groupId>
10
        <artifactId>spring-boot-starter-parent</artifactId>
11
        <version>3.2.0</version>
12
    </parent>
13

14
    <groupId>com.example</groupId>
15
    <artifactId>spring-ai-demo</artifactId>
16
    <version>1.0.0</version>
17

18
    <properties>
19
        <java.version>17</java.version>
20
        <spring-ai.version>0.8.0</spring-ai.version>
21
    </properties>
22

23
    <dependencies>
24
        <!-- Spring Boot Starters -->
25
        <dependency>
26
            <groupId>org.springframework.boot</groupId>
27
            <artifactId>spring-boot-starter-web</artifactId>
28
        </dependency>
29

30
        <dependency>
31
            <groupId>org.springframework.boot</groupId>
32
            <artifactId>spring-boot-starter-data-jpa</artifactId>
33
        </dependency>
34

35
        <!-- Spring AI -->
36
        <dependency>
37
            <groupId>org.springframework.ai</groupId>
38
            <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
39
        </dependency>
40

41
        <dependency>
42
            <groupId>org.springframework.ai</groupId>
43
            <artifactId>spring-ai-anthropic-spring-boot-starter</artifactId>
44
        </dependency>
45

46
        <dependency>
47
            <groupId>org.springframework.ai</groupId>
48
            <artifactId>spring-ai-pinecone-spring-boot-starter</artifactId>
49
        </dependency>
50

51
        <!-- 其他依赖 -->
52
        <dependency>
53
            <groupId>org.springframework.boot</groupId>
54
            <artifactId>spring-boot-starter-validation</artifactId>
55
        </dependency>
56

57
        <dependency>
58
            <groupId>org.springframework.boot</groupId>
59
            <artifactId>spring-boot-starter-test</artifactId>
60
            <scope>test</scope>
61
        </dependency>
62
    </dependencies>
63

64
    <dependencyManagement>
65
        <dependencies>
66
            <dependency>
67
                <groupId>org.springframework.ai</groupId>
68
                <artifactId>spring-ai-bom</artifactId>
69
                <version>${spring-ai.version}</version>
70
                <type>pom</type>
71
                <scope>import</scope>
72
            </dependency>
73
        </dependencies>
74
    </dependencyManagement>
75

76
    <build>
77
        <plugins>
78
            <plugin>
79
                <groupId>org.springframework.boot</groupId>
80
                <artifactId>spring-boot-maven-plugin</artifactId>
81
            </plugin>
82
        </plugins>
83
    </build>
84
</project>

核心代码实现

1. 主应用类

1
package com.example.springai;
2

3
import org.springframework.boot.SpringApplication;
4
import org.springframework.boot.autoconfigure.SpringBootApplication;
5

6
@SpringBootApplication
7
public class SpringAiApplication {
8
    public static void main(String[] args) {
9
        SpringApplication.run(SpringAiApplication.class, args);
10
    }
11
}

2. AI配置类

在多模型场景下，推荐为每个模型注册独立的 ChatClient Bean，分别注入各自的配置，实现灵活切换和独立管理参数：

1
@Configuration
2
public class AiConfig {
3

4
    @Bean("openaiChatClient")
5
    public ChatClient openaiChatClient(OpenAiChatClientProperties properties) {
6
        return ChatClient.builder()
7
            .baseUrl(properties.getBaseUrl())
8
            .apiKey(properties.getApiKey())
9
            .model(properties.getChat().getOptions().getModel())
10
            .temperature(properties.getChat().getOptions().getTemperature())
11
            .maxTokens(properties.getChat().getOptions().getMaxTokens())
12
            .build();
13
    }
14

15
    @Bean("anthropicChatClient")
16
    public ChatClient anthropicChatClient(AnthropicChatClientProperties properties) {
17
        return ChatClient.builder()
18
            .baseUrl(properties.getBaseUrl())
19
            .apiKey(properties.getApiKey())
20
            .model(properties.getChat().getOptions().getModel())
21
            .temperature(properties.getChat().getOptions().getTemperature())
22
            .maxTokens(properties.getChat().getOptions().getMaxTokens())
23
            .build();
24
    }
25

26
    @Bean("deepseekChatClient")
27
    public ChatClient deepseekChatClient(DeepSeekChatClientProperties properties) {
28
        return ChatClient.builder()
29
            .baseUrl(properties.getBaseUrl())
30
            .apiKey(properties.getApiKey())
31
            .model(properties.getChat().getOptions().getModel())
32
            .temperature(properties.getChat().getOptions().getTemperature())
33
            .maxTokens(properties.getChat().getOptions().getMaxTokens())
34
            .build();
35
    }
36
}

说明：
OpenAiChatClientProperties、AnthropicChatClientProperties、DeepSeekChatClientProperties 是类型安全的配置类，分别映射到 spring.ai.openai、spring.ai.anthropic、spring.ai.deepseek 配置。你可以用 @ConfigurationProperties 注解实现自动绑定。

3. AI服务类

1
package com.example.springai.service;
2

3
import org.springframework.ai.chat.client.ChatClient;
4
import org.springframework.ai.chat.model.ChatResponse;
5
import org.springframework.ai.chat.prompt.Prompt;
6
import org.springframework.ai.chat.prompt.PromptTemplate;
7
import org.springframework.stereotype.Service;
8

9
import java.util.Map;
10

11
@Service
12
public class AiService {
13

14
    private final ChatClient chatClient;
15
    private final PromptTemplate codeReviewTemplate;
16
    private final Map<String, ChatClient> modelClients;
17

18
    public AiService(ChatClient chatClient,
19
                    @Qualifier("openaiChatClient") ChatClient openaiClient,
20
                    @Qualifier("anthropicChatClient") ChatClient anthropicClient,
21
                    @Qualifier("deepseekChatClient") ChatClient deepseekClient) {
22
        this.chatClient = chatClient;
23
        this.modelClients = Map.of(
24
            "openai", openaiClient,
25
            "anthropic", anthropicClient,
26
            "deepseek", deepseekClient
27
        );
28
        this.codeReviewTemplate = new PromptTemplate("""
29
            你是一个经验丰富的代码审查专家。
30
            请审查以下代码并提供改进建议：
31

32
            代码语言：{language}
33
            代码内容：
34
            {code}
35

36
            请从以下方面进行审查：
37
            1. 代码质量和可读性
38
            2. 性能优化
39
            3. 安全性考虑
40
            4. 最佳实践建议
41
            """);
42
    }
43

44
    public String chat(String message) {
45
        return chat(message, null);
46
    }
47

48
    public String chat(String message, String model) {
49
        Prompt prompt = new Prompt(message);
50
        ChatClient client = getChatClient(model);
51
        ChatResponse response = client.call(prompt);
52
        return response.getResult().getOutput().getContent();
53
    }
54

55
    public String reviewCode(String language, String code) {
56
        return reviewCode(language, code, null);
57
    }
58

59
    public String reviewCode(String language, String code, String model) {
60
        Prompt prompt = codeReviewTemplate.create(Map.of(
61
            "language", language,
62
            "code", code
63
        ));
64
        ChatClient client = getChatClient(model);
65
        ChatResponse response = client.call(prompt);
66
        return response.getResult().getOutput().getContent();
67
    }
68

69
    public String generateDocumentation(String code, String framework) {
70
        return generateDocumentation(code, framework, null);
71
    }
72

73
    public String generateDocumentation(String code, String framework, String model) {
74
        PromptTemplate docTemplate = new PromptTemplate("""
75
            请为以下{framework}代码生成详细的API文档：
76

77
            {code}
78

79
            请包含：
80
            1. 方法/类的功能描述
81
            2. 参数说明
82
            3. 返回值说明
83
            4. 使用示例
84
            5. 注意事项
85
            """);
86

87
        Prompt prompt = docTemplate.create(Map.of(
88
            "framework", framework,
89
            "code", code
90
        ));
91

92
        ChatClient client = getChatClient(model);
93
        ChatResponse response = client.call(prompt);
94
        return response.getResult().getOutput().getContent();
95
    }
96

97
    private ChatClient getChatClient(String model) {
98
        if (model == null || model.isEmpty()) {
99
            return chatClient; // 使用默认客户端
100
        }
101
        return modelClients.getOrDefault(model.toLowerCase(), chatClient);
102
    }
103

104
    public List<String> getAvailableModels() {
105
        return List.of("openai", "anthropic", "deepseek");
106
    }
107

108
    public Map<String, Object> getModelInfo(String model) {
109
        Map<String, Object> info = new HashMap<>();
110
        switch (model.toLowerCase()) {
111
            case "openai":
112
                info.put("provider", "OpenAI");
113
                info.put("models", List.of("gpt-4", "gpt-3.5-turbo", "gpt-4-turbo"));
114
                info.put("maxTokens", 8192);
115
                break;
116
            case "anthropic":
117
                info.put("provider", "Anthropic");
118
                info.put("models", List.of("claude-3-sonnet", "claude-3-haiku", "claude-3-opus"));
119
                info.put("maxTokens", 200000);
120
                break;
121
            case "deepseek":
122
                info.put("provider", "DeepSeek");
123
                info.put("models", List.of("deepseek-chat", "deepseek-coder"));
124
                info.put("maxTokens", 32768);
125
                break;
126
            default:
127
                info.put("error", "Unknown model provider");
128
        }
129
        return info;
130
    }
131
}

4. 控制器类

1
package com.example.springai.controller;
2

3
import com.example.springai.model.ChatRequest;
4
import com.example.springai.model.ChatResponse;
5
import com.example.springai.service.AiService;
6
import org.springframework.web.bind.annotation.*;
7

8
import jakarta.validation.Valid;
9

10
@RestController
11
@RequestMapping("/api/ai")
12
public class AiController {
13

14
    private final AiService aiService;
15

16
    public AiController(AiService aiService) {
17
        this.aiService = aiService;
18
    }
19

20
    @PostMapping("/chat")
21
    public ChatResponse chat(@Valid @RequestBody ChatRequest request) {
22
        String response = aiService.chat(request.getMessage(), request.getModel());
23
        return new ChatResponse(response);
24
    }
25

26
    @PostMapping("/review-code")
27
    public ChatResponse reviewCode(@RequestParam String language,
28
                                 @RequestParam String code,
29
                                 @RequestParam(required = false) String model) {
30
        String review = aiService.reviewCode(language, code, model);
31
        return new ChatResponse(review);
32
    }
33

34
    @PostMapping("/generate-docs")
35
    public ChatResponse generateDocs(@RequestParam String code,
36
                                   @RequestParam String framework,
37
                                   @RequestParam(required = false) String model) {
38
        String docs = aiService.generateDocumentation(code, framework, model);
39
        return new ChatResponse(docs);
40
    }
41

42
    @GetMapping("/models")
43
    public Map<String, Object> getAvailableModels() {
44
        Map<String, Object> response = new HashMap<>();
45
        response.put("models", aiService.getAvailableModels());
46
        response.put("timestamp", System.currentTimeMillis());
47
        return response;
48
    }
49

50
    @GetMapping("/models/{model}")
51
    public Map<String, Object> getModelInfo(@PathVariable String model) {
52
        return aiService.getModelInfo(model);
53
    }
54

55
    @PostMapping("/chat/compare")
56
    public Map<String, Object> compareModels(@Valid @RequestBody ChatRequest request) {
57
        Map<String, Object> comparison = new HashMap<>();
58
        List<String> models = aiService.getAvailableModels();
59

60
        for (String model : models) {
61
            try {
62
                long startTime = System.currentTimeMillis();
63
                String response = aiService.chat(request.getMessage(), model);
64
                long endTime = System.currentTimeMillis();
65

66
                Map<String, Object> modelResult = new HashMap<>();
67
                modelResult.put("response", response);
68
                modelResult.put("responseTime", endTime - startTime);
69
                modelResult.put("model", model);
70

71
                comparison.put(model, modelResult);
72
            } catch (Exception e) {
73
                Map<String, Object> error = new HashMap<>();
74
                error.put("error", e.getMessage());
75
                error.put("model", model);
76
                comparison.put(model, error);
77
            }
78
        }
79

80
        comparison.put("timestamp", System.currentTimeMillis());
81
        return comparison;
82
    }
83
}

5. 模型类

1
package com.example.springai.model;
2

3
import jakarta.validation.constraints.NotBlank;
4

5
public class ChatRequest {
6
    @NotBlank(message = "消息不能为空")
7
    private String message;
8

9
    private String model; // 可选，指定使用的AI模型
10

11
    // getters and setters
12
    public String getMessage() {
13
        return message;
14
    }
15

16
    public void setMessage(String message) {
17
        this.message = message;
18
    }
19

20
    public String getModel() {
21
        return model;
22
    }
23

24
    public void setModel(String model) {
25
        this.model = model;
26
    }
27
}
28

29
public class ChatResponse {
30
    private String content;
31
    private long timestamp;
32

33
    public ChatResponse(String content) {
34
        this.content = content;
35
        this.timestamp = System.currentTimeMillis();
36
    }
37

38
    // getters and setters
39
    public String getContent() {
40
        return content;
41
    }
42

43
    public void setContent(String content) {
44
        this.content = content;
45
    }
46

47
    public long getTimestamp() {
48
        return timestamp;
49
    }
50

51
    public void setTimestamp(long timestamp) {
52
        this.timestamp = timestamp;
53
    }
54
}

配置文件

1
spring:
2
  ai:
3
    openai:
4
      api-key: ${OPENAI_API_KEY}
5
      base-url: https://api.openai.com/v1
6
      chat:
7
        options:
8
          model: gpt-4
9
          temperature: 0.7
10
          max-tokens: 2000
11

12
    anthropic:
13
      api-key: ${ANTHROPIC_API_KEY}
14
      chat:
15
        options:
16
          model: claude-3-sonnet-20240229
17
          temperature: 0.7
18
          max-tokens: 2000
19

20
    deepseek:
21
      api-key: ${DEEPSEEK_API_KEY}
22
      base-url: https://api.deepseek.com/v1
23
      chat:
24
        options:
25
          model: deepseek-chat
26
          temperature: 0.7
27
          max-tokens: 2000
28

29
    pinecone:
30
      api-key: ${PINECONE_API_KEY}
31
      environment: ${PINECONE_ENVIRONMENT}
32
      index-name: ${PINECONE_INDEX_NAME}
33

34
server:
35
  port: 8080
36

37
logging:
38
  level:
39
    org.springframework.ai: DEBUG
40
    com.example.springai: DEBUG

API使用示例

1. 基础聊天

1
# 使用默认模型
2
curl -X POST http://localhost:8080/api/ai/chat \
3
  -H "Content-Type: application/json" \
4
  -d '{
5
    "message": "请解释什么是Spring Boot自动配置？"
6
  }'
7

8
# 指定使用OpenAI模型
9
curl -X POST http://localhost:8080/api/ai/chat \
10
  -H "Content-Type: application/json" \
11
  -d '{
12
    "message": "请解释什么是Spring Boot自动配置？",
13
    "model": "openai"
14
  }'
15

16
# 指定使用Anthropic模型
17
curl -X POST http://localhost:8080/api/ai/chat \
18
  -H "Content-Type: application/json" \
19
  -d '{
20
    "message": "请解释什么是Spring Boot自动配置？",
21
    "model": "anthropic"
22
  }'

2. 代码审查

1
# 使用默认模型
2
curl -X POST "http://localhost:8080/api/ai/review-code" \
3
  -H "Content-Type: application/x-www-form-urlencoded" \
4
  -d "language=Java&code=public class Example { public void method() { String str = new String(); } }"
5

6
# 指定使用DeepSeek模型（适合代码相关任务）
7
curl -X POST "http://localhost:8080/api/ai/review-code" \
8
  -H "Content-Type: application/x-www-form-urlencoded" \
9
  -d "language=Java&code=public class Example { public void method() { String str = new String(); } }&model=deepseek"

3. 文档生成

1
# 使用默认模型
2
curl -X POST "http://localhost:8080/api/ai/generate-docs" \
3
  -H "Content-Type: application/x-www-form-urlencoded" \
4
  -d "framework=Spring Boot&code=@RestController public class UserController { @GetMapping('/users') public List<User> getUsers() { return userService.findAll(); } }"
5

6
# 指定使用Anthropic模型（适合文档生成）
7
curl -X POST "http://localhost:8080/api/ai/generate-docs" \
8
  -H "Content-Type: application/x-www-form-urlencoded" \
9
  -d "framework=Spring Boot&code=@RestController public class UserController { @GetMapping('/users') public List<User> getUsers() { return userService.findAll(); } }&model=anthropic"

4. 获取可用模型列表

1
curl -X GET http://localhost:8080/api/ai/models

5. 获取特定模型信息

1
curl -X GET http://localhost:8080/api/ai/models/openai
2
curl -X GET http://localhost:8080/api/ai/models/anthropic
3
curl -X GET http://localhost:8080/api/ai/models/deepseek

6. 模型对比测试

1
curl -X POST http://localhost:8080/api/ai/chat/compare \
2
  -H "Content-Type: application/json" \
3
  -d '{
4
    "message": "请用Java写一个快速排序算法"
5
  }'

测试示例

1
package com.example.springai;
2

3
import com.example.springai.service.AiService;
4
import org.junit.jupiter.api.Test;
5
import org.springframework.beans.factory.annotation.Autowired;
6
import org.springframework.boot.test.context.SpringBootTest;
7

8
import static org.junit.jupiter.api.Assertions.*;
9

10
@SpringBootTest
11
class AiServiceTest {
12

13
    @Autowired
14
    private AiService aiService;
15

16
    @Test
17
    void testChat() {
18
        String response = aiService.chat("你好，请介绍一下Spring AI");
19
        assertNotNull(response);
20
        assertFalse(response.isEmpty());
21
    }
22

23
    @Test
24
    void testChatWithSpecificModel() {
25
        String response = aiService.chat("你好，请介绍一下Spring AI", "openai");
26
        assertNotNull(response);
27
        assertFalse(response.isEmpty());
28
    }
29

30
    @Test
31
    void testCodeReview() {
32
        String javaCode = """
33
            public class Example {
34
                public void method() {
35
                    String str = new String();
36
                }
37
            }
38
            """;
39

40
        String review = aiService.reviewCode("Java", javaCode);
41
        assertNotNull(review);
42
        assertTrue(review.contains("建议") || review.contains("改进"));
43
    }
44

45
    @Test
46
    void testCodeReviewWithDeepSeek() {
47
        String javaCode = """
48
            public class Example {
49
                public void method() {
50
                    String str = new String();
51
                }
52
            }
53
            """;
54

55
        String review = aiService.reviewCode("Java", javaCode, "deepseek");
56
        assertNotNull(review);
57
        assertTrue(review.contains("建议") || review.contains("改进"));
58
    }
59

60
    @Test
61
    void testGetAvailableModels() {
62
        List<String> models = aiService.getAvailableModels();
63
        assertNotNull(models);
64
        assertFalse(models.isEmpty());
65
        assertTrue(models.contains("openai"));
66
        assertTrue(models.contains("anthropic"));
67
        assertTrue(models.contains("deepseek"));
68
    }
69

70
    @Test
71
    void testGetModelInfo() {
72
        Map<String, Object> openaiInfo = aiService.getModelInfo("openai");
73
        assertNotNull(openaiInfo);
74
        assertEquals("OpenAI", openaiInfo.get("provider"));
75

76
        Map<String, Object> anthropicInfo = aiService.getModelInfo("anthropic");
77
        assertNotNull(anthropicInfo);
78
        assertEquals("Anthropic", anthropicInfo.get("provider"));
79
    }
80
}

Docker部署

Dockerfile

1
FROM openjdk:17-jdk-slim
2

3
WORKDIR /app
4

5
COPY target/spring-ai-demo-1.0.0.jar app.jar
6

7
EXPOSE 8080
8

9
ENTRYPOINT ["java", "-jar", "app.jar"]

docker-compose.yml

1
version: '3.8'
2

3
services:
4
  spring-ai-app:
5
    build: .
6
    ports:
7
      - "8080:8080"
8
    environment:
9
      - OPENAI_API_KEY=${OPENAI_API_KEY}
10
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
11
      - DEEPSEEK_API_KEY=${DEEPSEEK_API_KEY}
12
      - PINECONE_API_KEY=${PINECONE_API_KEY}
13
      - PINECONE_ENVIRONMENT=${PINECONE_ENVIRONMENT}
14
      - PINECONE_INDEX_NAME=${PINECONE_INDEX_NAME}
15
    depends_on:
16
      - postgres
17

18
  postgres:
19
    image: postgres:15
20
    environment:
21
      POSTGRES_DB: springai
22
      POSTGRES_USER: user
23
      POSTGRES_PASSWORD: password
24
    ports:
25
      - "5432:5432"
26
    volumes:
27
      - postgres_data:/var/lib/postgresql/data
28

29
volumes:
30
  postgres_data:

最佳实践

1. 错误处理

1
@ControllerAdvice
2
public class AiExceptionHandler {
3

4
    @ExceptionHandler(AiException.class)
5
    public ResponseEntity<ErrorResponse> handleAiException(AiException e) {
6
        ErrorResponse error = new ErrorResponse(
7
            "AI_SERVICE_ERROR",
8
            e.getMessage(),
9
            System.currentTimeMillis()
10
        );
11
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
12
                           .body(error);
13
    }
14
}

2. 缓存策略

1
@Service
2
public class CachedAiService {
3

4
    private final AiService aiService;
5
    private final CacheManager cacheManager;
6

7
    @Cacheable(value = "ai-responses", key = "#message")
8
    public String chat(String message) {
9
        return aiService.chat(message);
10
    }
11
}

3. 监控和指标

1
@Component
2
public class AiMetrics {
3

4
    private final MeterRegistry meterRegistry;
5

6
    public AiMetrics(MeterRegistry meterRegistry) {
7
        this.meterRegistry = meterRegistry;
8
    }
9

10
    public void recordAiCall(String model, long duration) {
11
        Timer.Sample sample = Timer.start(meterRegistry);
12
        sample.stop(Timer.builder("ai.calls")
13
                        .tag("model", model)
14
                        .register(meterRegistry));
15
    }
16
}

总结

Spring AI为Spring生态系统提供了强大的AI集成能力，通过统一的API和自动配置，大大简化了AI功能的集成。它支持多种AI服务商，提供了向量数据库集成、提示工程等高级功能，是构建AI增强应用的理想选择。

模型切换功能亮点

多模型支持 - 支持OpenAI、Anthropic、DeepSeek等多种AI服务商
动态切换 - 可以在运行时指定使用不同的AI模型
模型对比 - 提供模型性能对比功能，帮助选择最适合的模型
灵活配置 - 每个模型可以独立配置参数和选项
向后兼容 - 保持原有API的兼容性，model参数为可选

使用建议

代码相关任务 - 推荐使用DeepSeek模型，其在代码理解和生成方面表现优秀
文档生成任务 - 推荐使用Anthropic模型，其文档写作能力较强
通用对话任务 - 可以根据需求选择OpenAI或Anthropic模型
性能优化 - 使用模型对比功能测试不同模型的响应时间和质量

通过本文的示例，你可以快速上手Spring AI，构建支持多模型切换的AI应用。记住要合理使用缓存、监控和错误处理，确保应用的稳定性和性能。