Anthropic Claude SDK Java 完全接入指南：Java/Spring Boot 调用 Claude API（2026）

<dependency>
    <groupId>com.anthropic</groupId>
    <artifactId>sdk</artifactId>
    <version>1.0.0</version>
</dependency>

implementation 'com.anthropic:sdk:1.0.0'

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.*;

public class ClaudeExample {
    public static void main(String[] args) {
        AnthropicClient client = AnthropicOkHttpClient.builder()
            .apiKey(System.getenv("ANTHROPIC_API_KEY"))
            .build();

        Message message = client.messages().create(
            MessageCreateParams.builder()
                .model(Model.CLAUDE_SONNET_4_5)
                .maxTokens(1024)
                .addUserMessage("帮我写一个 Java 线程池最佳实践示例")
                .build()
        );

        // 获取文本内容
        message.content().stream()
            .filter(block -> block.type() == ContentBlock.Type.TEXT)
            .forEach(block -> System.out.println(block.text().get()));
    }
}

try (MessageStream stream = client.messages().stream(
    MessageCreateParams.builder()
        .model(Model.CLAUDE_SONNET_4_5)
        .maxTokens(2048)
        .addUserMessage("详细解释 Java 虚拟线程（Project Loom）的原理")
        .build()
)) {
    stream.on(MessageStreamEvent.class, event -> {
        if (event instanceof ContentBlockDeltaEvent delta) {
            if (delta.delta().type() == ContentBlockDelta.Type.TEXT_DELTA) {
                System.out.print(delta.delta().text().get());
            }
        }
    });

    // 等待流完成
    stream.finalMessage();
}

// ClaudeConfig.java
@Configuration
public class ClaudeConfig {
    @Value("${anthropic.api-key}")
    private String apiKey;

    @Bean
    public AnthropicClient anthropicClient() {
        return AnthropicOkHttpClient.builder()
            .apiKey(apiKey)
            .build();
    }
}

// ClaudeService.java
@Service
public class ClaudeService {
    private final AnthropicClient client;

    public ClaudeService(AnthropicClient client) {
        this.client = client;
    }

    public String chat(String userMessage) {
        Message response = client.messages().create(
            MessageCreateParams.builder()
                .model(Model.CLAUDE_SONNET_4_5)
                .maxTokens(1024)
                .addSystemMessage("你是一个专业的技术助手，使用中文回复。")
                .addUserMessage(userMessage)
                .build()
        );

        return response.content().stream()
            .filter(b -> b.type() == ContentBlock.Type.TEXT)
            .findFirst()
            .map(b -> b.text().get())
            .orElse("");
    }
}

// ClaudeController.java（REST API 接口）
@RestController
@RequestMapping("/api/chat")
public class ClaudeController {
    private final ClaudeService claudeService;

    @PostMapping
    public ResponseEntity<Map<String, String>> chat(@RequestBody Map<String, String> req) {
        String reply = claudeService.chat(req.get("message"));
        return ResponseEntity.ok(Map.of("reply", reply));
    }
}

anthropic.api-key=${ANTHROPIC_API_KEY}

@Service
@Scope("prototype")
public class ChatSession {
    private final AnthropicClient client;
    private final List<MessageParam> history = new ArrayList<>();

    public String chat(String userMessage) {
        history.add(MessageParam.builder()
            .role(MessageParam.Role.USER)
            .content(userMessage)
            .build());

        Message response = client.messages().create(
            MessageCreateParams.builder()
                .model(Model.CLAUDE_SONNET_4_5)
                .maxTokens(2048)
                .messages(history)
                .build()
        );

        String assistantReply = response.content().get(0).text().get();
        history.add(MessageParam.builder()
            .role(MessageParam.Role.ASSISTANT)
            .content(assistantReply)
            .build());

        return assistantReply;
    }

    public void clearHistory() { history.clear(); }
}

public CompletableFuture<String> chatAsync(String message) {
    return CompletableFuture.supplyAsync(() -> {
        Message response = client.messages().create(
            MessageCreateParams.builder()
                .model(Model.CLAUDE_HAIKU_4_5) // Haiku 速度更快
                .maxTokens(512)
                .addUserMessage(message)
                .build()
        );
        return response.content().get(0).text().get();
    });
}

// 批量并发调用
public List<String> batchChat(List<String> messages) throws Exception {
    List<CompletableFuture<String>> futures = messages.stream()
        .map(this::chatAsync)
        .toList();

    return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
        .thenApply(v -> futures.stream().map(CompletableFuture::join).toList())
        .get(30, TimeUnit.SECONDS);
}

@GetMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<String> streamChat(@RequestParam String message) {
    return Flux.create(emitter -> {
        try (MessageStream stream = client.messages().stream(
            MessageCreateParams.builder()
                .model(Model.CLAUDE_SONNET_4_5)
                .maxTokens(2048)
                .addUserMessage(message)
                .build()
        )) {
            stream.on(ContentBlockDeltaEvent.class, event -> {
                event.delta().text().ifPresent(emitter::next);
            });
            stream.finalMessage();
            emitter.complete();
        } catch (Exception e) {
            emitter.error(e);
        }
    });
}