부트캠프52일차(framwork설명,동적쿼리,인터페이스이용한Mapper , model2Study 리팩토링)

JSP

부트캠프52일차(framwork설명,동적쿼리,인터페이스이용한Mapper , model2Study 리팩토링)

동곤일상 2025. 4. 16. 17:18

1)framwork

2)mybatis 설명

3) 동적쿼리

4) 인터페이스를 이용한 Mapper

4-1) select

4-2) insert , update , delete

5)인터페이스로 동적쿼리사용

6) 다시 model2Study로 돌아가기

6-1)mybatis.config.xml수정

6-2)MyBatisConnection (sqlSession생성)

6-3)MemberMapper(sql구문 )

6-4) MemberDto를 SqlSession을 사용하게끔 바꿈

1) framework

영속성 Framework

데이터의 저장 조회 변경 삭제를 다룸

데이터를 다루는 프로그램이 종료되어도 데이터가 영속되도록함

ex) Mybatis(SQL Mapper) , JPA(ORM)

자바 Framework

Java통한 웹개발을 도와줌

ex)Spring

기능지원 Framework

특정기능이나 업무수행에 도움을 줌

ex)logback or Log4j

2)MyBatis란?

특징

복잡한 SQL을 쉽게다룰수있는 프레임워크

JDBC보다 심플하게만들수있음

SQL문을 XML파일에저장이가능

흐름

MyBatis 환경설정
SQL을 XML파일이나 인터페이스로 정리
MyBatis가 SQL을 대신 실행하고 결과 반환

동작 구조

MyBatis 설정 파일(mybatis-config.xml)
- DB 연결 정보 설정
- SQL구문이 있는 XML파일의 위치 설정
SQL을 XML파일에 작성(~mapper.xml)
- SQL 쿼리문 설정
- 쿼리문을 수행하기 위해 필요한 인자, 결과 타입 등 설정
Java에서 MyBatis를 호출하는 코드 작성

Mybatis-config.xml

MyBatis 실행시 필요한 환경 설정 정보를 담고 있는 파일
주로 연동될 데이터베이스의 정보와 sql문이 작성된 파일(mapper)의 위치를 명시해줌

<environments>태그
- mybatis가 어떤 DB와 연결할지 설정하는 부분
- DB주소, 사용자 계정, 비밀번호 등을 적어줌
- 트랜젝션을 어떻게 처리할지도 설정 가능
<mappers> 태그
- SQL문이 저장된 파일(mapper)의 위치를 알려주는 부분
- mybatis가 이 파일을 보고 SQL문을 찾아서 실행함

Mapper파일

실행하고자 하는 SQL문에 맞춰 태그 추가

SessionTemplate

MyBatis가 제공하는 SqlSession 객체 생성해주는 static 메소드를 가지고 있는 클래스

SQLSession 객체 생성 메소드만 만들어주면 됨

쿼리실행

Parameter Type

설명

MyBatis의 쿼리를 실행하기 위해서 특정 값이 필요한 경우
사용하는 매개변수의 개수, 종류에 따라 작성법이 다름
단일 매개변수인 경우, 매개변수가 여러 개일 경우, 객체 형태로 전달할 경우

2) 단일 매개변수

매개변수가 하나만 존재할때 어떤 이름을 사용하든 관계없음
이론적으로 MyBatis는 자동으로 param1 이라는 이름으로 매핑함
일반적으로 Dao에서 전달한 매개변수명을 그대로 사용함

매개변수가 여러 개일 경우

매개변수가 여러개일 경우 parameterType은 map을 사용
Map의 key값을 #{}안에 사용함
제목과 내용을 기준으로 검색하는 경우

VO 객체(바구니)에 담을 수 있다면 담아서 전달

3) 동적쿼리

mybatis.config.xml에 추가

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org/DTD config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- config파일에서 사용되는 환경변수 설정 -->
  <properties resource="mapper/mybatis.properties" />
  
  <!-- 별명들 -->
  <typeAliases>
  ...
  	<typeAlias type="main.Student" alias="Student" />
  </typeAliases>
  
  <!-- Connection 객체  -->
  <environments default="development">
   ........
  </environments>

  
  <!--  sql 구문을 가진 파일 목록 -->
  <mappers>
	...
  	<mapper resource="mapper/StudentMapper2.xml"/>
  </mappers>
</configuration>

/main/Main3_Dynamic

package main;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.session.SqlSession;

import mapper.MybatisSet;

public class Main3_Dynamic {
	/*
	private  static SqlSessionFactory sqlMap;
	
	//한 번만 초기화되는 전역 SqlSessionFactory를 만들기 위한 구조
	//MyBatis 설정 파일을 읽고 파싱하는 작업을 중앙집중화해서 중복 제거 및 관리 용이성 확보
	public final static  SqlSession getSession() {
		InputStream input = null;
		try {
			input = Resources.getResourceAsStream("mapper/mybatis-config.xml");		
		}
		catch (IOException e) {
			e.printStackTrace();
		}
		sqlMap = new SqlSessionFactoryBuilder().build(input);
		return sqlMap.openSession();
	}
	 이걸로 밑에 getSession()메서드를 만든거임*/

	public static void main(String[] args) {
		SqlSession session = MybatisSet.getSession(); 
		
		System.out.println("학생전체레코드조회");
		List<Student> list = session.selectList("student2.select1");
		for (Student s : list) {
			System.out.println(s);
		}
		System.out.println("--- 1학년학생레코드조회하기 ---");
		Map<String, Object> map = new HashMap<>();
		map.put("grade",1);
		//똑같은 select1쿼리사용(where태그와 if태그이용)
		list = session.selectList("student2.select1",map);
		for (Student s : list) {
			System.out.println(s);
		}
		System.out.println("학생 중 학번이 220111인 레코드조회");
		map.clear(); // 모든요소제거
		map.put("studno", 220111);
		Student st = session.selectOne("student2.select1",map);
		System.out.println(st);
		
		System.out.println("학생 중 키가 180이상인 학생의정보조회");
		map.clear();
		map.put("height", 180);
		list = session.selectList("student2.select1",map);
		for (Student s : list) {
			System.out.println(s);
		}
		
		/*System.out.println("학생 중 키가 180이상인 1학년 학생의정보조회");
		map.clear();
		map.put("height", 180);
		map.put("grade", 1);
		list = session.selectList("student2.select1",map);
		for (Student s : list) {
			System.out.println(s);
		}*/
//------------------------------------------------------------------------------		
		System.out.println("@@@@");
		System.out.println("---------student2.select2로 조회하기----");
		System.out.println("@@@@");
		System.out.println("학생 중 키가 180이상인 1학년 학생의정보조회");
		map.clear();
		map.put("height", 180);
		map.put("grade", 1);
		list = session.selectList("student2.select2",map);
		for (Student s : list) {
			System.out.println(s);
		}
//------------------------------------------------------------------------------------------------------------------		
		System.out.println("@@@@");
		System.out.println("-----------student2.select3로 조회하기------");
		System.out.println("@@@@");
		System.out.println("학생 중 학번이 220111인 레코드조회");
		map.clear(); // 모든요소제거
		map.put("studno", 220111);
		st = session.selectOne("student2.select3",map);
		System.out.println(st);
		
		
		
		System.out.println("전체학생정보조회");
		list = session.selectList("student2.select3");
		for (Student s : list) {
			System.out.println(s);
		}
		
		System.out.println("1학년학생정보조회");
		map.clear();
		map.put("grade", 1);
		list = session.selectList("student2.select3",map);
		for (Student s : list) {
			System.out.println(s);
		}
		
		System.out.println("키가180이상인학생의정보");
		System.out.println("학생 중 키가 180이상인 학생의정보조회");
		map.clear();
		map.put("height", 180);
		list = session.selectList("student2.select3",map);
		for (Student s : list) {
			System.out.println(s);
		}
		
		System.out.println("학생 중 키가 180이상인 1학년 학생의정보조회");
		map.clear();
		map.put("height", 180);
		map.put("grade", 1);
		list = session.selectList("student2.select3",map);
		for (Student s : list) {
			System.out.println(s);
		}
		
		System.out.println("1학년학생중 키가180이상이고 학번이240111인학생");
		map.clear();
		map.put("height", 180);
		map.put("studno",240111);
		map.put("grade", 1);
		list = session.selectList("student2.select3",map);
		for (Student s : list) {
			System.out.println(s);
		}
		
		System.out.println("@@@@");
		System.out.println("-----------student2.select4로 조회하기------");
		System.out.println("@@@@");
		System.out.println("101,201,301학과에 속한 학생의정보조회");
		List<Integer> mlist = Arrays.asList(101,201,301);
		map.clear();
		map.put("column", "major1");
		map.put("datas", mlist);
		list = session.selectList("student2.select4",map);
		for (Student s : list) {
			System.out.println(s);
		}
		
		System.out.println("몸무게가75 80인 학생정보조회");
		mlist = Arrays.asList(75,80);
		map.clear();
		map.put("column", "weight");
		map.put("datas", mlist);
		list = session.selectList("student2.select4",map);
		for (Student s : list) {
			System.out.println(s);
		}
		
		System.out.println("키가170 175 180 185학생정보조회");
		mlist = Arrays.asList(170 ,175 ,180, 185);
		map.clear();
		map.put("column", "height");
		map.put("datas", mlist);
		list = session.selectList("student2.select4",map);
		for (Student s : list) {
			System.out.println(s);
		}

	}
}

동적태그사용한

StudentMapper2.xml

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- sql문장 설정 -->

<mapper namespace="student2" >
	<select id="select1" resultType="Student" parameterType="map">
		select * from student
		<where>
		<if test="grade != null">grade=#{grade}</if>
		<if test="studno != null">studno=#{studno}</if>
		<if test="height != null">height >= #{height}</if>
		</where>
	</select>
<!--동적태그
1.map = null
	select * from student실행
	
2.map=("grade",1)
	select * from student
		where grade=1
		
3.map=("studno",220111)
	select * from student
		where studno=220111
		
4.map=("height",180)
	select * from student
		where height>=180
		
5.map=("height":180,"grade":1)
	select * from student
		where height>=180 grade=1(오류)	
-->

<select id="select2" resultType="Student" parameterType="map">
		select * from student
		<choose>
		<when test="grade != null">
		where grade=#{grade} and height>=#{height}</when>
		<when test="grade != null">where grade=#{grade}</when>
		<when test="studno != null">where studno=#{studno}</when>
		<when test="height != null">where height >= #{height}</when>
		</choose>
	</select><!-- 비효율적임 -->
	
<select id="select3" resultType="Student" parameterType="map">
		select * from student
	<trim prefix="where" prefixOverrides="AND || OR">
		<if test="grade != null">and grade=#{grade}</if>
		<if test="studno != null">and studno=#{studno}</if>
		<if test="height != null">and height >= #{height}</if>
	</trim>
</select>
<!-- 
prefixOverrides="AND || OR"
첫번쨰조건문앞에 and나OR가있다면 없앤다
 -->
 
 
 <select id="select4" resultType="Student" parameterType="map">
		select * from student
	<if test="datas!=null">
		where ${column} in
		<foreach collection="datas" item="d" separator="," 
		open="("  close= ")">#{d}</foreach>
		<!-- (data[0],...,...) -->
	</if>
</select>
 
 <!--
map:{"column":"major1","datas":[101,201,301]}
 	select * from student
 	where major1 in (101,201,301)
 	
map:{"column":"weight","datas":[75,80]}
 	select * from student
 	where weight in (75,80)	
 	
map:{"column":"height","datas":[170 ,175 ,180, 185]}
 	select * from student
 	where height in (170 ,175 ,180, 185)	 	
  -->

</mapper>

4) 인터페이스 이용한 Mapper

4-1) select

인터페이스방식으로 Mapper사용하기

* 1.Mybatis-config.xml의 mapper에 package로설정

* 2.namespace: mapper.StudentMapper / 인터페이스의 전체이름이 namespace임

* 3.메서드의이름이 sql문장의 key값

=>Mapper인터페이스는 오버로딩불가능

config.xml

mappers태그 내에 package태그 추가

  <mappers>
 ....
  	<package name="mapper"/>
  	<!-- mapper패키지의 인터페이스를 sql구문으로등록 -->
  </mappers>

Main4_interface

(인터페이스를 mapper로사용)

package main;

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

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import mapper.MybatisSet;
import mapper.StudentMapper;

public class Main4_interface {
/*	private final static SqlSessionFactory sqlMap;
	
	static { //static변수 초기화
		InputStream input = null;
		try {
			//해당파일을 읽어 myBatis환경을 설정
			input = Resources.getResourceAsStream("mapper/mybatis-config.xml");		
		}
		catch (IOException e) {
			e.printStackTrace();
		}
		//
		sqlMap = new SqlSessionFactoryBuilder().build(input);
	} */ 
	
	//cls : Mapper의 클래스정보
	private final static Class<StudentMapper> cls = StudentMapper.class;
	public static void main(String[] args) {
		SqlSessionFactory sqlMap = MybatisSet.getSessionFactory();
		SqlSession session = sqlMap.openSession();
		System.out.println("모든 학생 정보 조회(인터페이스이용");
		List<Student> list = session.getMapper(cls).select();
		for (Student s : list) {
			System.out.println(s);
		}
		
		System.out.println("@ 1학년학생정보조회 @ ");
		list = session.getMapper(cls).selectGrade(1);
		for (Student s : list) {
			System.out.println(s);
		}
		
		System.out.println("@240111학생조회하기@");
		Student st = session.getMapper(cls).selectStudno(240111);
		System.out.println(st);
		
		
		System.out.println("@인터페이스형태를 xml형식으로호출해보기");
		st=session.selectOne("mapper.StudentMapper.selectStudno",240111);
		System.out.println(st);
		
		System.out.println("@진영훈 학생의 학번과이름 조회해보기");
		list = session.getMapper(cls).selectName("진영훈");
		for (Student s : list) {
			System.out.println(s);
		}
		
		System.out.println("@1학년학생중 키가180이상인 학생정보조회");
		Map<String, Object> map = new HashMap<>();
		map.put("grade", 1);
		map.put("height", 180);
		list = session.getMapper(cls).selectGradeHeight(map);
		for (Student s : list) {
			System.out.println(s);
		}
		
		list = session.getMapper(cls).selectGradeHeight2(1,180);
		for (Student s : list) {
			System.out.println(s);
		}
		
	}
}

(

StudentMapper

(인터페이스)

package mapper;

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

import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import main.Student;

/*
 * 인터페이스방식으로 Mapper사용하기
 * 1.Mybatis-config.xml의 mapper에 package로설정
 * 2.namespace: mapper.StudentMapper.인터페이스의 전체이름이 namespace임
 * 3.메서드의이름이 sql문장의 key값
 * 	=>Mapper인터페이스는 오버로딩불가능
 * */
public interface StudentMapper {

	@Select("select * from student")
	List<Student> select();

	@Select("select * from student where grade=#{i}")
	List<Student> selectGrade(int i);

	@Select("select * from student where studno=#{i}")
	Student selectStudno(int i);
	/*<select id="selectStudno" parameterType="string" resultType="Student">
		select * from student where studno=#{value}
	</select>*/

	@Select("select * from student where name=#{value}")
	List<Student> selectName(String st);

	@Select("select * from student where grade=#{grade} "
			+ " and height>=#{height}")
	List<Student> selectGradeHeight(Map<String, Object> map);

	@Select("select * from student where grade=#{grade} "
			+ " and height>=#{height}")
	//@Param("grade")int a : a변수를 grade key값으로설정
	List<Student> selectGradeHeight2
	(@Param("grade")int a, @Param("height")int b);

}

4-2) 인터페이스로 insert update delete

StudentMapper(인터페이스)의 메서드추가

@Insert("insert into student(studno,name,jumin,id)"
			+ " values(#{studno},#{name},#{jumin},#{id})")
	int insert(Student st);

	@Update("update  student set grade=#{grade}"
			+ ", weight=#{weight} , height=#{height} "
			+ "where name=#{name}")
	int update(Student st);

	@Delete("delete from student where name=#{val}")
	int deleteName(String name);

Main5_interface.java (insert , update , delete )

StudentMapper인터페이스 이용해 쿼리변경

package main;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import mapper.MybatisSet;
import mapper.StudentMapper;


public class Main5_interface {
	
	private final static Class<StudentMapper> cls = StudentMapper.class;
	
	public static void main(String[] args) {
		SqlSessionFactory sqlMap = MybatisSet.getSessionFactory();
		SqlSession session = sqlMap.openSession();
		System.out.println("이몽룡학생추가");
		Student st = new Student();
		st.setStudno(1002);
		st.setName("이몽룡");
		st.setJumin("9710011345111");
		st.setId("leemy97");
		int cnt = session.getMapper(cls).insert(st);
		System.out.println("변경된 레코드수 : "+cnt);
		
		Student dbst= session.getMapper(cls).selectName("이몽룡").get(0);
		System.out.println(dbst);
		
		System.out.println("이몽룡학생의 학년1 , 몸무개80 키175수정");
		st.setGrade(1);
		st.setWeight(80);
		st.setHeight(175);
		int update = session.getMapper(cls).update(st);
		System.out.println("업데이트한 레코드 수 : "+update);
		
		dbst= session.getMapper(cls).selectName("이몽룡").get(0);
		System.out.println(dbst);
		
		System.out.println("이몽룡학생정보 삭제하기");
		cnt = session.getMapper(cls).deleteName(st.getName());
		
		System.out.println(session.getMapper(cls).selectName("이몽룡"));
	}
}

5) 인터페이스로 동적쿼리만들어보기

StudentMapper2.java( 인터페이스)

package mapper;

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

import org.apache.ibatis.annotations.Select;

import main.Student;

/*
 * 동적쿼리(인터페이스)
 * */
public interface StudentMapper2 {

	@Select({"<script>",
		"select * from student",
			"<where>",
			"<if test='grade != null'>grade=#{grade}</if>",
			"<if test='height != null'>height>=#{height}</if>",
			"<if test='weight != null'> weight&lt;=#{weight}</if>",
			//< 를 사용시 태그로인식하므로(&lt(작다))를 이용하자
			"</where>",
			"</script>"})
	List<Student> select(Map<String, Object> map);

	
	@Select({"<script>",
		"select * from student",
			"<trim prefix='where' prefixOverrides='AND || OR'>",
			"<if test='grade != null'>and grade=#{grade}</if>",
			"<if test='height != null'>and height>=#{height}</if>",
			"</trim>",
			"</script>"})
	List<Student> select2(Map<String, Object> map);

}

Main6_interface

package main;

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

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import mapper.MybatisSet;
import mapper.StudentMapper2;

public class Main6_interface {
	private final static Class<StudentMapper2> cls = StudentMapper2.class;
	private static Map<String,Object>map = new HashMap<>();
	
	public static void main(String[] args) {
		SqlSession session = MybatisSet.getSession();
		System.out.println("모든학생정보조회하기");
		List<Student> list = session.getMapper(cls).select(map);
		for (Student s : list) {
			System.out.println(s);
		}
		
		System.out.println("1학년학생의정보");
		map.put("grade", 1);
		list = session.getMapper(cls).select(map);
		for (Student s : list) {
			System.out.println(s);
		}
		
		System.out.println("키가175이상인 학생정보조회");
		map.clear();
		map.put("height", 175);
		list = session.getMapper(cls).select(map);
		for (Student s : list) {
			System.out.println(s);
		}
		
		System.out.println("몸무게가 60 이하인 학생의정보");
		map.clear();
		map.put("weight", 60);
		list = session.getMapper(cls).select(map);
		for (Student s : list) {
			System.out.println(s);
		}
		
		
//----------------------select2 메서드를 이용할거임-------------------------------------
		System.out.println("@");
		System.out.println("select2 이용!!!!!!!");
		System.out.println("@");
		
		System.out.println("1학년학생의정보");
		map.put("grade", 1);
		list = session.getMapper(cls).select2(map);
		for (Student s : list) {
			System.out.println(s);
		}
		
		System.out.println("키가175이상인 학생정보조회");
		map.clear();
		map.put("height", 175);
		list = session.getMapper(cls).select2(map);
		for (Student s : list) {
			System.out.println(s);
		}
		
		System.out.println("1학년학생중 키가175이상인 학생의정보조회하기");
		map.clear();
		map.put("grade", 1);
		map.put("height", 175);
		list = session.getMapper(cls).select2(map);
		for (Student s : list) {
			System.out.println(s);
		}
	}
}

6) 다시 model2Study로 돌아가기

myBatisStudy프로젝트의 해당파일 2개를

model2Study프로젝트의 model하위에

mapper패키지를 만든 후 집어넣는다

/java/model/mapper/

mybatis.properties는 수정할게없다 ( 나의DB정보이기때문)

6-1) mybatis.config.xml수정

(properties resource , typeAlias , mapper 부분만 변경함

(경로도바뀌고 쓸 Mapper가 달라져서)

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org/DTD config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- config파일에서 사용되는 환경변수 설정 -->
  <properties resource="model/mapper/mybatis.properties" />
  
  <!-- 별명들 -->
  <typeAliases>
  	<typeAlias type="model.member.Member" alias="Member"/>
  </typeAliases>
  
  <!-- Connection 객체  -->
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC" />
      <dataSource type="POOLED" >
         <property name="driver" value="${driver}"/>
         <property name="url" value="${url}"/>
         <property name="username" value="${username}"/>
         <property name="password" value="${password}"/>
      </dataSource>
    </environment>
  </environments>
  <!-- 위에서 ${}로 properties에서 지정한값들을 가져온다 -->
  
  <!--  sql 구문을 가진 파일 목록 -->
  <mappers>
  	<package name="model.mapper"/>
  	<!-- mapper패키지의 인터페이스를 sql구문으로등록 -->
  </mappers>

</configuration>

나의 패키지구조

6-2)MyBatisConnection (sqlSession생성)

model패키지 하위에

MyBatisConnection을 만들자!!!!

(session을 만들고 해제하는 메서드존재)

package model;

import java.io.IOException;
import java.io.InputStream;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MyBatisConnection { 
	private MyBatisConnection() {}
	private  static SqlSessionFactory sqlMap;
	//한 번만 초기화되는 전역 SqlSessionFactory를 만들기 위한 구조
	//MyBatis 설정 파일을 읽고 파싱하는 작업을 중앙집중화해서 중복 제거 및 관리 용이성 확보
	static{
		String resource = "model/mapper/mybatis-config.xml";
		InputStream input = null;
		try {
			
			input = Resources.getResourceAsStream(resource);		
		}
		catch (IOException e) {
			e.printStackTrace();
		}
		sqlMap = new SqlSessionFactoryBuilder().build(input);
	}
	
	public static SqlSession getConnection() {
		return sqlMap.openSession();
	}
	
    
    //DB에 commit후 DB를 닫는 메서드
	public static void close(SqlSession session) {
		session.commit();
		session.close();
	}

}

6-3)MemberMapper(sql구문 )

인터페이스 (MemberMapper)

인터페이스에서 SQL을 처리하는 메서드를가짐

model.mapper.MemberMapper.java

package model.mapper;

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

import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import model.member.Member;

public interface MemberMapper {

	@Insert("insert into member(id,pass,name,gender,tel,email,picture)"
			+" values (#{id},#{pass},#{name},#{gender},#{tel},#{email},#{picture})")
	int insert(Member mem);

	@Select("select * from member where id=#{val}")
	Member selectOne(String id);

	@Select("select * from member")
	List<Member> selectList();

	@Update("update member set name=#{name},gender=#{gender},"
			+ " tel=#{tel},email=#{email},picture=#{picture} where id=#{id}")
	int update(Member mem);

	@Delete("delete from member where id=#{id}")
	int delete(String id);

	@Select("select id from member where name=#{name} and tel=#{tel}")
	String idSearch(Map<String, Object> map);

	
	@Select("select pass from member where id=#{id} and tel=#{tel} and email=#{email}")
	String pwSearch(Map<String, Object> map);

	@Update("update member set pass#{pass} where id=#{id}")
	int updatePass(Map<String, Object> map);

	
	
	@Select({"<script>",
			"select * from member where id in",
			" <foreach collection='datas' item='d' separator=',' open='(' close=')'>",
			"#{d}",
			"</foreach>",
			"</script>"
			//select * from member where id in('aa','bb','cc')
	})
	List<Member> emailList(Map<String, Object> map);
}

이 인터페이스를 사용해 DB와의 연결을 할거임

6-4) MemberDto를 SqlSession을 사용하게끔 바꿈

기존의 MemberDto전부 바꿀 예정

(Controller에서 DB와의접속을 위해 사용하는 파일)

변경전 MemberDto

MemberDtoOld.java

0.01MB

변경 후의 MemberDto( MemberMapper인터페이스를 mapper로사용)

SqlSession을 받아 Mapper(MemberMapper)이용해 쿼리실행

package model.member;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.session.SqlSession;

import model.MyBatisConnection;
import model.mapper.MemberMapper;

public class MemberDto {
	private final static Class<MemberMapper> cls = MemberMapper.class;
	private static Map<String,Object>map = new HashMap<>();
	public boolean insert(Member mem) {
		
		SqlSession conn = MyBatisConnection.getConnection(); //DB와 연결하기위한 객체
		
		try {
			if(conn.getMapper(cls).insert(mem)>0) {
				return true;
			}
			else return false;
		}
		catch(Exception e) {
			e.printStackTrace();
		}
		finally {
			MyBatisConnection.close(conn);
//DB에 commit후 DB를 닫는 메서드(finally를 이용해서 항상 해준다)
		}
		return false;
	}
	
	public  Member selectOne(String id) {
		SqlSession session = MyBatisConnection.getConnection();
		try {
			return session.getMapper(cls).selectOne(id);
		}
		catch(Exception e) {
			e.printStackTrace();
		}
		finally {
			MyBatisConnection.close(session);
		}
		return null;	//없다면 null;	
	}
	
	
	public List<Member> list() {
		SqlSession session = MyBatisConnection.getConnection();
		try {
			return session.getMapper(cls).selectList();
		}
		catch(Exception e) {
			e.printStackTrace();
		}
		finally {
			MyBatisConnection.close(session);
		}
		return null;
	}
	
	
		public boolean update(Member mem) {
			SqlSession session = MyBatisConnection.getConnection();
			try {
				if(session.getMapper(cls).update(mem)>0) {
					return true;
				}
				else return false;
			} catch(Exception e) {
				e.printStackTrace();
			} finally {
				MyBatisConnection.close(session);
			}
			return false;
		}
	
		
	public boolean delete(String id) {
		SqlSession session = MyBatisConnection.getConnection();
		String sql = "delete from member where id=?";
		try {
			if(session.getMapper(cls).delete(id)>0) {
				return true;
			}
			else return false;
		}
		catch(Exception e) {
			e.printStackTrace();
		}
		finally {
			MyBatisConnection.close(session);
		}
		return false;
	}


	public String idSearch(String name , String tel) {
		SqlSession session = MyBatisConnection.getConnection();
		String sql = "select id from member where name=? and tel=?";
		map.clear();
		map.put("name",name);
		map.put("tel",tel);
		try {
			return session.getMapper(cls).idSearch(map);
		}
		catch(Exception e) {
			e.printStackTrace();
		}
		finally {
			MyBatisConnection.close(session);
		}
		return null;
	}

	public String pwSearch(String id,String tel,String email) {
		SqlSession session = MyBatisConnection.getConnection();
		String sql = "select pass from member where id=? and tel=? and email=?";
		map.clear();
		map.put("id", id);
		map.put("tel", tel);
		map.put("email", email);
		try {
			return session.getMapper(cls).pwSearch(map);
		}
		catch(Exception e) {
			e.printStackTrace();
		}
		finally {
			MyBatisConnection.close(session);
		}
		return null;
	}
	
	public boolean updatePass(String id , String pass) {
		SqlSession session = MyBatisConnection.getConnection();
		String sql = "update member set pass=? where id=?";
		map.clear();
		map.put("id", id);
		map.put("pass", pass);
		try {
			if(session.getMapper(cls).updatePass(map)>0) {
				return true;
			}
			else return false;
		}
		catch(Exception e) {
			e.printStackTrace();
		}
		finally {
			MyBatisConnection.close(session);
		}
		return false;
	}

	public List<Member> emailList(String[] ids) {
		SqlSession session = MyBatisConnection.getConnection();
		ArrayList<Member> list = new ArrayList<Member>();
		StringBuilder sb = new StringBuilder();
		map.clear();
		map.put("datas", ids);
		try {
			return session.getMapper(cls).emailList(map);
		}
		catch (Exception e) {
			e.printStackTrace();
		}
		finally {
			MyBatisConnection.close(session);
		}
		return null;
	}
	

}

오늘의프로젝트 구조 (최종)

'JSP' 카테고리의 다른 글

부트캠프54일 (답변게시판 , 수정 , 삭제 , 권한) (0)	2025.04.18
부트캠프53일차(게시판생성,writeForm , list , info) (1)	2025.04.17
부트캠프51일차 (model2 idchk) , (MyBatis시작 , 세팅법 사용법) (0)	2025.04.15
부트캠프50일차(Model2 : mail , id pw search , password수정 , pictureForm) (0)	2025.04.14
주말 (49일차에 이어짐 id.pw찾기 , loginForm관련 , picture절대경로만들기) (0)	2025.04.12

현재글부트캠프52일차(framwork설명,동적쿼리,인터페이스이용한Mapper , model2Study 리팩토링)

web동곤

백엔드위주

반복문, Spring, 기본, 자바, `, 메서드, Method, 기초, java, 인텔리제이, 스코프, 코딩, 초보, Eclipse, 꿀팁, 유익한, 유익, 이클립스, Easy, 형변환,

Today :
Yesterday :

내 블로그 - 관리자 홈 전환	`Q` `Q`
새 글 쓰기	`W` `W`

글 수정 (권한 있는 경우)	`E` `E`
댓글 영역으로 이동	`C` `C`

이 페이지의 URL 복사	`S` `S`
맨 위로 이동	`T` `T`
티스토리 홈 이동	`H` `H`
단축키 안내	`Shift` + `/` `⇧` + `/`

2025. 05
일	월	화	수	목	금	토
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30	31