Ejemplo Básico con Ibatis - Java

Vamos a hacer aquí un pequeño ejemplo con Ibatis. No voy a poner código completo, pero sí
todo lo necesario para hacerlo. Veremos cómo hacer INSERT, UPDATE, DELETE y SELECT.

La base de datos

Como base de datos usaré MySQL y en la base de datos "test" tengo la siguiente tabla

mysql> use test;

Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> describe auto;
+-----------------+--------------+------+-----+----------------+
| Field | Type | Null | Key | Extra |
+-----------------+--------------+------+-----+----------------+
| id | int(11) | NO | PRI | auto_increment |
| marca | varchar(255) | YES | | |
| matricula | varchar(255) | YES | | |
| fecha_matricula | date | YES | | |
| propietario_id | int(11) | NO | | |
+-----------------+--------------+------+-----+----------------+
5 rows in set (0.00 sec)

El bean java

La clase java en la que guardaremos los datos de un registro leído de esta tabla o donde
guardaremos los datos que queremos insertar o modificar será un Java bean como el siguiente

package cl.uv.ibatis.beans;

import java.util.Date;

public class AutoBeans {

private Integer id;
private String marca;
private String matricula;
private Date fechaMatricula;
private Integer idPropietario;

public Integer getId() {

return id;
}

public void setId(Integer id) {

this.id = id;
}

public String getMarca() {

return marca;
}

public void setMarca(String marca) {

this.marca = marca.trim();
}
 public String getMatricula() {
return matricula;
}

public void setMatricula(String matricula) {

this.matricula = matricula.trim().toUpperCase();
}

public Date getFechaMatricula() {

return fechaMatricula;
}

public void setFechaMatricula(Date fechaMatricula) {

this.fechaMatricula = fechaMatricula;
}

public Integer getIdPropietario() {

return idPropietario;
}

public void setIdPropietario(Integer idPropietario) {

this.idPropietario = idPropietario;
}
}

Fichero XML con el mapeo

Ibatis necesita uno o más ficheros con las sentencias SQL que usaremos en nuestro programa.
El fichero XML con el mapeo, al que llamaré Auto.xml, puede ser como este

<?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>
<select id="getAuto" resultClass="cl.uv.ibatis.beans.AutoBeans">
SELECT
id,
marca,
matricula,
fecha_matricula as fechaMatricula,
propietario_id as idPropietario
FROM
auto
WHERE
id = #valor#
</select>

<select id="getAutos" resultClass="cl.uv.ibatis.beans.AutoBeans">

SELECT
id,
marca,
matricula,
fecha_matricula as fechaMatricula,
propietario_id as idPropietario
FROM
auto
</select>
 <select id="getHashAuto" resultClass="java.util.Hashtable">
SELECT
id,
marca,
matricula,
fecha_matricula as fechaMatricula,
propietario_id as idPropietario
FROM
Auto
WHERE
id = #valor#
</select>

<insert id="insertAuto">
INSERT INTO
auto
(marca, matricula, fecha_matricula, propietario_id)
VALUES
(#marca#, #matricula#, #fechaMatricula#, #idPropietario#)
</insert>

<update id="updateAuto"
parameterClass="cl.uv.ibatis.beans.AutoBeans">
UPDATE
auto
SET
marca = #marca#,
matricula = #matricula#,
fecha_matricula = #fechaMatricula#,
propietario_id = #idPropietario#
WHERE
id = #id#
</update>

<delete id="deleteAuto">
DELETE FROM
auto
WHERE
id = #valor#
</delete>
</sqlMap>

Vamos a comentar algunos detalles.

La parte del xml version y del DOCTYPE en la cabecera del fichero conviene ponerla para que
Ibatis pueda verificar que es correcto el resto del fichero.

El tag principal es <sqlMap>

Luego hay varios tag <select>, <update>, <insert> o <delete> en función del tipo de sentencia
SQL que queramos poner. Hay que fijarse que en las sentencias SQL aparecen "variables" entre
signos #. Ibatis, en tiempo de ejecución, reemplazará estas variables con valores que le
pasemos desde código.

Cada uno de estos tags lleva obligatoriamente un atributo id="nombre" en el que debemos
ponerle un nombre que distinga unas sentencias SQL de otras. Esos nombres son los que
usaremos en el código.
Cada uno de estos tags puede llevar además dos atributos parameterClass y resultClass.
Cuando desde código Java intentemos usar una de estas SQL, usaremos unos métodos que nos
proporciona Ibatis. Estos métodos admiten como primer parámetro un String que es el
nombre que identifica la sentencia SQL, y como segundo parámetro un Object. parameterClass
es el nombre de la clase que pasaremos como parámetro Object en el método Ibatis. De ese
parameterObject Ibatis tratará de obtener los valores de las variables entre #.

• Si parameterClass="int" o un tipo simple, en el código deberemos pasar un Integer o

un tipo simple, e Ibatis pondrá directamente ese Integer reemplazando a #id#.
• Si parameterClass="unaClaseJavaBean", en el código pasaremos esa clase como
parámetro e Ibatis tratará de obtener el id llamando al método getId().
• Si parameterClass="unHashTable" en el código pasaremos un Hashtable como
parámetro e Ibatis tratará de obtener el id llamando a get("id")

El parámetro parameterClass no es obligatorio, ya que Ibatis tratará de arreglarse con lo que le

pasemos. De todas formas, por eficiencia, es mejor ponerlo.

El atributo resultClass indica qué clase devolverán los métodos Ibatis en el return, y es
obligatorio si la sentencia SQL tiene que devolver algo -en concreto, para los SELECT-. Ibatis,
igual que hacía con parameterClass, instanciará una o más clases del tipo indicado en
resultClass y tratará de rellenar dentro los datos.

• Si resultClass="unaClaseJavaBean", Ibatis hará new de unaClaseJavaBean y tratará de

rellenar los valores llamando a los métodos setId(), setMarca(), setMatricula(), etc.
• Si resultClass="unHashTable", Ibatis hará new de HashTable y tratará de rellenar los
valores llamando a put("id", ...), put("marca", ...), etc.

Fichero XML de configuración de Ibatis

Ibatis necesita un fichero de configuración en XML donde se pongan los parámetros de

conexión a la base de datos y donde se indiquen todos los ficheros de mapeo XML -como el
anterior- que queremos usar. El fichero, al que llamaré Conexion.xml, puede ser como este:

<?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>
<transactionManager type="JDBC" >
<dataSource type="SIMPLE">
<property name="JDBC.Driver"
value="org.gjt.mm.mysql.Driver"/>
<property name="JDBC.ConnectionURL"
value="jdbc:mysql://localhost/prueba"/>
<property name="JDBC.Username" value="usuario"/>
<property name="JDBC.Password" value="password"/>
</dataSource>
</transactionManager>
<sqlMap resource="cl/uv/ibatis/orm/Auto.xml" />
</sqlMapConfig>
Esta configuración es para acceder de manera directa a la base de datos. Ahora bien, si
queremos realizar esta conexión a través de un pool de conexiones se debe crear el siguiente
archivo de configuración:

<?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>
<transactionManager type="JDBC" >
<dataSource type="JNDI">
<property name="DataSource" value="jdbc/MySQL"/>
</dataSource>
</transactionManager>
<sqlMap resource="cl/uv/ibatis/orm/Auto.xml" />
</sqlMapConfig>

Vemos la parte de la cabecera, que deberíamos poner tal cual está. También los datos de
conexión a la base de datos. Y finalmente, como <sqlMap resource="... /> uno de los ficheros
de mapeo XML. Pondríamos tantos de estos tags <sqlMap> como ficheros tuvieramos.

Tanto este fichero de configuración como los de mapeo en principio deben estar en el
classpath, es decir, o bien dentro del jar, o bien en los directorios de búsqueda de clases.

El código java

Vamos a ver ahora el código java para empezar a usar todo esto. Por supuesto, debemos
añadir a nuestro proyecto todos los jar de Ibatis más el driver de la base de datos que estemos
usando -MySQL en este caso-.

Configuramos Ibatis

Lo primero que hacemos en el código es instanciar una clase de Ibatis que lea los ficheros de
configuración y que es a la que pediremos que nos realice las consultas, inserciones,
modificaciones y borrados. El código para instanciar esta clase de Ibatis puede ser como este

String resource = "cl/uv/ibatis/config/Conexion.xml";

Reader reader = Resources.getResourceAsReader(resource);
SqlMapClient sqlMap = SqlMapClientBuilder.buildSqlMapClient(reader);

Este código simplemente obtiene un Reader de nuestro fichero de configuración de Ibatis y le

pide a SqlMapClientBuilder un SqlMapClient. El código puede lanzar excecpciones, así que
deberíamos meterlo en un try-catch o bien relanzar la excepción en nuestro método que tenga
este código.

Hacemos consultas con Ibatis

Vamos ahora a usar los distintos SELECT que hemos puesto en el fichero de configuración. El
primero es un SELECT por id, al que hemos puesto el nombre de "getAuto". Para la cláusula
WHERE hemos usado #value# y no hemos indicado el parameterClass, así que aquí deberemos
pasar directamente un entero. Si pasamos una clase que no sea un tipo primitivo, Ibatis tratará
de llamar al método getId() o get("id"). El código para esta consulta puede ser así
Integer idAuto = new Integer(1);
Auto auto = (Auto) sqlMap.queryForObject("getAuto", idAuto);

En queryForObject() estamos indicando que nos devuelva un sólo objeto AutoBean. Como
parámetro pasamos el nombre que le dimos a esta consulta en el fichero Auto.xml al SELECT y
el entero que hace de identificador. Ibatis se encarga de poner el entero en #value#, hacer la
consulta, hacer un new de la clase AutoBean y de rellenar todos sus parámetros llamando a los
distintos métodos set() de la clase AutoBean. El nombre de los métodos set() será el de los AS
que hemos puesto en la consulta.

Otro SELECT que tenemos es al que hemos llamado "getAutos", que pretendemos que nos
devuelva una lista de autos. Este SELECT no tiene ningún parámetro de entrada, ya que
consulta todos los coches y no hay cláusula WHERE. El resultClass indica con qué clase se hará
cada uno de los registros leídos de base de datos. El código para usar este SELECT puede ser
como el siguiente

List<AutoBean> autos = sqlMap.queryForList("getAutos", null);

Hemos llamado a queryForList() para indicar que queremos una lista. Como parámetro hemos
pasado el nombre del SELECT que es "getAutos" y un null, puesto que no hemos puesto
cláusula WHERE. Ibatis se encarga de hacer la consulta, construir tantas clases AutoBean como
registros obtenga y devolvernos una Lista de AutoBean.

Finalmente, otro SELECT que hemos puesto es para obtener un Hashtable en vez de una clase
AutoBean. Al SELECT lo hemos llamado "getHashAuto". No hemos indicado un parameterClass,
pero como hemos puesto en la cláusula WHERE un id = #valor#, tendremos que pasar un
entero como parámetro de entrada. Como resultClass hemos puesto un java.util.Hashtable,
que será donde Ibatis nos devuelva el resultado. El código para usar esto puede ser

Map hashAuto = (Map) sqlMap.queryForObject("getHashAuto", 3);

Ibatis se encarga de hacer la consulta, reemplazando el #valor# del WHERE por un 3, luego
instancia un Hashtable, lo rellena con el método put("id",...), put("marca", ...) y lo devuelve.
Los valores que usa como claves para el Hashtable son los AS que hemos puesto en el SELECT.

Insertamos registros con Ibatis

Para insertar usaremos la SQL que hemos llamado "insertAuto". No lleva resultClass puesto
que este SQL no devuelve ningún registro. No le hemos puesto parameterClass, así que en el
método java correspondiente podremos usar indistintamente una clase AutoBean o un
Hashtable. Este podría ser el código de ejemplo

/* Insertar un auto nuevo. No ponemos id porque se genera

automaticamente en la inserción.*/

AutoBean auto = new AutoBean();

auto.setMarca("una marca");
auto.setMatricula("una matricula");
auto.setFechaMatricula(new Date());
sqlMap.insert("insertAuto", auto);
// Ahora insertamos con un Hashtable.
Hashtable hashAuto = new Hashtable();
hashAuto.put("marca", "la marca");
hashAuto.put("matricula", "x-2222-z");
hashAuto.put("fechaMatricula", new Date());
sqlMap.insert("insertAuto", hashAuto);

En el método insert() pasamos como parámetro el nombre de la SQL "insertAuto" y la clase

que contiene los datos. En el caso del bean, Ibatis llamará a los métodos get() para obtener los
valores, en el caso del Hashtable llamará al método get(clave) para obtener los valores.

Modificamos registros en base de datos con Ibatis

Para modificar datos usaremos la SQL con el nombre "updateAuto". No lleva resultClass puesto
que no devuelve ningún registro y le hemos puesto como parameterClass la clase AutoBean,
por lo que sólo podremos usar este UPDATE pasando una instancia de Coche. El código de
ejemplo puede ser:

// Obtenemos un auto.
Integer idAuto = new Integer(1);
AutoBean auto = (AutoBean) sqlMap.queryForObject("getAuto", idAuto);

// modificar un auto
auto.setMarca("cambiada");
sqlMap.update("updateAuto", auto);

En este caso, Ibatis obtendrá el #id# para el WHERE y los campos que hay que modificar todos
de la clase AutoBean que le pasemos.

Borramos un registro con Ibatis

Para el borrado de registros, usaremos la SQL de nombre "deleteAuto" a la que se le debe

pasar un entero con el #valor# del id del auto a borrar. El código de ejemplo puede ser:

sqlMap.delete("deleteAuto", 11);

Borrará de base de datos el auto cuya clave (id) es 11.