NOTAS JAVA

O marco de DatamaPper Ibatis (tamén coñecido como SQL
Maps) permítelle reducir significativamente a codificación en
Java para unha aplicación que manexa a base de datos relacional.
Quizais a primeira impresión que ten é que é o mesmo que Hibernate (que é un mapeo de obxectos con placas
Relacionales – ORM). Ibatis é diferente. Como veremos neste titor, Ibats Maps SQL consultas e permítelle interactuar con JavaBeans, así como parámetros de entrada e saída

mans para traballar

Para comezar, recibiremos o marco da páxina |
ASF: http://ibatis.apache.org/
o ficheiro que imos descargar (IBatis_DBL-2.1.7.XX. ZIP) Contect
tres ficheiros .jar. Neste titor só usaremos Ibatis-Common-2.Jar e Ibatis-SQLMAP-2.JAR. Non necesita ningún outro .jar, polo menos
para este capítulo.

Definición da estrutura dos datos

Crearemos a nosa Categoría JavaBean coa seguinte estrutura.

package com.jugperu.tutores.ibatis.beans;
public class Categoria {
private int id; // podemos utilizar tipos de datos nativos
private String nombre;
/*... poner sus respectivos métodos
setXX() y getXX() para que tenga el
patrón JavaBean (value object)*/
}

Tamén necesitamos crear a nosa base de datos. Podemos usar calquera motor; Por suposto, necesitaremos o seu respectivo condutor.

Crearemos a nosa categoría de mesa, que terá a seguinte estrutura:

Nome

Tipo

cat_id

Autonameric (chave principal)

CAT_NAME

Varchar (30)

Como podes ver, poñemos nomes de campos distintos ás propiedades do noso JavaBean. Veremos como en Ibatis podemos asociar cada columna coa súa propiedade respectiva nos obxectos.

Configuración de conexión á base de datos desde a nosa aplicación

Nós imos Crea o ficheiro de base de datos.Properties dentro do paquete
com.jugperu.tutores.ibatis.Resources que terán os seguintes valores:

#el driver de nuestra base de datos
jdbc.driver=org.hsqldb.jdbcDriver
#el url para nuestra conexion.
jdbc.url=jdbc:hsqldb:file:data/productos.hsqldb
#el usuario
jdbc.username=sa
#y la contraseña
jdbc.password=

Crearemos o ficheiro sqlmapconfig.xml que terá o seguinte contido:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE sqlMapConfig
PUBLIC "-//iBATIS.com//DTD SQL Map Config 2.0//EN"
"http://www.ibatis.com/dtd/sql-map-config-2.dtd">
<sqlMapConfig>
<properties resource="com/jugperu/tutores/ibatis/resources/database.properties"/>
<transactionManager type="JDBC">
<dataSource type="SIMPLE">
<property name="JDBC.Driver" value="${jdbc.driver}"/>
<property name="JDBC.ConnectionURL" value="${jdbc.url}"/>
<property name="JDBC.Username" value="${jdbc.username}"/>
<property name="JDBC.Password" value="${jdbc.password}"/>
</dataSource>
</transactionManager>
<sqlMap resource="com/jugperu/tutores/ibatis/resources/Almacen.xml"/>
</sqlMapConfig>

o atributo “recurso” do Elemento “Propiedades”
Debe apuntar á localización do ficheiro .Properties que acabamos de crear. Debe estar en posición relativa ás nosas clases. Se queremos usar unha localización que está fóra do alcance da aplicación, utilizaremos o atributo
“URL”.

 <properties url="file://c:/proyecto/database.properties"/>

Vemos que as propiedades da conexión (elementos < propiedade / >) usan variables como $ {jdbc .driver}. Isto é porque está a usar os valores do noso ficheiro
Database.Properties. O ficheiro sqlmapconfig.xml só pode usar un ficheiro .properties para estes casos.

o sqlmap / > puntos a un ficheiro de almacenamento.xml. Este ficheiro describilo a continuación .

Os outros elementos deste .xml detallará o seguinte capítulo.

Definir o mapa do co NSults.

Crearemos o ficheiro de almacenamento dentro de
com.jugperu.tutores.ibatis.Resources, que terá o seguinte contido

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE sqlMap
PUBLIC "-//iBATIS.com//DTD SQL Map 2.0//EN"
"http://www.ibatis.com/dtd/sql-map-2.dtd">
<sqlMap namespace="almacen">
<typeAlias type="com.jugperu.tutores.ibatis.beans.Categoria" alias="categoria"/>
<insert parameterClass="categoria">
insert into CATEGORIA
(cat_nombre)
values (#nombre#)
</insert>
<select resultClass="categoria" parameterClass="int">
select cat_id as id, cat_nombre as nombre
from categoria
where cat_id=#value#
</select>
</sqlMap>

Detallaremos o contido desta .xml:

o Tipoalias / > permitiranos describir un alias para evitar escribir un nome de clase longa. Neste caso, en vez de escribir
“com.jugperu.tutores.ibatis.beans.category”
Usaremos “categoría”

Vemos que ten elementos que eles pode asociarse rapidamente con declaracións SQL. Todos estes elementos teñen o atributo “ID”.
Isto permitiranos identificar cada un deles.
Detectaremos a estrutura de cada un:

 <insert parameterClass="categoria">
insert into CATEGORIA
(cat_nombre)
values (#nombre#)
</insert>

Este elemento recibe como un parámetro un obxecto cuxo tipo defínese no atributo “Resultplass”. Como o nome completo da nosa clase é moi longo, temos Definiu un alias co < Tipoalias / >. Polo tanto, o tipo de parámetro
é com.jugperu.tutors.ibatis. Beans.Category.

A comando de inserción debe gardar a relación coa sintaxe do motor que estamos a usar.Os valores incluídos en signos numéricos
(#) refírense ás propiedades do obxecto recibido como parámetro.

O elemento

Seleccione > recibe como parámetro un valor numérico “int” e devolve devolver un obxecto

tipo “categoría”. O parámetro “int”
é un alias predefinido da clase java.lang.integer. Por
, invocando esta declaración SQL, pasaremos como parámetro a un obxecto enteiro.

 <select resultClass="categoria" parameterClass="int">
select cat_id as id, cat_nombre as nombre
from categoria
where cat_id=#value#
</select>

Neste elemento ten unha instrución SQL onde os campos que se seleccionan teñen un alias. É dicir, o campo Cat_id ten como alias ” ID “, e CAT_NAME ten como” nome “de alias.
Deste xeito, iBatis colocará cada campo do resultado resultante e colocalos nas súas respectivas propiedades sobre a proba de AGENDAME.

proba Programa

A mellor forma de facer un programa de proba está a usar unha proba de test de
en junit. Crearemos a nosa testcase
chamada IbatismApstestase e terá o seguinte método de configuración
().

 Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
// el .xml para la conexión
sqlMap = SqlMapClientBuilder.buildSqlMapClient(reader);
//construye el manejador de llamadas al iBatis

Crearemos a nosa proba para rexistrar as categorías de obxectos.

 public void testInsertarCategorias() throws SQLException {
try {
sqlMap.startTransaction();
Categoria c1 = new Categoria();
Categoria c2 = new Categoria();
Categoria c3 = new Categoria();
c1.setNombre("memorias");
c2.setNombre("placas");
c3.setNombre("procesadores");
sqlMap.insert("insertCategoria", c1);
sqlMap.insert("insertCategoria", c2);
sqlMap.insert("insertCategoria", c3);
sqlMap.commitTransaction();
} catch (SQLException ex) {
ex.printStackTrace();
assertTrue(false);
} finally {
sqlMap.endTransaction();
}
}

Tamén faremos unha proba para obter un obxecto.

 public void testGetCategoriaPorId() throws SQLException {
try {
sqlMap.startTransaction();
Categoria c1 = (Categoria) sqlMap.queryForObject(
"getCategoriaPorId", Integer.valueOf(2));
assertNotNull(c1);
mostrar(c1);
} catch (SQLException ex) {
ex.printStackTrace();
assertTrue(false);
} finally {
sqlMap.endTransaction();
}
}
private static void mostrar(Categoria cat) {
System.out.println(cat.getId() + "\t" + cat.getNombre());
}

Teclas auto-xeradas

O método SQLMAP “Inserir” devolve un obxecto
que contén o valor da nova chave xerada (se procede). Pero en
o noso exemplo o valor que devolve é nulo, aínda que
declaramos que a clave primaria é Autonumérica. Ibatis
Nunca sabes cal é o valor a menos que poñamos a instrución SQL que valor ten que devolver.

editamos almacenamento.xml na < Inserir > de tal xeito que pareza do seguinte xeito.

...
<insert parameterClass="categoria">
insert into CATEGORIA
(cat_nombre)
values (#nombre#)
<selectKey resultClass="int">
select distinct identity() as id
from categoria
</selectKey>
</insert>
...

Esta é a frase de HSQLDB, que é o motor usado neste e exemplo. Para MySQL comando SQL que está dentro
< SelectKey > debe ser:

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

e para SQL Server:

Xestionar resultados

Definición de resultados Mapa

Vimos que asociar todos os campos dunha consulta A
As propiedades de JavaBean, cada unha delas debe ter un Aliah.
que pode ser un gran problema, xa que se trataba de varios campos, teriamos que poñer varios “como” para cada un. E se houbese varias declaracións SQL, tamén

Pode ser problemático para facer unha modificación.

Ibatis permítenos crear un mapa de resultado. Hai: podemos definir a asociación que imos usar entre as propiedades do obxecto e os campos da consulta .

Para facelo, engadiremos o seguinte elemento en almacenamento.xml

 <resultMap class="categoria">
<result property="id" column="cat_id"/>
<result property="nombre" column="cat_nombre"/>
</resultMap>

Cada vez que usamos como xiro TA “Res-category”,
Ibatis será a encargada de crear unha instancia de “categoría” e poñer os valores de cada columna en cada propiedade que se usa.

Engadiremos unha nova consulta:

 <select resultMap="res-categoria">
select *
from categoria
</select>

Como podes ver, xa non é necesario colocar un alias para cada campo .

e crearemos unha nova proba para probalo:

 List lista = sqlMap.queryForList("getAllCategoria", null);
for (Iterator iter = lista.iterator(); iter.hasNext(); ) {
Categoria cat = (Categoria) iter.next();
mostrar(cat);
}

Resultados sen javaBeans

Non usaremos necesariamente a JavaBean para obter un resultado por un resultado. Podemos usar un java.util.hashmap para obter todos os campos dunha consulta. Cada clave será o nome do campo e o seu valor respectivo será o valor asociado.

 <resultMap class="java.util.HashMap">
<result property="id" column="cat_id"/>
<result property="nombre" column="cat_nombre"/>
</resultMap>
...
<select resultMap="res-map-categoria">
select *
from categoria
where cat_id=#value#
</select>

O obxecto devolto por QueryForObject () será clásicamente clásico java.util.hashmap.

 HashMap map = (HashMap) sqlMap.queryForObject(
"getMapCategoriaPorId", Integer.valueOf(1));

, Polo tanto, poderiamos construír unha consulta con varios
Campos sen preocuparse pola estrutura que vai volver.

Tamén podemos obter só un campo nunha lista.

 <resultMap class="java.lang.String">
<result property="nombre" column="cat_nombre"/>
</resultMap>
...
<select resultMap="res-categoria-nombre">
select *
from categoria
</select>

e cada obxecto da lista obtida a partir de QueryForlist () será un java.lang.string.

 List lista = sqlMap.queryForList("getNombresCategoria", null);

Por suposto, nós podería crear unha consulta que ten como obxecto HasHMAP e invocala cun QueryForlist (). O resultado será unha lista onde cada elemento será un hasHMAP.

Os parámetros de xestión

Ibatis tamén permite definir os parámetros que recibirán o Consultas. A súa estrutura é moi similar aos resultados. Para iso, imos usar un java.util.map.
Cada clave será acceder a que fose unha propiedade dun JavaBean

 <update parameterClass="java.util.Map">
update categoria
set cat_nombre=#nombre#
where cat_id=#id#
</update>

Asociacións

Un dos principais problemas de xestión de bases de datos
Relacións que usan obxectos é a asociación entre táboas.

Crearemos una tabla Producto con la siguiente estructura:

Campo

tipo

PR_ID

Autonumérica (Clave Principal)

pr_nombre

Varchar (30)

Pr_precio

decimal

Pr_stock

numérico entero

Pr_categoria

Numérico NO NULO (Clave Foránea de categoria)

Crearemos El JavaBean con sus respectivas Propiedades:

package com.jugperu.tutores.ibatis.beans;
public class Producto {
private int id;
private String nombre;
private int stock;
private double precio;
private Categoria categoria;
//.....
}

Agregando un rexistro

crearemos un Inserir > para manejar la inserción
de objetos a la tabla.

 <typeAlias type="com.jugperu.tutores.ibatis.beans.Producto" alias="producto"/>
//...
<insert parameterClass="producto">
insert into producto
(pr_nombre,pr_stock,pr_precio,pr_categoria)
values (#nombre#,#stock#,#precio#,#categoria.id#)
</insert>

Nota CÓMO se acceder a unha proposta de produto
Que é de clase Categoria. En Caso que La Propiedad
Categoría Fuera Nulo, Ibatis Toma toda a expresión
(Categoria.Id) Como Nulo.

Probamos Insertar un Objeto Producto:

 Categoria cat = (Categoria) sqlMap.queryForObject(
"getCategoriaPorId", Integer.valueOf(1));
Producto p1 = new Producto();
p1.setNombre("Kingston");
p1.setPrecio(300.50);
p1.setStock(5);
p1.setCategoria(cat);
sqlMap.insert("insertProducto", p1);

Es Necesario recalcar que ibatis no agrega automaticamente los
objetos asociados que non existan en la base de datos. ES Decir, Si Se
Crea un Objeto Categoría e Se AOCIA A ONVO OBJETO DE
PRODUCIÓN, Al Hacer El Insert () Solo Se Guaráns
Los Valores do OBJETO PRODUTO Y NO LOS DEL OBJETO Categoria.

Obteniendo un rexistro

para obsterer un rexistro mapeado en
objeto, al < resultmap > SE AGREGARÁ UN ATRIBUTO
MÁS:

 <resultMap class="producto">
<result property="id" column="pr_id"/>
<result property="nombre" column="pr_nombre"/>
<result property="stock" column="pr_stock"/>
<result property="precio" column="pr_precio"/>
<result property="categoria" column="pr_categoria" select="getCategoriaPorId"/>
</resultMap>

Como se ve, para a propiedad Categoria Se Tomará El
Campo Pr_Categoria y SE Buscará Su Valor del SELECT
GetCategoríporIporID. Al Hacer Esto, SE invocará a Dicho
Seleccione e Se le Pasará Como Parámetro El Valor de
Pr_Categoria OBTENIENTO O OBJETO correspondente.

EL SELECT PARA OBTENER Objetos de
Producto Será Muy Simple:

 <select resultMap="res-producto">
select *
from producto
where pr_id=#value#
</select>

e la llamada desde a java será la MISTA Que se ha Estado
Manejando:

 Producto p = (Producto) sqlMap.queryForObject("getProductoPorId",
Integer.valueOf(1));
mostrar(p); //muestra cada campo del objeto "p”
//.....
private static void mostrar(Producto p) {
System.out.println(p.getId() + "\t" + p.getNombre() + "\t" +
p.getPrecio() + "\t" + p.getStock() + "(" +
p.getCategoria().getNombre() + ")");
}

PERO ESTA SOLUCIÓN TIENE UNA DEFICIENCIA: PARA OBTENER ONE
PRODUCO, IBATIS HARÁ DOS CONSULTAS: UNO PARA EL PRODUTO Y
OTRO para a categoria. SI FUERAN VARIOS PRODUTOS, HARÁ
UNA CONSULTA POR LOS PRODUTOS Y N CONSULTAS POR CADA PRODUCIÓN PARA
OBTENER SU Categoría < resultmap >.

 <resultMap class="producto">
<result property="id" column="pr_id"/>
<result property="nombre" column="pr_nombre"/>
<result property="stock" column="pr_stock"/>
<result property="precio" column="pr_precio"/>
<result property="categoria.id" column="pr_categoria"/>
<result property="categoria.nombre" column="cat_nombre"/>
</resultMap>
....
<select resultMap="res-producto-opt">
select *
from producto p, categoria c
where p.pr_categoria=c.cat_id
</select>

conclusións

con Ibatis Se Puede Mapear Las Consultas Que Necesitamos Para
Nuestro Proyecto. La sintaxis que se se utilice para manejar los
Registros de la base de datos está fuertemente aislada en la
lóxica de negociación. Esto nos permite o Tener Un Código
Limpio de Sentencias SQL. SI ES Necesario Hacer Alguna Modificación
en SQL, Bastará con editar El XML Y NO CLASE CLASE EN JAVA
EVITANDO LA COMPILACIÓN DE ESTA.

Leave a Comment

O teu enderezo electrónico non se publicará Os campos obrigatorios están marcados con *