Hablemos de Quarkus

Quarkus es un framework (creado por Red Hat) moderno de Java diseñado para optimizar aplicaciones en entornos de nube, contenedores y Kubernetes. Su principal ventaja es ofrecer tiempos de arranque ultrarrápidos y bajo consumo de memoria, lo que lo hace ideal para microservicios y arquitecturas serverless.

Diseñado para funcionar tanto en JVM tradicional como en compilaciones nativas con GraalVM. 

Compatible con librerías y estándares conocidos: Eclipse MicroProfile, Spring, RESTEasy (JAX-RS), Hibernate ORM (JPA), Apache Kafka, Infinispan, Camel, entre otros.

Su sistema de inyección de dependencias (CDI) y extensiones permite integrar fácilmente nuevas funcionalidades.

Lo podemos usar para:

• Microservicios en Kubernetes: optimiza despliegues en contenedores con tiempos de arranque mínimos. 
• Aplicaciones serverless: ideal para funciones que requieren ejecución rápida y eficiente. 
• Aplicaciones reactivas y REST: soporta APIs modernas y comunicación asíncrona. 
• Integración con bases de datos y mensajería: Hibernate, Kafka, PostgreSQL, entre otros. 
• Desarrollo ágil: incluye un modo de desarrollo con recarga en caliente para iterar rápidamente.

Principales características:

• Arranque ultrarrápido: aplicaciones listas en milisegundos. 
• Consumo reducido de memoria: optimizado para entornos con recursos limitados. 
• Compilación nativa con GraalVM: genera binarios ligeros y eficientes. 
• Extensible: gran ecosistema de extensiones para añadir soporte a tecnologías populares. 
• Developer Joy: herramientas integradas para mejorar la experiencia del desarrollador (live reload, CLI). 
• Integración con la nube: pensado para Kubernetes, OpenShift y servicios cloud.

Para usar Quarkus lo puedes instalar de las siguientes formas:

Desde una terminal Linux, Mac OS, Windows (con WSL o Cygwin/MinGW):

$ curl -Ls https://sh.jbang.dev | bash -s - trust add https://repo1.maven.org/maven2/io/quarkus/quarkus-cli/
$ curl -Ls https://sh.jbang.dev | bash -s - app install --fresh --force quarkus@quarkusio

Con SDKMAN!:

$ sdk install quarkus

Con Powershell:

$ iex "& { $(iwr https://ps.jbang.dev) } trust add https://repo1.maven.org/maven2/io/quarkus/quarkus-cli/"
$ iex "& { $(iwr https://ps.jbang.dev) } app install --fresh --force quarkus@quarkusio"

Nota: También podemos crear un proyecto Quarkus usando Maven.

Verificamos la instalación:

$ quarkus --version

Emepzando con Quarkus

1. Vamos a abrir una terminal y tecleamos lo siguiente:

$ quarkus create && cd code-with-quarkus

Esto nos creará un proyecto y nos ubicará en el directorio principal.

2. Ejecutamos la aplicación:

$ quarkus dev

Si todo va bien, abrimos un navegador en la URL: http://localhost:8080/

Con esto hemos creado nuestra primera aplicación con Quarkus.

Este framework se podría considerar como el verdadero contendiente de Spring Boot dadas sus similitudes. Aunque existen otras alternativas como Helidon y Micronaut que no se quedan atrás.

En este blog ya hemos hablado de Quarkus indirectamente y vimos cómo es ideal para crear aplicaciones tipo REST.

En próximas entregas hablaremos un poco de Helidon y Micronaut.

Enlaces:

https://es.quarkus.io/
https://alquimistadecodigo.blogspot.com/2022/11/un-vistazo-quarkus-el-supersonic.html
https://code.quarkus.io/
https://alquimistadecodigo.blogspot.com/2023/01/quarkus-un-spring-boot-mejorado.html

Consumiendo una API pública con Kotlin & OkHttp

En el pasado post vimos cómo consumir un servicio Node desde una aplicación Java gracias a la librería OkHttp. Esta vez usaremos Kotlin como lenguaje base y Gradle para la administración de las dependencias y ejecución del proyecto.

¿Qué haremos?

• Crear una aplicación Kotlin con Gradle. 
• Consumir una API pública: https://api.chucknorris.io/jokes/random

1. Comenzaremos con la creación del directorio del proyecto:

$ mkdir proyecto-kotlin
$ cd proyecto-kotlin

El directorio del proyecto se verá así:

proyecto-kotlin/
   .gitattributes
   .gitignore
   .gradle
   .kotlin
   app/
   build/
   gradle/
   gradle.properties
   gradlew
   gradlew.bat
   settings.gradle.kts

2. Agregamos la dependencia de ``OkHttp`` en el archivo ``build.gradle.kts``:

plugins {
    alias(libs.plugins.kotlin.jvm)
    application
}

repositories {
    mavenCentral()
}

dependencies {
    implementation("com.squareup.okhttp3:okhttp:4.12.0") // Moved to implementation
    testImplementation("org.jetbrains.kotlin:kotlin-test")
    testImplementation(libs.junit.jupiter.engine)
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
    implementation(libs.guava)
    testImplementation("org.junit.jupiter:junit-jupiter:5.10.3")
    testImplementation("org.mockito:mockito-core:5.12.0")
    testImplementation("org.mockito:mockito-junit-jupiter:5.12.0")
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

application {
    mainClass = "org.inforhomex.AppKt"
}

tasks.named<Test>("test") {
    useJUnitPlatform()
}

Con esto se podrá descargar la dependencia.

3. Editamos el programa ``app/src/main/kotlin/org/inforhomex/App.kt``.

package org.inforhomex

import okhttp3.OkHttpClient
import okhttp3.Request
import java.io.IOException

private const val URL_API = "https://api.chucknorris.io/jokes/random"

fun run(client: OkHttpClient = OkHttpClient()) {
    val request = Request.Builder().url(URL_API).build()
    client.newCall(request).execute().use { response ->
        if (!response.isSuccessful) throw IOException("Unexpected code $response")
        for ((name: String, value: String) in response.headers) {
            println("$name: $value")
        }
        println(response.body?.string() ?: "No response body")
    }
}

fun main() {
    run()
}

4. Creamos una prueba unitaria ``AppTest.kt``

package org.inforhomex


import okhttp3.*
import okio.Buffer
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.ExtendWith
import org.mockito.Mock
import org.mockito.Mockito
import org.mockito.junit.jupiter.MockitoExtension
import java.io.IOException
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith

@ExtendWith(MockitoExtension::class)
class AppTest {

    @Mock
    private lateinit var client: OkHttpClient

    @Mock
    private lateinit var response: Response

    @Mock
    private lateinit var responseBody: ResponseBody

    @Mock
    private lateinit var call: Call

    private val urlApi = "https://api.chucknorris.io/jokes/random"

    @BeforeEach
    fun setUp() {
        
        Mockito.`when`(client.newCall(Mockito.any(Request::class.java))).thenReturn(call)
    }

    @Test
    fun `test run success response`() {
        
        val mockJson = """
            {
                "icon_url": "https://assets.chucknorris.host/img/avatar/chuck-norris.png",
                "id": "abc123",
                "url": "",
                "value": "Chuck Norris can divide by zero."
            }
        """
        Mockito.`when`(call.execute()).thenReturn(response)
        Mockito.`when`(response.isSuccessful).thenReturn(true)
        Mockito.`when`(response.body).thenReturn(responseBody)
        Mockito.`when`(responseBody.string()).thenReturn(mockJson)
        Mockito.`when`(response.headers).thenReturn(Headers.Builder().add("Content-Type", "application/json").build())

        
        val output = captureOutput {
            run(client) 
        }

        
        assert(output.contains("Content-Type: application/json"))
        assert(output.contains("Chuck Norris can divide by zero."))
    }

    @Test
    fun `test run unsuccessful response throws IOException`() {
       
        Mockito.`when`(call.execute()).thenReturn(response)
        Mockito.`when`(response.isSuccessful).thenReturn(false)
        Mockito.`when`(response.code).thenReturn(404)

       
        val exception = assertFailsWith<IOException> {
            run(client) 
        }
        assertEquals("Unexpected code 404", exception.message)
    }

    
    private fun captureOutput(block: () -> Unit): String {
        val outputStream = java.io.ByteArrayOutputStream()
        val printStream = java.io.PrintStream(outputStream)
        val originalOut = System.out
        System.setOut(printStream)
        try {
            block()
        } finally {
            System.setOut(originalOut)
        }
        return outputStream.toString()
    }
}

5. Compilamos y ejecutamos la aplicación:

$ gradle build
$ gradle run

Si todo va bien, veremos esto en la consola:

date: Sun, 19 Oct 2025 03:25:17 GMT
content-type: application/json
nel: {"report_to":"heroku-nel","response_headers":["Via"],"max_age":3600,"success_fraction":0.01,"failure_fraction":0.1}
report-to: {"group":"heroku-nel","endpoints":[{"url":"https://nel.heroku.com/reports?s=e%2BRTonTfjrgED0WXfh1o2mxbl6%2BLhQQ4LIu%2F1NhF4MM%3D\u0026sid=812dcc77-0bd0-43b1-a5f1-b25750382959\u0026ts=1760844317"}],"max_age":3600}
reporting-endpoints: heroku-nel="https://nel.heroku.com/reports?s=e%2BRTonTfjrgED0WXfh1o2mxbl6%2BLhQQ4LIu%2F1NhF4MM%3D&sid=812dcc77-0bd0-43b1-a5f1-b25750382959&ts=1760844317"
server: cloudflare
vary: Origin
vary: Access-Control-Request-Method
vary: Access-Control-Request-Headers
via: 1.1 heroku-router
cf-cache-status: DYNAMIC
cf-ray: 990d2ad69c2f69de-DFW
alt-svc: h3=":443"; ma=86400
{"categories":[],"created_at":"2020-01-05 13:42:20.262289","icon_url":"https://api.chucknorris.io/img/avatar/chuck-norris.png","id":"zDUih4UaS82sDRjSX0hlLQ","updated_at":"2020-01-05 13:42:20.262289","url":"https://api.chucknorris.io/jokes/zDUih4UaS82sDRjSX0hlLQ","value":"Chuck Norris always wanted to surf but couldn't. Everytime his board touches the water, the sea parts."}

¡La aplicación ha funcionado correctamente!

Continuaremos con esta serie de ejemplos en próximas entregas.

Enlaces:

https://square.github.io/okhttp/
https://www.baeldung.com/guide-to-okhttp
https://ironpdf.com/es/java/blog/java-help/okhttp-java/

Un vistazo a Apache Struts Framework

Apache Struts es un framework MVC gratuito y de código abierto para crear aplicaciones web Java elegantes y modernas.

Prioriza las convenciones sobre la configuración, es extensible mediante una arquitectura de plugins e incluye plugins compatibles con REST, AJAX y JSON.

Es utilizado para desarrollar aplicaciones web basadas en la arquitectura MVC (Modelo-Vista-Controlador).

Struts fue muy popular antes de la llegada de Spring Framework y sobre todo de Spring Boot. Sin embargo, debido a su gran rendimiento aún es usado en muchas empresas.

Requerimientos:

• JDK 8 o superior. 
• Apache Maven 3.8.6 o superior. 
• Tener nociones de Java y JSP.
• Se puede usar un IDE como Eclipse, Visual Studio Code o cualquier otro.
• Sirve de mucho conocer algo de Spring Boot.

Nosotros usaremos la terminal para crear y ejecutar el proyecto.

Creando nuestra primera aplicación con Apache Struts2

Vamos a crear una sencilla aplicación de "Hola, mundo".

Creamos el proyecto Apache Struts2 con Maven y nos ubicamos en el directorio creado:

$ mvn archetype:generate -B 
  -DgroupId=org.cursomaven 
  -DartifactId=auditor -DarchetypeGroupId=org.apache.struts  
  -DarchetypeArtifactId=struts2-archetype-blank 
  -DinteractiveMode=false
$ cd auditor 

Abrimos el proyecto. Tendrá más o menos está estructura de carpetas:

auditor/ 
   pom.xml
   src/
     main/
       webapp/
          index.html
          WEB-INF/
           example/
           web.xml 
       resources/
          example.xml
          log4j2.xml
          struts.xml
       java/

Debemos eliminar los archivos innecesarios como: Login.java, HelloWorld.java, ExampleSupport.java. Esto para que solo quede una nueva clase llamada HolaMundo.java. Esto en la carpeta de java/org/cursomaven/example:

package org.cursomaven.example;


import com.opensymphony.xwork2.ActionSupport;


public class HolaMundo extends ActionSupport{

    public String execute() throws Exception {
        setMessage(getText(MESSAGE));
        return SUCCESS;
    }

    public static final String MESSAGE = "HolaMundo.message";
    
   
    private String message;

   
    public String getMessage() {
        return message;
    }

  
    public void setMessage(String message) {
        this.message = message;
    }
}

Tambien eliminaremos las páginas JSP del directorio webapp/WEB-INF/example. Esto para que solo quede una página JSP llamada HolaMundo.jsp

<%@ page contentType="text/html; charset=UTF-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head>
    <title><s:text name="HolaMundo.message"/></title>
</head>

<body>
<h2><s:property value="message"/></h2>

</body>
</html>

Editamos los archivos: package.properties y example.xml. Los cuales se encuentran en los directorios src/main/resources y src/main/resources/org/cursomaven/example

package.properties

server.port= 8081
HolaMundo.message =Bienvenido a ApacheStruts2.

example.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
        "http://struts.apache.org/dtds/struts-2.5.dtd">
<!-- 
  - This file is included by the struts.xml file as an example
  - of how to break up the configuration file into multiple files.
-->
<struts>
    <package name="example" namespace="/example" extends="struts-default">

        <default-action-ref name="HolaMundo" />

        <action name="HolaMundo" class="org.cursomaven.example.HolaMundo">
            <result>/WEB-INF/example/HolaMundo.jsp</result>
        </action>


        <!-- Add additional "example" package actions here. -->

    </package>
</struts>

Tambien editamos el archivo XML struts.xml:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
        "http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
    <constant name="struts.enable.DynamicMethodInvocation" value="false"/>
    <constant name="struts.devMode" value="true"/>

    <include file="example.xml"/>

    <package name="default" namespace="/" extends="struts-default">

        <default-action-ref name="index"/>

        <action name="index">
            <result type="redirectAction">
                <param name="actionName">HolaMundo</param>
                <param name="namespace">/example</param>
            </result>
        </action>

    </package>

    <!-- Add addition packages and configuration here. -->
</struts>

Construimos con Maven:

$ mvn clean install -X

Ejecutamos con el servidor emembido Jetty:

$ mvn jetty:run -Djetty.port=8081

Abrimos el navegador en la dirección:

http://localhost:8081/auditor/example/HolaMundo

¡Hemos creado nuestra primera aplicación con Apache Struts2!

Continuaremos con esta serie sobre Frameworks web en próximas entregas.

Enlaces:

https://struts.apache.org/index.html

Instalando Scala & SBT

En este post veremos cómo instalar Scala y SBT. Para ello usaremos SDKMAN!

SBT es un gestor de proyectos similar a Gradle y Maven.

Como primera instrucción tenemos:

sdk install scala

Comprobamos su instalación:

scala --version

Ahora sbt:

sdk install sbt

Verificamos la instalación:

sbt --version

Comandos básicos de SBT

• clean, para limpiar proyecto.
• reload, recargar proyecto.
• update, actualizar proyecto.
• compile, compilar proyecto y
• run, para ejecutar proyecto.

Creamos un proyecto Play Framework con SBT. Abrimos una terminal y tecleamos:

sbt new playframework/play-scala-seed.g8

Ejecutamos la aplicación web:

sbt run

Abrimos un navegador en la ruta http://localhost:9000

Listo, nuestro primer proyecto creado!!

Enlaces:

https://sdkman.io/
https://www.scala-sbt.org/
https://www.scala-lang.org/
https://codemonkeyjunior.wordpress.com/

"No Introducción a Gradle", por Domingo Suárez (@domix)

Scala sobre SBT parte 2

En el anterior post sobre SBT vimos una breve descripción de la herramienta y cómo instalarlo.

Para listar la versión de la herramienta debemos abrir una terminal de comandos y teclear:

$ sbt -version

Mostrará algo como esto:

sbt version in this project: 1.3.4

sbt script version: 1.3.4

Creando un proyecto con SBT.

1. Crear directorio.
2. Ubicarnos en directorio creado y crear subdirectorio.
3. Crear archivo build.sbt
4. Escribir el código.
5. Compilar y ejecutar.

$ mkdir testSbt
$ cd testSbt
$ mkdir sbt-ejemplo
$ cd sbt-ejemplo

Una vez en el directorio sbt-ejemplo, creamos el archivo build.sbt con cualquier editor de textos.

Ahora creamos el programa.

Hola.scala

package main

object Hola{

   def main(args: Array[String]):Unit{
       println("Hola, mundo desde Codemonkey Junior")
   }

}

Para compilar y ejecutar el programa tecleamos:

$ sbt

 >compile
 >run

Si no hay ningún error, mostrará el mensaje:

"Hola, mundo desde Codemonkey Junior"

Links:

https://emanuelpeg.blogspot.com/2020/05/libro-gratuito-de-scala.html

https://www.scala-sbt.org/

http://www.scala-js.org/

https://sdkman.io

Scala sobre SBT

SBT (Simple Build Tool) es una herramienta similar a Gradle, pero para el lenguaje Scala, un lenguaje de programación dependiente de la JVM.

Con esta herramienta podremos crear proyectos Scala. Crear su documentación y soportar subproyectos.

El archivo build.sbt es como el build.gradle para Gradle y/o el pom.xml para Maven.

Instalando SBT usando SDKMAN!

$ sdk install scala

Instalando SBT en Windows

https://www.scala-sbt.org/download.html


En siguientes post veremos como usar esta herramienta.


Enlaces:
https://emanuelpeg.blogspot.com/2020/05/libro-gratuito-de-scala.html
https://www.scala-sbt.org/
http://www.scala-js.org/
https://sdkman.io
 

Construyendo proyectos con Gradle (estructura de directorios)

La estructura de todo proyecto en Gradle debe tener la siguiente forma:

Proyecto
     |
     src
        |
          main
                | java
                | resources

        | test
               | java
               | resources

Una parte de desarrollo:
src/main/java
src/main/resources

Y una de testing (pruebas):
src/test/java
src/test/resources

Dentro de  la carpeta src/main/java debe estar nuestra clase principal.
Ejemplo:
src/main/java/Main.java

Además de la estructura debemos contar con el archivo build.gradle:
Proyecto
      |
     src
        |
          main
                | java
                | resources

        | test
               | java
               | resources
    |
build.gradle

Es decir:
Proyecto
src/main/java/Main.java
src/main/resources
src/test/java/Main.java
src/test/resources
build.gradle

Dentro del archivo build.gradle escribiremos:

apply plugin: 'java'
apply plugin: 'application'

sourceCompatibility = 1.8

targetCompatibility = 1.8
mainClassName = "org.codemonkey.Main"
version = "1.0"


repositories {
    mavenLocal()
    mavenCenter()
}

dependencies {

    compile group: 'junit', name: 'junit', version: '4.12'

}

Ahora la clase Main.java

package org.codemonkey;

public class Main{
   
    public static void main(String[] args) throws IOException {
        System.out.println("Hola mundo!");
    }   
} 

Dentro de la terminal teclearemos:
$gradle build

Con esto construiremos nuestro proyecto. Ahora listemos las tareas disponibles con:
$gradle task

Al desplegar las tareas debe haber una llamada run, esta nos permitira correr nuestro programa:
$gradle run

Salida:
Hola, mundo!

Con esto tendremos nuestro primer ejemplo. En el siguiente post veremos un ejemplo con Spring y Gradle.

Construyendo proyectos con Gradle (instalación con SDKMAN!)

Gradle es una herramienta que nos permite construir proyectos Java, Groovy, Scala, etc. de una manera más sencilla que usando Maven.

¿Cómo instalar Gradle? 
La más sencilla es usando SDKMAN!, solo basta que escribas en la terminal:
$sdk install gradle

Así tendrás instalado la última versión, para comprobar que versión tienes instaladas tecleas:
$gradle --version o $gradle -v

Saldrá algo como esto:
------------------------------------------------------------
Gradle 3.5
------------------------------------------------------------

Build time:   2017-04-10 13:37:25 UTC
Revision:     b762622a185d59ce0cfc9cbc6ab5dd22469e18a6

Groovy:       2.4.10
Ant:          Apache Ant(TM) version 1.9.6 compiled on June 29 2015
JVM:          1.8.0_131 (Oracle Corporation 25.131-b11)
OS:           Linux 4.4.0-75-generic amd64


Ahora nos ubicaremos en una carpeta y escribiremos un archivo llamado build.gradle. Dentro del archivo escribiremos lo siguiente:

task holaMundo << {
    println "Hola, mundo!"
}

Se trata de una simple tarea (task) denominada "holaMundo".

Para ejecutar el script escribiremos lo siguiente en la terminal:
$gradle -q build.gradle
$gradle -q holaMundo

Y obtendremos:
Hola, mundo!


Listo. Nuestro primer ejemplo esta hecho. En el siguiente post se verá la estructura de un proyecto Java usando Gradle .

Links:
https://gradle.org/
https://maven.apache.org/ 
http://codemonkeyjunior.blogspot.mx/search?q=maven
http://codemonkeyjunior.blogspot.mx/search?q=gradle

Graven: Crear proyectos con Maven y Gradle

En post anteriores ya había tratado sobre Gradle y Maven

http://codemonkeyjunior.blogspot.com/2012/01/comenzar-un-proyecto-en-gradle.html

http://codemonkeyjunior.blogspot.com/2012/01/maven-crear-proyecto-web-e-importarlo.html

Pero creo faltó hacer un ejemplo más completo.

1. Crear las variables de entorno

2. Agregarlas al path del sistema

%GRADLE_HOME%\bin

%M2_HOME%\bin

3. Comprobar instalación, en la terminal escribir:

gradle  –v

mvn  –v

pom.xml  (Maven) y build.gradle (Gradle)

Son archivos que sirven para describir y administrar las dependencias de nuestros proyectos.

Interfaz gráfica de Gradle

En la terminal o consola de comandos escribir: gradle -gui

Ayuda a probrar tus scripts, algo así como groovyConsole

Un script sencillo con Gradle

En un bloc de notas (notepad u otro) escribir:

//primer script

task Script01 << { println “Si ves esto ya funciona el script”

}

Guardarlo como: build.gradle

Ejecutar en la consola:

gradle build

Si sale un error es porque todavía no hemos agregado nada al proyecto

Crear una tarea simple

task Script01 << { println "Si ves esto ya funciona correctamente"}

Para ejecutar esta tarea simple

gradle –q Script01  

También se puede desde la interfaz gráfica

gradle –gui

Crear proyecto con Maven

Ir al directorio donde se quiere crear el proyecto

mvn archetype:create -DgroupId=org.proyecto.prueba01 -DartifactId=SistemaGraven -DarchetypeArtifactId=maven-archetype-webapp -Dversion=”0.0.1”

Otra forma

mvn archetype:create -DgroupId= org.proyecto.prueba01 -DartifactId=SistemaGraven

Crear el paquete:

mvn  package

Instalar:

mvn install

Agregar  la variable del repositorio local Maven

mvn –Declipse.workspace= “C:\eclipse\Workspace eclipse:add-maven-repo”

En  Eclipse comprobar en Java\Build path\Classpath variables si se ha dado de alta correctamente el repositorio de Maven

Importar el proyecto al Eclipse mediante el menú File\Import...\Existing proyect into Workspace..

Si existe algún error al importar el proyecto puedes entrar al classpath
y reemplazar la etiqueta:

<classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER" .....

por:

<classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER">
<attributes>
<attribute name="org.eclipse.jst.component.dependency" value="/WEB-INF/lib"/>
</attributes>
</classpathentry>

Editar el fichero pom.xml...

Tal vez la parte más difícil del proyecto.

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <groupId>org.proyecto.prueba01</groupId>

  <artifactId>SistemaGraven</artifactId>

  <version>1.0-SNAPSHOT</version>

  <packaging>jar</packaging>

  <name>SistemaGraven</name>

  <url>http://maven.apache.org</url>

  <properties>

    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

  </properties>

  <dependencies>

    <dependency>

      <groupId>junit</groupId>

      <artifactId>junit</artifactId>

      <version>3.8.1</version>

      <scope>test</scope>

    </dependency>

  </dependencies>

</project>

Ahora  con Gradle

Al crear nuestro proyecto (“simple” o web) con Maven debe quedar la estructura de la siguiente manera:

SistemaGraven

src/main/java/prueba01

src/main/resources

src/test/java/prueba01

src/test/resources
pom.xml

Ahora agregar al directorio Sistemas el archivo build.gradle

SistemaGraven

src/main/java/prueba01

src/main/resources

src/test/java/prueba01

src/test/resources
pom.xml

build.gradle

Contenido del  build.gradle

//Esto es para usar el plugin de Gradle para Java

apply plugin:'java'

//Esto es para usar el plugin de Gradle para Eclipse

apply plugin:'eclipse'

//El plugin para Java define un montón de cosas, entre ellas varias tareas

//invocamos aquí la principal para compilar todo por default

defaultTasks 'build'

//En esta sección incluimos los repositorios de Maven

repositories {

  mavenLocal()

  mavenCentral()

}

//Aquí se definen las dependencias para cada configuración.

//Importamos jUnit solamente para la compilacion de pruebas unitarias

dependencies {

  testCompile 'junit:junit:4.+'

}

Desde la terminal escribir:

gradle build

La estructura del proyecto SistemaGraven queda asi:

SistemaGraven

src/main/java/prueba01

src/main/resources

src/test/java/prueba01

src/test/resources

pom.xml

build.gradle

build.gradle