Construir y probar Java con Maven

Introducción

Esta guía te muestra cómo crear un flujo de trabajo que realiza la integración continua (CI) para tu proyecto Java utilizando la herramienta de gestión de proyectos de software Maven. El flujo de trabajo que creas te permitirá ver cuándo las confirmaciones de una solicitud de extracción causan la construcción o las fallas de prueba en tu rama por defecto; este enfoque puede ayudar a garantizar que tu código siempre sea correcto. Puedes extender tu flujo de trabajo de CI para almacenar en caché los archivos y cargar artefactos desde una ejecución de flujo de trabajo.

Los ejecutores alojados en GitHub tienen una caché de herramientas con un software preinstalado, que incluye kits de desarrollo de Java (JDK) y Maven. Para encontrar una lista de software y de las versiones pre-instaladas de JDK y de Maven, consulta la sección "Especificaciones para los ejecutores hospedados en GitHub".

Prerrequisitos

Deberías estar familiarizado con YAML y la sintaxis para las GitHub Actions. Para obtener más información, consulta:

• "Sintaxis de flujo de trabajo para las GitHub Actions"
• "Aprende sobre las GitHub Actions"

Te recomendamos que tengas una comprensión básica de Java y del marco de Maven. Para obtener más información, consulta el Guía de introducción a Maven en la documentación de Maven.

Utilizar ejecutores auto-hospedados en GitHub Enterprise Server

Cuando utilices acciones de configuración, (tales como actions/setup-LANGUAGE) en GitHub Enterprise Server con ejecutores auto-hospedados, tal vez necesites configurar el caché de las herramientas en los ejecutores que no tienen acceso a internet. Para obtener más información, consulta la sección " Configurar el caché de herramientas en ejecutores auto-hospedados sin acceso a internet".

Utilizar el flujo de trabajo inicial de Maven

GitHub proporciona un flujo de trabajo inicial de Maven que funcionará para la mayoría de los proyectos Java basados en Maven. Para obtener más información, consulta el Fluje de trabajo inicial de Maven.

Para iniciar rápidamente, puedes elegir el flujo de trabajo inicial de Maven preconfigurado cuando crees un flujo de trabajo nuevo. Para obtener más información, consulta la "guía rápida de GitHub Actions".

También puedes agregar este flujo de trabajo de forma manual al crear un archivo nuevo en el directorio de tu repositorio .github/workflows.

name: Java CI

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v2
      - name: Set up JDK 11
        uses: actions/setup-java@v2
        with:
          java-version: '11'
          distribution: 'adopt'
      - name: Build with Maven
        run: mvn --batch-mode --update-snapshots verify

Este flujo de trabajo realiza los siguientes pasos:

1. El paso checkout (comprobación) descarga una copia de tu repositorio en el ejecutor.
2. El paso setup-java configura el JDK de Java 11 por Adoptium.
3. El paso "Build with Maven" (Construir con Maven) ejecuta el paquete destino de Maven en modo no interactivo para garantizar que tu código se compile, se superen las pruebas y se pueda crear un paquete.

Los flujos de trabajo iniciales predeterminados son un punto de partida excelente para crear tu flujo de trabajo de prueba y de compilación y puedes personalizarlos de acuerdo con las necesidades de tu proyecto.

Ejecución en un sistema operativo diferente

El flujo de trabajo inicial configura los jobs para que se ejecuten en Linux, utilizando los ejecutores ubuntu-latest hospedados en GitHub. Puedes cambiar la clave runs-on para ejecutar tus jobs en un sistema operativo diferente. Por ejemplo, puedes utilizar los ejecutores de Windows hospedados en GitHub.

runs-on: windows-latest

O puedes utilizar los ejecutores de macOS hospedados en GitHub.

runs-on: macos-latest

También puedes ejecutar jobs en contenedores de Docker, o puedes proporcionar un ejecutor auto-hospedado que se ejecute en tu propia infraestructura. Para obtener más información, consulta "Sintaxis de flujo de trabajo para GitHub Actions".

Especificar la versión y arquitectura de JVM

El flujo de trabajo inicial configura el PATH para contener el OpenJDK 8 para la plataforma x64. Si quieres utilizar una versión diferente de Java, o enfocarte en una arquitectura diferente (x64 o x86), puedes utilizar la acción setup-java para elegir un ambiente de ejecución de Java diferente.

Por ejemplo, para utilizar la versión 11 de JDK que se proporciona con Adoptium para la plataforma x64, puedes utilizar la acción setup-java y configurar los parámetros java-version, distribution y architecture en '11', 'adopt' y x64.

steps:
  - uses: actions/checkout@v2
  - name: Set up JDK 11 for x64
    uses: actions/setup-java@v2
    with:
      java-version: '11'
      distribution: 'adopt'
      architecture: x64

Para obtener más información, consulta la acción setup-java.

Construir y probar tu código

Puedes usar los mismos comandos que usas de forma local para construir y probar tu código.

El flujo de trabajo de inicio ejecutará el paquete destino por defecto. En la configuración predeterminada de Maven, este comando descargará dependencias, construirá clases, ejecutar pruebas y las clases de paquetes en su formato distribuible, por ejemplo, un archivo JAR.

Si usas diferentes comandos para compilar tu proyecto, o si quieres usar un destino diferente, puedes especificarlos. Por ejemplo, es posible que desees ejecutar el objetivo verify (verificar) que está configurado en un archivo pom-ci.xml.

steps:
  - uses: actions/checkout@v2
  - uses: actions/setup-java@v2
    with:
      java-version: '11'
      distribution: 'adopt'
  - name: Run the Maven verify phase
    run: mvn --batch-mode --update-snapshots verify

Almacenar dependencias en caché

Cuando utilizas ejecutores hospedados en GitHub, puedes guardar tus dependencias en el caché para acelerar tus ejecuciones de flujo de trabajo. Después de una ejecución exitosa, tu repositorio Maven local se almacenará en la infraestructura de acciones de GitHub. En las ejecuciones de flujo de trabajo futuras, el caché se restaurará para que las dependencias no necesiten descargarse desde los repositorios remotos de Maven. Puedes guardar las dependencias en caché utilizando simplemente la acción setup-java o puedes utilizar la Acción cache para tener una configuración personalizada y más avanzada.

steps:
  - uses: actions/checkout@v2
  - name: Set up JDK 11
    uses: actions/setup-java@v2
    with:
      java-version: '11'
      distribution: 'adopt'
      cache: maven
  - name: Build with Maven
    run: mvn --batch-mode --update-snapshots verify

Este flujo de trabajo guardará los contenidos de tu repositorio local de Maven, ubicado en el directorio .m2 del directorio de inicio del ejecutor. La clave de caché será el contenido con hash de pom.xml, por lo que los cambios en pom.xml invalidará el caché.

Empaquetar datos de flujo de trabajo como artefactos

Una vez que tu compilación haya tenido éxito y tus pruebas hayan pasado, es posible que desees cargar los paquetes Java resultantes como un artefacto de construcción. Esto almacenará los paquetes construidos como parte de la ejecución del flujo de trabajo y te permitirá descargarlos. Los artefactos pueden ayudarte a probar y depurar solicitudes de extracción en tu entorno local antes de que se fusionen. Para obtener más información, consulta "Conservar datos de flujo de trabajo mediante artefactos."

Por lo general, Maven creará archivos de salida como tarros, orejas o guerras en el Objetivo Directorio. Para cargarlos como artefactos, puedes copiarlos en un nuevo directorio que contenga artefactos para cargar. Por ejemplo, puedes crear un directorio llamado staging (preparación). Luego puedes cargar los contenidos de ese directorio usando la acción upload-artifact (cargar artefacto).

steps:
  - uses: actions/checkout@v2
  - uses: actions/setup-java@v2
    with:
      java-version: '11'
      distribution: 'adopt'
  - run: mvn --batch-mode --update-snapshots verify
  - run: mkdir staging && cp target/*.jar staging
  - uses: actions/upload-artifact@v2
    with:
      name: Package
      path: staging