iBATIS - Kurzanleitung

iBATIS ist ein Persistenz-Framework, das die Zuordnung zwischen SQL-Datenbanken und Objekten in Java, .NET und Ruby on Rails automatisiert. Die Zuordnungen werden von der Anwendungslogik entkoppelt, indem die SQL-Anweisungen in XML-Konfigurationsdateien gepackt werden.

iBATIS ist ein leichtes Framework und eine Persistenz-API, die sich gut für persistierende POJOs (Plain Old Java Objects) eignet.

iBATIS ist ein sogenannter Data Mapper und sorgt für die Zuordnung der Parameter und Ergebnisse zwischen den Klasseneigenschaften und den Spalten der Datenbanktabelle.

Ein wesentlicher Unterschied zwischen iBATIS und anderen Persistenz-Frameworks wie Hibernate besteht darin, dass iBATIS die Verwendung von SQL betont, während andere Frameworks normalerweise eine benutzerdefinierte Abfragesprache verwenden, z. B. Hibernate Query Language (HQL) oder Enterprise JavaBeans Query Language (EJB QL).

iBATIS Designphilosophien

iBATIS bietet die folgenden Designphilosophien:

• Simplicity − iBATIS wird allgemein als eines der einfachsten derzeit verfügbaren Persistenz-Frameworks angesehen.

• Fast Development − iBATIS tut alles, um eine hyperschnelle Entwicklung zu ermöglichen.

• Portability − iBATIS kann für nahezu jede Sprache oder Plattform wie Java, Ruby und C # für Microsoft .NET implementiert werden.

• Independent Interfaces − iBATIS bietet datenbankunabhängige Schnittstellen und APIs, mit denen der Rest der Anwendung unabhängig von persistenzbezogenen Ressourcen bleibt.

• Open source − iBATIS ist kostenlos und eine Open Source Software.

Vorteile von iBATIS

iBATIS bietet folgende Vorteile:

• Supports stored procedures − iBATIS kapselt SQL in Form von gespeicherten Prozeduren, sodass die Geschäftslogik aus der Datenbank herausgehalten wird und die Anwendung einfacher bereitzustellen und zu testen ist und portabler ist.

• Supports inline SQL − Es wird kein Precompiler benötigt und Sie haben vollen Zugriff auf alle Funktionen von SQL.

• Supports dynamic SQL − iBATIS bietet Funktionen zum dynamischen Erstellen von SQL-Abfragen basierend auf Parametern.

• Supports O/RM − iBATIS unterstützt viele der gleichen Funktionen wie ein O / RM-Tool, z. B. verzögertes Laden, Abrufen von Verknüpfungen, Zwischenspeichern, Generieren von Laufzeitcode und Vererbung

iBATIS verwendet die Programmiersprache JAVA bei der Entwicklung datenbankorientierter Anwendungen. Bevor Sie fortfahren, stellen Sie sicher, dass Sie die Grundlagen der prozeduralen und objektorientierten Programmierung verstehen - Kontrollstrukturen, Datenstrukturen und Variablen, Klassen, Objekte usw.

Um JAVA im Detail zu verstehen, können Sie unser JAVA-Tutorial durchgehen .

Sie müssten eine geeignete Umgebung für iBATIS einrichten, bevor Sie mit der eigentlichen Entwicklungsarbeit beginnen können. In diesem Kapitel wird erläutert, wie Sie eine Arbeitsumgebung für iBATIS einrichten.

iBATIS Installation

Führen Sie die folgenden einfachen Schritte aus, um iBATIS auf Ihrem Linux-Computer zu installieren:

• Laden Sie die neueste Version von iBATIS von Download iBATIS herunter .

• Entpacken Sie die heruntergeladene Datei, um die JAR-Datei aus dem Bundle zu extrahieren, und bewahren Sie sie im entsprechenden lib-Verzeichnis auf.

• Stellen Sie die Variablen PATH und CLASSPATH in den extrahierten JAR-Dateien entsprechend ein.

$ 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

Datenbank-Setup

Erstellen Sie eine EMPLOYEE-Tabelle in einer beliebigen MySQL-Datenbank mit der folgenden Syntax:

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

Erstellen Sie SqlMapConfig.xml

Betrachten Sie Folgendes:

• Wir werden JDBC verwenden, um auf die Datenbank zuzugreifen testdb.

• Der JDBC-Treiber für MySQL lautet "com.mysql.jdbc.Driver".

• Die Verbindungs-URL lautet "jdbc: mysql: // localhost: 3306 / testdb".

• Wir würden Benutzername und Passwort als "root" bzw. "root" verwenden.

• Unsere SQL-Anweisungszuordnungen für alle Vorgänge werden in "Employee.xml" beschrieben.

Basierend auf den obigen Annahmen müssen wir eine XML-Konfigurationsdatei mit Namen erstellen SqlMapConfig.xmlmit folgendem Inhalt. Hier müssen Sie alle für iBatis erforderlichen Konfigurationen bereitstellen -

Es ist wichtig, dass sowohl die Dateien SqlMapConfig.xml als auch Employee.xml im Klassenpfad vorhanden sind. Im Moment würden wir die Datei Employee.xml leer lassen und den Inhalt in den folgenden Kapiteln behandeln.

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

Sie können die folgenden optionalen Eigenschaften auch mithilfe der Datei SqlMapConfig.xml festlegen:

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

Um eine CRUD-Operation (Create, Read, Update and Delete) mit iBATIS auszuführen, müssen Sie eine POJO-Klasse (Plain Old Java Objects) erstellen, die der Tabelle entspricht. Diese Klasse beschreibt die Objekte, die Datenbanktabellenzeilen "modellieren".

Die POJO-Klasse hätte eine Implementierung für alle Methoden, die zum Ausführen der gewünschten Operationen erforderlich sind.

Nehmen wir an, wir haben die folgende EMPLOYEE-Tabelle in 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)
);

Mitarbeiter POJO Klasse

Wir würden eine Employee-Klasse in der Employee.java-Datei wie folgt erstellen:

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

Sie können Methoden definieren, um einzelne Felder in der Tabelle festzulegen. Im nächsten Kapitel wird erläutert, wie Sie die Werte einzelner Felder ermitteln.

Employee.xml-Datei

Um die SQL-Zuordnungsanweisung mit iBATIS zu definieren, verwenden wir das Tag <Einfügung> und innerhalb dieser Tag-Definition definieren wir eine "ID", die in der Datei IbatisInsert.java zum Ausführen der SQL INSERT-Abfrage in der Datenbank verwendet wird.

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

Hier parameterClass −könnte nehmen einen Wert als String, int, float, double , oder jede Klasse Objekt basiert auf Anforderung. In diesem Beispiel würden wir das Employee-Objekt als Parameter übergeben, während wir die insert- Methode der SqlMap-Klasse aufrufen.

Wenn Ihre Datenbanktabelle eine IDENTITY-, AUTO_INCREMENT- oder SERIAL-Spalte verwendet oder Sie eine SEQUENCE / GENERATOR definiert haben, können Sie das <selectKey> -Element in einer <insert> -Anweisung verwenden, um diesen von der Datenbank generierten Wert zu verwenden oder zurückzugeben.

IbatisInsert.java-Datei

Diese Datei verfügt über eine Logik auf Anwendungsebene zum Einfügen von Datensätzen in die Employee-Tabelle.

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

Kompilieren und Ausführen

Hier sind die Schritte zum Kompilieren und Ausführen der oben genannten Software. Stellen Sie sicher, dass Sie PATH und CLASSPATH richtig eingestellt haben, bevor Sie mit der Kompilierung und Ausführung fortfahren.

• Erstellen Sie Employee.xml wie oben gezeigt.
• Erstellen Sie Employee.java wie oben gezeigt und kompilieren Sie es.
• Erstellen Sie IbatisInsert.java wie oben gezeigt und kompilieren Sie es.
• Führen Sie die Binärdatei IbatisInsert aus, um das Programm auszuführen.

Sie würden das folgende Ergebnis erhalten und ein Datensatz in der Tabelle EMPLOYEE erstellt.

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

Wenn Sie die Tabelle EMPLOYEE überprüfen, sollte das folgende Ergebnis angezeigt werden:

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

Im letzten Kapitel haben wir erläutert, wie Sie mit iBATIS eine CREATE-Operation für eine Tabelle ausführen. In diesem Kapitel wird erläutert, wie Sie eine Tabelle mit iBATIS lesen.

Wir haben die folgende EMPLOYEE-Tabelle in 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)
);

Diese Tabelle enthält nur einen Datensatz wie folgt:

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

Mitarbeiter POJO Klasse

Um eine Leseoperation auszuführen, ändern wir die Employee-Klasse in Employee.java wie folgt:

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

Um die SQL-Zuordnungsanweisung mit iBATIS zu definieren, fügen wir der Datei Employee.xml das Tag <select> hinzu und definieren innerhalb dieser Tag-Definition eine "id", die in der Datei IbatisRead.java zum Ausführen der SQL SELECT-Abfrage in der Datenbank verwendet wird.

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

Hier haben wir die WHERE-Klausel mit der SQL SELECT-Anweisung nicht verwendet. Wir werden im nächsten Kapitel zeigen, wie Sie die WHERE-Klausel mit der SELECT-Anweisung verwenden und wie Sie Werte an diese WHERE-Klausel übergeben können.

IbatisRead.java-Datei

Diese Datei verfügt über eine Logik auf Anwendungsebene zum Lesen von Datensätzen aus der Employee-Tabelle.

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

Kompilieren und Ausführen

Hier sind die Schritte zum Kompilieren und Ausführen der oben genannten Software. Stellen Sie sicher, dass Sie PATH und CLASSPATH richtig eingestellt haben, bevor Sie mit der Kompilierung und Ausführung fortfahren.

• Erstellen Sie Employee.xml wie oben gezeigt.
• Erstellen Sie Employee.java wie oben gezeigt und kompilieren Sie es.
• Erstellen Sie IbatisRead.java wie oben gezeigt und kompilieren Sie es.
• Führen Sie die IbatisRead-Binärdatei aus, um das Programm auszuführen.

Sie würden das folgende Ergebnis erhalten und ein Datensatz würde wie folgt aus der EMPLOYEE-Tabelle gelesen:

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

Im letzten Kapitel haben wir erläutert, wie Sie mit iBATIS eine READ-Operation für eine Tabelle ausführen. In diesem Kapitel wird erläutert, wie Sie Datensätze in einer Tabelle mit iBATIS aktualisieren können.

Wir haben die folgende EMPLOYEE-Tabelle in 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)
);

Diese Tabelle enthält nur einen Datensatz wie folgt:

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

Mitarbeiter POJO Klasse

Um den udpate-Vorgang auszuführen, müssen Sie die Datei Employee.java wie folgt ändern:

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

Um die SQL-Zuordnungsanweisung mit iBATIS zu definieren, fügen wir in Employee.xml das Tag <update> hinzu und definieren in dieser Tag-Definition eine "id", die in der Datei IbatisUpdate.java zum Ausführen der SQL UPDATE-Abfrage in der Datenbank verwendet wird.

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

Diese Datei verfügt über eine Logik auf Anwendungsebene zum Aktualisieren von Datensätzen in der Employee-Tabelle.

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

Kompilieren und Ausführen

Hier sind die Schritte zum Kompilieren und Ausführen der oben genannten Software. Stellen Sie sicher, dass Sie PATH und CLASSPATH richtig eingestellt haben, bevor Sie mit der Kompilierung und Ausführung fortfahren.

• Erstellen Sie Employee.xml wie oben gezeigt.
• Erstellen Sie Employee.java wie oben gezeigt und kompilieren Sie es.
• Erstellen Sie IbatisUpdate.java wie oben gezeigt und kompilieren Sie es.
• Führen Sie die IbatisUpdate-Binärdatei aus, um das Programm auszuführen.

Sie würden folgendes Ergebnis erhalten und ein Datensatz würde in der Tabelle EMPLOYEE aktualisiert, und später würde derselbe Datensatz aus der Tabelle EMPLOYEE gelesen.

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

In diesem Kapitel wird beschrieben, wie Sie mit iBATIS Datensätze aus einer Tabelle löschen.

Wir haben die folgende EMPLOYEE-Tabelle in 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)
);

Angenommen, diese Tabelle enthält zwei Datensätze wie folgt:

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)

Mitarbeiter POJO Klasse

Um einen Löschvorgang auszuführen, müssen Sie die Datei Employee.java nicht ändern. Behalten wir es bei, wie es im letzten Kapitel war.

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

Um die SQL-Zuordnungsanweisung mit iBATIS zu definieren, fügen wir in Employee.xml das Tag <delete> hinzu und definieren innerhalb dieser Tag-Definition eine "id", die in der Datei IbatisDelete.java zum Ausführen der SQL DELETE-Abfrage in der Datenbank verwendet wird.

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

Diese Datei verfügt über eine Logik auf Anwendungsebene zum Löschen von Datensätzen aus der Employee-Tabelle.

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

Kompilieren und Ausführen

Hier sind die Schritte zum Kompilieren und Ausführen der oben genannten Software. Stellen Sie sicher, dass Sie PATH und CLASSPATH richtig eingestellt haben, bevor Sie mit der Kompilierung und Ausführung fortfahren.

• Erstellen Sie Employee.xml wie oben gezeigt.
• Erstellen Sie Employee.java wie oben gezeigt und kompilieren Sie es.
• Erstellen Sie IbatisDelete.java wie oben gezeigt und kompilieren Sie es.
• Führen Sie die IbatisDelete-Binärdatei aus, um das Programm auszuführen.

Sie würden das folgende Ergebnis erhalten und ein Datensatz mit der ID = 1 würde aus der EMPLOYEE-Tabelle gelöscht und der Rest der Datensätze würde gelesen.

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

Das resultMap-Element ist das wichtigste und leistungsstärkste Element in iBATIS. Mit iBATIS ResultMap können Sie die JDBC-Codierung um bis zu 90% reduzieren. In einigen Fällen können Sie damit Dinge tun, die JDBC nicht einmal unterstützt.

Das Design von ResultMaps ist so, dass einfache Anweisungen überhaupt keine expliziten Ergebniszuordnungen erfordern und komplexere Anweisungen nicht mehr erfordern, als zur Beschreibung der Beziehungen unbedingt erforderlich ist.

Dieses Kapitel enthält nur eine einfache Einführung in iBATIS ResultMaps.

Wir haben die folgende EMPLOYEE-Tabelle in 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)
);

Diese Tabelle enthält zwei Datensätze wie folgt:

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)

Mitarbeiter POJO Klasse

Um iBATIS ResultMap verwenden zu können, müssen Sie die Datei Employee.java nicht ändern. Behalten wir es bei, wie es im letzten Kapitel war.

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

Hier würden wir Employee.xml ändern, um das <resultMap> </ resultMap> -Tag einzuführen. Dieses Tag hätte eine ID, die erforderlich ist, um diese resultMap im resultMap-Attribut unseres <select> -Tags auszuführen.

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

Diese Datei verfügt über eine Logik auf Anwendungsebene zum Lesen von Datensätzen aus der Employee-Tabelle mithilfe von ResultMap -

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

Kompilieren und Ausführen

Hier sind die Schritte zum Kompilieren und Ausführen der oben genannten Software. Stellen Sie sicher, dass Sie PATH und CLASSPATH richtig eingestellt haben, bevor Sie mit der Kompilierung und Ausführung fortfahren.

• Erstellen Sie Employee.xml wie oben gezeigt.
• Erstellen Sie Employee.java wie oben gezeigt und kompilieren Sie es.
• Erstellen Sie IbatisResultMap.java wie oben gezeigt und kompilieren Sie es.
• Führen Sie die Binärdatei IbatisResultMap aus, um das Programm auszuführen.

Sie würden das folgende Ergebnis erhalten, bei dem es sich um eine Leseoperation für die Tabelle EMPLOYEE handelt.

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

Sie können eine gespeicherte Prozedur mithilfe der iBATIS-Konfiguration aufrufen. Lassen Sie uns zunächst verstehen, wie eine gespeicherte Prozedur in MySQL erstellt wird.

Wir haben die folgende EMPLOYEE-Tabelle in 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)
);

Lassen Sie uns die folgende gespeicherte Prozedur in der MySQL-Datenbank erstellen:

DELIMITER $$

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

DELIMITER;

Angenommen, die Tabelle EMPLOYEE enthält zwei Datensätze wie folgt:

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)

Mitarbeiter POJO Klasse

Um die gespeicherte Prozedur zu verwenden, müssen Sie die Datei Employee.java nicht ändern. Behalten wir es bei, wie es im letzten Kapitel war.

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

Hier würden wir Employee.xml ändern, um die Tags <procedure> </ process> und <parameterMap> </ parameterMap> einzuführen. Hier hätte das Tag <procedure> </ process> eine ID, die wir in unserer Anwendung zum Aufrufen der gespeicherten Prozedur verwenden würden.

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

Diese Datei verfügt über eine Logik auf Anwendungsebene, mit der die Namen der Mitarbeiter mithilfe von ResultMap aus der Employee-Tabelle gelesen werden können.

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

Kompilieren und Ausführen

Hier sind die Schritte zum Kompilieren und Ausführen der oben genannten Software. Stellen Sie sicher, dass Sie PATH und CLASSPATH richtig eingestellt haben, bevor Sie mit der Kompilierung und Ausführung fortfahren.

• Erstellen Sie Employee.xml wie oben gezeigt.
• Erstellen Sie Employee.java wie oben gezeigt und kompilieren Sie es.
• Erstellen Sie IbatisSP.java wie oben gezeigt und kompilieren Sie es.
• Führen Sie die IbatisSP-Binärdatei aus, um das Programm auszuführen.

Sie würden folgendes Ergebnis erhalten:

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

Dynamisches SQL ist eine sehr leistungsstarke Funktion von iBATIS. Manchmal müssen Sie das WHERE-Klauselkriterium basierend auf dem Status Ihres Parameterobjekts ändern. In solchen Situationen bietet iBATIS eine Reihe dynamischer SQL-Tags, die in zugeordneten Anweisungen verwendet werden können, um die Wiederverwendbarkeit und Flexibilität von SQL zu verbessern.

Die gesamte Logik wird mithilfe einiger zusätzlicher Tags in eine XML-Datei eingefügt. Das folgende Beispiel zeigt, wie die SELECT-Anweisung auf zwei Arten funktioniert:

Wenn Sie eine ID übergeben, werden alle dieser ID entsprechenden Datensätze zurückgegeben.

Andernfalls werden alle Datensätze zurückgegeben, in denen die Mitarbeiter-ID auf NULL gesetzt ist.

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

Sie können eine Bedingung mit dem Tag <isNotEmpty> wie folgt überprüfen. Hier würde eine Bedingung nur hinzugefügt, wenn eine übergebene Eigenschaft nicht leer ist.

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

Wenn Sie eine Abfrage wünschen, bei der wir eine ID und / oder den Vornamen eines Mitarbeiters auswählen können, lautet Ihre SELECT-Anweisung wie folgt:

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

Dynamisches SQL-Beispiel

Das folgende Beispiel zeigt, wie Sie eine SELECT-Anweisung mit dynamischem SQL schreiben können. Bedenken Sie, wir haben die folgende EMPLOYEE-Tabelle in 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)
);

Nehmen wir an, diese Tabelle enthält nur einen Datensatz wie folgt:

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

Mitarbeiter POJO Klasse

Um eine Leseoperation durchzuführen, lassen Sie uns eine Employee-Klasse in Employee.java wie folgt haben:

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

Um die SQL-Zuordnungsanweisung mit iBATIS zu definieren, fügen wir das folgende modifizierte <select> -Tag in Employee.xml hinzu und definieren innerhalb dieser Tag-Definition eine "ID", die in IbatisReadDy.java zum Ausführen der Dynamic SQL SELECT-Abfrage verwendet wird Datenbank.

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

Die obige SELECT-Anweisung würde auf zwei Arten funktionieren:

• Wenn Sie eine ID übergeben, werden Datensätze zurückgegeben, die dieser ID entsprechen. Andernfalls werden alle Datensätze zurückgegeben.

IbatisReadDy.java-Datei

Diese Datei verfügt über eine Logik auf Anwendungsebene zum Lesen von bedingten Datensätzen aus der Employee-Tabelle.

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

Kompilieren und Ausführen

Hier sind die Schritte zum Kompilieren und Ausführen der oben genannten Software. Stellen Sie sicher, dass Sie PATH und CLASSPATH richtig eingestellt haben, bevor Sie mit der Kompilierung und Ausführung fortfahren.

• Erstellen Sie Employee.xml wie oben gezeigt.
• Erstellen Sie Employee.java wie oben gezeigt und kompilieren Sie es.
• Erstellen Sie IbatisReadDy.java wie oben gezeigt und kompilieren Sie es.
• Führen Sie die IbatisReadDy-Binärdatei aus, um das Programm auszuführen.

Sie würden das folgende Ergebnis erhalten und ein Datensatz aus der Tabelle EMPLOYEE gelesen.

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

Versuchen Sie das obige Beispiel, indem Sie bestehen nullals smc.queryForList ("Employee.findByID", null) .

iBATIS OGNL-Ausdrücke

iBATIS bietet leistungsstarke OGNL-basierte Ausdrücke, um die meisten anderen Elemente zu eliminieren.

• if-Anweisung
• Wählen Sie, wann, sonst Aussage
• wo Aussage
• foreach Statement

Die if-Anweisung

In dynamischem SQL wird am häufigsten ein Teil einer where-Klausel bedingt eingeschlossen. Zum Beispiel -

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

Diese Anweisung bietet eine optionale Funktionalität für die Textsuche. Wenn Sie keinen Titel übergeben, werden alle aktiven Blogs zurückgegeben. Wenn Sie jedoch einen Titel übergeben, wird nach einem Titel mit dem angegebenen Titel gesuchtlike Bedingung.

Sie können mehrere einschließen if Bedingungen wie folgt -

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

Die Anweisungen wählen, wann und ansonsten

iBATIS bietet a chooseElement, das der switch-Anweisung von Java ähnelt. Es hilft, nur einen Fall unter vielen Optionen auszuwählen.

Das folgende Beispiel würde nur nach Titel suchen, wenn einer angegeben ist, und nur nach Autor, wenn einer angegeben ist. Wenn beides nicht angegeben ist, werden nur vorgestellte Blogs zurückgegeben -

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

Die where-Anweisung

Schauen Sie sich unsere vorherigen Beispiele an, um zu sehen, was passiert, wenn keine der Bedingungen erfüllt ist. Sie würden mit einem SQL enden, das so aussieht -

SELECT * FROM BLOG
WHERE

Dies würde fehlschlagen, aber iBATIS hat eine einfache Lösung mit einer einfachen Änderung, alles funktioniert gut -

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

Das whereDas Element fügt nur dann ein WHERE ein , wenn die enthaltenen Tags Inhalte zurückgeben. Wenn dieser Inhalt mit UND oder ODER beginnt , kann er ihn außerdem entfernen.

Die foreach-Erklärung

Mit dem foreach-Element können Sie eine Sammlung angeben und Element- und Indexvariablen deklarieren, die im Hauptteil des Elements verwendet werden können.

Außerdem können Sie öffnende und schließende Zeichenfolgen angeben und ein Trennzeichen zwischen den Iterationen einfügen. Sie können eine bauenIN Bedingung wie folgt -

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

Es ist einfach, Ihr Programm zu debuggen, während Sie mit iBATIS arbeiten. iBATIS verfügt über eine integrierte Protokollierungsunterstützung und arbeitet mit den folgenden Protokollierungsbibliotheken und sucht in dieser Reihenfolge nach ihnen.

• Jakarta Commons Logging (JCL).
• Log4J
• JDK-Protokollierung

Sie können jede der oben aufgeführten Bibliotheken zusammen mit iBATIS verwenden.

Debuggen mit Log4J

Angenommen, Sie verwenden Log4J für die Protokollierung. Bevor Sie fortfahren, müssen Sie die folgenden Punkte überprüfen:

• Die Log4J-JAR-Datei (log4j- {version} .jar) sollte sich im CLASSPATH befinden.
• Sie haben log4j.properties im CLASSPATH verfügbar.

Es folgt die Datei log4j.properties. Beachten Sie, dass einige der Zeilen auskommentiert sind. Sie können sie auskommentieren, wenn Sie zusätzliche Debugging-Informationen benötigen.

# 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

Die vollständige Dokumentation zu Log4J finden Sie auf der Apaches-Website - Log4J-Dokumentation .

iBATIS-Debugging-Beispiel

Die folgende Java-Klasse ist ein sehr einfaches Beispiel, das die Log4J-Protokollierungsbibliothek für Java-Anwendungen initialisiert und anschließend verwendet. Wir würden die oben erwähnte Eigenschaftendatei verwenden, die in CLASSPATH liegt.

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

Kompilieren und Ausführen

Stellen Sie zunächst sicher, dass Sie PATH und CLASSPATH entsprechend eingestellt haben, bevor Sie mit der Kompilierung und Ausführung fortfahren.

• Erstellen Sie Employee.xml wie oben gezeigt.
• Erstellen Sie Employee.java wie oben gezeigt und kompilieren Sie es.
• Erstellen Sie IbatisUpdate.java wie oben gezeigt und kompilieren Sie es.
• Erstellen Sie log4j.properties wie oben gezeigt.
• Führen Sie die IbatisUpdate-Binärdatei aus, um das Programm auszuführen.

Sie würden das folgende Ergebnis erhalten. Ein Datensatz würde in der Tabelle EMPLOYEE aktualisiert, und später würde derselbe Datensatz aus der Tabelle EMPLOYEE gelesen.

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

Debug-Methoden

Im obigen Beispiel haben wir nur verwendet info() Methode, Sie können jedoch eine der folgenden Methoden gemäß Ihren Anforderungen verwenden -

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

Es gibt große Unterschiede zwischen iBATIS und Hibernate. Beide Lösungen funktionieren aufgrund ihrer spezifischen Domäne gut. iBATIS wird für den Fall empfohlen -

• Sie möchten Ihre eigenen SQLs erstellen und sind bereit, diese zu verwalten.
• Ihre Umgebung wird von einem relationalen Datenmodell gesteuert.
• Sie müssen an vorhandenen und komplexen Schemata arbeiten.

Verwenden Sie den Ruhezustand, wenn die Umgebung vom Objektmodell gesteuert wird und SQL automatisch generieren muss.

Unterschied zwischen iBATIS und Hibernate

Sowohl Hibernate als auch iBATIS sind Open-Source-ORM-Tools (Object Relational Mapping), die in der Branche erhältlich sind. Die Verwendung jedes dieser Tools hängt vom Kontext ab, in dem Sie sie verwenden.

Die folgende Tabelle zeigt die Unterschiede zwischen iBATIS und Hibernate -

iBATIS	Überwintern
iBATIS ist einfacher. Es kommt in einer viel kleineren Packungsgröße.	Der Ruhezustand generiert SQL für Sie, sodass Sie keine Zeit für die Generierung von SQL aufwenden müssen.
iBATIS ist flexibel. Es bietet eine schnellere Entwicklungszeit.	Der Ruhezustand ist hoch skalierbar. Es bietet einen viel fortgeschritteneren Cache.
iBATIS verwendet SQL, das datenbankabhängig sein kann.	Hibernate verwendet HQL, das relativ unabhängig von Datenbanken ist. Es ist einfacher, die Datenbank im Ruhezustand zu ändern.
iBatis ordnet das ResultSet von der JDBC-API Ihren POJO-Objekten zu, sodass Sie sich nicht um Tabellenstrukturen kümmern müssen.	Hibernate ordnet Ihre Java POJO-Objekte den Datenbanktabellen zu.
Es ist ziemlich einfach, gespeicherte Prozeduren in iBATIS zu verwenden.	Die Verwendung gespeicherter Prozeduren ist im Ruhezustand etwas schwierig.

Sowohl Hibernate als auch iBATIS werden vom SPRING-Framework gut unterstützt, daher sollte es kein Problem sein, eines davon auszuwählen.

iBATOR ist ein Codegenerator für iBATIS. iBATOR überprüft eine oder mehrere Datenbanktabellen und generiert iBATIS-Artefakte, mit denen auf die Tabellen zugegriffen werden kann.

Später können Sie Ihren benutzerdefinierten SQL-Code oder Ihre gespeicherte Prozedur schreiben, um Ihre Anforderungen zu erfüllen. iBATOR generiert die folgenden Artefakte:

• SqlMap XML-Dateien
• Java-Klassen, die mit dem Primärschlüssel und den Feldern der Tabelle (n) übereinstimmen
• DAO-Klassen, die die oben genannten Objekte verwenden (optional)

iBATOR kann als eigenständige JAR-Datei, als Ant-Task oder als Eclipse-Plugin ausgeführt werden. Dieses Tutorial beschreibt die einfachste Methode zum Generieren von iBATIS-Konfigurationsdateien über die Befehlszeile.

Laden Sie iBATOR herunter

Laden Sie die eigenständige JAR herunter, wenn Sie eine andere IDE als Eclipse verwenden. Die eigenständige JAR enthält eine Ant-Task zum Ausführen von iBATOR, oder Sie können iBATOR über die Befehlszeile von Java-Code ausführen.

• Sie können die Zip-Datei von Download iBATOR herunterladen .

• Sie können die Online-Dokumentation überprüfen - iBATOR-Dokumentation .

Konfigurationsdatei generieren

Gehen Sie folgendermaßen vor, um iBATOR auszuführen:

Schritt 1

Erstellen und füllen Sie eine Konfigurationsdatei ibatorConfig.xml entsprechend. Sie müssen mindestens Folgendes angeben:

• EIN <jdbcConnection> Element, um anzugeben, wie eine Verbindung zur Zieldatenbank hergestellt werden soll.

• EIN <javaModelGenerator> Element zum Angeben des Zielpakets und des Zielprojekts für die generierten Java-Modellobjekte.

• EIN <sqlMapGenerator> Element zum Angeben des Zielpakets und des Zielprojekts für die generierten SQL-Zuordnungsdateien.

• EIN <daoGenerator> Element, um das Zielpaket und das Zielprojekt für die generierten DAO-Schnittstellen und -Klassen anzugeben (Sie können das <daoGenerator> -Element weglassen, wenn Sie keine DAOs generieren möchten).

• Mindestens eine Datenbank <table> Element

NOTE −Auf der Seite Referenz zur XML-Konfigurationsdatei finden Sie ein Beispiel für eine iBATOR-Konfigurationsdatei.

Schritt 2

Speichern Sie die Datei an einem geeigneten Ort, z. B. unter: \ temp \ ibatorConfig.xml.

Schritt 3

Führen Sie nun iBATOR wie folgt über die Befehlszeile aus:

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

Es weist iBATOR an, mit Ihrer Konfigurationsdatei ausgeführt zu werden. Außerdem wird iBATOR angewiesen, vorhandene Java-Dateien mit demselben Namen zu überschreiben. Wenn Sie vorhandene Java-Dateien speichern möchten, lassen Sie das weg−overwrite Parameter.

Im Konfliktfall speichert iBATOR die neu generierte Datei unter einem eindeutigen Namen.

Nach dem Ausführen von iBATOR müssen Sie die Standard-iBATIS-Konfigurationsdateien erstellen oder ändern, um Ihren neu generierten Code verwenden zu können. Dies wird im nächsten Abschnitt erläutert.

Aufgaben nach dem Ausführen von iBATOR

Nachdem Sie iBATOR ausgeführt haben, müssen Sie andere iBATIS-Konfigurationsartefakte erstellen oder ändern. Die Hauptaufgaben sind wie folgt:

• Erstellen oder ändern Sie die Datei SqlMapConfig.xml.
• Erstellen oder ändern Sie die Datei dao.xml (nur wenn Sie das iBATIS DAO Framework verwenden).

Jede Aufgabe wird im Folgenden ausführlich beschrieben -

Aktualisieren der Datei SqlMapConfig.xml

iBATIS verwendet eine XML-Datei mit dem allgemeinen Namen SqlMapConfig.xml, um Informationen für eine Datenbankverbindung, ein Transaktionsverwaltungsschema und SQL Map-XML-Dateien anzugeben, die in einer iBATIS-Sitzung verwendet werden.

iBATOR kann diese Datei nicht für Sie erstellen, da sie nichts über Ihre Ausführungsumgebung weiß. Einige der Elemente in dieser Datei beziehen sich jedoch direkt auf von iBATOR generierte Elemente.

Die iBATOR-spezifischen Anforderungen in der Konfigurationsdatei lauten wie folgt:

• Anweisungsnamespaces müssen aktiviert sein.
• Von iBATOR generierte SQL Map-XML-Dateien müssen aufgelistet sein.

Angenommen, iBATOR hat eine SQL Map-XML-Datei mit dem Namen MyTable_SqlMap.xml generiert und die Datei wurde im Paket test.xml Ihres Projekts abgelegt. Die Datei SqlMapConfig.xml sollte diese Einträge enthalten -

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

Wenn mehr als eine SQL Map-XML-Datei vorhanden ist (wie üblich), können die Dateien in beliebiger Reihenfolge mit wiederholten <sqlMap> -Elementen nach dem <transactionManager> -Element aufgelistet werden.

Aktualisieren der Datei dao.xml

Das iBATIS DAO-Framework wird durch eine XML-Datei konfiguriert, die üblicherweise als dao.xml bezeichnet wird.

Das iBATIS DAO-Framework verwendet diese Datei, um die Datenbankverbindungsinformationen für DAOs zu steuern und um die DAO-Implementierungsklassen und DAO-Schnittstellen aufzulisten.

In dieser Datei sollten Sie den Pfad zu Ihrer Datei SqlMapConfig.xml und allen von iBATOR generierten DAO-Schnittstellen und Implementierungsklassen angeben.

Angenommen, iBATOR hat eine DAO-Schnittstelle mit dem Namen MyTableDAO und eine Implementierungsklasse mit dem Namen MyTableDAOImpl generiert und die Dateien wurden im Paket test.dao Ihres Projekts abgelegt.

Die Datei dao.xml sollte diese Einträge enthalten -

<?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 − Dieser Schritt ist nur erforderlich, wenn Sie DAOs für das iBATIS DAO-Framework generiert haben.