Notes Java

Le framework ibatis Datamapper (également connu sous le nom de cartes SQL
) vous permet de réduire considérablement la codage de
Java pour une application qui gère la base de données relationnelle.
Peut-être que la première impression que l’on a est que c’est la même chose que Hibernate (qui est un mappage d’objet avec des planches de référence – orm). Ibatis est différent. Comme nous le verrons dans ce tuteur, Ibats Maps SQL requêtes et vous permet d’interagir avec des paramètres JavaBeans, ainsi que des paramètres de saisie et de sortie.

mains au travail

Pour commencer, nous obtiendrons le cadre de la page |
Asf: http://ibatis.apache.org/ Le fichier que nous allons télécharger (ibatis_dbl-2.1.7.xx. Zip) CONTECT
trois fichiers .jar. Dans ce tuteur, nous n’utiliserons qu’IBATIS-COMMON-2.JAR et IBATIS-SQLMAP-2.JAR. Vous n’avez pas besoin d’autre .jar, au moins

pour ce chapitre.

Définition de la structure des données

Nous allons créer notre Catégorie JavaBean avec la
Structure suivante.

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

Nous devons également créer notre base de données. Nous pouvons utiliser n’importe quel moteur; Naturellement, nous aurons besoin de votre pilote respectif.

Nous allons créer notre catégorie de table, qui aura la structure suivante:

nom

Type

ID = « 91079FD1ED »>

CAT_ID

Autonameric (clé principale)

CAT_NAME

varchar (30)

Comme vous pouvez le constater, nous avons mis des noms de champs autres que les propriétés de notre JavaBean. Nous verrons comme dans Ibatis, nous pouvons associer chaque colonne avec sa propriété respective sur les objets.

Configuration de la connexion à la base de données depuis notre application

Nous allons Créez le fichier de base de données.properties dans le package
com.jugperu.Tutores.ibatis.Resources qui auront les valeurs suivantes:

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

Nous allons créer le fichier sqlmapconfig.xml qui aura le contenu suivant:

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

L’attribut « ressource » de la Elément « Propriétés »
Vous devez indiquer l’emplacement du fichier .properties que nous venons de créer. Il doit être en position par rapport à nos classes de
. Si nous voulons utiliser un emplacement qui dépasse la portée de l’application, nous utiliserons l’attribut RL « .

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

Nous voyons que les propriétés de la connexion (éléments < propriété
/ >) Utilisez des variables telles que $ {jdbc .Driver}. Ceci est parce que vous utilisez les valeurs Notre fichier
de base de données.properties. Le fichier sqlmapconfig.xml uniquement

Vous pouvez utiliser un fichier .properties pour ces cas.

le SQLMAP / > Points à un fichier ML. Ce fichier le décrire ci-dessous .
que l’élément Propriétés / > peut être spécifié pour pointer vers une ressource en dehors du cadre de l’application.

Les autres éléments de ce fichier .xml la détailleront dans le chapitre suivant.

Définition de la carte CO Nsults.

Nous allons créer le fichier de stockage dans le com.jugperu.TorTores.ibatis.resources, qui aura le contenu suivant

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

Nous détaillerons le contenu de ce fichier .xml:

TYPEALIE / > nous permettra de décrire un alias pour éviter d’écrire un nom de classe longue. Dans ce cas, au lieu d’écrire de
« com.jugperu.TorTores.ibatis.beans.Category »
Nous allons utiliser « Catégorie »

Nous voyons qu’il a des éléments qu’ils ont des éléments qu’ils ont Peut s’associer rapidement avec des relevés SQL. Tous ces éléments ont l’attribut « ID ».
Cela nous permettra d’identifier chacun d’eux.
Nous détaillerons la structure de chacun:

div id = « 563e296ded »>

Cet élément reçoit comme paramètre Un objet dont le type est défini dans l’attribut « résultatsClass ». Comme le nom complet de notre classe il est très long, nous avons Défini à un alias avec le < TYPEALIAS / >. Par conséquent, le type de paramètre
est com.jugperu.tutors.ibatis. Beans.Category.

La commande insertion doit enregistrer la relation avec la syntaxe du moteur que nous utilisons.Les valeurs enfermées dans des panneaux numériques
(#) se réfèrent aux propriétés de l’objet reçues sous forme de paramètre.

Sélectionnez > en tant que paramètre une valeur numérique « INT » et renvoie renvoie un objet « Catégorie ». Le paramètre « int »
est un alias prédéfini de la classe Java.lang.Integer. De ar
, en invoquant cette instruction SQL, nous transmettrons comme paramètre à un objet entier.

BR>

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

Dans cet élément a une instruction SQL où les champs sélectionnés ont un alias. C’est-à-dire que le champ CAT_ID a comme alias  » ID « , et CAT_NAME a comme alias » nom « .
Ibatis fera placer chaque domaine de la egré de
et les placera dans leurs propriétés respectives sur le nom de l’ordre du jour.

Test Programme

Le meilleur moyen de faire un programme de test utilise un test de
à Junit. Nous allons créer notre TESTCASE nviron l’appelant ibatismapstsestCase et aura la méthode de configuration
suivante ().

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

Nous allons créer notre test pour enregistrer les catégories d’objets.

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

Nous allons également faire un test pour obtenir un objet.

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

Touches auto-générées

La méthode SQLMAP « insert » renvoie un objet
contenant la valeur de la nouvelle touche générée (le cas échéant). Mais sur notre exemple, la valeur qui retourne est NULL, bien que nous ayons déclaré que la clé primaire est Autonumérica. Ibatis
Vous ne saurez jamais quelle est la valeur que si nous mettons sur l’énoncé SQL quelle valeur vous devez revenir.

Nous édions stockage.xml sur l’adresse < Insérer > de telle sorte qu’il ressemble de la manière suivante.


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

Ceci est la phrase pour HSQLDB, qui est le moteur utilisé sur ce et exemple. Pour MySQL, la commande SQL qui est intérieure < SelectKey > devrait être:

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

et pour SQL Server:

Gestion des résultats

Définition de la carte des résultats

Nous avons vu que pour associer tous les domaines d’une requête A
Les propriétés JavaBean, chacune d’entre elles doit avoir une Aliah.
qui peut être un gros problème, car il s’agissait de plusieurs domaines, nous devrions placer plusieurs « comme » pour chacun. Et s’il y avait plusieurs déclarations SQL, nous aussi

problématique de faire une modification.

Ibatis nous permet de créer une carte de résultat. Nous pouvons définir l’association que nous utiliserons entre les propriétés de l’objet et des champs de la requête .

Pour ce faire, nous ajouterons l’élément suivant dans STOCKS.XML

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

Chaque fois que nous utilisons comme tour TA « RES-Catégorie »,
Ibatis sera responsable de la création d’une instance de « catégorie » et de placer les valeurs de chaque colonne sur chaque propriété utilisée.

Nous allons ajouter une nouvelle requête:

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

Comme vous pouvez le constater, il n’est plus nécessaire de placer un alias pour chaque champ .

et nous allons créer un nouveau test pour le tester:

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

Résultats sans JavaBeans

Nous n’utiliserons pas nécessairement une JavaBean pour obtenir un résultat pour obtenir un résultat. Nous pouvons utiliser un java.Util.Hashmap pour obtenir tous les champs d’une requête. Chaque clé sera le nom du champ et sa valeur respective sera la valeur associée.

<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’objet renvoyé par QuereforObject () sera classique classique java.util.hashpmap.

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

, nous pourrions donc construire une requête avec diverses
Champs sans se soucier de la structure qui va retourner.

Nous pouvons également obtenir un seul champ sur une liste.

<resultMap class= »java.lang.String »>
<result property= »nombre » column= »cat_nombre »/>
</resultMap>

<select resultMap= »res-categoria-nombre »>
select *
from categoria
</select>

et chaque objet de la liste obtenue à partir de Queryfrofist () sera un java.lang.string.

Naturally, nous pourrait créer une requête qui a un objet hashmap et l’invoquera avec une queryforlist (). Le résultat sera une liste où chaque élément sera un hashmap.

Gestion des paramètres

Ibatis vous permet également de définir les paramètres qui vont recevoir la consultations. Sa structure est très similaire aux programmes des résultats.

Nous pouvons également vous dispenser avec une JavaBean pour envoyer des paramètres. Pour cela, nous utiliserons une java.util.map.
Chaque touche sera accessible comme s’il s’agissait d’une propriété d’une propriété JavaBean
<update parameterClass= »java.util.Map »>
update categoria
set cat_nombre=#nombre#
where cat_id=#id#
</update>

Associations

L’un des principaux problèmes de gestion de la base de données
Les relations à l’aide d’objets sont l’association entre les tables.

Crearemos UNA Tabla Producto con La Siguiente Estructura:

DIV = « 91079FD1ED « >

CAMPO

Tipo

pr_id

Autonumérico (Clave Principal)

pr_nombre

varchar (30)

pr_precio

décimal

pr_stock

numerrico Entero

pr_categoria

numerrico no nulo (clave foránea de catégorie)

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;
//…..
}

ACCORDGANDO UN REGISTO

CREAREMOS UN Insert > Para manejar la Inserción
de Objetos A la tabla.

Note Cómo SE Accédez à un Una Propipiedad de Producto
Qu’ES de Clase Catégorie. EN CASO QUE LA PROPIFIED
Catégorie Fuera Nulo, Ibatis Toma Toda La Expresión
(Catégorie.Id) Côme Nulo.

Probamos insert de l’ONU 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 sans ACCORDGA Automáticament Los
Objetos Asociados que non existante en la Base de Datos. ES Decir, Si SE
Crea Un NUEVO Catégorie Y OBJETO ASOCIA A UN NUEVO OBJETO DE
PRODUCTO, AL HACER EL INSERT () SOLO SE GARDARÁN
LOS VALORES DEL objeto Produit Y NO LOS DEL objeto Catégorie.

Obteniendo Un Registro

Para obtener Un registre MAPEADO EN
OBJETO, AL < TUREDMAP > SE ACCORDGRAÁ 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>

Côme SE Ve, Para La Propiedad Catégorie SE Tomará el
Campo Pr_Categoria Y SE Buscará su Valor del Sélectionnez
GetCategoriaPorid. Al HACER Esto, SE Invocará A Dicho
Sélectionnez Y SE SE SELE-Y SE LE PASARÁ COMO Parámetro el Valor de
Pr_Categoria obteniendo el objeto Correspondante.

el Sélectionnez Para Obtener objetos de
Será Muy Simple:

 <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 produit, IBATIS HARÁ DOS Consultas: Uno Para El Producto Y
Otro para la catégorie. SI Fueran Varios Productos, Hará
Una Consulta Por Los Productos Y N Consultas Par Cada Producto Para
Obtener SU Catégorie.

Esto SE PURE SOLUCIONARA HACIENDO UN REJOIND MODIFICANDO EL
< résultats = « ABC6C03176 »> .

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

Conclusements

CON IBATIS SE PUREE MAPEAR LAS CONSULTA QUE NECESITAMOS PARA
NUESTRO ProYecto. La Sintaxis QUE SE UTILICE PARA MANEJAR LOS
Registres de la Base de Datos Está Fuertement Aislamada en La
Lógica de Negocio. ESTO NOS ALLITE TENER UNE CÓDIGO
LIMPIO DE SENTENCIE SQL. Si ES Necesario Hacer Alguna Modificación
en SQL, BASTARÁ CON EDITAR EL XML Y Aucun CLASE EN JAVA
Evitando La Compilación de Esta.

Leave a Comment

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *