[SpringBoot] 페이지네이션(Pagination)

📌환경

IntelliJ Ultimate

Java 17

SpringBoot 3.2.3

Gradle - Groovy

 

Dependencies: 

Spring Web

Thymeleaf

Spring Data JPA

lombok

MariaDB 10.11

Spring Dev tool

QueryDSL 5.0.0

 

 

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

페이징 또는 페이지네이션이라고 부른다. 다량의 데이터를 공통된 개수만큼 여러 묶음으로 나누어 특정 페이지 당 한 묶음을 화면에 보여주는 것을 말한다.

DB에 등록된 데이터가 많은 경우 요청 시 전체를 한번에 들고온다면 응답 시간이 길어지게 되면서 클라이언트에게 불편을 초래한다. 이때 데이터를 페이지에 해당하는 개수만큼 일부만 잘라서 가져온다면 시간을 단축할 수 있다. 예를 들어 화면에서 1페이지를 요청했다면 백엔드에서는 정렬한 데이터 중 첫번째 데이터부터 10번째 데이터까지만 잘라서 반환한다. 

 

DB에서 원하는 만큼만 잘라오기 위해서는 `offset`과 `limit`을 사용하는데, `offset`은 건너뛸 데이터의 개수, `limit`은 잘라낼 데이터의 개수를 말한다. 페이지당 데이터를 10개씩 보여주는 화면에서 2페이지를 요청했다면 쿼리문은 `select * from table limit 10 offset 10`이 된다. 또는 `select * from table limit 10, 10`과 같이 `limit`만으로도 쿼리문을 작성할 수 있다.

 

 

📌SpringBoot - Spring Data JPA의 페이징

JDBC 또는 Mybatis를 사용한다면 페이지를 직접 쿼리문으로 구현해야하지만, SpringBoot에서는 Spring Data JPA를 사용하여 페이지에 관한 처리를 `Pageable`과 `Page<E>`타입으로 다루고 있다.

 

 

 

 

`Pageable` 타입의 객체를 구성하여 `repository` 내 메서드의 파라미터로 전달하면 결과를 `Page<T>`로 반환받을 수 있다.  `Pageable`는 인터페이스로, 페이지 생성 조건을 가진 객체라고 생각하면 된다. 페이지 번호, 가져올 데이터 개수, 정렬 방식을 다음과 같이 구성할 수 있다.

 

//	1페이지(0 ~ 10), bno로 내림차순 정렬
Pageable pageable = PageRequest.of(0, 10, Sort.by("bno").descending());

 

 

이제 이 `pageable`을 `repository`의 메서드에 파라미터로 전달하면 `Page<E>` 객체를 얻을 수 있다.

 

//	1페이지(0 ~ 10), bno로 내림차순 정렬
Pageable pageable = PageRequest.of(0, 10, Sort.by("bno").descending());
Page<Board> result = boardRepository.findAll(pageable);

 

 

콘솔을 까보면 Hibernate가 다음과 같이 쿼리문을 실행하는 것을 확인할 수 있다.

 

select
    board0_.bno as bno1_0_,
    board0_.modda t e as moddate2_0_,
    board0_.re gdat e as regdate3_0_,
    board0_.con t ent as content4_0_,
    board0_. titl e as title5_0_,
    board0_.wr it er as writer6_0_
from
    board board0_
order by
    board0_.bno desc limit ?

 

 

`Page<T>` 타입의 객체는 내부적으로 페이징 처리에 필요한 여러 정보를 가지고 있다. 전체 데이터의 개수는 몇 개인지, 총 페이지는 몇 개인지, 데이터 개수는 몇 개인지 등의 정보를 모두 가져올 수 있다.

 

 

Page<Board> result = boardRepository.findAll(pageable);

result.getTotalElements();		//	총 데이터 개수: limit 조건을 걸지 않았을 때 개수
result.getTotalPage();		//	총 페이지: 사이즈에 맞춰 잘라냈을 때 페이지 개수
result.getNumber();		//	페이지 번호: 가져온 페이지
result.getSize();			//	페이지 당 가져오는 데이터 개수
result.getContent();		//	가져온 데이터 목록 List<Board>

 

 

`getTotalElements()`는 데이터 목록을 가져오는 것이 아니라 limit 조건을 걸지 않았을 때의 총 데이터 개수를 뜻하므로 주의한다. 데이터 목록만 따로 `List<T>` 객체로 얻고 싶다면 `getContent()`를 사용하면 된다.

 

 

📌활용

화면에서 검색 조건, 페이지를 요청했을 때 검색 조건을 만족한 특정 권한의 멤버를 등록순으로 정렬 후 페이지 처리하여 화면에 보여주고자 한다. 이때 검색 조건을 적용하기 위해  `queryDSL`을 사용한다. 검색 조건이 존재하거나 존재하지 않을 때 모두 페이지 처리하여 데이터를 가져오고 싶다면 `RepositoryImpl`은 다음과 같이 작성한다.

 

package com.torobbb.repository.search;

import com.torobbb.domain.Member;
import com.torobbb.domain.MemberRole;
import com.torobbb.domain.QMember;
import com.querydsl.core.BooleanBuilder;
import com.querydsl.jpa.JPQLQuery;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.support.QuerydslRepositorySupport;

import java.util.List;
import java.util.Set;

public class MemberSearchImpl extends QuerydslRepositorySupport implements MemberSearch {

    public MemberSearchImpl() {
        super(Member.class);
    }

    @Override
    public Page<Member> searchMember(String[] types, String keyword, Pageable pageable, Set<MemberRole> memberRoleSet) {

//        QueryDSL 객체
        QMember member = QMember.member;

//        select ... from member
        JPQLQuery<Member> query = from(member);

//        order by regDate desc;
        query.orderBy(member.regDate.desc());

        BooleanBuilder booleanBuilder = new BooleanBuilder();

        if(types != null && keyword != null){

            for(String type : types){
                switch (type){
                    case "i" :
                        //        where id like ...
                        booleanBuilder.or(member.id.contains(keyword));
                        break;
                    case "n" :
                        //        or name like ...
                        booleanBuilder.or(member.name.contains(keyword));
                        break;
                }
            }// for
        }// if

//        and roleSet like
        memberRoleSet.forEach(memberRole -> {
            booleanBuilder.and(member.roleSet.contains(memberRole));
        });

        query.where(booleanBuilder);

//        페이징
        this.getQuerydsl().applyPagination(pageable, query);

        List<Member> list = query.fetch();
        long count = query.fetchCount();

        return new PageImpl<>(list, pageable, count);
    }
}

 

 

 

`PageImpl<T>`는 `Page<T>` 인터페이스의 구현 객체로 실제 목록 데이터(List<T>), 페이지 정보(Pageable), 전체 개수(long)을 파라미터로 전달하면 `Page<T>` 타입의 참조 변수로 참조하여 사용할 수 있다. 

해당 `Repository`의 `searchMember()` 메서드를 사용하는 `ServiceImpl`은 다음과 같다.

 

    @Override
    public PageResponseDTO<Member> findBySpecificRoles(Set<MemberRole> memberRoleSet, PageRequestDTO pageRequestDTO) {
        Pageable pageable = pageRequestDTO.getPageable();

        String[] types = pageRequestDTO.getTypes(); // split("_")
        String keyword = pageRequestDTO.getKeyword();

        log.info("types: " + Arrays.toString(types));
        log.info("keyword: " + keyword);

//        검색 카테고리, 키워드, 특정 권한을 가진 멤버 regDate 내림차순으로 페이징 처리해서 가져옴
        Page<Member> memberPage = memberRepository.searchMember(types, keyword, pageable, memberRoleSet);

//        페이지 안에 담긴 dtoList
        List<Member> dtoList = memberPage.getContent();

        return PageResponseDTO.<Member>withAll()
                .pageRequestDTO(pageRequestDTO)
                .dtoList(dtoList)
//                검색했을 때 총 개수(페이지에 담긴 개수 말고 검색 결과 개수)
                .total((int)memberPage.getTotalElements())
                .build();
    }

 

 

실제 사용할 때는 `Member` 엔티티를 바로 반환하지 말고 `DTO`로 변환하여 반환하도록 한다.

해당 메서드를 사용하는 `Controller`는 다음과 같다.

 

 

 @GetMapping("/member")
    public String index(Model model, PageRequestDTO pageRequestDTO){

        Set<MemberRole> memberRoleSet = new HashSet<>();
        memberRoleSet.add(MemberRole.MEMBER);

        PageResponseDTO<Member> pageResponseDTO = memberService.findBySpecificRoles(memberRoleSet, pageRequestDTO);

        model.addAttribute("admin", MemberRole.MEMBER);
        model.addAttribute("pageResponseDTO", pageResponseDTO);

        return "/member/index";
    }

 

 

 

`/member` url을 요청했을 때 `MEMBER` 권한을 가진 멤버의 리스트를 보여준다. `PageRequestDTO`와 `PageResponseDTO`는 페이징 처리를 위해 뷰에서 모든 정보를 한번에 요청하거나 백에서 뷰로 넘기기 위한 객체로, 필요하다면 다음과 같이 선언한다.

 

 

 

@Getter
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PageRequestDTO {

//    기본값: null이면 1페이지
    @Builder.Default
    private int page = 1;

//    기본값: null이면 10개씩
    @Builder.Default
    private int size = 10;

//    검색 카테고리
    private String type;

//    검색 키워드
    private String keyword;

    private String link;

    public Pageable getPageable(String...props){
        return PageRequest.of(this.page -1, this.size, Sort.by(props).descending());
    }

    public String[] getTypes(){
        if(type == null || type.isEmpty()){
            return null;
        }

        return type.split("");
    }
}

 

 

@Getter
@ToString
public class PageResponseDTO<E> {

    private int page;

//    페이지당 개수 요청 따로 없으면 10개씩
    @Builder.Default
    private int size = 10;

    private int total;

//    시작 페이지
    private int start;

//    끝
    private int end;

    private boolean prev;
    private boolean next;

    private List<E> dtoList;

//    PageResponseDTO.<Member>withAll 로 사용할 수 있음
    @Builder(builderMethodName = "withAll")
    public PageResponseDTO(PageRequestDTO pageRequestDTO, List<E> dtoList, int total){

        if(total <= 0){
            return;
        }

        this.page = pageRequestDTO.getPage();
        this.size = pageRequestDTO.getSize();

        this.total = total;
        this.dtoList = dtoList;

//        화면에서  <  1 2 3 4 5 6 7 8 9 10 > 이렇게 보여주니까 end는 마지막 출력될 페이지 버튼, start는 처음 출력될 페이지 버튼
        this.end = (int)(Math.ceil(this.page / 10.0)) * 10;
        this.start = this.end - 9;

//        마지막 페이지 버튼
        int last = (int)(Math.ceil((total/(double)size)));

        this.end = Math.min(end, last);
        this.prev = this.start > 1;
        this.next = total > this.end * this.size;

    }
}

 

 

 

이제 전달받은 `pageResponseDTO`를 사용해 화면을 다음과 같이 작성할 수 있다.

 

 

<div style="display: inline-flex">총 [[${pageResponseDTO.total}]]명</div>
<div th:each="member : ${pageResponseDTO.getDtoList()}" th:with="admin=${admin}">
    <img class="rounded-circle" th:src="@{/img/{fileName}(fileName=${member.getFileName()})}">

    <div style="display: inline-flex" th:text="${member.name}"></div>
    <div style="display: inline-flex" th:text="${#temporals.format(member.regDate, 'yy-MM-dd')}"></div>

    <div class="float-end">
        <button style="display: inline-flex" class="btn btn-secondary" th:data-name="${member.id}" th:onclick="adminUpdate(this.getAttribute('data-name'))">수정</button>
        <button style="display: inline-flex" class="btn btn-danger" th:data-name="${member.id}" th:onclick="admindelete(this.getAttribute('data-name'))">삭제</button>
    </div>

</div>



<div class="">
    <ul class="pagination flex-wrap">
        <li class="page-item" th:if="${pageResponseDTO.prev}">
        	<a class="page-link" th:data-num="${pageResponseDTO.start -1}">이전</a>
        </li>

        <th:block th:each="i : ${#numbers.sequence(pageResponseDTO.start, pageResponseDTO.end)}">
            <li th:class="${pageResponseDTO.page == i} ? 'page-item active' : 'page-item'">
            	<a class="page-link" th:data-num="${i}" >[[${i}]]</a>
            </li>
        </th:block>

        <li class="page-item" th:if="${pageResponseDTO.next}">
        	<a class="page-link" th:data-num="${pageResponseDTO.end + 1}">다음</a>
        </li>

    </ul>
</div>

 

 

 

 

검색 시에는 `pageRequestDTO` 를 전달할 수 있도록 form 태그를 다음과 같이 추가한다.

 

 

<form action="/member" method="get">

    <input type="hidden" name="size" th:value="${pageRequestDTO.size}">
    <div class="input-group">
        <div class="input-group-prepend">
            <select class="form-select type" name="type">
                <option value="">---</option>
                <option th:selected="${pageRequestDTO.type == 'n'}" value="n">이름</option>
                <option th:selected="${pageRequestDTO.type == 'i'}" value="i">아이디</option>
                <option th:selected="${pageRequestDTO.type == 'ni'}" value="ni">이름/아이디</option>
            </select>
        </div>

        <input type="text" class="form-control keyword" name="keyword" th:value="${pageRequestDTO.keyword}">

        <div class="input-group-append">
            <button type="submit" class="btn btn-outline-primary searchBtn">검색</button>
            <button type="button" class="btn btn-outline-secondary clearBtn">초기화</button>
        </div>

    </div>

</form>

 

 

 

 

검색을 실행하면 `/member?size=10&type=n&keyword=안녕` url로 이동한다. type, keyword가 존재하기 때문에 검색 조건이 적용된 페이지가 처리되어 뷰에 반환된다.

 

 

📌참고

자바 웹 개발 워크북 - 구멍가게 코딩단

Page (Spring Data Core 3.2.3 API)

Pageable (Spring Data Core 3.2.3 API)