SpringBoot整合SpringAI配置多平臺API密鑰的解決方案

更新時間：2026年05月20日 08:23:38 作者：小壞說Java

本文介紹了如何在SpringBoot項目中整合SpringAI配置平臺API密鑰,包括添加依賴、配置文件、配置屬性類及核心配置類等,通過動態(tài)切換不同AI平臺,實現(xiàn)統(tǒng)一接口調用,此外,支持YAML配置和環(huán)境變量,便于靈活配置和擴展新平臺,需要的朋友可以參考下

1. 添加依賴 (pom.xml)

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai</artifactId>
    <version>1.0.0-M5</version>
</dependency>
<!-- 或根據(jù)需要添加具體供應商 -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    <version>1.0.0-M5</version>
</dependency>
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-azure-openai-spring-boot-starter</artifactId>
    <version>1.0.0-M5</version>
</dependency>
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-anthropic-spring-boot-starter</artifactId>
    <version>1.0.0-M5</version>
</dependency>

2. 配置文件 (application.yml)

# 應用配置
spring:
  application:
    name: ai-platform-demo
  ai:
    # 默認激活的平臺
    active-platform: openai
    # OpenAI 配置
    openai:
      api-key: ${OPENAI_API_KEY:sk-your-openai-key}
      base-url: https://api.openai.com/v1
      chat:
        options:
          model: gpt-4-turbo
          temperature: 0.7
    # Azure OpenAI 配置
    azure:
      openai:
        api-key: ${AZURE_OPENAI_API_KEY:your-azure-key}
        endpoint: https://your-resource.openai.azure.com
        deployment-name: gpt-4
        chat:
          options:
            temperature: 0.7
            max-tokens: 2000
    # Anthropic Claude 配置
    anthropic:
      api-key: ${ANTHROPIC_API_KEY:your-anthropic-key}
      base-url: https://api.anthropic.com
      chat:
        options:
          model: claude-3-opus-20240229
          temperature: 0.7
          max-tokens: 4096
    # Ollama 本地模型配置
    ollama:
      base-url: http://localhost:11434
      chat:
        options:
          model: llama2
          temperature: 0.7
    # 多模型工廠配置
    model: chatgpt4
    provider: openai

3. 配置屬性類

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Data
@Component
@ConfigurationProperties(prefix = "spring.ai")
public class AIConfigProperties {
    private String activePlatform;
    private OpenAIConfig openai;
    private AzureOpenAIConfig azure;
    private AnthropicConfig anthropic;
    private OllamaConfig ollama;
    @Data
    public static class OpenAIConfig {
        private String apiKey;
        private String baseUrl = "https://api.openai.com/v1";
        private ChatOptions chat = new ChatOptions();
        @Data
        public static class ChatOptions {
            private String model = "gpt-4-turbo";
            private Double temperature = 0.7;
            private Integer maxTokens = 2000;
        }
    }
    @Data
    public static class AzureOpenAIConfig {
        private String apiKey;
        private String endpoint;
        private String deploymentName = "gpt-4";
        private ChatOptions chat = new ChatOptions();
        @Data
        public static class ChatOptions {
            private Double temperature = 0.7;
            private Integer maxTokens = 2000;
        }
    }
    @Data
    public static class AnthropicConfig {
        private String apiKey;
        private String baseUrl = "https://api.anthropic.com";
        private ChatOptions chat = new ChatOptions();
        @Data
        public static class ChatOptions {
            private String model = "claude-3-opus-20240229";
            private Double temperature = 0.7;
            private Integer maxTokens = 4096;
        }
    }
    @Data
    public static class OllamaConfig {
        private String baseUrl = "http://localhost:11434";
        private ChatOptions chat = new ChatOptions();
        @Data
        public static class ChatOptions {
            private String model = "llama2";
            private Double temperature = 0.7;
        }
    }
}

4. 核心配置類

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.openai.OpenAiChatClient;
import org.springframework.ai.openai.OpenAiChatOptions;
import org.springframework.ai.openai.api.OpenAiApi;
import org.springframework.ai.azure.openai.AzureOpenAiChatClient;
import org.springframework.ai.azure.openai.AzureOpenAiChatOptions;
import org.springframework.ai.azure.openai.AzureOpenAiApi;
import org.springframework.ai.anthropic.AnthropicChatClient;
import org.springframework.ai.anthropic.AnthropicChatOptions;
import org.springframework.ai.anthropic.api.AnthropicApi;
import org.springframework.ai.ollama.OllamaChatClient;
import org.springframework.ai.ollama.OllamaChatOptions;
import org.springframework.ai.ollama.api.OllamaApi;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

@Configuration
public class AIConfiguration {
    
    private final AIConfigProperties aiConfig;
    
    public AIConfiguration(AIConfigProperties aiConfig) {
        this.aiConfig = aiConfig;
    }
    
    // OpenAI Client
    @Bean
    @Primary
    public OpenAiChatClient openAiChatClient() {
        var config = aiConfig.getOpenai();
        var api = new OpenAiApi(config.getBaseUrl(), config.getApiKey());
        
        var options = OpenAiChatOptions.builder()
            .withModel(config.getChat().getModel())
            .withTemperature(config.getChat().getTemperature())
            .withMaxTokens(config.getChat().getMaxTokens())
            .build();
        
        return new OpenAiChatClient(api, options);
    }
    
    // Azure OpenAI Client
    @Bean
    public AzureOpenAiChatClient azureOpenAiChatClient() {
        var config = aiConfig.getAzure();
        var api = new AzureOpenAiApi(config.getEndpoint(), config.getApiKey());
        
        var options = AzureOpenAiChatOptions.builder()
            .withDeploymentName(config.getDeploymentName())
            .withTemperature(config.getChat().getTemperature())
            .withMaxTokens(config.getChat().getMaxTokens())
            .build();
        
        return new AzureOpenAiChatClient(api, options);
    }
    
    // Anthropic Client
    @Bean
    public AnthropicChatClient anthropicChatClient() {
        var config = aiConfig.getAnthropic();
        var api = new AnthropicApi(config.getApiKey(), config.getBaseUrl());
        
        var options = AnthropicChatOptions.builder()
            .withModel(config.getChat().getModel())
            .withTemperature(config.getChat().getTemperature())
            .withMaxTokens(config.getChat().getMaxTokens())
            .build();
        
        return new AnthropicChatClient(api, options);
    }
    
    // Ollama Client
    @Bean
    public OllamaChatClient ollamaChatClient() {
        var config = aiConfig.getOllama();
        var api = new OllamaApi(config.getBaseUrl());
        
        var options = OllamaChatOptions.builder()
            .withModel(config.getChat().getModel())
            .withTemperature(config.getChat().getTemperature())
            .build();
        
        return new OllamaChatClient(api, options);
    }
    
    // 動態(tài)選擇 ChatClient
    @Bean
    @Primary
    public ChatClient chatClient(
            @Qualifier("openAiChatClient") OpenAiChatClient openAiChatClient,
            @Qualifier("azureOpenAiChatClient") AzureOpenAiChatClient azureOpenAiChatClient,
            @Qualifier("anthropicChatClient") AnthropicChatClient anthropicChatClient,
            @Qualifier("ollamaChatClient") OllamaChatClient ollamaChatClient) {
        
        return ChatClient.builder()
            .defaultAdvisors(request -> {
                switch (aiConfig.getActivePlatform()) {
                    case "openai":
                        return request.advisors(advisor -> advisor.param("chatClient", openAiChatClient));
                    case "azure":
                        return request.advisors(advisor -> advisor.param("chatClient", azureOpenAiChatClient));
                    case "anthropic":
                        return request.advisors(advisor -> advisor.param("chatClient", anthropicChatClient));
                    case "ollama":
                        return request.advisors(advisor -> advisor.param("chatClient", ollamaChatClient));
                    default:
                        return request.advisors(advisor -> advisor.param("chatClient", openAiChatClient));
                }
            })
            .build();
    }
}

5. 服務層封裝

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.prompt.PromptTemplate;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import java.util.Map;

@Service
public class AIChatService {
    
    private final ChatClient chatClient;
    private final AIConfigProperties aiConfig;
    
    public AIChatService(
            @Qualifier("chatClient") ChatClient chatClient,
            AIConfigProperties aiConfig) {
        this.chatClient = chatClient;
        this.aiConfig = aiConfig;
    }
    
    public String chat(String message) {
        return chatClient.prompt()
            .system("你是一個有幫助的AI助手")
            .user(message)
            .call()
            .content();
    }
    
    public String chatWithTemplate(String template, Map<String, Object> variables) {
        PromptTemplate promptTemplate = new PromptTemplate(template);
        Prompt prompt = promptTemplate.create(variables);
        
        ChatResponse response = chatClient.call(prompt);
        return response.getResult().getOutput().getContent();
    }
    
    public void switchPlatform(String platform) {
        aiConfig.setActivePlatform(platform);
    }
    
    public String getActivePlatform() {
        return aiConfig.getActivePlatform();
    }
}

6. 控制器示例

import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;

import java.util.Map;

@RestController
@RequestMapping("/api/ai")
public class AIController {
    
    private final AIChatService aiChatService;
    
    public AIController(AIChatService aiChatService) {
        this.aiChatService = aiChatService;
    }
    
    @PostMapping("/chat")
    public ResponseEntity<Map<String, String>> chat(@RequestBody ChatRequest request) {
        String response = aiChatService.chat(request.getMessage());
        return ResponseEntity.ok(Map.of(
            "response", response,
            "platform", aiChatService.getActivePlatform()
        ));
    }
    
    @PostMapping("/switch-platform")
    public ResponseEntity<Map<String, String>> switchPlatform(
            @RequestParam String platform) {
        aiChatService.switchPlatform(platform);
        return ResponseEntity.ok(Map.of(
            "message", "已切換到平臺: " + platform,
            "platform", platform
        ));
    }
    
    @GetMapping("/current-platform")
    public ResponseEntity<Map<String, String>> getCurrentPlatform() {
        return ResponseEntity.ok(Map.of(
            "platform", aiChatService.getActivePlatform()
        ));
    }
    
    public record ChatRequest(String message) {
    }
}

7. 環(huán)境變量配置 (.env 或系統(tǒng)環(huán)境變量)

# OpenAI
OPENAI_API_KEY=sk-your-openai-key
# Azure OpenAI
AZURE_OPENAI_API_KEY=your-azure-key
AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com
# Anthropic
ANTHROPIC_API_KEY=your-anthropic-key
# 其他可選配置
SPRING_AI_ACTIVE_PLATFORM=openai

8. 使用示例

@Service
public class BusinessService {
    
    private final AIChatService aiChatService;
    
    public String analyzeContent(String content) {
        String template = """
            請分析以下內容：
            內容：{content}
            
            請?zhí)峁?
            1. 主要內容總結
            2. 關鍵點提取
            3. 建議
            """;
            
        return aiChatService.chatWithTemplate(template, 
            Map.of("content", content));
    }
    
    public String translateText(String text, String targetLanguage) {
        String prompt = String.format("請將以下文本翻譯成%s: %s", 
            targetLanguage, text);
        return aiChatService.chat(prompt);
    }
}

主要使用教程：

多平臺支持：OpenAI、Azure OpenAI、Anthropic、Ollama
動態(tài)切換：運行時可切換不同AI平臺
統(tǒng)一接口：通過統(tǒng)一的ChatClient調用
配置靈活：支持YAML配置和環(huán)境變量
模板支持：支持Prompt模板
易于擴展：可輕松添加新平臺

這樣配置后，你可以通過修改spring.ai.active-platform或調用API接口來切換不同的AI平臺，每個平臺使用各自的API密鑰。

以上就是SpringBoot整合SpringAI配置多平臺API密鑰的解決方案的詳細內容，更多關于SpringBoot SpringAI配置API密鑰的資料請關注腳本之家其它相關文章！

您可能感興趣的文章:

一文詳解Java中的注解(Annotation)
在Java中注解(Annotation)引入始于Java5,用來描述Java代碼的元信息,通常情況下注解不會直接影響代碼的執(zhí)行,盡管有些注解可以用來做到影響代碼執(zhí)行,這篇文章主要給大家介紹了關于Java中注解(Annotation)的相關資料,需要的朋友可以參考下
2024-03-03
java8中Stream的使用示例教程
Stream是Java8的一大亮點,是對容器對象功能的增強，下面這篇文章主要給大家介紹了關于java8中Stream使用的相關資料，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
2018-10-10
Spring @Valid和@Validated區(qū)別和用法實例
這篇文章主要介紹了Spring @Valid和@Validated區(qū)別和用法實例,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下
2020-04-04
在Java SE上使用Headless模式的超級指南
這篇文章主要介紹了在Java SE上使用Headless模式的超級指南,文中介紹了Headless模式實際使用的各種技巧,極力推薦!需要的朋友可以參考下
2015-07-07
JavaWeb實現(xiàn)簡單的自動登錄功能
這篇文章主要為大家詳細介紹了JavaWeb實現(xiàn)簡單的自動登錄功能，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下
2021-08-08
Spring AOP如何實現(xiàn)注解式的Mybatis多數(shù)據(jù)源切換詳解
這篇文章主要給大家介紹了關于Spring AOP如何實現(xiàn)注解式的Mybatis多數(shù)據(jù)源切換的相關資料，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
2020-11-11
深入理解Spring?Boot中的Flyway
Flyway將數(shù)據(jù)庫結構的變更定義為一系列遷移腳本，通常是SQL腳本文件，當應用程序啟動時，F(xiàn)lyway會自動檢測并執(zhí)行未應用的遷移腳本，將數(shù)據(jù)庫升級到最新版本，這篇文章主要介紹了深入理解Spring?Boot中的Flyway,需要的朋友可以參考下
2024-01-01
Java使用正則表達式判斷獨立字符的存在(代碼示例)
通過使用正則表達式,我們可以更加靈活地判斷字符串中是否包含特定的字符,并且可以控制匹配的條件,如獨立的字符,這為我們處理字符串提供了更多的選擇和功能,這篇文章主要介紹了Java使用正則表達式判斷獨立字符的存在,需要的朋友可以參考下
2023-10-10
Spring AOP執(zhí)行先后順序實例詳解
這篇文章主要介紹了Spring AOP執(zhí)行先后順序實例詳解,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下
2020-01-01
java異步編程之一文看完其異步函數(shù)表
這篇文章主要為大家介紹了java異步編程之一文看完其異步函數(shù)表示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪
2023-01-01