Una guida a JGit

1. Introduzione

JGit è un'implementazione leggera e pura della libreria Java del sistema di controllo della versione Git, comprese le routine di accesso al repository, i protocolli di rete e gli algoritmi di controllo della versione principale.

JGit è un'implementazione relativamente completa di Git scritta in Java ed è ampiamente utilizzata nella comunità Java. Il progetto JGit è sotto l'ombrello di Eclipse e la sua sede può essere trovata su JGit.

In questo tutorial, spiegheremo come lavorarci.

2. Introduzione

Esistono diversi modi per connettere il tuo progetto a JGit e iniziare a scrivere codice. Probabilmente il modo più semplice è usare Maven: l'integrazione si ottiene aggiungendo il seguente frammento altag nel nostro file pom.xml :

 org.eclipse.jgit org.eclipse.jgit 4.6.0.201612231935-r 

Visita il repository Maven Central per la versione più recente di JGit. Una volta completato questo passaggio, Maven acquisirà e utilizzerà automaticamente le librerie JGit di cui avremo bisogno.

Se preferisci i bundle OSGi, c'è anche un repository p2. Visitare Eclipse JGit per ottenere le informazioni necessarie su come integrare questa libreria.

3. Creazione di un repository

JGit ha due livelli di base di API: idraulica e porcellana . La terminologia per questi viene da Git stesso. JGit è suddiviso nelle stesse aree:

  • API porcellana : front-end per azioni comuni a livello di utente (simile allo strumento da riga di comando Git)
  • API idrauliche : interazione diretta con oggetti di repository di basso livello

Il punto di partenza per la maggior parte delle sessioni JGit è nella classe Repository . La prima cosa che faremo è la creazione di una nuova istanza di repository .

Il comando init ci permetterà di creare un repository vuoto:

Git git = Git.init().setDirectory("/path/to/repo").call();

Questo creerà un repository con una directory di lavoro nella posizione data a setDirectory () .

Un repository esistente può essere clonato con il comando cloneRepository :

Git git = Git.cloneRepository() .setURI("//github.com/eclipse/jgit.git") .setDirectory("/path/to/repo") .call();

Il codice precedente clonerà il repository JGit nella directory locale denominata path / to / repo .

4. Oggetti Git

Tutti gli oggetti sono rappresentati da un ID SHA-1 nel modello a oggetti Git. In JGit, questo è rappresentato dalle classi AnyObjectId e ObjectId .

Esistono quattro tipi di oggetti nel modello a oggetti Git:

  • blob : utilizzato per archiviare i dati dei file
  • albero : una directory; fa riferimento ad altri alberi e blob
  • commit : punta a un singolo albero
  • tag : contrassegna un commit come speciale; generalmente utilizzato per contrassegnare rilasci specifici

Per risolvere un oggetto da un repository, è sufficiente passare la revisione corretta come nella seguente funzione:

ObjectId head = repository.resolve("HEAD");

4.1. Rif

Il Rif è una variabile che contiene un unico identificatore di oggetto. L'identificatore di oggetto può essere qualsiasi oggetto Git valido ( blob , albero , commit , tag ).

Ad esempio, per cercare il riferimento a head, puoi semplicemente chiamare:

Ref HEAD = repository.getRef("refs/heads/master");

4.2. RevWalk

Il RevWalk cammina un grafico impegnare e produce i commit corrispondenti in ordine:

RevWalk walk = new RevWalk(repository);

4.3. RevCommit

Il RevCommit rappresenta un commit nel modello a oggetti Git. Per analizzare un commit, utilizza un'istanza RevWalk :

RevWalk walk = new RevWalk(repository); RevCommit commit = walk.parseCommit(objectIdOfCommit);

4.4. RevTag

Il RevTag rappresenta un tag nel modello a oggetti Git. È possibile utilizzare un'istanza di RevWalk per analizzare un tag:

RevWalk walk = new RevWalk(repository); RevTag tag = walk.parseTag(objectIdOfTag);

4.5. RevTree

Il RevTree rappresenta un albero nel modello a oggetti Git. Un RevWalk istanza viene utilizzato anche per analizzare un albero:

RevWalk walk = new RevWalk(repository); RevTree tree = walk.parseTree(objectIdOfTree);

5. API in porcellana

Sebbene JGit contenga molto codice di basso livello per lavorare con i repository Git, contiene anche un'API di livello superiore che imita alcuni dei comandi Git porcellana nel pacchetto org.eclipse.jgit.api .

5.1. AddCommand ( git-add )

L' AddCommand ti consente di aggiungere file all'indice tramite:

  • addFilepattern ()

Ecco un rapido esempio di come aggiungere un set di file all'indice utilizzando l' API della porcellana :

Git git = new Git(db); AddCommand add = git.add(); add.addFilepattern("someDirectory").call();

5.2. CommitCommand ( git-commit )

Il CommitCommand consente di eseguire commit e ha le seguenti opzioni:

  • setAuthor ()
  • setCommitter ()
  • setAll ()

Ecco un rapido esempio di come impegnarsi utilizzando l' API porcellana :

Git git = new Git(db); CommitCommand commit = git.commit(); commit.setMessage("initial commit").call();

5.3. TagCommand ( git-tag )

Il TagCommand supporta una varietà di opzioni di codifica:

  • setName ()
  • setMessage ()
  • setTagger ()
  • setObjectId ()
  • setForceUpdate ()
  • setSigned ()

Ecco un rapido esempio di etichettatura di un commit utilizzando l' API porcellana :

Git git = new Git(db); RevCommit commit = git.commit().setMessage("initial commit").call(); RevTag tag = git.tag().setName("tag").call();

5.4. LogCommand ( git-log )

Il LogCommand ti consente di camminare facilmente su un grafico di commit.

  • aggiungi (AnyObjectId start)
  • addRange (AnyObjectId dal, AnyObjectId fino al)

Ecco un rapido esempio di come ottenere alcuni messaggi di registro:

Git git = new Git(db); Iterable log = git.log().call();

6. Attività delle formiche

JGit ha anche alcune attività Ant comuni contenute nel bundle org.eclipse.jgit.ant .

Per utilizzare queste attività:

Ciò fornirebbe le attività git-clone, git-init e git-checkout .

6.1. git-clone

Sono richiesti i seguenti attributi:

  • uri : l'URI da cui clonare

I seguenti attributi sono facoltativi:

  • dest : la destinazione in cui clonare (il valore predefinito utilizza un nome di directory leggibile dall'uomo basato sull'ultimo componente del percorso dell'URI )
  • nudo : vero / falso / / no per indicare se il repository clonato deve essere nudo o meno (il valore predefinito è falso )
  • ramo : il ramo iniziale da controllare durante la clonazione del repository (il valore predefinito è HEAD )

6.2. git-init

Non sono richiesti attributi per eseguire l'attività git-init .

I seguenti attributi sono facoltativi:

  • dest : il percorso in cui viene inizializzato un repository git (il valore predefinito è $ GIT_DIR o la directory corrente)
  • nudo : vero / falso / / no per indicare se il repository deve essere nudo o no (il valore predefinito è falso )

6.3. git-checkout

Sono richiesti i seguenti attributi:

  • src : il percorso del repository git
  • branch : il ramo iniziale da controllare

I seguenti attributi sono facoltativi:

  • createbranch : true / false / yes / no per indicare se il ramo deve essere creato se non esiste già (il valore predefinito è false )
  • forza : vero / falso / / no : se vero / e il ramo con il nome dato già esistente, l'avvio punto di un ramo esistente verrà impostato su un nuovo start-point; se false , il ramo esistente non verrà modificato (il valore predefinito è false )

7. Conclusione

L'API JGit di alto livello non è difficile da capire. Se sai quale comando git usare, puoi facilmente indovinare quali classi e metodi usare in JGit.

È disponibile una raccolta di frammenti di codice JGit pronti per l'esecuzione qui.

Se hai ancora difficoltà o domande, lascia un commento qui o chiedi assistenza alla comunità JGit.