Cómo construir una API Rest con Spring Boot usando MySQL y JPA

Las dependencias de iniciador y probador son el núcleo para crear la aplicación Spring Boot para servir en el servidor.

Ahora, pasemos a APIApplication.java, que es el archivo principal.

package com.rest.API;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ApiApplication {
public static void main(String[] args) {
      SpringApplication.run(ApiApplication.class, args);
   }
}

Aquí el nombre del paquete está en la primera línea del código. Usando ese nombre de paquete, puede importar cualquier clase, método o instancia en otro archivo de paquete.

Después de eso, se importan dos módulos del paquete "org.springframework.boot".

1. Aplicación Primavera
2. Aplicación SpringBoot

Dado que Spring boot es el marco de desarrollo de aplicaciones más reciente de Spring, necesita los paquetes de Spring Application, así como sus paquetes específicos.

Después de eso @SpringBootApplication Se utiliza la anotación. Esta anotación consiste en una anotación que se usa en Spring:

1. @Componente — Le dice al compilador que la siguiente clase es un componente que debe incluirse al compilar toda la aplicación.
2. @ComponentScan — Este hace el Escaneo de qué paquetes vamos a usar en la siguiente clase de Java.
3. @EnableAutoConfiguration — permite que el mecanismo de configuración automática de Spring Boot importe módulos importantes para que se ejecute Spring Boot.

Estas son las anotaciones utilizadas para iniciar la aplicación Spring Boot para que se ejecute en un servidor.

Aquí hay un artículo que he escrito sobre Anotación y sus usos en Java.

Vamos a crear un modelo para nuestros datos

Vamos a crear una clase Modelo para guardar, recuperar, actualizar y eliminar los detalles de un libro.

Para eso, tengo que crear un nuevo paquete llamado modelo y dentro de eso creando un Book.java clase para poner mi código.

package com.rest.API.model;
import javax.persistence.*;
import javax.validation.constraints.NotBlank;
@Entity
@Table(name = "books")
public class Book {
    @Id
    @GeneratedValue
    private Long id;
@NotBlank
    private String book_name;
@NotBlank
    private String author_name;
@NotBlank
    private String isbn;
public Book(){
        super();
    }
public Book(Long id, String book_name, String author_name, String isbn) {
        super();
        this.id = id;
        this.book_name = book_name;
        this.author_name = author_name;
        this.isbn=isbn;
    }
public Long getId() {
        return id;
    }
public void setId(Long id) {
        this.id = id;
    }
public String getBook_name() {
        return book_name;
    }
public void setBook_name(String book_name) {
        this.book_name = book_name;
    }
public String getAuthor_name() {
        return author_name;
    }
public void setAuthor_name(String author_name) {
        this.author_name = author_name;
    }
public String getIsbn() {
        return isbn;
    }
public void setIsbn(String isbn) {
        this.isbn = isbn;
    }
}

Aquí estoy usando JPA (API de persistencia de Java), que es una colección de clases y métodos para almacenar datos continuamente en una base de datos.

@Entidad — usado para indicar que esta clase será una Entidad en la base de datos.

@Mesa — que toma algunos valores como el nombre que le darás a tu tabla

@Id — indica que el id es la clave principal/clave de identificación para esta tabla

@No en blanco — se usa para decir que estos atributos no deben estar en blanco.

Aparte de eso, hay un constructor vacío que tiene un supermétodo para satisfacer las costumbres de JPA. Los métodos getter y setter suelen estar en una clase POJO (objeto Java simple y antiguo ).

Creando el Repositorio

A continuación, vamos a crear un repositorio paquete para gestionar la base de datos en Java.

Cree una interfaz llamada BookRepository.java dentro del repositorio paquete.

package com.rest.API.repository;
import com.rest.API.model.Book;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface BookRepository extends JpaRepository<Book, Long> {
}

He importado el JpaRepository paquete para usar ese repositorio en el BookRepository interfaz conectando mi modelo de Libro codificado más recientemente para hacer CRUD operaciones.

Ya existen métodos incorporados en esos repositorios para realizar operaciones CRUD.

Por ejemplo:

.findAll() - to get All datas
.save()    - to save the got Data
.delete()  - to delete the data

Dentro de la etiqueta <> estamos tomando el nombre del modelo que vamos a usar y el tipo de datos de la clave principal.

@Repositorio :Anotación utilizada para indicar el DAO (objeto de acceso a datos ) componente en la capa de persistencia.

Le dice al compilador que la interfaz usará el Repositorio para realizar actividades en la base de datos.

Creando Controlador y Manejo de Excepciones

Cree un nuevo paquete llamado controlador, y dentro que crea un BookController.java archivo que contiene los puntos finales.

package com.rest.API.controller;

import com.rest.API.exception.BookNotFoundException;
import com.rest.API.model.Book;
import com.rest.API.repository.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;
import javax.validation.Valid;
import java.util.List;

@RestController
public class BookController {

@Autowired
    BookRepository bookRepository;

// Get All Notes
    @GetMapping("/books")
    public List<Book> getAllNotes() {
        return bookRepository.findAll();
    }

// Create a new Note
    @PostMapping("/books")
    public Book createNote(@Valid @RequestBody Book book) {
        return bookRepository.save(book);
    }

// Get a Single Note
    @GetMapping("/books/{id}")
    public Book getNoteById(@PathVariable(value = "id") Long bookId) throws BookNotFoundException {
        return bookRepository.findById(bookId)
                .orElseThrow(() -> new BookNotFoundException(bookId));
    }

// Update a Note
    @PutMapping("/books/{id}")
    public Book updateNote(@PathVariable(value = "id") Long bookId,
                           @Valid @RequestBody Book bookDetails) throws BookNotFoundException {

Book book = bookRepository.findById(bookId)
                .orElseThrow(() -> new BookNotFoundException(bookId));

book.setBook_name(bookDetails.getBook_name());
        book.setAuthor_name(bookDetails.getAuthor_name());
        book.setIsbn(bookDetails.getIsbn());

Book updatedBook = bookRepository.save(book);

return updatedBook;
    }

// Delete a Note
    @DeleteMapping("/books/{id}")
    public ResponseEntity<?> deleteBook(@PathVariable(value = "id") Long bookId) throws BookNotFoundException {
        Book book = bookRepository.findById(bookId)
                .orElseThrow(() -> new BookNotFoundException(bookId));

bookRepository.delete(book);

return ResponseEntity.ok().build();
    }
}

El primer paquete importado es para la excepción Libro no encontrado (para el cual vamos a crear un archivo en un momento).

Explicación de las anotaciones que usamos aquí:

1. RestController: Esta anotación se usa para indicar cada método en la clase anotada como objeto de dominio.

Entonces, ¿qué es el objeto de dominio...?

Simplemente dice que Objeto de dominio ==Objeto comercial.

Suelen estar representados por entidades y objetos de valor relacionados con el punto final que estamos dando para obtener los datos de la base de datos.

2. Autocableado :esta anotación se utiliza para conectar las clases de bean automáticamente.

Para eso, necesita saber acerca de "¿Qué es una clase de frijol...? ”

Básicamente, una clase Java Bean es una clase simple que encapsula muchos objetos en ella.

Este es un artículo que escribí sobre Java Bean Classes.

Las siguientes son las anotaciones de mapeo para que los puntos finales realicen operaciones CRUD.

3. Obtener asignación: Esta es una interfaz que contiene la ruta del punto final para realizar un método Get. Esta interfaz GetMapping utiliza la interfaz RequestMapping que puede tener el método de "ruta, valor, parámetros, encabezados" para realizar el método Get en versiones anteriores de Spring.

Ahora se simplifica usando GetMapping.

4. Asignación posterior :Esta es una interfaz que contiene la ruta del punto final para realizar el método Post.

5. PutMapping: Esta es una interfaz que contiene la ruta del punto final para realizar el método Put para actualizar.

6. Eliminar asignación: Esta es una interfaz que contiene la ruta del punto final para realizar el método Eliminar.

En las líneas finales, probablemente notó la "ResponseEntity ” palabra clave.

¿Qué es eso …??

Es una clase Java que hereda HttpEntity clase para manipular las respuestas HTTP. Si la solicitud de conexión es "OK ” o si hay algún problema, lanzar una excepción de HttpEntity clase.

oElseThrow(): Este es un método que se encuentra en la clase Opcional en Java8 que se introdujo para manejar excepciones. La clase opcional proporciona varios métodos de utilidad para verificar la presencia o ausencia de un objeto, lo que ayuda a lidiar con NullPointerException.

oElseLanzar es un método que devuelve un valor si está presente; de ​​lo contrario, invoca una excepción.

Crear una NotFoundException si no existe tal book_id

Como el método orElseThrow arroja una excepción NotFound. La siguiente es la parte de manejo de excepciones. Cree una excepción BookNotFoundException.java archivo dentro del paquete de excepción.

package com.rest.API.exception;
public class BookNotFoundException extends Exception {
private long book_id;
public BookNotFoundException(long book_id) {
        super(String.format("Book is not found with id : '%s'", book_id));
        }
}

La clase creada extiende la Superclase de Excepción. En el constructor, estoy pasando book_id e imprimiendo la excepción.

Entonces, eso es todo...

Hemos terminado la parte de la API REST. Ahora puede compilar la aplicación (que se explicó en la Parte 1) y hacer algunas pruebas con Postman.

Conectando con la base de datos MySql

Dentro de application.properties de sus recursos carpeta, agregue lo siguiente:

## Spring DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)
spring.datasource.url = jdbc:mysql://localhost:3306/library
spring.datasource.username = root //normally put your MySQL username 
spring.datasource.password = YOUR_MYSQL_PASSWORD
## Hibernate Properties
# The SQL dialect makes Hibernate generate better SQL for the chosen database
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5InnoDBDialect
# Hibernate ddl auto (create, create-drop, validate, update)
spring.jpa.hibernate.ddl-auto = update

Eso es todo.

Hemos creado una API REST básica en Spring Boot. ¡Felicidades!

Si algo está mal o necesita ser corregido, házmelo saber en la sección de comentarios.

Ponte en contacto conmigo en twitter.

¡Feliz codificación!