Aplicaciones software avanzadas con Java™ Germán Bordel(CD4 P1.6) german.bordel@ehu.es Mikel Peñagarikano (CD4 P1.5) mikel.penagarikano@ehu.es

Práctica (caso de uso): Requisitos: Conocimiento del lenguaje de programación Java™ Objetivo: Desarrollo de Aplicaciones Web basadas en Data Mining, XML y Bases de Datos. Práctica (caso de uso): Presentación dinámica en una web de información relativa a las cotizaciones del Nasdaq

Material bibliográfico The Java™ Tutorials http://docs.oracle.com/javase/tutorial Java™ Platform, Standard Edition 7 API Specification http://docs.oracle.com/javase/7/docs/api

Temario IDE: El entorno de desarrollo integrado NetBeans + JDK La bolsa. Cotizaciones del Nasdaq Descarga de contenido web Expresiones Regulares Extracción de cotizaciones Estructuras de datos Diseño de estructuras para almacenar cotizaciones XML como representación de la información Cotizaciones en formato XML

Temario II Procesamiento (parsing) de XML Servidores Web Instanciación de objetos desde XML Servidores Web Instalación de un servidor de aplicaciones Aplicaciones web: JSPs Servicio dinámico de información de cotizaciones Nasdaq Bases de Datos: MySQL Almacenamiento de cotizaciones en una Base de Datos Consulta web a una base de datos

IDE: Entorno de desarrollo integrado IDE: Integrated Development Environment Editor + compilador/intérprete + depurador

NetBeans: http://netbeans.org

JDK: Java Development Kit http://www.oracle.com/technetwork/java/javase/downloads Podemos instalar ambos a la vez

La bolsa. Cotizaciones del Nasdaq Bolsa de Valores (es.wikipedia.org): organización privada que brinda las facilidades necesarias para que sus miembros, atendiendo los mandatos de sus clientes, introduzcan órdenes y realicen negociaciones de compra y venta de valores. acciones de sociedades o compañías anónimas, bonos públicos y privados Certificados títulos de participación ... NASDAQ (National Association of Securities Dealers Automated Quotation): la bolsa de valores electrónica y automatizada más grande de los Estados Unidos

La bolsa. Cotizaciones del Nasdaq Bolsa de Valores (es.wikipedia.org): organización privada que brinda las facilidades necesarias para que sus miembros, atendiendo los mandatos de sus clientes, introduzcan órdenes y realicen negociaciones de compra y venta de valores. acciones de sociedades o compañías anónimas, bonos públicos y privados Certificados títulos de participación ... NASDAQ (National Association of Securities Dealers Automated Quotation): la bolsa de valores electrónica y automatizada más grande de los Estados Unidos http://www.nasdaq.com/

http://charting. nasdaq. com/ext/charts. dll http://charting.nasdaq.com/ext/charts.dll?2-1-14-0-0-512-03NA000000GOOG-&SF:6|5-WD=530-HT=395--XTBL-

Aplicación Java Compuesta por Clases (estructuras) Campos (variables) Métodos (funciones) Al instanciar una clase, creamos un nuevo objeto Los campos y métodos pueden ser Propios de cada instancia/objeto Estáticos (compartidos por todas las instancias) Herencia Si una clase extiende a otra, hereda todos sus componentes Si no extiende nada, extiende Object Los componentes heredados pueden ser sobreescritos Las clases se agrupan en paquetes (librerías) Java API: conjunto de paquetes preexistentes

Proyecto de Netbeans Permite agrupar clases en un conjunto de paquetes Gestión de clases y paquetes Generación de código fuente (esqueletos) Gestión de plataforma Java (JVM) Gestión de versión del código fuente (JDK 7) Gestión de la clase principal (aplicación) comentarios declaración de paquete declaración de clase declaración de método

¡Hola Mundo! Programa mínimo Ejecutar una aplicación (F6) Para poder utilizar una clase, debemos importarla (indicar a qué paquete pertenece), excepto: java.lang.* System == java.lang.System System.out Objeto de tipo PrintStream Contiene el método void println(String x) Muestra una cadena por la salida estándar Ejecutar una aplicación (F6) Se ejecuta el método main(String[] args) de la clase declarada como principal (prueba.Main)

I/O Streams (java.io) Clases que representan Flujos de entrada/salida de datos Permiten conectar nuestra aplicación a Dispositivos de entrada/salida Ficheros Aplicaciones remotas (sockets) Estructuras de datos Conjunto básico de Streams InputStream/OutputStream: lectura/escritura a nivel de byte BufferedInputStream /BufferedOutputStream : añade buffering BufferedReader: lectura de caracteres con buffering (String readLine()) PrintWriter: escritura con formato (void println(…))

Descarga de contenido web La clase URL (java.net.URL) permite crear una URL a partir de su descripción textual (p. ej. , http://www.ehu.es). El método openStream() devuelve un InputStream, de donde poder leer el contenido web (lectura de bytes). Con el InputStream podemos crear un InputStreamReader (lectura a nivel de caracteres). A partir del InputStreamReader podemos crear un BufferedReader (lectura por líneas)

Descarga de contenido web II Ciertos métodos pueden generar Excepciones Podemos Atenderlas o Declararlas Las excepciones son también clases  importarlas Debemos cerrar todos los Streams abiertos “try with resources” (jdk 1.7) readLine() devuelve null cuando ya no hay más datos

package prueba; import java. io. BufferedReader; import java. io package prueba; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.MalformedURLException; import java.net.URL; public class Main { public static void main(String[] args) throws MalformedURLException, IOException { System.out.println(getHTML("http://www.ehu.es")); } public static String getHTML(String url) throws MalformedURLException, IOException{ StringBuilder sb = new StringBuilder(); try ( BufferedReader in = new BufferedReader( new InputStreamReader( new URL(url).openStream())); ){ String s; while ((s = in.readLine()) != null) sb.append(s).append('\n'); return sb.toString();

Expresiones Regulares - Clases Java.lang.String matches(String regex) replaceAll(String regex, String replacement) replaceFirst(String regex, String replacement) split(String regex) java.util.regex.Pattern Pattern.compile(String regex) java.util.regex.Matcher pattern.matcher(CharSequence input)

Expresiones Regulares - Ejemplos Representa un conjunto de cadenas mediante un patrón “hola*” representa a “hol”, “hola”, “holaa”, “holaaa”,… “co*sa” representa a “csa”, “cosa”, “coosa”, “cooosa”,… “hola|adiós” representa únicamente a “hola” y “adios” “(p|m)adre” representa únicamente a “padre” y “madre” “.*” representa a todas la posibles cadenas Existe un conjunto de caracteres especiales: <([{\^-=$!|]})?*+.> Si deseamos incluirlos en las expresiones Para incluirlos, debemos poner “\” por delante “\.*” representa a “”, “.”, “..”, “...”,… “\\” representa a “\” En java, debemos además añadir un “\” para representar “\”, por lo cual, la expresión regular que representa “\” es: “\\\\”

Clases (conjuntos) de caracteres Construct Description [abc] a, b, or c (simple class) [^abc] Any character except a, b, or c (negation) [a-zA-Z] a through z, or A through Z, inclusive (range) [a-d[m-p]] a through d, or m through p: [a-dm-p] (union) [a-z&&[def]] d, e, or f (intersection) [a-z&&[^bc]] a through z, except for b and c: [ad-z] (subtraction) [a-z&&[^m-p]] a through z, and not m through p: [a-lq-z] (subtraction)

Clases predefinidas Construct Description . Any character (may or may not match line terminators) \d A digit: [0-9] \D A non-digit: [^0-9] \s A whitespace character: [ \t\n\x0B\f\r] \S A non-whitespace character: [^\s] \w A word character: [a-zA-Z_0-9] \W A non-word character: [^\w]

Cuantificadores Greedy Reluctant Possessive Meaning X? X?? X?+ X, once or not at all X* X*? X*+ X, zero or more times X+ X+? X++ X, one or more times X{n} X{n}? X{n}+ X, exactly n times X{n,} X{n,}? X{n,}+ X, at least n times X{n,m} X{n,m}? X{n,m}+ X, at least n but not more than m times

Patrones de borde Boundary Construct Description ^ The beginning of a line $ The end of a line \b A word boundary \B A non-word boundary \A The beginning of the input \G The end of the previous match \Z The end of the input but for the final terminator, if any \z The end of the input

Captura de grupos (subsequencias) Cualquier par de paréntesis captura una subsecuencia El patrón ((A)(B(C))) captura 4 grupos: 1: ((A)(B(C))) 2: (A) 3: (B(C)) 4: (C) Es posible referenciar capturas mediante “\numero” El patrón “(\d\d)\1” representa a “1212” pero no a “1234”

Extracción de patrones Se usan las clases Pattern y Matcher: Pattern p = Pattern.compile(String regex); Matcher m = p.matcher(CharSequence input); La clase Matcher permite localizar subcadenas mediante expresiones regulares: while (m.find()) { System.out.println(m.group()); } Es posible obtener los grupos capturados en la regexp m.group(int i) m.group() == m.group(0)

Interfaces en Java Una interfaz es una especie de contrato. Es sintácticamente similar a una clase, sólo puede contener: Constantes Prototipos de métodos (funciones) Nombre + tipos de los argumentos No pueden existir dos métodos con un mismo prototipo Tipos anidados (clases, interfaces…) Pueden ser Implementadas por clases Toda clase (no abstracta) que implemente una interfaz debe contener las funciones de la interfaz (de ahí el concepto de contrato) Una clase puede implementar tantas interfaces como desee. Extendidas por otra interfaz Es posible crear jerarquías de interfaces

Estructuras de datos La API de java incluye una familia de interfaces/clases diseñadas para servir de estructuras de datos genéricas: java.util.Collection Se basa en una jerarquía de interfaces que define de manera abstracta un conjunto de estructuras de datos de uso general:

Interfaz Collection public interface Collection extends Iterable { // Basic operations int size(); boolean isEmpty(); boolean contains(Object element); // optional boolean add(Object element); boolean remove(Object element); // Bulk operations boolean containsAll(Collection c); boolean addAll(Collection c); boolean removeAll(Collection c); boolean retainAll(Collection c); void clear(); // Array operations Object[] toArray(); … }

Genericos en Java Permiten el uso de los tipos (clases e interfaces) como parámetros al definir clases, interfaces y métodos: Permite minimizar errores de programación en la compilación No existen en tiempo de ejecución (X  Object) public Caja { Object o; public void guarda(Object o){ this.o = o; } public Object recupera(){ return o; …… Caja micaja = new Caja(); public Caja<X> { X o; public void guarda(X o){ this.o = o; } public X recupera(){ return o; …… Caja<Cacharros> micaja = new Caja<>();

Interfaz Collection - Generics public interface Collection<E> extends Iterable<E> { // Basic operations int size(); boolean isEmpty(); boolean contains(Object element); // optional boolean add(E element); boolean remove(Object element); // Bulk operations boolean containsAll(Collection<?> c); boolean addAll(Collection<? extends E> c); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); // Array operations Object[] toArray(); <T> T[] toArray(T[] a); … }

XML (Extensible Markup Language) Lenguaje de Marcas Forma de codificar un documento que, junto con el texto, incorpora etiquetas o marcas que contienen información adicional acerca de la estructura del texto o su presentación (p.ej.: HTML) Estándar para el intercambio de información estructurada entre diferentes plataformas/aplicaciones. Características: Extensible, estructurado y legible (basado en texto) El analizador (parser) puede ser genérico Codificación de texto no ambigua <?xml version="1.0" encoding="iso-8859-1" ?> <Nombre>Mikel Peñagarikano</Nombre> <?xml version="1.0" encoding="UTF-8" ?> <Nombre>Mikel Peñagarikano</Nombre> <?xml version="1.0" encoding="UTF-8" ?> <俄语>данные</俄语>

XML - Estructura Prólogo (opcional) Cuerpo: un único elemento raíz Una declaración XML <?xml version="1.0" encoding="UTF-8"?> Una declaración de tipo de documento <!DOCTYPE MiXML SYSTEM "http://midominio.org/Mi.dtd"> Uno o más comentarios e instrucciones de procesamiento <!-- esto es un comentario --> Cuerpo: un único elemento raíz Elementos <ElementoSimple /> <ElementoComplejo> … </ElementoComplejo> Atributos: características propias de los elementos <Texto tamaño="12“ estilo=="cursiva"> Mañana volveremos en coche </Texto> Entidades: < ("<"), > (">"), & ("&") Comentarios Texto: entre las etiquetas Secciones CDATA (ignorado por el parser): <![CDATA[ … ]]>

XML - Ejemplos <?xml version="1.0" encoding="UTF-8"?> <note> <to>Tove</to> <from>Jani</from> <heading>Reminder</heading> <body>Don't forget me this weekend!</body> </note> <note to="Tove" from="Jani" heading="Reminder"> Don't forget me this weekend! <note to="Tove" from="Jani" heading="Java example"> Look at my code: <![CDATA[ for (int i = 0; i < v.length(); i++) ]]> Did you like it?

XML – Definición de Estructura DTD (Document Type Definition) Tipos de elementos, listas de atributos, entidades y notaciones permitidas XML Schema Similar a un DTD, pero basado en XML y pudiendo especificar tipos de datos. <?xml version="1.0" encoding="UTF-8"?>  <matricula>    <personal>      <dni>52945813C</dni>      <nombre>Ricardo Borillo Domenech</nombre>      <titulacion>Enginiería Informática (Plan 2001)</titulacion>      <curso_academico>2002/2003</curso_academico>     <domicilios>        <domicilio tipo="familiar">          <nombre>C/ Principal nº1</nombre>        </domicilio>        <domicilio tipo="habitual">          <nombre>C/ Secundaria nº2</nombre>        </domicilio>      </domicilios>    </personal>   <pago>      <tipo_matricula>Matrícula ordinária</tipo_matricula>    </pago>  </matricula> 

XML – DTD <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE matricula SYSTEM "matricula.dtd"> <matricula>    <personal>      <dni>52945813C</dni>      <nombre>Ricardo Borillo Domenech</nombre>      <titulacion>Enginiería Informática (Plan 2001)</titulacion>      <curso_academico>2002/2003</curso_academico>     <domicilios>        <domicilio tipo="familiar">          <nombre>C/ Principal nº1</nombre>        </domicilio>        <domicilio tipo="habitual">          <nombre>C/ Secundaria nº2</nombre>        </domicilio>      </domicilios>    </personal>   <pago>      <tipo_matricula>Matrícula ordinária</tipo_matricula>    </pago>  </matricula>  <!ENTITY matricula (personal, pago)> <!ENTITY personal (dni, nombre titulacion, curso_academico, domicilios)>  <!ENTITY dni (#PCDATA)>  <!ENTITY nombre (#PCDATA)>  <!ENTITY titulacion (#PCDATA)>  <!ENTITY curso_academico (#PCDATA)>  <!ENTITY domicilios (domicilio+)>  <!ENTITY domicilio (nombre)>  <!ATTLIST domicilio     tipo (familiar|habitual) #REQUIRED>  <!ENTITY nombre (#PCDATA)> <!ENTITY pago (tipo_matricula)>  <!ENTITY tipo_matricula (#PCDATA)> 

XML – XSD <?xml version="1.0" encoding="UTF-8"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xml:lang="ES"> <xs:element name="matricula" type="tMatricula"/> <xs:complexType name="tMatricula"> <xs:sequence> <xs:element name="personal" type="tPersonal"/> <xs:element name="pago" type="tPago"/> </xs:sequence> </xs:complexType> <xs:complexType name="tPersonal"> <xs:all> <xs:element name="dni" type="xs:string"/> <xs:element name="nombre" type="xs:string"/> <xs:element name="titulacion" type="xs:string"/> <xs:element name="curso_academico" type="xs:string"/> <xs:element name="domicilios" type="tDomicilio"/> </xs:all> <xs:complexType name="tPago"> <xs:element name="tipo_matricula" type="xs:string"/> <xs:complexType name="tDomicilio"> <xs:element name="domiclio" maxOccurs="unbounded"> <xs:complexType> </xs:element> </xs:schema> <?xml version="1.0" encoding="UTF-8"?> <matricula xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="prueba.xsd"> <matricula>    <personal>      <dni>52945813C</dni>      <nombre>Ricardo Borillo Domenech</nombre>      <titulacion>Enginiería Informática (Plan 2001)</titulacion>      <curso_academico>2002/2003</curso_academico>     <domicilios>        <domicilio tipo="familiar">          <nombre>C/ Principal nº1</nombre>        </domicilio>        <domicilio tipo="habitual">          <nombre>C/ Secundaria nº2</nombre>        </domicilio>      </domicilios>    </personal>   <pago>      <tipo_matricula>Matrícula ordinária</tipo_matricula>    </pago>  </matricula> 

XML – Analizador (parser) Framework programable para procesar XML Dos APIs estándares: SAX (Simple API for XML) Procesamiento secuencial Eficiente (tiempo y memoria), pero difícil de manipular Implementamos los manejadores de eventos DOM (Document Object Model) Se carga el XML dentro de un único objeto y posteriormente se procesa el objeto No eficiente, pero sencill0 Extraemos la información del objeto

XML – SAX & DOM SAXParserFactory SAXParser SAXReader DefaultHandler ContentHandlerMethods ErrorHandlerMethods  DTDHandler EntityResolver Document Node Element