스프링의 정석 Ch. 04 MyBatis로 게시판 만들기

Back-End/Spring

스프링의 정석 Ch. 04 MyBatis로 게시판 만들기

챔🐻 2024. 1. 25. 12:05

01. MyBatis의 소개와 설정

1. MyBatis란?

SQL Mapping Framework - Easy & Simple
자바 코드와 SQL을 매핑한다.

자바 코드로부터 SQL문을 분리해서 관리

매개변수 설정과 쿼리 결과를 읽어오는 코드를 제거
setString(), setInt() | getString(), getInt()

작성할 코드가 줄어서 생산성 향상 & 유지 보수 편리
E = m $c^2$
Error = more code
코드가 많을 수록 에러 ↑

스프링에서 MyBatis를 사용하려면 아래 2개의 모듈이 필요하다.

<dependency>
	<groupId>org.mybatis</groupId>
	<artifactId>mybatis</artifactId>
	<version>3.5.9</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
	<groupId>org.mybatis</groupId>
	<artifactId>mybatis-spring</artifactId>
	<version>2.0.7</version>
</dependency>

2. SqlSessionFactoryBean과 SqlSessionTemplate

SqlSessionFactory - SqlSession을 생성해서 제공
SqlSession - SQL 명령을 수행하는데 필요한 메서드 제공

SqlSessionFactoryBean - SqlSessionFactory를 Spring에서 사용하기 위한 빈
SqlSessionTemplate - SQL 명령을 수행하는데 필요한 메서드 제공.

root-context.xml

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="configLocation" value="classpath:mybatis-config.xml"/> <!-- mybatis 설정파일 -->
		<property name="mapperLocations" value="classpath:mapper/*Mapper.xml"/>
</bean>

<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
    <constructor-arg ref="sqlSessionFactory"/>
</bean>

💡포인트

멀티 쓰레드에 안전하기 때문에 여러 Dao가 SqlSessionTemplate를 공유해도 문제가 없다.

3. SqlSession의 주요 메서드

메서드	설명	비고
int insert(String statement) int insert(String statement, Object parameter)	insert문을 실행하고, insert된 행의 갯수를 반환	int는 DB에 영향을 준 row의 수를 반환한다. param은 예를 들어 User객체나 Map도 들어올 수 있다.
int delete(String statement) int delete(String statement, Object parameter)	delete문을 실행하고, delete된 행의 갯수를 반환
int update(String statement) int update(String statement, Object parameter)	update문을 실행하고, update된 행의 갯수를 반환
T selectOne(String statement) T selectOne(String statement, Object parameter)	하나의 행을 반환하는 select에 사용 paramter로 SQL에 binding될 값 제공	한 행 조회(1개 조회)
List<E> selectList(String statement) List<E> selectList(String statement, Object parameter)	여러 행을 반환하는 select에 사용 paramter로 SQL에 binding될 값 제공	n개 조회(얘 많이 씀)
Map<K,V> selectMap(String statement, String keyCol) Map<K,V> selectMap(String statement, String keyCol, Object parameter)	여러 행을 반환하는 select에 사용 keyCol에 Map의 Key로 사용할 컬럼 지정	n개 조회

4. Mapper XML의 작성

getter를 통해서 값을 넣어주기 때문에 DTO에 getter는 필수다.

parameterType : 입력
resultType : 출력

💡insert는 반환타입이 항상 int라 resultType이 없다.

+) Mapper 인터페이스? 설정이라는 게 있다는 것만 알아두기

5. <typeAliases>으로 이름 짧게 하기

mybatis – MyBatis 3 | Configuration

https://mybatis.org/mybatis-3/configuration.html#typeAliases

typeAliases : 별명

02. MyBatis로 DAO 작성하기

1. BoardDao의 작성

DB 테이블 작성

Mapper XML & DTO 작성

DAO 인터페이스 작성

DAO 인터페이스 구현 & 테스트

2. DTO란? - Data Transfer Object

계층간의 데이터를 주고 받기 위해 사용되는 객체

게시판에서 글을 읽을 때는 board 테이블에 있는 Data를 BoardDto 객체에 담아서 가져와야 하고,

게시판에서 글을 쓸 때는 DTO라는 객체에 값을 채워서 DB의 board 테이블에 저장한다.

그래서 BoardDTO는 board 테이블에 맞게 정의해줘야 한다.

사용자가 요청한 data를 DTO에 담아서 Service 계층으로, 또 Repository 계층(DAO)으로 전달해야 한다. 계층을 분리했기 때문에 각 계층간의 데이터를 전달할 무언가가 있어야 하는데 그게 DTO다.

또 조회를 하면 조회한 테이터를 DTO에 담아서 각 계층을 거쳐서 응답하게 되어있다.

→ data를 전송할 때 쓰는 객체임

MVC에서는 Model

3계층에서는 DTO

예외처리

Repository(DAO) 계층에서는 예외처리 ❌
전에 배운 것과 같이 @Service 계층에서 try-catch로 처리하기 때문에 DAO에서 예외처리를 하면 트랜잭션에서는 커밋해야 할지 롤백해야 할지 알 수가 없다. 그래서 Repository 계층에서는 예외처리를 하지 않는다.

보편적으로 Service 계층에서 예외처리.
트랜잭션 처리를 try-catch로 하니까 필요하다.(처리 안 하고 컨트롤러로 넘기는 선택지도 있음)

<예외처리 방법>

Service에서 처리

Controller에서 처리

아니면 둘 다(예외 되던지기)

어떤 방법으로 예외처리할지 위 3가지에서 스스로 고민해봐야 한다.(어려우면 컨트롤러로 넘기면 됨. 예외 종류에 따라서 알아서 처리하도록.)

+) VO(Value Object)는 잘못된 용어다. DTO가 맞음.

실습

getter, setter가 있어야 MyBatis가 값을 자동으로 읽어오고 채워준다. 그래서 DTO에서 getter, setter는 필수.

만약 BoardDTO에 bno라는 iv에 getter가 존재하지 않았다면 MyBatis가 값을 읽어오지 못한다.

<mapper namespace="com.fastcampus.ch4.dao.BoardMapper">
    <!-- mybatis-config.xml에서 alias를 줘서 BoardDTO 패키지명 생략 가능 -->
    <select id="select" parameterType="int" resultType="BoardDTO">
        select bno,
               title,
               content,
               writer,
               view_cnt,
               comment_cnt,
               reg_date,
               up_date
          from board
         where bno = #{bno};
    </select>
</mapper>

<typeAliases>
    <typeAlias alias="BoardDto" type="com.fastcampus.ch4.domain.BoardDto"/>
</typeAliases>

sql문을 호출하는 메서드를 직접 만들어보기!

table 만들고

CREATE TABLE `board` (
  `bno` int NOT NULL AUTO_INCREMENT,
  `title` varchar(100) NOT NULL,
  `content` text NOT NULL,
  `writer` varchar(30) NOT NULL,
  `view_cnt` int DEFAULT '0',
  `comment_cnt` int DEFAULT '0',
  `reg_date` datetime DEFAULT CURRENT_TIMESTAMP,
  `up_date` datetime DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`bno`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3

Sql mapper에서 sql 작성

<mapper namespace="com.fastcampus.ch4.dao.BoardMapper">
    <!-- mybatis-config.xml에서 alias를 줘서 실제 타입 대신에 BoardDTO로 사용 가능
        id는 select지만 실제 이름은 앞에 namespace가 붙어야 한다.(클래스 앞에 패키지 이름 붙듯이)
    -->
    <select id="select" parameterType="int" resultType="BoardDTO">
        select bno,
               title,
               content,
               writer,
               view_cnt,
               comment_cnt,
               reg_date,
               up_date
        from board
        where bno = #{bno};
    </select>
</mapper>

DAO 작성

🚨 주의할 점

namespace 마지막에 ‘.’ 붙여야 하는 거 잊지 말기

public class BoardDao {
    @Autowired
    SqlSession session;

    String namespace = "com.fastcampus.ch4.dao.BoardMapper."; // 뒤에 점 하나 붙여야 하는 거 잊지말기

    /*
    * 메서드명 : select
    * 매개변수 : int
    * 반환타입 : BoardDTO
    * */
    public BoardDTO select(int bno) throws Exception { // 예외를 service로 던져줘야 해서 예외 선언.
        // session 객체를 지용해서 one row 가지고 온다.
        return session.selectOne(namespace + "select", bno);
    }
}

인터페이스로 추출
인터페이스로 해놓으면 다중에 DAO가 변경될 때 Service쪽에 영향을 받지 않도록, 클래스가 아니라 인터페이스 타입을 이용해서 주입받는 것.

Refacter > Extract Interface

다음. BoardDao를 테스트 해보자.

BoardDaoImpl 우클릭 > Go to > Test
Junit4로 체크하고 생성

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"file:src/main/webapp/WEB-INF/spring/**/root-context.xml"})
public class BoardDaoImplTest {
    @Autowired
    BoardDao boardDao;

    @Test
    public void select() throws Exception {
        // boardDao가 주입이 잘 되었는지 확인
        assertTrue(boardDao != null);
        System.out.println("boardDao = " + boardDao);

        BoardDto boardDto = boardDao.select(1);
        System.out.println("boardDto = " + boardDto);

        assertTrue(boardDto.getBno().equals(1));
    }
}

3. #{}와 ${}의 차이

#{} → PreparedStatement 사용

pstmt를 쓰는 게 좋음

장점

성능 : sql문 재사용 가능

보안 : sql injection 막을 수 있다.
사용자의 입력을 문자열로 변환한다.

<insert id="insert" parameterType="BoardDto">
    INSERT INTO board
        (title, content, writer)
    VALUES
        (#{title}, #{content}, #{writer})
</insert>

→

String sql = "INSERT INTO board"
				+ "(title, content, writer)"
				+ "VALUES"
				+ "(?, ?, ?)";

${} → Statement 사용

title, content, writer가 뭐냐에 따라 sql문이 다 바뀐다. → 성능에 좋지 않다.

but 제약이 더 적음

문자열 변환 없이 값을 직접 SQL에 삽입한다.

<insert id="insert" parameterType="BoardDto">
    INSERT INTO board
        (title, content, writer)
    VALUES
        ('${title}', '${content}', '${writer}')
</insert>

→

String sql = "INSERT INTO board"
				+ "(title, content, writer)"
				+ "VALUES"
				+ " ('"+title+"','"+content+"','"+writer+"')";

4. XML의 특수 문자 처리 - CDATA

XML 내의 특수 문자 (<, >, &, …)는 < >로 변환 필요

또는 특수문자가 포함된 쿼리를 <![CDATA[sql문 ]]>로 감쌓ㄴ다.
CDATA = Character Data. 이 안에는 전부 문자 data라는 뜻이다.

<update id="update" parameterType="BoardDto">
    UPDATE board
    SET   title = #{title}
      , content = #{content}
      , up_date = now()
    WHERE bno = #{bno} and bno &lt &gt 0
</update>

태그로 오해할 수 있기 때문에 HTML 엔티티 사용해야 한다.

<update id="update" parameterType="BoardDto">
		<![CDATA[  
		    UPDATE board
		    SET   title = #{title}
		      , content = #{content}
		      , up_date = now()
		    WHERE bno = #{bno} and bno <> 0
		]]>
</update>

가독성면에서 이거 쓰는 ㄱ ㅔ 좋음

03~04. 게시판 목록 만들기와 페이징 - TDD

1. 게시물 목록 페이징

페이징은 용어가 헷갈리기 때문에 용어를 적어두고 시작하기

화면을 만들기 전에 TDD로 내가 원하는대로 페이징되는지 Test 해봐야 한다. → 페이징이 TDD하기에 가장 적합

2. LIMIT [offset ,] row_count

TABLE에 들어있는 Data를 페이지 별도로 가져오려면 SELECT문에 LIMIT 구문을 사용해야 한다.

offset : 맨 처음부터 얼마만큼 떨어져있는가

row_count : 읽어올 row의 수

ex) LIMIT 0, 10 : 처음부터 10개 가져온다.

실습1 - 페이징(PageHandler 만들고 TDD)

TDD로 페이징하는 걸 계산해보자.

beginPage 구하는 공식

PageHandler.java

public class PageHandler {
    int totalCnt; // 총 게시물 갯수
    int pageSize; // 한 페이지의 크기
    int naviSize = 10; // 페이지 내비게이션의 크기
    int totalPage; // 전체 페이지의 갯수
    int page; // 현재 페이지
    int beginPage; // 내비게이션의 첫 번째 페이지
    int endPage; // 내비게이션의 마지막 페이지
    boolean showPrev; // 이전 페이지로 이동하는 링크를 보여줄 것인지의 여부
    boolean showNext; // 다음 페이지로 이동하는 링크를 보여줄 것인지의 여부

    public PageHandler(int totalCnt, int page) {
        this(totalCnt, page, 10);
    }

    // 페이징 계산하는데 필요한게 3가지
    public PageHandler(int totalPage, int page, int pageSize) {
        this.totalPage = totalPage;
        this.page = page;
        this.pageSize = pageSize;

        totalPage = (int) Math.ceil(totalCnt / pageSize); // 남는 페이지가 있을 수 있기 때문에 올림처리
        beginPage = page / naviSize * naviSize + 1;
        endPage = Math.min(beginPage + naviSize, totalPage); // endPage가 totalPage보다 작을 수 있기 때문에
        showPrev = beginPage != 1; // 시작 페이지가 1일 때만 안 나오면 된다.
        showNext = endPage != totalPage; // 다음으로 갈게 없으니까 보여주지않음
    }

    // page nav를 print하는 메서드
    void print() {
        System.out.println("page = " + page);

        System.out.println(showPrev ? "[PREV] " : "");
        for (int i = beginPage; i <= endPage; i++) {
            System.out.println(i + " ");
        }
        System.out.println(showNext ? " [NEXT]" : "");
    }

    @Override
    public String toString() {
        return "PageHandler{" +
                "totalCnt=" + totalCnt +
                ", pageSize=" + pageSize +
                ", naviSize=" + naviSize +
                ", totalPage=" + totalPage +
                ", page=" + page +
                ", beginPage=" + beginPage +
                ", endPage=" + endPage +
                ", showPrev=" + showPrev +
                ", showNext=" + showNext +
                '}';
    }
}

테스트1

우리가 작성한대로 잘 동작하는지 확인해보자

@Test
  public void test() {
      PageHandler ph = new PageHandler(250, 1);
      ph.print();
      System.out.println("ph = " + ph);

      assertTrue(ph.beginPage == 1);
      assertTrue(ph.endPage == 10);

}

테스트2

어떻게 나올지 예상 결과를 먼저 그림으로 그려보기

@Test
public void test2() {
    PageHandler ph = new PageHandler(250, 11);
    ph.print();
    System.out.println("ph = " + ph);

    assertTrue(ph.beginPage == 11);
    assertTrue(ph.endPage == 20);
}

테스트3

여기서 실수. totalPage 게산이 잘못됨. 이래서 테스트를 해야 한다.

페이징 테스트 시에는 맨 앞과 맨 끝, 경계가 되는 지점의 테스트를 잘 해야 한다.

before ==> totalPage = (int) Math.ceil(totalCnt / pageSize); // 남는 페이지가 있을 수 있기 때문에 올림처리

after ==> totalPage = (int) Math.ceil(totalCnt / (double) pageSize); // 남는 페이지가 있을 수 있기 때문에 올림처리

@Test
public void test3() {
    PageHandler ph = new PageHandler(255, 25);
    ph.print();
    System.out.println("ph = " + ph);

    assertTrue(ph.beginPage == 21);
    assertTrue(ph.endPage == 26);
}

그림을 그려서 결과를 예상해보고 테스트를 돌려서 결과가 내가 예상한 것과 동일한지 꼭 테스트를 해보아야 한다.

❗❗❗❗❗그림 그리는 거 중요!!!!!!!!! 강의 안 보고 그릴 수 있어야 함❗❗❗❗❗

실습2 - 페이징(PageHandler 수정)

PageHandler.java에 getter, setter 추가

PageHandler.java

package com.fastcampus.ch4.domain;

import java.net.SocketTimeoutException;

public class PageHandler {
    private int totalCnt; // 총 게시물 갯수
    private int pageSize; // 한 페이지의 크기
    private int naviSize = 10; // 페이지 내비게이션의 크기
    private int totalPage; // 전체 페이지의 갯수
    private int page; // 현재 페이지
    private int beginPage; // 내비게이션의 첫 번째 페이지
    private int endPage; // 내비게이션의 마지막 페이지
    private boolean showPrev; // 이전 페이지로 이동하는 링크를 보여줄 것인지의 여부
    private boolean showNext; // 다음 페이지로 이동하는 링크를 보여줄 것인지의 여부

    public PageHandler(int totalCnt, int page) {
        this(totalCnt, page, 10);
    }

    // 페이징 계산하는데 필요한게 3가지
    public PageHandler(int totalCnt, int page, int pageSize) {
        this.totalCnt = totalCnt;
        this.page = page;
        this.pageSize = pageSize;

        totalPage = (int) Math.ceil(totalCnt / (double) pageSize); // 남는 페이지가 있을 수 있기 때문에 올림처리
        beginPage = (page - 1) / naviSize * naviSize + 1;
        endPage = Math.min(beginPage + naviSize - 1, totalPage); // endPage가 totalPage보다 작을 수 있기 때문에
        showPrev = beginPage != 1; // 시작 페이지가 1일 때만 안 나오면 된다.
        showNext = endPage != totalPage; // 다음으로 갈게 없으니까 보여주지않음
    }

    // page nav를 print하는 메서드
    public void print() {
        System.out.println("page = " + page);

        System.out.print(showPrev ? "[PREV] " : "");
        for (int i = beginPage; i <= endPage; i++) {
            System.out.print(i + " ");
        }
        System.out.println(showNext ? " [NEXT]" : "");
    }

    public int getTotalCnt() {
        return totalCnt;
    }

    public void setTotalCnt(int totalCnt) {
        this.totalCnt = totalCnt;
    }

    public int getPageSize() {
        return pageSize;
    }

    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    public int getNaviSize() {
        return naviSize;
    }

    public void setNaviSize(int naviSize) {
        this.naviSize = naviSize;
    }

    public int getTotalPage() {
        return totalPage;
    }

    public void setTotalPage(int totalPage) {
        this.totalPage = totalPage;
    }

    public int getPage() {
        return page;
    }

    public void setPage(int page) {
        this.page = page;
    }

    public int getBeginPage() {
        return beginPage;
    }

    public void setBeginPage(int beginPage) {
        this.beginPage = beginPage;
    }

    public int getEndPage() {
        return endPage;
    }

    public void setEndPage(int endPage) {
        this.endPage = endPage;
    }

    public boolean isShowPrev() {
        return showPrev;
    }

    public void setShowPrev(boolean showPrev) {
        this.showPrev = showPrev;
    }

    public boolean isShowNext() {
        return showNext;
    }

    public void setShowNext(boolean showNext) {
        this.showNext = showNext;
    }

    @Override
    public String toString() {
        return "PageHandler{" +
                "totalCnt=" + totalCnt +
                ", pageSize=" + pageSize +
                ", naviSize=" + naviSize +
                ", totalPage=" + totalPage +
                ", page=" + page +
                ", beginPage=" + beginPage +
                ", endPage=" + endPage +
                ", showPrev=" + showPrev +
                ", showNext=" + showNext +
                '}';
    }
}

BoardDao.java

package com.fastcampus.ch4.dao;

import com.fastcampus.ch4.domain.*;

import java.util.*;

public interface BoardDao {
    BoardDto select(Integer bno) throws Exception;
    int delete(Integer bno, String writer) throws Exception;
    int insert(BoardDto dto) throws Exception;
    int update(BoardDto dto) throws Exception;
    int increaseViewCnt(Integer bno) throws Exception;

    List<BoardDto> selectPage(Map map) throws Exception;
    List<BoardDto> selectAll() throws Exception;
    int deleteAll() throws Exception;
    int count() throws Exception;

//    int searchResultCnt(SearchCondition sc) throws Exception;
//    List<BoardDto> searchSelectPage(SearchCondition sc) throws Exception;
}

BoardDaoImpl.java

package com.fastcampus.ch4.dao;

import com.fastcampus.ch4.domain.*;
import org.apache.ibatis.session.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.stereotype.*;

import java.util.*;

@Repository
public class BoardDaoImpl implements BoardDao {
    @Autowired
    private SqlSession session;
    private static String namespace = "com.fastcampus.ch4.dao.BoardMapper.";

    @Override
    public int count() throws Exception {
        return session.selectOne(namespace+"count");
    } // T selectOne(String statement)

    @Override
    public int deleteAll() {
        return session.delete(namespace+"deleteAll");
    } // int delete(String statement)

    @Override
    public int delete(Integer bno, String writer) throws Exception {
        Map map = new HashMap();
        map.put("bno", bno);
        map.put("writer", writer);
        return session.delete(namespace+"delete", map);
    } // int delete(String statement, Object parameter)

    @Override
    public int insert(BoardDto dto) throws Exception {
        return session.insert(namespace+"insert", dto);
    } // int insert(String statement, Object parameter)

    @Override
    public List<BoardDto> selectAll() throws Exception {
        return session.selectList(namespace+"selectAll");
    } // List<E> selectList(String statement)

    @Override
    public BoardDto select(Integer bno) throws Exception {
        return session.selectOne(namespace + "select", bno);
    } // T selectOne(String statement, Object parameter)

    @Override
    public List<BoardDto> selectPage(Map map) throws Exception {
        return session.selectList(namespace+"selectPage", map);
    } // List<E> selectList(String statement, Object parameter)

    @Override
    public int update(BoardDto dto) throws Exception {
        return session.update(namespace+"update", dto);
    } // int update(String statement, Object parameter)

    @Override
    public int increaseViewCnt(Integer bno) throws Exception {
        return session.update(namespace+"increaseViewCnt", bno);
    } // int update(String statement, Object parameter)

//    @Override
//    public int searchResultCnt(SearchCondition sc) throws Exception {
//        System.out.println("sc in searchResultCnt() = " + sc);
//        System.out.println("session = " + session);
//        return session.selectOne(namespace+"searchResultCnt", sc);
//    } // T selectOne(String statement, Object parameter)
//
//    @Override
//    public List<BoardDto> searchSelectPage(SearchCondition sc) throws Exception {
//        return session.selectList(namespace+"searchSelectPage", sc);
//    } // List<E> selectList(String statement, Object parameter)
}

BoardDaoImplTest.java

package com.fastcampus.ch4.dao;

import com.fastcampus.ch4.domain.*;
import org.junit.*;
import org.junit.runner.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.test.context.*;
import org.springframework.test.context.junit4.*;

import java.util.*;

import static org.junit.Assert.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"file:src/main/webapp/WEB-INF/spring/root-context.xml"})
public class BoardDaoImplTest {
    @Autowired
    private BoardDao boardDao;

    @Test
    public void countTest() throws Exception {
        boardDao.deleteAll();
        assertTrue(boardDao.count() == 0);

        BoardDto boardDto = new BoardDto("no title", "no content", "asdf");
        assertTrue(boardDao.insert(boardDto) == 1);
        assertTrue(boardDao.count() == 1);

        assertTrue(boardDao.insert(boardDto) == 1);
        assertTrue(boardDao.count() == 2);
    }

    @Test
    public void deleteAllTest() throws Exception {
        boardDao.deleteAll();
        assertTrue(boardDao.count() == 0);

        BoardDto boardDto = new BoardDto("no title", "no content", "asdf");
        assertTrue(boardDao.insert(boardDto) == 1);
        assertTrue(boardDao.deleteAll() == 1);
        assertTrue(boardDao.count() == 0);

        boardDto = new BoardDto("no title", "no content", "asdf");
        assertTrue(boardDao.insert(boardDto) == 1);
        assertTrue(boardDao.insert(boardDto) == 1);
        assertTrue(boardDao.deleteAll() == 2);
        assertTrue(boardDao.count() == 0);
    }

    @Test
    public void deleteTest() throws Exception {
        boardDao.deleteAll();
        assertTrue(boardDao.count() == 0);

        BoardDto boardDto = new BoardDto("no title", "no content", "asdf");
        assertTrue(boardDao.insert(boardDto) == 1);
        Integer bno = boardDao.selectAll().get(0).getBno();
        assertTrue(boardDao.delete(bno, boardDto.getWriter()) == 1);
        assertTrue(boardDao.count() == 0);

        assertTrue(boardDao.insert(boardDto) == 1);
        bno = boardDao.selectAll().get(0).getBno();
        assertTrue(boardDao.delete(bno, boardDto.getWriter() + "222") == 0);
        assertTrue(boardDao.count() == 1);

        assertTrue(boardDao.delete(bno, boardDto.getWriter()) == 1);
        assertTrue(boardDao.count() == 0);

        assertTrue(boardDao.insert(boardDto) == 1);
        bno = boardDao.selectAll().get(0).getBno();
        assertTrue(boardDao.delete(bno + 1, boardDto.getWriter()) == 0);
        assertTrue(boardDao.count() == 1);
    }

    @Test
    public void insertTest() throws Exception {
        boardDao.deleteAll();
        BoardDto boardDto = new BoardDto("no title", "no content", "asdf");
        assertTrue(boardDao.insert(boardDto) == 1);

        boardDto = new BoardDto("no title", "no content", "asdf");
        assertTrue(boardDao.insert(boardDto) == 1);
        assertTrue(boardDao.count() == 2);

        boardDao.deleteAll();
        boardDto = new BoardDto("no title", "no content", "asdf");
        assertTrue(boardDao.insert(boardDto) == 1);
        assertTrue(boardDao.count() == 1);
    }

    @Test
    public void selectAllTest() throws Exception {
        boardDao.deleteAll();
        assertTrue(boardDao.count() == 0);

        List<BoardDto> list = boardDao.selectAll();
        assertTrue(list.size() == 0);

        BoardDto boardDto = new BoardDto("no title", "no content", "asdf");
        assertTrue(boardDao.insert(boardDto) == 1);

        list = boardDao.selectAll();
        assertTrue(list.size() == 1);

        assertTrue(boardDao.insert(boardDto) == 1);
        list = boardDao.selectAll();
        assertTrue(list.size() == 2);
    }

    @Test
    public void selectTest() throws Exception {
        boardDao.deleteAll();
        assertTrue(boardDao.count() == 0);

        BoardDto boardDto = new BoardDto("no title", "no content", "asdf");
        assertTrue(boardDao.insert(boardDto) == 1);

        Integer bno = boardDao.selectAll().get(0).getBno();
        boardDto.setBno(bno);
        BoardDto boardDto2 = boardDao.select(bno);
        assertTrue(boardDto.equals(boardDto2));
    }

    @Test
    public void selectPageTest() throws Exception {
        boardDao.deleteAll();

        for (int i = 1; i <= 10; i++) {
            BoardDto boardDto = new BoardDto("" + i, "no content" + i, "asdf");
            boardDao.insert(boardDto);
        }

        Map map = new HashMap();
        map.put("offset", 0);
        map.put("pageSize", 3);

        List<BoardDto> list = boardDao.selectPage(map);
        assertTrue(list.get(0).getTitle().equals("10"));
        assertTrue(list.get(1).getTitle().equals("9"));
        assertTrue(list.get(2).getTitle().equals("8"));

        map = new HashMap();
        map.put("offset", 0);
        map.put("pageSize", 1);

        list = boardDao.selectPage(map);
        assertTrue(list.get(0).getTitle().equals("10"));

        map = new HashMap();
        map.put("offset", 7);
        map.put("pageSize", 3);

        list = boardDao.selectPage(map);
        assertTrue(list.get(0).getTitle().equals("3"));
        assertTrue(list.get(1).getTitle().equals("2"));
        assertTrue(list.get(2).getTitle().equals("1"));
    }

    @Test
    public void updateTest() throws Exception {
        boardDao.deleteAll();
        BoardDto boardDto = new BoardDto("no title", "no content", "asdf");
        assertTrue(boardDao.insert(boardDto) == 1);

        Integer bno = boardDao.selectAll().get(0).getBno();
        System.out.println("bno = " + bno);
        boardDto.setBno(bno);
        boardDto.setTitle("yes title");
        assertTrue(boardDao.update(boardDto) == 1);

        BoardDto boardDto2 = boardDao.select(bno);
        assertTrue(boardDto.equals(boardDto2));
    }

    @Test
    public void increaseViewCntTest() throws Exception {
        boardDao.deleteAll();
        assertTrue(boardDao.count() == 0);

        BoardDto boardDto = new BoardDto("no title", "no content", "asdf");
        assertTrue(boardDao.insert(boardDto) == 1);
        assertTrue(boardDao.count() == 1);

        Integer bno = boardDao.selectAll().get(0).getBno();
        assertTrue(boardDao.increaseViewCnt(bno) == 1);

        boardDto = boardDao.select(bno);
        assertTrue(boardDto != null);
        assertTrue(boardDto.getView_cnt() == 1);

        assertTrue(boardDao.increaseViewCnt(bno) == 1);
        boardDto = boardDao.select(bno);
        assertTrue(boardDto != null);
        assertTrue(boardDto.getView_cnt() == 2);
    }
}

이제 Service를 만들 차례. BoardService는 BoardDaoImpl에 있는 걸 다 가져와야 한다.

BoardServiceImpl.java

package com.fastcampus.ch4.service;

import com.fastcampus.ch4.dao.*;
import com.fastcampus.ch4.domain.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.stereotype.*;

import java.util.*;

@Service
public class BoardServiceImpl implements BoardService {
    @Autowired
    BoardDao boardDao;

    @Override
    public int getCount() throws Exception {
        return boardDao.count();
    }

    @Override
    public int remove(Integer bno, String writer) throws Exception { // 삭제 시 게시물 번호와 작성자 일치하는지 확인
        return boardDao.delete(bno, writer);
    }

    @Override
    // Tx처리할게 없기 때문에 예외를 다 컨트롤러에게 던짐 Tx 처리해야 한다면 try-catch로 묶어야 함
    public int write(BoardDto boardDto) throws Exception {
        return boardDao.insert(boardDto);
    }

    @Override
    public List<BoardDto> getList() throws Exception {
        return boardDao.selectAll();
    }

    @Override
    public BoardDto read(Integer bno) throws Exception {
        BoardDto boardDto = boardDao.select(bno);
        boardDao.increaseViewCnt(bno);

        return boardDto;
    }

    @Override
    public List<BoardDto> getPage(Map map) throws Exception {
        return boardDao.selectPage(map);
    }

    @Override
    public int modify(BoardDto boardDto) throws Exception {
        return boardDao.update(boardDto);
    }

//    @Override
//    public int getSearchResultCnt(SearchCondition sc) throws Exception {
//        return boardDao.searchResultCnt(sc);
//    }
//
//    @Override
//    public List<BoardDto> getSearchResultPage(SearchCondition sc) throws Exception {
//        return boardDao.searchSelectPage(sc);
//    }
}

BoardService.java

package com.fastcampus.ch4.service;

import com.fastcampus.ch4.domain.BoardDto;

import java.util.List;
import java.util.Map;

public interface BoardService {
    int getCount() throws Exception;

    int remove(Integer bno, String writer) throws Exception;

    int write(BoardDto boardDto) throws Exception;

    List<BoardDto> getList() throws Exception;

    BoardDto read(Integer bno) throws Exception;

    List<BoardDto> getPage(Map map) throws Exception;

    int modify(BoardDto boardDto) throws Exception;

//    int getSearchResultCnt(SearchCondition sc) throws Exception;
//
//    List<BoardDto> getSearchResultPage(SearchCondition sc) throws Exception;
}

boardMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.fastcampus.ch4.dao.BoardMapper">
    <select id="count" resultType="int">
        SELECT count(*) FROM board
    </select>

    <delete id="deleteAll">
        DELETE FROM board
    </delete>

    <delete id="delete" parameterType="map">
        DELETE FROM board WHERE bno = #{bno} and writer = #{writer}
    </delete>

    <insert id="insert" parameterType="BoardDto">
        INSERT INTO board
            (title, content, writer)
        VALUES
            (#{title}, #{content}, #{writer})
    </insert>

    <select id="selectAll" resultType="BoardDto">
        SELECT bno, title, content, writer, view_cnt, comment_cnt, reg_date
        FROM board
        ORDER BY reg_date DESC, bno DESC
    </select>

    <sql id="selectFromBoard">
        SELECT bno, title, content, writer, view_cnt, comment_cnt, reg_date
        FROM board
    </sql>

    <select id="select" parameterType="int" resultType="BoardDto">
        <include refid="selectFromBoard"/>
        WHERE bno = #{bno}
    </select>

<!--    <select id="selectPage" parameterType="map" resultType="BoardDto">-->
<!--        <include refid="selectFromBoard"/>-->
<!--        ORDER BY reg_date DESC, bno DESC-->
<!--        LIMIT #{offset}, #{pageSize}-->
<!--    </select>-->

    <select id="selectPage" parameterType="map" resultType="BoardDto">
        SELECT bno, title, content, writer, view_cnt, comment_cnt, reg_date
        FROM board
        ORDER BY reg_date DESC, bno DESC
        LIMIT #{offset}, #{pageSize}
    </select>

    <update id="update" parameterType="BoardDto">
        UPDATE board
        SET   title = #{title}
          , content = #{content}
          , up_date = now()
        WHERE bno = #{bno}
    </update>

    <update id="updateCommentCnt" parameterType="map">
        UPDATE board
        SET   comment_cnt = comment_cnt + #{cnt}
        WHERE bno = #{bno}
    </update>

    <update id="increaseViewCnt" parameterType="int">
        UPDATE board
        SET   view_cnt = view_cnt + 1
        WHERE bno = #{bno}
    </update>

</mapper>

BoardController.java

package com.fastcampus.ch4.controller;

import com.fastcampus.ch4.domain.*;
import com.fastcampus.ch4.service.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.stereotype.*;
import org.springframework.ui.*;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.mvc.support.*;

import javax.servlet.http.*;
import java.time.*;
import java.util.*;

@Controller
@RequestMapping("/board")
public class BoardController {
    @Autowired
    BoardService boardService;

    @GetMapping("/list")
    public String list(int page, int pageSize, Model m, HttpServletRequest request) {
        if (!loginCheck(request))
            return "redirect:/login/login?toURL=" + request.getRequestURL();  // 로그인을 안했으면 로그인 화면으로 이동

        try {
            Map map = new HashMap();
            map.put("offset", (page - 1) * pageSize);
            map.put("pageSize", pageSize);

            List<BoardDto> list = boardService.getPage(map);
            m.addAttribute("list", list);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return "boardList"; // 로그인을 한 상태이면, 게시판 화면으로 이동
    }

    private boolean loginCheck(HttpServletRequest request) {
        // 1. 세션을 얻어서
        HttpSession session = request.getSession();
        // 2. 세션에 id가 있는지 확인, 있으면 true를 반환
        return session.getAttribute("id") != null;
    }
}

boardList.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>fastcampus</title>
    <link rel="stylesheet" href="<c:url value='/css/menu.css'/>">
</head>
<body>
<div id="menu">
    <ul>
        <li id="logo">fastcampus</li>
        <li><a href="<c:url value='/'/>">Home</a></li>
        <li><a href="<c:url value='/board/list'/>">Board</a></li>
        <li><a href="<c:url value='/login/login'/>">login</a></li>
        <li><a href="<c:url value='/register/add'/>">Sign in</a></li>
        <li><a href=""><i class="fas fa-search small"></i></a></li>
    </ul>
</div>
<div style="text-align:center">
    <table border="1">
        <tr>
            <th>번호</th>
            <th>제목</th>
            <th>이름</th>
            <th>등록일</th>
            <th>조회수</th>
        </tr>
        <c:forEach var="board" items="${list}">
            <tr>
                <td>${board.bno}</td>
                <td>${board.title}</td>
                <td>${board.writer}</td>
                <td>${board.reg_date}</td>
                <td>${board.view_cnt}</td>
            </tr>
        </c:forEach>
    </table>
    <br>
    <div>
        <c:if test="${ph.showPrev}">
            <a href="<c:url value='/board/list?page=${ph.beginPage - 1}&pageSize=${ph.pageSize} '/>">&lt;</a>
        </c:if>
        <c:forEach var="i" begin="${ph.beginPage}" end="${ph.endPage}">
            <a href="<c:url value='/board/list?page=${i}&pageSize=${ph.pageSize} '/>">${i}</a>
        </c:forEach>
        <c:if test="${ph.showNext}">
            <a href="<c:url value='/board/list?page=${ph.endPage + 1}&pageSize=${ph.pageSize} '/>">&gt;</a>
        </c:if>
    </div>
</div>
</body>
</html>

💡 매개변수를 Integer로하면 값이 안 들어왔을 때 에러가 발생하지 않는다. 둘이 어떤 차이인지 잘 알아두기

//    public String list(int page, int pageSize, Model m, HttpServletRequest request) {
    public String list(Integer page, Integer pageSize, Model m, HttpServletRequest request) { // page 값이 안 들어왔을 때 에러 발생 X

select * from board
order by reg_date desc, bno desc
limit 0, 10; # 0부터 10개 가져오라는 뜻

select * from board
order by reg_date desc, bno desc
limit 10, 10; # 2페이지

pageHandler 사용해서 view navigation 보여주기

잘 안 나오는 거 있으면 테스트 코드 작성해보기…

이 케이스 통과 안 되었었음

@Test
public void test3() {
    PageHandler ph = new PageHandler(255, 25);
    ph.print();
    System.out.println("ph = " + ph);
    assertTrue(ph.getBeginPage() == 21);
    assertTrue(ph.getEndPage() == 26);
}

before -> beginPage = (page - 1) / naviSize * naviSize + 1; // beginPage 계산이 잘못됐었음
after ->  beginPage = page/ naviSize * naviSize + 1;

05~06. 게시판 읽기, 쓰기, 삭제, 수정 기능 구현

1. 기능별 URI 정의

각 기능별로 URI를 먼저 정한다.

그 다음에는 메서드와 설명을 TABLE로 정리한다.

URL과 URI의 차이

URL : 전체 경로

URI : URL 일부

작업	URI	HTTP메서드	설명
읽기	/board/read?bno=번호	GET	지정된 번호의 게시물을 보여준다.
삭제	/board/remove	POST	게시물을 삭제한다.
쓰기	/board/write	GET	게시물을 작성하기 위한 화면을 보여준다.
	/board/write	POST	작성한 게시물을 저장한다.
수정	/board/modify?bno=번호	GET	게시물을 수정하기 위해 읽어온다.
	/board/modify	POST	수정된 게시물을 저장한다.

삭제 → 읽기 → 쓰기 → 수정 순서로 쉬움

2. 게시물 읽기 기능의 구현

boardList에서 title 클릭 시 해당 게시물을 읽는 요청(/board/read?bno=533)이 GET으로 가고 그걸 BoardController가 받아서 boardService.read(bno)를 호출해서 DB에서 boardDto를 받아다가 그 내용을 board.jsp에 뿌려줘야 한다.

아래처럼 프로젝트할 때 직접 다 flow를 그려봐야 한다.(DFD?가 뭔지 찾아보기)

[ 실습 ]

BoardController.java

Model에 담을 때 이름 생략 시 타입의 첫 글자를 소문자로 한 문자열이 키가 된다.

public String read(Integer bno, Model m) {
    try {
        BoardDto boardDto = boardService.read(bno);
				// m.addAttribute("boardDto", boardDto); // 아래 문장과 동일
        m.addAttribute(boardDto); // 이름 생략 시 타입의 첫 글자가 소문자로 바뀐게 key가된다.
    } catch (Exception e) {
        e.printStackTrace();
    }

    return "board";
}

board.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>fastcampus</title>
    <link rel="stylesheet" href="<c:url value='/css/menu.css'/>">
</head>
<body>
<div id="menu">
    <ul>
        <li id="logo">fastcampus</li>
        <li><a href="<c:url value='/'/>">Home</a></li>
        <li><a href="<c:url value='/board/list'/>">Board</a></li>
        <li><a href="<c:url value='/login/login'/>">login</a></li>
        <li><a href="<c:url value='/register/add'/>">Sign in</a></li>
        <li><a href=""><i class="fas fa-search small"></i></a></li>
    </ul>
</div>
<div style="text-align:center">
    <h2>게시물 읽기</h2>
    <form action="" id="form">
        <input type="text" name="bno" value="${boardDto.bno}" readonly/>
        <input type="text" name="title" value="${boardDto.title}" readonly>
        <textarea name="content" id="" cols="30" rows="10" readonly>${boardDto.content}</textarea>
        <button type="button" id="writeBtn" class="btn">등록</button>
        <button type="button" id="modifyBtn" class="btn">수정</button>
        <button type="button" id="removeBtn" class="btn">삭제</button>
        <button type="button" id="listBtn" class="btn">목록</button>
    </form>
</div>
</body>
</html>

게시물 읽기와 수정을 같은 board.jsp를 쓸 예정이다.

[ 결과 화면 ]

목록 버튼 누르면 boardList.jsp로 이동하는 기능 구현

게시물 리스트에서 제목 버튼을 눌려서 상세페이지로 이동한 상태일 때, 여기서 목록 버튼을 누르면 아무 목록 페이지로 이동하는 게 아니라 내가 보고 있었던 페이지로 가야 한다.

How?

boardList.jsp에서 첫 요청 시 BoardController가 page=3&pageSize=10을 받아서 그걸 board.jsp에 넘겨줘야 한다. 그래야 버튼 링크에 그 값이 넘어갈 수 있음

[ 실습 ]

BoardController.java

page와 pageSize를 boardController의 list 메서드가 줘야 한다.

@GetMapping("/list")
//    public String list(int page, int pageSize, Model m, HttpServletRequest request) {
public String list(Integer page, Integer pageSize, Model m, HttpServletRequest request) { // page 값이 안 들어왔을 때 에러 발생 X
    if (!loginCheck(request))
        return "redirect:/login/login?toURL=" + request.getRequestURL();  // 로그인을 안했으면 로그인 화면으로 이동

    if (page == null) page = 1;
    if (pageSize == null) pageSize = 10;

    try {
        int totalCnt = boardService.getCount();
        PageHandler pageHandler = new PageHandler(totalCnt, page, pageSize);

        Map map = new HashMap();
        map.put("offset", (page - 1) * pageSize);
        map.put("pageSize", pageSize);

        List<BoardDto> list = boardService.getPage(map);
        m.addAttribute("list", list);
        m.addAttribute("ph", pageHandler);
        m.addAttribute("page", page);
        m.addAttribute("pageSize", pageSize);
    } catch (Exception e) {
        e.printStackTrace();
    }

    return "boardList"; // 로그인을 한 상태이면, 게시판 화면으로 이동
}

/board/read

 @GetMapping("/read")
public String read(Integer bno, Integer page, Integer pageSize, Model m) {
    try {
        BoardDto boardDto = boardService.read(bno);
        m.addAttribute(boardDto); // 이름 생략 시 타입의 첫 글자가 소문자로 바뀐게 key가된다.
        m.addAttribute("page", page);
        m.addAttribute("pageSize", pageSize);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return "board";
}

board.jsp에 jquery 추가

원본

<%@ page language="java" contentType="text/html; charset=UTF-8" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>fastcampus</title>
    <link rel="stylesheet" href="<c:url value='/css/menu.css'/>">
    <script src="https://code.jquery.com/jquery-1.11.3.js"></script>
</head>
<body>
<div id="menu">
    <ul>
        <li id="logo">fastcampus</li>
        <li><a href="<c:url value='/'/>">Home</a></li>
        <li><a href="<c:url value='/board/list'/>">Board</a></li>
        <li><a href="<c:url value='/login/login'/>">login</a></li>
        <li><a href="<c:url value='/register/add'/>">Sign in</a></li>
        <li><a href=""><i class="fas fa-search small"></i></a></li>
    </ul>
</div>
<div style="text-align:center">
    <h2>게시물 읽기</h2>
    <form action="" id="form">
        <input type="text" name="bno" value="${boardDto.bno}" readonly/>
        <input type="text" name="title" value="${boardDto.title}" readonly>
        <textarea name="content" id="" cols="30" rows="10" readonly>${boardDto.content}</textarea>
        <button type="button" id="writeBtn" class="btn">등록</button>
        <button type="button" id="modifyBtn" class="btn">수정</button>
        <button type="button" id="removeBtn" class="btn">삭제</button>
        <button type="button" id="listBtn" class="btn">목록</button>
    </form>
</div>
<script>
    $(document).ready(function(){ // main() js window.onload랑 비슷한 거?
        $('#listBtn').on("click", function() {
            location.href = "<c:url value='/board/list'/>?page=${page}&pageSize=${pageSize}";
        });
    });
</script>
</body>
</html>

브라우저가 html문서를 쭉 읽고 dom을 다 구성하고 나면 document.ready이벤트가 발생

<script>
    $(document).ready(function(){ // main() js window.onload랑 비슷한 거?
        $('#listBtn').on("click", function() {
            location.href = "<c:url value='/board/list'/>?page=${page}&pageSize=${pageSize}";
        });
    });
</script>

3. 게시물 삭제 기능의 구현

model에 담아주면 redirect시 뒤에 자동으로 붙는다.

BoardController.java

@PostMapping("/remove")
public String remove(Integer bno, Integer page, Integer pageSize, Model m, HttpSession session) {
    String writer = (String) session.getAttribute("id");

    try {
        boardService.remove(bno, writer);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }

    m.addAttribute("page", page);
    m.addAttribute("pageSize", pageSize);

    return "redirect:/board/list";
}

board.jsp

remove 버튼 이벤트 등록

전체

<%@ page language="java" contentType="text/html; charset=UTF-8" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>fastcampus</title>
    <link rel="stylesheet" href="<c:url value='/css/menu.css'/>">
    <script src="https://code.jquery.com/jquery-1.11.3.js"></script>
</head>
<body>
<div id="menu">
    <ul>
        <li id="logo">fastcampus</li>
        <li><a href="<c:url value='/'/>">Home</a></li>
        <li><a href="<c:url value='/board/list'/>">Board</a></li>
        <li><a href="<c:url value='/login/login'/>">login</a></li>
        <li><a href="<c:url value='/register/add'/>">Sign in</a></li>
        <li><a href=""><i class="fas fa-search small"></i></a></li>
    </ul>
</div>
<div style="text-align:center">
    <h2>게시물 읽기</h2>
    <form action="" id="form">
        <input type="text" name="bno" value="${boardDto.bno}" readonly/>
        <input type="text" name="title" value="${boardDto.title}" readonly>
        <textarea name="content" id="" cols="30" rows="10" readonly>${boardDto.content}</textarea>
        <button type="button" id="writeBtn" class="btn">등록</button>
        <button type="button" id="modifyBtn" class="btn">수정</button>
        <button type="button" id="removeBtn" class="btn">삭제</button>
        <button type="button" id="listBtn" class="btn">목록</button>
    </form>
</div>
<script>
    $(document).ready(function(){ // main() js window.onload랑 비슷한 거?
        $('#listBtn').on("click", function() {
            location.href = "<c:url value='/board/list'/>?page=${page}&pageSize=${pageSize}";
        });

        $('#removeBtn').on("click", function() {
            if(!confirm("정말로 삭제하시겠습니까?")) return;

            let form = $('#form');
            form.attr("action", "<c:url value='/board/remove'/>?page=${page}&pageSize=${pageSize}")
            form.attr("method", "post");
            form.submit();
        });
    });
</script>
</body>
</html>

$('#removeBtn').on("click", function() {
    if(!confirm("정말로 삭제하시겠습니까?")) return;
    
    let form = $('#form');
    form.attr("action", "<c:url value='/board/remove'/>?page=${page}&pageSize=${pageSize}")
    form.attr("method", "post");
    form.submit();
});

삭제되면 삭제되었다고 메시지 띄우기 + 삭제가 정상적으로 안 되면 예외

BoardController.java

@PostMapping("/remove")
public String remove(Integer bno, Integer page, Integer pageSize, Model m, HttpSession session) {
    String writer = (String) session.getAttribute("id");

    try {
        m.addAttribute("page", page);
        m.addAttribute("pageSize", pageSize);

        int rowCnt = boardService.remove(bno, writer);

        if (rowCnt != 1) {
            throw new Exception("board remove error");
        }
        m.addAttribute("msg", "DEL_OK");

    } catch (Exception e) {
        e.printStackTrace();
        m.addAttribute("msg", "DEL_ERR");
    }

    return "redirect:/board/list";
}

boardList.jsp

전체 코드

<%@ page language="java" contentType="text/html; charset=UTF-8" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>fastcampus</title>
    <link rel="stylesheet" href="<c:url value='/css/menu.css'/>">
</head>
<body>
<div id="menu">
    <ul>
        <li id="logo">fastcampus</li>
        <li><a href="<c:url value='/'/>">Home</a></li>
        <li><a href="<c:url value='/board/list'/>">boardDto</a></li>
        <li><a href="<c:url value='/login/login'/>">login</a></li>
        <li><a href="<c:url value='/register/add'/>">Sign in</a></li>
        <li><a href=""><i class="fas fa-search small"></i></a></li>
    </ul>
</div>
<div style="text-align:center">
    <table border="1">
        <tr>
            <th>번호</th>
            <th>제목</th>
            <th>이름</th>
            <th>등록일</th>
            <th>조회수</th>
        </tr>
        <c:forEach var="boardDto" items="${list}">
            <tr>
                <td>${boardDto.bno}</td>
                <td><a href="<c:url value='/board/read?bno=${boardDto.bno}&page=${page}&pageSize=${pageSize}' />">${boardDto.title}</a></td>
                <td>${boardDto.writer}</td>
                <td>${boardDto.reg_date}</td>
                <td>${boardDto.view_cnt}</td>
            </tr>
        </c:forEach>
    </table>
    <br>
    <div>
        <c:if test="${ph.showPrev}">
            <a href="<c:url value='/board/list?page=${ph.beginPage - 1}&pageSize=${ph.pageSize} '/>">&lt;</a>
        </c:if>
        <c:forEach var="i" begin="${ph.beginPage}" end="${ph.endPage}">
            <a href="<c:url value='/board/list?page=${i}&pageSize=${ph.pageSize} '/>">${i}</a>
        </c:forEach>
        <c:if test="${ph.showNext}">
            <a href="<c:url value='/board/list?page=${ph.endPage + 1}&pageSize=${ph.pageSize} '/>">&gt;</a>
        </c:if>
    </div>
</div>

<script>
    let msg = "${param.msg}";
    if (msg == "DEL_OK") alert("성공적으로 삭제되었습니다.");
    if (msg == "DEL_ERR") alert("삭제 실패");
</script>
</body>
</html>

get 방식이라 model에 있는게 parameter로 전달이 됨

<script>
    let msg = "${param.msg}";
    if (msg == "DEL_OK") alert("성공적으로 삭제되었습니다.");
    if (msg == "DEL_ERR") alert("삭제 실패");
</script>

여기서 새로고침하면 삭제 실패했다는 메시지가 계속 뜸

메시지가 한 번만 뜨게할 때 쓰는 게 redirectAttributes다. model이 아니라 redirectAttribute에 저장하면 메시지가 한 번만 나온다.

BoardController.java

전체코드

package com.fastcampus.ch4.controller;

import com.fastcampus.ch4.domain.*;
import com.fastcampus.ch4.service.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.stereotype.*;
import org.springframework.ui.*;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.mvc.support.*;

import javax.servlet.http.*;
import java.time.*;
import java.util.*;

@Controller
@RequestMapping("/board")
public class BoardController {
    @Autowired
    BoardService boardService;

    @PostMapping("/remove")
    public String remove(Integer bno, Integer page, Integer pageSize, Model m, HttpSession session, RedirectAttributes rattr) {
        String writer = (String) session.getAttribute("id");

        try {
            m.addAttribute("page", page);
            m.addAttribute("pageSize", pageSize);

            int rowCnt = boardService.remove(bno, writer);

            if (rowCnt != 1) {
                throw new Exception("board remove error");
            }

            // 일회성. 한 번만 쓰고 사라진다.(세션을 이용함. 세션에 잠깐 저장했다가 한 번 사용하고 삭제.)
            rattr.addFlashAttribute("msg", "DEL_OK"); //
        } catch (Exception e) {
            e.printStackTrace();
            rattr.addFlashAttribute("msg", "DEL_ERR");
        }

        return "redirect:/board/list";
    }

    @GetMapping("/read")
    public String read(Integer bno, Integer page, Integer pageSize, Model m) {
        try {
            BoardDto boardDto = boardService.read(bno);
//            m.addAttribute("boardDto", boardDto); // 아래 문장과 동일
            m.addAttribute(boardDto); // 이름 생략 시 타입의 첫 글자가 소문자로 바뀐게 key가된다.
            m.addAttribute("page", page);
            m.addAttribute("pageSize", pageSize);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "board";
    }

    @GetMapping("/list")
//    public String list(int page, int pageSize, Model m, HttpServletRequest request) {
    public String list(Integer page, Integer pageSize, Model m, HttpServletRequest request) { // page 값이 안 들어왔을 때 에러 발생 X
        if (!loginCheck(request))
            return "redirect:/login/login?toURL=" + request.getRequestURL();  // 로그인을 안했으면 로그인 화면으로 이동

        if (page == null) page = 1;
        if (pageSize == null) pageSize = 10;

        try {
            int totalCnt = boardService.getCount();
            PageHandler pageHandler = new PageHandler(totalCnt, page, pageSize);

            Map map = new HashMap();
            map.put("offset", (page - 1) * pageSize);
            map.put("pageSize", pageSize);

            List<BoardDto> list = boardService.getPage(map);
            m.addAttribute("list", list);
            m.addAttribute("ph", pageHandler);
            m.addAttribute("page", page);
            m.addAttribute("pageSize", pageSize);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return "boardList"; // 로그인을 한 상태이면, 게시판 화면으로 이동
    }

    private boolean loginCheck(HttpServletRequest request) {
        // 1. 세션을 얻어서
        HttpSession session = request.getSession();
        // 2. 세션에 id가 있는지 확인, 있으면 true를 반환
        return session.getAttribute("id") != null;
    }
}

RedirectAttributes의 addFlashAttribute : 일회성. 한 번만 쓰고 사라진다.(세션을 이용함. 세션에 잠깐 저장했다가 한 번 사용하고 삭제.)

@PostMapping("/remove")
public String remove(Integer bno, Integer page, Integer pageSize, Model m, HttpSession session, RedirectAttributes rattr) {
    String writer = (String) session.getAttribute("id");

    try {
        m.addAttribute("page", page);
        m.addAttribute("pageSize", pageSize);

        int rowCnt = boardService.remove(bno, writer);

        if (rowCnt != 1) {
            throw new Exception("board remove error");
        }

        // 일회성. 한 번만 쓰고 사라진다.(세션을 이용함. 세션에 잠깐 저장했다가 한 번 사용하고 삭제.)
        rattr.addFlashAttribute("msg", "DEL_OK"); //
    } catch (Exception e) {
        e.printStackTrace();
        rattr.addFlashAttribute("msg", "DEL_ERR");
    }

    return "redirect:/board/list";
}

boardList.jsp

param.쓰면 안 되고 msg만 써야됨

전체코드

<%@ page language="java" contentType="text/html; charset=UTF-8" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>fastcampus</title>
    <link rel="stylesheet" href="<c:url value='/css/menu.css'/>">
</head>
<body>
<div id="menu">
    <ul>
        <li id="logo">fastcampus</li>
        <li><a href="<c:url value='/'/>">Home</a></li>
        <li><a href="<c:url value='/board/list'/>">boardDto</a></li>
        <li><a href="<c:url value='/login/login'/>">login</a></li>
        <li><a href="<c:url value='/register/add'/>">Sign in</a></li>
        <li><a href=""><i class="fas fa-search small"></i></a></li>
    </ul>
</div>
<div style="text-align:center">
    <table border="1">
        <tr>
            <th>번호</th>
            <th>제목</th>
            <th>이름</th>
            <th>등록일</th>
            <th>조회수</th>
        </tr>
        <c:forEach var="boardDto" items="${list}">
            <tr>
                <td>${boardDto.bno}</td>
                <td><a href="<c:url value='/board/read?bno=${boardDto.bno}&page=${page}&pageSize=${pageSize}' />">${boardDto.title}</a></td>
                <td>${boardDto.writer}</td>
                <td>${boardDto.reg_date}</td>
                <td>${boardDto.view_cnt}</td>
            </tr>
        </c:forEach>
    </table>
    <br>
    <div>
        <c:if test="${ph.showPrev}">
            <a href="<c:url value='/board/list?page=${ph.beginPage - 1}&pageSize=${ph.pageSize} '/>">&lt;</a>
        </c:if>
        <c:forEach var="i" begin="${ph.beginPage}" end="${ph.endPage}">
            <a href="<c:url value='/board/list?page=${i}&pageSize=${ph.pageSize} '/>">${i}</a>
        </c:forEach>
        <c:if test="${ph.showNext}">
            <a href="<c:url value='/board/list?page=${ph.endPage + 1}&pageSize=${ph.pageSize} '/>">&gt;</a>
        </c:if>
    </div>
</div>

<script>
    let msg = "${msg}";
    if (msg == "DEL_OK") alert("성공적으로 삭제되었습니다.");
    if (msg == "DEL_ERR") alert("삭제 실패");
</script>
</body>
</html>

// let msg = "${param.msg}";
let msg = "${msg}";
if (msg == "DEL_OK") alert("성공적으로 삭제되었습니다.");
if (msg == "DEL_ERR") alert("삭제 실패");

SQL Injection 실습

sql injection을 막으려면 statement 쓰면 안 되고 preparedstatement를 써야 한다.

4. 게시물 쓰기 기능의 구현

[GET] /board/write

BoardController

write

@GetMapping("/write")
public String write(Model m) {
    m.addAttribute("mode", "new"); // 읽기과 쓰기에 사용. 쓰게에 사용할 때는 mode = new
    return "board";
}

board.jsp

mode 여부에 따라 h2와 readonly

<h2>게시물 ${mode == "new" ? "글쓰기" : "읽기"}</h2>
<form action="" id="form">
    <input type="hidden" name="bno" value="${boardDto.bno}" />
    <input type="text" name="title" value="${boardDto.title}" ${mode == "new" ? '' : 'readonly'}>
    <textarea name="content" id="" cols="30" rows="10" ${mode == "new" ? '' : 'readonly'}>${boardDto.content}</textarea>
    <button type="button" id="writeBtn" class="btn">등록</button>
    <button type="button" id="modifyBtn" class="btn">수정</button>
    <button type="button" id="removeBtn" class="btn">삭제</button>
    <button type="button" id="listBtn" class="btn">목록</button>
</form>

jsp에서는 mode 값을 확인해서 new일 때는 쓰기 세팅 아닐 때는 보여만준다.

[POST] /board/write

board.jsp

$('#writeBtn').on("click", function() {
    let form = $('#form');
    form.attr("action", "<c:url value='/board/write'/>");
    form.attr("method", "post");
    form.submit();
});

BoardController.java

몇페이지인지 상관없이 최근 게시물로 보내면 됨
```
return "redirect:/board/list"
```

게시글 등록 시 boardDto에 writer를 추가해야 한다.

String writer = (String) session.getAttribute("id");
boardDto.setWriter(writer);

boardService.write가 예외를 발생시킬 가능성이 있기 때문에 try-catch로 감싸준다.

try {
    int rowCnt = boardService.write(boardDto);
} catch (Exception e) {
    e.printStackTrace();
}

boardService.write의 결과값을 받아서 rowCnt가 1이 아니면 exception을 발생시킨다.
```
throw new Exception("Write failed");
```

저장 실패 시 사용자가 입력했던 내용을 다시 보여주어야함
model을 이용해서 다시 보여준다.
```
} catch (Exception e) {
    e.printStackTrace();
    m.addAttribute("boardDto", boardDto);
    return "board";
}
```

처리 결과를 클라이언트쪽에 알려줘야 한다. (세션을 이용한 1회성 저장)

try {
    int rowCnt = boardService.write(boardDto);

    if (rowCnt != 1)
        throw new Exception("Write failed");

    m.addAttribute("msg", "WRT_OK");

} catch (Exception e) {
    e.printStackTrace();
    m.addAttribute("boardDto", boardDto);
    m.addAttribute("msg", "WRT_ERR");
    return "board";
}

그런데 결과를 model에 담으면 주소창에 남아서 alert창이 계속 뜨기 때문에 RedirectAttributes를 쓴다.

flash → 세션을 이용한 1회성 저장

rattr.addFlashAttribute("msg", "WRT_OK");
m.addAttribute("msg", "WRT_ERR");

boardList.jsp

if (msg == "WRT_OK") alert("성공적으로 등록되었습니다.");

board.jsp

let msg = "${msg}";
if (msg == "WRT_ERR") alert("게시글 등록에 실패하였습니다. 다시 시도해주세요.");

실패 시에도 잘 동작하는지 무조건 다 테스트를 해봐야 한다.

5. 게시물 수정 기능의 구현

[GET] /board/modify

attribute VS property

HTML에서는 둘을 명확히 구분한다.

HTML 태그 내부에 작성된 것을 attribute라고 하고, 생성된 객체의 속성을 property라고 한다.(Java에서의 iv임)

[POST] /board/modify

실습

board.jsp

$('#modifyBtn').on("click", function() {
    // 1. 읽기 상태이면 수정 상태로 변경
    let form = $('#form');
    let isReadOnly = $("input[name=title]").attr('readonly');

		if (isReadOnly == 'readonly') {
        $("input[name=title]").attr('readonly', false); // title
        $("textarea").attr('readonly', false);
        $("#modifyBtn").html("등록");
        $("h2").html("게시물 수정")
    }

    // 2. 수정 상태이면, 수정된 내용을 서버로 전송
    form.attr("action", "<c:url value='/board/modify'/>")
    form.attr("method", "post");
    form.submit();
});

BoardController.java

@PostMapping("/write")
public String modify(BoardDto boardDto, Model m, HttpSession session, RedirectAttributes rattr) {
    String writer = (String) session.getAttribute("id");
    boardDto.setWriter(writer);

    try {
        int rowCnt = boardService.modify(boardDto);

        if (rowCnt != 1)
            throw new Exception("modify failed");

        rattr.addFlashAttribute("msg", "MOD_OK");

    } catch (Exception e) {
        e.printStackTrace();
        m.addAttribute("boardDto", boardDto);
        m.addAttribute("msg", "MOD_ERR");
        return "board";
    }

    return "redirect:/board/list";
}

boardMapper.xml

수정/삭제 버튼은 본인일 때만 나타나야 한다.

<update id="update" parameterType="BoardDto">
    UPDATE board
    SET   title = #{title}
      , content = #{content}
      , up_date = now()
    WHERE bno = #{bno} and writer = #{writer}
</update>

과제

게시글 수정 후 목록으로 돌아가야 하는데 사용자가 보고 있던 위치로 가야 한다.

그리고 게시글을 수정하는 도중 다른 사용자가 게시글을 삭제하면, “삭제되었거나 없는 게시글입니다.”라는 메시지가 출력된다. 이때 화면은 유지되어야 한다.

다른 서비스들이 게시판을 어떻게 처리하는지 확인하고, 실패했을 때의 상황을 테스트해보자. 이런 경험은 개발 능력을 향상시키는 데 큰 도움이 된다.

07~08 게시판 검색 기능 추가하기(1)

1. 게시판 검색

동적 쿼리 : 검색 대상에 따라 SQL 쿼리가 달라지는 기능이다. 사용자가 어떤 항목을 기준으로(제목+내용, 제목, 내용) 검색하는지에 따라 쿼리가 변경되어야 한다.

페이지 이동 처리 : 검색 결과에도 페이징 필요

이제 page와 pageSize외에도 검색 옵션과 키워드를 전송해야 한다.

2. MyBatis의 동적 쿼리

<sql>과 <include>

공통 부분을 <sql>로 정의하고 <include>로 포함시켜 재사용할 수 있다.

<if>

특정 조건이 만족될 때만 SQL 문장을 생성한다.

위의 케이스에서는 여러 조건 중에 하나만 만족하면 되기 때문에 if문보다는 choose가 적합하다.

<choose> <when>

<foreach>

배열이나 컬렉션의 각 항목에 대해 반복적으로 SQL을 생성한다.

WHERE bno IN(1, 2, 3) 에서 괄호 안이 몇 개인지 정해져 있지 않은 경우에는 sql문을 작성하기 어렵다. 그럴 때 쓰는 게 foreach다.

배열을 주면 괄호 안에다가 ‘,’ 를 구분자로 해서 위처럼 만들어준다.

배열에 들어있는 값이 [1, 2, 3, 4]라면 WHERE bno IN (1, 2, 3, 4)와 같은 SQL이 생성된다.

실습

1. sql 작성

boardMapper.xml

searchSelectPage 추가 : 게시판의 게시글을 페이지 단위로 검색한다.

<select id="searchSelectPage" parameterType="SearchCondition" resultType="BoardDto">
    SELECT bno, title, content, writer, view_cnt, comment_cnt, reg_date
    FROM board
     WHERE TRUE
       AND title LIKE concat('%', #{keyword}, '%')
    ORDER BY reg_date DESC, bno DESC
        LIMIT #{offset}, #{pageSize}
</select>

[ parameterType 설정 ]

패키지명을 모두 입력하는 대신 ‘SearchCondition’과 같은 별칭을 사용하고 있다. 이 별칭은 mybatis-config.xml 파일의 <typeAliases> 부분에 등록한다.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <typeAlias alias="BoardDto" type="com.fastcampus.ch4.domain.BoardDto"/>
        <typeAlias alias="SearchCondition" type="com.fastcampus.ch4.domain.SearchCondition" />
    </typeAliases>
</configuration>

searchResultCnt 추가 : 검색 결과가 몇 개인지 알아야 페이징을 할 수 있기 때문에 추가

<select id="searchResultCnt" parameterType="SearchCondition" resultType="int">
    SELECT count(*)
    FROM board
    WHERE TRUE
      AND title LIKE concat('%', #{keyword}, '%')
</select>

동적쿼리는 실수하기 쉽기 때문에 기본적인 동작을이 다 돌아가는지 먼저 확인해보고 그 뒤에 작성해야 한다.

2. DAO

[ DAO 메서드 추가]

방금 만든 쿼리문을 호출하는 메서드를 만들어보자.

@Override
    public int searchResultCnt(SearchCondition sc) throws Exception {
    return session.selectOne(namespace + "searchResultCnt", sc);
} // T selectOne(String statement, Object parameter)

@Override
public List<BoardDto> searchSelectPage(SearchCondition sc) throws Exception {
    return session.selectList(namespace + "selectPage", sc);
} // List<E> selectList(String statement, Object parameter)

[ SearchCondition 클래스 생성 ]

SearchCondition = 검색조건

생성자는 offset을 제외하고 생성한다.

[ 테스트 코드 작성 ]

테스트 코드 정말 꼼꼼히 해야 하는데 시간 관계상 간단히 한것.

어떻게 하면 철저하게 할 수 있을지 고민을 많이 해야 한다.

@Test
public void searchSelectPageTest() throws Exception {
    boardDao.deleteAll();

    for (int i = 0; i <= 20; i++) {
        BoardDto boardDto = new BoardDto("title" + i, "asdfafd", "adff");
        boardDao.insert(boardDto);
    }

    SearchCondition sc = new SearchCondition(1, 10, "title2", "T");
     List<BoardDto> list = boardDao.searchSelectPage(sc);
    System.out.println("boardList = " + list);
    assertTrue(list.size() == 2);
}

@Test
public void searchResultCntTest() throws Exception {
    boardDao.deleteAll();

    for (int i = 0; i <= 20; i++) {
        BoardDto boardDto = new BoardDto("title" + i, "asdfafd", "adff");
        boardDao.insert(boardDto);
    }

    SearchCondition sc = new SearchCondition(1, 10, "title2", "T");
    int list = boardDao.searchResultCnt(sc);
    System.out.println("boardList = " + list);
    assertTrue(list == 2);
}

[ SQL 실행 확인 ]

log4jdbc 라이브러리를 사용하여 실제로 실행되는 SQL을 확인할 수 있다.

Maven Repository

log4jdbc.log4j2.properties

log4jdbc.spylogdelegator.name=net.sf.log4jdbc.log.slf4j.Slf4jSpyLogDelegator

logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration>
<configuration>
    <include resource="org/springframework/boot/logging/logback/base.xml"/>

    <!-- log4jdbc-log4j2 -->
    <logger name="jdbc.sqlonly" level="INFO"/>
    <logger name="jdbc.sqltiming" level="INFO"/>
    <logger name="jdbc.audit" level="WARN"/>
    <logger name="jdbc.resultset" level="INFO"/>
    <logger name="jdbc.resultsettable" level="INFO"/>
    <logger name="jdbc.connection" level="INFO"/>
</configuration>

root-context.xml

2줄 추가

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="net.sf.log4jdbc.sql.jdbcapi.DriverSpy" />
    <property name="url" value="jdbc:log4jdbc:mysql://localhost:3306/springbasic?useUnicode=true&amp;characterEncoding=utf8" />
<!--        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>-->
<!--        <property name="url" value="jdbc:mysql://localhost:3306/springbasic?useUnicode=true&amp;characterEncoding=utf8"></property>-->
    <property name="username" value="coals0115"></property>
    <property name="password" value="1234"></property>
</bean>

이렇게 설정하고 test를 돌리면 sql이 실행되는 과정이 쭉 나온다.

INFO : jdbc.sqltiming - SELECT count(*) FROM board WHERE TRUE AND title LIKE concat('%', 'title2', '%') ORDER BY reg_date 
DESC, bno DESC LIMIT 0, 10 
 {executed in 8 msec}
INFO : jdbc.audit - 23. PreparedStatement.execute() returned true
INFO : jdbc.resultset - 23. ResultSet.new ResultSet returned 
INFO : jdbc.audit - 23. PreparedStatement.getResultSet() returned net.sf.log4jdbc.sql.jdbcapi.ResultSetSpy@4f67e3df
INFO : jdbc.resultset - 23. ResultSet.getMetaData() returned com.mysql.cj.jdbc.result.ResultSetMetaData@45d64d27 - Field level information: 
	com.mysql.cj.result.Field@34fe326d[dbName=null,tableName=null,originalTableName=null,columnName=count(*),originalColumnName=null,mysqlType=8(FIELD_TYPE_BIGINT),sqlType=-5,flags= BINARY, charsetIndex=63, charsetName=ISO-8859-1]
INFO : jdbc.resultset - 23. ResultSet.getType() returned 1003
INFO : jdbc.resultset - 23. ResultSet.isClosed() returned false
INFO : jdbc.resultset - 23. ResultSet.next() returned true
INFO : jdbc.resultset - 23. ResultSet.getInt(count(*)) returned 2
INFO : jdbc.resultset - 23. ResultSet.isClosed() returned false
INFO : jdbc.resultsettable - 
|---------|
|count(*) |
|---------|
|2        |
|---------|

3. Service

BoardServiceImpl.java

@Override
public int getSearchResultCnt(SearchCondition sc) throws Exception {
    return boardDao.searchResultCnt(sc);
}

@Override
public List<BoardDto> getSearchResultPage(SearchCondition sc) throws Exception {
    return boardDao.searchSelectPage(sc);
}

BoardService.java

int getSearchResultCnt(SearchCondition sc) throws Exception;

List<BoardDto> getSearchResultPage(SearchCondition sc) throws Exception;

service 테스트는 시간과계샹 생략, 알아서 해보기

4. Controller

BoardController.java

public String list(@RequestParam(defaultValue = "1") Integer page,
                   @RequestParam(defaultValue = "10") Integer pageSize, String option, String keyword, Model m, HttpServletRequest request) { // page 값이 안 들어왔을 때 에러 발생 X

[ 1. Controller 메서드 파라미터 수정 ]

(page, pageSize, option, keyword) 매개변수가 너무 길기 때문에 아래처럼 깔끔하게 SearchCondition 객체 하나 받도록 변경!(자동으로 앞에 ModelAttribute 붙는다.)

public String list(SearchCondition sc, Model m, HttpServletRequest request)

[ 2. 코드 리팩토링 ]

SearchCondition 객체를 사용하면서, 페이징 관련 코드가 간단해졌다. 기존에는 페이지 번호와 페이지 크기를 직접 처리했지만, 이제는 PageHandler를 통해 처리합니다. , 페이지 오프셋과 페이지 크기를 맵 객체에 담아서 boardService.getPage 메서드에 전달하는 부분도 삭제됨

Before

@GetMapping("/list")
//    public String list(int page, int pageSize, Model m, HttpServletRequest request) {
public String list(SearchCondition sc, Model m, HttpServletRequest request) { // page 값이 안 들어왔을 때 에러 발생 X
    if (!loginCheck(request))
        return "redirect:/login/login?toURL=" + request.getRequestURL();  // 로그인을 안했으면 로그인 화면으로 이동

    try {
        int totalCnt = boardService.getCount();
//            PageHandler pageHandler = new PageHandler(totalCnt, page, pageSize);
        PageHandler pageHandler = new PageHandler(totalCnt, sc);

        // 아래는 다 내부적 처리하도록 변경
//            if (page < 0 || page > pageHandler.getTotalPage())
//                page = 1;
//            if (pageSize < 0 || pageSize > 50)
//                pageSize = 10;

        // 얘도 지우기
//            Map map = new HashMap();
//            map.put("offset", (page - 1) * pageSize);
//            map.put("pageSize", pageSize);

        List<BoardDto> list = boardService.getPage(map);
        m.addAttribute("list", list);
        m.addAttribute("ph", pageHandler);
        m.addAttribute("page", page);
        m.addAttribute("pageSize", pageSize);
    } catch (Exception e) {
        e.printStackTrace();
    }

    return "boardList"; // 로그인을 한 상태이면, 게시판 화면으로 이동
}

After

@GetMapping("/list")
//    public String list(int page, int pageSize, Model m, HttpServletRequest request) {
public String list(SearchCondition sc, Model m, HttpServletRequest request) { // page 값이 안 들어왔을 때 에러 발생 X
    if (!loginCheck(request))
        return "redirect:/login/login?toURL=" + request.getRequestURL();  // 로그인을 안했으면 로그인 화면으로 이동

    try {
        int totalCnt = boardService.getCount();
        PageHandler pageHandler = new PageHandler(totalCnt, page, pageSize);

        if (page < 0 || page > pageHandler.getTotalPage())
            page = 1;
        if (pageSize < 0 || pageSize > 50)
            pageSize = 10;

        Map map = new HashMap();
        map.put("offset", (page - 1) * pageSize);
        map.put("pageSize", pageSize);

        List<BoardDto> list = boardService.getPage(map);
        m.addAttribute("list", list);
        m.addAttribute("ph", pageHandler);
        m.addAttribute("page", page);
        m.addAttribute("pageSize", pageSize);
    } catch (Exception e) {
        e.printStackTrace();
    }

    return "boardList"; // 로그인을 한 상태이면, 게시판 화면으로 이동
}

PageHandler.java

//    private int page; // 현재 페이지
//    private int pageSize; // 한 페이지의 크기
//    private String option;
//    private String keyword;
   private SearchCondition sc; 

public PageHandler(int totalCnt, SearchCondition sc) {
    this.totalPage = totalCnt;
    this.sc = sc;

    doPaging(totalCnt, sc);
}

[ PageHandelr 생성자 메서드로 변경 ]

public PageHandler(int totalCnt, int page, int pageSize) {
    this.totalCnt = totalCnt;
    this.page = page;
    this.pageSize = pageSize;

    totalPage = (int) Math.ceil(totalCnt / (double) pageSize); // 남는 페이지가 있을 수 있기 때문에 올림처리
    beginPage = (page - 1) / naviSize * naviSize + 1;
    endPage = Math.min(beginPage + naviSize - 1, totalPage); // endPage가 totalPage보다 작을 수 있기 때문에
    showPrev = beginPage != 1; // 시작 페이지가 1일 때만 안 나오면 된다.
    showNext = endPage != totalPage; // 다음으로 갈게 없으니까 보여주지않음
}

public PageHandler(int totalCnt, SearchCondition sc) {
    this.totalPage = totalCnt;
    this.sc = sc;

    doPaging(totalCnt, sc);
}

// 페이징 계산하는데 필요한게 3가지
public void doPaging(int totalCnt, SearchCondition sc){
    this.totalCnt = totalCnt;

    totalPage = (int) Math.ceil(totalCnt / (double) sc.getPageSize()); // 남는 페이지가 있을 수 있기 때문에 올림처리
    beginPage = (sc.getPage() - 1) / naviSize * naviSize + 1;
    endPage = Math.min(beginPage + naviSize - 1, totalPage); // endPage가 totalPage보다 작을 수 있기 때문에
    showPrev = beginPage != 1; // 시작 페이지가 1일 때만 안 나오면 된다.
    showNext = endPage != totalPage; // 다음으로 갈게 없으니까 보여주지않음
}

[ 2. board.jsp, boardList.jsp 변경 ]

jsp를 바꿔보자.

board.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jstl/core_rt" %>
<%@ page session="true" %>
<c:set var="loginId" value="${sessionScope.id}"/>
<c:set var="loginOutLink" value="${loginId=='' ? '/login/login' : '/login/logout'}"/>
<c:set var="loginOut" value="${loginId=='' ? 'Login' : 'ID='+=loginId}"/>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>fastcampus</title>
    <link rel="stylesheet" href="<c:url value='/css/menu.css'/>">
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css">
    <script src="https://code.jquery.com/jquery-1.11.3.js"></script>
    <style>
        * {
            box-sizing: border-box;
            margin: 0;
            padding: 0;
            font-family: "Noto Sans KR", sans-serif;
        }

        .container {
            width: 50%;
            margin: auto;
        }

        .writing-header {
            position: relative;
            margin: 20px 0 0 0;
            padding-bottom: 10px;
            border-bottom: 1px solid #323232;
        }

        input {
            width: 100%;
            height: 35px;
            margin: 5px 0px 10px 0px;
            border: 1px solid #e9e8e8;
            padding: 8px;
            background: #f8f8f8;
            outline-color: #e6e6e6;
        }

        textarea {
            width: 100%;
            background: #f8f8f8;
            margin: 5px 0px 10px 0px;
            border: 1px solid #e9e8e8;
            resize: none;
            padding: 8px;
            outline-color: #e6e6e6;
        }

        .frm {
            width: 100%;
        }

        .btn {
            background-color: rgb(236, 236, 236); /* Blue background */
            border: none; /* Remove borders */
            color: black; /* White text */
            padding: 6px 12px; /* Some padding */
            font-size: 16px; /* Set a font size */
            cursor: pointer; /* Mouse pointer on hover */
            border-radius: 5px;
        }

        .btn:hover {
            text-decoration: underline;
        }
    </style>
</head>
<body>
<div id="menu">
    <ul>
        <li id="logo">fastcampus</li>
        <li><a href="<c:url value='/'/>">Home</a></li>
        <li><a href="<c:url value='/board/list'/>">Board</a></li>
        <li><a href="<c:url value='${loginOutLink}'/>">${loginOut}</a></li>
        <li><a href="<c:url value='/register/add'/>">Sign in</a></li>
        <li><a href=""><i class="fa fa-search"></i></a></li>
    </ul>
</div>
<script>
    let msg = "${msg}";
    if (msg == "WRT_ERR") alert("게시물 등록에 실패하였습니다. 다시 시도해 주세요.");
    if (msg == "MOD_ERR") alert("게시물 수정에 실패하였습니다. 다시 시도해 주세요.");
</script>
<div class="container">
    <h2 class="writing-header">게시판 ${mode=="new" ? "글쓰기" : "읽기"}</h2>
    <form id="form" class="frm" action="" method="post">
        <input type="hidden" name="bno" value="${boardDto.bno}">

        <input name="title" type="text" value="${boardDto.title}"
               placeholder="  제목을 입력해 주세요." ${mode=="new" ? "" : "readonly='readonly'"}><br>
        <textarea name="content" rows="20"
                  placeholder=" 내용을 입력해 주세요." ${mode=="new" ? "" : "readonly='readonly'"}>${boardDto.content}</textarea><br>

        <c:if test="${mode eq 'new'}">
            <button type="button" id="writeBtn" class="btn btn-write"><i class="fa fa-pencil"></i> 등록</button>
        </c:if>
        <c:if test="${mode ne 'new'}">
            <button type="button" id="writeNewBtn" class="btn btn-write"><i class="fa fa-pencil"></i> 글쓰기</button>
        </c:if>
        <c:if test="${boardDto.writer eq loginId}">
            <button type="button" id="modifyBtn" class="btn btn-modify"><i class="fa fa-edit"></i> 수정</button>
            <button type="button" id="removeBtn" class="btn btn-remove"><i class="fa fa-trash"></i> 삭제</button>
        </c:if>
        <button type="button" id="listBtn" class="btn btn-list"><i class="fa fa-bars"></i> 목록</button>
    </form>
</div>
<script>
    $(document).ready(function () {
        let formCheck = function () {
            let form = document.getElementById("form");
            if (form.title.value == "") {
                alert("제목을 입력해 주세요.");
                form.title.focus();
                return false;
            }

            if (form.content.value == "") {
                alert("내용을 입력해 주세요.");
                form.content.focus();
                return false;
            }
            return true;
        }

        $("#writeNewBtn").on("click", function () {
            location.href = "<c:url value='/board/write'/>";
        });

        $("#writeBtn").on("click", function () {
            let form = $("#form");
            form.attr("action", "<c:url value='/board/write'/>");
            form.attr("method", "post");

            if (formCheck())
                form.submit();
        });

        $("#modifyBtn").on("click", function () {
            let form = $("#form");
            let isReadonly = $("input[name=title]").attr('readonly');

            // 1. 읽기 상태이면, 수정 상태로 변경
            if (isReadonly == 'readonly') {
                $(".writing-header").html("게시판 수정");
                $("input[name=title]").attr('readonly', false);
                $("textarea").attr('readonly', false);
                $("#modifyBtn").html("<i class='fa fa-pencil'></i> 등록");
                return;
            }

            // 2. 수정 상태이면, 수정된 내용을 서버로 전송
            form.attr("action", "<c:url value='/board/modify${searchCondition.queryString}'/>");
            form.attr("method", "post");
            if (formCheck())
                form.submit();
        });

        $("#removeBtn").on("click", function () {
            if (!confirm("정말로 삭제하시겠습니까?")) return;

            let form = $("#form");
            form.attr("action", "<c:url value='/board/remove${searchCondition.queryString}'/>");
            form.attr("method", "post");
            form.submit();
        });

        $("#listBtn").on("click", function () {
            location.href = "<c:url value='/board/list${searchCondition.queryString}'/>";
        });
    });
</script>
</body>
</html>

boardList.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jstl/core_rt" %>
<%@taglib prefix="fmt" uri="http://java.sun.com/jstl/fmt_rt" %>
<%@ page session="true" %>
<c:set var="loginId" value="${sessionScope.id}"/>
<c:set var="loginOutLink" value="${loginId=='' ? '/login/login' : '/login/logout'}"/>
<c:set var="loginOut" value="${loginId=='' ? 'Login' : 'ID='+=loginId}"/>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>fastcampus</title>
    <link rel="stylesheet" href="<c:url value='/css/menu.css'/>">
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css">
    <script src="https://code.jquery.com/jquery-1.11.3.js"></script>
    <style>
        * {
            box-sizing: border-box;
            margin: 0;
            padding: 0;
            font-family: "Noto Sans KR", sans-serif;
        }

        a {
            text-decoration: none;
            color: black;
        }

        button,
        input {
            border: none;
            outline: none;
        }

        .board-container {
            width: 60%;
            height: 1200px;
            margin: 0 auto;
            /* border: 1px solid black; */
        }

        .search-container {
            background-color: rgb(253, 253, 250);
            width: 100%;
            height: 110px;
            border: 1px solid #ddd;
            margin-top: 10px;
            margin-bottom: 30px;
            display: flex;
            justify-content: center;
            align-items: center;
        }

        .search-form {
            height: 37px;
            display: flex;
        }

        .search-option {
            width: 100px;
            height: 100%;
            outline: none;
            margin-right: 5px;
            border: 1px solid #ccc;
            color: gray;
        }

        .search-option > option {
            text-align: center;
        }

        .search-input {
            color: gray;
            background-color: white;
            border: 1px solid #ccc;
            height: 100%;
            width: 300px;
            font-size: 15px;
            padding: 5px 7px;
        }

        .search-input::placeholder {
            color: gray;
        }

        .search-button {
            /* 메뉴바의 검색 버튼 아이콘  */
            width: 20%;
            height: 100%;
            background-color: rgb(22, 22, 22);
            color: rgb(209, 209, 209);
            display: flex;
            align-items: center;
            justify-content: center;
            font-size: 15px;
        }

        .search-button:hover {
            color: rgb(165, 165, 165);
        }

        table {
            border-collapse: collapse;
            width: 100%;
            border-top: 2px solid rgb(39, 39, 39);
        }

        tr:nth-child(even) {
            background-color: #f0f0f070;
        }

        th,
        td {
            width: 300px;
            text-align: center;
            padding: 10px 12px;
            border-bottom: 1px solid #ddd;
        }

        td {
            color: rgb(53, 53, 53);
        }

        .no {
            width: 150px;
        }

        .title {
            width: 50%;
        }

        td.title {
            text-align: left;
        }

        td.writer {
            text-align: left;
        }

        td.viewcnt {
            text-align: right;
        }

        td.title:hover {
            text-decoration: underline;
        }

        .paging {
            color: black;
            width: 100%;
            align-items: center;
        }

        .page {
            color: black;
            padding: 6px;
            margin-right: 10px;
        }

        .paging-active {
            background-color: rgb(216, 216, 216);
            border-radius: 5px;
            color: rgb(24, 24, 24);
        }

        .paging-container {
            width: 100%;
            height: 70px;
            display: flex;
            margin-top: 50px;
            margin: auto;
        }

        .btn-write {
            background-color: rgb(236, 236, 236); /* Blue background */
            border: none; /* Remove borders */
            color: black; /* White text */
            padding: 6px 12px; /* Some padding */
            font-size: 16px; /* Set a font size */
            cursor: pointer; /* Mouse pointer on hover */
            border-radius: 5px;
            margin-left: 30px;
        }

        .btn-write:hover {
            text-decoration: underline;
        }
    </style>
</head>
<body>
<div id="menu">
    <ul>
        <li id="logo">fastcampus</li>
        <li><a href="<c:url value='/'/>">Home</a></li>
        <li><a href="<c:url value='/board/list'/>">Board</a></li>
        <li><a href="<c:url value='${loginOutLink}'/>">${loginOut}</a></li>
        <li><a href="<c:url value='/register/add'/>">Sign in</a></li>
        <li><a href=""><i class="fa fa-search"></i></a></li>
    </ul>
</div>
<script>
    let msg = "${msg}";
    if (msg == "LIST_ERR") alert("게시물 목록을 가져오는데 실패했습니다. 다시 시도해 주세요.");
    if (msg == "READ_ERR") alert("삭제되었거나 없는 게시물입니다.");
    if (msg == "DEL_ERR") alert("삭제되었거나 없는 게시물입니다.");

    if (msg == "DEL_OK") alert("성공적으로 삭제되었습니다.");
    if (msg == "WRT_OK") alert("성공적으로 등록되었습니다.");
    if (msg == "MOD_OK") alert("성공적으로 수정되었습니다.");
</script>
<div style="text-align:center">
    <div class="board-container">
        <div class="search-container">
            <form action="<c:url value="/board/list"/>" class="search-form" method="get">
                <select class="search-option" name="option">
                    <option value="A" ${ph.sc.option=='A' || ph.sc.option=='' ? "selected" : ""}>제목+내용</option>
                    <option value="T" ${ph.sc.option=='T' ? "selected" : ""}>제목만</option>
                    <option value="W" ${ph.sc.option=='W' ? "selected" : ""}>작성자</option>
                </select>

                <input type="text" name="keyword" class="search-input" type="text" value="${ph.sc.keyword}"
                       placeholder="검색어를 입력해주세요">
                <input type="submit" class="search-button" value="검색">
            </form>
            <button id="writeBtn" class="btn-write" onclick="location.href='<c:url value="/board/write"/>'"><i
                    class="fa fa-pencil"></i> 글쓰기
            </button>
        </div>

        <table>
            <tr>
                <th class="no">번호</th>
                <th class="title">제목</th>
                <th class="writer">이름</th>
                <th class="regdate">등록일</th>
                <th class="viewcnt">조회수</th>
            </tr>
            <c:forEach var="boardDto" items="${list}">
                <tr>
                    <td class="no">${boardDto.bno}</td>
                    <td class="title"><a
                            href="<c:url value="/board/read${ph.sc.queryString}&bno=${boardDto.bno}"/>">${boardDto.title}</a>
                    </td>
                    <td class="writer">${boardDto.writer}</td>
                    <c:choose>
                        <c:when test="${boardDto.reg_date.time >= startOfToday}">
                            <td class="regdate"><fmt:formatDate value="${boardDto.reg_date}" pattern="HH:mm"
                                                                type="time"/></td>
                        </c:when>
                        <c:otherwise>
                            <td class="regdate"><fmt:formatDate value="${boardDto.reg_date}" pattern="yyyy-MM-dd"
                                                                type="date"/></td>
                        </c:otherwise>
                    </c:choose>
                    <td class="viewcnt">${boardDto.view_cnt}</td>
                </tr>
            </c:forEach>
        </table>
        <br>
        <div class="paging-container">
            <div class="paging">
                <c:if test="${ph.totalCnt==null || ph.totalCnt==0}">
                    <div> 게시물이 없습니다.</div>
                </c:if>
                <c:if test="${ph.totalCnt!=null && ph.totalCnt!=0}">
                    <c:if test="${ph.showPrev}">
                        <a class="page"
                           href="<c:url value="/board/list${ph.sc.getQueryString(ph.beginPage-1)}"/>">&lt;</a>
                    </c:if>
                    <c:forEach var="i" begin="${ph.beginPage}" end="${ph.endPage}">
                        <a class="page ${i==ph.sc.page? "paging-active" : ""}"
                           href="<c:url value="/board/list${ph.sc.getQueryString(i)}"/>">${i}</a>
                    </c:forEach>
                    <c:if test="${ph.showNext}">
                        <a class="page"
                           href="<c:url value="/board/list${ph.sc.getQueryString(ph.endPage+1)}"/>">&gt;</a>
                    </c:if>
                </c:if>
            </div>
        </div>
    </div>
</div>
</body>
</html>

PageHandler에 queryString 처리해주는 걸 넣어줘야 한다.

얘네들을 묶은 게 SearchCondition인데, 검색 결과 내용을 봤다가 목록으로 돌아올 때 아래 값들을 유지해야 한다. 쿼리 스트링으로 이 값들을 다 줘야함. 이걸 다 주는 게 번거롭기 때문에 getQueryString()이라는 메서드를 하나 만들 것이다.

Integer page = 1;
Integer pageSize = 10;
Integer offset = 0;
String keyword = "";
String option = "";

UriComponentBuilder라는 util 클래스를 사용하면 된다.

지정된 페이지로 페이지가 세팅이 되도록.

public String getQueryString(Integer page) {
    return UriComponentsBuilder.newInstance()
            .queryParam("page", page)
            .queryParam("pageSize", sc.getPageSize())
            .queryParam("option", sc.getOption())
            .queryParam("keyword", sc.getKeyword())
            .build().toString();
}

위 두 메서드는 코드 중복이라 중복 제거해야함

페이지를 지정해주면 그 페이지를 쓰고, 지정해주지 않으면 sc의 getPage를 가져다쓴다.

public String getQueryString(Integer page) {
    return UriComponentsBuilder.newInstance()
            .queryParam("page", page)
            .queryParam("pageSize", sc.getPageSize())
            .queryParam("option", sc.getOption())
            .queryParam("keyword", sc.getKeyword())
            .build().toString();
}

public String getQueryString() {
    return getQueryString(sc.getPage());
}

getQueryString은 PageHandler보다 SearchCondition이 적합하기 때문에 옮겨주자.

톰캣 실행하고 Board를 보면, 검색은 잘 되는 것을 알 수 있다.

그런데 페이징이 정상적이지 않음. offset 때문에 그럼.

offset은 page와 pageSize로 계산되는 값이기 때문에 굳이 iv로 넣을 필요가 없다?

오히려 이 값이 있으면 계속 관리를 해줘야 한다.

public class SearchCondition {
    Integer page = 1;
    Integer pageSize = 10;
    Integer offset = 0;
    String keyword = "";
    String option = "";
}

그렇기 때문에 주석 처리를 하고,

offset을 읽을 때 page와 pageSize로 계산만 해주면 된다.

setter는 지우고 getOffset 수정.

public Integer getOffset() {
    return (page - 1) * pageSize;
}

boardMapper에서 #{offset}시 getOffset을 호출하기 때문에, 그냥 offset이 아님…

그래서 getOffset이 있어야 한다.

페이징이 잘 되는 것을 확인할 수 있다.

이제 boardMapper.xml로 가서 제대로된 쿼리를 작성해보자.

동적 sql로 만들기

boardMapper.xml

<select id="searchSelectPage" parameterType="SearchCondition" resultType="BoardDto">
    SELECT bno, title, content, writer, view_cnt, comment_cnt, reg_date
    FROM board
     WHERE TRUE
     <choose>
         <when test='option=="T"'>
             AND title LIKE CONCAT('%', #{keyword}, '%')
         </when>
         <when test='option=="W"'>
             AND writer LIKE CONCAT('%', #{keyword}, '%')
         </when>
         <otherwise>
             AND (writer LIKE CONCAT('%', #{keyword}, '%')
              OR content LIKE CONCAT('%', #{keyword}, '%'))
         </otherwise>
     </choose>
    ORDER BY reg_date DESC, bno DESC
        LIMIT #{offset}, #{pageSize}
</select>

<select id="searchResultCnt" parameterType="SearchCondition" resultType="int">
    SELECT count(*)
    FROM board
    WHERE TRUE
    <choose>
        <when test='option=="T"'>
            AND title LIKE CONCAT('%', #{keyword}, '%')
        </when>
        <when test='option=="W"'>
            AND writer LIKE CONCAT('%', #{keyword}, '%')
        </when>
        <otherwise>
            AND (writer LIKE CONCAT('%', #{keyword}, '%')
            OR content LIKE CONCAT('%', #{keyword}, '%'))
        </otherwise>
    </choose>
</select>

BoardDaoImplTest 이 잘 돌아가는지 확인해보자. searchSelectPageTest 의 option을 W로도 바꿔서 테스트 해보아야 한다.

@Test
public void searchSelectPageTest() throws Exception {
    boardDao.deleteAll();

    for (int i = 0; i <= 20; i++) {
        BoardDto boardDto = new BoardDto("title" + i, "asdfafd", "adff" + i);
        boardDao.insert(boardDto);
    }

    SearchCondition sc = new SearchCondition(1, 10, "title2", "T");
     List<BoardDto> list = boardDao.searchSelectPage(sc);
    System.out.println("boardList = " + list);
    assertTrue(list.size() == 2);

    sc = new SearchCondition(1, 10, "adff2", "W");
    list = boardDao.searchSelectPage(sc);
    System.out.println("boardList = " + list);
    assertTrue(list.size() == 2);
}

@Test
public void searchResultCntTest() throws Exception {
    boardDao.deleteAll();

    for (int i = 0; i <= 20; i++) {
        BoardDto boardDto = new BoardDto("title" + i, "asdfafd", "adff" + i);
        boardDao.insert(boardDto);
    }

    SearchCondition sc = new SearchCondition(1, 10, "adff2", "W");
    int list = boardDao.searchResultCnt(sc);
    System.out.println("boardList = " + list);
    assertTrue(list == 2);

    sc = new SearchCondition(1, 10, "adff2", "W");
    list = boardDao.searchResultCnt(sc);
    System.out.println("boardList = " + list);
    assertTrue(list == 2);
}

searchResultCntTest 도 똑같이 테스트 하면 됨. 사실은 더 꼼꼼히 해야 한다.!!

위의 쿼리에서 이부분이 중복이다. 이럴 때 쓰면 좋은 게 일단 이부분을 cut해서 별도의 sql문으로 만든다.

<choose>
    <when test='option=="T"'>
        AND title LIKE CONCAT('%', #{keyword}, '%')
    </when>
    <when test='option=="W"'>
        AND writer LIKE CONCAT('%', #{keyword}, '%')
    </when>
    <otherwise>
        AND (writer LIKE CONCAT('%', #{keyword}, '%')
        OR content LIKE CONCAT('%', #{keyword}, '%'))
    </otherwise>
</choose>

이렇게 sql을 분리해서 코드를 훨씬 간결하게 할 수 있고 변경할 일이 생겨도 한 군데만 변경하면 된다.

바꾼 뒤에는 문제가 없는지 꼭 테스트를 해야 한다.

<sql id="searchCondition">
    <choose>
        <when test='option=="T"'>
            AND title LIKE CONCAT('%', #{keyword}, '%')
        </when>
        <when test='option=="W"'>
            AND writer LIKE CONCAT('%', #{keyword}, '%')
        </when>
        <otherwise>
            AND (writer LIKE CONCAT('%', #{keyword}, '%')
            OR content LIKE CONCAT('%', #{keyword}, '%'))
        </otherwise>
    </choose>
</sql>

<select id="searchSelectPage" parameterType="SearchCondition" resultType="BoardDto">
    SELECT bno, title, content, writer, view_cnt, comment_cnt, reg_date
    FROM board
     WHERE TRUE
    <include refid="searchCondition" />
    ORDER BY reg_date DESC, bno DESC
        LIMIT #{offset}, #{pageSize}
</select>

<select id="searchResultCnt" parameterType="SearchCondition" resultType="int">
    SELECT count(*)
    FROM board
    WHERE TRUE
    <include refid="searchCondition" />
</select>

⭐ 테스트 코드의 필요성

변경사항이 있을 때 테스트를 꼭 다시 돌려봐야 한다는 것 잊지 말기

TDD가 단순히 테스트를 위한 것만이 아니라 변경사항이 발생했거나 리팩토링을 해야 할 때, 리팩토링 하고나서 테스트를 일일히 하나씩 또 해보는 것보단 기존에 만들어둔 테스트를 돌려봤을 때 이상이 없으면 리팩토링이 잘 되었다고 판단할 수 있다. 그래서 tdd가 리팩토링에 있어서도 굉장한 의미를 가진다.

실무에서 개발할 때 좀 미진한 코드가 있어서 고치고 싶은데 손을 못 대는 경우가 있다. 왜냐면 괜히 잘못 고쳤다가 다른데 영향을 준다던가 실수하면 안 되니까 리팩토링을 주저하게되는데, 테스트 코드를 잘 만들어놓은 프로젝트에서는 테스트 코드를 믿고 편안하게 리팩토링 할 수 있다. 리팩토링 해놓고 테스트를 돌렸을 때 통과하면 문제가 없는 것. → 리팩토링 활발하게 가능 계속 좋은 코드를 만들어낼 수 있다.

ㅡ럼 코드 짧아지고 ,코드의 중복도 줄얻르고 유지보수하는데 훨씬 도움이 된다.

귀찮긴 하더라도 자꾸 tdd해서 더 많은 부분을 tdd로 커버할 수 있어야 한다.

⭐ JSTL 버전 불일치 해결 방법

board.jsp

가끔 버전 불일치 때문에 문제가 생긴다. 해결책이 뒤에 _rt를 붙이는 것.

jstl에서 에러가 많이 난다. 그럴 때는 버ㅓㅈㄴ을 잘 맞춰줘야 하는데 가장 쉬운 방법이 _rt를 붙이는 것.

이 점 알아두고.

<%@taglib prefix="c" uri="http://java.sun.com/jstl/core_rt" %

🚨 스크립트 공격 막기(c:out 활용)

글쓰기에서 script alert을 입력하고 글을 쓰면?

내용과 제목에 넣고

등록되면서 hello가 뜸

내용을 보면 깨져서 나온다. 그래서 여기에 <script>alert(”Hello”)</script> 를 넣게 하면 안 된다.

여기선 alert이라 다행이지만, 해커가 악의적인 코드를 넣을 수도 있다.

해결책.

내용을 그냥 보여주면 안 되고, 코어 태그 라이브러리의 out 태그를 써야 한다.

이렇게 out으로 감싸면, 그 안에 태그가 있을 경우 자동으로 변환해준다.

<input name="title" type="text" value="${boardDto.title}" placeholder="  제목을 입력해 주세요." ${mode=="new" ? "" : "readonly='readonly'"}><br>
<input name="title" type="text" value="<c:out value='${boardDto.title}' />" placeholder="  제목을 입력해 주세요." ${mode=="new" ? "" : "readonly='readonly'"}><br>

+) content도 변경
<c:out value="${boardDto.content}" />

boardList.jsp의 제목에도도 변경해야..

변경 후 다시 실행하면

보이는 건 잘 보이는데 단순 text로 인식해서 실행이 안 된다. 해커가 악의적인 코드를 넣어도 자바스크립트로 인식을 안 하고 텍스트로 인식해서 공격 방어 가능 그래서 out태그를 쓴다.

09. REST API와 AJAX

1. JSON이란?

Java Script Object Notation

데이터를 주고 받을 때 XML을 많이 썼는데 너무 복잡하고, 실제 Data보다 태그가 더 많다. 배보다 배꼽이 더 큼…

그래서 복잡한 XML 대신에 간단하게 가자고 해서 JSON을 사용하게 되었다.(XML → JSON)

JSON = 자바스크립트에서 객체를 표현하는 방법

{ 속성명1: 속성값1, 속성명2: 속성값2, ...}

[{ 속성명: 속성값, ...}, { 속성명: 속성값, ...}, ... ] // 객체 배열
{ 키1:{ 속성명: 속성값, ...}, 키2: { 속성명: 속성값, ...}, /// } // Map

2. stringify()와 parse()

JS 객체를 서버로 전송하려면, 직렬화(문자열로 변환)가 필요

서버가 보낸 데이터(JSON 문자열)를 JS객체로 변환할 때, 역직렬화가 필요

💡 직렬화? : 문자열로 바꾸는 것

JSON.stringfiy() : 객체를 JSON 문자열로 변환(직렬화, JS 객체 → 문자열)

JSON.parse() : JSON 문자열을 객체로 변환(역직렬화, 문자열 → JS 객체)

객체를 저장하려면 어떻게? 객체는 메모리에 저장된 값이다.

아래처럼 직렬화해서 문자열로 만들면 문자열이라 HTTP(Text 기반 프로토콜)로 전송이 가능해진다. 그래서 JS 객체를 문자열로 바꾸는 것이다.

실습

JS는 동적으로 멤버를 추가, 삭제가 가능하다.

💡 dir로 객체가 가지고 있는 멤버를 다 볼 수 있다.

JS에서는 객체로 다루다가 전송할 때는 문자열로 변환해서 전송한다.

이럴 때 사용하는 게 stringfy(), parse()다.

var obj = {name: "abc", age: 10, hp: '010-5517-3236'}

let strObj = JSON.stringify(obj);
console.log(strObj); // '{"name":"abc","age":10,"hp":"010-1234-5678"}'

typeof strObj // 'string'
typeof obj // 'object'

let obj2 = JSON.parse(strObj);
console.log(obj2); // {name: 'abc', age: 10, hp: '010-1234-5678'}

3. Ajax란? - Asynchronous Javascript And XML

비동기(Asynchronous) 통신으로 데이터를 주고 받기 위한 기술이다. - 요즘은 JSON을 주로 사용.

AJAX를 사용하면 웹페이지 전체(data + UI)가 아닌 일부(data)만 업데이트가 가능
옛날에는 화면이 조금만 바뀌어도 웹페이지 전체를 응답으로 받아 update하는 비효율적인 방법을 사용했었다. 이 방법은 네트워크가 낭비될 뿐더러 속도도 느리다. 그래서 일부만 update 할 때는 AJAX를 사용한다.

동기 VS 비동기

동기

메서드 호출과 똑같다고 생각하면 된다. 메서드를 호출하면 메서드가 결과를 줄 때까지 기다린다. 그리고 응답이 와야 다른 일을 할 수 있다.

비동기

그런데 비동기는 요청을 해놓고 응답을 줄 때까지 기다리지 않아도 된다. 그래서 요청만 보내두고 다른 일을 할 수 있다. 대신 요청이 언제 처리되었는지는 모른다.

이럴 때 사용하는 게 콜백 함수이다. 콜백 함수는 처리가 완료되었다는 걸 알려준다.

❓이름이 콜백인 이유?

콜백 함수의 이름은 친구에게 전화를 했는데 친구가 집에 없을 때 메시지를 남겨놓으면 친구가 집에 돌아왔을 때 다시 전화를 주는 것에서 유래했다.

너 집에 돌아오면 나한테 전화 좀 줘. 여기서는 처리 끝나면 나한테 연락주라는 뜻

웹 브라우저로 예를 들면 여러 개의 탭이 존재한다. 브라우저 전체는 멀티 쓰레드이지만 각 탭은 싱글 쓰레드다. 탭을 추가할 때마다 싱글 쓰레드가 생성된다. 싱글 쓰레드로인해 요청을 보내고 응답을 기다리는 동안 다른 작업을 수행할 수 없다. 그러나 사용자는 하나의 화면에서 여러 작업을 수행한다. 이 경우에 동기로 요청을 보내면 응답이 올 때까지 브라우저가 멈추게된다. 그러나 비동기로 요청을 보내면 일단 요청을 보내놓고 다른 작업을 처리할 수 있다. 그래서 비동기 방식을 사용한다.

💡동기 방식은 요청을 하고 응답이 올 때까지 기다리는데 비동기는 기다리지 않고 다른 일을 한다는 게 핵심이다.

+) 비동기 방식은 페이지 전체의 리로드 없이 필요한 부분만 업데이트할 수 있다.

4. jQuery를 이용한 Ajax

jQuery에서 제공하는 비동기 처리 함수다.

요청을 하면서 작업이 끝나면 이 함수를 호출하라고 콜백 함수 2개를 준다. 그럼 서버는 요청을 다 처리한 뒤에 둘 중에 하나를 호출한다. 이렇게 함으로써 비동기 요청의 성공/실패 여부를 알 수 있다.

$(document).ready(function () {
    let person = { name: "abc", age: 10};
    let person2 = {};

    $.ajax({
        type: 'POST',                                   // 요청 메서드
        url: '/send',                                   // 요청 URI
        headers: {"content-type": "application/json"},  // 요청 헤더
				contentType: 'application/json; charset=utf-8', // 서버로 보내는 데이터 타입
        dataType: 'text',                               // 서버에서 받을 데이터 형식
        data: JSON.stringify(person),                   // 서버로 전송할 데이터. stringify()로 직렬화 필요.
        success: function (result) { // 서버로부터 응답이 도착하면 호출될 함수
            person2 = JSON.parse(result);
            alert(result);           // result는 서버가 전송한 데이터
        },
        error: function () {         // 에러가 발생했을 때, 호출될 함수
            alert("error")
        }
    });
});

jQuery.ajax()

https://api.jquery.com/jquery.ajax/#jQuery-ajax-url-settings

실습

SimpleRestController.java

@Controller
public class SimpleRestController {
    @GetMapping("/ajax")
    public String ajax() {
        return "ajax";
    }

    @PostMapping("/send")
    @ResponseBody
    public Person test(@RequestBody Person p) {
        System.out.println("p = " + p);
        p.setName("ABC");
        p.setAge(p.getAge() + 10);

        return p;
    }
}

Person.java

public class Person {
    private String name;
    private String age;

    public Person() {}

    public Person(String name, String age) {
        this.name = name;
        this.age = age;
    }
	
		// getter, setter, toString() 생성
}

ajax.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script src="https://code.jquery.com/jquery-1.11.3.js"></script>
</head>
<body>
<h2>{name:"abc", age:10}</h2>
<button id="sendBtn" type="button">SEND</button>
<h2>Data From Server :</h2>
<div id="data"></div>
<script>
    $(document).ready(function () {
        let person = {name: "abc", age: 10};
        let person2 = {};

        $("#sendBtn").click(function () {
            $.ajax({
                type: 'POST',       // 요청 메서드
                url: '/ch4/send',  // 요청 URI
                headers: {"content-type": "application/json"}, // 요청 헤더
                dataType: 'text', // 전송받을 데이터의 타입
                data: JSON.stringify(person),  // 서버로 전송할 데이터. stringify()로 직렬화 필요.
                success: function (result) {
                    person2 = JSON.parse(result);    // 서버로부터 응답이 도착하면 호출될 함수
                    alert("received=" + result);       // result는 서버가 전송한 데이터
                    $("#data").html("name=" + person2.name + ", age=" + person2.age);
                },
                error: function () {
                    alert("error")
                } // 에러가 발생했을 때, 호출될 함수
            }); // $.ajax()

            alert("the request is sent")
        });
    });
</script>
</body>
</html>

send 버튼을 누르면, {name : “abc”, age : 10} 객체가 stringify되어서(문자열로 직렬화.) 서버로 보내진다. 그럼 서버가 받아서 처리한다음에 다시 준다.

@PostMapping("/send")
@ResponseBody
public Person test(@RequestBody Person p) {
    System.out.println("p = " + p);
    p.setName("ABC");
    p.setAge(p.getAge() + 10);

    return p;
}

JSON(Javascript 객체)로 보낸 게 자바 객체로 바뀌어서 들어온다. 그리고 이름과 나이를 바꿔서 반환한다.

success: function (result) {
    person2 = JSON.parse(result);    // 서버로부터 응답이 도착하면 호출될 함수
    alert("received=" + result);       // result는 서버가 전송한 데이터
    $("#data").html("name=" + person2.name + ", age=" + person2.age);
},

그럼 sucess에서 반환한 걸 result로 받는다. 그리고 parse해서 출력함

지금 예상대로 동작하지 않는 이유는 Jackson Databind라는 라이브러리가 하나 필요하다.

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-databind</artifactId>
	<version>2.15.1</version>
</dependency>

라이브러리 추가 후 응답이 성공적으로 온 것을 확인할 수 있다.

5. Ajax 요청과 응답 과정

서버에게 JS 객체를 그대로 직접 전송할 수 없기 때문에, 문자열로 변환해서 전송한다.(HTTP가 텍스트 기반 프로토콜이기 때문)

POST로 요청을 보내면, 서버는 받은 문자열을 jackson-databind를 사용해 자바 객체로 변환해서 매개변수로 전달한다.
이때 jackson-databind는 문자열을 자바 객체로 변환하는 역할을 한다.

test 메서드를 수행하고 서버는 객체를 반환해서 응답을 제공하는데, jackson-databind가 자바 객체를 JSON 문자열로 변환해서 전송한다.

클라이언트는 이를 받아서 JSON.parse()를 사용해 Javascript 객체로 변환한다.

이 과정은 별거없고 전송하려면 문자열로 변환해서 주고 받아야 해서 이렇게 하는 것이다.

JS 객체를 문자열로 바꿔서 주면 jackson-databind 가 Java 객체로 바꿔주고,

작업의 결과를 객체로 주면 jackson-databind가 알아서 JSON 문자열로 바꿔주고,

클라이언트에서는 JSON.parse()해서 JS 객체로 변환해 사용하면 된다.

@PostMapping("/send")
@ResponseBody
public Person test(@RequestBody Person p) {
		System.out.println("p = " + p);
		p.setName("ABC");
		p.setAge(p.getAge() + 10);

		return p;
}

이때, 그냥 자동으로 변환을 해주는 게 아니라 @RequestBody와 @ResponseBody 어노테이션을 사용해야 한다.

@RequestBody 가 있어야 요청 내용이 자바 객체로 변환된다.

응답 시에도 마찬가지로 @ResponseBody 어노테이션을 써야 응답의 바디로 객체가 반환된다.

💡결론 : JSON으로 데이터를 주고 받을 때는 받을 객체 앞에 @RequestBody 어노테이션을 붙여야 하고, 결과를 반환할 때는 @ResponseBody 어노테이션을 사용해야 한다.

6. @RestController

@ResponseBody 대신, 클래스에 @RestController 사용 가능
JSON 형식의 데이터를 반환할 때는 메서드 앞에 @ResponseBody를 사용해야 한다. 그런데 이걸 메서드마다 일일히 다 붙이기가 귀찮으니 클래스 앞에 @RestController를 쓸 수 있도록 바뀌었다.

@RestController 애너테이션이 붙은 클래스 내의 메서드들은 자동으로 @ResponseBody가 붙은 것으로 간주된다.

7. REST란?

Roy Fielding이 제안한 웹서비스 디자인 아키텍쳐 접근 방식

프로토콜에 독립적이며, 주로 HTTP를 사용해서 구현

리소스 중심의 API 디자인 - HTTP 메서드로 수행할 작업을 정의

리소스	POST	GET	PUT	DELETE
/customers	새 고객 만들기	모든 고객 검색	고객 대량 업데이트	모든 고객제거
/customers/1	Error	고객 1에 대한 세부 정보 검색	고객 1이 있는 경우 고객 1의 세부 정보 업데이트	고객 1 제거
/customers/1/orders	고객 1에 대한 새주문 만들기	고객 1에 대한 모든 주문 검색	고객 1의 주문 대량 업데이트	고객 1의 모든 주문 제거

REST API는 Representational State Transfer의 약자로, URI를 리소스 중심적으로 설계하고 HTTP 메서드를 사용해서 수행할 작업을 정의한다.

HTTP 메서드의 종류는 다음과 같다.

종류	설명
GET	읽기(r)
POST	쓰기(w)
PUT	리소스 업데이트 / 파일, 리소스 업로드
DELETE	리소스 삭제 / 파일, 리소스 삭제
PATCH	일부 수정

이렇게 많은 HTTP 메서드들이 있는데, GET과 POST만 쓰지말고 메서드를 잘 활용하고 대신에 리소스 부분을 심플하게 가자는 의도이다. 심플하게 가면 유지보수도 쉽고 알아보기도 쉬움.

리소스는 다 명사로만 이루어져있다. 대신 메서드로 수행할 작업을 정의하는게 바로 REST 방식의 API 설계다.

/customers

s가 붙어서 리소스가 여러개있는 걸 의미한다.

POST인 경우 쓰기, 새로운 고객 정보를 쓴다.

GET은 읽기. 모든 고객을 검색한다.

/customers/1

고객1에 대한 정보를 얻어온다.

PUT이나 PATCH인 경우에는 고객 1번의 정보를 UPDATE한다.

이런식으로 웹 서비스에 대한 API를 디자인하는 걸 REST 방식이라고 한다.

웹 API 디자인 모범 사례 - Azure Architecture Center

플랫폼 독립성과 서비스 진화를 지원하는 웹 API 설계를 위한 모범 사례를 알아봅니다.

https://learn.microsoft.com/ko-kr/azure/architecture/best-practices/api-design

8. REST API란?

규칙들을 정해놓은 게 REST. REST에서 정한 규칙을 잘 준수하는 API를 REST API라고 한다.

프로토콜에 대한 표준은 아니고 규칙만 정의해두고 그걸 지키면 REST API라고 한다. 다양한 방법으로 개발자들이 REST API를 구현할 수 있다.

❓API란?

API는 프로그래밍 인터페이스다.

인터페이스는 서비스를 제공하는 쪽과 사용하는 쪽 사이의 약속이다.

웹서비스를 제공하는 쪽에서 API를 설계해서 오픈하면, 사용자들이 그걸 보고서 사용한다.

이 규칙들을 다지키는 게 쉽지는 않다. 상황에 맞게, 서비스의 목적에 맞게 사용하는 사람이 편리하게 설계를 하는 것이 중요하다. REST API가 맞냐 아니냐는 둘째의 문제이다.

9. RESTful API의 설계

REST 방식의 API를 잘 지킨 걸 RESTful API라고 한다.

아래는 설계의 예시이다.

댓글 기능을 구현할 건데 댓글 기능은 페이지 전체가 바뀌는 게 아니라 일부만 바뀌면 된다. 그래서 댓글 기능을 개발할 때 RestController와 REST 방식의 API 설계를 적용해보려고 한다.

작업	URI	HTTP 메서드	설명
읽기	/comment/read?cno=번호	GET	지정된 번호의 댓글을 보여준다.
쓰기	/comment/write	POST	작성한 게시물을 저장한다.
삭제	/comment/remove	POST	댓글을 삭제한다.
수정	/comment/modify	POST	수정된 게시물을 저장한다.

작업	URI	HTTP 메서드	설명
읽기	/comments	GET	모든 댓글을 보여준다.
읽기	/comments/{cno}	GET	지정된 번호의 댓글을 보여준다.
쓰기	/comments	POST	새로운 댓글을 보여준다.
삭제	/comments/{cno}	DELETE	지정된 번호의 댓글을 삭제한다.
수정	/comments/{cno}	PUT / PATCH	수정된 댓글을 저장한다.

URI에 동사를 넣지않고 HTTP 메서드가 담당하게 했다. URI에는 명사만 남겨서 심플해졌다.

RESTful하게 설계하는 것이 쉽지는 않다. 이번에는 맛만 보는 것.. 얘가 뭔지 아는 정도면됨

10~13. 댓글 기능 구현

⭐ 1. DAO 작성

댓글 기능 구현 순서

DB 테이블 생성

Mapper XML 작성

DAO 작성 & 테스트

Service 작성 & 테스트

컨트롤러 작성 & 테스트

뷰(UI) 작성 & 테스트

실습

CommentDTO

package com.fastcampus.ch4.domain;

import java.util.Date;
import java.util.Objects;

public class CommentDto {
    private Integer cno;
    private Integer bno;
    private Integer pcno;
    private String comment;
    private String commenter;
    private Date regDate;
    private Date upDate;

    public CommentDto() {}

    public CommentDto(Integer bno, Integer pcno, String comment, String commenter) {
        this.bno = bno;
        this.pcno = pcno;
        this.comment = comment;
        this.commenter = commenter;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        CommentDto that = (CommentDto) o;
        return Objects.equals(cno, that.cno) && Objects.equals(bno, that.bno) && Objects.equals(pcno, that.pcno) && Objects.equals(comment, that.comment) && Objects.equals(commenter, that.commenter);
    }

    @Override
    public int hashCode() {
        return Objects.hash(cno, bno, pcno, comment, commenter);
    }

		// getter, setter, toString() 생략.
}

comment 테이블 생성

commentMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.fastcampus.ch4.dao.CommentMapper">
    <delete id="deleteAll" parameterType="int">
        DELETE
        FROM comment
        WHERE bno = #{bno}
    </delete>

    <select id="count" parameterType="int" resultType="int">
        SELECT COUNT(*)
        FROM comment
        WHERE bno = #{bno}
    </select>

    <delete id="delete" parameterType="map">
        DELETE
        FROM comment
        WHERE cno = #{cno}
          AND commenter = #{commenter}
    </delete>

    <insert id="insert" parameterType="CommentDto">
        INSERT INTO comment
            (bno, pcno, comment, commenter, reg_date, up_date)
        VALUES (#{bno}, #{pcno}, #{comment}, #{commenter}, NOW(), NOW())
    </insert>

    <select id="selectAll" parameterType="int" resultType="CommentDto">
        SELECT cno, bno, pcno, comment, commenter, reg_date, up_date
        FROM comment
        WHERE bno = #{bno}
        ORDER BY reg_date ASC, cno ASC
    </select>

    <select id="select" parameterType="int" resultType="CommentDto">
        SELECT cno, bno, pcno, comment, commenter, reg_date, up_date
        FROM comment
        WHERE cno = #{cno}
    </select>

    <update id="update" parameterType="CommentDto">
        UPDATE comment
        SET comment = #{comment}
          , up_date = NOW()
        WHERE cno = #{cno}
          AND commenter = #{commenter}
    </update>
</mapper>

CommentDAO.java
commentMapper.xml에 있는 SQL을 호출하는 메서드를 하나씩 작성한다.
cno는 자동증가로 생성해두었으니 제외할 것

+) 인터페이스로 추출까지.

mybatis-config.xml

typeAlias 등록

<typeAlias alias="CommentDto" type="com.fastcampus.ch4.domain.CommentDto"/>

CommentDaoImplTest

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"file:src/main/webapp/WEB-INF/spring/root-context.xml"})
public class CommentDaoImplTest {
    @Autowired
    CommentDao commentDao;

    @Test
    public void count() throws Exception {
        commentDao.deleteAll(1);
        assertTrue(commentDao.count(1) == 0);
    }

    @Test
    public void delete() throws Exception {
        commentDao.deleteAll(1);
        CommentDto commentDto = new CommentDto(1, 0, "comment", "asdf");
        assertTrue(commentDao.insert(commentDto) == 1);
        assertTrue(commentDao.count(1) == 1);
    }

    @Test
    public void insert() throws Exception {
        commentDao.deleteAll(1);
        CommentDto commentDto = new CommentDto(1, 0, "comment", "asdf");
        assertTrue(commentDao.insert(commentDto) == 1);
        assertTrue(commentDao.count(1) == 1);

        commentDto = new CommentDto(1, 0, "comment", "asdf");
        assertTrue(commentDao.insert(commentDto) == 1);
        assertTrue(commentDao.count(1) == 2);
    }

    @Test
    public void selectAll() throws Exception {
        commentDao.deleteAll(1);
        CommentDto commentDto = new CommentDto(1, 0, "comment", "asdf");
        assertTrue(commentDao.insert(commentDto) == 1);
        assertTrue(commentDao.count(1) == 1);

        List<CommentDto> list = commentDao.selectAll(1);
        assertTrue(list.size() == 1);

        commentDto = new CommentDto(1, 0, "comment", "asdf");
        assertTrue(commentDao.insert(commentDto) == 1);
        assertTrue(commentDao.count(1) == 2);

        list = commentDao.selectAll(1);
        assertTrue(list.size() == 2);
    }

    @Test
    public void select() throws Exception {
        commentDao.deleteAll(1);
        CommentDto commentDto = new CommentDto(1, 0, "comment", "asdf");
        assertTrue(commentDao.insert(commentDto) == 1);
        assertTrue(commentDao.count(1) == 1);

        List<CommentDto> list = commentDao.selectAll(1);
        String comment = list.get(0).getComment();
        String commenter = list.get(0).getCommenter();
        assertTrue(comment.equals(commentDto.getComment()));
        assertTrue(commenter.equals(commentDto.getCommenter()));
    }

    @Test
    public void update() throws Exception {
        commentDao.deleteAll(1);
        CommentDto commentDto = new CommentDto(1, 0, "comment", "asdf");
        assertTrue(commentDao.insert(commentDto) == 1);
        assertTrue(commentDao.count(1) == 1);

        List<CommentDto> list = commentDao.selectAll(1);
        commentDto.setCno(list.get(0).getCno());
        commentDto.setComment("comment2");
        assertTrue(commentDao.update(commentDto) == 1);

        list = commentDao.selectAll(1);
        String comment = list.get(0).getComment();
        String commenter = list.get(0).getCommenter();
        assertTrue(comment.equals(commentDto.getComment()));
        assertTrue(commenter.equals(commentDto.getCommenter()));
    }
}

CommentService
CommentService는 BoardDAO와 CommentDAO 둘 다 주입받아야 한다.
댓글이 추가되거나 삭제되면 BoardDAO에게도 영향이 가기 때문. board 테이블을 보면 댓글이 몇 개 달렸는지 보여주는 comment_cnt라는 컬럼이 있다.

⭐ 이를 위해 아래 두가지 방법이 있다.
1. 필드 주입 방식
2. 생성자 주입 방식
```
@Autowired
BoardDao boardDao;
@Autowired
CommentDao commentDao;
```
```
BoardDao boardDao;
CommentDao commentDao;

@Autowired
public CommentServiceImpl(CommentDao commentDao, BoardDao boardDao) {
    this.commentDao = commentDao;
    this.boardDao = boardDao;
}
```
⭐ 필드 주입 방식보다는 생성자 주입 방식을 사용하자.
필드 주입은 간단하지만, 생성자 주입을 사용하면 의존성이 누락되었을 경우 컴파일 타임에 발견할 수 있다. 다만 생성자 주입은 클래스에 생성자가 하나만 있을 때만 사용 가능하는 점에 주의하자.
- 추가 설명?
  필드에 직접 @Autowired를 붙일 경우, 하나에는 붙였는데 하나는 안 붙이는 실수를 할 수 있다.
  생성자로 주입받으면 아래처럼 CommentDaoImpl에서 @Repository를 지울 경우 객체 생성이 안 되기 때문에 다른 곳에서 주입을 못 받는다.
  
  이렇게 주입이 안 될 경우에 컴파일 에러가 발생한다. 이런 장점 때문에 생성자 주입을 사용한다.
remove 메서드를 주목하자.
댓글 삭제 시에 board의 comment 수를 수정하고 댓글을 지워야 한다.
두 가지 작업 모두 성공해야 하므로 트랜잭션을 걸었고 Exception과 그 자손들의 예외가 발생하면 롤백하도록 ‘rollbackFor’를 지정했다.
```
@Override
@Transactional(rollbackFor = Exception.class)
public int remove(Integer cno, Integer bno, String commenter) throws Exception {
    int rowCnt = boardDao.updateCommentCnt(bno, -1);
    System.out.println("updateCommentCnt - rowCnt = " + rowCnt);
//        throw new Exception("test"); // 실제로 롤백이되는지 보려고 테스트 용도로 넣은 것
    rowCnt = commentDao.delete(cno, commenter);
    System.out.println("rowCnt = " + rowCnt);
    return rowCnt;
}
```

CommentServiceImplTest

일부러 예외를 발생시키고 Tx가 취소되는지 확인해야 한다.

package com.fastcampus.ch4.service;

import com.fastcampus.ch4.dao.*;
import com.fastcampus.ch4.domain.*;
import org.junit.*;
import org.junit.runner.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.test.context.*;
import org.springframework.test.context.junit4.*;

import java.util.*;

import static org.junit.Assert.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"file:src/main/webapp/WEB-INF/spring/root-context.xml"})
public class CommentServiceImplTest {
    @Autowired
    CommentService commentService;
    @Autowired
    CommentDao commentDao;
    @Autowired
    BoardDao boardDao;

    @Test
    public void remove() throws Exception {
        boardDao.deleteAll();

        BoardDto boardDto = new BoardDto("hello", "hello", "asdf");
        assertTrue(boardDao.insert(boardDto) == 1);
        Integer bno = boardDao.selectAll().get(0).getBno();
        System.out.println("bno = " + bno);

        commentDao.deleteAll(bno);
        CommentDto commentDto = new CommentDto(bno, 0, "hi", "qwer");

        assertTrue(boardDao.select(bno).getComment_cnt() == 0);
        assertTrue(commentService.write(commentDto) == 1);
        assertTrue(boardDao.select(bno).getComment_cnt() == 1);

        Integer cno = commentDao.selectAll(bno).get(0).getCno();

        // 일부러 예외를 발생시키고 Tx가 취소되는지 확인해야.
        int rowCnt = commentService.remove(cno, bno, commentDto.getCommenter());
        assertTrue(rowCnt == 1);
        assertTrue(boardDao.select(bno).getComment_cnt() == 0);
    }

    @Test
    public void write() throws Exception {
        boardDao.deleteAll();

        BoardDto boardDto = new BoardDto("hello", "hello", "asdf");
        assertTrue(boardDao.insert(boardDto) == 1);
        Integer bno = boardDao.selectAll().get(0).getBno();
        System.out.println("bno = " + bno);

        commentDao.deleteAll(bno);
        CommentDto commentDto = new CommentDto(bno, 0, "hi", "qwer");

        assertTrue(boardDao.select(bno).getComment_cnt() == 0);
        assertTrue(commentService.write(commentDto) == 1);

        Integer cno = commentDao.selectAll(bno).get(0).getCno();
        assertTrue(boardDao.select(bno).getComment_cnt() == 1);
    }
}

개발 시에 어떤 순서로 개발하는지 잘 알아둬야 한다.

2. Controller 작성

list : 지정된 게시물의 모든 댓글을 가져오는 메서드

@Controller
public class CommentController {
    @Autowired
    CommentService service;

    // 지정된 게시물의 모든 댓글을 가져오는 메서드
    @GetMapping("comments")
    @ResponseBody public List<CommentDto> list(Integer bno) {
        List<CommentDto> list = null;
        try {
            list = service.getList(bno);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return list;
    }
}

댓글이 정상적으로 가져와졌을 때의 상태 코드는 200. 정상적으로 받아온 것을 알 수 있다.

여기서 예외를 발생시켜보자.

예외 발생하더라도 상태 코드가 200으로 반환되기 때문에, 오류가 발생했음에도 불하고 성공한 것처럼 보일 수 있다. 원래라면 서버에서 발생한 오류 때문에 500번대 상태 코드가 반환되어야 한다.

// 지정된 게시물의 모든 댓글을 가져오는 메서드
@GetMapping("comments")
@ResponseBody public ResponseEntity<List<CommentDto>> list(Integer bno) {
    List<CommentDto> list = null;
    try {
        list = service.getList(bno);
        return new ResponseEntity<List<CommentDto>>(list, HttpStatus.OK); // 200
    } catch (Exception e) {
        e.printStackTrace();
        return new ResponseEntity<List<CommentDto>>(list, HttpStatus.BAD_REQUEST); // 400
    }
}

이런 문제를 해결하기 위해 ResonseEntity를 사용해 결과물과 함께 상태 코드를 반환할 수 있다.

이 클래스를 사용하면 예외가 발생했을 때 500과 같은 적절한 상태코드를 반환할 수 있다.

+) 여기서 요청 또는 응답 메시지의 전송 대상을 엔티티라고 부른다.

HTTP 상태 코드는 클라이언트에게 요청의 결과를 알려주는 중요한 방법이다. 적절한 상태 코드를 반환하면 클라이언트는 요청이 성공했는지, 실패했는지, 실패했다면 그 이유가 무엇인지 쉽게 파악할 수 있다.

따라서 상태 코드를 정확하게 설정하는 것은 개발에서 중요한 부분이다.

위처럼 ResponseEntity를 이용해서 상황에 맞는 상태코드를 보낼 수 있어야 한다.

remove : 지정된 댓글을 삭제하는 메서드

// 지정된 댓글을 삭제하는 메서드
@DeleteMapping("/comments/{cno}") // /comments/1?bno=1085 <- 삭제할 댓글 번호
@ResponseBody
public ResponseEntity<String> remove(@PathVariable Integer cno, Integer bno, HttpSession session) {
    String commenter = (String) session.getAttribute("id");
    try {
        int rowCnt = service.remove(cno, bno, commenter);

        if (rowCnt != 1)
            throw new Exception("Delete Failed");

        return new ResponseEntity<>("DEL_OK", HttpStatus.OK);
    } catch (Exception e) {
        e.printStackTrace();
        return new ResponseEntity<>("DEL_ERR", HttpStatus.BAD_REQUEST);
    }
}

쿼리 스트링일 경우는 그냥 쓰면 되는데, 위 같은 경우는 쿼리 스트링이 아니라 URI의 일부를 읽어오는 것이기 때문에 변수 앞에다 @PathVariable을 써야 한다.

[ Postman을 이용한 remove 메서드의 테스트 ]

작성한 메서드가 잘 동작하는지 테스트를 해보자.

브라우저에서 DELETE 메서드를 직접 실행할 수 없기 때문에 Postman과 같은 API 테스트 도구를 사용해야 한다.

comment는 asdf로 하드코딩.

status도 200이고, 응답도 del_ok(문자열)로 온걸봐서 잘 처리된 것을 알 수 있다.

+) 잘 삭제되었는지 db에서도 확인해보기

write : 댓글을 등록하는 메서드

delete와 똑같은데 DTO 받는 부분만 다르다.

// 댓글을 등록하는 메서드
@PostMapping("comments") // /comments?bno=1085 POST
@ResponseBody
public ResponseEntity<String> write(@RequestBody CommentDto commentDto, Integer bno, HttpSession session) {
//        String commenter = (String) session.getAttribute("id");
    String commenter = "asdf";
    commentDto.setCommenter(commenter);
    commentDto.setBno(bno);

    System.out.println("commentDto = " + commentDto);

    try {
        int rowCnt = service.write(commentDto);

        if (rowCnt != 1)
            throw new Exception("Write failed.");

        return new ResponseEntity<>("WRT_OK", HttpStatus.OK);

    } catch (Exception e) {
        e.printStackTrace();
        return new ResponseEntity<>("WRT_OK", HttpStatus.BAD_REQUEST);
    }
}

[ Postman을 이용한 write 메서드의 테스트 ]

클라이언트에서 서버로 JSON 데이터를 전송할 때, 'Content-type: application/json' 헤더를 설정해야 한다.

→ 내가 보내는 데이터(entity)의 Content-type이 json이라고 알려줘야 함

modify : 댓글을 수정하는 메서드

마지막으로 댓글을 수정하는 메서드를 만들어보자.

// 댓글을 수정하는 메서드
@PatchMapping("comments/{cno}") // /comments?bno=1085 POST
@ResponseBody
public ResponseEntity<String> modify(@PathVariable Integer cno, @RequestBody CommentDto commentDto) {
    commentDto.setCno(cno);
    System.out.println("commentDto = " + commentDto);

    try {
        int rowCnt = service.modify(commentDto);

        if (rowCnt != 1)
            throw new Exception("Write failed.");

        return new ResponseEntity<>("MOD_OK", HttpStatus.OK);

    } catch (Exception e) {
        e.printStackTrace();
        return new ResponseEntity<>("MOD_ERR", HttpStatus.BAD_REQUEST);
    }
}

지금 CommentController.java에 @ResponseBody 가 붙어있는데, 이걸 다 지우고, 클래스 앞에 붙일 수 있다.

그럼 이 클래스의 모든 메서드에 @ResponseBody를 붙인다는 의미다.

@Controller
@ResponseBody

@ResponseBody는 메서드가 반환하는 값을 HTTP 응답 바디에 작성한다. 이 어노테이션이 클래스에 붙어 있으면, 해당 클래스의 모든 메서드에 적용된다.

그리고 저 두 개를 합친 게 @RestController다.

@RestController = @Controller + @ResponseBody

가보면 두 개다 들어있는 걸 확인할 수 있다. 별개가 아니라 두개를 묶어놓은 것임 ㅁㅇ라ㅓ밍러밀ㅇ

3. UI 작성

댓글 가져오기

dataType(전송 받을 데이터의 타입)을 명시하지 않으면 기본값이 json이다. 그렇기 때문에 success에서 받은 데이터를 parse할 필요가 없다.

추가
- dataType은 서버로부터 반환받을 데이터의 유형을 지정합니다.
- dataType이 명시적으로 설정되지 않은 경우, jQuery는 서버의 응답 헤더를 보고 데이터 유형을 결정하려고 시도합니다.
- dataType이 json으로 설정되면, 서버로부터 반환받은 JSON 문자열은 자동으로 JavaScript 객체로 파싱됩니다.
결국, dataType 설정 여부에 관계없이 서버로부터 반환된 데이터가 JSON 형식이면 success 콜백 함수에서 추가적인 파싱 작업을 할 필요가 없습니다.

let showList = function (bno) {
    $.ajax({
        type: 'GET',       // 요청 메서드
        url: '/comments?bno=' + bno,  // 요청 URI
        success: function (result) {
            $("#commentList").html(result);    // 서버로부터 응답이 도착하면 호출될 함수
        },
        error: function () {
            alert("error")
        } 
    }); // $.ajax()
}

<button id="sendBtn" type="button">SEND</button>
<h2>Data From Server :</h2>
<div id="commentList"></div>
<script>
    let bno = 1085;

    // 특정 게시물에 달려있는 댓글들을 가져온다.
    let showList = function (bno) {
        $.ajax({
            type: 'GET',       // 요청 메서드
            url: '/comments?bno=' + bno,  // 요청 URI
            success: function (result) {
                $("#commentList").html(toHtml(result)); // 서버로부터 응답이 도착하면 호출될 함수
            },
            error: function () {
                alert("error")
            }
        }); // $.ajax()
    }

    $(document).ready(function () {
        $("#sendBtn").click(function () {
            showList(bno);
        })
    });

    let toHtml = function (comments) {
        let tmp = "<ul>";

        comments.forEach(function (comment) {
            tmp += '<li data-cno=' + comment.cno
            tmp += ' data-pcno=' + comment.pcno
            tmp += ' data-bno=' + comment.bno + '>'
            tmp += ' commenter=<span class="commenter">' + comment.commenter + '</span>'
            tmp += ' comment=<span class="comment">' + comment.comment + '</span>'
            tmp += ' up_date=' + comment.up_date
            tmp += '</li>'
        });

        return tmp + "</ul>";
    }

결과

댓글 삭제하기

tmp += '<button class="delBtn">삭제</button>' // 삭제 버튼 추가

이렇게 하면 alert 창이 안 뜬다.

$(document).ready(function () {
    $(".delBtn").click(function () {
        alert("delBtn");
    });
});

먼저 페이지가 로딩이 된다. 아래와 같은 상태임

💡동적으로 생성되는 요소에 이벤트를 거는 방법

동적으로 생성된 요소(이 경우 .delBtn)에 이벤트를 연결하려면, 고정된 상위요소(#commentList)에 이벤트를 걸어야 한다. (이벤트 위임)

이렇게 변경하면 된다. #commentList 안에 있는 .delBtn 클래스 요소에다가 클릭 이벤트를 건다.

// $(".delBtn").click(function () {
$("#commentList").on("click", ".delBtn", function () {
    alert("delBtn");
});

// $(".delBtn").click(function () {
$("#commentList").on("click", ".delBtn", function () {
    let cno = $(this).parent().attr("data-cno");
    let bno = $(this).parent().attr("data-bno");

    $.ajax({
        type: 'DELETE',       // 요청 메서드
        url: '/comments/' + cno + '?bno=' + bno,  // 요청 URI
        success: function (result) {
            alert(result);
            showList(bno);
        },
        error: function () {
            alert("error")
        }
    }); // $.ajax()
});

사용자 정의 속성은 기존 속성과 충돌날 수 있기 때문에 data-를 붙여주는 게 좋다.

data- 로 시작하는 애들은 dataset이라는 속성 안에 map 형태로 쌓인다 참고로 알아두기.(dataset 속성 통해 접근 가능)

댓글 쓰기

send 버튼 누르면 Input 태그에 있는 내용이 저장되도록 하기

comment : <input type="text" name="comment"> <br>
<button id="sendBtn" type="button">SEND</button>


$("#sendBtn").click(function () {
    let comment = $("input[name=comment]").val();

    $.ajax({
        type: 'POST',       // 요청 메서드
        url: '/comments?bno=' +  bno,  // 요청 URI
        headers: {"content-type": "application/json"}, // 요청 헤더
        data: JSON.stringify({bno : bno, comment : comment}),  // 서버로 전송할 데이터. stringify()로 직렬화 필요.
        success: function (result) {
            alert(result);
            showList(bno);
        },
        error: function () {
            alert("error")
        } // 에러가 발생했을 때, 호출될 함수
    }); // $.ajax()
});

댓글 수정

$("span.comment", $(this).parent()) : 클릭된 수정 버튼에 부모에 있는 span만 가지고 온다.

$("#commentList").on("click", ".modBtn", function () {
    let cno = $(this).parent().attr("data-cno");
    let bno = $(this).parent().attr("data-bno");
    let comment = $("span.comment", $(this).parent()).text();

    // 1. comment의 내용을 input에 뿌려주기
    $("input[name=comment]").val(comment);
    // 2. cno 전달하기
    $("#modBtn").attr("data-cno", cno);

    $("#modBtn").click(function () {
        let cno = $(this).attr("data-cno");
        let comment = $("input[name=comment]").val();

        $.ajax({
            type: 'PATCH',       // 요청 메서드
            url: '/comments/' + cno, // 요청 URI /ch4/comments/70 POST
            headers: {"content-type": "application/json"}, // 요청 헤더
            data: JSON.stringify({cno : cno, comment : comment}),  // 서버로 전송할 데이터. stringify()로 직렬화 필요.
            success: function (result) {
                alert(result);
                showList(bno);
            },
            error: function () {
                alert("error")
            } // 에러가 발생했을 때, 호출될 함수
        }); // $.ajax()
    });
});

4. 대댓글

11:50

<div id="replyForm" style="display: none;">
    <input type="text" name="replyComment">
    <button id="wrtRepBtn" type="button">등록</button>
</div>

$("#commentList").on("click", ".replyBtn", function () {
    // 1. replyForm을 옮기고
    $("#replyForm").appendTo($(this).parent());

    // 2. 답글을 입력할 폼을 보여준다.
    $("#replyForm").css("display", "block");
});

$("#wrtRepBtn").click(function () {
    let comment = $("input[name=replyComment]").val();
    let pcno = $("#replyForm").parent().attr("data-pcno");

    if (comment.trim() == '') {
        alert("댓글을 입력해주세요.");
        $("input[name=replyComment]").focus();

        return;
    }

    $.ajax({
        type: 'POST',       // 요청 메서드
        url: '/comments?bno=' +  bno,  // 요청 URI
        headers: {"content-type": "application/json"}, // 요청 헤더
        data: JSON.stringify({pcno : pcno, bno : bno, comment : comment}),  // 서버로 전송할 데이터. stringify()로 직렬화 필요.
        success: function (result) {
            alert(result);
            showList(bno);
        },
        error: function () {
            alert("error")
        } // 에러가 발생했을 때, 호출될 함수
    }); // $.ajax()

    // 초기화 작업
    $("#replyForm").css("display", "none");
    $("input[name=replyComment]").val('');
    $("#replyForm").appendTo("body"); // 대댓글 입력 form을 원래 자리로 다시 되돌려놓기
});

기존 쿼리에서 댓글을 가져오는 쿼리를 수정
답글이 여러개일 수 있기 때문에 cno로도 정렬을 해야 한다.
```
SELECT cno, bno, ifnull(pcno, cno) as pcno, comment, commenter, reg_date, up_date
FROM comment
WHERE bno = 1085
ORDER BY pcno asc;
```

ㄴㅇㅇ

if (comment.cno != comment.pcno)
		tmp += 'ㄴ'

대댓글에서 답글을 누르면 최상의 댓글의 대댓글로 들어가얌(대댓글 1단계만 허용)
```
let pcno = $("#replyForm").pa rent().attr("data-cno");
let pcno = $("#replyForm").parent().attr("data-pcno");
```

github comment.html에 대댓글 댓글 디자인 있음. 적용해서 마들어보기

수정, 삭제는 해당 아이디인 사람에게만 나오도록

Uploaded by N2T