Mybatis

1. 설치

mybatis3.xx

2. 설정

SqlSessionFactory 👉 SqlSession 객체 생성
SqlSessionFactoryBuilder 👉 설정 👉 SqlSessionFactory 객체생성

public class DBConn {
    private static SqlSessionFactory factory;

    static{
        try {
            Reader reader = Resources.getResourceAsReader("configs/mybatis-config.xml"); //SqlSessionFactory 설정 XML파일경로
            factory = new SqlSessionFactoryBuilder().build(reader);
        }catch(IOException e){
            e.printStackTrace();
        }

    }

    public static SqlSession getSession(boolean autoCommit){ //커밋을 제어할수있는 메서드

        return factory.openSession(autoCommit); //기본값은 false이기 때문에 커밋하지않는다.
    }

    public static SqlSession getSession(){ //바로 커밋이 되는 메서드
        return factory.openSession(true);
    }

}

1) XML에서 SqlSessionFactory 빌드하기

변경되지않는 정적 설정파일은 resources에 저장해야한다.

XML설정파일에서 지정하는 마이바티스의 핵심이 되는 설정은 트랜잭션을 제어하기 위한 TransactionManager과 함께 데이터베이스 Connection인스턴스를 가져오기 위한 DataSource 를 포함한다.

<?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="mappers.MemberMapper"> <!--현재파일경로-->
    <resultMap id="memberMap" type="member.Member"> <!--멤버클래스의 변수명을 map처리하여 오라클과 동일하게만듬-->
        <result column="USER_NO" property="userNo" />
        <result column="USER_ID" property="userId" />
        <result column="USER_PW" property="userPw" />
        <result column="USER_NM" property="userNm" />
        <result column="MOBILE" property="mobile" />
        <result column="REG_DT" property="regDt" />
        <result column="MOD_DT" property="modDt" />
    </resultMap>

    <select id="getList" resultMap="memberMap"><!--클래스경로  or 매퍼된변수이름-->
        SELECT * FROM MEMBER
    </select>
    <!--
    <insert>

    </insert>
    <update>

    </update>
    <delete>

    </delete>
    -->
</mapper>

2) SQL매핑하기

<?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="mappers.MemberMapper"> <!--현재파일경로-->
    <select id="getList" resultType="member.Member"> <!--클래스경로-->
        SELECT * FROM MEMBER
    </select>
    <!--
    <insert id="">

    </insert>
    <update id="">

    </update>
    <delete id="">

    </delete>
    -->
</mapper>

3) SqlSession : SQL 구문 실행

• insert(...)
• delete(...)
• update(...)
• List<T> selctList(...)
• T selectOne(...)

public class Member {
    private long USER_NO;
    private String USER_ID;
    private String USER_PW;
    private String USER_NM;
    private String MOBILE;
    private LocalDateTime REG_DT;
    private LocalDateTime MOD_DT;
}
//오라클과 변수명이 동일해야한다.

getMapper(Class class)

public class Ex01 {
    @Test
    void test1(){
        SqlSession session = DBConn.getSession();
        List<Member> members = session.selectList("mappers.MemberMapper.getList");
        members.forEach(System.out::println);

    }

    @Test
    void test2(){
        SqlSession session = DBConn.getSession();
        MemberMapper mapper = session.getMapper(MemberMapper.class);
        //MemberMapper과 동일한 이름인 인터페이스를 구성하여 getList을 통해 가져올수도있다.
        List<Member> members = mapper.getList();
        members.forEach(System.out::println);
    }
}

//MemberMapper과 동일한 이름인 인터페이스를 구성하여 getList을 해당 매퍼를 가져올수도있다.

4)의존성 설정

의존성 설정

5) 매퍼 인터페이스

@Select(...)
@Insert(...)
@Update(...)
@Delete(...)

//MemberMapper 인터페이스
public interface MemberMapper {
    List<Member> getList();

	//멤버클래스에 변수명과 오라클의 변수명이 달라서 오라클의 변수명과 똑같이 해야하기떄문에 별칭을 사용하여 표현
    @Select("SELECT USER_NO userNo, USER_ID userId FROM MEMBER") 
    List<Member> getList2();
}

public class Ex01 {
    @Test
    void test3(){
        SqlSession session = DBConn.getSession();
        MemberMapper mapper = session.getMapper(MemberMapper.class);
        List<Member> members = mapper.getList2();
        members.forEach(System.out::println);
    }
}

3. 적용

4. 로그

SLF4J
slf4j.api : slf4j 가이드라인(인터페이스 위주) 👉 사용하기 위해서는 구현(logback-class)이 필요
logback-class : 구현체

마이바티스는 내부 로그 팩토리를 사용하여 로깅 정보를 제공한다. 내부 로그 팩토리는 로깅 정보를 다른 로그 구현체 중 하나에 전달한다.

설정

1) 의존성

slf4j.api, Logback Classic

implementation 'org.slf4j:slf4j-api:2.0.13' //slf4j.api
implementation 'ch.qos.logback:logback-classic:1.5.6'//Logback Classic Module

2) mybitis 설정 "mybatis-config.xml"

...
    <settings>
        <setting name="logImpl" value="SLF4J"/> <!--log설정-->
    </settings>
...

3) LogBack설정 "logback,xml"

로그레벨 : 레벨별로 출력된다.

• FATAL :
• ERROR :
• WARN : 경고(오류 ❌, 문제 소지가 생길 가능성이 있는 경우)
• INFO : 일반정보
• DEBUG : 자세한 정보
• TRACE : DEBUG보다 더 자세한 정보

<pattern> : 로그 기록 패턴

• %d : 로그 기록 시점(날짜, 시간)
• %p : 로그 레벨, %5p 👉 5글자내에서 로그레벨을 표기
• %t : 쓰레드
• %m : 로그 메세지
• %n : 줄갱
• %c: 패키지명을 포함한 전체 클래스명, %c{2} : 패키지명은 한 자로 축약, 클래스명은 전체이름

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

    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%5level [%thread] - %msg%n</pattern>
        </encoder>
    </appender>

    <root level="INFO"><!--로그레벨-->
        <appender-ref ref="stdout"/>
    </root>

    <logger name="mappers">  <!--매퍼경로-->
        <level value="DEBUG"/> <!--로그레벨-->
    </logger>

</configuration>

insert update delete 빌더사용

(1) MemberMapper 인터페이스

package mappers;

import member.Member;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface MemberMapper {
    List<Member> getList();

    @Select("SELECT USER_NO userNo, USER_ID userId FROM MEMBER")
    List<Member> getList2();

    int register(Member member);
    int register2(Member member); //시퀀스 값 넣는거

    int modify(Member member);

    int delete(String userId);

    @Delete("DELETE FROM MEMBER WHERE USER_ID = #{userID}")
        //간단한 쿼리는 mappers.membermappe에 정의하기보다는 두곳에 정의하기보다는 여기서 정의하여 바로 사용
    int delete2(String userId);


}

(2) member.mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="mappers.MemberMapper"> <!--현재파일경로-->
    <resultMap id="memberMap" type="member.Member"> <!--멤버클래스의 변수명을 map처리하여 오라클과 동일하게만듬-->
        <result column="USER_NO" property="userNo" />
        <result column="USER_ID" property="userId" />
        <result column="USER_PW" property="userPw" />
        <result column="USER_NM" property="userNm" />
        <result column="MOBILE" property="mobile" />
        <result column="REG_DT" property="regDt" />
        <result column="MOD_DT" property="modDt" />
    </resultMap>

    <select id="getList" resultMap="memberMap"><!--클래스경로  or 매퍼된변수이름-->
        SELECT * FROM MEMBER
    </select>
    <insert id="register">
        INSERT INTO MEMBER (USER_NO, USER_ID, USER_PW, USER_NM, MOBILE)
        VALUES (SEQ_MEMBER.NEXTVAL, #{userId}, #{userPw}, #{userNm}, #{mobile})
    </insert>
    <insert id="register2">
        <selectKey keyProperty="userNo" order="BEFORE" resultType="long">
            <!-- 시퀀스객체에 값을 넣을수 있게함.  insert쿼리를 수행하기 전에 먼저 수행해야하기 때문에 BEFORE -->
            SELECT SEQ_MEMBER.NEXTVAL FROM DUAL
        </selectKey>
        INSERT INTO MEMBER (USER_NO, USER_ID, USER_PW, USER_NM, MOBILE)
        VALUES (#{userNo}, #{userId}, #{userPw}, #{userNm}, #{mobile})
        <!-- SELECT SEQ_MEMBER.NEXTVAL FROM DUAL을통해 가져온 시퀀스값을 userno에 넣음 -->
    </insert>
    <update id="modify">
        UPDATE MEMBER
        SET
            USER_PW = #{userPw},
            USER_NM = #{userNm},
            MOBILE = #{mobile},
            MOD_DT = SYSDATE
        WHERE USER_ID = #{userId}
    </update>
    <delete id="delete">
        DELETE FROM MEMBER
        WHERE USER_ID = #{userId}
    </delete>

</mapper>

public class Ex02 {

    private SqlSession session = DBConn.getSession();

    @Test
    void test1(){ //insert
        MemberMapper mapper = session.getMapper(MemberMapper.class);
        Member member = Member.builder()
                .userId("USER" + System.currentTimeMillis())
                .userPw("123456").
                userNm("사용자..").
                mobile("01000000000").
                build();//빌더패턴 사용

        //int cnt = mapper.register(member);
        //int cnt = session.insert("mappers.MemberMapper.register", member);
        int cnt = mapper.register2(member);
        System.out.println(cnt);
        System.out.println(member);
    }

    @Test
    void test2(){ //update
        MemberMapper mapper = session.getMapper(MemberMapper.class);
        Member member = Member.builder()
                .userId("USER01")
                .userPw("123456").
                userNm("(수정)사용자..").
                mobile("01000000000").
                build();//빌더패턴 사용


        int cnt = mapper.modify(member);
        //int cnt = session.update("mappers.MemberMapper.modify", member);
        System.out.println(cnt);
    }

    @Test
    void test3(){
        Member member = Member.builder()
                .userId("USER01")
                .build();
        int cnt = session.delete("mappers.MemberMapper.delete",member);
        System.out.println(cnt);
    }

    @Test
    void test4(){
        MemberMapper mapper = session.getMapper(MemberMapper.class);
        int cnt = mapper.delete("USER02");
        int cnt2 = mapper.delete2("USER03");
        System.out.println(cnt);
        System.out.println(cnt2);
    }
}

5. 동적 SQL

1) if

<update id="modify2"> <!--동적 SQL-->
        UPDATE MEMBER
        SET
            <if test="userPw != null"> <!--동적 SQL-->
                USER_PW = #{userPw},
            </if>
            <if test="userNm != null"> <!--동적 SQL-->
            USER_PW = #{userNm},
            </if>
            <if test="mobile != null"> <!--동적 SQL-->
            MOBILE = #{mobile},
            </if>
            MOD_DT = SYSDATE
        WHERE USER_ID = #{userId}
    </update>

2) choose, when, otherwise

3) trim, where, set

trim

<trim..>
	prefix = "WHERE" : trim 태그 내부에 유효한 조건식이 하나라도 있으면 출력
  	suffix
  	prefixOverrides = "AND | OR" : 가장 앞쪽에 나와 있는 (WHERE 바로 뒤 ) AND 또
  는 OR제거
  	suffixOverrides="," : 마지막","는 제거
</trim>

<select id="getList3" resultMap="memberMap">
        SELECT * FROM MEMBER
        <trim prefix="WHERE" prefixOverrides="AND | OR">
            <if test="userId != null">
                USER_ID = #{userId}
            </if>
            <if test="userNm != null">
                AND USER_NM LIKE #{userNm}
            </if>
            <if test="mobile != null">
                AND MOBILE LIKE #{mobile}
            </if>
        </trim>
    </select>

package exam01;

import configs.DBConn;
import mappers.MemberMapper;
import member.Member;
import org.apache.ibatis.session.SqlSession;
import org.junit.jupiter.api.Test;

import java.util.List;

public class Ex03 {

    private SqlSession session = DBConn.getSession();
  
    @Test
    void test2(){
        MemberMapper mapper = session.getMapper(MemberMapper.class);
        Member member = Member.builder()
                //.userId("USER99")
                .userNm("%사용%")
                .mobile("%010%")
                .build();
        List<Member> members = mapper.getList3(member);
        members.forEach(System.out::println);
    }
}

where

<where>
  
</where>

 <select id="getList3" resultMap="memberMap">
        SELECT * FROM MEMBER
        <where>
            <if test="userId != null">
                USER_ID = #{userId}
            </if>
            <if test="userNm != null">
                AND USER_NM LIKE #{userNm}
            </if>
            <if test="mobile != null">
                AND MOBILE LIKE #{mobile}
            </if>
        </where>
    </select>

set

<update id="modify2"> <!--동적 SQL-->
        UPDATE MEMBER
        <set>
            <if test="userPw != null"> <!--동적 SQL-->
                USER_PW = #{userPw},
            </if>
            <if test="userNm != null"> <!--동적 SQL-->
            USER_PW = #{userNm},
            </if>
            <if test="mobile != null"> <!--동적 SQL-->
            MOBILE = #{mobile},
            </if>
            MOD_DT = SYSDATE
        </set>
        WHERE USER_ID = #{userId}
    </update>

4) foreach

 <select id="getList4" resultMap="memberMap">
        SELECT * FROM MEMBER
        <where>
            <foreach item="item" index="index" collection="list" open="USER_ID IN (" close=")" separator=",">
                #{item}
            </foreach>
        </where>
    </select>

5) bind

USER_NM LIKE '키워드%' : 사용자명이 키워드로 시작하는 패턴
USER_NM LIKE '%키워드' : 사용자명이 키워드로 끝나는 패턴
USER_NM LIKE '%키워드%' : 사용자명이 키워드를 포함하는 패턴
_parameter : MemberMapper인터페이스를 가르킨다*

<<select id="getList3" resultMap="memberMap">
        <bind name="P_userNm" value="'%' + _parameter.getUserNm() + '%'" />
<!--        '_parameter'은 MemberMapper인터페이스를 가르킨다.-->
        <bind name="P_mobile" value="'%' + _parameter.getMobile() + '%'" />
        SELECT * FROM MEMBER
        <where>
            <if test="userId != null">
                USER_ID = #{userId}
            </if>
            <if test="userNm != null">
                AND USER_NM LIKE #{P_userNm}
            </if>
            <if test="mobile != null">
                AND MOBILE LIKE #{P_mobile}
            </if>
        </where>
    </select>
    </select>

6) <![CDATA[]]

<select id = "getList5">
        SELECT * FROM MEMBER WHERE 
        <![CDATA[USER_NO > #{userNo}
        ]]>
</select>