[mybatis] 9. XML+INTERFACE 매퍼(매퍼바인딩) 3 (MYHEWON)

01. DTO

1) MyHewon.java

package xyz.itwill.dto;
/*
MYHEWON 테이블 : 회원정보를 저장하기 위한 테이블
create table myhewon(hewon_id varchar2(50) primary key, hewon_name varchar2(50)
	, hewon_phone varchar2(20), hewon_email varchar2(100), hewon_state number(1));

이름          널?       유형
----------- -------- -------------
HEWON_ID    NOT NULL VARCHAR2(50)  - 회원 아이디
HEWON_NAME           VARCHAR2(50)  - 회원 이름
HEWON_PHONE          VARCHAR2(20)  - 회원 전화번호
HEWON_EMAIL          VARCHAR2(100) - 회원 이메일
HEWON_STATE          NUMBER(1)     - 회원 공개여부

공개여부 : 1(아이디) 2(아이디&이름) 3(아이디&이름&전화번호) 4(아이디&이름&전화번호&이메일)
*/

public class MyHewon {
	private String id;
	private String name;
	private String phone;
	private String email;
	private int state;
	public MyHewon() {
		// TODO Auto-generated constructor stub
	}
	public MyHewon(String id, String name, String phone, String email, int state) {
		super();
		this.id = id;
		this.name = name;
		this.phone = phone;
		this.email = email;
		this.state = state;
	}
	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 getPhone() {return phone;}
	public void setPhone(String phone) {this.phone = phone;}
	public String getEmail() {return email;}
	public void setEmail(String email) {this.email = email;}
	public int getState() {return state;}
	public void setState(int state) {this.state = state;}
}

 

 

 

02. Mapper바인딩

1) [Mapper바인딩] MyHewonMapper.xml

https://mybatis.org/dtd/mybatis-3-mapper.dtd>">

 

🍊회원삽입, 회원리스트출력

	<!-- 🍊insertHewon -->
	<insert id="insertHewon" parameterType="MyHewon">
		insert into myhewon values (#{id}, #{name}, #{phone}, #{email}, #{state})
	</insert>
    
	<!-- 🍊selectHewonList -->
	<!-- 모든 회원정보 검색 -->
	<!-- 클래스의 필드명과 테이블명이 다르므로 자동 매핑이 안됨 그래서 resultMap 이용함-->
	<resultMap type="MyHewon" id="myHewonResultMap">
		<id column="hewon_id" property="id"/>
		<result column="hewon_name" property="name"/>
		<result column="hewon_phone" property="phone"/>
		<result column="hewon_email" property="email"/>
		<result column="hewon_state" property="state"/>
	</resultMap>
	<select id="selectHewonList" resultMap="myHewonResultMap">
		select * from myhewon order by hewon_id
	</select>

 

🍋회원정보 검색 (공개범위에 따른 부분만)

	<!-- 🍋selectDiscriminatorHewonList : 공개범위에 따른 부분 회원정보 검색 -->

	<!-- [🍋resultMap 만드는 방법1] -->
	<!-- 검색된 회원정보에서 공개범위에 따라 다른 매핑정보를 제공하기 위한 resultMap 엘리먼트 -->
	<!--  discriminator : 검색행의 컬럼값을 비교하여 "서로 다른 매핑정보를 제공"하기 위한 엘리먼트 -->
	<!-- => 하위 엘리먼트로 case 엘리먼트를 사용하여 컬럼갑을 비교해 같은 경우 매핑정보 제공 :  일종의 자바의 switch~case문과 비슷 -->
	<!-- javaType 속성 : 검색행의 비교 컬럼값의 Java 자료형을 속성값으로 설정 -->
	<!-- => Java 자료형 대신 typeAlias 엘리먼트의 별칭 사용 가능 -->
	<!-- column 속성 : 검색행의 비교 컬럼명을 속성값으로 설정 -->
	<!--
	<resultMap type="MyHewon" id="myHewonDiscriminatorResultMap">
		<discriminator javaType="int" column="hewon_state">
			//hewon_state에 저장되는 int값이 1이라면
			<case value="1">
				<id column="hewon_id" property="id"/>
				<result column="hewon_state" property="state"/>
			</case>
			//hewon_state에 저장되는 int값이 2라면
			<case value="2">
				<id column="hewon_id" property="id"/>
				<result column="hewon_name" property="name"/>
				<result column="hewon_state" property="state"/>
			</case>
			<case value="3">
				<id column="hewon_id" property="id"/>
				<result column="hewon_name" property="name"/>
				<result column="hewon_phone" property="phone"/>
				<result column="hewon_state" property="state"/>
			</case>
			<case value="4">
				<id column="hewon_id" property="id"/>
				<result column="hewon_name" property="name"/>
				<result column="hewon_phone" property="phone"/>
				<result column="hewon_email" property="email"/>
				<result column="hewon_state" property="state"/>
			</case>
		</discriminator>
	</resultMap>
	-->




	<!-- [🍋resultMap 만드는 방법2] -->
	<!-- case 엘리먼트의 공통적인 매핑정보가 존재할 경우 discriminator 엘리먼트가 아닌 다른
	엘리먼트를 사용하여 매핑 정보 제공 가능 -->
	<!-- discriminator는 조건에 의한 매핑이라면,
		id와 result는 무조건적인 매핑이므로 방법1보다 효율적 -->
	<!--
	<resultMap type="MyHewon" id="myHewonDiscriminatorResultMap">
		<id column="hewon_id" property="id"/>
		<result column="hewon_state" property="state"/>
		<discriminator javaType="int" column="hewon_state">
			<case value="2">
				<result column="hewon_name" property="name"/>
			</case>
			<case value="3">
				<result column="hewon_name" property="name"/>
				<result column="hewon_phone" property="phone"/>
			</case>
			<case value="4">
				<result column="hewon_name" property="name"/>
				<result column="hewon_phone" property="phone"/>
				<result column="hewon_email" property="email"/>
			</case>
		</discriminator>
	</resultMap>
	 -->




	<!-- [🍋resultMap 만드는 방법3] -->	
	<!-- resultMap 엘리먼트는 아래처럼 상속도 가능하고, associtation 엘리먼트를 이용해 포함관계도 만들 수 있음 (앞부분 참고) -->
	 <resultMap type="MyHewon" id="myHewonOneResultMap">
	 	<id column="hewon_id" property="id"/>
		<result column="hewon_state" property="state"/>
	 </resultMap>

	 <!-- extends 속성 : resultMap 엘리먼트의 식별자를 속성값으로 설정 -->
	 <!-- => 다른 resultMap 엘리먼트의 매핑정보를 상속받아 사용하기 위한 속성 -->
	 <resultMap type="MyHewon" id="myHewonTwoResultMap" extends="myHewonOneResultMap">
		<result column="hewon_name" property="name"/>
	 </resultMap>

	 <resultMap type="MyHewon" id="myHewonThreeResultMap" extends="myHewonTwoResultMap">
		<result column="hewon_phone" property="phone"/>
	 </resultMap>

	 <resultMap type="MyHewon" id="myHewonFourResultMap" extends="myHewonThreeResultMap">
		<result column="hewon_email" property="email"/>
	 </resultMap>

	<resultMap type="MyHewon" id="myHewonDiscriminatorResultMap">
		<discriminator javaType="int" column="hewon_state">
			<!-- resultMap속성을 사용하여 다른 resultMap 엘리먼트의 매핑정보를 제공받아 사용 가능 -->
			<case value="1" resultMap="myHewonOneResultMap"/>
			<case value="2" resultMap="myHewonTwoResultMap"/>
			<case value="3" resultMap="myHewonThreeResultMap"/>
			<case value="4" resultMap="myHewonFourResultMap"/>
		</discriminator>
	</resultMap>

	<select id="selectDiscriminatorHewonList" resultMap="myHewonDiscriminatorResultMap">
		select * from myhewon order by hewon_id
	</select>

 

🥝selectStateHewonList()

	<!-- parameterType 속성 이용방법 -->
	<!-- 매퍼에 등록된 SQL 명령에 필요한 값을 전달하는 방법 -->
	<!-- => 전달값은 SQL 명령에서 #{변수명|필드명|맵키} 형식으로 표현하여 사용 -->

	<!-- 1. 🥝XML 기반의 매퍼 파일에서 SQL 명령이 등록된 엘리먼트의 parameterType 속성값으로
	Java 자료형(별칭)을 설정하여 값을 전달받아 사용 -->

	<!-- => 🥝단일값을 전달받기 위해
		parameterType 속성에 원시형(PrimitiveType 또는 Wrapper 클래스)
	 	또는 String 클래스를 속성값으로 설정 - SQL 명령에서는 #{변수명} 형식으로 전달값을 사용 -->

	<!-- => 🥝다수값을 전달받기 위해
		parameterType 속성에 JavaBean(DTO) 클래스를 속성값으로 설정
		- SQL 명령에서는 #{필드명} 형식으로 전달값(필드값)을 사용 -->

	<!-- => 🥝다수값을 전달받기 위해
		parameterType 속성에 HashMap(Map 인터페이스)를 속성값으로 설정
 		- SQL 명령에서는 #{맵키} 형식으로 전달값(맵값)을 사용 -->


	<!-- 2. 🍒인터페이스 기반의 매퍼 파일에서 추상 메소드의 매개변수에 @param 어노테이션을 설정하여 매개변수에 전달값을 SQL 명령에서 사용 -->
	<!-- => 바인딩된 XML 기반의 매퍼 파일의 엘리먼트에 등록된 SQL 명령에서도 사용 가능 -->
	<!-- => 단, 값을 인터페이스가 제공하므로 XML 기반의 매퍼 파일에 엘리먼트에서 parameterType 속성 무조건 생략 -->


	<!-- 🥝selectStateHewonList : 🥝parameterType = 단일값 -->
	<!-- 공개범위를 전달받아 MYHEWON 테이블에 저장된 해당 공개 범위의 회원정보를 검색하여 검색결과를 제공하는 엘리먼트 -->

	<!-- => 값을 하나만 전달받아 SQL 명령에서 사용할 경우 parameterType 속성값으로 원시형(Wrapper 클래스) 또는 String 클래스를 설정하고 SQL 명령에서 #{변수명} 형식으로 전달값 사용 -->
	<!-- => 변수명은 아무런 의미가 없으며 식별자 작성 규칙에 맞게 설정 -->

	<!--
	<select id="selectStateHewonList" parameterType="int" resultMap="myHewonResultMap">
		select * from myhewon where hewon_state=#{state} order by hewon_id
	</select>
	 -->

	 <!-- XML 기반의 매퍼파일만 설정한 경우 parameterType 속성값으로 원시형(Wrapper 클래스) 또는 String 클래스를 설정했을 때 parameterType 속성 생략 가능 -->
	 <!-- => Interface 기반의 매퍼 파일과 바인딩된 경우 전달값에 상관 없이 parameterType 속성을 "아래처럼 생략 가능"하지만 위에 처럼 "같이쓰는 것을 권장"-->
	<select id="selectStateHewonList" resultMap="myHewonResultMap">
		select * from myhewon where hewon_state=#{state} order by hewon_id
	</select>

 

🥝selectBeanHewonId(hewon)

	<!-- 🥝selectBeanHewonId : 🥝parameterType = 다수값 - JavaBean객체 이용 -->
	<!-- => 단, 반드시 해당하는 DTO 클래스가 있어야함 -->
	<!-- => DTO 클래스는 일반적으로 테이블의 컬럼값들을 표현하기 위해 만듦 -->
	<!-- => 즉, 테이블에 컬럼값들이 존재하면 DTO 클래스가 존재한다는 뜻 -->

	<!-- [이름]과 [이메일]을 전달받아 MYHEWON 테이블에 저장된 해당 이름과 이메일의 회원정보에 대한 아이디를 검색하여 제공하는 엘리먼트 -->
	<!-- => 값을 여러개 전달받아 SQL 명령에서 사용할 경우 parameterType 속성값으로 JavaBean (DTO) 클래스를 설정하여 JavaBean 객체를 전달받고 SQL 명령에서 #{필드명} 형식으로 필드값 사용 가능 -->

	<!-- 검색결과가 하나밖에 없으므로 무조건 자동매핑됨-->
	<!--
	<select id="selectBeanHewonId" parameterType="MyHewon" resultType="string">
		select hewon_id from myhewon where hewon_name=#{name} and hewon_email=#{email}
	</select>
	 -->

	<!-- => Interface 기반의 매퍼파일과 바인딩된 경우 전달값에 상관없이 parameterType 속성 생략 가능 (전달값이 하나든, 두개든.. 상관없이 안씀) -->
	<!-- => 실제 현업에서도 parameterType 잘 안씀 -->
	<select id="selectBeanHewonId"  resultType="string">
		select hewon_id from myhewon where hewon_name=#{name} and hewon_email=#{email}
	</select>

🥝selectMapHewonId(map)

	<!-- 🥝selectMapHewonId : 🥝parameterType = 다수값 - Map객체 이용-->
	<!-- => HashMap 클래스보다 Map 인터페이스로 참조변수를 만드는 것이 효율적, 그래야지 Map 인터페이스의 모든 자식객체 저장 가능하니 유지보수의 효율성 높임-->
	<!-- => 자바빈 클래스가 없을 경우 이용 많이함 -->
	<!-- [이름]과 [이메일]을 전달받아 MYHEWON 테이블에 저장된 해당 이름과 이메일의 회원정보에 대한 아이디를 검색하여 제공하는 엘리먼트 -->
	<!-- => 값을 여러개 전달받아 SQL 명령에서 사용할 경우 parameterType 속성값으로 HashMap 클래스 (Map 인터페이스)를 설정하여 Map 객체를 전달받아 SQL 명령에서 #{맵키} 형식으로 맵값 사용 가능 -->
	<select id="selectMapHewonId" parameterType="map" resultType="string">
		select hewon_id from myhewon where hewon_name=#{name} and hewon_email=#{email}
	</select>

 

🍈insertMapHewon(map)

	<!-- 🍈Map 객체의 다양한 이용법 -->
	<!-- 🍈insertMapHewon : parameterType에 Map객체 이용 -->
	<!-- map객체가 가진 map키에 해당하는 map값들을 전달할 것임 -->
	<!-- insert 엘리먼트에는 resultType 속성 사용 불가능 -->
	<insert id="insertMapHewon" parameterType="map">
		insert into myhewon values (#{id}, #{name}, #{phone}, #{email}, #{state})
	</insert>

 

🍈selectMapHewonList()

	<!-- 🍈selectMapHewonList : resultType에 Map객체 이용 -->
	<!-- select 엘리먼트의 resultType 속성값으로 HashMap 클래스(Map 인터페이스)로 설정하면
	검색행을 Map 객체로 제공 - 하나의 검색행을 Map 객체로 표현-->
	<!-- => 검색행의 컬럼명을 맵키로 매핑되고 컬럼값이 맵값으로 저장되어 엔트리로 추가 -->
	<!-- => 검색행의 컬럼명은 "대문자"로 검색되어 맵키로 매핑 처리 -->
	<!-- => 맵키명 : "HEWON_ID", "HEWON_NAME", "HEWON_PHONE", "HEWON_EMAIL", "HEWON_STATE"-->
	<select id="selectMapHewonList" resultType="map">
      	<!-- 회원정보 하나 = 맵객체의 하나로 만들어주세요 -->
		select * from myhewon order by hewon_id
	</select>

🍒selectParamHewonId(name, email)

<!-- 🍒추상메소드에서 전달된 값 가져다 쓰기-->
<!-- => 위에서는 parameterType에 전달된 값 사용했다면, 이번에는 추상메소드의 매개변수에 전달된 값 사용할 것임 -->
<!-- => 주의) parameterType 반드시 생략!! -->
<!-- mybatis만 만든다면 이 방법도 좋긴한데, 스프링을 사용한다면 스프링이 사용자 입력값을 자동으로 Map객체나 DTO객체를 만들어주기 때문에 굳이 xml파일과 인터페이스 파일 둘 다 설정하면서까지 사용하지는 않음 -->
<!-- 일반적으로 바인딩해서 사용하는 것은 XML이나 인터페이스 매퍼파일 둘 중 하나만 설정해 사용하는 것이 좋은데 이건 둘 다 설정해야함 -->

	<!-- 🍒selectParamHewonId -->
	<!-- [이름]과 [이메일]을 전달받아 MYHEWON 테이블에 저장된 해당 이름과 이메일의 회원정보에 대한 아이디를 검색하여 제공하는 엘리먼트 -->
	<!-- => 매퍼 바인딩 처리된 인터페이스 기반의 매퍼파일에서 추상메소드의 매개변수에 전달된 값을 @Param 어노테이션의 Value 속성값으로 제공받아 SQL 명령에서는 #{속성값}으로 전달값 사용 -->
	<!-- => parameterType 속성은 반드시 생략해야함 -->
	<select id="selectParamHewonId" resultType="string">
		select hewon_id from myhewon where hewon_name=#{name} and hewon_email=#{email}
	</select>

 

🍒selectSearchHewonList(map)

	<!-- 🍒selectSearchHewonList -->

	<!-- [🍒방법1 - 키워드가 반드시 일치해야 검색됨] -->
	<!-- 검색 컬럼명과 검색 단어를 전달받아 MYHEWON 테이블에 저장된 회원정보 중 검색 컬럼에
	검색 단어가 저장된 회원정보를 검색하여 검색결과를 제공하는 엘리먼트 -->
	<!-- 즉, 검색단어가 반드시 일치하지 않으면 검색이 안됨!! -->

	<!-- => 테이블을 표현된 것이 아니기 때문에, DTO클래스 만들지 않고
			Map객체를 이용하거나 Param어노테이션 이용함 -->
	<!-- => resultMap속성을 이용해 재사용할 것임 -->

	<!-- #{변수명|필드명|맵키} : '전달값' - 전달값이 SQL 명령에서 문자값으로 표현 -->
	<!-- ${변수명|필드명|맵키} : 전달값 - 전달값이 SQL 명령에서 문장으로 표현 -->
	<!-- ibatis 프레임워크에서는 $변수명|필드명|맵키$ 형식으로 표현 -->
	<!-- => $ 표현식은 InSQL 공격에 취약하므로 사용하는 것을 비권장하지만,
			여기서는 사용자 입력값을 직접 받는 것이 아닌
			option 중 하나를 선택하는 것이므로 $ 표현식을 사용함 -->
	<!--
	<select id="selectSearchHewonList" parameterType="map" resultMap="myHewonResultMap">
		select * from myhewon where ${searchColumn}=#{searchKeyword} order by hewon_id
	</select>
	 -->



	<!-- [🍒방법2 - 키워드가 포함되면 검색됨] -->
	<!-- => '%'||#{searchKeyword}||'%' : searchKeyword가 포함되는 -->
  	<!-- => '%'||#{searchKeyword}|| : searchKeyword로 시작되는 -->
	<!-- => #{searchKeyword}||'%' : searchKeyword로 끝나는 -->
	<!-- 검색 컬럼명과 검색 단어를 전달받아 MYHEWON 테이블에 저장된 회원정보 중 검색 컬럼에
	검색 단어가 포함된 회원정보를 검색하여 검색결과를 제공하는 엘리먼트 -->
	<!--
	<select id="selectSearchHewonList" parameterType="map" resultMap="myHewonResultMap">
		select * from myhewon where ${searchColumn} like '%'||#{searchKeyword}||'%' order by hewon_id
	</select>
	 -->
	


	<!-- [🍒방법3 - bind 엘리먼트 이용] -->
	<select id="selectSearchHewonList" parameterType="map" resultMap="myHewonResultMap">
      
		<!-- bind : SQL 명령에서 사용하기 위한 이름과 값을 설정하는 엘리먼트 : 일종의 변수 선언과 비슷 -->
		<!-- => 언제 사용? 전달값을 다시 고쳐 사용하고 싶을 때 이용 , bind 엘리먼트는 select에서 많이 사용함 (insert,delete,update도 사용은 가능함)
			 => 여기서는 검색패턴문자를 결합해 사용할 때 쓰면 효율적 -->
		<!-- => bind 엘리먼트로 설정된 값은 SQL 명령에서 #{이름} 형식으로 표현하여 사용 가능 -->
		<!-- => 일반적으로 전달값을 변경할 때 많이 사용함 -->
      
		<!-- name 속성 : SQL 명령에서 사용될 값을 구분하기 위한 식별자를 속성값으로 설정
					    => 일종의 변수명 -->
		<!-- value 속성 : SQL 명령에서 사용될 값을 속성값으로 설정
					     => 일종의 변수에 저장되는 값 -->
		<!-- => parameterType 속성으로 전달된 값을 사용할 수 있으며 문자값 결합(+ 연산자) 기능 제공-->
		<!-- => 즉, value에는 parameterType이 map으로 전달되니 map키를 작성하고 + % 결합을 시켜 select문에서는 결합연산자 작성할 필요가 없음 -->
      
		<bind name="keyword" value="'%'+searchKeyword+'%'"/>
		<!-- select * from myhewon where ${searchColumn} like '%'||#{searchKeyword}||'%' order by hewon_id  -->
		select * from myhewon where ${searchColumn} like #{keyword} order by hewon_id
	</select>

🍄selectNameHewonList(name)

	<!-- 🍄동적SQL 이용X -->
	<!-- 🍄selectNameHewonList -->
	<!-- 이름을 전달받아 MYHEWON 테이블에 저장된 해당 이름의 회원정보를 검색하여 검색결과를
	제공하는 엘리먼트 -->
	<!-- => 비슷한 명령들은 전달값에 따라 명령들을 다르게 전달될 수 있도록 동적 SQL을 이용하는 것이 훨씬 더 효율적임 -->
	<select id="selectNameHewonList" parameterType="string" resultMap="myHewonResultMap">
		select * from myhewon where hewon_name=#{name} order by hewon_id
	</select>

 

🍄selectDynamicNameHewonList(name)

	<!-- 🍄동적SQL 이용 : 전달값을 비교해서 포함할 때 많이 이용함 -->	

	<!-- 🍄selectDynamicNameHewonList - 전달값 : String -->
	<!-- 동적SQL(Dynamic SQL) : 전달값에 따라 다른 SQL 명령이 엘리먼트에 등록되는 기능 -->
	<!-- =>OGNL(Object Graph Navigation Language) 표현식을 사용하여 구현 -->
	<!-- =>JSTL의 태그라이브러리와 거의 비슷함 -->

	<!-- 이름을 전달받지 않을 경우 MYHEWON 테이블에 저장된 모든 회원정보를 검색하고,
	이름을 전달받은 경우 MYHEWON 테이블에 저장된 해당 이름의 회원정보를 검색하여
	검색결과를 제공하는 엘리먼트 -->

	<!-- => 동적 SQL 관련 엘리먼트를 사용하여 전달값에 따라 다른 SQL 명령이 다르게 등록되도록 설정 -->
	<!-- => 과거 parameterType에 전달값이 하나일 경우 동적SQL 작성을 못했지만, 현재버전에서는 가능해짐 , 만약안되면 객체(자바빈객체 OR map)으로 변경해주기 -->
	<select id="selectDynamicNameHewonList" parameterType="string" resultMap="myHewonResultMap">
		select * from myhewon
      
		<!-- if : 조건에 의해 엘리먼트에 내용(SQL 명령을 구성하는 문장)의 포함여부를 설정하는 엘리먼트 -->
        <!-- => if 엘리먼트의 조건이 참인 경우 엘리먼트 내용을 SQL 명령에 포함 -->
		<!-- test 속성 : false(엘리먼트 내용 미포함) 또는 true(엘리먼트 내용 포함) 중 하나를 속성값으로 설정 -->
		<!-- =>parameterType 속성으로 전달된 값에 대한 조건식을 사용하여 test 타입 속성값으로 제공 -->
		<!-- => 만약 name이 null이 아니고 null string도 아니라면 아래의 where절을 추가해줘! -->
		<if test="name!=null and name!=''"> <!-- 전달값(이름)이 있는 경우 >> [true] -->
			where hewon_name=#{name}
		</if>
			order by hewon_id
	</select>

 

🍄selectDynamicHewonList(map)

	<!-- selectDynamicHewonList - 전달값 : Map객체 -->
	<!-- => 아이디 또는 이름을 전달받지 않은 경우 MYHEWON 테이블에 저장된 모든 회원정보를 검색하고 아이디 또는 이름을 전달받은 경우 MYHEWON 테이블에 저장된 회원정보 중 해당 아이디 또는 이름의 회원정보를 검색하여 검색결과를 제공하는 엘리먼트 -->
	<!-- => 전달값이 0개 ~ 2개 : 자바빈으로 해도 되지만, 0개일 경우도 있으므로 map으로 받는 것이 더 편함 -->

	<!-- 문제점) 아이디와 이름이 모두 전달된 경우 에러 발생 -->
	<!-- => 모든 if 엘리먼트의 test 속성값이 true 이므로 where 문장이 2번 포함됨 -->
	<!--
	<select id="selectDynamicHewonList" parameterType="map" resultMap="myHewonResultMap">
		select * from myhewon
		<if test="id!=null and id!=''">
			where hewon_id=#{id}
		</if>
		<if test="name!=null and name!=''">
			where hewon_name=#{name}
		</if>
		order by hewon_id
	</select>
	-->




	<!-- 해결법1) 아이디와 이름이 모두 전달되도 하나의 WHERE 문장만 포함되도록 설정 -->
	<!-- => choose : 조건에 맞는 하나의 엘리먼트 내용(SQL 명령을 구성하는 문장)이 포함되도록 설정하는 엘리먼트-->
	<!-- => 하위 엘리먼트 : when 엘리먼트(1개 이상) , otherwise 엘리먼트(0개 또는 1개) -->
	<!-- => 다수의 하위 엘리먼트 중 하나의 엘리먼트 내용만 SQL 명령에 포함 -->
	<!-- when : 조건에 의한 엘리먼트 내용 포함여부를 설정하는 엘리먼트 -->
	<!-- test 속성 : false(엘리먼트 내용 미포함) 또는 true(엘리먼트 내용 포함) 중 하나를 속성값으로 설정 -->
	<!-- otherwise : when 엘리먼트에 모든 조건이 거짓인 경우 엘리먼트 내용을 SQL 명령에 포함하는 엘리먼트 : 속성 없음 -->

	<!-- 다수의 when 엘리먼트 중 조건에 만족하는 행을 만나면 실행하고 바로 나가버림-->
	<!-- 검색기능으로 id와 name 둘 다 이용했어도 id만 검색한다는 것 -->
	<!--
	<select id="selectDynamicHewonList" parameterType="map" resultMap="myHewonResultMap">
		select * from myhewon
		<choose>
			<when test="id!=null and id!=''">
				where hewon_id=#{id}
			</when>
			<when test="name!=null and name!=''">
				where hewon_name=#{name}
			</when>
		</choose>
		order by hewon_id
	</select>
	-->


	 <!-- 해결법2-1) 아이디와 이름이 모두 전달된 경우 하나의 WHERE 문장에 포함되도록 설정 -->
	 <!-- trim : 엘리먼트 내용에 필요한 값을 추가하거나 삭제하여 SQL 명령에 포함하는 엘리먼트 -->
	 <!-- => trim을 사용하기 위해서는 trim 안에 반드시 엘리먼트 내용이 있어야함 -->
	 <!-- => select , update, delete, insert 다 사용 가능 -->
	 <!-- => 하위 엘리먼트로 다수의 if 엘리먼트 사용 -->

	 <!-- prefix 속성 : trim 엘리먼트에 엘리먼트 내용이 존재할 경우 엘리먼트 내용 앞에 추가될 문장을 속성값으로 설정 -->
	 <!-- prefixOverrides속성 : trim 엘리먼트에 엘리먼트 내용이 존재할 경우 엘리먼트 내용 앞에 제거될 문장을 속성값으로 설정 -->
	 <!-- suffix 속성 : trim 엘리먼트에 엘리먼트 내용이 존재할 경우 엘리먼트 내용 뒤에 추가될 문장을 속성값으로 설정 -->
	 <!-- suffixOverrides속성 : trim 엘리먼트에 엘리먼트 내용이 존재할 경우 엘리먼트 내용 뒤에 제거될 문장을 속성값으로 설정 -->
	<!--
	<select id="selectDynamicHewonList" parameterType="map" resultMap="myHewonResultMap">
		select * from myhewon
		<trim prefix="where" prefixOverrides="and|or">
			<if test="id!=null and id!=''">
				hewon_id=#{id}
			</if>
			<if test="name!=null and name!=''">
				${choice} hewon_name=#{name}
			</if>
		</trim>
		order by hewon_id
	</select>
	-->


	<!-- 해결법2-2) 앞서 trim 사용했던 부분을 where 엘리먼트를 이용해서 표현 가능 -->
	<!-- where : 엘리먼트 내용이 존재할 경우 엘리먼트 내용 앞에 [and] 또는 [or] 키워드가 있으면 삭제하고
	[where] 키워드를 추가하여 SQL 명령에 포함하는 엘리먼트  -->
	<!-- => 하위 엘리먼트로 다수의 if 엘리먼트 사용 -->
	<select id="selectDynamicHewonList" parameterType="map" resultMap="myHewonResultMap">
		select * from myhewon
		<where>
			<if test="id!=null and id!=''">
				hewon_id=#{id}
			</if>
			<if test="name!=null and name!=''">
				${choice} hewon_name=#{name}
			</if>
		</where>
		order by hewon_id
	</select>

 

🍑updateMyHewon(hewon)

	<!-- 🍑동적SQL을 미사용한 UPDATE 처리 -->
	<!-- 🍑updateMyHewon -->
	<!-- 회원정보를 전달받아 MYHEWON 테이블에 저장된 회원정보를 변경하는 엘리먼트 -->
	<!-- => 아이디를 비교하여 아이디를 제외한 모든 회원정보 변경 -->
	<update id="updateMyHewon" parameterType="MyHewon">
		update myhewon set hewon_name=#{name}, hewon_phone=#{phone}, hewon_email=#{email},
		hewon_state=#{state} where hewon_id=#{id}
	</update>

 

🍑updateDynamicHewon(hewon)

	<!-- 🍑동적SQL을 사용한 UPDATE 처리 -->
	<!-- 🍑updateDynamicHewon -->
	<!-- 동적SQL을 이용한 단 하나의 UPDATE 메소드만 잘 만들어두면 필드값 update 시 계쏙 하나의 메소드로만 계속 사용 가능함 -->
	<!-- 회원정보를 전달받아 MYHEWON 테이블에 저장된 회원정보를 변경하는 엘리먼트 -->
	<!-- => 아이디를 비교하여 아이디를 제외한 전달값이 존재하는 모든 회원정보의 컬럼값만 변경 -->
    
	<!-- test 속성에서 관계 연산자 (>,<,>=,<=) 대신 문자(gt,lt,gte,lte)로 표현하여 사용 -->
	<!-- => 관계 연산자를 기호로 사용한 경우 에러 발생 -->
	<!-- => <if test="state>=1 and state<=4"> 불가능 -->
  	<!-- 현재 설정된 trim의 뜻 : 맨 앞부분에는 무조건 [set]추가, 맨 뒷부분에 [,]있으면 제거 -->
	<!--
	<update id="updateDynamicHewon" parameterType="MyHewon" >
		update myhewon
		<trim prefix="set" suffixOverrides=",">
			<if test="name!=null and name!=''">
				hewon_name=#{name},
			</if>
			<if test="phone!=null and phone!=''">
				hewon_phone=#{phone},
			</if>
			<if test="email!=null and email!=''">
				hewon_email=#{email},
			</if>
			<if test="state gte 1 and state lte 4">
				hewon_state=#{state}
			</if>
		</trim>
		where hewon_id=#{id}
	</update>
	-->


	<!-- 앞서 trim 사용했던 부분을 set 엘리먼트를 이용해서 표현 가능 -->
	<!-- set : 엘리먼트 내용이 존재할 경우 엘리먼트 내용 뒤에 [,]가 있으면 삭제하고
	엘리먼트 내용 앞에 [set] 키워드를 추가하여 SQL 명령에 포함하는 엘리먼트  -->
	<!-- => 하위 엘리먼트로 다수의 if 엘리먼트 사용 -->
	<update id="updateDynamicHewon" parameterType="MyHewon" >
		update myhewon
		<set>
			<if test="name!=null and name!=''">
				hewon_name=#{name},
			</if>
			<if test="phone!=null and phone!=''">
				hewon_phone=#{phone},
			</if>
			<if test="email!=null and email!=''">
				hewon_email=#{email},
			</if>
			<if test="state gte 1 and state lte 4">
				hewon_state=#{state}
			</if>
		</set>
		where hewon_id=#{id}
	</update>

 

🍑selectMultiDynamicHewonList(idList)

	<!-- 🍑동적SQL 이용한 SELECT -->
	<!-- 🍑selectMultiDynamicHewonList--> 
	<!-- 아이디 목록을 전달받아 MYHEWON 테이블에 저장된 해당 아이디의 회원정보를 검색하여 검색결과를 제공하는 엘리먼트 -->

	<!-- => 아이디 목록을 전달받지 못한 경우 MYHEWON 테이블에 저장된 모든 회원정보 검색 -->
	<!-- => parameterType 속성값으로 ArrayList 클래스(List 인터페이스)를 설정하여 아이디
	목록을 List 객체로 제공받아 사용 -->
	<!-- => parameterType 속성값으로 ArrayList 클래스(List 인터페이스)를 설정한 경우 List 객체를
	전달받아 SQL 명령에서 [list] 이름으로 표현하여 사용  -->
	<!-- => 만약 id 말고 name도 함께 전달하고 싶다면 parameterType에 map으로 전달하기 -->
	<!--<select id="selectMultiDynamicHewonList" parameterType="map" resultMap="myHewonResultMap">-->
	<select id="selectMultiDynamicHewonList" parameterType="list" resultMap="myHewonResultMap">
		select * from myhewon
		<if test="list!=null"><!-- list객체가 전달되었다면 -->
			where hewon_id in
			<!-- foreach : 전달받은 List 객체의 요소값을 반복적으로 제공받아 SQL 명령에 포함하는 엘리먼트 -->
			<!-- collection 속성 : 반복 처리하기 위한 List 객체의 이름을 속성값으로 설정 -->
			<!-- item속성 : List 객체의 요소값을 저장하기 위한 이름을 속성값으로 설정 -->
			<!-- open속성 : foreach 엘리먼트 내용 앞부분에 추가될 문장을 속성값으로 설정 -->
			<!-- close속성 : foreach 엘리먼트 내용 뒷부분에 추가될 문장을 속성값으로 설정 -->
			<!-- separator속성 : List 객체의 요소값을 구분하기 위한 문장을 속성값으로 설정 -->
			<!-- => 아래처럼 작성하면 (#{id},#{id},#{id},#{id},#{id} ) 처럼 출력되는 효과임 -->
			<foreach collection="list" item="id" open="(" close=")" separator=",">
				#{id}<!-- 리스트 객체에 있는 요소값을 표현 -->
			</foreach>
		</if>
		order by hewon_id
	</select>

</mapper>

2) [Mapper바인딩] MyHewonMapper.java

package xyz.itwill.mapper;

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

import org.apache.ibatis.annotations.Param;

import xyz.itwill.dto.MyHewon;

public interface MyHewonMapper  {
	int insertHewon(MyHewon hewon);
	List<MyHewon> selectHewonList();
	List<MyHewon> selectDiscriminatorHewonList();
	List<MyHewon> selectStateHewonList(int state);
	String selectBeanHewonId(MyHewon hewon);

	//HashMap 클래스(Map 인터페이스)의 제네릭은 맵키를 [String]으로 설정하고 맵값은 [Object]로 설정
	String selectMapHewonId(Map<String, Object> map);
	int insertMapHewon(Map<String, Object> map);

	List<Map<String, Object>> selectMapHewonList(); //리스트 안에 맵을 넣어 반환받을 것임

	//@Param : 추상메소드의 매개변수에 저장된 값을 XML 기반의 매퍼파일에 엘리먼트에게 전달하여
	//등록된 SQL 명령에서 사용할 수 있도록 제공하는 어노테이션
	//value 속성 : 추상메소드의 매개변수에 저장된 값을 XML 기반의 매퍼파일의 엘리먼트에 등록된
	//SQL 명령에서 사용하기 위한 식별자를 속성값으로 설정
	//=> 다른 속성이 없는 경우 속성값만 설정 가능
	String selectParamHewonId(@Param(value = "name") String name, @Param("email")String email);
	List<MyHewon> selectSearchHewonList(Map<String, Object> map);
	List<MyHewon> selectNameHewonList(String name);
	List<MyHewon> selectDynamicNameHewonList(String name);
	List<MyHewon> selectDynamicHewonList(Map<String, Object> map);
	int updateMyHewon(MyHewon hewon);
	int updateDynamicHewon(MyHewon hewon);
	List<MyHewon> selectMultiDynamicHewonList(List<String> idList);
}

 

 

03. DAO

1) [DAO] MyHewonDAO.java

package xyz.itwill.dao;

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

import org.apache.ibatis.session.SqlSession;

import xyz.itwill.dto.MyHewon;
import xyz.itwill.mapper.MyHewonMapper;

public class MyHewonDAO extends AbstractSession{
	private static MyHewonDAO _dao;

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

	static {
		_dao = new MyHewonDAO();
	}

	public static MyHewonDAO getDAO() {
		return _dao;
	}
    //1.
	public int insertHewon(MyHewon hewon) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).insertHewon(hewon);
		} finally {
			sqlSession.close();
		}
	}
    //2.
	public List<MyHewon> selectHewonList() {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectHewonList();
		} finally {
			sqlSession.close();
		}
	}
    //3.
	public List<MyHewon> selectDiscriminatorHewonList() {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectDiscriminatorHewonList();
		} finally {
			sqlSession.close();
		}
	}
    //4.
	public List<MyHewon> selectStateHewonList(int state) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectStateHewonList(state);
		} finally {
			sqlSession.close();
		}
	}
    //5.
	public String selectBeanHewonId(MyHewon hewon) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectBeanHewonId(hewon);
		} finally {
			sqlSession.close();
		}
	}
    //6.
	public String selectMapHewonId(Map<String, Object> map) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectMapHewonId(map);
		} finally {
			sqlSession.close();
		}
	}
    //7.
	public int insertMapHewon(Map<String, Object> map) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).insertMapHewon(map);
		} finally {
			sqlSession.close();
		}
	}
    //8.
	public List<Map<String, Object>> selectMapHewonList() {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectMapHewonList();
		} finally {
			sqlSession.close();
		}
	}
    //9.
	public String selectParamHewonId(String name,String email) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectParamHewonId(name,email);
		} finally {
			sqlSession.close();
		}
	}
    //10.
    	public List<MyHewon> selectSearchHewonList(Map<String, Object> map) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectSearchHewonList(map);
		} finally {
			sqlSession.close();
		}
	}
    //11.
    	public List<MyHewon> selectNameHewonList(String name) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectNameHewonList(name);
		} finally {
			sqlSession.close();
		}
	}
    //12.
    	public List<MyHewon> selectDynamicNameHewonList(String name) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectDynamicNameHewonList(name);
		} finally {
			sqlSession.close();
		}
	}
    //13.
    	public List<MyHewon> selectDynamicHewonList(Map<String, Object> map) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectDynamicHewonList(map);
		} finally {
			sqlSession.close();
		}
	}
    //14.
    	public int updateMyHewon(MyHewon hewon) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).updateMyHewon(hewon);
		} finally {
			sqlSession.close();
		}
	}
    //15.
	public int updateDynamicHewon(MyHewon hewon) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).updateDynamicHewon(hewon);
		} finally {
			sqlSession.close();
		}
	}
    //16.
    	public List<MyHewon> selectMultiDynamicHewonList(List<String> idList){
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectMultiDynamicHewonList(idList);
		} finally {
			sqlSession.close();
		}
	}
    
    
   
}

 

 

04. JSP

1)🍊hewonInsert.jsp - insertHewon(hewon)

<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@page import="xyz.itwill.dto.MyHewon"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
	MyHewonDAO.getDAO().insertHewon(new MyHewon("aaa","홍길동","010-1234-5678","aaa@itwill.xyz",1));
	MyHewonDAO.getDAO().insertHewon(new MyHewon("bbb","임꺽정","010-9413-1324","bbb@itwill.xyz",2));
	MyHewonDAO.getDAO().insertHewon(new MyHewon("ccc","전우치","010-4578-3214","ccc@itwill.xyz",3));
	MyHewonDAO.getDAO().insertHewon(new MyHewon("ddd","일지매","010-4259-6333","ddd@itwill.xyz",4));
	MyHewonDAO.getDAO().insertHewon(new MyHewon("eee","장길산","010-7841-3245","eee@itwill.xyz",3));
%>

2)🍊hewonListSelect.jsp - selectHewonList()

<%@page import="xyz.itwill.dto.MyHewon"%>
<%@page import="java.util.List"%>
<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
	List<MyHewon> hewonList = MyHewonDAO.getDAO().selectHewonList();
%>
<!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;}
.id {width: 150px;} .name {width: 150px;} .phone {width: 200px;} .email {width: 200px;} .state {width: 100px;}
</style>
</head>
<body>
	<h1>회원목록</h1>
	<hr/>
		<table>
		<tr>
			<td class="id">아이디</td>
			<td class="name">이름</td>
			<td class="phone">전화번호</td>
			<td class="email">이메일</td>
			<td class="state">공개범위</td>
		</tr>
		<%for(MyHewon hewon:hewonList) {%>
		<tr>
			<td><%=hewon.getId() %></td>
			<td><%=hewon.getName() %></td>
			<td><%=hewon.getPhone() %></td>
			<td><%=hewon.getEmail() %></td>
			<td><%=hewon.getState() %></td>
		</tr>
		<%} %>
	</table>
</body>
</html>

3)🍋hewonDiscriminatorListSelect.jsp -selectDiscriminatorHewonList()

• 저장된 필드값에 따라 다르게 매핑되어 결과 제공됨

<%@page import="xyz.itwill.dto.MyHewon"%>
<%@page import="java.util.List"%>
<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
	List<MyHewon> hewonList = MyHewonDAO.getDAO().selectDiscriminatorHewonList();
%>
<!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;}
.id {width: 150px;} .name {width: 150px;} .phone {width: 200px;} .email {width: 200px;} .state {width: 100px;}
</style>
</head>
<body>
	<h1>회원목록</h1>
	<hr/>
		<table>
		<tr>
			<td class="id">아이디</td>
			<td class="name">이름</td>
			<td class="phone">전화번호</td>
			<td class="email">이메일</td>
			<td class="state">공개범위</td>
		</tr>
		<%for(MyHewon hewon:hewonList) {%>
		<tr>
			<td><%=hewon.getId() %></td>
			<td><%=hewon.getName() %></td>
			<td><%=hewon.getPhone() %></td>
			<td><%=hewon.getEmail() %></td>
			<td><%=hewon.getState() %></td>
		</tr>
		<%} %>
	</table>
</body>
</html>

4)🥝hewonListStateSelect.jsp - selectStateHewonList()

<%@page import="xyz.itwill.dto.MyHewon"%>
<%@page import="java.util.List"%>
<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
	int state = 0;
	if(request.getParameter("state")!=null){
		state = Integer.parseInt(request.getParameter("state"));
	}

	List<MyHewon> hewonList = null;

	if(state == 0){//전달값이 없으면
		hewonList = MyHewonDAO.getDAO().selectHewonList(); //전체 검색
	} else {//전달값이 있으면
		hewonList = MyHewonDAO.getDAO().selectStateHewonList(state); //조건 검색
	}
%>
<!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;}
.id {width: 150px;} .name {width: 150px;} .phone {width: 200px;} .email {width: 200px;} .state {width: 100px;}
</style>
</head>
<body>
	<h1>회원목록</h1>
	<hr/>
		<table>
		<tr>
			<td class="id">아이디</td>
			<td class="name">이름</td>
			<td class="phone">전화번호</td>
			<td class="email">이메일</td>
			<td class="state">공개범위</td>
		</tr>
		<%if(hewonList.isEmpty()){ %>
			<tr>
				<td colspan="5">검색된 회원정보가 없습니다.</td>
			</tr>
		<%} else{%>
		<%for(MyHewon hewon:hewonList) {%>
			<tr>
				<td><%=hewon.getId() %></td>
				<td><%=hewon.getName() %></td>
				<td><%=hewon.getPhone() %></td>
				<td><%=hewon.getEmail() %></td>
				<td><%=hewon.getState() %></td>
			</tr>
			<%} %>
		<%} %>
	</table>
	<br />
	<form method="post">
		회원검색(공개범위) :
		<select name="state">
			<option value="0" selected="selected"> 전체</option>
			<option value="1">1&nbsp;&nbsp;&nbsp; </option>
			<option value="2">2&nbsp;&nbsp;&nbsp;</option>
			<option value="3">3&nbsp;&nbsp;&nbsp;</option>
			<option value="4">4&nbsp;&nbsp;&nbsp;</option>
		</select>
		<button type="submit">검색</button>
	</form>
</body>
</html>

5)🥝hewonIdBeanSelect.jsp - selectBeanHewonId(hewon)

<%@page import="xyz.itwill.dto.MyHewon"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
	request.setCharacterEncoding("utf-8");

	String name = request.getParameter("name");
	String email = request.getParameter("email");

	String id = "";
	if(name!=null && email!=null){
		MyHewon hewon = new MyHewon();
		hewon.setName(name);
		hewon.setEmail(email);

		id=MyHewonDAO.getDAO().selectBeanHewonId(hewon);
	}
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
</head>
<body>
	<h1>아이디 찾기</h1>
	<hr />
	<form method="post" name="searchForm" id="searchForm">
		<table>
			<tr>
				<td>이름</td>
				<td><input type="text" name="name"></td>
			</tr>
			<tr>
				<td>이메일</td>
				<td><input type="text" name="email"></td>
			</tr>
			<tr>
				<td colspan="2"><button type="submit">아이디 검색</button></td>
			</tr>
		</table>
	</form>
	<%if(name!=null && email!=null){ //전달값이 있을때만 출력 %>
		<div style="font-weight: bold; color: red;">
			<%if(id==null || id.equals("")) {%>
				<%=name %>님의 아이디가 존재하지 않습니다.
			<%} else { %>
				<%=name %>님의 아이디는 [<%=id %>]입니다.
			<%} %>
		</div>
	<%} %>
	<script type="text/javascript">
	document.getElementById("searchForm").onsubmit=function() {
		if(searchForm.name.value=="") {
			alert("이름을 입력해 주세요.");
			return false;
		}
		if(searchForm.email.value=="") {
			alert("이메일을 입력해 주세요.");
			return false;
		}
	}
	</script>
</body>
</html>

6)🥝hewonIdMapSelect.jsp - selectMapHewonId(map)

• 실제로 자바빈객체가 없어도, Map객체를 사용하면됨!!

<%@page import="xyz.itwill.dto.MyHewon"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
	request.setCharacterEncoding("utf-8");

	String name = request.getParameter("name");
	String email = request.getParameter("email");

	String id = "";
	if(name!=null && email!=null){
		Map<String,Object> map = new HashMap<String,Object>();
		map.put("name", name);
		map.put("email", email);

		id=MyHewonDAO.getDAO().selectMapHewonId(map);
	}
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
</head>
<body>
	<h1>아이디 찾기</h1>
	<hr />
	<form method="post" name="searchForm" id="searchForm">
		<table>
			<tr>
				<td>이름</td>
				<td><input type="text" name="name"></td>
			</tr>
			<tr>
				<td>이메일</td>
				<td><input type="text" name="email"></td>
			</tr>
			<tr>
				<td colspan="2"><button type="submit">아이디 검색</button></td>
			</tr>
		</table>
	</form>
	<%if(name!=null && email!=null){ //전달값이 있을때만 출력 %>
		<div style="font-weight: bold; color: red;">
			<%if(id==null || id.equals("")) {%>
				<%=name %>님의 아이디가 존재하지 않습니다.
			<%} else { %>
				<%=name %>님의 아이디는 [<%=id %>]입니다.
			<%} %>
		</div>
	<%} %>
	<script type="text/javascript">
	document.getElementById("searchForm").onsubmit=function() {
		if(searchForm.name.value=="") {
			alert("이름을 입력해 주세요.");
			return false;
		}
		if(searchForm.email.value=="") {
			alert("이메일을 입력해 주세요.");
			return false;
		}
	}
	</script>
</body>
</html>

7)🍈hewonMapInsert.jsp - insertMapHewon(map)

• DTO객체가 아닌 MAP객체를 전달받아 사용 CRUD할 것임

<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@page import="java.util.HashMap"%>
<%@page import="org.apache.coyote.http2.Http2AsyncUpgradeHandler"%>
<%@page import="xyz.itwill.dto.MyHewon"%>
<%@page import="java.util.Map"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
	Map<String, Object> map = new HashMap<String, Object>();
	map.put("id", "xxx");
	map.put("name", "홍경래");
	map.put("phone", "010-2347-7541");
	map.put("email", "xxx@itwill.xyz");
	map.put("state", 4);

	MyHewonDAO.getDAO().insertMapHewon(map);
%>

8)🍈hewonMapSelect.jsp - selectMapHewonList()

• Map객체로 만든 List 출력

<%@page import="xyz.itwill.dto.MyHewon"%>
<%@page import="java.util.List"%>
<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@page import="java.util.Map"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
	List<Map<String, Object>> hewonList = MyHewonDAO.getDAO().selectMapHewonList();
%>
<!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;}
.id {width: 150px;} .name {width: 150px;} .phone {width: 200px;} .email {width: 200px;} .state {width: 100px;}
</style>
</head>
<body>
	<h1>회원목록</h1>
	<hr/>
		<table>
		<tr>
			<td class="id">아이디</td>
			<td class="name">이름</td>
			<td class="phone">전화번호</td>
			<td class="email">이메일</td>
			<td class="state">공개범위</td>
		</tr>
		<%for(Map<String,Object> hewon:hewonList) {%>
		<tr>
			<td><%=hewon.get("HEWON_ID") %></td>
			<td><%=hewon.get("HEWON_NAME") %></td>
			<td><%=hewon.get("HEWON_PHONE") %></td>
			<td><%=hewon.get("HEWON_EMAIL") %></td>
			<td><%=hewon.get("HEWON_STATE") %></td>
		</tr>
		<%} %>
	</table>
</body>
</html>

9) 🍒hewonIdParamSelect.jsp - selectParamHewonId(name, email)

<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@page import="xyz.itwill.dto.MyHewon"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
	request.setCharacterEncoding("utf-8");

	String name = request.getParameter("name");
	String email = request.getParameter("email");

	String id = "";
	if(name!=null && email!=null){
		MyHewon hewon = new MyHewon();
		hewon.setName(name);
		hewon.setEmail(email);

		id=MyHewonDAO.getDAO().selectParamHewonId(
	}
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
</head>
<body>
	<h1>아이디 찾기</h1>
	<hr />
	<form method="post" name="searchForm" id="searchForm">
		<table>
			<tr>
				<td>이름</td>
				<td><input type="text" name="name"></td>
			</tr>
			<tr>
				<td>이메일</td>
				<td><input type="text" name="email"></td>
			</tr>
			<tr>
				<td colspan="2"><button type="submit">아이디 검색</button></td>
			</tr>
		</table>
	</form>
	<%if(name!=null && email!=null){ //전달값이 있을때만 출력 %>
		<div style="font-weight: bold; color: red;">
			<%if(id==null || id.equals("")) {%>
				<%=name %>님의 아이디가 존재하지 않습니다.
			<%} else { %>
				<%=name %>님의 아이디는 [<%=id %>]입니다.
			<%} %>
		</div>
	<%} %>
	<script type="text/javascript">
	document.getElementById("searchForm").onsubmit=function() {
		if(searchForm.name.value=="") {
			alert("이름을 입력해 주세요.");
			return false;
		}

		if(searchForm.email.value=="") {
			alert("이메일을 입력해 주세요.");
			return false;
		}
	}
	</script>
</body>
</html>

10) 🍒hewonListSearchSelect.jsp - selectSearchHewonList(map)

<%@page import="java.util.HashMap"%>
<%@page import="java.util.Map"%>
<%@page import="xyz.itwill.dto.MyHewon"%>
<%@page import="java.util.List"%>
<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
	request.setCharacterEncoding("utf-8");

	String searchColumn = request.getParameter("searchColumn");
	String searchKeyword = request.getParameter("searchKeyword");

	List<MyHewon> hewonList = null;

	if(searchKeyword==null || searchKeyword.equals("")){//전달값이 없으면
		hewonList = MyHewonDAO.getDAO().selectHewonList(); //전체 검색
	} else {//전달값이 있으면
		Map<String, Object> map = new HashMap<>();
		map.put("searchColumn", searchColumn);
		map.put("searchKeyword", searchKeyword);
		hewonList=MyHewonDAO.getDAO().selectSearchHewonList(map); //조건 검색
	}
%>
<!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;}
.id {width: 150px;} .name {width: 150px;} .phone {width: 200px;} .email {width: 200px;} .state {width: 100px;}
</style>
</head>
<body>
	<h1>회원목록</h1>
	<hr/>
		<table>
            <tr>
                <td class="id">아이디</td>
                <td class="name">이름</td>
                <td class="phone">전화번호</td>
                <td class="email">이메일</td>
                <td class="state">공개범위</td>
            </tr>
		<%if(hewonList.isEmpty()){ %>
			<tr>
				<td colspan="5">검색된 회원정보가 없습니다.</td>
			</tr>
		<%} else{%>
		<%for(MyHewon hewon:hewonList){%>
            <tr>
                <td><%=hewon.getId() %></td>
                <td><%=hewon.getName() %></td>
                <td><%=hewon.getPhone() %></td>
                <td><%=hewon.getEmail() %></td>
                <td><%=hewon.getState() %></td>
            </tr>
                <%} %>
            <%} %>
		</table>
	<br />
	<form method="post">
		//<%-- 검색대상 입력(선택) : 전달값을 반드시 컬럼명과 같도록 작성 --%>
		//회원검색(공개범위) :
		<select name="searchColumn">
			<option value="hewon_id" selected="selected"> 아이디</option>
			<option value="hewon_name">이름</option>
			<option value="hewon_phone">전화번호</option>
			<option value="hewon_email">이메일</option>
		</select>

		<!-- 검색단어 입력 -->
		<input type="text" name="searchKeyword">
		<button type="submit">검색</button>
	</form>
</body>
</html>

11) 🍄HewonListNameSelect.jsp - selectNameHewonList(name)

• 프로그램에서 if문을 직접 사용함
• 동적SQL 이용X
• 검색단어 없이 그냥 검색을 클릭할 경우 전체검색되고, (selectHewonList)
• 검색단어가 있을 경우 해당 회원정보가 검색됨 (selectNameHewonList(name))

<%@page import="java.util.HashMap"%>
<%@page import="java.util.Map"%>
<%@page import="xyz.itwill.dto.MyHewon"%>
<%@page import="java.util.List"%>
<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
	request.setCharacterEncoding("utf-8");
	String name = request.getParameter("name");

	List<MyHewon> hewonList = null;
	//if문으로 메소드 여러번 호출!!
	if(name==null || name.equals("")){//전달값이 없는 경우 - 검색기능 미사용
		hewonList = MyHewonDAO.getDAO().selectHewonList(); //전체 검색
	} else {//전달값이 있는 경우 - 검색기능 사용
		hewonList=MyHewonDAO.getDAO().selectNameHewonList(name); //조건 검색
	}
%>
<!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;}
.id {width: 150px;}.name {width: 150px;}.phone {width: 200px;}.email {width: 200px;}.state {width: 100px;}
</style>
</head>
<body>
	<h1>회원목록</h1>
	<hr/>
		<table>
		<tr>
			<td class="id">아이디</td>
			<td class="name">이름</td>
			<td class="phone">전화번호</td>
			<td class="email">이메일</td>
			<td class="state">공개범위</td>
		</tr>
		<%if(hewonList.isEmpty()){ %>
			<tr>
				<td colspan="5">검색된 회원정보가 없습니다.</td>
			</tr>
		<%} else{%>
		<%for(MyHewon hewon:hewonList) {%>
			<tr>
				<td><%=hewon.getId() %></td>
				<td><%=hewon.getName() %></td>
				<td><%=hewon.getPhone() %></td>
				<td><%=hewon.getEmail() %></td>
				<td><%=hewon.getState() %></td>
			</tr>
			<%} %>
		<%} %>
	</table>
	<br>
	<form method="post">
		 이름 : <input type="text" name="name">
		<button type="submit">검색</button>
	</form>
</body>
</html>

12)🍄hewonListDynamicNameSelect.jsp - selectDynamicNameHewonList(name) 동적SQL

• xml매퍼에서 OGNL 표현식을 통해 동적SQL이 구현되었기 때문에
• 프로그램에서 직접 제어문을 사용해 DAO메소드를 다르게 호출할 필요가 없음!!
• 동적SQL 이용

<%@page import="java.util.HashMap"%>
<%@page import="java.util.Map"%>
<%@page import="xyz.itwill.dto.MyHewon"%>
<%@page import="java.util.List"%>
<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
	request.setCharacterEncoding("utf-8");
	String name = request.getParameter("name");

	//메소드 하나만 호출!! - 동적SQL
	List<MyHewon> hewonList = MyHewonDAO.getDAO().selectDynamicNameHewonList(name);
%>
<!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;}
.id {width: 150px;}.name {width: 150px;}.phone {width: 200px;}.email {width: 200px;}.state {width: 100px;}
</style>
</head>
<body>
	<h1>회원목록</h1>
	<hr/>
		<table>
		<tr>
			<td class="id">아이디</td>
			<td class="name">이름</td>
			<td class="phone">전화번호</td>
			<td class="email">이메일</td>
			<td class="state">공개범위</td>
		</tr>
		<%if(hewonList.isEmpty()){ %>
			<tr>
				<td colspan="5">검색된 회원정보가 없습니다.</td>
			</tr>
		<%} else{%>
		<%for(MyHewon hewon:hewonList) {%>
			<tr>
				<td><%=hewon.getId() %></td>
				<td><%=hewon.getName() %></td>
				<td><%=hewon.getPhone() %></td>
				<td><%=hewon.getEmail() %></td>
				<td><%=hewon.getState() %></td>
			</tr>
			<%} %>
		<%} %>
	</table>
	<br>
	<form method="post">
		 이름 : <input type="text" name="name">
		<button type="submit">검색</button>
	</form>
</body>
</html>

13) 🍄hewonListDynamicSelect.jsp - selectDynamicHewonList(map) 동적SQL

• 동적SQL 이용

<%@page import="java.util.HashMap"%>
<%@page import="java.util.Map"%>
<%@page import="xyz.itwill.dto.MyHewon"%>
<%@page import="java.util.List"%>
<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
	request.setCharacterEncoding("utf-8");

	String id = request.getParameter("id");
	String name = request.getParameter("name");
	String choice = request.getParameter("choice");

	Map<String, Object> map = new HashMap<String, Object>();
	map.put("id", id);
	map.put("name", name);
	map.put("choice", choice);

	List<MyHewon> hewonList = MyHewonDAO.getDAO().selectDynamicHewonList(map);
%>
<!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;}
.id {width: 150px;}.name {width: 150px;}.phone {width: 200px;}.email {width: 200px;}.state {width: 100px;}
</style>
</head>
<body>
	<h1>회원목록</h1>
	<hr/>
		<table>
		<tr>
			<td class="id">아이디</td>
			<td class="name">이름</td>
			<td class="phone">전화번호</td>
			<td class="email">이메일</td>
			<td class="state">공개범위</td>
		</tr>
		<%if(hewonList.isEmpty()){ %>
			<tr>
				<td colspan="5">검색된 회원정보가 없습니다.</td>
			</tr>
		<%} else{%>
		<%for(MyHewon hewon:hewonList) {%>
			<tr>
				<td><%=hewon.getId() %></td>
				<td><%=hewon.getName() %></td>
				<td><%=hewon.getPhone() %></td>
				<td><%=hewon.getEmail() %></td>
				<td><%=hewon.getState() %></td>
			</tr>
			<%} %>
		<%} %>
	</table>
	<br>
	<form method="post">
		 아이디 : <input type="text" name="id">
		 <select name="choice">
		 	<option value="or" selected="selected">OR&nbsp;&nbsp;&nbsp;</option>
		 	<option value="and">AND&nbsp;&nbsp;&nbsp;</option>
		 </select>
		 이름 : <input type="text" name="name">
		<button type="submit">검색</button>
	</form>
</body>
</html>

14) 🍑hewonUpdate.jsp - updateMyHewon(hewon)

• 동적SQL을 미사용한 UPDATE 처리
• 특정 필드값만을 변경을 원할 경우, update DAO 메소드 각각 만들어야 함 - 불편

<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@page import="xyz.itwill.dto.MyHewon"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
	/*
	//MYHEWON 테이블에서 아이디가 [xxx]인 회원의 이름을 [로빈홋]으로 변경
	//기본생성자에 의해 생성된 객체의 필드에는 기본값(논리형:false,숫자형:0,참조형:null) 저장
	MyHewon hewon = new MyHewon();
	hewon.setId("xxx");
	hewon.setName("로빈홋");

	//DAO 클래스의 메소드 매개변수에는 아이디와 이름만 저장된 회원정보가 전달
	// => 아이디와 이름을 제외한 필드에는 기본값이 저장되어 전달
	//문제점) MYHEWON 테이블에 저장된 회원정보가 비정상적으로 변경 처리
    //=> 출력하면 id가 xxx인 행에 name 필드값만 변경되고, 나머지는 null로 변경됨
	MyHewonDAO.getDAO().updateMyHewon(hewon);
	*/

	//해결법) DAO클래스의 메소드 매개변수에 모든 회원정보를 저장하여 전달
	// => 회원정보를 변경하지 않는 컬럼에는 기존 컬럼값이 저장되도록 필드값 변경
    // => 해결법이 불편하므로 동적 SQL 이용하자
	MyHewon hewon = new MyHewon();
	hewon.setId("xxx");
	hewon.setName("로빈홋");
	hewon.setPhone("010-5467-3487");
	hewon.setEmail("xxx@itwill.xyz");
	hewon.setState(4);

	MyHewonDAO.getDAO().updateMyHewon(hewon);
%>

15) 🍑hewonDynamicUpdate.jsp - updateDynamicHewon(hewon) 동적SQL

• 동적SQL을 사용한 UPDATE 처리
• 동적SQL을 이용했기 때문에 하나의 메소드 호출로 특정 필드값만 변경할 수 있음
• 훨씬 효율적, 유지보수의 효율성 증가 - 권장

<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@page import="xyz.itwill.dto.MyHewon"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
	//MYHEWON 테이블에서 아이디가 [xxx]인 회원의 이름을 [홍경래]로 변경
	MyHewon hewon = new MyHewon();
	hewon.setId("xxx");
	hewon.setName("홍경래");

	MyHewonDAO.getDAO().updateDynamicHewon(hewon);
%>

16)🍑hewonListDynamicMultiSelect.jsp - selectMultiDynamicHewonList(idList)

<%@page import="java.util.ArrayList"%>
<%@page import="java.util.HashMap"%>
<%@page import="java.util.Map"%>
<%@page import="xyz.itwill.dto.MyHewon"%>
<%@page import="java.util.List"%>
<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
	String ids = request.getParameter("ids");

	List<String> idList =null;
	if(ids!=null && !ids.equals("")){//전달받은 아이디 목록이 있는 경우
		//전달받은 아이디 목록을 [,] 기호로 분리하여 List 객체의 요소값으로 추가하여 저장
		idList=new ArrayList<String>();
		for(String id:ids.split(",")){
			idList.add(id.trim());
		}
	}
    
	List<MyHewon> hewonList = MyHewonDAO.getDAO().selectMultiDynamicHewonList(idList);
%>
<!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;}
.id {width: 150px;}.name {width: 150px;}.phone {width: 200px;}.email {width: 200px;}.state {width: 100px;}
</style>
</head>
<body>
	<h1>회원목록</h1>
	<hr/>
		<table>
		<tr>
			<td class="id">아이디</td>
			<td class="name">이름</td>
			<td class="phone">전화번호</td>
			<td class="email">이메일</td>
			<td class="state">공개범위</td>
		</tr>
		<%if(hewonList.isEmpty()){ %>
			<tr>
				<td colspan="5">검색된 회원정보가 없습니다.</td>
			</tr>
		<%} else{%>
		<%for(MyHewon hewon:hewonList) {%>
			<tr>
				<td><%=hewon.getId() %></td>
				<td><%=hewon.getName() %></td>
				<td><%=hewon.getPhone() %></td>
				<td><%=hewon.getEmail() %></td>
				<td><%=hewon.getState() %></td>
			</tr>
			<%} %>
		<%} %>
	</table>
	<br>
	<form method="post">
		 아이디 : <input type="text" name="ids">
		<button type="submit">검색</button>
		<p>[검색하고자 하는 아이디가 여러개인 경우 ,로 구분하여 검색해 주세요.]</p>
	</form>
</body>
</html>