NOTE JAVA

IBATIS DataMapper Framework (noto anche come mappe SQL
) consente di ridurre in modo significativo la codifica su Java per un’applicazione che gestisce il database relazionale.
Forse la prima impressione che si sia è che è lo stesso di Hibernate (che è una mappatura dell’oggetto con le schede relazionali – orm). Ibatis è diverso. Come vedremo in questo tutor, IBATS mappa le query SQL e ti permette di interagire con i javabeans e i parametri di input e output.

Mani al lavoro

Per iniziare, otterremo il framework dalla pagina |
ASF: http://ibatis.apache.org/
Il file che scaricheremo (ibatis_dbl-2.1.7.xx. Zip) Concetto
Tre file .jar. In questo tutor useremo solo ibatis-common-2.jar e ibatis-sqlmap-2.jar. Non hai bisogno di altri .jar, almeno per questo capitolo.

Definizione della struttura dei dati

Creeremo il nostro Categoria JavaBean con la
Prossima struttura.

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

Abbiamo anche bisogno di creare il nostro database. Possiamo usare qualsiasi motore; Naturalmente avremo bisogno del tuo rispettivo pilota.

Creeremo la nostra categoria di tabella, che avrà la seguente struttura:

Nome

Tipo

cat_id

Autonameric (chiave principale)

Cat_name

Varchar (30)

Come puoi vedere, abbiamo messo nomi di campi diversi dalle proprietà del nostro JavaBean. Vedremo come in Ibatis possiamo associare ogni colonna con la sua rispettiva proprietà sugli oggetti.

Configurazione della connessione al database dalla nostra applicazione

Lo faremo Creare il file di database.properties all’interno del pacchetto
com.jugperu.Tutores.ibatis.resources che avrà i seguenti valori:

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

Creeremo il file SQLMAPCONFIG.XML che avrà il seguente contenuto:

L’attributo “Risorsa” dal Elemento “Proprietà”
È necessario indicare la posizione del file .properties che abbiamo appena creato. Deve essere in posizione relativa alle nostre classi
. Se vogliamo utilizzare una posizione che è al di là della portata dell’applicazione, useremo l’attributo
“URL”.

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

Vediamo che le proprietà della connessione (elementi < Proprietà
/ >) Utilizzare variabili come $ {JDBC .Driver}. Questo perché stai usando i valori il nostro file e il database. Proproperties. Solo file sqlmapconfig.xml
È possibile utilizzare un file .properties per questi casi.

SQLMAP / > Punti su un file
Storage.xml. Questo file lo descriverà di seguito .

che Proprietà / > può essere specificato per puntare a una risorsa al di fuori dell’ambito dell’applicazione.

Gli altri elementi di questo .xml lo specificheranno nel prossimo capitolo.

Definizione della mappa della CO NULTE.

Creeremo il file di archiviazione all’interno dei
com.jugperu.tutores.ibatis.resources, che avrà il prossimo contenuto

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

Dettagli il contenuto di questo .xml:

TypeAalias / > ci consentirà di descrivere un alias per evitare di scrivere un nome di classe lungo. In questo caso, invece di scrivere
“com.jugperu.tutores.ibatis.beans.category”
useremo “Categoria”

Vediamo che ha elementi che loro può associare rapidamente le dichiarazioni SQL. Tutti questi elementi hanno l’attributo “ID”.
Questo ci permetterà di identificare ognuno di loro.
Definiremo la struttura di ciascuno:

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

Questa voce riceve come parametro un oggetto il cui tipo è definito nell’attributo “ResultClass”. Come il nome completo della nostra classe è molto lungo, noi abbiamo Definito un alias con < typealias / >. Pertanto, il tipo di parametro
è com.jugperu.tutors.ibatis. Beans.Category.

Il comando Inserisci deve salvare la relazione con la sintassi del motore che stiamo utilizzando.I valori racchiusi in segni numerici
(#) Fare riferimento alle proprietà dell’oggetto ricevuto come parametro.

Selezionare > riceve come parametro un valore numerico “int” e restituisce restituisce un oggetto “Categoria”. Il parametro “int”
è un alias predefinito della classe Java.lang.integer. Per
, invocando questa dichiarazione SQL passeremo come parametro su un oggetto intero.

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

In questo elemento ha una dichiarazione SQL in cui i campi selezionati hanno un alias. Cioè, il campo Cat_ID ha come in alias ” ID “, e Cat_name ha come nome di alias” Nome “.
Questo modo Ibatis posizionerà ogni campo del risultato risultante e li posizionerà nelle rispettive proprietà sull’agenzio.

Test Programma

Il modo migliore per effettuare un programma di prova sta utilizzando un testCase in Junit. Creeremo il nostro TestCase, chiamandolo IbatismaAppStestCase e avrà il seguente metodo di installazione
().

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

Creeremo il nostro test per registrare le categorie di oggetti.

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

Faremo anche un test per ottenere un oggetto.

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

Tasti auto-generati

Il metodo SQLMAP “Insert” restituisce un oggetto e contenere il valore del tasto nuovo generato (se applicabile). Ma sul nostro esempio il valore che ritorna è nullo, sebbene
abbiamo dichiarato che la chiave primaria è Autonumérica. Ibatis
Non saprai mai qual è il valore a meno che non entriamo sull’istruzione SQL quale valore devi tornare.

Modifica storage.xml su The < Inserire > in modo tale da guardare dal seguente modo.

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

Questa è la frase per HSQLDB, che è il motore utilizzato su questo ed esempio. Per MySQL il comando SQL che è dentro
< SelectKey > dovrebbe essere:

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

e per SQL Server:

...
<selectKey resultClass="int">
select @@IDENTITY as ID
</selectKey>
...

Gestione dei risultati

Definizione dei risultati Mappa

Abbiamo visto che per associare tutti i campi di una query A
Le proprietà javaban, ognuna di queste deve avere un aliah.
che può essere un grosso problema, poiché se fosse circa diversi campi, dovremmo mettere diversi “come” per ciascuno. E se ci fossero diverse dichiarazioni SQL, anche noi

Possono essere problematico per fare una modifica.

Ibatis ci consente di creare una mappa dei risultati. Ci sono: possiamo definire l’associazione che utilizzeremo tra le proprietà dell’oggetto e dei campi della query .

Per fare ciò, aggiungeremo il seguente elemento in Storage.xml

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

Ogni volta che usiamo come turno Ta “res-category”,
Ibatis sarà responsabile della creazione di un’istanza di “categoria” e posizionare i valori di ciascuna colonna su ciascuna proprietà che viene utilizzata.

Aggiungeremo una nuova query:

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

Come puoi vedere, non è più necessario posizionare un alias per ogni campo .

e creeremo un nuovo test per testarlo:

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

Risultati senza javabeans

Non useremo necessariamente un javabale per ottenere un risultato per un risultato. Possiamo usare un java.util.hashmap per ottenere tutti i campi di una query. Ogni tasto sarà il nome del campo e il suo rispettivo valore sarà il valore associato.

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

L’oggetto restituito da QueryFobject () sarà classicamente classico java.util.hashmap.

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

, quindi, potremmo costruire una query con vari
Campi senza preoccuparti della struttura che restituirà.

Possiamo anche ottenere un solo campo su un elenco.

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

e ogni oggetto dall’elenco ottenuto da queryforlist () sarà un java.lang.String.

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

Naturalmente, noi potrebbe creare una query che ha un oggetto hashmap e invocalo con una queryformis (). Il risultato sarà un elenco in cui ogni elemento sarà un hashmap.

Gestione dei parametri

IBATIS consente inoltre di definire i parametri che riceveranno il consultazioni. La sua struttura è molto simile ai programmi dei risultati.

Possiamo anche dispensare con un JavaBean per inviare parametri. Per questo useremo un java.util.map.
Ogni chiave sarà accessibile come se fosse una proprietà di un javabean

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

Associazioni

Uno dei principali problemi della gestione del database
Relazioni utilizzando oggetti è l’associazione tra le tabelle.

Crearemos una tabla Prodotto con la siguiente estructura:

Campo

TIPO

PR_ID

Autonumérico (Clave Principal)

PR_NOMBRE

Varchar (30)

pr_precio

decimale

PR_Stock

numérico entero

PR_Categoria

Numérico No Nulo (clave foránea de categoria)

CREAREMOS EL JAVABEAN CON SUS DISPECTIVAS 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 Registro

Crearemos Un Inserire > PARI 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 accedere a una propegioned de producto
Que Es de Clase Categoria. En casò que la propediad
Categoria Fuera Nulo, Ibatis Toma Toda La Expresión
(categoria.Id) Como Nulo.

Probamos Insertar Unbjeto 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 Automáticamente los

Objetos Asociados Ques Objetos Asociados Ques Nessun esistente en la base de datos. Es decir, si se
Crea un objeto categoria y se asocia a un nuevo objeto de
Prodotto, Al Hacer El insert () Solo se Guardarán
Los Valores del Objeto Producto y No los del objeto categoria.

Obteniendo Un Registro

Para Obtener Un Registro Mapeado en
Objeto, AL < Risultato > SE ARGEGARÁ 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 LA PRIPIEDAD Categoria SE Tomará el
Campo PR_Categoria Y Se Buscará Su Valoor del Seleziona
GetCategoriaporID. AL HACER Esto, SE Invocará a Dico
Select Y SE LE PASHARÁ COMO PARÁMETRO EL VALORRO DE
PR_Categoria OBTENIENDO EL OBJETO MANDESIENTE.

El Select Para Objetos de
ProductO SERÁ MUY SEMPLE:

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

Y La Llamada Desde Java Será La Misma 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 Un
Prodotto, Ibatis Hará Dos Consultas: UNO PARA EL ProductO Y
Otro Para la categoria. SI Fueran Varios Productos, Hará
UNA Consulta por Los Productos y N consultas por cada prodotto para

Otttener Su categoria.

Esto se pu beede solucionar haciendo unisciti a modificando el
< RISUALMMAP >.

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

Conclusione

/ h2>

con ibatis se puede mapear las consultas quesetamos para
nuestro preyecto. La sintaxis que se utilice par manejar los
Registrazione de la base de coatos está fuertemente aislada en la
lógica de negocio. Esto Nos Permesso Tener Un código
Limpio de Menpencias SQL. Si es necesario hacer alguna modificación
en sql, bastará con editore el xml y no una clase en java
Evitando la compilación de este.

Leave a Comment

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *