Fetching Updates From a Remote Repository Using JGit

JGit is a lightweight Java library that can be implemented for Git version control systems. It allows developers to perform Git operations programmatically within Java applications. One of the essential tasks in Git is fetching updates from a remote repository, ensuring that the local repository stays in sync with the remote repository. This article will guide you through the process of fetching updates using JGit.

Prerequisites:

• Basic knowledge of the Git and its operations.
• Java Development Kit installed in your local system.
• Maven for building dependency management.

Setting up the Environment

To use JGit, we need to include the JGit dependency in the project.

Maven Dependency:

Add the following dependency to the pom.xml file.

<dependency>
    <groupId>org.eclipse.jgit</groupId>
    <artifactId>org.eclipse.jgit</artifactId>
    <version>6.9.0.202403050737</version>
</dependency>

Fetching the updates from the remote repository involves the pulling the latest commits and branches from the repository to the local repository without the merging them. This is the common task to keep the local repository up to date with the changes made in the remote repository.

Implementation of Fetching Updates using JGit

Step 1: Create the Local repository

First, we will create a local repository.

git init
echo "#my project " >>README.md
git add .
git commit -m "Initial commit"

Image reference:

Step 2: Create the Maven Project

Create the maven project using Intellij Idea. After the project creation done, then the file structure will look like the below image.

Step 3: Create the SimpleProgressMonitor class

package org.example;

import org.eclipse.jgit.lib.ProgressMonitor;

public class SimpleProgressMonitor implements ProgressMonitor {

    @Override
    public void start(int totalTasks) {
        System.out.println("Starting fetch...");
    }

    @Override
    public void beginTask(String title, int totalWork) {
        System.out.println("Task: " + title + " (" + totalWork + " units)");
    }

    @Override
    public void update(int completed) {
        System.out.println("Completed: " + completed);
    }

    @Override
    public void endTask() {
        System.out.println("Task complete.");
    }

    @Override
    public boolean isCancelled() {
        return false;
    }

    @Override
    public void showDuration(boolean b) {

    }
}

The SimpleProgressMonitor class implements the ProgressMonitor interface from JGit, providing basic methods to monitor and display progress during Git operations in Java applications. It prints messages to indicate the start, progress, and completion of tasks, ensuring transparency and feedback to users or developers executing Git fetch operations programmatically.

Step 4: Create the JGitFetchExample class

package org.example;

import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.transport.UsernamePasswordCredentialsProvider;

import java.io.File;

public class JGitFetchExample {

    public static void main(String[] args) {
        File repoDir = new File("c:/Users/Mahesh/Desktop/git-repo/.git");

        try (Git git = Git.open(repoDir)) {
            System.out.println("Fetching updates from the remote repository...");

            git.fetch()
                    .setRemote("origin")
                    .setCredentialsProvider(new UsernamePasswordCredentialsProvider("iammahesh123", "IamMahesh@123")) // Replace with your credentials
                    .setProgressMonitor(new SimpleProgressMonitor())
                    .call();

            System.out.println("Fetch complete.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

This JGitFetchExample class demonstrates how to fetch updates from a remote Git repository using JGit in a Java application. It opens a local Git repository located at "c:/Users/Mahesh/Desktop/git-repo/.git", configures credentials for authentication, sets up a progress monitor (SimpleProgressMonitor), and performs the fetch operation. If successful, it prints a message indicating completion; otherwise, it prints the stack trace for any encountered exceptions.

pom.xml file:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>Junit-Fetch-Example</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.eclipse.jgit/org.eclipse.jgit -->
        <dependency>
            <groupId>org.eclipse.jgit</groupId>
            <artifactId>org.eclipse.jgit</artifactId>
            <version>6.9.0.202403050737-r</version>
        </dependency>
    </dependencies>

</project>

Step 5: Run the application

Now, run the application. Below is the console output.

Repository Updates successfully:

By following the above steps outlined in this article, we will be able to fetch the updates from the remote repository using JGit effectively. It will help you keep the local repository in sync with the remote repository and manage the project codebase effectively.