일신우일신

 Java 코드를 오랫동안 작성해 본 개발자라면 Java 오브젝트의 데이터와 RDBMS(Relational Database Management System)의 데이터를 상호 맵핑하는 메소드 내의 로직으로 수많은 클래스를 작성했던 날들이 기억날 것이다. ORM 도구를 베스트 프랙티스로 사용하게 되면서 오늘날에는 이러한 수동 작업을 거의 수행하지 않는다.

ORM 도구를 사용하면 Java 오브젝트 특성이 포함된 관계형 데이터베이스의 데이터 요소 간 맵핑을 구성할 수 있다. 구성이 완료되면 Java 클래스의 특성 데이터가 제거 또는 검색되는 방법에 대한 세부 사항을 고려할 필요 없이 이러한 도구를 통해 Java 오브젝트를 사용할 수 있다. 따라서 수많은 반복 코드에서 발생할 수 있는 쓰기, 디버깅 및 처리 오류에 대한 걱정을 떨쳐버릴 수 있다.

이 기사에서는 데이터베이스에 연결하는 Java 애플리케이션을 작성하는 데 사용할 수 있는 Apache Foundation의 ORM 도구인 iBATIS 3의 새로운 기능을 소개한다. 이 기사의 내용을 충분히 이해하려면 JDK(Java Development Kit) V5 이상과 Eclipse V3.4 이상이 필요하다. 이 기사에서는 iBATIS 3 베타 9를 사용한다. iBATIS 사이트에 따르면 베타 9가 GA(General Availability)에 가까우므로 이 기사의 예제도 GA 버전에 적용되어야 한다(가능한 경우).

iBATIS의 목적은 RDBMS에 대한 맵핑을 수행하는 것이므로 예제를 전체적으로 이해하려면 데이터베이스도 필요하다. 이 기사의 예제에서는 Apache Derby를 데이터베이스로 선택해서 사용한다. ORM 도구를 사용하면 JDBC(Java Database Connectivity)를 사용하는 Java 코드를 반복해서 작성하지 않아도 될 뿐만 아니라 향상된 데이터 계층의 추상화를 제공할 수도 있다. iBATIS 구성의 일부를 변경하고 올바른 JDBC 라이브러리에 대한 참조만 있으면 이 기사의 예제를 다른 데이터베이스와도 함께 사용할 수 있다.

iBATIS 개요

iBATIS 3는 Java 클래스의 특성과 RDBMS의 테이블 열 사이의 맵핑을 구성할 수 있는 지속성 프레임워크이다. 구성이 완료되면 사용자를 대신해서 프레임워크가 JDBC 연결 및 할당을 처리한다. XML 파일을 사용하여 iBATIS 3를 구성할 수 있다. iBATIS 사이트에서 iBATIS 프레임워크를 압축된 파일 아카이브(ZIP)로 다운로드할 수 있다(참고자료 참조). 이 아카이브 내에는 사용하는 클래스를 제공하기 위해 Java 프로젝트에 포함시킬 JAR(Java Archive) 파일이 있다.

Listing 1에서는 예제 애플리케이션에 사용되는 Java 클래스의 예제를 보여 준다.

1. package com.ibm.developerWorks.examples.ibatis.model;
2. public class Automobile {
3.     private int id;
       private String make;
       private String model;
       private int year;
4.     public Automobile() {
           super();
       }
5.     public Automobile(final int id, final String make, final String model,
           final int year) {
6.         super();
           this.id = id;
           this.make = make;
           this.model = model;
           this.year = year;
       }
7.     public int getId() {
           return id;
       }
8.     public String getMake() {
           return make;
       }
9.     public String getModel() {
           return model;
       }
10.     public int getYear() {
            return year;
        }
11.     public void setId(final int id) {
            this.id = id;
        }
12.     public void setMake(final String make) {
            this.make = make;
        }
13.     public void setModel(final String model) {
            this.model = model;
        }
14.     public void setYear(final int year) {
            this.year = year;
        }
15.     @Override
        public String toString() {
            return "Automobile [id=" + id + ", make=" + make + ", model=" + model + ",
        year=" + year + "]";
        }
    }

이 Automobile 클래스는 애플리케이션에 사용되는 데이터가 포함된 간단한 POJO(Plain Old Java Object)이다. 구성된 iBATIS 프레임워크는 이 오브젝트를 데이터베이스에 지속시키거나 데이터베이스에서 이 오브젝트를 선택한 메소드의 결과로서 이 오브젝트를 리턴할 수 있다.

Listing 2에서는 샘플 데이터베이스 테이블을 작성하는 SQL 스크립트를 보여 준다.

1. CREATE TABLE automobiles (
       id INT NOT NULL,
       make VARCHAR(255) NOT NULL,
       model VARCHAR(255) NOT NULL,
       model_year INT NOT NULL
   );

이 데이터베이스 스크립트를 실행하여 데이터베이스에 테이블을 작성한다. Derby를 데이터베이스로 사용 중인 경우에는 Derby와 함께 제공되는 명령행 유틸리티를 bin 폴더에서 사용하여 이 스크립트를 실행할 수 있다(Listing 3 참조). 예제를 실행하기 전에 DERBY_HOME 변수를 Derby가 설치되어 있는 디렉토리의 전체 경로에 할당하고 create.sql이라는 파일에 SQL 스크립트를 저장해야 한다.

1. $ cd $DERBY_HOME/bin
   $ ./ij
   > connect 'jdbc:derby:/tmp/MyDB';
   > run create.sql

Listing 4에서는 Java 클래스의 특성을 데이터 테이블의 데이터 열에 맵핑할 수 있는 XML 맵핑 파일을 보여 준다.

1. <?xml version="1.0" encoding="UTF-8" ?>
   <!DOCTYPE mapper
       PUBLIC "-//ibatis.apache.org//DTD Mapper 3.0//EN"
       "http://ibatis.apache.org/dtd/ibatis-3-mapper.dtd">
   <mapper namespace="com.ibm.developerWorks.examples.ibatis.model.Automobile">
       <resultMap type="Automobile" id="automobileResult">
           <result column="id" property="id" />
           <result column="make" property="make" />
           <result column="model" property="model" />
           <result column="model_year" property="year" />
       </resultMap>
       <select id="select" parameterType="int" resultType="Automobile"
           resultMap="automobileResult">
           select * from
           automobiles where id = #{id}
     </select>
       <insert id="insert" parameterType="Automobile">
           insert into automobiles (id,
           model, make, model_year)
           values (#{id}, #{model}, #{make}, #{year})
       </insert>
       <delete id="delete" parameterType="int">
           delete from automobiles where
           id = #{id}
     </delete>
       <delete id="deleteAll">
           delete from automobiles
     </delete>
   </mapper>

이 XML 맵핑 파일에는 <select>, <insert> 및 <delete> 요소가 있으며, 이러한 요소 내에는 일반적인 ANSI SQL처럼 보이는 코드가 있다. XML 요소 이름은 예상대로 SQL 문의 유형에 해당한다. 즉, <insert> 요소는 SQL INSERT 문에 해당한다. 매개변수는 SQL 코드에서 #{parameter} 표기법으로 정의된다. 여기서, parameter는 Java 클래스에 있는 필드의 이름이다. 예를 들어, Automobile 오브젝트에는 make라는 필드가 있으며 #{make}를 사용하여 이 필드에 저장된 값을 SQL 문에 전달할 수 있다.

iBATIS 3의 새 기능은 Java 인터페이스에서 어노테이션을 사용하여 이와 동일한 구성을 수행하는 기능이다. 나중에 XML 구성 파일 대신 Java 5 어노테이션을 사용하는 방법에 대해서 설명한다(Java 5 기능 참조).

마지막으로 Listing 5에서는 iBATIS 3를 위한 XML 구성 파일을 보여 준다. 이 구성 파일에서는 데이터베이스의 이름, 사용할 드라이버의 유형 및 신임 정보와 같은 기타 데이터베이스 특성을 지정한다. Listing 4에서 본 것처럼 맵핑 파일의 이름은 구성 파일의 <mappers> 요소에 나열된다.

1. <?xml version="1.0" encoding="UTF-8" ?>
   <!DOCTYPE configuration
     PUBLIC "-//ibatis.apache.org//DTD Config 3.0//EN"
     "http://ibatis.apache.org/dtd/ibatis-3-config.dtd">
   <configuration>
       <typeAliases>
           <typeAlias type="com.ibm.developerWorks.examples.ibatis.model.Automobile"
               alias="Automobile" />
       </typeAliases>
       <environments default="development">
           <environment id="development">
               <transactionManager type="JDBC" />
               <dataSource type="POOLED">
                   <property name="driver"
                       value="org.apache.derby.jdbc.EmbeddedDriver" />
                   <property name="url" value="jdbc:derby:/tmp/MyDB" />
               </dataSource>
           </environment>
       </environments>
       <mappers>
           <mapper resource="automobile-mapper.xml" />
       </mappers>
   </configuration>

Java 어노테이션 메소드를 사용하여 오브젝트와 데이터베이스 간의 맵핑을 정의할 경우에는 iBATIS 3가 이 구성을 프로그래밍 방식으로 수행할 수 있는 Java API(Application Program Interface)를 제공하므로 이 구성 파일이 필요하지 않다.

iBATIS 사용상의 장점

iBATIS의 사용상 장점은 XML 구성에서 오브젝트를 기존 관계형 데이터베이스에 맵핑하기 위한 좋은 ORM 프레임워크로 iBATIS를 사용할 수 있다는 것이다. Mapper 클래스 및 맵핑 파일을 사용할 경우에는 오브젝트 구조에 대한 데이터 구조를 확인하기 보다는 오브젝트를 기존 데이터 구조에 맵핑하는 것이 강조된다. 개발자와 데이터 구조를 분리하는 프레임워크를 사용할 때보다 구성 시간이 더 많이 걸리기 때문에 데이터베이스 및 오브젝트 모델을 설계하는 것이 효과적이다. 우수한 관계형 데이터베이스 실무자 및 오브젝트 모델 설계자는 서로 매우 다른 자신만의 구현을 작성하려는 경쟁력 있는 목표를 가질 수 있다.

과거에 필자는 데이터베이스에 관계형 구조와 저장 프로시저를 사용하고 개발자에게 데이터베이스 설계를 제어할 수 없는 프로젝트에서 iBATIS를 자주 사용했다.

샘플 Java 프로젝트 작성하기

이 기사의 예제를 테스트하려면 비어 있는 Java 프로젝트를 작성해야 한다. 새 Java 프로젝트에서 main() 메소드가 포함된 클래스를 작성한다(Listing 6 참조).

1. package com.ibm.developerWorks.examples.ibatis;
2. import java.io.IOException;
3. import javax.sql.DataSource;
4. import org.apache.commons.cli.CommandLine;
   import org.apache.commons.cli.GnuParser;
   import org.apache.commons.cli.OptionBuilder;
   import org.apache.commons.cli.Options;
   import org.apache.derby.jdbc.EmbeddedDataSource;
   import org.apache.ibatis.mapping.Environment;
   import org.apache.ibatis.session.Configuration;
   import org.apache.ibatis.session.SqlSession;
   import org.apache.ibatis.session.SqlSessionFactory;
   import org.apache.ibatis.session.SqlSessionFactoryBuilder;
   import org.apache.ibatis.transaction.TransactionFactory;
   import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
5. import com.ibm.developerWorks.examples.ibatis.data.AutomobileMapper;
   import com.ibm.developerWorks.examples.ibatis.model.Automobile;
6. public class Main {
7.     private static final String CREATE = "create";
       private static final String DELETE = "delete";
       private static final String IBATIS_CONFIG = "ibatis-config.xml";
       private static final String SHOW = "show";
8.     @SuppressWarnings("static-access")
       private static Options createOptions() {
           Options options = new Options();
           options.addOption(CREATE, false, "creates the objects in the database");
           options.addOption(OptionBuilder.withArgName(SHOW).hasArg().withDescription(
                   "shows the specified automobile").withLongOpt(SHOW).create());
           options.addOption(DELETE, false, "deletes all of the objects in database");
           return options;
       }
9.     private static SqlSessionFactory createSqlMapper() throws IOException {
           Reader reader = Resources.getResourceAsReader(IBATIS_CONFIG);
           return new SqlSessionFactoryBuilder().build(reader);
       }
10.     public static void main(final String[] args) {
            Options options = createOptions();
            try {
                CommandLine cmd = new GnuParser().parse(options, args);
11.             SqlSession session = createSqlMapper().openSession();
12.             try {
                    if (cmd.hasOption(CREATE)) {
                        System.out.println("Creating the objects in the database...");
                        // Create the automobiles
                        session.insert(Automobile.class.getName() + ".insert", new
                            Automobile(1, "Toyota", "Tercel", 1993));
                        session.insert(Automobile.class.getName() + ".insert", new
                            Automobile(2, "Honda", "CR-V", 2000));
                        session.insert(Automobile.class.getName() + ".insert", new
                            Automobile(3, "Chevrolet", "Impala", 1964));
                        session.insert(Automobile.class.getName() + ".insert", new
                            Automobile(4, "Dodge", "Pickup", 1946));
13.                     session.commit();
14.                 } else if (cmd.hasOption(SHOW)) {
15.                     Automobile auto = (Automobile) session.selectOne(
                            Automobile.class.getName() + ".select", cmd.getOptionValue(SHOW));
16.                     if (auto == null) {
                            System.out.println("No matching results found!");
                        } else {
                            System.out.println(auto);
                        }
17.                 } else if (cmd.hasOption(DELETE)) {
18.                     session.delete(Automobile.class.getName() + ".deleteAll");
                        session.commit();
19.                 } else {
                        System.out.println("Doing nothing.");
                    }
20.             } finally {
                    session.close();
                }
21.         } catch (Exception e) {
                e.printStackTrace();
            }
        }
22. }

임의 인수 구문 분석 코드 행을 피하기 위해 이 main 메소드에서는 Apache Commons CLI 프로젝트를 사용하여 명령행으로부터 받은 인수를 구문 분석한다. Apache Commons CLI 프로젝트를 사용하면 예제에서 --create, --delete 또는 --show와 같은 다양한 명령행 인수에 응답할 수 있다. Apache Commons CLI 프로젝트에 대한 자세한 정보는 참고자료를 참조하기 바란다. main() 메소드에서는 이 인수 지원을 사용하여 오브젝트 및 iBATIS와 관련된 몇 가지 샘플 작업을 수행할 수 있다.

이 예제에서는 iBATIS Resources 클래스를 사용하여 XML 파일로부터 구성을 로드한다. Resources 클래스는 이 파일을 Reader로 로드한 후 SqlSessionFactoryBuilder에게 전달한다. SqlSessionFactoryBuilder는 SqlSessionFactory를 생성할 수 있으며, 그런 다음 SqlSessionFactory는 SqlSession 오브젝트를 작성하는 데 사용되며, 코드에서는 이 오브젝트를 사용하여 맵핑 클래스에 정의된 메소드를 통해 데이터베이스와 상호 작용한다.

예제 코드를 컴파일하고 실행하기 전에 iBATIS 3, Apache Commons CLI 및 Apache Derby JAR 파일(ibatis-3-core-x.jar, commons-cli-1.2.jar 및 derby.jar)을 가져와야 한다.

예제 실행하기

Eclipse에서 main 클래스를 실행하여 이 예제를 실행할 수 있다. Java 호출에 인수를 추가하려면 Run > Run Configurations를 열고 Java Application/Main 실행 구성을 찾는다. Arguments 탭에서 Program Arguments에 제공할 인수를 지정한다(그림 1 참조).

또는 명령행에서 Java 애플리케이션을 호출한 후 iBATIS 3, Apache Commons CLI 및 Apache Derby JAR 파일을 포함하도록 클래스 경로를 설정한다. Listing 7에서 애플리케이션을 호출하는 방법을 보여 주는 예제를 볼 수 있다.

1. $ java -classpath {jars} com.ibm.developerWorks.examples.ibatis.Main --create
   Creating the objects in the database...

Java 애플리케이션을 실행하면 --create가 네 개의 Automobile 오브젝트를 새로 작성한 후 데이터베이스의 automobiles 테이블에 추가한다. --delete 인수를 사용하면 데이터베이스에서 오브젝트를 삭제한다. --show를 ID와 함께 사용하면 일치하는 데이터베이스 레코드를 가져오는 SQL 스크립트가 실행되고, 데이터가 포함된 Automobile 오브젝트가 작성된 후 콘솔에 결과가 표시된다.

XML 구성 예제를 작동해 보았으므로 이제 iBATIS 3의 새로운 주요 기능 중 하나인 Java 어노테이션 지원을 살펴볼 차례이다.

Java5 기능

iBATIS 3는 Java 5 어노테이션을 활용할 수 있도록 지원하는 새로운 변경 사항을 제공한다. 어노테이션을 사용하면 Java 코드에서 오브젝트를 데이터베이스에 맵핑하는 데 사용되는 맵퍼 인터페이스를 작성할 수 있다. Listing 8의 코드를 살펴보면 XML 구성 대신 AutomobileMapper 인터페이스가 구성을 위해 사용되는 것을 볼 수 있다.

1.  package com.ibm.developerWorks.examples.ibatis.data;
2. import org.apache.ibatis.annotations.Delete;
   import org.apache.ibatis.annotations.Insert;
   import org.apache.ibatis.annotations.Select;
3. import com.ibm.developerWorks.examples.ibatis.model.Automobile;
4. public interface AutomobileMapper {
5.     @Select("select id, make, model, model_year as \"year\" from automobiles where id = #{id}")
       Automobile selectAutomobile(final int id);
6.  
7.     @Insert("insert into automobiles(id,make,model,model_year) values (#{id}, #{make}, #{model}, #{year})")
       void insertAutomobile(final Automobile arg);
8.  
9.     @Delete("delete from automobiles")
       void deleteAll();
10. }

Automobile 맵퍼에 대한 XML 구성에서 resultMap 요소는 model_year 데이터베이스 열과 Automobile 오브젝트의 year 필드를 맵핑하는 데 사용된다. 이 방법은 열의 별명을 지정하는 SQL 기능을 사용하여 어노테이션에서 수행할 수 있는 상당히 쉬운 맵핑이며, @Select 어노테이션에 정의된 SQL에서 수행된다.

AutomobileMapper 인터페이스의 Select 어노테이션은 selectAutomobile 메소드를 SQL에 맵핑하며, 이 메소드는 automobiles 테이블에서 지정된 값이 있는 레코드를 선택하는 데 사용할 수 있다. 값은 인수에 대한 id 매개변수로 지정되며 XML 구성에서와 마찬가지로 SQL 문에 #{id}로 포함된다. Java 인터페이스를 사용하여 SQL 맵핑을 사용할 때 얻을 수 있는 큰 장점은 Java 편집기에서 컴파일 시 오류 형식의 피드백을 사용할 수 있다는 것이다. 이 경우 메소드가 예상대로 올바른 유형을 리턴하는지 확인할 수 있다. 이에 반해 XML 구성을 사용할 경우에는 일반적으로 코드를 실행해야만 오류를 찾을 수 있다.

또한 iBATIS 3에서는 이제 인터페이스 상속이 지원되므로 Java 인터페이스를 구체화하여 코드 중복을 줄일 수 있다.

iBATIS 문서에는 작고 간단한 프로젝트일수록 어노테이션을 훨씬 더 쉽게 읽을 수 있다는 설명이 있다. 하지만 어노테이션은 XML 구성에 비해 제한적이다. 프로젝트에 복합 오브젝트나 복합 데이터베이스 구조가 있을 경우에는 Java 어노테이션 대신 XML 구성을 사용하는 것이 좋다.

기타 API 변경사항

iBATIS를 위한 어노테이션 기반 구성을 수행하려면 약간 다른 인스턴스화가 필요하다. XML 구성을 읽는 Reader 클래스를 사용하는 대신 맵퍼를 Configuration 오브젝트에 추가할 수 있다(Listing 9 참조).

1. package com.ibm.developerWorks.examples.ibatis;
2. // snipped imports
3. public class Main {
4.     // snipped constants declarations--didn't change
5.     // new method for creating data source private static DataSource createDataSource() { EmbeddedDataSource dataSource = new org.apache.derby.jdbc.EmbeddedDataSource(); dataSource.setDatabaseName("/tmp/MyDB"); return dataSource; }
   
6.     @SuppressWarnings("static-access")
       private static Options createOptions() {
      // snipped... no changes
       }
7.     private static SqlSessionFactory createSqlMapper() throws IOException {DataSource
   datasource = createDataSource(); TransactionFactory transaction = new JdbcTransactionFactory(); Configuration configuration = new Configuration(new Environment("development", transaction, datasource)); configuration.addMapper(AutomobileMapper.class);
   
           return new SqlSessionFactoryBuilder().build(configuration);
       }
8.     public static void main(final String[] args) {
           Options options = createOptions();
           try {
               CommandLine cmd = new GnuParser().parse(options, args);
9.             SqlSession session = createSqlMapper().openSession(); AutomobileMapper mapper = session.getMapper(AutomobileMapper.class);
   
10.             try {
                    if (cmd.hasOption(CREATE)) {
                        System.out.println("Creating the objects in the database...");
                        // Create the automobiles mapper.insertAutomobile(new Automobile(1, "Toyota", "Tercel", 1993)); mapper.insertAutomobile(new Automobile(2, "Honda", "CR-V", 2000)); mapper.insertAutomobile( new Automobile(3, "Chevrolet", "Impala", 1964)); mapper.insertAutomobile(new Automobile(4, "Dodge", "Pickup", 1946));
    
11.                     session.commit();
12.                 } else if (cmd.hasOption(SHOW)) {
     Automobile auto = mapper.selectAutomobile( Integer.parseInt(cmd.getOptionValue(SHOW)));
13.                     if (auto == null) {
                            System.out.println("No matching results found!");
                        } else {
                            System.out.println(auto);
                        }
14.                 } else if (cmd.hasOption(DELETE)) {
15.                     mapper.deleteAll();
                        session.commit();
16.                 } else {
                        System.out.println("Doing nothing.");
                    }
17.             } finally {
                    session.close();
                }
18.         } catch (Exception e) {
                e.printStackTrace();
            }
        }
19. }

addMapper() 메소드에 제공된 AutomobileMapper는 Listing 8에서 보았던 것과 동일한 Java 인터페이스이다.

또한 Configuration 오브젝트에는 DataSource 구현이 필요하다. 이 예제에서는 DataSource 구현이 정적 createDataSource() 메소드에서 매우 쉽게 작성된다. 하지만 프로덕션 애플리케이션에서는 데이터베이스의 이름과 같은 데이터 소스 정보를 좀 더 동적으로 설정할 수 있도록 이 구현을 수정해야 한다. 지속성을 관리하는 애플리케이션 서버 또는 웹 서버에서 애플리케이션을 작성하는 경우에는 JNDI(Java Naming and Directory Interface)를 사용하여 DataSource를 가져올 수 있다.

XML 구성 변경사항

이전 버전의 iBATIS에서 업그레이드하는 동안 iBATIS용 Java 어노테이션 대신 XML 구성을 사용하기로 결정한 경우에는 기존 버전과 새 버전 사이에 XML과 관련된 몇 가지 주요 차이점이 있다는 것을 알 수 있다.

이전 버전의 iBATIS에서는 resultMap과 유사한 parameterMap을 사용하여 메소드의 매개변수를 맵핑한다. 하지만 parameterMap 요소는 더 이상 사용되지 않으므로 사용하면 안된다. 대신 parameterType에 오브젝트의 유형을 포함한 후 표준 표기법을 사용하여 해당 유형의 특성에 액세스한다. (예를 들어, Java 오브젝트의 id 필드의 경우 #{id}를 사용한다.)

구성 및 맵퍼 파일의 루트 요소가 새 DTD(Document Type Definition) 선언을 포함하도록 업데이트되었으며, 향상된 구성을 제공하기 위해 일부 요소가 옮겨졌다.

iBATIS XML 구성 변경 사항에 대한 자세한 정보는 참고자료를 참조하기 바란다. 베타 9 버전의 iBATIS부터 기존 버전의 XML을 새 버전으로 이식하는 방법에 대한 문서화 작업이 진행되고 있다.

요약

iBATIS 3는 Java 오브젝트의 특성을 데이터베이스의 테이블 열에 맵핑하는 작업을 지원하는 ORM 지속성 프레임워크이다. iBATIS의 맵핑 중심적 관점에서는 솔리드 오브젝트 모델과 솔리드 관계형 데이터베이스 설계의 맵핑을 강조한다.

iBATIS 3의 새로운 기능은 Java 어노테이션을 이용한 맵핑이다. 이 맵핑 방법을 사용하면 많은 프로젝트의 계속 소스 코드에서 액세스할 수 있는 깔끔하고 직접적인 맵핑을 수행할 수 있다. iBATIS 3에서는 XML 구성 파일을 사용하여 오브젝트를 맵핑하는 기능도 여전히 제공한다. 두 가지 구성 방법이 있으므로 프로젝트에 가장 적합한 방법으로 iBATIS를 구성할 수 있다.

이 글은 스프링노트에서 작성되었습니다.