Iniciar proyecto de Spring Boot usando Gradle

Tutorial para iniciar en Spring Boot usando Gradle: en este post te voy a enseñar cómo crear tu primer proyecto usando Spring Boot, un framework web de Java.

Veremos cómo iniciar un nuevo proyecto, hacer un hola mundo con Spring Boot y generar finalmente un archivo JAR para empaquetar el proyecto compilado.

Todo esto lo haremos con Gradle, verás que es realmente sencillo.

Nota: puedes probar y descargar el JAR generado en este enlace, solo asegúrate de tener Java en tu PC.

También puedes ver todo el código en el repositorio de GitHub.

Requisitos y recomendaciones

Simplemente instala gradle.

Crear proyecto de Spring Boot

Para iniciar con Spring Boot debes crear una carpeta que tendrá todo el código fuente. Colócala en el lugar de tu preferencia.

La mía se llama HolaMundoSpringBoot (si tú colocas otro nombre, asegúrate de cambiar el package en los archivos de java).

Abre una terminal y navega hasta ella, una vez en esa ubicación, ejecuta:

gradle init --type java-application

Responde a las preguntas como se ve en la imagen:

En los dos últimos simplemente presiona Enter (deja el valor por defecto). Eso debió crear un árbol de directorios así:

El archivo build.gradle

Ahora abre el archivo build.gradle y remplaza su contenido por el de este enlace del repositorio, o copia y pega lo siguiente:

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:2.1.6.RELEASE")
    }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'

bootJar {
    baseName = 'gs-rest-service'
    version =  '0.1.0'
}

repositories {
    mavenCentral()
}

sourceCompatibility = 1.8
targetCompatibility = 1.8

dependencies {
    compile("org.springframework.boot:spring-boot-starter-web")
    testCompile('org.springframework.boot:spring-boot-starter-test')
}

Lo único que estamos haciendo es tomar el build.gradle que ya tiene indicadas todas las dependencias.

Una cosa importante es el baseName de bootJar pues ese nombre tendrá nuestro JAR cuando empaquetemos la app, si quieres puedes cambiarlo.

Modificar código de App.java

Modifica el archivo llamado App.java (src/main/java/HolaMundoSpringBoot) de manera que quede así:

package HolaMundoSpringBoot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class App {
     public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

Lo único que hacemos es, en el método main, ejecutar nuestra App. No olvides la anotación de @SpringBootApplication arriba de la clase.

Este archivo simplemente se encarga de encender el servidor y comenzar nuestra app de Spring Boot.

Controlador REST

Para tocar un poco el tema de REST vamos a crear un controlador que se encargará de servir un JSON de una Mascota, es decir, de la clase Mascota cuando se visite una URL.

Debe estar en la misma ubicación que App.java, o bueno, en la misma carpeta del código fuente.

Queda así:

package HolaMundoSpringBoot;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MascotasController {

    @RequestMapping("/mascota")
    public Mascota mascota(
        @RequestParam(value="nombre", defaultValue="Sin nombre") String nombre, 
        @RequestParam(value="edad", defaultValue="0")  int edad) {
        return new Mascota(nombre, edad);
    }

    @RequestMapping("/")
    public String inicio() {
        return "Estamos en el índice /";
    }
}

Indicamos que será un controlador REST con la anotación @RestController

Para indicar que un método se llamará cuando coincida con una URL usamos la anotación de @RequestMapping

Dentro del método simplemente regresamos lo que el cliente verá al visitar la URL. Si visita /mascota se regresará una instancia de la clase Mascota, y se están tomando valores de la URL que se pueden pasar por GET.

Por ejemplo:

localhost:8080/mascota?nombre=Maggie

En caso de que los parámetros no sean proporcionados indicamos el valor por defecto. Todo esto se logra haciendo anotaciones con @RequestParam.

Abajo tenemos el método inicio que se llamará cuando se visite a /

Por cierto, la clase Mascota es esta:

package HolaMundoSpringBoot;

public class Mascota{

    private final String nombre;
    private final int edad;

    public Mascota(String nombre, int edad){
        this.nombre = nombre;
        this.edad = edad;
    }

    public String getNombre(){
        return this.nombre;
    }

    public int getEdad(){
        return this.edad;
    }
}

Ejecutar proyecto para iniciar con Spring Boot

Ya pusimos código y estamos listos para ejecutar nuestro proyecto. Solo como recortadorio, en src/main/java/NombreDeTuApp/ deben estar los 3 archivos:

• App.java
• Mascota.java
• MascotasController.java

Ahora abre una terminal y navega a la raíz de tu app. Ahí, ejecuta:

gradlew bootRun

Se debe ver algo así:

Ahora podemos visitar localhost:8080:

O visitar localhost:8080/mascota:

Recuerda que a esta última se le pueden pasar argumentos que regresará en el objeto, pasado a través de JSON:

Para detener el proyecto simplemente presiona CTRL + D en la consola y si Windows pregunta sobre detener el proceso elige s.

Empaquetar proyecto y generar JAR

No siempre vas a ejecutar el proyecto desde la terminal; cuando lo lleves a producción lo tendrás compilado en un archivo JAR. Para crear un archivo JAR ejecuta:

gradlew build

Como se ve en la imagen:

El JAR lo encuentras dentro de tu proyecto, en build/libs/ y tendrá el nombre que esté dentro de build.gradle.

Ese archivo JAR ya puedes distribuirlo. Recuerda que para ejecutarlo debes escribir:

java -jar gs-rest-service-0.1.0.jar

Como se ve a continuación:

Obviamente puedes poner el archivo en otro lugar y ejecutar su ruta completa, aquí solo muestro un ejemplo.

Si quieres probar la app, la dejo aquí.

Conclusión

A partir de aquí ya tenemos una base sólida para comenzar a usar el maravilloso framework Spring Boot en Java. Aunque el proyecto es muy sencillo, sirve muy bien para comenzar.

Además, ya viste cómo crear un controlador, leer datos, ejecutar el proyecto y compilarlo en un JAR.

Recuerda que puedes probar y descargar el JAR generado en este enlace, solo asegúrate de tener Java en tu PC.

También puedes ver todo el código en el repositorio de GitHub.