iBATIS-퀵 가이드

iBATIS는 SQL 데이터베이스와 Java, .NET 및 Ruby on Rails의 객체 간의 매핑을 자동화하는 지속성 프레임 워크입니다. 매핑은 XML 구성 파일에 SQL 문을 패키징하여 응용 프로그램 논리에서 분리됩니다.

iBATIS는 POJO (Plain Old Java Objects)를 유지하는 데 좋은 경량 프레임 워크 및 지속성 API입니다.

iBATIS는 데이터 매퍼로 알려져 있으며 클래스 속성과 데이터베이스 테이블의 열 사이의 매개 변수와 결과 매핑을 처리합니다.

iBATIS와 Hibernate와 같은 다른 지속성 프레임 워크의 중요한 차이점은 iBATIS가 SQL 사용을 강조하는 반면 다른 프레임 워크는 일반적으로 Hibernate Query Language (HQL) 또는 Enterprise JavaBeans Query Language (EJB QL)와 같은 사용자 정의 쿼리 언어를 사용한다는 것입니다.

iBATIS 디자인 철학

iBATIS에는 다음과 같은 디자인 철학이 있습니다.

Simplicity − iBATIS는 오늘날 사용 가능한 가장 간단한 지속성 프레임 워크 중 하나로 널리 알려져 있습니다.
Fast Development − iBATIS는 초고속 개발을 촉진하기 위해 최선을 다합니다.
Portability − iBATIS는 Java, Ruby 및 Microsoft .NET 용 C #과 같은 거의 모든 언어 또는 플랫폼에 대해 구현할 수 있습니다.
Independent Interfaces − iBATIS는 데이터베이스 독립적 인 인터페이스와 API를 제공하여 나머지 애플리케이션이 지속성 관련 리소스와 독립적으로 유지되도록 도와줍니다.
Open source − iBATIS는 무료이며 오픈 소스 소프트웨어입니다.

iBATIS의 장점

iBATIS는 다음과 같은 이점을 제공합니다.

Supports stored procedures − iBATIS는 SQL을 저장 프로 시저의 형태로 캡슐화하여 비즈니스 로직이 데이터베이스에 포함되지 않도록하고 애플리케이션을 배포 및 테스트하기 쉽고 이식성이 더 높습니다.
Supports inline SQL − 프리 컴파일러가 필요하지 않으며 SQL의 모든 기능에 대한 전체 액세스 권한이 있습니다.
Supports dynamic SQL − iBATIS는 매개 변수를 기반으로 SQL 쿼리를 동적으로 작성하는 기능을 제공합니다.
Supports O/RM − iBATIS는 지연 로딩, 조인 페칭, 캐싱, 런타임 코드 생성 및 상속과 같은 O / RM 도구와 동일한 많은 기능을 지원합니다.

iBATIS는 데이터베이스 지향 애플리케이션을 개발하면서 JAVA 프로그래밍 언어를 사용합니다. 계속 진행하기 전에 절차 및 객체 지향 프로그래밍의 기본 사항 (제어 구조, 데이터 구조 및 변수, 클래스, 객체 등)을 이해하고 있는지 확인하십시오.

JAVA를 자세히 이해하려면 JAVA Tutorial을 참조하십시오 .

실제 개발 작업을 시작하기 전에 iBATIS에 대한 적절한 환경을 설정해야합니다. 이 장에서는 iBATIS의 작업 환경을 설정하는 방법에 대해 설명합니다.

iBATIS 설치

Linux 시스템에 iBATIS를 설치하려면 다음과 같은 간단한 단계를 수행하십시오.

iBATIS 다운로드에서 최신 버전의 iBATIS를 다운로드 합니다.
다운로드 한 파일의 압축을 풀어 번들에서 .jar 파일을 추출하고 적절한 lib 디렉토리에 보관하십시오.
추출 된 .jar 파일에서 PATH 및 CLASSPATH 변수를 적절하게 설정하십시오.

$ unzip ibatis-2.3.4.726.zip inflating: META-INF/MANIFEST.MF creating: doc/ creating: lib/ creating: simple_example/ creating: simple_example/com/ creating: simple_example/com/mydomain/ creating: simple_example/com/mydomain/data/ creating: simple_example/com/mydomain/domain/ creating: src/ inflating: doc/dev-javadoc.zip inflating: doc/user-javadoc.zip inflating: jar-dependencies.txt inflating: lib/ibatis-2.3.4.726.jar inflating: license.txt inflating: notice.txt inflating: release.txt $pwd
/var/home/ibatis
$set PATH=$PATH:/var/home/ibatis/
$set CLASSPATH=$CLASSPATH:/var/home/ibatis\
      /lib/ibatis-2.3.4.726.jar

데이터베이스 설정

다음 구문을 사용하여 MySQL 데이터베이스에 EMPLOYEE 테이블을 만듭니다.

mysql> CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

SqlMapConfig.xml 만들기

다음을 고려하십시오-

JDBC를 사용하여 데이터베이스에 액세스 할 것입니다. testdb.
MySQL 용 JDBC 드라이버는 "com.mysql.jdbc.Driver"입니다.
연결 URL은 "jdbc : mysql : // localhost : 3306 / testdb"입니다.
사용자 이름과 암호를 각각 "root"와 "root"로 사용합니다.
모든 작업에 대한 SQL 문 매핑은 "Employee.xml"에 설명되어 있습니다.

위의 가정에 따라 이름이있는 XML 구성 파일을 만들어야합니다. SqlMapConfig.xml다음 내용으로. iBatis에 필요한 모든 구성을 제공해야하는 곳입니다.

SqlMapConfig.xml 및 Employee.xml 파일이 모두 클래스 경로에 있어야합니다. 지금은 Employee.xml 파일을 비워두고 다음 장에서 그 내용을 다룰 것입니다.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMapConfig PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-config-2.dtd">

<sqlMapConfig>
   <settings useStatementNamespaces="true"/>
	
   <transactionManager type="JDBC">
      <dataSource type="SIMPLE">
		
         <property name="JDBC.Driver" value="com.mysql.jdbc.Driver"/>
         <property name="JDBC.ConnectionURL" value="jdbc:mysql://localhost:3306/testdb"/>
         <property name="JDBC.Username" value="root"/>
         <property name="JDBC.Password" value="root"/>
			
      </dataSource>
   </transactionManager>
	
   <sqlMap resource="Employee.xml"/> 
</sqlMapConfig>

SqlMapConfig.xml 파일을 사용하여 다음과 같은 선택적 속성을 설정할 수 있습니다.

<property name="JDBC.AutoCommit" value="true"/>
<property name="Pool.MaximumActiveConnections" value="10"/>
<property name="Pool.MaximumIdleConnections" value="5"/>
<property name="Pool.MaximumCheckoutTime" value="150000"/> 
<property name="Pool.MaximumTimeToWait" value="500"/> 
<property name="Pool.PingQuery" value="select 1 from Employee"/> 
<property name="Pool.PingEnabled" value="false"/>

iBATIS를 사용하여 CRUD (Create, Read, Update, Delete) 작업을 수행하려면 테이블에 해당하는 POJO (Plain Old Java Objects) 클래스를 만들어야합니다. 이 클래스는 데이터베이스 테이블 행을 "모델링"할 개체를 설명합니다.

POJO 클래스는 원하는 작업을 수행하는 데 필요한 모든 메서드를 구현합니다.

MySQL에 다음 EMPLOYEE 테이블이 있다고 가정 해 보겠습니다.

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

직원 POJO 클래스

Employee.java 파일에 다음과 같이 Employee 클래스를 생성합니다.

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  

   /* Define constructors for the Employee class. */
   public Employee() {}
  
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }
} /* End of Employee */

테이블에서 개별 필드를 설정하는 방법을 정의 할 수 있습니다. 다음 장에서는 개별 필드의 값을 가져 오는 방법에 대해 설명합니다.

Employee.xml 파일

iBATIS를 사용하여 SQL 매핑 문을 정의하려면 <insert> 태그를 사용하고이 태그 정의 내에서 데이터베이스에서 SQL INSERT 쿼리를 실행하기 위해 IbatisInsert.java 파일에서 사용할 "id"를 정의합니다.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Employee"> 

   <insert id="insert" parameterClass="Employee">
      insert into EMPLOYEE(first_name, last_name, salary)
      values (#first_name#, #last_name#, #salary#)

      <selectKey resultClass="int" keyProperty="id">
         select last_insert_id() as id
      </selectKey>
   </insert> 

</sqlMap>

여기 parameterClass −요구 사항에 따라 string, int, float, double 또는 모든 클래스 객체 로 값을 취할 수 있습니다 . 이 예제에서는 SqlMap 클래스의 insert 메서드 를 호출하는 동안 Employee 개체를 매개 변수로 전달합니다 .

데이터베이스 테이블이 IDENTITY, AUTO_INCREMENT 또는 SERIAL 열을 사용하거나 SEQUENCE / GENERATOR를 정의한 경우 <insert> 문에서 <selectKey> 요소를 사용하여 해당 데이터베이스 생성 값을 사용하거나 반환 할 수 있습니다.

IbatisInsert.java 파일

이 파일은 Employee 테이블에 레코드를 삽입하는 애플리케이션 레벨 로직을 가지고 있습니다.

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class IbatisInsert{
   public static void main(String[] args)throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);

      /* This would insert one record in Employee table. */
      System.out.println("Going to insert record.....");
      Employee em = new Employee("Zara", "Ali", 5000);

      smc.insert("Employee.insert", em);

      System.out.println("Record Inserted Successfully ");
   }
}

컴파일 및 실행

위에서 언급 한 소프트웨어를 컴파일하고 실행하는 단계는 다음과 같습니다. 컴파일 및 실행을 계속하기 전에 PATH 및 CLASSPATH를 적절하게 설정했는지 확인하십시오.

위와 같이 Employee.xml을 만듭니다.
위와 같이 Employee.java를 생성하고 컴파일합니다.
위와 같이 IbatisInsert.java를 생성하고 컴파일합니다.
IbatisInsert 바이너리를 실행하여 프로그램을 실행하십시오.

다음 결과를 얻을 수 있으며 EMPLOYEE 테이블에 레코드가 생성됩니다.

$java IbatisInsert
Going to insert record.....
Record Inserted Successfully

EMPLOYEE 테이블을 확인하면 다음 결과가 표시됩니다.

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
|  1 | Zara       | Ali       |   5000 |
+----+------------+-----------+--------+
1 row in set (0.00 sec)

지난 장에서 iBATIS를 사용하여 테이블에서 CREATE 연산을 수행하는 방법에 대해 논의했습니다. 이 장에서는 iBATIS를 사용하여 표를 읽는 방법을 설명합니다.

MySQL에는 다음과 같은 EMPLOYEE 테이블이 있습니다.

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

이 테이블에는 다음과 같이 하나의 레코드 만 있습니다.

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
|  1 | Zara       | Ali       |   5000 |
+----+------------+-----------+--------+
1 row in set (0.00 sec)

직원 POJO 클래스

읽기 작업을 수행하려면 Employee.java의 Employee 클래스를 다음과 같이 수정합니다.

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  

   /* Define constructors for the Employee class. */
   public Employee() {}
  
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }

   /* Here are the method definitions */
   public int getId() {
      return id;
   }
	
   public String getFirstName() {
      return first_name;
   }
	
   public String getLastName() {
      return last_name;
   }
	
   public int getSalary() {
      return salary;
   }
	
} /* End of Employee */

Employee.xml 파일

iBATIS를 사용하여 SQL 매핑 문을 정의하려면 Employee.xml 파일에 <select> 태그를 추가하고이 태그 정의 내에 데이터베이스에서 SQL SELECT 쿼리를 실행하기 위해 IbatisRead.java 파일에서 사용할 "id"를 정의합니다.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Employee">

   <insert id="insert" parameterClass="Employee">
      INSERT INTO EMPLOYEE(first_name, last_name, salary)
      values (#first_name#, #last_name#, #salary#)

      <selectKey resultClass="int" keyProperty="id">
         select last_insert_id() as id
      </selectKey>
   </insert>
	
   <select id="getAll" resultClass="Employee">
      SELECT * FROM EMPLOYEE
   </select>
	
</sqlMap>

여기서는 SQL SELECT 문과 함께 WHERE 절을 사용하지 않았습니다. 다음 장에서는 SELECT 문과 함께 WHERE 절을 사용하는 방법과 해당 WHERE 절에 값을 전달하는 방법을 설명합니다.

IbatisRead.java 파일

이 파일에는 Employee 테이블에서 레코드를 읽는 응용 프로그램 수준 논리가 있습니다.

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class IbatisRead{
   public static void main(String[] args)throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);

      /* This would read all records from the Employee table. */
      System.out.println("Going to read records.....");
      List <Employee> ems = (List<Employee>)
         smc.queryForList("Employee.getAll", null);
      Employee em = null;
		
      for (Employee e : ems) {
         System.out.print("  " + e.getId());
         System.out.print("  " + e.getFirstName());
         System.out.print("  " + e.getLastName());
         System.out.print("  " + e.getSalary());
         em = e; 
         System.out.println("");
      }    
		
      System.out.println("Records Read Successfully ");
   }
}

컴파일 및 실행

위와 같이 Employee.xml을 만듭니다.
위와 같이 Employee.java를 생성하고 컴파일합니다.
위와 같이 IbatisRead.java를 만들고 컴파일합니다.
IbatisRead 바이너리를 실행하여 프로그램을 실행하십시오.

다음과 같은 결과를 얻고 다음과 같이 EMPLOYEE 테이블에서 레코드를 읽습니다.

Going to read records.....
   1  Zara  Ali  5000
Record Reads Successfully

지난 장에서 iBATIS를 사용하여 테이블에서 READ 작업을 수행하는 방법에 대해 논의했습니다. 이 장에서는 iBATIS를 사용하여 테이블의 레코드를 업데이트하는 방법에 대해 설명합니다.

MySQL에는 다음과 같은 EMPLOYEE 테이블이 있습니다.

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

이 테이블에는 다음과 같이 하나의 레코드 만 있습니다.

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
|  1 | Zara       | Ali       |   5000 |
+----+------------+-----------+--------+
1 row in set (0.00 sec)

직원 POJO 클래스

udpate 작업을 수행하려면 다음과 같이 Employee.java 파일을 수정해야합니다.

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  

   /* Define constructors for the Employee class. */
   public Employee() {}
  
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }

   /* Here are the required method definitions */
   public int getId() {
      return id;
   }
	
   public void setId(int id) {
      this.id = id;
   }
	
   public String getFirstName() {
      return first_name;
   }
	
   public void setFirstName(String fname) {
      this.first_name = fname;
   }
	
   public String getLastName() {
      return last_name;
   }
   public void setlastName(String lname) {
      this.last_name = lname;
   }
	
   public int getSalary() {
      return salary;
   }
	
   public void setSalary(int salary) {
      this.salary = salary;
   }

} /* End of Employee */

Employee.xml 파일

iBATIS를 사용하여 SQL 매핑 문을 정의하려면 Employee.xml에 <update> 태그를 추가하고이 태그 정의 내에 데이터베이스에서 SQL UPDATE 쿼리를 실행하기 위해 IbatisUpdate.java 파일에서 사용할 "id"를 정의합니다.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Employee">

   <insert id="insert" parameterClass="Employee">
      INSERT INTO EMPLOYEE(first_name, last_name, salary)
      values (#first_name#, #last_name#, #salary#)

      <selectKey resultClass="int" keyProperty="id">
         select last_insert_id() as id
      </selectKey>
   </insert>

   <select id="getAll" resultClass="Employee">
      SELECT * FROM EMPLOYEE
   </select>

   <update id="update" parameterClass="Employee">
      UPDATE EMPLOYEE
      SET    first_name = #first_name#
      WHERE  id = #id#
   </update>
	
</sqlMap>

IbatisUpdate.java 파일

이 파일은 Employee 테이블에 레코드를 업데이트하는 애플리케이션 레벨 로직을 가지고 있습니다.

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class IbatisUpdate{
   public static void main(String[] args)
   throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);

      /* This would update one record in Employee table. */
      System.out.println("Going to update record.....");
      Employee rec = new Employee();
      rec.setId(1);
      rec.setFirstName( "Roma");
      smc.update("Employee.update", rec );
      System.out.println("Record updated Successfully ");

      System.out.println("Going to read records.....");
      List <Employee> ems = (List<Employee>)
         smc.queryForList("Employee.getAll", null);
      Employee em = null;
		
      for (Employee e : ems) {
         System.out.print("  " + e.getId());
         System.out.print("  " + e.getFirstName());
         System.out.print("  " + e.getLastName());
         System.out.print("  " + e.getSalary());
         em = e; 
         System.out.println("");
      }    

      System.out.println("Records Read Successfully ");
   }
}

컴파일 및 실행

위와 같이 Employee.xml을 만듭니다.
위와 같이 Employee.java를 생성하고 컴파일합니다.
위와 같이 IbatisUpdate.java를 생성하고 컴파일합니다.
IbatisUpdate 바이너리를 실행하여 프로그램을 실행하십시오.

다음 결과를 얻고 EMPLOYEE 테이블에서 레코드가 업데이트되고 나중에 EMPLOYEE 테이블에서 동일한 레코드를 읽습니다.

Going to update record.....
Record updated Successfully
Going to read records.....
   1  Roma  Ali  5000
Records Read Successfully

이 장에서는 iBATIS를 사용하여 테이블에서 레코드를 삭제하는 방법에 대해 설명합니다.

MySQL에는 다음과 같은 EMPLOYEE 테이블이 있습니다.

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

이 테이블에 다음과 같이 두 개의 레코드가 있다고 가정합니다.

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
|  1 | Zara       | Ali       |   5000 |
|  2 | Roma       | Ali       |   3000 |
+----+------------+-----------+--------+
2 row in set (0.00 sec)

직원 POJO 클래스

삭제 작업을 수행하기 위해 Employee.java 파일을 수정할 필요가 없습니다. 지난 장에서와 같이 유지합시다.

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  

   /* Define constructors for the Employee class. */
   public Employee() {}
  
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }

   /* Here are the required method definitions */
   public int getId() {
      return id;
   }
	
   public void setId(int id) {
      this.id = id;
   }
	
   public String getFirstName() {
      return first_name;
   }
	
   public void setFirstName(String fname) {
      this.first_name = fname;
   }
	
   public String getLastName() {
      return last_name;
   }
	
   public void setlastName(String lname) {
      this.last_name = lname;
   }
	
   public int getSalary() {
      return salary;
   }
	
   public void setSalary(int salary) {
      this.salary = salary;
   }

} /* End of Employee */

Employee.xml 파일

iBATIS를 사용하여 SQL 매핑 문을 정의하려면 Employee.xml에 <delete> 태그를 추가하고이 태그 정의 내에 데이터베이스에서 SQL DELETE 쿼리를 실행하기 위해 IbatisDelete.java 파일에서 사용할 "id"를 정의합니다.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Employee">

   <insert id="insert" parameterClass="Employee">
      INSERT INTO EMPLOYEE(first_name, last_name, salary)
      values (#first_name#, #last_name#, #salary#)

      <selectKey resultClass="int" keyProperty="id">
         select last_insert_id() as id
      </selectKey>
   </insert>

   <select id="getAll" resultClass="Employee">
      SELECT * FROM EMPLOYEE
   </select>

   <update id="update" parameterClass="Employee">
      UPDATE EMPLOYEE
      SET    first_name = #first_name#
      WHERE  id = #id#
   </update>

   <delete id="delete" parameterClass="int">
      DELETE FROM EMPLOYEE
      WHERE  id = #id#
   </delete>

</sqlMap>

IbatisDelete.java 파일

이 파일에는 Employee 테이블에서 레코드를 삭제하는 응용 프로그램 수준 논리가 있습니다.

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class IbatisDelete{
   public static void main(String[] args)
   throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);

      /* This would delete one record in Employee table. */
      System.out.println("Going to delete record.....");
      int id = 1;

      smc.delete("Employee.delete", id );
      System.out.println("Record deleted Successfully ");

      System.out.println("Going to read records.....");
      List <Employee> ems = (List<Employee>)
         smc.queryForList("Employee.getAll", null);
      Employee em = null;
		
      for (Employee e : ems) {
         System.out.print("  " + e.getId());
         System.out.print("  " + e.getFirstName());
         System.out.print("  " + e.getLastName());
         System.out.print("  " + e.getSalary());
         em = e; 
         System.out.println("");
      }    

      System.out.println("Records Read Successfully ");
   }
}

컴파일 및 실행

위와 같이 Employee.xml을 만듭니다.
위와 같이 Employee.java를 생성하고 컴파일합니다.
위와 같이 IbatisDelete.java를 만들고 컴파일합니다.
IbatisDelete 바이너리를 실행하여 프로그램을 실행하십시오.

다음 결과가 표시되고 ID = 1 인 레코드가 EMPLOYEE 테이블에서 삭제되고 나머지 레코드가 읽 힙니다.

Going to delete record.....
Record deleted Successfully
Going to read records.....
   2  Roma  Ali  3000
Records Read Successfully

resultMap 요소는 iBATIS에서 가장 중요하고 강력한 요소입니다. iBATIS ResultMap을 사용하여 최대 90 %까지 JDBC 코딩을 줄일 수 있으며 경우에 따라 JDBC가 지원하지 않는 작업도 수행 할 수 있습니다.

ResultMaps의 디자인은 단순한 문에는 명시적인 결과 매핑이 전혀 필요하지 않으며 더 복잡한 문은 관계를 설명하는 데 절대적으로 필요한 것 이상을 요구하지 않습니다.

이 장에서는 iBATIS ResultMaps에 대한 간단한 소개를 제공합니다.

MySQL에는 다음과 같은 EMPLOYEE 테이블이 있습니다.

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

이 테이블에는 다음과 같은 두 개의 레코드가 있습니다.

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
|  1 | Zara       | Ali       |   5000 |
|  2 | Roma       | Ali       |   3000 |
+----+------------+-----------+--------+
2 row in set (0.00 sec)

직원 POJO 클래스

iBATIS ResultMap을 사용하기 위해 Employee.java 파일을 수정할 필요가 없습니다. 지난 장에서와 같이 유지합시다.

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  

   /* Define constructors for the Employee class. */
   public Employee() {}
  
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }

   /* Here are the required method definitions */
   public int getId() {
      return id;
   }
	
   public void setId(int id) {
      this.id = id;
   }
	
   public String getFirstName() {
      return first_name;
   }
	
   public void setFirstName(String fname) {
      this.first_name = fname;
   }
	
   public String getLastName() {
      return last_name;
   }
	
   public void setlastName(String lname) {
      this.last_name = lname;
   }
	
   public int getSalary() {
      return salary;
   }
	
   public void setSalary(int salary) {
      this.salary = salary;
   }

} /* End of Employee */

Employee.xml 파일

여기서는 Employee.xml을 수정하여 <resultMap> </ resultMap> 태그를 도입합니다. 이 태그에는 <select> 태그의 resultMap 속성에서이 resultMap을 실행하는 데 필요한 ID가 있습니다.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Employee">

   <!-- Perform Insert Operation -->
	
   <insert id="insert" parameterClass="Employee">
      INSERT INTO EMPLOYEE(first_name, last_name, salary)
      values (#first_name#, #last_name#, #salary#)

      <selectKey resultClass="int" keyProperty="id">
         select last_insert_id() as id
      </selectKey>
   </insert>

   <!-- Perform Read Operation -->
   <select id="getAll" resultClass="Employee">
      SELECT * FROM EMPLOYEE
   </select>

   <!-- Perform Update Operation -->
   <update id="update" parameterClass="Employee">
      UPDATE EMPLOYEE
      SET    first_name = #first_name#
      WHERE  id = #id#
    </update>

   <!-- Perform Delete Operation -->
   <delete id="delete" parameterClass="int">
      DELETE FROM EMPLOYEE
      WHERE  id = #id#
   </delete>

   <!-- Using ResultMap -->
   <resultMap id="result" class="Employee">
      <result property="id" column="id"/>
      <result property="first_name" column="first_name"/>
      <result property="last_name" column="last_name"/>
      <result property="salary" column="salary"/>
   </resultMap> 
	
   <select id="useResultMap" resultMap="result">
      SELECT * FROM EMPLOYEE
      WHERE id=#id#
   </select>

</sqlMap>

IbatisResultMap.java 파일

이 파일은 ResultMap을 사용하여 Employee 테이블에서 레코드를 읽는 응용 프로그램 수준 논리를 가지고 있습니다-

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class IbatisResultMap{
   public static void main(String[] args)
   throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);

      int id = 1;
      System.out.println("Going to read record.....");
      Employee e = (Employee)smc.queryForObject ("Employee.useResultMap", id);

      System.out.println("ID:  " + e.getId());
      System.out.println("First Name:  " + e.getFirstName());
      System.out.println("Last Name:  " + e.getLastName());
      System.out.println("Salary:  " + e.getSalary());
      System.out.println("Record read Successfully ");
   }
}

컴파일 및 실행

위와 같이 Employee.xml을 만듭니다.
위와 같이 Employee.java를 생성하고 컴파일합니다.
위와 같이 IbatisResultMap.java를 작성하고 컴파일하십시오.
IbatisResultMap 바이너리를 실행하여 프로그램을 실행합니다.

EMPLOYEE 테이블에 대한 읽기 작업 인 다음 결과를 얻을 수 있습니다.

Going to read record.....
ID:  1
First Name:  Zara
Last Name:  Ali
Salary:  5000
Record read Successfully

iBATIS 구성을 사용하여 스토어드 프로 시저를 호출 할 수 있습니다. 먼저 MySQL에서 저장 프로 시저를 만드는 방법을 이해하겠습니다.

MySQL에는 다음과 같은 EMPLOYEE 테이블이 있습니다.

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

MySQL 데이터베이스에 다음 저장 프로 시저를 생성 해 보겠습니다.

DELIMITER $$

   DROP PROCEDURE IF EXISTS `testdb`.`getEmp` $$ CREATE PROCEDURE `testdb`.`getEmp` (IN empid INT) BEGIN SELECT * FROM EMPLOYEE WHERE ID = empid; END $$

DELIMITER;

EMPLOYEE 테이블에 다음과 같은 두 개의 레코드가 있다고 가정 해 보겠습니다.

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
|  1 | Zara       | Ali       |   5000 |
|  2 | Roma       | Ali       |   3000 |
+----+------------+-----------+--------+
2 row in set (0.00 sec)

직원 POJO 클래스

저장 프로 시저를 사용하기 위해 Employee.java 파일을 수정할 필요가 없습니다. 지난 장에서와 같이 유지합시다.

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  

   /* Define constructors for the Employee class. */
   public Employee() {}
  
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }

   /* Here are the required method definitions */
   public int getId() {
      return id;
   }
	
   public void setId(int id) {
      this.id = id;
   }
	
   public String getFirstName() {
      return first_name;
   }
	
   public void setFirstName(String fname) {
      this.first_name = fname;
   }
	
   public String getLastName() {
      return last_name;
   }
	
   public void setlastName(String lname) {
      this.last_name = lname;
   }
	
   public int getSalary() {
      return salary;
   }
	
   public void setSalary(int salary) {
      this.salary = salary;
   }

} /* End of Employee */

Employee.xml 파일

여기서 우리는 Employee.xml을 수정하여 <procedure> </ procedure> 및 <parameterMap> </ parameterMap> 태그를 도입합니다. 여기서 <procedure> </ procedure> 태그는 저장 프로 시저를 호출하기 위해 애플리케이션에서 사용할 ID를 갖습니다.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Employee">

   <!-- Perform Insert Operation -->
   <insert id="insert" parameterClass="Employee">
      INSERT INTO EMPLOYEE(first_name, last_name, salary)
      values (#first_name#, #last_name#, #salary#)

      <selectKey resultClass="int" keyProperty="id">
         select last_insert_id() as id
      </selectKey>
   </insert>

   <!-- Perform Read Operation -->
   <select id="getAll" resultClass="Employee">
      SELECT * FROM EMPLOYEE
   </select>

   <!-- Perform Update Operation -->
   <update id="update" parameterClass="Employee">
      UPDATE EMPLOYEE
      SET    first_name = #first_name#
      WHERE  id = #id#
   </update>

   <!-- Perform Delete Operation -->
   <delete id="delete" parameterClass="int">
      DELETE FROM EMPLOYEE
      WHERE  id = #id#
   </delete>

   <!-- To call stored procedure. -->
   <procedure id="getEmpInfo" resultClass="Employee" parameterMap="getEmpInfoCall">
      { call getEmp( #acctID# ) } 
   </procedure>
	
   <parameterMap id="getEmpInfoCall" class="map">
      <parameter property="acctID" jdbcType="INT" javaType="java.lang.Integer" mode="IN"/>
   </parameterMap>

</sqlMap>

IbatisSP.java 파일

이 파일은 ResultMap을 사용하여 Employee 테이블에서 직원의 이름을 읽는 응용 프로그램 수준 논리를 가지고 있습니다-

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class IbatisSP{
   public static void main(String[] args)
   throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);

      int id = 1;
      System.out.println("Going to read employee name.....");
      Employee e = (Employee) smc.queryForObject ("Employee.getEmpInfo", id);

      System.out.println("First Name:  " + e.getFirstName());
      System.out.println("Record name Successfully ");
   }
}

컴파일 및 실행

위와 같이 Employee.xml을 만듭니다.
위와 같이 Employee.java를 생성하고 컴파일합니다.
위와 같이 IbatisSP.java를 만들고 컴파일합니다.
IbatisSP 바이너리를 실행하여 프로그램을 실행합니다.

다음과 같은 결과를 얻을 수 있습니다.

Going to read employee name.....
First Name:  Zara
Record name Successfully

동적 SQL은 iBATIS의 매우 강력한 기능입니다. 때때로 매개 변수 개체의 상태에 따라 WHERE 절 기준을 변경해야합니다. 이러한 상황에서 iBATIS는 SQL의 재사용 성과 유연성을 향상시키기 위해 매핑 된 문 내에서 사용할 수있는 일련의 동적 SQL 태그를 제공합니다.

모든 논리는 몇 가지 추가 태그를 사용하여 .XML 파일에 저장됩니다. 다음은 SELECT 문이 두 가지 방식으로 작동하는 예입니다.

ID를 전달하면 해당 ID에 해당하는 모든 레코드가 반환됩니다.

그렇지 않으면 직원 ID가 NULL로 설정된 모든 레코드를 반환합니다.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Employee">

   <select id="findByID" resultClass="Employee">
      SELECT * FROM EMPLOYEE
		
      <dynamic prepend="WHERE ">
         <isNull property="id">
            id IS NULL
         </isNull>
			
         <isNotNull property="id">
            id = #id#
         </isNotNull>
      </dynamic>
		
   </select>
</sqlMap>

다음과 같이 <isNotEmpty> 태그를 사용하여 조건을 확인할 수 있습니다. 여기서 조건은 전달 된 속성이 비어 있지 않은 경우에만 추가됩니다.

..................
<select id="findByID" resultClass="Employee">
   SELECT * FROM EMPLOYEE
	
   <dynamic prepend="WHERE ">
      <isNotEmpty property="id">
         id = #id#
      </isNotEmpty>
   </dynamic>
	
</select>
..................

직원의 ID 및 / 또는 이름을 선택할 수있는 쿼리를 원하는 경우 SELECT 문은 다음과 같습니다.

..................
<select id="findByID" resultClass="Employee">
   SELECT * FROM EMPLOYEE
	
   <dynamic prepend="WHERE ">
      <isNotEmpty prepend="AND" property="id">
         id = #id#
      </isNotEmpty>
		
      <isNotEmpty prepend="OR" property="first_name">
         first_name = #first_name#
      </isNotEmpty>
   </dynamic>
</select>
..................

동적 SQL 예

다음 예는 동적 SQL을 사용하여 SELECT 문을 작성하는 방법을 보여줍니다. MySQL에 다음과 같은 EMPLOYEE 테이블이 있습니다.

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

이 테이블에 다음과 같이 하나의 레코드 만 있다고 가정합니다.

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
|  1 | Zara       | Ali       |   5000 |
+----+------------+-----------+--------+
1 row in set (0.00 sec)

직원 POJO 클래스

읽기 작업을 수행하기 위해 다음과 같이 Employee.java에 Employee 클래스가 있습니다.

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  

   /* Define constructors for the Employee class. */
   public Employee() {}
  
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }

   /* Here are the method definitions */
   public int getId() {
      return id;
   }
	
   public String getFirstName() {
      return first_name;
   }
	
   public String getLastName() {
      return last_name;
   }
	
   public int getSalary() {
      return salary;
   }
	
} /* End of Employee */

Employee.xml 파일

iBATIS를 사용하여 SQL 매핑 문을 정의하려면 Employee.xml에 다음 수정 된 <select> 태그를 추가하고이 태그 정의 내에 동적 SQL SELECT 쿼리를 실행하기 위해 IbatisReadDy.java에서 사용할 "id"를 정의합니다. 데이터 베이스.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Employee">
   <select id="findByID" resultClass="Employee">
      SELECT * FROM EMPLOYEE
	
      <dynamic prepend="WHERE ">
         <isNotNull property="id">
            id = #id#
         </isNotNull>
      </dynamic>
		
   </select>
</sqlMap>

위의 SELECT 문은 두 가지 방식으로 작동합니다.

ID를 전달하면 해당 ID에 해당하는 레코드를 반환합니다. 그렇지 않으면 모든 레코드를 반환합니다.

IbatisReadDy.java 파일

이 파일에는 Employee 테이블에서 조건부 레코드를 읽는 응용 프로그램 수준 논리가 있습니다.

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class IbatisReadDy{
   public static void main(String[] args)
   throws IOException,SQLException{
      Reader rd=Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc=SqlMapClientBuilder.buildSqlMapClient(rd);

      /* This would read all records from the Employee table.*/
      System.out.println("Going to read records.....");
      Employee rec = new Employee();
      rec.setId(1);

      List <Employee> ems = (List<Employee>)  
         smc.queryForList("Employee.findByID", rec);
      Employee em = null;
		
      for (Employee e : ems) {
         System.out.print("  " + e.getId());
         System.out.print("  " + e.getFirstName());
         System.out.print("  " + e.getLastName());
         System.out.print("  " + e.getSalary());
         em = e; 
         System.out.println("");
      }    
      System.out.println("Records Read Successfully ");
   }
}

컴파일 및 실행

위와 같이 Employee.xml을 만듭니다.
위와 같이 Employee.java를 생성하고 컴파일합니다.
위와 같이 IbatisReadDy.java를 생성하고 컴파일합니다.
IbatisReadDy 바이너리를 실행하여 프로그램을 실행하십시오.

다음 결과를 얻고 EMPLOYEE 테이블에서 레코드를 읽습니다.

Going to read records.....
   1  Zara  Ali  5000
Record Reads Successfully

전달하여 위의 예를 시도하십시오 nullas smc.queryForList ( "Employee.findByID", null) .

iBATIS OGNL 표현식

iBATIS는 대부분의 다른 요소를 제거하기 위해 강력한 OGNL 기반 표현식을 제공합니다.

if 문
선택,시기, 그렇지 않은 경우
where 문
foreach 문

if 문

동적 SQL에서 수행하는 가장 일반적인 작업은 조건부로 where 절의 일부를 포함하는 것입니다. 예를 들면-

<select id="findActiveBlogWithTitleLike" parameterType="Blog" resultType="Blog">
   SELECT * FROM BLOG
   WHERE state = 'ACTIVE.
	
   <if test="title != null">
      AND title like #{title}
   </if>
	
</select>

이 명령문은 선택적 텍스트 검색 유형의 기능을 제공합니다. 제목없이 전달하면 모든 활성 블로그가 반환됩니다. 그러나 제목을 전달하면 주어진 제목이있는 제목을 찾습니다.like 질환.

여러 개를 포함 할 수 있습니다. if 다음과 같은 조건-

<select id="findActiveBlogWithTitleLike" parameterType="Blog" resultType="Blog">
   SELECT * FROM BLOG
   WHERE state = 'ACTIVE.
	
   <if test="title != null">
      AND title like #{title}
   </if>
	
   <if test="author != null">
      AND author like #{author}
   </if>
	
</select>

선택,시기 및 기타 진술

iBATIS는 chooseJava의 switch 문과 유사한 요소입니다. 여러 옵션 중 하나만 선택하는 데 도움이됩니다.

다음 예제는 제목이 제공되는 경우 제목으로 만 검색하고 제공되는 경우 작성자로만 검색합니다. 둘 다 제공되지 않으면 추천 블로그 만 반환합니다.

<select id="findActiveBlogWithTitleLike" parameterType="Blog" resultType="Blog">
   SELECT * FROM BLOG
   WHERE state = 'ACTIVE.
	
   <choose>
      <when test="title != null">
         AND title like #{title}
      </when>
		
      <when test="author != null and author.name != null">
         AND author like #{author}
      </when>
		
      <otherwise>
         AND featured = 1
      </otherwise>
   </choose>
	
</select>

Where 문

조건이 충족되지 않으면 어떻게되는지 이전 예제를 살펴보십시오. 당신은 다음과 같은 SQL로 끝날 것입니다-

SELECT * FROM BLOG
WHERE

이것은 실패 할 것이지만 iBATIS는 하나의 간단한 변경으로 간단한 솔루션을 가지고 있으며 모든 것이 잘 작동합니다.

<select id="findActiveBlogLike" parameterType="Blog" resultType="Blog">
   SELECT * FROM BLOG
	
   <where>
      <if test="state != null">
         state = #{state}
      </if>
		
      <if test="title != null">
         AND title like #{title}
      </if>
		
      <if test="author != null>
         AND author like #{author}
      </if>
   </where>
	
</select>

그만큼 where요소 는 포함하는 태그가 콘텐츠를 반환하는 경우에만 WHERE를 삽입합니다 . 또한 해당 콘텐츠가 AND 또는 OR로 시작 하면 제거하는 것을 알고 있습니다.

foreach 문

foreach 요소를 사용하면 컬렉션을 지정하고 요소 본문 내에서 사용할 수있는 항목 및 인덱스 변수를 선언 할 수 있습니다.

또한 열기 및 닫기 문자열을 지정하고 반복 사이에 배치 할 구분 기호를 추가 할 수 있습니다. 당신은 만들 수 있습니다IN 다음과 같은 조건-

<select id="selectPostIn" resultType="domain.blog.Post">
   SELECT *
   FROM POST P
   WHERE ID in
	
   <foreach item="item" index="index" collection="list"
      open="(" separator="," close=")">
      #{item}
   </foreach>
	
</select>

iBATIS로 작업하는 동안 프로그램을 디버그하는 것은 쉽습니다. iBATIS는 로깅 지원이 내장되어 있으며 다음 로깅 라이브러리와 함께 작동하며이 순서대로 검색합니다.

Jakarta Commons Logging (JCL).
Log4J
JDK 로깅

iBATIS와 함께 위에 나열된 라이브러리를 사용할 수 있습니다.

Log4J로 디버깅

로깅에 Log4J를 사용한다고 가정합니다. 계속하기 전에 다음 사항을 교차 확인해야합니다.

Log4J JAR 파일 (log4j- {version} .jar)은 CLASSPATH에 있어야합니다.
CLASSPATH에 log4j.properties가 있습니다.

다음은 log4j.properties 파일입니다. 일부 줄은 주석 처리되어 있습니다. 추가 디버깅 정보가 필요한 경우 주석 처리를 제거 할 수 있습니다.

# Global logging configuration
log4j.rootLogger = ERROR, stdout

log4j.logger.com.ibatis = DEBUG

# shows SQL of prepared statements
#log4j.logger.java.sql.Connection = DEBUG

# shows parameters inserted into prepared statements
#log4j.logger.java.sql.PreparedStatement = DEBUG

# shows query results
#log4j.logger.java.sql.ResultSet = DEBUG

#log4j.logger.java.sql.Statement = DEBUG

# Console output
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = %5p [%t] − %m%n

Apaches 사이트 -Log4J Documentation 에서 Log4J에 대한 전체 문서를 찾을 수 있습니다 .

iBATIS 디버깅 예

다음 Java 클래스는 초기화 한 다음 Java 응용 프로그램 용 Log4J 로깅 라이브러리를 사용하는 매우 간단한 예제입니다. CLASSPATH에있는 위에서 언급 한 속성 파일을 사용합니다.

import org.apache.log4j.Logger;

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class IbatisUpdate{
   static Logger log = Logger.getLogger(IbatisUpdate.class.getName());

   public static void main(String[] args)
   throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);

      /* This would insert one record in Employee table. */
      log.info("Going to update record.....");
      Employee rec = new Employee();
      rec.setId(1);
      rec.setFirstName( "Roma");
      smc.update("Employee.update", rec );
      log.info("Record updated Successfully ");

      log.debug("Going to read records.....");
      List <Employee> ems = (List<Employee>) 
         smc.queryForList("Employee.getAll", null);
      Employee em = null;
		
      for (Employee e : ems) {
         System.out.print("  " + e.getId());
         System.out.print("  " + e.getFirstName());
         System.out.print("  " + e.getLastName());
         System.out.print("  " + e.getSalary());
         em = e;
         System.out.println("");
      }
      log.debug("Records Read Successfully ");
   }
}

컴파일 및 실행

먼저 컴파일 및 실행을 진행하기 전에 PATH 및 CLASSPATH를 적절하게 설정했는지 확인하십시오.

위와 같이 Employee.xml을 만듭니다.
위와 같이 Employee.java를 생성하고 컴파일합니다.
위와 같이 IbatisUpdate.java를 생성하고 컴파일합니다.
위에 표시된대로 log4j.properties를 생성합니다.
IbatisUpdate 바이너리를 실행하여 프로그램을 실행하십시오.

다음과 같은 결과를 얻을 수 있습니다. EMPLOYEE 테이블에서 레코드가 업데이트되고 나중에 EMPLOYEE 테이블에서 동일한 레코드가 읽 힙니다.

DEBUG [main] - Created connection 28405330.
DEBUG [main] - Returned connection 28405330 to pool.
DEBUG [main] - Checked out connection 28405330 from pool.
DEBUG [main] - Returned connection 28405330 to pool.
   1  Roma  Ali  5000
   2  Zara  Ali  5000
   3  Zara  Ali  5000

디버그 방법

위의 예에서 우리는 info() 그러나 요구 사항에 따라 다음 방법 중 하나를 사용할 수 있습니다.

public void trace(Object message);
public void debug(Object message);
public void info(Object message);
public void warn(Object message);
public void error(Object message);
public void fatal(Object message);

iBATIS와 Hibernate 사이에는 큰 차이점이 있습니다. 두 솔루션 모두 특정 도메인을 고려할 때 잘 작동합니다. iBATIS는 다음과 같은 경우에 권장됩니다.

당신은 당신 자신의 SQL을 만들고 싶어하고 그것을 유지하기를 원합니다.
환경은 관계형 데이터 모델에 의해 주도됩니다.
기존 및 복잡한 스키마에서 작업해야합니다.

환경이 객체 모델에 의해 구동되고 SQL을 자동으로 생성해야하는 경우 Hibernate를 사용하십시오.

iBATIS와 Hibernate의 차이점

Hibernate와 iBATIS는 모두 업계에서 사용할 수있는 오픈 소스 ORM (Object Relational Mapping) 도구입니다. 이러한 각 도구의 사용은 사용중인 컨텍스트에 따라 다릅니다.

다음 표는 iBATIS와 Hibernate의 차이점을 강조합니다.

iBATIS	최대 절전 모드
iBATIS는 더 간단합니다. 훨씬 작은 패키지 크기로 제공됩니다.	Hibernate는 SQL을 생성하므로 SQL 생성에 시간을 할애 할 필요가 없습니다.
iBATIS는 유연합니다. 더 빠른 개발 시간을 제공합니다.	Hibernate는 확장 성이 뛰어납니다. 훨씬 더 고급 캐시를 제공합니다.
iBATIS는 데이터베이스에 종속 될 수있는 SQL을 사용합니다.	Hibernate는 데이터베이스와 상대적으로 독립적 인 HQL을 사용합니다. Hibernate에서 db를 변경하는 것이 더 쉽습니다.
iBatis는 JDBC API의 ResultSet을 POJO Objets에 매핑하므로 테이블 구조에 대해 신경 쓸 필요가 없습니다.	Hibernate는 Java POJO 객체를 데이터베이스 테이블에 매핑합니다.
iBATIS에서 저장 프로 시저를 사용하는 것은 매우 쉽습니다.	저장 프로 시저를 사용하는 것은 Hibernate에서 약간 어렵습니다.

Hibernate와 iBATIS는 모두 SPRING 프레임 워크에서 좋은 지원을 받기 때문에 둘 중 하나를 선택하는 것이 문제가되지 않습니다.

iBATOR는 iBATIS 용 코드 생성기입니다. iBATOR는 하나 이상의 데이터베이스 테이블을 조사하고 테이블에 액세스하는 데 사용할 수있는 iBATIS 아티팩트를 생성합니다.

나중에 요구 사항을 충족하기 위해 사용자 지정 SQL 코드 또는 저장 프로 시저를 작성할 수 있습니다. iBATOR는 다음과 같은 아티팩트를 생성합니다.

SqlMap XML 파일
테이블의 기본 키 및 필드와 일치하는 Java 클래스
위의 객체를 사용하는 DAO 클래스 (선택 사항)

iBATOR는 독립형 JAR 파일, Ant 작업 또는 Eclipse 플러그인으로 실행할 수 있습니다. 이 자습서에서는 명령 줄에서 iBATIS 구성 파일을 생성하는 가장 간단한 방법을 설명합니다.

iBATOR 다운로드

Eclipse 이외의 IDE를 사용하는 경우 독립형 JAR을 다운로드하십시오. 독립형 JAR에는 iBATOR를 실행하기위한 Ant 태스크가 포함되어 있거나 Java 코드의 명령 줄에서 iBATOR를 실행할 수 있습니다.

iBATOR 다운로드에서 zip 파일을 다운로드 할 수 있습니다 .
온라인 문서 -iBATOR 문서를 확인할 수 있습니다 .

구성 파일 생성

iBATOR를 실행하려면 다음 단계를 따르십시오.

1 단계

구성 파일 ibatorConfig.xml을 적절하게 작성하고 채 웁니다. 최소한 다음을 지정해야합니다.

ㅏ <jdbcConnection> 대상 데이터베이스에 연결하는 방법을 지정하는 요소입니다.
ㅏ <javaModelGenerator> 생성 된 Java 모델 오브젝트의 대상 패키지 및 대상 프로젝트를 지정하는 요소입니다.
ㅏ <sqlMapGenerator> 생성 된 SQL 맵 파일에 대한 대상 패키지 및 대상 프로젝트를 지정하는 요소입니다.
ㅏ <daoGenerator> 생성 된 DAO 인터페이스 및 클래스에 대한 대상 패키지 및 대상 프로젝트를 지정하는 요소입니다 (DAO를 생성하지 않으려면 <daoGenerator> 요소를 생략 할 수 있습니다).
하나 이상의 데이터베이스 <table> 요소

NOTE −iBATOR 구성 파일의 예 는 XML 구성 파일 참조 페이지를 참조 하십시오.

2 단계

편리한 위치 (예 : \ temp \ ibatorConfig.xml)에 파일을 저장하십시오.

3 단계

이제 다음과 같이 명령 줄에서 iBATOR를 실행합니다.

java -jar abator.jar -configfile \temp\abatorConfig.xml -overwrite

iBATOR에게 구성 파일을 사용하여 실행하도록 지시합니다. 또한 iBATOR에게 동일한 이름을 가진 기존 Java 파일을 덮어 쓰도록 지시합니다. 기존 Java 파일을 저장하려면−overwrite 매개 변수.

충돌이 발생하면 iBATOR는 새로 생성 된 파일을 고유 한 이름으로 저장합니다.

iBATOR를 실행 한 후 새로 생성 된 코드를 사용하려면 표준 iBATIS 구성 파일을 생성하거나 수정해야합니다. 이에 대해서는 다음 섹션에서 설명합니다.

iBATOR 실행 후 작업

iBATOR를 실행 한 후 다른 iBATIS 구성 아티팩트를 생성하거나 수정해야합니다. 주요 작업은 다음과 같습니다-

SqlMapConfig.xml 파일을 만들거나 수정합니다.
dao.xml 파일을 생성하거나 수정합니다 (iBATIS DAO 프레임 워크를 사용하는 경우에만).

각 작업은 아래에 자세히 설명되어 있습니다.

SqlMapConfig.xml 파일 업데이트

iBATIS는 일반적으로 SqlMapConfig.xml이라는 XML 파일을 사용하여 iBATIS 세션에 사용되는 데이터베이스 연결, 트랜잭션 관리 체계 및 SQL 맵 XML 파일에 대한 정보를 지정합니다.

iBATOR는 실행 환경에 대해 전혀 모르기 때문에이 파일을 생성 할 수 없습니다. 그러나이 파일의 일부 항목은 iBATOR 생성 항목과 직접 관련됩니다.

구성 파일의 iBATOR 특정 요구 사항은 다음과 같습니다.

명령문 네임 스페이스를 활성화해야합니다.
iBATOR에서 생성 한 SQL Map XML 파일이 나열되어야합니다.

예를 들어 iBATOR가 MyTable_SqlMap.xml이라는 SQL Map XML 파일을 생성했으며 파일이 프로젝트의 test.xml 패키지에 배치되었다고 가정합니다. SqlMapConfig.xml 파일에는 다음 항목이 있어야합니다.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMapConfig PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-config-2.dtd">

<sqlMapConfig>
   <!-- Statement namespaces are required for Abator -->
   <settings useStatementNamespaces="true" />

   <!-- Setup the transaction manager and data source that are
   appropriate for your environment
   -->
	
   <transactionManager type="...">
      <dataSource type="...">
      </dataSource>
   </transactionManager>

   <!-- SQL Map XML files should be listed here -->
   <sqlMap resource="test/xml/MyTable_SqlMap.xml" />

</sqlMapConfig>

둘 이상의 SQL Map XML 파일이있는 경우 (일반적으로) 파일은 <transactionManager> 요소 뒤에 반복되는 <sqlMap> 요소와 함께 임의의 순서로 나열 될 수 있습니다.

dao.xml 파일 업데이트

iBATIS DAO 프레임 워크는 일반적으로 dao.xml이라는 xml 파일로 구성됩니다.

iBATIS DAO 프레임 워크는이 파일을 사용하여 DAO에 대한 데이터베이스 연결 정보를 제어하고 DAO 구현 클래스 및 DAO 인터페이스를 나열합니다.

이 파일에서 SqlMapConfig.xml 파일과 모든 iBATOR 생성 DAO 인터페이스 및 구현 클래스에 대한 경로를 지정해야합니다.

예를 들어, iBATOR가 MyTableDAO라는 DAO 인터페이스와 MyTableDAOImpl이라는 구현 클래스를 생성했으며 파일이 프로젝트의 test.dao 패키지에 배치되었다고 가정합니다.

dao.xml 파일에는 다음 항목이 있어야합니다.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE daoConfig PUBLIC "-//ibatis.apache.org//DTD DAO Configuration 2.0//EN" "http://ibatis.apache.org/dtd/dao-2.dtd">

<daoConfig>

   <context>
	
      <transactionManager type="SQLMAP">
         <property name="SqlMapConfigResource" value="test/SqlMapConfig.xml"/>
      </transactionManager>

      <!-- DAO interfaces and implementations should be listed here -->
      <dao interface="test.dao.MyTableDAO" implementation="test.dao.MyTableDAOImpl" />
   </context>
	
</daoConfig>

NOTE − 이 단계는 iBATIS DAO 프레임 워크 용 DAO를 생성 한 경우에만 필요합니다.