Semana 7

Sesión 2: API REST con Spring Boot en Java

Spring Boot es un framework que simplifica la creación de aplicaciones Java
basadas en Spring, incluyendo API RESTful. Una API REST en Spring Boot se basa
en los siguientes conceptos:

Controladores REST (@RestController): Se encargan de manejar las

solicitudes HTTP y devolver respuestas en formato JSON.

Manejo de Rutas (@RequestMapping, @GetMapping, @PostMapping, etc.):

Define los endpoints de la API y sus métodos HTTP asociados.

Modelo de Datos (Entidades JPA): Representa los datos que se almacenan en

una base de datos.

Repositorio (JpaRepository): Interfaz que permite la interacción con la base

de datos sin escribir consultas SQL.

Servicios (@Service): Contienen la lógica de negocio para separar la capa de

persistencia del controlador.

Spring Boot Starter (spring-boot-starter-web, spring-boot-starter-data-

jpa): Dependencias que facilitan el desarrollo web y la conexión a bases de
datos.

1. Controladores REST (@RestController)

Los controladores en Spring Boot manejan las solicitudes HTTP y devuelven
respuestas en formato JSON o XML.

¿Qué es @RestController?

Semana 7 1
 @RestController es una combinación de @Controller y @ResponseBody , lo que significa
que:

1. @Controller se usa para definir un componente Spring que maneja solicitudes

web.

2. @ResponseBody convierte automáticamente las respuestas en formato JSON o

XML.

@RestController
@RequestMapping("/api/todos")
public class TodoController {
private final TodoService todoService;

public TodoController(TodoService todoService) {

this.todoService = todoService;
}

@GetMapping
public List<Todo> getAllTodos() {
return todoService.getAllTodos();
}
}

✅ @RestController : Define que esta clase manejará solicitudes REST.

✅ @RequestMapping("/api/todos") : Define el prefijo base para los endpoints.

✅ : Maneja solicitudes GET y devuelve datos en JSON
@GetMapping

automáticamente.

Manejo de Rutas (@RequestMapping, @GetMapping,

@PostMapping, etc.)
Las anotaciones de mapeo en Spring Boot permiten definir rutas y métodos HTTP
asociados.

Semana 7 2
 Tipos de Mapeo

Anotación Método HTTP Propósito

@GetMapping GET Obtener datos
@PostMapping POST Enviar datos (crear recurso)
@PutMapping PUT Actualizar un recurso existente
@DeleteMapping DELETE Eliminar un recurso

@RestController
@RequestMapping("/api/todos")
public class TodoController {

private final TodoService todoService;

public TodoController(TodoService todoService) {

this.todoService = todoService;
}

@GetMapping("/{id}")
public ResponseEntity<Todo> getTodoById(@PathVariable Long id) {
return todoService.getTodoById(id)
.map(ResponseEntity::ok)
.orElse(ResponseEntity.notFound().build());
}

@PostMapping
public Todo createTodo(@RequestBody Todo todo) {
return todoService.createTodo(todo);
}

@PutMapping("/{id}")
public ResponseEntity<Todo> updateTodo(@PathVariable Long id, @Reque
stBody Todo todo) {
return ResponseEntity.ok(todoService.updateTodo(id, todo));

Semana 7 3
 }

@DeleteMapping("/{id}")
public ResponseEntity<Void> deleteTodo(@PathVariable Long id) {
todoService.deleteTodoById(id);
return ResponseEntity.noContent().build();
}
}

✅ : Extrae el ID de la URL.
✅
@PathVariable Long id

: Convierte el JSON recibido en un objeto Todo.

✅
@RequestBody Todo todo

ResponseEntity : Permite devolver códigos HTTP como 200 OK, 404 Not Found, 204
No Content, etc.

Modelo de Datos (Entidades JPA)

Las entidades JPA representan las tablas de la base de datos como objetos en
Java.

@Entity
@Table(name = "todos")
@Getter @Setter @NoArgsConstructor @AllArgsConstructor
public class Todo {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@Column(nullable = false)
private String title;

@Column(nullable = false)

Semana 7 4
 private boolean completed;
}

Repositorio (JpaRepository)
Un repositorio permite interactuar con la base de datos sin necesidad de escribir
SQL.

@Repository
public interface TodoRepository extends JpaRepository<Todo, Long> {
}

La implementación del repositorio con

es completamente funcional y ya incluye todos los métodos
JpaRepository<Todo, Long>

CRUD por defecto. Sin embargo, si necesitas consultas personalizadas, puedes

agregarlas manualmente.

✅
JpaRepository<Todo, Long> proporciona métodos listos para usar:

save(todo) : Guarda un nuevo registro.

findAll() : Obtiene todas las tareas.

findById(id) : Busca una tarea por ID.

deleteById(id) : Elimina una tarea.

✅
@Repository : Indica que esta interfaz es un componente de persistencia.

¿Qué métodos incluye JpaRepository por defecto?

Cuando extiendes JpaRepository<Todo, Long> , obtienes automáticamente métodos
como:

Semana 7 5
 ✅ Operaciones CRUD básicas:
save(T entity) : Guarda o actualiza una entidad.

findById(Long id) : Busca una entidad por su ID.

findAll() : Retorna todas las entidades.

deleteById(Long id) : Elimina una entidad por su ID.

existsById(Long id) : Verifica si una entidad existe.

count() : Retorna el número total de entidades.

Servicios (@Service)
Los servicios en Spring Boot manejan la lógica de negocio y actúan como
intermediarios entre el controlador y el repositorio.

@Service
public class TodoService {
private final TodoRepository todoRepository;

public TodoService(TodoRepository todoRepository) {

this.todoRepository = todoRepository;
}

public List<Todo> getAllTodos() {

return todoRepository.findAll();
}

public Optional<Todo> getTodoById(Long id) {

return todoRepository.findById(id);
}

public Todo createTodo(Todo todo) {

return todoRepository.save(todo);
}

public Todo updateTodo(Long id, Todo todoDetails) {

Semana 7 6
 return todoRepository.findById(id).map(todo -> {
todo.setTitle(todoDetails.getTitle());
todo.setCompleted(todoDetails.isCompleted());
return todoRepository.save(todo);
}).orElseThrow(() -> new RuntimeException("Tarea no encontrada"));
}

public void deleteTodoById(Long id) {

todoRepository.deleteById(id);
}
}

✅ : Marca la clase como un servicio de negocio.

@Service

✅ Separa la lógica de negocio del controlador.

✅ Maneja excepciones si una tarea no se encuentra.

Configuración BD

1. Instalar MySQL y Crear una Base de Datos

CREATE DATABASE todoapp;

USE todoapp;

Agregar Dependencias en pom.xml

Modifica el archivo pom.xml para incluir el conector de MySQL y JPA.

<dependencies>
<!-- Spring Web -->
<dependency>

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

<!-- Spring Data JPA -->

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

<!-- MySQL Driver -->

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>

Configurar la Conexión en application.properties

Modifica el archivo src/main/resources/application.properties para indicar los datos de
conexión:

# Configuración de la base de datos

spring.datasource.url=jdbc:mysql://localhost:3306/todoapp?useSSL=false&se
rverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=tu_contraseña

# Configuración de Hibernate (JPA)

spring.jpa.database-platform=org.hibernate.dialect.MySQL8Dialect
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

Semana 7 8
 ✅ Explicación:
spring.datasource.url : URL de conexión a la base de datos ( localhost , puerto 3306 ).

spring.datasource.username : Usuario de MySQL.

spring.datasource.password : Contraseña del usuario.

spring.jpa.database-platform : Indica el dialecto de MySQL para Hibernate.

spring.jpa.hibernate.ddl-auto=update :

create : Crea la BD desde cero en cada ejecución.

update : Modifica la BD sin perder datos.

validate : Verifica que la BD coincida con las entidades.

none : No hace cambios en la BD.

spring.jpa.show-sql=true : Muestra las consultas SQL en la consola.

Crear la Entidad JPA

Define una entidad Todo que se mapeará a una tabla en la base de datos.

@Entity
@Table(name = "todos")
@Getter @Setter @NoArgsConstructor @AllArgsConstructor
public class Todo {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@Column(nullable = false)
private String title;

@Column(nullable = false)

Semana 7 9
 private boolean completed;
}

✅ Explicación:
@Entity : Marca la clase como una entidad JPA.

@Table(name = "todos") : Define el nombre de la tabla en MySQL.

@Id @GeneratedValue(strategy = GenerationType.IDENTITY) : Usa un ID autoincremental.

@Column(nullable = false) : Indica que el campo es obligatorio.

5. Crear el Repositorio JPA

Proyecto: Todo App - Java

spirng initializr
https://www.youtube.com/watch?v=M7lhQMzzHWU

https://www.youtube.com/watch?v=3cJeqk3RYyM

1. Creación del Proyecto y Definición del Modelo de Datos

Archivo: Todo.java (Entidad JPA)

package com.example.todoapp.model;

import jakarta.persistence.*;
import lombok.*;

@Entity
@Table(name = "todos")
@Getter @Setter @NoArgsConstructor @AllArgsConstructor
public class Todo {
@Id

Semana 7 10
 @GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@Column(nullable = false)
private String title;

@Column(nullable = false)
private boolean completed;
}

@Entity : Define la clase como una entidad JPA.

@Table(name = "todos") : Asigna un nombre a la tabla.

@Id , @GeneratedValue : Configura la clave primaria.

@Column : Define restricciones en los atributos.

Uso de Lombok ( @Getter , @Setter , @NoArgsConstructor , @AllArgsConstructor ) para

reducir código repetitivo.

2. Creación del Repositorio para Acceso a Datos

Archivo: TodoRepository.java

package com.example.todoapp.repository;

import com.example.todoapp.model.Todo;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository

Semana 7 11
 public interface TodoRepository extends JpaRepository<Todo, Long> {
}

JpaRepository<Todo, Long> proporciona métodos como save() , findAll() , findById() ,

deleteById() sin necesidad de escribir consultas SQL.

@Repository : Marca la interfaz como un componente de acceso a datos.

3. Implementación del Servicio para Lógica de Negocio

Archivo: TodoService.java

package com.example.todoapp.service;

import com.example.todoapp.model.Todo;
import com.example.todoapp.repository.TodoRepository;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;

@Service
public class TodoService {
private final TodoRepository todoRepository;

public TodoService(TodoRepository todoRepository) {

this.todoRepository = todoRepository;
}

public List<Todo> getAllTodos() {

return todoRepository.findAll();
}

public Optional<Todo> getTodoById(Long id) {

return todoRepository.findById(id);
}

Semana 7 12
 public Todo createTodo(Todo todo) {
return todoRepository.save(todo);
}

public Todo updateTodo(Long id, Todo todoDetails) {

return todoRepository.findById(id).map(todo -> {
todo.setTitle(todoDetails.getTitle());
todo.setCompleted(todoDetails.isCompleted());
return todoRepository.save(todo);
}).orElseThrow(() -> new RuntimeException("Tarea no encontrada"));
}

public void deleteTodoById(Long id) {

todoRepository.deleteById(id);
}
}

Explicación
getAllTodos() : Obtiene todas las tareas.

getTodoById(Long id) : Busca una tarea específica.

createTodo(Todo todo) : Guarda una nueva tarea.

updateTodo(Long id, Todo todoDetails) : Modifica una tarea existente.

deleteTodoById(Long id) : Elimina una tarea.

4. Creación del Controlador REST

Archivo: TodoController.java

package com.example.todoapp.controller;

import com.example.todoapp.model.Todo;
import com.example.todoapp.service.TodoService;

Semana 7 13
 import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/todos")
public class TodoController {
private final TodoService todoService;

public TodoController(TodoService todoService) {

this.todoService = todoService;
}

@GetMapping
public List<Todo> getAllTodos() {
return todoService.getAllTodos();
}

@GetMapping("/{id}")
public ResponseEntity<Todo> getTodoById(@PathVariable Long id) {
return todoService.getTodoById(id)
.map(ResponseEntity::ok)
.orElse(ResponseEntity.notFound().build());
}

@PostMapping
public Todo createTodo(@RequestBody Todo todo) {
return todoService.createTodo(todo);
}

@PutMapping("/{id}")
public ResponseEntity<Todo> updateTodo(@PathVariable Long id, @Reque
stBody Todo todo) {
try {
Todo updatedTodo = todoService.updateTodo(id, todo);

Semana 7 14
 return ResponseEntity.ok(updatedTodo);
} catch (RuntimeException e) {
return ResponseEntity.notFound().build();
}
}

@DeleteMapping("/{id}")
public ResponseEntity<Void> deleteTodo(@PathVariable Long id) {
todoService.deleteTodoById(id);
return ResponseEntity.noContent().build();
}
}

Explicación
@RestController : Indica que este controlador maneja peticiones REST.

@RequestMapping("/api/todos") : Define el prefijo para todos los endpoints.

@GetMapping : Obtiene todas las tareas.

@GetMapping("/{id}") : Obtiene una tarea específica.

@PostMapping : Crea una nueva tarea.

@PutMapping("/{id}") : Actualiza una tarea existente.

@DeleteMapping("/{id}") : Elimina una tarea.

Semana 7 15