Librería JGit - Cómo utilizar Git desde Java

Consigue gratis tu cuenta

Curso de Java

Java es uno de los lenguajes de programación más utilizados y que más oferta laboral tiene. Sirve para hacer aplicaciones móviles, páginas web y muchas cosas más. ¿Quieres aprender? ¡Apúntate!

Comenzar ahora

jgit¡Hola! En este tutorial os voy a enseñar una librería que estoy utilizando en un proyecto (UMHDL) para controlar Git desde Java. Con JGit podremos crear nuestro propio programa en Java para controlar repositorios.

¿Qué es JGit?

JGit es una librería open-source bajo licencia EDL (Eclipse Distribution License) que implementa el sistema de control de versiones Git en Java. Se recomienda utilizar esta librería con un JDK mayor que la versión 6 (recientemente salió la versión 8), así que no habrá problema.

Además, para poder utilizar esta librería, necesitaremos otra, llamada JSCH.

¿Qué es JSCH?

JSCH (Java Secure Channel) es una librería que implementa SSH2 en Java. Es, igual que JGit, open-source y la utilizaremos para transferir los datos desde nuestro ordenador al repositorio remoto (GitHub, BitBucket...). Su uso para nosotros es transparente, ya que no tendremos que programar nada con ella. La utiliza JGit internamente.

PASOS A SEGUIR

PASO 1

Descargar las librerías:

  • JGit: descargamos el .jar (Raw API library).
  • JSCH.

PASO 2

Crearé un proyecto llamado GitControl que  utilizará ambas librerías. Tendrá dos clases: - Clase GitControl: aquí estarán definidos los métodos principales. Estos métodos serán:
  • GitControl: constructor de la clase. Con él inicializamos los parámetros necesarios.
  • cloneRepo: lo utilizaremos para clonar un repositorio desde una URL.
  • addToRepo: con él añadimos los archivos cambiados.
  • commitToRepo: con él haremos commit de lo añadido.
  • pushToRepo: lo utilizaremos para hacer push.
  • pullFromRepo: lo utilizaremos para hacer pull.
 - Clase Test: esta clase tendrá el método main, que utilizaremos para probar las funciones creadas anteriormente.

PASO 3

En este paso os voy a enseñar el código de la clase GitControl y también de la clase Test. No voy a entrar en muchos detalles porque está bastante claro. Al final es utilizar Git en Java.
package gitcontrol;

import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import org.eclipse.jgit.api.AddCommand;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.PushCommand;
import org.eclipse.jgit.api.errors.CanceledException;
import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;
import org.eclipse.jgit.api.errors.DetachedHeadException;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.InvalidConfigurationException;
import org.eclipse.jgit.api.errors.InvalidRemoteException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.api.errors.NoFilepatternException;
import org.eclipse.jgit.api.errors.NoHeadException;
import org.eclipse.jgit.api.errors.NoMessageException;
import org.eclipse.jgit.api.errors.RefNotFoundException;
import org.eclipse.jgit.api.errors.WrongRepositoryStateException;
import org.eclipse.jgit.internal.storage.file.FileRepository;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.transport.CredentialsProvider;
import org.eclipse.jgit.transport.PushResult;
import org.eclipse.jgit.transport.UsernamePasswordCredentialsProvider;

/**
 *
 * @author Mario Pérez Esteso
 *
 */
public class GitControl {

    private String localPath, remotePath;
    private Repository localRepo;
    private Git git;
    private CredentialsProvider cp;
    private String name = "username";
    private String password = "password";

    public GitControl(String localPath, String remotePath) throws IOException {
        this.localPath = localPath;
        this.remotePath = remotePath;
        this.localRepo = new FileRepository(localPath + "/.git");
        cp = new UsernamePasswordCredentialsProvider(this.name, this.password);
        git = new Git(localRepo);
    }

    public void cloneRepo() throws IOException, NoFilepatternException, GitAPIException {
        Git.cloneRepository()
                .setURI(remotePath)
                .setDirectory(new File(localPath))
                .call();
    }

    public void addToRepo() throws IOException, NoFilepatternException, GitAPIException {
        AddCommand add = git.add();
        add.addFilepattern(".").call();
    }

    public void commitToRepo(String message) throws IOException, NoHeadException,
            NoMessageException, ConcurrentRefUpdateException,
            JGitInternalException, WrongRepositoryStateException, GitAPIException {
        git.commit().setMessage(message).call();
    }

    public void pushToRepo() throws IOException, JGitInternalException,
            InvalidRemoteException, GitAPIException {
        PushCommand pc = git.push();
        pc.setCredentialsProvider(cp)
                .setForce(true)
                .setPushAll();
        try {
            Iterator<PushResult> it = pc.call().iterator();
            if (it.hasNext()) {
                System.out.println(it.next().toString());
            }
        } catch (InvalidRemoteException e) {
            e.printStackTrace();
        }
    }

    public void pullFromRepo() throws IOException, WrongRepositoryStateException,
            InvalidConfigurationException, DetachedHeadException,
            InvalidRemoteException, CanceledException, RefNotFoundException,
            NoHeadException, GitAPIException {
        git.pull().call();
    }

}
Veremos ahora la clase Test.java:
package gitcontrol;

import java.io.IOException;
import org.eclipse.jgit.api.errors.GitAPIException;

/**
 *
 * @author Mario Pérez Esteso
 *
 */

public class Test {
    
    public static void main(String[] args) throws IOException, GitAPIException {
        String localPath = "/home/user/repos/gittutorial";
        String remotePath = "https://github.com/GeekyTheory/GitTutorial.git";
        GitControl gc = new GitControl(localPath, remotePath);
        //Clone repository
        gc.cloneRepo();
        //Add files to repository
        gc.addToRepo();
        //Commit with a custom message
        gc.commitToRepo("Modified testfile.txt");
        //Push commits
        gc.pushToRepo();
        //Pull
        gc.pullFromRepo();
    }
    
}

Como véis en el método main, tenemos la ruta de nuestro ordenador donde vamos a crear el repositorio y también la URL de nuestro repositorio, en este caso en GitHub. Creamos un objeto de la clase GitControl y luego llamamos a los diferentes métodos de esa clase. Lo lógico sería primero llamar a cloneRepo y cuando hayamos trabajado con el código de ese repositorio, haremos lo demás. En caso de que queramos hacer un pull, llamamos a pullFromRepo.

Esto es todo por este tutorial. Espero que os sea de utilidad para vuestros proyectos en Java.

Si queréis descargar el código, está alojado en GitHub:

github-profile

¡Un saludo!


¿Quieres seguir aprendiendo?