ACCESO A DATOS

Ciclo DAM

IRENE CALDELAS
2º CURSO
Camino de la Miranda
 Tema 1. Introducción al acceso a
datos
1.Introducción
Iniciamos esta primera unidad del módulo Acceso a datos, en el
que veremos la gran variedad de métodos de acceso a datos que
tenemos en el panorama actual.
Los contenidos del módulo son eminentemente prácticos, y los
ejemplos estarán basados en Java. Utilizaremos como entorno de
programación NetBeans, por coherencia con otros módulos del
ciclo y por ser ambos gratuitos. Además, NetBeans es un entorno
muy potente y fácil de usar, si lo comparamos con otros entornos
de desarrollo.
Pero, ¿a qué nos referimos cuando hablamos de acceso a datos en
una aplicación informática?
Podemos afirmar que en la inmensa mayoría de aplicaciones
informáticas se pueden diferenciar, a grandes rasgos, en dos partes:
 Por un lado, el programa propiamente dicho, que realiza
las operaciones deseadas con los datos necesarios.
 Por otro lado, los datos con los que opera le programa.
Esos datos pueden ser obtenidos por el programa
mediante diversos métodos: leídos mediante teclado,
escaneados, leídos de algún soporte de almacenamiento
secundario, etc.
En la mayoría de los casos, cuando programamos, nos interesa que
el programa guarde los datos que le hemos introducido, o los
resultados que dicho programa haya obtenido, de manera que si el
programa termina su ejecución, los datos no se pierdan y puedan
ser recuperados posteriormente, es decir, persistan. Una forma
tradicional de hacer esto es mediante la utilización de ficheros o de
bases de datos que se guardarán en un dispositivo de memoria no
volátil (normalmente un disco).
Te habrás dado cuenta de que el almacenamiento en memoria
RAM, mediante variables o vectores, es temporal, los datos se
pierden cuando el programa termina. Quizás te habrá pasado
alguna vez que, debido a un apagón eléctrico, has perdido el
trabajo que estabas haciendo, que todavía no habías grabado. Los
datos que se guardan en almacenamiento secundario, como
ficheros o bases de datos, se denominan datos persistentes, porque
existen, o persisten más allá de la ejecución de la aplicación.
Ese almacenamiento secundario de datos que acabamos de
mencionar, habitualmente suele consistir en una base de datos
relacional, si bien, a veces, hay otros métodos de almacenamiento,
y por tanto, métodos de acceso a esos datos
De conocer esos tipos de almacenamiento y cómo acceder a ellos
es de lo que trata este módulo.
En esta unidad inicial, vas a ver una panorámica de los diversos
métodos de persistencia que encontramos en el mercado.
2.Acceso a datos
Hay diversas estrategias de acceso a datos para gestionar la
persistencia de los datos:
 Mediante ficheros.
 Bases de datos, que pueden ser:
o Relacionales,
o Orientadas a objetos,
o Objeto-relacionales.
 Mapeo objeto relacional (ORM).
 Bases de datos XML (eXtensible Markup Language).
 Componentes.
Al principio, en los primeros tiempos de la informática, los datos se
guardaban en ficheros convencionales. Con el tiempo, y la
experiencia de trabajar con dichos ficheros, se observaron los
inconvenientes de los ficheros, y para intentar solucionar los
inconvenientes que se observaron surgieron las bases de datos, que
entre otras ventajas permitían:
 Eliminar el problema de la información redundante.
 Eliminar información inconsistente.
 Globalizar o centralizar la información.
 Garantizar el mantenimiento de la integridad en la
información. Únicamente se almacena la información
correcta. Independencia de datos. La
 independencia de datos implica una separación entre
programas y datos, es decir, se pueden hacer cambios en
la información que contiene la base de datos, o tener
acceso a la base de datos de diferente manera, sin tener
que hacer cambios en las aplicaciones o en los
programas.
3. Qué estrategia o método de
acceso usar
Posteriormente, con la aparición y expansión de la programación
orientada a objetos, empezaron a surgir las bases de datos
orientadas a objetos, y también se ampliaron algunas bases de datos
relacionales, añadiéndoles extensiones de orientación a objetos.
Entonces ¿qué método de acceso a datos es mejor? ¿Cuál deberías
utilizar en la próxima aplicación que construyas?
Pues..., no hay una respuesta fácil para esas preguntas, no se puede
afirmar que haya un método que sea el mejor de manera absoluta.
Más bien, la cuestión es tener claro qué tipo de aplicación hay que
construir y, según eso, estudiar qué tipo de sistema de
almacenamiento será mejor usar: si una base de datos orientada a
objetos, o una base de datos XML, etc.
Conociendo el funcionamiento de las diferentes alternativas
podemos comparar sus prestaciones al problema de la persistencia
concreto que se nos presente. Cada una de las tecnologías tiene su
propio origen y filosofía para alcanzar el mismo fin y, por esta
razón, no es fácil analizar sus ventajas y desventajas frente a las
demás alternativas.
Por poner un ejemplo, lo más sencillo posible: si voy a crear una
base de datos para guardar mi colección de vídeos, probablemente
no me va a interesar utilizar una base de datos Oracle, sino un
producto mucho más barato, y sencillo de instalar y mantener.
4.Ficheros
En las antiguas aplicaciones informáticas, antes de que surgieran
las bases de datos, la información se guardaba en ficheros.
Así, por ejemplo, una aplicación que guardaba los datos de
personas almacenaba dichos datos en un fichero convencional cuyo
contenido bien podía ser este:
Antonio Pérez Pérez 30 C/ Morales nº 11 Madrid Madrid
Feliciano Gómez Sander 25 C/ Terreros nº 121 Vitoria Vitoria
Arturo Bueno Hernández 46 C/ Cocoliso nº 43 Murcia Murcia
...
Esto tenía como efecto, que el programador de las aplicaciones que
usaran ese fichero tuviera que construir el programa conociendo
detalladamente las posiciones de los datos, para saber desde qué
posición hasta qué otra posición, se guardaba el nombre y
apellidos, etc. Además, tendría que controlar si se guardan filas de
datos duplicadas, y así un montón de inconvenientes. Por eso,
cuando surgieron las bases de datos, se empezó a dejar de usar los
ficheros convencionales.
Pero bien es cierto, que aún en las más modernas aplicaciones, a
veces necesitamos un simple fichero para guardar información,
como por ejemplo un fichero de configuración, o un fichero log. Es
decir, no siempre nos hace falta una base de datos para almacenar
la información.
En Java, como en otros lenguajes de programación, hay diversas
clases para el manejo de ficheros, pues, como hemos dicho, a veces
son muy útiles. Para guardar poca información, es mejor usarlos
que usar otro método.
4.1. Uso ficheros en la
actualidad
Hay que tener en cuenta, que los ficheros en sí, para grabar la
información del modo que poníamos como ejemplo anteriormente,
en el ejemplo de las personas, ya no se usan. Pero, sí que se usan
ficheros que guardan datos siguiendo un patrón o estructura bien
definida, en otros métodos de almacenamiento, como por ejemplo
en ficheros y en bases de datos XML.
De especial interés y uso cada vez más extendido, son los ficheros
XML. Éstos son archivos de texto que por consiguiente no
necesitan un software propietario para ser interpretados, como
ocurre con la mayoría de los archivos binarios, y tienen
normalmente la extensión xml.
También debemos tener en cuenta, que las bases de datos
relativamente modernas, como son las bases de datos XML,
guardan sus datos empleando ficheros xml.
Por eso, en muchas ocasiones se recurre a utilizar este tipo de
soluciones, el uso de ficheros en vez de bases de datos, y en
particular de ficheros XML cuando se necesita intercambiar
información a través de varias plataformas de hardware o de
software, o de varias aplicaciones. A veces se exporta de una base
de datos a ficheros XML para trasladar la información a otra base
de datos que leerá esos ficheros XML.
Por esta razón se emplea XML en tecnologías de comunicación
como, por ejemplo, en WML (lenguaje de formato inalámbrico) y
WAP (protocolo de aplicaciones inalámbricas).
La fácil estructuración de la información en los ficheros XML ha
permitido que surjan muchas librerías de conversión de la
información almacenada a otros formatos como a PDF, texto, hojas
de cálculo, etc. Hay muchos productos propietarios y de código
abierto.
5.Bases de datos
Quizás hayas estudiado ya el módulo de bases de datos. Tanto si es
así como si no, recordamos aquí qué es un sistema de bases de
datos. Es:
 Un sistema de información orientado hacia los datos, que
pretende recuperar y almacenar la información de manera
eficiente y cómoda.
 Surge en un intento de resolver las dificultades del
procesamiento tradicional de datos, teniendo en cuenta
que los datos suelen ser independientes de las
aplicaciones.
5.1. Introducción
Las ventajas que aportan los sistemas de bases de datos respecto a
los sistemas de archivos convencionales son:
 Independencia de los datos respecto de los
procedimientos. El usuario tiene una visión abstracta de
los datos, sin necesidad de ningún conocimiento sobre la
implementación de los ficheros de datos, índices, etc.
Esto supone un gran ahorro en los costes de
programación, de forma que la modificación de la
estructura de los datos no suponga un cambio en los
programas y viceversa. Sin ella, el mantenimiento de la
base de datos ocuparía el 50% de los recursos humanos
dedicados al desarrollo de cualquier aplicación.
 Disminución de las redundancias y en consecuencia,
  Disminución de la posibilidad de que se produzca
inconsistencia de datos.
 Mayor integridad de los datos.
 Mayor disponibilidad de los datos.
 Mayor seguridad de los datos.
 Mayor privacidad de los datos.
 Mayor eficiencia en la recogida, codificación y entrada
en el sistema.
 Lo que se suele denominar interfaz con el pasado y
futuro: una base de datos debe estar abierta a reconocer
información organizada físicamente por otro software.
 Compartición de los datos. Los datos deben poder ser
accedidos por varios usuarios simultáneamente, teniendo
previstos procedimientos para salvaguardar la integridad
de los mismos.
Podemos afirmar generalizando, que se usa un sistema de ficheros
convencional cuando la cantidad de datos a guardar es tan
reducida que no justifica las desventajas del uso de los sistemas de
bases de datos. Por ejemplo, para guardar los datos del resultado de
la instalación de un programa, usamos un fichero de texto, no se
guardan los datos en una base de datos.
5.2. Bases de datos relacionales
Probablemente habrás cursado ya el módulo de bases de datos, si es
así, e incluso si no lo es, quizás sepas que el modelo de bases de
datos relacional fue propuesto en 1969 por Edgar Codd.
El propósito del modelo relacional es proporcionar un método
declarativo para especificar datos y consultas. Así, en el diseño de
la base de datos establecemos qué información contendrá dicha
base de datos, luego recuperaremos la información que queramos,
y dejamos al software del sistema gestor de la base de datos que se
ocupe de: describir las estructuras de datos para almacenarlos, y
gestionar los procedimientos de recuperación para obtener las
consultas deseadas.
Las bases de datos relacionales son adecuadas para manejar
grandes cantidades de datos, compartir datos entre programas,
realizar búsquedas rápidas, etc. Pero tienen como desventaja
fundamental que no presentan un buen modelo de las relaciones
entre los datos, ya que todo se representa como tablas
bidimensionales, o sea, en filas y columnas.
Podemos decir de las bases de datos relacionales que:
 Están muy extendidas.
 Son muy robustas.
 Permiten interoperabilidad entre aplicaciones.
 Permiten una forma de compartir datos entre
aplicaciones.
 Son el común denominador de muchos sistemas y
tecnologías. Una base de datos puede ser utilizada en
programas realizados en Java, o en C++, etc.
Otros modelos tradicionales
Cuando se estudian las bases de datos relacionales, se suelen
mencionar también los modelos jerárquico y en red. Algunos
sistemas antiguos utilizan todavía estas arquitecturas, en centros de
datos donde se manejan grandes volúmenes de información y la
complejidad de los sistemas hace prohibitivo el coste que
supondría migrar a sistemas que utilizaran otro modelo como el
relacional.
El modelo relacional fue el primer modelo de bases de datos
definido de manera formal. Posteriormente, se formularon modelos
informales para describir bases de datos jerárquicas (el modelo
jerárquico) y bases de datos en red (el modelo en red). Ambas, las
bases de datos jerárquicas y en red existían antes que las bases de
datos relacionales, pero fueron descritas como modelo después
de que el modelo relacional fuera definido.
5.3. Bases de datos orientadas a
objetos (i)
El origen de las Bases de datos orientadas a objetos (en adelante:
BDOO) se debe básicamente a las siguientes razones:
 La existencia de problemas al representar cierta
información y modelar ciertos aspectos del mundo real.
Los modelos clásicos permiten representar gran cantidad
de datos, pero las operaciones y representaciones que se
pueden realizar sobre ellos son bastante simples.
 Pasar del modelo de objetos al modelo relacional, para
almacenar la información, genera dificultades que en el
caso de las BDOO no surgen, ya que el modelo es el
mismo. Es decir, los datos de los programas escritos en
lenguaje orientado a objetos se pueden almacenar
directamente, sin conversión alguna, en las BDOO.
Los sistemas de bases de datos orientadas a objetos soportan un
modelo de objetos puro, ya que no están basados en extensiones
de otros modelos más clásicos como el relacional.
Por ello, una característica general es que el lenguaje de
programación y el esquema de la base de datos utilizan las
mismas definiciones de tipos.
5.3.1. Bases de datos orientadas a
objetos (ii)
El acceso a los datos puede ser más rápido con las bases de datos
orientadas a objetos que con las bases de datos tradicionales porque
no hay necesidad de utilizar las uniones o joins, que sí se necesitan
en los esquemas relacionales tabulares. Esto se debe a que un
objeto puede recuperarse directamente sin una búsqueda,
simplemente siguiendo punteros.
Cada vez más, las necesidades de las aplicaciones actuales con
respecto a las bases de datos son:
 Soporte para objetos complejos y datos multimedia.
 Jerarquías de objetos o tipos y herencia.
 Gestión de versiones.
 Modelos extensibles mediante tipos de datos definidos
por el usuario.
 Integración de los datos con sus procedimientos
asociados.
 Manipulación navegacional (en vez de declarativa) y de
conjunto de registros.
 Interconexión e interoperabilidad.
Como ejemplos de Sistemas Gestores de Bases de datos Orientados
a Objetos podemos señalar:
 Jasmine
 ObjectStore
 GemStone

5.4. Comparativa entre bases
de datos relaciones y
orientadas a objetos
En numerosos bancos de pruebas realizados para comparar los
sistemas de bases de datos orientados a objetos (ODBMS) y los
sistemas de bases de datos relacionales (RDBMS), se ha mostrado
que los ODBMS pueden ser superiores para ciertos tipos de tareas.
La explicación a esto es que muchas operaciones se realizan
utilizando interfaces navegacionales más que declarativos, y el
acceso a datos navegacional es normalmente implementado muy
eficientemente.
Un buen argumento a favor de las bases de datos orientadas a
objetos es la transparencia (no ensucia la construcción de una
aplicación). El desarrollador así se debe preocupar de los objetos
de su aplicación, en lugar de cómo los debe almacenar y recuperar
de un medio físico.
Podemos decir que las ventajas de un SGBDOO frente a las
relacionales son:
 Permiten mayor capacidad de modelado. El modelado
de datos orientado a objetos permite modelar el mundo
real de una manera mucho más fiel. Esto se debe a:
o un objeto permite encapsular tanto un estado
como un comportamiento
o un objeto puede almacenar todas las relaciones
que tenga con otros objetos
o los objetos pueden agruparse para formar
objetos complejos (herencia).
 Extensibilidad, debido a que:
o Se pueden construir nuevos tipos de datos a
partir de los ya existentes.
o Podemos agrupar propiedades comunes de
diversas clases e incluirlas en una superclase,
lo que reduce la redundancia.
o Tenemos reusabilidad de clases, lo que
repercute en una mayor facilidad de
mantenimiento y un menor tiempo de
desarrollo.
 Disposición de un lenguaje de consulta más expresivo.
El acceso navegacional desde un objeto al siguiente es la
forma más común de acceso a datos en un sistema gestor
orientado a objetos. Mientras que SQL utiliza el acceso
declarativo. El acceso navegacional es más adecuado
para gestionar operaciones tales como consultas
recursivas, etc.
 Adaptación a aplicaciones avanzadas de base de datos.
Hay muchas áreas en las que las bases de datos
relacionales no han tenido excesivo éxito, como es el
caso de en sistemas de diseño CAD, CASE, sistemas
multimedia, etc. en los que las capacidades de modelado
de los SGBDOO han hecho que esos sistemas sí resulten
efectivos para este tipo de aplicaciones.
 Prestaciones. Los sistemas gestores de bases de datos
orientadas a objetos proporcionan mejoras significativas
de rendimiento con respecto a los SGBD relacionales.
Aunque hay autores, que han argumentado que los
bancos de prueba, usados en dichas pruebas, están
dirigidos a aplicaciones de ingeniería donde los
SGBDOO son más adecuados. También está demostrado,
que los SGBDR tienen un rendimiento mejor que los
SGBDOO en las aplicaciones tradicionales de bases de
datos como el procesamiento de transacciones en línea
(OLTP).
 Reglas de acceso. En las bases de datos relacionales, a
los atributos se accede y se modifican a través de
operadores relacionales predefinidos. En las orientadas a
objetos se procede mediante las interfaces que se creen a
tal efecto de las clases. Desde este punto de vista, los
sistemas orientados a objetos dan independencia a cada
objeto que el sistema relacional no permite.
 Clave. En el modelo relacional, las claves primarias
generalmente tienen una forma representable en texto, sin
embargo, los objetos no necesitan una representación
visible del identificador.
5.4.1. Desventajas de las bases de
datos orientadas a objetos
frente a las relaciones
Como desventajas o puntos débiles de las BBDDOO respecto a las
relacionales podemos mencionar:
 La reticencia del mercado, tanto para desarrolladores
como usuarios, a este tipo de bases de datos.
 Carencia de un modelo de datos universal. No hay
ningún modelo de datos que esté universalmente
aceptado para los SGBDOO y la mayoría de los modelos
carecen de una base teórica. El modelo de objetos aún no
tiene una teoría matemática coherente que le sirva de
base.
 Carencia de experiencia. Al ser una tecnología
relativamente nueva, todavía no se dispone del nivel de
experiencia del que se dispone para los sistemas
relacionales.
 Panorama actual. Tanto los sistemas gestores de bases de
datos como los sistemas gestores de bases de datos
objeto-relacionales están muy extendidos. SQL es un
estándar aprobado y ODBC y JDBC son estándares de
facto. Además, el modelo relacional tiene una sólida base
teórica y los productos relacionales disponen de muchas
herramientas de soporte que sirven tanto para
desarrolladores como para usuarios finales.
 Dificultades en optimización. La optimización de
consultas necesita realizar una compresión de la
implementación de los objetos, para poder acceder a la
base de datos de manera eficiente. Sin embargo, esto
compromete el concepto de encapsulación.
5.5. Bases de datos objeto-
relacionales
Entendemos Base de Datos Objeto Relacional (BDOR), una base
de datos que ha evolucionado desde el modelo relacional a otro
extendido que incorpora conceptos del paradigma orientado a
objetos. Por tanto, un Sistema de Gestión ObjetoRelacional
(SGBDOR) contiene ambas tecnologías: relacional y de objetos.
En una Base de Datos Objeto Relacional el diseñador puede crear
sus propios tipos de datos y crear métodos para esos tipos de datos.
Por ejemplo, podríamos definir un tipo de la siguiente manera:
CREATE TYPE persona_t AS OBJECT (
nif VARCHAR2(9),
nombre VARCHAR2(30),
direccion VARCHAR2(40),
telefono VARCHAR2(15),
 fecha_nac DATE);
Por poner un ejemplo, si consideramos la base de datos Oracle,
debido a los requerimientos de las nuevas aplicaciones, el sistema
de gestión de bases de datos relacional desde versión 8i fue
extendido con conceptos del modelo de bases de datos orientadas a
objetos. De esta manera, aunque las estructuras de datos que se
utilizan para almacenar la información siguen siendo tablas, los
diseñadores pueden utilizar muchos de los mecanismos de
orientación a objetos para definir y acceder a los datos. Se reconoce
el concepto de objetos, de tal manera que un objeto tiene un tipo, se
almacena en cierta fila de cierta tabla y tiene un identificador único
(OID). Estos identificadores se pueden utilizar para referenciar a
otros objetos y así representar relaciones de asociación y de
agregación.
La ventaja de este tipo de base de datos es que los usuarios pueden
pasar sus aplicaciones actuales sobre bases de datos relaciones este
nuevo modelo sin tener que reescribirlas. Más tarde, se pueden ir
adaptando las aplicaciones y bases de datos para que utilicen las
funciones orientadas a objetos.
Con las Bases de Datos Objeto-Relacional se amplía el modelo
relacional destacando las siguientes aportaciones:
 Se aumentan la variedad en los tipos de datos,
o se pueden crear nuevos tipos de datos que
permitan construir aplicaciones complejas con
una gran riqueza de dominios. Se soportan
tipos complejos como: registros, conjuntos,
referencias, listas, pilas, colas y vectores.
 Hay extensiones en el control de la Semántica de datos
Objeto-Relacionales:
o Se pueden crear procedimientos almacenados y
funciones que tengan un código en algún
lenguaje de programación, como por ejemplo:
SQL, Java, C, etc.
 Se pueden compartir varias librerías de clases ya
existentes, esto es lo que conocemos como reusabilidad.
Como productos comerciales de bases de Datos Objeto-Relacional
podemos destacar:

DB2 Universal Database de IBM (International Business
Machines).
 Universal Server de Informix (ahora de IBM),


INGRES II, de Computer Associates.
ORACLE de Oracle Corporation,
 SyBASE
Como productos de código abierto, destacamos PostGreSQL.
6.Acceso a bases de datos
mediante conectores.
Para gestionar la información de las bases de datos hay unos
estándares que facilitan a los programas informáticos manipular la
información almacenada en ellas.
En Java existe un API basado en estos estándares que permite al
desarrollar aplicaciones, que se pueda acceder a bases de datos
relacionales: JDBC (Java Database Connectivity, conectividad de
bases de datos de Java).
La mayoría de las aplicaciones importantes de una empresa están
respaldadas por una arquitectura normalizada y optimizada de
bases de datos relacionales. Tradicionalmente, dichas aplicaciones
están basadas en sentencias SQL con las cuales se gestionan todos
los datos que manejan.
Este modelo continúa teniendo una gran importancia estratégica y
es la base para el continuo crecimiento del mapeo Objeto-
Relacional (O/R) y está asociado a los mecanismos de persistencia.
Un driver JDBC es un componente software que posibilita a una
aplicación Java interaccionar con una base de datos.
El API JDBC define interfaces y clases para escribir aplicaciones
de bases de datos en Java realizando conexiones de base de datos.
Mediante JDBC el programador puede enviar sentencias SQL, y
PL/SQL a una base de datos relacional. JDBC permite embeber
SQL dentro de código Java.
La ilustración muestra una representación de los diferentes
mecanismos de mapeo O/R y cómo se relacionan con el código de
la aplicación y con los recursos de datos relacionados. Se observa
claramente la función crítica que desempeña el driver JDBC puesto
que está situado en la base de cada uno de los marcos de trabajo.
La ventaja de usar conectores JDBC es que independiza de la base
de datos que utilice.
No obstante hay un trabajo de traducción para mapear los campos
devueltos por cada consulta a la colección de objetos
correspondiente. Y hay que trabajar las sentencias de actualización,
inserción y eliminación para cada uno de los campos. Esto
constituye una razón para tratar de buscar alternativas menos
costosas en tiempo de desarrollo.
7.Mapeo objeto relacional
(ORM)
En los inicios de la programación, los programas se desarrollaban
con la llamada programación imperativa. De hecho, y como sabes,
la programación orientada a objetos surgió unos años después.
Con la expansión de la programación orientada a objetos, se da la
circunstancia de que las bases de datos relacionales se siguen
utilizando hoy en día de manera masiva, por lo que muchas
aplicaciones se desarrollan con POO pero los datos, no se
almacenan en bases de datos orientadas a objetos, sino en las bases
de datos relacionales.
El sistema más extendido en las empresas hoy en día para guardar
la información de sus aplicaciones es el uso de una base de datos
relacional. Tradicionalmente, dichas aplicaciones están basadas en
sentencias SQL con las cuales se gestionan todos los datos que
manejan. Este sistema es la base para el continuo crecimiento del
mapeo Objeto-Relacional (O/R) y está asociado a los mecanismos
de persistencia.
Cuando se programan sistemas orientados a objetos, utilizando una
base de datos relacional, los programadores invierten gran cantidad
de tiempo en desarrollar los objetos persistentes, o sea, convertir
los objetos del lenguaje de programación a registros de la base de
datos. Igualmente, también pasan bastante tiempo implementando
la operación inversa, es decir, convirtiendo los registros en objetos.
El mapeo objeto-relacional (Object-Relational Mapping, o ORM)
consisten en una técnica de programación para convertir datos
entre el sistema de tipos utilizado en un lenguaje de programación
orientado a objetos y el sistema utilizado en una base de datos
relacional.
Cuando se trabaja con programación orientada a objetos y con
bases de datos relacionales, es fácil observar que estos son dos
paradigmas diferentes. El modelo relacional trata con relaciones y
conjuntos, es de naturaleza matemática. Por el contrario, el
paradigma orientado a objetos trata con objetos, atributos y
asociaciones de unos con otros.
Cuando se requiere almacenar la información de los objetos
utilizando una base de datos relacional se comprueba que hay un
problema de compatibilidad entre estos dos paradigmas, el llamado
desfase objeto-relacional.
Por ello, para ahorrar trabajo al programador, se puede utilizar un
framework que se encargue de realizar estas tareas de modo
transparente, de modo que el programador no tenga por qué usar
JDBC ni SQL y la gestión del acceso a base de datos esté
centralizada en un componente único permitiendo su reutilización.
7.1. Capa de persistencia y
framework de mapeo
La capa de persistencia de una aplicación es la pieza que permite
almacenar, recuperar, actualizar y eliminar el estado de los objetos
que necesitan persistir en un sistema gestor de datos.
En el caso del mapeo objeto-relacional, un ORM es una capa que
permite relacionar objetos con un modelo de datos relacional,
ocultando todo el mecanismo de conexión al motor de base de
datos, y también no teniendo que escribir las sentencias SQL
necesarias para la gestión de los datos.
La capa de persistencia traduce entre los dos modelos de datos:
desde objetos a registros y desde registros a objetos. Así, si el
programa quiere grabar un objeto, entonces llama al motor de
persistencia, el motor de persistencia traduce el objeto a registros
y llama a la base de datos para que guarde estos registros.
De este modo el programa sólo ve que puede guardar y recuperar
objetos, como si estuviera programado para una base de datos
orientada a objetos. Y la base de datos sólo ve que guarda y
recupera registros como si el programa estuviera dirigiéndose a ella
de forma relacional.
Dispones de múltiples alternativas como desarrollador en Java
cuando pretendas trabajar con mapeadores O/R. Hay tres
comunidades que están implicadas en el mundo de la persistencia
O/R de Java de forma activa:
 Organizaciones basadas en el estándar,
 Comunidades código abierto (open source) y
 Grupos comerciales.
Las comunidades open source incluyen importantes tecnologías,
entre ellas Hibernate y el Spring framework.
Hibernate es una herramienta de Mapeo objeto-relacional (ORM)
para la plataforma Java (y disponible también para .Net con el
nombre de NHibernate) que facilita el mapeo de atributos entre una
base de datos relacional tradicional y el modelo de objetos de una
aplicación, mediante archivos declarativos (XML) o anotaciones en
los beans de las entidades que permiten establecer estas relaciones.
Spring es un framework para el desarrollo de aplicaciones y
contenedor de inversión de control, de código abierto para la
plataforma Java.
Las alternativas más importantes basadas en el estándar, son EJB
3.2 y JDO 3.1.
Entre las implementaciones comerciales se puede resaltar TopLink
que es un paquete de Mapeo objeto-relacional (ORM) para
desarrolladores Java. Provee un marco de trabajo para almacenar
objetos Java en una base de datos relacional, o convertir objetos
Java a archivos XML.
Cada uno de los mecanismos de mapeo O/R tiene una
dependencia particular en el conector JDBC para poder
comunicarse con la base de datos de una forma eficiente. Si el
conector JDBC que participa en la comunicación no es óptimo, la
posible gran eficiencia de cualquier framework quedará debilitada.
Por tanto, seleccionar el driver JDBC que mejor se adapte a la
aplicación es esencial a la hora de construir un sistema eficiente en
el que intervenga un mecanismo de mapeo O/R.
*Insertar imagen
8.Bases de datos XML
Se define XML como: eXtensible Markup Language (lenguaje de
marcado extensible).
Es una especificación del World Wide Web Consortium (W3C).
Debido a las limitaciones de la tecnología de bases de datos
relacionales están surgiendo nuevas clases de bases de datos como
son las bases de datos XML.
Estas bases de datos almacenan los datos estructurados como XML
sin la necesidad de traducir los datos a una estructura relacional o
de objeto.
Podemos distinguir entre:
  Bases de datos nativas XML: consiste en un modelo
lógico para documentos XML. El Sistema Gestor de
Base de Datos correspondiente almacena y recupera
documentos de acuerdo a dicho modelo.
o Productos ejemplo de esa filosofía son: eXist,
Apache Xindice, Berkeley dbXML....
 Bases de datos compatibles con XML (XML-
enabled): son bases de datos, generalmente objeto-
relacionales, que admiten entradas de datos en forma de
XML y proporcionan salidas en este mismo formato.
o Podemos citar productos como: Oracle, DB2
(Viper),...
Las bases de datos XML nativas permiten trabajar con XQL
(eXtensible Query Language), el cuál sirve un propósito similar a
SQL en una base de datos relacional.
El trabajo con bases de datos XML nativas involucra dos pasos
básicos:
 Describir los datos mediante Definiciones de Tipos de
Datos (Document Type Definitions, DTD) o esquemas
XML y
 Definir un nuevo esquema de base de datos XML nativa
o Mapa de Datos a usar para almacenar y obtener datos.
9.Desarrollo de
componentes
La expansión, en los últimos años, de Internet y el comercio
electrónico ha llevado a la necesidad de adoptar nuevas tecnologías
y nuevos requisitos de desarrollo en las aplicaciones informáticas.
Al principio de la informática, los ordenadores eran caros y la
mano de obra de los programadores asequible. Con el paso del
tiempo los ordenadores son baratos y la mano de obra de los
programadores suele ser cara. Además, los requisitos de las
aplicaciones informáticas son cada vez más complejos. Por ello,
aparecieron las técnicas orientadas a objetos, para, entre otras
cosas, intentar programar de manera que el código que se
desarrolle pueda ser reutilizable.
9.1. Definición de componente
Un componente es una unidad de software que realiza una función
bien definida y posee una interfaz bien definida.
Un componente software posee interfaces especificadas
contractualmente, pudiendo ser desplegado independientemente y
puede interaccionar con otros componentes para formar un sistema.
Un interfaz es un punto de acceso a los componentes: permite a los
clientes acceder a los servicios proporcionados por un componente.
La idea de dividir u organizar en trozos el software, o sea, dividirlo
en componentes surge para reducir la complejidad del software.
Así se permite la reutilización y se acelera el proceso de
ensamblaje del software.
Los creadores de componentes pueden especializarse creando
objetos cada vez mas complejos y de mayor calidad.
La interoperabilidad entre componentes de distintos fabricantes:
 Aumenta la competencia.
 Reduce los costes.
 Facilita la construcción de estándares.
Por tanto, así el software se hace cada vez más rápido, de mejor
calidad y a menor coste incluso de mantenimiento.
Un componente software también debe especificar sus necesidades
para funcionar correctamente, lo que se denominan las
dependencias de contexto:
 Interfaces requeridas.
 Entorno de ejecución: máquina necesaria, sistema
operativo a utilizar, etc.
En el entorno Java, contamos con los JavaBeans.
Los JavaBeans son un modelo de componentes creado por Sun
Microsystems para la construcción de aplicaciones en Java.
9.2. JavaBeans
El origen de los JavaBeans lo podemos encontrar en un par de
necesidades que Java tenía:
 Disponer de una tecnología de objetos y componentes
reutilizables.
 Mejorar el proceso para crear interfaces de usuario,
acercándose a la facilidad de uso que otros productos
permitían como Visual Basic de Microsoft.
Un JavaBean es un componente software reutilizable basado en la
especificación JavaBean de Sun (ahora Oracle) que se puede
manipular visualmente con una herramienta de desarrollo.
Hay una serie de propiedades que presenta un JavaBean:
 Portabilidad: uno de los principales objetivos de los
JavaBeans es proporcionar una arquitectura neutral de
componentes, es decir, que los beans puedan utilizarse en
otras plataformas y entornos.
 Reusabilidad: son componentes reutilizables, la filosofía
es que estos componentes puedan usarse como bloques
en la construcción de aplicaciones complejas.
 Introspección: los IDE reconocen ciertas pautas de
diseño, nombres de las funciones miembros o métodos y
definiciones de las clases, permitiendo a la herramienta
de programación mirar dentro del bean y conocer sus
propiedades y comportamiento.
 Personalización: en tiempo de diseño, con el IDE que se
utilice, se pueden modificar las características de
apariencia y comportamiento de un bean.
 Persistencia: un bean puede guardar su estado y
recuperarlo posteriormente. Esta capacidad se logra
mediante la serialización. Cuando un ejemplar de bean se
serializa se convierte en un flujo de datos que se
almacenará en algún sitio, probablemente en un fichero.
Cualquier applet, aplicación o herramienta que utilice el
bean puede restaurarlo mediante la deserialización.
 Comunicación entre eventos: Los eventos constituyen
un mecanismo de notificación entre objeto fuente y
objeto(s) receptor(es). Las herramientas de desarrollo
pueden examinar un bean para determinar qué eventos
puede enviar y cuáles puede recibir.
 Tema 2. Manejo de ficheros
1.Introducción
Si estás estudiando este módulo, es probable que ya hayas
estudiado el de programación, por lo que no te serán desconocidos
muchos conceptos que se tratan en este tema.
Ya sabes que cuando apagas el ordenador, los datos de la memoria
RAM se pierden. Un ordenador utiliza ficheros para guardar los
datos. Piensa que los datos de las canciones que oyes en mp3, las
películas que ves en formato avi, o mp4, etc., están, al fin y al cabo,
almacenadas en ficheros, los cuales están grabados en un soporte
como son los discos duros, DVD, pendrives, etc.
Se llama a los datos que se guardan en ficheros datos persistentes,
porque persisten más allá de la ejecución de la aplicación que los
trata. Los ordenadores almacenan los ficheros en unidades de
almacenamiento secundario como discos duros, discos ópticos, etc.
En esta unidad veremos, entre otras cosas, cómo hacer con Java las
operaciones de crear, actualizar y procesar ficheros.
A las operaciones, que constituyen un flujo de información del
programa con el exterior, se les conoce como Entrada/Salida (E/S).
Las operaciones de E/S en Java las proporciona el paquete estándar
de la API de Java denominado java.io que incorpora interfaces,
clases y excepciones para acceder a todo tipo de ficheros.
La librería java.io contiene las clases necesarias para gestionar las
operaciones de entrada y salida con Java. Estas clases de E/S las
podemos agrupar fundamentalmente en:
 Clases para leer entradas desde un flujo de datos.
 Clases para escribir entradas a un flujo de datos.
 Clases para operar con ficheros en el sistema de ficheros
local.
 Clases para gestionar la serialización de objetos.
java.nio (Non- Blocking I/O) fue introducido en el API de Java
desde la versión 1.4 como extensión eficiente a los
paquetes java.io y java.net. Java NIO ofrece una forma diferente de
trabajar con IO que las API de IO estándar. Se basa en el “Buffer”
y el “Channel”.
java.io vs java.nio
 Depende de lo que necesitemos pueden ser
complementarios y utilizaremos conjuntamente ambos
paquetes.
 java.nio permite manejar múltiples canales (archivos o
conexiones de red) con uno o unos pocos hilos. 
 En java.nio el procesamiento de datos es más complicado
que usar los streams bloqueantes de java.io
 java.nio es la opción si necesito manejar cientos de
conexiones (canales) abiertas y en cada una manejar una
pequeña cantidad de datos. 
 java.io es la opción si voy a manejar pocas conexiones
con un alto ancho de banda (envío mucha información a
la vez)
 Hasta JSE7 java.io.File era la clase utilizada para realizar
operaciones I/O con archivos
  Esta clase tenía limitaciones como:
o Muchos métodos no lanzaban excepciones por
lo que era muy complicado detectar y resolver
errores
o No permitía manejar enlaces simbólicos
o Presenta problemas de escalabilidad.
Directorios largos provocaban problemas de
memoria e incluso de denegación de servicio
 El paquete java.nio.file incorporado a partir de JSE7
resuelve estos problemas. 
 Es el que debemos usar para trabajar con archivos
independientemente de si realizamos I/O con streams
(java.io) ó con buffers y channels (java.nio)
2.Clases asociadas a las
operaciones de gestión
de ficheros y directorios
En efecto, tal y como dicen Ana y Antonio, hay bastantes métodos
involucrados en las clases que en Java nos permiten manipular
ficheros y carpetas o directorios.
Vamos a ver la clase File que nos permite hacer unas cuantas
operaciones con ficheros, también veremos cómo filtrar ficheros, o
sea, obtener aquellos con una característica determinada, como
puede ser que tengan la extensión .odt, o la que nos interese, y por
último, en este apartado también veremos como crear y eliminar
ficheros y directorios.
2.1. Clase File
La clase File proporciona una representación abstracta de ficheros
y directorios.
Esta clase, permite examinar y manipular archivos y directorios,
independientemente de la plataforma en la que se esté trabajando:
Linux, Windows, etc.
Las instancias de la clase File representan nombres de archivo, no
los archivos en sí mismos.
El archivo correspondiente a un nombre puede ser que no exista,
por esta razón habrá que controlar las posibles excepciones.
Un objeto de clase File permite examinar el nombre del archivo,
descomponerlo en su rama de directorios o crear el archivo si no
existe, pasando el objeto de tipo File a un constructor adecuado
como FileWriter(File f), que recibe como parámetro un objeto File.
Para archivos que existen, a través del objeto File, un programa
puede examinar los atributos del archivo, cambiar su nombre,
borrarlo o cambiar sus permisos. Dado un objeto File, podemos
hacer las siguientes operaciones con él:
 Renombrar el archivo, con el método renameTo(). El
objeto File dejará de referirse al archivo renombrado, ya
 que el String con el nombre del archivo en el objeto File no
cambia.
 Borrar el archivo, con el método delete(). También, con
deleteOnExit() se borra cuando finaliza la ejecución de la
máquina virtual Java.
 Crear un nuevo fichero con un nombre único. El método
estático createTempFile() crea un fichero temporal y
devuelve un objeto File que apunta a él. Es útil para crear
archivos temporales, que luego se borran, asegurándonos
tener un nombre de archivo no repetido.
 Establecer la fecha y la hora de modificación del archivo
con setLastModified(). Por ejemplo, se podría hacer: new
File("prueba.txt").setLastModified(new Date().getTime()); para
establecerle la fecha actual al fichero que se le pasa como
parámetro, en este caso prueba.txt.
 Crear un directorio, mediante el método mkdir(). También
existe mkdirs(), que crea los directorios superiores si no
existen.
 Listar el contenido de un directorio. Los métodos list() y
listFiles() listan el contenido de un directorio. list() devuelve
un vector de String con los nombres de los archivos,
listFiles() devuelve un vector de objetos File.
 Listar los nombres de archivo de la raíz del sistema de
archivos, mediante el método estático listRoots().
La clase proporciona los siguientes constructores para crear
objetos File:
 public File(String nombreFichero|path);
 public File(String path, String nombreFichero|path);
 public File(File path, String nombreFichero|path);
La ruta o path puede ser absoluta o relativa.
Ejemplos utilizando el primer constructor:
 File f = new File("ficheros/personas.dat");
Crea un Objeto File asociado al fichero personas.dat que
se encuentra en el directorio ficheros dentro del
directorio actual.  En este caso se indica la ruta relativa
tomando como base el directorio actual de trabajo. Se
supone que el fichero personas.dat se encuentra en el
directorio ficheros. A su vez el directorio ficheros se
encuentra dentro del directorio actual de trabajo.
 File f = new File("c:/ficheros/personas.dat"); 
Crea un Objeto File asociado al fichero personas.dat
dando la ruta absoluta:
Ejemplos utilizando el segundo constructor:
En este caso se crea un objeto File cuya ruta (absoluta o relativa) se
indica en el primer String.
 File f = new File("ficheros", "personas.dat" ); 
Crea un Objeto File asociado al fichero personas.dat que
se encuentra en el directorio ficheros dentro del
directorio actual. En este caso se indica la ruta relativa
tomando como base el directorio actual de trabajo.
Ejemplos utilizando el tercer constructor:
Este constructor permite crear un objeto File cuya ruta se indica a
través de otro objeto File.
 File ruta = new File("ficheros");
File f = new File(ruta, "personas.dat" );
Crea un Objeto File asociado al fichero personas.dat que
se encuentra en el directorio ficheros dentro del
directorio actual.
Debemos tener en cuenta que crear un objeto File no significa que
deba existir el fichero o el directorio o que el path sea correcto.

 File f = new File("personas.dat"); Si no existen no se lanzará ningún tipo de excepción ni tampoco

Crea un Objeto File asociado al fichero personas.dat que serán creados.
se encuentra en el directorio de trabajo. En este caso no
Métodos
se indica path. Se supone que el fichero se encuentra en el
directorio actual de trabajo. Alguno de los métodos de la clase File son los siguientes:

Método Descripción
boolean canRead() Devuelve true si se puede leer el fichero
boolean canWrite() Devuelve true si se puede escribir en el fichero
boolean createNewFile() Crea el fichero asociado al objeto File. Devuelve true si se ha podido crear. Para poder crearlo el fichero no debe existir.
Lanza una excepción del tipo IOException.
boolean delete() Elimina el fichero o directorio. Si es un directorio debe estar vacío. Devuelve true si se ha podido eliminar.
boolean exists() Devuelve true si el fichero o directorio existe
String getName() Devuelve el nombre del fichero o directorio
String getAbsolutePath() Devuelve la ruta absoluta asociada al objeto File.
String getCanonicalPath() Devuelve la ruta única absoluta asociada al objeto File. Puede haber varias rutas absolutas asociadas a un File pero solo
una única ruta canónica. Lanza una excepción del tipo IOException.
String getPath() Devuelve la ruta con la que se creó el objeto File. Puede ser relativa o no.
String getParent() Devuelve un String conteniendo el directorio padre del File. Devuelve null si no tiene directorio padre.

File getParentFile() Devuelve un objeto File conteniendo el directorio padre del File. Devuelve null si no tiene directorio padre.

boolean isAbsolute() Devuelve true si es una ruta absoluta

boolean isDirectory() Devuelve true si es un directorio válido
boolean isFile() Devuelve true si es un fichero válido
long lastModified() Devuelve un valor en milisegundos que representa la última vez que se ha modificado (medido desde las 00:00:00 GMT,
del 1 de Enero de 1970). Devuelve 0 si el fichero no existe o ha ocurrido un error.
long length() Devuelve el tamaño en bytes del fichero. Devuelve 0 si no existe. Devuelve un valor indeterminado si es un directorio.
String[] list() Devuelve un array de String con el nombre de los archivos y directorios que contiene el directorio indicado en el objeto
File. Si no es un directorio devuelve null. Si el directorio está vacío devuelve un array vacío.
String[] list(FilenameFilter Similar al anterior. Devuelve un array de String con el nombre de los archivos y directorios que contiene el directorio
filtro) indicado en el objeto File que cumplen con el filtro indicado.
boolean mkdir() Crea el directorio. Devuelve true si se ha podido crear.
boolean mkdirs() Crea el directorio incluyendo los directorios no existentes especificados en la ruta padre del directorio a crear. Devuelve
true si se ha creado el directorio y los directorios no existentes de la ruta padre.
boolean renameTo(File Cambia el nombre del fichero por el indicado en el parámetro dest. Devuelve true si se ha realizado el cambio.
dest)

String directorio = "C:\\prueba";

String varios = "carpeta1/carpeta2/carpeta3";
1.1.1. Existencia y listado de // Crear un directorio
boolean exito = (new File(directorio)).mkdir();
ficheros y carpetas if (exito)
Mediante la clase File, podemos ver si un fichero cualquiera, System.out.println("Directorio: " + directorio + " creado");
digamos por ejemplo texto.txt, existe o no. Para ello, nos valemos
// Crear varios directorios
del método exists() de la clase File. Hacemos referencia a ese fichero
en concreto con el código siguiente: exito = (new File(varios)).mkdirs();
if (exito)
File f = new File("C:\texto.txt"); System.out.println("Directorios: " + varios + " creados");
}catch (Exception e){
File.
como verás, permite listar el contenido de la carpeta que
System.err.println("Error: " + e.getMessage());
pongas en un campo de texto, introduciendo el resultado en un
JList. }

Pero ¿qué pasa si nos interesa copiar un fichero, ¿cómo lo

haríamos? Para borrar un directorio con Java, tendremos que borrar cada
uno de los ficheros y directorios que este contenga. Al poder
Con la clase File no es suficiente, necesitamos saber más, en almacenar otros directorios, se podría recorrer recursivamente el
concreto, necesitamos hablar de los flujos, como vamos a ver más directorio para ir borrando todos los ficheros.
adelante.
Podemos listar el contenido de un directorio e ir borrando con:

File [] ficheros = directorio.listFiles ();

1.1.2. Creación y eliminación Si el elemento es un directorio, lo sabemos mediante el
de ficheros y directorios método isDirectory ().

Cuando queramos crear un fichero, podemos proceder del Después de vaciar el directorio, este, se puede borrar importando la
siguiente modo: librería FileUtils y después
escribir FileUtils.deleteDirectory(newFile(destination));
try {
// Creamos el objeto que encapsula el fichero
File fichero = new File("c:\\prueba\\miFichero.txt");
1.2. Interface FilenameFilter
Hemos visto cómo obtener la lista de ficheros de una carpeta o
// A partir del objeto File creamos el fichero físicamenteif
directorio. A veces, nos interesa ver no la lista completa, sino los
(fichero.createNewFile())
archivos que encajan con un determinado criterio.
System.out.println("El fichero se ha creado correctamente");
else Por ejemplo, nos puede interesar un filtro para ver los ficheros
System.out.println("No ha podido ser creado el fichero"); modificados después de una fecha, o los que tienen un tamaño
} catch (Exception ioe) { mayor del que el que indiquemos, etc.
ioe.getMessage(); El interface FilenameFilter se puede usar para crear filtros que
} establezcan criterios de filtrado relativos al nombre de los ficheros.
Una clase que lo implemente debe definir e implementar el
Para borrar un fichero podemos usar la clase File, comprobando método:
previamente si existe el fichero, del siguiente modo:
boolean accept(File dir, String nombre)
// Borrar fichero
File fichero = new File("c:\\prueba\\miFichero.txt"); Este método devolverá verdadero en el caso de que el fichero cuyo
nombre se indica en el parámetro nombre aparezca en la lista de los
if (fichero.exists ())
ficheros del directorio indicado por el parámetro dir..
fichero.delete();
En el siguiente ejemplo vemos cómo se listan los ficheros de la
carpeta c:\datos que tengan la extensión .txt. Usamos try y catch para
Para crear un directorio, lo realizaremos del siguiente modo: capturar las posibles excepciones, como que no exista dicha
carpeta.
Try {
// Declaración de variables import java.io.File;
import java.io.FilenameFilter; 

public class Filtrar implements FilenameFilter {

String extension;
// Constructor
Filtrar(String extension){
this.extension = extension;
}
public boolean accept(File dir, String name){
return name.endsWith(extension);
}
public static void main(String[] args) {
try { 3.Flujos
// Obtendremos el listado de los archivos de ese directorio
File fichero=new File("c:\\datos\\.");
String[] listadeArchivos = fichero.list();
// Filtraremos por los de extension .txt
listadeArchivos = fichero.list(new Filtrar(".txt"));
// Comprobamos el número de archivos en el listado
int numarchivos = listadeArchivos.length ;
// Si no hay ninguno lo avisamos por consola
if (numarchivos < 1)
Un programa en Java, que necesita realizar una operación de
System.out.println("No hay archivos que listar"); entrada/salida (en adelante E/S), lo hace a través de un flujo o
// Y si hay, escribimos su nombre por consola. stream.
else
{ Un flujo es una abstracción de todo aquello que produce o
consume información.
for(int conta = 0; conta < listadeArchivos.length; conta++)
System.out.println(listadeArchivos[conta]); La vinculación de este flujo al dispositivo físico la hace el
} sistema de entrada y salida de Java.
}
Las clases y métodos de E/S que necesitamos emplear son las
catch (Exception ex) { mismas independientemente del dispositivo con el que estemos
System.out.println("Error al buscar en la ruta indicada"); } actuando. Luego, el núcleo de Java sabrá si tiene que tratar con el
} teclado, el monitor, un sistema de archivos o un socket de red;
liberando al programador de tener que saber con quién está
 En el ejemplo anterior se utiliza la función endsWith. interactuando.

Java define dos tipos de flujos en el paquete java.io:

1.3. Rutas de los ficheros  Byte streams (8 bits): proporciona lo necesario para la
En los ejemplos que vemos en el tema, estamos usando la ruta de
los ficheros tal y como se usan en MS-DOS, o Windows, es decir, gestión de entradas y salidas de bytes y su uso está
por ejemplo: orientado a la lectura y escritura de datos binarios. El
tratamiento del flujo de bytes viene determinado por dos
C:\\datos\Programacion\fichero.txt clases abstractas que son InputStream y OutputStream Estas
dos clases definen los métodos que sus subclases tendrán
Cuando operamos con rutas de ficheros, el carácter separador entre implementados y, de entre todos, destacan read() y write()
directorios o carpetas suele cambiar dependiendo del sistema que leen y escriben bytes de datos respectivamente.
operativo en el que se esté ejecutando el programa.  Character streams (16 bits): de manera similar a los
flujos de bytes, los flujos de caracteres están
Para evitar problemas en la ejecución de los programas cuando se determinados por dos clases abstractas, en este caso:
ejecuten en uno u otro sistema operativo y, por tanto, persiguiendo Reader y Writer. Dichas clases manejan flujos de caracteres
que nuestras aplicaciones sean lo más portables posibles, se Unicode. Y también de ellas derivan subclases concretas
recomienda usar en Java: File.separator. que implementan los métodos definidos en ellas siendo
Podríamos hacer una función que, al pasarle una ruta, nos los más destacados los métodos read() y write() que leen y
devolviera la adecuada según el separador del sistema actual, del escriben caracteres de datos respectivamente.
siguiente modo:
1.4. Flujos basados en bytes
Para el tratamiento de los flujos de bytes, hemos dicho que Java
tiene dos clases abstractas que son InputStream y OutputStream.

Los archivos binarios guardan una representación de los datos en el

archivo, es decir, cuando guardamos texto no guardan el texto en
sí, sino que guardan su representación en un código llamado UTF-
8.
Las clases principales que heredan de OutputStream, para la escritura
de ficheros binarios son:
 FileOutputStream: escribe bytes en un fichero. Si el
archivo existe, cuando vayamos a escribir sobre él, se
borrará. Por tanto, si queremos añadir los datos al final de
éste, habrá que usar el constructor FileOutputStream(String
filePath, boolean append), poniendo append a true.
 ObjectOutputStream: convierte objetos y variables en
vectores de bytes que pueden ser escritos en un
OutputStream.
 DataOutputStream, que da formato a los tipos
primitivos y objetos String, convirtiéndolos en un flujo de
forma que cualquier DataInputStream, de cualquier máquina,
los pueda leer. Todos los métodos empiezan por " write",
como writeByte(), writefloat(), etc.
De InputStream, para lectura de ficheros binarios, destacamos:
 FileInputStream: lee bytes de un fichero.
 ObjectInputStream: convierte en objetos y variables los
vectores de bytes leídos de un InputStream.:
en el disco duro. Si se leen o escriben pocos caracteres cada vez, el
proceso se hace costoso y lento por los muchos accesos a disco
duro.
Los BufferedReader, BufferedInputStream, BufferedWriter y
añaden un buffer intermedio. Cuando se lee o
BufferedOutputStream
escribe, esta clase controla los accesos a disco. Así, si vamos
escribiendo, se guardarán los datos hasta que haya bastantes datos
como para hacer una escritura eficiente.
Al leer, la clase leerá más datos de los que se hayan pedido. En las
siguientes lecturas nos dará lo que tiene almacenado, hasta que
necesite leer otra vez físicamente. Esta forma de trabajar hace los
accesos a disco más eficientes y el programa se ejecuta más rápido.
Además FileReader no contiene métodos que nos permitan leer líneas
completas, pero sí BufferedReader. Afortunadamente, podemos
construir un BufferedReader a partir del FileReader de la siguiente
manera:
File archivo = new File ("C:\\archivo.txt");
FileReader fr = new FileReader (archivo);

BufferedReader br = new BufferedReader(fr);

Ejemplo: escritura a fichero.
...
En el siguiente ejemplo se puede ver cómo se escribe a un archivo
binario con DataOutputStream: String linea = br.readLine();

Ejemplo: lectura de un fichero

import java.io.File;
import java.io.FileInputStream; En este ejemplo leemos caracteres hasta llegar al fin de archivo
import java.io.FileOutputStream; (EOF o End Of File) del flujo.
import java.io.IOException;
import java.io.InputStream; import java.io.BufferedReader;
import java.io.OutputStream; import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class CopiaFicheros { public class LeerFichEOF {
public static void main(String args[]) { public static void main (String args[]) throws
IOException {
// Copiar ficheros
BufferedReader br = new
File origen = new File("origen.txt");
BufferedReader(new FileReader("origen.txt")) ;
File destino = new File("destino.txt");
int codigo = br.read();//lee el primer caracter
try {
char caracter;
InputStream in = new FileInputStream(origen);
//mientras el código no sea -1 (EOF) continuo leyendo
OutputStream out = new FileOutputStream(destino);
while (codigo != -1) {
byte[] buf = new byte[1024];
caracter = (char) codigo; //casting
int len;
System.out.print(caracter);
while ((len = in.read(buf)) > 0) {
codigo = br.read(); //lee un caracter
out.write(buf, 0, len);
}
}
}
in.close();
}
out.close();
} catch (IOException ioe) {
ioe.printStackTrace();
4.Formas de acceso a un
}
}
fichero
}
Hemos visto que en Java puedes utilizar dos tipos de ficheros (de

1.5. Flujos basados en texto o binarios) y dos tipos de acceso a los ficheros (secuencial
o aleatorio). Si bien, y según la literatura que consultemos, a veces

caracteres se distingue una tercera forma de acceso denominada

concatenación, tuberías o pipes.
Para los flujos de caracteres, Java dispone de dos clases abstractas:
Reader y Writer.  Acceso aleatorio: los archivos de acceso aleatorio, al
igual que lo que sucede usualmente con la memoria
Si se usan sólo FileInputStream, FileOuputStream, FileReader o FileWriter, (RAM=Random Access Memory), permiten acceder a
cada vez que se efectúa una lectura o escritura, se hace físicamente los datos en forma no secuencial, desordenada. Esto
 implica que el archivo debe estar disponible en su
totalidad al momento de ser accedido, algo que no
siempre es posible.
 Acceso secuencial: En este caso los datos se leen de
manera secuencial, desde el comienzo del archivo hasta
el final (el cual muchas veces no se conoce a priori). Este
es el caso de la lectura del teclado o la escritura en una
consola de texto, no se sabe cuándo el operador terminará
de escribir.
 Concatenación (tuberías o "pipes"): Muchas veces es
útil hacer conexiones entre programas que se ejecutan
simultáneamente dentro de una misma máquina, de modo
que lo que uno produce se envía por un "tubo" para ser
recibido por el otro, que está esperando a la salida del
tubo. Las tuberías cumplen esta función
Cuando se trabaja con ficheros de texto se recomienda usar las
clases Reader, para entrada o lectura de caracteres, y Writer para
salida o escritura de caracteres. Estas dos clases están optimizadas
para trabajar con caracteres y con texto en general, debido a que
tienen en cuenta que cada carácter Unicode está representado por
dos bytes.
Las subclases de Writer y Reader que permiten trabajar con ficheros
de texto son:
 FileReader, para lectura desde un fichero de texto. Crea un
flujo de entrada que trabaja con caracteres en vez de con
bytes.
 FileWriter, para escritura hacia un fichero de texto. Crea un
flujo de salida que trabaja con caracteres en vez de con
bytes.

1.6. Operaciones básicas También se puede montar un buffer sobre cualquiera de los flujos
que definen estas clases:
sobre ficheros de acceso  BufferedWriterse usa para montar un buffer sobre un flujo

secuencial 
de salida de tipo FileWriter.
BufferedReader se usa para montar un buffer sobre un flujo
Como operaciones más comunes en ficheros de acceso secuencial, de entrada de tipo FileReader.
tenemos el acceso para:

 Crear un fichero o abrirlo para grabar datos. 1.7. Operaciones básicas

 Leer datos del fichero.
 Borrar información de un fichero. sobre ficheros de acceso
 Copiar datos de un fichero a otro.
 Búsqueda de información en un fichero. aleatorio
 Cerrar un fichero. A menudo, no necesitas leer un fichero de principio a fin, sino
simplemente acceder al fichero como si fuera una base de datos,
Ahora vamos a ver como buscar en un archivo secuencial. La idea donde se salta de un registro a otro; cada uno en diferentes partes
es que al ser un fichero secuencial tenemos que abrirlo e ir leyendo del fichero. Java proporciona una clase RandomAccessFile para este
hasta encontrar el dato que buscamos, si es que lo encontramos. tipo de entrada/salida.
Esto se muestra a continuación:
Esta clase:
String busqueda = jTexField1.getText();
try {  Permite leer y escribir sobre el fichero, no es necesario
dos clases diferentes.
// Declarar variable
 Necesita que le especifiquemos el modo de acceso al
DataInputStream archivo = null;
construir un objeto de esta clase: sólo lectura o bien
// Abrir el archivo lectura y escritura.
archivo = new DataInputStream ( new FileInputStream  Posee métodos específicos de desplazamiento como
("c:\\secuencial.dar") ); seek(long posicion) o skipBytes(int desplazamiento) para poder
// Leer archivo movernos de un registro a otro del fichero, o
while (seguir) { posicionarnos directamente en una posición concreta del
// Leer el nombre fichero.
nombre = archivo.readUTF();
Por esas características que presenta la clase, un archivo de acceso
// Si el nombre es el que buscamos directo tiene sus registros de un tamaño fijo o predeterminado de
if (busqueda.equals (nombre) { antemano.
System.out.println ("encontrado");
seguir = false; La clase posee dos constructores:
jLabel2.setText ("¡¡Registro encontrado!!");  RandomAccessFile(File file, String mode).
}  RandomAccessFile(String name, String mode).

// Leer los otros campos En el primer caso se pasa un objeto File como primer parámetro,
apellidos = archivo.readUTF (); mientras que en el segundo caso es un String. El modo es: "r" si se
edad = archivo.readInt (); abre en modo lectura o "rw" si se abre en modo lectura y escritura.
}
A continuación puedes ver una presentación en la que se muestra
// Cerrar fichero
cómo abrir y escribir en un fichero de acceso aleatorio. También,
archivo.close (); en el segundo código descargable, se presenta el código
} correspondiente a la escritura y localización de registros en
catch (FileNotFoundException fne) { / * Archivo no encontrado * / ficheros de acceso aleatorio.
}
catch (IOException ioe) { / * Error al escribir * / } Ejemplo:
Vamos a ver un pequeño ejemplo, Log.java, que añade una cadena
a un fichero existente, lo crea en caso de que no exista.
import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomEjemplo {
public static void main( String args[] ) throws IOException {
RandomAccessFile miRAFile;
String s = "linea a añadir al final del fichero";
// Abrimos el fichero de acceso aleatorio
miRAFile = new RandomAccessFile( "java.log","rw" );
// Nos vamos al final del fichero
miRAFile.seek( miRAFile.length() );
// Incorporamos la cadena al fichero
miRAFile.writeBytes( s );
// Cerramos el fichero
miRAFile.close();
}
}
5.Java NIO
Una de las tareas más importante que realizan algunas aplicaciones
es el manejo de la entrada y salida ya sea al sistema de ficheros o a
la red.
Una de las tareas más importante que realizan algunas aplicaciones
es el manejo de la entrada y salida ya sea al sistema de ficheros o a
la red. Desde las versiones iniciales de Java se ha mejorado soporte
añadiendo programación asíncrona de E/S, permitir obtener
información de atributos propios del sistema de archivos,
reconocimiento de enlaces simbólicos y facilitado de algunas
operaciones básicas.
Hemos usado durante muchos años java.io para trabajar con
ficheros en el mundo Java . Se trata de un API muy potente y
flexible que nos permite realizar casi cualquier tipo de operación.
Sin embargo es un API complicada de entender. Java NIO (New IO)
es un nuevo API disponible desde Java7 que nos permite mejorar el
rendimiento así como simplificar el manejo de muchas cosas.  implementen esta interfaz puede utilizarse para localizar
Java.nio defineinterfaces y clases para que la máquina virtual
Java tenga acceso a archivos, atributos de archivos y sistemas
de archivos. Aunque dicho API comprende numerosas clases, solo
existen unas pocas de ellas que sirven de puntos de entrada al API,
lo que simplifica considerablemente su manejo
Java NIO: canales y búferes
En la API de IO estándar, trabajas con secuencias de bytes y
secuencias de caracteres. En NIO, trabaja con canales y búferes.
Los datos siempre se leen de un canal a un búfer, o se escriben
desde un búfer a un canal.
Java NIO: IO sin bloqueo
Java NIO le permite hacer IO sin bloqueo. Por ejemplo, un hilo
puede pedirle a un canal que lea datos en un búfer. Mientras el
canal lee datos en el búfer, el hilo puede hacer otra cosa. Una vez
que se leen los datos en el búfer, el hilo puede continuar
procesándolo. Lo mismo es cierto para escribir datos en canales.
Java NIO: Selectores
Java NIO contieneel concepto de "selectores". Un selector es un
objeto que puede gestionar múltiples canales para eventos (como:
conexión abierta, datos recibidos, etc.).  Un Selector permite que
un solo hilo maneje múltiples canales.
El estudio de la  API  NIO completa, excede el modulo, por lo que
veremos lo mas básico.  Vamos a estudiar en los subcapítulos
siguiente  las interfaces  Path y Files que son las clases básicas para
acceder a los ficheros. 
En la imagen puedes ver las clases de las que se dispone en
java.nio. 
 La interfaz java.nio.file.Path representa un path y las clases
que implementen esta interfaz puede utilizarse para
localizar ficheros en el sistema de ficheros. Nos permite
manejar rutas al estilo GNU/Linux y rutas al estilo
Windows dependiendo del SO en el que estemos
trabajando.
 La clase java.nio.file.Files es el otro punto de entrada a la
librería de ficheros de Java. Es la que nos permite
manejar ficheros reales del disco desde Java.+
5.1. Java NIO Path
La interfaz java.nio.file.Path representa un path y las clases que
implementen esta interfaz puede utilizarse para localizar
ficheros en el sistema de ficheros.
La interfaz java.nio.file.Path representa un path y las clases que
ficheros en el sistema de ficheros.
Una ruta puede señalar a un archivo o un directorio. Un camino
puede ser absoluto o relativo. Una ruta absoluta contiene la ruta
completa desde la raíz del sistema de archivos hasta el archivo o
directorio al que apunta. Una ruta relativa contiene la ruta al
archivo o directorio relativo a alguna otra ruta. 
La forma mas sencilla de construir un objeto que cumpla la interfaz
Path es a partir de la clase java.nio.file.Paths, que tiene métodos
estáticos que retornan objetos Path a partir de una
representación tipo String del path deseado, por ejemplo:
Path p = Paths.get("/home/ad/mi_fichero");
Por supuesto, no es necesario que los ficheros existan de verdad
en el disco duro para que se puedan crear los objetos Path
correspondientes: La representación y manejo de paths en Java no
está restringida por la existencia de esos ficheros o directorios en el
sistema de ficheros.
El interfaz Path declara numerosos métodos que resultan muy
útiles para el manejo de paths, como por ejemplo, obtener el
nombre corto de un fichero, obtener el directorio que lo contiene, while (it.hasNext()) {
resolver paths relativos, etc. System.out.println(it.next().getFileName());
Una instancia de tipo Path refleja el sistema de nombrado del }
sistema operativo subyacente, por lo que objetos path de diferentes }
sistemas operativos no pueden ser comparados fácilmente entre si. }

Operaciones con Path 5.2. Clases Java NIO Files

 Recuperar partes de una ruta. La clase java.nio.file.Files es el otro punto de entrada a la librería
 Eliminar redundancias de una ruta. de ficheros de Java. Es la que nos permite manejar ficheros reales
 Convertir una ruta. del disco desde Java.
 Unir dos rutas.
La clase java.nio.file.Files es el otro punto de entrada a la librería
 Crear una ruta relativa a otra dada. de ficheros de Java. Es la que nos permite manejar ficheros reales
 Comparar dos rutas. del disco desde Java.

Ejemplo: Esta clase tiene métodos estáticos para el manejo de ficheros, los
métodos de la clase Files trabajan sobre objetos Path. 
import java.nio.file.Path;
Las operaciones principales a realizar con archivos y
import java.nio.file.Paths;
directorios son:

public class PathEjamplo {  Verificación de existencia y accesibilidad.

public static void main(String args[]) {  Borrar un archivo o directorio.
Path path = Paths.get("C:/Users/alumno/PathEjemplo");  Copiar un archivo o directorio.
System.out.println(" path = " + path);  Mover un archivo o directorio.
System.out.println(" is absoute ? = " + path.isAbsolute());
System.out.println(" file short name = " + path.getFileName()); Veamos cómo se realizan algunas de estas operaciones.
System.out.println(" parent = " + path.getParent());
System.out.println(" uri = " + path.toUri());
path = Paths.get("/home/PathEjemplo");
System.out.println(" path = " + path);
Ejemplo 1: Existencia y comprobación de permisos
System.out.println(" is absoute ? = " + path.isAbsolute());
System.out.println(" file short name = " + path.getFileName()); import java.nio.file.Path;
System.out.println(" parent = " + path.getParent()); import java.nio.file.Paths;
System.out.println(" uri = " + path.toUri()); import java.nio.file.Files;
} public class FileEjemplo {
} public static void main(String args[]) {
Path path =
Paths.get("C:\\Users\\alumno\\FileEjamplo\\hola.txt");
Clase FileSystem
System.out.println(" path = " + path);
El concepto de FileSystem define un sistema de ficheros System.out.println(" exists = " + Files.exists(path));
completo. Mientras que por otro lado el concepto de Path hace System.out.println(" readable = " + Files.isReadable(path));
referencia a un directorio, fichero o link que tengamos dentro System.out.println(" writeable = " + Files.isWritable(path));
de nuestro sistema de ficheros. El siguiente código hace uso
System.out.println(" executeable = " + Files.isExecutable(path))
de FileSystem y Path para obtener el nombre de un fichero así como
la carpeta padre en la que se encuentra ubicado.
Ejemplo2: Creación y borrado de directorios
Ejemplo:
import java.nio.file.Path;
import java.nio.file.FileSystem;
import java.nio.file.Paths;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.io.IOException;
import java.util.Iterator;
// Crea un nuevo fichero o directorio o lo borra si ya existe
public class EjemploPath2 {
public class FileEjemplo2 {
public static void main(String args[]) {
public static void main(String args[]) {
FileSystem sistemaFicheros = FileSystems.getDefault();
Path path = Paths.get("C:\\Users\\alumno\\prueba");
Path rutaFichero =
sistemaFicheros.getPath("C:\\Users\\alumno\\PathEjemplo"); try {
System.out.println(rutaFichero.getFileName()); if (Files.exists(path))
System.out.println(rutaFichero.getParent().getFileName()); Files.delete(path);
Path rutaDirectorio = else
sistemaFicheros.getPath("C:\\Users\\alumno"); Files.createFile(path);
Iterator<Path> it = rutaDirectorio.iterator(); } catch (IOException e) {
System.err.println(e);
 System.exit(1); import java.nio.file.Path;
} import java.nio.file.Paths;
} import java.nio.file.FileAlreadyExistsException;
} import java.nio.file.Files;
import java.io.IOException;
//import java.nio.file.FileAlreadyExistsException; //en caso de
El método  delete(Path) borra el fichero o directorio o lanza una
querer sobrescribir el directorio destino
excepción si el borrado falla. El siguiente ejemplo muestra como
public class FileEjemplo5 {
capturar y gestionar las excepciones que pueden producirse en el
borrado  Si el fichero o directorio no existe la excepción que se public static void main(String args[]) {
produce es  NoSuchFileException. Los sucesivos cath permiten Path sourcePath = Paths.get("C:\\Users\\alumno\\origen");
determinar por  que ha fallado el borrado: Path destinationPath =
Paths.get("C:\\Users\\alumno\\FileEjamplo\\destino");
try {
try { Files.copy(sourcePath, destinationPath);
Files.delete(path); //Files.copy(sourcePath, destinationPath,
StandardCopyOption.REPLACE_EXISTING);
} catch (NoSuchFileException x) {
} catch (FileAlreadyExistsException e) {
System.err.format("%s: no such" + " file or directory%n", path);
System.out.println("el fichero existe");
} catch (DirectoryNotEmptyException x) {
} catch (IOException e) {
System.err.format("%s not empty%n", path);
e.printStackTrace();
} catch (IOException x) {
}
// File permission problems are caught here.
}
System.err.println(x);
}
}

Ejemplo 5: Copiar ficheros

El metodo deleteIfExists(Path) tambien borra el fichero o
directorio, pero no lanza ningun error en caso de que el fichero o import java.io.IOException;
directorio no exista.
import java.nio.file.FileAlreadyExistsException;
Ejemplo3: crear un directorio import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Path; import java.nio.file.Paths;
import java.nio.file.Paths; import java.nio.file.StandardCopyOption;
import java.nio.file.FileAlreadyExistsException; public class FileEjemplo7 {
import java.nio.file.Files; public static void main(String args[]) {
import java.io.IOException; Path sourcePath =
// crea una nueva carpeta Paths.get("C:\\Users\\alumno\\FileEjamplo\\hola.txt");
public class FileEjemplo4 Path destinationPath
{ =Paths.get("C:\\Users\\alumno\\FileEjamplo\\destino\\hola.txt");
public static void main(String args[]) { try {
Path path = Paths.get("C:\\Users\\alumno\\newdir"); Files.copy(sourcePath, destinationPath,
try { StandardCopyOption.REPLACE_EXISTING);
Path newDir = Files.createDirectory(path); } catch (FileAlreadyExistsException e) {
} catch(FileAlreadyExistsException e){ System.out.println("el destino existe");
// el directorio ya existe } catch (IOException e) {
} catch (IOException e) { e.printStackTrace();
//error I/O }
e.printStackTrace(); }
} }
}
}
Ejemplo 6: Mover ficheros y directorios, cambiando el nombre

import java.io.IOException;
Ejemplo4: copiar directorios
import java.nio.file.FileAlreadyExistsException;
Se puede copiar un archivo o directorio usando el import java.nio.file.Files;
método copy(Path, Path, CopyOption...). La copia falla si el import java.nio.file.Path;
archivo de destino existe, a menos que se especifique la opción import java.nio.file.Paths;
REPLACE_EXISTING. 
import java.nio.file.StandardCopyOption;
Se puede copiar directorios  Aunque, los archivos dentro del public class FileEjemplo7 {
directorio no se copian, por lo que el nuevo directorio está vacío public static void main(String args[]) {
incluso cuando el directorio original contiene archivos.
Path sourcePath = public class FileEjemplo10 {
Paths.get("C:\\Users\\alumno\\FileEjamplo\\hola.txt"); public static void main(String args[]) {
Path destinationPath = Path inputFile =
Paths.get("C:\\Users\\alumno\\FileEjamplo\\destino\\OtroNombre.t Paths.get("C:\\Users\\alumno\\FileEjamplo\\origen\\hola.txt");
xt"); Path outputFile =
try { Paths.get("C:\\Users\\alumno\\FileEjamplo\\destino\\hola.txt");
Files.move(sourcePath, destinationPath, try {
StandardCopyOption.REPLACE_EXISTING); byte[] contents = Files.readAllBytes(inputFile);
} catch (FileAlreadyExistsException e) { Files.write(outputFile, contents,
System.out.println("el destino existe"); StandardOpenOption.WRITE,
} catch (IOException e) { StandardOpenOption.CREATE,
e.printStackTrace(); StandardOpenOption.TRUNCATE_EXISTING);
} } catch (IOException e) {
} System.err.println(" ERROR : " + e);
} System.exit(1);
}
}
5.3. Escribir contenido en }
Escritura desde buffers
un fichero La escritura desde buffers resulta mucho más eficiente que
utilizando arrays de bytes para ficheros grandes. 
Modos de acceso, el parámetro OpenOptions.
El siguiente programa Java copia ficheros, accediendo al fichero
A la hora de utilizar un fichero en Java se puede restringir el acceso original una 
que  tenemos al mismo desde el propio lenguaje, haciendo más vez por línea y escribiendo en el fichero destino una línea cada vez.
estrictos los permisos de acceso que dicho fichero ya tiene en el Utiliza las clases de java.io:  BufferedReader y BufferedWriter:
sistema de ficheros.
import java .nio. file. Path;
Por ejemplo, si el usuario tiene permisos de lectura y escritura import java .nio. file. Paths ;
sobre un fichero, un programa Java que solo quiera leerlo puede import java .nio. file. Files ;
abrir el fichero solo en modo lectura, lo que ayudará a evitar bugs import java .io. IOException;
desde el propio lenguaje. import java .nio. charset . Charset ;
A tal efecto, en java se definen una serie de modos de acceso a un import java .io. BufferedReader;
fichero a través del parámetro OpenOptions. La forma más cómoda de import java .io. BufferedWriter;
utilizar este parámetro es a través del enum StandardOpenOptions que import java .nio. file. StandardOpenOption;
puede tomar los siguientes valores (hay más): public class FileEjemplo11 {
// Copy a file
 WRITE: habilita la escritura en el fichero
public static void main( String args []) {
 APPEND: todo lo escrito al fichero se hará al final del
Path input = Paths .
mismo
get( "C:\\Users\\alumno\\FileEjamplo\\origen\\hola.txt") ;
 CREATE_NEW: crea un fichero nuevo y lanza una
Path output = Paths .
excepción si ya existía
get("C:\\Users\\alumno\\FileEjamplo\\destino\\hola.txt") ;
 CREATE: crea el fichero si no existe y simplemente lo
try {
abre si ya existía
BufferedReader inputReader = Files .
 TRUNCATE_EXISTING: si el fichero existe, y tiene
newBufferedReader(input , Charset .
contenido, se ignora su contenido para sobreescribirlo
defaultCharset());
desde el principio.
BufferedWriter outputWriter = Files .
Los métodos que se muestran en las siguientes ejemplos utilizan newBufferedWriter(output , Charset .
este parámetro, en la descripción de cada método en el API se defaultCharset() , StandardOpenOption. WRITE ,
explica cual es el comportamiento por defecto en caso de no StandardOpenOption.
utilizarse este parámetro. CREATE , StandardOpenOption.
TRUNCATE_EXISTING);
Escritura desde arrays de bytes String line;
La escritura a ficheros mediante arrays es la forma más sencilla (y while ( ( line = inputReader. readLine ()) != null ) {
limitada) de escritura de ficheros, y se realiza mediante el outputWriter. write (line , 0, line. length ());
método java.nio.file.Files.write(). outputWriter. newLine () ;
}
import java.io.IOException;
inputReader. close ();
import java.nio.file.Files;
outputWriter. close ();
import java.nio.file.Path;
} catch ( IOException e) {
import java.nio.file.Paths;
System .err. println (" ERROR : " + e);
import java.nio.file.StandardOpenOption;
System . exit (1);
 } representando la información obtenida de los documentos XML en
} un programa en formato Java, o sea, proporciona a los
}
6.Trabajo con ficheros
XML: analizadores
sintácticos (parser) y
vinculación (binding)
Probablemente hayas estudiado ya XML, bien porque hayas
cursado el módulo Lenguajes de marcas y sistemas de gestión de
información, o bien porque lo conozcas por tu cuenta. Si no
conoces XML, te recomendamos que te familiarices con él, hay
múltiples tutoriales y cursos en Internet.
El metalenguaje XML se crea para evitar problemas de
interoperabilidad entre plataformas y redes. Con él se consigue un
soporte estándar para el intercambio de datos: no sólo los datos
están en un formato estándar sino también la forma de acceder a
ellos. Y entre las ventajas de su uso destacamos:
 Facilita el intercambio de información entre distintas
aplicaciones ya que se basa en estándares aceptados.
 Proporciona una visión estructurada de la
información, lo que permite su posterior tratamiento de
forma local.
1.8. Conceptos previos
¿Cómo se trabaja con datos XML desde el punto de vista del
desarrollador de aplicaciones?
Una aplicación que consume información XML debe:
 Leer un fichero de texto codificado según dicho estándar.
 Cargar la información en memoria y, desde allí...
 Procesar esos datos para obtener unos resultados (que
posiblemente también almacenará de forma persistente
en otro fichero XML).
El proceso anterior se enmarca en lo que se conoce en informática
como "parsing" o análisis léxico-sintáctico, y los programas que
lo llevan a cabo se denominan "parsers" o analizadores (léxico-
sintácticos). Más específicamente podemos decir que el "parsing
XML" es el proceso mediante el cual se lee y se analiza un
documento XML para comprobar que está bien formado para,
posteriormente, pasar el contenido de ese documento a una
aplicación cliente que necesite consumir dicha información.
Schema: Un esquema (o schema) es una especificación XML que
dicta los componentes permitidos de un documento XML y las
relaciones entre los componentes. Por ejemplo, un esquema
identifica los elementos que pueden aparecer en un documento
XML, en qué orden deben aparecer, qué atributos pueden tener, y
qué elementos son subordinados (esto es, son elementos hijos) para
otros elementos. Un documento XML no tiene por qué tener un
esquema, pero si lo tiene, debe atenerse a ese esquema para ser un
documento XML válido.
1.9. Definiciones
¿Qué es y para qué sirve JAXB (Java Architecture for XML
Binding)? JAXB simplifica el acceso a documentos XML
desarrolladores de aplicaciones Java, una forma rápida para
vincular esquemas XML a representaciones Java.
JAXB proporciona métodos para, a partir de documentos XML,
obtener árboles de contenido (generados en código Java), para
después operar con ellos o manipular los los mismos en una
aplicación Java y generar documentos XML con la estructura de
los iniciales, pero ya modificados.
Parsear un documento XML consiste en "escanear" el documento
y dividirlo o separarlo lógicamente en piezas discretas. El
contenido parseado está entonces disponible para la aplicación.
Binding: Binding o vincular un esquema (schema) significa
generar un conjunto de clases Java que representan el esquema.
Compilador de esquema o schema compiler: liga un esquema
fuente a un conjunto de elementos de programa derivados. La
vinculación se describe mediante un lenguaje de vinculación
basado en XML.
>Binding runtime framework: proporciona operaciones de
unmarshalling y marshalling para acceder, manipular y validar
contenido XML usando un esquema derivado o elementos de
programa.
Marshalling: es un proceso de codificación de un objeto en un
medio de almacenamiento, normalmente un fichero. Proporciona a
una aplicación cliente la capacidad para convertir un árbol de
objetos Java JAXB a ficheros XML. Por defecto, el marshaller usa
codificación UTF-8 cuando genera los datos XML.
Unmarshalling: proporciona a una aplicación cliente la capacidad
de convertir datos XML a objetos Java JAXB derivados.
1.10. "Parser" o analizador
XML.
Cuando se quieren almacenar datos que deban ser leídas por
aplicaciones ejecutadas en múltiples plataformas será necesario
recurrir a formatos más estandarizados, como los lenguajes de
marcas.
Los documentos XML consiguen estructurar la información
intercalando una serie de marcas denominadas etiquetas. En XML ,
las marcas o etiquetas tienen cierta similitud con un contenedor de
información. Así, una etiqueta puede contener otras etiquetas o
información textual. De este modo, conseguiremos subdividir la
información estructurando de forma que pueda ser fácilmente
interpretada.
Como toda la información es textual, no existe el problema de
representar los datos de diferente manera. Cualquier dato, ya sea
numérica o booleana, habrá transcribirla en modo texto, de modo
que cualquiera que sea el sistema de representación de datos será
posible leer e interpretar correctamente la información contenida en
un archivo XML.
Es cierto que los caracteres se pueden escribir usando también
diferentes sistemas de codificación, pero XML ofrece diversas
técnicas para evitar que esto sea un problema. Por ejemplo, es
posible incluir en la cabecera del archivo que codificación se ha
utilizado durante el almacenamiento, o también se pueden escribir
los caracteres de código ASCII superior a 127, utilizando entities
de carácter , una forma universal de codificar cualquier símbolo .
XML consigue estructurar cualquier tipo de información
jerárquica. Se puede establecer cierta similitud con la forma como
la información se almacena en los objetos de una aplicación y la
forma como se almacenaría en un documento XML . La
información, en las aplicaciones orientadas a objeto, estructura,
agrupa y jerarquiza en clases, y en los documentos XML se
estructura, organiza y jerarquiza en etiquetas contenidas unas
dentro de otras y atributos de las etiquetas
Analizador XML
Dado que XML es un lenguaje utilizado ámpliamente en el
desarrollo de la World Wide Web, existen ya herramientas y
estándares de programación para leer documentos XML. Las
herramientas o programas que leen el lenguaje XML y comprueban
si el documento es válido sintácticamente, se denominan
analizadores o "parsers".  contenido, se almacenan en la memoria RAM siguiendo la
Un parser XML es un módulo, biblioteca o programa que se ocupa
de analizar, clasificar y transformar un archivo de XML en una
representación interna,  extrayendo la información contenida en
cada una de las etiquetas y relacionándola de acuerdo con su
posición en la jerarquía.
 En el caso de XML, como el formato siempre es el mismo, no
necesitamos crear un parser cada vez que hacemos un programa,
sino que existen un gran número de parsers o analizadores
sintácticos disponibles que pueden averiguar si un documento
XML cumple con una determinada gramática. Estos analizadores o
parsers pueden ser secuenciales como SAX o STAX o jerarquicos
como DOM.
Analizadores secuenciales
Comparativa analizadores
Los analizadores secuenciales, que permiten extraer el contenido a
medida que se van descubriendo las etiquetas de apertura y cierre,
se denominan analizadores sintácticos. Son analizadores muy
rápidos, pero presentan el problema de que cada vez que se
necesita acceder a una parte del contenido necesario releer todo el
documento de arriba a abajo.
En Java hay dos analizadores secuenciales: SAX, que es el
acrónimo de Simple API for XML . Es una analizador muy usado
en varias bibliotecas de tratamiento de datos XML , pero no suele
usarse en aplicaciones finales y STAX, Streaming API for XML,
posterior a SAX y que lo ha superado.
Analizadores jerárquicos
Generalmente, las aplicaciones finales que necesitan trabajar con
datos XML suelen usar analizadores jerárquicos, porque además de
realizar un análisis secuencial que les permite clasificar el
estructura jerárquica detectada en el documento. Esto facilita
mucho las consultas que haya que repetir varias veces, dado que las
estructuras jerárquicas de la memoria RAM tienen un rendimiento
de acceso parcial a los datos muy eficiente.
Los analizadores jerárquicos guardan todos los datos del XML en
memoria dentro de una estructura jerárquica. Son ideales para
aplicaciones que requieran una consulta continua de los datos. El
formato de la estructura donde se almacena la información en la
memoria RAM ha sido especificado por el organismo internacional
W3C (World Wide Web Consortium) y se suele conocer como
DOM (Document Object Model). Es una estructura que HTML y 
javascript han popularizado mucho y se trata de una especificación
que Java materializa en forma de interfaces. La principal se
denomina Documento y representa todo un documento XML . Al
tratarse de una interfaz, puede ser implementada por varias clases.
 CARACTERÍSTICA STAX SAX DOM TRAX
Tipo de API Pull, streaming Push, streaming En memoria Regla XSLT
Facilidad de uso Alta Media Alta Media
Capacidad XPath No No Si Si
Eficiencia de CPU y memoria Buena Buena Varia Varia
Solo hacia adelante Si Si No No

Lee XML Si Si Si Si
Escribe XML Si No Si Si
Crear, Leer, Modificar, Borrar No No Si No

6.1. DOM // Creación de una instancia Transformer

DOM  (Document Object Model ) es una recomendación oficial
del World Wide Web Consortium (W3C). Define una interfaz que
permite a los programas acceder y actualizar el estilo, la estructura
y el contenido de los documentos XML. Los analizadores XML
compatibles con DOM implementan esta interfaz.
DOM  (Document Object Model ) es una recomendación oficial
del World Wide Web Consortium (W3C). Define una interfaz que
permite a los programas acceder y actualizar el estilo, la estructura
y el contenido de los documentos XML. Los analizadores XML
compatibles con DOM implementan esta interfaz.
Transformer trans = TransformerFactory. newInstance .
newTransformer ;
// Creación de los adaptadores Source y Results a partir de un
Documento
// y un File.
StreamResult result = new StreamResult ( file ) ;
DOMSource source = new DOMSource ( doc ) ;
trans.transform ( source, result ) ;
Con el fin de rebajar la complejidad, vamos a crear una clase que
llamaremos XmlCtrlDomcon utilidades genéricas que nos
simplifiquen el traspaso de archivos XML a DOM o viceversa.

El estándar W3C define la especificación de la public class XmlCtrlDom {

clase DocumentBuilder con el propósito de poder instanciar estructuras public static Document instanciarDocument
DOM a partir de un XML. La clase DocumentBuilder es una clase throws ParserConfigurationException {
abstracta, y para que se pueda adaptar a las diferentes plataformas, Document doc = null ;
puede necesitar fuentes de datos o requerimientos diversos. doc = DocumentBuilderFactory. newInstance .
Recuerda que las clases abstractas no se pueden instanciar de forma newDocumentBuilder . newDocument ;
directa. Por este motivo, el consorcio W3 especifica también la return doc ;
clase DocumentBuilderFactory
}
Las instrucciones necesarias para leer un archivo XML y crear un public static void escriureDocumentATextXml ( Document
objeto Documento serían las siguientes:  doc, File file )
throws TransformerException {
DocumentBuilderFactory dbFactory = DocumentBuilderFactory. newInstance ; 
DocumentBuilder dBuilder = dbFactory. newDocumentBuilder ; Transformer trans = TransformerFactory. newInstance .
Document doc = dBuilder. parse ( new File ( "fitxer.xml" ) ) ; newTransformer ;
La escritura de la información contenida en el DOM se puede trans.setOutputProperty ( OutputKeys. indent , "yes" ) ;
secuenciar en forma de texto utilizando otra utilidad de Java
StreamResult result = new StreamResult ( file ) ;
llamada Transformer. Se trata de una utilidad que permite realizar
DOMSource source = new DOMSource ( doc ) ;
fácilmente conversiones entre diferentes representaciones de
información jerárquica. Es capaz, por ejemplo, de pasar la trans. transform ( source, result ) ;
información contenida en un objeto Documento a un archivo de }
texto en formato XML . También sería capaz de hacer la operación public static Document instanciarDocument ( File fXmlFile )
inversa, pero el mismo DocumentBuilder ya se encarga de ello.  throws ParserConfigurationException,
SAXException,
Transformer es también una clase abstracta y requiere de IOException {
una fábrica para poder ser instanciada. La clase Transformer puede
Document doc = null ;
trabajar con multitud de contenedores de información porque en
realidad trabaja con un par de tipos adaptadores (clases que hacen doc = DocumentBuilderFactory.
compatibles jerarquías diferentes) que se llaman Source y Result. Las newInstance.newDocumentBuilder . parse ( fXmlFile ) ;
clases que implementen estas interfaces se encargarán de hacer doc. getDocumentElement.normalize ;
compatible un tipo de contenedor específico al requerimiento de la return doc ;
clase Transformer . Así, disponemos de las }
clases DOMSource, SAXSource o StreamSorce como adaptadores del ...
contenedor de la fuente de información ( DOM, SAX o Stream }
respectivamente). DOMResult, SAXResult o StreamResult son los
adaptadores equivalentes del contenedor destino.

El código básico para realizar una transformación de DOM archivo

de texto XML sería el siguiente:
6.1.1. La estructura DOM
La estructura DOM toma la forma de un árbol, donde cada parte
del XML se encontrará representada en forma de nodo. En función
de la posición en el documento XML, hablaremos de diferentes  Node.getAttribute(attrName) −
Retorna el atributo del nodo con
tipos de nodos. El nodo principal que representa todo el XML el nombre que se pasa como atributo.
entero denomina documento, y las diversas etiquetas, incluida la
etiqueta raíz, se conocen como nodos elemento. 
Para facilitar la obtención del contenido de
El contenido textual de una etiqueta se instancia como nodo de un Element ampliaremos las utilidades de la
tipo TextElement y los atributos como nodos de tipo Atribute. Cada clase XmlCtrlDom añadiendo dos métodos más.
nodo específico dispone de métodos para acceder a sus datos
concretos (nombre, valor, nodos hijos, nodo padre, etc.). public static String getValorEtiqueta ( String etiqueta,
Element elemento ) {
La estructura DOM toma la forma de un árbol, donde cada parte
Nodo nValue = elemento.
del XML se encontrará representada en forma de nodo. En función
getElementsByTagName ( etiqueta ) . item ( 0 ) ;
de la posición en el documento XML, hablaremos de diferentes
return nValue. getChildNodes . item ( 0 ) .
tipos de nodos. El nodo principal que representa todo el XML
getNodeValue ;
entero denomina documento, y las diversas etiquetas, incluida la
etiqueta raíz, se conocen como nodos elemento. El contenido }
textual de una etiqueta se instancia como nodo de tipo TextElement y
los atributos como nodos de tipo Atribute. Cada nodo específico public static Elemento getElementEtiqueta ( String
dispone de métodos para acceder a sus datos concretos (nombre, etiqueta, Element elemento ) {
valor, nodos hijos, nodo padre, etc.). return ( Element ) elemento.
getElementsByTagName ( etiqueta ).item ( 0 ) ;
El DOM resultante obtenido de un XML termina siendo una copia
}
exacta del archivo, pero con una disposición distinta. Tanto el
DOM como el XML tendrán información no visible, como los El primero recibe el nombre de la etiqueta y el elemento (o nodo
retornos de carro, que deben tenerse en cuenta para saber cómo parcial del árbol) a partir  del cual se desea realizar la búsqueda.
procesar correctamente el contenido y evitar sorpresas un poco Utilizando el método getElementsByTagName, conseguiremos todos los
comprensibles. nodos que tengan por nombre el valor del parámetro etiqueta. Es
decir, nos devolverá una colección de nodos. Si sólo existe un
Debes tener en cuenta que al mapear XML los retornos de carro se único nodo con el nombre del parámetro, éste ocupará la primera
interpretan en DOM como un hijo  y que  el contenido textual de posición de la lista. Por ello accedemos con el método item,
las etiquetas se plasma en el DOM como un nodo hijo de la indicando que nos interesa el primer elemento (posición cero).
etiqueta contenedora. Es decir, para obtener el texto de una etiqueta
hay que obtener el primer hijo de ésta. El segundo método es muy similar al primero, pero en vez de
recuperar el texto, obtendremos el nodo con todos los hijos que
La interfaz Documentcontempla un conjunto de métodos para tenga. Es útil para aplicar a nodos intermedios (no textuales).
seleccionar diferentes partes del árbol a partir del nombre de la
etiqueta o de un atributo identificador. Las partes del árbol se Los objetos Elemento disponen de métodos para añadir nuevos
devuelven como objetos Element, los cuales representan un nodo y hijos ( appendChild) o asignar el valor a un atributo ( setAtributte).
todos sus hijos. De este modo, podremos ir explorando partes del También permiten la consulta del valor de los atributos
árbol sin necesidad de tener que pasar por todos los nodos. ( getAttributte) o la navegación por los nodos del árbol ( getParentNode,
para obtener el padre; getFirstChild/getLastChild, para obtener el
primer / último hijo, o getNextSiblingpara navegar de hermano en
hermano).
Interfaces DOM 
El objeto Document hará de factory para cualquier nodo del
DOM define varias interfaces, las mas comunes son las documento. La creación de nuevos elementos (etiquetas) implicará
siguientes el uso de createElement. Si queremos crear contenido textual habrá
llamar al método createTextNode, y si lo que queremos son
 Node − Representa
a cualquier nodo del documento. comentarios llamaremos createComment.
 Element −
expone propiedades y métodos para manipular
los elementos del documento y sus atributos. La creación de nodos no implica la ubicación de este dentro del
 Attr − Representa un atributo de un elemento. árbol. Es decir, además de crearlos habrá asignarlos a un padre
usando appendChild.
 Text − Contenido de un elemento o atributo.
 Document − Representa al documento XML completo.
Generalmente nos referiremos a el como árbol 6.4.2. Ejemplo completo.
DOM. Proporciona información del documento. Permite El ejemplo siguiente muestra cómo utilizar DOM para analizar y
crear nuevos nodos en el documento. extraer información un fichero XML.
 NodeList. Colección de nodos a los que se puede acceder
Listamos la información contenida en el  documento clase.xml, si
por medio de un índice.
etiquetas.
Métodos DOM mas usuales
clase.xml
 Document.getDocumentElement() − Retorna el elemento raiz del
<? xml version = "1.0"?>
documento.
 Node.getFirstChild() −Retorna el primer nodo hijo del nodo.
<clase>
 Node.getLastChild() − Retorna el ultimo nodo  hijo del nodo.
<alumno numero = "393">
 Node.getNextSibling() − Retorna el siguiente hermano de un
<nombre> Luis </ nombre>
nodo.
<apellido> Luna </ apellido>
 Node.getPreviousSibling() −  Retorna el hermano anterior de
un nodo. <apodo> Na </ apodo>
 <marcas> 85 </ marcas> import org.w3c.dom.Node;
</ alumno> import org.w3c.dom.Element;
<alumno numero = "493"> public class DomParserDemo {
<nombre> Antonio </ nombre> public static void main(String[] args) {
<apellido> Alvarez</ apellido> try {
<apodo> Avez </ apodo> File inputFile = new File("clase.xml");
<marcas> 95 </ marcas> DocumentBuilderFactory dbFactory =
</ alumno> DocumentBuilderFactory.newInstance();
<alumno numero = "593"> DocumentBuilder dBuilder =
<nombre> Juan </ nombre> dbFactory.newDocumentBuilder();
<apellido> Juz </ apellido> Document doc = dBuilder.parse(inputFile);
<apodo> jazz </ apodo> doc.getDocumentElement().normalize();
<marcas> 90 </ marcas> System.out.println("Root element :" +
</ alumno> doc.getDocumentElement().getNodeName());
</ clase> NodeList nList = doc.getElementsByTagName("alumno");
System.out.println("----------------------------");
for (int temp = 0; temp < nList.getLength(); temp++) {
Pasos a seguir... Node nNode = nList.item(temp);
1.- Importar paquetes XML. System.out.println("\nCurrent Element :" +
nNode.getNodeName());
import org.w3c.dom.*; if (nNode.getNodeType() == Node.ELEMENT_NODE) {
import javax.xml.parsers.*; Element eElement = (Element) nNode;
import java.io.*; System.out.println("numero de alumno : "+
2.- Crear un SAXBuilder. eElement.getAttribute("numero"));
System.out.println("nombre : "+
DocumentBuilderFactory factory = eElement.getElementsByTagName("nombre").item(0).getTextCont
DocumentBuilderFactory.newInstance(); ent());
DocumentBuilder builder = factory.newDocumentBuilder(); System.out.println("apellido :"+
3.- Crear un documento para el flujo de datos. eElement.getElementsByTagName("apellido").item(0).getTextCon
tent());
StringBuilder xmlStringBuilder = new StringBuilder(); System.out.println("apodo : "+
xmlStringBuilder.append("<?xml version="1.0"?> <class> eElement.getElementsByTagName("apodo").item(0).getTextConte
</class>"); nt());
ByteArrayInputStream input = new ByteArrayInputStream( System.out.println("marcas :
xmlStringBuilder.toString().getBytes("UTF-8")); "+eElement.getElementsByTagName("marcas").item(0).getTextCo
Document doc = builder.parse(input); ntent());
4.- Extraer el elemento raíz. }
}
Element root = document.getDocumentElement(); } catch (Exception e) {
e.printStackTrace();
5.- Examinar atributos.
}
//returns specific attribute }
getAttribute("attributeName"); }

//returns a Map (table) of names/values

getAttributes(); 6.4.3 Creación de un fichero
6.- Examinar subelementos.
XML a partir de un
//returns a list of subelements of specified name
getElementsByTagName("subelementName"); documento.
La escritura de la información contenida en el DOM se puede
secuenciar en forma de texto utilizando otra utilidad de Java
//returns a list of all child nodes
llamada Transformer. Se trata de una utilidad que permite realizar
getChildNodes(); fácilmente conversiones entre diferentes representaciones de
información jerárquica. Es capaz, por ejemplo, de pasar la
El programa completo... información contenida en un objeto Documento a un archivo de
texto en formato XML.
import java.io.File;
import javax.xml.parsers.DocumentBuilderFactory; La escritura de la información contenida en el DOM se puede
import javax.xml.parsers.DocumentBuilder; secuenciar en forma de texto utilizando otra utilidad de Java
llamada Transformer . Se trata de una utilidad que permite
import org.w3c.dom.Document;
realizar fácilmente conversiones entre diferentes
import org.w3c.dom.NodeList;
representaciones de información jerárquica. Es capaz, por
ejemplo, de pasar la información contenida en un objeto
Documento a un archivo de texto en formato XML .  por el programador procesando el documento poco a
Transformer es también una clase abstracta y requiere de una fábrica
para poder ser instanciada. La clase Transformer puede trabajar con
multitud de contenedores de información porque en realidad trabaja
con un par de tipos adaptadores (clases que hacen compatibles
jerarquías diferentes) que se llaman Source y Result. Las clases que
implementen estas interfaces se encargarán de hacer compatible un
tipo de contenedor específico al requerimiento de la
clase Transformer. Así, disponemos de las clases DOMSource,
SAXSource o StreamSorce como adaptadores del contenedor de la
fuente de información ( DOM, SAX o Stream
respectivamente). DOMResult, SAXResult o StreamResult son los
adaptadores equivalentes del contenedor destino.
El código básico para realizar una transformación de DOM archivo
de texto XML sería el siguiente:
1.- Instanciar el documento DOM en memoria.
DocumentBuilderFactory factory = va cargando en memoria diferentes partes del mismo, cosa
DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
DOMImplementation implementation = Es conveniente utilizar SAX:
builder.getDOMImplementation();
Document document = implementation.createDocument(null,
name, null);
2.- El documento DOM se crea en memoria creando primero el
elemento raíz.
Element raiz = document.getDocumentElement();
y a partir de el añadiendo otros elementos, los métodos:
createElement(String tagName) //crea el elemento del tipo
especificado
createTextNode(String data)//crea un Textnode dando valor
(Node newChild)
appendChild(Node newChild)
//añade un nodo hijo al final de de la lista de nodos hijos del
nodo3.- Creación e instalación Transformer.
<span>Transformer trans = 
TransformerFactory.newInstance&nbsp;.newTransformer&nbsp;;<
br></span><span id="yui_3_17_2_1_1596016483417_136">
// Creación de los adaptadores Source y Results a partir de un
Documento
<br></span><span>
// y un File.<br></span><span>StreamResult result = new
StreamResult ( file ) ;
<br></span><span>DOMSource source = new DOMSource ( doc )
;<br></span>
<span>trans. transform ( source, result ) ;</span>
6.2. SAX.
SAX (API Simple para XML), es una interfaz simple de
aplicaciones XML, fácil e intuitiva. El parser trabaja de la siguiente
forma:
1. Lee un fichero XML de forma secuencial, produciendo
eventos de manera secuencial en función de los
resultados de lectura.
2. Cada evento invoca a un método que ha sido realizado
poco y no consumiendo prácticamente memoria, aunque
por otra parte impide tener visión general de todo el
documento XML.
SAX (API Simple para XML), es una interfaz simple de
aplicaciones XML, fácil e intuitiva. El parser trabaja de la siguiente
forma:
1. Lee un fichero XML de forma secuencial, produciendo
eventos de manera secuencial en función de los
resultados de lectura.
2. Cada evento invoca a un método que ha sido realizado
por el programador procesando el documento poco a
poco y no consumiendo prácticamente memoria, aunque
por otra parte impide tener visión general de todo el
documento XML.
3.
Permite analizar el documento  XML de forma secuencial, es decir,
contraria a lo que hace DOM que carga todo el documento de golpe
en memoria.
 Cuando el documento XML  es considerablemente
grande.
 Cuando no se requiere una modificación estructural.
 Si se quiere parsear diferentes partes del documento.
La lectura de un documento XML produce eventos los cuales
invocan a métodos, los eventos son: inicio y fin de un archivo
XML(startDocument() y endDocument()), inicio y fin de un elemento
(startElement() y endElement()) y la información que llevan las diferentes
etiquetas (characters()).
SAX genera un objeto procesador de XML llamado XMLReader,
para después decir que objetos tienen métodos para transferir los
eventos. Estos objetos implementan los siguientes interfaces:
 ContentHandler, el cual recibe las notificaciones de los
eventos del fichero XML.
 DTDHandler, que recoge los eventos del DTD del fichero.
ErrorHandler, crea el tratamiento de errores.
 EntityResolver, se utilizan siempre que se referencia a otra
entidad.
 DefaultHandler, la cual implementa por defecto los métodos,
siendo el programador quien los defina. Con esta clase se
podrá crear el parser XML. Se compone de los siguientes
eventos básicos:
o startDocument: se llama cuando se detecta que el
documento empieza. Aquí deben indicarse las
acciones a realizar al inicio del documento.
o endDocument: se llama cuando se detecta que el
documento ha acabado. Por lo tanto, aquí
deben indicarse las acciones a realizar al
finalizar el documento.
o startElement: Se llama cuando encuentra un
nuevo elemento, nodo, etiqueta, tag, etc. Aquí
debe indicarse el tratamiento que se deberá
realizar sobre cada nuevo elemento, como la
recogida de información de sus atributos.
o endElement: Se llama una vez ha leído el
elemento. Aquí se encuentra la información del
nodo y del contenido del nodo por lo que es
 aquí donde, normalmente, se recoge la
información.
o Characters: se invoca para encontrar una cadena
de texto.
6.3. StAX.
StAX es una API basada en Java para analizar documentos
XML de forma similar a como lo hace el analizador SAX. Pero
hay dos diferencias principales entre las dos API:
 StAX es una API PULL, mientras que SAX es una API
PUSH. Significa que en el caso del analizador StAX, una
aplicación cliente necesita solicitar al analizador StAX
que obtenga información de XML siempre que lo
necesite. Pero en el caso del analizador SAX, se requiere
una aplicación cliente para obtener información cuando
el analizador SAX notifica a la aplicación cliente que la
información está disponible.
 StAX API puede leer y escribir documentos
XML. Usando SAX API, un archivo XML solo se puede
leer.
StAX consta realmente de 2 distintas API:
 API Cursor: Representa un cursor con el cual se puede ir
hacia adelante en un documento XML desde el principio
hasta el final. Este cursor puede apuntar un elemento a
la vez y siempre se mueve hacia adelante, nunca hacia
atrás.
 API Iterator : Representa un flujo de un documento XML
como un conjunto de objetos de eventos discretos. La
aplicación saca estos eventos en el mismo orden que los
proporciona el parser al leerlos del documento XML. Por
cada paso de iteración se obtiene un objeto XMLEvent, que
contiene información sobre el evento generado en el
proceso de lectura de la información. Mediante la
referencia a este objeto, podemos extraer la información
de los eventos generados, con los métodos que
proporciona esta clase.
Una de las principales diferencias entre ambos estilos es que
cuando se usa la Iterator API es posible ir hacia atras en la jerarquia ,
cosa que no puede realizarse cuando utilizamos la Cursor API, ya
que una vez mueves el cursor hacia el próximo evento, no se tiene
información acerca del evento previo. Sin embargo la Cursor API
es mas eficiente en cuanto a memoria, así que la selección de que
estilo de API utilizar dependerá de las necesidades.
6.3.1. Características de StAX
Las siguientes son las características de StAX API:
 Lee un documento XML de arriba a abajo, reconociendo
los tokens que componen un documento XML bien
formado.
 Los tokens se procesan en el mismo orden en que
aparecen en el documento.
 Informa sobre el programa de aplicación la naturaleza de
los tokens que el analizador ha encontrado a medida que
ocurren.
 El programa de aplicación proporciona un lector de
"eventos" que actúa como un iterador e itera sobre el
evento para obtener la información requerida. Otro lector
disponible es "cursor" que actúa como un puntero a los
nodos XML.
 A medida que se identifican los eventos, los elementos
XML pueden recuperarse del objeto de evento y pueden
procesarse más.
Debemos usar un analizador StAX cuando:
 Puede procesar el documento XML de forma lineal de
arriba a abajo.
 El documento no está profundamente anidado.
 Está procesando un documento XML muy grande cuyo
árbol DOM consumiría demasiada memoria. Las
implementaciones DOM típicas usan diez bytes de
memoria para representar un byte de XML.
 El problema a resolver involucra solo una parte del
documento XML.
 Los datos están disponibles tan pronto como el
analizador los vea, por lo que StAX funciona bien para
un documento XML que llega a través de una
transmisión.
Para poder utilizar clases e interfaces de ambas
API necesitamos un origen de datos XML valido. Esto lo
conseguimos con la factoria XMLInputFactory:
XMLInputFactory xmlif = XMLInputFactory.newInstance();
XMLStreamReader xmlsr =xmlif.createXMLStreamReader(new
FileReader("books.xml"));
o bien 
XMLInputFactory inputFactory =
XMLInputFactory.newInstance();
InputStream in = new FileInputStream("books.xml");
Como deciamos anteriormente,  STAX consiste en dos API
llamados lectores "Iterador" y "cursor"
 ¿Cómo funciona?
El analizador crea diferentes tipos de eventos a medida que avanza
leyendo el documento XML de origen.
Algunos de los tipos de eventos importantes son:
1. Comience el documento
2. Elemento de inicio
3. Comentarios
4. Caracteres
5. Elemento final
6. Documento final
partimos del siguiente documento XML:
<? xml version = "1.0"?>
<BookCatalogue xmlns = "http://www.publishing.org">
<Libro>
<Título> Yogasana Vijnana: la ciencia del yoga </ Title>
<ISBN> 81-40-34319-4 </ ISBN>
<Cost currency = "INR"> 11.50 </ Cost>
</ Book>
</ BookCatalogue>
Este documento genera 18 eventos entre primarios y secundarios:
 # Element/Attribute Event
1 version="1.0" StartDocument
2 isCData = false data = "\n" IsWhiteSpace = true Characters
3 qname = BookCatalogue:http://www.publishing.org attributes = null namespaces = StartElement
{BookCatalogue" -> http://www.publishing.org"}
4 qname = Book attributes = null namespaces = null StartElement
5 qname = Title attributes = null namespaces = null StartElement
6 isCData = false data = "Yogasana Vijnana: the Science of Yoga\n\t" IsWhiteSpace = false Characters
7 qname = Title namespaces = null EndElement
8 qname = ISBN attributes = null namespaces = null StartElement
9 isCData = false data = "81-40-34319-4\n\t" IsWhiteSpace = false Characters
10 qname = ISBN namespaces = null EndElement
11 qname = Cost attributes = {"currency" -> INR} namespaces = null StartElement
12 isCData = false data = "11.50\n\t" IsWhiteSpace = false Characters
13 qname = Cost namespaces = null EndElement
14 isCData = false data = "\n" IsWhiteSpace = true Characters
15 qname = Book namespaces = null EndElement
16 isCData = false data = "\n" IsWhiteSpace = true Characters
17 qname = BookCatalogue:http://www.publishing.org namespaces = {BookCatalogue" -> EndElement
http://www.publishing.org"}
18 EndDocument

 Los eventos se crean en el orden en que se encuentran los books.xml

elementos XML correspondientes en el documento,
incluida la anidación de elementos, la apertura y el cierre <bookstore>
de elementos, el orden de los atributos, el inicio del <book category="cooking">
documento y el final del documento, y así sucesivamente. <title lang="en">Everyday Italian</title>
 Al igual que con la sintaxis XML adecuada, todos los <author>Giada De Laurentiis</author>
elementos del contenedor tienen los correspondientes <year>2005</year>
eventos de inicio y final; por ejemplo, <price>30.00</price>
cada StartElement tiene un EndElement correspondiente , </book>
incluso para elementos vacíos.
<book category="children">
 Los eventos de atributo se tratan como eventos
<title lang="en">Harry Potter</title>
secundarios, y se accede a ellos desde su
<author>J K. Rowling</author>
evento StartElement correspondiente .
<year>2005</year>
 De forma similar a los eventos de Atributo , los eventos
de Espacio de nombres se tratan como secundarios, pero <price>29.99</price>
aparecen dos veces y son accesibles dos veces en la </book>
secuencia de eventos, primero desde <book category="web">
su StartElement correspondiente y luego desde <title lang="en">XQuery Kick Start</title>
su EndElement correspondiente . <author>James McGovern</author>
 Los eventos de caracteres se especifican para todos los <author>Per Bothner</author>
elementos, incluso si esos elementos no tienen datos de <author>Kurt Cagle</author>
caracteres. Del mismo modo, los eventos de carácter se
<author>James Linn</author>
pueden dividir entre eventos.
<author>Vaidyanathan Nagarajan</author>
 El analizador StAX mantiene una pila de espacio de
<year>2003</year>
nombres, que contiene información sobre todos los
espacios de nombres XML definidos para el elemento <price>49.99</price>
actual y sus antecesores. Se puede acceder a la pila del </book>
espacio de nombres, que se expone a través de la <book category="web" cover="paperback">
interfaz javax.xml.namespace.NamespaceContext , mediante el <title lang="en">Learning XML</title>
prefijo del espacio de nombres o el URI. <author>Erik T. Ray</author>
<year>2003</year>
<price>39.95</price>
6.3.2. Ejemplo de API Cursor </book>
El siguiente programa es un ejemplo muy sencillo de como utilizar </bookstore>
un cursor para recorrer un documento XMLPartiendo del
documento XML books.xml,  listamos los  títulos de los libros.
import java.io.FileNotFoundException; XMLInputFactory inputFactory =
import java.io.FileReader; XMLInputFactory.newInstance();
import java.util.ArrayList; // Configura un nuevo eventReader a partir del fichero XML
import javax.xml.stream.FactoryConfigurationError; InputStream in = null;
import javax.xml.stream.XMLInputFactory; try {
import javax.xml.stream.XMLStreamException; in = new FileInputStream("books.xml");
import javax.xml.stream.XMLStreamReader; } catch (FileNotFoundException e1) {
import javax.xml.stream.events.XMLEvent; e1.printStackTrace();
//El programa java que recorre el documento para extraer los titulos }
y el atributo lang es el siguiente try {
&nbsp;public class ListaLibros {
public static void main(String[] args) throws XMLEventReader eventReader =
FileNotFoundException, XMLStreamException { InputFactory.createXMLEventReader(in);
// Creamos el flujo // repetitiva que recorre todos los eventos
XMLInputFactory xmlif = XMLInputFactory.newInstance(); while (eventReader.hasNext()) {
XMLStreamReader xmlsr = xmlif.createXMLStreamReader(new XMLEvent event = eventReader.nextEvent();
FileReader("books.xml")); // si el evento es el inicio del nodo titulo
String tag = null; // avanzo un evento para obtener el titulo del libro
int eventType; if (event.getEventType() ==
System.out.println("Lista de libros"); MLStreamConstants.START_ELEMENT) {
// iteramos con el cursor a lo largo del documento StartElement startElement = event.asStartElement();
while (xmlsr.hasNext()) { if (startElement.getName().getLocalPart() == "title") {
eventType = xmlsr.next(); Iterator iterator = ((StartElement) event).getAttributes();
switch (eventType) { while (iterator.hasNext())
case XMLEvent.START_ELEMENT: { Attribute attribute = (Attribute) iterator.next();
tag = xmlsr.getLocalName(); QName name = attribute.getName();
if (tag.equals("title")) { String value = attribute.getValue();
System.out.println(xmlsr.getElementText() + " System.out.println("Atributo name/valor: " ++ "/" +
idioma&nbsp; " + xmlsr.getAttributeValue(0)); value); }
} event = eventReader.nextEvent();
break; System.out.println((String)
case XMLEvent.END_DOCUMENT: event.asCharacters().getData()); }
System.out.println("Fin del documento"); } else if (event.getEventType() ==
break; XMLStreamConstants.END_DOCUMENT)
} { System.out.println("fin del documento");
} }
} }
} } catch (XMLStreamException e) {
e.printStackTrace();
}
6.3.3. Ejemplo de API Event }
}
Utilizamos el documento books.XML  del ejemplo de la API
cursor, el listado es similar al ejemplo de API de cursor

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.Iterator;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;
public class EventReader {
public static void main(String[] args) {
// primero crea un nuevo XMLInputFactory
6.4. Binding
El Binding es una técnica que consiste en vincular clases Java con
formatos específicos de almacenamiento de manera automatizada. 
El Binding es una técnica que consiste en vincular clases Java
con formatos específicos de almacenamiento de manera
automatizada. 
En Java existen varias bibliotecas para gestionar el binding , como
por ejemplo JAXB , JiBX , XMLBinding , etc. Desde la versión 6.0
se ha incorporado en el JDK estándar JAXB, una potente biblioteca.
Java Architecture for XML Binding (JAXB) permite a los
desarrolladores Java asignar clases de Java a representaciones
XML. JAXB proporciona dos características principales: la
capacidad de serializar las referencias de objetos Java a XML y la
inversa, es decir, deserializar XML en objetos Java. En otras
palabras, JAXB permite almacenar y recuperar datos en memoria
en cualquier formato XML, sin la necesidad de implementar un <ListaLibro>
conjunto específico de rutinas de carga y guardado de XML para la <Libro>
estructura de clases del programa.  <autor>XXXXXXX</autor>
La siguiente figura muestra lo que ocurre durante el proceso de <nombre>XXXXXXX</nombre>
enlace de JAXB. <editorial>XXXXXXX</editorial>
<isbn>XXXXXXX</isbn>
</Libro>
......
</ListaLibro>
....
<lugar>XXXXXXX</lugar>
<nombre>XXXXXX</nombre>
</libreria>
Para mapear la raiz es necesario una clase librería con anotación
@XmlRootElement.
6.4.1. Configuración con      
anotaciones @XmlRootElement
Las Anotaciones pueden asociarse a un paquete, a una clase, a
un atributo o incluso a un parámetro. Estas clases especiales se public class Libreria {
declaran en el código de la aplicación anteponiendo el símbolo .....
@ en el nombre de la Anotación. }
Esta clase tiene un atributo por cada etiqueta del XML incluido
Las Anotaciones pueden asociarse a un paquete, a una clase, a ListaLibro que es un array de elementos de tipo Libro:
un atributo o incluso a un parámetro. Estas clases especiales se
declaran en el código de la aplicación anteponiendo el símbolo @XmlElementWrapper(name = "ListaLibro")
@ en el nombre de la Anotación . Cuando el compilador de Java @XmlElement(name = "Libro")
detecta una Anotación crea una instancia y la inyecta en el
private ArrayList<Libro> ListaLibro;
elemento estructural afectado (paquete, clase, método, atributo,
etc.). Esto hace que éstas no aparezcan como atributos o métodos
propios del objeto, y por eso decimos que no interacciona con el
modelo de datos, pero las aplicaciones que lo necesiten pueden
obtener la instancia inyectada y usarla.

Las Anotaciones pueden declararse con parámetros o sin

ellos. En caso de que tengan parámetros, estos pueden ser otros
Anotaciones, valores constantes o valores literales, de modo que La clase librería, es la clase que mapea  el XML 
estén disponibles en tiempo de compilación (que es cuando el
import java.util.ArrayList;
compilador realiza la inyección).
import javax.xml.bind.annotation.XmlElement;
Anotaciones principales. import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(namespace = "namespace", name = "nombre" ): Define la raíz
del XML. //Esto significa que la clases "Libreria.java" es el elemento raiz
@XmlType(propOrder = { "field2", "field1",.. }, name = "nombre"): Permite @XmlRootElement
definir en que orden se van escribir los elementos dentro del XML. public class Libreria {
Esta anotación deberán tenerla todas las clases que no mapean la //Wrapper
raiz del XML. @XmlElementWrapper(name = "ListaLibro")
@XmlElement(name = "nombre"):  Define el elemento de XML que se va
@XmlElement(name = "Libro")
usar. Si el atributo de la clase tiene el mismo nombre que la
private ArrayList<Libro> ListaLibro;
etiqueta XML, podemos omitirlo. Tenemos que escribir esta
anotación  antes del método setter correspondiente. Mirar ejemplos private String nombre;
en el siguiente subcapitulo. private String lugar;
@XmlAttribute se utiliza para mapear atributos a los nodos XML.  public ArrayList<Libro> getListaLibro() {
@XmlElementWrapper: ofrece la posibilidad de crear un contenedor return ListaLibro;
alrededor de una representación XML. Este contenedor puede }
contener una colección de elementos. public void setListaLibro(ArrayList<Libro> ListaLibro) {
El parámetro name = "nombre" permite especificar el nombre de la this.ListaLibro = ListaLibro;
etiqueta XML. }
public void setNombre(String nombre) {
6.4.2. Ejemplos con }
this.nombre = nombre;

anotaciones. public void setLugar(String lugar) {

Tenemos la estructura XML siguiente: this.lugar = lugar;
}
<libreria>
 public String getNombre() { el código fuente, podremos escribir una aplicación
return nombre; basada en las clases que resulten.
3. Construir el árbol de objetos Java: con nuestra
}
aplicación, se genera el árbol de objetos java, también
public String getLugar() {
llamado árbol de contenido, que representa los datos
return lugar; XML que son validados con el esquema. Hay dos formas
} de hacer esto:
} o Instanciando las clases generadas.
La clase libro que mapea cada uno de los nodos <Libro> del o Invocando al método unmarshall de una clase
XML generada y pasarlo en el documento. El método
unmarshall toma un documento XML válido y
import javax.xml.bind.annotation.XmlType; construye una representación de árbol de
@XmlType(propOrder = { "autor", "nombre", "editorial", "isbn" }) objetos.
public class Libro { 4. Acceder al árbol de contenido usando nuestra
private String nombre; aplicación: ahora podemos acceder al árbol de contenido
private String autor; y modificar sus datos.
5. Generar un documento XML desde el árbol de
private String editorial;
contenido. Para poder hacerlo tenemos que invocar al
private String isbn; método marshall sobre el objeto raíz del árbol.
public String getNombre() {
return nombre; JAXB proporciona dos principales características:
}
 La capacidad de serializar (marshalling) objetos Java a
public String getAutor() {
XML.
return autor;
}  Lo inverso, es decir, deserializar (unmarshalling) XML a
public String getEditorial() { objetos Java.
return editorial;
O sea que JAXB permite almacenar y recuperar datos en
} memoria en cualquier formato XML, sin la necesidad de
public String getIsbn() { implementar un conjunto específico de rutinas XML de carga y
return isbn; salvaguarda para la estructura de clases del programa.
}
El compilador de JAXB (schema compiler) permite generar una
public void setNombre(String nombre) {
serie de clases Java que podrán ser llamadas desde nuestras
this.nombre = nombre;
aplicaciones a través de métodos sets y gets para obtener o
} establecer los datos de un documento XML.
public void setAutor(String autor) {
this.autor = autor; Los pasos en el proceso de enlace de JAXB están representados en
} la figura:
public void setEditorial(String editorial) {
this.editorial = editorial;
}
public void setIsbn(String isbn) {
this.isbn = isbn;
}
}

1. Generar clases: podemos escribirlas manualmente, como

6.4.3. Funcionamiento de
JAXB
Para construir una aplicación JAXB necesitamos tener un esquema
XML.
Tras obtener el esquema XML, seguimos los siguientes pasos
para construir la aplicación JAXB:
1. Escribir el esquema: es un documento XML que
contiene la estructura que se tomará como indicaciones
para construir las clases. Estas indicaciones pueden ser,
por ejemplo, el tipo primitivo al que se debe unir un valor
de atributo en la clase generada.
2. Generar los ficheros fuente de Java: para esto usamos
el compilador de esquema, ya que éste toma el esquema
como entrada de información. Cuando se haya compilado
en el capitulo anterior o utilizar las clases  generadas por
el IDE JAXB automáticamente utilizando el esquema
.xsd correspondiente al XML, lo veremos más adelante.
2. Deben compilarse todas las clases generadas, los
archivos fuente y el código de la aplicación .
3. Aplicar Marshall a los objetos de las clases mapeadas
para crear XML
4. Aplicar UnMarshall al XML para obtener objetos de las
clases mapeadas . 
Marshall
Para poder hacer esta traducción, lo primero que necesitamos es un
contexto, el cual instanciaremos pasándole la clase de nuestro root:             
&nbsp;JAXBContext jaxbContext = libro1.setNombre("The Game");
JAXBContext.newInstance(Libreria.class); libro1.setAutor("Neil Strauss");
libro1.setEditorial("Harpercollins");
Ya tenemos un contexto y ahora toca generar nuestro Marshaller
libroLista.add(libro1);
       Libro libro2 = new Libro();
libro2.setIsbn("978-3832180577");
Marshaller marshaller = jaxbContext.createMarshaller(); libro2.setNombre("Feuchtgebiete");
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPU libro2.setAutor("Charlotte Roche");
T, true);
libro2.setEditorial("Dumont Buchverlag");
libroLista.add(libro2);
Para obtener un resultado, debemos pasarle una salida a nuestro // Se crea La libreria y se le asigna la lista de libros
marshaller. Aquí tienes un par de ejemplo de como hacerlo.         Libreria libreria = new Libreria();
libreria.setNombre("LIbreria sin limite");
marshaller.marshal(libreria, System.out);
libreria.setLugar("Barrio Obrero");
o bien              libreria.setListaLibro(libroLista);
// Creamos un contexto de la clase JAXB y lo intanciamos
File libreria-jaxb = this.getFile(); JAXBContext context =
if (libreria-jaxbl != null) { JAXBContext.newInstance(Libreria.class);
marshaller.marshal(libreria, libreria-jaxb); Marshaller m = context.createMarshaller();
} m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,
Boolean.TRUE);
// Lo creamos con system out
UnMarshall
m.marshal(libreria, System.out);
Otra parte también fácil, tenemos varios inputs y utilizaremos el // Escribimos en el archivo
fichero por ahora para poder parsear. Partiendo de que tenemos ya m.marshal(libreria, new File(LIBRERIA_XML));
un contexto, el cual reutilizaremos en esta parte.     // Obtenemos las variables obtenidas del XML creado
anteriormente
Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
System.out.println();
System.out.println("Salida del XML: ");
Libreria libreria = (Libreria) unmarshaller.unmarshal( libreria-
Unmarshaller um = context.createUnmarshaller();
jaxb);
Libreria libreria2 = (Libreria) um.unmarshal(new
FileReader(LIBRERIA_XML));
Así de simple, recuperaremos o pasaremos de nuestro fichero xml a ArrayList<Libro> lista = libreria2.getListaLibro();
un objeto el cual tenemos ya mapeado for (Libro libro : lista) {
System.out.println("Libro: " + libro.getNombre() + " de " +
libro.getAutor());
}
6.4.4. Ejemplo: Marshall, }

Unmarshall. }

Una vez que tenemos el proyecto con las clases del apartado
Ejemplo anotaciones, vamos a añadir el siguiente programa
6,7,5, Generación automática de
import java.io.File;
import java.io.FileReader; clases Java a partir del esquema
import java.io.IOException;
import java.util.ArrayList;
.xsd.
AXB es una parte de la plataforma Java SE y una de las APIs de la
import javax.xml.bind.JAXBContext;
plataforma Java EE, y es parte del Java Web Services Development
import javax.xml.bind.JAXBException; Pack (JWSDP). También es uno de los fundamentos para WSIT.
import javax.xml.bind.Marshaller; JAXB es parte de la versión 1.6 SE.
import javax.xml.bind.Unmarshaller;
JAXB es una parte de la plataforma Java SE y una de las APIs de
public class JavaJAXB {
la plataforma Java EE, y es parte del Java Web Services
private static final String LIBRERIA_XML = "./libreria-
Development Pack (JWSDP). También es uno de los fundamentos
jaxb.xml";
para WSIT. JAXB es parte de la versión 1.6 SE.
public static void main(String[] args) throws JAXBException,
IOException { La herramienta "xjc" se puede utilizar para convertir un XML
// Lista de LIbros Schema y otros tipos de archivo de esquemas (en Java 1.6, RELAX
ArrayList<Libro> libroLista = new ArrayList<Libro>(); NG, XML DTD y WSDL son compatibles experimentalmente) a
// Creamos varios libros representaciones de clase. Las clases son marcadas usando
anotaciones del espacio de nombres javax.xml.bind.annotation.*, por
Libro libro1 = new Libro();
ejemplo, @XmlRootElement y @XmlElement. Las secuencias de listas
libro1.setIsbn("978-0060554736"); XML se representan con atributos de tipo java.util.List.
Los serializadores y deserializadores se crean a través de una
instancia de JAXBContext. Byte

Además, JAXB incluye la herramienta " schemagen" que en esencia

puede llevar a cabo la inversa de "xjc", creando un XML Schema a xsd:unsigned
java.math.BigDecimal
partir de un conjunto de clases anotadas. Long

La siguiente tabla muestra las asignaciones de tipos de datos XML

Schema (XSD) a tipos de datos Java en JAXB: javax.xml.datatype.XMLGre
xsd:time
gorianCalendar
Tipo de
XML Tipo de dato Java
javax.xml.datatype.XMLGre
Schema xsd:date
gorianCalendar

xsd:string java.lang.String
javax.xml.datatype.XMLGre
xsd:g
gorianCalendar
xsd:positiveI
java.math.BigInteger
nteger
xsd:anySimp
leType (for
java.lang.Object
xsd:element
xsd:int int
of this type)

xsd:long long
xsd:anySimp
leType (for
java.lang.String
xsd:short short xsd:attribute
of this type)

xsd:decimal java.math.BigDecimal
xsd:duration javax.xml.datatype.Duration

xsd:float float
xsd:NOTAT
javax.xml.namespace.QName
ION
xsd:double double

xsd:boolean boolean Los pasos para obtener las clases IDE Eclipse

1. Descargar la distribución:
xsd:byte byte Download standalone distribution, descomprimimos el
fichero.
2. Añadir todas las clases que estan en la carpeta \jaxb-ri-
xsd:QName javax.xml.namespace.QName 2.3.0\jaxb-ri\lib, jaxb-api.jar, jaxb-core.jar, jaxb-
impl.jar, jaxb-jxc.jar, jaxb-xjc.jar
3. Obtener el esquema .xsd a partir del XML.
xsd:dateTim javax.xml.datatype.XMLGre 4. Crear un proyecto en Eclipse, en la carpeta scr del
e gorianCalendar proyecto situar el esquema  y en la carpeta raíz del
proyecto situamos el fichero XML .Para generar las
clases de forma automática clicamos el botón derecho del
xsd:base64Bi ratón sobre el esquema, generate -> JAXB Classes.
byte[]
nary

xsd:hexBina
byte[]
7.Librerías para
ry

xsd:unsigned
Int
long conversión de
xsd:unsigned
documentos XML a
int
Short
otros formatos
xsd:unsigned short En la mayoría de las aplicaciones informáticas, hay que mostrar la
información resultante de los procesos que se ejecutan, sobre todo
en aplicaciones que generan información que implica tomar
decisiones comerciales. Dicha información está almacenada
normalmente en bases de datos o en archivos.
Hoy en día, XML está muy extendido, y muchas empresas guardan
la información en ficheros o bases de datos con ese formato.
Hay muchos productos o herramientas informáticas que permiten
convertir documentos XML a otros formatos.
En nuestro caso, vamos a optar por una herramienta que permite
generar informes de todo tipo en Java de una forma sencilla:
JasperReport.
Esta herramienta permite generar informes electrónicos en formato
pdf, quizás el formato más usado debido a su portabilidad entre
sistemas conservando la apariencia. Pero existen muchos más: xls,
html, rtf, csv, xml, etc
1.11. Introducción a
JasperReport
En Java, durante un tiempo, la generación de informes fue uno de
los puntos débiles del lenguaje, pero hoy en día, existen muchas
librerías y herramientas dedicadas (varias de ellas, de código
abierto) para la rápida generación de informes. JasperReports, es
una de las más conocidas.
JasperReports es una herramienta que consta de un poderoso motor
para la generación de informes. Está empaquetada en un archivo
JAR y puede ser utilizada como una librería, la cuál podemos
integrar en cualquier IDE de desarrollo en Java para desarrollar
nuestras aplicaciones. Está escrita totalmente en Java, su código es
abierto y es totalmente gratuita bajo los términos de la licencia
GPL (Licencia Pública General).
En la presentación que acabas de ver, al descomprimir el fichero de
la descarga, has visto que en el mismo hay varios directorios o
carpetas. Comentamos brevemente qué contiene cada una:
 build: es la librería JasperReports sin empaquetar, con
todas las clases que incluye.
 demo: podemos encontrar algunos ejemplos de
utilización de la librería. Estos ejemplos están preparados
para ser compilados con la herramienta "ant". Puedes
inspeccionar el código Java e intentar compilarlos y
ejecutarlos.
 dist: es donde se encuentra realmente la librería
empaquetada en un fichero JAR (jasperreports-3.7.4.jar) y
algunos ficheros JAR que no utilizaremos. También
podemos acceder a la documentación tipo javadoc.
 docs: es la referencia rápida en formato XML.
 lib: Diferentes librerías necesarias por JasperReports,
como algunas para exportar a distintos formatos, para
incluir gráficos, etc.
 src: Ficheros fuente de la librería.
1.12. Diseñar y compilar la
plantilla
Las plantillas de los informes de JasperReports son sencillamente
ficheros XML con la extensión .jrxml. Podemos hacer que
NetBeans reconozca este tipo de ficheros como XML, para que
cuando los editemos en el editor se muestren los mismos códigos
de colores en las etiquetas y demás elementos de la sintaxis de
XML.
En la imagen se ilustra cómo conseguirlo: en NetBeans pinchamos
en el menú Tools, y ahí en Options. Ahí seleccionamos
Miscellaneous, luego la pestaña Files. Entonces pulsamos en el
botón New... para añadir la nueva extensión.
Los pasos a seguir para trabajar con JasperReport serían:
Paso 1: Diseñar la plantilla del informe: un fichero .jrxml. El
documento de diseño está representado por un archivo XML que
mantiene la estructura de un archivo DTD (Document Type
Definition) definido por el motor de JasperReports.
La generación de un diseño implica editar un archivo XML
validado mediante:
<!DOCTYPE jasperReport PUBLIC "-//JasperReports//DTD
Report Design//EN"
"http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">
Estos documentos XML cuentan con una estructura similar a la de
cualquier documento de texto. Fundamentalmente se siguen estas
secciones:
 title Título del informe.
 pageHeader Encabezado del documento.
 columnHeader Encabezado de las columnas.
 detail Detalle del documento. Cuerpo
 columnFooter Pie de la columna.
 pageFooter Pie del documento.
 sumary Cierre del documento.
Paso 2: Compilación: Una vez que se ha realizado el diseño, se
compila antes de poder iniciar el proceso de carga de datos. La
compilación se lleva a cabo a través del método compileReport().
En este proceso, el diseño se transforma en un objeto serializable
de tipo net.sf.jasperreports.engine JasperReport, que luego se guarda en
disco.
1.13. Rellenar el informe
con datos, exportar el
informe
Paso 3: Rellenar el informe con datos: mediante los métodos
fillReportXXX(), se puede realizar la carga de datos del informe,
pasándole como parámetros el objeto de diseño (o bien, el archivo
que lo representa en formato serializado) y la conexión JDBC a la
base de datos desde donde se obtendrá la información que
necesitemos.

Como resultado de este proceso, se obtiene un objeto que

representa un documento listo para ser impreso, un objeto
serializable de tipo JasperPrint. Este objeto puede guardarse en
disco para su uso posterior, o bien puede ser impreso, enviado a la
pantalla o transformado en PDF, XLS, CSV, etc.

Paso 4: Visualización

Ahora podemos optar por mostrar un informe por pantalla,

imprimirlo, o bien obtenerlo en algún tipo específico de fichero,
como PDF, etc.

 Para mostrar un informe por pantalla se utiliza la clase

JasperViewer, la cual, a través de su método main(), recibe el
informe a mostrar.
 Para imprimir el informe usaremos los métodos
printReport(), printPage() o printPages(), contenidos en la clase
JasperPrintManager.
 Para exportar los datos a un formato de archivo
específico podemos utilizar los métodos
exportReportXXX().

8.Anexo I.- Listar ficheros

de una carpeta, filtrando.

9.Anexo II.- Código de

separador de rutas

10. Anexo III.- Código
de crear un fichero
Tema 3. Manejo de conectores
1.Introducción
Actualmente, las bases de datos relacionales constituyen el
sistema de almacenamiento probablemente más extendido, aunque
otros sistemas de almacenamiento de la información se estén
abriendo paso poco a poco.
Una base de datos relacional se puede definir, de una manera
simple, como aquella que presenta la información en tablas con
filas y columnas.
Una tabla o relación es una colección de objetos del mismo tipo
(filas o tuplas).
En cada tabla de una base de datos se elige una clave primaria para
identificar de manera unívoca a cada fila de esta.
11. Anexo IV.- Código
de crear un directorio
El sistema gestor de bases de datos, en inglés conocido como:
Database Management System (DBMS) gestiona el modo en que
los datos se almacenan, mantienen y recuperan.
En el caso de una base de datos relacional, el sistema gestor de
base de datos se denomina: Relational Database Management
System (RDBMS).
Tradicionalmente, la programación de bases de datos ha sido como
una torre de Babel: gran cantidad de productos de bases de datos en
el mercado y cada uno "hablando" en su lenguaje privado con las
aplicaciones.
Java, mediante JDBC (Java Database Connectivity), permite
simplificar el acceso a bases de datos relacionales, proporcionando
un lenguaje mediante el cual las aplicaciones pueden comunicarse
con motores de bases de datos. Sun desarrolló este API para el
acceso a bases de datos, con tres objetivos principales en mente:
 Ser un API con soporte de SQL: poder construir
sentencias SQL e insertarlas dentro de llamadas al API
de Java.
 Aprovechar la experiencia de los API's de bases de
datos existentes.
 Ser lo más sencillo posible.
 1.1. El desfase objeto- 2. Protocolos de acceso
relacional a bases de datos
Inicialmente, cada empresa desarrolladora de un SGBD
implementaba soluciones propietarias específicas para su
sistema, pero pronto se dieron cuenta de que colaborando
conjuntamente podían sacar mayor rendimiento y avanzar
mucho más rápidamente.

Cada SGBD tiene su propia conexión y su propio API

El desfase objeto-relacional, también conocido como impedancia
objeto-relacional, consiste en la diferencia de aspectos que
existen entre la programación orientada a objetos y la base de
datos. Estos aspectos se pueden presentar en cuestiones como:

 Lenguaje de programación: el programador debe

conocer el lenguaje de programación orientado a objetos
(POO) y el lenguaje de acceso a datos.
 Tipos de datos: en las bases de datos relacionales
siempre hay restricciones en el uso de tipos, mientras que
la programación orientada a objetos utiliza tipos de datos
más complejos.
La llegada del ODBC representó un avance sin precedentes en el
 Paradigma de programación: en el proceso de diseño y
camino hacia la interoperabilidad entre bases de datos y lenguajes
construcción del software se tiene que hacer una
de programación. La mayoría de empresas desarrolladoras de
traducción del modelo orientado a objetos de clases al
sistemas gestores de bases de datos incorporaron los drivers de
modelo Entidad-Relación (E/R) puesto que el primero
conectividad a las utilidades de sus sistemas y los lenguajes de
maneja objetos y el segundo maneja tablas y tuplas (o
programación más importantes desarrollaron bibliotecas
filas), lo que implica que se tengan que diseñar dos
específicas para soportar el API ODBC.
diagramas diferentes para el diseño de la aplicación.
Aunque la industria aceptó ODBC como medio principal para
El modelo relacional trata con relaciones y conjuntos debido a
acceso a bases de datos en Windows, la verdad es que no se
su naturaleza matemática. Sin embargo, el modelo de POO
introduce bien en el mundo Java, debido a la complejidad que
trata con objetos y las asociaciones entre ellos. Por esta razón, el
presenta ODBC, y que entre otras cosas ha impedido su transición
problema entre estos dos modelos surge en el momento de querer
fuera del entorno Windows.
persistir los objetos de negocio.
Sistema de conexión ODBC configurado usando diferentes
La escritura (y de manera similar la lectura) mediante JDBC
controladores (drivers) y un API estándar.
implica:

 Abrir una conexión.

 Crear una sentencia en SQL.
 Copiar todos los valores de las propiedades de un objeto
en la sentencia, ejecutarla y así almacenar el objeto.

Esto es sencillo para un caso simple, pero complicado si el objeto

posee muchas propiedades, o bien se necesita almacenar un objeto
que a su vez posee una colección de otros elementos. Se necesita
crear mucho más código, además del tedioso trabajo de creación de
sentencias SQL.

Este problema es lo que denominábamos impedancia Objeto-

Relacional, o sea, el conjunto de dificultades técnicas que surgen
cuando una base de datos relacional se usa en conjunto con un
programa escrito en POO.
Como ejemplo de desfase objeto-relacional, podemos poner el
siguiente: supón que tienes un objeto "Agenda Personal" con un
atributo que sea una colección de objetos de la clase "Persona".
Cada persona tiene un atributo "teléfono". Al transformar este caso
a relacional, se ocuparía más de una tabla para almacenar la
información, conllevando varias sentencias SQL y bastante código.
JDBC  (Java Database Connectivity) se trata de un API bastante
similar a ODBC en cuanto a funcionalidad,  implementado
específicamente para usar con el lenguaje Java, adaptado a las
especificidades de Java. Es decir, la funcionalidad se encuentra
capsulada en clases (ya que Java es un lenguaje totalmente
orientado a objetos) y además, no depende de ninguna plataforma
específica, de acuerdo con la característica multiplataforma
defendida por Java.La idea en el desarrollo de JDBC era intentar
ser tan sencillo como fuera posible, pero proporcionando a los
desarrolladores la máxima flexibilidad.

Java, mediante JDBC, permite simplificar el acceso a bases de

datos relacionales, proporcionando un lenguaje mediante el cual las
aplicaciones pueden comunicarse con motores de bases de datos. 
Sun desarrolló este API (java.sql.*)para el acceso a bases de datos,
con tres objetivos principales en mente:
 Ser un API con soporte de SQL: poder construir
sentencias SQL e insertarlas dentro de llamadas al API
de Java.
 Aprovechar la experiencia de los API's de bases de datos
existentes.
 Ser lo más sencillo posible.
Los desarrolladores de Los Sistemas Gestores de Bases de Datos
proporcionan la implementación de esa interfaz (Drivers).
JDBC es similar en estructura a ODBC. Una aplicación JDBC está
compuesta de varias capas, como se muestra en la figura:
La capa superior en este modelo es la aplicación Java. Las
aplicaciones Java son portátiles: puede ejecutar una aplicación Java
sin modificaciones en cualquier sistema que tenga instalado
una maquina virtual java  (Java runtime environment).  Un conector o driver es un conjunto de clases encargadas de
Una aplicación Java que utiliza JDBC puede comunicarse con
muchas bases de datos con pocas modificaciones, si es que las
hay. Al igual que ODBC, JDBC proporciona una manera
consistente de conectarse a una base de datos, ejecutar comandos y
recuperar los resultados. Al igual que ODBC, JDBC no impone un
lenguaje de comando común: puede usar la sintaxis específica de
Oracle cuando está conectado a un servidor Oracle y la sintaxis
específica de MySQL cuando está conectado a un servidor
MySQL.  programador se ocupe sólo de su aplicación.
La clase JDBC DriverManager es responsable de localizar un
controlador JDBC que necesita la aplicación. Cuando una
aplicación cliente solicita una conexión de base de datos, la
solicitud se expresa en forma de una URL (Uniform Resource
Locator). Una URL de JDBC es similar a las URL que utiliza con
un navegador web.  Para conectarnos a la base de datos Oracle,  
por ejemplo: jdbc:oracle:thin:ejemplo/ejemplo@localhost:1521:XE
A medida que cada controlador se carga en una Máquina Virtual de
Java (VM), se registra con el DriverManager JDBC . Cuando una
aplicación solicita una conexión, el DriverManager pregunta a
cada Controlador si puede conectarse a la base de datos
especificada en la URL dada. Tan pronto como encuentra
un controlador adecuado , la búsqueda se detiene y En principio, todos los conectores deben ser compatibles con ANSI
el controlador intenta establecer una conexión con la base de
datos. Si el intento de conexión falla, el Controlador lanzará
una SQLException a la aplicación. Si la conexión se completa con
éxito, el controlador crea un objeto de conexión y lo devuelve a la
aplicación.
2.1. Arquitectura JDBC
/*Añadir imágenes
El API JDBC soporta dos modelos de procesamiento para acceso a
bases de datos: de dos y tres capas.
En el modelo de dos capas, una aplicación se comunica
directamente a la fuente de datos. Esto necesita un conector JDBC
que pueda comunicar con la fuente de datos específica a la que
acceder.
Los comandos o instrucciones del usuario se envían a la base de
datos y los resultados se devuelven al usuario. La fuente de datos
puede estar ubicada en otra máquina a la que el usuario se conecte
por red. A esto se denomina configuración cliente/servidor, con la
máquina del usuario como cliente y la máquina que aloja los datos
como servidor.
En el modelo de tres capas, los comandos se envían a una capa
intermedia de servicios, la cual envía los comandos a la fuente de
datos. La fuente de datos procesa los comandos y envía los
resultados de vuelta la capa intermedia, desde la que luego se le
envían al usuario.
El API JDBC viene distribuido en dos paquetes:
 java.sql, dentro de J2SE.
 javax.sql, extensión dentro de J2EE
2.2. Conectores o Drivers
/*Añadir imagen
implementar los interfaces del API y acceder a la base de datos.
Para poder conectarse a una base de datos y lanzar consultas, una
aplicación necesita tener un driver adecuado. Un conector suele ser
un fichero .jar que contiene una implementación de todas las
interfaces del API JDBC.
Cuando se construye una aplicación de base de datos, JDBC
oculta lo específico de cada base de datos, de modo que el
El conector lo proporciona el fabricante de la base de datos o bien
un tercero. El código de nuestra aplicación no depende del driver,
puesto que trabajamos mediante los paquetes java.sql y javax.sql.
JDBC ofrece las clases e interfaces para:
Establecer una conexión a una base de datos.
 Ejecutar una consulta.
 Procesar los resultados.
Ejemplo:
/* Añadir imagen
SQL-2 Entry Level (ANSI SQL-2 se refiere a los estándares
adoptados por el American National Standards Institute en 1992.
Entry Level se refiere a una lista específica de capacidades de
SQL.) Los desarrolladores de drivers pueden establecer que sus
conectores conocen estos estándares.
Hay cuatro tipos de drivers JDBC: Tipo 1, Tipo 2, Tipo 3 y Tipo
4, que veremos a continuación.

2.3. Conectores tipo 1 y
tipo 2
/*Añadir Imágenes
Los conectores tipo 1 se denominan también JDBC-ODBC
Bridge (puente JDBC-ODBC).
Proporcionan un puente entre el API JDBC y el API ODBC. El
driver JDBC-ODBC Bridge traduce las llamadas JDBC a llamadas
ODBC y las envía a la fuente de datos ODBC.
Como ventajas destacar:
 No se necesita un driver específico de cada base de datos
de tipo ODBC.
 Está soportado por muchos fabricantes, por lo que
tenemos acceso a muchas Bases de Datos.
Como desventajas señalar:
 Hay plataformas que no lo tienen implementado.
 El rendimiento no es óptimo ya que la llamada JDBC se
realiza a través del puente hasta el conector ODBC y de
ahí a la interface de conectividad de la base de datos. El
resultado recorre el camino inverso.
 Se tiene que registrar manualmente en el gestor de
ODBC teniendo que configurar el DSN (Data Source
Names, Nombres de fuentes de datos).
Este tipo de driver va incluido en el JDK.
Los conectores tipo 2 se conocen también como: API nativa
Convierten las llamadas JDBC a llamadas específicas de la base de
datos para bases de datos como SQL Server, Informix, Oracle, o
Sybase.
El conector tipo 2 se comunica directamente con el servidor de
bases de datos, por lo que es necesario que haya código en la
máquina cliente.
Como ventaja, este conector destaca por ofrecer un rendimiento
notablemente mejor que el JDBC-ODBC Bridge.
Como inconveniente, señalar que la librería de la base de datos del
vendedor necesita cargarse en cada máquina cliente. Por esta razón
los drivers tipo 2 no pueden usarse para Internet.
Los drivers Tipo 1 y 2 utilizan código nativo vía JNI, por lo que
son más eficientes.
/* Añadir imagen
2.4. Conectores tipo 3 y
tipo 4
/*Añadir imagen
Tipo 3: JDBC-Net pure Java driver.
Tiene una aproximación de tres capas. Las peticiones JDBC a la
base de datos se pasan a través de la red al servidor de la capa
intermedia (middleware). Este servidor traduce este protocolo
independiente del sistema gestor a protocolo específico del sistema
gestor y se envía a la base de datos. Los resultados se mandan de
vuelta al middleware y se enrutan al cliente.
Es útil para aplicaciones en Internet.
Este driver está basado en servidor, por lo que no se necesita
ninguna librería de base de datos en las máquinas clientes.
Normalmente, un driver de tipo 3 proporciona soporte para
balanceo de carga, funciones avanzadas de administrador de
sistemas tales como auditoría, etc.
Tipo 4: Protocolo nativo.
En este caso se trata de conectores que convierten directamente las
llamadas JDBC al protocolo de red usando por el sistema gestor de
la base de datos. Esto permite una llamada directa desde la
máquina cliente al servidor del sistema gestor de base de datos y es
una solución excelente para acceso en intranets.
Como ventaja se tiene que no es necesaria traducción adicional o
capa middleware, lo que mejora el rendimiento, siendo éste mejor
que en el caso de los tipos 1 y 2.
Además, no se necesita instalar ningún software especial en el
cliente o en el servidor.
Como inconveniente, de este tipo de conectores, el usuario necesita
un driver diferente para cada base de datos.
Un ejemplo de este tipo de conector es Oracle Thin.
/* Añadir imagen
3.Conexión a una base
de datos
Para acceder a una base de datos y así poder operar con ella, lo
primero que hay que hacer es conectarse a dicha base de datos.
En Java, para establecer una conexión con una base de datos
podemos utilizar el método getConnection() de la clase DriverManager.
Este método recibe como parámetro la URL de JDBC que
identifica a la base de datos con la que queremos realizar la
conexión.
La ejecución de este método devuelve un objeto Connection que
representa la conexión con la base de datos.
Cuando se presenta con una URL específica, DriverManager itera
sobre la colección de drivers registrados hasta que uno de ellos
reconoce la URL especificada. Si no se encuentra ningún conector
adecuado, se lanza una SQLException
Veamos un ejemplo con comentarios, para conectarnos a una base
de datos MySQL:
/*Añadir imagen
3.1. Instalar el conector de
la base de datos
Para que podamos ejecutar el código anterior, necesitamos instalar
el conector de la base de datos.
Entre nuestra aplicación Java y el Sistema Gestor de Base de Datos
(SGBD), se intercala el conector JDBC. Este conector es el que
implementa la funcionalidad de las clases de acceso a datos y
proporciona la comunicación entre el API JDBC y el SGBD.
La función del conector es traducir los comandos del API JDBC al
protocolo nativo del SGBD.
En la siguiente presentación vamos a ver cómo descargarnos el
conector que necesitamos para trabajar con MySQL. Como verás,
tan sólo consiste en descargar un archivo, descomprimirlo y desde
NetBeans añadir el fichero .jar que constituye el driver que
necesitamos.
/*Añadir imagen
3.2. Pool de conexiones (I)
Acabamos de ver cómo se realiza una conexión a una base de
datos. En ocasiones, sobre todo cuando se trabaja en el ámbito de
las aplicaciones distribuidas, en entornos web, es recomendable
gestionar las conexiones de otro modo.
La explicación es que: abrir una conexión, realizar las operaciones
necesarias con la base de datos, y cerrar la conexión; puede ser
lento en entornos web si lo hacemos como hemos visto.
En las aplicaciones en las que es necesario el acceso concurrente y
masivo a una base de datos, como es el caso de las aplicaciones
web, es necesario disponer de varias conexiones. El proceso de
creación y destrucción de una conexión a una base de datos es
costoso e influye sensiblemente en el rendimiento de una
aplicación. Es mejor en estos casos, por tanto, abrir una o más
conexiones y mantenerlas abiertas.
La versión 3 y 4 de JDBC proporcionan un pool de conexiones que
funciona de forma transparente.
Al iniciar un servidor JavaEE, automáticamente el pool de
conexiones crea un número de conexiones físicas iniciales.
Cuando un objeto Java del servidor J2EE necesita una conexión a
través del método dataSource.getConnection(), la fuente de datos
javax.sql.DataSource habla con el pool de conexiones y éste le entrega
una conexión lógica java.sql.Connection. Esta conexión lógica la
recibe, por último, el objeto Java.
Cuando un objeto Java del servidor Java EE desea cerrar una
conexión a través del método connection.close(), la fuente de datos
javax.sql.DataSource habla con el pool de conexiones y le devuelve la
conexión lógica en cuestión.
Si hay un pico en la demanda de conexiones a la base de datos, el
pool de conexiones de forma transparente crea más conexiones
físicas de objetos tipo Connection. Si por el contrario las conexiones a
la base de datos disminuyen, el pool de conexiones, también de
forma transparente elimina conexiones físicas de objetos de tipo
Connection.
3.2.1. Pool de conexiones (II)
El código básico para conectarnos a una base de datos con pool de
conexiones transparente a través de JNDI podría ser:
//Initial Context es el punto de entrada para
// comenzar a explorar un espacio de nombres.
javax.naming.Context ctx = new InitialContext();
dataSource = (DataSource)
ctx.lookup("java:comp/env/jdbc/Basededatos");
Cada vez que necesitamos realizar una operación tendremos que
escribir el siguiente código para obtener una conexión lógica:
connection = dataSource.getConnection();
Cuando hayamos finalizado la operación entonces cerraremos la
conexión lógica con el siguiente código:
connection.close();
4.Creación de la base
de datos
Juan le explica a Antonio, que una base de datos puede crearse
utilizando las herramientas proporcionadas por el fabricante de la
base de datos, o por medio de sentencias SQL desde un programa
Java. Pero normalmente es el administrador de la base de datos, a
través de las herramientas que proporcionan el sistema gestor, el
que creará la base de datos. No todos los conectores JDBC
soportan la creación de la base de datos mediante el lenguaje de
definición de datos (DDL). Es decir, la sentencia CREATE
DATABASE no es parte del estándar SQL, sino que es dependiente
del sistema gestor de la base de datos.
Así pues, mediante JDBC podemos conectarnos y manipular bases
de datos: crear tablas, modificarlas, borrarlas, añadir datos en las
tablas, etc. Pero la creación en sí de la base de datos la hacemos
con la herramienta específica para ello.
Normalmente, cualquier sistema gestor de bases de datos incluye
asistentes gráficos para crear la base de datos, sus tablas, claves, y
todo lo necesario.
También, como en el caso de MySQL, o de Oracle, y la mayoría de
los sistemas gestores de bases de datos, se puede crear la base de
datos, desde la línea de comandos de MySQL o de Oracle, con las
sentencias SQL apropiadas.
Veamos cómo crear paso a paso una base de datos con Microsoft
Access. Si no dispones de Microsoft Access, no te preocupes, más
abajo puedes descargar la base de datos ya creada.
/*Añadir imagen
5. Operaciones:
ejecución de
consultas
Para operar con una base de datos, ejecutando las consultas
necesarias, nuestra aplicación deberá hacer:
 Cargar el driver necesario para comprender el protocolo
que usa la base de datos en cuestión.
 Establecer una conexión con la base de datos.
 Enviar consultas SQL y procesar el resultado.
 Liberar los recursos al terminar.
 Gestionar los errores que se puedan producir.
Podemos utilizar los siguientes tipos de sentencias:
 Statement:
para sentencias sencillas en SQL.
 PreparedStatement:
para consultas preparadas, como por
ejemplo las que tienen parámetros.
  CallableStatement: para ejecutar procedimientos
almacenados en la base de datos.
El API JDBC distingue dos tipos de consultas:
 Consultas: SELECT
 Actualizaciones: INSERT, UPDATE, DELETE, sentencias
DDL.
Veamos a continuación cómo realizar una consulta en la base de
datos que creamos en el apartado anterior, la base de datos
farmacia.mdb.
En este caso utilizaremos un acceso mediante puente JDBC-
ODBC. Dicho puente da acceso a bases de datos ODBC.
Este driver está incorporado dentro de la distribución de Java, por
lo que no es necesario incorporarlo explícitamente en el classpath
de una aplicación Java.
5.1. Ejemplo: consultas con
MS-Access (I)
/* Añadir imagen
En primer lugar, tenemos que definir la fuente de datos ODBC.
Dependiendo de la versión de Windows con la que trabajemos, el
programa de definición de fuentes de datos ODBC puede variar de
localización, pero siempre dentro del Panel de Control o algún
subgrupo. En Windows 7, lo encontramos en el panel de control,
luego en herramientas administrativas y finalmente en “Orígenes
de datos (ODBC)”.
Dentro de la pestaña “DSN de usuario” encontramos los diferentes
drivers ODBC instalados en el sistema.
A continuación, hay que instalar el driver JDBC. Las clases e
interfaces para trabajar con una base de datos relacional quedan
establecidas por el API JDBC. Algunas de estas clases están
parcialmente diferidas y los interfaces están sin implementar. Es
responsabilidad de cada sistema gestor la implementación de las
clases que dan acceso a las bases de datos. Por ello, para cada tipo
de base de datos se trabaja con un conjunto diferente de clases.
Esto es lo que se denomina driver JDBC.
Dentro del código se carga el driver antes de acceder a la base de
datos:
Class.forName("jdbc:odbc:admdb");
Posteriormente, una vez instalado el conector y cargado dentro del
código Java sólo necesitamos realizar la conexión a la base de
datos para comenzar a trabajar con ella. La clase DriverManager
define el método getConnection para crear una conexión a una base de
datos. Este método toma como parámetro una URL JDBC donde se
indica el sistema gestor y la base de datos. Opcionalmente, y
dependiendo del sistema gestor, habrá que especificar el login y
password para la conexión. En el caso de JDBC-ODBC la cadena
de conexión sería: jdbc:odbc:admdb, en la que no es necesario
establecer el protocolo. Finalmente, el código para establecer una
conexión quedaría del siguiente modo:
Connection con =
DriverManager.getConnection("jdbc:odbc:admdb");
Ahora ya podemos realizar las consultas que deseemos.
Definir la fuente de datos ODBC es bien fácil, de todos modos, te
lo ponemos aquí para veas cómo se hace.
/*Añadir imagen
5.1.1. Ejemplo: consultas con
MS-Access (II)
Las consultas que se realizan a una base de datos se realizan
utilizando objetos de las clases Statement y PreparedStatement. Estos
objetos se crean a partir de una conexión.
Statement stmt = con.createStatement();
La clase Statement contiene los métodos executeQuery y executeUpdate
para realizar consultas y actualizaciones, respectivamente. Ambos
métodos soportan consultas en SQL-92. Así por ejemplo, para
obtener los nombres de los medicamentos que tenemos en la tabla
medicamentos, de la base de datos farmacia.mdb que creamos
anteriormente, tendríamos que emplear la sentencia:
ResultSet rs = stmt.executeQuery("SELECT nombre from
medicamentos");
El método executeQuery devuelve un objeto ResultSet para poder
recorrer el resultado de la consulta utilizando un cursor.
while (rs.next())
String usuario = rs.getString("nombre");
El método next se emplea para hacer avanzar el cursor. Para obtener
una columna del registro utilizamos los métodos get. Hay un
método get para cada tipo básico Java y para las cadenas.
Hay que comentar que un método interesante del cursor es wasNull
que nos informa si el último valor leído con un método get es nulo.
Respecto a las consultas de actualización, executeUpdate, retornan el
número de registros insertados, registros actualizados o eliminados,
dependiendo del tipo de consulta que se trate.
Aquí tienes el proyecto que realiza la consulta de todos los
medicamentos de la tabla que los contiene, llamada medicamentos,
en la base de datos farmacia.mdb.
/*Añadir imagen
5.2. Consultas preparadas
Las consultas preparadas están representadas por la clase
PreparedStatement.
Son consultas precompiladas, por lo que son más eficientes, y
pueden tener parámetros.
Una consulta se instancia del modo que vemos con un ejemplo:
PreparedStatement pstmt = con.preparedStatement("SELECT *
from medicamentos");
Para las consultas que se realizan muy a menudo es aconsejable
usar este tipo de consultas, de modo que el rendimiento del sistema
será mejor de esta manera.
Si hay que emplear parámetros en una consulta, se puede hacer
usando el carácter ‘?’. Por ejemplo, para realizar una consulta de
un medicamento que tenga un código determinado, haríamos la
consulta siguiente:
PreparedStatement pstmt = con.preparedStatement("SELECT *
from medicamentos WHERE codigo = ? ");
Establecemos los parámetros de una consulta utilizando métodos
set que dependen del tipo SQL de la columna.
Así, le decimos que el primer parámetro, que es el único que tiene
esta consulta, es “712786”:
pstmt.setString(1, "712786");
El primer argumento de este método es la posición del parámetro
dentro de la consulta.
Finalmente, ejecutamos la consulta utilizando el método
executeQuery()o executeUpdate(), ambos sin parámetros, dependiendo
del tipo de consulta.
6. Ejecución de
procedimientos
almacenados en la
base de datos
Un procedimiento almacenado es un procedimiento o subprograma
que está almacenado en la base de datos.
Muchos sistemas gestores de bases de datos los soportan, por
ejemplo: MySQL, Oracle, etc.
Además, estos procedimientos suelen ser de dos clases:
 Procedimientos almacenados.
 Funciones, las cuales devuelven un valor que se puede
emplear en otras sentencias SQL.
Un procedimiento almacenado típico tiene:
 Un nombre.
 Una lista de parámetros.
 Unas sentencias SQL.
Veamos un ejemplo de sentencia para crear un procedimiento
almacenado sencillo para MySQL, aunque sería similar en otros
sistemas gestores:
/*Añadir imagen
Como se ve en los comentarios, este procedimiento admite un
parámetro, llamado par1. También se declara una variable a la que
llamamos var1 y es de tipo carácter y longitud 13. Si el valor que le
llega de parámetro es igual a 24, entonces se asigna a la variable
var1, la cadena 'perro rabioso' y en caso contrario se le asignará la
cadena: 'gato persa'. Finalmente, se inserta en la tabla “Animales” el
valor que se asignó a la variable var1.
6.1. Ejecutando
procedimientos
almacenados en
MySQL
A continuación, vamos a realizar un procedimiento almacenado en
MySQL, que simplemente insertará datos en la tabla clientes.
Desde el programa Java que realizamos, llamaremos para ejecutar a
ese procedimiento almacenado. Por tanto, ¿cuál sería la secuencia
que seguiríamos para realizar esto?
 Si no tenemos creada la tabla de clientes, la creamos. Por
simplicidad, en este ejemplo, trabajamos sobre la base de
datos que viene por defecto en MySQL, el esquema
denominado: test. Para crear la tabla de clientes, el script
correspondiente es:
/*Añadir imagen
 Creamos el procedimiento almacenado en la base de
datos. Sería tan fácil como:
/*Añadir imagen
 Crear la clase Java para desde aquí, llamar al
procedimiento almacenado:
/*Añadir imagen
Si hemos definido la tabla correctamente, con su clave primaria, y
ejecutamos el programa, intentando insertar una fila igual que otra
insertada, o sea, con la misma clave primaria, obtendremos un
mensaje al capturar la excepción de este tipo:
SQL Exception:
com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolat
ionException:
Duplicate entry '765' for key 'PRIMARY'
7.Transacciones
Cuando tenemos una serie de consultas SQL que deben ejecutarse
en conjunto, con el uso de transacciones podemos asegurarnos de
que nunca nos quedaremos a medio camino de su ejecución.
Las transacciones tienen la característica de poder “deshacer” los
cambios efectuados en las tablas, de una transacción dada, si no se
han podido realizar todas las operaciones que forman parte de
dicha transacción.
Por eso, las bases de datos que soportan transacciones son mucho
más seguras y fáciles de recuperar si se produce algún fallo en el
servidor que almacena la base de datos, ya que las consultas se
ejecutan o no en su totalidad.
Al ejecutar una transacción, el motor de base de datos garantiza:
atomicidad, consistencia, aislamiento y durabilidad (ACID) de
la transacción (o conjunto de comandos) que se utilice.
El ejemplo típico que se pone para hacer más clara la necesidad de
transacciones en algunos casos es el de una transacción bancaria.
Por ejemplo, si una cantidad de dinero es transferida de la cuenta
de Antonio a la cuenta de Pedro, se necesitarían dos consultas:
 En la cuenta de Antonio para quitar de su cuenta ese
dinero:
UPDATE cuentas SET saldo = saldo - cantidad WHERE
cliente = “Antonio”;
 En la cuenta de Pedro para añadir ese dinero a su cuenta:
UPDATE cuentas SET saldo = saldo + cantidad WHERE
cliente = “Pedro”;
Pero ¿qué ocurre si por algún imprevisto (un apagón de luz, etc.),
el sistema “cae” después de que se ejecute la primera consulta, y
antes de que se ejecute la segunda? Antonio tendrá una cantidad de
dinero menos en su cuenta y creerá que ha realizado la
transferencia. Pedro, sin embargo, creerá que todavía no le han
realizado la transferencia.
7.1. Commit y Rollback
/*Añadir imagen
Una transacción tiene dos finales posibles, COMMIT o
ROLLBACK. Si se finaliza correctamente y sin problemas se hará
con COMMIT, con lo que los cambios se realizan en la base de
datos, y si por alguna razón hay un fallo, se deshacen los cambios
efectuados hasta ese momento, con la ejecución de ROLLBACK.
Por defecto, al menos en MySQL o con Oracle, en una conexión
trabajamos en modo autocommit con valor true. Eso significa que cada
consulta es una transacción en la base de datos.
Por tanto, si queremos definir una transacción de varias
operaciones, estableceremos el modo autocommit a false con el
método setAutoCommit de la clase Connection.
En modo no autocommit las transacciones quedan definidas por las
ejecuciones de los métodos commit y rollback. Una transacción abarca
desde el último commit o rollback hasta el siguiente commit. Los
métodos commit o rollback forman parte de la clase Connection.
En la siguiente porción de código de un procedimiento
almacenado, puedes ver un ejemplo sencillo de cómo se puede
utilizar commit y rollback: tras las operaciones se realiza el commit, y si
ocurre una excepción, al capturarla realizaríamos el rollback.
Es conveniente planificar bien la aplicación para minimizar el
tiempo en el que se tengan transacciones abiertas ejecutándose, ya
que consumen recursos y suponen bloqueos en la base de datos que
puede parar otras transacciones. En muchos casos, un diseño
cuidadoso puede evitar usos innecesarios que se salgan del modo
estándar AutoCommit.
8.Excepciones y cierre
de conexiones
Debemos tener en cuenta siempre que las conexiones con una base
de datos consumen muchos recursos en el sistema gestor, y por lo
tanto en el sistema informático en general. Por ello, conviene
cerrarlas con el método close siempre que vayan a dejar de ser
utilizadas, en lugar de esperar a que el garbage collector de Java las
elimine.
También conviene cerrar las consultas ( Statement y PreparedStatement) y
los resultados (ResultSet) para liberar los recursos.
Una excepción es una situación que no se puede resolver y que
provoca la detención del programa de manera abrupta. Se produce
por una condición de error en tiempo de ejecución.
En Java hay muchos tipos de excepciones, el paquete
java.lang.Exception es el que contiene los tipos de excepciones.
Para saber más
Resumen
8.1. Excepciones
Cuando se produce un error durante la ejecución de un
programa, se genera un objeto asociado a esa excepción. Ese
objeto es de la clase Exception o de alguna de sus subclases. Este
objeto se pasa entonces al código que se ha definido para gestionar
la excepción.
En una porción de programa donde se trabajará con ficheros, y con
bases de datos podríamos tener esta estructura para capturar las
posibles excepciones.
/*Añadir imagen
El bloque de instrucciones del try es el que se ejecuta, y si en él
ocurre un error que dispara una excepción, entonces se mira si es
de tipo fichero no encontrado; si es así, se ejecutarían las
instrucciones del bloque del fichero no encontrado. Si no era de ese
tipo la excepción, se mira si es del siguiente tipo, o sea, de entrada
salida, y así sucesivamente.
Las instrucciones que hay en el bloque del finally, se ejecutarán
siempre, se haya producido una excepción o no, ahí suelen ponerse
instrucciones de limpieza, de cierre de conexiones, etc.
Las acciones que se realizan sobre una base de datos pueden lanzar
la excepción SQLException. Este tipo de excepción proporciona entre
otra información:
 Una cadena de caracteres describiendo el error. Se
obtiene con el método getMesage.
 Un código entero de error que especifica al fabricante de
la base de datos.
Para saber más
Resumen
8.2. Cierre de conexiones
Como ya hemos dicho, al trabajar con bases de datos, se consumen
muchos recursos por parte del sistema gestor, así como del resto de
la aplicación.
Por esta razón, resulta totalmente conveniente cerrarlas con el
método close cuando ya no se utilizan.
Podríamos por tanto tener un ejemplo de cómo hacer esto:
/*Añadir imagen
 Tema 4. Mapeo objeto relacional
1. Concepto de Mapeo
objeto-relacional
A la hora de almacenar los datos de un programa orientado a
objetos en una base de datos relacional, surge un inconveniente
debido a incompatibilidad de sistemas de tipo de datos. En el
software orientado a objetos, la información se representa como
clases y objetos. En las bases de datos relacionales, como tablas y
sus restricciones. Por tanto, para almacenar la información tratada
en un programa orientado a objetos en una base de datos relacional
es necesaria una traducción entre ambas formas.
El mapeo objeto-relacional (ORM) soluciona este problema. Es
una técnica de programación que se utiliza con el propósito de
convertir datos entre el utilizado en un lenguaje de programación
orientado a objetos y el utilizado en una base de datos relacional,
gracias a la persistencia. Esto posibilita el uso en las bases de datos
relacionales de las características propias de la programación
orientada a objetos (básicamente herencia y polimorfismo).
La mayoría de las aplicaciones se construyen usando técnicas de
programación orientada a objetos; sin embargo, los sistemas de
bases de datos más extendidos son de tipo relacional.
Las bases de datos más extendidas son del tipo relacional y estas
sólo permiten guardar tipos de datos primitivos (enteros, cadenas
de texto, etc.) por lo que no se puede guardar de forma directa los
objetos de la aplicación en las tablas. Por tanto, se debe convertir
los valores de los objetos en valores simples que puedan ser
almacenados en una base de datos (y poder recuperarlos más
tarde).
El mapeo objeto-relacional surge, pues, para dar respuesta a esta
problemática: traducir los objetos a formas que puedan ser
almacenadas en bases de datos preservando las propiedades de los
objetos y sus relaciones; estos objetos se dice entonces que son
persistentes.
/* Añadir imagen
El ORM se encarga, de forma automática, de convertir los objetos
en registros y viceversa, simulando así tener una base de datos
orientada a objetos.
2. Herramientas ORM.
Características y 
herramientas más
utilizadas
Ya hemos dicho que las herramientas ORM se utilizan para dar
solución al problema de que, en la programación orientada a
objetos, la gestión de datos se implementa usando objetos; sin
embargo, en los sistemas de gestión de bases de datos SQL sólo se
pueden almacenar y manipular valores escalares organizados en
tablas relacionales.
Object Relational Mapping (ORM) es la herramienta que nos sirve
para transformar representaciones de datos de los Sistemas de
Bases de Datos Relacionales, a representaciones (Modelos) de
objetos. Dado a que los RDBMS carecen de la flexibilidad para
representar datos no escalares, la existencia de un ORM es
fundamental para el desarrollo de sistemas de software robustos y
escalables.
En el modelo relacional, cada fila en la tabla se mapea a un objeto
y cada columna a una propiedad.
Las herramientas ORM pues, actúan como un puente que conecta
las ventajas de los RDBMS con la buena representación de estos en
un lenguaje Orientado a Objetos, o, dicho en otras palabras, nos
lleva de la base de datos al lenguaje de programación.
En el siguiente documento podrás ver un adelanto de los siguientes
puntos de la unidad:
/* Añadir imagen
2.1. Características
Las herramientas ORM facilitan el mapeo de atributos entre una
base de datos relacional y el modelo de objetos de una aplicación,
mediante archivos declarativos (XML) que permiten establecer
estas relaciones. Gracias a las ORM, podemos conectar con una
base de datos relacional para extraer la información contenida en
objetos de programas que están almacenados. Para ello, sólo
tendremos que definir la forma en la que establecer la
correspondencia entre las clases y las tablas una sola vez
(indicando qué propiedad se corresponde con cada columna, qué
clase con cada tabla, etc.). Una vez hecho esto, podremos utilizar
POJO's de nuestra aplicación e indicar a la ORM que los haga
persistentes, consiguiendo que una sola herramienta pueda leer o
escribir en la base de datos utilizando VO's directamente.
Una herramienta ORM permite tomar un objeto Java y hacerlo
persistente, carga el objeto de la base de datos a memoria y permite
hacer consultas a las tablas de la base de datos.
Ventajas de ORM.
Ayudan a reducir el tiempo de desarrollo de software. La
mayoría de las herramientas ORM disponibles, permiten
la creación del modelo a través del esquema de la base de
datos, es decir, el usuario crea la base de datos y la
herramienta automáticamente lee el esquema de tablas y

relaciones y crea un modelo ajustado.
Abstracción de la base de datos.
 Reutilización.
  Permiten persistir objetos a través de un método Orm.Save
y generar el SQL correspondiente.
 Permiten recuperar los objetos persistidos a través de un
método Orm.Load.
 Lenguaje propio para realizar las consultas.
 Independencia de la base de datos.
 Incentivan la portabilidad y escalabilidad de los
programas de software.
Desventajas de ORM.
 Tiempo utilizado en el aprendizaje. Este tipo de
herramientas suelen ser complejas por lo que su correcta
utilización lleva un tiempo que hay que emplear en ver el
funcionamiento correcto y ver todo el partido que se le
puede sacar.
 Menor rendimiento (aplicaciones algo más lentas). Esto
es debido a que todas las consultas que se hagan sobre la
base de datos, el sistema primero deberá de
transformarlas al lenguaje propio de la herramienta,
luego leer los registros y por último crear los objetos.
 Sistemas complejos. Normalmente la utilidad de ORM
desciende con la mayor complejidad del sistema
relacional.
/* Añadir imagen
2.2. Herramientas ORM
más utilizadas
Entre las herramientasORM más relevantes encontramos las
siguientes:
Hibernate:
Hibernate es una herramienta de Mapeo objeto-relacional (ORM)
para la plataforma Java (y disponible también para .Net con el
nombre de NHibernate) que facilita el mapeo de atributos entre una
base de datos relacional tradicional y el modelo de objetos de una
aplicación. Utiliza archivos declarativos (XML) o anotaciones en
los beans de las entidades que permiten establecer estas relaciones.
Hibernate es software libre, distribuido bajo los términos de la
licencia GNU LGPL
Java Persistence Api (JPA):
El Java Persistence API (JPA) es una especificación de Sun
Microsystems para la persistencia de objetos Java a cualquier base
de datos relacional. Esta API fue desarrollada para la plataforma
JEE e incluida en el estándar de EJB 3.0, formando parte de la Java
Specification Request JSR 220.
Para su utilización, JPA requiere de J2SE 1.5 (también conocida
como Java 5) o superior, ya que hace uso intensivo de las nuevas
características de lenguaje Java, como las anotaciones y los
genéricos.
iBatis:
iBatis es un framework (marca de trabajo) de persistencia
desarrollado por la Apache software Foundation. Al igual que que
el resto de los proyectos desarrollados por la ASF, iBatis es una
herramienta de código libre y de código abierto.
iBatis sigue el mismo esquema de uso que Hibernate; se apoya en
ficheros de mapeo XML para persistir la información contenida en
los objetos en un repositorio relacional.
3.Instalación y
configuración de
Hibernate
La instalación de Hibernate sobre el IDE NetBeans requiere tener
instalado previamente este entorno de desarrollo, junto al JDK
Una vez que inicializamos NetBeans, podemos encontrar la
herramienta Hibernate como un plugin de este entorno de
desarrollo. Lo único que tienes que hacer es ir a la lista de plugins
de NetBeans y comprobar que lo tienes instalado; en caso
contrario, deberás instalarlo desde la opción de plugins disponibles
Para utilizar Hibernate en una aplicación, es necesario conocer
cómo configurarlo.
Hibernate puede configurarse y ejecutarse en la mayoría de
aplicaciones Java y entornos de desarrollo. El archivo de
configuración de Hibernate recibe el nombre de Hibernate.cfg.xml
y contiene información sobre la conexión de la base de datos y
otras propiedades. Al crearlo, hay que especificar la conexión a la
base de datos.
En los siguientes puntos del tema veremos más detenidamente el
proceso de configuración.
/* Añadir imagen
4. Ficheros de
configuración y mapeo.
Estructura y
propiedades
Para empezar a trabajar con Hibernate es necesario configurar la
herramienta para que conozca qué objetos debe recuperar de la
base de datos relacional y en qué lugar los hará persistir. Por tanto,
el primer paso será tener una base de datos relacional con la que
poder trabajar.
Debes conocer
/* Imágenes
En NetBeans, cuando se crea el archivo de configuración de
Hibernate usando el asistente, podemos especificar la conexión a la
base de datos, eligiendo de una lista de conexiones de bases de
datos registradas en el IDE. Cuando se genera el archivo de
configuración, el IDE añade de forma automática detalles de la
conexión e información basada en la conexión de la base de datos
seleccionada. El IDE añade también las bibliotecas de Hibernate en
el proyecto. Después de crear el fichero de configuración, éste
puede ser editado usando el editor interactivo, o editar directamente
el código XML.
El fichero de configuración contiene información sobre la base de
datos a la que vamos a conectar la aplicación. Si la aplicación se va
a conectar a varias bases de datos, sería necesario definir tantos
archivos de configuración como bases de datos a las que nos
queramos conectar.
Para tener toda esta información, en Hibernate surgen dos ficheros
distintos:
 El archivo de propiedades de Hibernate
(Hibernate.properties), que es el encargado de determinar
todos los aspectos relacionados con el gestor de la base
de datos y las conexiones con él.
 Los archivos que definen el emparejamiento (mapping)
de propiedades con tablas y columnas (*.hbm.xml).
/*Añadir imagen
Para utilizar Hibernate necesitamos tener una base de datos
relacional instalada en NetBeans. La base de datos Sakila es una
muestra gratuita disponible, como plugin, en NetBeans.
La seleccionamos desde la lista de plugins disponibles y la
instalamos en nuestro IDE.
Como ya se ha visto, tras instalar el plugin podemos crear la base
de datos Sakila desde la ventana Servicios de NetBeans. Para ello,
seleccionaremos el servidor de MySQL y a continuación esta base
de datos. Conectaremos con ella para poder tenerla disponible
cuando empecemos a extraer la información que se nos pida.
4.1. Ficheros de
configuración.
Propiedades
El archivo de configuración de Hibernate es el Hibernate.cfg.xml y
contiene información sobre la conexión de base de datos, las
asignaciones de recursos y otras propiedades de conexión.
Debes conocer
Resumen
Al seleccionar una conexión a una base de datos en NetBeans, se
crea un archivo de configuración en Hibernate que guarda los
detalles de esa conexión. NetBeans también añade de forma
automática la biblioteca de Hibernate para la ruta de clase que
tendrá nuestro proyecto. Después de la creación del archivo
Hibernate.cfg.xml, podemos editarlo o modificar el código xml
mediante el editor xml.
/* Añadir imagen
Las propiedades más importantes del fichero Hibernate.cfg.xml son:
 Hibernate.dialect:
ejemplo, MySQL.
Dialecto o lenguaje empleado. Por
 Hibernate.connection.driver_class . Driver utilizado para la
conexión con la base de datos.
 Hibernate.connection.url. Dirección de la base de datos con la
que se va a conectar Hibernate.
 Hibernate.connection.username. Nombre del usuario que va a
realizar la extracción de información. Por defecto, el
nombre de usuario es root.
 Hibernate.connection.password . Contraseña el root.
 Hibernate.show_sql.Para mostrar la herramienta. Por
defecto, su valor es true.
4.2. Ficheros de mapeo.
Estructura, elementos y
propiedades
Hibernate utiliza ficheros de mapeo para relacionar tablas con
objetos Java, estos ficheros están en formato XML y que tienen
extensión .hbm.xml.
Hibernate-mapping:
Todos los ficheros de mapeo comienzan y acaban
con esta etiqueta. Al comienzo indicamos en el atributo package el
paquete Java donde se encuentra la clase.
Los archivos de mapeo indican la correspondencia entre el bean y
una tabla de la base datos; por tanto, en el momento en que se
inicie una tarea que requiera el acceso a la base de datos se
obtendrá una conexión JDBC.
A los archivos de mapeo se les asigna el nombre de la Clase
seguido de la extensión "hbm.xml".
Podemos utilizar la ingeniería inversa para crear archivos de mapeo
basados en tablas de la base de datos que seleccionemos. El archivo
de ingeniería inversa es Hibernate.reveng.xml. Se trata de un archivo
XML que se puede utilizar para modificar la configuración
predeterminada de Hibernate.cfg.xml con el propósito de especificar
explícitamente el esquema de base de datos que se va a utilizar,
filtrar las tablas que no deseamos recuperar y especificar cómo se
asignan los tipos JDBC a los tipos de Hibernate.
Para extraer un tabla concreta de la base de datos, la sintaxis en el
mapeo requiere definir el POJO Nombre_Clase.hbm.xml, donde
nombre_clase se corresponderá con el nombre la tabla que
queremos extraer y donde se describe cómo se relacionan clases y
tablas y propiedades y columnas.
Mediante el asistente de NetBeans, seleccionamos Nuevo Mapeo
en Hibernate y rellenamos los campos que nos piden, en función de
la información que nos interese extraer de la base de datos.
De esta manera, NetBeans genera un POJO nombre_clase.java (siendo
nombre_clase aquella tabla cuya información nos interesa extraer
de la base de datos) con todos los campos necesarios.
Con ello, genera un fichero de mapeo de Hibernate, agregando su
entrada a Hibernate.cfg.xml, entre las etiquetas.
Debes conocer
/* Añadir imagen
5.Mapeo de colecciones,
relaciones y herencia
1. Mapeo de colecciones.
Hay bastantes rangos de mapeos que se pueden generar para
colecciones que cubran diversos modelos relacionales.
El elemento de mapeo de Hibernate utilizado para mapear una
colección depende del tipo de la interfaz; por ejemplo, un elemento
se utiliza para mapear propiedades de tipo Set aunque, no obstante,
existen además los elementos de mapeo etc.
Las instancias de colección de distinguen por la clave foránea de la
entidad que posee la colección. El elemento mapea la columna
clave de la colección.
Hay que resaltar que las colecciones pueden contener casi
cualquier tipo de datos; esto implica que un objeto en una
colección puede ser manejado con una semántica de "valor" o
podría ser una referencia a otra entidad, con su propio ciclo de
vida. Todos los mapeos de colección necesitan una columna índice
en la tabla de colección: una columna índice es una columna que
mapea a un índice de array o índice de List. Por último, una
colección de valores o asociación muchos-a-muchos requiere una
tabla de colección dedicada con una columna o columnas de clave
foránea, columna de elemento de colección y probablemente una o
varias columnas índice.
2. Mapeo de relaciones.
Para persistir, las relaciones usan las denominadas transacciones,
ya que los cambios pueden incluir varias tablas. Una regla general
para el mapeo es respetar el tipo de relación en el modelo de
objetos y en el modelo relacional: así, una relación 1-1 en el
modelo de objetos deberá corresponderse a una relación 1-1 en el
modelo relacional.
Para mapear las relaciones, se usan los identificadores de objetos
(OID). Son la llave primaria de la tabla relacionada y se agregan
como una columna más en la tabla donde se quiere establecer la
relación. Dicha columna es una clave foránea a la tabla con la que
está relacionada.
3. Mapeo de herencia.
Como hemos comentado, las colecciones funcionan en ambos
modelos, objeto y relacional. Para el caso de la herencia se presenta
el problema que las base de datos relacionales no la soportan. Así
es que somos nosotros quienes debemos modelar como se verá la
herencia en el modelo relacional. Existen tres tipos de mapeos
principales: modelar la jerarquía a una sola tabla, modelar la
jerarquía completa en tablas, mapear cada tabla en tablas concretas.
La decisión estará basada en el rendimiento y en la escalabilidad
del modelo.
6.Clases persistentes
Se denomina "persistencia" de los objetos a su capacidad para
guardarse y recuperarse desde un medio de almacenamiento. Las
clases persistente son clases en una aplicación que nos van a servir
para representar entidades de la base de datos. No se considera que
todas las instancias de una clase persistente puedan estar en estado
persistente, ya que una instancia puede ser transitorio o separada.
El estándar Java Data Objects (JDO), define una clase con
capacidad de persistencia, como aquella que implementa la
interaface javax.jdo.PersistenceCapable.
Las clases persistentes tienen la capacidad de definir objetos que
pueden almacenarse y recuperarse y un almacén persistente de
datos. La especificación JDO incorpora la figura del procesador de
clases en código ejecutable Java, JDO Enhacer, que es un programa
que modifica los archivos compilados de las clases, añadiendo el
código ejecutable necesario para realizar la grabación y
recuperación transparente de los atributos de las instancias
persistentes.
JDO permite a los programadores convertir sus clases en
persistentes, de forma que los objetos pertenecientes a clases
concretas definidas por el programador pueden mantener su
estado, con la única limitación de que el estado esté compuesto por
los atributos persistentes que sean independientes del contexto de
ejecución: tipos primitivos, tipos de referencia e interfaz y algunas
clases del sistema que permiten modelar el estado como por
ejemplo la clase Array, Date, etc.
Para poder indicar las clases y atributos que son persistentes, se
utiliza un fichero de configuración XML, que se denomina
descriptor de persistencia. Para que las instancias de las clases
persistentes pueden mantenerse en los sistemas gestores de bases
de datos, es necesario establecer la correspondencia entre los
objetos y su estado persistente.
7.Sesiones; estados de un
objeto
Para poder utilizar la persistencia en Hibernate es necesario definir
un objeto Session utilizando la clase SesssionFactory. La sesión
corresponde con un objeto que representa una unidad de trabajo
con la base de datos. La sesión nos permite representar el gestor de
persistencia, ya que dispone de una API básica que nos permite
cargar y guardar objetos.
La sesión está formada internamente por una cola de sentencias
SQL que son necesarias ejecutar para poder sincronizar el estado
de la sesión con la base de datos.
Asimismo, la sesión contiene una lista de objetos persistentes. Una
sesión corresponde con el primer nivel de caché.
Si para realizar el acceso a datos, usamos Hibernate, la sesión nos
permite definir el alcance de un contexto determinado. Para poder
utilizar los mecanismos de persistencia de Hibernate se debe
inicializar el entorno Hibernate y obtener un objeto Session
utilizando la clase SessionFactory de Hibernate. Un objeto Session
Hibernate representa una única unidad-de-trabajo para un almacén
de datos dado y lo abre un ejemplar de SessionFactory. Se deben
cerrar las sesiones cuando se haya completado todo el trabajo de
una transacción.
Los estados en los que se puede encontrar un objetos son:
 Transitorio (Transient). En este estado estará un objeto
recién creado que no ha sido enlazado con el gestor de
persistencia.
 Persistente: Ente este caso el objeto está enlazado con la
sesión. Todos los cambios que se realicen será
persistentes.
 Disociado (Detached): En este caso nos encontramos con
un objeto persistente que sigue en memoria después de
que termine la sesión. En este caso existe en Java y en la
base de datos.
 Borrado (Removed): En este caso el objeto está marcado
para ser borrado de la base de datos. Existe en la
aplicación Java y se borrará de la base de datos al
terminar la sesión.

8. Carga,
almacenamiento y aplique "flush" a la sesión.
modificación de
objetos.
Para cargar un objeto de acceso a datos en la aplicación Java, el
método load() de la clase Session suministra un mecanismo para
capturar una instancia persistente, si conocemos su identificador. El
método load() acepta un objeto Class, y cargará el estado de una
nueva instancia de esa clase, inicializada en estado persistente.
El método load() lanzará una excepción irrecuperable si no existe la
fila de base de datos correspondiente. Si no se está seguro de que
exista una fila correspondiente, debe usarse el método get(), el cual
consulta la base de datos inmediatamente y devuelve null si no
existe una fila correspondiente
Existen dos métodos que se encargan de recuperar un objeto
persistente por identificador: load() y get(). La diferencia entre ellos
radica en cómo indican que un objeto no se encuentra en la base de
datos: get() devuelve un nulo y load() lanza una excepción
ObjectNotFoundException .
Aparte de esta diferencia, load() intenta devolver un objeto proxy
siempre y cuando le sea posible (no esté en el contexto de
persistencia). Con lo que es posible que la excepción sea lanzada
cuando se inicialice el objeto proxy. Esto es conocido como carga
perezosa.
En el caso que se obtenga un proxy, no tiene impacto sobre la base
de datos (no se ejecuta ninguna consulta), hasta que no se inicializa
el mismo. Muy útil cuando se obtiene una referencia de un objeto
para asociarlo a otro. (No es necesario obtener el objeto). Se
modifica un objeto persistente.
/*Añadir imagen
8.1. Almacenamiento y
modificando de objetos
persistentes
Para almacenar objetos persistentes se proceso siguiendo los
siguientes pasos:
1. Se instancia un objeto nuevo (estado transitorio).
2. Se obtiene una sesión y se comienza la transacción,
inicializando el contexto de persistencia.
3. Una vez obtenida da la sesión, se llama al método save(),
el cual introduce el objeto en el contexto de persistencia.
Este método devuelve el identificador del objeto
persistido.
4. Para que los cambios sean sincronizados en las bases de
datos, es necesario realizar el commit de la transacción.
Dentro del objeto sesión se llama al método flush(). Es
posible llamarlo explícitamente. En este momento, se
obtiene la conexión JDBC a la bases de datos para poder
ejecutar la oportuna sentencia.
5. Finalmente, la sesión se cierra, con el objeto de liberar el
contexto de persistencia, y por tanto, devolver la
referencia del objeto creado al estado disociado.
Los objetos cargados, grabados, creados o consultados por la
sesión pueden ser manipulados por la aplicación, y cualquier
cambio a su estado de persistencia será persistido cuando se le
No hay que invocar ningún método en particular para que las
modificaciones se vuelvan persistentes. Así que la manera más
sencilla y directa de actualizar el estado de un objeto es cargarlo
con load(), y luego manipularlo directamente, mientras la sesión
esté abierta.
Para borrar objetos persistentes, podemos ejecutar Session.delete(), que
quitará el estado de un objeto de la base de datos. Por supuesto, su
aplicación podría aún contener una referencia al objeto quitado. Se
puede borrar objetos en cualquier orden, no se van a producir
violaciones de llave externa, pero sí es posible violar constraints NOT
NULL aplicadas a la columna de llave externa.
Muchas aplicaciones necesitan capturar un objeto en una
transacción, mandarlo a la capa de interfaz de usuario para su
manipulación, y grabar sus cambios en una nueva transacción. Las
aplicaciones que usan este tipo de estrategia en entornos de alta
concurrencia, normalmente usan datos versionados para garantizar
aislamiento durante la "larga" unidad de trabajo.
Hibernate soporta este modelo, proveyendo "reasociación" de
entidades desprendidas usando los métodos Session.update() o
Session.merge().
9.Consultas SQL
Usando Hibernate, la ejecución de consultas SQL nativas se
controla por medio de la interfaz SQLQuery, la cual se obtiene
llamando a Session.createSQLQuery(). Las siguientes secciones
describen cómo utilizar esta API para consultas
La consulta SQL más básica es para obtener a una lista de escalares
(valores).
 sess.createSQLQuery("SELECT * FROM
Personas").list();
 sess.createSQLQuery("SELECT ID,NOMBRE, EDAD
FROM PERSONAS").list();
Estas retornarán una lista de objetos arrays ( Object[]) con valores
escalares para cada columna en la tabla PERSONAS. Hibernate
utilizará ResultSetMetadata para deducir el orden real y los tipos de los
valores escalares retornados.
Otro tipo de consulta más compleja es la consulta de entidades.
Para obtener los objetos entidades desde una consulta sql nativa, se
utiliza por medio de addEntity().
 sess.createSQLQuery("SELECT * FROM
PERSONAS").addEntity(Persona.class);
 sess.createSQLQuery("SELECT ID,NOMBRE,EDAD
FROM PERSONAS").addEntity(Persona.class);
Se especifica esta consulta:
 La cadena de consulta SQL.
 La entidad devuelta por la consulta.
Asumiendo que Persona es mapeado como una clase con las
columnas IDENTIFICACION, NOMBRE y FECHA DE
NACIMIENTO las consultas anteriores devolverán una Lista en
donde cada elemento es una entidad Persona.
 10. Lenguajes propios from Alumnos where nombre='Francisco'.

Si existe un alias, usaremos un nombre de propiedad calificado:

de la herramienta ORM from Alumnos as alumnos where alumnos.nombre='Francisco'.

Hibernate utiliza un lenguaje de consulta potente (HQL) que se
parece a SQL. Sin embargo, comparado con SQL, HQL es
completamente orientado a objetos y comprende nociones como
herencia, polimorfismo y asociación. Las consultas se escriben en
HQL y Hibernate se encarga de convertirlas al SQL usado por la
base de datos con la que estemos trabajando y ejecutarla para
realizar la operación indicada.
Esto retorna instancias de Alumnos llamados "Francisco".
Funciones de agregación. Las consultas HQL pueden retornar
resultados de funciones de agregación sobre propiedades:
select avg(alumnos.nota), sum(alumnos.nota), max(alumnos.nota),
count(alumnos) from Alumnos alumnos.

HQL es case-insensitive, o sea que sus sentencias pueden escribirse
en mayúsculas y minúsculas. Por lo tanto "SeLeCt", "seleCT",
"select", y "SELECT" se entienden como la misma cosa. Lo único
con lo que debemos tener cuidado es con los nombres de las clases
que estamos recuperando y con sus propiedades, ahí si se
distinguen mayúsculas y minúsculas. O sea, en este caso
"pruebas.Hibernate.Usuario" NO ES LO MISMO que
"PrueBAs.Hibernate.UsuArio".
Entre las características más importantes de HQL.
 Soporte completo para operaciones relacionales: HQL
permite representar consultas SQL en forma de objetos.
HQL usa clases y atributos o propiedades en vez de
tablas y columnas.
 Regresa sus resultados en forma de objetos: Las
consultas realizadas usando HQL regresan los resultados
de las mismas en la forma de objetos o listas de objetos,
que son más fáciles de usar.
 Consultas Polimórficas: Podemos declarar el resultado
usando el tipo de la superclase e Hibernate se encargara
de crear los objetos adecuados de las subclases correctas
de forma automática.
 Soporte para características avanzadas: HQL contiene
muchas características avanzadas que son muy útiles y
que no siempre están presentes en todas las bases de
datos, o no es fácil usarlas, como paginación, fetch joins
con perfiles dinámicos, inner y outer joins, etc. Además
soporta proyecciones, funciones de agregación (max,
avg), y agrupamientos, ordenamientos, y subconsultas.
 Independiente del manejador de base de datos: Las
consultas escritas en HQL son independientes de la base
de datos (siempre que la base de datos soporte la
característica que estamos intentando utilizar)
10.1. Lenguaje HQL
Expresiones. Las expresiones utilizadas en la cláusula where
incluyen lo siguiente: operadores matemáticos, operadores de
comparación binarios, operadores lógicos, paréntesis () que indican
agrupación, funciones Java, etc.
La cláusula order by. La lista retornada por una consulta se puede
ordenar por cualquier propiedad de una clase retornada o
componentes. La palabra asc o desc opcionales indican ordenamiento
ascendente o descendente respectivamente.
La cláusula group by. Una consulta que retorna valores agregados
se puede agrupar por cualquier propiedad de una clase retornada o
componentes:
Subconsultas. Para bases de datos que soportan subconsultas,
Hibernate soporta subconsultas dentro de consultas. Una
subconsulta se debe encerrar entre paréntesis (frecuentemente por
una llamada a una función de agregación SQL). Incluso se
permiten subconsultas correlacionadas (subconsultas que se
refieren a un alias en la consulta exterior).
12. Gestión de transacciones
Una transacción es un conjunto de órdenes que se ejecutan
formando una unidad de trabajo, en forma indivisible o atómica.
Para la gestión de transacciones en Hibernate, no se produce
bloqueo de objetos en la memoria. La aplicación puede esperar el
comportamiento definido por el nivel de aislamiento de sus
transacciones de las bases de datos. Gracias a la Session, la cual
también es un caché con alcance de transacción. Para realizar con
éxito la gestión de transacciones, éstas se van a basar en el uso del
objeto Session.
El objeto Session se obtiene a partir de un objeto SessionFactory,
invocando el método openSession. Un objeto SessionFactory
representa una configuración particular de un conjunto de
metadatos de mapping objeto/relaciona.

Clausula from: La consulta más simple que se puede realizar con

Hibernate, es utilizando la cláusula from, la siguiente sería una
consulta que mostraría todos los datos de una tabla de nombre
Alumnos:

from Alumnos

Cláusula select: La cláusula select escoge qué objetos y

propiedades devolver en el conjunto de resultados de la consulta.
Un ejemplo de consulta podría ser:

select alumno.nombre from Alumnos alumno where

alumno.nombre like 'A%'

La cláusula where: La cláusula where nos permite refinar la lista de

instancias retornadas. Si no existe ningún alias, puede referirse a
las propiedades por nombre:
Cuando se crea el objeto Session , se le asigna la conexión de la base
de datos que va a utilizar. Una vez obtenido el objeto Session, se
crea una nueva unidad de trabajo ( Transaction) utilizando el
método beginTransaction. Dentro del contexto de la transacción
creada, se pueden invocarlos métodos de gestión de persistencia
proporcionados por el objeto Session, para recuperar, añadir,
eliminar o modificar el estado de instancias de clases persistentes.
También se pueden realizar consultas. Si las operaciones de
persistencia no han producido ninguna excepción, se invoca el
método commit de la unidad de trabajo para confirmar los cambios
realizados. En caso contrario, se realiza un rollback para deshacer los
cambios producidos. Sobre un mismo objeto Session pueden
crearse varias unidades de trabajo. Finalmente se cierra el objeto
Session invocando su método close.
 Tema 5. Bases de datos objeto-
relacionales y orientadas a objetos
1. Introducción
Las Bases de Datos Relacionales (BDR) son ideales para
aplicaciones tradicionales que soportan tareas administrativas, y
que trabajan con datos de estructuras simples y poco cambiantes,
incluso cuando la aplicación pueda estar desarrolla en un lenguaje
OO y sea necesario un Mapeo Objeto Relacional (ORM)
Pero cuando la aplicación requiere otras necesidades, como por
ejemplo, soporte multimedia, almacenar objetos muy cambiantes y
complejos en estructura y relaciones, este tipo de base de datos no
son las más adecuadas.
Recuerda, que si queremos representar un objeto y sus relaciones
en una BDR esto implica que:
 Los objetos deben ser descompuestos en diferentes
tablas.
 A mayor complejidad, mayor número de tablas, de
manera que se requieren muchos enlaces (joins) para
recuperar un objeto, lo cual disminuye dramáticamente el
rendimiento.
Las Bases de Datos Orientadas a Objetos (BDOO) o Bases de
Objetos se integran directamente y sin problemas con las
aplicaciones desarrolladas en lenguajes orientados a objetos, ya que
soportan un modelo de objetos puro y son ideales para
almacenar y recuperar datos complejos permitiendo a los usuarios
su navegación directa (sin un mapeo entre distintas
representaciones).
Las Bases de Objetos aparecieron a finales de los años 80
motivadas fundamentalmente por dos razones:
 Las necesidades de los lenguajes de Bases de Datos
Orientadas a Objetos (POO), como la necesidad de
persistir objetos.
 Las limitaciones de las bases de datos relacionales, como
el hecho de que sólo manejan estructuras muy simples
(tablas) y tienen poca riqueza semántica
Pero como las BDOO no terminaban de asentarse, debido
fundamentalmente a la inexistencia de un estándar, y las BDR
gozaban y gozan en la actualidad de una gran aceptación,
experiencia y difusión, debido fundamentalmente a su gran
robustez y al lenguaje SQL, los fabricantes de bases de datos
comenzaron e implementar nuevas funcionalidades orientadas a
objetos en las BDR existentes. Así surgieron, las bases de datos
objeto-relacionales.
Las Bases de Datos Objeto-Relacionales (BDOR) son bases de
datos relacionales que han evolucionado hacia una base de datos
más extensa y compleja, incorporando conceptos del modelo
orientado a objetos. Pero en estas bases de datos aún existe un
mapeo de objetos subyacente, que es costoso y poco flexible,
cuando los objetos y sus interacciones son complejos.
2. Características de
las bases de datos
orientadas a objetos
En una BDOO, los datos se almacenan como objetos. Un objeto es,
al igual que en POO, una entidad que se puede identificar
unívocamente y que describe tanto el estado como el
comportamiento de una entidad del 'mundo real'. El estado de un
objeto se describe mediante atributos y su comportamiento es
definido mediante procedimientos o métodos. Entonces, ¿a qué
equivalen las entidades, ocurrencias de entidades y relaciones del
modelo relacional? Las entidades son las clases, las ocurrencias de
entidad son objetos creados desde las clases, las relaciones se
mantienen por medio de inclusión lógica, y no existen claves
primarias, los objetos tienen un identificador.
La principal característica de las BDOO es que soportan un
modelo de objetos puro y que el lenguaje de programación y el
esquema de la base de datos utilizan las mismas definiciones de
tipos.
Otras características importantes de las BDOO son las
siguientes:
 Soportan las características propias de la Orientación
a Objetos como agregación, encapsulamiento,
polimorfismo y herencia. La herencia se mantiene en la
propia base de datos.
 Identificador de objeto (OID). Cada objeto tiene un
identificador, generado por el sistema, que es único para
cada objeto, lo que supone que cada vez que se necesite
modificar un objeto, habrá que recuperarlo de la base de
datos, hacer los cambios y almacenarlo nuevamente. Los
OID son independientes del contenido del objeto, esto es,
si cambia su información, el objeto sigue teniendo el
mismo OID. Dos objetos serán equivalentes si tienen la
misma información, pero diferentes OID.
 Jerarquía y extensión de tipos. Se pueden definir
nuevos tipos basándose en otros tipos predefinidos,
cargándolos en una jerarquía de tipos (o jerarquía de
clases). Objetos complejos. Los objetos pueden tener una
estructura de objeto de complejidad arbitraria, a fin de
contener toda la información necesaria que describe el
objeto.
 Acceso navegacional de datos. Cuando los datos se
almacenan en una estructura de red densa y
 probablemente con una estructura de diferentes niveles
de profundidad, el acceso a datos se hace principalmente
navegando la estructura de objetos y se expresa de forma
natural utilizando las construcciones nativas del lenguaje,
sin necesidad de uniones o joins típicas en las BDR.
 Gestión de versiones. El mismo objeto puede estar
representado por múltiples versiones. Muchas
aplicaciones de bases de datos que usan orientación a
objetos requieren la existencia de varias versiones del
mismo objeto, ya que, si estando la aplicación en
funcionamiento es necesario modificar alguno de sus
módulos, el diseñador deberá crear una nueva versión de
cada uno de ellos para efectuar cambios.
2.2 Ventajas e inconvenientes
/* Añadir imagen
El uso de una BDOO puede ser ventajoso frente a una BDR
relacional si nuestra aplicación requiere alguno de estos elementos:
 Un gran número de tipos de datos diferentes.


Un gran número de relaciones entre los objetos.
Objetos con comportamientos complejos.
Una de las principales ventajas de los sistemas de bases de datos
orientados a objetos es la transparencia, (manipulación directa de
datos utilizando un entorno de programación basado en objetos),
por lo que el programador, solo se debe preocupar de los objetos de
su aplicación, en lugar de como los debe almacenar y recuperar de
un medio físico.
Otras ventajas de un sistema de bases de datos orientado a objetos
son las siguientes:
 Gran capacidad de modelado. El modelado de datos
orientado a objetos permite modelar el 'mundo real' de
una manera óptima gracias al encapsulamiento y la
herencia.
 Flexibilidad. Permiten una estructura cambiante con solo
añadir subclases.
 Soporte para el manejo de objetos complejos.
Manipula de forma rápida y ágil objetos complejos, ya
que la estructura de la base de datos está dada por
referencias (apuntadores lógicos) entre objetos.
 Alta velocidad de procesamiento. Como el resultado de
las consultas son objetos, no hay que reensamblar los
objetos cada vez que se accede a la base de objetos
 Extensibilidad. Se pueden construir nuevos tipos de
datos a partir de los ya existentes, agrupar propiedades
comunes de diversas clases e incluirlas en una
superclase, lo que reduce la redundancia.
 Mejora los costes de desarrollo, ya que es posible la
reutilización de código, una de las características de los
lenguajes de programación orientados a objetos.
 Facilitar el control de acceso y concurrencia, puesto
que se puede bloquear a ciertos objetos, incluso en una
jerarquía completa de objetos.
 Funcionan de forma eficiente en entornos
cliente/servidor y arquitecturas distribuidas.
Pero, aunque los sistemas de bases de datos orientados a objetos
pueden proporcionar soluciones apropiadas para muchos tipos de
aplicaciones avanzadas de bases de datos, también tienen sus
desventajas. Éstas son las siguientes:
 Carencia de un modelo de datos universal. No hay
ningún modelo de datos aceptado universalmente, y la
mayor parte de los modelos carecen de una base teórica.
 Falta de estándares. Existe una carencia de estándares
general para los sistemas de BDOO.
 Complejidad. La estructura de una BDOO es más
compleja y difícil de entender que la de una BDR.
 Competencia de otros modelos. Las bases de datos
relacionales y objeto-relacionales están muy asentadas y
extendidas, siendo un duro competidor.
 Difícil optimización de consultas. La optimización de
consultas requiere una compresión de la implementación
de los objetos, para poder acceder a la base de datos de
manera eficiente. Sin embargo, esto compromete el
concepto de encapsulación.
3. Gestores de bases
de datos orientadas a
objetos
/* Añadir imagen
Un Sistema Gestor de Bases de Datos Orientada a Objetos
(SGBDOO) y en inglés ODBMS, Object Database Management
System) es un software específico, dedicado a servir de interfaz
entre la base de objetos, el usuario y las aplicaciones que la
utilizan. Un SGBDOO incorpora el paradigma de Orientación a
Objetos y permite el almacenamiento de objetos en soporte
secundario:
 Por ser SGBD debe incluir mecanismos para optimizar el
acceso, gestionar el control de concurrencia, la seguridad
y la gestión de usuarios, así como facilitar la consulta y
recuperación ante fallos.
 Por ser OO incorpora características de identidad,
encapsulación, herencia, polimorfismo y control de tipos.
Cuando aparecieron las bases de datos orientadas a objetos, un
grupo formado por desarrolladores y usuarios de bases de objetos,
denominado ODMG (Object-Oriented Database Management
Group), propuso un estándar que se conoce como estándar
ODMG-93 y que se ha ido revisando con el tiempo, pero que en
realidad no ha tenido mucho éxito, aunque es un punto de partida.
Debes conocer
/*Añadir resumen
¿Qué estrategias o enfoques se siguen para el desarrollo de
SGBDOO? Básicamente, las siguientes:
 Ampliar un lenguaje de programación OO existente con
capacidades de BD (Ejemplo: GemStone).
 Proporcionar bibliotecas de clases con las capacidades
tradicionales de las bases de datos, como persistencia,
transacciones, concurrencia, etc., (Ejemplo: ObjectStore
y Versant).
 Ampliar un lenguaje de BD con capacidades OO, caso de
SQL 2003 y Object SQL (OQL, propuesto por ODMG).
Tal y como estarás pensando, la carencia de un estándar real hace
difícil el soporte para la portabilidad de aplicaciones y su
interoperabilidad, y es en parte por ello, que a diferencia de las
bases de datos relacionales donde hay muchos productos donde
elegir, la variedad de sistemas de bases de datos orientadas a
objetos es mucho menor. En la actualidad hay diferentes productos
de este tipo, tanto con licencia libre como propietaria.
A continuación, te indicamos algunos ejemplos de SGBOO:
 Db4o de Versant. Es una BDOO Open Source para Java
y .NET. Se distribuye bajo licencia GPL.
 Matisse. Es un SGBOO basado en la especificación
ODMG, proporciona lenguajes para definición y
manipulación de objetos, así como interfaces de
programación para C, C++, Eiffel y Java.
 ObjectDB. Es una BDOO que ofrece soporte para Java,
C++, y Python entre otros lenguajes. No es un producto
libre, aunque ofrecen versiones de prueba durante un
periodo determinado.
 EyeDB. Es un SGBOO basado en la especificación
ODMG, proporciona lenguajes para definición y
manipulación de objetos, e interfaces de programación
para C++ y Java. Se distribuye bajo licencia GNU y es
software libre.
 Neodatis, ObjectStore y GemStone. Son otros SGBDOO.
3.2. Objetos simples y /* Añadir imagen
objetos estructurados
/* Añadir imagen
En las BDOO los objetos se encuentran interrelacionados por
referencias entre ellos de manera similar a como los objetos se
referencian entre sí en memoria.
Un objeto de tipo simple u objeto simple es aquel que no contiene
a otros objetos y por tanto posee una estructura de un solo nivel de
profundidad en este sentido.
Un objeto de tipo estructurado u objeto estructurado incluye
entre sus componentes a otros objetos y se define aplicando los
constructores de tipos disponibles por el SGBDOO recursivamente
a varios niveles de profundidad.
Entre un objeto y sus componentes de cada nivel, existen dos tipos
de referencia:
 Referencia de propiedad. Se aplica cuando los
componentes de un objeto se encapsulan dentro del
propio objeto y se consideran, por tanto, parte de ese
objeto. Relación es-parte-de. No necesitan tener
identificadores de objeto y sólo los métodos de ese objeto
pueden acceder a ellos. Desaparecen si el propio objeto
se elimina.
 Referencia de asociación. Se aplica cuando entre los
componentes del objeto estructurado existen objetos
independientes, pero es posible hacer referencia a ellos
desde el objeto estructurado. Relación está-asociado-
con. Cuando un objeto estructurado tiene que acceder a
sus componentes referenciados, lo hace invocando los
métodos apropiados de los componentes, ya que no están
encapsulados dentro del objeto estructurado.
Por ejemplo, si observas la figura superior derecha, en un objeto
tipo Oficina los componentes codigo y dirección son_parte_del
objeto, mientras que el componente jefe, es un objeto
independiente que está_asociado_con el objeto oficina.
Entonces, ¿las referencias de asociación son como las relaciones
del modelo relacional? Así es:
 La referencia de asociación representa las relaciones o
interrelaciones entre objetos independientes, dando la
posibilidad de que los objetos puedan detectarse
mutuamente en una o dos direcciones, (lo que en el
modelo relacional representamos mediante claves ajenas
o foráneas que provienen de relaciones uno a uno, uno a
muchos y muchos a muchos).
 Una relación uno a muchos se representa mediante un
objeto tipo colección (List, Set, etc.). En una BDOO la
colección se maneja como cualquier otro objeto (aunque
potencialmente profundo) y normalmente se podrá
recuperar y almacenar el objeto padre junto con la
colección asociada y su contenido en una sola llamada.
Además, un objeto miembro referenciado puede ser referenciado
por más de un objeto estructurado y, no se elimina
automáticamente cuando se elimina el objeto del nivel superior.
3.3. Instalación del gestor de
objetos Db4o
DB4O es un novedoso motor de base de datos orientada a objetos.
Sus siglas se corresponden con la expresión "DataBase 4 (for)
Objects", que a su vez es el nombre de la compañía que lo
desarrolla: db4objects, Inc., disponible para Java y .Net, y utilizada
en la actualidad por diversas compañías para el desarrollo de
aplicaciones de dispositivos móviles, dispositivos médicos y
biotecnología, aplicaciones web, software enlatado y aplicaciones
en tiempo real.
Tres características importantes de Db4o son las siguientes:
 El modelo de clases es el propio esquema de la base de
datos, por lo que se elimina el proceso de diseño,
implementación y mantenimiento de la base de datos.
 Está diseñada bajo la estrategia de proporcionar
bibliotecas de clases con las capacidades tradicionales de
las bases de datos, y con el objetivo de cero
administración.
 Puede trabajar como base de datos embebida, lo que
significa que se puede distribuir con la aplicación, y solo
la aplicación que lanza la base de datos embebida puede
acceder a ella, siendo ésta invisible para el usuario final.
La mayor clave del éxito que está teniendo este motor de base de
datos frente a otros competidores que han desarrollado tecnologías
similares, es que se ha optado por un modelo de licenciamiento
idéntico al utilizado por empresas como MySQL: licencia dual
GPL/comercial. Es decir, si se quiere desarrollar software libre con
esta biblioteca, su uso no conlleva ningún coste por licencia; sin
embargo si se desea aplicar a un software privativo, se aplica otro
modelo de licenciamiento concreto.
Actualmente este producto funciona como una biblioteca para dos
tipos de plataformas de desarrollo: Java y.NET (tanto la
implementación de Microsoft como la de Mono).
Una de las ventajas de db4o es que es un simple fichero .jar
distribuible con cualquier aplicación sin necesidad de tener que
instalar nada. Tampoco necesita drivers de tipo JDBC o similar.
La instalación de db4o consistirá en:
  Instalar el motor de base de datos, que son las clases
necesarias para hacer que funcione la API en toda su

extensión.
Instalar alguna aplicación para visualizar los datos con
los que se está trabajando. Esto último es necesario, pues
en otro caso se trabajaría a ciegas con los datos.
4. El API de la base
de objetos
Todos los SGBDOO, independientemente de su estrategia de
diseño, proporcionan un API (Interfaz de Programación de
Aplicaciones), más o menos extenso, disponible para ciertos
lenguajes OO. En el caso de Db4o, el API está disponible para Java
y .Net.
Los principales paquetes del API de Db4o son los siguientes:
 com.db4o. Paquete principal (core) de la Base de Objetos.
Las interfaces y clases más importantes que incluye son:
o ObjectContainer. Es el interfaz que permite
realizar las principales tareas con la base de
objetos. Un ObjectContainer puede representar
una base de datos independiente (stand-
alone) o una conexión a un servidor (en línea
cliente-servidor). Este interfaz proporciona
métodos para almacenar store(), consultar
queryByExample() y eliminar delete() objetos de la
base de datos, así como cerrar la conexión a
ésta close(). También permite confirmar commit y
deshacer rollback transacciones.
o EmbeddedObjectContainer. Es un interfaz que
extiende a ObjectContainer y representa un
ObjectContainer local atacando a la base de datos.
o Db4oEmbedded. Es una clase que proporciona
métodos estáticos para conectar con la base de
datos en modo embebido.
o ObjectServer. Es el interfaz que permite trabajar
con una base de datos db4o en modo cliente-
servidor.
o ObjectSet. Es un interfaz que representa el
conjunto de objetos devueltos por una consulta.
 com.db4o.query. Paquete con funcionalidades de consulta.
Proporciona interfaces que permiten establecer las
condiciones y criterios de una consulta y una clase para
realizar consultas mediante Native Query (Consultas
nativas).
 com.db4o.config. Paquete con funcionalidades de
configuración. Contiene interfaces y clases que nos
permiten configurar y/o personalizar la base de objetos
según necesiades. La configuración de la base de objetos
se hace por norma general antes de abrir la sesión en la
misma.
o EmbeddedConfiguration. Es la interface de
configuración para el uso en modo embebido.
Siempre que trabajemos con bases de objetos Db4o utilizaremos el
interface ObjectContainer, puesto que es quien representará a la base
de objetos, sea embebida o no.
La documentación del API viene en formato JavaDoc y la puedes
encontrar en el directorio /doc/api del fichero .zip descargado y
descomprimido.
3.2 Apertura y cierre de
conexiones
/*Añadir imagen
En general, la conexión de una aplicación Java con una base de
objetos se podrá realizar vía:
 JDBC.
 El API proporcionado por el propio gestor de objetos.
En el caso de Db4o, el paquete com.db4o proporciona las clases e
interfaces que permiten abrir conexiones a una base de objetos
db4o, así como el cierre de la misma. Estas son:
 Abrir conexión. Podemos utilizar las siguientes clases:
o Db4oEmbedded. Es una clase que hereda de
java.lang.Object y proporciona métodos estáticos
como openFile() para abrir una instancia de la
base de datos en modo embebido. En modo
embebido tiene la limitación de que sólo se
puede utilizar en la base de datos una conexión.
o ObjectServer. Es un interfaz que permite trabajar
con una base de datos db4o en modo cliente-
servidor. Una vez abierta la base de datos
como servidor mediante Db4o.openServer(), el
método openClient() del interfaz ObjectServer
permitirá abrir conexiones cliente
directamente en memoria o bien mediante
TCP/IP.
 Cerrar conexión. Para ello utilizaremos el método close()
de la interfaz ObjectContainer.
El esquema de trabajo para operar con la base de objetos será
el siguiente:
 Declarar un ObjectContainer.
 Abrir una conexión a la base de objetos ( openFile()). Si al
abrir la BDOO esta no existe, se creará.
 Realizar operaciones con la base de objetos como
consultas, borrados y modificaciones (en un bloque try{ }
catch (){ } ).
 Cierre o desconexión de la base de objetos (close()).
En el siguiente recurso didáctico tienes un ejemplo de apertura,
creación y cierre a una base de objetos en modo embebido. En la
BDOO creada se almacenan 4 objetos mediante el método store().
3.3 Consultas a la base de
objetos
A una BDOO se podrán realizar consultas mediante:
 Un lenguaje de consultas como OQL, si el gestor está
basado en el estándar ODMG e incluye sentencias del
tipo SQL.
 El API proporcionado por el propio sistema gestor de
bases de datos orientadas a objetos.
Los tres sistemas de consulta que proporciona Db4o basados en el
API del propio gestor, son los siguientes:
  Consultas por ejemplo. Query By Example (QBE). Es
la forma más sencilla y básica de realizar consultas, pero
tienen bastantes limitaciones.
 Consultas nativas. Native Queries (NQ). Es la interface
principal de consultas de la base de objetos. Permiten
realizar un filtro contra todas las instancias de la base de
objetos.
 Consultas SODA. Simple Object Data Access
(SODA). Permite generar consultas dinámicas. Es más
potente que las anteriores y más rápida puesto que las
anteriores (QBE y NQ) tienen que ser traducidas a
SODA para ejecutarse.
¿En qué consiste cada uno de estos sistemas de consulta?
En el siguiente recurso didáctico encontrarás un resumen y
ejemplos de estos sistemas de consulta. Los ejemplos se realizan
sobre la base de objetos Congreso.
/* Añadir imagen
3.4 Actualización de objetos
simples
Recuerda que un objeto simple es un objeto que no contiene a
otros objetos, como por ejemplo los objetos de la clase ponente. Un
segmento de la definición de esta clase, es la siguiente:
/* Añadir imagen
Para consultar objetos simples se pueden utilizar cualquiera de los
tres sistemas de consulta proporcionados por db4o, tal y como has
podido ver en el apartado anterior.
Para modificar objetos almacenados debes seguir los siguientes
pasos:
 Cambiar los valores del objeto con los nuevos valores.
 Almacenar de nuevo el objeto con el método store() de la
interfaz ObjectContainer.
Por ejemplo, el siguiente método permitirá modificar objetos
ponente, en concreto actualizar el e-mail de ponentes por nif de
ponente:
/*Añadir imagen
Db4o necesita conocer previamente un objeto para poder
actualizarlo. Esto significa que para poder ser actualizados los
objetos, éstos deben de haber sido insertados o recuperados en la
misma sesión; en otro caso se añadirá otro objeto en vez de
actualizarse.
Para eliminar objetos almacenados utilizaremos el método delete()
de la interface ObjectContainer .
Por ejemplo, el siguiente método elimina un objeto ponente por su
nif:
/*Añadir imagen
3.5 Actualización de objetos
estructurados
/*Añadir imagen
Los objetos estructurados son objetos que contienen a su vez a
otros objetos (objetos hijo u objetos miembro).
En el caso de objetos estructurados se habla de diferentes niveles
de profundidad del objeto. El nivel más alto, nivel 1, será el que
corresponde a la definición del objeto estructurado (objeto padre),
el siguiente nivel, nivel 2, corresponderá a la definición del objeto
hijo y así sucesivamente podrá haber un nivel 3, 4... dependiendo
de que los objetos hijos a su vez incluyan en su definición a otro u
otros objetos miembro.
En el siguiente ejemplo, definimos la clase charla (objeto
estructurado padre) que incorpora a un objeto ponente (objeto
miembro). El nivel más alto de profundidad o nivel 1 es el que
corresponde a la definición de charla y el nivel 2 corresponderá a la
definición del objeto ponente.
¿Cómo se almacenan, consultan y actualizan los objetos
estructurados en Db4o?
 Los objetos estructurados se almacenan asignando
valores con set() y después persistiendo el objeto con
store(). Al almacenar un objeto estructurado del nivel más
alto, se almacenarán de forma implícita todos los objetos
hijo.
 Las consultas se realizan por cualquiera de los sistemas
soportados por el gestor y se podrá ir descendiendo por
los diferentes niveles de profundidad.
 La eliminación o borrado de un objeto estructurado se
realiza mediante el método delete(). Por defecto, no se
eliminarán los objetos miembro. Para eliminar objetos
estructurados en cascada o de forma recursiva,
eliminando los objetos miembro, habrá que configurar de
modo apropiado la base de objetos antes de abrirla,
mediante el paquete com.db4o.config. En el caso de modo
embebido, se hará mediante la interface
EmbeddedConfiguration . En la nueva configuración se debe
indicar cascadeOnDelete(true).
 La modificación se realizará actualizando los nuevos
valores mediante el método set(). Por defecto las
modificaciones solo afectan al nivel más alto. Para
actualizar de forma recursiva todos los objetos miembro
habrá que indicar en la configuración cascadeOnUpdate(true).
En este otro enlace dispones de un ejemplo con eliminación y
modificación de charlas en cascada.
/*Añadir imagen
5. El lenguaje de
consulta de objetos
OQL
OQL (Object Query Languaje) es el lenguaje de consulta de
objetos propuesto en el estándar ODMG.
Las siguientes son algunas de las características más relevantes
de OQL:
 Es un lenguaje declarativo del tipo de SQL que permite
realizar consultas de modo eficiente sobre bases de datos

orientadas a objetos.
Su sintaxis es similar a la de SQL, proporcionando un
superconjunto de la sintaxis de la sentencia SELECT,
 con algunas características añadidas para los conceptos
ODMG, como la identidad del objeto, los objetos
complejos, las operaciones, la herencia, el polimorfismo
y las relaciones.
 No posee primitivas para modificar el estado de los
objetos ya que las modificaciones se pueden realizar
mediante los métodos que estos poseen.
 Puede ser usado como un lenguaje autónomo o
incrustado dentro de otros lenguajes como C++,
Smalltalk y Java.
 Una consulta OQL incrustada en uno de estos
lenguajes de programación puede devolver objetos que
coincidan con el sistema de tipos de ese lenguaje.
 Desde OQL se pueden invocar operaciones escritas en
estos lenguajes.
 Permite acceso tanto asociativo como navegacional:
o Una consulta asociativa devuelve una
colección de objetos.
o Una consulta navegacional accede a objetos
individuales y las interrelaciones entre objetos
sirven para navegar entre objetos.
5.1 Sintaxis, expresiones y
operadores
La sintaxis básica y resumida de una sentencia SELECT del OQL
estándar es la siguiente:
/*Añadir imagen
SELECT [DISTINCT <expresión, ...>]
FROM <lista from>
[WHERE <condición>]
[ORDER BY <expresión>]
Por ejemplo, suponiendo el esquema de base de objetos que puedes
ver en la figura ampliable de la derecha, la siguiente sentencia
select recupera de la base de objetos los atributos nombre y el
correo de objetos tipo profesor cuyo año de ingreso es anterior al
1990, y ordenados alfabéticamente por nombre:
SELECT p.nombre, p.email FROM p in Profesor WHERE
p.ingreso <= 1990 ORDER BY p.nombre;
Las siguientes, son algunas consideraciones a tener en cuenta:
 En las consultas se necesita un punto de entrada, que
suele ser el nombre de una clase.
 El resultado de una consulta es una colección que puede
ser tipo bag (si hay valores repetidos) o tipo set (no hay
valores repetidos). En este último caso habrá que
especificar SELECT DISTINCT.
 En general, una consulta OQL puede devolver un
resultado con una estructura compleja especificada en la
misma consulta utilizando struct.
 Una vez que se establece un punto de entrada, se pueden
utilizar expresiones de caminos para especificar un
camino a atributos y objetos relacionados. Una expresión
de camino empieza normalmente con un nombre de
objeto persistente o una variable iterador, seguida de
ninguno o varios nombres de relaciones o de atributos
conectados mediante un punto.
 Es posible crear objetos mutables (no literales) formados
por el resultado de una consulta.
Además, en una consulta OQL se pueden utilizar, entre otros, los
siguientes operadores y expresiones:
 Operadores de acceso: "." / "->" aplicados a un atributo,
una expresión o una relación. FIRST / LAST (primero /
último elemento de una lista o un vector).
 Operadores aritméticos: +, -, *, /, -(unario), MOD, ABS
para formar expresiones aritméticas.
 Operadores relacionales: >, =, <=, <>, = que permiten
comparaciones y construir expresiones lógicas.
 Operadores lógicos: NOT, AND, OR que permiten enlazar
otras expresiones.
A continuación, te indicamos de manera resumida, algunas otras
características, del estándar OQL:
 Definición de vistas, es decir, es posible dar nombre a
una consulta y utilizarlo en otras consultas.
 Extracción de elementos sencillos de colecciones set, bag,
o list.
 Operadores de colecciones como funciones de
agregación (MAX(), MIN(), COUNT(), SUM() y AVG()) y
cuantificadores (FOR ALL, EXISTS).
 Realización de agrupaciones mediante GROUP BY y filtro
de los grupos mediante HAVING.
 Combinación de consultas mediante JOINs
 Unión, intersección y resta de colecciones mediante los
operadores UNION, INTERSEC y EXCEPT.
En los siguientes apartados nos centraremos en el OQL concreto de
un SGBDOO y que por supuesto, incorpora sus propias
particularidades y diferencias respecto a la propuesta OQL de
ODMG.
5.2 Matisse, un gestor de
objetos que incorpora
OQL
Para practicar y trabajar con OQL utilizaremos Matisse, un gestor
orientado a objetos que incorpora características del estándar
ODMG, como los lenguajes ODL y OQL, y que tiene soporte para
Java. Aunque Matisse llama SQL a su lenguaje de consultas,
nosotros nos referiremos a él como OQL.
El propio gestor proporciona el driver matisse.jar para interactuar
con aplicaciones escritas en Java.
Dentro de los paquetes del API destacamos:
 com.matisse. Proporciona las clases e interfaces básicos
para trabajar con Java y una base de datos de objetos
Matisse.
 MtDatabase. Clase que proporciona todos los métodos para
realizar las conexiones y transacciones en la base de
objetos.
 com.matisse.sql. Proporciona clases que permiten interactuar
con la base de objetos vía JDBC.
Todas las interacciones entre una aplicación Java y la base de
objetos Matisse se realizan en el contexto de una transacción
(implícita o explícita).

5.3 Ejecución de Sentencias
OQL
La sintaxis básica del OQL de Matisse es una sentencia SELECT de
la forma: SELECT... FROM... WHERE...;
or ejemplo, para recuperar el valor de todos los atributos de los
objetos tipo Profesor, escribiríamos la siguiente sentencia OQL:
SELECT * FROM Profesor;
Y para recuperar del atributo nombre de los objetos tipo Profesor
cuyo año de ingreso es anterior al 1990, escribiríamos la siguiente
sentencia:
SELECT nombre FROM Profesor WHERE ingreso <= 1990;
Las siguientes son algunas consideraciones y ejemplos sobre las
consultas con SELECT:
 Toda sentencia SELECT finaliza en punto y coma.
 Además de la cláusula WHERE, que permite establecer un
criterio de selección se pueden utilizar las cláusulas de
agrupamiento GROUP BY, y de ordenación ORDER BY,
entre otras. También se pueden asignar alias mediante AS,
realizar búsquedas por patrones de caracteres con LIKE.
Ejemplo: título y tema de las tesis cuyo tema contien la
palabra Objeto, ordenadas por tema.
SELECT titulo AS "Tesis", tema FROM Tesis
WHERE tema LIKE '%Objeto%' ORDER BY tema;
 Al recuperar todos los atributos de una clase mediante
SELECT *, la consulta retornará el OID de cada objeto
recuperado, así como las interrelaciones o relaciones
definidas para esa clase. El OID y la interrelación son del
tipo string y se representan mediante un número
hexadecimal. Realmente el identificador recuperado para
la interrelación, hace referencia al primer objeto
relacionado, incluso aunque la interrelación incluya a

más de un objeto.
Se pueden hacer JOIN de clases, y por ejemplo esto puede
permitir obtener todos los objetos relacionados con otro
objeto en una consulta asociativa.
Ejemplo: nombre de cada profesor y título y tema de las
tesis que dirige con JOIN
SELECT p.nombre, t.titulo, t.tema FROM Profesor p
JOIN Tesis t ON t.es_dirigida = p.OID;
 Mediante SELECT se pueden realizar consultas
navegacionales haciendo referencia a las
interrelacionales entre objetos.
Ejemplo: nombre de cada profesor y título y tema de las
tesis que dirige, navegacional
SELECT t.titulo AS "Tesis", tema, t.es_dirigida.nombre
AS "Profesor " FROM Tesis t;
 También se pueden realizar consultas navegacionales a
través de la referencia de los objetos (REF()).
Ejemplo: tesis que dirigen los profesores con ingreo el
1990 o posterior
SELECT REF(p.dirige) FROM Profesor p 1)
WHERE p.ingreo >= 1990;
En el siguiente recurso didáctico encontrarás diferentes ejemplos
de consultas utilizando de forma autónoma o conversacional el
lenguaje OQL de Matisse.
/*Añadir imagen
5.4 Ejecución de sentencias
OQL vía JDBC
Veremos ahora cómo realizar consultas a una base de objetos
Matisse mediante sentencias OQL embebidas en Java. Para ello, la
conexión a la base de objetos se realizará vía JDBC. Matisse
proporciona dos formas de manipular objetos vía JDBC: mediante
JDB puro o mediante una mezcla de JDBC y Matisse.
1. Para crear una conexión vía JDBC puro utilizaremos
java.SQL.* y com.Matisse.SQL.MtDriver , no siendo necesario en
este caso el paquete com.Matisse.
a. La cadena de conexión será de la forma: String
url = "JDBC:mt://" + hostname + "/" + dbname;
b. La conexión se realizará mediante Connection
jcon = DriverManager.getConnection(url);
2. Para crear una conexión vía JDBC y Matisse (a través de
MtDatabase) se necesita java.SQL.* y com.Matisse.MtDatabase.
a. La cadena de conexión será de la forma:
MtDatabase db = new MtDatabase(hostname,
dbname);
b. La conexión se realizará mediante: db.open(); y
Connection jcon = db.getJDBCConnection();
Una vez realizada la conexión por uno u otro método, ya podremos
ejecutar sentencias OQL vía JDBC, (tal y como si de una sentencia
SQL se tratara) en la aplicación java.
6.Características de las
bases de datos objeto-
relacionales
Las BDOR las podemos ver como un híbrido de las BDR y las
BDOO que intenta aunar los beneficios de ambos modelos, aunque
por descontado, ello suponga renunciar a algunas características de
ambos.
Los objetivos que persiguen estas bases de datos son:
 Mejorar la representación de los datos mediante la
orientación a objetos.
 Simplificar el acceso a datos, manteniendo el sistema
relacional.
En una BDOR se siguen almacenando tablas en filas y columnas,
aunque la estructura de las filas no está restringida a contener
escalares o valores atómicos, sino que las columnas pueden
almacenar tipos estructurados (tipos compuestos como vectores,
conjuntos, etc.) y las tablas pueden ser definidas en función de
otras, que es lo que se denomina herencia directa.
Y eso, ¿cómo es posible?
Pues porque internamente tanto las tablas como las columnas son
tratados como objetos, esto es, se realiza un mapeo objeto-
relacional de manera transparente.
Como consecuencia de esto, aparecen nuevas características,
entre las que podemos destacar las siguientes:
 Tipos definidos por el usuario. Se pueden crear nuevos
tipos de datos definidos por el usuario, y que son
compuestos o estructurados, esto es, será posible tener en
una columna un atributo multivaluado (un tipo
compuesto).
 Tipos Objeto. Posibilidad de creación de objetos como
nuevo tipo de dato que permiten relaciones anidadas.
 Reusabilidad. Posibilidad de guardar esos tipos en el
gestor de la BDOR, para reutilizarlos en tantas tablas
como sea necesario
 Creación de funciones. Posibilidad de definir funciones
y almacenarlas en el gestor. Las funciones pueden
modelar el comportamiento de un tipo objeto, en este
caso se llaman métodos.
 Tablas anidadas. Se pueden definir columnas como
arrays o vectores multidimensionales, tanto de tipos
básicos como de tipos estructurados, esto es, se pueden
anidar tablas
 Herencia con subtipos y subtablas.
Estas y otras características de las bases de datos objeto-
relacionales vienen recogidas en el estándar SQL 1999.
6.1 El estándar SQL99
La norma ANSI SQL1999 (abreviadamente, SQL99) extiende el
estándar SQL92 de las Bases de Datos Relacionales, y da cabida a
nuevas características orientadas a objetos preservando los
fundamentos relacionales.
Algunas extensiones que contempla este estándar y que están
relacionadas directamente con la orientación a objetos son las
siguientes:
 Extensión de tipos de datos.
o Nuevos tipos de datos básicos para datos de
caracteres de gran tamaño, y datos binarios de
gran tamaño (Large Objects)
o Tipos definidos por el usuario o tipos
estructurados.
o Tipos colección, como los arrays, set, bag y list.
o Tipos fila y referencia
 Extensión de la semántica de datos.
o Procedimientos y funciones definidos por el
usuario, y almacenados en el gestor.
o Un tipo estructurado puede tener métodos
definidos sobre él.
Por ejemplo, el siguiente segmento de SQL crea un nuevo tipo de
dato, un tipo estructurado de nombre profesor y que incluye en su
definición un método, el método sueldo() .
CREATE TYPE profesor AS
( id INTEGER,
nombre VARCHAR (20),
sueldo_base DECIMAL (9,2),
complementos DECIMAL (9,2),
INSTANTIABLE NOT FINAL
METHOD sueldo() RETURNS DECIMAL (9,2));
CREATE METHOD sueldo() FOR profesor
BEGIN
......
END;
7.Gestores de Bases de
Datos Objeto-
Relacionales
Podemos decir que un sistema gestor de bases de datos objeto-
relacional (SGBDOR) contiene dos tecnologías; la tecnología
relacional y la tecnología de objetos, pero con ciertas restricciones.
A continuación, te indicamos algunos ejemplos de gestores objeto-
relacionales, tanto de código libre como propietario, todos ellos
con soporte para Java:
 De código abierto:
o PostgreSQL
o Apache Derby
 De código propietario
o Oracle
o First SQL
o DB2 de IBM
Las normativas SQL99 y SQL2003 son el estándar base que siguen
los SGBDOR en la actualidad, aunque como siempre ocurre, cada
gestor incorpora sus propias particularidades y diferencias respecto
al estándar. Por ejemplo, en Oracle se pueden usar las dos
posibilidades de herencia, de tipos y de tablas, mientras que en
PostgreSQL solo se puede usar la herencia entre tablas.
7.1 Instalación del Gestor
PostgreSQL
Para practicar con este tipo de gestores y algunas de las nuevas
características que incorporan, hemos elegido PostgreSQL,
considerado como el gestor de código abierto más avanzado del
mundo.
El código fuente de PostgreSQL está disponible bajo la licencia
BSD. Esta licencia te da libertad para usar, modificar y distribuir
PostgreSQL en cualquier forma, ya sea junto a código abierto o
cerrado. Además, PostgreSQL. incluye API para diferentes
lenguajes de programación, entre ellos Java y .NET
En la instalación se solicita una contraseña para el usuario postgres,
que es el administrador por defecto de la Base de Datos. La utilidad
pgAdmin (III) permite realizar esta administración de forma visual.
7.2 Tipos de datos: tipos
básicos y tipos
estructurados
/*Añadir imagen
Como ya sabes, los SGBDOR incorporan un conjunto muy rico de
tipos de datos. PostgreSQL no soporta herencia de tipos, pero
permite definir nuevos tipos de datos mediante los mecanismos
de extensión.
Te vamos a comentar tres categorías de tipos de datos que
encontramos en PostgreSQL:

 Tipos básicos: el equivalente a los tipos de columna
usados en cualquier base de datos relacional.
 Tipos compuestos: un conjunto de valores definidos por
el usuario con estructura de fila de tabla, y que como tal
puede estar formada por tipos de datos distintos.
 Tipos array: un conjunto de valores distribuidos en un
vector multidimensional, con la condición de que todos
sean del mismo tipo de dato (básico o compuesto).
Ofrece más funcionalidades que el array del estándar
SQL99.
Entre los tipos básicos, podemos destacar:
 Tipos numéricos. Aparte de valores enteros, números de
coma flotantes, y números de precisión arbitraria,
PostgreSQL incorpora también un tipo entero auto-
incremental denominado serial.
 Tipos de fecha y hora. Además de los típicos valores de
fecha, hora e instante, PostgreSQL incorpora el tipo
interval para representar intervalos de tiempo.
 Tipos de cadena de caracteres. Prácticamente los
mismos que en cualquier BDR.
 Tipos largos. Como, por ejemplo, el tipo BLOB para
representar objetos binarios. En la actualidad presentes
en muchas BDR como MySQL.
¿No soporta PostgreSQL el tipo estructurado?
Los tipos compuestos de PostgreSQL son el equivalente a los
tipos estructurados definidos por el usuario del estándar SQL99.
De hecho, son la base sobre la que se asienta el soporte a objetos.
Por ejemplo, podemos crear un nuevo tipo, el tipo dirección a partir
del nombre de la calle (varchar), del número de la calle ( integer) y del
código postal (integer), de la siguiente forma:
CREATE TYPE direccion AS (
calle varchar,
numero integer,
codigo_postal integer);
y luego definir la tabla de nombre afiliados, con una columna
basada en el nuevo tipo:
CREATE TABLE afiliados AS(
afiliado_id serial,
nombre varchar(45),
apellidos varchar(45),
domicilio direccion);
7.3 Conexión mediante
JDBC
La conexión de una aplicación Java con PostgreSQL se realiza
mediante un conector tipo JDBC.
Una vez integrado en un proyecto, el driver puede utilizarse desde
cualquiera de sus clases mediante un:
import java.sql.*
Recuerda que en JDBC, una base de datos está representada por
una URL. La cadena correspondiente tiene una de las tres formas
siguientes:
 jdbc: postgresql: base de datos
 jdbc: postgresql: //host/base de datos
 jdbc: postgresql: //host: puerto/base de datos
El nombre de host por defecto, del servidor PostgreSQL, será
localhost, y el puerto por el que escucha el 5432. Como ves, esta
cadena es idéntica a la empleada por otros sistemas gestores de
bases de datos.
Para conectar con la base de datos, utilizaremos el método
DriverManager.getConnection() que devuelve un objeto
Connection (la conexión con la base de datos). Una de las posibles
sintaxis de este método es:
Connection conn = DriverManager.getConnection(url, username,
password);
Una vez abierta, la conexión se mantendrá operativa hasta que se
llame a su método close() para efectuar la desconexión. Si al intentar
conectar con la base de datos ésta no existe, se generará una
excepción del tipo PSQLException "FATAL: no existe la base de
datos ...". En cualquier caso se requiere un bloque try-catch .
/*Añadir imagen
7.4 Consulta y actualización
de tipos básicos
PostgreSQL implementa los objetos como filas, las clases como
tablas, y los atributos como columnas. Hablaremos por tanto de
tablas, filas y columnas, tal y como lo hace PostgreSQL.
Para interactuar con PostgreSQL desde Java, vía JDBC, debemos
enviar sentencias SQL a la base de datos mediante el uso de
comandos.
Por tanto, si nuestra conexión es conn, para enviar un comando
Statement haríamos lo siguiente:
 Crear la sentencia, por ejemplo.: Statement sta =
conn.createStatement();
 Ejecutar la sentencia:
o sta.executeQuery(string sentenciaSQL); si
sentenciaSQL es una consulta (SELECT)
o sta.executeUpdate(string sentenciaSQL); si
sentenciaSQL es una actualización ( INSERT,
UPDATE O DELETE)
o sta.execute(string sentenciaSQL); si sentenciaSQL
es un CREATE, DROP, o un ALTER
Como ves, en PostgreSQL se utilizan estos comandos como en
cualquier otra BDR.
En el siguiente enlace te proporcionamos un ejemplo que ilustra
este hecho, con sentencias perfectamente conocidas por ti del
modelo relacional. Se crean varias tablas en la base de datos
anaconda, se insertan, modifican, eliminan y consultan datos de
tipos básicos.
/*Añadir imagen
En las próximas secciones, emplearemos estos mismos comandos
para estudiar las nuevas características del estándar SQL99

7.5 Consulta y actualización
de tipos estructurados
Imaginemos que tenemos el tipo estructurado direccion:
CREATE TYPE direccion AS (
calle varchar, numero integer, codigo_postal varchar);
y la tabla afiliados, con una columna basada en el nuevo tipo:
CREATE TABLE afiliados(afiliado_id serial, nombre varchar,
apellidos varchar, domicilio direccion);
¿Cómo insertamos valores en una tabla con un tipo
estructurado? Se puede hacer de dos formas:
 Pasando el valor del campo estructurado entre comillas
simples (lo que obliga a encerrar entre comillas dobles
cualquier valor de cadena dentro), y paréntesis para
encerrar los subvalores separados por comas:
INSERT INTO afiliados (nombre, apellidos, direccion)
VALUES ('Onorato', 'Maestre Toledo', '(“Calle
de Rufino”, 56, 98080)');
 Mediante la función ROW que permite dar valor a un
tipo compuesto o estructurado.
INSERT INTO afiliados (nombre, apellidos, direccion)
VALUES ('Onorato', 'Maestre Toledo',
ROW('Calle de Rufino', 56, 98080));
¿Cómo se referencia una subcolumna de un tipo estructurado?
 Se emplea la notación punto, '.' , tras el nombre de la
columna entre paréntesis, (tanto en consultas de
selección, como de modificación) . Por ejemplo:
SELECT (domicilio).calle FROM afiliados WHERE
(domicilio).codigo _postal=98080
devolvería el nombre de la calle Maestre Toledo. Los
paréntesis son necesarios para que el gestor no confunda
el nombre del campo compuesto con el de una tabla.
Y ¿cómo se elimina el tipo estructurado?
 Se elimina con DROP TYPE, por ejemplo DROP TYPE
direccion;
7.6 Consulta y actualización
de tipos array
PostgreSQL permite especificar vectores multidimensionales
como tipo de dato para las columnas de una tabla. La única
condición es que todos sus elementos sean del mismo tipo.
Por ejemplo:
 Declaración de una columna de tipo vector:
nombre_columna tipo_dato[]
 Declaración de una columna de tipo matriz
multidimensional: nombre_columna tipo_dato[][]
donde como se ve, sólo hay que agregar uno o más corchetes '[]' al
tipo de dato.
Aunque PostgreSQL permite especificar el tamaño de cada
dimensión en la declaración, y acepta escribir:
o bien nombre_columna tipo_dato[2][3] , las
nombre_columna tipo_dato[5]
versiones actuales ignoran estos valores en la práctica, de manera
que los array declarados de esta forma tienen la misma
funcionalidad que los del ejemplo anterior.
En realidad, ninguna de estas declaraciones es conforme al estándar
SQL99, que sólo contempla el tipo array como columnas de vectores
unidimensionales declarados con la palabra reservada array:
En el siguiente ejemplo puedes ver la creación de una tabla con una
columna de tipo array de varchar y como se insertan y consultan
valores:
/*Añadir imagenes
Debes conocer
/*Añadir información
7.7 Funciones del gestor
desde Java
Recuerda que el estándar SQL99 introduce la posibilidad de crear
funciones de usuario que puedan quedar almacenadas en el gestor
de bases de datos, utilizando un Lenguaje Procedural (PL). Estas
funciones pueden definir el comportamiento de ciertos objetos y
entonces, se llaman métodos. Oracle soporta métodos en este
sentido, no así el gestor PostgreSQL.
Lo que si podremos hacer en PostgreSQL es crear funciones con
prestaciones para los nuevos tipos de datos, tipos estructurados y
array, y llamarlas desde una aplicación Java.
En PostgreSQL se pueden construir funciones mediante diferentes
lenguajes:
 Funciones de lenguaje de consultas o funciones SQL
(Escritas en lenguaje SQL)
 Funciones de lenguaje procedural (Escritas en lenguaje
PL/pgSQL, PL/Java, etc)
 Funciones de lenguaje de programación (Escritas en
un lenguaje de compilado, como C o C++),
Veremos algún ejemplo de funciones en SQL. Sobre estas
funciones debes saber que:
 Los parámetros de la función pueden ser cualquier tipo
de dato admitido por el gestor (un tipo básico, un tipo
compuesto, un array o alguna combinación de ellos).
 El tipo devuelto puede ser un tipo básico, un array o un
tipo compuesto.
 Su estructura general tiene la forma:
CREATE FUNCION nombre_funcion(tipo_1,tipo_2,...)
RETURN tipo AS $$sentencia_sql$$
LANGUAJE SQL
Y debes tener en cuenta que:
  Los argumentos de la función SQL se pueden referenciar
en las consultas usando la sintaxis $n:, donde $1 se refiere al
primer argumento, $2 al segundo, y así sucesivamente. Si un
argumento es un tipo compuesto, entonces se usará la
notación '.' para acceder a sus subcolumnas.
 Por último, al final de la función hay que especificar que
la función se ha escrito en lenguaje SQL mediante las
palabras clave LENGUAJE SQL.
Por ejemplo, desde Java podemos crear una función que convierte
un tipo estructurado, por ejemplo el tipo direccion, en una cadena.
Para ello, ejecutaremos un comando Statement (sta) con el código
SQL de creación de la función:
sta.execute (“CREATE FUNCTION
cadena_direccion(direccion)”+
“RETURNS varchar AS 'SELECT $1.calle||' '|| CAST($1.numero
AS varchar)”+
“LANGUAGE SQL”;)
Si una función tiene algún parámetro de tipo estructurado, no se
podrá eliminar el tipo hasta que no se elimine la función. Se puede
usar DROP C nb_tipo CASCADE para eliminar de manera
automática las funciones que utilizan ese tipo.
En el siguiente enlace te puedes descargar un ejemplo donde se
crean funciones del gestor y se invocan desde una aplicación Java.
/* Añadir imagen
6. Gestión de
transacciones
Como en cualquier otro Sistema de Bases de datos, en un Sistema
de bases de objetos u objeto relacional, una transacción es un
conjunto de sentencias que se ejecutan formando una unidad de
trabajo, esto es, en forma indivisible o atómica, o se ejecutan todas
o no se ejecuta ninguna.
Mediante la gestión de transacciones, los sistemas gestores
proporcionan un acceso concurrente a los datos almacenados,
mantienen la integridad y seguridad de los datos, y proporcionan
un mecanismo de recuperación de la base de datos ante fallos.
Un ejemplo habitual para motivar la necesidad de transacciones es
el traspaso de una cantidad de dinero (digamos 10000€) entre dos
cuentas bancarias. Normalmente se realiza mediante dos
operaciones distintas, una en la que se decrementa el saldo de la
cuenta origen y otra en la que incrementamos el saldo de la cuenta
destino.
Para garantizar la integridad del sistema (es decir, para que no
aparezca o desaparezca dinero), las dos operaciones tienen que
completarse por completo, o anularse íntegramente en caso de que
una de ellas falle.
Las transacciones deben cumplir el criterio ACID.
 Atomicidad. Se deben cumplir todas las operaciones de
la transacción o no se cumple ninguna; no puede quedar a
medias.
 Consistencia. La transacción solo termina si la base de
datos queda en un estado consistente.
 Isolation (Aislamiento). Las transacciones sobre la
misma información deben ser independientes, para que
no interfieran sus operaciones y no se produzca ningún
tipo de error.
 Durabilidad. Cuando la transacción termina el resultado
de la misma perdura, y no se puede deshacer, aunque
falle el sistema.
Algunos sistemas proporcionan también puntos de salvaguarda
(savepoints) que permiten descartar selectivamente partes de la
transacción, justo antes de acometer el resto. Así, después de
definir un punto como punto de salvaguarda, puede retrocederse al
mismo. Entonces se descartan todos los cambios hechos por la
transacción después del punto de salvaguarda, pero se mantienen
todos los anteriores.
Originariamente, los puntos de salvaguarda fueron una aportación
del estándar SQL99 de las Bases de Datos Objeto-Relacionales.
Pero con el tiempo, se han ido incorporando también a muchas
Bases de Datos Relaciones como MySQL (al menos cuando se
utiliza la tecnología de almacenamiento InnoDB).
4.1 Transacciones en una
base objeto-relacional
Los SGBDOR gestionan transacciones mediante las sentencias
COMMIT (confirmar transacción) y ROLLBACK (deshacer
transacción).
JDBC permite agrupar instrucciones SQL en una sola transacción.
Así, podemos asegurar las propiedades ACID usando las
facilidades transaccionales del JDBC.
El control de la transacción lo realiza el objeto Connection. Cuando
se crea una conexión, por defecto es en modo AUTO COMMIT= TRUE.
Esto significa que cada instrucción individual SQL se trata como
una transacción en sí misma, y se confirmará en cuanto que la
ejecución termine.
Por tanto, si queremos que un grupo de sentencias se ejecuten
como una transacción, tras abrir una conexión Connection conn; habrá
que:
 Poner autocommit=false de la siguiente manera:
if (conn.getAutoCommit() )
conn.setAutoCommit( false );
 Mediante un bloque try-catch controlar si se deshace
conn.rollback o confirma conn.commit la transacción iniciada
con esa conexión.
En el siguiente enlace puedes ver como se controlan una secuencia
de insert como una transacción en PostgreSQL.
/*Añadir imagen
4.2 Transacciones en un
gestor de objetos
Las transacciones en un sistema de objetos puro, se gestionan
mediante COMMIT y ROLLBACK.
Un fallo causa un rollback de los datos, como normalmente sucede
en las bases de datos relacionales. En cuanto a la concurrencia, las
bases de objetos verifican en qué momento permiten el acceso en
paralelo a los datos. Este acceso concurrente implica que más de
una aplicación o hilo podrían estar leyendo o actualizando los
mismos objetos a la vez. Esto se suele denominar commit de dos
fases (dos procesos pueden trabajar sobre el mismo objeto
concurrentemente). Para ello se utiliza normalmente bloqueo de
datos para lecturas y escrituras.
Veamos un ejemplo sencillo con la base de objetos db4o. En
Db4o:
 Siempre se trabaja dentro de una transacción.
 Al abrir un ObjectContainer se crea e inicia implícitamente
una transacción.
 Las transacciones se gestionan explícitamente mediante
commit y rollback.
 La transacción actual hace commit implícitamente cuando
se cierra el ObjectContainer.
Por ejemplo, podemos deshacer una transacción con rollback,
restaurando la base de objetos al estado anterior, justo al estado
después del último commit o rollback.
En el siguiente ejemplo, al ejecutar db.rollback después de db.store(p3) y
db.store(p4), hará que los objetos p3 y p4 no se almacenen en la base
de objetos.
/*Añadir imagen
7. Anexo I.- Estándar
ODMG-93 u ODMG.
El estándar ODMG (Object Database Management Group) trata
de estandarizar conceptos fundamentales de los Sistemas Gestores
de Bases de Datos Orientados a Objetos (SGBDOO) e intenta
definir un SGBDOO como un sistema que integra las
capacidades de las bases de datos con las capacidades de los
lenguajes de programación orientados a objetos, de manera que
los objetos de la base de datos aparezcan como objetos del lenguaje
de programación.
Fue desarrollado entre los años 1993 y 1994 por representantes de
un amplio conjunto de empresas relacionadas con el desarrollo de
software y sistemas orientados a objetos.
Arquitectura del estándar ODMG La arquitectura propuesta por
ODMG consta de:
 Un modelo de objetos que permite que tanto los diseños,
como las implementaciones, sean portables entre los
sistemas que lo soportan.
 Un sistema de gestión que soporta un lenguaje de bases
de datos orientado a objetos, con una sintaxis similar a un
lenguaje de programación también orientado a objetos.
 Un lenguaje de base de datos que es especificado
mediante:
o Un Lenguaje de Definición de Objetos (ODL)
o Un Lenguaje de Manipulación de Objetos
(OML)
o Un Lenguaje de Consulta (OQL)
siendo todos ellos portables a otros sistemas con el
fin de conseguir la portabilidad de la aplicación
completa.
 Enlaces con lenguajes Orientados a Objetos como C++,
Java, Smaltalk.
El modelo de objeto ODMG es el modelo de datos en el que están
basados el ODL y el OQL. Este modelo de objeto proporciona los
tipos de datos, los constructores de tipos y otros conceptos que
pueden utilizarse en el ODL para especificar el esquema de la base
de datos de objetos.
Vamos a destacar algunas de las características más relevantes
del estándar ODMG:
 Las primitivas básicas de modelado son los objetos y los
literales.
 Un objeto tiene un Identificador de Objeto (OID) y un
estado (valor actual) que puede cambiar y tener una
estructura compleja. Un literal no tiene OID, pero si un
valor actual, que es constante.
 El estado está definido por los valores que el objeto toma
para un conjunto de propiedades. Una propiedad puede
ser:
o Un atributo del objeto.
o Una interrelación entre el objeto y otro u otros
objetos.
 Objetos y literales están organizados en tipos. Todos los
objetos y literales de un mismo tipo tienen un
comportamiento y estado común.
 Un objeto queda descrito por cuatro características:
identificador, nombre, tiempo de vida y estructura.
 Los tipos de objetos se descomponen en atómicos,
colecciones y tipos estructurados.
o Tipos atómicos o básicos: constan de un único
elemento o valor, como un entero.
o Tipos estructurados: compuestos por un
número fijo de elementos que pueden ser de
distinto tipo, como por ejemplo una fecha.
o Tipos colección: número variable de
elementos del mismo tipo. Entre ellos:
 Set: grupo desordenado de elementos
y sin duplicados.
 Bag: grupo desordenado de
elementos que permite duplicados.
 List: grupo ordenado de elementos
que permite duplicados.
 Array: grupo ordenado de elementos
que permite el acceso por posición.
Algunos fabricantes sólo ofrecen vinculaciones de lenguajes
específicos, sin ofrecer capacidades completas de ODL y OQL
 Tema 6. Bases de datos xml.
1 Introducción
Atendiendo al nivel de estructuración, podemos decir que existen
tres tipos de datos:
 Datos estructurados. Son los que tienen un formato
estricto. Toda la información recogida se ajusta al mismo
formato, como, por ejemplo: los datos tabulados en filas
y columnas de una tabla.
 Datos desestructurados. No tienen ninguna estructura,
como un documento de texto o un archivo de vídeo.
 Datos semi-estructurados. Tienen cierta estructura, pero
no toda la información recogida tiene la misma forma, y
además puede ir variando de manera dinámica.
Las bases de datos tradicionales, como las Bases de Datos
Relacionales (BDR) son apropiadas para almacenar datos
estructurados, pero la cuestión es que, en la actualidad, son muchas
las situaciones en las que interesa almacenar grandes volúmenes de
datos no estructurados, e incluso integrarlos con datos
estructurados. Pero ¿cómo hacerlo? Aquí es donde entra en juego
XML (eXtensible Markup Language).
XML define un conjunto de reglas semánticas que permiten la
organización de información de distintas maneras. Es un estándar
definido por el W3C y ofrece muchas ventajas, entre ellas:
 Es un lenguaje bien formado. No puede haber etiquetas
sin finalizar.
 Extensible. Permite ampliar el lenguaje mediante nuevas
etiquetas y la definición de lenguajes nuevos.
 Fácil de leer.
 Autodescriptivo. La estructura de la información de
alguna manera está definida dentro del mismo
documento
 Intercambiable.
 Portable entre distintas arquitecturas. Para su lectura e
interpretación es necesario un parser, y hay productos y
versiones libres.
Debido fundamentalmente a estas ventajas y a su sencillez, el
estándar XML ha sido ampliamente aceptado y adoptado para
el almacenamiento e intercambio de información, y como
consecuencia de este uso se ha creado la necesidad de almacenar
dicha información.
Y ¿cómo se almacena la información en formato XML de cara a su
recuperación y consulta? Existen varias aproximaciones para
organizar y almacenar información XML que fundamentalmente
van a depender de los diferentes archivos o documentos XML que
nos podemos encontrar (centrados en datos y centrados en texto).
Pero, en definitiva, lo que se busca es una estrategia que permita
almacenar y recuperar datos poco estructurados con la eficiencia de
las Bases de Datos convencionales, y es por ello que surgen las
Bases de Datos XML.
6.5 Documentos XML
centrados en datos y
centrados en texto
Como te hemos comentado antes, los tipos de documentos XML
que nos podemos encontrar son:
 Documentos centrados en datos, con las siguientes
características:
o Muchos elementos de datos de pequeño
tamaño.
o Con estructura regular y bien definida.
o Datos muy estructurados o semi-estructurados.
o Dirigidos a utilización automática (por
máquinas). E
o jemplos: Facturas, Pedidos Ficha de alumno.
 Documentos centrados en texto, contenido o
documentos con las siguientes características:
o Pocos elementos.
o Con grandes cantidades de texto.
o Con estructuras impredecibles en tamaño y
contenido.
o Datos poco estructurados.
o Orientados a ser interpretadas por humanos.
o Enfocados a sistemas documentales y de
gestión de contenidos.
o Ejemplos: Libros, Informes, Memorias,
Artículos bibliográficos.
En la siguiente imagen ampliable puedes apreciar las características
indicadas para estos dos tipos de documentos.
/*Añadir imagen
En el siguiente enlace tienes un ejemplo de cada tipo de documento
/*Añadir imagen
6.6 Opciones de
almacenamiento
Para almacenar documentos XML tenemos las siguientes opciones:
 Almacenamiento directo del fichero. Es una opción
pobre ya que las operaciones que podemos hacer sobre
ellos son limitadas, las que proporcione el sistema de
archivos.
 Almacenar el documento en una base de datos
existente (base de datos relacional, orientada a objetos u
objeto-relacional). En este caso existen las siguientes
posibilidades:
 o Directamente como una columna tipo
binario grande (BLOB) dentro de una tabla.
En este caso se almacena el documento intacto.
Es una buena estrategia si el documento XML
contiene contenido estático, que solo será
modificado cuando se reemplaza el documento
completo. Almacenar el documento completo
en formato de texto es fácil de implementar
dado que no se necesita mapeo o traducción,
pero limita las consultas y búsquedas de
contenido.
o Mediante mapeo basado en tablas, o basado
en objetos. En ambos casos hay que realizar
una transformación para ajustarlo a la
estructura de la BD antes de almacenarlo, y
normalmente esto conlleva prescindir de cierta
información, que supondrá que el documento y
su formato no se almacena y recupera de
manera intacta. Además, en el caso de
documentos centrados en texto, no podemos
controlar todas las posibles estructuras del
documento, y por tanto realizar un mapeo sobre
la base de datos será prácticamente imposible.
 Almacenar el documento en una base de datos nativa
XML. El documento, tanto si es centrado en datos como
en texto, se almacena y recupera de forma intacta. Como
veremos, será la mejor opción, sobre todo si el
documento está basado en texto.
La siguiente imagen ampliable ilustra las anteriores opciones de
almacenamiento:
/*Añadir imagen
En la actualidad, cada vez más, las BD convencionales ofrecen
posibilidades de almacenamiento XML, por lo que se habla de BD
XML-compatible o BD XML-enabled. Por tanto, podemos hablar
de dos tipos de Sistemas de Bases de Datos que soportan
documentos XML:
 BD XML-compatibles: desglosan un documento XML
en su correspondiente modelo relacional o de objetos.
 BD XML Nativas: respetan la estructura del documento,
permiten hacer consultas sobre dicha estructura y
recuperan el documento tal y como fue insertado
originalmente
Las principales diferencias entre ambos tipos de BD XML son las
siguientes:
 Una BD XML nativa proporciona un modelo de datos
propio, mientras que un BD XML-compatible tiene ya un
modelo de datos y añade una capa de software que
permite de alguna manera almacenar documentos XML y
recuperar los datos generando nuevos documentos XML.
 Una BD XML nativa debe manejar todos los tipos de
documentos posibles, mientras que una BD XML-
compatible solo puede manejar y almacenar los
documentos que encajan dentro del modelo definido para
ellos
8. Bases de Datos
Nativas XML
Las Bases de Datos nativas XML NXD (Native XML Database)
aunque existen desde hace años, en la actualidad siguen
evolucionando, por lo que existen ciertas diferencias entre los
productos de este tipo que podemos encontrar en el mercado. Lo
que, si está bastante claro, es que una NXD o BD XML debe
cumplir las siguientes propiedades:
 Define un modelo lógico de datos XML, estableciendo
los elementos que son significativos, de forma que el
documento XML se pueda almacenar y recuperar de
manera intacta, esto es, con todos sus componentes. Por
tanto, el modelo, como mínimo, debe tener en cuenta: los
elementos, atributos, texto, secciones CDATA, y
preservar el orden en el documento.
 El documento XML es la unidad lógica de
almacenamiento, esto es, la unidad mínima de
almacenamiento.
 No tiene ningún modelo de almacenamiento físico
subyacente concreto. Pueden ser construidas sobre
bases de datos relacionales, jerárquicas, orientadas a
objetos o bien mediante formatos de almacenamiento
propietarios.
Lo que realmente cambia en estas BD respecto a las
convencionales, es el formato que soportan, ya que, están
especializadas en almacenar documentos XML, almacenarlos y
recuperarlos con todos sus componentes.
Otras características de las BD Nativas XML son las siguientes:
 Documentos y colecciones. Los documentos se pueden
agrupar en unidades denominadas colecciones.
 Indexación. Permiten la creación de índices para acelerar
las consultas realizadas frecuentemente.
 Identificador único. A cada documento XML se le
asocia un identificador único, por el que será reconocido
dentro del repositorio.
 Consultas. Soportan uno o más lenguajes de consulta.
Entre ellos, uno de los más populares es XQuery (XML
Query)
 Actualizaciones. Poseen diferentes estrategias para
actualizar documentos, entre ellas la más popular es
Update XQuery.
 Validación. No siempre se realiza validación de
documentos, esto es, no necesitan un DTD o un XML
Schema (W3C) para almacenar documentos, basta con
que los documentos sean XML bien formados.
 Soportan transacciones, accesos concurrentes, control de
accesos y backup como cualquier otro sistema de bases
de datos.
Y ¿en qué situaciones puede resultar imprescindible su uso?
Fundamentalmente en las siguientes situaciones:
 Existencia de documentos con anidamientos profundos.
 Importancia de preservar la integridad de los
documentos.
 Frecuentes búsquedas de contenido.
8.1 Estrategias de
almacenamiento
Podemos diferenciar o clasificar las BD XML nativas en función
del tipo de almacenamiento que utilicen, que puede ser:
 Almacenamiento basado en texto
  Almacenamiento basado en el modelo
 Soluciones desarrolladas específicamente para la gestión
de documentos XML
¿En qué consiste el almacenamiento basado en texto y basado en
modelo?
 El almacenamiento basado en texto consiste en
almacenar el documento XML entero en forma de texto
(fichero de texto), y proporcionar alguna funcionalidad
de base de datos para acceder a él. Se suelen aplicar
técnicas de compresión para reducir el espacio de
almacenamiento, utilizar índices adicionales para mejorar
el acceso a la información, y se pueden definir sobre BD
tradicionales o sistemas de ficheros. Básicamente existen
dos posibilidades:
o Almacenar el documento como un binario
largo (BLOB) en una base de datos relacional,
o mediante un fichero, y proporcionar algunos
índices sobre el documento que aceleren el
acceso a la información.
o Almacenar el documento en un almacén
adecuado con índices, soporte para
transacciones, etc.
 El almacenamiento basado en modelo consiste en
definir un modelo de datos lógico, como DOM, para la
estructura jerárquica de los documentos XML y
almacenar el modelo binario del documento en un
almacén existente o bien específico. En este caso las
posibilidades que existen son:
o Traducir el DOM a tablas relacionales como
elementos, atributos, entidades, etc.
o Traducir el DOM a objetos en una BDOO.
o Utilizar un almacén creado especialmente para
esta finalidad
A continuación, te indicamos algunos ejemplos de BD XML
nativas clasificadas según su sistema de almacenamiento:
 Sistema propietario: XIndice, Virtuoso, Tamino XML
Server.
 Sistema relacional: eXist, DBCOM, XDB
 Sistema orientado a objetos: Ozone, MindSuite XDB.
¿Y qué ventajas proporcionan las BD XML nativas sobre otros
sistemas de almacenamiento? Las principales ventajas son las
siguientes:
 No necesitan mapeos adicionales.
 Conservan la integridad de los documentos.
 Permiten almacenar documentos heterogéneos
8.2 Colecciones y
documentos
/*Añadir imagen
En general, una BD XML tiene una estructura jerárquica
organizada en colecciones y documentos XML. La estructura
jerárquica comienza con un nodo raíz ('/'), del que parten
colecciones y documentos.
Una colección:
 Es un conjunto de documentos agrupados, normalmente,
en función de la información que contienen.
 Puede contener otras colecciones.
Un documento:
 Información XML
 Información de otro tipo y entonces se le denomina non-
XML data (Datos no-XML)
Comparando con una base de datos relacional o un sistema de
archivos:
 Las colecciones juegan en las bases de datos nativas el
papel de las tablas en las DB relacionales, o de un
directorio en un sistema de archivos.
 Los documentos juegan el papel de las filas de una tabla
de una BD relacional o un fichero en un sistema de
archivos.
Aunque depende de cada implementación, en muchos casos:
 Cada colección puede tener más de un DOCTYPE
asociado.
 El elemento raíz del documento XML define a que
DOCTYPE estará asociado el documento, en caso de no
poseer ninguno, éste se crea dinámicamente. Esto
posibilita el almacenamiento de documentos sin formato
definido.
 La colección también puede tener asociado un Schema
con información tanto física como lógica de la colección.
La parte lógica define las relaciones y propiedades de los
documentos XML y la física contiene información sobre
el almacenamiento e indexación de los mismos.
 También se pueden almacenar documentos no-XML,
para estos existe un DOCTYPE especial llamado non-
XML.
8.3 Gestores nativos XML
comerciales y libres
Te indicamos a continuación algunos ejemplos de gestores nativos
XML clasificados según sean de código libre o código propietario.
Los comerciales, generalmente ofrecen versiones de prueba con
limitaciones de tiempo de uso y de funcionalidades. Los libres, a
veces también ofrecen dualidad de licencia, comercial y libre.
Algunos de estos gestores nativos XML son los siguientes:
Gestores nativos XML comerciales o de código propietario son:
 TaminoXML Server. Es un gestor nativo XML de la
empresa SoftwareAG. Es un producto comercial de alto
rendimiento y disponibilidad, además de ser uno de los
primeros SGBD XML nativos disponibles. Algunas de
sus características son las siguientes:
o Los documentos se almacenan en una base de
datos propia y no se transforman en otro
modelo.
o Existe un espacio separado para documentos y
para índices.
o Soporta el lenguaje de consultas XQuery y
APIs para Java, C, y .NET, entre otras.
 TEXTML de Isiasoft. Los documentos se almacenan en
su formato nativo, sin ser mapeados.
o Permite almacenar documentos sin DTD o
esquema.
o Proporciona índices de acuerdo a la propia
estructura del documentos.
 o Permite la utilización de varios índices al
mismo tiempo.
o Incluye API para Java, WebDAV, OLE DB
y .NET.
Gestores nativos XML libres o de código abierto son:
 Qizx. Es una base de datos nativa XML escrita en Java.
Almacena los datos utilizando una representación que se
basa en el modelo de XPath 2,0.
o La representación utiliza compresión de
manera que un documento y sus índices suelen
utilizar menos espacio que el original XML.
o Los documentos se almacenan en una jerarquía
de colecciones.
o Permite almacenar documentos sin DTD o
esquema.
o Soporta el lenguaje de consulta XQuery y sus
extensiones, como XUpdate, así como API
para Java.
 eXist. Utiliza un sistema de almacenamiento propio
(árboles B + y archivos paginados). Se puede ejecutar
como un servidor de base de datos independiente, como
una biblioteca de Java embebida, o en el motor servlet de
una aplicación Web.
o Los documentos se almacenan en una jerarquía
de colecciones.
o Permite almacenar documentos sin DTD o
esquema.
o Soporta el lenguaje de consulta XQuery y sus
extensiones, como XUpdate, así como API
para Java.
9. Instalación del
gestor Qizx
En los siguientes apartados trabajaremos con la base de datos
nativa XML Qizx, especialmente diseñada para integrarse en una
aplicación Java independiente, esto es, para trabajar en modo
embebido (embedded). Como tal, se utiliza principalmente como
una biblioteca de clases, lo que supone que para utilizarla en una
aplicación habrá que añadir los correspondientes archivos .jar.
También se puede utilizar en un entorno JEE, Servlets o EJB.
Algunas características de Qizx, que iremos viendo en los
siguientes apartados, son las siguientes:
 Consultas e indexación optimizadas. A diferencia de
otras bases de datos nativas XML, que están optimizadas
para la actualización masiva de documentos XML, Qizx
optimiza las búsquedas y consultas de documentos
mediante un sistema de indexación muy eficiente. Sin
embargo, la actualización de documentos de gran tamaño
no es tan eficiente.
 Compatible con estándares. Es totalmente compatible
con el lenguaje XQuery y sus extensiones Full-Text
XQuery y Update XQuery.
 No necesita DTD o Esquemas predefinidos, siempre y

cuando el documento XML esté bien formado.
Indexado Automático. Los documentos son indexados
automáticamente, aunque permite también personalizar
los índices.
Qizx fue inicialmente desarrollado por Xavier Franc of Axyana y
fue comprado por Qualcomm in 2013.
Qizx fue lanzado de nuevo por Qualcomm a finales de 2014 on
Amazon Web Services.
a. Gestionar la base de
datos XML mediante
QizxStudio
Una BD XML Qizx está organizada como una estructura jerárquica
de colecciones, que a su vez contienen documentos, similar a un
sistema de archivos, donde las colecciones juegan el papel de los
directorios y los documentos XML desempeñan el papel de los
archivos planos. Dentro de una colección pueden almacenarse
documentos de cualquier tipo.
Te detallamos a continuación la terminología utilizada por Qizx:
 XML Library. Es el equivalente a una base de datos XML.
Físicamente, una BD o Library se almacena en un
directorio en un disco, y no hay límite en el número de
bases de datos que se pueden crear con Qizx.
 Su estructura jerárquica siempre comienza con un nodo
raíz, '/', del que parten documentos XML y/o colecciones.
 XML Library Group. Es un conjunto de BD XML,
agrupadas dentro de un directorio en disco.
Por ejemplo, la imagen ampliable de la derecha muestra:
 XML Library Group at C:\dxml. Es el grupo de BD XML
situado en el directorio físico c:\dbxml.
 XML Library 'Libros'. Es la BD XML de nombre Libros.


'/'. Es el nodo raíz de la BD o Library
Las colecciones Publisher, Authors y Books dentro de la BD

XML de nombre Libros.
Diferentes documentos (archivos XML) dentro de la
colección Authors, como por ejemplo iasimov.xml.
Podemos trabajar directamente con Qizx a través de la herramienta
gráfica denominada QizxStudio, la cual nos permite entre otras
acciones las siguientes:
 Crear la BD XML
 Explorar colecciones y documentos XML de la base de
datos
 Importar, crear y eliminar colecciones
 Importar y eliminar documentos, así como copiar o
exportar a fichero
 Consultar documentos
Antes de comenzar a trabajar con Qizx y Java, y con el objetivo de
que te familiarices con esta BD XML, verás algunos ejemplos de
cómo gestionar colecciones y documentos mediante QizxStudio.
En el siguiente recurso didáctico encontrarás ejemplos de todo ello.
/*Añadir imagen
4 El lenguaje de consultas
XQuery
XQuery es un lenguaje de consulta diseñado para extraer
información de colecciones de datos expresadas en XML. Entre las
principales características de XQuery vamos a destacar las
siguientes:
 Está basado en el lenguaje XPath, (XML Path
Language), y se fundamenta en él para realizar la
selección de información y la iteración a través del
conjunto de datos XML.
 Es un lenguaje declarativo, lo que significa que, en vez
de ejecutar una lista de comandos como un lenguaje
procedimental clásico, cada consulta es una expresión
que es evaluada y devuelve un resultado, al igual que en
SQL.
Podemos decir que XQuery es a XML lo mismo que SQL es a
las bases de datos relacionales. Sin embargo, aunque XQuery y
SQL puedan considerarse similares, el modelo de datos sobre el
que se sustenta XQuery es muy distinto del modelo de datos
relacional sobre el que sustenta SQL, ya que XML incluye
conceptos como jerarquía y orden de los datos que no están
presentes en el modelo relacional.
Por ejemplo, a diferencia de SQL, en XQuery es importante y
determinante el orden en que se encuentren los datos, ya que no es
lo mismo buscar una etiqueta nombre dentro de una etiqueta autor
que todas las etiquetas nombre del documento (que pueden estar
anidadas dentro de una etiqueta autor o fuera).
Los principales tipos de expresiones de XQuery son:
 Expresiones XPath, para navegar por los documentos.
 Expresiones FLWOR (For, Let, Where, Order, Return) para
iterar por los elementos de un conjunto de datos.
Pero XQuery también admite:
 Constructores para generar nodos y contenido dinámico.
 Condicionales (IF, THEN ELSE) para construir el resultado
en base a alguna condición.
 Cuantificadores (SOME, ANY) para chequear la existencia
de algún elemento que cumpla una condición.
 Listas a las que se pueden aplicar operadores ( UNION,...)
y funciones de agregación (AVG, COUNT,...).
4.1 Modelo de datos
modelo de datos en que se sustenta XQuery es el modelo de datos
de XPath.
XPath modela un documento XML como una estructura
jerárquica en forma de árbol. El árbol está formado por nodos,
y hay siete tipos de nodos: raíz, elemento, texto, atributo, espacio
de nombres, instrucción de procesamiento y comentario.
/*Añadir imagen
Los principales nodos de la estructura jerárquica o en árbol en un
documento XML son:
 Nodo raíz o /. Es el primer nodo del documento.
 Nodo elemento. Cualquier elemento de un documento
XML. Cada nodo elemento posee un padre y puede o no
tener hijos. En el caso de que no tenga hijos, es un nodo
hoja.
 Nodo texto. Cualquier elemento del documento que no
esté marcado con una etiqueta de la DTD del documento
XML.
 Nodo atributo. Un nodo elemento puede tener etiquetas
que complementen la información de ese elemento. Esto
sería un nodo atributo.
Debes conocer
/*Añadir imagen
4.2 Caminos de localización
¿Cómo se localiza cada uno de esos nodos en al árbol XML?
Mediante una expresión XPath conocida como camino o ruta de
localización. Un camino de localización:
 Selecciona un conjunto de nodos relativo al nodo de
contexto.
 Puede contener recursivamente expresiones utilizadas
para filtrar conjuntos de nodos.
 Al ser evaluado, devuelve el conjunto de nodos
seleccionados por el camino de localización.
 Se construye siguiendo unas reglas de sintaxis y
semántica.
Hay dos tipos de caminos de localización:
 Caminos relativos. Son una secuencia de uno o más
pasos de localización separados por /.
o Los pasos se componen de izquierda a derecha.
 Caminos absolutos. Consiste en / seguido,
opcionalmente, por un camino de localización relativo.
o Una / por si misma selecciona el nodo raíz del
documento que contiene al nodo contextual.
Los siguientes, son algunos ejemplos de caminos de localización:
 cuadro selecciona los elementos cuadro hijos del nodo
contextual.
 cuadro//titulo selecciona los elementos titulo descendientes de
los elementos cuadro hijos del nodo contextual.
 * selecciona todos los elementos hijos del nodo
contextual.
 @año selecciona el atributo año del nodo contextual
 @* selecciona todos los atributos del nodo contextual
 cuadro[1] selecciona el primer hijo cuadro del nodo

contextual
cuadro[@año=1907] selecciona todos los hijos cuadro del nodo
contextual que tengan un atributo año con valor 1907.
Debes conocer
/*Añadir contenido
4.3 Primeras consultas
XQuery
Una consulta XQuery es una expresión que lee una secuencia
de datos en XML y devuelve como resultado otra secuencia de
datos en XML, donde:
 Una secuencia es un conjunto ordenado de cero o más
ítems.
 Un ítem es cualquier tipo de nodo del árbol XML o un
valor atómico.
Las funciones que se pueden invocar para referirnos a colecciones
y documentos dentro de la BD son las siguientes:
 collection(camino de la colección)
  doc(camino del documento)
Así por ejemplo:
 La consulta collection(/Books): devuelve el contenido de
la colección de ruta absoluta /Books.
 La consulta doc(/Empresa.xml): devuelve el documento
/Empresa.xml completo.
Otros ejemplos de consultas XQuery basadas en expresiones
XPath son los siguientes:
 La consulta collection(/Books)//book/title devuelve los
nodos title de todos los libros ( book) de la colección
/Books
 Si se utilizan espacios de nombres o namespaces, entonces
la consulta anterior se redactaría de la siguiente forma:
declare namespace t =
http://www.qizx.com/namespace/Tutorial;
collection(/Books)//t:book/t:title
 La consulta doc(/Empresa.xml)//nombre devuelve todos
los nodos nombre del documento /Empresa.xml
Diferentes ejemplos de consultas XQuery ejecutadas directamente
sobre una sencilla BD XML denominada 'Cursillos'
/*Añadir ejemplos
4.4 Expresiones FLWOR
Los ejemplos de consultas XQuery vistos en el apartado anterior,
son la manera más sencilla de realizar búsquedas y selecciones de
nodos concretos en una BD XML. Pero existe otra manera mucho
más potente de realizar este trabajo, mediante lo que se denomina
consultas o expresiones FLWOR (leído como flower), siendo
FLWOR las siglas de For, Let, Where, Order y Return.
Se trata de una expresión que permite la unión de variables
sobre conjuntos de nodos y la iteración sobre el resultado. Las
diferentes cláusulas de una expresión FLWOR son:
 For. Permite seleccionar los nodos que se quieren
consultar, guardándose su valor en una variable
(identificador que comienza por $). Al conjunto de
valores de la variable se le llama tupla.
 Let. (opcional). Asocia valores a variables.
 Where (opcional). Permite filtrar los resultados según una
condición.
 Order (opcional). Permite ordenar la secuencia de valores
o resultados.
 Return. Genera los valores de salida o devueltos.
En la siguiente imagen, puedes ver un ejemplo de una consulta
(izquierda) donde aparecen las 5 cláusulas. La consulta devuelve
los nombres de los cursos con 20 plazas, ordenados por nombre de
curso (derecha).
/*Añadir imagen
Una expresión FLWOR vincula variables a valores con las
cláusulas for y let y utiliza esos vínculos para crear nuevas
estructuras de datos XML.
A continuación, se muestra otro ejemplo de consulta XQuery. La
siguiente consulta (izquierda) devuelve los nombres de los cursos
con cuota mensual (derecha). Como cuota es un atributo del
elemento precio, recuerda que se le antecede con un carácter @.
/* Añadir imagen
En el siguiente recurso didáctico dispones de más ejemplos de
consultas XQuery, utilizando expresiones FLOWR.
/*Añadir imagen
4.5 XQuery Update Facility
El lenguaje XQuery solo proporciona expresiones para la
realización de consultas sobre documentos XML, pero no su
actualización (inserción, modificación o eliminación de nodos).
XQuery Update Facility es una extensión de XQuery que permite
la actualización de documentos mediante las cláusulas insert,
delete, replace y rename.
El funcionamiento de las cláusulas de XQuery Update es el
siguiente:
 insert. Permite la inserción de uno o varios nodos antes
(before) o después (after) del nodo indicado. También se
puede insertar al principio (as first into) o al final del
documento (as last into).
 delete. Elimina uno o varios nodos del documento.
 replace. Tiene dos funciones:
o Modificar el valor del nodo

o Modificar el nodo completo
rename. Renombra un nodo (elemento, atributo o
instrucciones de proceso) sin afectar a su contenido.
A continuación, te mostramos dos ejemplos sencillos, uno de insert y
otro de delete:
 Eliminar la empresa de id=2 en el documento
Empresa.xml:
delete node doc(Empresa.xml)//empresa[@id=2]
 Insertar el nodo tipoAccesible/tipo al final del documento
/Aulas/aula3 insert node tipoAccesible/tipo as last into
doc(Aulas/aula3.xml)//aula
/*Añadir imagen
Ejemplos de actualizaciones usando XQuery Update:
/*Añadir contenido
Para saber más
/*Añadir resumen
5 Trabajar con colecciones
y documentos desde Java
El API principal para trabajar con una base de datos XML de
Qizx en un entorno de desarrollo Java, la proporciona el paquete
com.qizx.api, que permite, entre otras cosas, realizar las siguientes
tareas:
 crear la BD XML,
 abrir y cerrar conexiones a la BD,
 importar/crear colecciones y documentos, y
 realizar consultas con XQuery.
A continuación, te indicamos algunas de las clases e interfaces del
paquete com.qizx.api de más interés:
 Interface Library. Representa una BD XML o una
conexión a una BD XML.
 Interface LibraryManager. Representa el gestor de las BDs.
Permite gestionar grupos de BDs XML.
 Clase Configuration. Inicializa y configura un LibraryManager,
permitiendo su creación, apertura, etc..
 Interface LibraryMember. Representa un miembro de una
BD XML, esto es, colección o documento.
o Algunas sub_interfaces son: Collection, Document,
NonXMLDocument.
 Interface Collection. Para gestionar colecciones y
sub_colecciones que contienen documentos XML.
 Interface Document. Representa documentos XML bien
formados y almacenados en una BD XML.
o Al ser un LibraryMember (miembro de una
Library), puede tener propiedades (metadatos)
que pueden consultarse.
 Clase Index. Para crear índices en una BD XML y
especificar sus parámetros.
Otros paquetes de interés son:
 El paquete org.xml.sax. Proporciona las clases e interfaces
para el API SAX, que es un componente de la API de
Java para el procesamiento de documentos XML, como
por ejemplo el interface XMLReader.
 El paquete com.qizx.xdm. Proporciona clases e interfaces
para el análisis y procesamiento de documentos XML,
como por ejemplo la clase DocumentParser.
En el siguiente recurso didáctico encontrarás un tutorial con los
pasos a seguir para la integración de Qizx en el IDE NetBeans, y
poder hacer uso de las clases e interfaces comentadas
anteriormente.
/*Añadir imagen
5.1 Creación de la BD
XML. Establecer
conexiones
En general, la conexión de una aplicación Java a una base de datos
XML se realizará mediante el API proporcionado por el propio
gestor XML.
Para crear una BD XML y establecer una conexión se utilizan
métodos del interface LibraryManager.
 Crear la BD XML. El método createLibrary(String nombreBD,
File directorioBD) crea la BD de nombre nombreBD
localizada físicamente en el directorio directorioBD,
directorio que debe existir y estar vacío. Si el
parámetro directorioBD se pasa como valor null, la BD se
creará en un subdirectorio del grupo con nombre
nombreBD.
 Establecer conexión. El método openLibrary(String
nombreBD) abre una nueva sesión o conexión a la BD de
nombre nombreBD. También es posible, indicar parámetros
de autentificación de usuario, si se ha establecido un
Control de Accesos a la Library o BD.
/*Añadir imagen
En el siguiente ejemplo puedes ver un método que realiza la
conexión o apertura a una base de datos XML, y si no existe la crea
y después la abre.
/*Añadir imagen
Si observas el ejemplo anterior (valor devuelto por el método),
verás que en Qizx, un objeto Library representa dos cosas:
 La base de datos XML
 Una conexión concreta a la base de datos o Library XML
Debes conocer
En el paquete API (com.quizx.api) encontrarás una explicación
más detallada de la dualidad del interface Library: como Base de
datos y como conexión en el apartado Library
5.2 Cerrar conexiones
Podemos cerrar la conexión de una BD o Library concreta, mediante
el método close() de la interface Library, o cerrar todas las conexiones
a las bases de datos de un grupo, mediante el método
closeAllLibraries() de la interface LibraryManager.
Te detallamos cada caso:
 Cerrar una conexión. El método Library.close() cierra la
conexión a una BD particular. Si ha comenzado alguna
transacción, no se podrá invocar close(), solo se podrá
invocar commit() o rollback(), por lo que antes de invocar
close(), debemos comprobar mediante el método
Library.isModified() si la base de datos está inmersa en una
transacción.
 Cerrar todas las conexiones. El método
LibraryManager.closeAllLibraries(int tiempo) cierra todas las
conexiones a BD del mismo grupo y libera los recursos.
Mediante el parámetro int tiempo, se le puede indicar el
tiempo en milisegundos que debe esperar el sistema antes
de realizar la desconexión de aquellas Library o bases de
datos en las que haya alguna transacción sin finalizar.
Pasado ese tiempo, se generará de forma automática un
rollback(), se deshacen las operaciones, en aquellas
transacciones que no hayan finalizado aún.
En el siguiente ejemplo, puedes ver cómo realizar la desconexión o
cierre tanto de una BD particular, como de todo un grupo de bases
de datos o Library.
/*Añadir imagen
5.3 Crear colecciones
Para crear colecciones se usan los métodos:
 createCollection(String ruta).Método de la interface Library.
Crea una colección en la BD, cuya posición dentro de la
base de datos es la que indica el parámetro ruta, siendo ruta
un camino o path absoluto en la BD.
 createChildCollection(String nombre). Método de la interface
Collection. Crea una sub_colección dentro de una
colección, denominada nombre.
/*Añadir imagen
Por ejemplo, en el siguiente segmento de código se estaría creando
dentro de la Library o base de datos bd una colección situada dentro
de la base de datos en la posición indicada por ruta. Observa que,
previamente se comprueba si ya existe esa colección dentro de la
base de datos.
/*Añadir imagen
5.4 Añadir documentos
Para añadir documentos se utiliza el método:
 importDocument(String documentoRuta, Tipo fuente). Método
de la
interface Library. Existen diferentes métodos para importar
documentos XML a una BD XML, que se diferencian
fundamentalmente en el Tipo de los documentos fuente
indicados como segundo parámetro: java.io.File, java.net.URL,
org.xml.sax.InputSource, etc. En todos los casos, la fuente
debe contener un documento XML bien formado. Uno de
estos métodos es:
o importDocument(String documentoRuta, File fichero).
Importa un documento a la base de datos
mediante un análisis o parsing de un fichero de
texto XML ubicado en fichero.
 Si ya existe un documento con la
misma ruta en la BD, se sustituye por
los nuevos contenidos.
 Si la colección que contiene este
documento no existe, se crea
automáticamente.
/* Añadir imagen
El siguiente código Java, es un ejemplo de cómo importar
documentos mediante el método importDocument():
/* Añadir imagen
Qizx necesita analizar un documento XML con el fin de poder
importarlo a la base de datos. El primer paso del análisis consiste
en comprobar que se trata de un documento bien formado.
También se puede realizar su validación, mediante la
comprobación del DTD. Si falla este paso, fallará la importación.
Con Qizx, se puede utilizar lo que se conoce como catálogo XML
para realizar este análisis o comprobaciones, sin necesidad de
acceder a direcciones externas u otras localizaciones que puedan
suponer un fallo si no las encuentra en el sistema local.
Qizx incluye la biblioteca resolver.jar, conocida como resolución
del catálogo XML, que forma parte del proyecto Apache XML
Commons, de manera que todos los métodos
Library.importDocument() son catálogos XML habilitados. Por lo
tanto, basta con especificar el correspondiente importDocument() y
dejar que mediante resolver.jar se realice la resolución, análisis o
parsing.
Debes conocer
Consulta el API para conocer los diferentes métodos
importDocument() que puedes utilizar. Lo encontrarás en el
apartado Library
5.5 Creación de una BD
XML e importación de
colecciones y
documentos
Otros métodos útiles al llenar una Library con colecciones y
documentos, o bien trasladar colecciones y documentos de una
Library a otra son los siguientes:
 Library.getMember(String rutaAbsoluta): devuelve el miembro
especificado en esa ruta de la BD, un LibraryMember
(documento o colección), o bien null si no existe ese
miembro.
 Library.getDocument(String rutaAbsoluta): devuelve el documento
especificado en esa ruta de la BD, un Document o bien null
si no existe.
 Library.getCollection(String rutaAbsoluta): devuelve colección
especficada en esa ruta de la BD, una Collection o bien null
si no existe.
 Library.getName(): devuelve el nombre de la Library o base de
datos.
 LibraryMember.getPath(): devuelve la ruta completa del
miembro en esa BD.
 LibraryMember.getName(): devuelve el nombre del miembro
dentro de su colección sin '/', excepto si es la colección
raíz.
 LibraryMember.isDocument(): devuelve verdadero si el
miembro es un documento.
 LibraryMember.isCollection(): devuelve verdadero si el
miembro es una colección.
 Collection.getChildren(): devuelve un iterador, un
LibraryMemberIterator, sobre los miembros de esa colección
(documentos o colecciones).
 LibraryMemberIterator.iter.moveToNextMember(): devuelve
verdadero si accede al siguiente miembro.
 LibraryMemberIterator.getCurrentMember(): devuelve el mimbro
actual.
En este apartado, verás el ejemplo completo de cómo crear una
base de datos XML desde un entorno Java, y llenarla con
colecciones y documentos existentes, esto es, importando
colecciones y documentos a la base de datos.
Recuerda tener desconectado el Library Group en QizxStudio
cuando ejecutes tus programas Java.
En el siguiente recurso didáctico se explica cómo crear desde Java
una BD XML y llenarla con colecciones y documentos.
/*Añadir contenido
5.6 Eliminar colecciones y
documentos
Para eliminar colecciones y documentos se pueden utilizar los
métodos:
 Método de la interface Library.
deleteMember(String ruta).
Elimina el miembro de la BD indicado mediante el
parámetro ruta, que será la ruta absoluta dentro de la BD.
Si se trata de una colección, elimina también de forma
recursiva todos sus documentos y sub_colecciones.
  Método de la interface LibraryMember. Es
delete().
equivalente al método anterior, es decir, es equivalente a
Library.deleteMember(getPath()).
Al igual que otras operaciones de actualización, para que tenga
efecto permanente, debe ir seguida de una confirmación o commit().
Por ejemplo, si bdNombre vale Libros (BD creada anteriormente con
qizxStudio, el siguiente segmento de código borra cada una de las
colecciones de esta base de datos que se hayan indicado en el array
String[] coleccionNombre = {"/Authors","/Books"}
/*Añadir imágenes
Si por ejemplo, ruta vale /Publishers/Pocket.xml, lo que estaríamos
borrando con la sentencia bd.deleteMember(ruta); sería exactamente el
documento Pocket.xml.
¿Y cómo eliminar toda la base de datos? Para ello, puedes
utilizar:
 el método de la interface
deleteLibrary(String bdNnombre)
LibraryManager, que elimina físicamente la BD.
5.7 Consultar documentos
¿Se utiliza el lenguaje XQuery para realizar consultas a la BD
XML desde una aplicación Java? La respuesta es sí, pero será
necesario realizar los siguientes pasos para procesar una
consulta desde Java:
 Compilar la consulta o expresión XQuery mediante el
método Library.compileExpression(). Si la compilación se
realiza sin errores (CompilationException), devolverá un
objeto Expression.
 Evaluar la expresión o consulta compilada mediante el
método Expression.evaluate(). Si la evaluación se realiza sin
errores (EvaluationException), devolverá el resultado en
forma de un ItemSequence.
 Iterar sobre la secuencia obtenida. Un ItemSequence
permite iterar sobre una secuencia de Items, donde un
Item es un valor atómico o un nodo XML.
Por ejemplo:
 Expresión 3+4 : se evalúa como el valor atómico 7
 Expresión collection("/Books")//book/title: se evalúa como una
secuencia de nodos title
Un iterador siempre tiene un método moveToNextItem() que mueve la
posición del cursor al siguiente elemento y un getCurrentItem() que
devuelve el elemento encontrado en la posición actual del cursor.
Por tanto, los pasos anteriores suponen las siguientes sentencias de
código:
Expression exprcompilada =
bd.compileExpression(scriptConsulta);
ItemSequence resultado = exprcompilada.evaluate();
while (resultado.moveToNextItem()) {
Item resul = resul.getCurrentItem();
/* Manipular resultado*/
} En ese directorio dispones de otros scripts de actualización para
Otros métodos útiles en el procesamiento de una consulta son
los siguientes:
 El método Item.getNode() que obtiene el valor de un nodo
XML (objeto tipo Node) tras la evaluación de una consulta
XQuery compilada.
 El método XMLSerializer.serializeToString() que permite
serializar como una cadena un nodo XML.
 El método Expression.bindImplicitCollection() que permite
escribir consultas con rutas o paths las cuales no van
precedidas por las expresiones collection(XXX) o doc(YYY).
Por ejemplo, usando bindImplicitCollection() se puede utilizar como
expresión: //book/title en vez de collection(/Books) //book/title
 El método Expression.bindVariable() que permite vincular una
secuencia de Items a una variable.
A continuación, dispones de un ejemplo detallado de consultas
XQuery desde una aplicación Java. Las consultas se realizan sobre
la BD Cursillos que creaste anteriormente. Las consultas que se
ejecutan están almacenadas como scripts en ficheros de extensión .xq
dentro del directorio C:\BDCursillosXML\cursillos_query\.
También puedes probar con este mismo programa las consultas 7.xq
y 8.xq que vienen con la distribución Qizx Free Engine Edition y
que encontrarás en la carpeta de instalación dentro del directorio
\docs\samples\book_queries\. En este caso, la BD a utilizar será
Tutorial.
/* Proyecto java
Debes conocer
Es importante que conozcas las posibilidades del interface Expression
y del interface ItemSequence. Consulta el API (com.quizx.api)
5.8 Actualizar documentos.
Aunque dependiendo del sistema de BD XML pueden existir
diferentes formas de actualizar documentos, la manera más sencilla
de hacerlo es mediante Update XQuery, la extensión del lenguaje
XQuery que permite inserciones, eliminaciones y
modificaciones de nodos de los documentos XML.
Con Qizx, independientemente del método utilizado para la
actualización, ésta siempre implica sustituir el documento
prácticamente en su totalidad. Esto es así debido a que de esta
forma se consigue optimizar la velocidad de las consultas.
Para ejecutar una consulta de actualización desde Java se
siguen básicamente los mismos pasos que para una consulta normal
XQuery:
 Compilar la consulta de actualización mediante
Library.compileExpression() obteniendo un objeto Expression.
 Evaluar la consulta de actualización compilada mediante
Expression.evaluate() obteniendo un ItemSequence.
A continuación dispones de un ejemplo detallado de actualización
XQuery desde una aplicación Java. La actualización consiste en
añadir dos nodos empresa al documento /Empresa.xml de la BD
Cursillos. La consulta de actualización está almacenada como un
script en el fichero 12update_insert.xq dentro del directorio
C:\BDCursillosXML\cursillos_query\.
realizar eliminaciones y modificaciones, que puedes probar desde
el mismo programa. (13update_delete.xq, 14update_replace_node_value.xq,
15update_rename_varios_nodos.xq)

/*Añadir contenido
El siguiente ejemplo actualiza un documento de la colección
Authors, insertando un nuevo pseudónimo al autor que se pasa como
parámetro al script. El script de actualización está almacenado dentro
del directorio de instalación de Qizx:
docs\samples\programming\edit\pseudonym.xq.
La BD utilizada es Tutorial. Para esta actualización se usa la
interface QName, que permite gestionar nombres calificados.
Observa el script pseudoynm.xq, que viene con tu distribución
descargada, para comprobar que todas las referencias a QName lo
hacen con Q mayúscula. Además, observa cómo se utiliza una
consulta de actualización con sentencias alternativas if-else para
detectar errores en el proceso de actualización.
/*Añadir contenido
6 Indexación
Como cualquier otra BD XML, Qizx utiliza índices para optimizar
y aumentar la velocidad de las consultas realizadas a la BD.
De manera predeterminada, Qizx indexa la mayor parte de la
información disponible en documentos XML: elementos,
atributos, nodos, y texto completo. Esto se realiza
automáticamente, por lo tanto, en la mayoría de los casos no hay
necesidad de especificar explícitamente nuevos índices.
Qizx soporta los siguientes tipos de índices:
 Índices elemento. Dado un nombre de elemento, este
índice devuelve todos los elementos XML en todos los
documentos de una BD con este nombre.
 Índices de atributos. Dado un nombre de atributo y un
valor, este índice devuelve todos los elementos que
tienen un atributo con este nombre y valor. Hay tres
tipos de índices de atributos, de acuerdo con el tipo del
valor del atributo: texto, numéricos y de fecha / hora.
o Texto. Por defecto, todos los valores de los
atributos están indexados como cadenas o
texto.
o Numérico. Si el valor se puede convertir al
tipo double, entonces se añade como índice
atributo numérico.
o Fecha/Hora. Si el valor se puede convertir al
tipo date-time, entonces se añade como índice
date/time.
 Índices de contenido simple. Dado un nombre de
elemento y un valor, este índice devuelve todos los
elementos que tienen un contenido simple
correspondiente a este valor.
 Índices Full-text. Dada una palabra, este índice devuelve
todos los nodos de texto que contienen una ocurrencia de
esta palabra.
Para utilizar índices diferentes a los predeterminados, habrá que
establecer lo que se denomina una especificación de indexado. Esto
lo vamos a ver en el siguiente apartado
6.1 Especificaciones de
indexado
Podemos asociar una especificación de indexado a una BD XML,
de manera que ésta, se aplicará a todos sus documentos. Una
especificación de indexado puede contener:
 Valores para parámetros generales.
 Especificaciones para índices full-text.
 Reglas para el reconocimiento de valores numéricos y de
fecha en el contenido de elementos y atributos.
Pero ¿qué es realmente una especificación de indexado? Una
especificación de indexado es un documento XML con la
siguiente estructura:
 El elemento raíz tiene el nombre indexing.
 El elemento indexing contiene los atributos que definen las
condiciones generales.
 Contiene una lista de reglas aplicables a los elementos o
atributos.
En el manual del paquete de instalación puedes ver un ejemplo de
especificación de indexado en la ruta
docs/manual/indexing.html#d0e4192.
Qizx proporciona una especificación de indexado por defecto, que
se puede editar con QizxStudio y personalizar.
Si creamos una especificación de indexado nueva para una BD:
 Habrá que guardar el documento XML de la
especificación junto a la BD o Library, de manera que
ésta se iniciará al crear la BD, utilizándose de forma
automática cuando se añaden documentos.
 Se deben incluir en ella las reglas que pone Qizx en su
especificación por defecto, ya que, en otro caso, éstas se
perderán
Debes conocer
Las reglas de especificación de indexado por defecto de Qizx las
puedes ver en la siguiente ruta del paquete de instalación:
docs/manual/indexing.html#d0e4615
En la imagen ampliable, puedes ver las diferentes opciones que
proporciona QizxStudio para gestionar índices en una BD:
 Modificar la especificación de indexado actual.
 Exportar la especificación de indexado a un fichero .xml.
 Reconstruir los índices.
 Optimizar la BD, esto es, optimiza su almacenamiento y
los índices de la BD.
 Optimizar de forma rápida la BD, esto es, en un tiempo
limitado.
/*Añadir imagen
6.2 Re-Indexar una BD
desde Java
Para reindexar una BD XML de Qizx será necesario un objeto de la
clase com.qizx.api.Indexing.
 Cada objeto Indexing es una especificación de indexado
con las reglas y parámetros necesarios para construir
índices en una BD o Library.
  El método Indexing.parse(InputSource source) analiza la
especificación de indexado contenida en el texto XML
del parámetro source.
Además, se necesitan los siguientes métodos de Library:
 Define las reglas de indexado
Library.setIndexing(Indexing ind).
para esa BD o Library, especificadas en el parámetro ind.
Normalmente va seguida de un reindexado, que se realiza
mediante el método reIndex().
 Library.reIndex(). Reconstruye y reorganiza los índices de
una BD
En el siguiente enlace tienes un ejemplo de reindexado de la BD
Tutorial. Las especificaciones de indexado están escritas en el
archivo indexing.xml que viene con el paquete de instalación y que
encontrarás en la carpeta de instalación dentro del directorio
docs\samples\programming\reindex\.
13. Gestión de transacciones
En muchos de los ejemplos que has visto, ha estado presente el
concepto de transacción: conjunto de sentencias que se ejecutan
formando una unidad de trabajo, de forma indivisible, de manera
que se ejecutan todas o no se ejecuta ninguna.
Mediante la gestión de transacciones, los gestores XML
proporcionan un acceso concurrente a los datos almacenados,
mantienen la integridad y seguridad de los datos, y proporcionan
un mecanismo de recuperación de la base de datos ante fallos.
Qizx soporta transacciones que cumplen el criterio ACID:
 Atomicidad: Se deben cumplir todas las operaciones de
la transacción o no se cumple ninguna; no puede quedar a
medias.
 Consistencia: La transacción solo termina si la base de
datos queda en un estado consistente.
 Isolation (Aislamiento): Las transacciones sobre la
misma información deben ser independientes, para que
no interfieran sus operaciones y no se produzca ningún
tipo de error.
 Durabilidad. Cuando la transacción termina el resultado
de la misma perdura, y no se puede deshacer, aunque
falle el sistema.
6.3 Los métodos commit() y
rollback()
/*Añadir imagen
Los métodos para gestionar transacciones en Qizx los proporciona
la interface Library y son:
 commit(). Confirma la transacción actual. Si este método se
completa sin errores, las actualizaciones realizadas en la
transacción garantizan la persistencia, y se hacen visibles
a otras sesiones.
o Una vez confirmada, desbloquea todos los
objetos de la BD, previamente bloqueados.
o Finalizada la transacción, el estado de la BD
también refleja los cambios realizados
posiblemente por otras transacciones.
 rollback(). Cancela la transacción actual.
o Desbloquea todos los objetos de la BD,
previamente bloqueados.
o Después de un rollback() se refresca o actualiza
el estado de la BD, de manera que se reflejan
los cambios realizados por otras transacciones.
En Qizx, todas las operaciones de actualización sobre una BD o
Library, para que tengan efecto permanente, deben ir seguidas de una
confirmación o commit(). Por ejemplo, después de realizar una
consulta de actualización, para que permanezcan los cambios es
necesario realizar un commit(), tal y como refleja el siguiente código.
/* Añadir imagen
Por otra parte, al cerrar una conexión a una BD es necesario
comprobar si hay alguna transacción en curso, de manera que, si
hay alguna en curso, para poder cerrar la BD habrá que cancelar la
transacción actual.
El código que refleja de forma clara este hecho es el siguiente:
/*Añadir imagen
14. Tratamiento de excepciones
Una excepción es un suceso excepcional que ocurre durante la
ejecución de un programa y que interrumpe su ejecución o flujo
normal de sentencias. El origen o causa de una excepción es un
error en el programa.
Gestionando de manera adecuada las posibles excepciones del
programa, podemos construir programas robustos, que pueden
continuar su ejecución sin que el problema les afecte, o bien
finalizar de manera no abrupta.
En Qizx, la clase que contiene los diferentes tipos de
excecpiones es QizxException del paquete com.qizx.api. Esta clase
extiende a Exception, superclase de todas las excepciones del API
y sus constructores son:
 QizxException(String message).Construye un mensaje con la
razón o causa de excepción. El código del error es
indefinido.
 QizxException(String message, Throwable cause). Construye un
mensaje con la razón o causa de excepción, y la
excepción. El código del error es indefinido.
 QizxException(QName errorCode, String message). Construye un
mensaje con la razón de la excepción y un código de
error XQuery.
En el siguiente segmento de código, puedes ver el ejemplo de un
método que puede generar excepciones que deben ser capturadas.
En este caso, se utiliza throws, de manera que si se produce un error
en la ejecución del método, error que puede ser originado al
intentar cerrar la conexión de un objeto Library o bien todas las
Library de un grupo, el método no se encarga de resolverlo, sino que
deja el tratamiento de la excepción al bloque desde donde se hace
la llamada.
/*Añadir imagen
Tres subclases directas de QizxExcepction son:
 CompilationException.Excepciones debidas a errores en la
compilación de consultas a la BD
 DataModelException. Excepciones debidas a manipulación de
documentos XML en la BD.
  EvaluationException.
Excepciones debidas a errores en la
ejecución de una consulta.

En el siguiente apartado verás un ejemplo de captura de

excepciones CompilationException.

Tratamiento de excepciones en Java

/*Añadir imagen

6.4 Excepciones en el
procesamiento de
consultas
Cuando se procesa una consulta XQuery o una consulta de
actualización XQuery, pueden ocurrir errores en el proceso de
compilación y evaluación de la expresión de consulta, que suponen
el lanzamiento de excepciones.

Estas excepciones las puedes gestionar mediante dos subclases

directas de la clase QizxException:

 CompilationException .Se lanza cuando hay errores de

compilación en una expresión de consulta. Los mensajes
asociados pueden ser: el error, una advertencia o
warning, y la descripción o detalle del error. Podemos
gestionar esos errores mediante los siguientes métodos
o getErrorCount() devuelve el número actual de
errores.
o getMessages() devuelve una lista de errores o
warnings
 EvaluationException. Se lanza cuando hay errores en la
ejecución de una expresión XQuery.

Por ejemplo, el siguiente código muestra un método que compila

una expresión de consulta y controla posibles errores, almacenando
en un array de tipo Message los posibles errores de compilación,
Observa que en este caso, el tratamiento de la excepción se realiza
mediante un bloque try-catch, y que en caso de que se produzca se
captura la lista de errores.

/*Añadir imagen
 Tema 7. Creación de componentes
visuales
1. Concepto de
componente.
Características
Un componente software es una clase creada para ser reutilizada y
que puede ser manipulada por una herramienta de desarrollo de
aplicaciones visual. Se define por su estado que se almacena en un
conjunto de propiedades, las cuales pueden ser modificadas para
adaptar el componente al programa en el que se inserte. También
tiene un comportamiento que se define por los eventos ante los
que responde y los métodos que ejecuta ante dichos eventos.
Los componentes tienen una interfaz bien definida formada por sus
propiedades y métodos, y se distribuyen mediante un paquete
instalable que contiene todo lo necesario para su funcionamiento.
Además, deben ser independientes de otras bibliotecas o
componentes.
Para que una clase sea considerada un componente debe cumplir
ciertas normas:
 Debe poder modificarse para adaptarse a la aplicación en
la que se integra.
 Debe tener persistencia, es decir, debe poder guardar el
estado de sus propiedades cuando han sido modificadas.
 Debe tener introspección, es decir, debe permitir a un
IDE que pueda reconocer ciertos elementos de diseño
como los nombres de las funciones miembros o métodos
y definiciones de las clases, y devolver esa información.
 Debe poder gestionar eventos.
El desarrollo basado en componentes tiene, además, las siguientes
ventajas:
 Es mucho más sencillo y se realiza en menos tiempo y
con un coste inferior.
 Se disminuyen los errores en el software ya que los
componentes se deben someter a un riguroso control de
calidad antes de ser utilizados.
2 Propiedades y atributos
Como en cualquier clase, un componente tendrá definido un estado
a partir de un conjunto de atributos. Los atributos son variables
definidas por su nombre y su que toman valores concretos.
Normalmente los atributos son privados y no se ven desde fuera de
la clase que implementa el componente, se usan sólo a nivel de
programación. tipo de datos
Las propiedades son un tipo específico de atributos que representan
características de un componente que afectan a su apariencia o a su
comportamiento. Son accesibles desde fuera de la clase y forman
parte de su interfaz. Suelen estar asociadas a un atributo interno.
Una propiedad no es exactamente un atributo público, sino que
tiene asociados ciertos métodos que son la única manera de poder
modificarla o devolver su valor y que pueden ser de dos tipos:
 getter: permiten leer el valor de la propiedad. Tienen la
estructura:
public <TipoPropiedad> get<NombrePropiedad>( )
si la propiedad es el método getter se implementa así:
public boolean is<NombrePropiedad>()
 setter: permiten establecer el valor de la propiedad. Tiene
la estructura:
public void set<NombrePropiedad>(<TipoPropiedad>
valor)
Si una propiedad no incluye el método set entonces es
una propiedad de sólo lectura.
Por ejemplo, si estamos generando un componente para
crear un botón circular con sombra, podemos tener, entre
otras, una propiedad de ese botón que sea color, que
tendría asociados los siguientes métodos:
public void setColor(String color)
public String getColor()
Función principal de un componente: La principal
función de un componente es recoger en una entidad que
sea fácilmente reutilizable un segmento que código con
una funcionalidad cerrada. Aporta ventajas como la
reutilización, disminución de costes al utilizar código ya
hecho y mejorar la robustez y tolerancia a fallos de los
nuevos programas ya que suelen estar ampliamente
probados.
3 Editores de propiedades
Una de las principales características de un componente es que, una
vez instalado en un entorno de desarrollo, éste debe ser capaz de
identificar sus propiedades simplemente detectando parejas de
operaciones get/ set, mediante la capacidad denominada
introspección.
El entorno de desarrollo podrá editar automáticamente cualquier
propiedad de los tipos básicos o de las clases Color y Font. Aunque
no podrá hacerlo si el tipo de datos de la propiedad es algo más
complejo, por ejemplo, si usamos otra clase, como Cliente. Para
poder hacerlo tendremos que crear nuestro propio editor de
propiedades.
Un editor de propiedad es una herramienta para personalizar un
tipo de propiedad en particular. Los editores de propiedades se
utilizan en la ventana Propiedades, que es donde se determina el
tipo de la propiedad, se busca de un editor de propiedades
apropiado, y se muestra el valor actual de la propiedad de una
manera apropiada.
La creación de un editor de propiedades usando tecnología Java
supone programar una clase que implemente la interfaz
PropertyEditor, que proporciona métodos para especificar cómo se
debe mostrar una propiedad en la hoja de propiedades. Su nombre
debe ser el nombre de la propiedad seguido de la palabra Editor:
public Editor implements PropertyEditor {…}
Por defecto la clase PropertyEditorSupport que implementa
PropertyEditor proporciona los editores más comúnmente
empleados, incluyendo los mencionados tipos básicos, Color y Font.
Una vez que tengamos todos los editores, tendremos que
empaquetar las clases con el componente para que use el editor que
hemos creado cada vez que necesite editar la propiedad. Así,
conseguimos que cuando se añada un componente en un panel y lo
seleccionemos, aparezca una hoja de propiedades, con la lista de
las propiedades del componente y sus editores asociados para cada
una de ellas. El IDE llama a los métodos getters, para mostrar en
los editores los valores de las propiedades. Si se cambia el valor de
una propiedad, se llama al método setter, para actualizar el valor de
dicha propiedad, lo que puede o no afectar al aspecto visual del
componente en el momento del diseño.
3.1 Ejemplo de creación de
un componente
JavaBean con NetBeans
Para ilustrar cómo se implementa un componente con una
herramienta como NetBeans, crearemos uno que permita almacenar
la información de una persona, guardaremos por ejemplo, su
nombre, apellidos, teléfono y dirección:
 El nombre se puede representar como una propiedad de
tipo String.
 Los apellidos también se pueden representar como una
propiedad de tipo String.
 El teléfono también puede ser una cadena de caracteres o
String.
 La dirección será una propiedad compuesta, por la
dirección propiamente dicha, la población y la provincia.
Dado que la última propiedad no es simple, será necesario
implementar un editor de propiedades para modificarla desde
NetBeans.
4 Eventos. Asociación de
acciones a eventos
Se puede programar un componente para que reaccione ante
determinadas acciones del usuario, como un clic del ratón o la
pulsación de una tecla del teclado. Cuando estas acciones se
producen, se genera un evento que el componente puede capturar y
procesar ejecutando alguna función. Pero no solo eso, un
componente puede también lanzar un evento cuando sea necesario
y que su tratamiento se realice en otro objeto.
Los eventos que lanza un componente se reconocen en las
herramientas de desarrollo y se pueden usar para programar la
realización de acciones.
Para que el componente pueda reconocer el evento y responder
ante el tendrás que hacer lo siguiente:
 Crear una clase para los eventos que se lancen.
 Definir una interfaz que represente el oyente (listener)
asociado al evento. Debe incluir una operación para el
procesamiento del evento.
 Definir dos operaciones, para añadir y eliminar oyentes.
Si queremos tener más de un oyente para el evento
tendremos que almacenar internamente estos oyentes en
una estructura de datos como ArrayList o LinkedList:
public void addListener(Listener l)
public void removeListener(Listener l)
 Finalmente, recorrer la estructura de datos interna
llamando a la operación de procesamiento del evento de
todos los oyentes registrados. En resumen:
/*Añadir imagen
5 Introspección. Reflexión
Un componente, como cualquier otra clase dispone de una interfaz,
que es el conjunto de métodos y propiedades accesibles desde el
entorno de programación. Normalmente, la interfaz la forman los
atributos y métodos públicos.
La introspección es una característica que permite a las
herramientas de programación visual arrastrar y soltar un
componente en la zona de diseño de una aplicación y determinar
dinámicamente qué métodos de interfaz, propiedades y eventos del
componente están disponibles.
Esto se puede conseguir de diferentes formas, pero en el nivel más
bajo se encuentra una característica denominada reflexión, que
busca aquellos métodos definidos como públicos que empiezan por
get o set, es decir, se basa en el uso de patrones de diseño, es decir,
en establecer reglas en la construcción de la clase de forma que
mediante el uso de una nomenclatura específica se permita a la
herramienta encontrar la interfaz de un componente. reflexión
En JavaBeans la introspección se puede conseguir de varias
maneras:
 Reflexión de bajo nivel, que utiliza patrones de diseño
para descubrir las características del componente por
 medio de las posibilidades de reflexión del paquete
java.lang.reflect.
 Examinando una clase asociada de información del
componente (BeanInfo) que describe explícitamente sus
características para que puedan ser reconocidas.
6 Persistencia
componente
A veces, necesitamos almacenar el estado de una clase para que
perdure a través del tiempo. A esta característica se le llama
persistencia. Para implementar esto, es necesario que pueda ser
almacenada en un archivo y recuperado posteriormente.
El mecanismo que implementa la persistencia se llama
serialización. Al proceso de almacenar el estado de una clase en un
archivo se le llama serializar.
/*Añadir imagen
Al de recuperarlo después deserializar
/*Añadir imagen
Todos los componentes deben persistir. Para ello, siempre desde el
punto de vista Java, deben implementar los interfaces
java.io.Serializable o java.io.Externalizable que te ofrecen la posibilidad de
serialización automática o de programarla según necesidad:
 Serialización Automática: el componente implementa la
interfaz Serializable que proporciona serialización
automática mediante la utilización de las herramientas de
Java Object Serialization. Para poder usar la interfaz
Serializable debemos tener en cuenta lo siguiente:
o Las clases que implementan Serializable deben
tener un constructor sin argumentos que será
llamado cuando un objeto sea "reconstituido"
desde un fichero .ser.
o Todos los campos excepto static y transient son
serializados. Utilizaremos el modificador
transient para especificar los campos que no
queremos serializar, y para especificar las
clases que no son serializables (por ejemplo
Image no lo es).
o Se puede programar una serialización propia
si es necesario implementando los siguientes
métodos (las firmas deben ser exactas):
private
writeObject(java.io.ObjectOutputStream
throws IOException;
private
readObject(java.io.ObjectInputStream
throws IOExcept;
 Serialización programada: el componente implementa
la interfaz Externalizable, y sus dos métodos para guardar el
componente con un formato específico. Características:
o Precisa de la implementación de los métodos
readExternal () y writeExternal ().
o Las clases Externalizable también deben tener un
constructor sin argumentos.
Los componentes que implementarás en esta unidad emplearán la
serialización por defecto por lo que debes tener en cuenta lo
siguiente:
 La clase debe implementar la interfaz Serializable.
 Es obligatorio que exista un constructor sin argumentos.
del
7 Propiedades simples e
indexadas
/*Añadir imagen
Una propiedad simple representa un único valor, un número,
verdadero o falso o un texto por ejemplo.
Tiene asociados los métodos getter y setter para establecer y rescatar
ese valor. Por ejemplo, si un componente de software tiene una
propiedad llamada peso de tipo real susceptible de ser leída o
escrita, deberá tener los siguientes métodos de acceso:
public real getPeso()
public void setPeso(real nuevoPeso)
Una propiedad simple es de sólo lectura o sólo escritura si falta uno
de los mencionados métodos de acceso.
Una propiedades indexadas representa un conjunto de elementos,
que suelen representarse mediante un vector y se identifica
mediante los siguientes patrones de operaciones para leer o escribir
elementos individuales del vector o el vector entero (fíjate en los
corchetes del vector):
public <TipoProp>[] get<NombreProp>()
public void set<NombreProp> (<TipoProp>[] p)
public <TipoProp> get<NombreProp>(int posicion)
public void set<NombreProp> (int posicion, <TipoProp> p)
Aquí tienes un ejemplo de propiedad indexada. El componente
almacena un conjunto de miembros, a los que puedes acceder en
conjunto o de uno en uno.
/* Añadir imagen
8 Propiedades compartidas y
void
restringidas
out)
Los objetos de una clase que tiene una propiedad compartida o
ligada notifican a otros objetos oyentes interesados, cuando el
void
valor de dicha propiedad cambia, permitiendo a estos objetos
in)
realizar alguna acción. Cuando la propiedad cambia, se crea un
objeto (de una clase que hereda de ObjetEvent) que contiene
información acerca de la propiedad (su nombre, el valor previo y el
nuevo valor), y lo pasa a los otros objetos oyentes interesados en el
cambio.
La notificación del cambio se realiza a través de la generación de
un PropertyChangeEvent. Los objetos que deseen ser notificados del
cambio de una propiedad limitada deberán registrarse como
auditores. Así, el componente de software que esté implementando
la propiedad limitada suministrará métodos de esta forma:

public void addPropertyChangeListener (PropertyChangeListener
l)
public void removePropertyChangeListener
(PropertyChangeListener l)
Los métodos precedentes del registro de auditores no identifican
propiedades limitadas específicas. Para registrar auditores en el
PropertyChangeEvent de una propiedad específica, se deben
proporcionar los métodos siguientes:
public void addPropertyNameListener (PropertyChangeListener l)
public void removePropertyNameListener
(PropertyChangeListener l)
En los métodos precedentes, PropertyName se sustituye por el nombre
de la propiedad limitada. Los objetos que implementan la interfaz
PropertyChangeListener deben implementar el método propertyChange().
Este método lo invoca el componente de software para todos sus
auditores registrados, con el fin de informarles de un cambio de
una propiedad.
Una propiedad restringida es similar a una propiedad ligada salvo
que los objetos oyentes que se les notifica el cambio del valor de la
propiedad tienen la opción de vetar cualquier cambio en el valor de
dicha propiedad.
Los métodos que se utilizan con propiedades simples e indexadas
que veíamos anteriormente se aplican también a las propiedades
restringidas. Además, se ofrecen los siguientes métodos de registro
de eventos:
public void addPropertyVetoableListener (VetoableChangeListener
l)
public void removePropertyVetoableListener
(VetoableChangeListener l)
public void addPropertyNameListener (VetoableChangeListener l)
public void removePropertyNameListener
(VetoableChangeListener l)
Los objetos que implementa la interfaz VetoableChangeListener deben
implementar el método vetoableChange(). Este método lo invoca el
componente de software para todos sus auditores registrados con el
fin de informarles del cambio en una propiedad.
Todo objeto que no apruebe el cambio en una propiedad puede
arrojar una PropertyVetoException dentro del método vetoableChange(),
para informar al componente cuya propiedad restringida hubiera
cambiado de que el cambio no se ha aprobado.
9 Herramientas para el
desarrollo de componentes
visuales.
BeanBox
Es la primera herramienta que se creó para trabajar con
componentes de JavaBeans y se podría definir como un contenedor
de Beans. Se proporcionaba desde la página web de Sun, y la
documentación sobre JavaBeans se basaba en esta herramienta.
En BeanBox se pueden escribir los Beans, para luego arrastrarlos
dentro de BeanBox y comprobar si funcionan como se esperaba.
El BeanBox también puede verse como una demostración de cómo
deben comportarse las herramientas de desarrollo compatibles con
los JavaBeans. El BeanBox es una buena herramienta para
aprender a trabajar con Beans, aunque hoy en día ha sido sustituida
por NetBeans.
Bean Builder
En una versión mejorada del BeanBox. Con esta aplicación se
comenzó a dar un enfoque al proyecto que se desarrollaba, puesto
que al igual que el BeanBox permitía el enlazado de componentes
de manera gráfica y ver sus propiedades en tiempo que diseño, pero
a diferencia de él y lo que más interesante resultaba era que no
creaba archivos .ser para la serialización de los objetos sino que
utiliza archivos XML que podían ser entendidos por cualquier
aplicación.
Netbeans
Es la apuesta actual de Oracle para crear y utilizar Beans.
Proporciona una base completa para todo el ciclo de vida de
creación del Bean, y ayudas para la escritura de código para añadir
propiedades, métodos getter y setter en propiedades simples,
complejas, compartidas o ligadas, o para la generación de eventos.
Además desde el administrador de la paleta es extremadamente
sencillo incorporar nuevos beans desde sus archivos .jar, e
incorporarlos a una aplicación solo precisa de un par de clics.
Una de las características que aporta NetBeans es la creación de la
clase BeanInfo para el componente. Una clase BeanInfo puede
gestionar el modo en que el componente aparece en la herramienta
de desarrollo de aplicaciones, indicando que propiedades deben
aparecer, en primer lugar, cual es deben estar ocultas, si existe un
editor de propiedades asociado, etc, siendo además una de las bases
de la introspección en Java.
Puedes generar un BeanInfo automáticamente desplegando el menú
contextual de la clase que implementa el componente en el
inspector de proyectos de NetBeans y seleccionar Editor BeanInfo,
si no existe te preguntará si quieres crearlo, cuando lo hagas se
creará la clase BeanInfo y se mostrará el código, si cambias al
diseño visual verás un panel que te permite gestionar gráficamente
las propiedades de tu componente.
La principal ventaja de utilizar este método es que cuando nuestro
componente hereda de una clase del tipo JPanel o JFrame, que son
bastante complejas, el manejo de las propiedades heredadas es
automático en el BeanInfo.
10 Empaquetado de
componentes
Una vez creado el componente, es necesario empaquetarlo para
poder distribuirlo y utilizarlo después. Para ello necesitarás el
paquete jar que contiene todas las clases que forman el
componente:
 El propio componente.
 Objetos BeanInfo.
 Objetos Customizer.
 Clases de utilidad o recursos que requiera el componente,
etc.
Puedes incluir varios componentes en un mismo jar.
El paquete jar debe incluir un fichero de manifiesto (con extensión
.mf) que describa su contenido, por ejemplo: /*Añadir imagen

Manifest-Version: 1.0 La base de datos se compone de una sola tabla de alumnos. Para
Name: demo/Componente.class cada alumno almacenamos su DNI, nombre, apellidos, dirección y
Java-Bean: True fecha de nacimiento
Name: demo/ComponenteBeanInfo.class
Java-Bean: False
Name: demo/ClaseAuxiliar.class
Java-Bean: False
11.2 Controlador o lógica del
Name: demo/Imagen.png
Java-Bean: False
modelo
En el entorno de la arquitectura MVC el controlador representa la
lógica de negocio de una aplicación. Encapsula las reglas de
Observa, en el fichero de manifiesto como la clase del componente
negocio en componentes que son fáciles de probar, permiten
va acompañada de Java-Bean: True, indicando que es un JavaBean.
mejorar la calidad del software y promueven la reutilización.

La forma más sencilla de generar el archivo jar es utilizar la
herramienta Limpiar y construir del proyecto en NetBeans, que
deja el fichero .jar perfectamente en el directorio /dist del proyecto,
aunque siempre puedes recurrir a la orden jar y crearlo tu
directamente:
jar cfm Componente.jar manifest.mf Componente.class
ComponenteBEanInfo.class ClaseAuxiliar.class Imagen.png
proyecto.jar
El estado define el conjunto actual de valores del modelo e incluye
métodos para cambiar estos valores. Estos métodos recogen parte
de la lógica de negocio. Deberían de ser independientes del
protocolo que se utilizara para acceder a ellos. Si resumimos la
encapsulación, calidad del software, reutilización e independencia
del protocolo obtenemos que los JavaBeans son la elección lógica
para implementar estos componentes.
El componente se encarga de conectar con la base de datos y
ejecutar la sentencia deseada. A través de los métodos puede

11 Elaboración de un posicionarse en cada fila de la consulta y almacena en las

propiedades cada uno de los campos.

componente de ejemplo Las acciones definen los cambios permitidos para los estados en
respuesta a los eventos.
En el ámbito del acceso a datos que estudiamos en este módulo
formativo el uso de componentes está muy relacionado con el
mundo de la creación de aplicaciones web.
11.3 Estructura del JavaBean
La tecnología JSP utiliza una arquitectura denominado MVC Para la elaboración de un componente, debes tener muy claros
(Modelo-Victa-Controlador) cuya misión fundamental es separar el los pasos que debes dar.
desarrollo de la base de datos (Modelo), creada por ejemplo en
MySQL o cualquier otro gestor de bases de datos, de la interfaz 1. Creación del componente.
(Vista), que puede hacerse usando HTML en combinación con JSP, 2. Adición de propiedades.
de la lógica de negocio (Controlador) cuya implementación más 3. Implementación de su comportamiento.
sencilla y fácil de gestionar por JSP es un JavaBean que acceda a la 4. Gestión de los eventos.
base de datos y permita recuperar fácilmente la información que 5. Uso de componentes ya creados en NetBeans.
contiene.
En las siguientes secciones verás cómo se realizan estos pasos con
/* Añadir imagen el ejemplo que se acaba de exponer.

En el esquema el modelo sería la base de datos, la vista el apartado El componente a crear dispondrá de un constructor con las
de presentación de datos y el controlador está formado por la lógica siguientes características:
de la aplicación y acceso a datos.
 Propiedades que se corresponden con los campos de la
Para saber más tabla alumnos.
/*Añadir imagen  Clase auxiliar llamada Alumno que usaremos para crear
un vector de alumnos donde cargaremos el contenido de
Para ejemplificar el uso de componentes JavaBean de acceso a la tabla.
datos, supondremos que queremos crear una aplicación web que  Vector de alumnos.
muestre información de los alumnos del ciclo que mantendremos  Constructor (sin argumentos):
almacenados en una base de datos. De momento, nos encargaremos o Realiza la conexión a la base de datos.
de los apartados Modelo y Controlador, dejando la vista para otros o Realiza la consulta.
módulos del ciclo. o Guarda los resultados en una estructura local al
componente.
o Establece los valores de las propiedades.
11.1 Modelo o base de datos 
o Cierra la conexión.
Métodos para recorrer los resultados, recargando las
Nos basaremos en una base de datos muy sencilla que tendremos
almacenada en un servidor MySql. El código SQL para crear la propiedades cada vez que cambie. Usaremos los
base de datos sería: siguientes métodos:
 o obtenerFilas():hace la consulta sobre la base de
datos y almacena los resultados sobre un vector
interno actualizando los valores de las
propiedades.
o SeleccionarFilas/(i): se posiciona en el elemento i
del vector y actualiza los valores de las
propiedades.
o seleccionarDNI(String DNI): busca en el vector
interno el registro que coincide con el valor del
DNI y actualiza los valores de las propiedades.
11.4 Creación del
componente
Comenzamos creando un proyecto NetBeans nuevo de tipo Java
Application. Nos aseguramos de desmarcar las opciones Crear
clase principal y Configurar como proyecto principal y ponemos de
nombre al proyecto AlumnoBean, por ejemplo.
Una vez creado el proyecto, le añadimos un archivo nuevo de tipo
Componente JavaBeans (si no lo encuentras en la lista que sale en
el menú contextual, haz clic en la opción Otros... para acceder al
resto de tipos de archivos). Puedes llamar a la clase AlumnoBean y
al paquete en el que se ubicará Alumno.
/*Añadir imagen
Para que una clase se pueda considerar un componente debe
implementar la interfaz Serializable y, además, tener un
constructor sin argumentos que vimos eran requisitos para la
creación de componentes.
El proyecto cuenta con una propiedad de ejemplo que puedes
eliminar (su declaración y los métodos get y set de la propiedad), así
como un gestor de escuchadores de cambio de propiedades que no
necesitaremos, quedando el siguiente código para empezar:
public class AlumnoBean implements Serializable {
private PropertyChangeSupport propertySupport;
public TemporizadorBean() {
propertySupport = new
PropertyChangeSupport(this);
} Los componentes Java utilizan el modelo de delegación de eventos
} para gestionar la comunicación entre objetos como hemos visto.
11.5 Añadir propiedades.
El componente tendrá como propiedades las mismas que los
campos de la base de datos: DNI, nombre, apellidos, dirección y
fecha de nacimiento.
La adición de propiedades en una clase Java se realiza simplemente
escribiendo el código de declaración del atributo privado (o
protegido) y los métodos getter y setter que son la base de la
instrospección.
Si bien NetBeans proporciona una ayuda especial para realizar esta
tarea. Con el cursor posicionado dentro de la clase (puedes reservar
una zona para el código de propiedades), haz clic con el botón
secundario y selecciona la opción Insertar Código..., en la lista
que te saldrá elige Agregar propiedad. Se desplegará el siguiente
cuadro de diálogo en el que puedes escribir el nombre de la
propiedad y su tipo, e insertar los métodos get y set de manera
automática:
/*Añadir imagen
Fíjate que si quisieras crear una propiedad indexada o restringida es
muy sencillo de hacer, sólo hay que marcar la opción
correspondiente y la herramienta genera el código base de los
métodos necesarios.
11.6 Implementar el
comportamiento
Con las propiedades listas, tenemos que programar el
comportamiento del componente. En principio la idea es que al
crear el componente se cargue el contenido de la tabla alumno de la
base de datos en un vector de uso interno que nos va a servir para
no tener que estar conectándonos constantemente, recuerda que
estos componentes se usan en entornos cliente servidor con gran
cantidad de accesos por parte de múltiples usuarios que pueden
llegar a saturar la base de datos. Por este motivo programaremos el
constructor para que realice la carga de datos. En un primer
momento los valores de las propiedades serán los del primer
alumno recuperado.
También generaremos un par de métodos para recuperar
información de un registro según su posición o según su clave.
A continuación, tienes el enlace al código de la clase con lo visto
hasta el momento:
Añadiremos el siguiente código:
/*Añadir imagen
11.7 Gestión de eventos
Los componentes usan los eventos para generar acciones en
respuesta a los cambios del estado permitidos
/* Añadir imagen
Para ilustrar el uso de los eventos en un componente JavaBean le
añadiremos un comportamiento extra que añadirá un nuevo alumno
a la base de datos. Tendrá como especial característica que cada
vez que se inserte un alumno nuevo que generará un evento que
alerte de esta modificación. Esto que en principio puede parecer
redundante no lo es en un entorno multiusuario en el que varios
clientes se conecten simultáneamente a la base de datos. Para poder
implementar esto necesitarás varias cosas:
 Una clase que implemente los eventos. Esta clase hereda
de java.util.EventObject. En el ejemplo se llamará
BDModificadaEvent.
 Una interfaz que defina los métodos a usar cuando se
genere el evento. Implementa java.util.EventListener. En este
caso la gestión del evento se hará a través del método
capturarBDModificada de la interfaz BDModificadaListener.
También tenemos un objeto de tipo DBModificadaListener
llamado receptor que representa aquellos programas que
contienen al componente AlumnosBean susceptibles de
recibir el evento.
  Dos métodos, addEventoListener y removeEventoListener que
permitan al componente añadir oyentes y eliminarlos. En
principio se deben encargar de que pueda haber varios
oyentes. En nuestro caso sólo vamos a tener un oyente,
pero se suele implementar para admitir a varios.
 Implementar el método que lanza el evento,
asegurándonos de todos los oyentes reciban el aviso. En
este caso lo que se ha hecho es lanzar el método que se
creó en la interfaz que describe al oyente.

Finalmente, el código de la clase componente queda como aparece

a continuación:

/* Añadir imagen

11.8 Uso de componentes

previamente elaborados
en NetBeans
Una vez construido el componente es sencillo incorporarlo a la
paleta de NetBeans. Podemos hacerlo de diferentes formas:

 Si lo hemos desarrollado nosotros mismos (con

NetBeans) basta con utilizar Limpiar y Construir para
generar el fichero .jar con el componente.
 Si es un componente generado por otras personas, es
preciso disponer de la distribución en un fichero .jar.

Para probar el componente tendrás que importar el fichero .jar desde

las propiedades del proyecto con la nueva aplicación.

La gestión de eventos pasa por crear una clase que implemente la

interfaz BDModificadaListener.

public class AccedeBD implements BDModificadaListener{

en el constructor indicamos que vamos a estar escuchando si se

produce el evento:

AccedeBD(){
alumnos = new AlumnoBean();
alumnos.addBDModificadaListener((BDModificadaListener)t
his );
}

y sobreescribimos el método capturarBDModificada(BDModificadaEvent ev)

para escribir un mensaje cuando se produzca el evento.

public void capturarBDModificada(BDModificadaEvent ev) {

System.out.println("Se ha añadido un elemento a la base
de datos");
}