Java Notas

O IBATIS DataMapper Framework (também conhecido como mapas do SQL) permite reduzir significativamente a codificação de
Java para um aplicativo que lida com o banco de dados relacional.
Talvez a primeira impressão que se tenha é que é o mesmo que o Hibernate (que é um mapeamento de objetos com placas
Relacionais – ORM). Ibatis é diferente. Como veremos neste tutor, o Ibats mapeia as consultas SQL e permite que você interaja com os parâmetros JavaBeans, bem como de entrada e saída.

Mãos para trabalhar

Para começar, obteremos a estrutura da página |
ASF: http://ibatis.apache.org/
o arquivo que vamos baixar (ibatis_dbl-2.1.7.xx. Zip) Contate
três arquivos .jar. Neste tutor, usaremos apenas o Ibatis-Common-2.Jar e o Ibatis-SQLMAP-2.JAR. Você não precisa de nenhum outro .jar, pelo menos
para este capítulo.

Definindo a estrutura dos dados

vamos criar o nosso Categoria JavaBean com a próxima estrutura de
.

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

também precisamos criar nosso banco de dados. Nós podemos usar qualquer motor; Naturalmente, vamos precisar do seu respectivo driver.

Vamos criar nossa categoria de tabela, que terá a seguinte estrutura:

nome

tipo

cat_id

autonamérico (chave principal)

cat_name

varchar (30)

Como você pode ver, nós colocamos nomes de campos que não as propriedades do nosso javebean. Vamos ver como em Ibatis, podemos associar cada coluna com sua respectiva propriedade nos objetos.

Configuração da conexão com o banco de dados desde o nosso aplicativo

Nós vamos Crie o arquivo de banco de dados.properties dentro do pacote
com.jugperu.tutores.ibatis.resources que terão 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=

Vamos criar o arquivo sqlmapconfig.xml que terá o seguinte conteúdo:

<?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 “Propriedades” elemento
Você deve apontar para a localização do arquivo .properties que acabamos de criar. Deve estar em posição em relação às nossas classes. Se quisermos usar um local além do escopo do aplicativo, usaremos o atributo
“URL”.

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

Vemos que as propriedades da conexão (elementos < Propriedade
/ >) Use variáveis como $ {JDBC .Driver}. Isto é porque você está usando os valores do nosso arquivo de banco de dados do arquivo. O arquivo sqlmapconfig.xml apenas de
Você pode usar um arquivo .properties para estes casos.

o sqlmap / > aponta para um arquivo
storage.xml. Este arquivo irá descrevê-lo abaixo .
de
Que o elemento < propriedades / > pode ser especificado para apontar para um recurso que está fora do escopo do aplicativo.

Os outros elementos deste .xml o detalhará no próximo capítulo.

Definindo o Mapa de CO Nsuls.

Vamos criar o arquivo de armazenamento dentro do com.jugperu.tutores.ibatis.resources, que terá o próximo conteúdo

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

Nós detalharemos o conteúdo deste .xml:

o elemento < Tybealias / > nos permitirá descrever um alias para evitar escrever um nome de classe longa. Neste caso, em vez de escrever
“com.jugperu.tutores.ibatis.beans.category”
Nós usaremos “Categoria”

Vemos que tem elementos que eles pode associar-se rapidamente com instruções SQL. Todos esses elementos têm o atributo “ID”.
Isso nos permitirá identificar cada um deles.
Nós detalharemos a estrutura de cada um:

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

este item recebe como um parâmetro um objeto cujo tipo é definido no atributo “ResultClass”. Como o nome completo da nossa classe é muito longo, temos Definiu um alias com o < tyballias / >. Portanto, o tipo de parâmetro é com.jugperu.tutors.ibatis. Beans.Categoria.

O comando Inserir deve salvar o relacionamento com a sintaxe do mecanismo que estamos usando.Os valores incluídos em sinais numéricos
(#) Consulte as propriedades do objeto recebido como um parâmetro.

O elemento < Selecione > Recebe como um parâmetro Um valor numérico “int” e retorna retorna um objeto de “categoria”. O parâmetro “int” de “int” é um alias predefinido da classe java.lang.integer. Por fotos, invocando esta instrução SQL, vamos passar como um parâmetro para um objeto inteiro.

BR>

neste elemento tem uma instrução SQL em que os campos selecionados têm um alias. Ou seja, o campo CAT_ID tem como alias ” ID “, e CAT_NAME tem como” nome “de alias.
Desta forma, Ibatis colocará cada campo do redondo e colocá-las em suas respectivas propriedades no agente do agente.

Programa

A melhor maneira de fazer um programa de teste está usando um testcase no JUnit. Vamos criar nosso testcase
Chamando IbatismapStase e terá o seguinte método de configuração
().

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

nós vamos criar nosso teste para registrar categorias de objetos.

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

Nós também faremos um teste para obter um objeto.

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

chaves auto-geradas

O método SQLMap “Inserir” retorna um objeto, contendo o valor da nova chave gerada (se aplicável). Mas no nosso exemplo o valor que retorna é nulo, embora nós declaramos que a chave primária é autonumérica. Ibatis
Você nunca saberá qual é o valor, a menos que colocamos na instrução SQL que valor você tem para retornar.

Editamos o armazenamento.xml no
Inserir > De tal forma que seja da seguinte maneira.

...
<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 para HSQLDB, que é o motor usado nisso e exemplo. Para o comando mysql o sql que está dentro de
< selectkey > deve ser:

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

e para o SQL Server:

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

Gerenciando resultados

Definindo o mapa de resultados

Vimos que para associar todos os campos de uma consulta A
as propriedades javebeanas, cada um destes deve ter um aliah. O que pode ser um grande problema, já que se fosse sobre vários campos, teríamos que colocar vários “como” para cada um. E se houvesse várias declarações SQL, nós também problemático para fazer uma modificação.

Ibatis nos permite criar um mapa de resultados. Há: Podemos definir a associação que usaremos entre as propriedades do objeto e os campos da consulta. .

Para fazer isso, adicionaremos o seguinte item no armazenamento.xml

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

Cada vez que usamos como uma curva TA “RES Categoria”,
Ibatis será responsável por criar uma instância de “categoria” de
e coloque os valores de cada coluna em cada propriedade que é usada.

Vamos adicionar uma nova consulta:

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

como você pode ver, não é mais necessário colocar um alias para cada campo .

e vamos criar um novo teste para testá-lo:

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

Resultados sem javebeans

Não vamos necessariamente usar um Javabean para obter um resultado para um resultado. Podemos usar um java.util.hashmap para obter todos os campos de uma consulta. Cada tecla será o nome do campo, e seu respectivo valor será o valor associado.

 <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 objeto retornado por QueryFoObject () será classicamente clássico java.util.hashmap.

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

, portanto, poderíamos construir uma consulta com vários
Campos sem se preocupar com a estrutura que vai retornar.

Também podemos obter apenas um campo em uma lista.

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

e cada objeto da lista obtida a partir de QueryFlist () será um java.lang.string.

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

Naturalmente, nós poderia criar uma consulta que tenha como um objeto Hashmap e invocá-lo com um QueryFlist (). O resultado será uma lista onde cada elemento será um hashmap.

Gerenciando parâmetros

ibatis também permite que você defina os parâmetros que vão receber o consultas. Sua estrutura é muito semelhante aos programas dos resultados.

também podemos dispensar um javebean para enviar parâmetros. Para isso, usaremos um java.util.map. Todas as teclas serão acessadas como se fosse uma propriedade de um javabean

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

Associações

Um dos principais problemas de gerenciamento de banco de dados
relacionamentos usando objetos é a associação entre tabelas.

Crearemos Una Tabla Produto Con La Siguiente Estructura:

Campo

tipo

pr_id

autonumérico (Clave Principal)

Pr_nombre

varchar (30)

BR>

pr_precio

decimal

pr_stock

numérico entero

pr_categoria

numérico no nulo (Clave foránea de categoria)

crearemos el javabean con sus respeitosivas 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 Inserir > para manejo 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 um UNA Propiedad de Producto – Que Es de Clase Categoria. En casco Que la proieTAD
Categoria Fuera Nulo, Ibatis toma Toda la expresión
(Categoria.id) Como Nulo.

Probamos Insertar UN Objeto Produto:

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

e es necesario recalcar Que Ibatis No Agrega Automáticos Los
Objetos Asociados Que Não Existan EN LA Base de Dados. Es Decir, Si Se …
Crea OBJETO Categoria Y Se Asocia A UN Nuevo Objeto de
Produto, Al Hacer El Inserir () Solo Se Guidarán
Los Valores del Objeto Categoria Não Los del Objeto. / P>

Obteniendo Unicistro

Para Obtener Un Registro Mapeado PT
Objeto, Al < ResultMap > SE AGRGARÁ 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, par, par, para la, para la Categoria Se Tomará El
Campo Pr_Categoria Y Se Buscará Su Valor Del Select
GetCategoriaporid. Al Hacer Esto, SE INVOCARÁ A Dico – Select Y Se Le Pasará Como Parámetro El Valor de
PR_Categoria El Objeto Correspondente.

El Select Para Objetos de
Produto será muy simples:

 <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 DEFICIÊNCIA: Para Obtener UN PROPOSTO, IBATIS HARÁ DOS CONSULSAS: UNO PARA EL OTRO Para La Categoría. Si Fueran Varios Productos, Hará e Una Consultora por Los Productos Y N Consulsas por Cada Producto Pará – Obtener su Categoria.

Esto SE Pude Solucionar Haciendo UN Junte-se ao Modificando El < 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>

conclusão

con Ibatis SE Pude MAPEAR LAS CONSULTAS QUE NECESITAMOS PARA NUESTRO PROYECTO. La Sintaxis Que Se Seilice Para Manejo Los
Registros de la Base de Dados de Dados Fuerteme Aislada En La
Lódia de Negocio. Esto Nos Permite Tener UN CÓDigo
Limpio de Sentencias SQL. SI ES Necesario Hacer Alguna Modificación
en SQL, Bastará Con Editar El Xml Y No Una Clase En Java
EVITANDO LA COMPILACIÓN DE ESTA.

Leave a Comment

O seu endereço de email não será publicado. Campos obrigatórios marcados com *