脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → 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中的注解(Annotation)

    一文详解Java中的注解(Annotation)

    在Java中注解(Annotation)引入始于Java5,用来描述Java代码的元信息,通常情况下注解不会直接影响代码的执行,尽管有些注解可以用来做到影响代码执行,这篇文章主要给大家介绍了关于Java中注解(Annotation)的相关资料,需要的朋友可以参考下
    2024-03-03
  • java8中Stream的使用示例教程

    java8中Stream的使用示例教程

    Stream是Java8的一大亮点,是对容器对象功能的增强，下面这篇文章主要给大家介绍了关于java8中Stream使用的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2018-10-10
  • Spring @Valid和@Validated区别和用法实例

    Spring @Valid和@Validated区别和用法实例

    这篇文章主要介绍了Spring @Valid和@Validated区别和用法实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-04-04
  • 在Java SE上使用Headless模式的超级指南

    在Java SE上使用Headless模式的超级指南

    这篇文章主要介绍了在Java SE上使用Headless模式的超级指南,文中介绍了Headless模式实际使用的各种技巧,极力推荐!需要的朋友可以参考下
    2015-07-07
  • JavaWeb实现简单的自动登录功能

    JavaWeb实现简单的自动登录功能

    这篇文章主要为大家详细介绍了JavaWeb实现简单的自动登录功能，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2021-08-08
  • Spring AOP如何实现注解式的Mybatis多数据源切换详解

    Spring AOP如何实现注解式的Mybatis多数据源切换详解

    这篇文章主要给大家介绍了关于Spring AOP如何实现注解式的Mybatis多数据源切换的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2020-11-11
  • 深入理解Spring Boot中的Flyway

    深入理解Spring Boot中的Flyway

    Flyway将数据库结构的变更定义为一系列迁移脚本，通常是SQL脚本文件，当应用程序启动时，Flyway会自动检测并执行未应用的迁移脚本，将数据库升级到最新版本，这篇文章主要介绍了深入理解Spring Boot中的Flyway,需要的朋友可以参考下
    2024-01-01
  • Java使用正则表达式判断独立字符的存在(代码示例)

    Java使用正则表达式判断独立字符的存在(代码示例)

    通过使用正则表达式,我们可以更加灵活地判断字符串中是否包含特定的字符,并且可以控制匹配的条件,如独立的字符,这为我们处理字符串提供了更多的选择和功能,这篇文章主要介绍了Java使用正则表达式判断独立字符的存在,需要的朋友可以参考下
    2023-10-10
  • Spring AOP执行先后顺序实例详解

    Spring AOP执行先后顺序实例详解

    这篇文章主要介绍了Spring AOP执行先后顺序实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-01-01
  • java异步编程之一文看完其异步函数表

    java异步编程之一文看完其异步函数表

    这篇文章主要为大家介绍了java异步编程之一文看完其异步函数表示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2023-01-01

最新评论