🚩페이지네이션

🏁 페이지네이션(Pagination)이란?

페이지네이션 정의

• 스프링(Spring)은 데이터 액세스를 위한 다양한 API(Spring Data JDBC, Spring Data JPA 등)를 지원하며, 페이지네이션(Pagination)⭐은 대용량 데이터를 효과적으로 처리하고 사용자에게 적절한 양의 데이터를 보여주는 데 유용한 기능이다.

스프링에서 페이지네이션을 구현하는 일반적 방법

• Spring Data JPA를 사용하는 방법
• Spring JDBC 템플릿을 사용하는 방법

• 여기서는 Spring Data JPA에 대한 내용을 다루도록 하겠다.

🏁 Spring Data JPA의 페이지네이션

페이지네이션의 파라미터

• 스프링 데이터 JPA는 쿼리 메소드에 페이징과 정렬 기능을 사용할 수 있도록 2가지 특별한 파라미터를 제공한다.

  • org. springframework. data. domain. Sort： 정렬 기능
  • org.springframework.data.domain.Pageable： 페이징 기능(내부에 Sort 포함)

Page, Pageable, PageRequest

• 페이징 처리는 Pageable이라는 타입의 객체를 구성해서 파라미터로 전달하면 된다. Pageable은 인터페이스로 설계되어 있고, 일반적으로 PageRequest.of()라는 기능을 이용해서 개발이 가능하다.
  (😊 PageRequest 클래스는 Pageable의 구현 클래스로 다양한 정적 팩토리 메서드 of를 통해 Pageable 인터페이스를 쉽게 구현할 수 있다.)
  

// Pageable 객체는 PageRequest.of로 쉽게 구현할 수 있다.
    @Test
    public void testPagingO {
      //1 page order by bno desc
      Pageable pageable = PageRequest.of(0,10, Sort.by("bno”).descending());
      Page<Board> resuLt = boardRepository.findALL(pageabLe);
    }

• 테스트 실행 결과 (예시)

select
  boardO_.bno as bnol_0_,
  boards..moddate as moddate2_0.
  boardG_.regdate as regdate3_0.
  board0_.content as content4_0.
  boarde_.title as title5_0_,
  board0_.writer as writer6_0_
from
	board boardO_
order by
	board0.bno desc limit ?

// ⭐ 반환타입을 페이지 관련으로 받았을 경우 count(컬럼) 쿼리가 실행된다.
select
	count(boardO_.bno) as col_0_0_ 
from
	board boardO

• findAll()의 리턴 타입으로 나오는 Page<T> 타입은 내부적으로 페이징 처리에 필요한 여러 정보를 처리한다. 예를 들어 다음 페이지 존재여부, 이전 페이지 존재여부, 전체 데이터 개수 등의 기능을 모두 확인할 수 있다.

// 과거에는 Slice 인터페이스가 아닌 Iterable을 상속받았었다.
// 현재는 Slice<T>가 Streamable<T>를 상속받고, Streamable<T>가 Iterable<T>와 Supplier<Stream<T>>를 상속받는다.
public interface Page<T> extends Slice<T> // Slice<T>
int getNumber(); //현재 페이지
int getSize(); //페이지 크기
int getTotalPages(); //전체 페이지 수
int getNumberOfElements(); //현재 페이지에 나올 데이터 수
long getTotalElements(); //전체 데이터 수
boolean hasPreviousPage(); //이전 페이지 여부
boolean isFirstPage(); //현재 페이지가 첫 페이지 인지 여부
boolean hasNextPage(); //다음 페이지 여부
boolean isLastPage(); //현재 페이지가 마지막 페이지 인지 여부
Pageable nextPageable (); //다음 페이지 객체 , 다음 페이지가 없으면 null
Pageable previousPageable ();//다음 페이지 객체, 이전 페이지가 없으면 null
List<T> getContent(); //조회된 데이터
boolean hasContent(); //조회된 데이터 존재 여부
Sort getSort(); //정렬 정보

• Pageable과 Page를 사용하면 페이징을 쉽게 개발할 수 있다.

• ⭐ Page를 사용하면 스프링 데이터 JPA는 페이징 기능을 제공하기 위해 검색된 전체 데이터 건수를 조회하는 count 쿼리를 추가로 호출한다.

//count 쿼리 사용
Page<Member> findByName(String name, Pageable pageable);
//count 쿼리 사용 안 함
List<Member> findByName (String name, Pageable pageable);
List<Member> findByName (String name, Sort sort);

- Sort 클래스

• Spring Domain 클래스 중 org.springframework.data.domain.Sort⭐ 클래스는 Spring Data 프로젝트에서 DB 쿼리 결과를 정렬하기 위해 사용되는 클래스이다. Spring Data JPA를 비롯해 다양한 Spring Data 모듈에서 이 클래스를 활용하여 정렬 기능을 구현할 수 있다.

• Sort 클래스는 다음과 같은 기능을 제공한다:

  • ①정렬 속성과 방향 설정: Sort 객체는 정렬에 사용될 속성과 정렬 방향을 지정할 수 있습니다. 속성은 엔티티의 필드를 나타내며, 방향은 오름차순(Ascending) 또는 내림차순(Descending)으로 설정할 수 있습니다.
    
    
  • ②다중 정렬: Sort 객체를 사용하여 여러 속성에 대해 다중 정렬을 지정할 수 있습니다. 이렇게 함으로써 첫 번째 속성으로 정렬한 후, 동일한 값이 있는 경우에 두 번째 속성으로 정렬할 수 있습니다.
    
    
  • ③페이징과 함께 사용: Sort 객체는 Pageable과 함께 사용하여 페이지네이션된 결과를 정렬할 수 있습니다. 이를 통해 특정 속성과 방향에 따라 특정 페이지의 데이터를 정렬하여 반환할 수 있습니다.

• 사용 예제

import org.springframework.data.domain.Sort;

// 단일 속성으로 오름차순 정렬 (name 속성 기준으로 오름차순)
Sort sort = Sort.by(Sort.Direction.ASC, "name");

// 단일 속성 내림차순으로 정렬 (name 속성을 기준으로 내림차순 정렬)
Sort sort = Sort.by(Sort.Order.desc("name"));

// 다중 속성으로 오름차순 정렬 (첫 번째 속성으로 정렬하고, 동일한 값이 있으면 두 번째 속성으로 정렬)
Sort sort = Sort.by(Sort.Direction.ASC, "category").and(Sort.by(Sort.Direction.DESC, "price"));


// 다중 속성으로 오름차순 정렬 (category로 먼저 정렬하고, 동일한 category 내에서는 price로 정렬)
Sort sort = Sort.by(Sort.Order.asc("category"), Sort.Order.asc("price"));

• Pageable과 함께 사용할 때

import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;

// 첫 번째 페이지, 페이지당 10개의 결과, category 속성을 기준으로 오름차순 정렬
Pageable pageable = PageRequest.of(0, 10, Sort.by(Sort.Direction.ASC, "category"));

// 리포지토리 메서드에서 사용할 수 있는 예제
Page<MyEntity> result = myEntityRepository.findAll(pageable);

페이지네이션 구현하는 구체적인 방법

1. JpaRepository 인터페이스 상속

• Repository 인터페이스를 정의하고 JpaRepository를 상속받는다. JpaRepository⚡는 CRUD(Create, Read, Update, Delete) 작업과 함께 페이지네이션 기능을 제공한다.

import org.springframework.data.jpa.repository.JpaRepository;

public interface YourEntityRepository extends JpaRepository<YourEntity, Long> {
}

2. 페이지네이션 메서드 사용

• Spring Data JPA는 페이징을 위해 Pageable 객체를 사용한다. Pageable⚡은 페이지 번호, 페이지 크기, 정렬 방식 등을 지정하는 데 사용된다.

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;

public interface YourEntityRepository extends JpaRepository<YourEntity, Long> {
    Page<YourEntity> findAll(Pageable pageable);
}

3. 서비스단에서 DB와 연동된 페이지 받아오기

@Service
public class YourService {

    @Autowired
    private YourRepository yourRepository;

    public Page<YourEntity> getEntities(int page, int size) {
        PageRequest pageRequest = PageRequest.of(page, size);
        return yourRepository.findAll(pageRequest);
    }

    // 다른 비즈니스 로직들...
}

4. 컨트롤러단에서 페이지 받기

@RestController
public class YourController {

    @Autowired
    private YourService yourService;

    @GetMapping("/entities")
    public ResponseEntity<List<YourEntity>> getEntities(@RequestParam(defaultValue = "0") int page,
                                                        @RequestParam(defaultValue = "10") int size) {
        Page<YourEntity> pageResult = yourService.getEntities(page, size);
        List<YourEntity> entities = pageResult.getContent();
        return new ResponseEntity<>(entities, HttpStatus.OK);
    }

    // 다른 컨트롤러 메서드들...
}

• 필드에 @Autowired를 붙였지만, 생성자를 통한 DI를 하는 것이 일반적이다.
  

  • GPT:
    생성자 인젝션은 명시적인 생성자를 통해 필요한 의존성을 주입하기 때문에 생성자에 @Autowired를 사용하는 것을 권장합니다. 이 방법은 테스트를 용이하게 하고, 클래스의 의존성을 명확하게 표현하여 코드 가독성을 높일 수 있습니다. 또한, 생성자 인젝션을 사용하면 해당 클래스의 필드들을 final로 선언하여 불변성을 유지할 수 있으며, 이는 코드 안정성과 품질을 높이는데 도움이 됩니다.

🔥 Controller에서 인자를 Pageable 타입으로 받을 경우

• Controller 단에서 반드시 page, size를 모두 명시적으로 받을 필요는 없다.
  인자를 Pageable 타입으로 받는다면 Spring Data JPA 내부에서 클라이언트 측에서 전달된 쿼리 파라미터 ?page=0&size=10 등을 인식하여 동타입 객체로 생성해준다.
  

• 참고) 이전 코드 (@RequestParam 사용)

@Operation(summary = "Get All Member", description = "전체 계정 조회 기능")
    @GetMapping
    public ResponseEntity getAccounts(@Positive @RequestParam int page,
                                      @Positive @RequestParam int size) {
        Page<AccountPageResponseDto> accountsPage = accountService.findAccounts(page-1, size);
        List<AccountPageResponseDto> accounts = accountsPage.getContent();

        return new ResponseEntity<>(
                new MultiResponseDto<>(HttpStatusCode.OK.getStatusCode(), HttpStatusCode.OK.getMessage(), accounts, accountsPage)
        , HttpStatus.OK);
    }

🏁 페이지네이션 공식문서

• Page인터페이스 공식문서(Spring Data Core 3.1.2 API)

  Slice 인터페이스 공식문서 (Page가 Slice를 확장한다.)

• Interface Pageable 공식문서(Spring Data Core 3.1)
• PageRequest (Spring Data Core 3.1.2 API) 공식문서
• Sort (Spring Data Core 3.1.2 API)

• 참고 : 쿼리메서드

🏁 출처

• 자바 ORM 표준 JPA 프로그래밍 (김영한 저)
• 자바 웹개발 워크북 (구명가게 코딩단 저)
• Interface Pageable 공식문서(Spring Data Core 3.1)
• PageRequest (Spring Data Core 3.1.2 API) 공식문서