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

       Copyright ${license.git.copyrightYears} the original author or authors.

       Licensed under the Apache License, Version 2.0 (the "License");
       you may not use this file except in compliance with the License.
       You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

       Unless required by applicable law or agreed to in writing, software
       distributed under the License is distributed on an "AS IS" BASIS,
       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
       See the License for the specific language governing permissions and
       limitations under the License.

-->
<document xmlns="http://maven.apache.org/XDOC/2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/XDOC/2.0 http://maven.apache.org/xsd/xdoc-2.0.xsd">

  <properties>
    <title>마이바티스 3 | 매퍼 설정 </title>
    <author email="clinton.begin@gmail.com">Clinton Begin</author>
    <author email="fromm0@gmail.com">이동국(한국어 번역)</author>
  </properties>

  <body>
    <section name="매퍼 설정 ">
      <p>마이바티스 XML 설정파일은 다양한 설정과 프로퍼티를 가진다. 문서의 구조는 다음과 같다.:</p>

      <ul>
        <li>
          configuration
          <ul>
            <li><a href="#properties">properties</a></li>
            <li><a href="#settings">settings</a></li>
            <li><a href="#typeAliases">typeAliases</a></li>
            <li><a href="#typeHandlers">typeHandlers</a></li>
            <li><a href="#objectFactory">objectFactory</a></li>
            <li><a href="#plugins">plugins</a></li>
            <li><a href="#environments">environments</a>
              <ul>
                <li>
                  environment
                  <ul>
                    <li>transactionManager</li>
                    <li>dataSource</li>
                  </ul>
                </li>
              </ul>
            </li>
            <li><a href="#databaseIdProvider">databaseIdProvider</a></li>
            <li><a href="#mappers">mappers</a></li>
          </ul>
        </li>
      </ul>
      <subsection name="properties">
        <p>이 설정은 외부에 옮길 수 있다. 자바 프로퍼티 파일 인스턴스에 설정할 수도 있고 properties 엘리먼트의 하위 엘리먼트에 둘수도 있다. 예를들면:</p>
        <source><![CDATA[<properties resource="org/mybatis/example/config.properties">
  <property name="username" value="dev_user"/>
  <property name="password" value="F2Fa3!33TYyg"/>
</properties>]]></source>
        <p>속성들은 파일 도처에 둘수도 있다. 예를들면:</p>
        <source><![CDATA[<dataSource type="POOLED">
  <property name="driver" value="${driver}"/>
  <property name="url" value="${url}"/>
  <property name="username" value="${username}"/>
  <property name="password" value="${password}"/>
</dataSource>]]></source>
        <p>이 예제에서 username과 password는 properties엘리먼트의 설정된 값으로 대체될 수 있다. driver와 url속성은 config.properties파일에 포함된 값으로 대체될 수도 있다. 이것은 설정에 대한 다양한 옵션을 제공하는 셈이다.</p>
        <p>속성은 SqlSessionFactoryBuilder.build() 메소드에 전달될 수 있다. 예를들면:</p>
        <source><![CDATA[SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, props);

// ... or ...

SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, environment, props);
]]></source>
        <p>속성이 한개 이상 존재한다면 마이바티스는 일정한 순서로 로드한다.:</p>
        <ul>
          <li>properties 엘리먼트에 명시된 속성을 가장 먼저 읽는다.</li>
          <li>properties 엘리먼트의 클래스패스 자원이나 url 속성으로 부터 로드된 속성을 두번째로 읽는다. 그래서 이미 읽은 값이 있다면 덮어쓴다.</li>
          <li>마지막으로 메소드 파라미터로 전달된 속성을 읽는다. 앞서 로드된 값을 덮어쓴다.</li>
        </ul>
        <p>그래서 가장 우선순위가 높은 속성은 메소드의 파라미터로 전달된 값이고 그 다음은 자원및 url 속성이고 마지막은 properties 엘리먼트에 명시된 값이다.</p>

        <p>
          Mybatis 3.4.2 부터, placeholder 에 기본값을 아래처럼 지정할 수 있다.
        </p>
        <source><![CDATA[
<dataSource type="POOLED">
  <!-- ... -->
  <property name="username" value="${username:ut_user}"/> <!-- 만약 'username' 속성이 없다면, username 은 'ut_user' 가 된다. -->
</dataSource>]]></source>

        <p>
          이 기능은 기본적으로 비활성화되어 있다. placeholder 에 기본값을 지정한다면,
          이 기능을 활성화하려면 다음과 같이 특별한 속성을 추가해주어야 한다.
        </p>

        <source><![CDATA[
<properties resource="org/mybatis/example/config.properties">
  <!-- ... -->
  <property name="org.apache.ibatis.parsing.PropertyParser.enable-default-value" value="true"/> <!-- 이 기능을 활성화한다. -->
</properties>]]></source>

        <p>
          <span class="label important">NOTE</span>
          또한 이미 property key (예 : <code>db : username</code>)로 <code>":"</code>를 사용하거나
          SQL 정의에서 OGNL 표현식의 삼항 연산자 (예 : <code>${tableName != null ? tableName : 'global_constants'}</code>)를 사용하는 경우
          다음과 같이 특별한 속성을 추가하여 키와 기본값을 구분하는 문자를 변경해야한다.
        </p>

        <source><![CDATA[
<properties resource="org/mybatis/example/config.properties">
  <!-- ... -->
  <property name="org.apache.ibatis.parsing.PropertyParser.default-value-separator" value="?:"/> <!-- separator 의 기본값을 변경한다. -->
</properties>]]></source>
        <source><![CDATA[
<dataSource type="POOLED">
  <!-- ... -->
  <property name="username" value="${db:username?:ut_user}"/>
</dataSource>]]></source>

      </subsection>
      <subsection name="settings">
        <p>런타임시 마이바티스의 행위를 조정하기 위한 중요한 값들이다. 다음표는 설정과 그 의미 그리고 디폴트 값을 설명한다.</p>

        <table>
          <thead>
            <tr>
              <th>설정</th>
              <th>설명</th>
              <th>사용가능한 값들</th>
              <th>디폴트</th>
            </tr>
          </thead>
          <tbody>
            <tr>
              <td>
                cacheEnabled
              </td>
              <td>설정에서 각 매퍼에 설정된 캐시를 전역적으로 사용할지 말지에 대한 여부 </td>
              <td>
                true | false
              </td>
              <td>
                true
              </td>
            </tr>
            <tr>
              <td>
                lazyLoadingEnabled
              </td>
              <td>
                지연로딩을 사용할지에 대한 여부. 사용하지 않는다면 모두 즉시 로딩할 것이다.
                이 값은 <code>fetchType</code> 속성을 사용해서 대체할 수 있다.
              </td>
              <td>
                true | false
              </td>
              <td>
                false
              </td>
            </tr>
            <tr>
              <td>
                aggressiveLazyLoading
              </td>
              <td>
                활성화되면 모든 메서드 호출은 객체의 모든 lazy properties 을 로드한다. 그렇지 않으면 각 property 가 필요에 따라 로드된다. (<code>lazyLoadTriggerMethods</code> 참조).
              </td>
              <td>
                true | false
              </td>
              <td>
                false (3.4.1 부터 true)
              </td>
            </tr>
            <tr>
              <td>
                multipleResultSetsEnabled
              </td>
              <td>한개의 구문에서 여러개의 ResultSet을 허용할지의 여부(드라이버가 해당 기능을 지원해야 함) </td>
              <td>
                true | false
              </td>
              <td>
                true
              </td>
            </tr>
            <tr>
              <td>
                useColumnLabel
              </td>
              <td>칼럼명 대신에 칼럼라벨을 사용.
			  드라이버마다 조금 다르게 작동한다.
			  문서와 간단한 테스트를 통해 실제 기대하는 것처럼 작동하는지 확인해야 한다.</td>
              <td>
                true | false
              </td>
              <td>
                true
              </td>
            </tr>
            <tr>
              <td>
                useGeneratedKeys
              </td>
              <td>생성키에 대한 JDBC 지원을 허용. 지원하는 드라이버가 필요하다.
			  true로 설정하면 생성키를 강제로 생성한다.
			  일부 드라이버(예를들면, Derby)에서는 이 설정을 무시한다.</td>
              <td>
                true | false
              </td>
              <td>
                False
              </td>
            </tr>
            <tr>
              <td>
                autoMappingBehavior
              </td>
              <td>마이바티스가 칼럼을 필드/프로퍼티에 자동으로 매핑할지와 방법에 대해 명시.
			  PARTIAL은 간단한 자동매핑만 할뿐 내포된 결과에 대해서는 처리하지 않는다.
			  FULL은 처리가능한 모든 자동매핑을 처리한다.</td>
              <td>
                NONE, PARTIAL, FULL
              </td>
              <td>
                PARTIAL
              </td>
            </tr>
            <tr>
              <td>
                autoMappingUnknownColumnBehavior
              </td>
              <td>
                자동매핑 대상중 알수 없는 칼럼(이나 알수없는 프로퍼티 타입)을 발견했을때 행위를 명시
                <ul>
                  <li><code>NONE</code>: 아무것도 하지 않음</li>
                  <li><code>WARNING</code>: 경고 로그를 출력(<code>'org.apache.ibatis.session.AutoMappingUnknownColumnBehavior'</code>의 로그레벨은 <code>WARN</code>이어야 한다.) </li>
                  <li><code>FAILING</code>: 매핑이 실패한다. (<code>SqlSessionException</code>예외를 던진다.)</li>
                </ul>
              </td>
              <td>
                NONE, WARNING, FAILING
              </td>
              <td>
                NONE
              </td>
            </tr>
            <tr>
              <td>
                defaultExecutorType
              </td>
              <td>디폴트 실행자(executor) 설정.
			  SIMPLE 실행자는 특별히 하는 것이 없다.
			  REUSE 실행자는 PreparedStatement를 재사용한다.
			  BATCH 실행자는 구문을 재사용하고 수정을 배치처리한다.</td>
              <td>
                SIMPLE
                REUSE
                BATCH
              </td>
              <td>
                SIMPLE
              </td>
            </tr>
            <tr>
              <td>
                defaultStatementTimeout
              </td>
              <td>데이터베이스로의 응답을 얼마나 오래 기다릴지를 판단하는 타임아웃을 설정</td>
              <td>
				양수
              </td>
              <td>설정되지 않음(null)</td>
            </tr>
            <tr>
              <td>
                defaultFetchSize
              </td>
              <td>
                조회결과를 가져올때 가져올 데이터 크기를 제어하는 용도로 드라이버에 힌트를 설정
				이 파라미터값은 쿼리 설정으로 변경할 수 있다.
              </td>
              <td>
                양수
              </td>
              <td>
                설정하지 않음(null)
              </td>
            </tr>
            <tr>
              <td>
                defaultFetchSize
              </td>
              <td>
                결과를 가져오는 크기를 제어하는 힌트처럼 드라이버에 설정한다.
				이 파라미터는 쿼리설정으로 변경할 수 있다.
              </td>
              <td>
                양수
              </td>
              <td>
                셋팅되지 않음(null)
              </td>
            </tr>
            <tr>
              <td>
                defaultResultSetType
              </td>
              <td>
                Specifies a scroll strategy when omit it per statement settings. (Since: 3.5.2)
              </td>
              <td>
                FORWARD_ONLY | SCROLL_SENSITIVE | SCROLL_INSENSITIVE | DEFAULT(same behavior with 'Not Set')
              </td>
              <td>
                Not Set (null)
              </td>
            </tr>
            <tr>
              <td>
                safeRowBoundsEnabled
              </td>
              <td>
                중첩구문내 RowBound사용을 허용
                허용한다면 false로 설정
              </td>
              <td>
                true | false
              </td>
              <td>
                False
              </td>
            </tr>
            <tr>
              <td>
                safeResultHandlerEnabled
              </td>
              <td>
                중첩구문내 ResultHandler사용을 허용
                허용한다면 false로 설정
              </td>
              <td>
                true | false
              </td>
              <td>
                True
              </td>
            </tr>
            <tr>
              <td>
                mapUnderscoreToCamelCase
              </td>
              <td>
                전통적인 데이터베이스 칼럼명 형태인 A_COLUMN을 CamelCase형태의 자바 프로퍼티명 형태인 aColumn으로 자동으로 매핑하도록 함
              </td>
              <td>
                true | false
              </td>
              <td>
                False
              </td>
            </tr>
            <tr>
              <td>
                localCacheScope
              </td>
              <td>
                마이바티스는 순환참조를 막거나 반복된 쿼리의 속도를 높히기 위해 로컬캐시를 사용한다.
                디폴트 설정인 SESSION을 사용해서 동일 세션의 모든 쿼리를 캐시한다.
                localCacheScope=STATEMENT 로 설정하면 로컬 세션은 구문 실행할때만 사용하고 같은 SqlSession에서 두개의 다른 호출사이에는 데이터를 공유하지 않는다.
              </td>
              <td>
                SESSION | STATEMENT
              </td>
              <td>
                SESSION
              </td>
            </tr>
            <tr>
              <td>
                jdbcTypeForNull
              </td>
              <td>
                JDBC타입을 파라미터에 제공하지 않을때 null값을 처리한 JDBC타입을 명시한다.
                일부 드라이버는 칼럼의 JDBC타입을 정의하도록 요구하지만 대부분은 NULL, VARCHAR 나 OTHER 처럼 일반적인 값을 사용해서 동작한다.
              </td>
              <td>
                JdbcType 이늄. 대부분은 NULL, VARCHAR 나 OTHER 를 공통적으로 사용한다.
              </td>
              <td>
                OTHER
              </td>
            </tr>
            <tr>
              <td>
                lazyLoadTriggerMethods
              </td>
              <td>
                지연로딩을 야기하는 객체의 메소드를 명시
              </td>
              <td>
                메소드 이름을 나열하고 여러개일 경우 콤마(,) 로 구분
              </td>
              <td>
                equals,clone,hashCode,toString
              </td>
            </tr>
            <tr>
              <td>
                defaultScriptingLanguage
              </td>
              <td>
                동적으로 SQL을 만들기 위해 기본적으로 사용하는 언어를 명시
              </td>
              <td>
                타입별칭이나 패키지 경로를 포함한 클래스명
              </td>
              <td>
                org.apache.ibatis.scripting.xmltags.XMLLanguageDriver
              </td>
            </tr>
            <tr>
              <td>
                defaultEnumTypeHandler
              </td>
              <td>
                Enum에 기본적으로 사용되는 <code>TypeHandler</code> 를 지정합니다. (3.4.5 부터)
              </td>
              <td>
                타입별칭이나 패키지 경로를 포함한 클래스명
              </td>
              <td>
                org.apache.ibatis.type.EnumTypeHandler
              </td>
            </tr>
            <tr>
              <td>
                callSettersOnNulls
              </td>
              <td>
                가져온 값이 null일때 setter나 맵의 put 메소드를 호출할지를 명시
                Map.keySet() 이나 null값을 초기화할때 유용하다.
                int, boolean 등과 같은 원시타입은 null을 설정할 수 없다는 점은 알아두면 좋다.
              </td>
              <td>
                true | false
              </td>
              <td>
                false
              </td>
            </tr>
            <tr>
              <td>
                returnInstanceForEmptyRow
              </td>
              <td>
                MyBatis 는 기본적으로 모든 열들의 행이 NULL 이 반환되었을 때 <code>null</code>을 반환한다.
                이 설정을 사용하면 MyBatis가 대신 empty 인스턴스를 반환한다.
                nested results(collection 또는 association) 에도 적용된다. 3.4.2 부터
              </td>
              <td>
                true | false
              </td>
              <td>
                false
              </td>
            </tr>
            <tr>
              <td>
                logPrefix
              </td>
              <td>
                마이바티스가 로거(logger) 이름에 추가할 접두사 문자열을 명시
              </td>
              <td>
                문자열
              </td>
              <td>
                설정하지 않음
              </td>
            </tr>
            <tr>
              <td>
                logImpl
              </td>
              <td>
                마이바티스가 사용할 로깅 구현체를 명시
                이 설정을 사용하지 않으면 마이바티스가 사용할 로깅 구현체를 자동으로 찾는다.
              </td>
              <td>
                SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING
              </td>
              <td>
                설정하지 않음
              </td>
            </tr>
            <tr>
              <td>
                proxyFactory
              </td>
              <td>
                마이바티스가 지연로딩을 처리할 객체를 생성할 때 사용할 프록시 툴을 명시
              </td>
              <td>
                CGLIB | JAVASSIST
              </td>
              <td>
                JAVASSIST (마이바티스 3.3과 이상의 버전)
              </td>
            </tr>
            <tr>
              <td>
                vfsImpl
              </td>
              <td>
                VFS 구현체를 명시
              </td>
              <td>
                콤마를 사용해서 VFS구현체의 패키지를 포함한 전체 클래스명
              </td>
            </tr>
            <tr>
              <td>
                useActualParamName
              </td>
              <td>
                메소드 시그니처에 명시된 실제 이름으로 구문파라미터를 참조하는 것을 허용
				이 기능을 사용하려면 프로젝트를 자바 8의 <code>-parameters</code>옵션을 사용해서 컴파일해야만 한다.(마이바티스 3.4.1이상의 버전)
              </td>
              <td>
                true | false
              </td>
              <td>
                true
              </td>
            </tr>
            <tr>
              <td>
                configurationFactory
              </td>
              <td>
                <code>Configuration</code> 인스턴스를 제공하는 클래스를 지정한다.
                반환된 Configuration 인스턴스는 역직렬화 된 객체의 지연로딩 속성들을 불러오는데 사용된다.
                이 클래스는 <code>static Configuration getConfiguration()</code> 메서드를 가져야 한다. (3.2.3 부터)
              </td>
              <td>
                타입별칭이나 패키지 경로를 포함한 클래스명
              </td>
              <td>
                설정하지 않음
              </td>
            </tr>
          </tbody>
        </table>
        <p>위 설정을 모두 사용한 setting 엘리먼트의 예제이다:</p>
        <source><![CDATA[<settings>
  <setting name="cacheEnabled" value="true"/>
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="multipleResultSetsEnabled" value="true"/>
  <setting name="useColumnLabel" value="true"/>
  <setting name="useGeneratedKeys" value="false"/>
  <setting name="autoMappingBehavior" value="PARTIAL"/>
  <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
  <setting name="defaultExecutorType" value="SIMPLE"/>
  <setting name="defaultStatementTimeout" value="25"/>
  <setting name="defaultFetchSize" value="100"/>
  <setting name="safeRowBoundsEnabled" value="false"/>
  <setting name="mapUnderscoreToCamelCase" value="false"/>
  <setting name="localCacheScope" value="SESSION"/>
  <setting name="jdbcTypeForNull" value="OTHER"/>
  <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>]]></source>

      </subsection>
      <subsection name="typeAliases">
        <p>타입 별칭은 자바 타입에 대한 짧은 이름이다.
		오직 XML 설정에서만 사용되며, 타이핑을 줄이기 위해 존재한다.
		예를들면:</p>
        <source><![CDATA[<typeAliases>
  <typeAlias alias="Author" type="domain.blog.Author"/>
  <typeAlias alias="Blog" type="domain.blog.Blog"/>
  <typeAlias alias="Comment" type="domain.blog.Comment"/>
  <typeAlias alias="Post" type="domain.blog.Post"/>
  <typeAlias alias="Section" type="domain.blog.Section"/>
  <typeAlias alias="Tag" type="domain.blog.Tag"/>
</typeAliases>
]]></source>
        <p>이 설정에서 “Blog”는 여러군데에서 “domain.blog.Blog” 대신 사용할 수 있다.</p>
        <p>마이바티스가 빈을 찾도록 패키지를 명시할 수 있다. 예를들면:
        </p>
        <source><![CDATA[<typeAliases>
  <package name="domain.blog"/>
</typeAliases>
]]></source>
        <p>
          <code>domain.blog</code> 에서 빈을 검색하고 애노테이션이 없을 경우 빈의 이름이 소문자로 변환된 형태의 별칭으로 등록할 것이다.
		  이때 빈의 패키지정보도 제거하고 등록된다.
          이를테면 <code>domain.blog.Author</code>는 <code>author</code>로 등록될 것이다.
		  만약에 <code>@Alias</code> 애노테이션을 사용한다면 이 애노테이션에서 지정한 값이 별칭으로 사용될 것이다.
          아래의 예를 보라:
        </p>
        <source><![CDATA[@Alias("author")
public class Author {
    ...
}
]]></source>
        <p>공통의 자바타입에 대해서는 내장된 타입 별칭이 있다.
		이 모두 대소문자를 가린다.</p>
        <table>
          <thead>
            <tr>
              <th>
                별칭
              </th>
              <th>
                매핑된 타입
              </th>
            </tr>
          </thead>
          <tbody>
            <tr>
              <td>
                _byte
              </td>
              <td>
                byte
              </td>
            </tr>
            <tr>
              <td>
                _long
              </td>
              <td>
                long
              </td>
            </tr>
            <tr>
              <td>
                _short
              </td>
              <td>
                short
              </td>
            </tr>
            <tr>
              <td>
                _int
              </td>
              <td>
                int
              </td>
            </tr>
            <tr>
              <td>
                _integer
              </td>
              <td>
                int
              </td>
            </tr>
            <tr>
              <td>
                _double
              </td>
              <td>
                double
              </td>
            </tr>
            <tr>
              <td>
                _float
              </td>
              <td>
                float
              </td>
            </tr>
            <tr>
              <td>
                _boolean
              </td>
              <td>
                boolean
              </td>
            </tr>
            <tr>
              <td>
                string
              </td>
              <td>
                String
              </td>
            </tr>
            <tr>
              <td>
                byte
              </td>
              <td>
                Byte
              </td>
            </tr>
            <tr>
              <td>
                long
              </td>
              <td>
                Long
              </td>
            </tr>
            <tr>
              <td>
                short
              </td>
              <td>
                Short
              </td>
            </tr>
            <tr>
              <td>
                int
              </td>
              <td>
                Integer
              </td>
            </tr>
            <tr>
              <td>
                integer
              </td>
              <td>
                Integer
              </td>
            </tr>
            <tr>
              <td>
                double
              </td>
              <td>
                Double
              </td>
            </tr>
            <tr>
              <td>
                float
              </td>
              <td>
                Float
              </td>
            </tr>
            <tr>
              <td>
                boolean
              </td>
              <td>
                Boolean
              </td>
            </tr>
            <tr>
              <td>
                date
              </td>
              <td>
                Date
              </td>
            </tr>
            <tr>
              <td>
                decimal
              </td>
              <td>
                BigDecimal
              </td>
            </tr>
            <tr>
              <td>
                bigdecimal
              </td>
              <td>
                BigDecimal
              </td>
            </tr>
            <tr>
              <td>
                object
              </td>
              <td>
                Object
              </td>
            </tr>
            <tr>
              <td>
                map
              </td>
              <td>
                Map
              </td>
            </tr>
            <tr>
              <td>
                hashmap
              </td>
              <td>
                HashMap
              </td>
            </tr>
            <tr>
              <td>
                list
              </td>
              <td>
                List
              </td>
            </tr>
            <tr>
              <td>
                arraylist
              </td>
              <td>
                ArrayList
              </td>
            </tr>
            <tr>
              <td>
                collection
              </td>
              <td>
                Collection
              </td>
            </tr>
            <tr>
              <td>
                iterator
              </td>
              <td>
                Iterator
              </td>
            </tr>
          </tbody>
        </table>
      </subsection>
      <subsection name="typeHandlers">
        <p>마이바티스가 PreparedStatement에 파라미터를 설정하고 ResultSet에서 값을 가져올때마다 TypeHandler는 적절한 자바 타입의 값을 가져오기 위해 사용된다.
        다음의 표는 디폴트 TypeHandlers를 설명한다.</p>
        <p>
          <span class="label important">NOTE</span>
          3.4.5 버전부터, MyBatis는 JSR-310(Date 와 Time API) 를 기본적으로 지원한다.
        </p>
        <table>
          <thead>
            <tr>
              <th>
              타입 핸들러
              </th>
              <th>
              자바 타입
              </th>
              <th>
              JDBC 타입
              </th>
            </tr>
          </thead>
          <tbody>
            <tr>
              <td>
                <code>BooleanTypeHandler</code>
              </td>
              <td>
                <code>java.lang.Boolean</code>, <code>boolean</code>
              </td>
              <td>어떤 호환가능한 BOOLEAN</td>
            </tr>
            <tr>
              <td>
                <code>ByteTypeHandler</code>
              </td>
              <td>
                <code>java.lang.Byte</code>, <code>byte</code>
              </td>
              <td>어떤 호환가능한 NUMERIC 또는 BYTE</td>
            </tr>
            <tr>
              <td>
                <code>ShortTypeHandler</code>
              </td>
              <td>
                <code>java.lang.Short</code>, <code>short</code>
              </td>
              <td>어떤 호환가능한 NUMERIC 또는 SMALLINT</td>
            </tr>
            <tr>
              <td>
                <code>IntegerTypeHandler</code>
              </td>
              <td>
                <code>java.lang.Integer</code>, <code>int</code>
              </td>
              <td>어떤 호환가능한 NUMERIC 또는 INTEGER</td>
            </tr>
            <tr>
              <td>
                <code>LongTypeHandler</code>
              </td>
              <td>
                <code>java.lang.Long</code>, <code>long</code>
              </td>
              <td>어떤 호환가능한 NUMERIC 또는 BIGINT</td>
            </tr>
            <tr>
              <td>
                <code>FloatTypeHandler</code>
              </td>
              <td>
                <code>java.lang.Float</code>, <code>float</code>
              </td>
              <td>어떤 호환가능한 NUMERIC 또는 FLOAT</td>
            </tr>
            <tr>
              <td>
                <code>DoubleTypeHandler</code>
              </td>
              <td>
                <code>java.lang.Double</code>, <code>double</code>
              </td>
              <td>어떤 호환가능한 NUMERIC 또는 DOUBLE</td>
            </tr>
            <tr>
              <td>
                <code>BigDecimalTypeHandler</code>
              </td>
              <td>
                <code>java.math.BigDecimal</code>
              </td>
              <td>어떤 호환가능한 NUMERIC 또는 DECIMAL</td>
            </tr>
            <tr>
              <td>
                <code>StringTypeHandler</code>
              </td>
              <td>
                <code>java.lang.String</code>
              </td>
              <td><code>CHAR</code>, <code>VARCHAR</code></td>
            </tr>
            <tr>
              <td>
                <code>ClobReaderTypeHandler</code>
              </td>
              <td>
                <code>java.io.Reader</code>
              </td>
              <td>
                -
              </td>
            </tr>
            <tr>
              <td>
                <code>ClobTypeHandler</code>
              </td>
              <td>
                <code>java.lang.String</code>
              </td>
              <td><code>CLOB</code>, <code>LONGVARCHAR</code></td>
            </tr>
            <tr>
              <td>
                <code>NStringTypeHandler</code>
              </td>
              <td>
                <code>java.lang.String</code>
              </td>
              <td><code>NVARCHAR</code>, <code>NCHAR</code></td>
            </tr>
            <tr>
              <td>
                <code>NClobTypeHandler</code>
              </td>
              <td>
                <code>java.lang.String</code>
              </td>
              <td>NCLOB</td>
            </tr>
            <tr>
              <td>
                <code>BlobInputStreamTypeHandler</code>
              </td>
              <td>
                <code>java.io.InputStream</code>
              </td>
              <td>
                -
              </td>
            </tr>
            <tr>
              <td>
                <code>ByteArrayTypeHandler</code>
              </td>
              <td>
                <code>byte[]</code>
              </td>
              <td>어떤 호환가능한 byte 스트림 타입</td>
            </tr>
            <tr>
              <td>
                <code>BlobTypeHandler</code>
              </td>
              <td>
                <code>byte[]</code>
              </td>
              <td>
                <code>BLOB</code>, <code>LONGVARBINARY</code>
              </td>
            </tr>
            <tr>
              <td>
                <code>DateTypeHandler</code>
              </td>
              <td>
                <code>java.util.Date</code>
              </td>
              <td>
                <code>TIMESTAMP</code>
              </td>
            </tr>
            <tr>
              <td>
                <code>DateOnlyTypeHandler</code>
              </td>
              <td>
                <code>java.util.Date</code>
              </td>
              <td>
                <code>DATE</code>
              </td>
            </tr>
            <tr>
              <td>
                <code>TimeOnlyTypeHandler</code>
              </td>
              <td>
                <code>java.util.Date</code>
              </td>
              <td>
                <code>TIME</code>
              </td>
            </tr>
            <tr>
              <td>
                <code>SqlTimestampTypeHandler</code>
              </td>
              <td>
                <code>java.sql.Timestamp</code>
              </td>
              <td>
                <code>TIMESTAMP</code>
              </td>
            </tr>
            <tr>
              <td>
                <code>SqlDateTypeHandler</code>
              </td>
              <td>
                <code>java.sql.Date</code>
              </td>
              <td>
                <code>DATE</code>
              </td>
            </tr>
            <tr>
              <td>
                <code>SqlTimeTypeHandler</code>
              </td>
              <td>
                <code>java.sql.Time</code>
              </td>
              <td>
                <code>TIME</code>
              </td>
            </tr>
            <tr>
              <td>
                <code>ObjectTypeHandler</code>
              </td>
              <td>
                Any
              </td>
              <td>
                <code>OTHER</code>, 또는 명시하지 않는
              </td>
            </tr>
            <tr>
              <td>
                <code>EnumTypeHandler</code>
              </td>
              <td>
                Enumeration Type
              </td>
              <td>
                <code>VARCHAR</code> – 문자열 호환타입.
              </td>
            </tr>
            <tr>
              <td>
                <code>EnumOrdinalTypeHandler</code>
              </td>
              <td>
                열거형(Enumeration) 타입
              </td>
              <td>
                코드자체가 아니라 위치를 저장할수 있는 <code>NUMERIC</code> 또는 <code>DOUBLE</code>와 호환가능한 타입
              </td>
            </tr>
            <tr>
              <td>
                <code>SqlxmlTypeHandler</code>
              </td>
              <td>
                <code>java.lang.String</code>
              </td>
              <td>
                <code>SQLXML</code>
              </td>
            </tr>
            <tr>
              <td>
                <code>InstantTypeHandler</code>
              </td>
              <td>
                <code>java.time.Instant</code>
              </td>
              <td>
                <code>TIMESTAMP</code>
              </td>
            </tr>
            <tr>
              <td>
                <code>LocalDateTimeTypeHandler</code>
              </td>
              <td>
                <code>java.time.LocalDateTime</code>
              </td>
              <td>
                <code>TIMESTAMP</code>
              </td>
            </tr>
            <tr>
              <td>
                <code>LocalDateTypeHandler</code>
              </td>
              <td>
                <code>java.time.LocalDate</code>
              </td>
              <td>
                <code>DATE</code>
              </td>
            </tr>
            <tr>
              <td>
                <code>LocalTimeTypeHandler</code>
              </td>
              <td>
                <code>java.time.LocalTime</code>
              </td>
              <td>
                <code>TIME</code>
              </td>
            </tr>
            <tr>
              <td>
                <code>OffsetDateTimeTypeHandler</code>
              </td>
              <td>
                <code>java.time.OffsetDateTime</code>
              </td>
              <td>
                <code>TIMESTAMP</code>
              </td>
            </tr>
            <tr>
              <td>
                <code>OffsetTimeTypeHandler</code>
              </td>
              <td>
                <code>java.time.OffsetTime</code>
              </td>
              <td>
                <code>TIME</code>
              </td>
            </tr>
            <tr>
              <td>
                <code>ZonedDateTimeTypeHandler</code>
              </td>
              <td>
                <code>java.time.ZonedDateTime</code>
              </td>
              <td>
                <code>TIMESTAMP</code>
              </td>
            </tr>
            <tr>
              <td>
                <code>YearTypeHandler</code>
              </td>
              <td>
                <code>java.time.Year</code>
              </td>
              <td>
                <code>INTEGER</code>
              </td>
            </tr>
            <tr>
              <td>
                <code>MonthTypeHandler</code>
              </td>
              <td>
                <code>java.time.Month</code>
              </td>
              <td>
                <code>INTEGER</code>
              </td>
            </tr>
            <tr>
              <td>
                <code>YearMonthTypeHandler</code>
              </td>
              <td>
                <code>java.time.YearMonth</code>
              </td>
              <td>
                <code>VARCHAR</code> or <code>LONGVARCHAR</code>
              </td>
            </tr>
            <tr>
              <td>
                <code>JapaneseDateTypeHandler</code>
              </td>
              <td>
                <code>java.time.chrono.JapaneseDate</code>
              </td>
              <td>
                <code>DATE</code>
              </td>
            </tr>
          </tbody>
        </table>
        <p>지원하지 않거나 비표준인 타입에 대해서는 당신 스스로 만들어서 타입핸들러를 오버라이드할 수 있다.
        그러기 위해서는 TypeHandler 인터페이스를 구현하고 자바 타입에 TypeHandler를 매핑하면 된다.
		예를들면:</p>

        <source><![CDATA[// ExampleTypeHandler.java
@MappedJdbcTypes(JdbcType.VARCHAR)
public class ExampleTypeHandler extends BaseTypeHandler<String> {

  @Override
  public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) throws SQLException {
    ps.setString(i, parameter);
  }

  @Override
  public String getNullableResult(ResultSet rs, String columnName) throws SQLException {
    return rs.getString(columnName);
  }

  @Override
  public String getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
    return rs.getString(columnIndex);
  }

  @Override
  public String getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
    return cs.getString(columnIndex);
  }
}
]]></source>

        <source><![CDATA[<!-- mybatis-config.xml -->
<typeHandlers>
  <typeHandler handler="org.mybatis.example.ExampleTypeHandler"/>
</typeHandlers>
]]></source>

        <p>이러한 TypeHandler를 사용하는 것은 자바 String프로퍼티와 VARCHAR파라미터 및 결과를 위해 이미 존재하는 핸들러를 오버라이드하게 될 것이다.
        마이바티스는 타입을 판단하기 위해 데이터베이스의 메타데이터를 보지 않는다.
		그래서 파라미터와 결과에 정확한 타입 핸들러를 매핑해야 한다.
        마이바티스가 구문이 실행될때까지는 데이터 타입에 대해 모르기 때문이다.</p>
        <p>마이바티스는 제네릭타입을 체크해서 TypeHandler로 다루고자 하는 자바타입을 알것이다.
		하지만 두가지 방법으로 이 행위를 재정의할 수 있다:
        </p>
        <ul>
          <li>typeHandler 엘리먼트의 <code>javaType</code> 속성 추가(예제: <code>javaType="String"</code>)
          </li>
          <li>TypeHandler클래스에 관련된 자바타입의 목록을 정의하는 <code>@MappedTypes</code> 애노테이션 추가.
          <code>javaType</code> 속성도 함께 정의되어 있다면 <code>@MappedTypes</code>는 무시된다.</li>
        </ul>

        <p>관련된 JDBC타입은 두가지 방법으로 명시할 수 있다:</p>
        <ul>
          <li>typeHandler 엘리먼트에 <code>jdbcType</code> 속성 추가(예제: <code>jdbcType="VARCHAR"</code>).
          </li>
          <li>TypeHandler클래스에 관련된 JDBC타입의 목록을 정의하는 <code>@MappedJdbcTypes</code> 애노테이션 추가.
          <code>jdbcType</code> 속성도 함께 정의되어 있다면 <code>@MappedJdbcTypes</code>는 무시된다.</li>
        </ul>

        <p>
          <code>ResultMap</code>에서 타입핸들러를 사용한다고 결정하면 마이바티스가 자바타입은 잘 처리하지만 JDBC타입은 잘 처리하지 못할 수 있다.
		  그래서 마이바티스는 타입핸들러를 선택하기 위해 <code>javaType=[TheJavaType], jdbcType=null</code>조합을 사용한다.
		  <code>@MappedJdbcTypes</code> 애노테이션의 사용은 타입핸들러의  범위를 <i>제한</i>하고 명시적으로 설정하지 않는한 <code>결과매핑</code>을 사용하지 못하도록 만든다.
		  <code>결과매핑</code>에서 타입핸들러를 사용할수 있도록 하려면 <code>@MappedJdbcTypes</code>애노테이션에 <code>includeNullJdbcType=true</code>를 설정하자.
		  자바타입을 다루기 위해 <b>한개의</b> 타입핸들러만 등록한다면 <code>결과매핑</code>에서 자바타입을 다루기 위해 이 타입핸들러를 기본적으로 사용할 것이다.
		  한개의 타입핸들러만 등록할 경우 <code>includeNullJdbcType=true</code>를 설정하지 않아도 동일하게 동작한다.
        </p>

        <p>마지막으로 마이바티스로 하여금 TypeHandler를 찾도록 할수 있다:</p>
        <source><![CDATA[<!-- mybatis-config.xml -->
<typeHandlers>
  <package name="org.mybatis.example"/>
</typeHandlers>
]]></source>

        <p>JDBC타입에 대한 자동검색 기능은 애노테이션을 명시한 경우에만 가능하다는 것을 알아둘 필요가 있다. </p>
        <p>
          한개 이상의 클래스를 다루는 제네릭 TypeHandler를 만들수 있다.
          파라미터로 클래스를 가져오는 생성자를 추가하고 마이바티스는 TypeHandler를 만들때 실제 클래스를 전달할 것이다.
        </p>

        <source><![CDATA[//GenericTypeHandler.java
public class GenericTypeHandler<E extends MyObject> extends BaseTypeHandler<E> {

  private Class<E> type;

  public GenericTypeHandler(Class<E> type) {
    if (type == null) throw new IllegalArgumentException("Type argument cannot be null");
    this.type = type;
  }
  ...
]]></source>

		<p><code>EnumTypeHandler</code> 와 <code>EnumOrdinalTypeHandler</code> 는 제네릭 TypeHandler이다.
		이어서 각각을 다룬다.
		</p>

      </subsection>

      <subsection name="Handling Enums">
      	<p>
      	<code>Enum</code>을 매핑하고자 한다면 <code>EnumTypeHandler</code> 나 <code>EnumOrdinalTypeHandler</code> 를 사용할 필요가 있을것이다.
      	</p>

      	<p>예를들어 순환 방식으로 몇개의 숫자를 사용하는 순환모드를 저장할 필요가 있다고 해보자.
      	기본적으로 마이바티스는 <code>Enum</code> 값을 각각의 이름으로 변환하기 위해 <code>EnumTypeHandler</code> 를 사용한다.
      	</p>

      	<b><code>EnumTypeHandler</code>는 특히 다른 핸들러와 차이가 있다.
      	어떤 하나의 특정 클래스를 다루지 않고 <code>Enum</code> 을 확장하는 모든 클래스를 다룬다. </b>

      	<p>아무리 이름을 저장하려해도 DBA는 숫자코드를 고집할수 있다.
		이름대신 숫자코드를 저장하는 방법은 쉽다.
      	설정파일의 <code>typeHandlers</code>에 <code>EnumOrdinalTypeHandler</code> 를 추가하자.
      	그러면 각각의 <code>RoundingMode</code>는 순서값을 사용해서 숫자를 매핑할 것이다.
      	</p>
       <source><![CDATA[<!-- mybatis-config.xml -->
<typeHandlers>
  <typeHandler handler="org.apache.ibatis.type.EnumOrdinalTypeHandler" javaType="java.math.RoundingMode"/>
</typeHandlers>
]]></source>
		<p>
		  같은 <code>Enum</code>을 사용해서 어떤곳에는 문자열로 매핑하고 다른곳에는 숫자로 매핑해야 한다면 무엇을 해야 하나?
		</p>
      	<p>
      	  자동매퍼는 <code>EnumOrdinalTypeHandler</code> 를 자동으로 사용할 것이다.
      	  그래서 평범한 순서를 나타내는 <code>EnumTypeHandler</code> 를 사용하고자 한다면 SQL구문에 사용할 타입핸들러를 몀시적으로 설정한다.
      	</p>
      	<p>
      	  (매퍼 파일은 다음절까지는 다루지 않는다.
      	  그래서 문서를 보면서 처음 봤다면 일단 이부분은 건너띄고 다음에 다시 볼수도 있다. )
      	</p>
      	<source><![CDATA[<!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="org.apache.ibatis.submitted.rounding.Mapper">
	<resultMap type="org.apache.ibatis.submitted.rounding.User" id="usermap">
		<id column="id" property="id"/>
		<result column="name" property="name"/>
		<result column="funkyNumber" property="funkyNumber"/>
		<result column="roundingMode" property="roundingMode"/>
	</resultMap>

	<select id="getUser" resultMap="usermap">
		select * from users
	</select>
	<insert id="insert">
	    insert into users (id, name, funkyNumber, roundingMode) values (
	    	#{id}, #{name}, #{funkyNumber}, #{roundingMode}
	    )
	</insert>

	<resultMap type="org.apache.ibatis.submitted.rounding.User" id="usermap2">
		<id column="id" property="id"/>
		<result column="name" property="name"/>
		<result column="funkyNumber" property="funkyNumber"/>
		<result column="roundingMode" property="roundingMode" typeHandler="org.apache.ibatis.type.EnumTypeHandler"/>
	</resultMap>
	<select id="getUser2" resultMap="usermap2">
		select * from users2
	</select>
	<insert id="insert2">
	    insert into users2 (id, name, funkyNumber, roundingMode) values (
	    	#{id}, #{name}, #{funkyNumber}, #{roundingMode, typeHandler=org.apache.ibatis.type.EnumTypeHandler}
	    )
	</insert>

</mapper>
]]></source>
		<p>
		  여기서 사용한 select구문에서는 <code>resultType</code> 대신에 <code>resultMap</code>을 사용해야 한다는 점을 알아두자.
		</p>
      </subsection>

      <subsection name="objectFactory">
        <p>매번 마이바티스는 결과 객체의 인스턴스를 만들기 위해 ObjectFactory를 사용한다.
		디폴트 ObjectFactory 는 디폴트 생성자를 가진 대상 클래스를 인스턴스화하는 것보다 조금 더 많은 작업을 한다.
		ObjectFactory 의 디폴트 행위를 오버라이드하고자 한다면 만들 수 있다.
		예를들면:</p>
        <source><![CDATA[// ExampleObjectFactory.java
public class ExampleObjectFactory extends DefaultObjectFactory {
  public Object create(Class type) {
    return super.create(type);
  }
  public Object create(Class type, List<Class> constructorArgTypes, List<Object> constructorArgs) {
    return super.create(type, constructorArgTypes, constructorArgs);
  }
  public void setProperties(Properties properties) {
    super.setProperties(properties);
  }
  public <T> boolean isCollection(Class<T> type) {
    return Collection.class.isAssignableFrom(type);
  }}
]]></source>

        <source><![CDATA[<!-- mybatis-config.xml -->
<objectFactory type="org.mybatis.example.ExampleObjectFactory">
  <property name="someProperty" value="100"/>
</objectFactory>]]></source>
        <p>ObjectFactory인터페이스는 매우 간단한다.
		두개의 create메소드를 가지고 있으며 하나는 디폴트 생성자를 처리하고 다른 하나는 파라미터를 가진 생성자를 처리한다.
		마지막으로 setProperties 메소드는 ObjectFactory를 설정하기 위해 사용될 수 있다.
		objectFactory엘리먼트에 정의된 프로퍼티는 ObjectFactory인스턴스가 초기화된 후 setProperties에 전달될 것이다.</p>

      </subsection>
      <subsection name="plugins">
        <p>마이바티스는 매핑 구문을 실행하는 어떤 시점에 호출을 가로챈다.
		기본적으로 마이바티스는 메소드 호출을 가로채기 위한 플러그인을 허용한다.</p>
        <ul>
          <li>
            Executor
            (update, query, flushStatements, commit, rollback,
            getTransaction, close,
            isClosed)
          </li>
          <li>
            ParameterHandler
            (getParameterObject, setParameters)
          </li>
          <li>
            ResultSetHandler
            (handleResultSets, handleOutputParameters)
          </li>
          <li>
            StatementHandler
            (prepare, parameterize, batch, update, query)
          </li>
        </ul>
        <p>이 클래스들의 메소드는 각각 메소드 시그니처를 통해 찾을 수 있고 소스코드는 마이바티스 릴리즈 파일에서 찾을 수 있다.
		오버라이드할 메소드의 행위를 이해해야만 한다.
		주어진 메소드의 행위를 변경하거나 오버라이드하고자 한다면 마이바티스의 핵심기능에 악영향을 줄수도 있다.
		이러한 로우레벨 클래스와 메소드들은 주의를 해서 사용해야 한다.</p>
        <p>플러그인을 사용하도록 처리하는 방법은 간단하다.
		Interceptor인터페이스를 구현해서 가로채고(intercept) 싶은 시그니처를 명시해야 한다.</p>

        <source><![CDATA[// ExamplePlugin.java
@Intercepts({@Signature(
  type= Executor.class,
  method = "update",
  args = {MappedStatement.class,Object.class})})
public class ExamplePlugin implements Interceptor {
  private Properties properties = new Properties();
  public Object intercept(Invocation invocation) throws Throwable {
    // implement pre processing if need
    Object returnObject = invocation.proceed();
    // implement post processing if need
    return returnObject;
  }
  public void setProperties(Properties properties) {
    this.properties = properties;
  }
}]]></source>

        <source><![CDATA[<!-- mybatis-config.xml -->
<plugins>
  <plugin interceptor="org.mybatis.example.ExamplePlugin">
    <property name="someProperty" value="100"/>
  </plugin>
</plugins>]]></source>
        <p>위 플러그인은 매핑된 구문의 로우레벨 실행을 책임지는 내부 객체인 Executor인스턴스의 “update” 메소드 호출을 모두 가로챌것이다.</p>
        <p><span class="label important">참고</span>
          <strong>설정파일 오버라이드하기</strong>
        </p>
        <p>플러그인을 사용해서 마이바티스 핵심 행위를 변경하기 위해 Configuration클래스 전체를 오버라이드 할 수 있다.
		이 클래스를 확장하고 내부 메소드를 오버라이드하고 SqlSessionFactoryBuilder.build(myConfig)메소드에 그 객체를 넣어주면 된다.
		다시 얘기하지만 이 작업은 마이바티스에 큰 영향을 줄수 있으니 주의해서 해야 한다.</p>
      </subsection>
      <subsection name="environments">
        <p>마이바티스는 여러개의 환경으로 설정할 수 있다.
		여러가지 이유로 여러개의 데이터베이스에 SQL Map을 적용하는데 도움이 된다.
		예를들어, 개발, 테스트, 리얼 환경을 위해 별도의 설정을 가지거나 같은 스키마를 여러개의 DBMS 제품을 사용할 경우들이다.
		그외에도 많은 경우가 있을 수 있다.</p>
        <p>
          <strong>중요하게 기억해야 할 것은 다중 환경을 설정할 수는 있지만 SqlSessionFactory 인스턴스마다 한개만 사용할 수 있다는 것이다.</strong>
        </p>
        <p>두개의 데이터베이스에 연결하고 싶다면 SqlSessionFactory 인스턴스를 두개 만들 필요가 있다.
		세개의 데이터베이스를 사용한다면 역시 세개의 인스턴스를 필요로 한다.
		기억하기 쉽게</p>
        <ul>
          <li>
            <strong>데이터베이스별로 하나의 SqlSessionFactory</strong>
          </li>
        </ul>
        <p>환경을 명시하기 위해 SqlSessionFactoryBuilder에 옵션으로 추가 파라미터를 주면 된다.
		환경을 선택하는 두가지 시그니처는</p>

        <source><![CDATA[SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, environment);
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, environment,properties);]]></source>

        <p>environment 파라미터가 없으면 디폴트 환경이 로드된다.</p>

        <source><![CDATA[SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader);
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader,properties);]]></source>

        <p>environments 엘리먼트는 환경을 설정하는 방법을 정의한다.</p>

        <source><![CDATA[<environments default="development">
  <environment id="development">
    <transactionManager type="JDBC">
      <property name="..." value="..."/>
    </transactionManager>
    <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>]]></source>
        <p>중요한 부분을 살펴보면</p>
        <ul>
          <li>디폴트 환경(Environment) ID (예를들면. default=”development”).</li>
          <li>각각의 환경을 정의한 환경(Environment) ID (예를들면. id=”development”).</li>
          <li>TransactionManager 설정 (예를들면. type=”JDBC”)</li>
          <li>DataSource 설정 (예를들면. type=”POOLED”)</li>
        </ul>
        <p>디폴트 환경(environment)과 환경(environment) ID 는 용어 자체가 역할을 설명한다.</p>
        <p>
          <strong>transactionManager</strong>
        </p>
        <p>마이바티스는 두가지 타입의 TransactionManager를 제공한다.</p>
        <ul>
          <li>JDBC - 이 설정은 간단하게 JDBC 커밋과 롤백을 처리하기 위해 사용된다.
		  트랜잭션의 스코프를 관리하기 위해 dataSource 로 부터 커넥션을 가져온다. </li>
          <li>MANAGED - 이 설정은 어떤것도 하지 않는다.
		  결코 커밋이나 롤백을 하지 않는다.
		  대신 컨테이너가 트랜잭션의 모든 생명주기를 관리한다.
		  디플트로 커넥션을 닫긴 한다.
		  하지만 몇몇 컨테이너는 커넥션을 닫는 것 또한 기대하지 않기 때문에 커넥션 닫는 것으로 멈추고자 한다면 “closeConnection”프로퍼티를 false로 설정하라.
		  예를들면:
            <source><![CDATA[<transactionManager type="MANAGED">
  <property name="closeConnection" value="false"/>
</transactionManager>]]></source>
          </li>
        </ul>
        <p>
          <span class="label important">참고</span>당신은 마이바티스를 스프링과 함께 사용하는 경우에는 구성할 필요가 없습니다
          스프링 모듈 자체의 설정 때문에 어떤 TransactionManager 이전에 설정된 구성을 무시합니다.</p>
        <p>TransactionManager 타입은 어떠한 프로퍼티도 필요하지 않다.
		어쨌든 둘다 타입 별칭이 있다.
		즉 TransactionFactory를 위한 클래스 명이나 타입 별칭 중 하나를 사용할 수 있다.</p>
        <source><![CDATA[public interface TransactionFactory {
  default void setProperties(Properties props) { // Since 3.5.2, change to default method
    // NOP
  }
  Transaction newTransaction(Connection conn);
  Transaction newTransaction(DataSource dataSource, TransactionIsolationLevel level, boolean autoCommit);
}]]></source>
        <p>XML에 설정된 프로퍼티는 인스턴스를 만든 뒤 setProperties()메소드에 전달할 것이다.
		당신의 구현체가 Transaction구현체를 만들 필요가 있을 것이다.:</p>
        <source><![CDATA[public interface Transaction {
  Connection getConnection() throws SQLException;
  void commit() throws SQLException;
  void rollback() throws SQLException;
  void close() throws SQLException;
  Integer getTimeout() throws SQLException;
}]]></source>
        <p>이 두개의 인터페이스를 사용하여 마이바티스가 트랜잭션을 처리하는 방법을 완벽하게 정의할 수 있다.</p>
        <p>
          <strong>dataSource</strong>
        </p>
        <p>dataSource엘리먼트는 표준 JDBC DataSource인터페이스를 사용하여 JDBC Connection객체의 소스를 설정한다.</p>
        <ul>
          <li>대부분의 마이바티스 애플리케이션은 예제처럼 dataSource를 설정할 것이다.</li>
        </ul>
        <p>여기엔 3 가지의 내장된 dataSource타입이 있다.</p>
        <p>
          <strong>UNPOOLED</strong> - 이 구현체는 매번 요청에 대해 커넥션을 열고 닫는 간단한 DataSource이다.
		  조금 늦긴 하지만 성능을 크게 필요로 하지 않는 간단한 애플리케이션을 위해서는 괜찮은 선택이다.
		  UNPOOLED DataSource에는 다음과 같은 속성이 있습니다.</p>
        <ul>
          <li><code>driver</code> - JDBC드라이버의 패키지 경로를 포함한 결제 자바 클래스명</li>
          <li><code>url</code> - 데이터베이스 인스턴스에 대한 JDBC URL</li>
          <li><code>username</code> - 데이터베이스에 로그인 할 때 사용할 사용자명</li>
          <li><code>password</code> - 데이터베이스에 로그인 할 때 사용할 패스워드</li>
          <li><code>defaultTransactionIsolationLevel</code> - 커넥션에 대한 디폴트 트랜잭션 격리 레벨</li>
          <li><code>defaultNetworkTimeout</code> – The default network timeout value in milliseconds to wait for the database operation to complete. See the API documentation of <code>java.sql.Connection#setNetworkTimeout()</code> for details.</li>

        </ul>
        <p>필수는 아니지만 선택적으로 데이터베이스 드라이버에 프로퍼티를 전달할 수도 있다.
		그러기 위해서는 다음 예제처럼 “driver.” 로 시작하는 접두어로 프로퍼티를 명시하면 된다.</p>
        <ul>
          <li><code>driver.encoding=UTF8</code></li>
        </ul>
        <p>이 설정은 “encoding” 프로퍼티를 “UTF8”로 설정하게 된다.
		이 방법외에도 DriverManager.getConnection(url, driverProperties)메소드를 통해서도 프로퍼티를 설정할 수 있다.</p>
        <p>
          <strong>POOLED</strong> - DataSource에 풀링이 적용된 JDBC 커넥션을 위한 구현체이다.
		  이는 새로운 Connection 인스턴스를 생성하기 위해 매번 초기화하는 것을 피하게 해준다.
		  그래서 빠른 응답을 요구하는 웹 애플리케이션에서는 가장 흔히 사용되고 있다.</p>
        <p>UNPOOLED DataSource에 비해 많은 프로퍼티를 설정할 수 있다.</p>
        <ul>
          <li><code>poolMaximumActiveConnections</code> - 주어진 시간에 존재할 수 있는 활성화된(사용중인) 커넥션의 수.
		  디폴트는 10이다.</li>
          <li><code>poolMaximumIdleConnections</code> - 주어진 시간에 존재할 수 있는 유휴 커넥션의 수</li>
          <li>강제로 리턴되기 전에 풀에서 “체크아웃” 될 수 있는 커넥션의 시간.
		  디폴트는 20000ms(20 초)</li>
          <li><code>poolTimeToWait</code> - 풀이 로그 상태를 출력하고 비정상적으로 긴 경우 커넥션을 다시 얻을려고 시도하는 로우 레벨 설정.
		  디폴트는 20000ms(20 초)</li>
          <li><code>poolMaximumLocalBadConnectionTolerance</code> – 이것은 모든 쓰레드에 대해 bad Connection이 허용되는 정도에 대한 낮은 수준의 설정입니다.
            만약 쓰레드가 bad connection 을 얻게 되어도 유효한 또 다른 connection 을 다시 받을 수 있습니다.
            하지만 재시도 횟수는 <code>poolMaximumIdleConnections</code> 과 <code>poolMaximumLocalBadConnectionTolerance</code> 의 합보다 많아야 합니다.
            디폴트는 3이다. (3.4.5 부터)
          </li>
          <li><code>poolPingQuery</code> - 커넥션이 작업하기 좋은 상태이고 요청을 받아서 처리할 준비가 되었는지 체크하기 위해 데이터베이스에 던지는 핑쿼리(Ping Query).
		  디폴트는 “핑 쿼리가 없음” 이다.
		  이 설정은 대부분의 데이터베이스로 하여금 에러메시지를 보게 할수도 있다.</li>
          <li><code>poolPingEnabled</code> - 핑쿼리를 사용할지 말지를 결정.
		  사용한다면 오류가 없는(그리고 빠른) SQL 을 사용하여 poolPingQuery 프로퍼티를 설정해야 한다.
		  디폴트는 false 이다.</li>
          <li><code>poolPingConnectionsNotUsedFor</code> - poolPingQuery가 얼마나 자주 사용될지 설정한다.
		  필요이상의 핑을 피하기 위해 데이터베이스의 타임아웃 값과 같을 수 있다.
		  디폴트는 0이다.
		  디폴트 값은 poolPingEnabled가 true일 경우에만 모든 커넥션이 매번 핑을 던지는 값이다.</li>
        </ul>
        <p>
          <strong>JNDI</strong> - 이 DataSource 구현체는 컨테이너에 따라 설정이 변경되며 JNDI 컨텍스트를 참조한다.
		  이 DataSource 는 오직 두개의 프로퍼티만을 요구한다.</p>
        <ul>
          <li><code>initial_context</code> - 이 프로퍼티는 InitialContext 에서 컨텍스트를 찾기(예를 들어 initialContext.lookup(initial_context))위해 사용된다.
		  이 프로퍼티는 선택적인 값이다.
		  이 설정을 생략하면 data_source프로퍼티가 InitialContext에서 직접 찾을 것이다.</li>
          <li><code>data_source</code> - DataSource인스턴스의 참조를 찾을 수 있는 컨텍스트 경로이다.
		  initial_context 룩업을 통해 리턴된 컨텍스트에서 찾을 것이다.
		  initial_context 가 지원되지 않는다면 InitialContext 에서 직접 찾을 것이다.</li>
        </ul>
        <p>다른 DataSource설정과 유사하게 다음처럼 “env.”를 접두어로 프로퍼티를 전달할 수 있다.</p>
        <ul>
          <li><code>env.encoding=UTF8</code></li>
        </ul>
        <p>이 설정은 인스턴스화할 때 InitialContext생성자에 “encoding”프로퍼티를 “UTF8”로 전달한다.</p>

		<p>
		  <code>org.apache.ibatis.datasource.DataSourceFactory</code> 인터페이스를 구현해서 또다른 DataSource구현체를 만들수 있다.
		</p>

        <source><![CDATA[public interface DataSourceFactory {
  void setProperties(Properties props);
  DataSource getDataSource();
}]]></source>

        <p>
		  <code>org.apache.ibatis.datasource.unpooled.UnpooledDataSourceFactory</code>는 새로운 데이터소스를 만들기 위한 상위 클래스처럼 사용할 수 있다.
		  예를들면 다음의 코드를 사용해서 C3P0를 사용할 수 있다.
		</p>

        <source><![CDATA[import org.apache.ibatis.datasource.unpooled.UnpooledDataSourceFactory;
import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3P0DataSourceFactory extends UnpooledDataSourceFactory {

  public C3P0DataSourceFactory() {
    this.dataSource = new ComboPooledDataSource();
  }
}]]></source>

        <p>마이바티스가 호출할 setter메소드가 사용하는 프로퍼티를 추가해서 설정한다.
        다음의 설정은 PostgreSQL데이터베이스에 연결할때 사용한 샘플 설정이다. </p>

        <source><![CDATA[<dataSource type="org.myproject.C3P0DataSourceFactory">
  <property name="driver" value="org.postgresql.Driver"/>
  <property name="url" value="jdbc:postgresql:mydb"/>
  <property name="username" value="postgres"/>
  <property name="password" value="root"/>
</dataSource>
]]></source>

      </subsection>

      <subsection name="databaseIdProvider">
        <p>마이바티스는 데이터베이스 제품마다 다른 구문을 실행할 수 있다.
		여러개의 데이터베이스 제품을 가진 업체 제품은 <code>databaseId</code> 속성을 사용한 매핑된 구문을 기반으로 지원한다.
        마이바티스는 <code>databaseId</code>속성이 없거나 <code>databaseId</code>속성을 가진 모든 구문을 로드한다.
        같은 구문인데 하나는 <code>databaseId</code>속성이 있고 하나는 <code>databaseId</code>속성이 없을때 뒤에 나온 것이 무시된다.
        다중 지원을 사용하기 위해서는 mybatis-config.xml파일에 다음처럼 <code>databaseIdProvider</code>를 추가하라:
        </p>

        <source><![CDATA[<databaseIdProvider type="DB_VENDOR" />
]]></source>

    <p>DB_VENDOR구현체 databaseIdProvider는 <code>DatabaseMetaData#getDatabaseProductName()</code>에 의해 리턴된 문자열로 databaseId를 설정한다.
    이때 리턴되는 문자열이 너무 길거나 같은 제품의 서로다른 버전으로 다른 값을 리턴하는 경우 다음처럼 프로퍼티를 추가해서 짧게 처리할 수도 있다:
    </p>

        <source><![CDATA[<databaseIdProvider type="DB_VENDOR">
  <property name="SQL Server" value="sqlserver"/>
  <property name="DB2" value="db2"/>
  <property name="Oracle" value="oracle" />
</databaseIdProvider>]]></source>

    <p>프로퍼터가 제공되면 DB_VENDOR databaseIdProvider는 리턴된 데이터베이스 제품명에서 찾은 첫번째 프로퍼티값이나 일치하는 프로퍼티가 없다면 "null" 을 찾을 것이다.
    이 경우 <code>getDatabaseProductName()</code>가 "Oracle (DataDirect)"를 리턴한다면 databaseId는 "oracle"로 설정될 것이다. </p>

    <p><code>org.apache.ibatis.mapping.DatabaseIdProvider</code> 인터페이스를 구현해서 자신만의 DatabaseIdProvider를 빌드하고 mybatis-config.xml파일에 등록할 수 있다:
    </p>

        <source><![CDATA[public interface DatabaseIdProvider {
  default void setProperties(Properties p) { // Since 3.5.2, change to default method
    // NOP
  }
  String getDatabaseId(DataSource dataSource) throws SQLException;
}]]></source>

      </subsection>

      <subsection name="mappers">
        <p>이제 우리는 매핑된 SQL 구문을 정의할 시간이다.
		하지만 먼저 설정을 어디에 둘지 결정해야 한다.
		자바는 자동으로 리소스를 찾기 위한 좋은 방법을 제공하지 않는다.
		그래서 가장 좋은 건 어디서 찾으라고 지정하는 것이다.
		클래스패스에 상대적으로 리소스를 지정할 수도 있고 url 을 통해서 지정할 수 도 있다.
		예를들면</p>
        <source><![CDATA[<!-- 클래스패스의 상대경로의 리소스 사용 -->
<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>]]></source>

        <source><![CDATA[<!-- 절대경로의 url을 사용 -->
<mappers>
  <mapper url="file:///var/mappers/AuthorMapper.xml"/>
  <mapper url="file:///var/mappers/BlogMapper.xml"/>
  <mapper url="file:///var/mappers/PostMapper.xml"/>
</mappers>]]></source>

        <source><![CDATA[<!-- 매퍼 인터페이스를 사용 -->
<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
  <mapper class="org.mybatis.builder.BlogMapper"/>
  <mapper class="org.mybatis.builder.PostMapper"/>
</mappers>]]></source>

        <source><![CDATA[<!-- 매퍼로 패키지내 모든 인터페이스를 등록 -->
<mappers>
  <package name="org.mybatis.builder"/>
</mappers>]]></source>

        <p>SQL 매핑 파일에 대해서 자세히 알아보자.</p>
      </subsection>
    </section>
  </body>
</document>
