Transcript Aplicaciones software avanzadas con Java

Germán Bordel(CD4 P1.6)
[email protected]
Mikel Peñagarikano (CD4 P1.5)
[email protected]
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
 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?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
 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
import
import
import
import
java.io.BufferedReader;
java.io.IOException;
java.io.InputStreamReader;
java.net.MalformedURLException;
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)
 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 todas la posibles cadenas
 “\.*” 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);
// optional
boolean remove(Object element);
// Bulk operations
boolean containsAll(Collection c);
// optional
boolean addAll(Collection c);
// optional
boolean removeAll(Collection c);
// optional
boolean retainAll(Collection c);
// optional
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:
public Caja {
public Caja<X> {
Object o;
public void guarda(Object o){
this.o = o;
}
public Object recupera(){
return o;
}
X o;
public void guarda(X o){
this.o = o;
}
public X recupera(){
return o;
}
}
}
……
……
Caja micaja = new Caja();
Caja<Cacharros> micaja = new Caja<>();
 Permite minimizar errores de programación en la
compilación
 No existen en tiempo de ejecución (X  Object)
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);
// optional
boolean remove(Object element);
// Bulk operations
boolean containsAll(Collection<?> c);
// optional
boolean addAll(Collection<? extends E> c);
// optional
boolean removeAll(Collection<?> c);
// optional
boolean retainAll(Collection<?> c);
// optional
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)
 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: &lt; ("<"), &gt; (">"), &amp; ("&")
 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>
<?xml version="1.0" encoding="UTF-8"?>
<note to="Tove" from="Jani" heading="Reminder">
Don't forget me this weekend!
</note>
<?xml version="1.0" encoding="UTF-8"?>
<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?
</note>
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>
<!ENTITY matricula (personal, pago)>
<domicilio tipo="habitual">
<!ENTITY personal (dni, nombre titulacion, curso_academico, domicilios)>
<nombre>C/ Secundaria nº2</nombre> <!ENTITY dni (#PCDATA)>
</domicilio>
<!ENTITY nombre (#PCDATA)>
</domicilios>
<!ENTITY titulacion (#PCDATA)>
</personal>
<!ENTITY curso_academico (#PCDATA)>
<pago>
<!ENTITY domicilios (domicilio+)>
<tipo_matricula>Matrícula ordinária</tipo_matricula>
<!ENTITY domicilio (nombre)>
</pago>
<!ATTLIST domicilio
</matricula>
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"/>
<?xml version="1.0" encoding="UTF-8"?>
</xs:sequence>
<matricula xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
</xs:complexType>
xsi:noNamespaceSchemaLocation="prueba.xsd">
<matricula>
<xs:complexType name="tPersonal">
<personal>
<xs:all>
<dni>52945813C</dni>
<xs:element name="dni" type="xs:string"/>
<nombre>Ricardo Borillo Domenech</nombre>
<xs:element name="nombre" type="xs:string"/>
<titulacion>Enginiería Informática (Plan 2001)</titulacion>
<xs:element name="titulacion" type="xs:string"/>
<curso_academico>2002/2003</curso_academico>
<xs:element name="curso_academico" type="xs:string"/>
<domicilios>
<xs:element name="domicilios" type="tDomicilio"/>
<domicilio tipo="familiar">
</xs:all>
<nombre>C/ Principal nº1</nombre>
</xs:complexType>
</domicilio>
<domicilio tipo="habitual">
<xs:complexType name="tPago">
<nombre>C/ Secundaria nº2</nombre>
<xs:all>
</domicilio>
<xs:element name="tipo_matricula" type="xs:string"/>
</domicilios>
</xs:all>
</personal>
</xs:complexType>
<pago>
<tipo_matricula>Matrícula ordinária</tipo_matricula>
<xs:complexType name="tDomicilio">
</pago>
<xs:sequence>
</matricula>
<xs:element name="domiclio" maxOccurs="unbounded">
<xs:complexType>
<xs:all>
<xs:element name="nombre" type="xs:string"/>
</xs:all>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:schema>
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