脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → SpringBoot SpringAI配置API密钥

SpringBoot整合SpringAI配置多平台API密钥的解决方案

 更新时间：2026年05月20日 08:23:38   作者：小坏说Java  
本文介绍了如何在SpringBoot项目中整合SpringAI配置平台API密钥,包括添加依赖、配置文件、配置属性类及核心配置类等,通过动态切换不同AI平台,实现统一接口调用,此外,支持YAML配置和环境变量,便于灵活配置和扩展新平台,需要的朋友可以参考下

搭建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密钥。

以上就是SpringBoot整合SpringAI配置多平台API密钥的解决方案的详细内容，更多关于SpringBoot SpringAI配置API密钥的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

相关文章

  • java.time包时间类的具体使用

    java.time包时间类的具体使用

    本文主要介绍了java.time包时间类的具体使用,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2024-08-08
  • Spring容器中添加bean的5种方式

    Spring容器中添加bean的5种方式

    我们知道平时在开发中使用Spring的时候，都是将对象交由Spring去管理，那么将一个对象加入到Spring容器中，有哪些方式呢，感兴趣的可以了解一下
    2021-07-07
  • 详解Spring Boot中如何自定义SpringMVC配置

    详解Spring Boot中如何自定义SpringMVC配置

    这篇文章主要给大家介绍了关于Spring Boot中如何自定义SpringMVC配置的相关资料,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2021-09-09
  • Spring依赖注入多种类型数据的示例代码

    Spring依赖注入多种类型数据的示例代码

    这篇文章主要介绍了Spring依赖注入多种类型数据,本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2022-03-03
  • 空指针HttpSession异常之SpringBoot集成WebSocket的方法

    空指针HttpSession异常之SpringBoot集成WebSocket的方法

    文章介绍了在Spring Boot中集成WebSocket时遇到的HttpSession为空的问题,并探讨了三种解决方法,方法一涉及域名配置,方法二通过监听创建Session,而方法三是从request中获取session并存入数据,感兴趣的朋友一起看看吧
    2025-01-01
  • SpringBoot整合Ureport2报表及常见使用方法

    SpringBoot整合Ureport2报表及常见使用方法

    这篇文章主要介绍了SpringBoot整合Ureport2报表及常见使用方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2021-01-01
  • SpringBoot项目多数据源及mybatis 驼峰失效的问题解决方法

    SpringBoot项目多数据源及mybatis 驼峰失效的问题解决方法

    这篇文章主要介绍了SpringBoot项目多数据源及mybatis 驼峰失效的问题解决方法，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2022-07-07
  • Java通过Process类Runtime.getRuntime().exec()执行bat脚本程序

    Java通过Process类Runtime.getRuntime().exec()执行bat脚本程序

    用Java编写应用时,有时需要在程序中调用另一个现成的可执行程序或系统命令,这篇文章主要给大家介绍了关于Java如何通过Process类Runtime.getRuntime().exec()执行bat脚本程序的相关资料,需要的朋友可以参考下
    2024-01-01
  • java.lang.NoSuchMethodException: com.sun.proxy.$Proxy58.list错误解决办法

    java.lang.NoSuchMethodException: com.sun.proxy.$Proxy58.list

    这篇文章主要介绍了java.lang.NoSuchMethodException: com.sun.proxy.$Proxy58.list错误解决办法的相关资料,需要的朋友可以参考下
    2016-12-12
  • mybatis-plus多表联查join的实现

    mybatis-plus多表联查join的实现

    本文主要介绍了mybatis-plus多表联查join的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2023-01-01

最新评论