在Trae?IDE中創(chuàng)建Spring?AI項目的實現(xiàn)步驟

更新時間：2025年08月14日 08:42:54 作者：一只愛擼貓的程序猿

Trae是一個下一代AI代碼編輯器,具有智能代碼生成、自然語言交互、圖像輔助需求表達等功能,本文就來介紹一下Trae?IDE創(chuàng)建Spring?AI項目的實現(xiàn)步驟,感興趣的可以了解一下

Spring AI 項目完整示例

1. 項目結(jié)構(gòu)

spring-ai-demo/
├── src/main/java/com/example/springai/
│   ├── SpringAiDemoApplication.java
│   ├── controller/
│   │   └── ChatController.java
│   ├── service/
│   │   └── ChatService.java
│   └── config/
│       └── AiConfig.java
├── src/main/resources/
│   └── application.yml
└── pom.xml

2. pom.xml 配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.0</version>
        <relativePath/>
    </parent>
    
    <groupId>com.example</groupId>
    <artifactId>spring-ai-demo</artifactId>
    <version>1.0.0</version>
    <name>Spring AI Demo</name>
    
    <properties>
        <java.version>17</java.version>
        <spring-ai.version>0.8.1</spring-ai.version>
    </properties>
    
    <dependencies>
        <!-- Spring Boot Starter Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!-- Spring AI OpenAI -->
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
            <version>${spring-ai.version}</version>
        </dependency>
        
        <!-- Spring AI Ollama (本地 AI 模型支持) -->
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-ollama-spring-boot-starter</artifactId>
            <version>${spring-ai.version}</version>
        </dependency>
        
        <!-- Spring Boot Starter Test -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

3. 應用配置 (application.yml)

spring:
  application:
    name: spring-ai-demo
  ai:
    openai:
      api-key: ${OPENAI_API_KEY:your-openai-api-key-here}
      chat:
        options:
          model: gpt-3.5-turbo
          temperature: 0.7
          max-tokens: 1000
    ollama:
      base-url: http://localhost:11434
      chat:
        options:
          model: llama2
          temperature: 0.7

server:
  port: 8080

logging:
  level:
    org.springframework.ai: DEBUG

4. 主應用類

package com.example.springai;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringAiDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringAiDemoApplication.class, args);
    }
}

5. AI 配置類

package com.example.springai.config;

import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.prompt.PromptTemplate;
import org.springframework.ai.openai.OpenAiChatClient;
import org.springframework.ai.openai.api.OpenAiApi;
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 AiConfig {

    @Value("${spring.ai.openai.api-key}")
    private String openAiApiKey;

    @Bean
    @Primary
    public ChatClient openAiChatClient() {
        var openAiApi = new OpenAiApi(openAiApiKey);
        return new OpenAiChatClient(openAiApi);
    }

    @Bean
    public PromptTemplate systemPromptTemplate() {
        return new PromptTemplate("""
            你是一個友善的AI助手。請用中文回答問題，并保持回答的準確性和有幫助性。
            如果你不確定答案，請誠實地說明。
            """);
    }
}

6. 服務(wù)層

package com.example.springai.service;

import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.ChatResponse;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.prompt.PromptTemplate;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.messages.SystemMessage;
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.List;
import java.util.Map;

@Service
public class ChatService {

    private final ChatClient chatClient;
    private final PromptTemplate systemPromptTemplate;

    @Autowired
    public ChatService(ChatClient chatClient, PromptTemplate systemPromptTemplate) {
        this.chatClient = chatClient;
        this.systemPromptTemplate = systemPromptTemplate;
    }

    /**
     * 簡單聊天
     */
    public String simpleChat(String userMessage) {
        UserMessage message = new UserMessage(userMessage);
        ChatResponse response = chatClient.call(new Prompt(List.of(message)));
        return response.getResult().getOutput().getContent();
    }

    /**
     * 帶系統(tǒng)提示的聊天
     */
    public String chatWithSystem(String userMessage) {
        SystemMessage systemMessage = new SystemMessage(systemPromptTemplate.render());
        UserMessage userMsg = new UserMessage(userMessage);
        
        List<Message> messages = List.of(systemMessage, userMsg);
        ChatResponse response = chatClient.call(new Prompt(messages));
        
        return response.getResult().getOutput().getContent();
    }

    /**
     * 模板化聊天
     */
    public String templateChat(String topic, String style) {
        PromptTemplate promptTemplate = new PromptTemplate("""
            請以{style}的風格，詳細介紹{topic}。
            要求：
            1. 內(nèi)容準確專業(yè)
            2. 結(jié)構(gòu)清晰
            3. 適合初學者理解
            """);

        Map<String, Object> model = Map.of(
            "topic", topic,
            "style", style
        );

        Prompt prompt = promptTemplate.create(model);
        ChatResponse response = chatClient.call(prompt);
        
        return response.getResult().getOutput().getContent();
    }

    /**
     * 代碼生成助手
     */
    public String generateCode(String language, String description) {
        PromptTemplate codeTemplate = new PromptTemplate("""
            請用{language}編程語言生成代碼，實現(xiàn)以下功能：
            {description}
            
            要求：
            1. 代碼要有詳細注釋
            2. 遵循最佳實踐
            3. 包含錯誤處理
            4. 提供使用示例
            """);

        Map<String, Object> model = Map.of(
            "language", language,
            "description", description
        );

        Prompt prompt = codeTemplate.create(model);
        ChatResponse response = chatClient.call(prompt);
        
        return response.getResult().getOutput().getContent();
    }
}

7. 控制器層

package com.example.springai.controller;

import com.example.springai.service.ChatService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.Map;

@RestController
@RequestMapping("/api/chat")
@CrossOrigin(origins = "*")
public class ChatController {

    private final ChatService chatService;

    @Autowired
    public ChatController(ChatService chatService) {
        this.chatService = chatService;
    }

    /**
     * 簡單聊天接口
     */
    @PostMapping("/simple")
    public ResponseEntity<Map<String, String>> simpleChat(@RequestBody Map<String, String> request) {
        try {
            String userMessage = request.get("message");
            if (userMessage == null || userMessage.trim().isEmpty()) {
                return ResponseEntity.badRequest()
                    .body(Map.of("error", "消息內(nèi)容不能為空"));
            }

            String response = chatService.simpleChat(userMessage);
            return ResponseEntity.ok(Map.of(
                "message", userMessage,
                "response", response
            ));
        } catch (Exception e) {
            return ResponseEntity.internalServerError()
                .body(Map.of("error", "處理請求時發(fā)生錯誤: " + e.getMessage()));
        }
    }

    /**
     * 系統(tǒng)提示聊天接口
     */
    @PostMapping("/system")
    public ResponseEntity<Map<String, String>> systemChat(@RequestBody Map<String, String> request) {
        try {
            String userMessage = request.get("message");
            String response = chatService.chatWithSystem(userMessage);
            return ResponseEntity.ok(Map.of(
                "message", userMessage,
                "response", response
            ));
        } catch (Exception e) {
            return ResponseEntity.internalServerError()
                .body(Map.of("error", "處理請求時發(fā)生錯誤: " + e.getMessage()));
        }
    }

    /**
     * 模板聊天接口
     */
    @PostMapping("/template")
    public ResponseEntity<Map<String, String>> templateChat(@RequestBody Map<String, String> request) {
        try {
            String topic = request.get("topic");
            String style = request.get("style");
            
            if (topic == null || style == null) {
                return ResponseEntity.badRequest()
                    .body(Map.of("error", "topic 和 style 參數(shù)不能為空"));
            }

            String response = chatService.templateChat(topic, style);
            return ResponseEntity.ok(Map.of(
                "topic", topic,
                "style", style,
                "response", response
            ));
        } catch (Exception e) {
            return ResponseEntity.internalServerError()
                .body(Map.of("error", "處理請求時發(fā)生錯誤: " + e.getMessage()));
        }
    }

    /**
     * 代碼生成接口
     */
    @PostMapping("/code")
    public ResponseEntity<Map<String, String>> generateCode(@RequestBody Map<String, String> request) {
        try {
            String language = request.get("language");
            String description = request.get("description");
            
            if (language == null || description == null) {
                return ResponseEntity.badRequest()
                    .body(Map.of("error", "language 和 description 參數(shù)不能為空"));
            }

            String response = chatService.generateCode(language, description);
            return ResponseEntity.ok(Map.of(
                "language", language,
                "description", description,
                "code", response
            ));
        } catch (Exception e) {
            return ResponseEntity.internalServerError()
                .body(Map.of("error", "處理請求時發(fā)生錯誤: " + e.getMessage()));
        }
    }

    /**
     * 健康檢查
     */
    @GetMapping("/health")
    public ResponseEntity<Map<String, String>> health() {
        return ResponseEntity.ok(Map.of(
            "status", "ok",
            "message", "Spring AI 服務(wù)運行正常"
        ));
    }
}

8. 使用示例

啟動應用后，您可以通過以下方式測試：

簡單聊天

curl -X POST http://localhost:8080/api/chat/simple \
  -H "Content-Type: application/json" \
  -d '{"message": "你好，請介紹一下Spring框架"}'

模板聊天

curl -X POST http://localhost:8080/api/chat/template \
  -H "Content-Type: application/json" \
  -d '{"topic": "Spring Boot", "style": "通俗易懂"}'

代碼生成

curl -X POST http://localhost:8080/api/chat/code \
  -H "Content-Type: application/json" \
  -d '{"language": "Java", "description": "實現(xiàn)一個簡單的用戶注冊功能"}'

9. 環(huán)境配置說明

OpenAI 配置：需要設(shè)置環(huán)境變量 OPENAI_API_KEY
本地 Ollama 配置：需要先安裝并運行 Ollama 服務(wù)

到此這篇關(guān)于在Trae IDE中創(chuàng)建Spring AI項目的實現(xiàn)步驟的文章就介紹到這了,更多相關(guān)Trae IDE創(chuàng)建Spring AI項目內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: