API REST con Java y Spring
Web, pasos esenciales.
Imaginemos este escenario:
Bueno, quiero crear una API REST con Java y Spring Web, pero
no sé por dónde empezar. He oído que Spring es un framework
muy útil para esto, así que supongo que es una buena elección.
Primero, necesito entender qué es una API REST. Creo que es
una forma de que diferentes sistemas se comuniquen entre sí
mediante HTTP, usando métodos como GET, POST, PUT y DELETE.
Empezaré pensando en qué tipo de proyecto quiero. Quizás algo
simple, como una API para gestionar libros. Tendría que
almacenar libros con su título, autor y género. Luego, las
operaciones CRUD: crear, leer, actualizar y eliminar.
Ahora, cómo configurar el proyecto. He oído que Spring
Initializr es una buena herramienta para empezar. Iré a su
sitio web y seleccionaré las dependencias necesarias. Necesito
Spring Web para crear la API REST y Spring Data JPA para
interactuar con la base de datos. También necesito una base de
datos, quizás H2 para pruebas porque es sencilla.
Después de configurar el proyecto, me descargará un archivo
ZIP que tendré que descomprimir en mi entorno de desarrollo.
Usaré IntelliJ IDEA porque me gusta su interfaz.
La estructura del proyecto: veré que hay una clase principal
con @SpringBootApplication. Esa debe ser la clase que inicia
la aplicación. Luego, crearé un modelo de datos. Haceré una
clase Book con los campos id, title, author, genre y los
getters y setters. También necesito anotaciones JPA como
@Entity y @Table para que sepa que es una entidad de base de
datos.
El siguiente paso es crear un repositorio. Usaré JpaRepository
porque me da métodos CRUD ya implementados. Crearé una
interfaz BookRepository que extienda de JpaRepository,
indicando los tipos que manejará.
Luego, debo crear el servicio. Haceré una clase BookService
con métodos para obtener todos los libros, uno por id,
guardar, actualizar y eliminar. Inyectaré el repositorio en el
servicio usando @Autowired para que Spring se encargue de la
inyección de dependencias.
Finalmente, crearé el controlador. Usaré @RestController y
@RequestMapping para indicar la ruta base. Los métodos del
controlador usarán @GetMapping, @PostMapping, etc., para
manejar las diferentes solicitudes HTTP. Cada método llamará
al servicio correspondiente.
Ahora, probaré la aplicación. Configuraré la base de datos en
[Link] con H2. Arrancaré la aplicación y usaré
Postman para hacer pruebas. Primero, un GET a /api/books para
ver si está funcionando. Luego, probaré POST para crear un
libro, PUT para actualizar y DELETE para eliminar.
Si todo funciona, habré creado una API REST básica con Java y
Spring Web. Pero quizás quiero añadir validaciones o
excepciones para manejar errores. También podría implementar
paginación o seguridad si es necesario.
Por ahora, empezar con algo simple y luego ir añadiendo más
funcionalidades a medida que aprendo más sobre Spring y REST.
Para crear una API REST con Java y Spring Web, sigue estos
pasos detallados:
1. Configurar el Proyecto
Usar Spring Initializr : Ve al sitio web Spring
Initializr. Selecciona:
Proyecto: Maven Project
Lenguaje: Java
Versión de Spring: La más reciente (por ejemplo,
3.1.5)
Nombre del paquete: [Link]
Dependencias:
Spring Web
Spring Data JPA
H2 Database (para una base de datos en
memoria)
Spring Boot DevTools (opcional, para recarga
en caliente)
Descargar y Configurar: Descarga el proyecto ZIP,
descomprímelo y ábrelo en tu IDE (por ejemplo, IntelliJ
IDEA).
2. Crear el Modelo de Datos
En el paquete [Link], crea una clase Book:
package [Link];
import [Link].*;
@Entity
@Table(name = "books")
public class Book {
@Id
@GeneratedValue(strategy = [Link])
private Long id;
private String title;
private String author;
private String genre;
// Constructores, Getters y Setters
public Book() {}
public Book(String title, String author, String genre) {
[Link] = title;
[Link] = author;
[Link] = genre;
}
public Long getId() { return id; }
public void setId(Long id) { [Link] = id; }
public String getTitle() { return title; }
public void setTitle(String title) { [Link] = title; }
public String getAuthor() { return author; }
public void setAuthor(String author) { [Link] =
author; }
public String getGenre() { return genre; }
public void setGenre(String genre) { [Link] = genre; }
}
3. Crear el Repositorio
En el paquete [Link], crea una
interfaz BookRepository:
package [Link];
import [Link];
import [Link];
import [Link];
@Repository
public interface BookRepository extends JpaRepository<Book,
Long> {
}
4. Crear el Servicio
En el paquete [Link], crea una
clase BookService:
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
@Service
public class BookService {
private final BookRepository bookRepository;
@Autowired
public BookService(BookRepository bookRepository) {
[Link] = bookRepository;
}
public List<Book> getAllBooks() {
return [Link]();
}
public Optional<Book> getBookById(Long id) {
return [Link](id);
}
public Book saveBook(Book book) {
return [Link](book);
}
public Book updateBook(Book book) {
return [Link](book);
}
public void deleteBook(Long id) {
[Link](id);
}
}
5. Crear el Controlador
En el paquete [Link], crea una
clase BookController:
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link].*;
import [Link];
import [Link];
@RestController
@RequestMapping("/api/books")
public class BookController {
private final BookService bookService;
@Autowired
public BookController(BookService bookService) {
[Link] = bookService;
}
@GetMapping
public ResponseEntity<List<Book>> getAllBooks() {
List<Book> books = [Link]();
return new ResponseEntity<>(books, [Link]);
}
@GetMapping("/{id}")
public ResponseEntity<?> getBookById(@PathVariable Long
id) {
Optional<Book> book = [Link](id);
if ([Link]()) {
return new ResponseEntity<>([Link](),
[Link]);
} else {
return new ResponseEntity<>(HttpStatus.NOT_FOUND);
}
}
@PostMapping
public ResponseEntity<Book> saveBook(@RequestBody Book
book) {
Book newBook = [Link](book);
return new ResponseEntity<>(newBook,
[Link]);
}
@PutMapping("/{id}")
public ResponseEntity<?> updateBook(@PathVariable Long id,
@RequestBody Book book) {
Optional<Book> existingBook =
[Link](id);
if ([Link]()) {
Book updatedBook = [Link]();
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
Book bookUpdated =
[Link](updatedBook);
return new ResponseEntity<>(bookUpdated,
[Link]);
} else {
return new ResponseEntity<>(HttpStatus.NOT_FOUND);
}
}
@DeleteMapping("/{id}")
public ResponseEntity<?> deleteBook(@PathVariable Long id)
{
[Link](id);
return new ResponseEntity<>(HttpStatus.NO_CONTENT);
}
}
6. Configurar la Base de Datos
En el archivo [Link] (en src/main/resources),
agrega:
[Link]=jdbc:h2:mem:library
[Link]=[Link]
[Link]=sa
[Link]=
[Link]=true
[Link]=/h2-console
[Link]-auto=update
[Link]-sql=true
[Link].format_sql=true
[Link]=[Link].
H2Dialect
7. Iniciar la Aplicación
En la clase principal LibraryApplication:
package [Link];
import [Link];
import
[Link];
@SpringBootApplication
public class LibraryApplication {
public static void main(String[] args) {
[Link]([Link], args);
}
}
En intelliJ IDEA utiliza el botón «Run» ▶️ para correr la
aplicación.
Ejecuta el proyecto con Maven en la consola
Si estás usando Maven:
mvn spring-boot:run
Ejecutar con el plugin de Maven en IntelliJ
Si tienes problemas, puedes ejecutar de igual forma desde la
pestaña Maven en IntelliJ:
1. Abre la pestaña Maven (a la derecha).
2. Ve a [Link] > Plugins > spring-boot.
3. Haz doble clic en spring-boot:run para ejecutarlo desde
ahí.
8. Probar la API
Usa una herramienta como Postman o cURL para probar las
endpoints agregando y consultando libros:
GET [Link] Lista todos los
libros.
GET [Link] Obtiene un libro
por ID.
POST [Link] Crea un nuevo
libro.
PUT [Link] Actualiza un
libro existente.
DELETE [Link] Elimina un
libro.
Agrega con el método POST un libro:
{
"title": "Don Quijote de la Mancha",
"author": "Miguel de Cervantes",
"genre": "Novela"
}
Consulta la API con el método GET:
9. Acceso a H2 Console
Accede a la consola H2 en [Link]
console para ver la base de datos.
10. Documentación Adicional
Puedes generar documentación con Swagger agregando la
dependencia de Springdoc en tu [Link]:
<dependency>
<groupId>[Link]</groupId>
<artifactId>springdoc-openapi-starter-webmvc-
ui</artifactId>
<version>2.2.0</version>
</dependency>
Accede a la documentación
en [Link]
¡Listo! Ahora tienes una API REST funcional con CRUD completo
usando Java y Spring Web.
Ampliando Spring 3 y su integración
con bases de datos
En el contexto de Spring 3 y su integración con bases de
datos, el uso de [Link].* es fundamental debido a
su relación con la Java Persistence API (JPA). A continuación,
te explico su importancia en Spring 3 ya que jakarta viene a
sustituir el anterior paquete javax:
1. ¿Qué es JPA?
La Java Persistence API (JPA) es una especificación de Java
para interactuar con bases de datos relacionales mediante
objetos de negocio (entities). Actúa como una capa de
abstracción entre el código Java y la base de datos,
permitiendo interactuar con la base de datos de manera más
simple y consistente.
2. Importancia
de [Link].* en Spring 3
a. Abstracción de la Base de Datos
JPA permite interactuar con la base de datos de manera
independiente del proveedor específico (MySQL,
PostgreSQL, H2, etc.). Esto se logra mediante el uso
de ORM (Object-Relational Mapping), que traduce objetos
Java en registros de la base de datos y viceversa.
En el ejemplo anterior, las anotaciones
como @Entity, @Table, @Id, @GeneratedValue, etc., son
parte de JPA y permiten definir la estructura de la base
de datos a través de clases Java.
b. Portabilidad
Las anotaciones [Link].* son estándar y no
dependen de un proveedor específico. Esto significa que
puedes cambiar de base de datos (por ejemplo, de H2 a
PostgreSQL) sin modificar tu código, solo ajustando la
configuración.
c. Integración con Spring Data JPA
Spring Data JPA es una capa sobre JPA que simplifica la
implementación de operaciones CRUD (Crear, Leer,
Actualizar, Eliminar). Al usar JPA, Spring Data JPA
puede generar automáticamente las consultas necesarias
para interactuar con la base de datos.
En el ejemplo anterior, la
interfaz BookRepository extiende de JpaRepository, lo
que permite usar operaciones CRUD sin necesidad de
implementarlas manualmente.
d. Lazy Loading y Caching
JPA soporta lazy loading, lo que evita cargar datos
relacionados innecesariamente, mejorando el rendimiento
de la aplicación.
Además, JPA puede integrar con cachés para optimizar el
acceso a datos frecuentemente solicitados.
e. Consistencia en el Código
Al usar JPA, el código es más limpio y mantenible. Por
ejemplo, no necesitas escribir consultas SQL a mano, lo
que reduce la posibilidad de errores y mejora la
legibilidad del código.
f. Soporte para Transacciones
JPA integra perfectamente con el manejo de transacciones
de Spring, lo que garantiza la integridad de los datos
durante las operaciones de base de datos.
g. Actualizaciones y Mantenibilidad
La transición a [Link].* en lugar
de [Link].* es importante porque:
[Link].* es la antigua ubicación de las
clases JPA, que pertenecía a Oracle.
Desde Java EE 8, JPA se ha movido
a [Link].* como parte de la
transición a Jakarta EE (anteriormente conocida
como Java EE).
En Spring 3, el soporte
para [Link].* está en desuso, y se
recomienda usar [Link].* para evitar
problemas de compatibilidad.
3. Ventajas de Usar JPA en Spring 3
Reducir código boilerplate: JPA elimina la necesidad de
escribir consultas SQL y código JDBC manualmente.
Mejor mantenibilidad: Si necesitas cambiar de base de
datos, solo necesitas modificar la configuración, no el
código.
Integración con Spring Data: Spring Data JPA simplifica
la implementación de operaciones CRUD.
Soporte para relaciones entre entidades: JPA admite
relaciones como @OneToMany, @ManyToMany, etc., que son
comunes en aplicaciones reales.
4. Ejemplo de Uso en el Código
En el ejemplo anterior, las
anotaciones [Link].* se usaron para definir la
entidad Book:
package [Link];
import [Link].*;
@Entity
@Table(name = "books")
public class Book {
@Id
@GeneratedValue(strategy = [Link])
private Long id;
private String title;
private String author;
private String genre;
// Getters y Setters
}
@Entity: Indica que Book es una entidad JPA, es decir,
una clase que se mapeará a una tabla en la base de
datos.
@Table: Especifica el nombre de la tabla en la base de
datos.
@Id: Indica que el campo id es la clave primaria de la
tabla.
@GeneratedValue: Configura la estrategia para generar
valores automáticos para la clave primaria.
5. Resumen
El uso de [Link].* en Spring 3 es esencial
porque:
1. Proporciona una capa de abstracción para interactuar con
la base de datos de manera independiente del proveedor.
2. Simplifica la implementación de operaciones CRUD
mediante Spring Data JPA.
3. Garantiza la portabilidad del código entre diferentes
bases de datos.
4. Reduce la cantidad de código boilerplate y mejora la
mantenibilidad de la aplicación.
5. Es el estándar actualizado para JPA en Spring 3,
reemplazando a las antiguas [Link].*.
En resumen, JPA es una herramienta fundamental para cualquier
aplicación Spring que requiera interactuar con una base de
datos relacional de manera eficiente y mantenible.