Primavera – Paginación REST

Spring Framework está construido sobre servlets. Este marco web en particular viene con características muy esenciales con las que podemos desarrollar aplicaciones web eficientes y efectivas. Además de Spring Framework, Spring Boot se lanzó en abril de 2014. El objetivo principal detrás de Spring Boot era la función de configuración automática. Spring MVC (Model View Controller) es el subdominio o subproyecto de Spring Framework que está integrado en la dependencia ‘Web Starter’ de Spring. Se utiliza para el desarrollo de aplicaciones web. Web Starter también contiene funciones para desarrollar API REST. Lo usamos para devolver los datos o la lista de datos en lugar de las páginas HTML.
Los datos que se recuperan de una fuente de datos pueden ser tan grandes que sería un inconveniente enumerarlos todos, demasiado directamente. Estos datos recuperados o devueltos se pueden controlar de varias maneras. Por ejemplo, para limitar el retorno de entidades u objetos, la forma en que se ordenan, etc. Aquí entra en acción la Paginación.

Características de la Paginación

1. Limite la salida al conjunto respectivo de elementos.
2. Puede atravesar de un conjunto de elementos a otro conjunto.
3. Puede manejar grandes compensaciones de valores de datos.
4. La salida se puede pedir. Por ejemplo: Ascendente o Descendente según alguna propiedad.

Trabajo de Paginación usando la API REST de Spring 

Estructura del proyecto – Maven

A. Archivo: pom.xml (Configuración de la aplicación)

<?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.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>sia</groupId>
    <artifactId>GFG-Pagination</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>GFG-Pagination</name>
    <description>GFG</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.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </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>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

B. GfgPaginationApplication.java 

// Java Program to Illustrate Bootstrapping of Application
 
package gfg;
 
// Importing required classes
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
// Annotation
@SpringBootApplication
// Class
public class GfgPaginationApplication {
 
    // Main driver method
    public static void main(String[] args)
    {
        SpringApplication.run(
            GfgPaginationApplication.class, args);
    }
}

C. application.properties (Configuración de las Propiedades)

• Este archivo contiene todas las propiedades y sus valores necesarios para crear un objeto Datasource.
• El objeto Datasource lo proporciona la dependencia ‘Spring Data JPA’.
• Spring Data JPA tiene la implementación predeterminada de Hibernate.
• Este archivo también contiene algunas propiedades de Hibernate.
• El controlador MySQL utiliza el objeto Datasource creado para conectarse a la base de datos.
• Por lo tanto, también podemos interactuar con la base de datos respectiva.

Descripción general de las entradas de entidades de la base de datos MySQL

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/userdetails
spring.datasource.username=root
spring.datasource.password=password
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect

D. Entidad de usuario.java 

Esta clase se asigna a una tabla en una base de datos.

1. Anotaciones de persistencia:

• @Entity – Especifica que la clase es una Entidad. El atributo ‘nombre’ se utiliza para asignar el nombre de la clase al nombre de la tabla en la base de datos si no son iguales.
• @Id: especifica que la propiedad sobre la que se aplica actúa como una clave principal para la tabla respectiva con la que podemos acceder a la base de datos.

2. Anotaciones de Lombok

• @Data: genera automáticamente métodos Getter y Setter para todos los campos en tiempo de ejecución.
• @RequiredArgsConstructor: genera constructores para todos los campos obligatorios, es decir, los campos con anotación de palabra clave final o @NonNull. Si no hay tales campos, se crea un constructor de cero argumentos. Esta anotación es parte de la anotación @Data.

La API REST devolverá el objeto de esta clase como una respuesta JSON.

Ejemplo:

// Java Program to Illustrate Model Data
 
package gfg;
 
// Importing required classes
import javax.persistence.Entity;
import javax.persistence.Id;
import lombok.Data;
import lombok.RequiredArgsConstructor;
 
// Annotation
@Data
@RequiredArgsConstructor
@Entity(name = "user")
// Class
public class UserEntity {
 
    @Id String user;
    String username;
    String password;
}

E. Archivo: UserRepository.java

• Esta interfaz se utiliza para trabajar con bases de datos sin necesidad de escribir los engorrosos métodos JDBC (Java Database Connectivity).
• Esta interfaz amplía ‘Interfaz JpaRepository<T, ID>’, donde T es un tipo de objeto e ID es el tipo de clave principal.

Nota : JpaRepository tiene 4 superinterfaces QueryByExampleExecutor<T>, Repository<T,ID>, CrudRepository<T,ID> y PagingAndSortingRepository<T, ID>, que es la que proporciona funciones de paginación esenciales.

CrudRepository proporciona los métodos JDBC generalizados que ejecutan scripts SQL para interactuar con las bases de datos.

(Crear, Leer, Actualizar, Eliminar).

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

Los métodos de la interfaz PagingAndSortingRepository son los siguientes: 

Ejemplo:

// Java Program to Illustrate Data Repository
 
package gfg;
 
// Importing required classes
import org.springframework.data.jpa.repository.JpaRepository;
 
// Interface
public interface UserRepository
    extends JpaRepository<UserEntity, String> {
}

F. Archivo: PagedRestController.java

• Esta clase de controlador devuelve una lista de objetos UserEntities como respuesta.
• Aquí, se crea un objeto Pageable utilizando el método de fábrica PageRequest.of().
• Este método acepta 3 argumentos:

1. Un número de una página respectiva.
2. Número de entradas a recuperar por página.
3. Técnica de clasificación.

Este objeto de Pageable se pasa al método findAll() de PagingAndSortingRepository<T, ID> que acepta el mismo objeto respectivo y devuelve un objeto de página. Luego, los elementos recuperados del objeto Página finalmente se devuelven.

Ejemplo:

// Java Program to Illustrate REST API
 
package gfg;
 
// Importing required classes
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
@RequestMapping("/get")
public class PagedRestController {
 
    // links automatically created repository bean in
    // Spring Application context
    @Autowired UserRepository data;
 
    @GetMapping("/page-One")
    public List<UserEntity> getPageOne()
    {
 
        // First page with 5 items
        Pageable paging = PageRequest.of(
            0, 5, Sort.by("user").ascending());
        Page<UserEntity> page = data.findAll(paging);
 
        // Retrieve the items
        return page.getContent();
    }
 
    @GetMapping("/page-Two")
    public List<UserEntity> getPageTwo()
    {
 
        // Second page with another 5 items
        Pageable paging = PageRequest.of(
            1, 5, Sort.by("user").ascending());
        Page<UserEntity> page = data.findAll(paging);
 
        // Retrieve the items
        return page.getContent();
    }
}

Salida 1:

Elementos en la primera página

Salida 2:

Elementos en la segunda página

Conclusión:

1. Dado que la mayoría de las industrias trabajan con grandes conjuntos de datos, las API REST son muy populares y se utilizan ampliamente, ya que ayudan a devolver respuestas de datos.
2. Por lo tanto, para ellos, la Paginación se convierte en una característica muy importante para aplicar.
3. También ayuda a construir una interfaz de usuario buena y manejable (interfaz de usuario).