Java AI写文档案例

我来为您提供几个Java中使用AI生成文档的实战案例。

案例1：使用OpenAI API生成Javadoc注释

import com.theokanning.openai.service.OpenAiService;
import com.theokanning.openai.completion.chat.*;
import java.util.Arrays;
public class AIDocGenerator {
    private final OpenAiService service;
    public AIDocGenerator(String apiKey) {
        this.service = new OpenAiService(apiKey);
    }
    /**
     * 为Java方法生成Javadoc注释
     */
    public String generateJavadoc(String methodCode, String className) {
        String prompt = String.format(
            "为以下Java方法生成专业的Javadoc注释，包含参数说明、返回值说明和异常说明：\n\n方法代码：\n%s\n\n类名：%s",
            methodCode, className
        );
        ChatCompletionRequest request = ChatCompletionRequest.builder()
            .model("gpt-3.5-turbo")
            .messages(Arrays.asList(
                ChatMessage.builder()
                    .role("system")
                    .content("你是一位专业的Java文档编写专家")
                    .build(),
                ChatMessage.builder()
                    .role("user")
                    .content(prompt)
                    .build()
            ))
            .maxTokens(500)
            .temperature(0.7)
            .build();
        ChatCompletionResult result = service.createChatCompletion(request);
        return result.getChoices().get(0).getMessage().getContent();
    }
    // 使用示例
    public static void main(String[] args) {
        AIDocGenerator generator = new AIDocGenerator("your-api-key");
        String methodCode = """
            public List<User> findUsersByAge(int minAge, int maxAge) {
                String sql = "SELECT * FROM users WHERE age BETWEEN ? AND ?";
                return jdbcTemplate.query(sql, new Object[]{minAge, maxAge}, userRowMapper);
            }
            """;
        String javadoc = generator.generateJavadoc(methodCode, "UserRepository");
        System.out.println(javadoc);
    }
}

案例2：使用Hugging Face模型生成API文档

import org.springframework.web.client.RestTemplate;
import org.springframework.http.*;
import java.util.*;
public class HuggingFaceApiDocGenerator {
    private static final String API_URL = "https://api-inference.huggingface.co/models/codellama/CodeLlama-7b-hf";
    private final String apiToken;
    public HuggingFaceApiDocGenerator(String apiToken) {
        this.apiToken = apiToken;
    }
    /**
     * 生成REST API接口文档
     */
    public String generateApiDocumentation(String controllerCode) {
        RestTemplate restTemplate = new RestTemplate();
        // 构建请求体
        Map<String, Object> requestBody = new HashMap<>();
        requestBody.put("inputs", createPrompt(controllerCode));
        requestBody.put("parameters", Map.of(
            "max_new_tokens", 1000,
            "temperature", 0.3,
            "do_sample", true
        ));
        // 设置请求头
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + apiToken);
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<Map<String, Object>> entity = new HttpEntity<>(requestBody, headers);
        // 发送请求
        ResponseEntity<String> response = restTemplate.postForEntity(
            API_URL, entity, String.class
        );
        return response.getBody();
    }
    private String createPrompt(String controllerCode) {
        return String.format("""
            Generate comprehensive API documentation for this Spring Boot controller:
            ```java
            %s

        Include:
        1. API endpoint description
        2. HTTP method
        3. Request parameters
        4. Response format
        5. Error codes
        6. Example request/response
        """, controllerCode);
}

## 案例3：使用Local LLM（Ollama）生成项目文档
```java
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.http.*;
import java.net.URI;
import java.net.http.HttpRequest.BodyPublishers;
public class OllamaDocGenerator {
    private static final String OLLAMA_URL = "http://localhost:11434/api/generate";
    private final HttpClient client;
    private final ObjectMapper mapper;
    public OllamaDocGenerator() {
        this.client = HttpClient.newHttpClient();
        this.mapper = new ObjectMapper();
    }
    /**
     * 生成项目README文档
     */
    public String generateReadme(String projectStructure, String projectDescription) {
        String prompt = String.format("""
            根据以下项目信息生成专业的README.md文档：
            项目描述：%s
            项目结构：
            %s
            请包含：
            1. 项目简介
            2. 技术栈
            3. 快速开始指南
            4. API文档链接
            5. 配置说明
            6. 部署说明
            """, projectDescription, projectStructure);
        return callOllama(prompt);
    }
    /**
     * 生成代码注释的Markdown文档
     */
    public String generateCodeDocumentation(String sourceCode, String documentType) {
        String prompt = String.format("""
            为以下Java代码生成%s格式的文档：
            ```java
            %s

        请输出清晰的Markdown格式文档，包含：
        - 类说明
        - 方法说明
        - 参数说明
        - 使用示例
        """, documentType, sourceCode);
    return callOllama(prompt);
}
private String callOllama(String prompt) {
    try {
        String jsonRequest = mapper.writeValueAsString(Map.of(
            "model", "codellama:7b",
            "prompt", prompt,
            "stream", false
        ));
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(OLLAMA_URL))
            .header("Content-Type", "application/json")
            .POST(BodyPublishers.ofString(jsonRequest))
            .build();
        HttpResponse<String> response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());
        JsonNode jsonResponse = mapper.readTree(response.body());
        return jsonResponse.get("response").asText();
    } catch (Exception e) {
        throw new RuntimeException("Failed to generate documentation", e);
    }
}

## 案例4：批处理文档生成器
```java
import java.io.*;
import java.nio.file.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.stream.Collectors;
public class BatchDocGenerator {
    private final AIDocGenerator docGenerator;
    private final ExecutorService executor;
    public BatchDocGenerator(String apiKey) {
        this.docGenerator = new AIDocGenerator(apiKey);
        this.executor = Executors.newFixedThreadPool(5);
    }
    /**
     * 批量生成项目文档
     */
    public Map<String, String> batchGenerateDocs(String projectPath) throws IOException {
        Map<String, String> documentation = new ConcurrentHashMap<>();
        List<Path> javaFiles = findJavaFiles(projectPath);
        List<CompletableFuture<Void>> futures = javaFiles.stream()
            .map(file -> CompletableFuture.runAsync(() -> {
                try {
                    String code = Files.readString(file);
                    String doc = docGenerator.generateJavadoc(code, file.getFileName().toString());
                    documentation.put(file.toString(), doc);
                    System.out.println("Generated doc for: " + file);
                } catch (Exception e) {
                    System.err.println("Failed to process: " + file + " - " + e.getMessage());
                }
            }, executor))
            .collect(Collectors.toList());
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
        executor.shutdown();
        return documentation;
    }
    /**
     * 保存生成的文档
     */
    public void saveDocumentation(Map<String, String> docs, String outputDir) throws IOException {
        Path outputPath = Paths.get(outputDir);
        Files.createDirectories(outputPath);
        for (Map.Entry<String, String> entry : docs.entrySet()) {
            String fileName = Paths.get(entry.getKey()).getFileName().toString()
                .replace(".java", "_DOC.md");
            Path filePath = outputPath.resolve(fileName);
            Files.writeString(filePath, entry.getValue());
            System.out.println("Saved: " + filePath);
        }
    }
    private List<Path> findJavaFiles(String projectPath) throws IOException {
        return Files.walk(Paths.get(projectPath))
            .filter(path -> path.toString().endsWith(".java"))
            .collect(Collectors.toList());
    }
}

案例5：集成到Maven插件

import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
@Mojo(name = "generate-ai-docs")
public class AIDocMojo extends AbstractMojo {
    @Parameter(property = "apiKey", required = true)
    private String apiKey;
    @Parameter(property = "sourceDir", defaultValue = "${project.build.sourceDirectory}")
    private String sourceDir;
    @Parameter(property = "outputDir", defaultValue = "${project.build.directory}/docs")
    private String outputDir;
    @Override
    public void execute() {
        getLog().info("Starting AI documentation generation...");
        try {
            BatchDocGenerator generator = new BatchDocGenerator(apiKey);
            Map<String, String> docs = generator.batchGenerateDocs(sourceDir);
            generator.saveDocumentation(docs, outputDir);
            getLog().info("Generated " + docs.size() + " documentation files");
        } catch (Exception e) {
            getLog().error("Failed to generate documentation", e);
            throw new RuntimeException(e);
        }
    }
}

使用说明

1. 添加依赖（Maven）：

   <dependency>
    <groupId>com.theokanning.openai-gpt3-java</groupId>
    <artifactId>service</artifactId>
    <version>0.14.0</version>
   </dependency>

2. 配置API密钥：

   // 通过环境变量或配置文件设置
   System.setProperty("OPENAI_API_KEY", "your-api-key");

3. 运行示例：

   # 使用Maven插件
   mvn com.example:ai-doc-maven-plugin:1.0.0:generate-ai-docs \
    -DapiKey=your-api-key

或直接运行Java程序

java AIDocGeneratorExample

这些案例展示了如何利用AI技术自动生成Java项目的各类文档，包括Javadoc注释、API文档、README等，根据实际需求选择合适的方案即可。