Introducción
El tema de esta revisión será el sistema de compilación automática Gradle. En inglés, los sistemas de compilación se llaman
Build Tools .
![Una introducción rápida a Gradle - 1]()
¿Por qué es esto necesario? La creación manual de proyectos en Java es un proceso bastante laborioso. Es necesario indicar correctamente las bibliotecas y frameworks que necesita el proyecto y de los que depende el proyecto. Aquí puedes leer un excelente artículo sobre Habré: “
Trabajar con Java en la línea de comandos ”. Tarde o temprano empezarás a crear algunos scripts para automatizar este proceso. Ahora imagina que todos los desarrolladores de todo el mundo hacen esto y todos escriben nuevamente lo que alguien ya escribió para su proyecto. Y luego aparecieron los sistemas de montaje de proyectos que automatizan este proceso. Además, por un lado, te permiten montar un proyecto como quieras, por otro lado, te proporcionan herramientas más o menos estandarizadas. Una alternativa a Gradle es el sistema de construcción automatizado Maven. Estos dos sistemas de montaje son, por un lado, diferentes, pero, por otro, tienen varias similitudes. Hay material sobre este tema en el sitio web de Gradle: "
Migración de Maven a Gradle ". Como se indica en este tutorial, Gradle y Maven tienen una perspectiva diferente sobre cómo construir un proyecto. Gradle se basa en un gráfico de tareas, que pueden depender unas de otras. Las tareas hacen algún tipo de trabajo. Maven utiliza un modelo de determinadas fases, a las que se adjuntan determinados "objetivos". Estos objetivos son donde se hace algo de trabajo. Sin embargo, con estos enfoques diferentes, ambos sistemas de compilación siguen la misma convención y la gestión de dependencias es similar. Para comenzar a usar Gradle necesitas descargarlo. En Google o Yandex ingresamos a “Gradle Build Tool” y en los primeros resultados vemos el sitio web oficial:
https://gradle.org . En la página principal de Gradle hay un enlace con el texto "Documentos", que conduce a la
documentación de Gradle . Primero, necesitamos instalar (Instalar) Gradle, por lo que nos interesa la sección "
Instalación de Gradle " de la documentación. Existen muchos métodos de instalación, incluido el método "anticuado", es decir. manualmente (“
Instalación manual ”). De acuerdo con las instrucciones, descargue un archivo del tipo "
solo binario ", que tendrá un nombre como gradle-5.1.1-bin.zip. A continuación, descomprima el archivo y configure la variable de entorno PATH de acuerdo con las instrucciones. Lo principal es que después de ejecutar las instrucciones, el comando
gradle -vmuestra la versión de Gradle instalado. Puede haber un problema de que al determinar la ubicación, el sistema encuentre que Gradle no está donde usted desea. Por lo tanto, en Windows puedes hacer (en *nix hay análogos):
for %i in (gradle.bat) do @echo. %~$PATH:i Ahora, tal vez, podamos empezar a familiarizarnos.
Inicializando un proyecto Gradle
Me gustaría señalar de inmediato que Gradle se trata de realizar tareas llamadas
tareas (las llamaré tareas). Las tareas las proporcionan varios
complementos . Le aconsejo que lea más sobre complementos en la documentación oficial: "
Uso de complementos de Gradle ". Hay un conjunto de "complementos principales" que siempre están disponibles cuando se instala Gradle. Hay diferentes categorías de estos complementos, pero a nosotros nos interesa la categoría "
Utilidad ". Este conjunto incluye el complemento "
Build Init Plugin ", que proporciona tareas para inicializar un proyecto Gradle. Estamos interesados en crear un tipo de proyecto: "
aplicación-java ". Ejecutemos la tarea de Gradle:
gradle init --type java-application respondamos algunas preguntas en el camino, por ejemplo, que queremos usar Groovy DSL (lenguaje de descripción de tareas estándar para Gradle) y el marco de prueba JUnit (hablaremos de esto en otra revisión). Después de la creación recibiremos el siguiente conjunto de archivos:
En primer lugar, después de la inicialización, recibimos un contenedor especial preconfigurado para nuestra versión de Gradle: este es un script especial. Le aconsejo que lea más sobre esto en la documentación oficial: "
The Gradle Wrapper ". En segundo lugar, vemos el script de compilación de Gradle: el archivo build.gradle. Este es el archivo principal, que describe qué bibliotecas y marcos utiliza nuestro proyecto, qué complementos deben conectarse al proyecto y describe varias tareas. Le aconsejo que lea más sobre este archivo en la documentación oficial: "
Conceptos básicos de compilación de scripts ".
Complementos y tareas
Si miramos ahora el contenido del Build Script, veremos la sección de complementos:
plugins {
id 'java'
id 'application'
}
Estos son los mismos complementos de los que hablamos antes. Y si hay complementos, entonces hay tareas que ahora están disponibles para nosotros. Podemos ejecutar el comando de tareas de Gradle y ver qué podemos hacer ahora con el proyecto:
Por ejemplo, al ejecutar
gradle runlanzaremos la clase principal de nuestra aplicación java:
Como podemos ver, lo mismo está escrito a continuación ¿
2 actionable tasks: 1 executed, 1 up-to-date Qué significa esto? Esto significa que se completaron un total de 2 tareas: además, 1 se completó realmente y la otra no se ejecutó porque... está al día, es decir, el estado es actual y no se ha hecho nada. Podemos ejecutar el llamado "Dry Run":
gradle run -m Ejecutemos este comando, veremos qué tareas se ejecutarán para ejecutar la tarea de ejecución:
Como podemos ver, se completaron un total de 4 tareas: antes de ejecutar ejecución, ejecutó las clases de tareas de dependencia. Las clases en sí tienen 2 dependencias y, por lo tanto, también ejecutaron compileJava y ProcessResources. Cuando realizamos una tarea, podemos realizarla mientras vemos un cierto nivel de registros (el nivel de registro determina qué tan importantes queremos ver los mensajes). Por ejemplo, podemos hacer
gradle run -i. Esto también nos mostrará mensajes informativos como:
Task :classes UP-TO-DATE
Skipping task ':classes' as it has no actions.
Para obtener más información sobre cómo iniciar sesión en Gradle, le recomiendo que consulte la documentación oficial: "
Gradle Logging ". Como podemos ver, la tarea de clases se omitió porque está
ACTUALIZADA , es decir, el estado es actual, no hay que hacer nada, por lo que no hubo acciones. Esto se debe a que, de forma predeterminada, Gradle tiene "
verificaciones de actualización " o la llamada compilación incremental. Puede leer más sobre este mecanismo en la documentación de Gradle: "
Comprobaciones actualizadas (también conocido como compilación incremental) ". Pero este mecanismo se puede desactivar ejecutando una tarea que especifique el indicador --rerun-tasks. Por ejemplo,
gradle run --rerun-tasks. Luego veremos:
2 tareas procesables: 2 ejecutadas Como puede ver, el número de tareas ejecutadas tiene en cuenta solo el primer nivel del gráfico, es decir, la tarea ejecutada en sí y aquellas tareas de las que depende directamente, es decir , clases. Las tareas de las que dependen las clases no se cuentan aquí (aunque se ejecutan cuando se ejecuta la tarea de clases). También deberías leer sobre las tareas:
Dependencias
Una de las principales tareas de cualquier sistema de compilación es gestionar las dependencias, es decir, qué bibliotecas/frameworks necesita nuestro proyecto. El sistema de compilación debe garantizar que estén disponibles en el momento adecuado y ensamblar el artefacto final de nuestra aplicación de la manera correcta. De forma predeterminada, después de gradle init para la aplicación java, veremos el siguiente contenido en el script de compilación:
dependencies {
implementation 'com.google.guava:guava:26.0-jre'
testImplementation 'junit:junit:4.12'
}
Aquí queda inmediatamente claro lo que estamos conectando. Pero sin un poco de comprensión, no está claro qué son la implementación y la implementación de pruebas. Aquí debemos volver a la documentación de Gradle, ya que está bien escrita. Se llama "
Gestión de configuraciones de dependencia ". Como se indica en la documentación, cada dependencia se declara con un alcance determinado: el área dentro de la cual estará disponible esta dependencia. Este ámbito está designado por alguna configuración, cada una de las cuales tiene un nombre único. También es interesante que muchos complementos de Gradle agregan configuraciones predefinidas. Para saber qué configuraciones tenemos podemos ejecutar:
gradle --console plain dependencies De esta forma veremos una lista de todas las configuraciones disponibles y sus dependencias. Podemos filtrar esta lista para que veamos solo las configuraciones disponibles: ¿
gradle --console plain dependencies | find " - " Cómo sabemos qué usar? Tendrás que leer un poco aquí. Porque Usamos el complemento "Java", así que comencemos con su documentación y la sección "
Gestión de dependencias ". Aquí vemos que solía haber una configuración (también conocida como alcance) llamada "compilar" y significaba "dependencia necesaria durante la compilación". Pero luego fue reemplazado (en inglés Superseded) por implementación. Puede leer más sobre el reemplazo en la sección "
Separación de API e implementación ". Resulta que esta dependencia estará en el "classpath de compilación". Pero a veces queremos que nuestra dependencia se incluya en el artefacto final. ¿Para qué? Por ejemplo, tendremos un jar ejecutable, que a su vez debería contener todo lo necesario. ¿Qué debemos hacer entonces? En primer lugar, no existe dicho soporte "listo para usar" (es decir, de forma predeterminada, sin ninguna acción adicional). Esto se explica por el hecho de que cada uno quiere recopilar el archivo a su manera y Gradle intenta ser minimalista. Tampoco podemos usar archivos jar en el classpath (sin manipulaciones adicionales en el código), porque no funciona de esa manera (consulte "
Oracle: Agregar clases al Classpath del archivo JAR " para obtener más detalles). Por lo tanto, la forma más hermosa es el siguiente código en el script de compilación:
jar {
manifest {
attributes 'Main-Class': 'jrgradle.App'
}
from configurations.compileClasspath.collect { it.isDirectory() ? it : zipTree(it) }
}
En la configuración de la tarea jar especificamos lo que se agregará al manifiesto del archivo jar (consulte "
Oracle: Configuración del punto de entrada de una aplicación "). Y luego decimos que todas las dependencias necesarias para la compilación se incluirán en el jar. Una alternativa es utilizar el "
Gradle Shadow Plugin ". Puede parecer complicado, pero otros complementos pueden hacer la vida más fácil. Por ejemplo, al crear una aplicación web (a diferencia de una aplicación Java que se ejecuta normalmente), usaremos un complemento especial: "
Gradle War Plugin ", que tiene un comportamiento diferente y nuestra vida será más fácil allí (todas las dependencias necesarias El propio complemento debe colocarlo en un directorio especial separado. Dicho trabajo está regulado por cómo se deben estructurar las aplicaciones web. Pero esa es una historia completamente diferente).
Resultados
Gradle es una excelente opción para sistemas de construcción de proyectos. Esto lo confirma el hecho de que lo utilizan desarrolladores de proyectos tan conocidos como Spring e Hibernate. Sólo las cosas más básicas se discutieron anteriormente. Detrás de ellos se esconden un millón de características y oportunidades que se les aparecen a los desarrolladores. Gradle también admite la creación de proyectos de múltiples módulos, lo cual no se trata en esta revisión, pero el propio Gradle tiene un excelente tutorial: "
Creación de compilaciones de múltiples proyectos ". Espero que esta revisión también demuestre que la documentación de Gradle está escrita en 5+ y que puedes encontrar fácilmente lo que necesitas si sabes dónde buscar. Y esto llegará cuando comprendas los conceptos básicos. Además, Gradle tiene excelentes tutoriales. Me gustaría terminar con una pequeña lista de qué más puedes ver usando Gradle:
#viacheslav
GO TO FULL VERSION