Spring Data JPA o JPA significa API de persistencia de Java, por lo que antes de investigar eso, debemos conocer ORM (Mapeo de relación de objetos) . Entonces, el mapeo de relaciones de objetos es simplemente el proceso de persistir cualquier objeto Java directamente en una tabla de base de datos. Por lo general, el nombre del objeto que se conserva se convierte en el nombre de la tabla y cada campo dentro de ese objeto se convierte en una columna. Con la configuración de la tabla configurada, cada fila corresponde a un registro en la aplicación. Hibernate es un ejemplo de ORM. En resumen, JPA es la interfaz mientras que hibernate es la implementación.
La API de persistencia de Java proporciona una especificación para conservar, leer y administrar datos desde su objeto Java a sus tablas relacionales en la base de datos. JPA especifica el conjunto de reglas y pautas para desarrollar interfaces que siguen estándares. Directamente al grano: JPA son solo pautas para implementar ORM y no hay un código subyacente para la implementación. Spring Data JPA es parte del marco de Spring. El objetivo de la abstracción del repositorio de datos Spring es reducir significativamente la cantidad de código repetitivo necesario para implementar una capa de acceso a datos para varias tiendas persistentes. Spring Data JPA no es un proveedor de JPA, es una biblioteca/marco que agrega una capa adicional de abstracción en la parte superior de nuestra línea de proveedores de JPA, Hibernate.
Configurar Spring Data JPA en Spring Application con ejemplo
Requisitos : STS IDE, banco de trabajo MySQL, Java 8+
Cree un proyecto de arranque de primavera en STS . Proporcione el nombre del proyecto y seleccione agregar las dependencias requeridas (Spring JPA, controlador MySQL, Spring web) que se muestran en el pom.xml adjunto .
XML
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.6.1</version> <relativePath/> <!-- lookup parent from repository --> </parent> <groupId>com.example</groupId> <artifactId>ex</artifactId> <version>0.0.1-SNAPSHOT</version> <name>ex</name> <description>Demo project for Spring Boot</description> <properties> <java.version>11</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <scope>runtime</scope> <optional>true</optional> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>
O también puede agregar estas dependencias al crear el proyecto.
archivo application.properties:
spring.datasource.url=jdbc:mysql://localhost:3306/emp spring.datasource.username=root spring.datasource.password=root spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver spring.jpa.database-platform = org.hibernate.dialect.MySQL5Dialect spring.jpa.generate-ddl=true spring.jpa.hibernate.ddl-auto = update
Estructura del proyecto :
Capa modal:
Cree un POJO simple (clase Java antigua simple) con alguna anotación JPA.
- @Entity : esta anotación define que una clase se puede asignar a una tabla
- @Id: esta anotación especifica la clave principal de la entidad.
- @GeneratedValue: esta anotación se usa para especificar la estrategia de generación de clave principal que se usará. es decir, indica a la base de datos que genere un valor para este campo automáticamente. Si la estrategia no está especificada por defecto, se utilizará AUTO.
Java
package com.example.demo.modal;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
// @Entity annotation defines that a
// class can be mapped to a table
@Entity
public class Employee {
// @ID This annotation specifies
// the primary key of the entity.
@Id
// @GeneratedValue This annotation
// is used to specify the primary
// key generation strategy to use
@GeneratedValue(strategy = GenerationType.AUTO)
private long id;
private String name;
private String city;
public Employee() {
super();
}
public Employee(String name, String city) {
super();
this.name = name;
this.city = city;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
}
Capa DAO (objeto de acceso a datos):
- @Repository: la anotación @Repository es un marcador para cualquier clase que cumpla el rol o estereotipo de un repositorio (también conocido como Objeto de acceso a datos o DAO).
- JpaRepository<Employee, Long> JpaRepository es una extensión específica de JPA del Repositorio. Contiene la API completa de CrudRepository y PagingAndSortingRepository. Por lo tanto, contiene API para operaciones CRUD básicas y también API para paginación y clasificación. Aquí habilitamos operaciones de base de datos para empleados.
Java
package com.example.demo.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import com.example.demo.modal.Employee;
// @Repository is a Spring annotation that
// indicates that the decorated class is a repository.
@Repository
public interface EmployeeRepository extends JpaRepository<Employee, Long>{
ArrayList<Employee> findAllEmployee();
}
Capa de servicio:
Java
package com.example.demo.service;
import java.util.ArrayList;
import com.example.demo.modal.Employee;
public interface EmpService {
ArrayList<Employee> findAllEmployee();
Employee findAllEmployeeByID(long id);
void addEmployee();
void deleteAllData();
}
@Service: esta anotación se usa con clases que brindan algunas funcionalidades comerciales. Spring context detectará automáticamente estas clases cuando se utilice la configuración basada en anotaciones y el escaneo de classpath. Aquí, el repositorio JPA tiene muchos métodos genéricos predefinidos para realizar la operación de la base de datos, algunos se usan en el siguiente código.
Java
package com.example.demo.service;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Optional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.example.demo.modal.Employee;
import com.example.demo.repository.EmployeeRepository;
// @Service marks a Java class that performs some service,
// such as executing business logic, performing
// calculations, and calling external APIs.
@Service
public class EmpServiceImpl implements EmpService {
@Autowired
EmployeeRepository employeeRepository;
@Override
public ArrayList<Employee> findAllEmployee() {
return (ArrayList<Employee>) employeeRepository.findAll();
}
@Override
public Employee findAllEmployeeByID(long id) {
Optional<Employee> opt = employeeRepository.findById(id);
if (opt.isPresent())
return opt.get();
else
return null;
}
@Override
public void addEmployee() {
ArrayList<Employee> emp = new ArrayList<Employee>();
emp.add(new Employee("Lucknow", "Shubham"));
emp.add(new Employee("Delhi", "Puneet"));
emp.add(new Employee("Pune", "Abhay"));
emp.add(new Employee("Noida", "Anurag"));
for (Employee employee : emp) {
employeeRepository.save(employee);
}
}
@Override
public void deleteAllData() {
employeeRepository.deleteAll();
}
}
Capa de controlador:
- @RestController: esta es una anotación de Spring que se usa para compilar la API REST de forma declarativa. La anotación RestController se aplica a una clase para marcarla como un controlador de requests, y Spring hará la construcción y proporcionará el servicio web RESTful en tiempo de ejecución.
- @Autowired: esta anotación se puede usar para autoconectar bean en el método setter al igual que la anotación @Required, constructor, una propiedad o métodos con nombres arbitrarios y/o múltiples argumentos.
- @PostMapping: esta anotación asigna requests HTTP POST a métodos de controlador específicos. Es una anotación compuesta que actúa como acceso directo para @RequestMapping(method = RequestMethod. POST)
- @GetMapping: esta anotación es una versión especializada de la anotación @RequestMapping que actúa como acceso directo para @RequestMapping(método = RequestMethod. GET). Los métodos anotados de @GetMapping en las clases anotadas de @Controller manejan las requests HTTP GET que coinciden con la expresión URI dada.
- @DeleteMapping: esta anotación asigna requests de DELETE HTTP a métodos de controlador específicos. Es una anotación compuesta que actúa como atajo para @RequestMapping(method = RequestMethod. DELETE)
Java
package com.example.demo.controller;
import java.util.ArrayList;
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.RestController;
import com.example.demo.modal.Employee;
import com.example.demo.service.EmpServiceImpl;
@RestController
public class EmpController {
@Autowired
EmpServiceImpl empServiceImpl;
@PostMapping("/")
public void add() {
empServiceImpl.addEmployee();
}
@GetMapping("/findall")
public ArrayList<Employee> getAllEmployee() {
return empServiceImpl.findAllEmployee();
}
@GetMapping("/findbyid/{id}")
public Employee getEmployeeUsingId(@PathVariable long id) {
return empServiceImpl.findAllEmployeeByID(id);
}
@DeleteMapping("/delete")
public void delete() {
empServiceImpl.deleteAllData();
}
}
Mostrar salida usando JPA en cartero:
Abra cartero y presione la API enumerada una por una.
Guardar datos de empleados
Encuentra toda la lista de empleados
Encuentre un empleado por id
Eliminar a todos los empleados
Publicación traducida automáticamente
Artículo escrito por shubhamp338 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA