Rolling back changes with JGit

JGit is a lightweight and pure Java library that can implement the Git version control system. It can allow the developers to manage the Git repositories directly within their Java applications. Rolling back changes in the Git repository using JGit can involves resetting the repository to the previous commit or reverting the specific commits.

This article will guide you to focus on using the JGit to rolling and reverting the repository's commits.

Prerequisites

• Basic understanding of Git and version control.
• Maven installed on your system.
• A Java IDE (e.g., IntelliJ IDEA, Eclipse).

Implementing the Rolling back changes with JGit

Step 1: Clone the Repository

git clonet remote-repo-path

Step 2: Create the Maven Project

Create the maven project using IntelliJ Idea. Once create the project then the file structure looks like the below image.

Step 3: Add the JGit Dependency

Open the pom.xml and add the below JGit dependency into the project.

 <!-- 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>

Step 4: Create the JGitRollback Class

package com.auxentios;



import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.ResetCommand;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.storage.file.FileRepositoryBuilder;

import java.io.File;
import java.io.IOException;

public class JGitRollback {
    public static void main(String[] args) {
        FileRepositoryBuilder builder = new FileRepositoryBuilder();
        try (Repository repository = builder.setGitDir(new File("C:/Users/Mahesh/Desktop/E-Commerce-Backend-Spring-Microservices/.git"))
                .readEnvironment()
                .findGitDir()
                .build()) {

            try (Git git = new Git(repository)) {
                // Perform a hard reset to the specified commit
                git.reset()
                        .setMode(ResetCommand.ResetType.HARD)
                        .setRef("a288504") // replace with your commit hash
                        .call();
                System.out.println("Reset to commit: a288504");
            } catch (GitAPIException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Pom.xml

<?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>com.auxentios</groupId>
    <artifactId>jgit-rollback</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

It will show the below output. It will print the commit hash code of specified repository.

By the following these steps. we should be able to rollback changes from any Git repository using JGit.

Conclusion

Rolling back changes with JGit in the Maven Java project that can involves the initializing the repository, identifying the commit to reset and performing the reset or revert the operations.