Java工具类-JGit基本功能实现

电玩女神 2022-10-23 12:48 693阅读 0赞

## 一、简介 ##

最近在写一个web前端代码覆盖率的工程（react），主要是负责后台的管理功能。目前的一个需求就是获取增量代码的覆盖率；需要去获取代码提交前后的代码差异，将代码差异信息提供给前端同事进行处理计算此覆盖率; 通过使用GitLab的API和Java提供的JGit后发现，java提供的JGit效果更好，差异的信息也准确；  
此工具类基于Jacoc二开代码，修改部分代码，实现自己需要的功能的一个工具类。也仅仅只获取了java工程的代码差异，react工程的代码差异与此原理差不多，删除掉几个不重要的文件即可。  
主要实现以下功能

*  远程拉取分支信息
 *  切换分支
 *  获取当前分支的所有commit信息（merge的commit信息）
 *  对比当前分支与master分支的最新代码差异
 *  对比当前分支与master分支某个commit时刻的代码差异
 *  校验本地分支是否是最新版本

注： 查阅此文档前可能需要先了解下Jgit的基本操作

## 二、工程代码 ##

##### 1. pom.xml pom依赖 #####

<dependency>
                <groupId>org.eclipse.jdt</groupId>
                <artifactId>org.eclipse.jdt.core</artifactId>
                <version>3.19.0</version>
            </dependency>
            <dependency>
                <groupId>org.eclipse.jgit</groupId>
                <artifactId>org.eclipse.jgit</artifactId>
                <version>5.9.0.202009080501-r</version>
            </dependency>
            <dependency>
                <groupId>org.bouncycastle</groupId>
                <artifactId>bcprov-jdk16</artifactId>
                <version>1.46</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>

##### 2. ClassInfo.java #####

保存差异类信息的实体类

@Data
    @ToString
    public class ClassInfo { 
        /** * java文件 */
        private String classFile;
        /** * 类名 */
        private String className;
        /** * 包名 */
        private String packages;
    
        /** * 类中的方法 */
        private List<MethodInfo> methodInfos;
    
        /** * 新增的行数 */
        private List<Integer> addLines;
    
        /** * 删除的行数 */
        private List<Integer> delLines;
    
        /** * 修改类型 */
        private String type;
    }

##### 3. MethodInfo.java #####

保存差异文件中的差异方法信息

@Data
    @ToString
    public class MethodInfo { 
        /** * 方法的md5 */
        public String md5;
        /** * 方法名 */
        public String methodName;
        /** * 方法参数 */
        public String parameters;
    }

##### 4. GitAdapter.java #####

Git工具操作类

public class GitAdapter { 
        private static final Logger logger = LoggerFactory.getLogger(GitAdapter.class);
    
        private final static String REF_HEADS = "refs/heads/";
        private final static String MASTER_BRANCH = "master";
        // 远程仓库路径 用的就是.git
        private String remotePath;
    
        // 本地仓库路径 包含了项目工程名projectName
        private String localPath;
    
        private String localGitPath;
    
        private Git git;
    
        private Repository repository;
    
        private Ref branchRef;
    
        public String branchName;
        // Git授权
        private static UsernamePasswordCredentialsProvider usernamePasswordCredentialsProvider;
    
        /** * 构造函数：没有传分支信息则默认拉取master代码 * @param remotePath * @param localPath */
        public GitAdapter(String remotePath, String localPath) { 
            this(remotePath,localPath,MASTER_BRANCH);
        }
    
        public GitAdapter(String remotePath, String localPath, String branchName) { 
            this.remotePath = remotePath;
            this.localPath = localPath;
            this.branchName = branchName;
            localGitPath = this.localPath+"/.git";
            // 鉴权账户密码可用自己gitHub的账户密码，或者是设置token
            this.usernamePasswordCredentialsProvider = new UsernamePasswordCredentialsProvider("account","password");
            // 初始化git
    // this.initGit();
    // repository = new FileRepository(localGitPath);
        }
    
        /** * 使用Git时需要先初始化git * 默认初始化的时候会自动拉取 @branchName 的最新代码 * @return */
        public  Git initGit() { 
            File file = new File(localPath);
            System.out.println("文件路径"+localPath);
            // 如果文件存在 说明已经拉取过代码,则拉取最新代码
            if(file.exists()) { 
                try { 
                    git = Git.open(new File(localPath));
                    // 判断是否是最新代码 判断是否是最新代码好像耗时更久？？！
                    boolean isLatest = checkBranchNewVersion(git.getRepository().exactRef(REF_HEADS+branchName));
                    if (isLatest==true) { 
                        logger.info("the local version is latest, need not pull it");
                    } else { 
                        // 拉取最新的提交
                        git.pull().setCredentialsProvider(usernamePasswordCredentialsProvider).call();
                        logger.info("pull success");
                    }
                } catch (GitAPIException e) { 
                    logger.info("pull failure");
                    e.printStackTrace();
                } catch (IOException e) { 
                    logger.info("pull failure");
                    e.printStackTrace();
                }
            }
            // 文件不存在，说明未拉取过代码 则拉取最新代码
            else { 
                try { 
                    git = Git.cloneRepository()
                            .setCredentialsProvider(usernamePasswordCredentialsProvider)
                            .setURI(remotePath)
                            .setBranch(branchName)
                            .setDirectory(new File(localPath))
                            .call();
                    // 拉取最新的提交
                    git.pull().setCredentialsProvider(usernamePasswordCredentialsProvider).call();
                    logger.info("down success");
                } catch (GitAPIException e) { 
                    logger.error("远程仓库下载异常");
                    e.printStackTrace();
                }
            }
            repository = git.getRepository();
            return git;
        }
    
        /** * 获取ref信息 * @return * @throws IOException */
        public Ref getBranchRef() throws IOException { 
            return getBranchRef(this.branchName);
        }
    
        /** * 根据branch 获取ref信息 * @param branchName * @return */
        public Ref getBranchRef(String branchName) { 
            try { 
                return this.branchRef = git.getRepository().exactRef(REF_HEADS+branchName);
            } catch (IOException e) { 
                e.printStackTrace();
            }
            return null;
        }
    
        /** * 获取指定分支的指定文件内容 * @param branchName 分支名称 * @param javaPath 文件路径 * @return java类 * @throws IOException */
        public String getBranchSpecificFileContent(String branchName, String javaPath) throws IOException { 
            Ref branch = repository.exactRef( REF_HEADS + branchName);
            ObjectId objId = branch.getObjectId();
            RevWalk walk = new RevWalk(repository);
            RevTree tree = walk.parseTree(objId);
            return  getFileContent(javaPath,tree,walk);
        }
    
        /** * 获取指定分支指定的指定文件内容 * @param javaPath 件路径 * @param tree git RevTree * @param walk git RevWalk * @return java类 * @throws IOException */
        private String getFileContent(String javaPath,RevTree tree,RevWalk walk) throws IOException { 
            TreeWalk treeWalk = TreeWalk.forPath(repository, javaPath, tree);
            ObjectId blobId = treeWalk.getObjectId(0);
            ObjectLoader loader = repository.open(blobId);
            byte[] bytes = loader.getBytes();
            walk.dispose();
            return new String(bytes);
        }
    
        /** * 分析分支树结构信息 * @param localRef 本地分支 * @return * @throws IOException */
        public AbstractTreeIterator prepareTreeParser(Ref localRef) throws IOException { 
            return prepareTreeParser(localRef.getObjectId().getName());
        }
    
        /** * 通过CommitId获取分支树结构信息 * 此方法是为了兼容 * 被比较的分支（一般为master分支）的commitId已知的情况下，无需在获取Ref直接通过commitId获取分支树结构 * @param commitId * @return * @throws IOException */
        public AbstractTreeIterator prepareTreeParser(String commitId) throws IOException { 
            RevWalk walk = new RevWalk(repository);
            RevCommit revCommit = walk.parseCommit(repository.resolve(commitId));
            RevTree tree = walk.parseTree(revCommit.getTree().getId());
            CanonicalTreeParser treeParser = new CanonicalTreeParser();
            ObjectReader reader = repository.newObjectReader();
            treeParser.reset(reader, tree.getId());
            walk.dispose();
            return treeParser;
        }
    
        /** * 切换分支 * @param branchName 分支名称 * @throws GitAPIException GitAPIException */
        public void checkOut(String branchName) throws GitAPIException { 
            // 切换分支
            git.checkout().setCreateBranch(false).setName(branchName).call();
        }
    
        /** * 更新分支代码 * @param branchName 分支名称 * @throws GitAPIException GitAPIException */
        public Ref checkOutAndPull(String branchName) throws GitAPIException { 
            // 1. 获取此分支的Ref信息
            Ref branchRef = getBranchRef(branchName);
            boolean isCreateBranch = branchRef == null;
            // 2. 如果Ref不为null，则校验Ref是否为最新，最新直接返回，不为最新则重新拉取分支信息
            if (!isCreateBranch && checkBranchNewVersion(branchRef)) { 
                return branchRef;
            }
            // 3. 切换分支
            git.checkout().setCreateBranch(isCreateBranch).setName(branchName)
                    .setStartPoint( "origin/"+branchName)
                    .setUpstreamMode(CreateBranchCommand.SetupUpstreamMode.SET_UPSTREAM)
                    .call();
            // 4. 拉取最新代码
            git.pull().setCredentialsProvider(usernamePasswordCredentialsProvider).call();
            branchRef = getBranchRef(branchName);
            return branchRef;
        }
    
    
        /** * 切换到目标分支的版本中（暂时不用） * @param versionCommit * @throws IOException * @throws GitAPIException */
        public void checkoutFromVersionCommit(String versionCommit) throws IOException, GitAPIException { 
            RevWalk walk = new RevWalk(repository);
            ObjectId versionId = repository.resolve(versionCommit);
            RevCommit verCommit = walk.parseCommit(versionId);
            git.checkout().setCreateBranch(false).setName(versionCommit).setStartPoint(verCommit).call();
            git.branchDelete().setBranchNames(versionCommit);
    
            Collection<Ref> remoteRefs = git.lsRemote().setHeads(true).setCredentialsProvider(usernamePasswordCredentialsProvider).call();
            String ref = git.getRepository().getRefDatabase().getRefs().toString();
            System.out.println(ref);
        }
    
        /** * 判断本地分支是否是最新版本。目前不考虑分支在远程仓库不存在，本地存在 * 此方法有点耗时，可以考虑直接拉取最新版本 * @param localRef 本地分支 * @return boolean * @throws GitAPIException GitAPIException */
        private boolean checkBranchNewVersion(Ref localRef) throws GitAPIException { 
            String localRefName = localRef.getName(); // refs/heads/master 分支名
            String localRefObjectId = localRef.getObjectId().getName(); //commit_id
            // 获取远程所有分支
            Collection<Ref> remoteRefs = git.lsRemote().setCredentialsProvider(usernamePasswordCredentialsProvider).setHeads(true).call();
            for (Ref remoteRef : remoteRefs) { 
                String remoteRefName = remoteRef.getName();
                String remoteRefObjectId = remoteRef.getObjectId().getName();
                if (remoteRefName.equals(localRefName)) { 
                    if (remoteRefObjectId.equals(localRefObjectId)) { 
                        return true;
                    }
                    return false;
                }
            }
            return false;
        }
    
        /** * 获取当前分支的所有提交记录 * @return * @throws IOException * @throws GitAPIException */
        public List<CommitMessage> getCommitMessages() throws IOException, GitAPIException { 
            List<CommitMessage> commitMessages = new ArrayList<>();
            CommitMessage commitMessage = null;
            Iterable<RevCommit> commits = git.log().all().call();
            RevWalk walk = new RevWalk(repository);
            int flag =0;
            for(RevCommit commit:commits) { 
                commitMessage = new CommitMessage();
                boolean foundInThisBranch = false;
                RevCommit targetCommit = walk.parseCommit(commit.getId());
                for(Map.Entry< String,Ref> e : repository.getAllRefs().entrySet()){ 
                    if(e.getKey().startsWith("refs/remotes/origin")) { 
                        if(walk.isMergedInto(targetCommit,walk.parseCommit(e.getValue().getObjectId()))) { 
                            String foundInBranch = e.getValue().getTarget().getName();
    // foundInBranch = foundInBranch.replace("refs/heads","");
                            if(foundInBranch.contains(branchName)) { 
                                // 等于2 说明是来自两个合并的分支 算的是merge的记录
                                if(targetCommit.getParents().length==2) { 
                                    flag++;
                                    foundInThisBranch = true;
                                    break;
                                }
                            }
                        }
                    }
    
                }
                if(foundInThisBranch) { 
                    commitMessage.setCommitId(commit.getName());
                    commitMessage.setCommitIdent(commit.getAuthorIdent().getName());
                    commitMessage.setCommitMessage(commit.getFullMessage());
                    commitMessage.setCommitDate(new Date(commit.getCommitTime()*1000L).toString());
                    commitMessage.setLastCommitId(commit.getParent(0).getName());
                    commitMessage.setMergeBranchCommitId(commit.getParent(1).getName());
                    commitMessages.add(commitMessage);
                }
                if(flag==5) { 
                    // 只取merge合并记录的前五条
                    break;
                }
    
            }
            return commitMessages;
        }
    }

##### 5. CodeDiff.java #####

真正对比git工程中差异文件的类

/** * Demo class * * @author bigman * @date 2021/3/1 */
    public class CodeDiff { 
    
        /** * 分支和分支之间的比较 * @param newBranchName 当前分支取最新的commit版本 * @param oldBranchName 比较分支取最新的commit版本 * @return */
        public static List<ClassInfo> diffBranchToBranch(GitAdapter gitAdapter, String newBranchName, String oldBranchName) { 
            return diffBranchToBranch(gitAdapter, newBranchName, oldBranchName,null);
        }
    
        /** * 当前分支与某个分支的某个版本进行比较 * @param gitAdapter * @param newBranchName 当前分支当前分支取最新的commit版本 * @param oldBranchName 比较分支 * @param commitId 比较分支的commit版本Id * @return */
        public static List<ClassInfo> diffBranchToBranch(GitAdapter gitAdapter, String newBranchName, String oldBranchName, String commitId) { 
            List<ClassInfo> classInfos = diffMethods(gitAdapter, newBranchName, oldBranchName,commitId);
            return classInfos;
        }
    
        private static List<ClassInfo> diffMethods(GitAdapter gitAdapter,String newBranchName, String oldBranchName,String commitId) { 
            try { 
                // 获取Git
                Git git = gitAdapter.initGit();
    
                // 获取两个分支的最新代码信息
                Ref newBranchRef = gitAdapter.checkOutAndPull(newBranchName);
                Ref oldBranchRef = gitAdapter.checkOutAndPull(oldBranchName);
    
                // 获取当前分支信息
                AbstractTreeIterator newTreeParser = gitAdapter.prepareTreeParser(newBranchRef.getObjectId().getName());
    
                // 获取比较分支的版本信息 如果commit为null，则默认取比较分支的最新版本信息
                if(null == commitId && oldBranchRef!=null) { 
                    commitId = oldBranchRef.getObjectId().getName();
                }
                AbstractTreeIterator oldTreeParser = gitAdapter.prepareTreeParser(commitId);
    
                // 对比差异
                List<DiffEntry> diffs = git.diff().setOldTree(oldTreeParser).setNewTree(newTreeParser).setShowNameAndStatusOnly(true).call();
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                DiffFormatter df = new DiffFormatter(out);
                // 设置比较器为忽略空白字符对比（Ignores all whitespace）
                df.setDiffComparator(RawTextComparator.WS_IGNORE_ALL);
                df.setRepository(git.getRepository());
                List<ClassInfo> allClassInfos = batchPrepareDiffMethod(gitAdapter, newBranchName, oldBranchName, df, diffs);
                return allClassInfos;
            } catch (Exception e) { 
                e.printStackTrace();
            }
            return new ArrayList<ClassInfo>();
        }
    
        /** * 多线程执行对比 * * @return */
        private static List<ClassInfo> batchPrepareDiffMethod(final GitAdapter gitAdapter, final String branchName, final String oldBranchName, final DiffFormatter df, List<DiffEntry> diffs) { 
            int threadSize = 100;
            int dataSize = diffs.size();
            int threadNum = dataSize / threadSize + 1;
            boolean special = dataSize % threadSize == 0;
            ExecutorService executorService = Executors.newFixedThreadPool(threadNum);
    
            List<Callable<List<ClassInfo>>> tasks = new ArrayList<Callable<List<ClassInfo>>>();
            Callable<List<ClassInfo>> task = null;
            List<DiffEntry> cutList = null;
            // 分解每条线程的数据
            for (int i = 0; i < threadNum; i++) { 
                if (i == threadNum - 1) { 
                    if (special) { 
                        break;
                    }
                    cutList = diffs.subList(threadSize * i, dataSize);
                } else { 
                    cutList = diffs.subList(threadSize * i, threadSize * (i + 1));
                }
                final List<DiffEntry> diffEntryList = cutList;
                task = new Callable<List<ClassInfo>>() { 
                    @Override
                    public List<ClassInfo> call() throws Exception { 
                        List<ClassInfo> allList = new ArrayList<ClassInfo>();
                        for (DiffEntry diffEntry : diffEntryList) { 
                            ClassInfo classInfo = prepareDiffMethod(gitAdapter, branchName, oldBranchName, df, diffEntry);
                            if (classInfo != null) { 
                                allList.add(classInfo);
                            }
                        }
                        return allList;
                    }
                };
                // 这里提交的任务容器列表和返回的Future列表存在顺序对应的关系
                tasks.add(task);
            }
            List<ClassInfo> allClassInfoList = new ArrayList<ClassInfo>();
            try { 
                List<Future<List<ClassInfo>>> results = executorService.invokeAll(tasks);
                //结果汇总
                for (Future<List<ClassInfo>> future : results) { 
                    allClassInfoList.addAll(future.get());
                }
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                // 关闭线程池
                executorService.shutdown();
            }
            return allClassInfoList;
        }
    
        /** * 单个差异文件对比 * * @param gitAdapter * @param branchName * @param oldBranchName * @param df * @param diffEntry * @return */
        private synchronized static ClassInfo prepareDiffMethod(GitAdapter gitAdapter, String branchName, String oldBranchName, DiffFormatter df, DiffEntry diffEntry) { 
            List<MethodInfo> methodInfoList = new ArrayList<MethodInfo>();
            try { 
                String newJavaPath = diffEntry.getNewPath();
                // 排除测试类
                if (newJavaPath.contains("/src/test/java/")) { 
                    return null;
                }
                // 非java文件 和 删除类型不记录
                if (!newJavaPath.endsWith(".java") || diffEntry.getChangeType() == DiffEntry.ChangeType.DELETE) { 
                    return null;
                }
                String newClassContent = gitAdapter.getBranchSpecificFileContent(branchName, newJavaPath);
                ASTGenerator newAstGenerator = new ASTGenerator(newClassContent);
                /* 新增类型 */
                if (diffEntry.getChangeType() == DiffEntry.ChangeType.ADD) { 
                    return newAstGenerator.getClassInfo();
                }
                /* 修改类型 */
                // 获取文件差异位置，从而统计差异的行数，如增加行数，减少行数
                FileHeader fileHeader = df.toFileHeader(diffEntry);
                List<int[]> addLines = new ArrayList<int[]>();
                List<int[]> delLines = new ArrayList<int[]>();
                EditList editList = fileHeader.toEditList();
                for (Edit edit : editList) { 
                    if (edit.getLengthA() > 0) { 
                        delLines.add(new int[]{ edit.getBeginA(), edit.getEndA()});
                    }
                    if (edit.getLengthB() > 0) { 
                        addLines.add(new int[]{ edit.getBeginB(), edit.getEndB()});
                    }
                }
                String oldJavaPath = diffEntry.getOldPath();
                String oldClassContent = gitAdapter.getBranchSpecificFileContent(oldBranchName, oldJavaPath);
                ASTGenerator oldAstGenerator = new ASTGenerator(oldClassContent);
                MethodDeclaration[] newMethods = newAstGenerator.getMethods();
                MethodDeclaration[] oldMethods = oldAstGenerator.getMethods();
                Map<String, MethodDeclaration> methodsMap = new HashMap<String, MethodDeclaration>();
                for (int i = 0; i < oldMethods.length; i++) { 
                    methodsMap.put(oldMethods[i].getName().toString() + oldMethods[i].parameters().toString(), oldMethods[i]);
                }
                for (final MethodDeclaration method : newMethods) { 
                    // 如果方法名是新增的,则直接将方法加入List
                    if (!ASTGenerator.isMethodExist(method, methodsMap)) { 
                        MethodInfo methodInfo = newAstGenerator.getMethodInfo(method);
                        methodInfoList.add(methodInfo);
                        continue;
                    }
                    // 如果两个版本都有这个方法,则根据MD5判断方法是否一致
                    if (!ASTGenerator.isMethodTheSame(method, methodsMap.get(method.getName().toString() + method.parameters().toString()))) { 
                        MethodInfo methodInfo = newAstGenerator.getMethodInfo(method);
                        methodInfoList.add(methodInfo);
                    }
                }
                return newAstGenerator.getClassInfo(methodInfoList, translate(addLines), translate(delLines));
            } catch (Exception e) { 
                e.printStackTrace();
            }
            return null;
        }
    
        /** * 将修改文件的行数信息 int[] 转化为list类型 * diff返回的int[] 表示修改的区间，修改区间是左开右闭（ 】 * @param listInt * @return */
        public static List<Integer> translate(List<int[]> listInt) { 
            List<Integer> list = new ArrayList<>();
            for(int[] ints:listInt) { 
                for(int i=ints[0];i<ints[1];i++) { 
                    list.add(i+1);
                }
            }
            return list;
        }
    }

##### 6. ASTGenerator.java #####

此文件是将java转化为AST树，如果是react工程此类不可用，需要定制化修改

/** * Demo class * * @author bigman * @date 2021/3/1 */
    public class ASTGenerator { 
        private String javaText;
        private CompilationUnit compilationUnit;
    
        public ASTGenerator(String javaText) { 
            this.javaText = javaText;
            this.initCompilationUnit();
        }
    
        /** * 获取AST编译单元,首次加载很慢 */
        private void initCompilationUnit() { 
            // AST编译
            final ASTParser astParser = ASTParser.newParser(8);
            final Map<String, String> options = JavaCore.getOptions();
            JavaCore.setComplianceOptions(JavaCore.VERSION_1_8, options);
            astParser.setCompilerOptions(options);
            astParser.setKind(ASTParser.K_COMPILATION_UNIT);
            astParser.setResolveBindings(true);
            astParser.setBindingsRecovery(true);
            astParser.setStatementsRecovery(true);
            astParser.setSource(javaText.toCharArray());
            compilationUnit = (CompilationUnit) astParser.createAST(null);
        }
    
        /** * 获取java类包名 * @return */
        public String getPackageName() { 
            if (compilationUnit == null) { 
                return "";
            }
            PackageDeclaration packageDeclaration = compilationUnit.getPackage();
            if (packageDeclaration == null){ 
                return "";
            }
            String packageName = packageDeclaration.getName().toString();
            return packageName;
        }
    
        /** * 获取普通类单元 * @return */
        public TypeDeclaration getJavaClass() { 
            if (compilationUnit == null) { 
                return null;
            }
            TypeDeclaration typeDeclaration = null;
            final List<?> types = compilationUnit.types();
            for (final Object type : types) { 
                if (type instanceof TypeDeclaration) { 
                    typeDeclaration = (TypeDeclaration) type;
                    break;
                }
            }
            return typeDeclaration;
        }
    
        /** * 获取java类中所有方法 * @return 类中所有方法 */
        public MethodDeclaration[] getMethods() { 
            TypeDeclaration typeDec = getJavaClass();
            if (typeDec == null) { 
                return new MethodDeclaration[]{ };
            }
            MethodDeclaration[] methodDec = typeDec.getMethods();
            return methodDec;
        }
    
        /** * 获取新增类中的所有方法信息 * @return */
        public List<MethodInfo> getMethodInfoList() { 
            MethodDeclaration[] methodDeclarations = getMethods();
            List<MethodInfo> methodInfoList = new ArrayList<MethodInfo>();
            for (MethodDeclaration method: methodDeclarations) { 
                MethodInfo methodInfo = new MethodInfo();
                setMethodInfo(methodInfo, method);
                methodInfoList.add(methodInfo);
            }
            return methodInfoList;
        }
    
        /** * 获取修改类型的类的信息以及其中的所有方法，排除接口类 * @param methodInfos * @param addLines * @param delLines * @return */
        public ClassInfo getClassInfo(List<MethodInfo> methodInfos, List<Integer> addLines, List<Integer> delLines) { 
            TypeDeclaration typeDec = getJavaClass();
            if (typeDec == null || typeDec.isInterface()) { 
                return null;
            }
            ClassInfo classInfo = new ClassInfo();
            classInfo.setClassFile(getJavaClass().getName().toString());
            classInfo.setClassName(getJavaClass().getName().toString());
            classInfo.setPackages(getPackageName());
            classInfo.setMethodInfos(methodInfos);
            classInfo.setAddLines(addLines);
            classInfo.setDelLines(delLines);
            classInfo.setType("REPLACE");
            return classInfo;
        }
    
        /** * 获取新增类型的类的信息以及其中的所有方法，排除接口类 * @return */
        public ClassInfo getClassInfo() { 
            TypeDeclaration typeDec = getJavaClass();
            if (typeDec == null || typeDec.isInterface()) { 
                return null;
            }
            MethodDeclaration[] methodDeclarations = getMethods();
            ClassInfo classInfo = new ClassInfo();
            classInfo.setClassName(getJavaClass().getName().toString());
            classInfo.setPackages(getPackageName());
            classInfo.setType("ADD");
            List<MethodInfo> methodInfoList = new ArrayList<>();
            for (MethodDeclaration method: methodDeclarations) { 
                MethodInfo methodInfo = new MethodInfo();
                setMethodInfo(methodInfo, method);
                methodInfoList.add(methodInfo);
            }
            classInfo.setMethodInfos(methodInfoList);
            return classInfo;
        }
    
        /** * 获取修改中的方法 * @param methodDeclaration * @return */
        public MethodInfo getMethodInfo(MethodDeclaration methodDeclaration) { 
            MethodInfo methodInfo = new MethodInfo();
            setMethodInfo(methodInfo, methodDeclaration);
            return methodInfo;
        }
    
        private void setMethodInfo(MethodInfo methodInfo,MethodDeclaration methodDeclaration) { 
            methodInfo.setMd5(MD5Encode(methodDeclaration.toString()));
            methodInfo.setMethodName(methodDeclaration.getName().toString());
            methodInfo.setParameters(methodDeclaration.parameters().toString());
        }
    
        /** * 计算方法的MD5的值 * @param s * @return */
        public static String MD5Encode(String s) { 
            String MD5String = "";
            try { 
                MessageDigest md5 = MessageDigest.getInstance("MD5");
                MD5String = Base64.encodeBase64String(md5.digest(s.getBytes("utf-8")));
            } catch (NoSuchAlgorithmException e) { 
                e.printStackTrace();
            } catch (UnsupportedEncodingException e) { 
                e.printStackTrace();
            }
            return MD5String;
        }
    
        /** * 判断方法是否存在 * @param method 新分支的方法 * @param methodsMap master分支的方法 * @return */
        public static boolean isMethodExist(final MethodDeclaration method, final Map<String, MethodDeclaration> methodsMap) { 
            // 方法名+参数一致才一致
            if (!methodsMap.containsKey(method.getName().toString() + method.parameters().toString())) { 
                return false;
            }
            return true;
        }
    
        /** * 判断方法是否一致 * @param method1 * @param method2 * @return */
        public static boolean isMethodTheSame(final MethodDeclaration method1,final MethodDeclaration method2) { 
            if (MD5Encode(method1.toString()).equals(MD5Encode(method2.toString()))) { 
                return true;
            }
            return false;
        }
    }

##### 7. TestDemo.java #####

这个是主函数，测试的时候用

/** * Demo class * * @author bigman * @date 2021/3/1 */
    public class TestDemo { 
    	//远程库路径
        public static String remotePath = "https://github.com/****/***.git";
        //下载已有仓库到本地路径
        public static String localPath = "/Users/bigman/software/local";
        public static String branchName = "master";
        public static String projectName = "***";
        public static void main(String[] args) throws GitAPIException, IOException { 
            String filePath = TestDemo.localPath+"/"+TestDemo.projectName;
            // 初始化adapter
            GitAdapter gitAdapter = new GitAdapter(TestDemo.remotePath,filePath,TestDemo.branchName);
    
            // 获取当前分支的所有commit提交记录
            gitAdapter.initGit();
            List<CommitMessage> commitMessages = gitAdapter.getCommitMessages();
            int i=1;
            for(CommitMessage commitMessage : commitMessages) { 
                System.out.println("===================================================================================================================================");
                System.out.println(i+" "+commitMessage.toString());
                i++;
            }
    
            // 对比master分支的commitId版本的代码差异
    // String commitId = "ce52c68b8bed4b6f76d469e951bbb509b29e9662";
     String commitId = "f15035ba055864429e99b2a763f1b2de3f612b9f";
     String commitId = "7b29e6d30a9c16af5f67d2ed2e72de988504166d";
    // List<ClassInfo> classInfos = CodeDiff.diffBranchToBranch(gitUtil,"f20210126","master",commitId);
    // for(ClassInfo classInfo:classInfos)
    // System.out.println(classInfo.toString());
    
    
    // Ref branchRef = gitAdapter.checkOutAndPull("master","1cf7615d811a0e92d53cb672fcec245eaec4506e");
    // GitAdapter gitAdapterA = new GitAdapter(TestMain.remotePath,filePath,"f20210126");
    // Ref ref = gitAdapter.getBranchRef();
    // gitAdapterA.getMergeMessage(ref);
    
        }
    }

## 三、 运行结果 ##

查看两个分支的差异情况  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70]: /images/20221023/aa743e2c9b224d3197048cb2556b93a5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70 1]: /images/20221023/15d0f3575c1c4551875ba324a6f1650c.png