[mybatis] 8. XML+INTERFACE 매퍼(매퍼바인딩) 2 (MYUSER, MYCOMMENT, MYREPLY)

01. DTO

1) 💙MyComment1.java - 테이블의 "컬럼명"과 "필드명"이 같음

package xyz.itwill.dto;

import java.io.Serializable;

/*
MYCOMMENT 테이블 : 게시글을 저장하기 위한 테이블
create table mycomment(comment_no number primary key, comment_id varchar2(50)
		, comment_content varchar2(100), comment_date date );

//MYCOMMENT_SEQ 시퀀스 : MYCOMMENT 테이블의 COMMENT_NO 컬럼에 저장될 자동 증가값을 제공하기 위한 시퀀스
create sequence mycomment_seq;

이름              널?       유형
--------------- -------- -------------
COMMENT_NO      NOT NULL NUMBER        - 게시글 번호
COMMENT_ID               VARCHAR2(50)  - 게시글 작성자(아이디)
COMMENT_CONTENT          VARCHAR2(100) - 게시글 내용
COMMENT_DATE             DATE          - 게시글 작성일
*/

//테이블의 컬럼명을 같은 이름의 필드를 선언하여 클래스 작성

//XML 기반의 매퍼 파일에서 cache 엘리먼트를 사용한 경우 SELECT 명령에 대한  검색결과를 제공될
//객체의 클래스는 반드시 객체 직렬화 클래스로 선언
//=> 객체 직렬화 클래스는 Serializable 인터페이스를 상속받아 작성
//=> 객체 직렬화 클래스는 serialVersionUID이름의 static final 필드 선언하는 것을 권장

public class MyComment1 implements Serializable{

	private static final long serialVersionUID = 1L;
	private int commentNo;
	private String commentId;
	private String commentContent;
	private String commentDate;
    
	public MyComment1() {	}
    
	public int getCommentNo() {return commentNo;}
	public void setCommentNo(int commentNo) {this.commentNo = commentNo;}
	public String getCommentId() {return commentId;}
	public void setCommentId(String commentId) {this.commentId = commentId;}
	public String getCommentContent() {return commentContent;}
	public void setCommentContent(String commentContent) {this.commentContent = commentContent;}
	public String getCommentDate() {return commentDate;}
	public void setCommentDate(String commentDate) {this.commentDate = commentDate;}
}

2) 💙MyComment2.java - 테이블의 "컬럼명"과 "필드명"이 다름

package xyz.itwill.dto;

//테이블의 컬럼명과 다른 이름의 필드를 선언하여 클래스 작성
public class MyComment2 {
	private int no;
	private String id;
	private String content;
	private String date;
    
	public MyComment2() {	}
	public MyComment2(int no, String id) {
		super();
		this.no = no;
		this.id = id;
	}
	public MyComment2(int no, String id, String content, String date) {
		super();
		this.no = no;
		this.id = id;
		this.content = content;
		this.date = date;
	}
    
	public int getNo() {return no;}
	public void setNo(int no) {this.no = no;}
	public String getId() {return id;}
	public void setId(String id) {this.id = id;}
	public String getContent() {return content;}
	public void setContent(String content) {this.content = content;}
	public String getDate() {return date;}
	public void setDate(String date) {this.date = date;}
}

3) 💙MyComment3.java - 테이블의 "컬럼명"과 "필드명"이 다름

package xyz.itwill.dto;

//MYCOMMENT 테이블과 MYUSER 테이블의 검색결과를 저장하기 위한 클래스
// => 1:1 관계의 조인 검색 결과를 저장하기 위한 클래스
// => 1:1 관계의 조인 : 테이블과 테이블이 만나 하나의 행으로 검색됨 (무조건 inner 조인 이용)
public class MyComment3 {
	private int no;
	private String id;
	private String name; //MYCOMMENT 테이블이나 MYUSER 테이블 중 어떤 컬럼값을 저장해도 상관없음
	private String content;
	private String date;
    
	public MyComment3() {	}
    
	public int getNo() {return no;}
	public void setNo(int no) {this.no = no;}
	public String getId() {return id;}
	public void setId(String id) {this.id = id;}
	public String getName() {return name;}
	public void setName(String name) {this.name = name;}
	public String getContent() {return content;}
	public void setContent(String content) {this.content = content;}
	public String getDate() {return date;}
	public void setDate(String date) {this.date = date;}
}

4) 💜MyCommentUser1.java - 필드에 값 저장 (비권장) - 1:1 관계

package xyz.itwill.dto;

//MYCOMMENT 테이블과 MYUSER 테이블의 검색결과를 저장하기 위한 클래스
//=> 1:1 관계의 조인 검색 결과를 저장하기 위한 클래스
public class MyCommentUser1 {

	//MYCOMMENT 테이블(게시글정보)의 검색결과를 저장하기 위한 필드 - 검색행 1개
	private int commentNo;
	private String commentId;
	private String commentContent;
	private String commentDate;

	//MYUSER 테이블(회원정보)의 검색결과를 저장하기 위한 필드 - 검색행 1개
	private String userId;
	private String userName;

	public MyCommentUser1() {	}
    
	public int getCommentNo() {return commentNo;}
	public void setCommentNo(int commentNo) {this.commentNo = commentNo;}
	public String getCommentId() {return commentId;}
	public void setCommentId(String commentId) {this.commentId = commentId;}
	public String getCommentContent() {return commentContent;}
	public void setCommentContent(String commentContent) {this.commentContent = commentContent;}
	public String getCommentDate() {return commentDate;}
	public void setCommentDate(String commentDate) {this.commentDate = commentDate;}
	public String getUserId() {return userId;}
	public void setUserId(String userId) {this.userId = userId;}
	public String getUserName() {return userName;}
	public void setUserName(String userName) {this.userName = userName;}
}

5) 💜 MyCommentUser2.java - 필드에 객체 저장 (권장) - 1:1 관계

• 생산성 증가 및 유지보수의 효율성 증가

package xyz.itwill.dto;

//MYCOMMENT 테이블과 MYUSER 테이블의 검색결과를 저장하기 위한 클래스
//=> 1:1 관계의 조인 검색 결과를 저장하기 위한 클래스
//기존에 선언된 클래스(POZO : Plan Old Java Object)를 재사용하여 새로운 클래스 작성
//=> 생산성 증가 및 유지보수의 효율성 증가
public class MyCommentUser2 {

	//MYCOMMENT 테이블(게시글정보)의 검색결과를 저장하기 위한 필드 - 검색행 1개
	//=> 객체를 저장하기 위한 필드 : 포함관계
	//=> 포함관계가 성립되기 위해서는 반드시 필드에 객체 저장
	private MyComment1 comment;
	
	//MYUSER 테이블(회원정보)의 검색결과를 저장하기 위한 필드 - 검색행 1개
	//=> 객체를 저장하기 위한 필드 : 포함관계
	//=> 포함관계가 성립되기 위해서는 반드시 필드에 객체 저장
	private MyUser user;

	public MyCommentUser2() {	}
    
	public MyComment1 getComment() {return comment;}
	public void setComment(MyComment1 comment) {this.comment = comment;}
	public MyUser getUser() {return user;}
	public void setUser(MyUser user) {this.user = user;}
}

6) 🤎 MyReply.java

package xyz.itwill.dto;
/*
MYREPLY 테이블 : 게시글에 대한 댓글을 저장하기 위한 테이블
create table myreply(reply_no number primary key, reply_id varchar2(50)
, reply_content varchar2(100), reply_date date, reply_comment_no number );

MYREPLY_SEQ 시퀀스 : MYREPLY 테이블의 REPLY_NO 컬럼에 저장될 자동 증가값을 제공하기 위한 시퀀스
create sequence myreply_seq;

이름               널?       유형
---------------- -------- -------------
REPLY_NO         NOT NULL NUMBER        - 댓글 번호 : PK제약조건
REPLY_ID                  VARCHAR2(50)  - 댓글 작성자(아이디) : FK제약조건 - MYUSER 테이블의 user_id참조
REPLY_CONTENT             VARCHAR2(100) - 댓글 내용
REPLY_DATE                DATE          - 댓글 작성일
REPLY_COMMENT_NO          NUMBER        - 게시글 번호 : FK제약조건 - MYCOMMENT 테이블의 comment_no참조

=> "테이블 정규화"를 통해 잘못된 값이 저장되지 않도록 만드는 것이 핵심
=> 실제 회사에서는 FK 제약조건을 잘 만들지 않음
   (부모테이블의 컬럼값이 없으면 참조가 안되므로 값 저장이 안되기 때문)
*/

public class MyReply {
	private int replyNo;
	private String replyId;
	private String replyContent;
	private String replyDate;
	private int replyCommentNo;
    
	public MyReply() {	}
    
	public int getReplyNo() {return replyNo;}
	public void setReplyNo(int replyNo) {this.replyNo = replyNo;}
	public String getReplyId() {return replyId;}
	public void setReplyId(String replyId) {this.replyId = replyId;}
	public String getReplyContent() {return replyContent;}
	public void setReplyContent(String replyContent) {this.replyContent = replyContent;}
	public String getReplyDate() {return replyDate;}
	public void setReplyDate(String replyDate) {this.replyDate = replyDate;}
	public int getReplyCommentNo() {return replyCommentNo;}
	public void setReplyCommentNo(int replyCommentNo) {this.replyCommentNo = replyCommentNo;}
}

7) 🤎 MyReplyUser.java - 필드에 객체 저장 - 1:1 관계

package xyz.itwill.dto;

//MYREPLY 테이블과 MYUSER 테이블의 검색결과를 저장하기 위한 클래스
//=> 1:1 관계의 조인 검색 결과를 저장하기 위한 클래스
public class MyReplyUser {
	/*
	//MYREPLY 테이블(댓글정보)의 검색결과를 저장하기 위한 필드 - 검색형 1개
	private int replyNo;
	private String replyId;
	private String replyContent;
	private String replyDate;
	private int replyCommentNo;

	//MYUSER 테이블(회원정보)의 검색결과를 저장하기 위한 필드 - 검색형 1개
	private String userId;
	private String userName;
	*/

	//MYREPLY 테이블(댓글정보)의 검색결과를 저장하기 위한 필드 - 검색형 1개
	private MyReply reply;
	//MYUSER 테이블(회원정보)의 검색결과를 저장하기 위한 필드 - 검색형 1개
	private MyUser user;

	public MyReplyUser() {	}
    
	public MyReply getReply() {return reply;}
	public void setReply(MyReply reply) {this.reply = reply;}
	public MyUser getUser() {return user;}
	public void setUser(MyUser user) {this.user = user;}
}

8) 🤍MyCommentReply.java - 1:N관계

package xyz.itwill.dto;

import java.util.List;

//MYCOMMENT 테이블과 MYREPLY 테이블의 검색결과를 저장하기 위한 클래스
//=> MYCOMMENT는 하나만 검색되지만, MYREPLY는 여러개 검색될 수 있음
// => 1:N 관계의 조인 검색 결과를 저장하기 위한 클래스
public class MyCommentReply {

	private int commentNo;

	//MYCOMMENT 테이블(게시글정보)의 검색결과를 저장하기 위한 필드 - 검색행 : 1개
	private MyComment1 comment;

	//MYREPLY 테이블(댓글정보)의 검색결과를 저장하기 위한 필드 - 검색행 : 0개 이상
	private List<MyReply> replyList;

	public MyCommentReply() {	}
    
	public int getCommentNo() {return commentNo;}
	public void setCommentNo(int commentNo) {this.commentNo = commentNo;}
	public MyComment1 getComment() {return comment;}
	public void setComment(MyComment1 comment) {this.comment = comment;}
	public List<MyReply> getReplyList() {return replyList;}
	public void setReplyList(List<MyReply> replyList) {this.replyList = replyList;}
}

9) 🤍MyCommentReplyUser.java - 1 : 1 : N관계

• 1(MYCOMMENT) : 1(MYUSER)관계 + N(MYREPLY) : 1(MYUSER)관계
• 조인 3개 되어있음
  • 조인 1 - 1(MYCOMMENT) : 1(MYUSER) comment_id = user=id
  • 조인 2 - N(MYREPLY) : 1(MYUSER) reply_id = user_id
  • 조인 3 - 1(MYCOMMENT) : 1(MYREPLY) comment_no = reply_comment_no

package xyz.itwill.dto;

import java.util.List;

//[MYCOMMENT테이블과 MYUSER테이블] 및 [MYREPLY테이블과 MYUSER테이블]의 검색결과를 저장하기 위한 클래스
public class MyCommentReplyUser {
	//MYCOMMENT 테이블(게시글정보)의 검색결과를 저장하기 위한 필드 - 검색행 : 1개
	//=> 어차피 값을 저장하는 필드가 먼저 나와야 하므로, 객체말고 값으로 저장함
	private int commentNo;
	private String commentId;
	private String commentContent;
	private String commentDate;

	//MYUSER 테이블(회원정보 - 게시글)의 검색결과를 저장하기 위한 필드 - 검색행 : 1개
	private MyUser user;

	//MYREPLY 테이블(댓글정보)과 MYUSER 테이블(회원정보)의 검색결과를 저장하기 위한
	//필드 - 검색행 : 0개 이상
	//= >MyReplyUser객체 이용 : MyReply과 MyUser를 저장하는 객체
	private List<MyReplyUser> replyUserList;

	public MyCommentReplyUser() {	}

	public int getCommentNo() {return commentNo;}
	public void setCommentNo(int commentNo) {this.commentNo = commentNo;}
	public String getCommentId() {return commentId;}
	public void setCommentId(String commentId) {this.commentId = commentId;}
	public String getCommentContent() {return commentContent;}
	public void setCommentContent(String commentContent) {this.commentContent = commentContent;}
	public String getCommentDate() {return commentDate;}
	public void setCommentDate(String commentDate) {this.commentDate = commentDate;}
	public MyUser getUser() {return user;}
	public void setUser(MyUser user) {this.user = user;}
	public List<MyReplyUser> getReplyUserList() {return replyUserList;}
	public void setReplyUserList(List<MyReplyUser> replyUserList) {this.replyUserList = replyUserList;}
}

 

 

02.  Mapper바인딩

1) [Mapper바인딩] MyCommentMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "<https://mybatis.org/dtd/mybatis-3-mapper.dtd>">
<mapper namespace="xyz.itwill.mapper.MyCommentMapper">
	<!-- cache : SELECT 명령의 검색결과를 임시 메모리(Cache Memory)에 저장하여 빠른 검색결과를
	제공하기 위한 엘리먼트 - 가독성 증가 -->
	<!-- => 사용자가 SELECT 명령을 요청하면 mybatis가 DataBase에서 검색해서 그 검색결과를 임시 메모리에 저장하고,
	다른 사용자가 똑같은 SELECT 명령을 요청하면 임시메모리에 있는 객체를 바로줌 -->
	<!-- => INSERT, UPDATE, DELETE 명령이 실행되면 임시메모리에 저장된 검색결과는 자동 초기화됨 -->
	<!-- => 우리가 사용하는 웹에서는 빈번하게 INSERT, UPDATE, DELETE 명령이 일어나므로 굳이 cache 엘리먼트 쓸 이유가 없음 -->
	<!-- => 검색결과를 저장하는 객체는 반드시 객체 직렬화 클래스로 작성해야함 -->
	<!-- <cache/>  -->

 

💙MyComment1 이용 : 테이블의 컬럼명과 필드명이 같음

• insertComment1

	<!-- insert --> 
	<insert id="insertComment1" parameterType="MyComment1">
		insert into mycomment values(mycomment_seq.nextval, #{commentId}, #{commentContent}, sysdate)
	</insert>

• insertComment2

	<!-- insert : selectKey 이용 -->
	<insert id="insertComment2" parameterType="MyComment1">
      
		<!-- selectKey : [SELECT 명령]의 검색 결과값을 insert 엘리먼트의 parameterType 속성값으로 설정된 클래스의 필드값으로 저장하기 위한 엘리먼트 -->
		<!-- => insert 엘리먼트에 종속된 엘리먼트 -->
		<!-- => jsp1의 DAO클래스에서 selectNextNum() 메소드와 동일한 역할-->
	  
		<!-- => 일반적으로 자동 증가값(숫자) 또는 난수값(문자열)을 SELECT 명령으로 검색하여 객체의 필드에 저장하여 INSERT 명령에서 사용 -->
		<!-- => 오라클은 난수값(문자열)이 없으므로 우리는 자동 증가값(숫자)을 쓸 때 이용 -->
		<!-- => 아래처럼 설정하면 어떤 자동증가값으로 삽입되었는지 그 숫자가 명확히 로깅정보를 통해 확인 가능 -->
	
	  	<!-- 자동증가값 만들기 위해 사용 -->
		<!-- 자동 증가값을 여러개의 컬럼에서 이용 가능 (즉, 자동증가값 재사용 가능) -->
	  	<!-- ex. 다중답변형 게시판만들 때 이용하면 좋음(num컬럼값과 ref컬럼값의 자동증가값 이용)-->
		
		<!-- resultType속성 : SELECT 명령으로 검색된 결과값을 반환받기 위한 Java 자료형을 속성값으로 설정 -->
		  
		<!-- keyProperty속성 : insert 엘리먼트의 parameterType속성값으로 설정된 클래스의 필드명을 속성값으로 설정 -->
		<!-- => SELECT 명령의 검색 결과값을 제공받아 Java 객체의 필드에 저장하기 위해 설정 -->
		    
		<!-- order속성: BEFORE 또는 AFTER 중 하나를 속성값으로 설정 -->
		<!-- => BEFORE : insert명령 실행 전 select 명령 먼저 실행-->
		<!-- => AFTER : insert명령 실행 후 select 명령 실행-->
      
		<selectKey resultType="int" keyProperty="commentNo" order="BEFORE">
			select mycomment_seq.nextval from dual
		</selectKey>
      
		insert into mycomment values(#{commentNo}, #{commentId}, #{commentContent}, sysdate)
	</insert>

• selectCommentList1

	<!-- select - 자동매핑 -->
	<!-- resultType 속성을 사용하여 자동 매핑 처리로 Java 객체를 제공 -->
	<!-- => 검색행의 컬럼명과 resultType 속성값으로 설정된 클래스의 필드명이 같도록 작성 -->
	<select id="selectCommentList1" resultType="MyComment1">
		select * from mycomment order by comment_no desc
	</select>

 

💙MyComment2 이용 : 테이블의 컬럼명과 필드명이 다름

• selectCommentList2

	<!-- select - null 제공 -->
	<!-- 검색행의 컬럼명과 resultType 속성값으로 설정된 클래스의 필드명이 모두 다른 경우
	resultType 속성값으로 설정된 클래스의 객체 대신 NULL 제공 : NullPoniterException 발생-->
	<select id="selectCommentList2" resultType="MyComment2">
		select * from mycomment order by comment_no desc
	</select>

• selectCommentList2

	<!-- select - 자동매핑 -->
	<!-- 검색행의 컬럼명을 esultType 속성값으로 설정된 클래스의 필드명과 같도록 Column Alias
	기능을 사용하여 검색 - 컬럼의 별칭으로 사용하기 부적절한 단어는 "" 기호를 사용하여 표현  -->
	<!-- => date는 날짜와 시간을 표현하는 Java 자료형(키워드)이기 때문에 "date"로 표현 필요 -->
	<select id="selectCommentList2" resultType="MyComment2">
		select comment_no no, comment_id id,comment_content content,
		comment_date "date" from mycomment order by comment_no desc
	</select>

	 <!-- select - 수동매핑 : Setter메소드가 필드값 세팅 -->
	 <!-- resultMap 엘리먼트를 이용하여 검색행의 컬럼값을 클래스의 필드에 저장되도록 설정하여 제공 -->
	 <!-- type속성값으로 설정된 Java 클래스의 [기본 생성자]로 객체를 생성하고, id 엘리먼트 또는
	 result 엘리먼트를 사용하여 객체의 [Setter 메소드를 호출]하여 필드값이 변경되도록 처리 -->
	 <resultMap type="MyComment2" id="myComment2ResultMap">
	 	<id column="comment_no" property="no"/>
	 	<result column="comment_id" property="id"/>
	 	<result column="comment_content" property="content"/>
	 	<result column="comment_date" property="date"/>
	 </resultMap>

	 <!-- select 엘리먼트의 resultMap 속성을 사용하여 검색행을 Java 객체로 수동 매핑하여 제공 -->
	 <select id="selectCommentList2" resultMap="myComment2ResultMap">
	 	select * from mycomment order by comment_no desc
	 </select>

	 <!-- select - 수동매핑 : 매개변수가 있는 생성자가 필드값 세팅 -->
	 <!-- constructor 엘리먼트를 사용하여 type속성값으로 설정된 클래스의 매개변수가 작성된 생성자로 객체를 생성하고 생성자 매개변수에 검색행의 컬럼값을 전달하여 객체의 필드에 저장되도록 매핑 처리 -->
	 <resultMap type="MyComment2" id="myComment2ConstructResultMap">
       
	 	<!-- constructor : resultMap 엘리먼트의 type속성값으로 설정된 클래스의 [생성자를 이용]하여 매핑 처리하기 위한 정보를 제공하는 엘리먼트 -->
	 	<!--  => 하위 엘리먼트 : idArg, arg 중 하나 사용-->
	 	<!--  => [생성자 매개변수의 갯수(2개)와 자료형]과 [하위 엘리먼트의 갯수(2개)와 자료형(javaType)]이 동일해야만 매핑 가능 -->
	 	<constructor>
          
	 		<!-- idArg : 검색행의 컬럼값을 생성자 매개변수에 전달하기 위한 엘리먼트 -->
	 		<!-- => PK 제약조건이 설정된 컬럼값을 제공받아 생성자 매개변수에 전달하기 위해 사용 -->         
	 		<!-- column속성 : 검색행의 컬럼명을 속성값으로 설정 -->
	 		<!-- javaType속성 : 생성자 매개변수의 자료형을 속성값으로 설정 -->
	 		<!-- => Java 자료형 대신 typeAlias 엘리먼트로 설정된 별칭 사용 가능 -->
	 		<!-- => 주의) 반드시 [ _int : 원시값] 로 작성 -->
	 		<idArg column="comment_no" javaType="_int"/>
          
	 		<!-- arg : 검색행의 컬럼값을 생성자 매개변수에 전달하기 위한 엘리먼트 -->
	 		<arg column="comment_id" javaType="string"/>
          
	 		<!-- 2개(no,id)의 매개변수만 있는 생성자가 있기 때문에 아래 2개는 없어도 에러 안떨어지고 null값이 저장될 것임 -->
			<!--
	 		<arg column="comment_content" javaType="string"/>
	 		<arg column="comment_date" javaType="string"/>
	 		 -->
	 	</constructor>

	 	<!-- constructor 엘리먼트와 id엘리먼트(result 엘리먼트)를 같이 사용하여 매핑 처리 가능  -->
	 	<result column="comment_content" property="content"/>
	 	<result column="comment_date" property="date"/>
	 </resultMap>

	<select id="selectCommentList2" resultMap="myComment2ConstructResultMap">
		select * from mycomment order by comment_no desc
	</select>

 

💙MyComment3 이용 : 테이블의 컬럼명과 필드명이 다름 - 두 개의 테이블 조인하여 저장된 객체

• selectCommentList3

	<!-- select - 자동매핑 -->
	<select id="selectCommentList3" resultType="MyComment3">
		select comment_no "no", comment_id "id", user_name "name",
      	comment_content "content", comment_date "date" from mycomment
      	join myuser on comment_id=user_id
      	order by comment_no desc
	</select>

	<!-- select - 수동매핑 -->	
	<resultMap type="MyComment3" id="myComment3ResultMap">
		<id column="comment_no" property="no"/>
		<result column="comment_id" property="id"/>
		<result column="user_name" property="name"/>
		<result column="comment_content" property="content"/>
		<result column="comment_date" property="date"/>
	</resultMap>
	<select id="selectCommentList3" resultMap="myComment3ResultMap">
		select comment_no, comment_id, user_name, comment_content, comment_date
		 from mycomment join myuser on comment_id=user_id order by comment_no desc
	</select>

 

💜MyCommentUser1 이용 : 두 개의 테이블의 컬럼값 모두가 저장된 객체

• selectCommentUserList1

	<!-- select - 자동매핑 -->
	<select id="selectCommentUserList1" resultType="MyCommentUser1">
		select comment_no, comment_id, comment_content, comment_date, user_id, user_name
		from mycomment join myuser on comment_id=user_id order by comment_no desc
	</select>

 

💜MyCommentUser2 이용 : 두 개의 테이블의 컬럼값을 가진 객체가 저장된 객체 - 1 : 1 관계의 조인

• selectCommentUserList2

	<!-- select - 무조건 수동매핑만 가능 -->
	<!-- resultType 사용 불가능하므로 반드시 resultMap 이용 : 수동매핑만 가능 -->
	<!-- 검색행의 컬럼명과 필드명이 다르므로 사용 불가능하기도 하고, MyCommentUser2의 필드에는 값이 아닌 객체를 저장하므로 지금까지 했던 것처럼 수동 매핑 못함 -->
	<!-- =>즉, association 엘리먼트가 필요 -->

	<!-- resultMap 엘리먼트의 type 속성값으로 설정된 클래스의 필드가 Java 객체를 저장하기 위한 필드로 선언된 경우 하위 엘리먼트로 association 엘리먼트를 사용하여 Java 객체를 제공받아 필드에 저장되도록 설정 -->
	<resultMap type="MyCommentUser2" id="myCommentUser2ResultMap">

		<!-- association : 1:1 관계의 테이블 조인에서 1개의 검색행을 Java 객체로 제공받아 필드에 저장되도록 매핑 처리하는 엘리먼트 -->
		<!-- => id 엘리먼트와 result 엘리먼트를 하위 엘리먼트로 사용하여 검색행의 컬럼값이 포함 관계의 객체의 필드에 저장되도록 설정 -->
		<!-- property 속성 : 포함 관계의 객체를 저장하기 위한 필드명을 속성값으로 설정 -->
		<!-- javaType 속성 : 검색결과를 제공받기 위한 객체의 Java 자료형을 속성값으로 설정 -->
		<!-- => Java 자료형 대신 typeAlias 엘리먼트로 설정된 별칭 사용 가능 -->
		<!-- => 검색행의 컬럼값들을 포함관계의 객체의 필드에 저장할 수 있도록 만드는 것 -->

    <!-- MyComment1 객체를 제공받아 comment 필드에 저장해 -->
		<association property="comment" javaType="MyComment1">
			<id column="comment_no" property="commentNo"/>
			<result column="comment_id" property="commentId"/>
			<result column="comment_content" property="commentContent"/>
			<result column="comment_date" property="commentDate"/>
		</association>

    <!-- MyUser 객체를 제공받아 user 필드에 저장해 -->
		<association property="user" javaType="MyUser">
			<id column="user_id" property="userId"/>
			<result column="user_name" property="userName"/>
		</association>

	</resultMap>

	<select id="selectCommentUserList2" resultMap="myCommentUser2ResultMap">
		select comment_no, comment_id, comment_content, comment_date, user_id, user_name
		from mycomment join myuser on comment_id=user_id order by comment_no desc
	</select>

 

💙MyComment1 + 🤎MyReply 이용

• selectComment

	<!-- [😋방법1] 조인하지 않고 각각의 DAO 만들어서 메소드 호출해 출력하기 -->
	<!-- 게시글번호를 전달받아 MYCOMMENT 테이블에 저장된 해당 게시글번호의 게시글을 검색하여 MyComment1 객체로 제공하는 엘리먼트 - 검색행 1개 -->
	<!-- resultType쓰는 이유: MyComment1테이블의 컬럼명과 필드명이 같기 때문에 자동매핑됨 -->
	<select id="selectComment" parameterType="int" resultType="MyComment1">
		select * from mycomment where comment_no=#{commentNo}
	</select>

• selectCommentNoReplyList

	<!-- 원래는 MyReplyMapper.xml 문서에 있어야 하는 부분이지만 그냥 MyCommentMapper.xml 문서에 작성할 것임 -->
	<!-- 게시글번호를 전달받아 MYREPLY 테이블에 저장된 해당 게시글번호의 댓글을 검색하여 MyReply 객체로 제공하는 엘리먼트 - 검색행 0개 이상 (무조건 List로 반환)-->
	<!-- resultType쓰는 이유: MyReply테이블의 컬럼명과 필드명이 같기 때문에 자동매핑됨 -->
	<select id="selectCommentNoReplyList" parameterType="int" resultType="MyReply">
		select * from myreply where reply_comment_no=#{replyCommentNo} order by reply_no desc
	</select>

 

🤍MyCommentReply 이용

• selectCommentReply

	<!-- [😋방법2] 조인해서 DAO 메소드 1번만 호출해 출력하기 - 1 : N 관계의 조인 -->
	<!-- resultMap 엘리먼트의 type 속성값으로 설정된 클래스의 필드 자료형이 List인 경우 collection 엘리먼트를 사용하여 List 객체를 생성하여 필드에 저장되도록 설정 -->
	<!-- resultMap 엘리먼트의 하위 엘리먼트 작성 순서 -->
	<!-- => constructor, id, result, association, collection, discriminator -->
	<!-- => association 엘리먼트가 resultMap 엘리먼트의 첫번째 하위 엘리먼트인 경우 내부적으로 selectOne 메소드를 사용하여 하나의 검색 행에 대한 객체만 제공하여 필드에 저장 -->

	<!-- 문제점) association 엘리먼트가 resultMap 엘리먼트의 첫번째 하위 엘리먼트인 경우 다수의 검색행이 검색된 경우 TooManyResultException 발생 -->
	<!-- 해결법) 다수행을 검색할 경우 resultMap 엘리먼트의 첫번째 하위 엘리먼트를 association 엘리먼트가 아닌 다른 엘리먼트로 설정하여 매핑처리 : id 엘리먼트 추가함 -->

	<resultMap type="MyCommentReply" id="myCommentReplyResultMap">
		<id column="comment_no" property="commentNo"/>
		<!-- association은 selectOne()메소드를 호출해 매핑처리해주고 다음으로 넘김, 근데 collection은 행이 여러개라 selectOne()으로 처리 못해서 에러 발생함 -->
		<association property="comment" javaType="MyComment1">
			<id column="comment_no" property="commentNo"/>
			<result column="comment_id" property="commentId"/>
			<result column="comment_content" property="commentContent"/>
			<result column="comment_date" property="commentDate"/>
		</association>

		<!-- collection: List 객체를 생성하여 포함 객체 필드에 저장하기 위한 엘리먼트 -->
		<!-- => 1:N 관계의 테이블 조인에서 0개 이상의 테이블 검색행을 List 객체의 요소로 저장하여 생성 -->
		<!-- => id 엘리먼트와 result 엘리먼트를 하위 엘리먼트로 사용하여 검색행의 컬럼값이 List 객체의 요소 필드에 저장되도록 설정 -->
		<!-- property 속성 : resultMap 엘리먼트의 type 속성값으로 설정된 클래스의 필드명을 속성값으로 설정 -->
		<!-- ofType 속성 : List 객체에 저장될 요소의 Java 자료형을 속성값으로 설정 -->
		<!-- => Java 자료형 대신 typeAlias 엘리먼트로 설정된 별칭 사용 가능 -->
		<collection property="replyList" ofType="MyReply">
			<id column="reply_no" property="replyNo"/>
			<result column="reply_id" property="replyId"/>
			<result column="reply_content" property="replyContent"/>
			<result column="reply_date" property="replyDate"/>
			<result column="reply_comment_no" property="replyCommentNo"/>
		</collection>
	</resultMap>

	<!-- 1:N 관계의 조인은 반드시 OUTER JOIN 사용하여 검색 -->
	<!-- 이너 조인은 조건이 참인 경우만 출력하므로, n=0일 때(게시글이 없을 때) 검색이 되지 않음-->
	<!-- => 댓글이 없는 게시글을 검색하기 위해 LEFT OUTER JOIN 사용 -->
	<select id="selectCommentReply" parameterType="int" resultMap="myCommentReplyResultMap">
		select comment_no, comment_id, comment_content, comment_date,
		reply_no, reply_id, reply_content, reply_date, reply_comment_no
		from mycomment left join myreply on comment_no=reply_comment_no
		where comment_no=#{commentNo} order by reply_no desc
	</select>

 

🤍MyCommentReplyUser 이용

• selectCommentReplyUser

	<!-- [😋방법3] 🎵3개 조인해서 출력하기 - select 구문 잘 작성하기!! -->
	<!-- [🎵3개 조인하는 방법1] -->
	<resultMap type="MyCommentReplyUser" id="myCommentReplyUserResultMap">

		<!-- 1. 값으로 저장 -->
		<id column="comment_no" property="commentNo"/>
		<result column="comment_id" property="commentId"/>
		<result column="comment_content" property="commentContent"/>
		<result column="comment_date" property="commentDate"/>

		<!-- 2. 객체로 저장 -->
		<association property="user" javaType="MyUser">
			<id column="user_id" property="userId"/>
			<result column="user_name" property="userName"/>
		</association>

		<!-- 3. 리스트로 저장 -->
		<collection property="replyUserList" ofType="MyReplyUser">
			<!-- 3-1. 리스트의 요소가 객체라서 association 이용 : reply필드에 저장 -->
			<association property="reply" javaType="MyReply">
				<id column="reply_no" property="replyNo"/>
				<result column="reply_id" property="replyId"/>
				<result column="reply_content" property="replyContent"/>
				<result column="reply_date" property="replyDate"/>
				<result column="reply_comment_no" property="replyCommentNo"/>
			</association>
			<!-- 3-2. 리스트의 요소가 객체라서 association 이용 : user필드에 저장 -->
			<association property="user" javaType="MyUser">
				<id column="reply_user_id" property="userId"/>
				<result column="reply_user_name" property="userName"/>
			</association>
		</collection>      
	</resultMap>

	<select id="selectCommentReplyUser" parameterType="int" resultMap="myCommentReplyUserResultMap">
        select comment_no, comment_id, comment_content, comment_date, user_id, user_name,
		reply_no, reply_id, reply_content, reply_date, reply_comment_no, reply_user_id, reply_user_name
		from mycomment join myuser on comment_id=user_id left join
		(select reply_no, reply_id, reply_content, reply_date, reply_comment_no, user_id reply_user_id, user_name reply_user_name
		from myreply join myuser on reply_id=user_id) on comment_no=reply_comment_no
		where comment_no=#{commentNo} order by reply_no desc
	</select>

	<!-- [🎵3개 조인하는 방법2] -->
	<!-- autoMapping 속성 : false 또는 true 중 하나를 속성값으로 설정 -->
	<!-- => autoMapping 속성값을 [true]로 설정한 경우 검색행의 컬럼명과 필드명 같은 경우 자동 매핑 처리 -->
	<resultMap type="MyCommentReplyUser" id="myCommentReplyUserResultMap" autoMapping="true">
		<id column="comment_no" property="commentNo"/>
		<association property="user" javaType="MyUser" autoMapping="true"/>
		<collection property="replyUserList" select="selectReplyUser" column="comment_no"/>
	</resultMap>

	<resultMap type="MyReplyUser" id="myReplyUserResultMap" autoMapping="true">
		<association property="reply" javaType="MyReply" autoMapping="true"/>
		<association property="user" javaType="MyUser" autoMapping="true"/>
	</resultMap>

	<select id="selectReplyUser" parameterType="int" resultMap="myReplyUserResultMap">
		select reply_no,reply_id,reply_content,reply_date,reply_comment_no,user_id,user_name
			from myreply join myuser on reply_id=user_id where reply_comment_no=#{replyCommentNo} order by reply_no desc
	</select>

	<select id="selectCommentReplyUser" parameterType="int" resultMap="myCommentReplyUserResultMap">
		select comment_no,comment_id,comment_content,comment_date,user_id,user_name
			,reply_no,reply_id,reply_content,reply_date,reply_comment_no
			from mycomment join myuser on comment_id=user_id left join myreply on comment_no=reply_comment_no
			where comment_no=#{commentNo} order by reply_no desc
	</select>

</mapper>

 

2) [Mapper바인딩] MyCommentMapper.java

package xyz.itwill.mapper;

import java.util.List;

import xyz.itwill.dto.MyComment1;
import xyz.itwill.dto.MyComment2;
import xyz.itwill.dto.MyComment3;
import xyz.itwill.dto.MyCommentReply;
import xyz.itwill.dto.MyCommentReplyUser;
import xyz.itwill.dto.MyCommentUser1;
import xyz.itwill.dto.MyCommentUser2;
import xyz.itwill.dto.MyReply;

public interface MyCommentMapper {
	int insertComment1(MyComment1 comment);
	int insertComment2(MyComment1 comment);
	List<MyComment1> selectCommentList1();
	List<MyComment2> selectCommentList2();
	List<MyComment3> selectCommentList3();
  	List<MyCommentUser1> selectCommentUserList1();
  	List<MyCommentUser2> selectCommentUserList2();
  	//😋방법1을 이용하기 위해
  	MyComment1 selectComment(int commentNo);
	List<MyReply> selectCommentNoReplyList(int replyCommentNo);
  	//😋방법2를 이용하기 위해
  	MyCommentReply selectCommentReply(int commentNo);
  	//😋방법3을 이용하기 위해 🎵3개 조인
	MyCommentReplyUser selectCommentReplyUser(int commentNo);
}

 

3) [Mapper바인딩] MyReplyMapper.xml

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

 

🤎MyReply 이용

• insertReply

	<!-- insert : MyReply 삽입 -->
	<insert id="insertReply" parameterType="MyReply">
		<selectKey resultType="int" keyProperty="replyNo" order="BEFORE">
			select myreply_seq.nextval from dual
		</selectKey>
		insert into myreply values(#{replyNo}, #{replyId}, #{replyContent}, sysdate, #{replyCommentNo})
	</insert>

• selectReplyList

	<!-- select : MyReply 전체 출력 -->
	<select id="selectReplyList" resultType="MyReply">
		select * from myreply order by reply_no desc
	</select>

• selectCountReplyList

	<!-- select : MyReply 최근 5개만 출력 -->
	<!-- MYREPLY 테이블에 저장된 모든 댓글 중에서 가장 최근에 작성된 5개의 댓글만 검색 -->
	<!-- 문제점) XML 기반의 매퍼 파일에서는 SQL 명령이 등록된 엘리먼트에서 관계 연산자(> 또는 <)를
	사용할 경우 엘리먼트를 표시하는 기호로 인식되어 에러 발생함 -->
	<!-- 해결법-1) 관계 연산자(> 또는 <)를 엔티티 레퍼런스(회피문자)로 변경하여 SQL 명령 작성 -->
	<!-- 해결법-2) CDATA 세션을 사용하여 SQL 명령 작성 : CDATA 안에 작성된 값들을 모두 문자값으로 취급하기 때문 -->
	<select id="selectCountReplyList" resultType="MyReply">
		<!--
		select rownum, reply.* from (select * from myreply
		order by reply_no desc) reply where rownum &lt;= 5
		 -->
		 <![CDATA[
			select rownum, reply.* from (select * from myreply
			order by reply_no desc) reply where rownum <= 5
		 ]]>
	</select>

 

🤎MyReplyUser 이용

• selectReplyUserList1

	<!-- select - 수동매핑 : JOIN 이용함 : MyReplyUser (객체가 저장된 reply필드+ user필드) 출력 -->
	<resultMap type="MyReplyUser" id="MyReplyUserResultMap1">
      
		<association property="reply" javaType="MyReply">
			<id column="reply_no" property="replyNo"/>
			<result column="reply_id" property="replyId"/>
			<result column="reply_content" property="replyContent"/>
			<result column="reply_date" property="replyDate"/>
			<result column="reply_comment_no" property="replyCommentNo"/>
		</association>
      
		<association property="user" javaType="MyUser">
			<id column="user_id" property="userId"/>
			<result column="user_name" property="userName"/>
		</association>
      
	</resultMap>

	<select id="selectReplyUserList1" resultMap="MyReplyUserResultMap1">
		select reply_no, reply_id, reply_content, reply_date, reply_comment_no,
		user_id, user_name from myreply join myuser on reply_id=user_id order by reply_no desc
	</select>

• selectMyUser

	<!-- select - 수동매핑 : JOIN 이용안함 --> 
	<!-- 조인을 사용하지 않고도 (MYREPLY 테이블만 검색해도) MYUSER 테이블의 값까지 같이 출력하는 방법 -->
	<!-- => 3.2나 3.4 버전은 사용 못함 -->
	<resultMap type="MyReply" id="MyReplyResultMap">
		<id column="reply_no" property="replyNo"/>
		<result column="reply_id" property="replyId"/>
		<result column="reply_content" property="replyContent"/>
		<result column="reply_date" property="replyDate"/>
		<result column="reply_comment_no" property="replyCommentNo"/>
	</resultMap>
	
	<!-- => MyReplyUser객체에는 MyUser와 MyReply 둘 다 저장될 것 -->
	<resultMap type="MyReplyUser" id="MyReplyUserResultMap2">
      
		<!-- resultMap속성 : resultMap 엘리먼트의 식별자를 속성값으로 설정 -->
		<!-- => resultMap 엘리먼트로 설정된 매핑정보를 이용하여 검색행의 컬럼값을 객체 필드에 저장하여 객체를 제공받아 필드에 저장 - javaType 속성값 생략가능 -->
    
  	<!-- => resultMap 속성을 이용해 다른 resultMap 엘리먼트를 가져다 객체를 만들어 필드에 저장 -->
  	<!-- => resultMap의 재사용 --->
  	<!-- => reply필드에는 MyReply객체가 저장됨 -->
		<association property="reply" resultMap="MyReplyResultMap"/>
      
		<!-- select속성 : select 엘리먼트의 식별자를 속성값으로 설정 -->
		<!-- => select 엘리먼트의 SELECT 명령으로 실행된 검색결과를 객체로 제공받아 포함 객체의 필드에 저장 -->
		<!-- column속성 : SELECT 명령으로 검색된 행의 컬럼명을 속성값으로 설정 -->
		<!-- => SELECT 명령으로 검색된 행의 컬럼값을 select 속성으로 설정된 select 엘리먼트의 parameterType 속성값으로 전달하여 SQL 명령에서 사용 -->
	  
		<!-- => 전달해서 select명령 실행해! 그리고 user필드에 저장해!-->
		<!-- => user필드에는 MyUser객체가 저장됨-->
		<association property="user" select="selectMyUser" column="reply_id"/>
      
	</resultMap>
	
	<!-- association 엘리먼트에서만 사용하기 위한 SELECT 명령 등록 -->
	<!-- => 주의) parameterType 속성으로 전달받은 값으로 단일행이 검색되도록 SELECT 명령 작성 -->
	<!-- => DAO 클래스의 메소드에서 사용될 SQL 명령이 아니므로 인터페이스 기반의 매퍼 파일에서 추상메소드를 미선언함 -->

	<!-- select 명령이 실행되면 검색행이 myuser객체로 만들어줌 -->
	<select id="selectMyUser" parameterType="string" resultType="MyUser">
		select * from myuser where user_id=#{userId} <!-- 단일행만 검색되도록, 다중행은 안됨 -->
	</select>

• selectReplyUserList2

	<!-- 테이블 조인을 사용하지 않고 resultMap 엘리먼트의 매핑정보를 제공받아 2개 이상의 테이블의 컬럼값을 검색하여 Java 객체로 제공 가능 -->
	<select id="selectReplyUserList2" resultMap="MyReplyUserResultMap2">
		select * from myreply order by reply_no desc
	</select>

</mapper>

4)[Mapper바인딩] MyReplyMapper.java

package xyz.itwill.mapper;

import java.util.List;

import xyz.itwill.dto.MyReply;
import xyz.itwill.dto.MyReplyUser;

public interface MyReplyMapper {
	int insertReply(MyReply reply);
	List<MyReply> selectReplyList();
	List<MyReply> selectCountReplyList();
	List<MyReplyUser> selectReplyUserList1();
	List<MyReplyUser> selectReplyUserList2();
}

 

 

03. SQL문

 select comment_no, comment_id, comment_content, comment_date, user_id, user_name,
		reply_no, reply_id, reply_content, reply_date, reply_comment_no, reply_user_id, reply_user_name
		from mycomment join myuser on comment_id=user_id left join
		(select reply_no, reply_id, reply_content, reply_date, reply_comment_no, user_id reply_user_id, user_name reply_user_name
		from myreply join myuser on reply_id=user_id) on comment_no=reply_comment_no
		where comment_no=1 order by reply_no desc;

1) STEP1 (1:1 관계의 조인)

• mycomment join myuser on comment_id = user_id

 select comment_no, comment_id, comment_content, comment_date,
 		user_id, user_name
        from mycomment join myuser on comment_id=user_id;

2) STEP2 (1:1 관계의 조인)

• myreply join myuser on reply_id = user_id

select reply_no, reply_id, reply_content, reply_date, reply_comment_no,
	   user_id reply_user_id, user_name reply_user_name
	   from myreply join myuser on reply_id=user_id

 

3) STEP3 (1:N 관계의 조인)

• mycomment join myuser join myreply join myuser on comment_no = reply_comment_no

select comment_no, comment_id, comment_content, comment_date,
		user_id, user_name,
		reply_no, reply_id, reply_content, reply_date, reply_comment_no,
        reply_user_id, reply_user_name
		from mycomment join myuser on comment_id=user_id
        left join
		(select reply_no, reply_id, reply_content, reply_date, reply_comment_no, user_id reply_user_id, user_name reply_user_name
		from myreply join myuser on reply_id=user_id)
        on comment_no=reply_comment_no
		where comment_no=1 order by reply_no desc;

 

 

 

 

04. DAO

1) MyCommentDAO.java

package xyz.itwill.dao;

import java.util.List;

import org.apache.ibatis.session.SqlSession;

import xyz.itwill.dto.MyComment1;
import xyz.itwill.dto.MyComment2;
import xyz.itwill.dto.MyComment3;
import xyz.itwill.mapper.MyCommentMapper;

public class MyCommentDAO extends AbstractSession{
	private static MyCommentDAO _dao;

	private MyCommentDAO() {
		// TODO Auto-generated constructor stub
	}

	static {
		_dao = new MyCommentDAO();
	}

	public static MyCommentDAO getDAO() {
		return _dao;
	}

    //💙insertComment1
	public int insertComment1(MyComment1 commment) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyCommentMapper.class).insertComment1(commment);
		} finally {
			sqlSession.close();
		}
	}
    //💙insertComment2
	public int insertComment2(MyComment1 commment) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyCommentMapper.class).insertComment2(commment);
		} finally {
			sqlSession.close();
		}
	}
    //💙selectCommentList1
	public List<MyComment1> selectCommentList1() {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyCommentMapper.class).selectCommentList1();
		} finally {
			sqlSession.close();
		}
	}
    //💙selectCommentList2
	public List<MyComment2> selectCommentList2() {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyCommentMapper.class).selectCommentList2();
		} finally {
			sqlSession.close();
		}
	}
    //💙selectCommentList3
	public List<MyComment3> selectCommentList3() {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyCommentMapper.class).selectCommentList3();
		} finally {
			sqlSession.close();
		}
	}

	//💜selectCommentUserList1
	public List<MyCommentUser1> selectCommentUserList1() {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyCommentMapper.class).selectCommentUserList1();
		} finally {
			sqlSession.close();
		}
	}
	//💜selectCommentUserList2
	public List<MyCommentUser2> selectCommentUserList2() {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyCommentMapper.class).selectCommentUserList2();
		} finally {
			sqlSession.close();
		}
	}

	//💙MyComment1 + 🤎MyReply : 메소드 2개 만들어 각각 호출
    
	//selectComment
	public MyComment1 selectComment(int commentNo) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyCommentMapper.class).selectComment(commentNo);
		} finally {
			sqlSession.close();
		}
	}
	//selectCommentNoReplyList
	public List<MyReply> selectCommentNoReplyList(int replyCommentNo) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyCommentMapper.class).selectCommentNoReplyList(replyCommentNo);
		} finally {
			sqlSession.close();
		}
	}

	//🤍MyCommentReply : 2개 조인한 메소드 - 조인했기 때문에 메소드 1개 만들어 호출
	public MyCommentReply selectCommentReply(int commentNo) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyCommentMapper.class).selectCommentReply(commentNo);
		} finally {
			sqlSession.close();
		}
	}

	//🤍MyCommentReplyUser  : 3개 조인한 메소드
    public MyCommentReplyUser selectCommentReplyUser(int commentNo) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyCommentMapper.class).selectCommentReplyUser(commentNo);
		} finally {
			sqlSession.close();
		}
	}
}

2) MyReplyDAO.java

package xyz.itwill.dao;

import java.util.List;

import org.apache.ibatis.session.SqlSession;

import xyz.itwill.dto.MyReply;
import xyz.itwill.dto.MyReplyUser;
import xyz.itwill.mapper.MyReplyMapper;

public class MyReplyDAO extends AbstractSession{
	private static MyReplyDAO _dao;

	private MyReplyDAO() {
		// TODO Auto-generated constructor stub
	}

	static {
		_dao = new MyReplyDAO();
	}
	public static MyReplyDAO getDAO() {
		return _dao;
	}

    //🤎insertReply
    public int insertReply(MyReply reply) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyReplyMapper.class).insertReply(reply);
		} finally {
			sqlSession.close();
		}
	}
	//🤎selectReplyList
	public List<MyReply> selectReplyList() {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyReplyMapper.class).selectReplyList();
		} finally {
			sqlSession.close();
		}
	}
    //🤎selectCountReplyList
	public List<MyReply> selectCountReplyList() {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyReplyMapper.class).selectCountReplyList();
		} finally {
			sqlSession.close();
		}
	}

	//🤎selectReplyUserList1
	public List<MyReplyUser> selectReplyUserList1() {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyReplyMapper.class).selectReplyUserList1();
		} finally {
			sqlSession.close();
		}
	}
    //🤎selectReplyUserList2
	public List<MyReplyUser> selectReplyUserList2() {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyReplyMapper.class).selectReplyUserList2();
		} finally {
			sqlSession.close();
		}
	}
}

 

 

 

05. 실행할JSP

1) [테스트 프로그램] 💙commentInsert1.jsp - comment1 삽입

테스트 프로그램 대체

<%
	MyComment1 comment1 = new MyComment1();
	comment1.setCommentId("aaa");
	comment1.setCommentContent("첫번째 게시글입니다.");
	MyCommentDAO.getDAO().insertComment1(comment1);

	MyComment1 comment2 = new MyComment1();
	comment2.setCommentId("xyz");
	comment2.setCommentContent("두번째 게시글입니다.");
	MyCommentDAO.getDAO().insertComment1(comment2);
%>

2) [테스트 프로그램] 💙commentInsert2.jsp - comment1 삽입

테스트 프로그램 대체

<%
	MyComment1 comment3 = new MyComment1();
	comment3.setCommentId("opq");
	comment3.setCommentContent("세번째 게시글입니다.");
	MyCommentDAO.getDAO().insertComment2(comment3);

	MyComment1 comment4 = new MyComment1();
	comment4.setCommentId("aaa");
	comment4.setCommentContent("네번째 게시글입니다.");
	MyCommentDAO.getDAO().insertComment2(comment4);
%>

3) 💙commentListSelect1.jsp - comment1 출력

<%@page import="xyz.itwill.dao.MyCommentDAO"%>
<%@page import="xyz.itwill.dto.MyComment1"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<%
	List<MyComment1> commentList=MyCommentDAO.getDAO().selectCommentList1();
%>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
<style type="text/css">
table {
	border: 1px solid black;
	border-collapse: collapse;
}
td {
	border: 1px solid black;
	text-align: center;
	padding: 3px;
}
.no { width: 100px; }
.name { width: 150px; }
.content { width: 250px; }
.date { width: 200px; }
</style>
</head>
<body>
	<h1>게시글 목록</h1>
	<hr>
	<table>
		<tr>
			<td class="no">게시글번호</td>
			<td class="name">게시글작성자</td>
			<td class="content">게시글내용</td>
			<td class="date">게시글작성일</td>
		</tr>
		<% for(MyComment1 comment:commentList) { %>
		<tr>
			<td><%=comment.getCommentNo() %></td>
			<td><%=comment.getCommentId() %></td>
			<td><%=comment.getCommentContent() %></td>
			<td><%=comment.getCommentDate() %></td>
		</tr>
		<% } %>
	</table>
</body>
</html>

 

4) 💙commentListSelect2.jsp - comment2 출력

<%@page import="xyz.itwill.dto.MyComment2"%>
<%@page import="java.util.List"%>
<%@page import="xyz.itwill.dao.MyCommentDAO"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<%
	List<MyComment2> commentList=MyCommentDAO.getDAO().selectCommentList2();
%>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
<style type="text/css">
table {
	border: 1px solid black;
	border-collapse: collapse;
}
td {
	border: 1px solid black;
	text-align: center;
	padding: 3px;
}
.no { width: 100px; }
.name { width: 150px; }
.content { width: 250px; }
.date { width: 200px; }
</style>
</head>
<body>
	<h1>게시글 목록</h1>
	<hr>
	<table>
		<tr>
			<td class="no">게시글번호</td>
			<td class="name">게시글작성자</td>
			<td class="content">게시글내용</td>
			<td class="date">게시글작성일</td>
		</tr>
		<% for(MyComment2 comment:commentList) { %>
		<tr>
			<td><%=comment.getNo() %></td>
			<td><%=comment.getId() %></td>
			<td><%=comment.getContent() %></td>
			<td><%=comment.getDate() %></td>
		</tr>
		<% } %>
	</table>
</body>
</html>

5) 💙commentListSelect3.jsp - comment3 출력

<%@page import="xyz.itwill.dto.MyComment3"%>
<%@page import="java.util.List"%>
<%@page import="xyz.itwill.dao.MyCommentDAO"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<%
	List<MyComment3> commentList=MyCommentDAO.getDAO().selectCommentList3();
%>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
<style type="text/css">
table {
	border: 1px solid black;
	border-collapse: collapse;
}
td {
	border: 1px solid black;
	text-align: center;
	padding: 3px;
}
.no { width: 100px; }
.name { width: 150px; }
.content { width: 250px; }
.date { width: 200px; }
</style>
</head>
<body>
	<h1>게시글 목록</h1>
	<hr>
	<table>
		<tr>
			<td class="no">게시글번호</td>
			<td class="name">게시글작성자</td>
			<td class="content">게시글내용</td>
			<td class="date">게시글작성일</td>
		</tr>
		<% for(MyComment3 comment:commentList) { %>
		<tr>
			<td><%=comment.getNo() %></td>
			<td><%=comment.getName() %> (<%=comment.getId() %>)</td>
			<td><%=comment.getContent() %></td>
			<td><%=comment.getDate() %></td>
		</tr>
		<% } %>
	</table>
</body>
</html>

6) 💜commentUserListSelect1.jsp - MyCommentUser1 출력

<%@page import="xyz.itwill.dto.MyCommentUser1"%>
<%@page import="xyz.itwill.dto.MyComment3"%>
<%@page import="java.util.List"%>
<%@page import="xyz.itwill.dao.MyCommentDAO"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<%
	List<MyCommentUser1> commentUserList=MyCommentDAO.getDAO().selectCommentUserList1();
%>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
<style type="text/css">
table {
	border: 1px solid black;
	border-collapse: collapse;
}
td {
	border: 1px solid black;
	text-align: center;
	padding: 3px;
}
.no { width: 100px; }
.name { width: 150px; }
.content { width: 250px; }
.date { width: 200px; }
</style>
</head>
<body>
	<h1>게시글 목록</h1>
	<hr>
	<table>
		<tr>
			<td class="no">게시글번호</td>
			<td class="name">게시글작성자</td>
			<td class="content">게시글내용</td>
			<td class="date">게시글작성일</td>
		</tr>
		<% for(MyCommentUser1 commentUser :commentUserList) { %>
		<tr>
			<td><%=commentUser.getCommentNo() %></td>
			<!-- <td><%=commentUser.getUserName() %> (<%=commentUser.getCommentId() %>)</td> -->
			<td><%=commentUser.getUserName() %> (<%=commentUser.getUserId() %>)</td>
			<td><%=commentUser.getCommentContent() %></td>
			<td><%=commentUser.getCommentDate() %></td>
		</tr>
		<% } %>
	</table>
</body>
</html>

7) 💜commentUserListSelect2.jsp - MyCommentUser2 출력

a태그로 링크 만들기

<%@page import="xyz.itwill.dao.MyCommentDAO"%>
<%@page import="xyz.itwill.dto.MyCommentUser2"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<%
	List<MyCommentUser2> commentUserList=MyCommentDAO.getDAO().selectCommentUserList2();
%>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
<style type="text/css">
table {
	border: 1px solid black;
	border-collapse: collapse;
}
td {
	border: 1px solid black;
	text-align: center;
	padding: 3px;
}
.no { width: 100px; }
.name { width: 150px; }
.content { width: 250px; }
.date { width: 200px; }
</style>
</head>
<body>
	<h1>게시글 목록</h1>
	<hr>
	<table>
		<tr>
			<td class="no">게시글번호</td>
			<td class="name">게시글작성자</td>
			<td class="content">게시글내용</td>
			<td class="date">게시글작성일</td>
		</tr>
		<% for(MyCommentUser2 commentUser :commentUserList) { %>
		<tr>
			<td><%=commentUser.getComment().getCommentNo() %></td>
			//<%-- <td><%=commentUser.getUser().getUserName() %> (<%=commentUser.getComment().getCommentId() %>)</td> --%>
			<td><%=commentUser.getUser().getUserName() %> (<%=commentUser.getUser().getUserId() %>)</td>
			//<%-- <td><%=commentUser.getComment().getCommentContent() %></td> --%>
			<td>
				//<%--<%=commentUser.getComment().getCommentContent() %>--%>
				//<%--<a href="commentReplySelect1.jsp?commentNo=<%=commentUser.getComment().getCommentNo()%>"><%=commentUser.getComment().getCommentContent() %></a> --%>
				//<%--<a href="commentReplySelect2.jsp?commentNo=<%=commentUser.getComment().getCommentNo()%>"><%=commentUser.getComment().getCommentContent() %></a> --%>
				<a href="commentReplyUserSelect.jsp?commentNo=<%=commentUser.getComment().getCommentNo()%>"><%=commentUser.getComment().getCommentContent() %></a>
		    </td>
			<td><%=commentUser.getComment().getCommentDate() %></td>
		</tr>
		<% } %>
	</table>
</body>
</html>

8) [테스트 프로그램] 🤎ReplyInsert.jsp - MyReply 삽입 

<%@page import="xyz.itwill.dao.MyReplyDAO"%>
<%@page import="xyz.itwill.dto.MyReply"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

//<%-- 원래는 테스트 프로그램으로 만들어 테스트하는 것이지만, 아직 배우지 않았으니 우리는 JSP로 만들어서 사용 --%>
//<%-- 잘못된 결과가 나올 경우
//     drop sequence myreply_seq;
//     create sequence myreply_seq;
//     truncate table myreply;
//     후 JSP문서 재실행
//--%>

<%
	//첫번째 게시글에 대한 댓글 삽입 - 3개
	MyReply reply1 = new MyReply();
	reply1.setReplyCommentNo(1);
	reply1.setReplyId("xyz");
	reply1.setReplyContent("첫번째 게시글에 대한 댓글-1");
	MyReplyDAO.getDAO().insertReply(reply1);

	MyReply reply2 = new MyReply();
	reply2.setReplyCommentNo(1);
	reply2.setReplyId("opq");
	reply2.setReplyContent("첫번째 게시글에 대한 댓글-2");
	MyReplyDAO.getDAO().insertReply(reply2);

	MyReply reply3 = new MyReply();
	reply3.setReplyCommentNo(1);
	reply3.setReplyId("xyz");
	reply3.setReplyContent("첫번째 게시글에 대한 댓글-3");
	MyReplyDAO.getDAO().insertReply(reply3);

	//두번째 게시글에 대한 댓글 삽입 - 0개

	//세번째 게시글에 대한 댓글 삽입 - 1개
	MyReply reply4 = new MyReply();
	reply4.setReplyCommentNo(3);
	reply4.setReplyId("xyz");
	reply4.setReplyContent("세번째 게시글에 대한 댓글-1");
	MyReplyDAO.getDAO().insertReply(reply4);

	//네번째 게시글에 대한 댓글 삽입 - 2개
	MyReply reply5 = new MyReply();
	reply5.setReplyCommentNo(4);
	reply5.setReplyId("xyz");
	reply5.setReplyContent("네번째 게시글에 대한 댓글-1");
	MyReplyDAO.getDAO().insertReply(reply5);

	MyReply reply6 = new MyReply();
	reply6.setReplyCommentNo(4);
	reply6.setReplyId("opq");
	reply6.setReplyContent("네번째 게시글에 대한 댓글-2");
	MyReplyDAO.getDAO().insertReply(reply6);
%>

9) 🤎replyListSelect.jsp - MyReply 전체 출력

<%@page import="xyz.itwill.dao.MyReplyDAO"%>
<%@page import="xyz.itwill.dto.MyReply"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<%
	List<MyReply> replyList = MyReplyDAO.getDAO().selectReplyList();
%>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
<style type="text/css">
table {
	border: 1px solid black;
	border-collapse: collapse;
}
td {
	border: 1px solid black;
	text-align: center;
	padding: 3px;
}
.no { width: 100px; }
.name { width: 150px; }
.content { width: 250px; }
.date { width: 200px; }
.comment{ width: 100px; }
</style>
</head>
<body>
	<h1>댓글목록</h1>
	<hr>
	<table>
		<tr>
			<td class="no">댓글번호</td>
			<td class="name">댓글작성자</td>
			<td class="content">댓글내용</td>
			<td class="date">댓글작성일</td>
			<td class="comment">게시글번호</td>
		</tr>
		<% for(MyReply reply:replyList) { %>
		<tr>
			<td><%=reply.getReplyNo() %></td>
			<td><%=reply.getReplyId() %></td>
			<td><%=reply.getReplyContent() %></td>
			<td><%=reply.getReplyDate() %></td>
			<td><%=reply.getReplyCommentNo() %></td>
		</tr>
		<% } %>
	</table>
</body>
</html>

10) 🤎replyCountListSelect.jsp - MyReply 최신글 5개만 출력

<%@page import="xyz.itwill.dao.MyReplyDAO"%>
<%@page import="xyz.itwill.dto.MyReply"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<%
	List<MyReply> replyList = MyReplyDAO.getDAO().selectCountReplyList();
%>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
<style type="text/css">
table {
	border: 1px solid black;
	border-collapse: collapse;
}
td {
	border: 1px solid black;
	text-align: center;
	padding: 3px;
}
.no { width: 100px; }
.name { width: 150px; }
.content { width: 250px; }
.date { width: 200px; }
.comment{ width: 100px; }
</style>
</head>
<body>
	<h1>댓글목록</h1>
	<hr>
	<table>
		<tr>
			<td class="no">댓글번호</td>
			<td class="name">댓글작성자</td>
			<td class="content">댓글내용</td>
			<td class="date">댓글작성일</td>
			<td class="comment">게시글번호</td>
		</tr>
		<% for(MyReply reply:replyList) { %>
		<tr>
			<td><%=reply.getReplyNo() %></td>
			<td><%=reply.getReplyId() %></td>
			<td><%=reply.getReplyContent() %></td>
			<td><%=reply.getReplyDate() %></td>
			<td><%=reply.getReplyCommentNo() %></td>
		</tr>
		<% } %>
	</table>
</body>
</html>

11) 🤎replyUserListSelect1.jsp - MyReplyUser 출력

<%@page import="xyz.itwill.dao.MyReplyDAO"%>
<%@page import="xyz.itwill.dto.MyReplyUser"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<%
	List<MyReplyUser> replyUserList = MyReplyDAO.getDAO().selectReplyUserList();
%>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
<style type="text/css">
table {
	border: 1px solid black;
	border-collapse: collapse;
}
td {
	border: 1px solid black;
	text-align: center;
	padding: 3px;
}
.no { width: 100px; }
.name { width: 150px; }
.content { width: 250px; }
.date { width: 200px; }
.comment{ width: 100px; }
</style>
</head>
<body>
	<h1>댓글목록</h1>
	<hr>
	<table>
		<tr>
			<td class="no">댓글번호</td>
			<td class="name">댓글작성자</td>
			<td class="content">댓글내용</td>
			<td class="date">댓글작성일</td>
			<td class="comment">게시글번호</td>
		</tr>
		<% for(MyReplyUser replyUser:replyUserList) { %>
		<tr>
			<td><%=replyUser.getReply().getReplyNo() %></td>
            <!-- <td><%=replyUser.getUser().getUserName() %> (<%=replyUser.getReply().getReplyId() %>)</td>-->
			<td><%=replyUser.getUser().getUserName() %> (<%=replyUser.getUser().getUserId() %>)</td>
			<td><%=replyUser.getReply().getReplyContent() %></td>
			<td><%=replyUser.getReply().getReplyDate() %></td>
			<td><%=replyUser.getReply().getReplyCommentNo() %></td>
		</tr>
		<% } %>
	</table>
</body>
</html>

12) 🤎replyUserListSelect2.jsp - MyReplyUser 출력

<%@page import="xyz.itwill.dao.MyReplyDAO"%>
<%@page import="xyz.itwill.dto.MyReplyUser"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<%
	List<MyReplyUser> replyUserList = MyReplyDAO.getDAO().selectReplyUserList2();
%>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
<style type="text/css">
table {
	border: 1px solid black;
	border-collapse: collapse;
}
td {
	border: 1px solid black;
	text-align: center;
	padding: 3px;
}
.no { width: 100px; }
.name { width: 150px; }
.content { width: 250px; }
.date { width: 200px; }
.comment{ width: 100px; }
</style>
</head>
<body>
	<h1>댓글목록</h1>
	<hr>
	<table>
		<tr>
			<td class="no">댓글번호</td>
			<td class="name">댓글작성자</td>
			<td class="content">댓글내용</td>
			<td class="date">댓글작성일</td>
			<td class="comment">게시글번호</td>
		</tr>
		<% for(MyReplyUser replyUser:replyUserList) { %>
		<tr>
			<td><%=replyUser.getReply().getReplyNo() %></td>
			<!-- <td><%=replyUser.getUser().getUserName() %> (<%=replyUser.getReply().getReplyId() %>)</td>-->
			<td><%=replyUser.getUser().getUserName() %> (<%=replyUser.getUser().getUserId() %>)</td>
			<td><%=replyUser.getReply().getReplyContent() %></td>
			<td><%=replyUser.getReply().getReplyDate() %></td>
			<td><%=replyUser.getReply().getReplyCommentNo() %></td>
		</tr>
		<% } %>
	</table>
</body>
</html>

13) 😋commentReplySelect1.jsp - 💙MyComment1 + 🤎MyReply 출력

<%@page import="xyz.itwill.dto.MyReply"%>
<%@page import="java.util.List"%>
<%@page import="xyz.itwill.dao.MyCommentDAO"%>
<%@page import="xyz.itwill.dto.MyComment1"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<%
	if(request.getParameter("commentNo")==null){
		response.sendRedirect("commentUserListSelect2.jsp");
		return;
	}

	//전달값(게시글번호)을 반환받아 저장
	int commentNo = Integer.parseInt(request.getParameter("commentNo"));

	//전달받은 게시글번호에 대한 게시글(1개)을 검색하여 반환하는 DAO클래스의 메소드 호출
	MyComment1 comment = MyCommentDAO.getDAO().selectComment(commentNo);

	//전달받은 게시글번호에 대한 댓글(0개 이상)을 검색하여 반환하는 DAO클래스의 메소드 호출
	List<MyReply> replyList = MyCommentDAO.getDAO().selectCommentNoReplyList(commentNo);
%>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
<style type="text/css">
table{
	border: 1px solid black;
	border-collapse: collapse;
}
td{
	border: 1px solid black;
	text-align: center;
	padding: 3px;
}
.no{width: 100px;}
.name{width: 150px;}
.content{width: 250px;}
.date{width: 200px;}
.comment{width: 100px;}
</style>
</head>
<body>
	<h1>게시글과 댓글목록</h1>
	<hr />
	<table>
		<tr>
			<td width="200">게시글번호</td>
			<td width="200"><%=comment.getCommentNo() %></td>
		</tr>
		<tr>
			<td width="200">게시글 작성자</td>
			<td width="200"><%=comment.getCommentId() %></td>
		</tr>
		<tr>
			<td width="200">게시글 내용</td>
			<td width="200"><%=comment.getCommentContent() %></td>
		</tr>
		<tr>
			<td width="200">게시글 작성일</td>
			<td width="200"><%=comment.getCommentDate() %></td>
		</tr>
	</table>
	<br />

	//<%--댓글목록 출력 --%>
	<table>
		<tr>
			<td class="no">댓글번호</td>
			<td class="name">댓글작성자</td>
			<td class="content">댓글내용</td>
			<td class="date">댓글작성일</td>
			<td class="comment">게시글번호</td>
		</tr>

		<%if(replyList.isEmpty()) {%>
			<tr>
				<td colspan="5">댓글이 존재하지 않습니다.</td>
			</tr>
		<%} else {%>
		<tr>
			<%for(MyReply reply:replyList){ %>
			<tr>
				<td><%=reply.getReplyNo() %></td>
				<td><%=reply.getReplyId() %></td>
				<td><%=reply.getReplyContent() %></td>
				<td><%=reply.getReplyDate() %></td>
				<td><%=reply.getReplyCommentNo() %></td>
			</tr>
			<%} %>
		</tr>
		<%} %>
	</table>

</body>
</html>

14) 😋commentReplySelect2.jsp - 🤍MyCommentReply 출력

2개 조인한 객체

<%@page import="xyz.itwill.dto.MyCommentReply"%>
<%@page import="xyz.itwill.dto.MyReply"%>
<%@page import="java.util.List"%>
<%@page import="xyz.itwill.dao.MyCommentDAO"%>
<%@page import="xyz.itwill.dto.MyComment1"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<%
	if(request.getParameter("commentNo")==null){
		response.sendRedirect("commentUserListSelect2.jsp");
		return;
	}

	//전달값(게시글번호)을 반환받아 저장
	int commentNo = Integer.parseInt(request.getParameter("commentNo"));

	//전달받은 게시글번호에 대한 게시글(1개)과 댓글목록(0개 이상)을 검색하여 반환하는 DAO클래스의 메소드 호출
	MyCommentReply CommentReply = MyCommentDAO.getDAO().selectCommentReply(commentNo);
%>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
<style type="text/css">
table{
	border: 1px solid black;
	border-collapse: collapse;
}
td{
	border: 1px solid black;
	text-align: center;
	padding: 3px;
}
.no{width: 100px;}
.name{width: 150px;}
.content{width: 250px;}
.date{width: 200px;}
.comment{width: 100px;}
</style>
</head>
<body>
	<h1>게시글과 댓글목록</h1>
	<hr />
	<table>
		<tr>
			<td width="200">게시글번호</td>
			<td width="200"><%=CommentReply.getComment().getCommentNo() %></td>
		</tr>
		<tr>
			<td width="200">게시글 작성자</td>
			<td width="200"><%=CommentReply.getComment().getCommentId() %></td>
		</tr>
		<tr>
			<td width="200">게시글 내용</td>
			<td width="200"><%=CommentReply.getComment().getCommentContent() %></td>
		</tr>
		<tr>
			<td width="200">게시글 작성일</td>
			<td width="200"><%=CommentReply.getComment().getCommentDate() %></td>
		</tr>
	</table>
	<br />

	<!--댓글목록 출력 -->
	<table>
		<tr>
			<td class="no">댓글번호</td>
			<td class="name">댓글작성자</td>
			<td class="content">댓글내용</td>
			<td class="date">댓글작성일</td>
			<td class="comment">게시글번호</td>
		</tr>

		<%if(CommentReply.getReplyList().isEmpty()) {%>
			<tr>
				<td colspan="5">댓글이 존재하지 않습니다.</td>
			</tr>
		<%} else {%>
		<tr>
			<%for(MyReply reply:CommentReply.getReplyList()){ %>
			<tr>
				<td><%=reply.getReplyNo() %></td>
				<td><%=reply.getReplyId() %></td>
				<td><%=reply.getReplyContent() %></td>
				<td><%=reply.getReplyDate() %></td>
				<td><%=reply.getReplyCommentNo() %></td>
			</tr>
			<%} %>
		</tr>
		<%} %>
	</table>

</body>
</html>

15) 😋commentReplyUserSelect.jsp - 🤍commentReplyUser출력

3개 조인한 객체

<%@page import="xyz.itwill.dto.MyReplyUser"%>
<%@page import="xyz.itwill.dao.MyCommentDAO"%>
<%@page import="xyz.itwill.dto.MyCommentReplyUser"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<%
	if(request.getParameter("commentNo")==null){
		response.sendRedirect("commentUserListSelect2.jsp");
		return;
	}

	//전달값(게시글번호)을 반환받아 저장
	int commentNo = Integer.parseInt(request.getParameter("commentNo"));

	//전달받은 게시글번호에 대한 게시글(1개)과 댓글목록(0개 이상)을 검색하여 반환하는 DAO클래스의 메소드 호출
	MyCommentReplyUser commentReplyUser = MyCommentDAO.getDAO().selectCommentReplyUser(commentNo);
%>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
<style type="text/css">
table{
	border: 1px solid black;
	border-collapse: collapse;
}
td{
	border: 1px solid black;
	text-align: center;
	padding: 3px;
}
.no{width: 100px;}
.name{width: 150px;}
.content{width: 250px;}
.date{width: 200px;}
.comment{width: 100px;}
</style>
</head>
<body>
	<h1>게시글과 댓글목록</h1>
	<hr />
	<table>
		<tr>
			<td width="200">게시글번호</td>
			<td width="200"><%=commentReplyUser.getCommentNo() %></td>
		</tr>
		<tr>
			<td width="200">게시글 작성자</td>
			<td width="200"><%=commentReplyUser.getUser().getUserName() %>(<%=commentReplyUser.getUser().getUserId() %>)</td>
		</tr>
		<tr>
			<td width="200">게시글 내용</td>
			<td width="200"><%=commentReplyUser.getCommentContent() %></td>
		</tr>
		<tr>
			<td width="200">게시글 작성일</td>
			<td width="200"><%=commentReplyUser.getCommentDate() %></td>
		</tr>
	</table>
	<br />

	<!--댓글목록 출력 -->
	<table>
		<tr>
			<td class="no">댓글번호</td>
			<td class="name">댓글작성자</td>
			<td class="content">댓글내용</td>
			<td class="date">댓글작성일</td>
			<td class="comment">게시글번호</td>
		</tr>

		<%if(commentReplyUser.getReplyUserList()==null ||commentReplyUser.getReplyUserList().isEmpty()) {%>
			<tr>
				<td colspan="5">댓글이 존재하지 않습니다.</td>
			</tr>
		<%} else {%>
		<tr>
			<%for(MyReplyUser replyUser:commentReplyUser.getReplyUserList()){ %>
			<tr>
				<td><%=replyUser.getReply().getReplyNo() %></td>
				<td><%=replyUser.getUser().getUserId() %>(<%=replyUser.getUser().getUserName() %>)</td>
				<td><%=replyUser.getReply().getReplyContent() %></td>
				<td><%=replyUser.getReply().getReplyDate() %></td>
				<td><%=replyUser.getReply().getReplyCommentNo() %></td>
			</tr>
			<%} %>
		</tr>
		<%} %>
	</table>

</body>
</html>