HolaMundo.java (online)

Reestructurando el Blog

2008-07-23T07:54:00.010-03:00

Estimado lector, a partir del día de la fecha el blog HolaMundo.java comenzará a ser reestructurado (valga la paradoja).
Por favor, disculpe las molestias.

Pablo.

PROGRESO 68%.....
(6/Julio/2009).

PROGRESO 60%.....
(30/Abril/2009)

Falta poco... solo un poco más de paciencia...
(29/Diciembre/2008)

Este es el responsable de la demora en la reestructuración del blog:

Las quejas por favor remitirlas a OctavianitoSZ.
Gracias.

Felíz 2009,
Pablo.
.

Introducción

2008-01-12T14:34:00.001-02:00

.
Java es un lenguaje de programación orientado a objetos de propósitos generales con una sintaxis similar a la de C o C++.

Cuando apereció Java (mediados de 1995) llegó con dos propuestas que lo distinguían de los otros lenguajes:

La posibilidad de desarrollar Applets
El hecho de ser un lenguaje Multiplataforma

Applets

Los Applets son programas Java con la “habilidad” de poder correr dentro de una página web, dentro de un browser. Una página puede incluir Applets con un TAG especial como se muestra a continuación:

   1:
   2:<html>
   3:<body>
   4:<applet code ="MiApplet.class" 
   5:        height="300"
   6:        width  = "300"></applet>
   7:</body>
   8:</html>
   9:

En aquella época los browsers (Netscape 3, Internet Explorer 2) traían incorporada la máquina virtual Java por lo tanto el mismo browser era suficiente para correr el Applet.

El problema de los applets es que si son medianamente complejos pueden ocupar unos cuantos KBytes y (en aquellos tiempos, con modems de 14400) realmente se hacían difíciles de descargar.

Hoy en día los Applets tienen otro problema: los browsers no traen la máquina virtual, por lo tanto para poder ver páginas que incluyan Applets tenemos que instalar un plugin especial lo que (al menos para mi) resulta bastante molesto.

Podríamos decir que los Applets murieron. Hoy existe tecnología mucho más dinámica y liviana que permite añadir funcionalidad a una página web: AJAX, Flex, etc. Como ejemplo simplemente tenemos que ver cualquiera de los servicios de Google.

Multiplataforma

La Multiplataforma es el principal feature de Java. Un programa Java puede correr en cualquier sistema operativo y en cualquier hardware sin tener que ser recompilado. Esto se debe a que en realidad el programa corre interpretado por una máquina virtual llamada JVM (Java Virtual Machine) o JRE (Java Runtime Enviroment).

Actualmente existe JRE disponible practicamente para todas las plataformas (Sistema Operativo + Hardware). Esto quiere decir que un programa Java puede correr en:

Windows
Linux
Solaris
AIX
Macintosh
AS 400
Etc.

Si el sistema operativo no trae incorporada la máquina virtual o si trae una versión vieja la podemos descargar para instalar y/o actualizar de http://java.sun.com.

Versiones

Cuando comenzé con Java la versión estable era: JDK1.0.2 (Java Development Kit). Luego salió la versión JDK1.1.x, luego la JDK1.2.x y así.

Lo interesante es que cada nueva versión incluye a la anterior por lo tanto quien comenzó trabajando con JDK1.0.2 no tuvo que "descartar todo lo que sabia" para pasar a JDK1.1.x.

Sin embargo, entre versión y versión se aplican ciertas mejoras y/o correcciones. Por ejemplo: JDK1.1 incorporó la tecnología JavaBeans. Basicamente esta tecnología describe un bean como un objeto con sus atributos y métodos de acceso (accesors methods): setters y getters, y convirtió a todos los componentes gráficos en beans.

En JDK1.1 los componentes gráficos (botones, combos, areas de texto, etc) se convirieron en JavaBeans y se agregaron los métodos de acceso para sus atributos. Por ejemplo: para el atributo size de los componentes gráficos se agregaron los métodos getSize y setSize para asignar un nuevo tamaño al componente. El viejo método que haciá esto se llamaba resize y quedó obsoleto o deprecated. Esto implica que si intentamos compilar un programa que aplique el método resize sobre un componente el compilador va a mostrar un warning indicando que ese método quedó obsoleto e invitándonos a consultar la documentación para conocer las causas y cual es el método por el cual lo tenemos que reemplazar.

La imagen permite ver como Eclipse (la herramienta que vamos a utilizar) nos indica que estamos utilizando un método deprecated.

A partir de JDK1.2 se aplicó un cambio de nomemclatura, se comenzó a hablar de Java 2 y se crearon dos distribuciones:

J2SE – "Java 2 Standard Edition"
J2EE – "Java 2 Enterprise Edition"

J2SE es el lenguaje de programación propiamente dicho: compilador, librerías básicas (que incluyen las clases String, Object, System, etc) y herramientas de desarrollo como el debugger, un documentador, etc.

J2EE son “extensiones para el desarrollo de aplicaciones empresariales”. Esto lo veremos un poco más adelante pero podemos ir adelantando que incluye (por ejemplo) la tecnología Java desarrollar aplicaciones WEB: Servlets, JSP, etc.

Comparando Java con C y C++

Algunas diferencias

Si comparamos Java con C o C++ veremos que Java es mucho más simple. Por ejemplo: en C o C++ los strings son arrays de caracteres con un último caracter ‘\0’ (barra cero). En Java tenemos la clase String que permite manejar cadenas de caracteres a “alto nivel” como en los otros lenguajes.

String s1 = “Hola, ”;
String s2 = “que tal...???”;
String s3 = s1 + s2;

Respecto de los booleans, en C y C++ se manejan con valores numéricos enteros. Una variable int con valor 0 (cero) representa false y con valor distinto de cero representa true. En Java existe el tipo boolean.

boolean b1 = true; // asigno true a b1
boolean b2 = !b1; // asigno la negacion de b1 a b2
boolean b3 = "esto es una cadena".length()<=0;

En b3 estamos asignando el resultado lógico de la proposición:

“esto es una cadena”.length()<=0

“esto es una cadena” es un literal String; es un String por lo tanto es un objeto y como tal tiene métodos. En este caso aplicamos el método length que retorna la longitud del String y la comparamos con cero para asignar true o false según sea el resultado.

Otro punto importante que diferencia a Java de C y C++ es la liberación de memoria. En C alocamos memoria y cuando no la necesitamos más la tenemos que liberar.

char *s = “Esto es una cadena”;
free(s);
s = “Esta es otra cadena”:

En Java no es necesario liberar la memoria que vamos a desreferenciar porque existe el Garbage Collector (o recolector de residuos) que se ocupa de liberar la memoria a medida que queda desreferenciada.

String s = “Esto es una cadena”;
s = “Esto es otra cadena”;

Respecto de C++, en Java no existe herencia múltiple. Todas las clases heredan de la clase base Object (como en Smalltalk). Tampoco existen los destructores ni la sobrecarga de operadores.

Algunas Similitudes

Los tipos de datos primitivos son idénticos: short, int, long, float, double, char. Java además agrega: byte y boolean.

Las sentencias para codificar las estructuras de control: while, do while, for, if y switch son las mismas.

Los operadores lógicos y binarios son los mismos también.

Veamos algunas comparaciones:

HolaMundo.c

   1:
   2:#include <stdio.h>
   3:
   4:int main()
   5:{
   6:   /* imprime en stdout */
   7:   printf("Hola Mundo C");
   8:}
   9:

HolaMundo.java

   1:
   2:public class HolaMundo
   3:{
   4:   public static void main(String args[])
   5:   {
   6:      /* imprime en stdout */
   7:      System.out.println("Hola Mundo Java");
   8:   }
   9:}
  10:

En Java cualquier programa (incluso un simple "Hola Mundo") debe ser una clase ya que es un lenguaje fuertemente orientado a objetos.

El "printf" de Java es el System.out.println. La función main debe ser pública y estática (temas que veremos en el capítulo de objetos). Los comentarios, llaves y "punto y coma" son idénticos a C (también se puede comentar con "//" como en C++).

Numeros.c

   1:
   2:#include <stdio.h>
   3:
   4:int main(int argc, char **argv)
   5:{
   6:   int i,n;
   7:   if( argc<2 )
   8:   {
   9:      printf("Debe pasar el argumento");
  10:      return 0;
  11:   }
  12:
  13:   n=atoi(argv[1]);
  14:   for( i=0; i<n; i++ )
  15:   {
  16:      printf("%d\n",i);
  17:   }
  18:   return 0;
  19:}
  20:

Numeros.java

   1:
   2:import java.lang.*;
   3:
   4:public class Numeros
   5:{
   6:   public static void main(String args[])
   7:   {
   8:      int i,n;
   9:
  10:      if( args.length<1 )
  11:      {
  12:         System.out.println("Debe pasar el argumento");
  13:         return;
  14:      }
  15:
  16:      n = Integer.parseInt(args[0] );
  17:      for( i=0; i<n; i++ )
  18:      {
  19:         System.out.println(i);
  20:      }
  21:   }
  22:}
  23:

En este ejemplo vemos que el for y el if son los mismos que en C. El "atoi" (función de para convertir cadenas en valores enteros) en Java es el Integer.parseInt.

J2EE (o JEE) – “Java Enterprise Edition”

J2EE es una extensión de Java para facilitar el desarrollo de aplicaciones empresariales entendiendo “Aplicación Empresarial” como una aplicación marcada por un importante nivel de requerimientos no funcionales.

Por ejemplo, si hablamos de una aplicación de "home banking", un requerimiento funcional podría ser: “dado el número de una cuenta mostrar todos sus movimientos” pero el requerimiento funcional puede acotarse con un requerimiento no funcional diciendo “además, la pantalla que muestra los movimientos debe emitirse en menos de 3 segundos”.

De lo anterior se desprende que las aplicaciones enterprise deben tener buena respuesta, buena performance y demás habilidades que (en conjunto) se comocen como atributos de una arquitectura.

Disponibilidad
Escalabilidad
Confiabilidad
Seguridad

Es decir: una aplicación empresarial siempre debe estar disponible para su acceso, debe soportar incrementos de carga (sin que esto implique un costo demasiado elevado), debe ser segura, etc.

Para cumplir con todos estos requisitos las aplicaciones enterprise corren sobre un entorno operativo compuesto por diferentes servidores como ser: servidores de bases de datos, servidores de mensajería, servidores de nombres y directorios, de transacciones, etc.

J2EE provee APIs para que desde nuestros programas Java podamos interactuar con los servicios disponibles en un entorno de cómputo empresarial.

El gráfico muestra como una aplicación accede a los servicios empresariales (entorno operativo) a través de las diferentes APIs provistas por J2EE.

Además, por medio de la tecnología de interfaces y fábricas de instancias (factory method) J2EE permite que los programas Java accedan a los servidores que componen el entorno operativo sin que el programador tenga que preocuparse por la marca o fabricante del producto.

El fabricante del producto (Oracle por ejemplo) debe proveer un driver a través del cual se pueda establecer la conexión con su (en este caso) base de datos. El driver se sitúa en el medio, entre la base de datos y un conjunto de métodos definidos por las APIs J2EE en diferentes interfaces de forma tal que nuestro programa accede a los servicios del driver solo a través de los métodos definidos estas APIs. Esto permite que tan solo cambiando el driver nuestro programa pueda conectarse a otra base de datos sin tener que hacer ningún otro cambio.

También son parte de J2EE las APIs para generar contenido web dinamicamente. Servlets y JSP.

.

DWR - AJAX

2007-10-21T15:40:00.000-03:00

.
AJAX es un acrónimo que significa "Asynchonous JavaScript XML".

En si AJAX es una técnica de programación web mediante la cual una página web puede intercambiar información con el servidor en forma asincrónica, de manera tal que la página puede actualizarse sin necesidad de ser recargada. El cliente (browser con la página web) y el servidor mantienen una comunicación asincrónica y en background.

En sí, AJAX es netamente JavaScript pero en este capítulo vamos a explicar un framework que permite invocar desde JavaScript (browser, cliente) métodos remotos, en el servidor implementados en Java.

DWR - Direct Web Remoting

DWR es un framework open soucre que ofrece una alternativa estilo RPC (invocación remota de procedimientos) entre el cliente (browser) y el servidor. Utilizando DWR podemos invocar métodos vía JavaScript pero que se procesarán en el server. DWR se encarga de todo el marshalling de la comunicación.

DWR cconsiste en dos partes principales:

Un servlet corriendo en el server que procesa los requests y envia los responses al browser
JavaScript corriendo en el browser que envia los requests y puede dinámicamente actualizar la página HTML.

El JavaScript necesario para establecer la invocación remota de métodos se genera “on the fly” por lo que se minimiza bastante el código cliente que debemos escribir.

Hola Mundo DWR !

Para comenzar veremos como configurar DWR en nuestro proyecto web y luego desarrollaremos un HolaMundo. El siguiente tutorial (paso a paso) está sacado del sitio oficial de DWR: http://getahead.org/dwr/getstarted

1 - Descargar el archivo dwr.jar y copiarlo en el directorio WEB-INF/lib de la aplicación web.

2 - Agregar las siguientes líneas en el web.xml de la aplicación web.

   1:
   2:   <servlet>
   3:      <servlet-name>dwr-invoker</servlet-name>
   4:      <servlet-class>
   5:         org.directwebremoting.servlet.DwrServlet
   6:      </servlet-class>
   7:      <init-param>
   8:         <param-name>debug</param-name>
   9:         <param-value>true</param-value>
  10:      </init-param>
  11:   </servlet>
  12:
  13:   <servlet-mapping>
  14:      <servlet-name>dwr-invoker</servlet-name>
  15:      <url-pattern>/dwr/*</url-pattern>
  16:   </servlet-mapping>
  17:

3 - Crear un archivo llamado dwr.xml en el directorio WEB-INF de la aplicación web, con el siguiente código.

dwr.xml

   1:
   2:<!DOCTYPE dwr PUBLIC
   3:"-//GetAhead Limited//DTD Direct Web Remoting 1.0//EN"
   4:"http://www.getahead.ltd.uk/dwr/dwr10.dtd">
   5:
   6:<dwr>
   7:  <allow>
   8:    <create creator="new" javascript="JDate">
   9:      <param name="class" value="java.util.Date"/>
  10:    </create>
  11:  </allow>
  12:</dwr>
  13:

4 - Ahora probemos ingresar en nuestra aplicación web, en el directorio dwr:

http://localhost:8080/[YOUR-WEBAPP]/dwr/

DWR mostrará una página en la que podremos ver todas las clases publicadas, cuyos métodos podrán ser invocados vía JavaScript.

En este caso (a modo de ejemplo) solo está publicada la clase JDate (la de java.util). Recordemos que cuando creamos el archivo dwr.xml, definimos que íbamos a utilizar esta clase.

5 - Si hacemos "click" en JDate entonces veremos una página en la que podremos probar todos los métodos de (en este caso) JDate. Algo así:

Además (en la parte superior) veremos el código que tenemos que incluir en nuestro JSP o HTML para poder invocar al objeto remoto.

Ahora si, Hola Mundo !

Con el proyecto web correctamente configurado para poder utilizar DWR estamos en condiciones de hacer el primer ejemplo.

6 - Creamos la clase HolaMundoDWR.

HolaMundoDWR.java

   1:
   2:package test;
   3:
   4:public class HolaMundoDWR
   5:{
   6:    public String saludo(String n)
   7:    {
   8:        return "Hola Mundo, "+n;
   9:    }
  10:}
  11:

7 - Tenemos que publicar la clase en DWR. Para esto agregamos el siguiente código en el archivo dwr.xml.

   1:
   2:    <create creator="new" javascript="HolaMundoDWR">
   3:      <param name="class" value="test.HolaMundoDWR"/>
   4:    </create>
   5:

8 - Volvemos a ingresar en el directorio dwr de la aplicación web para asegurarnos que la clase HolaMundoDWR fue correctamente deployada.

http://localhost:8080/[YOUR-WEBAPP]/dwr/test/HolaMundoDWR

Si todo está bien veremos la siguiente página:

En esta página podemos probar el método saludo, pero también DWR nos muestra los scripts que tenemos que incluir en nuestra página JSP si queremos invocar métodos de la clase HolaMundoDWR. También nos sugiere incluir el script util.js que será muy util para actualizar dinámicamente contenido HTML.

9 - Ahora si, podemos programar la página JSP.

testDWR.jsp

   1:
   2:<html>
   3:   <head>
   4:     <!-- incluimos los scripts que nos indico   -->
   5:     <!-- la pagina de prueba de DWR             -->
   6:     <script 
   7:         type='text/javascript' 
   8:         src='/ZDWR/dwr/interface/HolaMundoDWR.js'>
   9:     </script>
  10:     <script type='text/javascript' 
  11:             src='/ZDWR/dwr/engine.js'>
  12:     </script>
  13:     <script type='text/javascript' 
  14:             src='/ZDWR/dwr/util.js'></script>
  15:   </head>
  16:
  17:   <body>
  18:      <!-- es muy importante el id (tfNom)       -->
  19:      Nombre <input type="text" id="tfNom">
  20:
  21:      <!-- en el onclick del boton llamamos a la -->
  22:      <!-- funcion saludo() que esta mas abajo   -->
  23:
  24:      <input value="Enviar" 
  25:             type="button" 
  26:             onclick="saludo()" />
  27:      <br>
  28:      <!-- notemos que el spam tiene un id       -->
  29:      Respuesta: <b><span id="lblNom" /></b>
  30:
  31:   </body>
  32:</html>
  33:
  34:<!-- ahora desarrollamos la funcion saludo que   -->
  35:<!-- obtiene el nombre que ingresamos en tfNom,  -->
  36:<!-- invoca a la funcion remota y setea en el    -->
  37:<!-- span (lblNom) el resultado recibido         -->
  38:<script>
  39:   function saludo()
  40:   {
  41:      // obtenemos el nombre ingresado por el usuario
  42:      var nom = dwr.util.getValue("tfNom");
  43:
  44:      // invocamos la funcion remota pasandole nom 
  45:      // y una funcion de callback que DWR invocara 
  46:      // cuando la informacion enviada por el server 
  47:      // este disponible en para ser utilizada
  48:      HolaMundoDWR.saludo(nom, function(data)
  49:      {
  50:            // seteamos el resultado en el span
  51:            dwr.util.setValue("lblNom", data);
  52:      });
  53:   }
  54:</script>
  55:

Podemos ver que con la librería util.js podemos acceder muy facilmente a los objetos de la página para obtener los datos que tienen cargados y para setearles resultados.

Para invocar al método remoto saludo necesitamos utilizar una función de callback. Esto se debe a que Java es sincrónico pero AJAX es asincrónico por lo tanto le pasamos esta función para que DWR la invoque cuando la información enviada por el servidor esté disponible y pueda ser utilizada en el browser. Allí seteamos el resultado en el span lblNom.

Manipulación de Objetos HTML

Como vemos, DWR resuelve de manera extremadamente simple la invocación remota de métodos entre la página HTML (o JSP) y la clase Java que los implementa. Por lo tanto la mayor complejidad está dada en poder actualizar dinámicamente el contenido HTML con la información que llega desde el servidor.

Para esto DWR provee una librería de funciones JavaScript llamada: util.js. Veremos algunos ejemplos de como actualizar contenido dinámicamente utilizando esta librería.

Combos Dependientes

En este ejemplo veremos como actualizar el contenido de un combo dependiendo de lo que el usuario selecciona en otro combo.

Para esto programamos la siguiente clase que basicamente proveerá dos métodos:

Collection obtenerArtistas();
Collection obtenerDiscos(String artista);

Es decir: el primer método retornará una Collection de Strings con los nombres de los artistas "registrados en una base de datos" y el segundo método, dado un nombre de artista retornará todos los discos de ese artista que "tenemos registrados".

Para simplificar, los datos los harcodearemos en una Hashtable.

CatalogoCD.java

   1:
   2:package test;
   3:import java.util.*;
   4:
   5:public class CatalogoCD
   6:{
   7:    private Hashtable artistas;
   8:
   9:    public CatalogoCD()
  10:    {
  11:        artistas=new Hashtable();
  12:        _cargarInformacion();
  13:    }
  14:
  15:    // retorna una Collection de Strins con los
  16:    // artistas que tenemos registrados
  17:    public Collection obtenerArtistas()
  18:    {
  19:        Vector v=new Vector();
  20:        for(Enumeration e=artistas.keys()
  21:                              ;e.hasMoreElements();)
  22:        {
  23:            v.add(e.nextElement());
  24:        }
  25:        return v;
  26:    }
  27:
  28:    // dado un artista, retorna una Collection de 
  29:    // Strings con los titulos de los discos del 
  30:    // artista especificado
  31:    public Collection obtenerDiscos(String artista)
  32:    {
  33:        return (Collection) artistas.get(artista);
  34:    }
  35:
  36:    // todo harcodeado...
  37:    private void _cargarInformacion()
  38:    {
  39:        Vector v1=new Vector();
  40:        v1.add("Please Please Me");
  41:        v1.add("Abbey Road");
  42:        v1.add("Magical Mistery Tour");
  43:        artistas.put("The Beatles",v1);
  44:
  45:        Vector v2=new Vector();
  46:        v2.add("Demasiado Ego");
  47:        v2.add("La Hija de la Lagrima");
  48:        v2.add("Say No More");
  49:        v2.add("Kill Gil");
  50:        artistas.put("Charly Garcia",v2);
  51:
  52:        // sexo Ibiza Locomia...!
  53:        Vector v3=new Vector();
  54:        v3.add("A Ibiza con Locomia");
  55:        v3.add("Abanicos Por Doquier!");
  56:        artistas.put("Locomia",v3);
  57:    }
  58:}
  59:

Para registrar la clase como servicio en DWR tenemos que agregar las siguientes líneas en el archivo dwr.xml.

   1:
   2:   <create creator="new" javascript="CatalogoCD">
   3:      <param name="class" value="test.CatalogoCD"/>
   4:   </create>
   5:

Ahora vamos a:
http://localhost:8080/[YOUR-WEBAPP]/dwr/test/CatalogoCD

para ver los scripts que debemos incluir en la página JSP.

Y ahora veamos la página JSP:

discos.jsp

   1:
   2:<html>
   3:   <head>
   4:      <script 
   5:         type='text/javascript' 
   6:         src='/TestAjax/dwr/interface/CatalogoCD.js'>
   7:      </script>
   8:      <script 
   9:         type='text/javascript' 
  10:         src='/TestAjax/dwr/engine.js'>
  11:      </script>
  12:      <script 
  13:         type='text/javascript' 
  14:         src='/TestAjax/dwr/util.js'>
  15:      </script>
  16:
  17:      <script>
  18:      function obtenerArtistas()
  19:      {
  20:         CatalogoCD.obtenerArtistas(function(data){
  21:            dwr.util.removeAllOptions("cbArtista");       
  22:            dwr.util.addOptions("cbArtista", data);
  23:            obtenerDiscos();
  24:         });
  25:      }
  26:
  27:      function obtenerDiscos()
  28:      {
  29:         var art = dwr.util.getValue("cbArtista");
  30:         CatalogoCD.obtenerDiscos(art,function(data)
  31:         {
  32:            dwr.util.removeAllOptions("cbDisco");
  33:            dwr.util.addOptions("cbDisco", data);
  34:         });
  35:      }
  36:      </script>
  37:   </head>
  38:
  39:   <body>
  40:      <input type="button" 
  41:             value="Cargar" 
  42:             onclick="obtenerArtistas()" />
  43:      <select id="cbArtista" 
  44:              onChange="obtenerDiscos()" />
  45:      <select id="cbDisco" />
  46:   </body>
  47:</html>
  48:

Como vemos, la página en si comienza a partir de la línea 39. Tenemos dos select (combos), uno con id="cbArtista" y el otro con id="idDisco" y un button.

En el evento onclick del botón invocamos a la función obtenerArtistas, y en el evento onChange del combo de artistas invocamos a la función obtenerDiscos.

Analicemos entonces la función obtenerArtistas (que se encuentra a partir de la línea 18).

17:
18:      function obtenerArtistas()
19:      {
20:         CatalogoCD.obtenerArtistas(function(data){
21:            dwr.util.removeAllOptions("cbArtista");        
22:            dwr.util.addOptions("cbArtista", data);
23:            obtenerDiscos();
24:         });
25:      }
26:

La función invoca a CatalogoCD.obtenerArtistas pasándole una función callback en la que primero removemos todos los items del combo y luego seteamos en el combo de artistas la colección que retorna el método Java. Por último invocamos a la función obtenerDiscos para cargargar los discos del artistas que quedó seleccionado.

El código de la función obtenerDiscos está a partir de la línea 27 y lo podemos ver a continuación.

26: 
27:      function obtenerDiscos()
28:      {
29:         var art = dwr.util.getValue("cbArtista");
30:         CatalogoCD.obtenerDiscos(art,function(data)
31:         {
32:            dwr.util.removeAllOptions("cbDisco");
33:            dwr.util.addOptions("cbDisco", data);
34:         });
35:      }
36:

En esta función tomamos el valor que se encuentra seleccionado en el combo de artistas y lo asignamos a la variable art. Luego invocamos a la función CatalogoCD.obtenerDiscos pasándole art y una función callback dentro de la cual borramos los items del combo de discos y seteamos en dicho combo la colección que retorna el método Java.

El resultado será:

Web Services

2007-10-15T16:07:00.000-03:00

.
Web Services es una tecnología middleware que permite exponer como servicio la funcionalidad de los componentes de nuestra aplicación de forma tal que dicha funcionalidad pueda ser accedida en forma remota.

Con Web Services podemos brindar acceso a cierta funcionalidad de nuestros sistemas para mejorar el intercambio de información con nuestros clientes y proveedores, y (por otro lado) podemos incrementar la funcionalidad de nuestras aplicaciones mediante el uso de servicios web externos.

Fundamentos de los Web Services

Un web service es un servicio provisto por alguien al cual podemos acceder para utilizarlo. El servicio puede estar implementado con cualquier tecnología por lo tanto (el proveedor del servicio) debe ofrecer un archivo con extensión wsdl en el que describa los detalles del servicio que provee. Esto es: que mensajes se intercambian, que parámetros se deben pasar, que errores puede tirar, etc.

En este capítulo veremos como utilizar Web Services provistos por terceras partes y (luego) como desarrollar y publicar nuestros propios servicios.

Invocar Web Services provistos por Terceros

Para poder invocar y utilizar un web service primero necesitaremos tener acceso a su wsdl. Luego tendremos que utilizar alguna API que nos permita (desde Java) invocarlo e interactuar con el servicio para lograr el intercambio de mensajes. Esta API (así como las herramientas necesarias) nos la proveerá AXIS, un producto open source de Apache.

A continuación veremos paso a paso como instalar AXIS y luego como utilizarlo para poder invocar un servicio provisto por terceras partes.

Instalar AXIS

1 - Descargar AXIS desde esta dirección: http://apache.patan.com.ar/ws/axis/1_4/axis-src-1_4.zip y descomprimirlo en algún directorio.

2 - Descargar los archivos activation.jar y mail.jar y copiarlos en el directorio $AXIS_HOME/lib.

Configurar un Proyecto en Eclipse

3 - Antes de comenzar con nuestro proyecto lo mejor será crear una librería que agrupe todos los jar de AXIS. Para esto vamos al menú Windows -> Preferences y seleccionamos la opción Java -> Build Path -> User Libraries como vemos a continuación.

Presionando el botón New podemos crear una nueva librería. En este caso vamos a llamarla AXIS_1.4.

4 - Presionando el botón Add Jars... (ubicado a la derecha de la ventana) tenemos que agregar todos los jar que se encuentran en el directorio $AXIS_HOME/lib, incluyedo el mail.jar y el activation.jar que descargamos por separado.

5 - Ahora si, creamos un proyecto Java (común) y en las preferencias del proyecto le agregamos la librería AXIS_1.4 que creamos recién. Esto lo hacemos clikeando en el nombre del proyecto con el botón derecho, seleccionamos Properties - > Java Buil Path -> Libraries - > User Libraries -> Next.

Crear un Cliente para un Web Service

Ahora que tenemos creado un proyecto con los jars necesarios para trabajar con AXIS vamos a crear un cliente que nos permita invocar un servicio web.

En esta página tenemos Web Services publicados que podemos utilizar para realizar pruebas: http://xmethods.com/

Comenzaremos por probar un servicio que, dado un código postal de Estados Unidos retorna el nombre de la localidad. Su wsdl es el siguiente:
http://webservices.imacination.com/distance/Distance.jws?wsdl

AXIS proporciona una herramienta que lee el wsdl y genera las clases Java necesarias para establecer la conexión con el servicio e invocarlo de forma simple y transparente. Esta herramienta es una clase llamada WSDL2Java. También está la herramienta inversa: Java2WSDL que permite generar el wsdl para una clase Java que querramos exponer como servicio web.

1 - Tenemos que generar las clases para interactuar con el web service. Para esto abrimos la librería AXIS_1.4 y buscamos la clase WSDL2Java.class dentro del paquete org.apache.axis.wsdl tal como vemos en la imagen.

2 - La clase WSDL2Java recibe como argumento en línea de comandos la dirección del wsdl que debe mapear. Para pasarle este parámetro hacemos "click" con el botón derecho sobre la clase y seleccionamos Run As -> Run -> Arguments y en "Program Arguments" pegamos la dirección del wsdl:
http://webservices.imacination.com/distance/Distance.jws?wsdl

3 - Una vez que ejecutamos la clase, AXIS generará en el directorio del proyecto las clases necesarias para invocar e interactuar con el web service. Las podemos ver si hacemos "Refresh" sobre el proyecto.

4 - Para poder utilizar estas clases tenemos que copiar toda la rama (desde el directorio com) en nuestro directorio de clases. Simplemente lo hacemos copiando [CTRL+C] y pegando [CTRL+V] desde eclipse.

Entre las clases que generó AXIS tenemos Distance.java. Esta es la interface que define todos los servicios expuestos detrás del web service.

Distance.java

   1:
   2:package
   3:com.imacination.webservices.distance.Distance_jws;
   4:
   5:import java.rmi.RemoteException;
   6:public interface Distance extends java.rmi.Remote
   7:{
   8:    public String getState(String zip)
   9:                             throws RemoteException;
  10:   
  11:    public String getLocation(String zip)
  12:                             throws RemoteException;
  13:   
  14:    public String getCity(String zip)
  15:                             throws RemoteException;
  16:   
  17:    public double getDistance(String from,String to)
  18:                             throws RemoteException;
  19:   
  20:    public double getLatitude(String zip)
  21:                             throws RemoteException;
  22:   
  23:    public double getLongitude(String zip)
  24:                             throws RemoteException;
  25:}
  26:

Veamos ahora nuestro cliente que utiliza estas clases para invocar los servicios expuestos detrás del web service:

Test1WS.java

   1:
   2:package test;
   3:
   4:import com.imacination
   5:        .webservices.distance.Distance_jws.*;
   6:
   7:public class TestWS1
   8:{
   9:    public static void main(String[] args)
  10:    throws Exception
  11:    {
  12:        DistanceService  service =
  13:                     new DistanceServiceLocator();
  14:
  15:        // aqui obtenemos la interface a traves de
  16:        // la cual podemos invocar los metodos del
  17:        // web service
  18:        Distance distance=service.getDistance();
  19:
  20:        // nombre de la localidad zip=90210
  21:        String loc1=distance.getLocation("90210");
  22:        System.out.println("90210="+loc1);
  23:
  24:        // nombre de la localidad zip=14280
  25:        String loc2=distance.getLocation("14280");
  26:        System.out.println("14280="+loc2);
  27:
  28:        // calculo la distancia entre las dos
  29:        // localidades
  30:        double dist=distance.getDistance(
  31:                                  "90210","14280");
  32:        System.out.print("La distancia entre ");
  33:        System.out.print("["+loc1+"] y ["+loc2+"]");
  34:        System.out.println(" es: "+dist);
  35:    }
  36:}
  37:

Probemos ahora con otro web service, cuyo wdsl está publicado aquí:
http://demo.wsabi.org/axis/services/YahooUserPingService?wsdl

Este servicio permite saber si un usuario de Yahoo está logueado o no.

Debemos volver a correr WSDL2Java pasándole la dirección del wsdl del web service y luego copiar las clases generadas a la carpeta de código fuente del proyecto.

Luego, un cliente que pruebe el servicio puede ser este:

Test2WS.java

   1:
   2:package test;
   3:
   4:import org.wsabi.demo.axis.services.
   5:                           YahooUserPingService.*;
   6:
   7:public class TestWS2
   8:{
   9:    public static void main(String[] args)
  10:    throws Exception
  11:    {
  12:        YahooUserPingService service;
  13:        YahooUserPing ping;
  14:        boolean online;
  15:
  16:        service = new YahooUserPingServiceLocator();
  17:        ping = service.getYahooUserPingService();
  18:
  19:        onLine = ping.isUserOnLine("pabloszn");
  20:        System.out.println(onLine);
  21:    }
  22:}
  23:

Escribir Nuestros Propios Web Services

La forma más rápida y simple de instalar un web service en AXIS es utilizando la característica provista por AXIS llamada Instant Deployment.

Con Instant Deployment tan solo tenemos que escribir una clase Java con los métodos que queremos exponer y luego copiarla con extensión jws (Java Web Services) al directorio $AXIS_HOME/webapps/axis.

Veamos entonces el código de nuestro HolaMundo web service.

HolaMundoWS.java

   1:
   2:public class HolaMundoWS
   3:{
   4:    public String saludo(String nom)
   5:    {
   6:        return new String("Hola Mundo, "+nom);
   7:    }
   8:}
   9:

El próximo paso será copiar el archivo HolaMundoWS.java (el código fuente) en el directorio $AXIS_HOME/webapps/axis con el nombre HolaMundoWS.jws.

Ahora vamos a codificar un cliente que invoque el servicio.

HolaMundoClienteWS.java

   1:
   2:import javax.xml.rpc.ParameterMode;
   3:import org.apache.axis.client.Call;
   4:import org.apache.axis.client.Service;
   5:import org.apache.axis.encoding.XMLType;
   6:
   7:public class HolaMundoClient
   8:{
   9:    public static void main(String[] args)
  10:                                 throws Exception
  11:    {
  12:        // url del servicio que vamos a invocar
  13:        String endpointURL="http://localhost:8080"
  14:                     +"/axis/HolaMundoWS.jws";
  15:
  16:        // creamos una llamada remota
  17:        Service service = new Service();
  18:        Call call = (Call) service.createCall();
  19:
  20:        // seteamos el url
  21:        call.setTargetEndpointAddress(endpointURL);
  22:
  23:        // nombre del metodo a invocar
  24:        call.setOperationName("saludo");
  25:
  26:        // nombre del parametro, tipo de dato 
  27:        // y si es parametro de IN,OUT o INOUT
  28:        call.addParameter("nom"
  29:                        , XMLType.XSD_STRING
  30:                        , ParameterMode.IN);
  31:
  32:        // tipo de dato de retorno
  33:        call.setReturnType(XMLType.XSD_STRING);
  34:
  35:        // argumentos a pasar
  36:        Object params[]={ "PabloSZ" };
  37:
  38:        // invocamos el metodo remoto
  39:        String ret = (String) call.invoke(params);
  40:
  41:        // -- :O) --
  42:        System.out.println(ret);
  43:    }
  44:}
  45:

El tema ahora será levantar el servidor AXIS. Tenemos dos opciones:

1 - Levantar el server que trae axis. Para esto tenemos que correrlo en línea de comandos, posicionados en el directorio $AXIS_HOME/webapps y seteando en el CLASSPATH todos los jar que se encuentran en el directorio lib. Podríamos hacer un .bat que haga todo el trabajo por nosotros.

runServer.bat

   1:
   2:@echo off
   3:
   4:rem JH -> JAVA_HOME
   5:@SET JH=\java\jdk1.5.0
   6:
   7:rem AH -> AXIS_HOME
   8:@SET AH=\JAVA\axis-1_4
   9:
  10:rem ACS -> AXIS CLASS SERVER
  11:@SET ACS=org.apache.axis.transport.http
  12:@SET ACS=%ACS%.SimpleAxisServer
  13:
  14:rem CP -> CLASSPATH
  15:@SET CP=%AH%\lib\activation.jar;
  16:@SET CP=%CP%;%AH%\lib\axis.jar;
  17:@SET CP=%CP%;%AH%\lib\axis-ant.jar;
  18:@SET CP=%CP%;%AH%\lib\commons-discovery-0.2.jar;
  19:@SET CP=%CP%;%AH%\lib\commons-logging-1.0.4.jar;
  20:@SET CP=%CP%;%AH%\lib\jaxrpc.jar;
  21:@SET CP=%CP%;%AH%\lib\log4j-1.2.8.jar;
  22:@SET CP=%CP%;%AH%\lib\saaj.jar;
  23:@SET CP=%CP%;%AH%\lib\mail.jar;
  24:@SET CP=%CP%;%AH%\lib\wsdl4j-1.5.1.jar;
  25:
  26:%JH%\bin\java -cp %CP% %ACS%
  27:

2 - La otro opción es copiar el directorio axis (ubicado en $AXIS_HOME/webapps) al $TOMCAT_HOME/webapps. Es decir: deployar AXIS como una aplicación web en tomcat. Luego (obviamente) correr Tomcat.

Lamentablemente, algo tan simple solo puede servir para muy poco... Con Instant Deployment solo podemos deployar servicios que manejen tipos básicos (no clases nuestras serializables). Tampoco podemos utilizar paquetes, etc.

Para deployar web services un poco más complejos tendremos que deployarlos de otra forma, como veremos a continuación.

Custom Deployment

Para deployar un servicio con custom deployment será necesario escribir un archivo wsdd con código xml que describa el web service.

Vamos a plantear un ejemplo. Se trata de un servicio FacadeWS que tiene dos métodos: login y obtenerUsuarios. El método login recibe usuario y password y retorna un UsuarioDTO si el login fue exitoso o null si no lo fue. El método obtenerUsuarios retorna una Collection de UsuarioDTO con todos los usuarios registrados en el sistema.

1 - Creamos las clases UsuarioDTO.java y FacadeWS.java

UsuarioDTO.java

   1:
   2:package test.customdeploy;
   3:import java.io.Serializable;
   4:
   5:public class UsuarioDTO implements Serializable
   6:{
   7:    private String username;
   8:    private String password;
   9:    private String email;
  10:
  11:    // constructor nulo
  12:    public UsuarioDTO(){ }
  13:
  14:    // constructor con los campos
  15:    public UsuarioDTO(String username
  16:                     ,String password
  17:                     , String email)
  18:    {
  19:        this.username = username;
  20:        this.password = password;
  21:        this.email = email;
  22:    }
  23:
  24:    // getters
  25:    public String getUsername() { return username; }
  26:    public String getPassword() { return password; }
  27:    public String getEmail() { return email; }
  28:
  29:    // setters
  30:
  31:    public void setUsername(String username)
  32:    {
  33:        this.username = username;
  34:    }
  35:
  36:    public void setPassword(String password)
  37:    {
  38:        this.password = password;
  39:    }
  40:
  41:    public void setEmail(String email)
  42:    {
  43:         this.email = email;
  44:    }
  45:
  46:    // toString para poder imprimir facilmente un dto
  47:    public String toString()
  48:    {
  49:        return username+", "+password+", "+email;
  50:    }
  51:}
  52:

Como vemos, UsuarioDTO simplemente es un bean con atributos, setters y getters, e implementa la interface Serializable ya que debe viajar entre el servidor y el cliente.

Veamos ahora la clase FacadeWS.

FacadeWS.java

   1:
   2:package test.customdeploy;
   3:import java.util.*;
   4:
   5:public class FacadeWS
   6:{
   7:    private Hashtable usuarios;
   8:
   9:    public FacadeWS()
  10:    {
  11:        // tabla de usuarios
  12:        usuarios = new Hashtable();
  13:
  14:        // harcodeamos los usuarios
  15:        usuarios.put("juan"
  16:              ,new UsuarioDTO("juan"
  17:                            , "juan1"
  18:                            , "juan@pp.com"));
  19:        usuarios.put("jose"
  20:              ,new UsuarioDTO("jose"
  21:                            , "jose1"
  22:                            , "jose@toto.net"));
  23:        usuarios.put("pedro"
  24:              ,new UsuarioDTO("pedro"
  25:                            , "pedro1"
  26:                            , "pedro@locomia.org"));
  27:    }
  28:
  29:    // si el login es correcto retorna el UsuarioDTO
  30:    // si no es correcto retorna null
  31:    public UsuarioDTO login(String usr, String pwd)
  32:    {
  33:        // busco el usr en la tabla
  34:        UsuarioDTO dto=(UsuarioDTO)usuarios.get(usr);
  35:
  36:        // si existe...
  37:        if ( dto != null )
  38:        {
  39:            // si coincide el password... 
  40:            if ( dto.getPassword().equals(pwd) )
  41:            {
  42:                // retorno el dto !
  43:                return dto;
  44:            }
  45:            else
  46:            {
  47:                return null;
  48:            }
  49:        }
  50:        return null;
  51:    }
  52:
  53:    // retorna la coleccion de usuarios
  54:    public Collection obtenerUsuarios()
  55:    {
  56:        Vector ret = new Vector();
  57:        for( Enumeration e = usuarios.elements()
  58:                           ; e.hasMoreElements(); )
  59:        {
  60:            ret.add(e.nextElement());
  61:        }
  62:        return ret;
  63:    }
  64:}
  65:

2 - Creamos un .jar con el las clases que queremos deployar.

Teniendo definidas todas las clases involucradas (FacadeWS y UsuarioDTO, ambas en el paquete test.customdeploy) podemos crear el jar desde Eclipse "clikeando" con el botón derecho sobre el paquete test.customdeploy, seleccionando Export -> JAR File. o bien desde línea de comandos, parados en la carpeta src (padre de test) con el comando jar:

jar cvf test.jar test

El comando jar está ubicado en $JAVA_HOME/bin por lo tanto tenemos que asegurarnos que el PATH esté seteado correctamente.

3 - Copiamos el jar al directorio axis/WEB-INF/lib para que esté disponible en el CLASSPATH.

4 - Generamos el descriptor wsdd.

Como dijimos, para deployar un servicio con custom deployment será necesario escribir un archivo wsdd. Veamos entonces el descriptor para nuestro FacadeWS.

facadeWS.wsdd

   1:
   2:<deployment xmlns="http://xml.apache.org/axis/wsdd/" 
   3:  xmlns:java=
   4:   "http://xml.apache.org/axis/wsdd/providers/java">
   5:   <service name="FacadeWS" provider="java:RPC">
   6:      <parameter name="scope" 
   7:                 value="application" />
   8:      <parameter name="className" 
   9:                 value="test.customdeploy.FacadeWS"/>
  10:      <parameter name="allowedMethods" 
  11:                 value="*" />
  12:      <beanMapping qname="ns:UsuarioDTO"
  13:         xmlns:ns="http://localhost:8080/WS/FacadeWS" 
  14:         languageSpecificType=
  15:            "java:test.customdeploy.UsuarioDTO" />
  16:   </service>
  17:</deployment>
  18:

En el wsdd estamos definiendo lo siguiente:

Nombre y Tipo de Servicio - FacadeWS (RPC)
Scope - aplication (que duración tendrá la instancia de FacadeWS). Puede ser request, session o application
Métodos Expuestos - En nuestro caso serán todos (por eso el "*")
Tipos de Dato Propietarios - UsuarioDTO

5 - Registrar el Servicio

Tenemos que registrar el servicio. Para esto utilizaremos el comando (clase de AXIS) AdminClient. Lo vamos a invocar a través del siguiente batch.

adminClient.bat

   1:
   2:@echo off
   3:
   4:rem JH -> JAVA_HOME
   5:@SET JH=\java\jdk1.5.0
   6:
   7:rem AH -> AXIS_HOME
   8:@SET AH=\JAVA\axis-1_4
   9:
  10:rem AAC -> AXIS ADMIN CLIENT
  11:@SET AAC=org.apache.axis.client
  12:@SET AAC=%AAC%.AdminClient
  13:
  14:rem CP -> CLASSPATH
  15:@SET CP=%AH%\lib\activation.jar;
  16:@SET CP=%CP%;%AH%\lib\axis.jar;
  17:@SET CP=%CP%;%AH%\lib\axis-ant.jar;
  18:@SET CP=%CP%;%AH%\lib\commons-discovery-0.2.jar;
  19:@SET CP=%CP%;%AH%\lib\commons-logging-1.0.4.jar;
  20:@SET CP=%CP%;%AH%\lib\jaxrpc.jar;
  21:@SET CP=%CP%;%AH%\lib\log4j-1.2.8.jar;
  22:@SET CP=%CP%;%AH%\lib\saaj.jar;
  23:@SET CP=%CP%;%AH%\lib\mail.jar;
  24:@SET CP=%CP%;%AH%\lib\wsdl4j-1.5.1.jar;
  25:
  26:%JH%\bin\java -cp %CP% %AAC% %1
  27:

Antes de ejecutar este comando debemos asegurarnos de que el server de AXIS esté levantado (ya sea detrás de Tomcat o en línea de comandos).

Corremos el comando de la siguiente manera:

adminClient facadeWS.wsdd

Si todo está bien entonces veremos la siguiente salida:

Processing file facadeWS.wsdd
<Admin>Done processing</Admin>

6 - Ahora, accediendo a: http://localhost:8080/axis/services veremos que entre los servicios deployados está nuestro FacadeWS, con sus métodos y con la opción de visualizar su wsdl.

7 - Para crear el cliente podríamos usar el utilitario WSDL2Java como vimos al comienzo de este capítulo pero en este caso lo vamos a crear a mano.

FacadeWSClient.java

   1:
   2:package test;
   3:
   4:import java.util.Collection;
   5:import javax.xml.namespace.QName;
   6:import javax.xml.rpc.ParameterMode;
   7:import org.apache.axis.client.Call;
   8:import org.apache.axis.client.Service;
   9:import org.apache.axis.encoding.XMLType;
  10:import test.customdeploy.UsuarioDTO;
  11:
  12:public class FacadeWSClient
  13:{
  14:    // direccion del servicio
  15:    public static String endpoint =
  16:      "http://localhost:8080/axis/services/FacadeWS";
  17:
  18:    public static void main(String[] args)
  19:    throws Exception
  20:    {
  21:        // harcodeo usuario y password
  22:        String usr="pedro";
  23:        String pwd="pedro1";
  24:     
  25:        // invoco el login
  26:        // a traves de un metodo privado
  27:        UsuarioDTO dto=invocarLogin(usr,pwd);
  28:        System.out.println(dto);
  29:     
  30:        // invoco obtenerUsuarios a traves
  31:        // de un metodo privado
  32:        Collection arr=invocarObtenerUsuarios();
  33:        System.out.println(arr);
  34:    }
  35:
  36:    private static UsuarioDTO invocarLogin(
  37:                                       String usr
  38:                                     , String pwd)
  39:    {
  40:        try
  41:        {
  42:
  43:            Service service = new Service();
  44:            Call call = (Call) service.createCall();
  45:         
  46:            // hay que definir un QName por cada tipo
  47:            // de datos custom que vayamos a utilizar
  48:            QName qn = new QName(
  49:               "http://localhost:8080/WS/FacadeWS"
  50:              ,"UsuarioDTO");
  51:         
  52:         
  53:            // registramos en la llamada remota
  54:            // el tipo de dato custom
  55:            call.registerTypeMapping(
  56:                      UsuarioDTO.class
  57:                     ,qn
  58:                     ,new BeanSerializerFactory(
  59:                                   UsuarioDTO.class
  60:                                  ,qn)
  61:                     ,new BeanDeserializerFactory(
  62:                                   UsuarioDTO.class
  63:                                  ,qn));
  64:            call.setTargetEndpointAddress(endpoint);
  65:            call.setOperationName("login");
  66:            call.addParameter("usr"
  67:                             ,XMLType.XSD_STRING
  68:                             ,ParameterMode.IN);
  69:            call.addParameter("pwd"
  70:                             ,XMLType.XSD_STRING
  71:                             ,ParameterMode.IN);
  72:            call.setReturnType(qn);
  73:            UsuarioDTO dto=(UsuarioDTO)
  74:               call.invoke(new Object[]{ usr,pwd });
  75:            return dto;
  76:        }
  77:        catch(Exception ex)
  78:        {
  79:            ex.printStackTrace();
  80:            throw new RuntimeException(ex);
  81:        }
  82:    }
  83:    private static Collection invocarObtenerUsuarios()
  84:    {
  85:        try
  86:        {
  87:            Service service = new Service();
  88:            Call call = (Call) service.createCall();
  89:            QName qn = new QName(
  90:               "http://localhost:8080/WS/FacadeWS"
  91:              ,"UsuarioDTO");
  92:                
  93:            // registramos en la llamada remota
  94:            // el tipo de dato custom que recibiremos
  95:            // dentro de la coleccion
  96:            call.registerTypeMapping(
  97:                      UsuarioDTO.class
  98:                     ,qn
  99:                     ,new BeanSerializerFactory(
 100:                                   UsuarioDTO.class
 101:                                  ,qn)
 102:                     ,new BeanDeserializerFactory(
 103:                                   UsuarioDTO.class
 104:                                  ,qn));      
 105:         
 106:            // direccion del servicio
 107:            call.setTargetEndpointAddress(endpoint);
 108:         
 109:            // nombre del metodo
 110:            call.setOperationName("obtenerUsuarios");
 111:            call.setReturnType(XMLType.XSD_ANYTYPE);
 112:         
 113:            // que tipo de clase esperamos
 114:            call.setReturnClass(Collection.class);
 115:            Collection coll=(Collection)
 116:                       call.invoke((Object[])null);
 117:                    
 118:            return coll;
 119:
 120:        }
 121:        catch(Exception ex)
 122:        {
 123:            ex.printStackTrace();
 124:            throw new RuntimeException(ex);
 125:        }
 126:    }     
 127:}
 128:

Connection Pooling

2007-10-11T15:27:00.001-03:00

.
Las especificaciones de J2ee definen que los servers compatibles deben proveer una implementacion de DataSource (o "Pool de Conexiones") para que los programadores lo puedan utilizar dentro de sus aplicaciones.

En este capítulo explicaremos los motivos por los cuales es necesario utilizar un DataSource y como configurarlo en Tomcat y JBoss.

El Pool de Conexiones

Un Pool de Conexiones (jdbc) es un conjunto de conexiones pre-instanciadas que serán "prestadas" a los threads a medida que estos lo requieran para que la usen y luego la devuelvan al pool.

Es como si se tratase de videos en un videoclub. El videoclub puede tener 500 socios, pero no por eso tiene que tener disponibles 500 copias de cada película. Sería muy costoso y ridículo ya que es muy improbable que los 500 socios requieran las misma película en el mismo momento. Por lo tanto (quizá) con 5 o 6 copias de la película pueda alcanzar para satisfacer la demanda.

En el caso de las aplicaciones abiertas en Internet o con gran cantidad de usuarios potenciales el análisis es el mismo. Nuestro recurso es la conexión a la base de datos. Tendremos un conjunto de n conexiones para asignarlas (o prestarlas) a los hilos que lo requieran.

Los ejemplos que veremos son para conectarnos con HSQL pero aplican (cambiando el driver y el url) a cualquier base de datos.

Como Configurar un DataSource en Tomcat 5

1 - Copiar el driver jdbc (hsqldb.jar) en el directorio %CATALINA_HOME%\common\lib.

2 - Tenemos que declarar el recurso que vamos a requerir en la aplicacion web. Para esto debemos agregar las siguientes líneas en el archivo web.xml, justo antes del cierre del tag </web-app>.

web.xml (agregar estas líneas)

   1:
   2:   <resource-ref>
   3:      <res-ref-name>jdbc/HSqlDS</res-ref-name>
   4:      <res-type>javax.sql.DataSource</res-type>
   5:      <res-auth>Container</res-auth>
   6:   </resource-ref>
   7:

3 - Crear el siguiente archivo entro del directorio /META-INF de la aplicación web.

context.xml

   1:
   2:<Context>
   3:   <Resource name="jdbc/HSqlDS" 
   4:           auth="Container" 
   5:           type="javax.sql.DataSource" 
   6:           username="sa" 
   7:           password="" 
   8:           url="jdbc:hsqldb:hsql://localhost/xdb" 
   9:           driverClassName="org.hsqldb.jdbcDriver" 
  10:           maxActive="8" 
  11:           maxIdle="4" />
  12:</Context>
  13:

4 - Para acceder al pool de conexiones (DataSource) para pedirle una conexión debemos utilizar algunas líneas de código de la API JNDI.

En este ejemplo lo hacemos a través de una página JSP:

testDS.jsp

   1:
   2:<%@ page import="java.sql.Connection" %>
   3:<%@ page import="javax.naming.Context" %>
   4:<%@ page import="javax.naming.InitialContext" %>
   5:<%@ page import="javax.sql.DataSource" %>
   6:
   7:<%
   8:   // obtengo el contexto inicial
   9:   Context ctx=new InitialContext();
  10:
  11:   // lookapeo el DataSource 
  12:   DataSource ds=(DataSource)
  13:            ctx.lookup("java:comp/env/jdbc/HSqlDS");
  14:     
  15:   // Tengo el DataSource, le pido una conexion
  16:   Connection con=ds.getConnection();
  17:
  18:   // la uso...
  19:   // en este caso muestro el toString() para ver si
  20:   // esta instanciada o si es null
  21:   out.println(con);
  22:
  23:   // al cerrar la conexion en realidad la estoy 
  24:   // devolviendo al pool
  25:   con.close();
  26:%>
  27:

Si estuviéramos trabajando con Struts, dentro de un Action, la conexión la tenemos que devolver en un finally para asegurarnos de que, pase lo que pase, la devolvemos.

TestDSAction.java

   1:
   2:package test.action;
   3:
   4:import java.sql.Connection;
   5:
   6:import javax.naming.*;
   7:import javax.servlet.http.*;
   8:import javax.sql.DataSource;
   9:import org.apache.struts.action.*;
  10:
  11:public class TestDSAction extends Action
  12:{
  13:    public ActionForward execute(
  14:                     ActionMapping mapping
  15:                   , ActionForm form
  16:                   , HttpServletRequest request
  17:                   , HttpServletResponse response)
  18:    {
  19:        Connection con=null;
  20:        try
  21:        {
  22:            // hago el lookup del pool de conexiones
  23:            Context ctx=new InitialContext();
  24:            DataSource ds=(DataSource)ctx.lookup(
  25:                       "java:comp/env/jdbc/HSqlDS");
  26:               
  27:            // pido una conexion
  28:            con=ds.getConnection();
  29:       
  30:            // la uso
  31:            System.out.println(con);
  32:       
  33:            // la devuelvo en el finally (OJO!)
  34:            return mapping.findForward("ok");
  35:         }
  36:        catch(Exception ex)
  37:        {
  38:            ex.printStackTrace();
  39:            throw new RuntimeException(ex);
  40:        }
  41:        finally
  42:        {
  43:           try
  44:           {
  45:               if( con!=null )
  46:               {
  47:                   // devuelvo la conexion al pool
  48:                   con.close();
  49:               }
  50:           }
  51:           catch(Exception ex)
  52:           {
  53:               ex.printStackTrace();
  54:               throw new RuntimeException(ex);
  55:           }
  56:        }
  57:    }
  58:}
  59:

Como Configurar un DataSource en JBoss 3

En JBoss el tema es mucho más simple.

1 - Creamos el siguiente archivo en el directorio %JBOSS_HOME%/server/default/deploy

test-ds.xml

   1:<?xml version="1.0" encoding="UTF-8"?>
   2:
   3:<datasources>
   4:   <local-tx-datasource>
   5:      <jndi-name>HSqlDS</jndi-name>
   6:      <connection-url>
   7:         jdbc:hsqldb:hsql://localhost/xdb
   8:      </connection-url>
   9:      <driver-class>
  10:         org.hsqldb.jdbcDriver
  11:      </driver-class>
  12:      <user-name>sa</user-name>
  13:      <password></password>
  14:      <min-pool-size>5</min-pool-size>
  15:      <max-pool-size>20</max-pool-size>
  16:      <idle-timeout-minutes>5</idle-timeout-minutes>
  17:   </local-tx-datasource>
  18:</datasources>
  19:

2 - Luego, en nuestro código el lookup de la conexión lo hacemos de la siguiente manera:

   1:
   2:DataSource ds=(DataSource)
   3:   ctx.lookup("java:/HSqlDS");
   4:

JAFramework

2007-10-10T18:17:00.003-03:00

.
BeanFactory

Podemos utilizar JAF para instanciar objetos definidos en el descriptor.

descriptor.xml

   1:
   2:<jaframework xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="jaframework.xsd">
   3:
   4:   <bean-factory>
   5:      <bean name="FRAME" class="java.awt.Frame" singleton="false"/>
   6:      <bean name="VECTOR" class="java.util.Vector" singleton="true"/>
   7:   </bean-factory>
   8:  
   9:</jaframework>
  10:

En la línea 5 definimos un objeto llamado FRAME de la clase java.awt.Frame. En la línea 6 definimos un objeto llamado VECTOR de la clase java.util.Vector. Los nombres FRAME y VECTOR son arbitrareos.

a FRAME lo definimos con el atributo singleton="false" en cambio a VECTOR lo definimos con singleton="true". Esto significa que cada vez que le pidamos al framework un objeto FRAME obtendremos una nueva instancia de java.awt.Frame (singleton="false"). Y cada vez que le pidamos al framework un objeto VECTOR el framework nos dará la misma (y única) instancia (singleton="true").

El tag <bean-factory> debe ir al final, justo antes del cierre </framework>

El siguiente programa muestra como pedirle objetos al framework y prueba el funcionamiento del atributo singleton.

PruebaBeans.java

   1:
   2:package demo;
   3:
   4:import framework.JABeanFactory;
   5:import framework.JAFactory;
   6:
   7:public class PruebaBeans
   8:{
   9:   public static void main(String[] args)
  10:   {
  11:      JABeanFactory factory = JAFactory
  12:                                    .getBeanFactory();
  13:
  14:      // levanto el descriptor
  15:      factory.load("descriptor.xml");
  16:   
  17:      // pido dos objetos FRAME (singleton=false)
  18:      Object f1 = factory.getBean("FRAME");
  19:      Object f2 = factory.getBean("FRAME");
  20:
  21:      // verifico si son la misma instancia
  22:      System.out.print("Son la misma instancia ? ");
  23:      System.out.println(f1 == f2); // debe dar false
  24:
  25:      // pido dos objetos VECTOR (singleton=true)
  26:      Object v1 = factory.getBean("VECTOR");
  27:      Object v2 = factory.getBean("VECTOR");
  28:
  29:      // verifico si son la misma instancia
  30:      System.out.print("Son la misma instancia ? ");
  31:      System.out.println(v1 == v2); // debe dar true
  32:   }
  33:}
  34:

JAFramework

2007-10-10T08:15:00.004-03:00

.
Manejo de Transacciones

JAF también provee un pequeño manejador de trasacciones a través del cual podemos confirmar (commit) o revertir (rollback) las sentencias realizadas contra la base de datos.

Veamos las tablas DEPT (departamento) y EMP (empleado) que tienen los campos que se detallan a continuación para luego analizar un ejemplo sobre como utilizar transacciones con JAF.

DEPT
- deptno (número de departamento, NUMERIC primay key)
- dname (nombre del departamento, VARCHAR)
- loc (localidad donde funciona el departamento, VARCHAR)

EMP
- empno (número de empleado, NUMERIC primary key)
- ename (nombre del empleado, VARCHAR)
- deptno (referencia al departament donde trabaja el empleado, NUMERIC foreign key)

En el siguiente ejemplo insertamos una fila en DEPT y varias filas en EMP. Queremos "todo o nada". Si todo salió bien entonces confirmamos la operación (commit). Si algo falla entonces no se llegará a ejecutar el commit y en el finally revertimos con rollback.

TestTransaccion.java

   1:
   2:package demo;
   3:
   4:import framework.JAConnectionFactory;
   5:import framework.JAFactory;
   6:import framework.jdbc.JATransaction;
   7:
   8:public class TestTransaccion
   9:{
  10:   public static void main(String[] args)
  11:   {
  12:      JAConnectionFactory factory = JAFactory
  13:                              .getConnectionFactory();
  14:
  15:      // levanto la configuracion del data-source
  16:      factory.load("descriptor.xml");
  17:
  18:      // defino un objetto para la transaccion
  19:      JATransaction trx = null;
  20:
  21:      try
  22:      {
  23:         // inicializo una transaccion
  24:         trx = factory.beginTransaction();
  25:
  26:         // inserto un departamento (padre)
  27:         // (departamento numero 6)
  28:         InsertaFilas.insertaDept(6);
  29:
  30:         // inserto varios empleados (hijos)
  31:         // (inserto 5 empleados numerados desde 7,
  32:         // todos en el departamento numero 6)
  33:         InsertaFilas.insertaEmp(6, 7, 5);
  34:
  35:         // si todo salio bien entonces comiteo
  36:         trx.commit();
  37:      }
  38:      catch( Exception ex )
  39:      {
  40:         ex.printStackTrace();
  41:         throw new RuntimeException(ex);
  42:      }
  43:      finally
  44:      {
  45:         // siempre hago el rollback
  46:         if( trx != null ) trx.rollback();
  47:      }
  48:   }
  49:}
  50:

Veamos la clase con la que insertamos las filas en las tablas.

InsertaFilas.java

   1:
   2:package demo;
   3:
   4:import java.sql.Connection;
   5:import java.sql.PreparedStatement;
   6:
   7:import javax.sql.DataSource;
   8:
   9:import framework.JAConnectionFactory;
  10:import framework.JAFactory;
  11:
  12:public class InsertaFilas
  13:{
  14:   // inserta una fila en la tabla DEPT
  15:   public static void insertaDept(int deptno)
  16:   {
  17:      Connection con = null;
  18:      PreparedStatement pstm = null;
  19:
  20:      try
  21:      {
  22:         JAConnectionFactory factory = JAFactory
  23:                              .getConnectionFactory();
  24:
  25:         String sql = "";
  26:         sql += "INSERT INTO dept ( ";
  27:         sql += "deptno, dname, loc) VALUES( ";
  28:         sql += "?,?,?)";
  29:
  30:         // Obtengo el data-source por default
  31:         DataSource ds = factory.getDataSource();
  32:
  33:         // le pido una conexion
  34:         con = ds.getConnection();
  35:        
  36:         // utilizo la conexion
  37:         pstm = con.prepareStatement(sql);
  38:
  39:         pstm.setInt(1, deptno);
  40:         pstm.setString(2, "Dept(" + deptno + ")");
  41:         pstm.setString(3, "Loc(" + deptno + ")");
  42:         if( pstm.executeUpdate() != 1 )
  43:         {
  44:            throw new RuntimeException("Error");
  45:         }
  46:      }
  47:      catch( Exception ex )
  48:      {
  49:         ex.printStackTrace();
  50:         throw new RuntimeException(ex);
  51:      }
  52:      finally
  53:      {
  54:         try
  55:         {
  56:            if( pstm != null ) pstm.close();
  57:           
  58:            // retorno la conexion al data-source
  59:            if( con != null ) con.close();
  60:         }
  61:         catch( Exception ex )
  62:         {
  63:            ex.printStackTrace();
  64:            throw new RuntimeException(ex);
  65:         }
  66:      }
  67:   }
  68:
  69:   // inserta n filas en la tabla EMP
  70:   public static void insertaEmp(int deptno
  71:                               , int empnoBase
  72:                               , int n)
  73:   {
  74:      Connection con = null;
  75:      PreparedStatement pstm = null;
  76:
  77:      try
  78:      {
  79:         JAConnectionFactory factory = JAFactory
  80:                              .getConnectionFactory();
  81:
  82:         String sql = "";
  83:         sql += "INSERT INTO emp ( ";
  84:         sql += "empno, ename, deptno) VALUES( ";
  85:         sql += "?,?,?)";
  86:
  87:         // obtengo el data-source por default
  88:         DataSource ds = factory.getDataSource();
  89:        
  90:         // le pido una conexion
  91:         con = ds.getConnection();
  92:        
  93:         // utilizo la conexion
  94:         pstm = con.prepareStatement(sql);
  95:
  96:         for( int i = 0; i < n; i++ )
  97:         {
  98:            pstm.setInt(1, empnoBase + i);
  99:            pstm.setString(2, "Emp(" + i + ")");
 100:            pstm.setInt(3, deptno);
 101:            if( pstm.executeUpdate() != 1 )
 102:            {
 103:               throw new RuntimeException("Error");
 104:            }
 105:         }
 106:      }
 107:      catch( Exception ex )
 108:      {
 109:         ex.printStackTrace();
 110:         throw new RuntimeException(ex);
 111:      }
 112:      finally
 113:      {
 114:         try
 115:         {
 116:            if( pstm != null ) pstm.close();
 117:
 118:            // devuelvo la conexion al data-source
 119:            if( con != null ) con.close();
 120:         }
 121:         catch( Exception ex )
 122:         {
 123:            ex.printStackTrace();
 124:            throw new RuntimeException(ex);
 125:         }
 126:      }
 127:   }
 128:}
 129:

JAFramework

2007-10-08T09:09:00.013-03:00

.
Acceso a Bases de Datos

JAF incluye una factory de DataSources JDBC a través de la cual podemos establecer conexiones contra una base de datos. Lo configuramos de la siguiente manera:

descriptor.xml

   1:
   2:<jaframework xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="jaframework.xsd">
   3:
   4:   <jdbc>
   5:      <data-source name="HSQL" 
   6:                driver="org.hsqldb.jdbcDriver" 
   7:                url="jdbc:hsqldb:hsql://localhost/xdb"
   8:                user="sa" 
   9:                password="" 
  10:                pool-size="4" />
  11:   </jdbc>
  12:
  13:</jaframework>
  14:

Dentro del tag jdbc definimos uno o varios data-source. Un data-source especifica los parámetros para establecer la conexión JDBC con la base de datos. El parámetro pool-size indica la cantidad de conexiones que serán pre-instanciadas al momento de crear el data-source. Es el tamaño del pool de conexiones.

Si en el descriptor tuviésemos también tags <driver> entonces el tag <jdbc> debe ir a continuación de estos.

Para probar el data-source lo haremos con el siguiente programa.

TestConnection.java

   1:
   2:package demo;
   3:
   4:import java.sql.Connection;
   5:import java.sql.ResultSet;
   6:import java.sql.Statement;
   7:
   8:import javax.sql.DataSource;
   9:
  10:import framework.JAConnectionFactory;
  11:import framework.JAFactory;
  12:
  13:public class TestConnection
  14:{
  15:   public static void main(String[] args)
  16:   {
  17:      JAConnectionFactory factory = JAFactory.getConnectionFactory();
  18:
  19:      // levanto el descriptor
  20:      factory.load("descriptor.xml");
  21:
  22:      Connection con = null;
  23:      Statement stm = null;
  24:      ResultSet rs = null;
  25:
  26:      try
  27:      {
  28:         // pido el data-source
  29:         DataSource ds = factory.getDataSource();
  30:
  31:         // ahora le pido la conexion
  32:         con = ds.getConnection();
  33:
  34:         // la utilizo
  35:         String sql = "";
  36:         sql+="SELECT deptno,dname,loc ";
  37:         sql+="FROM dept ";
  38:      
  39:         stm = con.createStatement();
  40:         rs = stm.executeQuery(sql);
  41:
  42:         while( rs.next() )
  43:         {
  44:            System.out.print(rs.getInt("deptno") + ", ");
  45:            System.out.print(rs.getString("dname") + ", ");
  46:            System.out.println(rs.getString("loc"));
  47:         }
  48:      }
  49:      catch( Exception ex )
  50:      {
  51:         ex.printStackTrace();
  52:         throw new RuntimeException(ex);
  53:      }
  54:      finally
  55:      {
  56:         try
  57:         {
  58:            if( rs != null ) rs.close();
  59:            if( stm != null ) stm.close();
  60:
  61:            // debo cerrar la conexion ya que al
  62:            // cerrarla la estoy devolviendo al
  63:            // pool de conexiones
  64:            if( con != null ) con.close();
  65:         }
  66:         catch( Exception ex )
  67:         {
  68:            ex.printStackTrace();
  69:            throw new RuntimeException(ex);
  70:         }
  71:      }
  72:   }
  73:}
  74:

..............................................

Programación Orientada a Objetos

2007-09-20T07:16:00.001-03:00

En POO la pila debe ser un objeto en si mismo, autosuficiente. Debe tener los datos y las funciones necesarias para manejar los datos.

Custom TAGs

2007-09-19T17:05:00.000-03:00

.
JSP permite definir TAGs. Si bien es una tarea un poco tediosa, en ciertos casos puede ser de gran ayuda para que nuestro código JSP sea más claro, legible y mantenible.

En este capítulo analizaremos algunos ejemplos bien simples con los cuales intentaremos cubrir varios de los casos se pueden presentar al momento de diseñar nuestra librería de Custom TAGs

Tipos de TAGs

Podríamos clasificar los custom tags en diferentes casos: tags con o sin atributos, con o sin cuerpo, etc. El siguiente código JSP ejemplifica de estos diferentes casos..

   1:
   2:<!-- tag sin atributos ni cuerpo -->
   3:<mitag />
   4:
   5:<!-- tag con atributos, sin cuerpo -->
   6:<mitag nombre="Pablo" />
   7:
   8:<!-- tag con atributos tomados como expresion -->
   9:<%
  10:   java.util.Date fec=new java.util.Date();
  11:%>
  12:<mitag fecha="<%=fec%>" />
  13:
  14:<!--  tag con cuerpo -->
  15:<mitag>
  16:Esto esta en el cuerpo de mi tag!
  17:</mitag>
  18:

Comenzando

Para programar un custom tag se necesitan dos partes: una clase Java que provee la implementación del tag en la que definimos lo que queremos que el tag haga y una entrada en un archivo XML (con extensión .tld) en donde definimos la estructura del tag.

Veamos una página JSP que utilize un custom tag y luego veremos como lo programamos.

testTags.jsp

   1:
   2:<!-- tenemos que tener el archivo demo.tld       -->
   3:<!-- en el directorio /WEB-INF                   -->
   4:<%@ taglib uri="/WEB-INF/demo.tld" prefix="sz" %>
   5:
   6:<html>
   7:<body>
   8:   <!-- aqui llamanos a nuestro custom tag -->
   9:   <sz:holamundo />
  10:</body>
  11:</html>
  12:

Los tags se definen (y se declaran) en archivos XML con extensión .tld (tag library descriptor). Para indicarle a la página JSP que vamos a utilizar tags definidos en una TLD específica se utiliza una directiva taglib en la que se indica un prefijo que se deberá anteponer cada vez que invoquemos tags de esta librería. En este caso el prefijo será "sz" (es una elección arbitraria).

Ahra tenemos que generar un archivo demo.tld en el directorio /WEB-INF de nuestra aplicación web.

demo.tld

   1:
   2:<taglib>
   3:   <tlibversion>1.0</tlibversion>
   4:   <jspversion>1.0</jspversion>
   5:   <shortname>Ejemplos de Custom Tags</shortname>
   6:
   7:   <!--  definicion del TAG holamundo -->
   8:   <tag>
   9:      <name>holamundo</name>
  10:      <tagclass>test.tags.HolaMundoTAG</tagclass>
  11:      <bodycontent>empty</bodycontent>
  12:      <info>Dice "Hola Mundo"</info>
  13:   </tag>
  14:
  15:</taglib>
  16:

En el TLD definimos la estructura del tag holamundo. En este caso, como es el caso más simple, los únicos parámetros que configuramos son el nombre del tag y la clase que lo procesa: test.tags.HolaMundoTAG. Este tag no recibe atributos.

Veamos ahora la clase que procesa el tag.

HolaMundoTAG.java

   1:
   2:package test.tags;
   3:
   4:import java.io.*;
   5:import javax.servlet.jsp.*;
   6:import javax.servlet.jsp.tagext.*;
   7:
   8:public class HolaMundoTAG extends TagSupport
   9:{
  10:    public int doStartTag() throws JspException
  11:    {
  12:        try
  13:        {
  14:            // obtengo el stream para escribir
  15:            JspWriter out=pageContext.getOut();
  16:
  17:            // escribo la salida del tag
  18:            out.print("Hola Mundo !!!");
  19:
  20:            // este tag no tiene body...
  21:            return SKIP_BODY;
  22:        }
  23:        catch(IOException e)
  24:        {
  25:            e.printStackTrace();
  26:            throw new JspException(e);
  27:        }
  28:    }
  29:
  30:    public int doEndTag() throws JspException
  31:    {
  32:        return EVAL_PAGE;
  33:    }
  34:}
  35:

Custom Tags con Atributos

Ahora veremos como programar un tag holamundopers que recibe como parámetro (o atributo) un nombre y escribe en la página la cadena: "Hola Mundo, nombre".

testTags.jsp (invoca un tag con atributos)

   1:
   2:<%@ taglib uri="/WEB-INF/demo.tld" prefix="sz" %>
   3:
   4:<html>
   5:<body>
   6:
   7:   <sz:holamundopers nombre="Pablo" /> <br>
   8:
   9:</body>
  10:</html>
  11:

El siguiente paso será definir el tag holamundopers agregando la siguiente entrada en el archivo demo.tld.

   1:
   2:   <tag>
   3:      <name>holamundopers</name>
   4:      <tagclass>test.tags.HolaMundoPersTAG</tagclass>
   5:      <bodycontent>empty</bodycontent>
   6:      <info>Saludo con Nombre</info>
   7:      <attribute>
   8:         <name>nombre</name>
   9:         <required>true</required>
  10:         <rtexprvalue>false</rtexprvalue>
  11:      </attribute>
  12:   </tag>
  13:

Ahora tenemos que programar la clase HolaMundoPersTAG.java. Es practicamente igual a la anterior solo que define un setter para cada atributo que el tag puede recibir.

HolaMundoPersTAG.java

   1:
   2:package test.tags;
   3:
   4:import java.io.*;
   5:import javax.servlet.jsp.*;
   6:import javax.servlet.jsp.tagext.*;
   7:
   8:public class HolaMundoPersTAG extends TagSupport
   9:{
  10:    // atributos
  11:    private String nombre;
  12:
  13:    // setters para los atributos
  14:    public void setNombre(String n)
  15:    {
  16:        nombre=n;
  17:    }
  18:
  19:    public int doStartTag() throws JspException
  20:    {
  21:        try
  22:        {
  23:            JspWriter out=pageContext.getOut();
  24:
  25:            // escribe "Hola Mundo" seguido del valor
  26:            // del atributo
  27:            out.print("Hola Mundo, "+nombre);
  28:            return SKIP_BODY;
  29:        }
  30:        catch(IOException e)
  31:        {
  32:            e.printStackTrace();
  33:            throw new JspException(e);
  34:        }
  35:    }
  36:
  37:    public int doEndTag() throws JspException
  38:    {
  39:        return EVAL_PAGE;
  40:    }
  41:}
  42:

Custom Tags con Cuerpo

Analizaremos un tag reversa que encierra una cadena (en su cuerpo) y la imprime en orden inverso.

testTags.jsp (invoca un custom tag con cuerpo)

   1:
   2:<%@ taglib uri="/WEB-INF/demo.tld" prefix="sz" %>
   3:
   4:<html>
   5:<body>
   6:
   7:   <sz:reversa>
   8:      Aprendiendo CUSTOM TAGs en HolaMundo.java :O)
   9:   </sz:reversa>
  10:
  11:</body>
  12:</html>
  13:

El tag reversa enciera una cadena la cual va a imprimir en orden inverso. Veamos ahora la definición de este tag que tenemos que agregar en demo.tld.

   1:
   2:   <tag>
   3:       <name>reversa</name>
   4:       <tagclass>test.tags.ReversaTAG</tagclass>
   5:       <bodycontent>JSP</bodycontent>
   6:       <info>imprime la inversa de la cadena</info>
   7:   </tag>
   8:

Y ahora veamos el código de la clase que lo implementa.

ReversaTAG.java

   1:
   2:package test.tags;
   3:
   4:import java.io.*;
   5:import javax.servlet.jsp.*;
   6:import javax.servlet.jsp.tagext.*;
   7:
   8:public class ReversaTAG extends BodyTagSupport
   9:{
  10:   // este metodo procesa el body
  11:    public int doAfterBody() throws JspException
  12:    {
  13:        try
  14:        {
  15:            BodyContent bc = getBodyContent();
  16:
  17:            String cuerpo = bc.getString();
  18:            JspWriter out = bc.getEnclosingWriter();
  19:            if ( cuerpo != null )
  20:            {
  21:                for(int i=cuerpo.length()-1;i>=0;i--)
  22:                {
  23:                    out.print(cuerpo.charAt(i));
  24:                }
  25:            }
  26:        }
  27:        catch(IOException ex)
  28:        {
  29:            ex.printStackTrace();
  30:            throw new JspException(ex);
  31:        }
  32:        return SKIP_BODY;
  33:    }
  34:}
  35:

Custom Tags con Expresiones <%= %>

Por último veremos un tag que recibe un atributo a través de una expresión de JSP. El ejemplo que vamos a desarrollar consiste en un tag que recibe una Collection (de Java) y la muestra.

testTags.jsp (define una Collection y se la pasa al custom tag)

   1:
   2:<%@ page import="java.util.Collection" %>
   3:<%@ page import="java.util.Vector" %>
   4:
   5:<%
   6:   Collection coll=new Vector();
   7:   coll.add("uno");
   8:   coll.add("dos");
   9:   coll.add("tres");
  10:%>
  11:
  12:
  13:<%@ taglib uri="/WEB-INF/demo.tld" prefix="sz" %>
  14:
  15:<html>
  16:<body>
  17:
  18:   <sz:mostrar data="<%=coll%>" />
  19:
  20:</body>
  21:</html>
  22:

Para definir este tag debemos agregar la siguiente entrada en demo.tld.

   1:
   2:   <tag>
   3:      <name>mostrar</name>
   4:      <tagclass>test.tags.MostrarTAG</tagclass>
   5:      <bodycontent>empty</bodycontent>
   6:      <info>Muestra una Collection</info>
   7:      <attribute>
   8:         <name>data</name>
   9:         <required>true</required>
  10:         <rtexprvalue>true</rtexprvalue>
  11:      </attribute>
  12:   </tag>
  13:

Para que el tag soporte expresiones JSP definimos true el parámetro rtexprvalue.

MostrarTAG.java

   1:
   2:package test.tags;
   3:
   4:import java.io.*;
   5:import java.util.*;
   6:import javax.servlet.jsp.*;
   7:import javax.servlet.jsp.tagext.*;
   8:
   9:public class MostrarTAG extends TagSupport
  10:{
  11:    private Collection data;
  12: 
  13:    public void setData(Collection c)
  14:    {
  15:        data=c;
  16:    }
  17: 
  18:    public int doStartTag() throws JspException
  19:    {
  20:        try
  21:        {
  22:            JspWriter out=pageContext.getOut();
  23:            Iterator it;
  24:            for( it=data.iterator(); it.hasNext(); )
  25:            {
  26:                out.print("<li>"
  27:                         +it.next().toString()
  28:                         +"</li>");
  29:            }
  30:            return SKIP_BODY;
  31:        }
  32:        catch(IOException e)
  33:        {
  34:            e.printStackTrace();
  35:            throw new JspException(e);
  36:        }
  37:    }
  38:
  39:    public int doEndTag() throws JspException
  40:    {
  41:        return EVAL_PAGE;
  42:    }
  43:}
  44:

Vemos que simplemente recibimos un atributo de tipo Collection y luego iteramos para mostrar sus elementos.

.

JAFramework

2007-09-10T07:48:00.002-03:00

.
Entrada de Datos por Consola

En Java no es tan simple leer datos por teclado (consola) como en Pascal o C. Por este motivo JAF provee una clase que soluciona el problema de manera muy simple.

Veamos algunos ejemplos.

Demo1.java

   1:
   2:package democonsole;
   3:import framework.util.JAConsole;
   4:
   5:public class Demo1
   6:{
   7:   public static void main(String[] args)
   8:   {
   9:      System.out.print("Ingrese un valor entero: ");
  10:      int i=JAConsole.readInt();
  11:      System.out.println("Ud. ingreso: "+i);
  12:
  13:      System.out.print("Ingrese un valor real: ");
  14:      float f=JAConsole.readFloat();
  15:      System.out.println("Ud. ingreso: "+f);
  16: 
  17:      System.out.print("Ingrese un String: "); 
  18:      String s=JAConsole.readString();
  19:      System.out.println("Ud. ingreso: ["+s+"]");
  20:   }
  21:}
  22:

En este ejemplo se pide al usuario que ingrese un valor entero. Cuando el usuario ingresa el valor entonces se muestra el valor ingresado y luego se pide que ingrese un valor real. Luego de que lo ingresa se muestra el valor ingresado y, por último, se le pide que ingrese un String y tambén se muestra el valor ingresado.

El resultado es:

El siguiente programa es similar al anterior. La diferencia es que se le pide al usuario que ingrese los tres valores a la vez, separados por un espacio en blanco.

Demo2.java

   1:
   2:package democonsole;
   3:import framework.util.JAConsole;
   4:
   5:public class Demo2
   6:{
   7:    public static void main(String[] args)
   8:    {
   9:        System.out.print("Ingrese entero, un real ");
  10:        System.out.print("y un String: ");
  11: 
  12:        int i=JAConsole.readInt();
  13:        float f=JAConsole.readFloat();
  14:        String s=JAConsole.readString();
  15:
  16:        System.out.println("Ud. ingreso: "+i);
  17:        System.out.println("Ud. ingreso: "+f);
  18:        System.out.println("Ud. ingreso: ["+s+"]");
  19:    }
  20:}
  21:

El resultado es:

Los String deben ir entre comillas dobles si contien más de una palabra. Si el String contiene una única palabra entonces no es necesario el uso de las comillas.

.

.