Instalación de Git en el ordenador
Instala Git a través de la terminal:
sudo apt install git
Configura tu nombre de usuario y correo electrónico para Git, utiliza el mismo que para tu cuenta de GitHub:
git config --global user.name "Tu Nombre"
git config --global user.email "[email protected]"
Creación de un repositorio local
Crea un directorio llamado ProyectoJava y abre una terminal en dicha carpeta.
Inicializa un nuevo repositorio de Git en este directorio:
git init
Cambia el nombre de la rama principal a “main”:
git branch -m main
Verifica que el repositorio ha sido creado correctamente
git status
Desarrollo de un proyecto en Java
Crea un archivo llamado HolaMundo.java.
Escribe un programa básico en Java que muestre por pantalla el mensaje "Hola mundo" y guárdalo en HolaMundo.java:
public class HolaMundo {
public static void main(String[] args) {
System.out.println("Hola mundo");
}
}
Ejecución del primer commit
Si ejecutamos otra vez git status, veremos el fichero HolaMundo.java no se encuentra en seguimiento, es decir, no se tendrá en cuenta para el control de versiones.
Añade el archivo HolaMundo.java al área de preparación (stagin area) para controlar sus versiones:
git add HolaMundo.java
Realiza un commit para guardar este cambio en el historial del repositorio:
git commit -m "Comienza el proyecto"
Seguimiento de los commits
Observa el historial de commits:
git log
Vamos a crear un comando que nos permita observar los commits con más información.
Dentro de la carpeta oculta .git que se ha creado en el directorio del proyecto, abre el fichero config e inlcuye lo siguiente:
[alias]
tree = log --oneline --graph --decorate --all
Ahora puedes ejecutar el comando git tree, el cual se ha definido como un alias que en realidad ejecuta git log con todas las opciones descritas arriba:
git tree
Este comando nos indica que existe un commit (con el símbolo *), y que nuestro proyecto está como cuando hicimos el commit (con la palabra HEAD). Además, ese es el último commit de la rama main.
Ahora mismo nos encontramos aquí, siendo la flecha el HEAD y el círculo el commit:
Creación y configuración del archivo .gitignore
Sitúate en la carpeta del proyecto y comila el programa HolaMundo.java para crear el fichero HolaMundo.class:
javac HolaMundo.java
Ejecuta git status. Verás que indica que el fichero HolaMundo.class no se encuentra en seguimiento. No interesa controlar las versiones de este tipo de archivos, pues siempre se pueden compilar a raíz del codigo fuente, que es el que sí nos interesa controlar con git. Por lo tanto, vamos a indicarle a git que ignore cualquier fichero CLASS del proyecto.
Crea un archivo .gitignore en la carpeta del proyecto y escribe lo siguiente:
# Ignorar los archivos de compilación
*.class
Si ejecutas de nuevo un git status, podrás ver que el propio fichero .gitignore no está en seguimiento. Por si moficiamos este fichero más adelante, sí es interesante controlar su versión, por lo que vamos a añadir toda la carpeta del proyecto y guardaremos un commit (aunque añadamos toda la carpeta al seguimiento, ignorará el fichero CLASS).
git add .
git commit -m "Añade archivo .gitignore"
Nos encontramos aquí:
Modificación del proyecto y volver a un commit anterior
Modifica el programa HolaMundo.java para que muestre por pantalla un mensaje con tu nombre:
public class HolaMundo {
public static void main(String[] args) {
System.out.println("Hola mundo");
System.out.println("Eres tuNombre");
}
}
Realiza un commit para guardar el cambio:
git add .
git commit -m "Añado un mensaje con mi nombre"
Comprueba los commits realizados y fíjate en los identificadores de cada commit:
git tree
Ahora estamos aquí:
Regresa al commit anterior utilizando su identificador:
git switch idDelCommitAnterior
Comprueba el fichero HolaMundo.java para descubrir si se han deshecho los cambios.
Vuelve a comprobar el log de commits con git tree y observa dónde te encuentras. Ahora nos situaríamos aquí:
Si hiciéramos otro commit ahora, se crearía automáticamente en otra rama nueva para no perder el último commit realizado, pero vamos a crear una rama manualmente.
Crear una nueva rama para añadir una nueva funcionalidad
Vamos a crear una rama nueva que simule que vamos a añadir una nueva funcionalidad pero queremos hacerlo en un espacio aparte para no afectar a la rama principal.
Crea una rama nueva llamada feature-suma:
git branch feature-suma
Muévete a la nueva rama:
git switch feature-suma
Modifica el archivo HolaMundo.java para que realice la suma de dos números enteros e imprima el resultado, observa cómo no está el comando que muestra tu nombre porque estábamos situados en un commit donde no lo habíamos añadido:
public class HolaMundo {
public static void main(String[] args) {
int num1 = 5, num2 = 3;
System.out.println("Hola mundo");
System.out.println("La suma de los números es " + (num1+num2));
}
}
Añade la carpeta del proyecto y realiza un commit de los cambios:
git add .
git commit -m "Añade la suma de dos números"
Ejecuta un git-tree y observa como se visualiza la rama main marcando su último commit, y la nueva rama en la que nos situamos ahora mismo. Estamos aquí:
Fusionar la rama feature-suma con la rama principal
Una vez terminada de implementar la nueva característica, podemos fusionar las ramas para continuar por un único camino.
Cambia a la rama principal, esto nos moverá al último commit de la rama main, es decir, aquel que mostraba tu nombre:
git switch main
Fusiona los cambios de feature-suma en main:
git merge feature-suma
Git nos avisará de que existe un conflicto entre las ramas, pues en una rama teníamos una línea que mostraba tu nombre y la rama feature-suma la creamos cuando esto no estaba aún implementado.
Corrige los conflictos abriendo el fichero HolaMundo.java y decidiendo cómo quieres la versión final del programa. Podemos dejarla así:
public class HolaMundo {
public static void main(String[] args) {
int num1 = 5, num2 = 3;
System.out.println("Hola mundo");
System.out.println("La suma de los números es " + (num1+num2);
}
}
Haz un nuevo commit confirmando los cambios:
git add .
git commit -m "Fusión de las ramas"
Ejecuta un git tree para visualizar esta fusión. Ahora volvemos a trabajar sobre la rama principal con los cambios introducidos en la rama feature-suma. Nuestro Git se vería así:
Ejercicio: fusionar rama sin conflicto
Vamos a crear una rama nueva en la que los cambios sean simplemente que se añade un segundo fichero al proyecto, así evitaremos que surjan conflictos con la rama principal. Realiza por tu cuenta estos pasos:
- Crea una nueva rama llamada
Programa2y crea un fichero nuevo llamadoSegundoPrograma.java. - Completa el programa
SegundoPrograma.javacon un nuevo mensaje a mostrar por pantalla. - Añade el fichero al staging area y guarda los cambios con un
commit. - Dirígete a la rama
mainy fusiona la ramaPrograma2. Ahora no deberían aparecer conflictos. - Verifica la fusión con un
git tree.