Pagination con Spring Boot

Clase 30 de 31 • Curso de Java: Backend con Spring Boot

Clase anteriorSiguiente clase

Ildar Tashtekov

student•

Pageable lol

Gian HM

student•

jajajaj

Engels Medina

student•

jajajajajaja cuando los profesores saben espajeablish

Roberto Fernández Romero

student•

A continuación les dejo un consejo. Como dejé comentado en anteriores clases, hay una excelente librería llamada lombok, la podemos añadir a nuestro proyecto como dependencia en el pom.xml de la siguiente manera:

<dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>lombok</artifactId>
</dependency>

Una vez hecho esto, no será necesario que creemos un constructor para inyectar nuestras clases como veníamos haciendo, sólo debemos instanciar como private final las clases que deseamos inyectar y arriba de la clase en la que deseamos hacer las inyecciones poner la anotación @RequiredArgsConstructor. Les dejo un ejemplo de como quedaría la clase:

@RequiredArgsConstructor
public class Ejemplo {

	private final EjemploLombok ejemploLombok;

	public void hazAlgo() {
		ejemploLombok.hazAlgo();
	}

}

Teniendo en cuenta la clase de arriba:

Ejemplo es la clase en la que queremos inyectar.

@RequiredArgsConstructor es la anotación de lombok que nos permite inyectar a nuestra clase sin la necesidad de crear constructor.

EjemploLombok es la clase que inyectamos.

Elkin Omar Jiménez García

student•

Hola, así como también para los Getters y Setters es muy buena esa dependencia. Gracias por el aporte :D

CARLOS ANDRES HERNANDEZ COPETE

student•

Excelente librería. <3

Celeste Daniela Luengo

student•

No es necesario cambiar la herencia a PagingAndSortingRepository, porque JpaRepository ya hereda de ella. Se puede hacer también de la siguiente manera:

@GetMapping("/lista") public Page<User> getAlls(@PageableDefault(size = 10, page = 0) Pageable pageable){ Page<User> list = userService.findAll(pageable); return list; }

Donde size y page, también podrían ser recibidos a través de RequestParam

Jose Sanchez

student•

Me ayudó bastante este aporte porque al cambiar JpaRepository por PagingAndSortingRepository me arrojaba errores, muchas gracias.

Anderson Martinez Jurado

student•

Otra forma de hacer la paginación es usar el Pageable como parámetro de entrada en el @GetMapping y enviar este a través del flujo hasta llegar a la capa repository, este te retornará un Page<User> el cual contendrá la data y otros datos adicionales como total de items, página actual, numero de items actuales, etc. para rellenar los campos de las tablas como numero de páginas, página actual, etc. etc.

URL: https://springframework.guru/spring-boot-pagination/

julian santiago moreno

student•

¿Es una buena practica que dentro de un Controller se inyecte un Repository? ¿No deberia respetar las capas y que el Service o un UseCase se encargue de llamar al Repo?

Omar Ali El Assaad El Assaad

student•

Es como indicas, en el ejemplo es por simpleza que se hizo de esta manera

Esneyder Saavedra Cardenas

student•

Para no tener errores inesperados podemos simplemente implementar JpaRepository<Users,Long>, PagingAndSortingRepository<Users,Long> y funciona normal

@Repository
public interface UserRepository extends JpaRepository<Users,Long>, PagingAndSortingRepository<Users,Long>
....................

Luis Betancourt

student•

Me gusto esta clase, no conocía la implementación de la paginación en SpringBoot.

Jose Funez

student•

La diferencia entre CrudRepository JpaRepository PagingAndSortingRepository

https://programmerclick.com/article/47381325017/

Jean Michael Lozano Cardoso

student•

Para los que quieren implementar el metodo desde la capa de servicio y no directamente del repositorio: En userService agregan este metodo:

public List<User> findAll(PageRequest of) {
       return userRepository.findAll(of).getContent();
    }

Y en el UserRestController:

 @GetMapping("/pageable")
    public List<User> getUserPageable(@RequestParam int page, @RequestParam int size) {
        return userService.findAll(PageRequest.of(page, size));
    }

Pd: En el repositorio, no hace falta cambiar JpaRepository, ya que esta ya hereda de la interfaz Paging

@NoRepositoryBean
public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T>

Gian HM

student•

así que los programadores son pageables, eso no lo sabía

Christian David Osorio Chacón

student•

Reto cumplido: :)

PageUser

@Component
public class PageUser {
    private UserService userService;

    public PageUser(UserService userService) {
        this.userService = userService;
    }

    public List<User> getAllPagination(int page, int size) {
        return userService.getAllPagination(page, size);
    }
}

UserService

    public List<User> getAllPagination(int page, int size) {
        return userRepository.findAll(PageRequest.of(page, size)).getContent();
    }

UserController

    @GetMapping("/pageable")
    List<User> getUserPageable(@RequestParam int page, @RequestParam int size) {
        return pageUser.getAllPagination(page, size);
    }

William Andres Tovar Riobo

student•

Implemente por aparte la paginación voy a dejar el código por si me pueden dar algún consejo o si a alguno le sirve.

En UserService agregue el siguiente metodo:

public List<User> getPageUsers(@RequestParam int page, @RequestParam int size) {
        return userRepository.findAll(PageRequest.of(page,size)).getContent();
}

En el paquete caseuse cree la clase "PageUser" y este seria el codigo:

@Component
public class PageUser{
    private UserService userService;
    public PageUser(UserService userService) {
        this.userService = userService;
    }
    public List<User> getPage(@RequestParam int page, @RequestParam int size) {
        return userService.getPageUsers(page, size);
    }
}

Y por ultimo en UserRestController agregue lo siguiente para consumir mi paginacion:

@GetMapping("/pageagle")
    List<User> getPage(@RequestParam int page, @RequestParam int size){
        return pageUser.getPage(page, size);
    }

PDTA: como dicen algunos compañeros, no me fue necesario cambiar la herencia de JpaRepository a PagingAndSortingRepository. Entonces ese paso me lo salte. <3

Mayk Edison Perez Arzapalo

student•

Solo una observación, no es necesario poner la anotación @RequestParam a cada método, solo es necesario en el controlador.

Jose Helver Yate Camacho

student•

buenas tardes,

comparto reto.

caso de uso

package com.fundamentosplatzi.springboot.fundamentos.caseuse;

import com.fundamentosplatzi.springboot.fundamentos.entity.User;
import com.fundamentosplatzi.springboot.fundamentos.service.UserService;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class PageableUser {
    private UserService userService;

    public PageableUser(UserService userService) {
        this.userService = userService;
    }

    public List<User> pageableUsers(int page, int size) {
        return userService.pageable(page, size);
    }
}

Servicio

package com.fundamentosplatzi.springboot.fundamentos.service;

import com.fundamentosplatzi.springboot.fundamentos.entity.User;
import com.fundamentosplatzi.springboot.fundamentos.repository.UserRepository;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;
import java.util.List;

@Service
public class UserService {
    private final Log LOG = LogFactory.getLog(UserService.class);
    private UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    /*
        la anotacion @Transactional nos permite
        es que si existe algun error al nivel del insert
        nos permite realizar un rollback de todas las
        transaciones que se han registrado.
     */
    @Transactional
    public void saveTransactional(List<User> userList) {
        /*
            .peek me ayuda a mostrar lo que voy registrando
         */
        userList.stream()
                .peek(user -> LOG.info("Usuario insertado: " + user))
                .forEach(userRepository :: save);
    }

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public User save(User user) {
        return userRepository.save(user);
    }

    public void delete(Long id) {
        userRepository.delete(new User(id));
    }

    public User update(User user, Long id) {
        return userRepository.findById(id)
                .map(userUpdate -> {
                    userUpdate.setName(user.getName());
                    userUpdate.setEmail(user.getEmail());
                    userUpdate.setBirthDate(userUpdate.getBirthDate());
                    return userRepository.save(userUpdate);
                }).get();
    }

    public List<User> pageable(int page, int size) {
        return userRepository.findAll(PageRequest.of(page, size)).getContent();
    }
}

Controlador

package com.fundamentosplatzi.springboot.fundamentos.controller;

import com.fundamentosplatzi.springboot.fundamentos.caseuse.*;
import com.fundamentosplatzi.springboot.fundamentos.entity.User;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserRestController {
    // create, get, delete, update
    private GetUser getUser;
    private CreateUser createUser;
    private DeleteUser deleteUser;
    private UpdateUser updateUser;
    private PageableUser pageableUser;

    public UserRestController(GetUser getUser, CreateUser createUser,
                              DeleteUser deleteUser, UpdateUser updateUser,
                              PageableUser pageableUser) {
        this.getUser = getUser;
        this.createUser = createUser;
        this.deleteUser = deleteUser;
        this.updateUser = updateUser;
        this.pageableUser = pageableUser;
    }

    @GetMapping("/")
    List<User> get() {
        return getUser.getAll();
    }

    @PostMapping("/")
    ResponseEntity<User> newUser(@RequestBody User user) {
        return new ResponseEntity<>(createUser.save(user), HttpStatus.CREATED);
    }

    @DeleteMapping("/{id}")
    ResponseEntity deleteUser(@PathVariable Long id) {
        deleteUser.remove(id);
        return new ResponseEntity(HttpStatus.NO_CONTENT);
    }

    @PutMapping("/{id}")
    ResponseEntity<User> replaceUser(@RequestBody User user, @PathVariable Long id) {
        return new ResponseEntity<>(updateUser.update(user, id), HttpStatus.OK);
    }

    @GetMapping("/pageable")
    List<User> getUserPageable(@RequestParam int page, @RequestParam int size) {
        return pageableUser.pageableUsers(page, size);
    }
}

Gracias.

@Component
public class PageUser {
    private UserService userService;

    public PageUser(UserService userService) {
        this.userService = userService;
    }

    public List<User> getAllPagination(int page, int size) {
        return userService.getAllPagination(page, size);
    }
}

@Component
public class PageUser{
    private UserService userService;
    public PageUser(UserService userService) {
        this.userService = userService;
    }
    public List<User> getPage(@RequestParam int page, @RequestParam int size) {
        return userService.getPageUsers(page, size);
    }
}

package com.fundamentosplatzi.springboot.fundamentos.caseuse;

import com.fundamentosplatzi.springboot.fundamentos.entity.User;
import com.fundamentosplatzi.springboot.fundamentos.service.UserService;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class PageableUser {
    private UserService userService;

    public PageableUser(UserService userService) {
        this.userService = userService;
    }

    public List<User> pageableUsers(int page, int size) {
        return userService.pageable(page, size);
    }
}

package com.fundamentosplatzi.springboot.fundamentos.service;

import com.fundamentosplatzi.springboot.fundamentos.entity.User;
import com.fundamentosplatzi.springboot.fundamentos.repository.UserRepository;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;
import java.util.List;

@Service
public class UserService {
    private final Log LOG = LogFactory.getLog(UserService.class);
    private UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    /*
        la anotacion @Transactional nos permite
        es que si existe algun error al nivel del insert
        nos permite realizar un rollback de todas las
        transaciones que se han registrado.
     */
    @Transactional
    public void saveTransactional(List<User> userList) {
        /*
            .peek me ayuda a mostrar lo que voy registrando
         */
        userList.stream()
                .peek(user -> LOG.info("Usuario insertado: " + user))
                .forEach(userRepository :: save);
    }

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public User save(User user) {
        return userRepository.save(user);
    }

    public void delete(Long id) {
        userRepository.delete(new User(id));
    }

    public User update(User user, Long id) {
        return userRepository.findById(id)
                .map(userUpdate -> {
                    userUpdate.setName(user.getName());
                    userUpdate.setEmail(user.getEmail());
                    userUpdate.setBirthDate(userUpdate.getBirthDate());
                    return userRepository.save(userUpdate);
                }).get();
    }

    public List<User> pageable(int page, int size) {
        return userRepository.findAll(PageRequest.of(page, size)).getContent();
    }
}

package com.fundamentosplatzi.springboot.fundamentos.controller;

import com.fundamentosplatzi.springboot.fundamentos.caseuse.*;
import com.fundamentosplatzi.springboot.fundamentos.entity.User;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserRestController {
    // create, get, delete, update
    private GetUser getUser;
    private CreateUser createUser;
    private DeleteUser deleteUser;
    private UpdateUser updateUser;
    private PageableUser pageableUser;

    public UserRestController(GetUser getUser, CreateUser createUser,
                              DeleteUser deleteUser, UpdateUser updateUser,
                              PageableUser pageableUser) {
        this.getUser = getUser;
        this.createUser = createUser;
        this.deleteUser = deleteUser;
        this.updateUser = updateUser;
        this.pageableUser = pageableUser;
    }

    @GetMapping("/")
    List<User> get() {
        return getUser.getAll();
    }

    @PostMapping("/")
    ResponseEntity<User> newUser(@RequestBody User user) {
        return new ResponseEntity<>(createUser.save(user), HttpStatus.CREATED);
    }

    @DeleteMapping("/{id}")
    ResponseEntity deleteUser(@PathVariable Long id) {
        deleteUser.remove(id);
        return new ResponseEntity(HttpStatus.NO_CONTENT);
    }

    @PutMapping("/{id}")
    ResponseEntity<User> replaceUser(@RequestBody User user, @PathVariable Long id) {
        return new ResponseEntity<>(updateUser.update(user, id), HttpStatus.OK);
    }

    @GetMapping("/pageable")
    List<User> getUserPageable(@RequestParam int page, @RequestParam int size) {
        return pageableUser.pageableUsers(page, size);
    }
}

Pagination con Spring Boot

Introducción a Spring Boot

¿Qué es Spring Boot?

Características principales de Spring Boot

Instalación de entorno de desarrollo: Windows

Instalación de entorno de desarrollo: macOS

Instalación de entorno de desarrollo: Ubuntu

Dependencias en Spring Boot

¿Qué es una dependencia?

Inversión de control y el patrón de inyección de dependencias

Autoconfiguration y runtime

Anotaciones para indicar dependencias en Spring Boot

Creación de proyecto bajo arquitectura de dependencias

Inyección de dependencia "Component"

Ejemplo de creación de dependencia propia

Configuración general de Spring Boot

Cambio de puerto y path

Uso de properties y valores

Uso de properties con ejemplo de generación de POJO

Qué son los logs y cómo usarlos

JPA con Spring y Spring Data

Modelado de entidades con JPA

Configuración de datasource con properties y classes

Registro en base de datos con JpaRepository

Uso de JPQL en anotación query

Uso de anotación value para apuntar a properties

Obtención de información usando Query methods

Uso de Query methods con Or, and, OrderBy, Between, Sort

Uso de JPQL con named parameters

Uso de anotación transactional

Rollback con la anotación transactional

REST con Spring Boot

CRUD bajo arquitectura REST

Métodos CREATE, UPDATE y DELETE

Probando la API REST

Pagination con Spring Boot

Conclusiones

Sigue aprendiendo Spring Boot