필터링 검색 (공개여부)

woom·2023년 2월 6일
framework
0

Framework

목록 보기
3/20
post-thumbnail

🌼 공개 여부 설정

  • 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 (아이디 & 이름 & 전화번호 & 이메일)

📕 DTO class

package xyz.itwill.dto;

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;
	}
}

⭐ xml 매퍼 (hewon)

  • 검색된 회원정보에서 공개범위에 따라 다른 매핑정보를 제공하기 위한 resultMap 엘리먼트

  • discriminator : 검색행의 컬럼값을 비교하여 서로 다른 매핑정보를 제공하기 위한 엘리먼트

    • 하위 엘리먼트로 case 엘리먼트를 사용하여 컬럼값을 비교해 같은 경우 매핑정보 제공
    • javaType 속성 : 검색행의 비교 컬럼값의 Java 자료형을 속성값으로 설정
    • Java 자료형 대신 typeAlias 엘리먼트의 별칭 사용 가능
    • column 속성 : 검생행의 비교 컬럼명을 속성값으로 설정

  • case 엘리먼트의 공통적인 매핑정보가 존재할 경우 discriminator 엘리먼트가 아닌 다른 엘리먼트를 사용하여 매핑 정보 제공 가능

  • extends 속성 : resultMap 엘리먼트의 식별자를 속성값으로 설정

    • 다른 resultMap 엘리먼트의 매핑정보를 상속받아 사용하기 위한 속성

  • resultMap 속성을 사용하여 다른 resultMap 엘리먼트의 매핑정보를 제공받아 사용 가능

📌 SQL 명령에 필요한 값 전달 방법

  • 전달값은 SQL 명령에서 #{변수명 | 필드명 | 맵키} 형식으로 표현하여 사용
  1. XML 기반의 매퍼 파일에서 SQL 명령이 등록된 엘리먼트의 parameterType 속성값으로 Java 자료형(별칭)을 설정하여 값을 전달받아 사용

  • 단일값을 전달받기 위해 parameterType 속성에 원시형(PrimitiveType - Wrapper 클래스) 또는 String 클래스를 속성값으로 설정

    • SQL 명령에서 #{변수명} 형식으로 전달값 사용

  • 다수값을 전달받기 위해 parameterType 속성에 JavaBean(DTO) 클래스를 속성값으로 설정

    • SQL 명령에서 #{필드명} 형식으로 전달값(필드값)을 사용

  • 다수값을 전달받기 위해 parameterType 속성에 HashMap 클래스(Map 인터페이스)를 속성값으로 설정

    • SQL 명령에서 #{맵키} 형식으로 전달값(맵값)을 사용
  1. 인터페이스 기반의 매퍼 파일에서 추상메소드의 매개변수에 @Param 어노테이션을 설정하여 매개변수에 전달값을 SQL 명령에서 사용
  • 바인딩된 XML 기반의 매퍼 파일의 엘리먼트에 등록된 SQL 명령에서도 사용 가능
  • XML 기반의 매퍼 파일에 엘리먼트에서 prarmeterType 속성 생략
  • 공개범위(state)를 전달받아 MYHEWON 테이블에 저장된 해당 공개범위(state)의 회원정보를 검색하여 검색결과를 제공하는 엘리먼트
    • 값을 하나만 전달받아 SQL 명령에서 사용할 경우 parameterType 속성값으로 원시형(Wrapper 클래스)또는 String 클래스를 설정하고 SQL 명령에서 #{변수명} 형식으로 전달값 사용
    • 변수명은 아무런 의미가 없으며 식별자 작성 규칙에 맞게 설정
    • XML 기반의 매퍼 파일만 설정할 경우 parameterType 속성값으로 원시형(Wrapper 클래스) 또는 String 클래스를 설정한 경우 parameterType 속성 생략 가능
  • 이름과 이메일을 전달받아 MYHEWON 테이블에 저장된 해당 이름과 이메일의 회원정보에 대한 아이디를 검색하여 검색결과를 제공하는 엘리먼트

  1. 값을 여러개 전달받아 SQL 명령에서 사용할 경우 parameterType 속성값으로 JavaBean(DTO)클래스를 설정하고 SQL 명령에서는 #{필드명} 형식으로 전달받은 JavaBean 객체의 필드값 사용

    • Interface 기반의 매퍼 파일과 바인딩된 경우 전달값에 상관없이 parameterType 속성 생략 가능

  2. 값을 여러개 전달받아 SQL 명령에서 사용할 경우 parameterType 속성값으로 HashMap 클래스(Map 인터페이스)를 설정하고 SQL 명령에서는 #{맵키} 형식으로 전달받은 Map 객체의 맵값 사용

  3. 매퍼 바인딩 처리된 인터페이스 기반의 매퍼파일에서 추상메소드의 매개변수에 전달된 값을 @Param 어노테이션의 value 속성값으로 제공받아 SQL 명령에서 #{속성값}으로 전달값 사용

    • parameterType 속성를 반드시 생략

  • select 엘리먼트의 resultType 속성값으로 HashMap 클래스(Map 인터페이스)로 설정하면 검색행을 Map 객체로 제공

    • Map 객체가 하나의 검색행을 표현
    • 검색행의 컬럼명을 맵키로 매핑되고 컬럼값이 맵값으로 저장되어 엔트리로 추가
    • 검색행의 컬럼명은 대문자로 검색되어 맵키로 매핑 처리
  • 검색 컬럼명과 검색 단어를 전달받아 MYHEWON 테이블에 저장된 회원정보 중 검색 컬럼에 검색 단어가 저장된 회원정보를 검색하여 검색결과를 제공하는 엘리먼트
    • #{변수명|필드명|맵키} : '전달값' - 전달값이 SQL 명령에서 문자값으로 표현
    • ${변수명|필드명|맵키} : 전달값 - 전달값이 SQL 명령에서 문장으로 표현
    • ibatis 프레임워크에서는 변수명∣필드명∣맵키변수명|필드명|맵키 형식으로 표현
    • $ 표현식은 InSQL 공격에 취약하므로 사용하는 것을 비권장

  • 검색 컬럼명과 검색 단어를 전달받아 MYHEWON 테이블에 저장된 회원정보 중 검색 컬럼에 검색 단어가 포함된 회원정보를 검색하여 검색결과를 제공하는 엘리먼트

    • select * from myhewon where ${searchColumn} like '%'||#{searchKeyword}||'%' order by hewon_id
    • searchKeyword가 포함되는 회원정보 검색
    • 결합은 || 로 표현

  • bind : SQL 명령에서 사용하기 위한 이름과 값을 설정하는 엘리먼트 (전달값 변경)

    • bind 엘리먼트로 설정된 값은 SQL 명령에서 #{이름} 형식으로 표현하여 사용
    • name 속성 : SQL 명령에서 사용될 값을 구분하기 위한 식별자를 속성값 설정
    • value 속성 : SQL 명령에서 사용될 값을 속성값으로 설정
    • parameterType 속성으로 전달된 값을 사용할 있으며 문자값 결합(+ 연산자) 기능 제공
    • <bind name="keyword" value="'%'+searchKeyword+'%'"/>


<?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">
<?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.MyHewonMapper">
	<insert id="insertHewon" parameterType="MyHewon">
		insert into myhewon values(#{id},#{name},#{phone},#{email},#{state})
	</insert>
	
	<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>
	
	<!-- 검색된 회원정보에서 공개범위에 따라 다른 매핑정보를 제공하기 위한 resultMap 엘리먼트 -->
	<!-- discriminator : 검색행의 컬럼값을 비교하여 서로 다른 매핑정보를 제공하기 위한 엘리먼트 -->
	<!-- => 하위 엘리먼트로 case 엘리먼트를 사용하여 컬럼값을 비교해 같은 경우 매핑정보 제공 -->
	<!-- javaType 속성 : 검색행의 비교 컬럼값의 Java 자료형을 속성값으로 설정 -->
	<!-- => Java 자료형 대신 typeAlias 엘리먼트의 별칭 사용 가능 -->
	<!-- column 속성 : 검생행의 비교 컬럼명을 속성값으로 설정 -->
	<!-- 
	<resultMap type="MyHewon" id="myHewonDiscriminatorResultMap">
		<discriminator javaType="int" column="hewon_state">
			<case value="1">
				<id column="hewon_id" property="id"/>
				<result column="hewon_state" property="state"/>
			</case>
			<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>
	-->

	<!-- case 엘리먼트의 공통적인 매핑정보가 존재할 경우 discriminator 엘리먼트가 아닌 다른
	엘리먼트를 사용하여 매핑 정보 제공 가능 -->	
	<!--  
	<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 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>
	
	<!-- 매퍼에 등록된 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 기반의 매퍼 파일에 엘리먼트에서 prarmeterType 속성 생략 -->
	
	<!-- 공개범위를 전달받아 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 속성 생략 가능 -->
	<select id="selectStateHewonList" resultMap="myHewonResultMap">
		select * from myhewon where hewon_state=#{state} order by hewon_id
	</select>
	
	<!-- 이름과 이메일을 전달받아 MYHEWON 테이블에 저장된 해당 이름과 이메일의 회원정보에
	대한 아이디를 검색하여 검색결과를 제공하는 엘리먼트 -->
	<!-- => 값을 여러개 전달받아 SQL 명령에서 사용할 경우 parameterType 속성값으로 JavaBean(DTO)
	클래스를 설정하여 JavaBean(DTO) 객체를 전달받고 SQL 명령에서 #{필드명} 형식으로 필드값 사용 -->
	<!-- 
	<select id="selectBeanHewonId" parameterType="MyHewon" resultType="string">
		select hewon_id from myhewon where hewon_name=#{name} and hewon_email=#{email}
	</select>
	-->
	 
	<!-- Interface 기반의 매퍼 파일과 바인딩된 경우 전달값에 상관없이 parameterType	속성 생략 가능 -->
	<select id="selectBeanHewonId" resultType="string">
		select hewon_id from myhewon where hewon_name=#{name} and hewon_email=#{email}
	</select>
	
	<!-- 이름과 이메일을 전달받아 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>
	
	<insert id="insertMapHewon" parameterType="map">
		insert into myhewon values(#{id},#{name},#{phone},#{email},#{state})
	</insert>
	
	<!-- select 엘리먼트의 resultType 속성값으로 HashMap 클래스(Map 인터페이스)로 설정하면
	검색행을 Map 객체로 제공 -  하나의 검색행을 Map 객체로 표현 -->
	<!-- => 검색행의 컬럼명을 맵키로 매핑되고 컬럼값이 맵값으로 매핑되어 엔트리로 추가 -->
	<!-- => 검색행의 컬럼명은 대문자로 검색되어 맵키로 매핑 처리 -->
	<select id="selectMapHewonList" resultType="map">
		select * from myhewon order by hewon_id
	</select>
	
	<!-- 이름과 이메일을 전달받아 MYHEWON 테이블에 저장된 해당 이름과 이메일의 회원정보에
	대한 아이디를 검색하여 검색결과를 제공하는 엘리먼트 -->
	<!-- 매퍼 바인딩된 처리된 인터페이스 기반의 매퍼파일에서 추상메소드의 매개변수에 전달된 
	값을 @Param 어노테이션의 value 속성값으로 제공받아 SQL 명령에서 #{속성값}으로 전달값 사용 -->
	<!-- => parameterType 속성을 반드시 생략 -->
	<select id="selectParamHewonId" resultType="string">
		select hewon_id from myhewon where hewon_name=#{name} and hewon_email=#{email}
	</select>
	
	<!-- 검색 컬럼명과 검색 단어를 전달받아 MYHEWON 테이블에 저장된 회원정보 중 검색 컬럼에
	검색 단어가 저장된 회원정보를 검색하여 검색결과를 제공하는 엘리먼트 -->
	<!-- #{변수명|필드명|맵키} : '전달값' - 전달값이 SQL 명령에서 문자값으로 표현 -->
	<!-- ${변수명|필드명|맵키} : 전달값 - 전달값이 SQL 명령에서 문장으로 표현 -->
	<!-- => ibatis 프레임워크에서는 $변수명|필드명|맵키$ 형식으로 표현 -->
	<!-- => $ 표현식은 InSQL 공격에 취약하므로 사용하는 것을 비권장 -->
	<!--  
	<select id="selectSearchHewonList" parameterType="map" resultMap="myHewonResultMap">
		select * from myhewon where ${searchColumn}=#{searchKeyword} order by hewon_id 
	</select>
	-->
	
	<!-- 검색 컬럼명과 검색 단어를 전달받아 MYHEWON 테이블에 저장된 회원정보 중 검색 컬럼에
	검색 단어가 포함된 회원정보를 검색하여 검색결과를 제공하는 엘리먼트 -->
	<!--  
	<select id="selectSearchHewonList" parameterType="map" resultMap="myHewonResultMap">
		select * from myhewon where ${searchColumn} like '%'||#{searchKeyword}||'%' order by hewon_id 
	</select>
	-->
	
	<select id="selectSearchHewonList" parameterType="map" resultMap="myHewonResultMap">
		<!-- bind : SQL 명령에서 사용하기 위한 이름과 값을 설정하는 엘리먼트 - 전달값 변경 -->
		<!-- => bind 엘리먼트로 설정된 값은 SQL 명령에서 #{이름} 형식으로 표현하여 사용 -->
		<!-- name 속성 : SQL 명령에서 사용될 값을 구분하기 위한 식별자를 속성값 설정 -->
		<!-- value 속성 : SQL 명령에서 사용될 값을 속성값으로 설정 -->
		<!-- => parameterType 속성으로 전달된 값을 사용할 있으며 문자값 결합(+ 연산자) 기능 제공 -->
		<bind name="keyword" value="'%'+searchKeyword+'%'"/>
		select * from myhewon where ${searchColumn} like #{keyword} order by hewon_id 
	</select>
	
</mapper>

📙 interface 매퍼 (hewon)

  • HashMap 클래스(Map 인터페이스)의 제네릭은 맵키를 [String]으로 설정하고 맵값은 [Object]로 설정하여 사용

  • @Param : 추상메소드의 매개변수에 저장된 값을 XML 기반의 맵퍼파일에 엘리먼트에게 전달하여 등록된 SQL 명령에서 사용할 수 있도록 제공하는 어노테이션

    • value 속성 : 추상메소드의 매개변수에 저장된 값을 XML 기반의 매퍼파일의 엘리먼트에 등록된 SQL 명령에서 사용하기 위한 식별자를 속성값으로 설정
    • 다른 속성이 없는 경우 속성값만 설정 가능

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);
	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);
}

📒 DAO class


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;
	}
	
	public int insertHewon(MyHewon hewon) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).insertHewon(hewon);
		} finally {
			sqlSession.close();
		}
	}
	
	public List<MyHewon> selectHewonList() {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectHewonList();
		} finally {
			sqlSession.close();
		}
	}
	
	public List<MyHewon> selectDiscriminatorHewonList() {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectDiscriminatorHewonList();
		} finally {
			sqlSession.close();
		}
	}
	
	public List<MyHewon> selectStateHewonList(int state) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectStateHewonList(state);
		} finally {
			sqlSession.close();
		}
	}
	
	public String selectBeanHewonId(MyHewon hewon) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectBeanHewonId(hewon);
		} finally {
			sqlSession.close();
		}
	}
	
	public String selectMapHewonId(Map<String, Object> map) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectMapHewonId(map);
		} finally {
			sqlSession.close();
		}
	}
	
	public int insertMapHewon(Map<String, Object> map) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).insertMapHewon(map);
		} finally {
			sqlSession.close();
		}
	}
	
	public List<Map<String, Object>> selectMapHewonList() {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectMapHewonList();
		} finally {
			sqlSession.close();
		}
	}
	
	public String selectParamHewonId(String name,String email) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectParamHewonId(name, email);
		} finally {
			sqlSession.close();
		}
	}
	
	public List<MyHewon> selectSearchHewonList(Map<String, Object> map) {
		SqlSession sqlSession=getSqlSessionFactory().openSession(true);
		try {
			return sqlSession.getMapper(MyHewonMapper.class).selectSearchHewonList(map);
		} finally {
			sqlSession.close();
		}
	}
}

🐣 회원 등록

<%@page import="xyz.itwill.dto.MyHewon"%>
<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@ 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));
%>    
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
</head>
<body>
	<h1>회원등록</h1>
	<hr>
	<h3>회원정보가 성공적으로 삽입 되었습니다.</h3>
</body>
</html>

🐣 회원 등록 (Map객체)

  • Map<String, Object> map=new HashMap<String, Object>();

  • 맵객체 생성하여 맵객체 엔트리로 추가

<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@page import="java.util.HashMap"%>
<%@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);
%>    
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
</head>
<body>
	<h1>회원등록</h1>
	<hr>
	<h3>회원정보가 성공적으로 삽입 되었습니다.</h3>
</body>
</html>

🐣 전체 회원 목록

<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@page import="xyz.itwill.dto.MyHewon"%>
<%@page import="java.util.List"%>
<%@ 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>

🐣 전체 회원 목록 (Map객체)

  • select 엘리먼트의 resultType 속성값으로 HashMap 클래스(Map 인터페이스)로 설정하면 검색행을 Map 객체로 제공
    • Map 객체가 하나의 검색행을 표현
    • 검색행의 컬럼명을 맵키로 매핑되고 컬럼값이 맵값으로 저장되어 엔트리로 추가
    • 검색행의 컬럼명은 대문자로 검색되어 맵키로 매핑 처리
    • hewon.get("HEWON_STATE") 

<%@page import="java.util.Map"%>
<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@page import="java.util.List"%>
<%@ 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>

🐣 회원 목록 (공개여부)

<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@page import="xyz.itwill.dto.MyHewon"%>
<%@page import="java.util.List"%>
<%@ 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>

🐣 회원 목록 (상태별 검색)

  • 공개범위(state)를 전달받아 MYHEWON 테이블에 저장된 해당 공개범위의 회원정보 검색


<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@page import="xyz.itwill.dto.MyHewon"%>
<%@page import="java.util.List"%>
<%@ 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">&nbsp;1&nbsp;</option>
			<option value="2">&nbsp;2&nbsp;</option>
			<option value="3">&nbsp;3&nbsp;</option>
			<option value="4">&nbsp;4&nbsp;</option>
		</select>
		<button type="submit">검색</button>
	</form>
</body>
</html>

🐣 회원 id 검색 (java객체)

  • 이름과 이메일을 전달받아 MYHEWON 테이블에 저장된 해당 이름과 이메일의 회원정보에 대한 아이디 검색

  • 값을 여러개 전달받아 SQL 명령에서 사용할 경우 parameterType 속성값으로 JavaBean(DTO) 클래스를 설정하고 SQL 명령에서는 #{필드명} 형식으로 전달받은 JavaBean 객체의 필드값 사용


<%@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().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> 
		</tr>
	</table>	
	</form>
	<hr>
	
	<% 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>

🐣 회원 id 검색 (Map객체)

  • 이름과 이메일을 전달받아 MYHEWON 테이블에 저장된 해당 이름과 이메일의 회원정보에 대한 아이디 검색

  • 값을 여러개 전달받아 SQL 명령에서 사용할 경우 parameterType 속성값으로 HashMap 클래스 (Map 인터페이스)를 설정하고 SQL 명령에서는 #{맵키} 형식으로 전달받은 Map 객체의 맵값 사용

  • 맵객체를 생성해서 맵객체의 엔트리로 추가한후 저장


<%@page import="java.util.HashMap"%>
<%@page import="java.util.Map"%>
<%@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) {
		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> 
		</tr>
	</table>	
	</form>
	<hr>
	
	<% 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>

🐣 회원 id 검색 (@param)

  • 이름과 이메일을 전달받아 MYHEWON 테이블에 저장된 해당 이름과 이메일의 회원정보에 대한 아이디 검색

  • 매퍼 바인딩 처리된 인터페이스 기반의 매퍼파일에서 추상메소드의 매개변수에 전달된 값을 @Param 어노테이션의 value 속성값으로 제공받아 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"%>
<%
	request.setCharacterEncoding("utf-8");
	String name=request.getParameter("name");
	String email=request.getParameter("email");
	
	String id="";
	if(name!=null && email!=null) {
		id=MyHewonDAO.getDAO().selectParamHewonId(name, email);
	}
%>    
<!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> 
		</tr>
	</table>	
	</form>
	<hr>
	
	<% 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>

🐣 검색 단어가 저장된 검색

  • 검색 컬럼명과 검색 단어를 전달받아 MYHEWON 테이블에 저장된 회원정보 중 검색 컬럼에 검색 단어가 저장된 회원정보를 검색하여 검색결과를 제공하는 엘리먼트

<%@page import="java.util.HashMap"%>
<%@page import="java.util.Map"%>
<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@page import="xyz.itwill.dto.MyHewon"%>
<%@page import="java.util.List"%>
<%@ 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<String, Object>();
		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>

🐣 검색 단어가 포함된 검색


<%@page import="java.util.HashMap"%>
<%@page import="java.util.Map"%>
<%@page import="xyz.itwill.dao.MyHewonDAO"%>
<%@page import="xyz.itwill.dto.MyHewon"%>
<%@page import="java.util.List"%>
<%@ 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<String, Object>();
		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>
profile
woom
Study Log 📂
이전 포스트

MyBatis 게시글 답글

다음 포스트

동적 SQL (전달값에 따라 다른 SQL 명령 실행)

0개의 댓글