Introducción a J2EE

Esta lección nos presenta la programación de aplicaciones J2EE, y el SDK J2EE mostrándonos como escribir una sencilla y pequeña aplicación Enterprise multi-capa que consiste en una página HTML, un servlet y un Bean de sesión.

El SDK J2EE es una definición y especificación operacional no comercial de la plataforma J2EE que Sun Microsystem a liberado para demostraciones, prototipos y usos educacionales. Viene con el servidor de aplicaciones J2EE, servidor Web, base de datos, los APIs J2EE, y un completo conjunto de herramientas de desarrollo. Nos iremos encontrando con estas características y herramientas según vayamos avanzando en este tutorial.

. Ejemplo de Aplicación Cliente Multi-Capa

La pequeña aplicación cliente de ejemplo de esta lección acepta entrada de usuario a través de un formulario HTML que invoca un servlet. El servlet usa el API JNDI (Java Naming and Directory Interface™) para buscar un Bean de sesión que realice los cálculos por él.

Este ejemplo es una aplicación pequeña porque el servlet no ejecuta ninguna lógica de negocio. El sencillo cálculo lo realiza un Bean de sesión que se ejecuta en el servidor de aplicaciones J2EE. Por eso el cliente es pequeño, porque no maneja el proceso; lo hace el Bean de sesión.

Las aplicaciones multi-capa pueden consistir en 3 ó 4 capas. Como se ve en la , el ejemplo multi-capa para este tutorial tiene cuatro capas. La arquitectura de tres capas extiende al cliente estándar de dos capas y el modelo del servidor situando un servidor de aplicaciones multi-capa entre la aplicación cliente no-basada-en-web y la base de datos final. La arquitectura de cuatro capas extiende el modelo de tres capas reemplazando la aplicación cliente con un navegador Web y una página HTML potenciada con las tecnologías servlet/JavaServer Pages™.

Mientras que esta lección usa sólo tres o cuatro capas, la siguiente lección extiende este mismo ejemplo para acceder al servidor de base de datos en la cuarta capa. Lecciones posteriores adaptan el ejemplo para usar las tecnologías JavaServer™ Pages y Extensible Markup Language (XML).

. Software J2EE y Configuración

Para ejecutar los ejemplos del tutorial, necesitas descargar e instalar el SDK Java 2 Enterprise Edition (J2EE), Versión 1.2.1 (http://java.sun.com/j2ee/download.html), y SDK Java 2, Standard Edition (J2SE), Versión 1.2 o posterior (http://java.sun.com/jdk/index.html).

Las instrucciones de este tutorial asumen que J2EE y J2SE están instalados en el directorio J2EE debajo del directorio home del usuario.

Nota:
Siempre que se utilice monicap en un nombre de path, tendrás que cambiarlo por tu nombre de usuario.

Unix:

/home/monicap/J2EE/j2sdkee1.2.1
/home/monicap/J2EE/jdk1.2.2

Windows:

\home\monicap\J2EE\j2sdkee1.2.1
\home\monicap\J2EE\jdk1.2.2

. Configuración del Path y ClassPath

La descarga contiene el servidor de aplicaciones J2EE, la base de datos Cloudscape, un servidor Web que usa capas de socket seguras (SSL) también conocido como HTTP sobre HTTPS, herramientas de desarrollo y despliegue, y los APIs Java para Enterprise. Para usar estar características, debemos configurar las variables de entorno path y classpath como se describe aquí: Configuración del Path

La configuración del Path hace accesibles las herramientas de desarrollo y despliegue desde cualquier lugar de nuestro sistema. Debemos asegurarnos de seleccionar estos path antes de cualquier otro path que pudiéramos tener de viejas instalaciones del JDK.

Unix:

/home/monicap/J2EE/jdk1.2.2/bin
/home/monicap/J2EE/j2sdkee1.2.1/bin

Windows:

\home\monicap\J2EE\jdk1.2.2\bin
\home\monicap\J2EE\j2sdkee1.2.1\bin
Configuración del ClassPath

La configuración del ClassPath le dice a las herramientas de desarrollo y despliegue de Java 2 dónde encontrar las distintas librerías de clases que usa:

Unix:

/home/monicap/J2EE/j2sdkee1.2.1/lib/j2ee.jar

Windows:

\home\monicap\J2EE\j2sdkee1.2.1\lib\j2ee.jar

. Componentes de Aplicación J2EE

Los programadores de aplicaciones J2EE escriben componentes de aplicación J2EE. Un componente J2EE es una unidad de software funcional auto-contenida que se ensambla dentro de una aplicación J2EE y que se comunica con otros componentes de aplicación. La especificación J2EE define los siguientes componentes de aplicación:

  • Componentes de Aplicación Cliente
  • Componentes JavaBeans Enterprise
  • Componentes Servlets y JavaServer Pages (también llamados componentes Web)
  • Applets

En esta lección, crearemos una aplicación y dos componentes J2EE: un servlet y un Bean de sesión. El servlet está empaquetado con su fichero HTML en un fichero Web Archive (WAR), y las clases e interfaces del Bean de sesión están empaquetadas en un fichero JAR. Los ficheros WAR y JAR se añaden a la aplicación J2EE y se empaquetan dentro de un fichero Enterprise Archive (EAR) para probar, verificar y desplegar el entorno de producción.

Mientras estemos haciendo todos estos pasos para esta lección, realmente estaremos realizando varias funciones diferentes. Escribir el código del servlet y del Bean de sesión es una función de desarrollo, mientras que crear la aplicación J2EE y añadir los componentes J2EE a una aplicación es una función de ensamblaje. En realidad, estas funciones podrían ser realizadas por diferentes personas de diferentes compañías.

. Crear la Página HTML

La página HTML para esta lección se llama bonus.html. Su código HTML está debajo de la , que muestra cómo vería la página HTML el usuario. El fichero bonus.html tiene dos campos de datos en los que usuario puede introducir un número de seguridad social y un multiplicador. Cuando el usuario pulsa el botón Submit, BonusServlet.java recupera el dato del usuario, busca el Bean de sesión, y le pasa el dato del usuario al Bean de sesión. el Bean de sesión calcula un valor "bonus" y lo devuelve al servlet. El servlet devuelve otra página HTML con el valor del "bonus" para que lo vea el usuario.

La siguiente Figura muestra el flujo de los datos entre el navegador y el Bean de sesión. El Bean de sesión se ejecuta en el servidor de aplicaciones J2EE.

. Código HTML

Lo más interesante sobre el código del formulario HTML es el alias usado para invocar a BonusServlet . Cuando el usuario pulsa el botón Submit sobre el formulario HTML, se llama a BonusServlet porque se ha mapeado a BonusAlias durante el ensamblaje de la aplicación descrito en Ensamblar la Aplicación J2EE.

El ejemplo asume que bonus.html está en el directorio /home/monicap/J2EE/ClientCode en UNIX. Aquí y desde ahora los usuarios de Windows pueden invertir las barras inclinadas para obtener los paths correctos para su plataforma:

<HTML>
<BODY BGCOLOR = "WHITE">
<BLOCKQUOTE>
<H3>Bonus Calculation</H3>
<FORM METHOD="GET"  ACTION="BonusAlias">
<P>
Enter social security Number:
<P>
<INPUT TYPE="TEXT" NAME="SOCSEC"></INPUT>
<P>
Enter Multiplier:
<P>
<INPUT TYPE="TEXT" NAME="MULTIPLIER"></INPUT>
<P>
<INPUT TYPE="SUBMIT" VALUE="Submit">
<INPUT TYPE="RESET">
</FORM>
</BLOCKQUOTE>
</BODY>
</HTML>

. Crear el Servlet

El ejemplo asume que el fichero BonusServlet.java está en el directorio /home/monicap/J2EE/ClientCode en UNIX. Durante la ejecución, el código del servlet hace lo siguiente:

  • Recupera los datos del usuario
  • Busca el bean de sesión
  • Le pasa los datos al bean de sesión
  • Después de recibir un valor de vuelta desde el bean de sesión, crea una página HTML para mostrar el valor devuelto al usuario.

La siguiente sección describe las diferentes partes del código del servlet. Aquí puedes ver el código del Servlet completo.

. Sentencias Import

El código del servlet empieza con sentencias import para los siguientes paquetes:

  • javax.servlet, que contiene clases servlets genéricas (independientes del protocolo). La clase HTTPServlet usa la clase ServletException de este paquete para indicar un problema en el servlet.
  • javax.servlet.http, que contiene clases servelts HTTP. La clase HttpServlet está en este paquete.
  • java.io para entrada y salida del sistema. La clase HttpServlet usa la clase IOException de este paquete para señalar que se ha producido una excepción de algún tipo de entrada o salida.
  • javax.naming para poder usar los APIs Java Naming and Directory Interface (JNDI™) para buscar el interface home del bean de sesión.
  • javax.rmi para buscar el interface home del bean de sesión y poner su objeto servidor remoto listo para las comunicaciones.

. Método init()

El método BonusServlet.init busca el interface home del bean de sesión y crea su ejemplar. El método usa el nombre JNDI especificado durante el ensamblado de componentes (calcs) para obtener una referencia al interface home por su nombre. La siguiente línea pasa la referencia y la clase del interface home al método PortableRemoteObject.narrow para asegurarse de que la referencia puede forzarse al tipo CalcHome.

InitialContext ctx = new InitialContext();
Object objref = ctx.lookup("calcs");
homecalc = (CalcHome)PortableRemoteObject.narrow(obj ref, CalcHome.class);

. Método doGet

La lista de parámetros de doGet toma un objeto request y un response. El navegador envía una petición (request) al servlet y el servlet envía una respuesta (response) de vuelta al navegador. La implementación del método accede a información del objeto request para encontrar quién ha hecho la petición, en qué formulario están los datos de la petición, y que cabeceras HTTP se enviarón, y usa el objeto response para crear una página HTML en respuesta a la petición del navegador.

El método doGet lanza una IOException si hay algún problema con los datos de entrada o salida cuando maneja la petición, y una ServletException si la petición no se puede manejar. Para calcular el valor del bonus, el método doGet crea el interface home y llama al método calcBonus.

  public void doGet (HttpServletRequest request,
                     HttpServletResponse response)
               throws ServletException, IOException {
    String socsec = null;
    int multiplier = 0;
    double calc = 0.0;
    PrintWriter out;
    response.setContentType("text/html");
    String title = "EJB Example";
    out = response.getWriter();
    out.println("<HTML><HEAD><TITLE>")
    out.println(title);
    out.println("</TITLE></HEAD><BODY>");

    try{
//Retrieve Bonus and Social Security Information
      String strMult = request.getParameter(
                       "MULTIPLIER");
      Integer integerMult = new Integer(strMult);
      multiplier = integerMult.intValue();
      socsec = request.getParameter("SOCSEC");

//Calculate  bonus
      double bonus = 100.00;
      theCalculation = homecalc.create();
      calc = theCalculation.calcBonus(
             multiplier, bonus);
    }catch(Exception CreateException){
      CreateException.printStackTrace();
    }

//Display Data
    out.println("<H1>Bonus Calculation</H1>");
     out.println("<P>Soc Sec: " + socsec + "<P>");
    out.println("<P>Multiplier: " + 
                multiplier + "<P>");
    out.println("<P>Bonus Amount: " + calc + "<P>");
    out.println("</BODY></HTML>");
    out.close();
  }

. Código del Servlet

Aquí está el código completo:

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import javax.naming.*;
import javax.rmi.PortableRemoteObject;
import Beans.*;

public class BonusServlet extends HttpServlet {
  CalcHome homecalc;

  public void init(ServletConfig config) 
		throws ServletException{

//Look up home interface
    try{
      InitialContext ctx = new InitialContext();
      Object objref = ctx.lookup("calcs");
      homecalc = 
              (CalcHome)PortableRemoteObject.narrow(
      objref, 
      CalcHome.class);
    } catch (Exception NamingException) {
      NamingException.printStackTrace();
    }
  }
  public void doGet (HttpServletRequest request, 
      HttpServletResponse response) 
      throws ServletException, IOException {
    String socsec = null;
    int multiplier = 0;
    double calc = 0.0;
    PrintWriter out;
    response.setContentType("text/html");
    String title = "EJB Example";
    out = response.getWriter();
    out.println("<HTML><HEAD><TITLE>");
    out.println(title);
    out.println("</TITLE></HEAD><BODY>");
    try{
      Calc theCalculation;
//Get Multiplier and Social Security Information
      String strMult = 
        request.getParameter("MULTIPLIER");
      Integer integerMult = new Integer(strMult);
      multiplier = integerMult.intValue();
      socsec = request.getParameter("SOCSEC");
//Calculate bonus
      double bonus = 100.00;
      theCalculation = homecalc.create();
      calc = 
         theCalculation.calcBonus(multiplier, bonus);
    } catch(Exception CreateException){
      CreateException.printStackTrace();
    }
//Display Data
    out.println("<H1>Bonus Calculation</H1>");
    out.println("<P>Soc Sec: " + socsec + "<P>");
    out.println("<P>Multiplier: " + 
                multiplier + "<P>");
    out.println("<P>Bonus Amount: " + calc + "<P>");
    out.println("</BODY></HTML>");
    out.close();
  }
  public void destroy() {
    System.out.println("Destroy");
  }
}

. Crear el Bean de Session

Un bean de sesión representa una conversación temporal con un cliente. Si el servidor o el cliente, se cuelgan, el bean de sesión y sus datos se van. En contraste, los beans de entidad son persistentes y representan datos en una base de datos. Si el servidor o el cliente se bloquean, los servicios relacionados aseguran que los datos del bean de entidad se graban.

La siguiente Figura muestra como funcionan el servlet y el bean de sesión como una aplicación J2EE completa una vez que se han ensamblado y desplegado. El contenedor, mostrado en la caja sombreada, es el interface entre el bean de sesión y las funcionalidades especificas de la plataforma de bajo-nivel que soporta el bean de sesión. El contenedor se crea durante el despliegue.

La siguiente sección muestra el código del bean de sesión. El ejemplo asume que los ficheros CalcBean.java , Calc.java, y CalcHome.java están situados en el directorio /home/monicap/J2EE/Beans. La sentencia package Beans en la parte superior del interface CalcBean y los ficheros de clases es el mismo nombre que el nombre de este directorio. Cuando se compilen estos ficheros, se hara desde el directorio superior Beans y el nombre del paquete Beans (o directorio) se pretende que apunte al interface y los ficheros class compilados. Compilar el Bean de Sesión.

Nota:
Este ejemplo muestra cómo escribir un bean de sesión, pero también es posible comprar beans enterprise a un proveedor y ensamblarlos dentro de una aplicación J2EE.

. CalcHome

BonusServlet no trabaja directamente con el bean de sesión, sino que crea un ejemplar de su interface home. El interface home extiende EJBHome y tiene un método create para crear el bean de sesión en su contendor. Se lanzará una CreateException si no se puede crear el bean de sesión y una RemoteException si ocurre una excepción relacionada con las comunicaciones durante la ejecución del método remoto.

package Beans;

import java.rmi.RemoteException;
import javax.ejb.CreateException;
import javax.ejb.EJBHome;

public interface CalcHome extends EJBHome {
  Calc create() throws CreateException, 
                RemoteException;
}

. Calc

Cuando se crea el interface home, el servidor de aplicaciones J2EE crea el interface remoto y el bean de sesión. El interface remoto extiende EJBObject declara el método calcBonus para el cálculo del valor del bonos. Este método requiere que se lance una javax.rmi.RemoteException, y está implementado por la clase CalcBean.

package Beans;

import javax.ejb.EJBObject;
import java.rmi.RemoteException;

public interface Calc extends EJBObject {
  public double calcBonus(int multiplier,
                          double bonus)
                     throws RemoteException;
}

. CalcBean

La clase del bean de sesión implementa el interface SessionBean y proporciona el comportamiento para el método calcBonus. Los métodos setSessionContext y ejbCreate son llamados en este orden por el contendor después de que BonusServlet llame al método create CalcHome.

Los métodos vacíos son del inteface SessionBean. Estos métodos los llama el contenedor del bean. No tenemos que proporcionar comportamiento para estos métodos a menos que necesitemos funcionalidades adicionales, por ejemplo cuando el bean es añadido o eliminado de su contenedor.

package Beans;

import java.rmi.RemoteException;
import javax.ejb.SessionBean;
import javax.ejb.SessionContext;

public class CalcBean implements SessionBean {
  public double calcBonus(int multiplier,
                         double bonus) {
    double calc = (multiplier*bonus);
    return calc;
  }
//These methods are described in more
//detail in Lesson 2
  public void ejbCreate() { }
  public void setSessionContext(
      SessionContext ctx) { }
  public void ejbRemove() { }
  public void ejbActivate() { }
  public void ejbPassivate() { }
  public void ejbLoad() { }
  public void ejbStore() { }
}

. Compilar el Bean de Sesión y el Servlet

Para ahorrarnos tecleado, la forma más sencilla para compilar el bean de sesión y el servlet es con un script (en Unix) o un fichero batch (en Windows).

. Compilar el Bean de Session

Unix

#!/bin/sh
cd /home/monicap/J2EE
J2EE_HOME=/home/monicap/J2EE/j2sdkee1.2.1
CPATH=.:$J2EE_HOME/lib/j2ee.jar
javac -d . -classpath "$CPATH" Beans/CalcBean.java
            Beans/CalcHome.java Beans/Calc.java 

Windows

cd \home\monicap\J2EE
set J2EE_HOME=\home\monicap\J2EE\j2sdkee1.2.1
set CPATH=.;%J2EE_HOME%\lib\j2ee.jar
javac -d . -classpath %CPATH% Beans/CalcBean.java
            Beans/CalcHome.java Beans/Calc.java 

. Compilar el Servlet

Unix

#!/bin/sh
cd /home/monicap/J2EE/ClientCode 
J2EE_HOME=/home/monicap/J2EE/j2sdkee1.2.1
CPATH=.:$J2EE_HOME/lib/j2ee.jar:
      /home/monicap/J2EE
javac -d . -classpath "$CPATH" BonusServlet.java 

Windows

cd \home\monicap\J2EE\ClientCode 
set J2EE_HOME=\home\monicap\J2EE\j2sdkee1.2
set CPATH=.;%J2EE_HOME%\lib\j2ee.jar;
  \home\monicap\J2EE
javac -d . -classpath %CPATH% BonusServlet.java

. Arrancar el Servidor de Aplicaciones J2EE

Necesitamos arrancar el servidor de aplicaciones J2EE para desplegar y ejecutar el ejemplo. El comando para arrancar el servidor está en el directorio bin debajo de nuestra instalación J2EE. Si tenemos el path configurado para que lea el directorio bin, vamos directamente al directorio J2EE (entonces nuestra versión real corresponde con lo que veremos en el texto) y tecleamos:

j2ee -verbose
Nota:
Algunas veces el servidor J2EE no arranca si estámos ejecutando Outlook

Si esto no funciona, tecleamos lo siguiente desde el directorio J2EE:

Unix:

j2sdkee1.2.1/bin/j2ee -verbose

Windows:

j2sdkee1.2.1\bin\j2ee -verbose

La opción verbose imprime mensajes de información en la línea de comandos cuando el servidor arranca. Cuando veamos J2EE server startup complete , podemos arrancar la herramienta de despliegue. Por ahora, podemos ignorar los otros mensajes que aparecen.

. Arrancar la Herramienta DeployTool

Para ensamblar y desplegar la aplicación J2EE, tenemos que arrancar la herramienta deploytool. Si tenemos el path configurado para que lea el directorio bin, vamos directamente al directorio J2EE (entonces nuestra versión real corresponde con lo que veremos en el texto) y tecleamos:

deploytool

Si esto no funciona, hacemos lo siguiente desde el directorio J2EE:

Unix:

j2sdkee1.2.1/bin/deploytool

Windows:

j2sdkee1.2.1\bin\deploytool
Notas:
Si ocurre un error de acceso a memoria mientras arrancamos deploytool , añadimos una variable de entorno llamada JAVA_FONTS y seleccionamos el path a c: \<font directory> . Por ejemplo c:\winnt\fonts. También, si se encuentra una NullPointerException para BasicFileChooserUI cuando se arranca deploytool, debemos asegurarnos de no arrancar la herramienta desde el directorio raíz (es decir c:\ ). Si la ejecutamos desde cualquier otro lugar, como el directorio bin de nuestra instalación j2sdkee1.2, no encontraremos este problema.

. DeployTool

El herramienta DeployTool mostrada en la siguiente figura tiene cuatro ventanas principales. La ventana "Local Aplications" muestra las aplicaciones J2EE y sus componentes. La ventana "Inspecting" muestra información sobre la aplicación o componentes seleccionados. La ventana "Servers" nos dice si el servidor de aplicaciones se está ejecutando en un host local. Y la ventana "Server Aplications" nos dice qué aplicaciones tenemos instaladas. Cuando sigamos los pasos para ensamblar la aplicación de ejemplo J2EE, veremos que todas estas ventanas nos muestran información.

Nota:
A la derecha de la ventana Server Applications hay un botón gris Uninstall. Después de desplegar la aplicación, veremos la aplicación listada en esta ventana. Podemos pulsar sobre Uninstall para desinstalarla, hacerle cambios, y reinstalarla sin tener que parar y rearrancar el servidor de aplicaciones.

. Ensamblar la Aplicación J2EE

Ensamblar una aplicación J2EE implica crear una nueva aplicación, y añadirle los componentes de aplicación. Aquí tenemos un sumario de los pasos para ensamblar, que se describen abajo con más detalle.

  1. Crear una nueva aplicación J2EE (BonusApp.ear).
  2. Crear un nuevo bean enterprise (CalcBean.jar).
  3. Crear un nuevo componente web (Bonus.war).
  4. Especificar un nombre JNDI para el bean enterprise (calcs).
  5. Especificar el contexto raíz para la aplicación J2EE (BonusRoot ).

. Crear la aplicación J2EE

Los componentes J2EE se ensamblan dentro de ficheros (EAR) "Enterprise Archive".

Menu File : Seleccionamos New Application .

Caja de diálogo New Application:

  • Tecleamos BonusApp.ear para el Application File Name.
  • Pulsamos el botón derecho del ratón en el campo Application Display Name. BonusApp aparece en el nombre.
  • Pulsamos el botón Browse para abrir el selector de ficheros para seleccionar la localización donde queremos grabar el fichero EAR

Selector de Ficheros New Application:

  • Localizamos el directorio donde queremos situar el fichero EAR de la aplicación.
  • En este ejemplo, este directorio es /home/monicap/J2EE .
  • En el campo File name, tecleamos BonusApp.ear.
  • Pulsamos sobre New Application .
  • Pulsamos sobre OK.

En la ventana de Local Applications ahora aparecerá "Bonusapp.ear", y en la ventana Inspector a la derecha muestyra el nombre, la localización y la información de contenidos para BonusApp . La meta información mostrada en la ventrana contents describe el fichero JAR y la aplicación J2EE, y prorporciona información de tiempo de ejecución sobre la aplicación.

. Crear el Bean de Sesión

Los beans Enterprise (tanto de entidad como de sesión) se empaquetan en un fichero JAR.

Menú File: Seleccionamos New Enterprise Bean. Arrancará el New Enterprise Bean Wizard y mostrará un diágolo de introducción que sumariza los pasos que vamos a tomar. Después de leerlos, pulsamos sobre Next .

Caja de Diálogo EJB JAR: Especificamos la siguiente información:

  • Enterprise Bean will go in : BonusApp
    Display name: CalcJar
    Description: Un sencillo Bean de sesión que calcula un bonus y tiene un método.
  • Pulsamos sobre Add. Hay dos botones en esta pantalla. No aseguramos de pulsar el segundo que está cerca de la ventana Contents.

Caja de Diálogo Add Files to .JAR: vamos al directorio J2EE. Podemos teclear el nombre del path o usar el navegador para obetenerlo. Una vez en el directorio J2EE, hacemos doble click sobre beans para mostrar el contenido del directorio beans.

  • Selecionamos Calc.class .
  • Pulsamos sobre Add .
  • Seleccionamos CalcHome.class .
  • Pulsamos sobre Add .
  • Seleccionamos CalcBean.class .
  • Pulsamos sobre Add .
Nota Importante:
La caja de diálogo Add Contents to .JAR se debería parecer a la de la figura siguiente. Las clases Enterprise Bean JAR se deberían mostrar con el prefijo del nombre de directorio Beans.
  • Pulsamos OK. Ahora deberíamos estar de nuevo en la caja de diálogo EJB JAR. Beans/Calc.class , Beans/CalcHome.class, y Beans/CalcBean.class deberían aparecer en la ventana Contents.
  • Pulsamos Next.

Caja de diálogo General: Seleccionamos la siguiente información:

  • classname: Beans.CalcBean
    Home interface:
    Beans.CalcHome
    Remote interface:
    Beans.Calc
    Bean type:
    Session y Stateless
  • Especificamos el nombre (el nombre que aparece cuando el fichero JAR se añade a BonusApp en la ventana de "Local Applications"), y proporcionamos una descripción para los contenidos del ficheros JAR.
  • Display Name: CalcBean
  • Description: Este fichero JAR contiene el bean de sesión CalcBean.
  • Pulsamos sobre Next .

Caja de Diálogo Environment Entries: Este ejemplo no hace uso de las propiedades (entradas de entorno) pero nosotros si podríamos:

  • Pulsamos sobre Finish .

Verificar que el fichero JAR se añadido realmente a la aplicación J2EE:

  • Vamos a la ventana "Local Applications"
  • Pulsamos el gráfico gris en frente de BonusApp . Veremos el fichero JAR CalcJar.
  • Pulsamos el gráfico gris en frente de CalcJar para ver el bean de sesión CalcBean.

. Crear Componentes Web

Los componentes Web (servlets, o JavaServer Pages™) se empaquetan dentro de un fichero Web Archive (WAR).

Menú File : Seleccionamos New Web Component . Se arrancará el New Web Component Wizard y mostrará una ventana que sumariza los pasos que vamos a tomar. Después de leerlos, pulsamos sobre Next .

Caja de diálogo WAR File General Properties : Proporcionamos la siguiente información:

  • WAR file: BonusApp
    Display name: BonusWar
    Description: Este fichero war contiene un servlet y una página HTML
  • Pulsamos Add .

Caja de Diálogo Add Contents to WAR:

  • Vamos el directorio ClientCode tecleando ClientCode después de J2EE en el campo Root Directory.
  • Seleccioamos bonus.html. Debemos asegurarnos de que WAR contents muestra el listado como bonus.html sin el directorio ClientCode precediendo al nombre.
  • Pulsamos sobre Add .
Nota:
Debemos asegurarnos de añadir bonus.html antes de añadir BonusServlet.class
  • Pulsamos sobre Next .
  • Elegimos de nuevo el directorio ClientCode.
  • Seleccionamos BonusServlet.class. Debemos asegurarnos de que WAR contents muestra el nombre de BonusServlet.class sin el directorio precediendo el nombre.
  • Pulsamos sobre Add .

Caja de Diágolo Contents to WAR: La pantalla se debería parecer a la de la siguiente figura:

  • Pulsamos Finish .

Caja de diágolo WAR File General Properties :

  • Pulsamos Next .

Caja de diálogo Choose Component Type:

  • Selecccionamos Servlet (si no está ya seleccionado)
  • Puslamos Next .

Caja de Diálogo Component General Properties:

  • Nos aseguramos de que BonusServlet está seleccionado para la clase Servlet.
  • Introducimos un nombre ( BonusServlet ) y una descripción.
  • Podemos ignornar las selecciones de Startup y load sequence aquí porque este ejemplo sólo usa un servlet.

Caja de diálogo Component Initialization Parameters:

  • Pulsamos Next . BonusServlet no usa ningún parámetro de inicialización.

Caja de diálogo Component Aliases:

  • Pulsamos Add .
  • Tecleamos BonusAlias y pulsamos Return . Este es el mismo nombre de alias que pusimos en el campo ACTION del formulario HTML embebido en el fichero bonus.html.
  • Pulsamos Finish .

En el panel de contenido, podemos ver que el fichero WAR contiene un fichero XML con información estructural y de atributos sobre la aplicación web. el fichero bonus.html, y el fichero class BonusServlet. El formato del fichero WAR es donde van todas las clases servlet en un punto de entrada con Web-INF/classes. Sin embargo, cuando se despliega el fichero WAR, la clase BonusServlet se sitúa en un directorio raíz de contexto bajo public_html. Esta situación es la convención parra servidores web compatibles con Servlet 2.2.

Para cambiar el nombre o la descripción:

  • Ponemos el cursor en el campo apropiado en la ventana
  • Lo cambiamos según nuestros deseos
  • Pulsamos la tecla Return para que las ediciones tengan efecto.

. Especificar el Nombre JNDI y el Contexto Raíz

Antes de poder desplegar la aplicación BonusApp y sus componentes, tenemos que especificar el nombre JNDI que BonusServlet usa para buscar el bean de sesión CalcBean, y especificar un directorio de contexto raíz donde el desplegador pondrá los componentes web.

Nombre JNDI:

  • Seleccionamos el fichero BonusApp en la ventana "Local Applications". La ventana "Inspecting" muestra pestañas en la parte superior, y una de esas pestañas es JNDI Names.
  • Seleccionamos Select JNDI. La ventana "Inspecting" muestra una pantalla con tres columnas y una fila. CalcBean se ve en la columna central.
  • En la columna más a la derecha bajo el nombre JNDI, tecleamos calc. Este nombre JNDI es el mismo nombre JNDI pasado al método BonusServlet.lookup.
  • Pulsamos la tecla Return.

Contexto Raíz:

  • Pulsamos la pestaña Web Context en la parte superior de la ventana Inspecting. Veremos BonusWar en la columna de la izquierda.
  • Tecleamos BonusRoot en la columna de la derecha
  • Pulsamos la tecla Return. Durante el despliegue se crea el directorio BonusRoot bajo el directorio public_html en nuestra instalación J2sdkee1.2, y los ficheros bonus.html y BonusServlet se copian como muestra en la siguiente figura:

Alias:

  • En la ventana LocalApp, pulsamos BonusWar y luego BonusServlet
  • Pulsamos la pestaña Aliases de la parte superior de la ventana Inspecting. Deberíamos ver BonusAlias en el campo.
  • Si BonusAlias no está ahí, lo tecleamos y pulsamos Return.

. Verificar y Desplegar la Aplicación J2EE

Antes de desplegar la aplicación, es una buena idea ejecutar el verificador. El verificador nos mostrará errores en los componentes de la aplicación como un método no existente en el bean que el compilador no captura.

Verificar:

  • Con BonusApp seleccionado, elegimos Verifier desde el menú Tools.
  • En el diálogo que aparece, pulsamos OK. La ventana nos debería decir si no han fallado los tests.
  • Cerramos la ventana del verificador porque ya estamos listos para desplegar la aplicación.
Nota:
En la versión 1.2 podríamos obtener un error tests app.WebURI. Esto significa que la herramienta de desarrollo no puso una extensión .war al fichero WAR durante su creación. Este es un bug menor y la apliación J2EE se despliega bien sin notarlo.

Desplegar:

  • Desde el menú Tools, elegimos Deploy Application . Se mostrará una caja de diálogo Deploy BonusApp. Debemos verificar que la selección Target Server es o localhost o el nombre del servidor donde se está ejecutando el J2EE.
Nota:
No debemos seleccionar el check box Return Client Jar. La única vez que necesitamos seleccionar este check box es cuando despleguemos una aplicación solitaria para el programa cliente. Este ejemplo usa un servlet y una página HTML por eso no debemos seleccionarlo. Seleccionar este check box crea un fichero Jar con la información de despliegue necesaria para una aplicación solitaria.
  • Pulsamos Next. Nos aseguramos de que el nombre JNDI muestra calcs. Si no lo hace, lo tecleamos nosotros mismos y pulsamos la tecla Return.
  • Pulsamos Next. Nos aseguramos de que el nombre Context Root muestra BonusRoot. Si no lo hace, lo tecleamos nosotros y pulsamos la tecla Return.
  • Pulsamos Next .
  • Pulsamos Finish para empezar el despliegue. Aparecerá una caja de diálogo que mostrará el estado de la operación de despliegue.
  • Cuando esté completa, las tres barras de la izquierda estárán completamente sombreadas, como se ve en la siguiente figura. Cuando esto suceda, pulsamos OK.

. Ejecutar la Aplicación J2EE

El servidor web se ejecuta por defecto en el puerto 8000. Para abrir la página bonus.html apuntamos nuestro navegador a http://localhost:8000/BonusRoot/bonus.html, que es donde DeployTool puso el fichero HMTL.

Nota:
Si necesitamos usar un puerto diferente porque el puerto 8000 está siendo utilizado por otra cosa, editamos el fichero web.properties en el directorio ~/J2EE/j2sdkee1.2/config y arrancamos de nuevo el servidor J2EE.
  • Rellenamos un número de seguridad social.
  • Rellenamos un multiplicador.
  • Pulsamos el botón Submit. BonusServlet procesa nuestros datos y devuelve una página HTML con el cálculo del bono.
Bonus Calculation

Soc Sec: 777777777
Multiplier: 25

Bonus Amount 2500.0

. Actualizar el Código de Componentes

El menú Tools tiene dos opciones de interés. Son Update Application Files y Update and Redeploy Application. Estas opciones nos permiten cambiar el código y redesplegar nuestra aplicación con facilidad. Simplemente hacemos los cambios en el código, lo recompilamos, y elegimos una de estas opciones del menú.

  • Update Application Files actualiza los ficheros de la aplicación con nuestro nuevo código. En este punto podemos verificar la aplicación o desplegarla.
  • Update and Redeploy Application actualiza los ficheros de la aplicación con nuestro nuevo código y redespliega la aplicación sin ejecutar el verificador.

. Código Fuente de los Ejemplos

Aquí tienes un fichero Zip con los ficheros fuente de los ejemplos de esta página:

fuentes_L1.zip

COMPARTE ESTE ARTÍCULO

ENVIAR A UN AMIGO
COMPARTIR EN FACEBOOK
COMPARTIR EN TWITTER
COMPARTIR EN GOOGLE +
ARTÍCULO ANTERIOR

SIGUIENTE ARTÍCULO

¡SÉ EL PRIMERO EN COMENTAR!
Conéctate o Regístrate para dejar tu comentario.