MyBatis :: Paging 페이징 구현

1. com.paging 패키지에 들어가는 Paging.java 소스

 

package com.paging;
 
public class Paging {
 
    int recordsPerPage;       // 페이지당 레코드 수
    int firstPageNo;          // 첫번째 페이지 번호
    int prevPageNo;           // 이전 페이지 번호
    int startPageNo;          // 시작 페이지 (페이징 너비 기준)
    int currentPageNo;        // 페이지 번호
    int endPageNo;            // 끝 페이지 (페이징 너비 기준)
    int nextPageNo;           // 다음 페이지 번호
    int finalPageNo;          // 마지막 페이지 번호
    int numberOfRecords;      // 전체 레코드 수
    int sizeOfPage;           // 보여지는 페이지 갯수 (1,2,3,4,5 갯수)
    
    public Paging(int currentPageNo, int recordsPerPage) {
 
        this.currentPageNo = currentPageNo;
        //기본 페이지 : 5개 보기를 default로 설정함
        this.sizeOfPage = 5;
        
        //recordsPerPage가 0이 아니면 recordsPerPage, 아니면 무조건 5(default : 5)
        this.recordsPerPage = (recordsPerPage != 0) ? recordsPerPage : 5;
        
//        System.out.println("debug > paging sizeOfPage : " + this.sizeOfPage);
//        System.out.println("debug > paging recordsPerPage : " + this.recordsPerPage);
//        System.out.println("debug > paging currentPageNo : " + this.currentPageNo);
    }
    
    public int getRecordsPerPage() {
        return recordsPerPage;
    }
 
    public void setRecordsPerPage(int recordsPerPage) {
        this.recordsPerPage = recordsPerPage;
    }
 
    public int getFirstPageNo() {
        return firstPageNo;
    }
 
    public void setFirstPageNo(int firstPageNo) {
        this.firstPageNo = firstPageNo;
    }
 
    public int getPrevPageNo() {
        return prevPageNo;
    }
 
    public void setPrevPageNo(int prevPageNo) {
        this.prevPageNo = prevPageNo;
    }
 
    public int getStartPageNo() {
        return startPageNo;
    }
 
    public void setStartPageNo(int startPageNo) {
        this.startPageNo = startPageNo;
    }
 
    public int getCurrentPageNo() {
        return currentPageNo;
    }
 
    public void setCurrentPageNo(int currentPageNo) {
        this.currentPageNo = currentPageNo;
    }
 
    public int getEndPageNo() {
        return endPageNo;
    }
 
    public void setEndPageNo(int endPageNo) {
        this.endPageNo = endPageNo;
    }
 
    public int getNextPageNo() {
        return nextPageNo;
    }
 
    public void setNextPageNo(int nextPageNo) {
        this.nextPageNo = nextPageNo;
    }
 
    public int getFinalPageNo() {
        return finalPageNo;
    }
 
    public void setFinalPageNo(int finalpageNo) {
        this.finalPageNo = finalpageNo;
    }
 
    public int getNumberOfRecords() {
        return numberOfRecords;
    }
 
    public void setNumberOfRecords(int numberOfRecords) {
        this.numberOfRecords = numberOfRecords;
    }
 
    /**
     * 페이징 생성
     */
    public void makePaging() {
        if (numberOfRecords == 0)        // 게시글 전체 수가 없는 경우
            return;
        
        if (currentPageNo == 0)
            setCurrentPageNo(1);        // 기본 값 설정
        
        if (recordsPerPage == 0)
            setRecordsPerPage(10);        // 기본 값 설정
        
                                        // 마지막 페이지
        int finalPage = (numberOfRecords + (recordsPerPage - 1)) / recordsPerPage;
        
        if (currentPageNo > finalPage)
            setCurrentPageNo(finalPage);// 기본 값 설정
        
        if (currentPageNo < 0 || currentPageNo > finalPage)
            currentPageNo = 1;            // 현재 페이지 유효성 체크
                                        // 시작 페이지 (전체)
        boolean isNowFirst = currentPageNo == 1 ? true : false;
        boolean isNowFinal = currentPageNo == finalPage ? true : false;
        
        int startPage = ((currentPageNo - 1) / sizeOfPage) * sizeOfPage + 1;
        int endPage = startPage + sizeOfPage - 1;        
        
        if (endPage > finalPage)
            endPage = finalPage;
        
        setFirstPageNo(1);                    // 첫번째 페이지 번호
        
        if (isNowFirst)
            setPrevPageNo(1);                // 이전 페이지 번호
        else                                // 이전 페이지 번호
            setPrevPageNo(((currentPageNo - 1) < 1 ? 1 : (currentPageNo - 1)));
 
        setStartPageNo(startPage);            // 시작페이지
        setEndPageNo(endPage);                // 끝 페이지
        
        if (isNowFinal)
            setNextPageNo(finalPage);        // 다음 페이지 번호
        else
            setNextPageNo(((currentPageNo + 1) > finalPage ? finalPage : (currentPageNo + 1)));
        
        setFinalPageNo(finalPage);            // 마지막 페이지 번호
    }
}

 

Paging.java 클래스 생성자에서 기본적으로 받아와야 할 값은

currentPageNo(현재 페이지), recordsPerPage(페이지당 게시글 수) 이렇게 두 인자가 필요하다.

생성자에서 인자 두 개를 받아 controller에서 컬럼의 인덱스를 리턴하는 offset 변수를 선언하는데 쓰게 된다.

 

 

2. controller (Servlet)

package com.servlet.book;
 
import java.io.IOException;
import java.util.List;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import com.paging.Paging;
import com.service.BookManageService;
import com.vo.BookVO;
 
@SuppressWarnings("serial")
@WebServlet("/BookCheckOutAdmin")
public class BookCheckOutAdminServlet extends HttpServlet {
       
    public BookCheckOutAdminServlet() {
        super();
    }
 
    protected void doGet(HttpServletRequest request, HttpServletResponse response) 
                                throws ServletException, IOException {
        doPost(request, response);
    }
 
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
                                throws ServletException, IOException {
 
        // Paging Calculation
        int currentPageNo = 1;        
        int recordsPerPage = 0;
        String url = null;
        
        //커넥션풀 연결, 인스턴스 생성
        BookManageService bookManageService = BookManageService.getInstance();
        
        //pages, lines 파라미터를 받아 currentPageNo, recordsPerPage 대입
        //처음 페이지 열릴 때에는 당연히 1, 0임
        if (request.getParameter("pages") != null)
            currentPageNo = Integer.parseInt(request.getParameter("pages"));
        
        if (request.getParameter("lines") != null)
            recordsPerPage = Integer.parseInt(request.getParameter("lines"));
        
        //Paging 객체 생성(currentPagenNo, recordsPerPage를 인자로 넣고 초기화함)
        //객체 선언한 뒤 paging 출력해보면 recordsPerPage가 5로 나온다. 
        Paging paging = new Paging(currentPageNo, recordsPerPage);
        
        //System.out.println("debug > BookCheckOutAdminServlet paging : " + paging);
        
        //해당 게시글의 인덱스를 구하는 변수(offset) 
        int offset = (paging.getCurrentPageNo() - 1) * paging.getRecordsPerPage();    
        
        //System.out.println("debug > BookCheckOutAdminServlet offset : " + offset);
        
        //현재 대출 가능한 도서(book_lending_possible이 true인 목록만 가져옴)
        List<BookVO> bookList = bookManageService.selectAllLendingPossibleBook(offset,
                                            paging.getRecordsPerPage());        
       
        //System.out.println("debug > BookCheckOutAdminServlet bookList : " + bookList);
 
       //bookList 전체 갯수 구하여 numberOfRecords 메소드에 셋팅함 
        paging.setNumberOfRecords(bookManageService.getBookDao().getNoOfRecords());
 
        //System.out.println("debug > BookCheckOutAdminServlet numberOfRecords : "
        //                            paging.getNumberOfRecords);
 
       //페이징 만듦 
        paging.makePaging();    
        
        //bookList가 존재할 경우
        if (bookList != null) {
            //book_check_out_list.jsp에서 출력할 객체들을 request 단위로 설정함
            request.setAttribute("bookList", bookList);
            request.setAttribute("paging", paging);
            request.setAttribute("servletPath", "BookCheckOutAdmin");
 
            //System.out.println("debug > BookCheckOutAdminServlet attribute bookList : "
            //                            + request.getAttribute("bookList"));
            //System.out.println("debug > BookCheckOutAdminServlet attribute paging : "
            //                            + request.getAttribute("paging"));
            //System.out.println("debug > BookCheckOutAdminServlet servletPath : "
            //                            + request.getAttribute("servletPath"));
 
            url = "book_check_out_list.jsp";            
        }
        //list가 존재하지 않을 경우
        else {
            //error_msg.jsp에서 출력할 객체들을 request 단위로 설정함
            request.setAttribute("msg", "Error 가 발생했습니다.");   
 
            //System.out.println("debug > BookCheckOutAdminServlet attribute msg : "
            //                            + request.getAttribute("msg"));
         
            url = "error_msg.jsp";
        }        
         
        //해당 url로 모든 request, response 정보 넘김
        //http 창에서 url이 이동하는 url로 변하진 않음
        request.getRequestDispatcher(url).forward(request, response);
    }
}
 

 

페이징을 할 때에는 SELECT 쿼리문에서 LIMIT 를 사용하기 때문에

LIMIT에 들어갈 컬럼의 인덱스 값과 SELECT할 컬럼의 갯수가 필요하다.

currentPage(현재 페이지), recordsPerPage로 설정해 놓고 Paging 객체 생성자에 두 값을 넣어

컬럼의 인덱스(offset)를 도출한다.

 

* 컬럼의 index 구하기 : (현재 페이지 - 1 ) * 페이지당 SELECT할 컬럼 수

 

편의에 맞게 '~개 보기'로 하여 recordsPerPage의 값이 변할 수 있다.

 

* 페이징을 할 때 꼭 알아야 할 값 (중요) *

- 현재 페이지

- 한 페이지 당 출력할 컬럼 갯수

- 전체 컬럼 수

 

전체 컬럼 수를 알아야 페이지가 몇 개가 나올 것인지를 알 수 있기 때문에 전체 컬럼 수는 꼭 필요하다.

그러나 컬럼은 편의에 따라 추가하거나 삭제될 수 있기 때문에

SELECT 쿼리문으로 해당 list 를 구한 후 COUNT를 도출해야만 한다.

 

(list를 구한 후 bookDAO.getNoOfRecords() 메소드를 이용하여 numberOfRecords를 setter한 뒤,

페이징을 만드는 메소드인 paging.makepaging() 을 실행하였음)

 

또한 반드시 setAttribute로 설정해줘야 list.jsp에서 paging 파라미터들을 사용할 수 있다.

 

 

3. Service

 

package com.service;
 
import java.util.List;
 
import com.dao.BookDao;
import com.vo.BookVO;
 
public class BookManageService {
 
    static BookManageService    bookManageService = null;
    BookDao                     bookDao;
    BookRentInfoDao             bookRentInfoDao;
    
    public BookManageService() {
 
        bookDao = BookDao.getInstance(); 
    }
    
    //BookDao를 리턴하는 getBookDao 메소드
    public BookDao getBookDao() {
 
        return bookDao;
    }
    
    public static BookManageService getInstance() {
        
        if (bookManageService == null) {
            bookManageService = new BookManageService();
        }
        
        return bookManageService;
    }
 
    public List<BookVO> selectAllLendingPossibleBook(int offset, int noOfRecords) {
        
        return bookDao.selectAllLendingPossibleBook(offset, noOfRecords);
    }
}

 

 

6. mapper.xml

 

<mapper namespace="BookDAO">
 
    <resultMap id="resultBook" type="BookVO">
        <result property="bookCode" column="book_code" />
        <result property="bookName" column="book_name" />
        <result property="bookAuthor" column="book_author" />
        <result property="bookMade" column="book_made" />
        <result property="bookPrice" column="book_price" />
        <result property="bookLendingPossible" column="book_lending_possible" />
        <result property="bookLendingCount" column="book_lending_count" />        
    </resultMap>
 
    <select id="selectAllLendingPossibleBook" parameterType="hashmap" resultMap="resultBook">
        SELECT SQL_CALC_FOUND_ROWS
                book_code,
                book_name,
                book_author,
                book_made,
                book_price,
                book_lending_count
        FROM book
        WHERE book_lending_possible is true
        LIMIT #{offset}, #{noOfRecords}        
    </select>
 
    <select id="selectTotalRecords" resultType="int">
        SELECT FOUND_ROWS();
    </select>
 
</mapper>