java 解析svn路径下的.java文件并获取改动方法

要解析SVN路径下的.java文件并获取改动方法，您可以使用JavaSVN库和JavaParser库。

JavaSVN库是一个Java库，用于访问Subversion存储库。您可以使用这个库来检索文件历史记录和版本信息。

JavaParser库是一个Java库，用于解析和分析Java源代码。您可以使用这个库来解析.java文件并获取文件中的方法。

以下是一个简单的示例代码，展示如何使用这两个库来实现这个任务：

import java.io.ByteArrayOutputStream;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.io.IOUtils;
import org.eclipse.jgit.diff.DiffEntry;
import org.eclipse.jgit.diff.DiffFormatter;
import org.eclipse.jgit.diff.Edit;
import org.eclipse.jgit.diff.EditList;
import org.eclipse.jgit.diff.RawText;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.treewalk.AbstractTreeIterator;
import org.eclipse.jgit.treewalk.CanonicalTreeParser;
import org.eclipse.jgit.treewalk.TreeWalk;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.NodeList;
import com.github.javaparser.ast.body.MethodDeclaration;
import com.github.javaparser.ast.stmt.Statement;

public class SVNJavaParser {
    
    public static void main(String[] args) throws Exception {
        String repoUrl = "svn://example.com/svn/myproject";
        String username = "myusername";
        String password = "mypassword";
        String filePath = "/src/main/java/com/example/MyClass.java";
        String commitId = "12345";
        
        Repository repository = SVNUtils.getRepository(repoUrl, username, password);
        RevWalk revWalk = new RevWalk(repository);
        ObjectId objectId = repository.resolve(commitId);
        RevCommit commit = revWalk.parseCommit(objectId);
        AbstractTreeIterator oldTreeParser = SVNUtils.prepareTreeParser(repository, commit.getParent(0));
        AbstractTreeIterator newTreeParser = SVNUtils.prepareTreeParser(repository, commit);
        List<DiffEntry> diffs = new Git(repository).diff()
                .setOldTree(oldTreeParser)
                .setNewTree(newTreeParser)
                .call();
        for (DiffEntry entry : diffs) {
            if (entry.getNewPath().equals(filePath)) {
                ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
                DiffFormatter formatter = new DiffFormatter(outputStream);
                formatter.setRepository(repository);
                formatter.format(entry);
                String diffString = outputStream.toString();
                RawText oldRawText = new RawText(diffString.split("@@")[0]);
                RawText newRawText = new RawText(diffString.split("@@")[2]);
                EditList editList = new EditList();
                editList.addAll(new EditList(oldRawText, newRawText).getEdits());
                TreeWalk treeWalk = new TreeWalk(repository);
                treeWalk.addTree(commit.getTree());
                treeWalk.setRecursive(true);
                while (treeWalk.next()) {
                    if (filePath.equals(treeWalk.getPathString())) {
                        CanonicalTreeParser oldTreeParser2 = new CanonicalTreeParser();
                        ObjectId oldTree = commit.getParent(0).getTree();
                        try (ObjectReader reader = repository.newObjectReader()) {
                            oldTreeParser2.reset(reader, oldTree);
                        }
                        String oldContent = new String(repository.open(treeWalk.getObjectId(0)).getBytes());
                        CompilationUnit oldCompilationUnit = JavaParser.parse(oldContent);
                        CompilationUnit newCompilationUnit = null;
                        for (Edit edit : editList) {
                            int beginLine = edit.getBeginA();
                            int endLine = edit.getEndA();
                            if (beginLine < 0 || endLine < 0) continue;
                            List<String> oldLines = new ArrayList<>();
                            for (int i = beginLine; i < endLine; i++) {
                                oldLines.add(oldRawText.getString(i));
                            }
                            String oldMethodContent = String.join("\n", oldLines);
                            MethodDeclaration oldMethodDeclaration = getMethodDeclaration(oldCompilationUnit, oldMethodContent);
                            if (oldMethodDeclaration == null) continue;
                            int newBeginLine = edit.getBeginB();
                            int newEndLine = edit.getEndB();
                            if (newBeginLine < 0 || newEndLine < 0) continue;
                            List<String> newLines = new ArrayList<>();
                            for (int i = newBeginLine; i < newEndLine; i++) {
                                newLines.add(newRawText.getString(i));
                            }
                            String newMethodContent = String.join("\n", newLines);
                            if (newCompilationUnit == null) {
                                String newContent = new String(repository.open(treeWalk.getObjectId(0)).getBytes());
                                newCompilationUnit = JavaParser.parse(newContent);
                            }
                            MethodDeclaration newMethodDeclaration = getMethodDeclaration(newCompilationUnit, newMethodContent);
                            if (newMethodDeclaration == null) continue;
                            System.out.println("Old method: " + oldMethodDeclaration.getNameAsString());
                            System.out.println("New method: " + newMethodDeclaration.getNameAsString());
                        }
                    }
                }
            }
        }
    }
    
    private static MethodDeclaration getMethodDeclaration(CompilationUnit compilationUnit, String methodContent) {
        List<MethodDeclaration> methods = compilationUnit.findAll(MethodDeclaration.class);
        for (MethodDeclaration method : methods) {
            String methodString = method.toString();
            if (methodString.equals(methodContent)) {
                return method;
            }
        }
        return null;
    }
    
}

在这个示例代码中，我们首先使用JavaSVN库来检索指定提交的特定文件的差异。然后，我们使用JavaParser库来解析旧文件中的方法和新文件中的方法，并将它们进行比较，以获取改动方法。