AutoFileGeneratorAutoFileGenerator

测试代码

import java.io.*;
import java.nio.file.*;
import java.util.*;
import java.util.regex.*;

public class AutoFileGenerator {
    
    /**
     * 自动生成文件的方法
     * @param filePath 文件路径
     * @param fileName 文件名
     * @param content 方法内容
     * @throws IOException 如果文件操作异常
     */
    public static void generateFile(String filePath, String fileName, String content) throws IOException {
        // 创建文件路径对象
        Path directory = Paths.get(filePath);
        
        // 如果路径不存在，创建目录
        if (!Files.exists(directory)) {
            Files.createDirectories(directory);
            System.out.println("创建目录: " + directory);
        }
        
        // 判断内容类型
        String fileType = determineFileType(content);
        if (!fileName.endsWith(fileType)) {
            fileName = fileName + "." + fileType;
        }
        
        Path filePath1 = directory.resolve(fileName);
        
        // 检查文件是否已存在
        if (Files.exists(filePath1)) {
            System.out.println("文件已存在，进行合并操作: " + filePath1);
            
            // 读取原文件内容
            String originalContent = Files.readString(filePath1);
            
            // 根据文件类型执行不同的合并逻辑
            if (fileType.equals("java")) {
                String mergedContent = mergeJavaContent(originalContent, content);
                Files.writeString(filePath1, mergedContent);
            } else if (fileType.equals("xml")) {
                String mergedContent = mergeXmlContent(originalContent, content);
                Files.writeString(filePath1, mergedContent);
            }
            
            System.out.println("文件更新成功: " + filePath1);
        } else {
            // 文件不存在，直接创建
            Files.writeString(filePath1, formatContent(content, fileType));
            System.out.println("文件创建成功: " + filePath1);
        }
    }
    
    /**
     * 根据内容判断文件类型
     * @param content 文件内容
     * @return 文件类型 (java 或 xml)
     */
    private static String determineFileType(String content) {
        // 检查是否包含XML特征
        if (content.contains("<?xml") || content.contains("<mapper") || 
            content.contains("<select") || content.contains("<insert") || 
            content.contains("<update") || content.contains("<delete")) {
            return "xml";
        } else {
            // 默认为Java
            return "java";
        }
    }
    
    /**
     * 合并Java内容
     * @param originalContent 原文件内容
     * @param newContent 新内容
     * @return 合并后的内容
     */
    private static String mergeJavaContent(String originalContent, String newContent) {
        // 提取新内容中的方法
        List<String> methods = extractJavaMethods(newContent);
        
        // 在类的结尾前插入新方法
        StringBuilder result = new StringBuilder(originalContent);
        
        // 查找类的结尾位置
        int endBraceIndex = originalContent.lastIndexOf("}");
        
        if (endBraceIndex != -1) {
            for (String method : methods) {
                // 检查方法是否已存在
                String methodName = extractJavaMethodName(method);
                if (methodName != null && !originalContent.contains(methodName)) {
                    // 方法不存在，插入到类结尾前
                    result.insert(endBraceIndex, "\n" + method + "\n");
                }
            }
        }
        
        return result.toString();
    }
    
    /**
     * 提取Java方法名
     * @param methodCode 方法代码
     * @return 方法名
     */
    private static String extractJavaMethodName(String methodCode) {
        // 匹配方法定义
        Pattern pattern = Pattern.compile("(public|private|protected)?\\s+(static)?\\s*[\\w<>\\[\\],\\s]+\\s+(\\w+)\\s*\\(");
        Matcher matcher = pattern.matcher(methodCode);
        
        if (matcher.find()) {
            return matcher.group(3); // 返回方法名
        }
        
        return null;
    }
    
    /**
     * 提取Java方法
     * @param content Java内容
     * @return 方法列表
     */
    private static List<String> extractJavaMethods(String content) {
        List<String> methods = new ArrayList<>();
        
        // 如果是完整类，提取类中的方法
        if (content.contains("class ")) {
            // 移除类定义和导入语句等
            int classBodyStart = content.indexOf("{");
            int classBodyEnd = content.lastIndexOf("}");
            
            if (classBodyStart != -1 && classBodyEnd != -1) {
                content = content.substring(classBodyStart + 1, classBodyEnd);
            }
        }
        
        // 提取方法
        Pattern methodPattern = Pattern.compile("(public|private|protected)?\\s+(static)?\\s*[\\w<>\\[\\],\\s]+\\s+\\w+\\s*\\([^\\)]*\\)\\s*\\{[^\\{\\}]*(\\{[^\\{\\}]*\\}[^\\{\\}]*)*\\}");
        Matcher methodMatcher = methodPattern.matcher(content);
        
        while (methodMatcher.find()) {
            methods.add(methodMatcher.group(0));
        }
        
        return methods;
    }
    
    /**
     * 合并XML内容
     * @param originalContent 原文件内容
     * @param newContent 新内容
     * @return 合并后的内容
     */
    private static String mergeXmlContent(String originalContent, String newContent) {
        // 提取新内容中的XML块
        List<String> xmlBlocks = extractXmlBlocks(newContent);
        
        // 在mapper结尾标签前插入新的XML块
        StringBuilder result = new StringBuilder(originalContent);
        
        // 查找mapper结尾位置
        int endMapperIndex = originalContent.lastIndexOf("</mapper>");
        
        if (endMapperIndex != -1) {
            for (String block : xmlBlocks) {
                // 提取ID
                String id = extractXmlId(block);
                if (id != null && !originalContent.contains("id=\"" + id + "\"")) {
                    // ID不存在，插入到mapper结尾前
                    result.insert(endMapperIndex, "\n" + block + "\n");
                }
            }
        }
        
        return result.toString();
    }
    
    /**
     * 提取XML块的ID
     * @param xmlBlock XML块
     * @return ID值
     */
    private static String extractXmlId(String xmlBlock) {
        Pattern pattern = Pattern.compile("id=[\"'](.*?)[\"']");
        Matcher matcher = pattern.matcher(xmlBlock);
        
        if (matcher.find()) {
            return matcher.group(1);
        }
        
        return null;
    }
    
    /**
     * 提取XML块
     * @param content XML内容
     * @return XML块列表
     */
    private static List<String> extractXmlBlocks(String content) {
        List<String> blocks = new ArrayList<>();
        
        // 尝试提取select, insert, update, delete等标签块
        Pattern pattern = Pattern.compile("<(select|insert|update|delete|sql|resultMap)\\s+[^>]*>.*?</(select|insert|update|delete|sql|resultMap)>", Pattern.DOTALL);
        Matcher matcher = pattern.matcher(content);
        
        while (matcher.find()) {
            blocks.add(matcher.group(0));
        }
        
        return blocks;
    }
    
    /**
     * 格式化内容
     * @param content 内容
     * @param fileType 文件类型
     * @return 格式化后的内容
     */
    private static String formatContent(String content, String fileType) {
        if (fileType.equals("xml") && !content.contains("<?xml")) {
            // 添加XML声明和mapper标签
            if (!content.contains("<mapper")) {
                return "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
                       "<!DOCTYPE mapper PUBLIC \"-//mybatis.org//DTD Mapper 3.0//EN\" \"http://mybatis.org/dtd/mybatis-3-mapper.dtd\">\n" +
                       "<mapper namespace=\"\">\n" + 
                       content + 
                       "\n</mapper>";
            } else {
                return "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
                       "<!DOCTYPE mapper PUBLIC \"-//mybatis.org//DTD Mapper 3.0//EN\" \"http://mybatis.org/dtd/mybatis-3-mapper.dtd\">\n" + 
                       content;
            }
        }
        
        return content;
    }
    
    /**
     * 主方法，用于测试
     */
    public static void main(String[] args) {
        try {
            // 测试例子 - Java文件
            String javaContent = "public void testMethod() {\n    System.out.println(\"Hello World\");\n}";
            generateFile("./output", "TestClass", javaContent);
            
            // 测试例子 - XML文件
            String xmlContent = "<select id=\"findUserById\" resultType=\"User\">\n    SELECT * FROM users WHERE id = #{id}\n</select>";
            generateFile("./output", "UserMapper", xmlContent);
            
            System.out.println("测试完成");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}