Handling merge conflicts with JGit

Merge conflicts are a common issue in version control systems when changes from different branches collide. JGit is a Java implementation of Git and it can allow the developers to manage the Git repositories programmatically, including handling the merge conflicts. This article will guide you through setting up the Maven project with JGit and resolving the merge conflicts.

Prerequisites

• Basic knowledge of Java and Git.
• JDK and IntelliJ Idea installed in your local system.
• Maven for building dependency management.

Main Concept: Handling merge conflicts with JGit

JGit is the pure Java implementation of Git and providing APIs to perform most git operations programmatically. It can be particularly useful in scenarios where you need to integrate the Git functionality within the Java applications such as the automated build systems or custom version control systems.

Key Operations in Handling Merge Conflicts

1. Repository Initialization: Setting up the JGit repository to interact with the local Git repository.
2. Branch Checkout: Switching to the branch where you want to merge the conflicts.
3. Merge Operation: It can perform the merge operation and detect the conflicts.
4. Conflict Resolution: Identifying and handling the merge conflicts.

Implementing the Handling merge conflicts with JGit

Step 1: Initialize the Git Repository

We can create the git initialization of the repository.

git init

Make the Initial Commit on the main branch:

echo "Initial content" > file.txtgit 
add file.txt
git commit -m "Initial commit"

Create and Switch to the feature branch

git checkout -b feature-branch
echo "Conflicting line in feature-branch" > file.txtgit 
add file.txtgit commit -m "Commit on feature-branch"

Switch back to main branch and make the Conflicting Commit

git checkout mainecho "Conflicting line in main" > file.txtgit
 add file.txtgit commit -m "Conflicting commit on main"

Step 2: Create the New Maven Project

Create the new 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 file and add the JGit dependency into the proejct and re-run the maven for ultilizing the JGit functionalities.

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-manage-conflict</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>22</maven.compiler.source>
        <maven.compiler.target>22</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.10.0.202406032230-r</version>
        </dependency>
    </dependencies>

</project>

Step 4: Create the JGitMergeConflictHandler Class

package com.auxentios;

import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.MergeResult;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.RepositoryBuilder;

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

public class JGitMergeConflictHandler {

    private Repository repository;
    private Git git;

    public JGitMergeConflictHandler(String repoPath) throws IOException {
        File repoDir = new File(repoPath);
        this.repository = new RepositoryBuilder().setGitDir(new File(repoDir, ".git")).build();
        this.git = new Git(repository);
    }

    public void mergeBranches(String sourceBranch, String targetBranch) {
        try {
            // Ensure the target branch exists before checking it out
            if (repository.findRef(targetBranch) == null) {
                System.out.println("Target branch does not exist: " + targetBranch);
                return;
            }
            git.checkout().setName(targetBranch).call();

            // Ensure the source branch exists before attempting to merge
            if (repository.findRef(sourceBranch) == null) {
                System.out.println("Source branch does not exist: " + sourceBranch);
                return;
            }

            MergeResult mergeResult = git.merge().include(repository.findRef(sourceBranch)).call();

            switch (mergeResult.getMergeStatus()) {
                case CONFLICTING:
                    System.out.println("Merge conflicts detected:");
                    mergeResult.getConflicts().forEach((path, conflict) -> System.out.println("Conflict in: " + path));
                    break;
                case MERGED:
                    System.out.println("Merged successfully");
                    break;
                default:
                    System.out.println("Merge status: " + mergeResult.getMergeStatus());
            }
        } catch (GitAPIException | IOException e) {
            e.printStackTrace();
        }
    }

    public void close() {
        if (repository != null) {
            repository.close();
        }
    }

    public static void main(String[] args) {
        try {
            JGitMergeConflictHandler handler = new JGitMergeConflictHandler("C:/Users/Syam/OneDrive/Desktop/TestingFolder/manage-git/jgit-merge-repo");
            handler.mergeBranches("feature-branch", "main");
            handler.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Step 5: Run the application

Once complete the project then run the application. It will show the below output as result.

This example project can demonstrates to handling the merge conflicts with JGit of the java project.

Conclusion

This article demonstrated how to handle the merge conflicts using JGit in the Maven project. By the following these steps, we can programmatically manage the Git repositories and handle the conflicts within Java applications.