【JGit 】一个完整的使用案例

已于 2024-02-28 16:08:12 修改
阅读量1.3k 收藏 14
点赞数 11
分类专栏： 工具使用 java技术 笔记 文章标签： JGIT git gitea
于 2024-02-28 15:05:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47406832/article/details/136346367
版权

需求

生成一系列结构相同的项目代码，将这些项目的代码推送至一个指定的 Git 仓库，每个项目独占一个分支。

推送时若仓库不存在，则自动创建仓库。

分析

生成代码使用 Java 程序模拟，每个项目中模拟三个文件。Project.cpp 、Project.h 和 README 。

使用 JGit 实现代码版本管理与推送。

代码实现

以下代码包含了代码生成，Git 仓库初始化、代码克隆、分支检出、代码修改、暂存、提交及推送等操作。

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.commons.lang.StringUtils;
import org.eclipse.jgit.api.CheckoutCommand;
import org.eclipse.jgit.api.CreateBranchCommand;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.ListBranchCommand;
import org.eclipse.jgit.api.PushCommand;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.transport.CredentialsProvider;
import org.eclipse.jgit.transport.PushResult;
import org.eclipse.jgit.transport.URIish;
import org.eclipse.jgit.transport.UsernamePasswordCredentialsProvider;

import cn.hutool.core.io.FileUtil;

public class JgitTest3 {

    private static String DEFAULE_REMOTE_NAME = "origin";
    private static String DEFAULE_BRANCH_NAME = "master";

    private static String gitUrl = "http://192.168.181.1:3000/root/a-test.git";

    private static String username = "root";
    private static String password = "123456";

    /**
     * 创建认证信息
     * 
     * @return
     */
    public static CredentialsProvider getCredentialsProvider() {
        return new UsernamePasswordCredentialsProvider(username, password);
    }

    public static void main(String[] args) throws Exception {

        List<String> branches = Stream.of("branchA", "branchB").collect(Collectors.toList());

        for (String branchName : branches) {

            System.out.println("\r\n ==========================<<" + branchName + ">>==========================\r\n");
            // 生成代码
            File codeDir = genCode(branchName);
            System.out.println(" >>>>>>>>>>>>>>> CodeDir: " + codeDir);

            // 判断仓库是否存在
            boolean remoteRepositoryExist = remoteRepositoryExist(gitUrl, username, password);
            if (remoteRepositoryExist) {
                pushOnRepoExist(branchName, codeDir);
            } else {
                pushOnRepoNotExist(branchName, codeDir);
            }

            // 清理生成的文件
            FileUtil.del(codeDir);
        }
    }

    private static void pushOnRepoNotExist(String branchName, File codeDir) throws Exception {
        // 将源码库初始化为Git仓库
        Git git = Git.init().setDirectory(codeDir).call();

        // 添加远程仓库
        git.remoteAdd()
                .setName(DEFAULE_REMOTE_NAME)
                .setUri(new URIish(gitUrl))
                .call();

        // 初始化提交
        git.add().addFilepattern(".").call();
        git.commit().setMessage("Initial commit").call();

        // 切换分支
        checkoutBranch(git, branchName);

        // 提交推送
        pushToRepo(git, branchName);

        // 关闭资源
        git.close();
    }

    private static void pushOnRepoExist(String branchName, File codeDir) throws Exception {

        // 创建临时工作目录
        File localDir = Files.createTempDirectory("Jgit-work-dir-").toFile();
        System.out.println("\r\n >>>>>>>>>>>>>>> Work dir is: " + localDir + "\r\n");

        // 克隆到本地
        Git git = Git.cloneRepository()
                .setDirectory(localDir)
                .setURI(gitUrl)
                .setCredentialsProvider(getCredentialsProvider())
                .call();

        // 切换到分支
        checkoutBranch(git, branchName);

        // 更新代码
        deleteContent(localDir.toPath(), ".git");
        // git.add().addFilepattern(".").setUpdate(true).call();
        // git.commit().setMessage("rm origin files").call();

        FileUtil.copyContent(codeDir, localDir, true);

        // 提交、推送
        pushToRepo(git, branchName);

        // 关闭资源
        git.close();

        FileUtil.del(localDir);
    }

    /**
     * 推送到远端分支
     * 
     * @param git
     * @param branchName 远端分支
     * @throws Exception
     */
    private static Iterable<PushResult> pushToRepo(Git git, String branchName) throws Exception {
        // 加入暂存区
        git.add().addFilepattern(".").call();
        git.add().addFilepattern(".").setUpdate(true).call();
        // 提交
        git.commit().setMessage(" Commit at : " + LocalDateTime.now()).call();

        // 构建推送命令
        PushCommand pushCmd = git.push()
                .setRemote(DEFAULE_REMOTE_NAME)
                .setCredentialsProvider(getCredentialsProvider());

        Ref remoteBranchRef = git.getRepository().findRef("refs/remotes/" + DEFAULE_REMOTE_NAME + "/" + branchName);
        if (Objects.isNull(remoteBranchRef)) {
            pushCmd.add(branchName);
        } else {
            pushCmd.setForce(true);
        }

        // 推送
        return pushCmd.call();
    }

    /**
     * 切换分支
     * <p>
     * <ul>
     * <li>先判断本地分支是否存在，存在则直接切换，不存在则下一步。</li>
     * <li>判断远程分支是否存在，存在则直接切换，不存在则在切换时创建分支。</li>
     * </ul>
     * 
     * </p>
     * 
     * @param git
     * @param branchName
     */
    private static void checkoutBranch(Git git, String branchName) throws Exception {

        CheckoutCommand checkoutCmd = git.checkout().setName(branchName);

        Repository repository = git.getRepository();
        Ref branchRef = repository.findRef("refs/heads/" + branchName);
        if (Objects.isNull(branchRef)) {
            Ref remoteBranchRef = repository.findRef("refs/remotes/" + DEFAULE_REMOTE_NAME + "/" + branchName);
            if (Objects.isNull(remoteBranchRef)) {
                CreateBranchCommand createBranchCmd = git.branchCreate().setName(branchName);
                // 先切换到已有分支，以获取提交记录，设置提交点辅助创建新的分支
                List<Ref> branches = git.branchList()
                        .setListMode(ListBranchCommand.ListMode.REMOTE)
                        .call();
                if (Objects.nonNull(branches) && branches.size() > 0) {
                    Ref remoteRef = branches.get(0);
                    String bName = Repository.shortenRefName(remoteRef.getName());
                    git.checkout().setName(bName).call();
                    RevCommit latestCommit = git.log().setMaxCount(1).call().iterator().next();
                    if (Objects.nonNull(latestCommit)) {
                        createBranchCmd.setStartPoint(latestCommit);
                    }
                }

                createBranchCmd.call();
            } else {
                checkoutCmd.setCreateBranch(true);
            }
        }

        checkoutCmd.call();
    }

    /**
     * 删除目录中的所有文件
     * <ul>
     * <li>文件</li>
     * <li>文件夹</li>
     * <li>子文件</li>
     * <li>子文件夹</li>
     * </ul>
     * 
     * @param folderPath  目标文件夹
     * @param ignoreFiles 忽略的文件或文件夹
     */
    public static void deleteContent(Path folderPath, String... ignoreFiles) {
        try {
            Files.walk(folderPath)
                    .filter(path -> !path.equals(folderPath))
                    .filter(path -> {
                        if (Objects.isNull(ignoreFiles) || ignoreFiles.length == 0) {
                            return false;
                        }
                        for (String ig : ignoreFiles) {
                            if (StringUtils.contains(path.toAbsolutePath().toString(), ig)) {
                                return false;
                            }
                        }
                        return true;
                    })
                    .forEach(path -> {
                        try {
                            if (path.toFile().isDirectory()) {
                                deleteContent(path, ignoreFiles);
                            } else {
                                Files.deleteIfExists(path);
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 生成代码
     * 
     * @param branchName
     * @return
     * @throws Exception
     */
    private static File genCode(String branchName) throws Exception {

        File codeDir = Files.createTempDirectory("Jgit-source-dir-").toFile();
        String codeDirAbsPath = codeDir.getAbsolutePath();

        // 生成 README
        File addNewFile = new File((codeDirAbsPath.concat(File.separator).concat("README.md")));
        String readmeContent = "Project for " + branchName + "\r\nWrite By Code JGitTest ";
        Files.write(addNewFile.toPath(), readmeContent.getBytes());

        // 生成文件
        File cppFile = new File(codeDirAbsPath.concat(File.separator).concat(branchName.concat(".cpp")));
        String cppContent = "Cpp Code for " + branchName + "\r\n Write By Code JGitTest ";
        Files.write(cppFile.toPath(), cppContent.getBytes());

        // 生成文件
        File hFile = new File(codeDirAbsPath.concat(File.separator).concat(branchName.concat(".h")));
        String hContent = "Header code for " + branchName + "\r\nWrite By Code JGitTest ";
        Files.write(hFile.toPath(), hContent.getBytes());

        return codeDir;
    }

    /**
     * 判断远程仓库是不是存在
     *
     * @param remoteUrl 远程仓库地址
     * @return true（存在）/false（不存在）
     */
    public static boolean remoteRepositoryExist(String remoteUrl, String username, String password) {
        try {
            Collection<Ref> refs = (Collection<Ref>) Git.lsRemoteRepository()
                    .setHeads(true)
                    .setTags(true)
                    .setCredentialsProvider(getCredentialsProvider(username, password))
                    .setRemote(remoteUrl)
                    .call();
            if (refs.isEmpty()) {
                return false;
            } else {
                return true;
            }
        } catch (Exception e) {
            log.warn("仓库{}不存在", remoteUrl);
            return false;
        }
    }

}

成果展示

在这里插入图片描述

附

1、JGit 版本

        <!-- https://mvnrepository.com/artifact/org.eclipse.jgit/org.eclipse.jgit -->
        <dependency>
            <groupId>org.eclipse.jgit</groupId>
            <artifactId>org.eclipse.jgit</artifactId>
            <version>5.1.3.201810200350-r</version>
        </dependency>

2、Gitea 安装

3、JGit 资料

SpringCloud使用教程
9.冄2.7.號的博客
09-12 531
从面试开始 什么是微服务？ 微服务之间是如何独立通讯的 SpringCloud和Dubbo有哪些区别？ SpringBoot和SpringCloud，请你谈谈对他们的理解 什么是服务熔断？什么是服务降级 微服务的优缺点分别是什么？说下你在项目开发中碰到的坑 你所知道的微服务技术栈有哪些？请列举一二 eureka和zookeeper都可以提供服务注册与发现的功能，请说说两个的区别？ … 微服务概...
java使用jgit工具拉取代码和推送代码（干货）
zx733988的博客
05-29 1679
报红的话直接import进去就好了filePath是绝对路径（文件夹：E:\gitCommit这种类型）remoteGitUrl是远端git地址branch直接传入名字 比如master。
jgit-cookbook, 提供 JGit Java Git实现的示例和代码 Fragment.zip
10-10
jgit-cookbook, 提供 JGit Java Git实现的示例和代码 Fragment jgit食谱 提供 JGit的Java Git实现示例和代码 Fragment 。JGit框架丰富多样，它有两层，一个低级的插件 api，以及一个高级别的系列的命令，比如 commands 。 这可以能会有点恐惧，因为有很多类
Jgit的使用
lmchhh的博客
10-08 621
当需要对系统中某些页面管理的文件做版本管理时，使用git作为其基本组件。此时需要在页面上做一些按钮，操作时会执行git指令。使用java作为开发语言时，需要引用jgit依赖例如
JGit基本使用
最新发布
了解➔熟悉➔掌握➔精通
03-17 722
分享一个大牛的教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请轻击人工智能教程​​​​​‌JGit是一个用于在Java中操作Git仓库的库，它提供了一组Java库和API，使开发人员可以在他们的Java应用程序中使用Git功能‌。JGit由Eclipse基金会开发和维护，是完全用Java实现的，没有外部依赖，因此可以轻松地与Java项目集成。JGit支持各种操作系统，包括Windows、Linux和Mac等‌。
JGit使用
阿呆的专栏
12-08 1497
pom依赖 <dependency> <groupId>org.eclipse.jgit</groupId> <artifactId>org.eclipse.jgit</artifactId> <version>3.5.0.201409260305-r</version> </depe...
git笔记——jgit使用
steven的博客
04-02 3051
git笔记——jgit使用 有时需要通过Java代码连接Git库，开源的JGit是不错选择。JGit连接代码仓库通常需要鉴权，这里介绍一种使用私有Token进行鉴权连接的方法。 首先在Git库上生成私有Token，Github中生成路径为：Settings->Developer settings ->Personal access tokens -> Generate ...
java操作Git工具-----Jgit使用
Luo God 的博客
04-28 3822
JGit正确食用方式，可以做一些小工具
JGit-cookbook：JGit Java Git实现的实例与代码指南
综上所述，jgit-cookbook项目旨在为Java开发者提供一个参考和学习JGit使用方式的资源库。通过介绍JGit的双层API、提供实用的代码片段，并指导如何构建和导入项目，jgit-cookbook帮助开发者能够快速地掌握使用Java...
timerTask定时任务使用java代码操作svn
08-20
本示例项目为初学者提供了一个结合定时任务与SVN操作的实践案例，有助于理解和掌握这些技术的综合应用。但请注意，实际生产环境中，这类操作可能需要更严谨的错误处理和权限控制。不断学习和实践，将使你在这个领域...
spring-boot示例项目
03-25
spring boot demo 是一个Spring Boot、Spring Cloud的项目示例，根据市场主流的后端技术，共集成了30+个demo，未来将持续更新。该项目包含helloworld(快速入门)、web(ssh项目快速搭建）、aop(切面编程)、data-redis...
Stanford CoreNLP 中文API包的开源项目介绍
org.eclipse.jgit.ant是Eclipse JGit项目中的一个组件，Eclipse JGit是一个纯Java实现的Git版本控制系统。该组件提供了Ant任务接口，允许开发人员通过Ant脚本与Git仓库进行交互。Ant是一种基于Java的构建工具，类似...
一个极简单JavaFX例子
10-07
一个极简单JavaFX例子！其实JavaFX也挺不错的，值得了解了解！
JGit介绍及使用
y368769的博客
12-31 3646
简介 JGit是一个可以用java来对git进行操作的插件，可以通过代码连接git远程仓库，在本地建立版本库，进行拉取、提交、推送等操作。 依赖 <dependency> <groupId>org.eclipse.jgit</groupId> <artifactId>org.eclipse.jgit</artifactId> <version>5.9.0.202
使用JGit进行身份验证
danpu0978的博客
04-28 745
JGit是实现Git版本控制系统的轻量级纯Java库。 您可以使用Java语言执行许多操作，例如创建或克隆Git存储库，创建分支，提交，重新设置基础或标记，您可以看到 此仓库了解如何使用JGit以及如何编写不同的命令。 但是认证过程并不广泛。 在这篇文章中，我将向您展示如何使用以下方法对Git存储库进行身份验证 吉吉特 首先要做的是将JGit添加为依赖项： dependenc...
JGit
儒雅随和丶mata坤的博客
01-20 3047
JGit 参考：https://yonge812.iteye.com/blog/1687480 概念： 就是用java代码实现git的命令行操作 JGit API： https://download.eclipse.org/jgit/site/5.2.1.201812262042-r/apidocs/index.html 打开git仓库  Git git=Git.open（new F...
Jgit基础教程(Java调用git)
热门推荐
qq_44299928的博客
11-09 2万+
前言 最近公司需要做一个java调用git的工具，这里简单的介绍了一下基本操作方法以及一些衍生的信息获取，或有不对的地方请大家批评指正。转载请注明出处。 一、Jgit依赖导入 <dependency> <groupId>org.eclipse.jgit</groupId> <artifactId>org.eclipse.jgit</artifactId> <version>4.4.1.20160715
DevOps系列文章 之 Java使用jgit管理git仓库
Coder_Boy_的博客
07-04 1808
最近设计基于gitops新的CICD方案,需要通过java读写git仓库，这里简单记录下。JGit是一款pure java的软件包，可以读写git仓库，下面介绍基本使用。
JGit用法总结
u013158317的博客
04-13 2794
clone public static void gitClone(String remoteUrl, File repoDir) { try { Git git = Git.cloneRepository() .setURI(remoteUrl) .setDirectory(repoDir) ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值