Acceso de datos

imprimirá por consola el valor del elemento e indicará que hemos terminado con este
bloque del XML.

Este método recibe por parámetro un string con la URI, otro con localName y otro con
el elemento XML finalizado. En este caso, solo tendrá valor el string "elementos" porque
nuestro XML es más sencillo y estos campos están vacíos. Cabe decir que solo se
rellenarán cuando el XML contenga esa información. Como vemos en el ejemplo, los
objetos para acceder a los datos de un fichero son con SaxParserFactory y SaxParser.

Este es un ejemplo muy simplificado para observar el funcionamiento básico y los

objetos. Es recomendable consultar GitLab para ver el ejemplo implementado, ya que la
implementación de SAX es bastante complicada.

1.4.1.3. Acceso a datos JAXB (binding)

Cuando trabajamos con un lenguaje de programación como Java, las posibilidades para
jugar con el lenguaje son muy extensas. En este caso, analizaremos cómo podemos
tratar los XML y a qué otros formatos podemos convertir ese archivo.

Una de las posibilidades más interesantes que nos ofrece Java es la posibilidad de
convertir un XML en un objeto Java. La librería Java JAXB (Java XML API Binding) nos
ofrece esa posibilidad. Está incluida dentro de la JDK de Java, por lo que no es necesario
importar librerías.

El data binding es el concepto para definir la voluntad de transformar un fichero

XML (o cualquier otro fichero) en un objeto Java.

Algunas de las características principales de esta API son que nos permite navegar por
el documento en ambas direcciones, es más eficiente que DOM y permite la conversión
de tipos XML a Java. Además, permite la manipulación del fichero XML. Trabaja de
manera muy simple la carga, creación y manipulación de ficheros XML.

50
 Acceso de datos

Como aspecto negativo, cabe destacar que no permite tratar un fichero XML si este no
es válido, por tanto, tenemos que validarlo antes de poder transformarlo a un objeto
Java.

String xml = "<?xml version= \"1.0\" encoding=\"UTF-8\"?>"

+ "<coches><coche><marca>Seat</marca><modelo>Ibiza</modelo>" +
"<color>rojo</color><matriculacion>2019</matriculacion>"
+ "</coche></coches>";

JAXBContext jaxbContext;

try {
jaxbContext = JAXBContext.newInstance(Coche.class);
// Este objeto se encargará de la transformación a objeto
Java que le indiquemos.
Unmarshaller jaxbUnmarshaller =
jaxbContext.createUnmarshaller();
Coche coche = (Coche) jaxbUnmarshaller.unmarshal(new
StringReader(xml));
System.out.println(coche);
} catch (JAXBException e) {
e.printStackTrace();
}

Tal y como podemos ver en el ejemplo, la API JAXB se encarga de coger los datos del
XML y convertirlos en el objeto que le indiquemos. El objeto debe tener los mismos
atributos que el XML, si no, se lanzará la excepción.

1.4.2. Librerías para la conversión de documentos XML a otros formatos

En Java existen una infinidad de librerías que podemos añadir a nuestro proyecto para
poder transformar nuestros XML a cualquier otro formato. En este apartado,
explicaremos cómo transformar nuestros ficheros XML a un formato JSON.

JSON: siglas para Javascript Object Notation. Es un tipo de archivo de formato de

texto derivado de Javascript, bastante ligero y que almacena información
estructurada. Es fácil de interpretar y generar, y se utiliza para transferir
información entre un cliente y un servidor.

51
 Acceso de datos

Los archivos JSON siguen una estructura basada en definición de objetos, asignando un
atributo y un valor. Un fichero JSON es capaz de definir seis tipos de valores: string,
número, objeto, arrays, true, false o null. Veamos un ejemplo:

Objeto
{ Atributo
"coche":{ Valor
"marca": "Seat",
"modelo": "Ibiza",
"color": "rojo",
"matriculacion": 2019
},
"coche":{
"marca": "Ford",
"modelo": "Focus",
"color": "rojo",
"matriculacion": 2019
}
}

Para definir el JSON, se abren y cierran corchetes. Los objetos se declaran entre comillas
y los diferentes objetos se separan con una coma. El nombre y el valor de cada pareja
van separados entre dos puntos. Cada objeto se considera un string; en cambio, los
valores de los atributos pueden ser de cada tipo permitido nombrado en el parágrafo
anterior.

XML a JSON

public static String XML_PRUEBA =

"<coche><id>1</id><modelo>Ibiza</modelo><marca>seat</marca></coc
he>";
try {
//Creamos el objeto que nos ayudara a convertir el XML en
JSON
JSONObject json = XML.toJSONObject(XML_PRUEBA);
//Identamos el json, le damos formato
String jsonFormatado = json.toString();
System.out.println(jsonFormatado);
} catch (JSONException je) {
System.out.println(je.toString());
}

Para esta conversión tenemos que añadir la librería Jackson a nuestro proyecto.

52
 Acceso de datos

Esta librería nos permitirá realizar la transformación de XML a JSON en muy pocas líneas
de código.

Se puede descargar en estos enlaces:

https://repo1.maven.org/maven2/org/json/json/20190722/

https://jar-download.com/artifacts/org.json

Este sería un ejemplo sencillo de la implementación de esta librería: en primer lugar,

tenemos que definir un XML, en el ejemplo tenemos un modelo sencillo de XML. A
continuación, definiremos un nuevo objeto usando la clase JSONObject que se rellenará
con la llamada al método XML.toJSONObject(). Este método nos permitirá transformar
cualquier XML a JSON, pasándole el XML como string. Una vez transformado a objeto
JSON, podemos pasarlo a string usando el método toString() y ya tendríamos la
transformación realizada. Tenemos que tener en cuenta que nuestro XML debe estar
bien estructurado y tiene que estar validado y sin ningún error. Si hay algún error, no se
hará la transformación correctamente y saltará un error que lo controlaremos en el
catch.

53
 Acceso de datos

1.5. Excepciones: detección y tratamiento

El tratamiento de las excepciones es un proceso muy importante en la creación de un
programa. Es el mecanismo que nos permite controlar un proceso anómalo dentro de
nuestro programa y gestionar qué ocurre cuando se produce un error.

Una excepción es un evento que se produce durante la ejecución de un programa

que interrumpe el flujo normal de ejecución del código a causa de un error, ya sea
controlado o inesperado.

Para poder gestionar los errores, en Java utilizamos lo que se llama un try-catch. Un try-
catch es un bloque de código que se añadirá a nuestro programa siempre que queramos
controlar una parte del código que vayamos a desarrollar. El código se ejecutará en
orden e irá siguiendo hasta que se produzca un error, en ese momento entrará al catch.
Podemos definir más de un catch en un mismo try. Cuando se produzca el error, entrará
en el primer bloque catch que coincida con el tipo de excepción y solo podrá entrar en
uno de los bloques catch. Los tipos de excepción más específicos deben aparecer
primero en la estructura, seguidos de los tipos de excepción más generales.

El try es lo que primero se ejecuta: se prueba la acción que se intenta realizar y, si se

produce un error, el catch recoge la excepción y, según lo que indiquemos, lanza un
mensaje con la descripción de lo que ha ocurrido. Al lanzar una excepción, el proceso
normal del programa se interrumpirá.

Lo mejor para controlar los errores es tener en cuenta todas las posibilidades de error y
controlarlas. Se debe utilizar un try-catch siempre que sea necesario.

try{
//Parte donde se ejecuta el código que puede dar excecion
File prueba = new File("c\\:prueba.txt");
} catch(NoSuchFileException e){
System.out.println(“No se ha encontrado el archivo” +e);
}catch(IOExcepction ex){
//Parte donde se gestiona la excepción
throw ex;
}
finally{
//Bloque de código que se ejecutará siempre, aunque se lanze una //excepcion
}

54
 Acceso de datos

Como vemos en el ejemplo, antes de realizar la acción debemos envolverla con un try-
catch. Dentro del bloque del try, añadiremos la parte del código que queremos controlar
si se produce un error. Si no se produce el error, el programa continuará la ejecución y
entrará dentro del bloque finally. Este bloque se ejecutará siempre, aunque no se
produzca un error, y es especialmente útil para cerrar el proceso o ejecutar algún tipo
de acción necesaria. En el caso de que se produzca un error, entrará en el catch y
realizará las acciones dentro de ese apartado y lanzará un error. Para lanzar el error, lo
realizaremos mediante la palabra "throw" seguida de la excepción definida, en este
caso, "ex". Cada excepción tiene diferentes métodos para dar detalle de lo que está
ocurriendo. Siempre que forme parte de la familia Throwable, tendremos estas
opciones.

Ilustración 8. Métodos de la clase IOException.

Para saber qué métodos contiene, podemos dirigirnos a la página web de la

documentación de Java, donde obtendremos toda la información.

https://docs.oracle.com/javase/8/docs/

Cuando se produce un error y hemos definido un bloque finally, también se ejecutará.

Como hemos explicado en el apartado anterior, debemos definir las excepciones más
específicas primero y dejar para lo último las más genéricas. Podemos definir cuantos
catch sean necesarios.

Cuando programemos en Java, podremos encontrar dos tipos de excepciones: las

excepciones controladas y las excepciones no controladas.

55
 Acceso de datos

Excepciones controladas (checked exceptions)

Entendemos por excepciones controladas todas aquellas que representan errores

fuera del control del programa. Estas excepciones se controlan en tiempo de
ejecución.

Usaremos este tipo de excepción siempre que se espere que el programa puede
recuperarse después de lanzarse la excepción. Son de uso obligatorio en cualquier
gestión de ficheros.

Este tipo de excepciones son subclases de la clase Exception.

Exception

IOException

FileSystemEx FileNotFound
ception Exception

DirectoryNot AccesDenied FileAlreadyEx NoSuchFileEx NotDirectory

empty Exception istsException ception Exception

Ilustración 9. Gráfico con la jerarquía de excepciones más comunes en gestión de ficheros.

• IOexception: es una clase de error genérico, la podemos usar siempre que

queramos controlar todo tipo de excepción sin saber exactamente cuál se podrá
lanzar. Subclase de Exception.

• FileSystemException: es una clase que lanza errores cuando una operación con
ficheros falla en un fichero o dos.

• DirectoryNotEmptyException: nos indicará que la carpeta no está vacía.

• FileNotFoundException: nos servirá para indicar que no se ha encontrado el

fichero.

56
 Acceso de datos

• AccesDeniedException: esta excepción es útil para controlar si el acceso al fichero

está permitido.

• FileAlreadyExistsException: cuando se crea un fichero y ya existe se lanza esta

excepción.

• NoSuchFileException: será útil para controlar si existe el fichero al cual queremos

acceder.

• NotDirectoryException: para controlar si existe la carpeta a la cual queremos

acceder o crear.

Hay dos maneras de controlar las excepciones:

private static void excepcionControladaConThrows() throws

FileNotFoundException {
File ej = new File("fichero.txt");
FileInputStream stream = new FileInputStream(ej);
}

private static void metodoConTryCatch() {

File ej = new File("ejemplo.txt");
try {
FileInputStream stream = new FileInputStream(ej);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}

Como podemos ver en el ejemplo, hay dos tipos de excepción: la que se pone en la
declaración del método con un throws o con un try-catch dentro de la implementación
del método. Hay que tener en cuenta que, cuando declaramos el throws en el método,
quien recibe la función deberá envolver esa llamada dentro de un try-catch, es decir,
quien haga la llamada al método excepcionControladaConThrows() deberá realizarla con
un try-catch. Algo más o menos así:

private static void ejemploLlamada() {

try {
excepcionControladaConThrows();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}

57
 Acceso de datos

Excepciones no controladas (unchecked exceptions)

Las excepciones no controladas son aquellas que reflejan un error dentro de la lógica
del programa que estamos desarrollando.

Este tipo de excepciones no se comprueban en tiempo de compilación, por tanto, no es

necesario englobar este tipo de excepción en un throws o un try-catch.

En la gestión de ficheros, este tipo de excepción no será la más usual, pero sí que se
tiene que tener en cuenta, porque puede que se reproduzca en algún momento si
alguno de los parámetros que usemos esta vacío o null.

Los más usuales serán:

Exception

RuntimeException

IllegalArgument SecurityExceptio NullPointerExce UncheckedIOExc

Exception n ption eption

Ilustración 10. Gráfico con la jerarquía de excepciones no controladas más comunes en gestión de ficheros.

• RuntimeException: se lanza cuando se produce un error con la máquina virtual

de Java.

• NullPointerException: se lanzará siempre que uno de los campos que se le pasen

al programa esté vacío.

• IllegalArgumentException: se lanzará esta excepción cuando uno de los

argumentos que se le pasen a un método no sea válido.

• SecurityException: cuando se produce algún problema de seguridad.

• UncheckedIOException: cuando se produce una excepción no controlada.

58
 Acceso de datos

1.6. Pruebas y documentación de las aplicaciones desarrolladas

Una de las partes más importantes de la programación y en la que seguramente muchas
veces nadie piensa es la documentación. Dejar el código bien documentado y
comentado es una tarea igualmente importante y que en nuestra trayectoria laboral nos
será de gran utilidad.

La manera más conocida de documentar el lenguaje Java es JavaDoc. Se trata de una

utilidad de Oracle que permite documentar clases de Java.

En primer lugar, lo más común es usar comentarios. Los comentarios se pueden escribir
de tres maneras:

//Comentario en una línea simple

/*
*Comentario en más de una línea
*/
/**
*Comentario con JavaDoc
*/

La estructura utilizada en JavaDoc es muy similar a la que se utiliza normalmente para

comentarios, pero en la API se añade un asterisco extra al empezar, que es el
característico para definirlo.

La gran peculiaridad de esta API es que permite añadir tags HTML dentro de los
comentarios. Eso es debido a que JavaDoc, a través de los comentarios, genera un
documento que servirá como documentación del proyecto.

Los comentarios para documentar, normalmente, se pueden poner en el código, encima

de cualquier clase, en los métodos o atributos que queramos documentar.

Cuando se añadan comentarios, es necesario tener en cuenta que se debe describir cuál
es la función de lo que se comenta. Por ejemplo, si comentamos una clase, haremos una
breve explicación de lo que se encarga.

59
 Acceso de datos

/**
* Aquí pondremos un resumen de la finalidad de esta clase
* Ej: Clase para documentar el funcionamiento de JavaDoc
*
* @author Ilerna
*
*/
public class JavaDoc {

/**
* Atributo nombre de la clase javaDoc
*/
private String nombre;

/**
* <p>Ejemplo de Javadoc con tags html .
* <a href="http://www.ilerna.es">Web ilerna</a>
* </p>
* @param ejemplo String que pasamos por parametro
* @return String con el resultado del metodo
* @see <a href="http://www.ilerna.es">Ejemplos</a>
* @since 1.0
*/
public String ejemploMetodoJavadoc(String ejemplo) {
// Comentario con explicación de lo que se realiza en el
método
return “OK”;
}

60
 Acceso de datos

Tags más importantes:

TAG DESCRIPCIÓN

@author Sirve para poner el autor del desarrollo.

@deprecated Indica que el método o clase es obsoleto (propio de versiones

anteriores) y que no se recomienda su uso.

@param Se usara para definir un parámetro de un método, es requerido para

todos los parámetros del método.

@return Se usa para indicar qué es lo que devuelve el método, no se usa para
los métodos void.

@see Asocia con otro método o clase.

@version Se usa para definir la versión del método o la clase

Tabla 8. Etiquetas más importantes para JavaDoc.

Para empezar, vamos a ver un ejemplo de cómo implementar JavaDoc en una clase.

Todos estos comentarios nos servirán para crear la documentación. Para generarla,
podemos hacerlo desde la línea de comandos ejecutando este comando:

javadoc –d doc src\

También podremos hacerlo a través de nuestro IDE. Si accedemos a Project > Generate
JavaDoc, nos aparecerá una ventana que nos permitirá elegir dónde queremos guardar
nuestra documentación. Y ya lo tendremos creado.

61
 Acceso de datos

Ilustración 11. Captura con las indicaciones para generar un JavaDoc.

Ilustración 12. Ventana para indicar dónde queremos guardar nuestro JavaDoc.

62
 Acceso de datos

A continuación, pondremos en práctica lo aprendido en esta lección y realizaremos

pruebas con JUnit. Para los que nunca hayan escuchado hablar de ello, JUnit es un
framework muy conocido para hacer pruebas de código.

Antes de empezar, detallaremos las etiquetas y métodos más importantes que

usaremos para construir nuestros test de pruebas.

TAG DESCRIPCIÓN

@Test Identifica un método como un método test.

@Before Indica qué se ejecuta antes de cada test. Se usa para preparar el
entorno del test antes de ejecutarlo.

@After Indica qué se ejecutará después de cada test. Se usa para limpiar
el entorno después de la ejecución de cada test.

@BeforeClass Se ejecuta solo una vez, antes de que se ejecuten todos los test.
Se usa, por ejemplo, para conectar la base de datos.

@AfterClass Se ejecuta solo una vez después de ejecutar todos los test. Se usa
para limpiar el entorno.

@Ignore or Marca ese test como deshabilitado.

@Ignore (“why
disabled”)

@Rule Establece una regla, añade funcionalidades extra a nuestro test.

Tabla 9. Relación de etiquetas más usadas para los test con JUnit.

MÉTODO DESCRIPCIÓN

fail([message]) Se usa para hacer que el método falle y descubrir qué

partes del código no se contemplan. Se suele hacer
antes de desarrollar. El parámetro message es
opcional.

63
 Acceso de datos

assertTrue([message,]boolean Comprueba si la condición es true.

condition)

assertFalse([message,]boolean Comprueba si la condición es false.

condition)

assertFalse([message,]boolean Hace test de dos valores para comprobar si son el

condition) mismo.

assertEquals([message,] Comprueba si un float o double son iguales.

expected,actual, tolerance)

assertNull([message,] object) Comprueba si un objeto es null.

assertNotNull([message,] Comprueba si el objeto no es null.

object)

assertSame([message,] Comprueba si las dos variables hacen referencia al

expected, actual) mismo objeto.

assertNotSame([message,] Comprueba si las dos variables no hacen referencia

expected, actual) al mismo objeto.
Tabla 10. Relación de métodos más importantes para la ejecución de JUnit.

64
 Acceso de datos

Para poder realizar los ejemplos y las prácticas, deberemos preparar Eclipse para que
podamos desarrollar los test.

En primer lugar, nos dirigiremos a la siguiente web para descargar la librería de JUnit:

https://mvnrepository.com/artifact/org.junit/junit5-api/5.0.0-ALPHA

Después debemos añadir esta librería a nuestro proyecto en Eclipse. Si no tenéis ningún
proyecto creado, os aconsejo que os descarguéis el proyecto con los ejemplos de este
tema. Os será útil para realizar la práctica (el enlace está al principio del tema 1).

Para ello, tenemos que dar botón derecho al proyecto e ir a Properties. A continuación,
dirigirnos a Java Build Path y a librerías, tal y como se muestra en la imagen.

Ilustración 13. Captura con las instrucciones para añadir la librería de JUnit.

65