iBATIS - Hızlı Kılavuz

iBATIS, Java, .NET ve Ruby on Rails'deki SQL veritabanları ile nesneler arasındaki eşleştirmeyi otomatikleştiren bir kalıcılık çerçevesidir. Eşlemeler, SQL deyimlerini XML yapılandırma dosyalarında paketleyerek uygulama mantığından ayrıştırılır.

iBATIS, kalıcı POJO'lar (Düz Eski Java Nesneleri) için iyi olan hafif bir çerçeve ve kalıcılık API'sidir.

iBATIS, veri eşleyici olarak bilinen şeydir ve sınıf özellikleri ile veritabanı tablosunun sütunları arasındaki parametrelerin ve sonuçların eşlenmesiyle ilgilenir.

İBATIS ile Hibernate gibi diğer kalıcılık çerçeveleri arasındaki önemli bir fark, iBATIS'in SQL kullanımını vurgularken, diğer çerçevelerin genellikle Hazırda Bekletme Sorgu Dili (HQL) veya Kurumsal JavaBeans Sorgu Dili (EJB QL) gibi özel bir sorgu dili kullanmasıdır.

iBATIS Tasarım Felsefeleri

iBATIS, aşağıdaki tasarım felsefeleriyle birlikte gelir:

Simplicity − iBATIS, günümüzde mevcut olan en basit kalıcılık çerçevelerinden biri olarak kabul edilmektedir.
Fast Development − iBATIS, hiper hızlı geliştirmeyi kolaylaştırmak için elinden geleni yapar.
Portability − iBATIS, Java, Ruby ve Microsoft .NET için C # gibi hemen hemen her dil veya platform için uygulanabilir.
Independent Interfaces − iBATIS, uygulamanın geri kalanının kalıcılıkla ilgili kaynaklardan bağımsız kalmasına yardımcı olan veritabanından bağımsız arabirimler ve API'ler sağlar.
Open source − iBATIS ücretsiz ve açık kaynaklı bir yazılımdır.

İBATIS'in avantajları

iBATIS aşağıdaki avantajları sunar -

Supports stored procedures − iBATIS, iş mantığının veritabanının dışında tutulması ve uygulamanın dağıtılması ve test edilmesi daha kolay ve daha taşınabilir olması için SQL'i saklı yordamlar biçiminde kapsüller.
Supports inline SQL − Ön derleyiciye gerek yoktur ve SQL'in tüm özelliklerine tam erişiminiz vardır.
Supports dynamic SQL − iBATIS, parametrelere dayalı olarak dinamik olarak SQL sorguları oluşturmak için özellikler sağlar.
Supports O/RM − iBATIS, geç yükleme, birleştirme getirme, önbelleğe alma, çalışma zamanı kodu oluşturma ve miras alma gibi bir O / RM aracı ile aynı özelliklerin çoğunu destekler

iBATIS, veritabanı odaklı uygulama geliştirirken JAVA programlama dilini kullanır. Daha fazla ilerlemeden önce, prosedürel ve nesne yönelimli programlamanın temellerini anladığınızdan emin olun - kontrol yapıları, veri yapıları ve değişkenler, sınıflar, nesneler vb.

JAVA'yı ayrıntılı olarak anlamak için JAVA Eğitimimizi inceleyebilirsiniz .

Fiili geliştirme çalışmasına başlamadan önce iBATIS için uygun bir ortam kurmanız gerekir. Bu bölüm, iBATIS için bir çalışma ortamının nasıl kurulacağını açıklar.

iBATIS Kurulumu

İBATIS'i Linux makinenize kurmak için aşağıdaki basit adımları uygulayın -

İBATIS'in en son sürümünü İndir iBATIS'den indirin .
.Jar dosyasını paketten çıkarmak için indirilen dosyayı açın ve bunları uygun lib dizininde saklayın.
Çıkarılan .jar dosyalarında PATH ve CLASSPATH değişkenlerini uygun şekilde ayarlayın.

$ 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

Veritabanı Kurulumu

Aşağıdaki sözdizimini kullanarak herhangi bir MySQL veritabanında bir EMPLOYEE tablosu oluşturun -

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 oluşturun

Aşağıdakileri düşünün -

Veritabanına erişmek için JDBC kullanacağız testdb.
MySQL için JDBC sürücüsü "com.mysql.jdbc.Driver" dır.
Bağlantı URL'si "jdbc: mysql: // localhost: 3306 / testdb" şeklindedir.
Kullanıcı adı ve şifreyi sırasıyla "root" ve "root" olarak kullanırdık.
Tüm işlemler için sql ifadesi eşlemelerimiz "Employee.xml" dosyasında açıklanacaktır.

Yukarıdaki varsayımlara dayanarak, adıyla bir XML yapılandırma dosyası oluşturmalıyız SqlMapConfig.xmlaşağıdaki içeriğe sahip. İBatis için gerekli tüm konfigürasyonları sağlamanız gereken yer burasıdır -

Sınıf yolunda hem SqlMapConfig.xml hem de Employee.xml dosyalarının bulunması önemlidir. Şimdilik Employee.xml dosyasını boş tutacak ve içeriğini sonraki bölümlerde ele alacağız.

<?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 dosyasını kullanarak aşağıdaki isteğe bağlı özellikleri de ayarlayabilirsiniz -

<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"/>

İBATIS kullanarak herhangi bir Oluşturma, Okuma, Güncelleme ve Silme (CRUD) işlemini gerçekleştirmek için, tabloya karşılık gelen bir Düz Eski Java Nesneleri (POJO) sınıfı oluşturmanız gerekir. Bu sınıf, veritabanı tablosu satırlarını "modelleyecek" nesneleri açıklar.

POJO sınıfı, istenen işlemleri gerçekleştirmek için gereken tüm yöntemler için uygulamaya sahip olacaktır.

MySQL'de aşağıdaki EMPLOYEE tablosuna sahip olduğumuzu varsayalım -

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)
);

Çalışan POJO Sınıfı

Employee.java dosyasında aşağıdaki gibi bir Çalışan sınıfı oluştururuz -

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 */

Tablodaki bireysel alanları ayarlamak için yöntemler tanımlayabilirsiniz. Bir sonraki bölüm, tek tek alanların değerlerinin nasıl alınacağını açıklamaktadır.

Employee.xml Dosyası

İBATIS kullanarak SQL eşleme deyimini tanımlamak için <insert> etiketini kullanırdık ve bu etiket tanımının içinde, veritabanında SQL INSERT sorgusunu çalıştırmak için IbatisInsert.java dosyasında kullanılacak bir "id" tanımlardık.

<?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>

Buraya parameterClass −gereksinime göre string, int, float, double veya herhangi bir sınıf nesnesi olarak bir değer alabilir . Bu örnekte, SqlMap sınıfının insert yöntemini çağırırken Employee nesnesini parametre olarak ileteceğiz.

Veritabanı tablonuz bir IDENTITY, AUTO_INCREMENT veya SERIAL sütunu kullanıyorsa veya bir SEQUENCE / GENERATOR tanımladıysanız, veritabanı tarafından üretilen bu değeri kullanmak veya döndürmek için <insert> ifadesinde <selectKey> öğesini kullanabilirsiniz.

IbatisInsert.java Dosyası

Bu dosya, Employee tablosuna kayıt eklemek için uygulama düzeyinde mantığa sahip olacaktır -

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 ");
   }
}

Derleme ve Çalıştırma

Yukarıda bahsedilen yazılımı derlemek ve çalıştırmak için adımlar aşağıda verilmiştir. Derleme ve yürütme için ilerlemeden önce PATH ve CLASSPATH'ı uygun şekilde ayarladığınızdan emin olun.

Employee.xml'yi yukarıda gösterildiği gibi oluşturun.
Employee.java'yı yukarıda gösterildiği gibi oluşturun ve derleyin.
IbatisInsert.java'yı yukarıda gösterildiği gibi oluşturun ve derleyin.
Programı çalıştırmak için IbatisInsert ikili dosyasını çalıştırın.

Aşağıdaki sonucu alırsınız ve EMPLOYEE tablosunda bir kayıt oluşturulur.

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

EMPLOYEE tablosunu kontrol ederseniz, aşağıdaki sonucu göstermelidir -

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

Son bölümde, CREATE işleminin iBATIS kullanarak bir tablo üzerinde nasıl gerçekleştirileceğini tartışmıştık. Bu bölüm, iBATIS kullanılarak bir tablonun nasıl okunacağını açıklar.

MySQL'de aşağıdaki EMPLOYEE tablosuna sahibiz -

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)
);

Bu tablonun aşağıdaki gibi yalnızca bir kaydı vardır -

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

Çalışan POJO Sınıfı

Okuma işlemini gerçekleştirmek için Employee.java'daki Employee sınıfını aşağıdaki gibi değiştirirdik -

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 Dosyası

İBATIS kullanarak SQL eşleme deyimini tanımlamak için Employee.xml dosyasına <select> etiketi ekleyeceğiz ve bu etiket tanımının içine, veritabanında SQL SELECT sorgusunu çalıştırmak için IbatisRead.java dosyasında kullanılacak bir "id" tanımlayacağız.

<?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>

Burada SQL SELECT deyimiyle WHERE cümlesini kullanmadık. Sonraki bölümde, WHERE cümlesini SELECT ifadesiyle nasıl kullanabileceğinizi ve bu WHERE cümlesine değerleri nasıl aktarabileceğinizi göstereceğiz.

IbatisRead.java Dosyası

Bu dosya, Çalışan tablosundan kayıtları okumak için uygulama düzeyinde mantığa sahiptir -

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 ");
   }
}

Derleme ve Çalıştırma

Employee.xml'yi yukarıda gösterildiği gibi oluşturun.
Employee.java'yı yukarıda gösterildiği gibi oluşturun ve derleyin.
IbatisRead.java'yı yukarıda gösterildiği gibi oluşturun ve derleyin.
Programı çalıştırmak için IbatisRead ikili dosyasını çalıştırın.

Aşağıdaki sonucu alırsınız ve ÇALIŞAN tablosundan aşağıdaki gibi bir kayıt okunur -

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

Son bölümde, iBATIS kullanarak bir tablo üzerinde OKUMA işleminin nasıl gerçekleştirileceğini tartışmıştık. Bu bölüm, iBATIS kullanarak bir tablodaki kayıtları nasıl güncelleyebileceğinizi açıklar.

MySQL'de aşağıdaki EMPLOYEE tablosuna sahibiz -

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)
);

Bu tablonun aşağıdaki gibi yalnızca bir kaydı vardır -

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

Çalışan POJO Sınıfı

Udpate işlemini gerçekleştirmek için Employee.java dosyasını aşağıdaki gibi değiştirmeniz gerekir -

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 Dosyası

SQL mapping deyimini iBATIS kullanarak tanımlamak için Employee.xml içine <update> etiketi ekleyeceğiz ve bu etiket tanımının içine, veritabanında SQL UPDATE sorgusu çalıştırmak için IbatisUpdate.java dosyasında kullanılacak bir "id" tanımlayacağız.

<?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 Dosyası

Bu dosya, kayıtları Çalışan tablosuna güncellemek için uygulama düzeyinde mantığa sahiptir -

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 ");
   }
}

Derleme ve Çalıştırma

Employee.xml'yi yukarıda gösterildiği gibi oluşturun.
Employee.java'yı yukarıda gösterildiği gibi oluşturun ve derleyin.
Yukarıda gösterildiği gibi IbatisUpdate.java'yı oluşturun ve derleyin.
Programı çalıştırmak için IbatisUpdate ikili dosyasını çalıştırın.

Aşağıdaki sonucu alırsınız ve EMPLOYEE tablosunda bir kayıt güncellenir ve daha sonra aynı kayıt EMPLOYEE tablosundan okunur.

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

Bu bölüm, iBATIS kullanılarak bir tablodan kayıtların nasıl silineceğini açıklar.

MySQL'de aşağıdaki EMPLOYEE tablosuna sahibiz -

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)
);

Bu tablonun aşağıdaki gibi iki kaydı olduğunu varsayalım -

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)

Çalışan POJO Sınıfı

Silme işlemini gerçekleştirmek için Employee.java dosyasını değiştirmenize gerek yoktur. Son bölümde olduğu gibi devam edelim.

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 Dosyası

SQL mapping deyimini iBATIS kullanarak tanımlamak için Employee.xml içine <delete> etiketi ekleyeceğiz ve bu etiket tanımının içine veritabanında SQL DELETE sorgusunu çalıştırmak için IbatisDelete.java dosyasında kullanılacak bir "id" tanımlayacağız.

<?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 Dosyası

Bu dosya, Employee tablosundan kayıtları silmek için uygulama düzeyinde mantığa sahiptir -

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 ");
   }
}

Derleme ve Çalıştırma

Employee.xml'yi yukarıda gösterildiği gibi oluşturun.
Employee.java'yı yukarıda gösterildiği gibi oluşturun ve derleyin.
IbatisDelete.java'yı yukarıda gösterildiği gibi oluşturun ve derleyin.
Programı çalıştırmak için IbatisDelete ikili dosyasını çalıştırın.

Aşağıdaki sonucu alırsınız ve ID = 1 olan bir kayıt EMPLOYEE tablosundan silinir ve kayıtların geri kalanı okunur.

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

ResultMap öğesi, iBATIS'teki en önemli ve güçlü unsurdur. İBATIS ResultMap kullanarak JDBC kodlamasını% 90'a kadar azaltabilirsiniz ve bazı durumlarda, JDBC'nin desteklemediği şeyleri bile yapmanıza izin verir.

ResultMaps'in tasarımı öyledir ki, basit ifadeler hiçbir şekilde açık sonuç eşlemeleri gerektirmez ve daha karmaşık ifadeler, ilişkileri tanımlamak için kesinlikle gerekenden fazlasını gerektirmez.

Bu bölüm, iBATIS Sonuç Haritalarına yalnızca basit bir giriş sağlar.

MySQL'de aşağıdaki EMPLOYEE tablosuna sahibiz -

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)
);

Bu tablonun aşağıdaki gibi iki kaydı vardır -

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)

Çalışan POJO Sınıfı

İBATIS ResultMap'i kullanmak için Employee.java dosyasını değiştirmenize gerek yoktur. Son bölümde olduğu gibi devam edelim.

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 Dosyası

Burada Employee.xml'yi <resultMap> </resultMap> etiketini tanıtacak şekilde değiştirirdik. Bu etiketin, <select> etiketinin resultMap özniteliğinde bu resultMap'i çalıştırmak için gerekli bir kimliği olacaktır.

<?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 Dosyası

Bu dosya, ResultMap kullanarak Çalışan tablosundaki kayıtları okumak için uygulama düzeyinde mantığa sahiptir -

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 ");
   }
}

Derleme ve Çalıştırma

Employee.xml'yi yukarıda gösterildiği gibi oluşturun.
Employee.java'yı yukarıda gösterildiği gibi oluşturun ve derleyin.
IbatisResultMap.java'yı yukarıda gösterildiği gibi oluşturun ve derleyin.
Programı çalıştırmak için IbatisResultMap ikili dosyasını çalıştırın.

EMPLOYEE tablosunda bir okuma işlemi olan aşağıdaki sonucu alırsınız.

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

İBATIS yapılandırmasını kullanarak bir saklı yordamı çağırabilirsiniz. Her şeyden önce, MySQL'de nasıl saklı yordam oluşturulacağını anlayalım.

MySQL'de aşağıdaki EMPLOYEE tablosuna sahibiz -

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 veritabanında aşağıdaki saklı yordamı oluşturalım -

DELIMITER $$

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

DELIMITER;

EMPLOYEE tablosunun aşağıdaki gibi iki kaydı olduğunu düşünelim:

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)

Çalışan POJO Sınıfı

Depolanan yordamı kullanmak için Employee.java dosyasını değiştirmeniz gerekmez. Son bölümde olduğu gibi devam edelim.

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 Dosyası

Burada Employee.xml'yi <procedure> </procedure> ve <parameterMap> </parameterMap> etiketlerini tanıtacak şekilde değiştirirdik. Burada <procedure> </procedure> etiketi, uygulamamızda saklı yordamı çağırmak için kullanacağımız bir kimliğe sahip olacaktır.

<?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 Dosyası

Bu dosya, çalışanların adlarını ResultMap kullanarak Çalışan tablosundan okumak için uygulama düzeyinde mantığa sahiptir -

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 ");
   }
}

Derleme ve Çalıştırma

Employee.xml'yi yukarıda gösterildiği gibi oluşturun.
Employee.java'yı yukarıda gösterildiği gibi oluşturun ve derleyin.
Yukarıda gösterildiği gibi IbatisSP.java'yı oluşturun ve derleyin.
Programı çalıştırmak için IbatisSP ikili dosyasını çalıştırın.

Aşağıdaki sonucu alırsınız:

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

Dinamik SQL, iBATIS'in çok güçlü bir özelliğidir. Bazen parametre nesnenizin durumuna bağlı olarak WHERE yan tümcesi kriterini değiştirmeniz gerekir. Bu gibi durumlarda, iBATIS, SQL'in yeniden kullanılabilirliğini ve esnekliğini artırmak için eşlenmiş ifadelerde kullanılabilen bir dizi dinamik SQL etiketi sağlar.

Tüm mantık, bazı ek etiketler kullanılarak .XML dosyasına yerleştirilir. Aşağıda, SELECT ifadesinin iki şekilde çalışacağı bir örnek verilmiştir:

Bir kimlik iletirseniz, o kimliğe karşılık gelen tüm kayıtları döndürür.

Aksi takdirde, çalışan kimliğinin NULL olarak ayarlandığı tüm kayıtları döndürür.

<?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>

Aşağıdaki gibi <isNotEmpty> etiketini kullanarak bir koşulu kontrol edebilirsiniz. Burada bir koşul, yalnızca geçirilen bir özellik boş olmadığında eklenir.

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

Bir Çalışanın kimliğini ve / veya ilk adını seçebileceğimiz bir sorgu istiyorsanız, SELECT ifadeniz aşağıdaki gibi olacaktır -

..................
<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>
..................

Dinamik SQL Örneği

Aşağıdaki örnek, dinamik SQL ile bir SELECT ifadesini nasıl yazabileceğinizi gösterir. Bir düşünün, MySQL'de aşağıdaki EMPLOYEE tablosuna sahibiz -

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)
);

Bu tablonun aşağıdaki gibi yalnızca bir kaydı olduğunu varsayalım -

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

Çalışan POJO Sınıfı

Okuma işlemini gerçekleştirmek için Employee.java'da aşağıdaki gibi bir Employee sınıfımız olsun -

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 Dosyası

İBATIS kullanarak SQL eşleme ifadesini tanımlamak için, Employee.xml'ye aşağıdaki değiştirilmiş <select> etiketini ekleyeceğiz ve bu etiket tanımının içine, Dinamik SQL SELECT sorgusunu çalıştırmak için IbatisReadDy.java'da kullanılacak bir "id" tanımlayacağız. veri tabanı.

<?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>

Yukarıdaki SELECT ifadesi iki şekilde çalışacaktır -

Bir kimlik geçirirseniz, o kimliğe karşılık gelen kayıtları döndürür. Aksi takdirde, tüm kayıtları döndürür.

IbatisReadDy.java Dosyası

Bu dosya, Employee tablosundan koşullu kayıtları okumak için uygulama düzeyinde mantığa sahiptir -

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 ");
   }
}

Derleme ve Çalıştırma

Employee.xml'yi yukarıda gösterildiği gibi oluşturun.
Employee.java'yı yukarıda gösterildiği gibi oluşturun ve derleyin.
IbatisReadDy.java'yı yukarıda gösterildiği gibi oluşturun ve derleyin.
Programı çalıştırmak için IbatisReadDy ikili dosyasını çalıştırın.

Aşağıdaki sonucu alırsınız ve EMPLOYEE tablosundan bir kayıt okunur.

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

Yukarıdaki örneği geçerek deneyin nullolarak smc.queryForList (boş, "Employee.findByID") .

iBATIS OGNL İfadeleri

iBATIS, diğer öğelerin çoğunu ortadan kaldırmak için güçlü OGNL tabanlı ifadeler sağlar.

if İfadesi
aksi takdirde seç, ne zaman, yoksa
nerede ifadesi
foreach İfadesi

İf İfadesi

Dinamik SQL'de yapılacak en yaygın şey, koşullu olarak where cümlesinin bir parçasını eklemektir. Örneğin -

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

Bu ifade, isteğe bağlı bir metin arama tipi işlevsellik sağlar. Hiçbir başlık vermezseniz, tüm aktif Bloglar döndürülür. Ancak bir başlığı geçerseniz, verilen başlık ile bir başlık arayacaktır.like durum.

Birden fazla ekleyebilirsiniz if aşağıdaki koşullar -

<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>

Seçim, ne zaman ve başka türlü İfadeler

iBATIS şunları sunar: chooseJava'nın switch deyimine benzer öğe. Birçok seçenek arasından yalnızca bir vakayı seçmeye yardımcı olur.

Aşağıdaki örnek, sağlanmışsa yalnızca başlığa göre, daha sonra sağlanmışsa yalnızca yazara göre aranacaktır. Hiçbiri sağlanmazsa, yalnızca öne çıkan blogları döndürür -

<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>

Nerede İfadesi

Koşullardan hiçbiri karşılanmazsa ne olacağını görmek için önceki örneklerimize bir göz atın. Şuna benzeyen bir SQL elde edersiniz -

SELECT * FROM BLOG
WHERE

Bu başarısız olur, ancak iBATIS'in basit bir değişiklikle basit bir çözümü var, her şey yolunda gidiyor -

<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öğesi, yalnızca içeren etiketler herhangi bir içerik döndürdüğünde bir WHERE ekler . Ayrıca, eğer bu içerik AND veya OR ile başlıyorsa , onu çıkarmayı bilir.

Foreach ifadesi

Foreach öğesi, bir koleksiyon belirtmenize ve öğenin gövdesi içinde kullanılabilecek öğe ve dizin değişkenlerini bildirmenize olanak tanır.

Ayrıca, açılış ve kapanış dizelerini belirlemenize ve yinelemeler arasına yerleştirmek için bir ayırıcı eklemenize olanak tanır. İnşa edebilirsinIN durum aşağıdaki gibidir -

<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>

İBATIS ile çalışırken programınızda hata ayıklamak kolaydır. iBATIS, yerleşik günlük kaydı desteğine sahiptir ve aşağıdaki günlük kaydı kitaplıkları ile çalışır ve bunları bu sırayla arar.

Jakarta Commons Günlüğü (JCL).
Log4J
JDK günlük kaydı

İBATIS ile birlikte yukarıda listelenen kitaplıklardan herhangi birini kullanabilirsiniz.

Log4J ile hata ayıklama

Log4J'yi günlük kaydı için kullanacağınızı varsayarsak. Devam etmeden önce aşağıdaki noktaları çapraz kontrol etmeniz gerekir -

Log4J JAR dosyası (log4j- {version} .jar) CLASSPATH içinde olmalıdır.
CLASSPATH'da log4j.properties'e sahipsiniz.

Log4j.properties dosyası aşağıdadır. Bazı satırların yorumlandığını unutmayın. Ek hata ayıklama bilgilerine ihtiyacınız varsa açıklamalarını kaldırabilirsiniz.

# 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 sitesinde - Log4J Documentation - Log4J için eksiksiz dokümantasyonu bulabilirsiniz .

iBATIS Hata Ayıklama Örneği

Aşağıdaki Java sınıfı, Java uygulamaları için Log4J günlük kitaplığını başlatan ve kullanan çok basit bir örnektir. CLASSPATH'da bulunan yukarıda belirtilen özellik dosyasını kullanırdık.

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 ");
   }
}

Derleme ve Çalıştırma

İlk olarak, derleme ve yürütme için ilerlemeden önce PATH ve CLASSPATH'ı uygun şekilde ayarladığınızdan emin olun.

Employee.xml'yi yukarıda gösterildiği gibi oluşturun.
Employee.java'yı yukarıda gösterildiği gibi oluşturun ve derleyin.
Yukarıda gösterildiği gibi IbatisUpdate.java'yı oluşturun ve derleyin.
Yukarıda gösterildiği gibi log4j.properties oluşturun.
Programı çalıştırmak için IbatisUpdate ikili dosyasını çalıştırın.

Aşağıdaki sonucu alırsınız. EMPLOYEE tablosunda bir kayıt güncellenecek ve daha sonra aynı kayıt EMPLOYEE tablosundan okunacaktır.

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

Hata Ayıklama Yöntemleri

Yukarıdaki örnekte sadece kullandık info() yöntem, ancak gereksinimlerinize göre aşağıdaki yöntemlerden herhangi birini kullanabilirsiniz -

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);

İBATIS ve Hibernate arasında büyük farklar vardır. Her iki çözüm de belirli alanlarına göre iyi çalışıyor. iBATIS şu durumlarda önerilir -

Kendi SQL'lerinizi oluşturmak istiyorsunuz ve onları korumaya hazırsınız.
Ortamınız ilişkisel veri modeli tarafından yönlendirilir.
Mevcut ve karmaşık şemalar üzerinde çalışmalısınız.

Ortam, nesne modeline göre yönlendiriliyorsa ve otomatik olarak SQL oluşturması gerekiyorsa Hazırda Bekletme'yi kullanın.

İBATIS ve Hibernate arasındaki fark

Hem Hibernate hem de iBATIS, sektörde bulunan açık kaynaklı Nesne İlişkisel Eşleme (ORM) araçlarıdır. Bu araçların her birinin kullanımı, onları kullandığınız bağlama bağlıdır.

Aşağıdaki tablo, iBATIS ve Hazırda Bekletme arasındaki farkları vurgulamaktadır -

iBATIS	Hazırda beklet
iBATIS daha basittir. Çok daha küçük bir paket boyutunda gelir.	Hazırda bekletme sizin için SQL oluşturur, bu da SQL oluşturmak için zaman harcamanıza gerek olmadığı anlamına gelir.
iBATIS esnektir. Daha hızlı geliştirme süresi sunar.	Hazırda bekletme oldukça ölçeklenebilir. Çok daha gelişmiş bir önbellek sağlar.
iBATIS, veritabanına bağlı olabilen SQL kullanır.	Hibernate, veritabanlarından nispeten bağımsız olan HQL kullanır. Hibernate'de db'yi değiştirmek daha kolaydır.
iBatis, JDBC API'sindeki ResultSet'i POJO Objetlerinize eşler, böylece tablo yapılarını önemsemeniz gerekmez.	Hibernate, Java POJO nesnelerinizi Veritabanı tablolarıyla eşler.
İBATIS'te saklı yordamı kullanmak oldukça kolaydır.	Hazırda bekletme modunda saklanan prosedürlerin kullanımı biraz zordur.

Hem Hibernate hem de iBATIS, SPRING çerçevesinden iyi bir destek alıyor, bu nedenle bunlardan birini seçmek sorun olmamalı.

iBATOR, iBATIS için bir kod üretecidir. iBATOR, bir veya daha fazla veritabanı tablosunun içini inceler ve tablolara erişmek için kullanılabilecek iBATIS yapıları oluşturur.

Daha sonra gereksinimlerinizi karşılamak için özel SQL kodunuzu veya saklı yordamınızı yazabilirsiniz. iBATOR aşağıdaki yapıları oluşturur -

SqlMap XML Dosyaları
Tablo (lar) ın birincil anahtarı ve alanlarıyla eşleşecek Java Sınıfları
Yukarıdaki nesneleri kullanan DAO Sınıfları (isteğe bağlı)

iBATOR, bağımsız bir JAR dosyası veya bir Ant görevi veya bir Eclipse eklentisi olarak çalışabilir. Bu eğitici, iBATIS yapılandırma dosyalarını komut satırından oluşturmanın en basit yolunu açıklar.

İBATOR'u indirin

Eclipse dışında bir IDE kullanıyorsanız bağımsız JAR'ı indirin. Bağımsız JAR, iBATOR'u çalıştırmak için bir Ant görevi içerir veya iBATOR'u Java kodunun komut satırından çalıştırabilirsiniz.

Zip dosyasını iBATOR İndir bölümünden indirebilirsiniz .
Çevrimiçi belgeleri kontrol edebilirsiniz - iBATOR Belgeleri .

Konfigürasyon Dosyası Oluşturuluyor

İBATOR'u çalıştırmak için şu adımları izleyin -

Aşama 1

Bir yapılandırma dosyası ibatorConfig.xml'yi uygun şekilde oluşturun ve doldurun. En azından şunu belirtmelisiniz -

Bir <jdbcConnection> Hedef veritabanına nasıl bağlanılacağını belirtmek için öğe.
Bir <javaModelGenerator> Oluşturulan Java modeli nesneleri için hedef paketi ve hedef projeyi belirtmek için öğe.
Bir <sqlMapGenerator> Oluşturulan SQL harita dosyaları için hedef paketi ve hedef projeyi belirtmek için öğe.
Bir <daoGenerator> Oluşturulan DAO arabirimleri ve sınıfları için hedef paketi ve hedef projeyi belirtmek için öğe (DAO'lar oluşturmak istemiyorsanız <daoGenerator> öğesini atlayabilirsiniz).
En az bir veritabanı <table> element

NOTE −Bkz XML Yapılandırma Dosyası Referans bir iBATOR yapılandırma dosyasının bir örneği için sayfa.

Adım 2

Dosyayı uygun bir konuma, örneğin şu konuma kaydedin: \ temp \ ibatorConfig.xml.

Aşama 3

Şimdi iBATOR'u komut satırından aşağıdaki gibi çalıştırın -

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

İBATOR'a yapılandırma dosyanızı kullanarak çalışmasını söyleyecektir. Ayrıca iBATOR'a aynı ada sahip mevcut Java dosyalarının üzerine yazmasını söyleyecektir. Mevcut herhangi bir Java dosyasını kaydetmek istiyorsanız,−overwrite parametre.

Bir çakışma varsa, iBATOR yeni oluşturulan dosyayı benzersiz bir adla kaydeder.

İBATOR'u çalıştırdıktan sonra, yeni oluşturulan kodunuzu kullanmak için standart iBATIS yapılandırma dosyalarını oluşturmanız veya değiştirmeniz gerekir. Bu sonraki bölümde açıklanmaktadır.

İBATOR'u Çalıştırdıktan Sonraki Görevler

İBATOR'u çalıştırdıktan sonra, diğer iBATIS yapılandırma yapılarını oluşturmanız veya değiştirmeniz gerekir. Ana görevler aşağıdaki gibidir -

SqlMapConfig.xml dosyasını oluşturun veya değiştirin.
Dao.xml dosyasını oluşturun veya değiştirin (yalnızca iBATIS DAO Framework kullanıyorsanız).

Her görev aşağıda ayrıntılı olarak açıklanmıştır -

SqlMapConfig.xml Dosyasını Güncelleme

iBATIS, bir iBATIS oturumunda kullanılan veritabanı bağlantısı, işlem yönetimi şeması ve SQL eşleme XML dosyalarını belirtmek için yaygın olarak SqlMapConfig.xml olarak adlandırılan bir XML dosyası kullanır.

iBATOR, yürütme ortamınız hakkında hiçbir şey bilmediği için bu dosyayı sizin için oluşturamaz. Ancak, bu dosyadaki bazı öğeler doğrudan iBATOR tarafından oluşturulan öğelerle ilgilidir.

Yapılandırma dosyasındaki iBATOR'a özgü ihtiyaçlar aşağıdaki gibidir -

İfade ad alanları etkinleştirilmelidir.
iBATOR tarafından oluşturulan SQL Map XML dosyaları listelenmelidir.

Örneğin, iBATOR'un MyTable_SqlMap.xml adlı bir SQL Map XML dosyası oluşturduğunu ve dosyanın projenizin test.xml paketine yerleştirildiğini varsayalım. SqlMapConfig.xml dosyası şu girişlere sahip olmalıdır -

<?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>

Birden fazla SQL Map XML dosyası varsa (oldukça yaygın olduğu gibi), dosyalar <transactionManager> öğesinden sonra tekrarlanan <sqlMap> öğeleriyle herhangi bir sırada listelenebilir.

Dao.xml Dosyasını Güncelleme

İBATIS DAO çerçevesi, genellikle dao.xml olarak adlandırılan bir xml dosyası tarafından yapılandırılır.

İBATIS DAO çerçevesi, bu dosyayı DAO'lar için veritabanı bağlantı bilgilerini kontrol etmek ve ayrıca DAO uygulama sınıflarını ve DAO arayüzlerini listelemek için kullanır.

Bu dosyada, SqlMapConfig.xml dosyanızın yolunu ve iBATOR tarafından üretilen tüm DAO arayüzlerini ve uygulama sınıflarını belirtmelisiniz.

Örneğin, iBATOR'un MyTableDAO adlı bir DAO arabirimi ve MyTableDAOImpl adlı bir uygulama sınıfı oluşturduğunu ve dosyaların projenizin test.dao paketine yerleştirildiğini varsayalım.

Dao.xml dosyası şu girişlere sahip olmalıdır -

<?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 − Bu adım yalnızca iBATIS DAO çerçevesi için DAO'lar oluşturduysanız gereklidir.