En el mundo Java siempre ha existido incertidumbre en las herramientas que debes utilizar, por el motivo que este apasionante lenguaje de programación es multiplataforma y tiene infinidad de posibilidad en lo que puedes utilizarlo. Pero en los últimos años, hay un proyecto que ha tomado mucha fuerza y ha sido pionero en muchos avances en cuanto arquitectura que se están implementando, ya que una empresa como Netflix lo utilizo en el desarrollo de su famosa arquitectura de microservicios.

Spring Boot

Uno de los proyectos mas utilizado, y que tienen un gran potencial por la cantidad de herramientas que se le han ido incorporando es Spring Boot. Facilita la creación de aplicaciones independientes, en tan poco tiempo. Se ha convertido en una infraestructura ligera que elimina la mayor parte del trabajo de configurar las aplicaciones en Spring.

Características

  • Creación de aplicaciones independientes de Spring
  • Incrusta servidor Embebido de Tomcat, Jetty o Undertow directamente (no es necesario implementar archivos WAR)
  • Proporcione dependencias destinadas para simplificar la configuración de su compilación
  • Configura automáticamente las bibliotecas de Spring y de terceros de lo mas simple posible
  • Proporciona funciones listas para producción, como métricas, comprobaciones de estado y configuración externa.
  • Absolutamente sin generación de código y sin requisitos de configuración XML

Requisitos para ejecutar una aplicación de Spring Boot

  • Tener instalado JDK 8 o una versión mayor de Java, preferiblemente descargarse la versión Open JDK
  • Tener instalado STS Spring, que es el IDE recomendado para desarrollar aplicaciones con Spring Boot.
  • No es esencial pero es recomendado tener instalado Maven
  • Esta herramienta es opcional pero muy recomendada, ya que se utiliza en muchos proyectos para el versionado, y es Git

Nota: Todas estas herramientas, son multiplataforma y para este tutorial se utilizaron en Windows 10. Como tal para este sistema operativo solo se descarga el ejecutable, a excepción de Maven que se debe instalar en una carpeta en el disco local C: u otra ubicación.

1. Configuración del proyecto en Spring Boot

Primero para crear los proyectos en Spring Boot, tenemos dos alternativas. Existe un sitio que nos proporciona la misma plataforma para inicializar proyecto llamado Spring initializr.

La segunda alternativa es la que nos proporciona el mismo IDE de STS Spring.

Para este tutorial se creara el proyecto desde el IDE de STS Spring.

Para iniciar el proyecto, se debe configurar diferentes propiedades como la versión de java a utilizar, el tipo de empaquetado que será en un jar, etc. Como nombre del aplicativo que se creara para este tutorial será para un Restaurante.

Luego de configurar las propiedad del proyecto, el siguiente paso es agregar las dependencias que se utilizaran en el proyecto. Para el aplicativo del Restaurante solamente agregaremos  Spring Web, más adelante se agregaran los necesarios.

En el punto final, se muestra la url que se ha formado con los datos configurados y la dependencia agregada. Como se observa esto se genera desde el sitio de Spring Initializr.

Al finalizar el proceso de creación del proyecto, se nos mostrara en la parte izquierda del IDE el proyecto Restaurant. Al abrir el archivo de ejecución del proyecto, se observa la anotación @SpringBootApplication la cual auto configura todo lo necesario para arrancar el aplicativo.

Para efecto del tutorial, crearemos un controlador llamado HomeController que tendrá un método publico para solamente mostrar un mensaje de saludo. Como es costumbre se creara una carpeta llamada controller, donde se colocaran todo los controladores.

package org.elsolitario.app.restaurant.controller;

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

@RestController
public class HomeController {
	
	@GetMapping(path = "/")
	public String home() {
		return "Saludo desde elsolitario.org";
	}

}

Con el código mostrado anteriormente, ejecutamos el proyecto y se puede probar desde el navegador ya que es un método GET o desde un aplicativo para el consumo de endpoint que permite el envío de peticiones HTTP REST sin necesidad de desarrollar un cliente. 

Como se observa para ejecutar un proyecto en el IDE STS Spring, es muy sencillo con darle clic al botón rojo y el icono play que se encuentra en la ventana izquierda inferior. Por defecto los aplicativos de Spring Boot al no configurarles otro puerto, ellos se ejecutan en el puerto 8080.

Como se muestra en la captura de pantalla, se ha ejecutado perfectamente el aplicativo de Spring Boot con un método GET que muestra un saludo.

2. Agregar dependencias adicionales

Ahora que ya ejecutamos el aplicativo, si queremos que persista los datos que se registren a la aplicación del Restaurante, debe tener una conexión a una base de datos. Para efectos de este tutorial se utilizara la base de datos H2, la cual nos permitirá simular la persistencia de datos. Para aplicativos que se lancen a producción, no es recomendado utilizar esta base de datos.

Que es H2:

H2 es un sistema administrador de bases de datos relacionales programado en Java. Puede ser incorporado en aplicaciones Java o ejecutarse de modo cliente-servidor. Una de las características más importantes de H2 es que se puede integrar completamente en aplicaciones Java y acceder a la base de datos lanzando SQL directamente, sin tener que pasar por una conexión a través de sockets.

Ahora para agregar las dependencias, hay dos formas. Una es que el IDE STS nos brinda la interfaz que nos apareció inicialmente. Solamente es de dar clic al proyecto y en la opción de Spring,  damos clic en Add Starter.

En la pantalla que nos aparece buscamos Spring Data JPA y H2, que serán las dependencias que agreguemos para persistir los datos que los usuarios ingresen al aplicativo. Cuando ya estén seleccionadas, damos Next y Next, hasta finalizar la adición de las dependencias.

La otra forma de agregar las dependencias es con el archivo pom.xml, donde se encuentran las dependencias que posee el proyecto pero para este caso se debe conocer el código que se debe colocar sino provocara un error en este archivo.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
</dependency>

3. Persistencia simple

Comenzaremos por definir el modelo de datos, una entidad de cliente simple para demostrar la funcionalidad de JPA en Spring Boot.

Siguiendo con la estructura de carpetas que debe tener el proyecto, se creara un paquete denominado entity donde se almacenaran todas las entidades que tendrá la aplicación.

La entidad Client tendrá el siguiente codigo:

package org.elsolitario.app.restaurant.entity;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Client implements Serializable {

	private static final long serialVersionUID = 1L;

	@Id
    @GeneratedValue(strategy = GenerationType.AUTO)
	private long id;
	
	@Column(nullable = false)
	private String firstName;
	
	@Column(nullable = false)
	private String lastName;
	
	@Column(nullable = false)
	private String telephone;
	
	@Column(nullable = false, unique = true)
	private String email;
	
	@Column(nullable = false)
	private Integer age;

	public Client(long id, String firstName, String lastName, String telephone, String email, Integer age) {
		super();
		this.id = id;
		this.firstName = firstName;
		this.lastName = lastName;
		this.telephone = telephone;
		this.email = email;
		this.age = age;
	}

	public Client() {
		super();
	}

	public long getId() {
		return id;
	}

	public void setId(long id) {
		this.id = id;
	}

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	public String getTelephone() {
		return telephone;
	}

	public void setTelephone(String telephone) {
		this.telephone = telephone;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Client [id=" + id + ", firstName=" + firstName + ", lastName=" + lastName + ", telephone=" + telephone
				+ ", email=" + email + ", age=" + age + "]";
	}
}

Ahora es de crear el repositorio de la entidad, Spring Boot nos ofrece una interfaz con una gran variedad de métodos para interactuar con la base sin necesidad de codificar métodos adicionales. Para poder utilizar esta interfaz que nos brinda Spring, es necesario haber agregado la dependencia de Spring Data JPA y con ello crear la interfaz relacionada con la entidad que se quiere utilizar para persistir los datos.

Siguiendo con la estructura de carpetas de nuestro proyecto, crearemos el paquete repository donde almacenaremos todas las interfaces de las entidades que la aplicación podrá utilizar para persistir los datos. Creamos la interfaz ClientRepository para aprovechar las bondades de Spring y poder realizar acciones hacia la base de datos.

Algo muy importante es que Spring Boot, con la dependencia de Spring Data JPA brinda la posibilidad de crear consultas con inicializadores de metodos. En el caso del método declarado en la interfaz del cliente, hemos declarado el método findByFirstNameAndLastName con dos parámetros y le estamos indicando a Spring que nos cree esa consulta para obtener todo los clientes con esos dos parámetros.

Código de la interfaz del cliente:

package org.elsolitario.app.restaurant.repository;

import java.io.Serializable;
import java.util.List;

import org.elsolitario.app.restaurant.entity.Client;
import org.springframework.data.repository.CrudRepository;

public interface ClientRepository extends CrudRepository<Client, Serializable> {
	
	public List<Client> findByFirstNameAndLastName(String firstName, String lastName); 
}

Ahora que ya se tiene la interfaz para interactuar con la base de datos, sigue agregar las configuraciones en el archivo application.properties para la conexion a H2.

spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.url=jdbc:h2:mem:bootapp;DB_CLOSE_DELAY=-1
spring.datasource.username=sa
spring.datasource.password=

Esta son propiedades que necesita Spring para saber que base de datos se debe conectar, y lo hace automáticamente. Ahora ya tenemos los ingredientes necesarios para crear nuestros endpoint para la entidad Cliente y poder persistir los datos que nos envíen los usuarios.

Siguiendo ahora con el controlador para la entidad cliente, crearemos en el paquete controller la clase ClientController donde colocaremos los endpoint necesarios para consumir y persistir los datos de los clientes en el restaurante. Se les comparte el codigo:

package org.elsolitario.app.restaurant.controller;

import java.util.List;

import org.elsolitario.app.restaurant.entity.Client;
import org.elsolitario.app.restaurant.repository.ClientRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping(path = "/client")
public class ClientController {

	@Autowired
	private ClientRepository clientRepo;
	
	/* Obtener todo los clientes registrados
	 * */
	@GetMapping
	public Iterable findAll() {
		return clientRepo.findAll();
	}
	
	/* Obtener un cliente por ID
	 * */
	@GetMapping("/{id}")
	public Client findOneClient(@PathVariable Long id) {
		return clientRepo.findById(id).orElseThrow(null);
	}
	
	/* Guardar un Cliente con los datos enviados por el usuario
	 * */
	@PostMapping
	@ResponseStatus(HttpStatus.CREATED)
	public Client create(@RequestBody Client client) {
		return clientRepo.save(client);
	}
	
	/* Eliminar un cliente por ID
	 * */
	@DeleteMapping("/{id}")
    public void delete(@PathVariable Long id) {
		clientRepo.findById(id).orElseGet(null);
		clientRepo.deleteById(id);
    }
	
	/* Actualizar los datos de un cliente
	 * */
	@PutMapping("/{id}")
    public Client updateClient(@RequestBody Client client, @PathVariable Long id) throws Exception {
        if (client.getId() != id) {
          throw new Exception("Error en actualizar el cliente");
        }
        clientRepo.findById(id).get();
        return clientRepo.save(client);
    }
	
	/* Buscar lista de clientes por nombre y apellidos que se encuentren repetidos
	 * */
	@GetMapping(path = "/find")
	public List<Client> getClientsByFirstNameAndLastname(@RequestParam String firstName, @RequestParam String lastName) {
		return clientRepo.findClientsByFirstNameAndLastName(firstName, lastName);
	}
}

Cuando se ejecute el aplicativo del restaurante, ya podremos probar los endpoint e interactuar con la base de datos de clientes. Para las pruebas se utilizo Postman para consumir los endpoint. Se adjunta imágenes con la prueba de guardar un cliente y obtener el registro con el endpoint que retorna todo los clientes.

Como se observa en la imagen, se realizo la petición para guardar el registro y el endpoint devolvió el estado 201, así como se había configurado que retornara cuando registrara un cliente. Ahora devolveremos el registro que hemos guardado.

Como observamos con Spring Boot, ya tenemos todo preconfigurado solamente para crear cualquier aplicación, solamente falta imaginación. Con tan poco código, realizamos la creación de endpoint y consultas a la base de datos,  Spring Boot nos facilita la vida al momento de utilizarlo por eso se ha vuelto muy utilizado en muchos proyectos y no se diga con los microservicios. Espero les sirva el conocimiento y aprovechar lo máximo de este genial Framework.

Saludos,

#HappyCode

Compartir:
Categorías: ProgramaciónTutoriales

0 comentarios

Deja una respuesta

Marcador de posición del avatar

Tu dirección de correo electrónico no será publicada.

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.