Java AI API ผนวกรวม Spring Boot 应用实战 — คู่มือฉบับสมบูรณ์

การนำ AI API มาใช้งานในแอปพลิเคชัน Spring Boot เป็นทักษะที่นักพัฒนายุคใหม่ต้องมี ในบทความนี้เราจะพาคุณเรียนรู้การตั้งค่าโปรเจกต์ Spring Boot ให้เชื่อมต่อกับ AI API ผ่าน HolySheep AI ซึ่งให้บริการด้วยราคาที่ประหยัดกว่า 85% พร้อมความเร็วตอบสนองต่ำกว่า 50 มิลลิวินาที

ตารางเปรียบเทียบบริการ AI API

เกณฑ์	HolySheep AI	API อย่างเป็นทางการ	บริการรีเลย์อื่นๆ
ราคา GPT-4.1	$8/MTok	$60/MTok	$15-30/MTok
ราคา Claude Sonnet 4.5	$15/MTok	$75/MTok	$25-40/MTok
ราคา Gemini 2.5 Flash	$2.50/MTok	$10/MTok	$5-8/MTok
ราคา DeepSeek V3.2	$0.42/MTok	$2/MTok	$1-1.50/MTok
ความหน่วง (Latency)	ต่ำกว่า 50ms	80-200ms	60-150ms
วิธีชำระเงิน	WeChat/Alipay	บัตรเครดิตระหว่างประเทศ	PayPal/บัตร
เครดิตฟรี	มีเมื่อลงทะเบียน	$5 ทดลอง	จำกัดหรือไม่มี
base_url	api.holysheep.ai	api.openai.com	แตกต่างกันไป

การตั้งค่า Spring Boot Project

เริ่มต้นด้วยการสร้างโปรเจกต์ Spring Boot ใหม่และเพิ่ม dependencies ที่จำเป็น สำหรับการเชื่อมต่อกับ AI API ผ่าน REST

ไฟล์ 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 
         https://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>ai-api-spring-boot</artifactId>
    <version>1.0.0</version>
    <name>AI API Spring Boot Integration</name>
    
    <properties>
        <java.version>17</java.version>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
        
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
</project>

ไฟล์ application.yml

spring:
  application:
    name: ai-api-service

server:
  port: 8080

ai:
  api:
    base-url: https://api.holysheep.ai/v1
    api-key: YOUR_HOLYSHEEP_API_KEY
    model: gpt-4.1
    temperature: 0.7
    max-tokens: 2000
    timeout: 30000

สร้าง Service Layer สำหรับ AI API

ในส่วนนี้เราจะสร้าง service class ที่ใช้ WebClient ในการเรียก API ไปยัง HolySheep โดยใช้ base_url ที่ถูกต้อง

package com.example.aiservice.service;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

import java.time.Duration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class AiApiService {
    
    private final WebClient webClient;
    private final ObjectMapper objectMapper;
    private final String model;
    private final double temperature;
    private final int maxTokens;
    
    public AiApiService(
            @Value("${ai.api.base-url}") String baseUrl,
            @Value("${ai.api.api-key}") String apiKey,
            @Value("${ai.api.model}") String model,
            @Value("${ai.api.temperature}") double temperature,
            @Value("${ai.api.max-tokens}") int maxTokens) {
        
        this.webClient = WebClient.builder()
                .baseUrl(baseUrl)
                .defaultHeader("Authorization", "Bearer " + apiKey)
                .defaultHeader("Content-Type", "application/json")
                .build();
        
        this.objectMapper = new ObjectMapper();
        this.model = model;
        this.temperature = temperature;
        this.maxTokens = maxTokens;
    }
    
    public Mono<String> generateChatCompletion(String userMessage) {
        Map<String, Object> requestBody = new HashMap<>();
        requestBody.put("model", model);
        
        Map<String, String> userMessageMap = new HashMap<>();
        userMessageMap.put("role", "user");
        userMessageMap.put("content", userMessage);
        
        requestBody.put("messages", List.of(userMessageMap));
        requestBody.put("temperature", temperature);
        requestBody.put("max_tokens", maxTokens);
        
        return webClient.post()
                .uri("/chat/completions")
                .bodyValue(requestBody)
                .retrieve()
                .bodyToMono(String.class)
                .map(this::extractContentFromResponse)
                .timeout(Duration.ofSeconds(30));
    }
    
    private String extractContentFromResponse(String responseJson) {
        try {
            JsonNode rootNode = objectMapper.readTree(responseJson);
            return rootNode.path("choices")
                    .get(0)
                    .path("message")
                    .path("content")
                    .asText();
        } catch (Exception e) {
            throw new RuntimeException("Failed to parse AI response: " + e.getMessage());
        }
    }
    
    public Mono<String> generateChatCompletionWithHistory(
            List<Map<String, String>> messages) {
        
        Map<String, Object> requestBody = new HashMap<>();
        requestBody.put("model", model);
        requestBody.put("messages", messages);
        requestBody.put("temperature", temperature);
        requestBody.put("max_tokens", maxTokens);
        
        return webClient.post()
                .uri("/chat/completions")
                .bodyValue(requestBody)
                .retrieve()
                .bodyToMono(String.class)
                .map(this::extractContentFromResponse)
                .timeout(Duration.ofSeconds(30));
    }
}

สร้าง REST Controller

package com.example.aiservice.controller;

import com.example.aiservice.service.AiApiService;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Mono;

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

@RestController
@RequestMapping("/api/ai")
public class AiController {
    
    private final AiApiService aiApiService;
    
    public AiController(AiApiService aiApiService) {
        this.aiApiService = aiApiService;
    }
    
    @PostMapping("/chat")
    public Mono<Map<String, String>> chat(@RequestBody Map<String, String> request) {
        String message = request.get("message");
        
        return aiApiService.generateChatCompletion(message)
                .map(response -> {
                    Map<String, String> result = new HashMap<>();
                    result.put("response", response);
                    result.put("model", "gpt-4.1");
                    return result;
                })
                .onErrorResume(e -> Mono.just(Map.of(
                        "error", e.getMessage(),
                        "response", "เกิดข้อผิดพลาดในการเชื่อมต่อ AI API"
                )));
    }
    
    @PostMapping("/chat-with-history")
    public Mono<Map<String, Object>> chatWithHistory(
            @RequestBody List<Map<String, String>> messages) {
        
        return aiApiService.generateChatCompletionWithHistory(messages)
                .map(response -> {
                    Map<String, Object> result = new HashMap<>();
                    result.put("response", response);
                    result.put("model", "gpt-4.1");
                    result.put("messageCount", messages.size());
                    return result;
                })
                .onErrorResume(e -> Mono.just(Map.of(
                        "error", e.getMessage(),
                        "response", "เกิดข้อผิดพลาดในการเชื่อมต่อ AI API"
                )));
    }
    
    @GetMapping("/models")
    public Map<String, String> getAvailableModels() {
        Map<String, String> models = new HashMap<>();
        models.put("gpt-4.1", "GPT-4.1 — $8/MTok");
        models.put("claude-sonnet-4.5", "Claude Sonnet 4.5 — $15/MTok");
        models.put("gemini-2.5-flash", "Gemini 2.5 Flash — $2.50/MTok");
        models.put("deepseek-v3.2", "DeepSeek V3.2 — $0.42/MTok");
        return models;
    }
}

Unit Test สำหรับ AI Service

package com.example.aiservice.service;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;

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

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.when;

class AiApiServiceTest {
    
    @Mock
    private WebClient webClient;
    
    @Mock
    private WebClient.RequestBodySpec requestBodySpec;
    
    @Mock
    private WebClient.RequestBodyUriSpec requestBodyUriSpec;
    
    private AiApiService aiApiService;
    
    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        
        when(webClient.post()).thenReturn(requestBodyUriSpec);
        when(requestBodyUriSpec.uri(anyString())).thenReturn(requestBodySpec);
        when(requestBodySpec.bodyValue(any())).thenReturn(requestBodySpec);
        when(requestBodySpec.retrieve()).thenReturn(null);
    }
    
    @Test
    void testGenerateChatCompletion_Success() {
        String mockResponse = """
                {
                    "choices": [
                        {
                            "message": {
                                "content": "นี่คือคำตอบจาก AI"
                            }
                        }
                    ]
                }
                """;
        
        when(requestBodySpec.bodyToMono(String.class))
                .thenReturn(Mono.just(mockResponse));
        
        StepVerifier.create(aiApiService.generateChatCompletion("ทดสอบ"))
                .expectNext("นี่คือคำตอบจาก AI")
                .verifyComplete();
    }
    
    @Test
    void testChatHistory() {
        List<Map<String, String>> messages = List.of(
                Map.of("role", "system", "content", "คุณเป็นผู้ช่วย"),
                Map.of("role", "user", "content", "สวัสดี")
        );
        
        String mockResponse = """
                {
                    "choices": [
                        {
                            "message": {
                                "content": "สวัสดีครับ มีอะไรให้ช่วยไหม"
                            }
                        }
                    ]
                }
                """;
        
        when(requestBodySpec.bodyToMono(String.class))
                .thenReturn(Mono.just(mockResponse));
        
        StepVerifier.create(
                aiApiService.generateChatCompletionWithHistory(messages))
                .expectNext("สวัสดีครับ มีอะไรให้ช่วยไหม")
                .verifyComplete();
    }
}

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

กรณีที่ 1: ข้อผิดพลาด 401 Unauthorized

// ❌ สาเหตุ: API Key ไม่ถูกต้องหรือไม่ได้ส่ง Authorization Header
// ✅ วิธีแก้ไข: ตรวจสอบ API Key และการตั้งค่า Header

@Configuration
public class WebClientConfig {
    
    @Value("${ai.api.base-url}")
    private String baseUrl;
    
    @Value("${ai.api.api-key}")
    private String apiKey;
    
    @Bean
    public WebClient aiWebClient() {
        return WebClient.builder()
                .baseUrl(baseUrl)
                .defaultHeader("Authorization", "Bearer " + apiKey)
                .defaultHeader("Content-Type", "application/json")
                .filter((request, next) -> {
                    System.out.println("Request URL: " + request.url());
                    System.out.println("Headers: " + request.headers());
                    return next.exchange(request);
                })
                .build();
    }
}

กรณีที่ 2: ข้อผิดพลาด Connection Timeout

// ❌ สาเหตุ: การเชื่อมต่อใช้เวลานานเกินกว่าที่กำหนด
// ✅ วิธีแก้ไข: เพิ่ม timeout ที่เหมาะสมและเพิ่ม retry logic

@Configuration
public class WebClientTimeoutConfig {
    
    @Bean
    public WebClient webClientWithTimeout() {
        return WebClient.builder()
                .baseUrl("https://api.holysheep.ai/v1")
                .defaultHeader("Authorization", "Bearer YOUR_HOLYSHEEP_API_KEY")
                .clientConnector(new ReactorClientHttpConnector(
                        HttpClient.create()
                                .responseTimeout(Duration.ofSeconds(60))
                                .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 30000)
                ))
                .build();
    }
}

// เพิ่ม retry logic สำหรับ transient errors
public Mono<String> generateWithRetry(String message) {
    return aiApiService.generateChatCompletion(message)
            .retryWhen(Retry.backoff(3, Duration.ofSeconds(2))
                    .filter(ex -> ex instanceof WebClientResponseException)
                    .onRetryExhaustedThrow((retryBackoffSpec, retrySignal) -> {
                        throw new RuntimeException("AI API ล่มหลังจาก retry 3 ครั้ง");
                    }));
}

กรณีที่ 3: ข้อผิดพลาด Rate Limit (429)

// ❌ สาเหตุ: ส่ง request เร็วเกินไปเกินโควต้าที่กำหนด
// ✅ วิธีแก้ไข: ใช้ RateLimiter และจัดการ response header

@Configuration
public class RateLimitConfig {
    
    private final RateLimiter rateLimiter = RateLimiter.create(10.0);
    
    public Mono<String> generateWithRateLimit(String message) {
        return Mono.fromCallable(() -> {
            rateLimiter.acquire();
            return message;
        }).flatMap(aiApiService::generateChatCompletion)
          .onErrorResume(WebClientResponseException.TooManyRequests.class, e -> {
              Duration retryAfter = Duration.ofSeconds(
                      Long.parseLong(e.getResponseHeaders()
                              .getFirst("Retry-After")));
              return Mono.delay(retryAfter)
                      .flatMap(ignored -> generateWithRateLimit(message));
          });
    }
}

กรณีที่ 4: ข้อผิดพลาด Response Parsing

// ❌ สาเหตุ: โครงสร้าง JSON response ไม่ตรงกับที่คาดหวัง
// ✅ วิธีแก้ไข: เพิ่ม defensive parsing และ logging

public String extractContentSafely(String responseJson) {
    try {
        JsonNode rootNode = objectMapper.readTree(responseJson);
        
        // ตรวจสอบ error response
        if (rootNode.has("error")) {
            String errorMessage = rootNode.path("error")
                    .path("message").asText("Unknown error");
            throw new AiApiException("API Error: " + errorMessage);
        }
        
        // ตรวจสอบโครงสร้าง choices
        JsonNode choices = rootNode.path("choices");
        if (choices.isMissingNode() || choices.isEmpty()) {
            throw new AiApiException("Empty response from AI API");
        }
        
        return choices.get(0).path("message").path("content").asText();
        
    } catch (AiApiException e) {
        throw e;
    } catch (Exception e) {
        throw new AiApiException("Failed to parse response: " + e.getMessage(), e);
    }
}

// Custom Exception
public class AiApiException extends RuntimeException {
    public AiApiException(String message) {
        super(message);
    }
    
    public AiApiException(String message, Throwable cause) {
        super(message, cause);
    }
}

สรุป

ในบทความนี้เราได้เรียนรู้การผนวกรวม Java AI API เข้ากับ Spring Boot application โดยใช้ HolySheep AI เป็นตัวอย่าง ซึ่งมีข้อได้เปรียบด้านราคาที่ประหยัดมากกว่า 85% เมื่อเทียบกับ API อย่างเป็นทางการ พร้อมความหน่วงต่ำกว่า 50 มิลลิวินาที และรองรับการชำระเงินผ่าน WeChat และ Alipay ทำให้สะดวกสำหรับนักพัฒนาในภูมิภาคเอเชีย

ราคาของโมเดลต่างๆ บน HolySheep ในปี 2026 อยู่ที่ GPT-4.1 ราคา $8/MTok, Claude Sonnet 4.5 ราคา $15/MTok, Gemini 2.5 Flash ราคา $2.50/MTok และ DeepSeek V3.2 ราคาเพียง $0.42/MTok ซึ่งเป็นตัวเลือกที่คุ้มค่าที่สุดสำหรับงานหลากหลายประเภท

การตั้งค่า WebClient ด้วย base_url ที่ถูกต้องเป็นหัวใจสำคัญของการเชื่อมต่อ รวมถึงการจัดการ error, timeout และ rate limiting ที่เหมาะสมจะช่วยให้แอปพลิเคชันทำงานได้อย่างเสถียร

👉 สมัคร HolySheep AI — รับเครดิตฟรีเมื่อลงทะเบียน