1 / 40

Unidad 1. Manejo de ficheros

Unidad 1. Manejo de ficheros. 1.1. Introducción. 1.2. Clases asociadas a las operaciones de gestión de ficheros. 1.3.Flujos o streams . Tipos. 1.4. Formas de acceso a un fichero. 1.5. Operaciones sobre ficheros. 1.6. Clases para gestión de flujos de datos desde/hacia ficheros.

dolph
Download Presentation

Unidad 1. Manejo de ficheros

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Unidad 1.Manejo de ficheros 1.1. Introducción. 1.2. Clases asociadas a las operaciones de gestión de ficheros. 1.3.Flujos o streams. Tipos. 1.4. Formas de acceso a un fichero. 1.5. Operaciones sobre ficheros. 1.6. Clases para gestión de flujos de datos desde/hacia ficheros. 1.7. Trabajo con ficheros XML. 1.8. Excepciones y tratamiento

  2. 1.1 Introducción • Fichero. Conjunto de datos almacenados en un dispositivo (DD, pen drive...) • Los datos almacenados en ficheros son no volátiles. • Los ficheros dentro de una carpeta tienen nombre único y su extensión identifica el tipo de archivo (pdf, doc, htm, gif...) • Un fichero está formado por líneas, registros (campos),...

  3. 1.2 Clases asociadas a las operaciones de gestión de ficheros Esto mostraría la lista de ficheros del directorio d:\db Clase File. Proporciona utilidades relacionadas con los ficheros,: información sobre nombre, atributos, directorios, etc. File(Stringdirectorioyfichero): newFile(“C:\\directorio\\fichero.txt”) File fichero1 = new File(“C:\\EJERCICIOS\\UNI1\\ejemplo1.txt”); File(String directorio, Stringnombrefichero): new File(“directorio”, “fichero.txt”) String directorio= “C:\\EJERCICIOS\\UNI1”; File fichero2 = new File(directorio, “ejemplo2.txt”); Ejemplo. Muestra la lista de ficheros del directorio actual import java io.*; publicclassVerDir { publicstaticvoidmain(String[] args) { System.out.println(“Ficheros en el directorio actual:”); File f = new File(“.”); - - - - - - - - -- - -- - - -- - - - -File f = new File(“d:\\db”); String[] archivos = f.list(); for (int i = 0; i < archivos.lenght; i++) { System.out.println(archivos[i]); } } }

  4. 1.2 Clases asociadas a las operaciones de gestión de ficheros Algunos de los métodos más importantes de la clase File son los siguientes: • length() • createNewFile() • delete() • exists() • getParent() • isDirectory() • isFile() • mkDir() • renameTo(Filenuevonombre) • getName() • getPath() • getAbsolutePath() • canRead() • canWrite()

  5. 1.2 Clases asociadas a las operaciones de gestión de ficheros Ejemplo. Mostrar información sobre el fichero VerInfo.java: import java io.*; publicclassVerInf { publicstaticvoidmain(String[] args) { System.out.println(“Infromación sobre el fichero:”); File f = new File(“VerInf.java”); if (f.exists(){ System.out.println(“Nombre del fichero: “+f.getName()); System.out.println(“Ruta : “+f.getPath()); System.out.println(“Se puede escribir : “+f.canWrite()); System.out.println(“Tamaño : “+f.length()); System.out.println(“Es un directorio : “+f.isDirectory()); System.out.println(“Es un fichero : “+f.isFile()); } } }

  6. 1.2 Clases asociadas a las operaciones de gestión de ficheros Ejemplo. Crear un nuevo directorio con dos ficheros vacíos y renombrar uno de ellos. import java io.*; publicclassCreaDir { publicstaticvoidmain(String[] args) { File d = new File(“NUEVODIR”); d.mkdir(); File f1 = newFile(d, “Fichero1.txt”); File f2 = newFile(d, “Fichero2.txt”); try { if (f1.createNewfile()) System.out.println(“Fichero1 creado correctamente”); else System.out.println(“No se puede crear Fichero1.txt”); if (f2.createNewfile()) System.out.println(“Fichero2 creado correctamente”); else System.out.println(“No se ha puede crear Fichero2.txt”); }catch (IOExceptionioe) {ioe.printStackTrace();} f1.renameTo(new File(d, “Fichero1Nuevo.txt”)); } }

  7. 1.3 Flujos o streams. Tipos • El paquete java.io contiene muchas clases que implementan el sistema de entrada/salida. • La abstracción del flujo (stream) trata la comunicación de datos entre una fuente y destino: disco duro, memoria, sitio de red, etc. • Cualquier programa que requiera enviar/recibir datos de otra fuente necesita abrir un stream. • La vinculación del stream al dispositivo físico la hace el sistema de entrada/salida de Java. Tipos de flujos al sistema de entrada/salida: • Flujo de bytes (8 bits). Operaciones de E/S de bytes; orientado la L/E de datos binarios. Clases InputStream y OutputStream. Cada una de estas clases tiene subclases que controlan las diferencias entre los distintos dispositivos de E/S que se pueden utilizar. • Flujo de caracteres (16 bits). Operaciones de E/S de caracteres. Clases Reader y Writer.

  8. 1.3 Flujos o streams. Tipos • ByteArrayInputStream • StringBufferInputStream • FileInputStream. • PidedInputStream. • FilterInputStream. • SequenceInputStream. • La clase OutputStreamincluye las clases que deciden donde irá la salida: un array de bytes, un fichero o una “tubería”. Los tipos de InputStream son: • ByteArrayOutputStream • FileOutputStream. • PidedOutputStream. • FilterOutputStream. 1.3.1 Flujos de bytes (Byte streams) • La clase InputStreamrepresenta las clases que producen entradas de fuentes tales como un array de bytes, un objeto String, un fichero, etc. Los tipos de InputStream son:

  9. 1.3 Flujos o streams. Tipos • Clases de flujos de bytes • InputStream • OutputStream • FileInputStream • FileOutputStream • StringBufferInputStream • (sin clase correspondinte) • ByteArrayInputStream • ByteArrayOutputStream • PidedInputStream • PidedOutputStream Clase correspondiente de flujo de caracteres ReaderWriter FileReader FileWriter Stringreader Stringwriter CharArrayReader CharArrayWriter PidedReader PidedWriter 1.3.2. Flujos de caracteres (Characterstreams) • Las clases Reader y Writermanejan flujos de caracteres Unicode. Hay situaciones en que hay que usar clases que manejan bytes combinadas con clases que utilizan caracteres. • En esos casos se utilizan clases “puente” que convierten los streams de bytes a streams de caracteres. • InputStreanReaderconvierte un InputStream en un Reader y OutputStreamReader convierte un OutputStream en un Writer.

  10. 1.3 Flujos o streams. Tipos 1.4 Formas de acceso a un fichero • Acceso secuencial. Los datos se leen y escriben en el mismo orden en que están almacenados. Para acceder al registro N hay que acceder primero a los (N-1) anteriores. • Acceso directo o aleatorio. Permite acceder a un registro en cualquier orden sin necesidad de leer los anteriores. • El acceso secuencial en ficheros más común en Java puede ser binario o de caracteres. Las clases de flujos de caracteres más importantes son: • FileReader y FilerWriter lectura y escritura de caracteres en ficheros. • CharArrayReadery CharArrayWriter para leer y escribir un flujo de caracteres en un array de caracteres. • BufferedReadery BufferedWriter para evitar que cada operación de lectura o escritura acceda directamente al fichero.

  11. 1.5 Operaciones sobre ficheros Flujos o streams. Tipos Operaciones básicas sobre un fichero sea cual asea su forma de acceso: • Creación del fichero. • Apertura del fichero. • Cierre del fichero. • Lectura de los datos del fichero. • Escritura de datos en el fichero. Operaciones sobre un fichero una vez abierto: • Altas. • Bajas. El borrado consiste en reescribir. • Modificaciones. • Consultas.

  12. 1.5 Operaciones sobre ficheros Flujos o streams. Tipos 1.5.2. Operaciones sobre ficheros secuenciales • Altas. Se realizan al final del último registro insertado. • Bajas. Hay que leer y escribir en un fichero auxiliar todos los registros excepto el que se quiere borrar. Después borrar el fichero original y renombrar el auxiliar con el nombre del original. • Modificaciones. Proceso similar al de las bajas. • Consultas. Para consultar el registro N, hay que leer los (N-1) registros anteriores. Los ficheros secuenciales se utilizan en: • Procesos por lotes. • Copias de respaldo (backup). Ventajas. Rápido acceso al registro siguiente y aprovechamiento del espacio en disco. Desventajas. Lectura de pocos registros y las actualizaciones.

  13. 1.6 Clases para gestión de flujos de datos desde/hacia ficheros 1.6.1. Ficheros de texto • Utilizaremos la clase FileReaderpara leer caracteres y FileWriter para escribir caracteres en un fichero. • Al trabajar con operaciones de L/E en ficheros se hará dentro de un manejador de excepciones try-catch. • Métodos de la clase FileReader para lectura. • intread() • intread(char[] buf) • intread(char[] buf, int desplazamiento, int n)) Para crear o abrir un fichero en Java, se invoca a la clase File y se crea el flujo de entrada hacia el fichero con la clase FileReader. Después se realizan las operaciones de L/E y se cierra el fichero con el método close().

  14. 1.6 Clases para gestión de flujos de datos desde/hacia ficheros 1.6.1. Ficheros de texto Ejemplo: Programa que lee los caracteres de un fichero de texto y los muestra por pantalla. import java.io.*; publicclassLeeFichTexto { publicstaticvoidmain (String[] args) throwsIOException { //declarar fichero File fichero = newFile(“C:\\Micarpeta\\LeerFichTexto.java”); FileReaderfic = newFileReader(fichero); // crear el flujo de entrada inti; while ((i = fic.read()) != -1) // se va leyendo un carácter System.out.println((char) i); fic.close(); // cerrar fichero } }

  15. 1.6 Clases para gestión de flujos de datos desde/hacia ficheros 1.6.1. Ficheros de texto Los métodos que proporciona la clase FileWriter para escritura son: • voidwrite(int c) • voidwrite(char[] buf) Escribe un array de caracteres • voidwrite(char[] buf, int desplazamiento, int n) • voidwrite(Stringstr) • append(char c) El siguiente ejemplo escribe caracteres en un fichero de nombre FichTexto.txt (si no lo crea). Los caracteres se obtienen uno a uno y se obtienen de un String. import java.io.*; publicclassEscribirFichTexto { publicstaticvoidmain (String[] args) throwIOExceptions { File fichero = newFile(“C:\\Micarpeta\\FichTexto.txt”); FileWriterfic = newFileWriter(fichero); // crear el flujo de salida Stringcadena = “Esto es una prueba de FileWriter”; char{[] cad = cadena.toCharArray(); //convierte un String a un array de caracteres. for (inti=0; i<cad.length; i++) fic.write(cad[i]); //se va escribiendo un carácter fic.append(‘*’); //añadimos al final un * fic.close(); // cerramos el fichero } }

  16. 1.6 Clases para gestión de flujos de datos desde/hacia ficheros 1.6.1. Ficheros de texto Ejemplo String pueblo[] = {“Catarroja”, “Albal”, “Silla”, “Masanassa”, “Benetusser”}; for (int i=0; i<pueblo.lenght; i++) fic.write(pueblo[i]); FileReader no contiene métodos para leer líneas completas. BufferedReader si. Ejemplo: Lee un fichero de texto por la línea y visualizarlo por pantalla. import java.io.*; publicclassLeerFichTextoBuf { publicstaticvoidmain (String[] args) throwIOExceptions { try BufferReader fichero = newBuffereReader (new FileReader(“LeerFichTexto.java”)); Stringlinea; while(linea=fichero.readLine())|=null) // lee una línea del fichero System.out.println(linea); fichero.close(); } catch (FileNotFoundExceptionfn) { System.out.println(l”No se encuentra el fichero”);} catch (IOExceptionio) { System.out.println(l”Error de E/S”);} }

  17. 1.6 Clases para gestión de flujos de datos desde/hacia ficheros 1.6.1. Ficheros de texto La clase PrintWriter que también deriva de Writer, posee los métodos print(String) y println(String) para escribir en un fichero. Para construir un PrintWriter necesitamos la clase FileWriter PrintWriter fichero = new PrintWriter(new Writer(NomFich)) El ejemplo anterior utilizando la clase PrintWriter y el método println() quedaría: PrintWriter fichero = new PrintWriter(new FileWriter(NomFich)) for (inti=1; 1<11; i++) fichero.println(“Fila número: “+i); fichero.close();

  18. 1.6 Clases para gestión de flujos de datos desde/hacia ficheros 1.6.2. Ficheros binarios Se trata de ficheros que almacenan secuencias de dígitos binarios que no son legibles por el usuario. Ocupan menos espacio en disco. Las clases de Java que trabajan con ficheros binarios son FileInputStream y FileOutputStream. Métodos de la clase FileInputStream. • intread() Lee un byte y lo devuelve • intread(byte[] b) Lee hasta b.lenght bytes de datos de una matriz de bytes • intread(byte[] b, int desplazamiento, int n) lee hasta n bytes de la matriz b comenzando por b[desplazamiento] y devuelve el número de bytes leídos. Métodos de la clase FileOutputStream. • voidwrite(int b) • voidwrite(byte[] b) • voidwrite(byte[] b, int desplazamiento, int n)

  19. 1.6 Clases para gestión de flujos de datos desde/hacia ficheros 1.6.2. Ficheros binarios El siguiente ejemplo escribe bytes en un fichero y después los visualiza. import java.io.*; publicclassEscribeFichBytes { publicstaticvoidmain (String[] args) throwIOExceptions { File fichero = new File(“C:\MiCarpeta\\FcihBytes.dat”); //crea flujo de salida hacia elfichero FileOutputStreamfileout = newFileOutputStream(fichero); //crea flujo de entrada FileInputStreamfilein= newFileInputStream(fichero); int i; for (i=1; i<100; i++) fileout.write(i); //escribe datos en el flujo de salida fileout.close(); // cerrar stream de salida //visualizar los datos del fichero while ((i=filein.read()) != -1) //lee dato del flujo de entrada System.out.println(i); filein.close(); //cerrar stream de entrada } }

  20. 1.6 Clases para gestión de flujos de datos desde/hacia ficheros Objetos serializables ¿Cómo guardamos un objeto de tipo empleado con atributos (dni, nombre, tfno,...)? Java permite guardar objetos en fichero binarios. Para eso el objeto debe implementar la interfaz serializable que dispone de una serie de métodos con los que podremos guardar y leer objetos en ficheros binarios: • voidreadObject(java.io.ObjectInputStreamstream) throwsIOException, ClassNotFoundException: para leer un objeto. • voidwriteObject(java.io.ObjectOutputStreamstream) throwsIOException, ClassNotFoundException: para escribir un objeto. La serialización de objetos de Java permite tomar cualquier objeto que implemente la interfaz Serializable y convertirlo en una secuencia de bits. Para leer/escribir objetos serializables a un stream se utilizan las clases Java ObjectInputStream y ObjectOutputStream.

  21. 1.6 Clases para gestión de flujos de datos desde/hacia ficheros Objetos serializables Ejemplo: Clase Persona que implementa la interfaz Serializable y que utilizaremos para escribir y leer objetos en un fichero binario. importjava.io.Serializable; publicclassPersona implementsSerializable { privateString nombre; privateint edad; publicPersona (String nombre, int edad) { this.nombre=nombre; this.edad=edad; } publicPersona() { this.nombre=null; } publicvoidsetNombre(Stringnom) {nombre=nom} publicvoidsetEdad(inted) {edad=nom;} publicStringgetNombre() {return nombre;} //devuelve nombre publicintgetEdad() {return edad;} //devuelve edad } //fin persona

  22. 1.6 Clases para gestión de flujos de datos desde/hacia ficheros Objetos serializables Ejemplo: Escribir objetos Persona en un fichero import java.io; publicclassEscribirFichObject { publicstaticvoidmain (String[] args) throwsIOException { Persona persona; //defino variable persona //declaro el fichero File fichero = newFile(“C:\\MiCarpeta\\FichPersona.dat”); FileOutputStreamfileout = newFileOutputStream (fichero); //salida //conecta el flujo de bytes al flujo de datos ObjectOutputStreamdatOS = newObjectOutputStream(fileout); String nombres[] = {“Pepe”, “Juan”, “Ana”, “Eva”, Luis”}; int edades[] = {18, 20, 19, 20, 18}; for (inti=0; i<edades.length; i++) { //recorro los arrays persona = new Persona(nombres[i], edades[i]); //creo la persona datOS.writeObject(persona); //escribo la persona en el fichero } datOS.close(); //cerrar stream de salida } }

  23. 1.6 Clases para gestión de flujos de datos desde/hacia ficheros Objetos serializables Ejemplo: Leer objetos Persona de un fichero import java.io; publicclassLeerFichObject { publicstaticvoidmain (String[] args) throwsIOException, ClassNotFoundException { Persona persona; //defino variable persona File fichero = newFile(“C:\\MiCarpeta\\FichPersona.dat”); FileInputStreamfilein = newFileInputStream (fichero); //entrada //conecta el flujo de bytes al flujo de datos ObjectInputStreamdatIS = newObjectInputStream(filein); try { while (true) { //lectura del fichero persona = (Persona) dataqIS.readObject(); //leer una persona System.out.println(“Nombre: “ + persona.getNombre() + “, edad: “ + persona.getEdad()); } }catch (EOFExceptioneo) {} datIS.close(); //cerrar stream de entrada } }

  24. 1.6 Clases para gestión de flujos de datos desde/hacia ficheros 1.6.3. Ficheros de acceso aleatorio La clase de Java RandomAccessFile dispone de métodos para acceder a ficheros binarios de manera aleatoria. Hay dos formas de crear ficheros de acceso aleatorio: • Escribiendo el nombre del fichero fichero = new RandomAccessFile(String nombre, StringmodoAcceso); • Con un objeto File fichero = new RandomAccessFile(Filefich, StringmodoAcceso); El argumento modoAcceso puede ser r para lectura o rwpara lectura-escritura Una vez abierto el fichero utilizaremos los métodos read() y write() de las clases DataInputStream y DataOutpuStream para leer y escribir Otros métodos importantes: longgetFilePointer() longlength() voidseek(longposicion) intskipBytes(int desplazamiento)

  25. 1.6 Clases para gestión de flujos de datos desde/hacia ficheros 1.6.3. Ficheros de acceso aleatorio importjava.io.*; publicclassEscribirFichAleatorio{ publicstaticvoidmain (String[] args) throwsIOException { File fichero = new File(“C:\\MiCarpeta\\AleatorioEmple.dat”); RandomAccessFile file = newRandomAccessFile(fichero, “rw”); //arrays con los datos Si donde ponemos “rw” es escritura Stringnombre[] = {“Pepe”, “Juan”, “Ana”, “Eva”, Luis”}; intdep[] = {10, 20, 10, 10, 30}; Doublesalario[]={1000, 1200, 1300, 1000, 1200}; StringBuffer buffer = null //buffer para almacenar nombre int n=nombre.length // nº de elementos del array for(inti=0; i<n; i++) { //recorro los arrays file.writeInt(i+1);/ // buffer=new StringBuffer(nombre[i]); buffer.setLength(10);// 10 caracteres para el nombre file.writeInt(dep[i]); file.writeDouble(salario[i]); } file.close(); //cerrar fichero } }

  26. 1.6 Clases para gestión de flujos de datos desde/hacia ficheros 1.6.3. Ficheros de acceso aleatorio import java.io; publicclassLeerFichAleatorio{ publicstaticvoidmain (String[] args) throwsIOException { File fichero = new File(“C:\\MiCarpeta\\AleatorioEmple.dat”); RandomAccessFile file = newRandomAccessFile(fichero, “r”); int id, dep, posicion; Double salario; charnombre[] = new char[10], aux for (;;){ //recorro el fichero con un bucle mientras qeuden datos en el fichero. file.seek(posicion); id=file.readInt(); for (int i=0; i<nombre.length;i++ { aux=file.readChar()//recorre uno de los caract. del nombre nombre[i]=aux; } StringnombreS=new String(nombre)//convierto a String el array dep=file.readInt(); salario=file.readDouble() Sistem.out.println(“ID: “ + id +”, nombre: “+ nombreS + “, Departamento: “:+dep + “, salario: “ + salario); posicion= posicion + 36 // me posiciono el el sig. Empleado ya que cada uno utiliza 36 bytes } file.close(); //cerrar fichero } }

  27. 1.6 Clases para gestión de flujos de datos desde/hacia ficheros 1.6.3. Ficheros de acceso aleatorio Sistem.out.println(“ID: “ + id +”, nombre: “+ nombreS + “, Departamento: “:+dep + “, salario: “ + salario); posicion= posicion + 36 // me posiciono el el sig. Empleado ya que cada uno utiliza 36 bytes (4 + 20 + 4 + 8) //Si he recorrido todos los bytes salgo del for if (file.getFilePointer()==file.legth()) break; } //del del bucle for file.close(); //cerrar fichero } }

  28. 1.7 Trabajo con fichero XML Qué es XML... • Metalenguaje para definir lenguajes de marcado. • Fichero de texto; información organizada secuencialmente y en orden jerárquico. • Jerarquía de la información y contenidos dentro del propio documento. Un fichero XML se utiliza para... • Proporcionar datos a una BD o almacenar copias de partes de la BD. • Escribir ficheros de configuración de programas o en el protocolo SOAP, para ejecutar comandos en servidores remotos. El contenido de un fichero XML se lee con un parser. Los más utilizados son DOM (Modelo de Objetos de Documento) y SAX (API simple para XML). Son independientes del lenguaje de programación y existen versiones para Java, Visual Basic, C,...

  29. 1.7 Trabajo con fichero XML DOM Almacena toda la estructura del documento en memoria en forma de árbol. Requiere más memoria si los ficheros XML son grandes y complejos. SAX Lee el fichero XML de forma secuencial y genera una secuencia de eventos en función de los resultados de la lectura. Cada evento invoca un método definido por el programador. Consume menos memoria.

  30. 1.7 Trabajo con fichero XML 1.7.1. Acceso a ficheros XML con DOM • Para trabajar con DOM en Java necesitamos el paquete org.w3c.dom y el paquete java.xml.parsersdel API estándar de Java. • Las clases de java.xml.parsersofrecen métodos para cargar documentos desde una fuente de datos (fichero, InpuStream,..). Destacan dos clases: DocumentBuilderFactory y DocumentBuilder. • Para generar un fichero XML a partir de un árbol DOM necesitamos el paquete java.xml.transform, que permite especificar una fuente y un resultado. • La fuente y el resultado pueden ser ficheros, flujos de datos o nodos DOM.

  31. 1.7 Trabajo con fichero XML 1.7.1. Acceso a ficheros XML con DOM Interfaces que necesitan los programas Java que utilicen DOM: • Document. Objeto que equivale a un ejemplar de un documento XML. • Element. Expone propiedades y métodos para manipular los elementos del documento y sus atributos. • Node. Representa a cualquier nodo del documento. • NodeList. Contiene una lista con los nodos hijos d un nodo. • Attr. Permite acceder a los atributos de un nodo. • Text. Son los datos carácter de un elemento. • CharacterData. Proporciona atributos y métodos para manipular los datos de caracteres. • DocumentType. Proporciona información contenida en la etiqueta <!DOCTYPE>. Ejemplo pág. 26.

  32. 1.7 Trabajo con fichero XML 1.7.2. Acceso a ficheros XML con SAX SAX (API Simple para XML) es un conjunto de clases e interfaces que ofrecen una herramienta muy útil para el procesamiento de documentos XML. • Permite analizar los documentos de forma secuencial (bajo consumo de memoria). • Es un API escrito en Java, incluido dentro de JRE. Esto permite crear un parser de XML propio. • La lectura de un documento XML produce eventos que ocasionan la llamada a métodos : startDocument(), endDocument(), starElement() endElement(), (characters()), etc. En el ejemplo la clase se llama GestionContenido y se tratan los eventos básicos. (págs. 31-33) • startDocument: se produce al comenzar el procesado del documento XML. • endDocument: se produce al finalizar el procesado del documento XML. • startElement: se produce al comenzar el procesado de una etiqueta XML. • endElement: se produce al finalizar el procesado de una etiqueta XML. • characters: se produce al encontrar una cadena de texto.

  33. 1.7 Trabajo con fichero XML importorg.xml.sax.Attributes; importorg.xml.sax.InputSource; importorg.xml.sax.SaxExceptions; importorg.xml.sax.XMLReader; importorg.xml.sax.DefaultHandler; importorg.xml.sax.XMLReaderFactory; Clases en interfaces de SAX para hacer que se puedan tratar los eventos. 1.7.2. Acceso a ficheros XML con SAX A continuación hay que indicar al XMLReader qué objetos poseen los métodos que tratarán los eventos: Esos objetos serán implementaciones de las siguientes interfaces: • ContentHandler: recibe notificaciones de los eventos que ocurren en el documento. • DTDHandler. Recoge eventos relacionados con la DTD. • ErrorHandler: define métodos de tratamiento de errores. • EntityResolver: sus métodos se llaman cada vez que se encuentra una referencia a una entidad. • DefaultHandler: clase que provee una implementación por defecto para todos sus métodos. De esta clase se harán las extensiones para crear el parser de XML.

  34. 1.7 Trabajo con fichero XML 1.7.2. Acceso a ficheros XML con SAX publicclassPruebaSax1 { publicstaticvoidmain (String[] args) throwsFileNotFoundException, IOException, SAXException { XMLReaderprocesadorXML = XMLReaderFactory.createXMLReader(); GestionContenido gestor = newGestionContenido(); procesadorXML.setContentHandler(gestor); InputSourcefileXML = new InputSource(“alumnos.xml”); procesadorXML.parse(fileXML); } }// fin pruebaSax1

  35. 1.7 Trabajo con fichero XML 1.7.2. Acceso a ficheros XML con SAX classGestionContenidoextendsDefaultHandler { publicGestionContenido() {super();} publicvoidstartDocument(){ System.out.println(“Comienzo del documento XML”); } publicvoidendDocument(){ System.out.println(“Fin del documento XML”); } publicvoidstartElement(Stringuri, String nombre, StringnombreC, Attributesatts){ System.out.println(“\tFin Elemento: “ + nombre); } publicvoidendElement(Stringuri, String nombre, StringnombreC){ System.out.println(“tFin Elemento: “ + nombre); } publicvoidcharacters(char[] ch, int inicio, int longitud) throwsSAXException { String car = new String(ch, inicio, longitud); car = car.replaceAll(“[\t\n]”,””); //quitar saltos de línea System.out.println(“\tCaracteres: “ + car); } }// fin GestionContenido

  36. 1.7 Trabajo con fichero XML 1.7.3. Serialización de objetos a XML Veremos como serializar objetos Java a XML y viceversa utilizando la librería Xstream. • Hay que descargar los JAR de www.xstream.codehaus.org/download.html. En este caso, el fichero xtream-distribution-1.4.2-bin.zipde donde hay que buscar el JAR xstream-1.4.2.jarque está en la carpeta lib. También necesitamos el archivo kxml2-2.3.0.jar que se puede descargar desde el apartado OptionalDependencies. • Hay que definir los dos ficheros en el CLASSPATH. Partiendo de FichPersona.dat, crearemos una lista de objetos Persona y la convertiremos en un fichero de datos XML. importjava.util.ArrayList; importjava.util.List; publicclassListaPersonas { privateList<Persona> lista = new ArrayList<Persona>(); privateListaPersonas() { } publicvoidadd(Persona per) { lista.add(per); } publicList>Persona> getListaPersonas() { return lista; } }

  37. 1.7 Trabajo con fichero XML 1.7.4. Conversión de ficheros XML a otro formato Mediante el lenguaje Java se puede generar un fichero HTML a partir de un fichero XML que contiene datos y otro XSL que contiene la presentación de esos datos. import org.w3c.dom.*; importjavax.xml.parsers.*; importjavax.xml.transform.*; importjavax.xml.transform.dom.*; importjavax.xml.transform.dom.*; importjavax.io.*; publica class convertidor { publicstaticvoidmain (Stringargv[]) throwsIOException { StringhojaEstilo = “alumnosPlantilla.xsl”; StringdatosAlumnos = “alumnos.xml”; File pagHTML = new File(“mipagina.html”) FileOutputStream os = new FileOutputStream(pagHTML); Source estilos = new StreamSource(hojaEstilo); // fuente XSL Source datos = new StreamSource(datosAlumnos); // fuente XML Resultresult= new StreamResult(os); try { Transformertransformer = TransformerFactory.newInstance().newTransformer(estilos); transformer.transform(datos, result); } //obtiene el HTML catch (Exception e) {System.err.println(“Error: “+e);} os.close(); }}

  38. 1.8 Excepciones: Detección y Tratamiento • Una excepción es un evento que ocurre durante la ejecución del programa que interrumpe el flujo normal de las sentencias. • Cuando no es capturada por el programa, se captura por el gestor de excepciones por defecto que retorna un mensaje y detiene el programa. • Cuando se produce un error por una excepción dentro de un método Java, el método crea un objeto Exception. • El manejo de excepciones en Java está pensado para situaciones en las que el método que detecta un error no es capaz de manejarlo. • Las excepciones en Java son objetos de clases derivadas de la clase base Exception que a su vez es una clase derivada de la clase Throwable.

  39. 1.8 Excepciones: Detección y Tratamiento 1.8.1. Capturar excepciones • Para capturar una excepción se utiliza el bloque try-catch. Se encierra en un bloque try el código que puede generar una excepción; este bloque va seguido por uno o más bloques catch. • Cada bloque catch especifica el tipo de excepción que puede atrapar y contiene un manejador de excepciones . • Después del último bloque catch puede aparecer un bloque finally, que siempre se ejecuta haya ocurrido o no una excepción. try { //Código que puede generar excepciones } catch (excepcion1 e1) { //manejo de la excepción1 } //Código que puede generar excepciones } catch (excepcion1 e2) { //manejo de la excepción2 } // etc... finally { // Se ejecuta después de try o catch }

  40. 1.8 Excepciones: Detección y Tratamiento 1.8.2. Especificar excepciones • Para especificar excepciones utilizamos throws, seguida de la lista de los tipos de excepciones potenciales. • Si un método decide no gestionar una excepción (mediante try-catch), debe especificar que puede lanzar esa excepción. publicstaticvoidmain(String[] args) throwsOexception, ClassNotFoundException { En la línea anterior, el método main() puede lanzar las excepciones IOException y ClassNotFoundException.

More Related