SpringBoot整合SpringAI配置多平台API密钥

搭建AI完整的SpringBoot整合SpringAI配置多平台API密钥的解决方案：

1. 添加依赖 (pom.xml)

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai</artifactId>
    <version>1.0.0-M5</version>
</dependency>

<!-- 或根据需要添加具体供应商 -->
<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);
    }
    
    // 动态选择 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. 环境变量配置 (.env 或系统环境变量)

# 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}
            
            请提供：
            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);
    }
}

主要使用教程：

1. 多平台支持：OpenAI、Azure OpenAI、Anthropic、Ollama
2. 动态切换：运行时可切换不同AI平台
3. 统一接口：通过统一的ChatClient调用
4. 配置灵活：支持YAML配置和环境变量
5. 模板支持：支持Prompt模板
6. 易于扩展：可轻松添加新平台

这样配置后，你可以通过修改spring.ai.active-platform或调用API接口来切换不同的AI平台，每个平台使用各自的API密钥。