Análisis y Diseño

 Análisis y Diseño

La tendencia actual de desarrollo bajo el enfoque orientado a objetos, exige que los profesionales de sistemas conozcan las actividades, técnicas y patrones para el análisis, diseño y desarrollo de sistemas de información bajo este paradigma.

Sistema Software

Análisis y Diseño (A/DOO)

Descripción general del curso

Las actividades de Análisis y Diseño son fundamentales en el desarrollo de Sistemas y el paradigma orientado a objetos es actualmente el más popular en el mundo del software. En este modelo, las estructuras de datos y los algoritmos se integran en unidades denominadas Clases.

Objetivos

* Complementar teoría y práctica para que el alumno apropie los elementos básicos relacionados con el modelado de sistemas
* Conocer los artefactos o productos a desarrollar en las fases de análisis y diseño de software orientado a objetos

* Aprender y aplicar las estrategias de desarrollo para un proyecto de software.

Contenido

La tecnología orientada a objetos se define como una metodología de diseño de software que modela las características de objetos reales o abstractos por medio del uso de Clases y Objetos. La orientación a objetos es fundamental en el desarrollo de software.
I. Estrategias de desarrollo
– Secuencial
– Incremental
II. Conceptos fundamentales de Objetos
– Clases y Objetos
– Abstracción
– Generalización
– Asociación
– Composición
III. Fase de Análisis
– Determinación de requerimientos
– Casos de Uso
– Modelo conceptual
– Secuencia del sistema
– Contratos
IV. Fase de Diseño

– Diagramas de interacción

– Diagramas de Secuencia

– Diagramas de Colaboración

– Patrones para la asignación de responsabilidades

– Diagramas de clase

 

V. Fase de Construcción

– Generación de código

– Pruebas

 

Metodología

* Generación de escenarios de aprendizaje activo

* Talleres en grupo como estrategia de aprendizaje

* Tareas de aplicación, uso de TIC, consultas y foros de discusión.

* Debates sobre casos “problemas en el desarrollo de proyectos informáticos”

* Interacción y desarrollo de habilidades de auto-estudio como fundamento principal de la educación contemporánea.

Materiales

BIBLIOGRAFÍA

Schach, Sthepen(2005). Análisis y diseño orientado a objetos con UML y el proceso unificado.
Craig, Larman (2006). UML y patrones. Una introducción al análisis y diseño orientado a objetos y al proceso unificado.
Bennett, Simon; McRobb, Steve y Farmer Ray(2007).Análisis y diseño orientado a objetos de sistemas usando UML.
Stevens, Perdita y Pooley, Rob(2007). Utilización de UML en Ingeniería del software con objetos y componentes.Bruegge/Dutoit (2009). Ingeniería de Software Orientada a Objetos. México: Pearson.Jacobson, I. (2000). El Proceso Unificado de Desarrollo de Software.

ENLACES DE INTERÉS

Recursos humanos y técnicos

– Profesor: MSc. Gustavo Martínez Villalobos

http://www.gmv.enibague.com
– Sala Software L10

Metodología PU (Proceso Unificado)

Introducción, Casos de uso , Arquitectura, Un ejemplo, Iterativo e incremental , Fases , Ciclo de vida, Modelo PU.

.

* <17/04/2012> Proyecto de Asignatura.

Sistema: Concurso de Belleza (Proyecto adaptado de Cupi2)

Ponderación : (25%)

Actividades : Proceso de Desarrollo de Software Orientado a Objetos
Modelado : UML con NetBeans, Visual-Paradigm u otro producto
Herramientas de desarrollo : Java/BD de Software Libre
Equipo : Cuatro integrantes

Entrega: Mayo 25 de 2012

Cada equipo de trabajo deberá garantizar el cumplimiento de actividades de Modelado y Desarrollo de un Proyecto de Software:

a. Modelado de A/DOO (Diagramas de CDU, Diagramas de Clases y Diagramas de Secuencia)

b. Implementación

El grupo organizará la entrega del producto software y la correspondiente sustentación de su Proyecto.

Especificación del sistema

Se requiere implementar un sistema que permita administrar la información de un concurso de belleza. En el concurso se tiene un conjunto de participantes. Para cada una de ellas se debe manejar la siguiente información: documento de identidad, nombre, ciudad y fecha de nacimiento, foto, medidas (busto, cintura, cadera), correo electrónico, estatura y ocupación.

El sistema a implementar debe (1) ordenar la lista de participantes según diferentes criterios (nombre, ciudad, medidas, edad, ocupación), (2) mostrar la información de una participante específica, (3) registrar una nueva concursante, (4) localizar una participante por su nombre, (5) buscar la participante de mayor estatura, (6) buscar la participante más joven y (7) Seleccionar las cinco finalistas del concurso.

La información del sistema debe ser persistente en Base de Datos.

 * <07/02/2012>

ASIGNATURA : SEMINARIO REGIONAL III (Programación Orientada a Objetos con Java)

CODIGO : 83357

SEMESTRE : X

HORAS SEMANA : 4

CREDITOS : (1 Crédito=48 horas)

 

OBJETIVO GENERAL

Orientar al estudiante en la adquisición de nuevos conocimientos del desarrollo de software, a través del lenguaje Java, con el fin de que los pueda aplicar a la creación de Interfaces gráficas y a la solución de problemas reales.

CONTENIDO

1. EL PROCESO DE DESARROLLO DE SOFTWARE

> Conceptos fundamentales de Ingeniería del Software

> Retos de la ingeniería del software siglo xxi

> Categorías de software

> Paradigmas de programación

> Programación orientada a objetos

> Learning the Java Language

> Requerimientos

Especificación de requerimientos y entidades


2. DISEÑO DE UNA INTERFAZ GRÁFICA

>Creación de componentes Swing

>Componentes Swing más comunes

>Contenedores

>Administradores de diseño

>Manejo de eventos

– Asignar manejadores de eventos a un objeto

– Adaptadores

– Responder a los eventos

 

3. JFC

>Componentes

>Arquitectura Modelo-Vista-Controlador

>Manejadores de eventos de Swing

>Jerarquía de componentes de una aplicación

>Cajas de texto, etiquetas y botones

>Barras de herramientas

>Cajas de diálogo modales y no modales

>Cajas de diálogo predefinidas

>Cajas de diálogo personalizadas

>Listas

4. J2EE

>Introducción

>¿Qué es J2EE?

>Arquitectura J2EE Multicapa

– Componentes J2EE

– Contenedores J2EE

>La capa Cliente

>La capa Web

>La capa EJB

 

5. ACCESO A UNA BASE DE DATOS

>SQL

>Creación de la BD y de sus tablas con MySQL

>Acceso a una Base de Datos con JDBC

>Controladores

>Metadatos

>Navegar por la Base de Datos

 

6. CLIENTES

>Servicios en Internet

>Páginas Web

>Hojas de estilo

>Páginas Web dinámicas

>Applets

– La clase JApplet

– Ciclo de vida de un Applet

– Paso de parámetros a un applet

– Visualizar una imagen

– Reproducir un archivo de sonido

– Crear una animación

– Restricciones de seguridad con los Applets.

 

BIBLIOGRAFIA

<>Ceballos, Francisco. JAVA2. Interfaces gráficas y aplicaciones para Internet. 3ª. Edición, Alfaomega-RaMa, 2008.

<>Deitel, Harvey y Deitel Paul. Como programar en Java 5ª Edición. Prentice – Hall

<>JOYANES Aguilar, Luis. Programación en Java. McGraw-Hill.

<>Schildt, Herbert. Fundamentos de Programación en Java2. McGraw Hill.

 

Enlaces de interés:

http://www.javapassion.com/

http://programandoenjava.over-blog.es/article-29626615.html

http://www.java.sun.com/developer

http://www.java.sun.com/docs/books/tutorial/

http://www.tooltorials.com

http://www.illasaron.com/html/

http://www.toptutoriales.com/

http://ww.desarrolloweb.com/articulos/499.php

http://www.gmv.enibague.com

* <18/08/2011> Taller

Buenas tardes. El siguiente taller por grupos (máximo 5 estudiantes) deberá ser entregado en formato impreso a su representante de grupo antes del día 2 de septiembre. Para desarrollarlo, realizarán una consulta sobre el Lenguaje de Modelado Unificado, UML. Como punto de partida, pueden descargar una presentación ubicada en: http://www.unibague.edu.co/~gustavo.martinez/cursos/is/diseno.html

El taller consiste en utilizar diagramas del UML para presentar diversas perspectivas de un sistema de mensajería.  Cada grupo de trabajo podrá realizar el modelado a través de alguna de las siguientes herramientas CASE: NetBeans, ArgoUML, Poseidón, Power-Designer, StartUML ó Rational Rose.

 

El objetivo del sistema es soportar el negocio de una nueva X empresa de la ciudad de Bogotá, la cual ofrece un amplio portafolio de servicios de correo, especiales de correo y mensajería especializada, mediante una red de cobertura nacional e internacional (Panamá, Ecuador, Perú, Brasil y Venezuela).Esta compañía busca serreconocida a nivel nacional e internacional, como una empresa de excelencia en la prestación de servicios postales y logísticos, integrales e innovadores, asegurando la satisfacción de sus clientes con procesos de alta calidad y tecnología de punta.

Cuando un cliente llega a la Empresa, un funcionario de ésta registra el paquete con la siguiente información: su descripción, su prioridad, país, la dirección, la zona de la ciudad en la cual se debe entregar, su peso, una imagen

La prioridad con la cual un cliente escoge que se envíe su paquete puede ser:

  • El mismo día
  • Entre dos y tres días
  • Una semana.

Cada prioridad tiene una tarifa asociada, las cuales son diferentes para envíos internacionales. El valor del envío se calcula con base en el peso del paquete y la tarifa aplicada.

 

 

Además de registrar un paquete, la aplicación permite monitorear su estado, para lo cual se definieron los siguientes estados: En el momento en que se registra un paquete su estado debe ser “En Bodega”, posteriormente se puede cambiar a “En Tránsito” y por último a “Entregado”. El sistema debe permitir el seguimiento en línea de los envíos para conocer la ciudad donde se encuentran nacional e internacionalmente. Para envíos especiales, se podrá contratar una garantía adicional que le responda al cliente por el valor asegurado.

Finalmente, una vez se han registrado varios paquetes, el usuario de la aplicación puede (a) Filtrarlos según su estado. (b) Ordenarlos por los siguientes criterios: Peso, Zona y Prioridad, y (c) Buscar el paquete con el mayor valor de envío y el paquete con el menor peso.

El modelado de sistemas para esta empresa deberá  incluir los siguientes diagramas:

<> Diagrama de Casos de Uso.
<> Diagrama de Clases.
<> Diagrama de Estados.
<> Diagrama de Secuencia.
<> Diagrama de Colaboración.

¿Por qué debemos construir modelos? ¿por qué no construimos el sistema y ya? La respuesta es que podemos construir modelos de tal forma que resaltemos o enfaticemos ciertas características críticas de un sistema, al mismo tiempo que quitamos énfasis a otros aspectos del sistema.” (Ed Yourdon)

AVISO IMPORTANTE!!!

Hola, jóvenes. Gracias a DIOS se desarrolló positivamente mi cirugía de columna en la Clínica Ibagué. La Vertebroplastia de dos niveles duró 2 hrs.  y las cosas salieron bien. Agradezco su apoyo y comprensión.

Mientras logro recuperarme, los invito a iniciar nuestro trabajo académico con una exploración del OVA sobre Ingeniería del Software: http://aprendeenlinea.udea.edu.co/ova/?q=node/787

y la elaboración de las tres actividades planteadas inicialmente para este curso.

 

Fundamentos de la POO

Las tecnologías orientadas a objetos se han convertido en las últimas décadas en uno de los motores de la industria del software, y la riqueza del entorno de Programación Orientada a Objetos ha permitido mejorar no sólo la calidad de los sistemas software sino también su productividad. Por ello es importante que los estudiantes de Ingeniería de Sistemas aprendan las técnicas de análisis, de diseño y estándares del desarrollo de aplicaciones con orientación a objetos.

 

Siempre he deseado que mi computador sea tan fácil de manejar como mi teléfono. Mi deseo se ha vuelto realidad. Ya no sé cómo usar mi teléfono“.

Bjarne Stronstrup(creador del lenguaje C++)

Descripción general

La Programación Orientada a Objetos (POO) fue creada para superar los inconvenientes de la Programación Orientada a Procedimientos (POP). Emplea el enfoque de programación ascendente. Trata a los datos como un elemento crítico en el desarrollo del programa y no permite que fluyan libremente por el sistema. Une los datos con las funciones que operan sobre ellos en una estructura de datos llamadaclase.

La POO se ha convertido en la actualidad en una de las palabras pegadizas de la programación. Aparece una gran cantidad de excitación e interés entre los ingenieros de software en usar POO. La aplicación más popular de la POO ha sido en el área del diseño de interfaces de usuario. Se han desarrollado cientos de sistemas de ventanas usando las técnicas de POO.

Es necesario comprender los conceptos fundamentales usados ampliamente en Programación Orientada a Objetos:

  • Clases
  • Objetos
  • Abstracción y encapsulación de datos
  • Herencia
  • Polimorfismo
  • Ligadura dinámica
  • Paso de mensajes

Los sistemas reales de las empresas son a menudo mucho más complejos y contienen más objetos con atributos y métodos complicados. POO es útil en estos tipos de aplicaciones ya que puede simplificar un problema complejo. Entre las áreas de aplicación de la POO se incluyen:

<> Sistemas de tiempo real

<> Simulación y modelado

<> Bases de datos orientadas a objetos

<> Hipertexto, hipermedia y expertexto

<> IA y sistemas expertos

<> Redes neuronales y programación paralela

<> Soporte de decisión y sistemas de automatización de oficinas

<> Sistemas CIM/CAM/CAD

La POO es un enfoque diferente del mundo informático, un nuevo modo de pensar y diseñar software con calidad, y el lenguaje
es uno de los LPOO más utilizados en la actualidad.

Actividad 1:

Descargar y explorar el siguiente OVA: http://aprendeenlinea.udea.edu.co/ova/?q=node/787

Actividad 2:

Objetivo: Introducir la terminología básica del desarrollo de software. (Copyright Cupi2 2008, Universidad de los Andes. Todos los derechos reservados).

Trabajo en parejas: construya un mapa conceptual, que identifique las relaciones entre los siguientes términos.

Cliente

Usuario

Programador

Requerimiento funcional

Mundo del problema

Requerimiento no funcional

Proceso

Etapa

Problema

Solución

Programa

Lenguaje de programación

Ambiente de desarrollo

Compilador

Análisis

Diseño

Implementación

Especificación

Etapa

Código fuente

Instalaciòn

Diseño de interfaz

Código ejecutable

Pruebas

Actividad 3:

Considere el siguiente enunciado:

La Dimayor quiere construir un programa que permita manejar la información del campeonato de fútbol  profesional colombiano “Liga Postobón”.

Usando el problema antes planteado, identifique o presente ejemplos de:

Cliente

Usuario

Requerimiento funcional

Nombre:

Entradas:

Resultado:

Nombre:

Entradas:

Resultado:

Nombre:

Entradas:

Resultado:

Nombre:

Entradas:

Resultado:

Mundo del problema

 


Programación Orientada a Objetos en lenguaje

El lenguaje Java tiene una sintaxis similar a la de C++ (que a su vez tiene una sintaxis similar a la de C). Con ellos, cada uno ha tratado de ganarse a los adeptos del lenguaje precedente. Pero, para ser justos, hay que decir que Java, aunque tiene el mismo ‘look‘, es mucho más simple que C++.  Por ejemplo, al eliminar los apuntadores se eliminan los atormentadores y estresantes  * y &.

// Un primer programita en Java: Imprimir texto
// Autor: Usted
// Fecha: 11/03/2011
// Cómo mostrar texto en un cuadro de diálogo
// Paquetes de Java (Colección de clases o bibliotecas)

import javax.swing.JOptionPane; // El programa usa la clase JOptionPane

public class Ventana{

// El método main empieza la ejecución del programa en Java
public static void main(String arg []){

JOptionPane.showMessageDialog( null, “Hola, mis pupilos Cooperativos!\nBienvenidos al mundo Java!!”);
System.exit(0); // Terminar el programa con la ventana
} // Fin del método main
} // Fin de la clase Ventana

————————————————————————————

// Un programa sencillo para multiplicar enteros
import javax.swing.JOptionPane; // Importa la clase JOptionPane

public class Prodent{

// El método main empieza la ejecución del programa en Java
public static void main(String arg []){
String primernum, segundonum;
int num1,num2,prod;
// Lee el primer número del usuario como una cadena
primernum=JOptionPane.showInputDialog(“Digite el primer entero: “);
// Lee el segundo número del usuario como una cadena
segundonum=JOptionPane.showInputDialog(“Digite el segundo entero: “);
// Convierte los números del tipo String a tipo int
num1 = Integer.parseInt(primernum);
num2 = Integer.parseInt(segundonum);
// Multiplica los números
prod = num1 * num2;
// visualiza el producto en una ventana
JOptionPane.showMessageDialog(null,”El producto es “+prod, “Resultados “,JOptionPane.PLAIN_MESSAGE);
System.exit(0); // Terminar el programa con la ventana
} // Fin del método main
} // Fin de la clase Prodent

Modificar el programa anterior para permitir otras operaciones aritméticas (suma, resta, división, división residuo, potencia, raiz cuadrada…). Utilizar los metodos de la clase Math (sqrt( ), pow( )…)

Especificación e implementación de Clases

/**
* Ejemplo simplificado: Especificación e implementación de Clases en Java
* @(#)TestEmpleado.java
*
* @author vGus
* @version 1.00  2011/3/03
*/

import javax.swing.*;

// Especificación de la Clase Fecha
class Fecha{
// Atributos
private int dd,mm,aa;
// Métodos
public void setFecha(int dd,int mm,int aa){ // con parámetros y sin retorno de valor
this.dd = dd;
this.mm = mm;
this.aa = aa;
}
public int getDia(){ // Sin parámetros
return dd; // con retorno de valor
}
public int getMes(){
return mm;
}
public int getAnio(){
return aa;
}
}
//Especificación de la Clase Empleado
class Empleado{
// Atributos
private int codigo;
private String nombre;
private double salario;
private Fecha fechaIngreso;
// Métodos
public void setCodigo(int codigo){ // de acceso <entrada>
this.codigo=codigo;
}
public void setNombre(String nombre){
this.nombre=nombre;
}
public void setSalario(double salario){
this.salario=salario;
}
public int getCodigo(){ // de acceso <salida>
return codigo;
}
public String getNombre(){
return nombre;
}
public double getSalario(){
return salario;
}
public int getDiaIngres(){
return (fechaIngreso.getDia());
}
public int getMesIngres(){
return (fechaIngreso.getMes());
}
public int getAñoIngres(){
return (fechaIngreso.getAnio());
}
public double getBonif(){ // de comportamiento
return (salario+salario*7/100);
}
}

// Implementación
public class TestEmpleado { // Inicio del programa

public static void main(String[] args) {
int dd,mm,aa,codigo;
double salario;
String nombre;
// Creación de Objetos o Instancias de las Clases
Empleado emp = new Empleado();
Fecha fechaIngreso = new Fecha();
// Entrada y conversión de datos
codigo=Integer.parseInt(JOptionPane.showInputDialog(“Codigo del empleado?”));
nombre=JOptionPane.showInputDialog(“Nombre del empleado?”);
salario=Double.parseDouble(JOptionPane.showInputDialog(“Salario?”));
dd=Integer.parseInt(JOptionPane.showInputDialog(“Fecha de ingreso a la empresa: Dia?”));
mm=Integer.parseInt(JOptionPane.showInputDialog(“Mes?”));
aa=Integer.parseInt(JOptionPane.showInputDialog(“Año”));
// Paso de mensajes
fechaIngreso.setFecha(dd,mm,aa); // Mensaje con paso de parámetros
emp.setCodigo(codigo);
emp.setNombre(nombre);
emp.setSalario(salario);
// Salida de datos
JOptionPane.showMessageDialog(null, “Codigo: “+emp.getCodigo()+”\nNombre: “+emp.getNombre()+”\nSalario: $”+emp.getSalario());
JOptionPane.showMessageDialog(null, “Fecha de ingreso a la empresa (dd/mm/aa): “+fechaIngreso.getDia()+”/”+fechaIngreso.getMes()+”/”+fechaIngreso.getAnio()+”\nNuevo salario (bonificacion 7%): $”+emp.getBonif());
}
} // Fin del programa

Creación de Applets

java.sun.com/applets/

sunsite.dcc.uchile.cl/java/docs/JavaTut/Cap2/metodv.html

Applets

Un applet es un pequeño programa que por lo general se almacena en un computador remoto para ser transmitido por internet y que los usuarios conectan mediante un navegador Web (como hotjava de Sun).

El applet es descargado dinámicamente por la red, tal como una imagen, un archivo de sonido, un archivo musical o un videoclip, pero con una notable propiedad: es un programa inteligente que puede reaccionar dinámicamente a entradas y cambios del usuario.

Los programas Java se pueden incluir (“embeber” o “empotrar”) en páginas html y descargarse por navegadores www, para llevar animaciones e interacciones a los clientes Web. Para crear un applet java se requieren dos archivos: El archivo de programa con extensión.java y un archivo en html que invoca el archivo.class, que contiene los bytecodes que comprende el intérprete java.

// Un primer Applet sencillo en Java
// Gus.java

import java.awt.*;
import javax.swing.*;

public class Gus extends JApplet{

public void paint(Graphics g){
super.paint(g);
g.drawLine(15,10,250,10);
g.drawLine(15,30,250,30);
g.setColor(Color.blue);
g.drawString(“Feliz fin de semana!!!”,25,25);
g.drawString(“‘Pingüino Gus'”,25,40);
}
}
————————————————————————

Gus.html

<html>
<applet code = “Gus.class” width=”300″ height=”60″></applet>
</html>
*****************************************************

// HolAmigos.java
// El siguiente applet crea y establece la fuente (tipo de letra, estilo y tamaño)
// para mostrar texto mediante un objeto de la clase Font.

import java.applet.*;
import java.awt.*;

public class HolAmigos extends Applet {
public void paint( Graphics g )
{
g.drawString(“:: PenguinSoft ::”, 5, 20 );
Font L1=new Font(“Tahoma”,Font.BOLD|Font.ITALIC,24);
Font L2=new Font(“Tahoma”,Font.PLAIN,18);
g.setFont(L1);
g.drawString(“HolAmigos!!!…”, 5, 50 );
g.setFont(L2);
g.drawString(“Bienvenidos a los applets de Java!.”, 5, 100 );
} // fin del método paint
} // fin de la clase HolAmigos
//****************************************************

HolAmigos.html

<html>
<applet code = “HolAmigos.class” width=”300″ height=”60″></applet>
</html>
*********************************************************

Analizar, compilar, ejecutar y modificar los ejercicios planteados en: Applets

________________________________________________________

MODIFICARel siguiente programa y transformarlo en unApplet java:

// Programa: TiraDados.java
// Tira 6000 veces un dado de seis lados
import javax.swing.*;

public class TiraDados {
public static void main( String args[] )
{
int frecuencia1 = 0, frecuencia2 = 0,
frecuencia3 = 0, frecuencia4 = 0,
frecuencia5 = 0, frecuencia6 = 0, cara;

// resume los resultados
for ( int tiro = 1; tiro <= 6000; tiro++ ) {
cara = 1 + (int) ( Math.random() * 6 );

switch ( cara ) {
case 1:
++frecuencia1;
break;
case 2:
++frecuencia2;
break;
case 3:
++frecuencia3;
break;
case 4:
++frecuencia4;
break;
case 5:
++frecuencia5;
break;
case 6:
++frecuencia6;
break;
} // fin de switch
} // fin de for

JTextArea areaSalida = new JTextArea( 7, 10 );

areaSalida.setText(
“Cara\tFrecuencia” +
“\n1\t” + frecuencia1 +
“\n2\t” + frecuencia2 +
“\n3\t” + frecuencia3 +
“\n4\t” + frecuencia4 +
“\n5\t” + frecuencia5 +
“\n6\t” + frecuencia6 );

JOptionPane.showMessageDialog( null, areaSalida,
“Lanzando 6000 veces un dado”,
JOptionPane.INFORMATION_MESSAGE );
System.exit( 0 );
} // fin de main
} // fin de la clase TiraDados

// TALLER: Modificar el programa para almacenar las frecuencias en un arreglo.

**********************************************************

// Un Applet de Java ejemplo para leer un arreglo.
import java.applet.*;
import java.awt.*;
import java.awt.event.*;

public class Ap extends Applet{

private TextField tf;
private Button bt;
private Button bs;
public int top = 0;
public float ar[] = new float[10];

public void init(){
tf = new TextField(10);
bt = new Button(“Ok”);
bs = new Button(“Sum”);
add(tf);
add(bt);
add(bs);

//listeners
bt.setActionCommand(“boton_Ok”);
bt.addActionListener(new MyActionListener());

bs.setActionCommand(“boton_Sum”);
bs.addActionListener(new MyActionListener());
}

/*
public void paint(Graphics g){
}
*/

//clase inner
class MyActionListener implements ActionListener{

//metodos evento
public void actionPerformed(ActionEvent e){

String c= e.getActionCommand();
String tem;
float sum=0;

if(c.equals(“boton_Ok”)){
tem = tf.getText();

if(top<10){
ar[top] = Float.parseFloat(tem);
tf.setText(“”);
top++;
}

}

if(c.equals(“boton_Sum”)){
for(int i=0;i<top;i++){
sum = sum + ar[i];
}

tf.setText(String.valueOf(sum));
}

tf.requestFocus();
}
}
} // Ejercicio amistoso: Visualizar el arreglo en orden descendente.

Creación de Threads (Hilos)

http://www.youtube.com/watch?v=mGhv-n3dtV0

http://www.scribd.com/doc/2875431/hilos-Java

http://www.idg.es/pcworld/Hilos-de-proceso-con-Java:-threads/art155444.htm

http://zarza.usal.es/~fgarcia/docencia/poo/01-02/trabajos/S3T3.pdf

http://www.chuidiang.com/java/hilos/hilos_java.php

http://www.slideshare.net/czelada/hilos-en-java

http://www.reloco.com.ar/prog/java/threads.html

Un hilo es una secuencia de instrucciones que está controlada por un planificador que se comporta como un flujo de control secuencial. El planificador gestiona el tiempo de ejecución del procesador y asigna de alguna manera dicho tiempo a los diferentes hilos actualmente presentes.

Normalmente los hilos de un proceso (en este contexto el proceso es lo que se suele llamar así en el ámbito de sistemas operativos) suelen tener acceso a todos los recursos disponibles al proceso, es decir, actúan sobre una memoria compartida.

Para crear un hilo sencillo en java se hereda de la clase Thread y se define el método run(). Luego se instancia esta clase y se llama al método start() para que arranque el hilo. Algo así como:

public MiHilo extends Thread {
public void run() {
// Aquí el código de una tarea pesada que tarda mucho } };
… MiHilo elHilo = new MiHilo();
elHilo.start();

// Ejemplo de Threads o Hilos
// Se definen unos sencillos hilos.
// Se detendrán un rato antes de imprimir sus nombres y retardos

class PruebaH extends Thread {
private String nombre;
private int retardo;
// Constructor para almacenar el nombre y el retardo
public PruebaH( String s,int d ) {
nombre = s;
retardo = d;
}

// El metodo run() es similar al main(), pero para threads. Cuando run() termina el thread muere
public void run() { // Se retrasa la ejecución el tiempo especificado
try {
sleep( retardo );
} catch( InterruptedException e ) { ; } // Ahora se imprime el nombre System.out.println( “Hola, mis pupilos! “+nombre+” “+retardo );
} }

public class MultiHola {
public static void main( String args[] ) {
PruebaH h1,h2,h3; // Se crean los hilos o threads
h1 = new PruebaH( “Hilo 1”,(int)(Math.random()*2000) );
h2 = new PruebaH( “Hilo 2”,(int)(Math.random()*2000) );
h3 = new PruebaH( “Hilo 3”,(int)(Math.random()*2000) ); // Se arrancan los hilos
h1.start();
h2.start();
h3.start();
} }

En síntesis, los hilos permiten aumentar la eficiencia de los programas al dejarnos realizar varias tareas de forma simultánea.

Existen dos formas de crear hilos en Java, la primera es heredando de la clase Thread e implementando a nuestro gusto el método run. La segunda es mediante la implementación de la interfaz Runnable e implementando, también, el método run. Para que el hilo se ejecute como hilo, hay que invocarlo mediante el método start, si se invoca mediante el método run se hará que se ejecute ese método mediante una invocación normal y el resto del programa no seguirá ejecutándose hasta que el método run haya acabado su ejecución.

Ejercicio: Escribir un programa que genere dos listas aleatorias de números enteros y lance dos hilos que van sumando dichas listas en paralelo.

En Java los hilos están en el paquete

java.lang.thread

y se puede usar por ejemplo dos hilos para realizar un pequeño pingPONG:

Thread PingThread = new Thread(); PingThread.start(); Thread PongThread = new Thread(); PongThread.start(); 

Por defecto, un hilo nuevamente creado y lanzado aún siendo activado así no hace nada. Sin embargo, los hilos se ejecutan durante un tiempo infinito y hay que abortar el programa de forma bruta: control-C en el terminal.

Extendemos la clase y sobre-escribimos el método run()para que haga algo útil:

public class CD_PingThread extends Thread { public void run() { while(true) { System.out.print("ping "); } } } 

El hilo hereda todo de la clase Thread, pero sobre-escribe el método run(). Hacemos lo mismo para el otro hilo:

public class CD_PongThread extends Thread { public void run() { while(true) { System.out.print("PONG "); } } } 

Y reprogramamos el hilo principal:

CD_PingThread PingThread=new CD_PingThread(); PingThread.start(); CD_PongThread PongThread=new CD_PongThread(); PongThread.start(); 

Resultado (esperado):

  • los dos hilos producen cada uno por su parte sus salidas en la pantalla

Resultado (observado):

  • se ve solamente la salida de un hilo durante cierto tiempo
  • parece que la salida dependa cómo el planificador está realizado en el entorno Java

Nuestro objetivo es: la ejecución del pingPONG independientemente del sistema debajo. Intentamos introducir una pausa para “motivar” el planificador para que cambie los hilos:

public class CD_PingThread extends Thread { public void run() { while(true) { System.out.print("ping "); try { sleep(10); } catch(InterruptedException e) { return; } } } } 
public class CD_PongThread extends Thread { public void run() { while(true) { System.out.print("PONG "); try { sleep(50); } catch(InterruptedException e) { return; } } } } 

Resultado (observado):

  • se ve un poco más ping que PONG
  • incluso si los dos tiempos de espera son iguales no se ve ningún pingPONG perfecto

Existe el método yield() (cede) para avisar explícitamente al planificador de que debe cambiar los hilos:

public class CD_PingThread extends Thread { public void run() { while(true) { System.out.print("ping "); yield(); } } } 
public class CD_PongThread extends Thread { public void run() { while(true) { System.out.print("PONG "); yield(); } } } 

Resultado (observado):

  • se ve un ping y un PONG alternativamente, pero de vez en cuando aparecen dos pings o dos PONGs
  • parece que el planificador re-seleccione el mismo hilo que ha lanzado el yield() (puede ser que el tercer hilo siendo el programa principal está intercalado de vez en cuando)
  • dicho comportamiento depende del sistema concreto con el cual se está trabajando

package pingPONG;

import javax.swing.JOptionPane;

public class PingThread extends Thread {

Interfaz i;
int SEGUNDOS = 5;

public PingThread(Interfaz inter) {
i = inter;
}

public void run() {
try {
while (true) {
for (int j = 1; j < SEGUNDOS + 1; j++) {
i.mostrarPing(“” + j);
sleep(1000);
}
i.mostrarPing(“PING”);
sleep(SEGUNDOS * 1000);
}
} catch (InterruptedException ex) {
JOptionPane.showMessageDialog(null, “Se presentó el siguiente error: ” + ex.getMessage());
}
}
}

package pingPONG;

import javax.swing.JOptionPane;

public class PongThread extends Thread {

Interfaz i;
int SEGUNDOS = 5;

public PongThread(Interfaz inter) {
i = inter;
}

public void run() {
try {
while (true) {
i.mostrarPong(“PONG”);
sleep(SEGUNDOS * 1000);
for (int j = 1; j < SEGUNDOS + 1; j++) {
i.mostrarPong(“” + j);
sleep(1000);
}
}
} catch (InterruptedException ex) {
JOptionPane.showMessageDialog(null, “Se presentó el siguiente error: ” + ex.getMessage());
}
}
}

package pingPONG;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.GridLayout;
import javax.swing.*;

import javax.swing.JOptionPane;

public class Interfaz extends JFrame {

private JLabel txtPong;
private JLabel txtPing;
private JPanel panel;

public Interfaz() {

setTitle(“Ping Pong “);
setSize(300, 200);

setLayout(new BorderLayout());
setResizable(false);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setBackground(Color.BLACK);

panel = new JPanel();
panel.setBackground(Color.BLACK);
panel.setLayout(new GridLayout(1, 2));

txtPong = new JLabel(“”, JLabel.CENTER);
txtPong.setFont(new Font(“Candara”, 0, 45));
txtPong.setForeground(Color.BLUE);

txtPing = new JLabel(“”, JLabel.CENTER);
txtPing.setFont(new Font(“Candara”, 0, 45));
txtPing.setForeground(Color.GREEN);

add(panel, BorderLayout.CENTER);
panel.add(txtPing);
panel.add(txtPong);
}

//Metodos
public void mostrarPing(String s) {
txtPing.setText(s);
}

public void mostrarPong(String s) {
txtPong.setText(s);
}

//—————————————————————–
// Programa principal
//—————————————————————–
public static void main(String[] args) {
try {
Interfaz interfaz = new Interfaz();
interfaz.setVisible(true);

PingThread ping = new PingThread(interfaz);
ping.start();
PongThread pong = new PongThread(interfaz);
pong.start();
} catch (Exception e) {
e.printStackTrace();
}
}
}

Programación con Sockets

http://www.tutorialesde.com/servidores498/sockets-en-java.html

http://sunsite.dcc.uchile.cl/java/docs/JavaTut/Cap9/socket.html

http://www.chuidiang.com/java/sockets/hilos/socket_hilos.php

Los sockets son puntos finales de enlaces de comunicaciones entre procesos. Los procesos los tratan como descriptores de archivos, de forma que se pueden intercambiar datos con otros procesos transmitiendo y recibiendo a través de sockets.

El tipo de sockets describe la forma en la que se transfiere información a través de ese socket.

EJEMPLO 1:

// Cliente.java

import java.net.*;

import java.io.*;

public class Cliente

{

public static void main( String[] args )throws IOException

{

Socket socket = new Socket( “192.168.10.169”, 2222 );// Cuando especifico una dir ip del server a conectarme

 

try

{

System.out.println(“El socket es: ” + socket);

BufferedReader in;

 

// engancho al flujo de entrada el socket para recibir informacion. Todo lo que se

// escriba utilizando in se lee desde el socket (no desde el teclado)

in = new BufferedReader(

new InputStreamReader( socket.getInputStream() ) );

 

// este objeto es para escribir en el server (PrintWriter solo sabe que tiene que escribir

// pero no a donde)

PrintWriter out;

BufferedWriter buf;

// engancho al flujo de salida el socket para enviar informacion. Todo lo que se

// escriba utilizando out se escribe en el socket (no en pantalla)

buf = new BufferedWriter(

new OutputStreamWriter( socket.getOutputStream() ) );

out = new PrintWriter( buf, true );

 

// Escribimos 10 mensajes al server

for(int i=0; i<10; i++){

out.println( “Enviando dato: ” + i );

String str = in.readLine();// Captura del server lo que este responde por enviarle el mensaje

System.out.println( “Respuesta: ” + str );// El cliente muestra en pantalla lo que recibió

}

out.println( “FIN” );// Envio un mensaje de finalizacion al server para terminar la comunicacion

}

finally

{

System.out.println( “Cerrando el socket” );

socket.close();

}

}

}

// Servidor.java
import java.io.*;
import java.net.*;
import java.util.*;
public class Servidor {
public static final int PUERTO = 2222;
public static void main( String[] args ) throws IOException
{
// inicializo el objeto que escucha sockets (es un contenedor para sockets, como el JPanel)
ServerSocket s = new ServerSocket( PUERTO );
System.out.println( “Iniciando el servidor… ” + s );
try
{
// El serverSocket esta escuchando, cuando llegue una peticion este creara un socket
// para iniciar comunicacion (para enviar datos). En este ejemplo se creará para enviar
// y recibir datos con un cliente
Socket socket = s.accept();
try
{
System.out.println( “Conexion aceptada: ” + socket );
BufferedReader in;
in = new BufferedReader(
new InputStreamReader( socket.getInputStream() ) );
PrintWriter out;
OutputStreamWriter outp =
new OutputStreamWriter( socket.getOutputStream() );
// area de escritura temporal antes de enviar la informacion (utilizando el PrintWriter)
BufferedWriter buffer = new BufferedWriter( outp );
out = new PrintWriter( buffer, true );
while ( true )
{
String str = in.readLine();
if( str.equals( “FIN” ) )
break;
System.out.println( “Se recibio: ” + str );
out.println( str );
}
}
finally
{
System.out.println(“Cerrando”);
socket.close();// cierro la conexion
}
}
finally
{
s.close();
}
}
}

EJEMPLO 2:

// Cliente.java

package socket.gui;

// Cliente que lee y muestra la información que le envía un Servidor.

import java.io.*;

import java.net.*;

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

public class Cliente extends JFrame {

private JTextField campoIntroducir;

private JTextArea areaPantalla;

private ObjectOutputStream salida;

private ObjectInputStream entrada;

private String mensaje = “”;

private String servidorChat;

private Socket cliente;

// inicializar servidorChat y configurar GUI

public Cliente( String host )

{

super( “Cliente” );

servidorChat = host; // establecer el servidor al que se va a conectar este cliente

Container contenedor = getContentPane();

// crear campoIntroducir y registrar componente de escucha

campoIntroducir = new JTextField();

campoIntroducir.setEditable( false );

campoIntroducir.addActionListener(

new ActionListener() {

// enviar mensaje al servidor

public void actionPerformed( ActionEvent evento )

{

enviarDatos( evento.getActionCommand() );

campoIntroducir.setText( “” );

}

}

);

contenedor.add( campoIntroducir, BorderLayout.NORTH );

// crear areaPantalla

areaPantalla = new JTextArea();

contenedor.add( new JScrollPane( areaPantalla ),

BorderLayout.CENTER );

setSize( 300, 150 );

setVisible( true );

} // fin del constructor de Cliente

// conectarse al servidor y procesar mensajes del servidor

private void ejecutarCliente()

{

// conectarse al servidor, obtener flujos, procesar la conexión

try {

conectarAServidor(); // Paso 1: crear un socket para realizar la conexión

obtenerFlujos();      // Paso 2: obtener los flujos de entrada y salida

procesarConexion(); // Paso 3: procesar la conexión

}

// el servidor cerró la conexión

catch ( EOFException excepcionEOF ) {

System.err.println( “El cliente termino la conexión” );

}

// procesar los problemas que pueden ocurrir al comunicarse con el servidor

catch ( IOException excepcionES ) {

excepcionES.printStackTrace();

}

finally {

cerrarConexion(); // Paso 4: cerrar la conexión

}

} // fin del método ejecutarCliente

// conectarse al servidor

private void conectarAServidor() throws IOException

{

mostrarMensaje( “Intentando realizar conexión\n” );

// crear Socket para realizar la conexión con el servidor

cliente = new Socket( InetAddress.getByName( servidorChat ), 12345 );

// mostrar la información de la conexión

mostrarMensaje( “Conectado a: ” +

cliente.getInetAddress().getHostName() );

}

// obtener flujos para enviar y recibir datos

private void obtenerFlujos() throws IOException

{

// establecer flujo de salida para los objetos

salida = new ObjectOutputStream( cliente.getOutputStream() );

salida.flush(); // vacíar búfer de salida para enviar información de encabezado

// establecer flujo de entrada para los objetos

entrada = new ObjectInputStream( cliente.getInputStream() );

mostrarMensaje( “\nSe recibieron los flujos de E/S\n” );

}

// procesar la conexión con el servidor

private void procesarConexion() throws IOException

{

// habilitar campoIntroducir para que el usuario del cliente pueda enviar mensajes

establecerCampoTextoEditable( true );

do { // procesar mensajes enviados del servidor

// leer mensaje y mostrarlo en pantalla

try {

mensaje = ( String ) entrada.readObject();

mostrarMensaje( “\n” + mensaje );

}

// atrapar los problemas que pueden ocurrir al leer del servidor

catch ( ClassNotFoundException excepcionClaseNoEncontrada ) {

mostrarMensaje( “\nSe recibió un objeto de tipo desconocido” );

}

} while ( !mensaje.equals( “SERVIDOR>>> TERMINAR” ) );

} // fin del método procesarConexion

// cerrar flujos y socket

private void cerrarConexion()

{

mostrarMensaje( “\nCerrando conexión” );

establecerCampoTextoEditable( false ); // deshabilitar campoIntroducir

try {

salida.close();

entrada.close();

cliente.close();

}

catch( IOException excepcionES ) {

excepcionES.printStackTrace();

}

}

// enviar mensaje al servidor

private void enviarDatos( String mensaje )

{

// enviar objeto al servidor

try {

salida.writeObject( “CLIENTE>>> ” + mensaje );

salida.flush();

mostrarMensaje( “\nCLIENTE>>> ” + mensaje );

}

// procesar los problemas que pueden ocurrir al enviar el objeto

catch ( IOException excepcionES ) {

areaPantalla.append( “\nError al escribir el objeto” );

}

}

// método utilitario que es llamado desde otros subprocesos para manipular a

// areaPantalla en el subproceso despachador de eventos

private void mostrarMensaje( final String mensajeAMostrar )

{

// mostrar mensaje del subproceso de ejecución de la GUI

SwingUtilities.invokeLater(

new Runnable() {  // clase interna para asegurar que la GUI se actualice apropiadamente

public void run() // actualiza areaPantalla

{

areaPantalla.append( mensajeAMostrar );

areaPantalla.setCaretPosition(

areaPantalla.getText().length() );

}

}  // fin de la clase interna

); // fin de la llamada a SwingUtilities.invokeLater

}

// método utilitario que es llamado desde otros subprocesos para manipular a

// campoIntroducir en el subproceso despachador de eventos

private void establecerCampoTextoEditable( final boolean editable )

{

// mostrar mensaje del subproceso de ejecución de la GUI

SwingUtilities.invokeLater(

new Runnable() {  // clase interna para asegurar que la GUI se actualice apropiadamente

public void run()  // establece la capacidad de modificar campoIntroducir

{

campoIntroducir.setEditable( editable );

}

}  // fin de la clase interna

); // fin de la llamada a SwingUtilities.invokeLater

}

public static void main( String args[] )

{

Cliente aplicacion;

if ( args.length == 0 )

aplicacion = new Cliente( “127.0.0.1” );

else

aplicacion = new Cliente( args[ 0 ] );

aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

aplicacion.ejecutarCliente();

}

} // fin de la clase Cliente

// Servidor.java

package socket.gui;

// Configurar un servidor que reciba una conexión de un cliente, envíe

// una cadena al cliente y cierre la conexión.

import java.io.*;

import java.net.*;

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

public class Servidor extends JFrame {

private JTextField campoIntroducir;

private JTextArea areaPantalla;

private ObjectOutputStream salida;

private ObjectInputStream entrada;

private ServerSocket servidor;

private Socket conexion;

private int contador = 1;

// configurar GUI

public Servidor()

{

super( “Servidor” );

Container contenedor = getContentPane();

// crear campoIntroducir y registrar componente de escucha

campoIntroducir = new JTextField();

campoIntroducir.setEditable( false );

campoIntroducir.addActionListener(

new ActionListener() {

// enviar mensaje al cliente

public void actionPerformed( ActionEvent evento )

{

enviarDatos( evento.getActionCommand() );

campoIntroducir.setText( “” );

}

}

);

contenedor.add( campoIntroducir, BorderLayout.NORTH );

// crear areaPantalla

areaPantalla = new JTextArea();

contenedor.add( new JScrollPane( areaPantalla ),

BorderLayout.CENTER );

setSize( 300, 150 );

setVisible( true );

} // fin del constructor de Servidor

// configurar y ejecutar el servidor

public void ejecutarServidor()

{

// configurar servidor para que reciba conexiones; procesar las conexiones

try {

// Paso 1: crear un objeto ServerSocket.

servidor = new ServerSocket( 12345, 100 );

while ( true ) {

try {

esperarConexion(); // Paso 2: esperar una conexión.

obtenerFlujos();        // Paso 3: obtener flujos de entrada y salida.

procesarConexion(); // Paso 4: procesar la conexión.

}

// procesar excepción EOFException cuando el cliente cierre la conexión

catch ( EOFException excepcionEOF ) {

System.err.println( “El servidor terminó la conexión” );

}

finally {

cerrarConexion();   // Paso 5: cerrar la conexión.

++contador;

}

} // fin de instrucción while

} // fin del bloque try

// procesar problemas con E/S

catch ( IOException excepcionES ) {

excepcionES.printStackTrace();

}

} // fin del método ejecutarServidor

// esperar que la conexión llegue, después mostrar información de la conexión

private void esperarConexion() throws IOException

{

mostrarMensaje( “Esperando una conexión\n” );

conexion = servidor.accept(); // permitir al servidor aceptar la conexión

mostrarMensaje( “Conexión ” + contador + ” recibida de: ” +

conexion.getInetAddress().getHostName() );

}

// obtener flujos para enviar y recibir datos

private void obtenerFlujos() throws IOException

{

// establecer flujo de salida para los objetos

salida = new ObjectOutputStream( conexion.getOutputStream() );

salida.flush(); // vaciar búfer de salida para enviar información de encabezado

// establecer flujo de entrada para los objetos

entrada = new ObjectInputStream( conexion.getInputStream() );

mostrarMensaje( “\nSe recibieron los flujos de E/S\n” );

}

// procesar la conexión con el cliente

private void procesarConexion() throws IOException

{

// enviar mensaje de conexión exitosa al cliente

String mensaje = “Conexión exitosa”;

enviarDatos( mensaje );

// habilitar campoIntroducir para que el usuario del servidor pueda enviar mensajes

establecerCampoTextoEditable( true );

do { // procesar los mensajes enviados por el cliente

// leer el mensaje y mostrarlo en pantalla

try {

mensaje = ( String ) entrada.readObject();

mostrarMensaje( “\n” + mensaje );

}

// atrapar problemas que pueden ocurrir al tratar de leer del cliente

catch ( ClassNotFoundException excepcionClaseNoEncontrada ) {

mostrarMensaje( “\nSe recibió un tipo de objeto desconocido” );

}

} while ( !mensaje.equals( “CLIENTE>>> TERMINAR” ) );

} // fin del método procesarConexion

// cerrar flujos y socket

private void cerrarConexion()

{

mostrarMensaje( “\nFinalizando la conexión\n” );

establecerCampoTextoEditable( false ); // deshabilitar campoIntroducir

try {

salida.close();

entrada.close();

conexion.close();

}

catch( IOException excepcionES ) {

excepcionES.printStackTrace();

}

}

// enviar mensaje al cliente

private void enviarDatos( String mensaje )

{

// enviar objeto al cliente

try {

salida.writeObject( “SERVIDOR>>> ” + mensaje );

salida.flush();

mostrarMensaje( “\nSERVIDOR>>> ” + mensaje );

}

// procesar problemas que pueden ocurrir al enviar el objeto

catch ( IOException excepcionES ) {

areaPantalla.append( “\nError al escribir objeto” );

}

}

// método utilitario que es llamado desde otros subprocesos para manipular a

// areaPantalla en el subproceso despachador de eventos

private void mostrarMensaje( final String mensajeAMostrar )

{

// mostrar mensaje del subproceso de ejecución despachador de eventos

SwingUtilities.invokeLater(

new Runnable() {  // clase interna para asegurar que la GUI se actualice apropiadamente

public void run() // actualiza areaPantalla

{

areaPantalla.append( mensajeAMostrar );

areaPantalla.setCaretPosition(

areaPantalla.getText().length() );

}

}  // fin de la clase interna

); // fin de la llamada a SwingUtilities.invokeLater

}

// método utilitario que es llamado desde otros subprocesos para manipular a

// campoIntroducir en el subproceso despachador de eventos

private void establecerCampoTextoEditable( final boolean editable )

{

// mostrar mensaje del subproceso de ejecución despachador de eventos

SwingUtilities.invokeLater(

new Runnable() {  // clase interna para asegurar que la GUI se actualice apropiadamente

public void run()  // establece la capacidad de modificar a campoIntroducir

{

campoIntroducir.setEditable( editable );

}

}  // fin de la clase interna

); // fin de la llamada a SwingUtilities.invokeLater

}

public static void main( String args[] )

{

Servidor aplicacion = new Servidor();

aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

aplicacion.ejecutarServidor();

}

}  // fin de la clase Servidor

Creación de Servlets

Servlets 

Un servlet es un programa que se ejecuta en el contenedor Web de un servidor de aplicaciones. Los clientes pueden invocarlo utilizando el protocolo HTTP. Comparativamente, lo mismo que un applet es cargado y ejecutado por un navegador, un servlet es cargado y ejecutado por un servidor Web.

Un servlet acepta peticiones de un cliente, procesa la información relativa a la petición realizada por el cliente y le devuelve a éste los resultados que podrán ser mostrados mediante applets, HTML, etc. Sin embargo, ésta no es la única función de un servlet; puede realizar también otras tareas como comunicarse con otro servlet para ayudarle en su trabajo, o bien facilitar el acceso a bases de datos. Utilizando servlets, con cada petición se inicia un hilo en vez de un proceso, lo cual reduce el uso de memoria del servidor y el tiempo de respuesta.

Java proporciona el soporte necesario para escribir servlets a través de los paquetes javax.servlet y javax.servlet.http.

Desde el punto de vista de Java, un servletno es más que un objeto de alguna de las clases de la API Java Servlet que implemente la interfaz Servlet, como son GenericServlet y HttpServlet. Cuando se implementa un servicio genérico normalmente se utiliza la clase GenericServlet. En cambio, la claseHttpServletes la idónea para servicios específicos HTTP.

El tipo de servlet http básico puede ser de la forma siguiente: un objeto de una clase derivada de HttpServlet que encapsula los métodos init para iniciar el servlet, si procede, doPost y/o doGet para responder a las peticiones de los clientes y destroy para realizar operaciones de limpieza cuando se descarga el servlet.

Un Servlet sencillo

El servlet que se implementa a continuación muestra el mensaje “Hola mundo” en el navegador desde el que es invocado. En este caso, independientemente del tipo de petición HTTP GET o POST que se realice, el servlet responderá en ambos casos enviando la misma página Web.

import java.io.*;

import java.net.*;

import javax.servlet.*;

import javax.servlet.http.*;

public class HolaMundo extends HttpServlet {

/**

* Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.

* @param request servlet request

* @param response servlet response

*/

protected void processRequest(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

response.setContentType(”text/html”);

PrintWriter out = response.getWriter();

try {

out.println(”<html>”);

out.println(”<head>”);

out.println(”<title>Servlet Hola Mundo</title>”);

out.println(”</head>”);

out.println(”<body>”);

out.println(”<h1>HolaMundo!!! ” + request.getContextPath () + “</h1>”);

out.println(”</body>”);

out.println(”</html>”);

} finally {

out.close();

}

}

// <editor-fold defaultstate=”collapsed” desc=”HttpServlet methods. Click on the + sign on the left to edit the code.”>

/**

* Handles the HTTP <code>GET</code> method.

* @param request servlet request

* @param response servlet response

*/

protected void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

processRequest(request, response);

}

/**

* Handles the HTTP <code>POST</code> method.

* @param request servlet request

* @param response servlet response

*/

protected void doPost(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

processRequest(request, response);

}

/**

* Returns a short description of the servlet.

*/

public String getServletInfo() {

return “Short description”;

}

// </editor-fold>

}

¿Cómo se ejecuta este servlet? Cuando el servlet recibe una petición de un cliente, el servidor lo carga para su ejecución, instante en el que se ejecuta el método init que lo inicia (por omisión, el método init invocado es el de su superclase). Cuando el método init finaliza, el servlet está en condiciones de atender a las peticiones de los clientes; en el ejemplo anterior, para cada una de las peticiones se ejecuta el método procesarPeticion que es invocado por doGet o por doPost. El servlet permanecerá cargado hasta que el servidor decida destruirlo, instante en el que se ejecutará el método destroy si fue implementado.

Analicemos el método procesarPeticion. Este método almacena en el objeto out de la clase PrintWriter los datos que el servlet HolaMundo enviará al cliente que realizó la petición (el navegador). Este objeto forma parte del objeto response y es obtenido a través de su método getWriter. Los datos se almacenan en out utilizando su método println. Observar que los datos almacenados se corresponden con una página HTML, la que será enviada al navegador.

Además de los datos explícitos enviados, se envía otra información de protocolo HTTP como son las cabeceras de respuesta generadas por el servidor (igual en la petición; el cliente envía datos más las cabeceras de petición generadas por él). Estas cabeceras de respuesta incluyen una línea como la siguiente:

Content-type: text/html

Esta línea identifica el tipo del documento; en este caso se trata de un documento HTML. Cuando el cliente reciba esta información, sabrá cómo interpretar el tipo de documento que tiene que visualizar. Para establecer este valor, procesarPeticion utiliza el método setContentType del objeto response.

Proyecto asignatura (Conectividad con Oracle):

// Codigo ejemplo de conectividad Java-Oracle. Si se utiliza un IDE, se debe importar la clase odbc14.jar que viene en la carpeta C:\oraclexe\app\oracle\product\10.2.0\server\jdbc\lib

package conexion;

import java.sql.*;
import javax.swing.JOptionPane;

/**
* 25/10/2010
* @author vGus
*/
public class ConexionOracle {
public static void main( String [] args ){
String url, password, nombreUsuario;

url = “jdbc:oracle:thin:@localhost:1521:xe”;
password = “ORACLE”;
nombreUsuario = “SYSTEM”;

// 1. Cargar el driver para conexion con Oracle
try {
Class.forName( “oracle.jdbc.driver.OracleDriver” );
}
catch ( ClassNotFoundException error ) {
System.out.println( error.getMessage() );
}

try{
// 2. Establecer conexion con la Base de Datos
Connection conexion = DriverManager.getConnection( url,
nombreUsuario, password );
Statement instruccion = conexion.createStatement();

String criterio = JOptionPane.showInputDialog(
“Por favor, ingrese el criterio de busqueda”);

ResultSet rset = instruccion.executeQuery(”select * from s_dept where name like ‘” + criterio + “%’ “);

while( rset.next() ){
System.out.println( rset.getString(1) + ” – ” +
rset.getString(2) );
}
instruccion.close();
}
catch( SQLException error ){
System.out.println( error.getMessage() );
}

}
}

Solución ejercicio del <Empleado>:

import javax.swing.*;

class Fecha{
private int dd,mm,aa;
public void setFecha(int dd,int mm,int aa){
this.dd = dd;
this.mm = mm;
this.aa = aa;
}
public int getDia(){
return dd;
}
public int getMes(){
return mm;
}
public int getAnio(){
return aa;
}
}

class Empleado{
private int codigo;
private String nombre;
private double salario;
private Fecha fechaIngreso;
public void setCodigo(int codigo){
this.codigo=codigo;
}
public void setNombre(String nombre){
this.nombre=nombre;
}
public void setSalario(double salario){
this.salario=salario;
}
public int getCodigo(){
return codigo;
}
public String getNombre(){
return nombre;
}
public double getSalario(){
return salario;
}
public int getDiaIngres(){
return (fechaIngreso.getDia());
}
public int getMesIngres(){
return (fechaIngreso.getMes());
}
public int getAñoIngres(){
return (fechaIngreso.getAnio());
}
public double getBonif(){
return (salario+salario*7/100);
}
}

public class TestEmpleado {

public static void main(String[] args) {
int dd,mm,aa,codigo;
double salario;
String nombre;
Empleado emp = new Empleado();
Fecha fechaIngreso = new Fecha();
codigo=Integer.parseInt(JOptionPane.showInputDialog(”Codigo del empleado?”));
nombre=JOptionPane.showInputDialog(”Nombre del empleado?”);
salario=Double.parseDouble(JOptionPane.showInputDialog(”Salario?”));
dd=Integer.parseInt(JOptionPane.showInputDialog(”Fecha de ingreso a la empresa: Dia?”));
mm=Integer.parseInt(JOptionPane.showInputDialog(”Mes?”));
aa=Integer.parseInt(JOptionPane.showInputDialog(”Año”));
fechaIngreso.setFecha(dd,mm,aa); //Paso de parámetros
emp.setCodigo(codigo);
emp.setNombre(nombre);
emp.setSalario(salario);
JOptionPane.showMessageDialog(null, “Codigo: “+emp.getCodigo()+”\nNombre: “+emp.getNombre()+”\nSalario: $”+emp.getSalario());
JOptionPane.showMessageDialog(null, “Fecha de ingreso a la empresa (dd/mm/aa): “+fechaIngreso.getDia()+”/”+fechaIngreso.getMes()+”/”+fechaIngreso.getAnio()+”\nNuevo salario (bonificacion 7%): $”+emp.getBonif());
}
}

PROYECTODE ASIGNATURA

Nr. 1 :  (40%)

Actividades : A/DOO y POO
Modelado: UML con NetBeans / ArgoUML
Herramientas: Tecnología Java –  SGBD: MySQL
Equipo  : Cinco integrantes

Especificación del sistema:

Aplicación de Mensajería instantánea

El objetivo de esta aplicación es construir un sistema de mensajería al estilo del MSN Messenger, Yahoo Messenger, GTalk de Gmail o AIM. Para esto será necesario construir una aplicación que funcione como servidor y como cliente: los usuarios de la aplicación utilizarán el cliente para conectarse al servidor y este les informará sobre el estado de sus amigos (están conectados o desconectados).

Cada uno de los usuarios de la aplicación tiene un nombre con el que se identifica en el sistema y puede construir una lista de amigos. Mientras esté utilizando el sistema, recibirá notificaciones cuando sus amigos se conecten o desconecten. El hecho de que un usuario tenga dentro de su lista de amigos a otro usuario no implica que al revés también sea cierto.

Dos amigos que estén conectados pueden establecer una conversación entre ellos. No es posible establecer conversaciones entre tres personas, pero sí se pueden tener varias conversaciones al mismo tiempo.

Finalmente, es importante mencionar que la información sobre los usuarios y sus amigos se almacena en una base de datos relacional (MySQL), a la que se tiene acceso desde la aplicación del servidor.

Interfaz del Cliente

mensajinst11

Interfaz del Servidor

mensajinst21

Durante el semestre se entregarán avances del proyecto así:

1> Mes: Análisis (10%)
2> Mes: Diseño (10%)
3> Mes: Implementación (10%)
4> Mes: Sustentación.
(10%)

Cada grupo organizará la entrega del producto software y la correspondiente sustentación de su sistema. Serán designados libremente dos expositores.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos necesarios están marcados *