복수의 데이터를 반환하는 경우에 페이징은 필수!

수십, 수백만개의 데이터를 한번에 반환한다면..?

API를 개발하다 보면 데이터 리스트를 반환하는 상황이 무조건 발생한다. 그런데 만약에 아무런 조치 없이 데이터 리스트를 반환한다고 생각해보자.  몇십, 몇백개의 데이터를 처리하는데는 큰 상관이 없지만 몇십만, 몇 백만개의 데이터를 반환하게 되면 문제가 발생할 수 밖에 없다.  이러한 상황을 방지하기 위해 우리는 API 설계시에 페이징 로직을 필수적으로 적용시켜야 한다. 

 

페이징을 적용한 API 구현 예시 

다음은 나만의 옷장 서비스에서 페이징을 적용한 옷 리스트를 반환하는 API 구현 예시이다.  

 

@Setter
@Getter
public class ResponseForClothes extends PaginatedResponse {
    private List<ContentForCloth> contents;
}

 

옷 리스트를 반환하기 위한 DTO 이다. contents 필드에 ContentForCloth 객체들이 담기게 된다. ContentForCloth는 Cloth 정보가 담기는 객체이고  ResponseForClothes가 상속받는 PaginatedResponse는 페이징 처리가 필요한 모든 DTO가 상속받는 객체이다. 

 

@Getter
@Setter
public class PaginatedResponse {
    private Integer _code;
    private String _message;
    private Integer totalPages; // 총 페이지 수
    private Integer pageNumber; // 현재 페이지
    private Integer numberOfElements; // 현재 페이지의 아이템 개수
    private Integer size; // 한 페이지의 최대 아이템 수
    private Long totalElements; // 총 아이템 수
    private Boolean isLast; // 마지막 페이지 여부
    private Boolean isFirst; // 첫 페이지 여부

    public void setPageNumber(Integer pageNumber) {
        this.pageNumber = pageNumber + 1;
    }
}

 

PaginatedResponse는 Page에 관련된 정보를 가지고 있다. 페이징 처리를 통해 데이터를 전달하는 만큼 그에 따른 페이징 정보를 함께 반환해야 한다. (그래야 클라이언트에서 데이터 처리가 가능하다) 자, 이제 DTO에 데이터를 담아 반환하기만 하면 페이징 처리가 완성이 된다. 그렇다면 페이징 로직은 어떤식으로 구현해야 할까? 

 

    /** WardrobeService **/
    @Transactional
    public ResponseEntity<ResponseForWardrobes> findAll(int pageNumber, int pageSize) {
        PageRequest pageRequest = PageRequest.of(pageNumber-1, pageSize);
        Page<Wardrobe> paginationedWardrobes = wardrobeRepository.findAll(pageRequest);

        return paginationService.convertToPaginatedWardrobes(paginationedWardrobes);
    }
    
    /** PaginationService **/ 
    protected ResponseEntity<ResponseForWardrobes> convertToPaginatedWardrobes(Page<Wardrobe> paginatedWardrobes) {
        List<ContentForWardrobe> wardrobes = new ArrayList<>();
        ResponseForWardrobes responseForWardrobes = new ResponseForWardrobes();

        for(Wardrobe wardrobe : paginatedWardrobes.getContent()) {
            wardrobes.add(new ContentForWardrobe(
                    wardrobe.getId(),
                    wardrobe.getName(),
                    wardrobe.getClothes().size(),
                    wardrobe.getLikeCnt(),
                    wardrobe.getMember().getName())
            );
        }

        responseForWardrobes.set_code(200);
        responseForWardrobes.set_message("OK");
        responseForWardrobes.setContents(wardrobes);
        responseForWardrobes.setTotalPages(paginatedWardrobes.getTotalPages());
        responseForWardrobes.setPageNumber(paginatedWardrobes.getNumber());
        responseForWardrobes.setSize(paginatedWardrobes.getSize());
        responseForWardrobes.setNumberOfElements(wardrobes.size());
        responseForWardrobes.setTotalElements(paginatedWardrobes.getTotalElements());
        responseForWardrobes.setIsLast(paginatedWardrobes.isLast());
        responseForWardrobes.setIsFirst(paginatedWardrobes.isFirst());

        return new ResponseEntity<>(responseForWardrobes, HttpStatus.OK);
    }

 

다행히도 Hibernate는 페이징 처리를 직접 제공한다. PageRequest를 통해 페이지 번호와 페이지 당 최대 데이터 수를 지정해주고 Repository에게 넘겨주면 페이징이 된 리스트가 반환 된다. 이때 이 데이터는 Page 형태를 가지고 있는데 페이징과 관련된 전반적인 정보도 함께 포함하고 있다. 특별한 로직 구현 없이 반환해준 페이지 정보와 데이터들을 DTO에 알맞게 매핑시켜 반환만 시켜주면 이리 간단하게 페이징 로직을 API에 적용시킬 수 있다.