SpringBoot CRUD

¿Qué son las operaciones CRUD?

CRUD Representa Creación, lectura/Recuperación, actualizacióny eliminarEstas son las cuatro funciones básicas de almacenamiento persistente.

Se puede definir CRUD como un acuerdo de interfaz de usuario, que permite ver, buscar y modificar información a través de formularios y informes basados en computadora. CRUD es orientado a datos, es Verbo de acción HTTPUso estándar. HTTP tiene algunos verbos importantes.

POST: crear recursos nuevos GET: leer recursos PUT: actualizar recursos existentes DELETE: eliminar recursos

en la base de datos, cada una de estas operaciones se mapea directamente a una serie de comandos. Sin embargo, su relación con las API RESTful es un poco más compleja.

operaciones CRUD estándar

operación de creación: ejecuta una sentencia INSERT para crear un nuevo registro. operación de lectura: lee los registros de la tabla basándose en los parámetros de entrada. operación de actualización: ejecuta una sentencia UPDATE en la tabla. Se basa en los parámetros de entrada. operación de eliminación: eliminará las filas especificadas de la tabla. También se basa en los parámetros de entrada.

cómo funcionan las operaciones CRUD

Las operaciones CRUD son la base más dinámica de los sitios web. Por lo tanto, deberíamos CRUD y HTTP verbos de accióndiferenciar

supongamos que queremos crearun nuevo registro, deberíamos usar el verbo de operación HTTP POST . Para actualizarun registro, deberíamos usar PUT verbo. Del mismo modo, si desea eliminarsi desea eliminar un registro, debe usar DELETE verbos. A través de operaciones CRUD, los usuarios y administradores tienen derechos para recuperar, crear, editar y eliminar registros en línea.

Tenemos muchas opciones para ejecutar operaciones CRUD. Una de las más efectivas es crear un conjunto de procedimientos almacenados en SQL para ejecutar las operaciones.

Las operaciones CRUD se refieren a todas las principales funciones implementadas en aplicaciones de bases de datos de relaciones. Cada letra de CRUD puede mapearse a una sentencia SQL y un método HTTP.

Spring Boot CrudRepository

Spring Boot proporciona una interfaz llamada CrudRepository la interfaz, que contiene métodos para operaciones CRUD. Se encuentra en el paquete org.springframework.data.repository definida. Extiende Spring Data almacenamientointerfaz. Proporciona operaciones Crud genéricas en el repositorio. Si se desea utilizar CrudRepository en la aplicación, debe crear una interfaz y extender CrudRepository .

sintaxis

public interface CrudRepository<T,ID> extends Repository<T,ID>

donde

T es el tipo de dominio administrado por el repositorio. ID es el tipo de ID de entidad administrada por el repositorio.

Por ejemplo:

public interface StudentRepository extends CrudRepository<Student, Integer>
{
}

En el ejemplo anterior, creamos un repositorio llamado StudentRepository la interfaz, que extiende CrudRepository. Donde Student es el repositorio que se debe gestionar, y Integer es el tipo de ID definido en el repositorio de Student.

Spring boot JpaRepository

JpaRepository proporciona métodos relacionados con JPA, como refrescar, contexto de persistencia y eliminar un registro en lote. Está en el paquete Definido en org.springframework.data.jpa.repository. JpaRepository extiende CrudRepository y PagingAndSortingRepository.

Por ejemplo:

public interface BookDAO extends JpaRepository　
{
}

¿Por qué usar estos interfaces?

Estos interfaces permiten que Spring busque interfaces de repositorio y cree objetos proxy para ellos. Proporciona métodos que nos permiten realizar algunas operaciones comunes. También podemos definir métodos personalizados.

CrudRepository y JpaRepository

Ejemplo de operación CRUD de Spring Boot

Configuraremos una aplicación de Spring Boot y realizaremos operaciones CRUD.

pasos1: Abra Spring Initializr http://start.spring.io .

pasos2: Elija la versión de Spring Boot 2.3.0.M1.

pasos2: GroupNombre. Hemos proporcionado com.w3codebox.

pasos3: Provide Artifact ID. We provide spring-boot-crud-operation.

pasos5: Add dependencies Spring Web, Spring Data JPA,y H2database.

pasos6: hacer clic Generate (Generate) button. When we click the "Generate" button, it will package the specification in Jar file and download it to the local system.

pasos7: Extract Jar file and paste it into the STS workspace.

pasos8: MoveProject folder import STS.

File-> Import-> Existing Maven project-> Browse-> Select folder spring-boot-crud-operation-> Complete

Importing may take some time.

pasos9: Create a directory named com.w3codebox.model package. Folder src/main/java.

pasos10: En el paquete com.w3Create the class in codebox.model. Hemos creado una clase llamada Books class. In the "Books" class, we performed the following operations:

Define four variables bookid, bookname, author,y Generate Getter and Setters.
Right-click on the file-> Source-> Generate Getters and Setters. Uso de anotaciones @EntityMarcar la clase comoEntity. Uso de anotaciones @TableMark this class as Table Name. Using annotations @Column Define each variable as Column .

Books.java

paquete com.w3codebox.model;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
//mark class as an Entity　
@Entity
//defining class name as Table name
@Table
public class Books
{
//Defining book id as primary key
@Id
@Column
private int bookid;
@Column
private String bookname;
@Column
private String author;
@Column
private int price;
public int getBookid()　
{
return bookid;
}
public void setBookid(int bookid)　
{
this.bookid = bookid;
}
public String getBookname()
{
return bookname;
}
public void setBookname(String bookname)　
{
this.bookname = bookname;
}
public String getAuthor()　
{
return author;
}
public void setAuthor(String author)　
{
this.author = author;
}
public int getPrice()　
{
return price;
}
public void setPrice(int price)　
{
this.price = price;
}
}

pasos11: En src/main/Crear un archivo java con el nombre com.w3codebox.controller paquete.

pasos12: En el paquete com.w3Crear una clase Controller en codebox.controller. Hemos creado una clase llamada Clase controladora BooksController. En la clase BooksController, hemos completado las siguientes operaciones:

Uso de anotaciones @RestControllerMarcar la clase como RestController . Uso de anotaciones @Autowired Anotaciones automáticas BooksService Clase. Definir los siguientes métodos: getAllBooks(): 。Devuelve una lista de todos los libros. getBooks(): Devuelve los detalles del libro especificado en la variable de rutas. Hemos pasado bookid como parámetro utilizando la anotación @PathVariable. La anotación indica que el parámetro del método debe estar vinculado al variable del patrón URI. deleteeBook(): Elimina el libro específico especificado en la variable de rutas. saveBook(): Guardar detalles de libros. La anotación @RequestBody indica que los parámetros del método deben estar vinculados al cuerpo de la solicitud web. update(): Este método actualiza un registro. Debemos especificar el registro que se actualizará en el cuerpo de la solicitud para alcanzar el mismo objetivo. Para lograr esto, hemos utilizado la anotación @RequestBody.

BooksController.java

paquete com.w3codebox.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
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.RestController;
import com.w3codebox.model.Books;
import com.w3codebox.service.BooksService;
//Marcar la clase como Controller
@RestController
public class BooksController　
{
　　　　//Automáticamente ensamblar la clase BooksService
　　　　@Autowired
　　　　BooksService booksService;
　　　　//Crear el mapeo GET para buscar todos los libros detallados en la base de datos
　　　　@GetMapping("/book")
　　　　private List<Books> getAllBooks()　
　　　　{
　　　　return booksService.getAllBooks();
　　　　}
　　　　//Crear el mapeo GET para buscar la información detallada de un libro específico
　　　　@GetMapping("/book/{bookid}")
　　　　private Books getBooks(@PathVariable("bookid") int bookid)　
　　　　{
　　　　return booksService.getBooksById(bookid);
　　　　}
　　　　//Crear el mapeo para eliminar, eliminar el libro especificado
　　　　@DeleteMapping("/book/{bookid}")
　　　　private void deleteBook(@PathVariable("bookid") int bookid)　
　　　　{
　　　　booksService.delete(bookid);
　　　　}
　　　　//Crear el mapeo POST para publicar la información detallada del libro en la base de datos
　　　　@PostMapping("/books")
　　　　private int saveBook(@RequestBody Books books)　
　　　　{
　　　　booksService.saveOrUpdate(books);
　　　　return books.getBookid();
　　　　}
　　　　//Crear el mapeo PUT para actualizar la información detallada del libro
　　　　@PutMapping("}}/books")
　　　　private Books update(@RequestBody Books books)　
　　　　{
　　　　booksService.saveOrUpdate(books);
　　　　return books;
　　　　}
}

pasos13: en la carpeta src/main/en el archivo com.w3codebox.service paquete.

pasos14: en el paquete Service clase. Creamos una com.w3en el paquete codebox.service se creó una clase llamada BooksService clase de servicio.

BooksService.java

paquete com.w3codebox.service;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.w3codebox.model.Books;
import com.w3codebox.repository.BooksRepository;
//Definir la lógica de negocio
@Service
public class BooksService　
{
　　　　@Autowired
　　　　BooksRepository booksRepository;
　　　　//Utilice el método findaAll() del cruddrepository para obtener todos los registros de libros
　　　　public List<Books> getAllBooks()　
　　　　{
　　　　List<Books> books = new ArrayList<Books>();
　　　　booksRepository.findAll().forEach(books1　-> books.add(books1));
　　　　return books;
　　　　}
　　　　//Obtenga el registro específico utilizando el método findById() de cruddrepository
　　　　public Books getBooksById(int id)　
　　　　{
　　　　return booksRepository.findById(id).get();
　　　　}
　　　　//Utilice el método save() del CrudRepository para guardar el registro específico
　　　　public void saveOrUpdate(Books books)　
　　　　{
　　　　booksRepository.save(books);
　　　　}
　　　　//Utilice el método deleteById() del CrudRepository para eliminar el registro específico
　　　　public void delete(int id)　
　　　　{
　　　　booksRepository.deleteById(id);
　　　　}
　　　　//Actualizar registro
　　　　public void update(Books books, int bookid)　
　　　　{
　　　　booksRepository.save(books);
　　　　}
}

pasos15: en la carpeta src/main/en el archivo com.w3codebox.repository paquete.

el16paso: crear un almacenamientoen el paquete com.w3se creó una interfaz llamada BooksRepository la interfaz de almacenamiento. que extiende Repositorio Crudinterfaz.

BooksRepository.java

paquete com.w3codebox.repository;
import org.springframework.data.repository.CrudRepository;
import com.w3codebox.model.Books;
//almacenamiento que extiende CrudRepository
public interface BooksRepository extends CrudRepository<Books, Integer>
{
}

Ahora, crearemos application.properties configurar el origen de datos en el archivo URL, nombre de la clase del driver, nombre de usuarioy Contraseña.

pasos17: abrir application.properties y configure las siguientes propiedades.

application.properties

spring.datasource.url=jdbc:h2:mem:books_data
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect#activando el H2　consolespring.h2.console.enabled=true

Después de crear todas las clases y paquetes, la estructura del directorio del proyecto es como se muestra a continuación.

Ahora ejecutaremos la aplicación.

pasos18: abrir SpringBootCrudOperationApplication.java y ejecutarlo como una aplicación Java.

SpringBootCrudOperationApplication.java

paquete com.w3codebox;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class SpringBootCrudOperationApplication　
{
public static void main(String[] args)　
{
SpringApplication.run(SpringBootCrudOperationApplication.class, args);
}
}

pasos19: abrir Postmany ejecutar la siguiente acción:

Elegir POST llamar a la URL http://localhost:8080/books. ElegirCuerpo seleccionar tipo de contenido JSON(aplicación/json). insertar datos. Hemos insertado los siguientes datos en el cuerpo:

{
　　　　"bookid": "5433",
　　　　"bookname": "Core and Advance Java",
　　　　"author": "R. Nageswara Rao",
　　　　"price": "800"
}

Hacer clicEnviar

Después de que se ejecute con éxito la solicitud, se mostrará estado: 200 OK . Esto significa que el registro se ha insertado con éxito en la base de datos.

Del mismo modo, hemos insertado los siguientes datos.

{"bookid": "0982", "bookname": "Programming with Java","author": "E. Balagurusamy","price": ""350"
}　
{
　　　　"bookid": "6321",
　　　　"bookname": "Estructuras de datos y algoritmos en Java",
　　　　"author": "Robert Lafore",
　　　　"price": "590"
}　
{
　　　　"bookid": "5433",
　　　　"bookname": "Effective Java",
　　　　"author": "Joshua Bloch",
　　　　"price": "670"
}

Vamos a acceder a H2consola para ver los datos.

pasos20: abrir el navegador y llamar a la URL http://localhost:8080/h2-consola. Hacer clic Conectar botón, como se muestra a continuación.

hacer clic conectarbotón, veremos en la base de datos Books tabla, como se muestra a continuación.

pasos21: hacer clic Books tabla, luego luego hacer clic en ejecutarbotón. Esta tabla muestra los datos que hemos insertado en el texto.

pasos22: abrir Postman, y envía la URL como http://localhost:8080/books de GET Solicitud. It returns los datos que hemos insertado en la base de datos.

Nosotros con la URL http://localhost:8080/book/{bookid} enviar GET Solicitud. Especificamos bookid 6830 . It returns683Detalles del libro 0.

De manera similar, también podemos enviar DELETE Solicitud para eliminar el registro. Supongamos que queremos eliminar el ID 5433 de registro de libros.

Elegir DELETE Método y llame a la URL http://localhost:8080/Libro/5433. Volver a H2Ejecutar en la consola Select Consulta. Descubrimos que el ID 5433 El libro se ha eliminado de la base de datos.

De manera similar, también podemos enviar PUT Solicitud para actualizar el registro. Vamos a actualizar el ID 6321 el precio del libro.

Elegir PUT En el cuerpo de la solicitud, pegue el registro que desea actualizar y realice los cambios. En este ejemplo, queremos actualizar el ID6321de registro de libros. En los siguientes registros, hemos cambiado el precio del libro.

{
　　　　"bookid": "6321",
　　　　"bookname": "Estructuras de datos y algoritmos en Java",
　　　　"author": "Robert Lafore",
　　　　"price": "500"
}

Hacer clicEnviar

Ahora, vaya a H2Consola, ver si los cambios se han reflejado. Vemos que el precio de este libro se ha cambiado, como se muestra a continuación.