Spring Boot REST JPA y MySQL
En este tutorial aprenderás a crear una aplicación web Java utilizando Spring Boot REST JPA y MySQL.
¿Qué es JPA? Java Persistence API, API de Persistencia en Java. Es un conjunto de definiciones y protocolos (interfaz) desarrollada para Java EE. Se utiliza para mapear y persistir datos en una base de datos relacional. Muy ligado a JPA está hibernate, que es un framework que puede implementar las especificaciones de JPA.
¿Qué es MySQL? Es un sistema gestor de base de datos (SGBD) y a través de él se pueden realizar operaciones CRUD (Crear, Leer, Actualizar y Borrar) sobre una base de datos relacional.
Crear Base de Datos
A la hora de crear la base de datos en local, yo he elegido el software oficial de MySQL, aunque existen muchos programas que podemos utilizar de uso gratuito, como XAMP o MariaDB.
Comenzaremos por la instalación del programa MySQL Installer (instalador que ayudará a configurar el servidor MySQL) y MySQL Workbench (cliente de la base de datos), que se puede descargar desde su web oficial en las direcciones siguientes:
MySQL Installer: https://dev.mysql.com/downloads/installer/
MySQL Workbench: https://dev.mysql.com/downloads/workbench/
Si tenéis dudas a la hora de instalar MySQL os recomiendo este tutorial: https://clicizquierdo.com/cursos-y-tutoriales/bases-de-datos/como-instalar-mysql-y-mysql-workbench/
Una vez instalados los programas, ejecuta MySQL Workbench y crea una base de datos (o esquema) sencillo con una tabla y tres campos. El sql para su creación es el siguiente:
DROP TABLE IF EXISTS `users`;
CREATE TABLE `users` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(45) DEFAULT NULL,
`username` varchar(45) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
Añade algunos registros de prueba a la tabla users.
Crear proyecto
Dirígete a File -> New -> Project y elige Spring Boot -> Spring Boot Starter. Presiona Next.
A continuación, completa los datos para el proyecto y presiona Next:
A continuación, activa las casillas Spring Web Services, Spring Web Starter, MySQL Driver y Spring Data JPA. Pulsa Finish:
Arranca la aplicación (ejecutando el proyecto como Spring Boot App) y observa la salida en la consola de Eclipse. Hay errores:
***************************
APPLICATION FAILED TO START
***************************
Description:
Failed to configure a DataSource: 'url' attribute is not specified and no embedded datasource could be configured.
Reason: Failed to determine a suitable driver class
Action:
Consider the following:
If you want an embedded database (H2, HSQL or Derby), please put it on the classpath.
If you have database settings to be loaded from a particular profile you may need to activate it (no profiles are currently active).
La aplicación está buscando los parámetros de conexión. Para ello, introduce en el fichero application.properties las siguientes líneas:
spring.jpa.hibernate.ddl-auto=update
spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=1234
Ejecuta de nuevo la aplicación y observa que han desaparecido los errores en la consola.
Clases a picar
A continuación añado las clases con el código necesario y el orden en el que se deben crear:
User.java (Clase que define los campos y atributos de la tabla users de nuestra base de datos)
package es.rosamarfil.jpa.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;
import javax.persistence.Table;
@Entity
@Table(name = "users")
public class User implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "name")
private String name;
@Column(name = "username")
private String username;
public User() {
super();
}
public User(Long id, String name, String username) {
super();
this.id = id;
this.name = name;
this.username = username;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
}
UserRepository.java (Interface de tipo Repositorio que nos va a permitir realizar operaciones sobre la base e datos)
package es.rosamarfil.jpa.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import es.rosamarfil.jpa.entity.User;
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}
UserRestController.java (Controlador de operaciones de servicios REST con una instancia de UserRepository definida. En los comentarios de cada operación tenéis un ejemplo de las URLs y datos a usar)
package es.rosamarfil.jpa.controller;
import java.util.List;
import java.util.Optional;
import javax.validation.Valid;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
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.RestController;
import es.rosamarfil.jpa.entity.User;
import es.rosamarfil.jpa.repository.UserRepository;
@RestController
@RequestMapping("/api")
public class UserRestController {
@Autowired
UserRepository userRepository;
// Get All Users
// URL: http://localhost:8080/api/users/1
@GetMapping("/users")
public List<User> getAllUsers() {
return userRepository.findAll();
}
// Create a new User
// URL: http://localhost:8080/api/createUser
// Object json: {"name":"Rosa3333","username":"Marfi3333l"}
@PostMapping("/createUser")
public User createUser(@Valid @RequestBody User user) {
return userRepository.save(user);
}
// Get a User by id
// URL: http://localhost:8080/api/users/1
@GetMapping("/users/{id}")
public User getNoteById(@PathVariable(value = "id") Long id) {
return userRepository.findById(id).orElse(null);
}
// Update a User
// URL: http://localhost:8080/api/updateUser/1
// Object json: {"name":"RosaUpdate","username":"Marfil"}
@PutMapping("/updateUser/{id}")
public User updateUser(@PathVariable(value = "id") Long id, @Valid @RequestBody User userDetails) {
User user = userRepository.findById(id).orElse(null);
user.setName(userDetails.getName());
user.setUsername(userDetails.getUsername());
User updatedNote = userRepository.save(user);
return updatedNote;
}
// Delete a User
// URL: http://localhost:8080/api/deleteUser/6
@DeleteMapping("/deleteUser/{id}")
public ResponseEntity<?> deleteUser(@PathVariable(value = "id") Long id) {
User note = userRepository.findById(id).orElse(null);
userRepository.delete(note);
return ResponseEntity.ok().build();
}
}
SbjpaMyqlApplication.java (Clase principal que ejecuta nuestra aplicación. Ésta es autogenerada de forma automática a la hora de crear el proyecto con Spring Boot. En este caso hemos añadido la anotación @EnableJpaAuditing)
package es.rosamarfil.jpa;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
@EnableJpaAuditing
@SpringBootApplication
public class SbjpaMyqlApplication {
public static void main(String[] args) {
SpringApplication.run(SbjpaMyqlApplication.class, args);
}
}
Una vez creadas todas las clases, ejecuta la aplicación y prueba los servicios creados.
Todo el código desarrollado forma parte del desarrollo BackEnd de una aplicación. En otros tutoriales veremos como acceder a estos servicios desde una aplicación Fron-End tipo Angular. Espero que te haya sido de utilidad este tutorial de Spring Boot REST JPA y MySQL.
¡Gracias por leerme!
