Java MCP客户端SDK实现

以下是一个完整的Java MCP客户端SDK实现：

```java
// MCPClient.java
package com.mcp.client;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import java.util.*;
import java.time.Instant;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Stream;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class MCPClient {
    private final String apiEndpoint;
    private final String apiKey;
    private final String protocolVersion;
    private final String sessionId;
    private final Map<String, Object> sessionState;
    private final ObjectMapper objectMapper;
    private final HttpClient httpClient;

    public MCPClient(String apiEndpoint, String apiKey) {
        this(apiEndpoint, apiKey, "1.0");
    }

    public MCPClient(String apiEndpoint, String apiKey, String protocolVersion) {
        this.apiEndpoint = apiEndpoint;
        this.apiKey = apiKey;
        this.protocolVersion = protocolVersion;
        this.sessionId = UUID.randomUUID().toString();
        this.sessionState = new HashMap<>();
        this.objectMapper = new ObjectMapper();
        this.httpClient = HttpClient.newBuilder().build();
    }

    public CompletableFuture<String> generateAsync(String prompt, MCPTaskType taskType) {
        return generateAsync(prompt, taskType, new MCPRequestOptions());
    }

    public CompletableFuture<String> generateAsync(String prompt, MCPTaskType taskType, MCPRequestOptions options) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                ObjectNode request = createMCPRequest(prompt, taskType, options);
                return sendRequest(request);
            } catch (Exception e) {
                throw new RuntimeException("MCP request failed", e);
            }
        });
    }

    public String generate(String prompt, MCPTaskType taskType) {
        return generate(prompt, taskType, new MCPRequestOptions());
    }

    public String generate(String prompt, MCPTaskType taskType, MCPRequestOptions options) {
        try {
            ObjectNode request = createMCPRequest(prompt, taskType, options);
            return sendRequest(request);
        } catch (Exception e) {
            throw new RuntimeException("MCP request failed", e);
        }
    }

    private ObjectNode createMCPRequest(String prompt, MCPTaskType taskType, MCPRequestOptions options) {
        ObjectNode request = JsonNodeFactory.instance.objectNode();
        
        // 基本协议信息
        request.put("protocol_version", protocolVersion);
        request.put("session_id", sessionId);
        request.put("timestamp", Instant.now().toString());

        // 模型控制
        ObjectNode modelControl = request.putObject("model_control");
        ArrayNode behaviorConstraints = modelControl.putArray("behavior_constraints");
        options.getBehaviorConstraints().forEach(behaviorConstraints::add);
        
        ObjectNode outputRequirements = modelControl.putObject("output_requirements");
        outputRequirements.put("format", options.getOutputFormat().toString());
        options.getOutputRequirements().forEach((k, v) -> outputRequirements.put(k, v.toString()));

        // 指令
        ObjectNode instruction = request.putObject("instruction");
        instruction.put("task_type", taskType.toString());
        ObjectNode executionParams = instruction.putObject("execution_parameters");
        options.getCustomParameters().forEach((k, v) -> executionParams.put(k, v.toString()));

        // 上下文
        ObjectNode context = request.putObject("context");
        ObjectNode sessionStateNode = context.putObject("session_state");
        sessionState.forEach((k, v) -> sessionStateNode.put(k, v.toString()));
        options.getContext().forEach((k, v) -> context.put(k, v.toString()));

        // 内容
        ObjectNode content = request.putObject("content");
        content.put("input", prompt);

        return request;
    }

    private String sendRequest(ObjectNode request) throws Exception {
        HttpRequest httpRequest = HttpRequest.newBuilder()
                .uri(URI.create(apiEndpoint))
                .header("Content-Type", "application/json")
                .header("Authorization", "Bearer " + apiKey)
                .POST(HttpRequest.BodyPublishers.ofString(objectMapper.writeValueAsString(request)))
                .build();

        HttpResponse<String> response = httpClient.send(httpRequest, HttpResponse.BodyHandlers.ofString());
        
        if (response.statusCode() != 200) {
            throw new RuntimeException("API request failed with status: " + response.statusCode());
        }

        return processResponse(response.body());
    }

    private String processResponse(String responseBody) throws Exception {
        ObjectNode response = (ObjectNode) objectMapper.readTree(responseBody);
        
        // 更新会话状态
        if (response.has("context") && response.get("context").has("session_state")) {
            ObjectNode newSessionState = (ObjectNode) response.get("context").get("session_state");
            newSessionState.fields().forEachRemaining(entry -> 
                sessionState.put(entry.getKey(), entry.getValue().asText()));
        }

        // 提取输出内容
        if (response.has("content") && response.get("content").has("output")) {
            return response.get("content").get("output").asText();
        }
        
        return responseBody;
    }

    public void resetSession() {
        sessionState.clear();
    }
}
```

```java
// MCPTaskType.java
package com.mcp.client;

public enum MCPTaskType {
    TEXT_GENERATION,
    CONTENT_ANALYSIS,
    TRANSLATION,
    SUMMARIZATION,
    QA,
    CUSTOM
}
```

```java
// MCPOutputFormat.java
package com.mcp.client;

public enum MCPOutputFormat {
    TEXT,
    JSON,
    STRUCTURED,
    MARKDOWN
}
```

```java
// MCPRequestOptions.java
package com.mcp.client;

import java.util.*;

public class MCPRequestOptions {
    private List<String> behaviorConstraints;
    private MCPOutputFormat outputFormat;
    private Map<String, String> outputRequirements;
    private Map<String, String> context;
    private Map<String, String> customParameters;
    private Map<String, String> safetySettings;

    public MCPRequestOptions() {
        this.behaviorConstraints = new ArrayList<>();
        this.outputFormat = MCPOutputFormat.TEXT;
        this.outputRequirements = new HashMap<>();
        this.context = new HashMap<>();
        this.customParameters = new HashMap<>();
        this.safetySettings = new HashMap<>();
    }

    // Getters and Setters
    public List<String> getBehaviorConstraints() {
        return behaviorConstraints;
    }

    public MCPRequestOptions setBehaviorConstraints(List<String> behaviorConstraints) {
        this.behaviorConstraints = behaviorConstraints;
        return this;
    }

    public MCPOutputFormat getOutputFormat() {
        return outputFormat;
    }

    public MCPRequestOptions setOutputFormat(MCPOutputFormat outputFormat) {
        this.outputFormat = outputFormat;
        return this;
    }

    public Map<String, String> getOutputRequirements() {
        return outputRequirements;
    }

    public MCPRequestOptions setOutputRequirements(Map<String, String> outputRequirements) {
        this.outputRequirements = outputRequirements;
        return this;
    }

    public Map<String, String> getContext() {
        return context;
    }

    public MCPRequestOptions setContext(Map<String, String> context) {
        this.context = context;
        return this;
    }

    public Map<String, String> getCustomParameters() {
        return customParameters;
    }

    public MCPRequestOptions setCustomParameters(Map<String, String> customParameters) {
        this.customParameters = customParameters;
        return this;
    }

    public Map<String, String> getSafetySettings() {
        return safetySettings;
    }

    public MCPRequestOptions setSafetySettings(Map<String, String> safetySettings) {
        this.safetySettings = safetySettings;
        return this;
    }
}
```

```java
// MCPBehaviorManager.java
package com.mcp.client;

import java.util.*;

public class MCPBehaviorManager {
    private static final Map<String, List<String>> CONSTRAINT_SETS = new HashMap<>();

    static {
        // 通用约束
        CONSTRAINT_SETS.put("general", Arrays.asList(
            "遵循用户指令",
            "提供准确信息",
            "不生成有害内容"
        ));

        // 教育领域约束
        CONSTRAINT_SETS.put("education", Arrays.asList(
            "确保内容教育性",
            "适合指定年龄段",
            "不提供考试答案"
        ));

        // 医疗领域约束
        CONSTRAINT_SETS.put("healthcare", Arrays.asList(
            "不做医疗诊断",
            "标记所有医疗信息为参考",
            "提供权威来源",
            "不处理个人医疗数据"
        ));

        // 金融领域约束
        CONSTRAINT_SETS.put("finance", Arrays.asList(
            "不提供具体投资建议",
            "标记所有金融信息为参考",
            "不处理个人金融数据"
        ));
    }

    public static List<String> getConstraints(String domain) {
        return CONSTRAINT_SETS.getOrDefault(domain, CONSTRAINT_SETS.get("general"));
    }
}
```

```java
// MCPStreamingClient.java
package com.mcp.client;

import java.util.concurrent.Flow;
import java.util.concurrent.SubmissionPublisher;
import java.util.function.Consumer;

public class MCPStreamingClient extends MCPClient {
    private final SubmissionPublisher<String> publisher;

    public MCPStreamingClient(String apiEndpoint, String apiKey) {
        super(apiEndpoint, apiKey);
        this.publisher = new SubmissionPublisher<>();
    }

    public void streamGenerate(String prompt, MCPTaskType taskType, Consumer<String> onChunk) {
        streamGenerate(prompt, taskType, new MCPRequestOptions(), onChunk);
    }

    public void streamGenerate(String prompt, MCPTaskType taskType, MCPRequestOptions options, Consumer<String> onChunk) {
        publisher.subscribe(new Flow.Subscriber<String>() {
            @Override
            public void onSubscribe(Flow.Subscription subscription) {
                subscription.request(Long.MAX_VALUE);
            }

            @Override
            public void onNext(String item) {
                onChunk.accept(item);
            }

            @Override
            public void onError(Throwable throwable) {
                throwable.printStackTrace();
            }

            @Override
            public void onComplete() {
                // 流式生成完成
            }
        });

        // 实现流式请求逻辑
        // 这里需要根据具体的API实现来发送流式请求
    }
}
```

## 使用示例

```java
// MCPExample.java
package com.mcp.client;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CompletableFuture;

public class MCPExample {
    public static void main(String[] args) {
        // 基本使用示例
        basicExample();
        
        // 异步使用示例
        asyncExample();
        
        // 高级配置示例
        advancedExample();
        
        // 流式生成示例
        streamingExample();
    }

    private static void basicExample() {
        MCPClient client = new MCPClient(
            "https://api.example.com/v1/mcp",
            "your_api_key_here"
        );

        String response = client.generate(
            "解释量子计算的基本原理",
            MCPTaskType.TEXT_GENERATION
        );
        
        System.out.println("基本生成结果: " + response);
    }

    private static void asyncExample() {
        MCPClient client = new MCPClient(
            "https://api.example.com/v1/mcp",
            "your_api_key_here"
        );

        CompletableFuture<String> future = client.generateAsync(
            "分析这些症状可能代表什么情况：头痛、发热、咳嗽",
            MCPTaskType.CONTENT_ANALYSIS
        );

        future.thenAccept(response -> 
            System.out.println("异步分析结果: " + response)
        );
    }

    private static void advancedExample() {
        MCPClient client = new MCPClient(
            "https://api.example.com/v1/mcp",
            "your_api_key_here"
        );

        // 创建高级选项
        MCPRequestOptions options = new MCPRequestOptions()
            .setOutputFormat(MCPOutputFormat.JSON)
            .setBehaviorConstraints(MCPBehaviorManager.getConstraints("healthcare"));

        // 设置输出要求
        Map<String, String> outputRequirements = new HashMap<>();
        outputRequirements.put("include_references", "true");
        outputRequirements.put("confidence_score", "required");
        options.setOutputRequirements(outputRequirements);

        // 设置上下文
        Map<String, String> context = new HashMap<>();
        context.put("medical_domain", "general_practice");
        context.put("severity_level", "moderate");
        options.setContext(context);

        // 设置安全参数
        Map<String, String> safetySettings = new HashMap<>();
        safetySettings.put("bias_mitigation", "high");
        safetySettings.put("factual_accuracy", "verified_only");
        options.setSafetySettings(safetySettings);

        String response = client.generate(
            "分析这些症状可能代表什么情况：头痛、发热、咳嗽",
            MCPTaskType.CONTENT_ANALYSIS,
            options
        );

        System.out.println("高级分析结果: " + response);
    }

    private static void streamingExample() {
        MCPStreamingClient client = new MCPStreamingClient(
            "https://api.example.com/v1/mcp/stream",
            "your_api_key_here"
        );

        client.streamGenerate(
            "生成一篇关于人工智能发展历史的文章",
            MCPTaskType.TEXT_GENERATION,
            chunk -> System.out.print(chunk)
        );
    }
}
```

## 主要特点

1. **面向对象设计**：使用Java面向对象特性，代码结构清晰
2. **异步支持**：提供同步和异步API
3. **流式处理**：支持流式响应处理
4. **类型安全**：使用枚举和强类型确保API使用正确
5. **构建者模式**：使用构建者模式简化配置
6. **会话管理**：自动处理会话状态
7. **错误处理**：完善的异常处理机制

## 依赖要求

```xml
<dependencies>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.13.0</version>
    </dependency>
</dependencies>
```

这个Java SDK提供了与Python版本相似的功能，但采用了Java特有的设计模式和最佳实践。使用时需要将API端点和密钥替换为实际的服务信息。