Construir y probar Java con Gradle

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 usando el sistema de construcción Gradle. 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 GitHub tienen una caché de herramientas con software preinstalado, que incluye kits de desarrollo de Java (JDK) y Gradle. Para encontrar una lista de software y de las versiones pre-instaladas de JDK y de Gradle, 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 Gradle. Para obtener más información, consulta Empezar en la documentación de Gradle.

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".

Comenzar con una plantilla de flujo de trabajo de Gradle

GitHub proporciona una plantilla de flujo de trabajo de Gradle que funcionará para la mayoría de los proyectos Java basados en Gradle. Para obtener más información, consulta la Plantilla de flujo de trabajo de Gradle.

Para comenzar rápidamente, puedes elegir la plantilla de Gradle preconfigurada cuando creas un nuevo flujo de trabajo. 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.

# This workflow uses actions that are not certified by GitHub.
# Estas las proporcionan entidades terceras y las gobiernan
# condiciones de servicio, políticas de privacidad y documentación de soporte
# documentación.

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: Validate Gradle wrapper
        uses: gradle/wrapper-validation-action@e6e38bacfdf1a337459f332974bb2327a31aaf4b
      - name: Build with Gradle
        run: ./gradlew build

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 de "Validar el wrapper de Gradle" valida la sumas de verificaciones de los archivos JAR del wrapper de Gradle que estén presentes en el árbol fuente.
4. El paso "Build with Gradle" (construir con Gradle) ejecuta el script contenedor gradlew para asegurar que tu código se cree, las pruebas pasen y se pueda crear un paquete.

Las plantillas de flujo de trabajo predeterminadas son excelentes puntos de inicio cuando creas tu flujo de trabajo de construcción y prueba, y puedes personalizar la plantilla para adaptarla a las necesidades de tu proyecto.

Ejecución en un sistema operativo diferente

La plantilla inicial de flujo de trabajo 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

La plantilla inicial de flujo de trabajo configura el PATH para que contenga OpenJDK 8 para las plataformas 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á la tarea build por defecto. En la configuración de Gradle predeterminada, este comando descargará las dependencias, construirá clases, ejecutará pruebas y empaquetará las clases en su formato distribuible, por ejemplo, un archivo JAR.

Si usas diferentes comandos para construir tu proyecto, o si quieres usar una tarea diferente, puedes especificarlo. Por ejemplo, es posible que desees ejecutar la tarea package que está configurada en tu archivo ci.gradle.

steps:
  - uses: actions/checkout@v2
  - uses: actions/setup-java@v2
    with:
      java-version: '11'
      distribution: 'adopt'
  - name: Validate Gradle wrapper
    uses: gradle/wrapper-validation-action@e6e38bacfdf1a337459f332974bb2327a31aaf4b
  - name: Run the Gradle package task
    run: ./gradlew -b ci.gradle package

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 caché de paquete de Gradle local se almacenará en la infraestructura de acciones de GitHub. En las ejecuciones de flujo de trabajo futuras, la caché se restaurará para que las dependencias no necesiten ser descargadas desde los repositorios de paquetes remotos. 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: gradle
  - name: Validate Gradle wrapper
    uses: gradle/wrapper-validation-action@e6e38bacfdf1a337459f332974bb2327a31aaf4b
  - name: Build with Gradle
    run: ./gradlew build
  - name: Cleanup Gradle Cache
    # Remove some files from the Gradle cache, so they aren't cached by GitHub Actions.
    # Restoring these files from a GitHub Actions cache might cause problems for future builds.
    run: |
      rm -f ~/.gradle/caches/modules-2/modules-2.lock
      rm -f ~/.gradle/caches/modules-2/gc.properties

Este flujo de trabajo guardará el contenido del caché de tu paquete local de Gradle, el cual se ubica en los directorios .gradle/caches y .gradle/wrapper dek directorio de inicio del ejecutor. La clave del caché será el contenido cifrado de los archivos de compilación de gradle (incluyendo las propiedades del archivo de envoltorio (wrapper)), así que cualquier cambio que se realice sobre ellos 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, Gradle creará archivos de salida como JAR, EAR o WAR en el directorio build/libs. Puedes cargar los contenidos de ese directorio utilizando la acción upload-Artifact.

steps:
  - uses: actions/checkout@v2
  - uses: actions/setup-java@v2
    with:
      java-version: '11'
      distribution: 'adopt'
  - name: Validate Gradle wrapper
    uses: gradle/wrapper-validation-action@e6e38bacfdf1a337459f332974bb2327a31aaf4b
  - run: ./gradlew build
  - uses: actions/upload-artifact@v2
    with:
      name: Package
      path: build/libs