¿Ya haz escuchado de Gradle? si haz creado o intentado crear un aplicacion en Android de seguro que sí, y es probable que te dé dolores de cabeza, que no quieras ni tocarlo. Si es así, entonces lo mejor es entenderlo, comprenderlo, asimilarlo. Es por eso que te traemos este artículo para que domines al mamut! (Elefante).
Contenido.
Introducción.
¿Qué es Gradle?
Instalación.
Primeros pasos con Gradle.
Creando nuestro primer proyecto Java.
Otro proyecto Java con Gradle.
Introducción.
Desde la clásica herramienta ‘make’ de los años 70, la tecnología de los sistema de construcción de proyectos ha ido mejorando día a día. En donde algunos están enfocados a ciertos aspectos de la construcción, otros tratan de abarcar la plenitud de los procesos de construcción de proyecto: compilación, manejo de dependencias, integración continua, automatización del proceso de construcción, etc., entre los cuales tenemos a Ant, Maven y Gradle.
¿Qué es Gradle?
Gradle es la nueva generación de herramientas de construcción automatizadas de proyectos, diseñado para superar las limitaciones de Maven. Gradle es software libre diseñado para construcciones multi-proyecto los cuales pueden pueden llegar a ser caóticos. Gradle basa la construcción de proyectos en algunos conceptos de Apache Ant y Apache Maven, cambiando la configuración de forma XML, a un lenguaje específico de dominio (Kotlin DSL). También utiliza un grafo acíclico dirigido (DAG) para determinar la secuencia en que se construirá el proyecto. Ver mas en Wikipedia
¿Qué es un lenguaje específico de dominio (DSL)?
Es un lenguaje de programación que provee una técnica para resolver un problema en específico (¿Quieres saber más?) . En el caso de Gradle utiliza sentencias de Groovy y Kotlin para la construcción de proyectos de software.
¿Qué es un grafo acíclico dirigido (DAG)?
Es un grafo que no sigue una secuencia lineal: no se sigue un camino directo o orden secuencial. ¿Quieres saber mas?.
Algunas características
- Depuración colaborativa: Permite compartir los resultados de la compilación para resolver en equipo de forma eficiente posibles problemas que aparezcan.
- Construcción incremental: Valida en el proceso de compilación si la entrada, salida o implementación de una tarea ha cambiado. En caso de no existir algún cambio la considera actualizada y no se ejecuta.
- Diseño de repositorio personalizado: Podremos tratar prácticamente cualquier estructura de directorios del sistema de archivos como un repositorio de Artifacts.
- Dependencias transitivas: Es uno de los principales beneficios que ofrece al utilizar la gestión de dependencias ya que se encarga de descargar y administrar las dependencias transitivas.
- Soporte a Groovy y Scala incorporado: Compatibilidad con los proyectos de Groovy, permitiendo trabajar con código Groovy o código Scala e inclusive desarrollar código mixto Java y Groovy o Java y Scala.
- Compilación incremental para Java: En caso de que el código fuente o la ruta de clase cambien, Gradle cuenta con la capacidad para detectar todas las clases que se vean afectadas por dicho cambio y procederá a recompilarlas.
- Embalaje y distribución de JAR, WAR y EAR: Cuenta con herramientas para empaquetar el código basado en JVM (Java Virtual Machine) en archivo comunes.
- Integración con Android Studio: Android Studio no cuenta con un generador interno, sino que delega todas las tareas de compilación en Gradle, garantizando la corrección en todas las construcciones, ya sea que se ejecuten desde Android Studio, la línea de comandos o un servidor de construcción de integración continua.
- Soporte de MS Visual C ++ y GoogleTest: Gradle acepta la construcción con el compilador de Visual C de Microsoft en Windows. (VS 2010, VS 2013 y VS 2015 compatibles), así como también realizar pruebas de aplicaciones C con GoogleTest.
NOTA: Para los ejemplos de este artículo utilizaremos Gradle con DSL basado en Groovy.
Instalación.
Pre-instalación (Requisitos)
Para poder ejecutar Gradle es necesario tener instalado JDK 8 o superior. Comencemos verificando la versión de Java que tenemos instalado, ejecutando la siguiente instrucción:
java -versionveremos algo así:
openjdk version "11.0.5" 2019-10-15
OpenJDK Runtime Environment (build 11.0.5+10-post-Debian-2)
OpenJDK 64-Bit Server VM (build 11.0.5+10-post-Debian-2, mixed mode, sharing)En el caso de no tener instalado JDK procedemos a su instalación.
Instalación de OpenJDK en distribuciones GNU/Linux.
En casi todas las distribuciones GNU/Linux el paquete JDK se encuentra en los repositorios oficiales:
Debian: sudo apt update && sudo apt-get install openjdk-11-jdk
Fedora: sudo dnf install java-11-openjdk
Instalación de OpenJDK en sistema operativo Windows.
Ver Tutoral Instalar Java(OpenJDK) en Windows
Instalación Manual de Gradle.
En los repositorio de distribuciones GNU/Linux se encuentran versiones de Gradle que podemos instalar, pero la documentación oficial nos sugiere instalar desde la página oficial. Los pasos de la instalación que mostraremos en este artículo están basados en la documentación oficial:
- Descargamos los binarios desde la página oficial de Gradle.
- Creamos una carpeta(directorio) donde almacenaremos los binarios.
En distribuciones GNU/Linux:sudo mkdir /opt/gradleEn sistema Windows:
md c:gradle - Descomprimimos el archivo que contiene los binarios. Luego se copian a la carpeta creada.
- Se agrega al sistema la ubicación de los binarios.
En distribuciones GNU/Linux:export PATH=$PATH:/opt/gradle/gradle-6.0.1/binEn sistema Windows:
set PATH=%PATH%;%c:gradlegradle-6.0.1%bin - Verificamos la instalación.
gradle -v ------------------------------------------------------------ Gradle 6.0.1 ------------------------------------------------------------
Gradle en los IDEs.
En algunos IDEs, como Eclipse 2019-9, Netbeans 11.2 y IntelliJ IDEA 2019.2, cuentan con integración para trabajar con Gradle, a continuación veremos imágenes de cómo podemos crear proyectos con Gradle desde los IDEs.
Gradle en el Market Place de Eclipse.Primeros pasos con Gradle.
¿Cómo se organiza la construcción en Gradle ?
Gradle se organiza en proyectos y tareas, en donde los proyectos puede ser un producto de lo que te encuentres haciendo, como una librería jar, una aplicación web o un archivo ZIP de distribución, etc. . Cada proyecto está compuesto por una o más tareas.
Las tareas representan la parte atómica en una construcción. Gradle proporciona una biblioteca de tareas, donde cada tarea realiza alguna operación básica, como compilar, ejecutar jar, copiar archivos, crear archivos jar, entre otras.
Ente las tareas de la biblioteca Gradle encontramos la herramientas para listar los proyectos y tareas. Para ello, desde una terminal digitamos la siguiente sentencia:
Listar tareas
gradle -q tasks
------------------------------------------------------------
Tasks runnable from root project
------------------------------------------------------------
Build Setup tasks
-----------------
init - Initializes a new Gradle build.
wrapper - Generates Gradle wrapper files.
Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'gradle'.
components - Displays the components produced by root project 'gradle'. [incubating]
dependencies - Displays all dependencies declared in root project 'gradle'.
dependencyInsight - Displays the insight into a specific dependency in root project 'gradle'.
dependentComponents - Displays the dependent components of components in root project 'gradle'. [incubating]
help - Displays a help message.
model - Displays the configuration model of root project 'gradle'. [incubating]
outgoingVariants - Displays the outgoing variants of root project 'gradle'.
projects - Displays the sub-projects of root project 'gradle'.
properties - Displays the properties of root project 'gradle'.
tasks - Displays the tasks runnable from root project 'gradle'.
To see all tasks and more detail, run gradle tasks --all
To see more detail about a task, run gradle help --task
Listar Proyectos
gradle -q projects
------------------------------------------------------------
Root project
------------------------------------------------------------
Root project 'gradle'
No sub-projects
To see a list of the tasks of a project, run gradle :tasks
For example, try running gradle :tasksNota: La opción -q evita que se visualicen mensajes innecesarios en el proceso de construcción.
Trabajando con tareas.
Vamos ejecutar algunas tareas listadas con la sentencia gradle -q tasks. Como vemos, ya hemos utilizado dos tareas de la lista las cuales son tasks y projects. Ejecutaremos dos tareas más para no hacer tan extenso este artículo, comenzando con ‘help’ y después con la tarea ‘init’.
gradle -q help
Welcome to Gradle 6.0.1.
To run a build, run gradle ...
To see a list of available tasks, run gradle tasks
To see a list of command-line options, run gradle --help
To see more detail about a task, run gradle help --task
For troubleshooting, visit https://help.gradle.org
De la salida mostrada por la tarea ‘help’ tomaremos la sentencia gradle help –task, la cual nos mostrará la ayuda de una tarea específica. En el siguiente ejemplo le pediremos a Gradle que nos muestre información de la tarea ‘init’.
gradle -q help --task init
Detailed task information for init
Path
:init
Type
InitBuild (org.gradle.buildinit.tasks.InitBuild)
Options
--dsl Set the build script DSL to be used in generated scripts.
Available values are:
groovy
kotlin
--package Set the package for source files.
--project-name Set the project name.
--test-framework Set the test framework to be used.
Available values are:
junit
junit-jupiter
kotlintest
scalatest
spock
testng
--type Set the type of project to generate.
Available values are:
basic
cpp-application
cpp-library
groovy-application
groovy-gradle-plugin
groovy-library
java-application
java-gradle-plugin
java-library
kotlin-application
kotlin-gradle-plugin
kotlin-library
pom
scala-library
swift-application
swift-library
Description
Initializes a new Gradle build.
Group
Build Setup
Ahora que ya sabemos que la tarea ‘init’ crea la estructura inicial de directorio en nuestro proyecto y además nos brinda las opciones que tenemos para ejecutar la tarea init, procederemos desde una terminal a ejecutar:
gradle init --project-name myproyect --type basic
Select build script DSL:
1: Groovy
2: Kotlin
Enter selection (default: Groovy) [1..2]
> Task :init
Get more help with your project: https://guides.gradle.org/creating-new-gradle-builds
BUILD SUCCESSFUL in 11s
2 actionable tasks: 1 executed, 1 up-to-dateHablaremos un poco de la sentencia que utilizamos para ejecutar la tarea init. Como vemos, utilizamos algunas de las opciones que nos mostró la tarea help –task init, de las cuales detallamos a continuación:
–project-name : con esta opción le indicamos a Gradle cómo se llama nuestro proyecto.
–type: con esta opción le indicamos a Gradle el tipo de estructura de directorio a construir.
Cómo pueden ver en el ejemplo anterior, Gradle nos pide que le indiquemos el DSL que va utilizar, por defecto Gradle utiliza Groovy, por lo que solo se presiona Enter para que Gradle entienda que debe utilizar DSL basados en Groovy. Hasta ahí todo bien. ¿Pero qué obtuvimos de ejecutar la tarea init?.
Veamos la estructura de directorio.
tree
.
├── build.gradle
├── gradle
│ └── wrapper
│ ├── gradle-wrapper.jar
│ └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
└── settings.gradle
Una visión general de lo que nos construyó la tarea init con el type basic.
Nos creó dos archivos en la raíz del proyecto con los nombres build.gradle y settings.gradle. Estos archivos son utilizados por Gradle para la configuración de construcción del proyecto.
build.gradle: Archivo de texto plano que mediante del lenguaje específico de dominio(DSL). En este archivo especificamos los tipos de empaquetados y el producto que requerimos al compilar (jar, war, etc). También especificamos los repositorios y dependencias que se necesitarán al momento de compilar. Además, puedes definir propiedades del archivo manifiesto.
settings.gradle: Archivo de texto plano que indica a gradle los módulos que deberá incluir al momento de compilar el proyecto.
También nos creó un directorio Gradle el cual almacena el wrapper. Wrapper es un script que invoca una versión declarada de Gradle, el cual lo descarga si es necesario. Los archivos que componen wrapper son:
gradle-wrapper.jar: El archivo Wrapper JAR que contiene el código para descargar la distribución Gradle.
gradle-wrapper.properties: Un archivo de propiedades responsable de configurar el comportamiento del tiempo de ejecución Wrapper, p. La versión Gradle compatible con esta versión. Tenga en cuenta que las configuraciones más genéricas, como configurar el Wrapper para usar un proxy, deben ir a un archivo diferente.
gradlew: script para sistemas basado en UNIX, almacenado en el directorio raíz del proyecto para ejecutar gradle-wrapper.
gradlew.bat: script para sistemas Windows, almacenado en el directorio raiz del proyecto para ejecutar gradle-wrapper.
Los scripts gradlew y gradlew.bat son los que recomienda gradle ejecutar con las tareas una vez que se inicializó el proyecto.
Creando nuestra primera tarea – Hola Mundo.
En Gradle no solo contamos con las tareas que vienen en la biblioteca, ya que podemos crear nuestra propias tareas utilizando el DSL.
Con nuestro editor de texto preferido crearemos una archivo build.gradle y le agregaremos la siguientes linea de código:
task hw {
doLast(){
println "Helo Word"
}
}Para ejecutar la tarea que acabamos de crear, desde una terminal nos ubicamos en el directorio donde creamos el archivo build.gradle y digitamos
gradle -q hw
Hello WordUtilizando el grafo acíclico en las tareas (dependencias).
Una de las bondades de Gradle es que podemos determinar el orden en que las tareas se va ejecutando. Para ello necesitaremos del método dependsOn.
Ejemplo 1.
Imagine que tenemos las tareas “A” y “B”, pero la tarea “B” depende que se realice primero la tarea “A”. Veamos con un ejemplo de cómo podemos hacer para que se realice la tarea “A” antes de la tarea “B”.
Editamos el archivo build.gradle que habíamos creado en el ejemplo anterior y nos quedará con el siguiente código:
task hw {
doLast(){
println "Helo Word"
}
}
task whoAmI(dependsOn: hw) {
doLast(){
println "I am Gradle"
}
}O con el siguiente código:
task hw {
doLast(){
println "Helo Word"
}
}
task whoAmI {
dependsOn hw
doLast(){
println "I am Gradle"
}
}Una vez realizadas las modificaciones, ejecutamos la tarea whoami con la siguiente sentencia
task -q whoami Creando nuestro primer proyecto Java.
Vamos a crear nuestro primer proyecto “hola mundo” en Java con ayuda de la tarea init de Gradle. Para ello, desde una terminal nos ubicamos en la carpeta donde crearemos nuestro proyecto y ejecutamos la siguiente sentencia:
De la sentencia anterior obtendremos la siguiente estructura de directorios:
tree
.
├── build.gradle
├── gradle
│ └── wrapper
│ ├── gradle-wrapper.jar
│ └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
├── settings.gradle
└── src
├── main
│ ├── java
│ │ └── ni
│ │ └── gacssoft
│ │ └── App.java
│ └── resources
└── test
├── java
│ └── ni
│ └── gacssoft
│ └── AppTest.java
└── resources
13 directories, 8 filesComo podemos ver, nos crea una estructura de directorio básicas para trabajar en proyectos desarrollados en Java. Veamos ahora el contenido del archivo build.gradle:
/*
* This file was generated by the Gradle 'init' task.
*
* This generated file contains a sample Java project to get you started.
* For more details take a look at the Java Quickstart chapter in the Gradle
* User Manual available at https://docs.gradle.org/6.0.1/userguide/tutorial_java_projects.html
*/
plugins {
// Apply the java plugin to add support for Java
id 'java'
// Apply the application plugin to add support for building a CLI application.
id 'application'
}
repositories {
// Use jcenter for resolving dependencies.
// You can declare any Maven/Ivy/file repository here.
jcenter()
}
dependencies {
// This dependency is used by the application.
implementation 'com.google.guava:guava:28.0-jre'
// Use JUnit test framework
testImplementation 'junit:junit:4.12'
}
application {
// Define the main class for the application.
mainClassName = 'ni.gacssoft.App'
}Veremos cada apartado del build.gradle que nos proporcionó la tarea init, iniciando con el bloque plugins.
Plugins
Con el propósito de dar lo que se necesite en el momento que lo necesite, Gradle brinda en su núcleo pocas herramientas de automatización. Las utilidades que se requieran para la automatización son proporcionadas por medio de complementos (plugins).
Existen dos tipos de complementos(¿Quieres saber mas?): complementos por script y complemento binarios.
Script: son scripts de compilación adicionales que configuran aun más la compilación y generalmente implementan un enfoque declarativo para manipular la compilación.
Binario: son clases que implementan la interfaz del complemento y adoptan un enfoque programático para manipular la compilación.
Para este artículo trabajaremos con los plugins binarios que nos proporciona la tarea init:
//Este bloque le indica a gradle que aplique los complementos que se espesifican dentro los corchtes
plugins {
id 'java' // le indica que utilizaremos el complemento para compilar java
id 'application' // le indica que utilizaremos el complemento para generar o ejecutar la aplicacion
}Estos plugins proporcionan tareas adicionales que podemos ejecutar. Listaremos las tareas que tenemos actualmente y veremos que tenemos una diferencia con el listado anterior:
gradle -q tasks
executing gradlew instead of gradle
------------------------------------------------------------
Tasks runnable from root project
------------------------------------------------------------
Application tasks
-----------------
run - Runs this project as a JVM application
Build tasks
-----------
assemble - Assembles the outputs of this project.
build - Assembles and tests this project.
buildDependents - Assembles and tests this project and all projects that depend on it.
buildNeeded - Assembles and tests this project and all projects it depends on.
classes - Assembles main classes.
clean - Deletes the build directory.
jar - Assembles a jar archive containing the main classes.
testClasses - Assembles test classes.
Build Setup tasks
-----------------
init - Initializes a new Gradle build.
wrapper - Generates Gradle wrapper files.
Distribution tasks
------------------
assembleDist - Assembles the main distributions
distTar - Bundles the project as a distribution.
distZip - Bundles the project as a distribution.
installDist - Installs the project as a distribution as-is.
Documentation tasks
-------------------
javadoc - Generates Javadoc API documentation for the main source code.
Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'java-gradle'.
components - Displays the components produced by root project 'java-gradle'. [incubating]
dependencies - Displays all dependencies declared in root project 'java-gradle'.
dependencyInsight - Displays the insight into a specific dependency in root project 'java-gradle'.
dependentComponents - Displays the dependent components of components in root project 'java-gradle'. [incubating]
help - Displays a help message.
model - Displays the configuration model of root project 'java-gradle'. [incubating]
outgoingVariants - Displays the outgoing variants of root project 'java-gradle'.
projects - Displays the sub-projects of root project 'java-gradle'.
properties - Displays the properties of root project 'java-gradle'.
tasks - Displays the tasks runnable from root project 'java-gradle'.
Verification tasks
------------------
check - Runs all checks.
test - Runs the unit tests.
Rules
-----
Pattern: clean: Cleans the output files of a task.
Pattern: build: Assembles the artifacts of a configuration.
Pattern: upload: Assembles and uploads the artifacts belonging to a configuration.
To see all tasks and more detail, run gradlew tasks --all
To see more detail about a task, run gradlew help --task "task" Como podemos ver, el complemento Application nos proporciona la tarea run. Con esta tarea podemos ejecutar el proyecto que hemos creado con la siguiente sentencia:
gradle -q run
executing gradlew instead of gradle
Hello world.Repositories
Sigamos analizando el archivo build.gradle. Ahora veremos el bloque repositories. Cuando trabajamos en proyectos, el 100% del código no lo escribe un solo desarrollador. En muchas ocasiones necesitamos librerías que nos ayudan con la funcionalidad de nuestra aplicación. Este bloque le indica a Maven dónde buscar y descargar las librerías que nuestro proyecto necesita para que funcione:
repositories {//le dice a gradle los repositorios donde buscara las librerias
jcenter() // le indica a gradle el repositorio donde ira a buscar las librerias necesarias para el proyecto
}Entre los repositorios populares, Gradle tiene asignado los siguientes DSL :
Respositorio DSL
Bintray JCenter -> jcenter()
Maven Central -> mavenCentral()
Google Android -> google()
La tarea init agrega en el repositorio Bintray (JCenter). Nosotros podremos cambiar el repositorio o combinarlos. ¿Quieres saber mas?
Dependencies.
En este bloque de código le indicamos a Gradle las dependencias que necesitará nuestra aplicación para funcionar. Las dependencias podrán ser utilizadas en tiempo de ejecución o para compilar. La configuración dependerá en algunos caso del complemento (plugin). Por ejemplo, el complemento de Java utiliza las configuraciones implementation, testImplementation, compileOnly, etc. . ¿Quieres saber mas?
dependencies {
implementation 'com.google.guava:guava:28.0-jre'
testImplementation 'junit:junit:4.12'
}Application
En este bloque se asignan valores a las propiedades del complemento Application. Para este ejemplo se utiliza la propiedad mainClassName. Esta propiedad le dice a Gradle que escriba en el archivo de manifiesto el nombre de la clase principal, para que en el momento de ejecutar el proyecto JVM pueda saber cuál es la clase que inicia la aplicación:
application {
mainClassName = 'ni.gacssoft.App'
}Ahora que ya tenemos una idea del contenido del archivo de configuración build.gradle, vamos hacer unos cambios. Vamos a mejorar el “hola mundo” utilizando la libreria jfiglet. Para ello le diremos a Gradle que busque en los repositorio de mavenCentral.
repositories {
mavenCentral()
}
Gradle- mavenCentralBuscamos en el repositorio de Maven la versión más actual de la librería.
Elegimos la versión 0.0.8, copiamos las especificaciones de la dependencia para Gradle.
mavenCentral librería jfigletdependencies {
// This dependency is used by the application.
implementation 'com.google.guava:guava:28.0-jre'
compile group: 'com.github.lalyos', name: 'jfiglet', version: '0.0.8'
// Use JUnit test framework
testImplementation 'junit:junit:4.12'
}Para la versión 6 de Gradle, podemos utilizar un formato más corto para las dependencias, tal como especifica la dependencia de guava. Entre comillas simple especificamos ‘grupo:name:version’, lo que nos quedaria ‘com.github.lalyos:jfiglet:0.0.8’
Como no estamos utilizando guava y junit en este proyecto, los pondremos como comentario para que Gradle los ignore al momento de compilar y nos queda así:
dependencies {
// This dependency is used by the application.
// implementation 'com.google.guava:guava:28.0-jre'
implementation 'com.github.lalyos:jfiglet:0.0.8'
compile group: 'com.github.lalyos', name: 'jfiglet', version: '0.0.8'
// Use JUnit test framework
//testImplementation 'junit:junit:4.12'
}Ahora vamos a modificar el código de nuestro proyecto, específicamente la clase App.java y la dejaremos así:
/*
* This Java source file was generated by the Gradle 'init' task.
*/
package ni.gacssoft;
import com.github.lalyos.jfiglet.FigletFont;
import java.io.IOException;
public class App {
public String getGreeting() {
return "Hello world.";
}
public static void main(String[] args) throws IOException {
String whoAmI = FigletFont.convertOneLine("JAVA");
System.out.println(new App().getGreeting());
System.out.println( "Yo soy ...." );
System.out.println( whoAmI );
}
}Una vez que tengamos guardado los cambios lo ejecutamos con la tarea run.
Hasta aquí nuestro proyecto Hola Mundo en Java construido, compilado y ejecutado con Gradle. El código se encuentra disponible en Github.
Otro proyecto Java con Gradle.
Ahora, vamos a crear otro proyecto en Java utilizando Gradle, pero esta vez agregando un poco más de complejidad que el proyecto “hola mundo“. Para este ejemplo utilizaré el código del artículo Persistencia de datos implementando JDBC .
Creando la estructura de directorios.
Utilizando Gradle digitamos desde la terminal la siguiente instrucción:
gradle -q init --project-name jdbcsqlite --type java-application
Select build script DSL:
1: Groovy
2: Kotlin
Enter selection (default: Groovy) [1..2] 1
Select test framework:
1: JUnit 4
2: TestNG
3: Spock
4: JUnit Jupiter
Enter selection (default: JUnit 4) [1..4] 1
Source package (default: jdbcsqlite): ni.gacssoft Nos quedará la siguiente estructura de directorios:
tree
.
├── build.gradle
├── gradle
│ └── wrapper
│ ├── gradle-wrapper.jar
│ └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
├── settings.gradle
└── src
├── main
│ ├── java
│ │ └── ni
│ │ └── gacssoft
│ │ └── App.java
│ └── resources
└── test
├── java
│ └── ni
│ └── gacssoft
│ └── AppTest.java
└── resources
13 directories, 8 files
Crearemos las carpetas controller, view y model dentro de la carpeta main/java/ni/gacssosft/
mkdir main/java/ni/gacssoft/util
mkdir main/java/ni/gacssoft/controller
mkdir main/java/ni/gacssoft/view
mkdir main/java/ni/gacssoft/modelModificación el build.gradle
Modificaremos el archivo build.gradle, que nos generó la tarea init:
/*
* This file was generated by the Gradle 'init' task.
*
* This generated file contains a sample Java project to get you started.
* For more details take a look at the Java Quickstart chapter in the Gradle
* User Manual available at https://docs.gradle.org/6.0.1/userguide/tutorial_java_projects.html
*/
plugins {
// Apply the java plugin to add support for Java
id 'java'
// Apply the application plugin to add support for building a CLI application.
id 'application'
}
repositories {
// Use jcenter for resolving dependencies.
// You can declare any Maven/Ivy/file repository here.
jcenter()
}
dependencies {
// This dependency is used by the application.
implementation 'com.google.guava:guava:28.0-jre'
// Use JUnit test framework
testImplementation 'junit:junit:4.12'
}
application {
// Define the main class for the application.
mainClassName = 'ni.gacssoft.App'
}Primero, agregamos la dependencia para el driver de SQLite.
dependencies {
// This dependency is used by the application.
implementation 'com.google.guava:guava:28.0-jre'
// Use JUnit test framework
testImplementation 'junit:junit:4.12'
implementation 'org.xerial:sqlite-jdbc:3.28.0'
}Como siguiente paso, especificamos a Gradle que estamos trabajando con la versión de Java 11:
sourceCompatibility = 11
targetCompatibility = 11
Si hemos trabajado con Maven, tendremos un repositorio local el cual podremos especificar a Gradle que busque dependencia en local agregando el DSL mavenLocal.
repositories {
mavenLocal()
// Use jcenter for resolving dependencies.
// You can declare any Maven/Ivy/file repository here.
jcenter()
}Como estamos utilizando el código del articulo artículo Persistencia de datos implementando JDBC, necesitamos hacer los siguientes pasos antes de compilar:
1. Crear una carpeta llamada var/db/
mkdir var
mkdir var/db2. Indicarle a Gradle que los archivos de distribución de la aplicación debe agregar la carpeta var/db/, el cual podemos hacer de la siguiente manera:
Creamos una carpeta dist/ dentro de la carpeta src/, y dentro de la carpeta dist/ creamos las carpetas var/db/.
mkdir src/dist
mkdir var
mkdir var/dbLa estructura de directorio nos quedaría:
tree
.
├── build.gradle
├── gradle
│ └── wrapper
│ ├── gradle-wrapper.jar
│ └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
├── settings.gradle
├── src
│ ├── dist
│ │ └── var
│ │ └── db
│ ├── main
│ │ ├── java
│ │ │ └── ni
│ │ │ └── gacssoft
│ │ │ ├── App.java
│ │ │ ├── ConnectionBD.java
│ │ │ ├── controller
│ │ │ │ └── PersonaController.java
│ │ │ ├── model
│ │ │ │ └── Persona.java
│ │ │ ├── util
│ │ │ │ └── Input.java
│ │ │ └── view
│ │ │ ├── DeletePersona.java
│ │ │ ├── EditPersona.java
│ │ │ ├── ListPersona.java
│ │ │ └── NewPersona.java
│ │ └── resources
│ └── test
│ ├── java
│ │ └── ni
│ │ └── gacssoft
│ │ └── AppTest.java
│ └── resources
└── var
└── db
3. Por último para poder ejecutar el proyecto con la tarea run, utilizando la entrada estándar con la Scanner, debemos agregar la siguiente configuración en nuestro archivo build.gradle
run{
standardInput = System.in
}Entonces el archivo build.gradle nos quedará de la siguiente manera:
/*
* This file was generated by the Gradle 'init' task.
*
* This generated file contains a sample Java project to get you started.
* For more details take a look at the Java Quickstart chapter in the Gradle
* User Manual available at https://docs.gradle.org/6.0.1/userguide/tutorial_java_projects.html
*/
plugins {
// Apply the java plugin to add support for Java
id 'java'
// Apply the application plugin to add support for building a CLI application.
id 'application'
}
sourceCompatibility = 11
targetCompatibility = 11
repositories {
mavenLocal()
// Use jcenter for resolving dependencies.
// You can declare any Maven/Ivy/file repository here.
jcenter()
}
dependencies {
// This dependency is used by the application.
implementation 'com.google.guava:guava:28.0-jre'
// Use JUnit test framework
testImplementation 'junit:junit:4.12'
implementation 'org.xerial:sqlite-jdbc:3.28.0'
}
application {
// Define the main class for the application.
mainClassName = 'ni.gacssoft.App'
}
run{
standardInput = System.in
}Ejecutando la aplicación
Hasta aquí hemos dado nuestro primeros pasos con Gradle con proyectos en Java. Si vemos nuestra estructura de directorio después de ejecutar la tarea run, tendremos algo así.
tree
.
├── build
│ ├── classes
│ │ └── java
│ │ └── main
│ │ └── ni
│ │ └── gacssoft
│ │ ├── App.class
│ │ ├── ConnectionBD.class
│ │ ├── controller
│ │ │ └── PersonaController.class
│ │ ├── model
│ │ │ └── Persona.class
│ │ ├── util
│ │ │ └── Input.class
│ │ └── view
│ │ ├── DeletePersona.class
│ │ ├── EditPersona.class
│ │ ├── ListPersona.class
│ │ └── NewPersona.class
│ ├── distributions
│ │ └── jdbcsqlite.tar
│ ├── generated
│ │ └── sources
│ │ └── annotationProcessor
│ │ └── java
│ │ └── main
│ ├── libs
│ │ └── jdbcsqlite.jar
│ ├── scripts
│ │ ├── jdbcsqlite
│ │ └── jdbcsqlite.bat
│ └── tmp
│ ├── compileJava
│ └── jar
│ └── MANIFEST.MF
├── build.gradle
├── gradle
│ └── wrapper
│ ├── gradle-wrapper.jar
│ └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
├── settings.gradle
├── src
│ ├── main
│ │ ├── java
│ │ │ └── ni
│ │ │ └── gacssoft
│ │ │ ├── App.java
│ │ │ ├── ConnectionBD.java
│ │ │ ├── controller
│ │ │ │ └── PersonaController.java
│ │ │ ├── model
│ │ │ │ └── Persona.java
│ │ │ ├── util
│ │ │ │ └── Input.java
│ │ │ └── view
│ │ │ ├── DeletePersona.java
│ │ │ ├── EditPersona.java
│ │ │ ├── ListPersona.java
│ │ │ └── NewPersona.java
│ │ └── resources
│ └── test
│ ├── java
│ │ └── ni
│ │ └── gacssoft
│ │ └── AppTest.java
│ └── resources
└── var
└── db
└── mybd.db
40 directories, 31 filesCómo podemos ver en el directorio build tenemos una carpeta llamada distributions/, y dentro de distributions tenemos un archivo con extensión .tar. En este archivo tenemos nuestro proyecto empaquetado para distribuirlo listo para ejecutar.
La tarea build nos facilita dos tipos de archivos empaquetado, uno con extensión .tar y otro con extensión .zip.
Este empaquetado es realizado por el plugin application a través de un complemento interno llamado distribution(¿Quieres saber mas?).
Contendido de archivo zipHasta aquí este articulo espero que sea de utilidad para iniciar a construir sus proyectos Java con Gradle. Déjame saber en los comentarios si tienes alguna duda, que te pareció el articulo, y de mas te gustaria aprender.
Articulos relacionados:
Crear aplicación Web Java desde Eclipse IDE Persistencia de datos con Sqlite implementando JDBC. 
Configuración y puesta en marcha de servidor WildFly 26 Server Preparando el IDE Eclipse para aplicaciones de escritorio. Katalon para iniciar en la automatización de TestCase Generar una aplicación web con Maven.