Cuando arrancamos un proyecto nuevo, la configuración inicial del backend puede resultar algo compleja y llevar más tiempo del deseado. En este artículo te enseñamos una forma sencilla de montar un servidor REST con Java y Spring Boot.
Introducción
En WATA Factory usamos Java de forma bastante habitual, tanto en proyectos propios como en los de nuestros clientes. A pesar de (o quizá gracias a) sus más de 25 años de historia, Java sigue siendo un lenguaje ampliamente utilizado.
Aunque hoy en día hay alternativas mejores para el frontend —como Angular (con TypeScript), React (con JavaScript) o Flutter (con Dart)—, Java sigue siendo una de las opciones más sólidas para el desarrollo del backend. De hecho, para aplicaciones grandes a nivel empresarial, sigue siendo prácticamente el estándar del sector.
Evidentemente, nadie empieza una aplicación desde cero sin apoyarse en frameworks. En Java hay varios, y elegir el más adecuado depende de los requisitos del proyecto:
- Jakarta EE (antes Java EE): para aplicaciones empresariales de gran escala
- Hibernate: framework de mapeo objeto-relacional (ORM), simplifica el trabajo con bases de datos usando JPA
- Quarkus: ideal para cloud y microservicios, muy ligero
- Spring: probablemente el más popular, muy usado en microservicios y apps REST
En este artículo nos vamos a centrar en Spring, más concretamente en Spring Boot, que se basa en Spring pero está diseñado para simplificar el desarrollo de aplicaciones independientes y listas para producción.
¿Por qué Spring Boot?
Antes, al empezar una aplicación desde cero con Java EE o con Spring a secas, era necesario configurar muchas cosas a mano y escribir bastante código repetitivo. Además de gestionar las dependencias y asegurarse de que todo funcionaba, también había que desplegar la aplicación en un servidor, lo cual podía complicar aún más las cosas.
Para proyectos grandes, esa configuración detallada puede estar justificada. Pero en proyectos más pequeños, todo ese trabajo es un lastre innecesario.
Ahí es donde entra Spring Boot. Su objetivo es facilitar el desarrollo de aplicaciones independientes y preparadas para producción. ¿Cómo lo consigue? Aplicando el principio de “Convención sobre configuración” y eliminando la necesidad de configuraciones complejas.
Convención sobre configuración
Este principio significa que Spring Boot ya viene con valores por defecto razonables para muchas cosas que normalmente habría que configurar a mano. Por ejemplo, incluye un servidor Tomcat embebido listo para usar, sin que tengas que tocar nada.
También detecta automáticamente las dependencias y configura los componentes necesarios según lo que encuentre en el classpath. Así se reduce mucho el código repetitivo y se puede empezar a ser productivo mucho antes.
Spring Boot Initializr
Una herramienta muy útil de Spring Boot para empezar con buen pie es el Spring Boot Initializr. Es una web que permite configurar y generar un proyecto completo en pocos clics, evitando la configuración manual y dándote una estructura lista para usar.
Crear una aplicación de prueba
Vamos a crear una aplicación sencilla con Spring Boot usando el Initializr.
- Elige el sistema de gestión de proyectos. Como vamos a usar Java, elegimos Maven (también se puede usar Gradle, que es menos verboso y más flexible, pero Maven es más probado y tiene plugins para todo).
- Selecciona el lenguaje: Java.
- Selecciona la versión de Spring Boot. Por defecto te propone la versión estable más reciente, que suele ser la mejor opción.
- Rellena los metadatos. Para esta demo, puedes dejar los valores por defecto.
- Elige el tipo de empaquetado: seleccionamos JAR, lo que generará un archivo ejecutable.
- Elige la versión de Java que tengas instalada.
Ahora viene lo más interesante: en el lado derecho, pulsa en “Add Dependencies”. Aquí puedes añadir todas las dependencias necesarias sin tener que buscar en Maven Central. Cada una viene con una breve descripción.
Para nuestra demo, seleccionamos:
- Spring Web: para crear endpoints REST fácilmente. Incluye Tomcat embebido por defecto.
- Spring Boot DevTools: herramientas útiles para desarrollo como recarga automática o arranque más rápido.
- Lombok: evita tener que escribir setters y getters a mano.
- Spring Data JPA: conectividad con bases de datos usando JPA.
- H2 Database: base de datos en memoria para hacer pruebas rápidas.
Haz clic en “Generate” para descargar el proyecto en un archivo .zip. Descomprímelo y ábrelo con tu IDE favorito. Nosotros usaremos IntelliJ.
El Initializr habrá generado varios archivos y carpetas, pero los más importantes son:
- src/main/java/com/example/demo/DemoApplication.java: clase principal de la app. Ejecuta este archivo para arrancarla.
- src/main/resources/application.properties: archivo de configuración. También se puede usar YAML.
- pom.xml: aquí se gestionan las dependencias y los plugins de compilación.
Crear el primer endpoint
Con todo preparado, vamos a crear un endpoint muy simple que solo devuelve un texto.
Crea un archivo nuevo en el mismo paquete que DemoApplication.java y llámalo HelloWataController.java, con este contenido:
package com.example.demo;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/hello")
public class HelloWataController {
@GetMapping
public String sayHello() {
return "Hello WATA Factory!";
}
}
¡Y ya está! Ejecuta DemoApplication.java para arrancar la aplicación (puede que tengas que hacer un clean e install de Maven antes).
Abre el navegador y entra en http://localhost:8080/hello. Deberías ver el texto “Hello WATA Factory!” en pantalla.
Añadir una base de datos
Ahora vamos a añadir soporte para base de datos. Por eso elegimos H2 en el Initializr. Esta base es en memoria, así que se borra cada vez que cierres la app, pero el proceso es el mismo para cualquier base SQL.
Vamos a leer datos de una base de libros. Primero, añade esto en application.properties:
spring.application.name=demo
spring.h2.console.enabled=true
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=update
Definir la entidad
Crea un paquete nuevo dentro de com.example.demo llamado book, y dentro un archivo Book.java con este contenido:
@Entity
@Getter
@Setter
public class Book {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String title;
private String author;
}
Esta clase representa la tabla book. Las anotaciones de Lombok (@Getter, @Setter) generan automáticamente los métodos correspondientes.Esta clase representa la tabla book. Las anotaciones de Lombok (@Getter, @Setter) generan automáticamente los métodos correspondientes.
Ahora crea el repositorio BookRepository.java:
public interface BookRepository extends JpaRepository<Book, Long> { }
public interface BookRepository extends JpaRepository<Book, Long> { }Crear el servicio
En una arquitectura en tres capas, no se accede directamente al repositorio desde el controlador. Se usa una capa intermedia de servicio. Crea BookService.java:
@Service
public class BookService {
@Autowired
private BookRepository bookRepository;
public List<Book> getAllBooks() {
return bookRepository.findAll();
}
public Book getBookById(Long id) {
return bookRepository.findById(id).orElse(null);
}
public void deleteBook(Long id) {
bookRepository.deleteById(id);
}
}
Los métodos de bookRepository ya funcionan sin necesidad de implementarlos, otro ejemplo del enfoque de Spring Boot: si sigues sus convenciones, todo encaja.
Crear el controlador
Vamos a exponer tres endpoints REST, uno para cada método del servicio. Crea BookController.java:
@RestController
@RequestMapping("/api/books")
public class BookController {
@Autowired
private BookService bookService;
@GetMapping
public List<Book> getAllBooks() {
return bookService.getAllBooks();
}
@GetMapping("/{id}")
public Book getBookById(@PathVariable Long id) {
return bookService.getBookById(id);
}
@DeleteMapping("/{id}")
public void deleteBook(@PathVariable Long id) {
bookService.deleteBook(id);
}
}
Añadir datos a la base de datos
Arranca la app. Como la base es en memoria, se vacía al cerrar. Puedes añadir datos manualmente entrando en http://localhost:8080/h2-console y ejecutando:
INSERT INTO BOOK VALUES(1, 'George Orwell', '1984');
INSERT INTO BOOK VALUES(2, 'J.R.R. Tolkien', 'The Lord of the Rings');
INSERT INTO BOOK VALUES(3, 'Franz Kafka', 'Metamorphosis');
¿Quieres evitar añadirlos a mano cada vez? Guarda estos INSERT en un archivo llamado data.sql en src/main/resources, y cambia la URL en application.properties a:
spring.datasource.url=jdbc:h2:mem:testdbTo
spring.datasource.url=jdbc:h2:file:./data/demoAsí los inserts se ejecutarán automáticamente al arrancar. Otro ejemplo más de cómo Spring Boot te facilita la vida si usas sus convenciones.
Probar la aplicación
Ya con datos en la base, toca probar los endpoints. Puedes usar Postman para lanzar peticiones GET y DELETE, o usar curl desde la línea de comandos.
Llamar a http://localhost:8080/api/books devolverá todos los libros.
Si haces un GET a http://localhost:8080/api/books/2, obtendrás solo el libro con ID 2.
Haz una petición DELETE a /api/books/2 y luego vuelve a listar todos los libros para comprobar que se ha borrado correctamente.
¡Y listo! Todo funciona como debe.
Conclusión
En WATA Factory seguimos confiando en Java para nuestros backends, tanto internos como de cliente. Aunque a veces se le acusa de ser más pesado de configurar que alternativas como NodeJS, con este artículo queríamos mostrar que con muy poco código se puede tener un servidor funcionando y empezar a trabajar desde el minuto uno.
