iBATIS - Guía rápida

iBATIS es un marco de persistencia que automatiza el mapeo entre bases de datos SQL y objetos en Java, .NET y Ruby on Rails. Las asignaciones se desacoplan de la lógica de la aplicación al empaquetar las instrucciones SQL en archivos de configuración XML.

iBATIS es un marco liviano y una API de persistencia buena para persistir POJOs (Plain Old Java Objects).

iBATIS es lo que se conoce como mapeador de datos y se encarga de mapear los parámetros y los resultados entre las propiedades de la clase y las columnas de la tabla de la base de datos.

Una diferencia significativa entre iBATIS y otros marcos de persistencia como Hibernate es que iBATIS enfatiza el uso de SQL, mientras que otros marcos suelen usar un lenguaje de consulta personalizado como Hibernate Query Language (HQL) o Enterprise JavaBeans Query Language (EJB QL).

Filosofías de diseño iBATIS

iBATIS viene con las siguientes filosofías de diseño:

• Simplicity − iBATIS es ampliamente considerado como uno de los marcos de persistencia más simples disponibles en la actualidad.

• Fast Development − iBATIS hace todo lo posible para facilitar el desarrollo ultrarrápido.

• Portability − iBATIS se puede implementar para casi cualquier lenguaje o plataforma, como Java, Ruby y C # para Microsoft .NET.

• Independent Interfaces − iBATIS proporciona interfaces y API independientes de la base de datos que ayudan al resto de la aplicación a permanecer independiente de cualquier recurso relacionado con la persistencia.

• Open source − iBATIS es un software gratuito y de código abierto.

Ventajas de iBATIS

iBATIS ofrece las siguientes ventajas:

• Supports stored procedures − iBATIS encapsula SQL en forma de procedimientos almacenados para que la lógica empresarial se mantenga fuera de la base de datos, y la aplicación sea más fácil de implementar y probar, y sea más portátil.

• Supports inline SQL − No se necesita un precompilador y tiene acceso completo a todas las funciones de SQL.

• Supports dynamic SQL − iBATIS proporciona funciones para la creación dinámica de consultas SQL basadas en parámetros.

• Supports O/RM − iBATIS admite muchas de las mismas características que una herramienta O / RM, como carga diferida, búsqueda de uniones, almacenamiento en caché, generación de código en tiempo de ejecución y herencia.

iBATIS utiliza el lenguaje de programación JAVA mientras desarrolla aplicaciones orientadas a bases de datos. Antes de continuar, asegúrese de comprender los conceptos básicos de la programación orientada a objetos y de procedimiento: estructuras de control, estructuras de datos y variables, clases, objetos, etc.

Para comprender JAVA en detalle, puede seguir nuestro Tutorial de JAVA .

Debería configurar un entorno adecuado para iBATIS antes de comenzar con el trabajo de desarrollo real. Este capítulo explica cómo configurar un entorno de trabajo para iBATIS.

Instalación de iBATIS

Realice los siguientes pasos sencillos para instalar iBATIS en su máquina Linux:

• Descargue la última versión de iBATIS desde Descargar iBATIS .

• Descomprima el archivo descargado para extraer el archivo .jar del paquete y manténgalo en el directorio lib apropiado.

• Establezca las variables PATH y CLASSPATH en los archivos .jar extraídos de forma adecuada.

$ 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

Configuración de la base de datos

Cree una tabla EMPLOYEE en cualquier base de datos MySQL utilizando la siguiente sintaxis:

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

Cree SqlMapConfig.xml

Considere lo siguiente:

• Vamos a utilizar JDBC para acceder a la base de datos. testdb.

• El controlador JDBC para MySQL es "com.mysql.jdbc.Driver".

• La URL de conexión es "jdbc: mysql: // localhost: 3306 / testdb".

• Usaríamos nombre de usuario y contraseña como "root" y "root" respectivamente.

• Nuestras asignaciones de sentencias sql para todas las operaciones se describen en "Employee.xml".

Con base en las suposiciones anteriores, tenemos que crear un archivo de configuración XML con el nombre SqlMapConfig.xmlcon el siguiente contenido. Aquí es donde debe proporcionar todas las configuraciones necesarias para iBatis:

Es importante que tanto los archivos SqlMapConfig.xml como Employee.xml estén presentes en la ruta de clases. Por ahora, mantendríamos el archivo Employee.xml vacío y cubriríamos su contenido en capítulos posteriores.

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

También puede establecer las siguientes propiedades opcionales mediante el archivo SqlMapConfig.xml:

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

Para realizar cualquier operación de creación, lectura, actualización y eliminación (CRUD) mediante iBATIS, deberá crear una clase de objetos Java antiguos simples (POJO) correspondiente a la tabla. Esta clase describe los objetos que "modelarán" las filas de la tabla de la base de datos.

La clase POJO tendría implementación para todos los métodos necesarios para realizar las operaciones deseadas.

Supongamos que tenemos la siguiente tabla EMPLOYEE en 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)
);

Clase POJO para empleados

Creamos una clase de empleado en el archivo Employee.java de la siguiente manera:

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

Puede definir métodos para establecer campos individuales en la tabla. El siguiente capítulo explica cómo obtener los valores de campos individuales.

Archivo Employee.xml

Para definir la declaración de mapeo SQL usando iBATIS, usaríamos la etiqueta <insertar> y dentro de esta definición de etiqueta, definiríamos un "id" que se usará en el archivo IbatisInsert.java para ejecutar la consulta SQL INSERT en la base de datos.

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

aquí parameterClass −podría tomar un valor como string, int, float, double o cualquier objeto de clase según el requisito. En este ejemplo, pasaríamos el objeto Employee como parámetro mientras llamamos al método insert de la clase SqlMap.

Si su tabla de base de datos utiliza una columna IDENTITY, AUTO_INCREMENT o SERIAL o ha definido una SEQUENCE / GENERATOR, puede utilizar el elemento <selectKey> en una sentencia <insertar> para utilizar o devolver ese valor generado por la base de datos.

Archivo IbatisInsert.java

Este archivo tendría lógica a nivel de aplicación para insertar registros en la tabla Empleado -

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

Compilación y ejecución

Estos son los pasos para compilar y ejecutar el software mencionado anteriormente. Asegúrese de haber configurado PATH y CLASSPATH correctamente antes de proceder con la compilación y ejecución.

• Cree Employee.xml como se muestra arriba.
• Cree Employee.java como se muestra arriba y compílelo.
• Cree IbatisInsert.java como se muestra arriba y compílelo.
• Ejecute IbatisInsert binary para ejecutar el programa.

Obtendría el siguiente resultado y se crearía un registro en la tabla EMPLOYEE.

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

Si marca la tabla EMPLEADO, debería mostrar el siguiente resultado:

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

Discutimos, en el último capítulo, cómo realizar la operación CREATE en una tabla usando iBATIS. Este capítulo explica cómo leer una tabla con iBATIS.

Tenemos la siguiente tabla EMPLOYEE en 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)
);

Esta tabla tiene solo un registro de la siguiente manera:

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

Clase POJO para empleados

Para realizar la operación de lectura, modificaríamos la clase Employee en Employee.java de la siguiente manera:

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

Archivo Employee.xml

Para definir la declaración de mapeo SQL usando iBATIS, agregaríamos la etiqueta <select> en el archivo Employee.xml y dentro de esta definición de etiqueta, definiríamos un "id" que se usará en el archivo IbatisRead.java para ejecutar la consulta SQL SELECT en la base de datos.

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

Aquí no usamos la cláusula WHERE con la instrucción SQL SELECT. Demostraremos, en el siguiente capítulo, cómo puede usar la cláusula WHERE con la instrucción SELECT y cómo puede pasar valores a esa cláusula WHERE.

Archivo IbatisRead.java

Este archivo tiene lógica de nivel de aplicación para leer registros de la tabla de empleados -

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

Compilación y ejecución

Estos son los pasos para compilar y ejecutar el software mencionado anteriormente. Asegúrese de haber configurado PATH y CLASSPATH correctamente antes de proceder con la compilación y ejecución.

• Cree Employee.xml como se muestra arriba.
• Cree Employee.java como se muestra arriba y compílelo.
• Cree IbatisRead.java como se muestra arriba y compílelo.
• Ejecute IbatisRead binary para ejecutar el programa.

Obtendría el siguiente resultado, y se leería un registro de la tabla EMPLOYEE de la siguiente manera:

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

Discutimos, en el último capítulo, cómo realizar la operación READ en una mesa usando iBATIS. Este capítulo explica cómo puede actualizar registros en una tabla usando iBATIS.

Tenemos la siguiente tabla EMPLOYEE en 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)
);

Esta tabla tiene solo un registro de la siguiente manera:

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

Clase POJO para empleados

Para realizar la operación udpate, necesitaría modificar el archivo Employee.java de la siguiente manera:

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

Archivo Employee.xml

Para definir la declaración de mapeo SQL usando iBATIS, agregaríamos la etiqueta <update> en Employee.xml y dentro de esta definición de etiqueta, definiríamos un "id" que se usará en el archivo IbatisUpdate.java para ejecutar la consulta SQL UPDATE en la base de datos.

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

Archivo IbatisUpdate.java

Este archivo tiene lógica de nivel de aplicación para actualizar registros en la tabla Empleado -

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

Compilación y ejecución

Estos son los pasos para compilar y ejecutar el software mencionado anteriormente. Asegúrese de haber configurado PATH y CLASSPATH correctamente antes de proceder con la compilación y ejecución.

• Cree Employee.xml como se muestra arriba.
• Cree Employee.java como se muestra arriba y compílelo.
• Cree IbatisUpdate.java como se muestra arriba y compílelo.
• Ejecute IbatisUpdate binary para ejecutar el programa.

Obtendría el siguiente resultado y se actualizaría un registro en la tabla EMPLOYEE y, más tarde, se leería el mismo registro de la tabla EMPLOYEE.

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

Este capítulo describe cómo eliminar registros de una tabla usando iBATIS.

Tenemos la siguiente tabla EMPLOYEE en 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)
);

Suponga que esta tabla tiene dos registros de la siguiente manera:

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)

Clase POJO para empleados

Para realizar la operación de eliminación, no es necesario modificar el archivo Employee.java. Dejémoslo como estaba en el último capítulo.

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

Archivo Employee.xml

Para definir la declaración de mapeo SQL usando iBATIS, agregaríamos la etiqueta <delete> en Employee.xml y dentro de esta definición de etiqueta, definiríamos un "id" que se usará en el archivo IbatisDelete.java para ejecutar la consulta SQL DELETE en la base de datos.

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

Este archivo tiene lógica de nivel de aplicación para eliminar registros de la tabla de empleados:

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

Compilación y ejecución

Estos son los pasos para compilar y ejecutar el software mencionado anteriormente. Asegúrese de haber configurado PATH y CLASSPATH correctamente antes de proceder con la compilación y ejecución.

• Cree Employee.xml como se muestra arriba.
• Cree Employee.java como se muestra arriba y compílelo.
• Cree IbatisDelete.java como se muestra arriba y compílelo.
• Ejecute IbatisDelete binary para ejecutar el programa.

Obtendría el siguiente resultado, y un registro con ID = 1 se eliminaría de la tabla EMPLOYEE y se leerían el resto de los registros.

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

El elemento resultMap es el elemento más importante y poderoso de iBATIS. Puede reducir hasta un 90% la codificación JDBC utilizando iBATIS ResultMap y, en algunos casos, le permite hacer cosas que JDBC ni siquiera admite.

El diseño de ResultMaps es tal que las declaraciones simples no requieren asignaciones de resultados explícitas, y las declaraciones más complejas no requieren más de lo absolutamente necesario para describir las relaciones.

Este capítulo proporciona una simple introducción a iBATIS ResultMaps.

Tenemos la siguiente tabla EMPLOYEE en 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)
);

Esta tabla tiene dos registros de la siguiente manera:

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)

Clase POJO para empleados

Para utilizar iBATIS ResultMap, no es necesario modificar el archivo Employee.java. Dejémoslo como estaba en el último capítulo.

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

Archivo Employee.xml

Aquí modificaríamos Employee.xml para introducir la etiqueta <resultMap> </resultMap>. Esta etiqueta tendría una identificación necesaria para ejecutar este resultMap en el atributo resultMap de nuestra etiqueta <select>.

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

Archivo IbatisResultMap.java

Este archivo tiene lógica de nivel de aplicación para leer registros de la tabla Empleado usando 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 ");
   }
}

Compilación y ejecución

Estos son los pasos para compilar y ejecutar el software mencionado anteriormente. Asegúrese de haber configurado PATH y CLASSPATH correctamente antes de proceder con la compilación y ejecución.

• Cree Employee.xml como se muestra arriba.
• Cree Employee.java como se muestra arriba y compílelo.
• Cree IbatisResultMap.java como se muestra arriba y compílelo.
• Ejecute el binario IbatisResultMap para ejecutar el programa.

Obtendría el siguiente resultado que es una operación de lectura en la tabla EMPLOYEE.

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

Puede llamar a un procedimiento almacenado mediante la configuración de iBATIS. Primero que nada, entendamos cómo crear un procedimiento almacenado en MySQL.

Tenemos la siguiente tabla EMPLOYEE en 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)
);

Creemos el siguiente procedimiento almacenado en la base de datos MySQL:

DELIMITER $$

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

DELIMITER;

Consideremos que la tabla EMPLOYEE tiene dos registros de la siguiente manera:

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)

Clase POJO para empleados

Para utilizar el procedimiento almacenado, no es necesario modificar el archivo Employee.java. Dejémoslo como estaba en el último capítulo.

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

Archivo Employee.xml

Aquí modificaríamos Employee.xml para introducir las etiquetas <procedure> </procedure> y <parameterMap> </parameterMap>. Aquí, la etiqueta <procedure> </procedure> tendría una identificación que usaríamos en nuestra aplicación para llamar al procedimiento almacenado.

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

Archivo IbatisSP.java

Este archivo tiene lógica de nivel de aplicación para leer los nombres de los empleados de la tabla de Empleados usando 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 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 ");
   }
}

Compilación y ejecución

Estos son los pasos para compilar y ejecutar el software mencionado anteriormente. Asegúrese de haber configurado PATH y CLASSPATH correctamente antes de proceder con la compilación y ejecución.

• Cree Employee.xml como se muestra arriba.
• Cree Employee.java como se muestra arriba y compílelo.
• Cree IbatisSP.java como se muestra arriba y compílelo.
• Ejecute el binario IbatisSP para ejecutar el programa.

Obtendría el siguiente resultado:

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

El SQL dinámico es una característica muy poderosa de iBATIS. A veces tienes que cambiar el criterio de la cláusula WHERE según el estado de tu objeto de parámetro. En tales situaciones, iBATIS proporciona un conjunto de etiquetas SQL dinámicas que se pueden utilizar dentro de declaraciones mapeadas para mejorar la reutilización y flexibilidad de SQL.

Toda la lógica se coloca en un archivo .XML usando algunas etiquetas adicionales. A continuación se muestra un ejemplo en el que la instrucción SELECT funcionaría de dos maneras:

Si pasa una identificación, devolverá todos los registros correspondientes a esa identificación.

De lo contrario, devolvería todos los registros donde el ID de empleado se establece en NULL.

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

<sqlMap namespace="Employee">

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

Puede verificar una condición usando la etiqueta <isNotEmpty> de la siguiente manera. Aquí se agregaría una condición solo cuando una propiedad pasada no esté vacía.

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

Si desea una consulta en la que podamos seleccionar una identificación y / o el nombre de un empleado, su declaración SELECT sería la siguiente:

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

Ejemplo de SQL dinámico

El siguiente ejemplo muestra cómo puede escribir una instrucción SELECT con SQL dinámico. Considere, tenemos la siguiente tabla EMPLOYEE en 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)
);

Supongamos que esta tabla tiene solo un registro de la siguiente manera:

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

Clase POJO para empleados

Para realizar la operación de lectura, tengamos una clase de empleado en Employee.java de la siguiente manera:

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

Archivo Employee.xml

Para definir la declaración de mapeo SQL usando iBATIS, agregaríamos la siguiente etiqueta <select> modificada en Employee.xml y dentro de esta definición de etiqueta, definiríamos un "id" que se usará en IbatisReadDy.java para ejecutar la consulta SQL SELECT dinámica en base de datos.

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

La declaración SELECT anterior funcionaría de dos maneras:

• Si pasa una ID, devuelve los registros correspondientes a esa ID. De lo contrario, devuelve todos los registros.

Archivo IbatisReadDy.java

Este archivo tiene lógica de nivel de aplicación para leer registros condicionales de la tabla de empleados -

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

Compilación y ejecución

Estos son los pasos para compilar y ejecutar el software mencionado anteriormente. Asegúrese de haber configurado PATH y CLASSPATH correctamente antes de proceder con la compilación y ejecución.

• Cree Employee.xml como se muestra arriba.
• Cree Employee.java como se muestra arriba y compílelo.
• Cree IbatisReadDy.java como se muestra arriba y compílelo.
• Ejecute IbatisReadDy binary para ejecutar el programa.

Obtendría el siguiente resultado y se leería un registro de la tabla EMPLOYEE.

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

Pruebe el ejemplo anterior pasando nullcomo smc.queryForList ("Employee.findByID", nulo) .

Expresiones iBATIS OGNL

iBATIS proporciona poderosas expresiones basadas en OGNL para eliminar la mayoría de los otros elementos.

• si declaración
• elegir, cuando, de lo contrario Declaración
• donde Declaración
• declaración foreach

La declaración if

Lo más común que se puede hacer en SQL dinámico es incluir condicionalmente una parte de una cláusula where. Por ejemplo

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

Esta declaración proporciona un tipo de funcionalidad de búsqueda de texto opcional. Si no pasa ningún título, se devuelven todos los blogs activos. Pero si pasa un título, buscará un título con ellike condición.

Puede incluir varios if condiciones de la siguiente manera:

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

Las declaraciones elegir, cuándo y de otro modo

iBATIS ofrece una chooseelemento que es similar a la declaración de cambio de Java. Ayuda a elegir solo un caso entre muchas opciones.

El siguiente ejemplo buscaría solo por título si se proporciona uno, luego solo por autor si se proporciona uno. Si no se proporciona ninguno, solo devuelve blogs destacados:

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

La declaración where

Eche un vistazo a nuestros ejemplos anteriores para ver qué sucede si no se cumple ninguna de las condiciones. Terminaría con un SQL que se ve así:

SELECT * FROM BLOG
WHERE

Esto fallaría, pero iBATIS tiene una solución simple con un simple cambio, todo funciona bien -

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

los whereEl elemento inserta un DONDE solo cuando las etiquetas contenedoras devuelven algún contenido. Además, si ese contenido comienza con Y u O, sabe eliminarlo.

La declaración de foreach

El elemento foreach le permite especificar una colección y declarar el elemento y las variables de índice que se pueden usar dentro del cuerpo del elemento.

También le permite especificar cadenas de apertura y cierre, y agregar un separador para colocar entre iteraciones. Puedes construir unIN condición de la siguiente manera:

<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 fácil depurar su programa mientras trabaja con iBATIS. iBATIS tiene soporte de registro incorporado y funciona con las siguientes bibliotecas de registro y las busca en este orden.

• Registro de Jakarta Commons (JCL).
• Log4J
• Registro JDK

Puede utilizar cualquiera de las bibliotecas enumeradas anteriormente junto con iBATIS.

Depurar con Log4J

Suponiendo que va a utilizar Log4J para iniciar sesión. Antes de continuar, debe verificar los siguientes puntos:

• El archivo JAR de Log4J (log4j- {versión} .jar) debe estar en CLASSPATH.
• Tiene log4j.properties disponible en CLASSPATH.

A continuación se muestra el archivo log4j.properties. Tenga en cuenta que algunas de las líneas están comentadas. Puede descomentarlos si necesita información adicional de depuración.

# 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

Puede encontrar la documentación completa de Log4J en el sitio de Apaches - Documentación de Log4J .

Ejemplo de depuración de iBATIS

La siguiente clase Java es un ejemplo muy simple que se inicializa y luego usa la biblioteca de registro Log4J para aplicaciones Java. Usaríamos el archivo de propiedades mencionado anteriormente que se encuentra en CLASSPATH.

import org.apache.log4j.Logger;

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

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

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

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

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

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

Compilación y ejecución

En primer lugar, asegúrese de haber configurado PATH y CLASSPATH correctamente antes de proceder con la compilación y ejecución.

• Cree Employee.xml como se muestra arriba.
• Cree Employee.java como se muestra arriba y compílelo.
• Cree IbatisUpdate.java como se muestra arriba y compílelo.
• Cree log4j.properties como se muestra arriba.
• Ejecute IbatisUpdate binary para ejecutar el programa.

Obtendría el siguiente resultado. Se actualizaría un registro en la tabla EMPLOYEE y posteriormente, se leería el mismo registro de la tabla EMPLOYEE.

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

Métodos de depuración

En el ejemplo anterior, usamos solo info() método, sin embargo, puede utilizar cualquiera de los siguientes métodos según sus requisitos:

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

Existen grandes diferencias entre iBATIS e Hibernate. Ambas soluciones funcionan bien, dado su dominio específico. Se sugiere iBATIS en caso de:

• Quiere crear sus propios SQL y está dispuesto a mantenerlos.
• Su entorno está impulsado por un modelo de datos relacionales.
• Tienes que trabajar en esquemas existentes y complejos.

Utilice Hibernate si el entorno está controlado por el modelo de objetos y necesita generar SQL automáticamente.

Diferencia entre iBATIS e Hibernate

Tanto Hibernate como iBATIS son herramientas de mapeo relacional de objetos (ORM) de código abierto disponibles en la industria. El uso de cada una de estas herramientas depende del contexto en el que las esté utilizando.

La siguiente tabla destaca las diferencias entre iBATIS e Hibernate:

iBATIS	Hibernar
iBATIS es más simple. Viene en un tamaño de paquete mucho más pequeño.	Hibernate genera SQL por usted, lo que significa que no tiene que dedicar tiempo a generar SQL.
iBATIS es flexible. Ofrece un tiempo de desarrollo más rápido.	Hibernate es altamente escalable. Proporciona una caché mucho más avanzada.
iBATIS utiliza SQL que podría depender de la base de datos.	Hibernate usa HQL, que es relativamente independiente de las bases de datos. Es más fácil cambiar db en Hibernate.
iBatis mapea el ResultSet de la API JDBC a sus Objets POJO, por lo que no tiene que preocuparse por las estructuras de las tablas.	Hibernate asigna sus objetos POJO de Java a las tablas de la base de datos.
Es bastante fácil de usar el procedimiento almacenado en iBATIS.	El uso de procedimientos almacenados es un poco difícil en Hibernate.

Tanto Hibernate como iBATIS reciben un buen soporte del marco SPRING, por lo que no debería ser un problema elegir uno de ellos.

iBATOR es un generador de código para iBATIS. iBATOR realiza una introspección de una o más tablas de la base de datos y genera artefactos iBATIS que se pueden utilizar para acceder a las tablas.

Más tarde, puede escribir su código SQL personalizado o procedimiento almacenado para cumplir con sus requisitos. iBATOR genera los siguientes artefactos:

• Archivos XML de SqlMap
• Clases de Java para hacer coincidir la clave principal y los campos de la (s) tabla (s)
• Clases DAO que usan los objetos anteriores (opcional)

iBATOR puede ejecutarse como un archivo JAR independiente, como una tarea Ant o como un complemento de Eclipse. Este tutorial describe la forma más sencilla de generar archivos de configuración de iBATIS desde la línea de comandos.

Descarga iBATOR

Descargue el JAR independiente si está utilizando un IDE que no sea Eclipse. El JAR independiente incluye una tarea Ant para ejecutar iBATOR, o puede ejecutar iBATOR desde la línea de comandos del código Java.

• Puede descargar el archivo zip desde Descargar iBATOR .

• Puede consultar la documentación en línea - Documentación de iBATOR .

Generando archivo de configuración

Para ejecutar iBATOR, siga estos pasos:

Paso 1

Cree y complete un archivo de configuración ibatorConfig.xml de forma adecuada. Como mínimo, debe especificar:

• UN <jdbcConnection> elemento para especificar cómo conectarse a la base de datos de destino.

• UN <javaModelGenerator> elemento para especificar el paquete de destino y el proyecto de destino para los objetos de modelo Java generados.

• UN <sqlMapGenerator> elemento para especificar el paquete de destino y el proyecto de destino para los archivos de mapa SQL generados.

• UN <daoGenerator> elemento para especificar el paquete de destino y el proyecto de destino para las interfaces y clases DAO generadas (puede omitir el elemento <daoGenerator> si no desea generar DAO).

• Al menos una base de datos <table> elemento

NOTE −Consulte la página de referencia del archivo de configuración XML para ver un ejemplo de un archivo de configuración de iBATOR.

Paso 2

Guarde el archivo en una ubicación conveniente, por ejemplo, en: \ temp \ ibatorConfig.xml.

Paso 3

Ahora ejecute iBATOR desde la línea de comando de la siguiente manera:

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

Le dirá a iBATOR que se ejecute usando su archivo de configuración. También le dirá a iBATOR que sobrescriba cualquier archivo Java existente con el mismo nombre. Si desea guardar cualquier archivo Java existente, omita el−overwrite parámetro.

Si hay un conflicto, iBATOR guarda el archivo recién generado con un nombre único.

Después de ejecutar iBATOR, debe crear o modificar los archivos de configuración estándar de iBATIS para hacer uso de su código recién generado. Esto se explica en la siguiente sección.

Tareas después de ejecutar iBATOR

Después de ejecutar iBATOR, debe crear o modificar otros artefactos de configuración de iBATIS. Las principales tareas son las siguientes:

• Cree o modifique el archivo SqlMapConfig.xml.
• Cree o modifique el archivo dao.xml (solo si está utilizando el marco iBATIS DAO).

Cada tarea se describe en detalle a continuación:

Actualización del archivo SqlMapConfig.xml

iBATIS utiliza un archivo XML, comúnmente llamado SqlMapConfig.xml, para especificar información para una conexión de base de datos, un esquema de gestión de transacciones y archivos XML de mapas SQL que se utilizan en una sesión de iBATIS.

iBATOR no puede crear este archivo por usted porque no sabe nada sobre su entorno de ejecución. Sin embargo, algunos de los elementos de este archivo se relacionan directamente con los elementos generados por iBATOR.

Las necesidades específicas de iBATOR en el archivo de configuración son las siguientes:

• Los espacios de nombres de instrucciones deben estar habilitados.
• Los archivos XML de mapas SQL generados por iBATOR deben estar listados.

Por ejemplo, suponga que iBATOR ha generado un archivo XML de mapa SQL llamado MyTable_SqlMap.xml y que el archivo se ha colocado en el paquete test.xml de su proyecto. El archivo SqlMapConfig.xml debe tener estas entradas:

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

Si hay más de un archivo XML de mapa SQL (como es bastante común), entonces los archivos se pueden enumerar en cualquier orden con elementos <sqlMap> repetidos después del elemento <transactionManager>.

Actualización del archivo dao.xml

El marco iBATIS DAO está configurado por un archivo xml comúnmente llamado dao.xml.

El marco iBATIS DAO utiliza este archivo para controlar la información de conexión de la base de datos para DAO, y también para listar las clases de implementación DAO y las interfaces DAO.

En este archivo, debe especificar la ruta a su archivo SqlMapConfig.xml y todas las interfaces DAO generadas por iBATOR y clases de implementación.

Por ejemplo, suponga que iBATOR ha generado una interfaz DAO llamada MyTableDAO y una clase de implementación llamada MyTableDAOImpl, y que los archivos se han colocado en el paquete test.dao de su proyecto.

El archivo dao.xml debe tener estas entradas:

<?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 − Este paso es necesario solo si generó DAO para el marco iBATIS DAO.