Boot | El Recetario

Comenzamos una serie de posts sobre una tecnología de Spring muy interesante, llamada Spring Boot.

Spring Boot es una parte de Spring que nos permite crear diferentes tipos de aplicaciones de una manera rápida y sencilla. Sus características principales son que provee out-of-the-box una serie de elementos que nos permiten desarrollar diferentes tipos de aplicaciones de forma casi inmediata. Algunas de estas características son:

Servidores de aplicaciones embebidos (Tomcat, Jetty, Undertow)
POMs con dependencias y plug-ins para Maven
Uso extensivo de anotaciones que realizan funciones de configuración, inyección, etc.

Un ejemplo práctico del inicio de un desarrollo con Spring Boot puede ser el siguiente. A continuación crearemos un proyecto en Eclipse, lo configuraremos para usar Spring Boot y crearemos una primera aplicación web haciendo uso del Tomcat embebido que trae Spring Boot.

1. Creamos un proyecto Java en Eclipse

Creamos un proyecto Java estandar en Eclipse. En este caso estamos usando Eclipse Luna. Creamos un proyecto Java. Añadimos un directorio ‘java’ dentro de ‘src’ y establecemos la ruta ‘src/java’ como ruta de las fuentes dentro del classpath del proyecto. Esto no es necesario para Spring Boot, simplemente sirve para dar una estructura coherente al proyecto.

Proyecto en Eclipse

2. Mavenizamos el proyecto

Activamos las opciones de Maven para el proyecto para poder usar el pom a la hora de resolver dependencias, usar plug-ins, etc. Esto si es recomendable a la hora de usar Spring Boot ya que aunque podemos descargar los JAR necesarios, a la hora de usarlos y resolver otras dependencias, o generar diferentes distribuibles, será beneficioso disponer de Maven.

Al mavenizar el proyecto, se crea de forma automática el pom.xml del proyecto. Agregamos al POM lo siguiente:

Para que se añadan las dependencias necesarias para Spring Boot, plug-ins, etc, heredamos del POM de Spring Boot tal que asi:

<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>1.3.0.BUILD-SNAPSHOT</version>
</parent>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>1.3.0.BUILD-SNAPSHOT</version>

</parent>

En este caso, como vamos a desarrollar aplicaciones web, entre otras, añadimos la siguiente dependencia también:

<!-- Add typical dependencies for a web application -->
<dependencies>
  <!-- Import dependency management from Spring Boot (if parent POM not downloaded) -->
  <!-- <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-dependencies</artifactId>
   <version>1.3.0.BUILD-SNAPSHOT</version>
   <type>pom</type>
   <scope>import</scope>
  </dependency> -->

  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
</dependencies>

<!-- <dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-dependencies</artifactId>

<version>1.3.0.BUILD-SNAPSHOT</version>

<scope>import</scope>

</dependency> -->

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

</dependencies>

Añadimos el siguiente plug-in para crear los JAR como ficheros ejecutables:

<!-- Package as an executable jar -->
<plugin>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-maven-plugin</artifactId>
</plugin>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

</plugin>

Por último, en caso de no disponer de una versión completa de Spring, agregamos la configuración de los siguientes repositorios en caso de tener que descargar las correspondientes dependencias:

<!-- Add Spring repositories -->
<!-- (you don't need this if you are using a .RELEASE version) -->
<repositories>
  <repository>
    <id>spring-snapshots</id>
    <url>http://repo.spring.io/snapshot</url>
    <snapshots><enabled>true</enabled></snapshots>
  </repository>
  <repository>
    <id>spring-milestones</id>
    <url>http://repo.spring.io/milestone</url>
  </repository>
</repositories>
<pluginRepositories>
  <pluginRepository>
    <id>spring-snapshots</id>
    <url>http://repo.spring.io/snapshot</url>
  </pluginRepository>
  <pluginRepository>
    <id>spring-milestones</id>
    <url>http://repo.spring.io/milestone</url>
  </pluginRepository>
</pluginRepositories>

<id>spring-snapshots</id>

<url>http://repo.spring.io/snapshot</url>

</repository>

<id>spring-milestones</id>

<url>http://repo.spring.io/milestone</url>

</repository>

</repositories>

<id>spring-snapshots</id>

<url>http://repo.spring.io/snapshot</url>

</pluginRepository>

<id>spring-milestones</id>

<url>http://repo.spring.io/milestone</url>

</pluginRepository>

</pluginRepositories>

El pom.xml final podria quedar tal que asi.

Ejecución en Maven

3. Implementamos la aplicación

Como ejemplo práctico de inicio, podemos codificar la siguiente clase:

package net.luisalbertogh.springboot.controllers;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
* Example controller class.
* @author lagarcia
*
*/
@RestController
@EnableAutoConfiguration
public class ExampleController {

  /**
  * Go to home.
  * @return
  */
  @RequestMapping("/")
  String home(){
    return "Hola Spring Boot";
  }

  /**
  * Main method.
  * @param args
  */
  public static void main(String[] args) {
    SpringApplication.run(ExampleController.class, args);
  }
}

package net.luisalbertogh.springboot.controllers;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;

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

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

/**

* Example controller class.

* @author lagarcia

@RestController

@EnableAutoConfiguration

public class ExampleController {

/**

* Go to home.

* @return

@RequestMapping("/")

String home(){

return "Hola Spring Boot";

}

/**

* Main method.

* @param args

public static void main(String[] args) {

SpringApplication.run(ExampleController.class, args);

}

Esta clase implementa un controlador web. Usa, ademas de Spring Boot, caracterísiticas de Spring MVC para ello. Las anotaciones presentes configuran la clase como controlador y establecen un mapeado entre el ‘/’ y una funcionalidad específica (devuelve un texto). La anotación @EnableAutoConfiguration configura la aplicación sin necesidad de otros ficheros de configuración XML, etc. Por último, se ejecuta el aplicativo usando la clase SpringApplication de Spring Boot.

4. Modificar las propiedades

El Tomcat embebido se lanza en el puerto 8080 por defecto. Como tenemos ese puerto ocupado, lo podemos cambiar usando diferentes mecanismos de propiedades del entorno de Spring Boot. Una de las formas de cambiar estas propiedades es usando el fichero application.properties. Spring Boot cargará automaticamente las propiedades que encuentre en el fichero application.properties si lo encuentra en una de las posibles localizaciones. Una de esas localizaciones es el directorio ‘config/’ dentro del directorio raíz del proyecto. Para más información acerca de la configuración de Spring Boot se puede consultar este enlace.

De esta manera, cambiamos el puerto de Tomcat al 9999:

# Spring Boot application properties

# Tomcat port
server.port=9999

# Spring Boot application properties

# Tomcat port

server.port=9999

Proyecto en Eclipse completo

5. Lanzar la aplicación

Finalmente solo nos queda compilar y lanzar la aplicación via Maven. Para ello podemos crear desde Eclipse un modo de ejecución via Maven con el plug-im m2 correspondiente. Lanzamos el goal ‘spring-boot:run’. Esto compila los cambios, ejecuta los posibles tests y lanza el aplicativo. En este caso, arranca el Tomcat embebido y ya tenemos la aplicación disponible en la siguiente URL:

http:\\localhost:9999

Ejecución desde Eclipse

Spring Boot web app

El Recetario

Recetas Java y más

Tag Archives: Boot

Iniciándose con Spring Boot (I)