Aplicaciones software avanzadas con Java
Download
Report
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: < ("<"), > (">"), & ("&")
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