使用 JGit 管理 Git 仓库

最编程 2024-03-09 21:12:55

...

在某些场景下我们可能有通过Java代码操作Git仓库的需求，例如您要开发一个工具，通过拉取远程仓库的代码，分析并统计某个时间范围内各提交人的代码行数等，那么接下来的这个工具可帮助你应对Git操作的问题

首先我们在项目中添加依赖

<dependency>
    <groupId>org.eclipse.jgit</groupId>
    <artifactId>org.eclipse.jgit</artifactId>
    <version>6.7.0.202309050840-r</version>
</dependency>

在使用前先对几个对象进行说明

Repository：表示一个Git存储库（在使用时不要认为一定是线程安全的，并且使用完后记得关闭）
Git：使用类似Git高层命令方式的API来操作Git存储库的对象
Gi对象(Git Objects)：就是git的对象，它们在git中用SHA-1来表示。在JGit中用AnyObjectId和ObjectId表示，而它又包含了四种类型：

二进制大对象(blob)：文件数据
树(Tree)：指向其它的tree和blob
提交（commit）：指向某一棵tree
标签（tag）：把一个commit标记为一个标签

Ref：对某一个Git对象的引用
RevWalk：该类用于从commit的关系图（graph）中遍历commit。
RevCommit：表示一个git的commit
RevTag：表示一个git的tag
RevTree：表示一个git的tree
TreeWalk：类似RevWalk，但是用于遍历一棵tree
CredentialsProvider：提供访问远程Git仓库的访问凭证，可以是用户名和密码，也可以是access token，其默认实现为

1、构建远程仓库凭借

通过用户名/密码构建凭据

//通过用户名和密码构建认证凭证
String username = "" ;
String password = "" ;
CredentialsProvider credentialsProvider = 
	new UsernamePasswordCredentialsProvider(username,password);

通过访问token构建凭据

//通过个人或项目的access token构建凭证
//需要注意，此时的用户名设置为：Automation token
String token = "dfewf244r4rg" ;
CredentialsProvider credentialsProvider = 
	new UsernamePasswordCredentialsProvider("Automation token",token);

2、从远程仓库进行克隆

//远程仓库地址
private String remoteUrl ;

//本地工作路径（在该目录或子目录下对代码进行克隆）
private File rootWorkDir ;

//源码目录(.git所在路径)
private File workDir ;

//远程仓库认证方式
private CredentialsProvider credentialsProvider ;

//GIT仓库示例对象
private Repository repository ;

/**
 * 从远程仓库克隆
 */
public Repository clone(Collection<String> branchesToClone,
                        Integer depth) 
  throws GitAPIException {
    CloneCommand cloneCommand  = Git.cloneRepository()
            .setURI(this.remoteUrl)
            .setCredentialsProvider(this.credentialsProvider)
            .setDirectory(this.workDir)
            .setProgressMonitor(new TextProgressMonitor())
            .setTimeout(120);
    if(depth != null){
        cloneCommand.setDepth(depth) ;
    }
    if(branchesToClone != null && branchesToClone.size() > 0){
        cloneCommand.setBranchesToClone(branchesToClone) ;
    }
    Git git = cloneCommand.call() ;
    return git.getRepository() ;
}

/**
 * 从远程仓库克隆
 */
public Repository gitClone() throws GitAPIException {
    return gitClone(null,null) ;
}

3、判断某路径下

/**
 * 判断指定路径是否已经是仓库
 */
public boolean isLocalRepoExist(File projectPath){
    File gitDir = Paths.get(projectPath.getAbsolutePath(),
                            Constants.DOT_GIT).toFile();
    return (gitDir.exists() && gitDir.isDirectory()) ;
}

4、打开本地已有的仓库

当本地仓库已经存在且不打算重新克隆时，可通过下面的方式打开仓库

/** 
 * 打开本地仓库
 * @gitDir  .git文件夹所在路径
 */
public Repository openRepository(Fie gitDir) throws IOException {
    //基于本地.git构建仓库对象
    return FileRepositoryBuilder.create(gitDir) ;
}

5、获取当前分支名

/**
 * 当前分支
 */
public Ref currentBranch() throws IOException {
    //String branchName = git.getRepository().getBranch();
    return repository.exactRef(Constants.HEAD)
        .getTarget().getName();
}

6、获取所有远程分支

/**
 * 创建GIT指令操作对象
 * @param repo 仓库对象
 */
public Git newGit(Repository repo){
    return new Git(repo);
}

/**
 * 所有的远程分支
 */
public List<Ref> remoteBranches(Repository repository) 
    throws GitAPIException {
    try(Git git = newGit(repository)){
        return git.branchList()
            .setListMode(ListBranchCommand.ListMode.REMOTE).call();
    }
}

7、获取所有本地分支

/**
 * 所有的远程分支信息
 */
public List<Ref> localBranches(Repository repository) 
    throws GitAPIException {
    try(Git git = newGit(this.repository)){
        return git.branchList().call();
    }
}

8、判断分支是否存在

/**
 * 判断指定的分支是否为本地分支
 */
private boolean isExistLocalBranch(Repository repository,
                                   String branchName) throws GitAPIException {
    List<Ref> localBranchs = localBranches(repository) ;
    if(localBranchs == null){
        return false ;
    }
    for(Ref ref : localBranchs){
        if(ref.getName().equals(branchName) 
           || toShrotNeme(ref.getName()).equals(branchName)){
            return true ;
        }
    }
    return false ;
}

/**
 * 将分支名转换成短名
 * @param type 分支类型，远程分支:1； 本地分支:0
 */
private String toShrotNeme(int type,String branchName){
	if(type == 1){
        return toRemoteShortName() ;
    }
    return toLocalShortName() ;
}

private static final String REMOTE_PREFIX = Constants.R_REMOTES + Constants.DEFAULT_REMOTE_NAME+"/" ;
private static final String LOCAL_PREFIX = Constants.R_HEADS  ;

private String toRemoteShortName(String branchName){
    return branchName.replaceAll(REMOTE_PREFIX,"") ;
}
private String toLocalShortName(String branchName){
    return branchName.replaceAll(LOCAL_PREFIX,"") ;
}

9、切换分支

/**
 * 切换到指定分支.
 * 拉取特定分支的特定提交
 */
public void checkout(Repository repository,
                     String branchName) throws GitAPIException {
    if(StringUtils.isBlank(branchName)){
        return;
    }
    try(Git git = new Git(repository)) {
        //指定要签出的分支或提交的名称，或者指定新的分支名称
        //当只签出路径而不切换分支时，请使用setStartPoint（String）或setStartPoint（RevCommit）指定从哪个分支或提交签出文件。
        //当setCreateBranch（boolean）设置为true时，请使用此方法设置要创建的新分支的名称，并使用setStartPoint（String）
        // 或setStartPoint（RevCommit）指定分支的起点。
        CheckoutCommand checkoutCommand = git.checkout().setName(branchName);
        checkoutCommand.setCreateBranch(true);
        checkoutCommand.setUpstreamMode(CreateBranchCommand.SetupUpstreamMode.TRACK) ;
        checkoutCommand.setStartPoint(Constants.DEFAULT_REMOTE_NAME+"/" + branchName) ;
        checkoutCommand.call();
    }
}

10、拉取最新代码

/**
 *拉取远程最新代码
 */
public void pull(Repository repository) throws Exception{
    try (Git git = new Git(repository)) {
        git.pull()
        .setCredentialsProvider(this.credentialsProvider)
        .call();
    }
}

11、获取提交日志

public class CommitLogInfo {
    //提交对象引用
    private RevCommit revCommit ;
    
    //作者姓名
    private String authorName ;
    //作者的邮箱
    private String authorEmail ;

    //提交人姓名
    private String committerName ;
    //提交人邮箱
    private String committerEmail ;
    //提交时间
    private Date commitTime ;
}

/**
 * 当前分支的所有提交日志
 * 注意：返回的数据是时间的倒序，也就是第一个元素为最新的提交
 */
public List<CommitLogInfo> commitLogs() throws GitAPIException {
     return commitLogs(null) ;
}

public List<CommitLogInfo>  commitLogs(RevFilter aFilter) throws GitAPIException {
    List<CommitLogInfo> commitLogs = new ArrayList<>() ;
    try(Git git = newGit(repository) ) {
        LogCommand logCommand = git.log() ;
        if(aFilter != null){
            logCommand.setRevFilter(aFilter) ;
        }
        Iterable<RevCommit> logs = logCommand.call();
        for (RevCommit rev : logs) {
            commitLogs.add(new CommitLogInfo(rev,rev.getAuthorIdent().getEmailAddress(),
                    rev.getCommitterIdent().getEmailAddress(),
                    rev.getCommitterIdent().getWhen())
                    .withAuthorName(rev.getAuthorIdent().getName())
                    .withCommitterName(rev.getCommitterIdent().getName()));
        }
        return commitLogs ;
    }
}

/**
 * 提取指定范围所有提交
 * @param since 开始时间(包含)
 * @param until 结束时间(包含)
 */
public List<CommitLogInfo> listCommit(Date since, Date until) throws GitAPIException {
    RevFilter revFilter = null ;
    if(since != null && until != null){
        revFilter = CommitTimeRevFilter.between(since,until) ;
    }else if(since != null){
        revFilter = CommitTimeRevFilter.after(since) ;
    }else if(until != null){
        revFilter = CommitTimeRevFilter.before(until) ;
    }
    return commitLogs(revFilter) ;
}

12、重置commit

 /**
 * @param ref  重置到指定的commit id
 */
public void reset(Repository repository,String ref){
    try(Git git = newGit(repository) ) {
        ResetCommand reset = git.reset()
            .setMode(ResetCommand.ResetType.HARD)
            .setRef(ref) ;
        reset.call();
    } catch (CheckoutConflictException e) {
        throw new RuntimeException(e);
    } catch (GitAPIException e) {
        throw new RuntimeException(e);
    }
}

13、获取变更文件

public class EditRow {
    //INSERT、DELETE、REPLACE、EMPTY
    public final String editType;
    public final int startLine;
    public final int endLine;
}

public class ChangedFile {
    //获取与该文件关联的旧路径[相对.git目录的相对路径]
    private String oldPath ;
    
    //获取与该文件关联的新路径[相对.git目录的相对路径]
    //例如：src/main/java/com/geega/sonar/Application.java
    private String newPath ;
    
    //变更类型:ADD、MODIFY、DELETE、RENAME、COPY
    private String changeType ;

    private List<EditRow> editRows ;
}
 
 /**
 * 指定两个提交间的变更
 */
public List<ChangedFile> listChangedFiles(String oldCommit, String newCommit) throws IOException {
    AbstractTreeIterator oldTree = prepareTreeParser(repository,oldCommit) ;
    AbstractTreeIterator newTree = prepareTreeParser(repository,newCommit) ;
    return listChangedFiles(oldTree,newTree) ;
}

private AbstractTreeIterator prepareTreeParser(Repository repository, String objectId) throws IOException {
    // from the commit we can build the tree which allows us to construct the TreeParser
    //noinspection Duplicates
    try (RevWalk walk = new RevWalk(repository)) {
        RevCommit commit = walk.parseCommit(repository.resolve(objectId));
        RevTree tree = walk.parseTree(commit.getTree().getId());

        CanonicalTreeParser treeParser = new CanonicalTreeParser();
        try (ObjectReader reader = repository.newObjectReader()) {
            treeParser.reset(reader, tree.getId());
        }
        walk.dispose();
        return treeParser;
    }
}

public List<ChangedFile> listChangedFiles(AbstractTreeIterator oldTree,AbstractTreeIterator newTree) throws IOException {
    List<ChangedFile> result = new ArrayList<>() ;
    // finally get the list of changed files
    try (Git git = new Git(repository)) {
        List<DiffEntry> diffs = git.diff()
                .setNewTree(newTree)
                .setOldTree(oldTree)
                .call();
        PatchIdDiffFormatter formatter = new PatchIdDiffFormatter() ;
        //设置比较器为忽略空白字符对比（Ignores all whitespace）
        formatter.setDiffComparator(RawTextComparator.WS_IGNORE_ALL);
        formatter.setRepository(this.repository);
        //List<DiffEntry> entries = formatter.scan(oldTree,newTree) ;

        for (DiffEntry entry : diffs) {
            //获取与该文件关联的旧名称(相对工作路径)
            String oldPath = entry.getOldPath() ;
            //获取与该文件关联的新名称(相对工作路径)
            String newPath = entry.getNewPath() ;
            if(!newPath.endsWith(com.geega.im.workunit.module.comm.Constants.SRC_JAVA_SUFFIX)){
                continue;
            }
            //打印文件差异具体内容
            //formatter.format(entry);
            //获取文件差异位置，从而统计差异的行数，如增加行数，减少行数
            FileHeader fileHeader = formatter.toFileHeader(entry) ;

            List<EditRow> editRows = new ArrayList<>() ;
            //每次编辑都会描述插入、删除或替换的区域以及受影响的线。
            //这些行从零开始计数，可以使用getBeginA()、getEndA()、getBeginB()和getEndB()进行查询
            EditList editList = fileHeader.toEditList() ;
            for(Edit edit : editList){
                int start = 0 ;
                int end = 0 ;
                /*
                 * beginA==endA && beginB<endB   的编辑是插入编辑，即序列B在beginA插入区域[beginB，endB)中的元素
                 * beginA＜endA && beginB==endB   的编辑是删除编辑，即序列B删除了[beginA，endA)之间的元素
                 * beginA＜endA && beginB＜endB   的编辑是替换编辑，即序列B已将[beginA，endA)之间的元素范围替换为[beginB，endB)中的元素
                 */
                if(edit.getType() == Edit.Type.INSERT){
                    start = edit.getBeginB() ;
                    end = edit.getEndB() ;
                }else{
                    start = edit.getBeginA() ;
                    end = edit.getEndA() ;
                }
                editRows.add(new EditRow(edit.getType().name(),start,end)) ;
            }
            /*
            List<HunkHeader> hunks = (List<HunkHeader>) fileHeader.getHunks();
            for(HunkHeader hunkHeader:hunks){
                EditList editList = hunkHeader.toEditList();
            }
            */
            result.add(new ChangedFile(oldPath,newPath,entry.getChangeType().name(),editRows));
        }
    } catch (GitAPIException e) {
        throw new RuntimeException(e);
    }
    return result ;
}

14、获取文件历史修改记录


public class BlameLine {

    //文件路径
    private String filePath ;

    //提交时间
    private Date commitTime;
    //提交人
    private String committerName;
    //提交人邮件
    private String committerEmail;

    //修订ID
    private Date authorTime;
    //修订人
    private String authorName;
    private String authorEmail;

    //更新的文件行
    private int sourceLine;
    //变更前文件内容
    private String rowContent ;
    //变更后文件内容
    private String content ;
}

/**
 * git blame用来追溯一个指定文件的历史修改记录.它能显示任何文件中每行最后一次修改的提交记录
 * 我们可以查出某个文件的每一行内容到底是由哪位大神所写【报告没有告诉你任何关于被删除或替换的行】
 * https://git-scm.com/docs/git-blame
 * - git blame filename
 * - git blame -L n1,n2 filename   [-L 指定文件的行数范围]
 * @param filename
 */
public List<BlameLine> blame(String filename){
    Git git = newGit(this.repository) ;
    BlameResult blameResult;
    try {
        blameResult = git.blame()
                // Equivalent to -w command line option
                .setTextComparator(RawTextComparator.WS_IGNORE_ALL)
                .setFilePath(filename).call();
    } catch (Exception e) {
        throw new IllegalStateException("Unable to blame file " + filename, e);
    }
    List<BlameLine> lines = new ArrayList<>() ;
    for (int i = 0; i < blameResult.getResultContents().size(); i++) {
        if (blameResult.getSourceAuthor(i) == null
                || blameResult.getSourceCommit(i) == null) {
            continue;
        }
        ByteBuffer byteBuffer = blameResult.getResultContents().getRawString(i);
        String rowContent = StandardCharsets.UTF_8.decode(byteBuffer).toString();
        byteBuffer.flip() ;
        String content = blameResult.getResultContents().getString(i) ;
        //添加变化行信息
        lines.add(new BlameLine()
                  .commitTime(blameResult.getSourceCommitter(i).getWhen())
                  .committerName(blameResult.getSourceCommitter(i).getName())
                  .committerEmail(blameResult.getSourceCommitter(i).getEmailAddress())
                  .authorName(blameResult.getSourceAuthor(i).getName())
                  .authorEmail(blameResult.getSourceAuthor(i).getEmailAddress())
                  .authorTime(blameResult.getSourceAuthor(i).getWhen())
                  .authorEmail(blameResult.getSourceAuthor(i).getEmailAddress())
                  .sourceLine(blameResult.getSourceLine(i))
                  .filePath(blameResult.getSourcePath(i))
                  .rowContent(rowContent)
                  .content(content));
        }
        return lines ;
    }

15、列出指定commit下的所有文件

public List<String> listAllFile(String commitId) throws Exception {
    List<String> items = new ArrayList<>();
    RevCommit revCommit = buildRevCommit(commitId);
    RevTree tree = revCommit.getTree();
    try (TreeWalk treeWalk = new TreeWalk(repository)) {
        treeWalk.addTree(tree);
        treeWalk.setRecursive(false);
        treeWalk.setPostOrderTraversal(false);

        while(treeWalk.next()) {
            items.add(treeWalk.getPathString());
        }
    }
    return items ;
}

public RevCommit buildRevCommit(String commit) throws IOException {
    // a RevWalk allows to walk over commits based on some filtering that is defined
    try (RevWalk revWalk = new RevWalk(this.repository)) {
        return revWalk.parseCommit(ObjectId.fromString(commit));
    }
}

示例代码地址：https://github.com/centic9/jgit-cookbook

上一篇： [Java] JGit 使用摘要

下一篇： Java 通过使用 JGit 操作 Git

使用 JGit 管理 Git 仓库

1、构建远程仓库凭借

2、从远程仓库进行克隆

3、判断某路径下

4、打开本地已有的仓库

5、获取当前分支名

6、获取所有远程分支

7、获取所有本地分支

8、判断分支是否存在

9、切换分支

10、拉取最新代码

11、获取提交日志

12、重置commit

13、获取变更文件

14、获取文件历史修改记录

15、列出指定commit下的所有文件

如何使用 Java 为仓库管理系统实施人工智能和机器学习技术

Git 仓库管理系统（开源 WMS）--分享如何在两个月内完成 10W+ 项目！

项目管理] git 和代码云的使用【重复

1.5.1 使用 Git 管理本地仓库的基本操作

使用 git 从远程仓库提取代码

git 操作：从远程仓库 gitLab 拉取指定分支到本地仓库；如何使用 git 分支进行多人开发；多人协作提交代码实践

git pull 远程仓库命令代码 - a ，使用 git 从远程仓库下载代码到本地

使用 git 命令将代码提交到远程仓库（命令提交；详细版本）

(超级详细）使用 git 命令行将本地仓库代码上传到 gitee/github 远程仓库

如何使用 Git 管理 Vivado 项目

使用 JGit 管理 Git 仓库

1、构建远程仓库凭借

2、从远程仓库进行克隆

3、判断某路径下

4、打开本地已有的仓库

5、获取当前分支名

6、获取所有远程分支

7、获取所有本地分支

8、判断分支是否存在

9、切换分支

10、拉取最新代码

11、获取提交日志

12、重置commit

13、获取变更文件

14、获取文件历史修改记录

15、列出指定commit下的所有文件

如何使用 Java 为仓库管理系统实施人工智能和机器学习技术

Git 仓库管理系统（开源 WMS）--分享如何在两个月内完成 10W+ 项目！

项目管理] git 和代码云的使用 【重复

1.5.1 使用 Git 管理本地仓库的基本操作

使用 git 从远程仓库提取代码

git 操作：从远程仓库 gitLab 拉取指定分支到本地仓库；如何使用 git 分支进行多人开发；多人协作提交代码实践

git pull 远程仓库命令代码 - a ，使用 git 从远程仓库下载代码到本地

使用 git 命令将代码提交到远程仓库（命令提交；详细版本）

(超级详细）使用 git 命令行将本地仓库代码上传到 gitee/github 远程仓库

如何使用 Git 管理 Vivado 项目

项目管理] git 和代码云的使用【重复