Pasos para Construir nuestro Primer Bean de Sesión sin Estado
Paso 1: Instalar un Servidor de JavaBeans Enterprise
Los componentes JavaBeans Enterprise se ejecutan dentro de Contenedores JavaBeans Enterprise, que son suministrados por servidores de JavaBeans Enterprise de terceras partes. Las siguientes instrucciones nos ayudarán a descargar e instalar el servidor BEA Weblogic en el que ejecutaremos el ejemplo DemoBean.
Nota: las instrucciones de instalación mostradas aquí son para Sun Solaris, pero el proceso es similar para Windows NT.
- Descargar el servidor Bea WebLogic desde su Web site.
http://www.weblogic.com/licbeta.html
- Extraer la distribución usando las utilidades jar o unzip. Este tutorial asume que el Weblogic está instalado en el directorio /export, por ejemplo, /export/weblogic.
- Descargar la última versión de Java Development Kit desde la web site del JDK para Solaris.
http://www.sun.com/solaris/java
- Configuramos el CLASSPATH sobre el host del servidor.
Añadimos weblogic/classes y weblogic/lib/weblogicaux.jar a nuestro CLASSPATH.
Añadimos weblogic/lib/solaris a nuestro LD_LIBRARY_PATH
- Editar el fichero de propiedades de BEA WebLogic: weblogic.properties
Seleccionamos la propiedad de password del sistema, weblogic.password.system
- Arrancamos el servidor Weblogic usando el script startTengah.sh.
Después seguimos los pasos de este tutorial para construir y desarrollar el Bean de ejemplo, probar que los beans JavaBeans Enterprise se han desarrollado correctamente, o chequeando la ventana de la línea de comandos del servidor, o abriendo la Consola y examinado el "EJB" bajo el "Distributed Objects"; deberíamos ver el DemoBean instalado, y podremos monitorizar su actividad.
Paso 2: Especificar el Interface Remoto de JavaBeans Enterprise
En este paso crearemos un interface remoto JavaBean Enterprise.
El interface remoto es la vista del cliente de los JavaBeans Enterprise, y las tareas que desarrolla nuestro javaBean se declaran en este interface usando las síntaxis RMI de Java. Es responsabilidad del proveedor de las herramientas de contenedores de JavaBeans Enterprise generar el código para este interface.
Nota: Hay algunas limitaciones sobre lo que se puede especificar en este interface. Para una lista completa puedes ver la sección 16 de la Especificación de JavaBeans Enterprise. Es importante que, todos los objetos usados, los parámetros, los valores de retorno y las excepciones sean tipos válidos en la "especificación de mapeo de Java a IDL".
Aquí tenemos el código fuente del interface remoto para el sencillo DemoBean. Debemos grabarlo en un fichero llamado Demo.java.
/**
* Demo -- this is the "remote" interface of
* our enterprise JavaBean, it
* defines only one simple method called
* demoSelect(). As this is meant to be
* the simplest of examples demoSelect()
* never goes to a database, it just
* returns a string
*
* Note: The implementation of this interface is
* provided by the container tools
* but the demoSelect() method and any
* other methods in this interface
* will need to have equivalent
* implementations in the demobean.java
* which is supplied by the bean writer
* ..i.e., you!
*/
package ejb.demo;
import java.rmi.RemoteException;
import java.rmi.Remote;
import javax.ejb.*;
public interface Demo extends EJBObject, Remote {
// NB this simple example does not even do a
// lookup in the database
public String demoSelect() throws RemoteException;
}
Paso 3: Especificar el Interface Home
El interface home para un bean de sesión proporciona el mecanismo mediante el cual el contenedor crea nuevos beans de sesión en nombre del cliente. El interface home, al igual que el interface remoto, se declara con la síntaxis RMI, y de nuevo, lo implementa la herramienta proveedora de contenedores. En este punto el programador no tiene mucho trabajo, es sólo declaraciones.
Aquí está el código fuente para el DemoBean EJB.
/**
* DemoHome.java - This is the Home interface it must
* extend javax.ejb.EJBHome and define one or more
* create() methods for the bean.
*
* Note: The implementation of this interface is
* generated by the container tools.
*/
package ejb.demo;
import javax.ejb.*;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.util.*;
/**
* This interface is extremely simple it declares only
* one create method.
*/
public interface DemoHome extends EJBHome {
public Demo create() throws CreateException,
RemoteException;
}
Paso 4: Escribir la Clase JavaBean Enterprise
Este paso nos enseña cómo se crea el código de una aplicación (la lógica del negocio). Hasta ahora, hemos declarado interfaces para los que la herramienta de contenedores generaba código, pero aquí es donde se codifica la funcionalidad del JavaBean.
Una cosa importante a observar sobre la implementación del Bean, es el poco código que debemos generar. La mayoría del código es simplemente implementar métodos de la especificación de JavaBeans Enterprise. Es fácil crear plantillas y herramientas que nos hagan la mayor parte del trabajo de implementación. Esto es comparable con la forma en que algunas herramientas crean los entornos GUI para Beans.
Aquí está el código fuente del JavaBean DemoBean.java.
/**
* DemoBean -- This is implemented by the EnterPrise
* Bean author This class must extend
* javax.ejb.SessionBean and implement
* the methods in this interface as well as providing
* the implementation of the business methods.
*
*/
package ejb.demo;
import javax.ejb.*;
import java.io.Serializable;
import java.util.*;
import java.rmi.*;
public class DemoBean implements SessionBean {
static final boolean verbose = true;
private transient SessionContext ctx;
private transient Properties props;
// Implement the methods in the SessionBean
// interface
public void ejbActivate() {
if (verbose)
System.out.println("ejbActivate called");
}
public void ejbRemove() {
if (verbose)
System.out.println("ejbRemove called");
}
public void ejbPassivate() {
if (verbose)
System.out.println("ejbPassivate called");
}
/**
* Sets the session context.
*
* @param SessionContext
*/
public void setSessionContext(SessionContext ctx) {
if (verbose)
System.out.println("setSessionContext called");
this.ctx = ctx;
props = ctx.getEnvironment();
}
/**
* This method corresponds to the create method in
* the home interface DemoHome.java.
* The parameter sets of the two methods are
* identical. When the client calls
* DemoHome.create(), the container allocates an
* instance of the EJBean and calls ejbCreate().
*/
public void ejbCreate () {
if (verbose)
System.out.println("ejbCreate called");
}
/**
* **** HERE IS THE BUSINESS LOGIC *****
* Do the demoSelect() but don't even go to
* the database in this eg but instead just
* return a String.
* The really BIG thing to notice here is that
* this is the only code we have invented at all
* the rest of the code has been declarations
* or simply implementing methods which are
* part of the EJB interfaces and in this example
* are not even used.
*/
public String demoSelect()
throws RemoteException
{
return("hello world");
}
}
Paso 5: Crear el Fichero ejb-jar
Una de las grandes ventajas de los JavaBeans Enterprise es la habilidad de empaquetar y distribuir la lógica del lado del servidor de la misma forma portable que los componentes GUI. En este paso los ficheros fuente procedentes de los pasos anteriores son compilados y empaquetados en un fichero ejb-jar. Completando los siguientes pasos produciremos el fichero Demo.jar ejb-jar, que estará listo para el despliegue o instalación en el Contenedor de JavaBeans Enterprise.
5.1. Compilar los ficheros .java
Ejecutamos javac sobre los ficheros que acabamos de crear, es decir, los interfaces remoto y home, y el propio bean JavaBeans Enterprise.
javac ejb/demo/DemoHome.java
javac ejb/demo/Demo.java
javac ejb/demo/DemoBean.java
5.2. Crer el Descriptor de Desarrollo
Nota: Desarrollo es el término en JavaBeans Enterprise para instalar los componentes JavaBeans dentro de un contenedor JavaBeans Enterprise.
El papel del descriptor de desarrollo es permitir que el desarrollador del Bean personalice muchas de las propiedades del Bean antes de desplegarlo. El descriptor de desarrollo se describe en la especificación de JavaBeans Enterprise (sección 15.2) como un ejemplar de javax.ejb.deployment.SessionDescriptor o javax.ejb.deployment.EntityDescriptor. En el ejemplo DemoBean, es un ejemplar de javax.ejb.deployment.SessionDescriptor. Abajo hay un ejemplo del fichero de texto de entrada a las utilidades de WebLogic que genera el ejemplar serializado de este descriptor de desarrollo.
Observa que la metodología para crear el descritor de desarrollo no está especificada, por eso las herramientas usadas para desplegar los JavaBeans Enterprise podrían aparecer y actuar de forma diferente unos de otros, sin afectar a las propias habilidades del propio bean muti-plataforma.
Este ejemplo continúa con la creacción de DeploymentDescriptor con las herramientas de WebLogic. La implementación del servidor de Bea WebLogic ofrece versiones para la línea de comandos y GUI. Por eso para desplegar el JavaBean Enterprise usando las herramientas de la línea de comandos, envíamos estos comandos.
java weblogic.ejb.utils.DDCreator -dir ejb/demo
ejb/demo DeploymentDescriptor.txt
Esto creará DemoBeanDD.ser en el directorio ejb/demo.
Un ejemplo del fichero de texto DeploymentDescriptor.txt como entrada para las herramientas de Bea WebLogic: (fuente).
(SessionDescriptor
; This file must start with SessionDescriptor or
; EntityDescriptor
; Indicate the name which the bean will be bound
; into the JNDI name as
beanHomeName demo.DemoHome
; The enterprise Java Bean class (see step 4)
enterpriseBeanClassName ejb.demo.DemoBean
homeInterfaceClassName ejb.demo.DemoHome
; The home interface implemented by a class
; generated by the container provided tools
; see step 3
remoteInterfaceClassName ejb.demo.Demo
; See step 2
isReentrant false
; Always false for session beans
stateManagementType STATELESS_SESSION
; Either STATELESS_SESSION or STATEFUL_SESSION.
; DemoBean is a stateless session bean
sessionTimeout 5
; seconds
(controlDescriptors
; This section decides the run-time properties when
; a method is called. The DEFAULT sub-section applies
; to all methods, but can be overridden on a per-method
; basis, similar to the "accessControlEntries" above.
(DEFAULT
isolationLevel TRANSACTION_SERIALIZABLE
transactionAttribute TX_REQUIRED
runAsMode CLIENT_IDENTITY
)
; end isolationLevel
)
; end controlDescriptors
(environmentProperties
maxBeansInFreePool 100
)
; end environmentProperties
)
; end SessionDescriptor
Nota: Este ejemplo es para el servidor BEA Weblogic que usa punto y coma (;) para líneas de comentario.
5.3. Crear el Manifiesto
El manifiesto lo genera automáticamente la utilidad jar, pero tomará una plantilla, por eso crear un fichero de texto (por ejemplo, ejb/demo/manifest.txt) con los siguientes contenidos. Puedes referirte a la sección sobre el empaquetado del Bean para ver como se usa este fichero de texto.
Para una descripción del fichero de manifiesto, puedes ver la Sección 15,3 de la Espcificación de JavaBeans Enterprise.
Name: ejb/demo/DemoBeanDD.ser
Enterprise-Bean: True
5.4. Asegurarnos de que Tenemos todas las Piezas
Aquí están las piezas que el desarrollador y proveedor de JavaBeans Enterprise necesita suministrar para crear un fichero ejb-jar válido, es decir, el bean JavaBean Enterprise.
- Las clases del bean Enterprise + cualquier otra clase de las que dependa el Bean (Paso 4).
- El interface remoto del Bean Enterprise (Paso 2).
- El interface home del Bean Enterprise (Paso 3).
- Un descriptor de desarrollo (ver arriba).
- Un ejemplar de java.util.Properties, si lo necesita el Bean.
- Un fichero manifiesto que identifica los descriptores de desarrollo del fichero ejb-jar.
El proveedor de Bean JavaBeans Enterprise es responsable de poner todas estas clases dentro del fichero ejb-jar, pero se espera que la mayoría de los proveedores de contenedores y servidores proporcionen herramietnas para hacer este empaquetado y ensamblaje.
5.5. Crear el Fichero ejb-jar
Para el ejemplo juntamos todas las piezas para crear un fichero jar llamando Demo.jar. Se espera que las futuras herramietnas hagan el empaquetado y la generación del fichero ejb-jar mucho más sencillas. Podemos imaginar un ayudante que nos guie y que chequee las dependencias.
Para crear el fichero ejb-jar Demo.jar para el ejemplo, podemos asumir que las piezas del fichero jar están para un directorio llamado ejb. Simplemente creamos un fichero jar con la estructura de este directorio.
Notas: Usamos la bandera m para empaquetar y el fichero ejb/demo/manifest.txt como una plantilla para el manifiesto. No es necesario poner el fichero manifest.txt dentro del fichero jar.
jar cvfm Demo.jar ejb/demo/manifest.txt ejb/demo/*.class \
ejb/demo/*.ser
Al inspeccionar el fichero Demo.jar deberiamos ver una salida similar a esta.
jar tf Demo.jar
META-INF/MANIFEST.MF
ejb/demo/Demo.class
ejb/demo/DemoBean.class
ejb/demo/DemoHome.class
ejb/demo/DemoBeanDD.ser
Como puedes ver, no hay nada demasiado especial sobre el fichero ejb-jar.
Paso 6: Desplegar el DemoBean JavaBean Enterprise
En este paso el JavaBean DemoBean es instalado, o desplegado, dentro de un contenedor de JavaBeans Enterprise. Es importante observar que cada vendedor de servidores tendrá herramietnas específicas para permitir esta instalación.
Seguimos las siguientes instrucciones para instalar DemoBean dentro del servidor de Bea Weblogic que instalamos en el Paso 1.
Desarrollo en BEA WebLogic
En la versión actual del servidor de Weblogic desde Bea Weblogic, desplegar el Bean JavaBean Enterprise significa "poner las clases del Bean donde el servidor Weblogic pueda encontrarlas." Esto no es una cosa dificil, pero tampoco es muy elegante, y esperamos que haya algunas herramientas para simplificar este paso y que hagan lo que está sucediendo más óbvio.
Nota: Este ejemplo asume que el servidor Weblogic está instalado en el directorio /export.
6.1. Generar las Implementaciones
Este paso crea las implementaciones de los interfaces especificados anteriormente, y las clases de soporte específicas del BEA WebLogic para el DemoBean. Observa que no están empaquetadas con nuestro Bean. Las clases generadas son, por ejemplo, los interfaces home y remoto, así como las clases requeridas para el soporte de los protocolos de comunicación. El hecho de que estás clases sean generadas durante el despliegue, y no escritas por el proveedor del Bean (programador) es la parte más importante que permite que los JavaBeans Enterprise sean de protocolo neutral.
Nota: Asumimos que el servidor WebLogic ha sido instalado en el directorio /export. Tendremos que modificar el directorio de destino (con el parámetro -d) si está instalado en otro lugar.
Para generar las implementaciones para el DemoBean usamos las herramientas de Bea WebLogic.
java weblogic.ejbc -d /export/weblogic/classes
ejb/demo/DemoBeanDD.ser
Esta utilidad crea clases con nombres similares a éstos y los pone bajo el directorio /export/weblogic/classes.
ejb/demo/DemoBeanEOImpl.class
ejb/demo/DemoBeanHomeImpl.class
ejb/demo/Skel5k5x705r2x671nd1i1vy2v524ua5y.class
ejb/demo/Skel5q585f5sfzo601q4e725b233m5140.class
ejb/demo/Stub5k5x705r2x671nd1i1vy2v524ua5y.class
ejb/demo/Stub5q585f5sfzo601q4e725b233m5140.class
6.2. Poner el fichero Demo.jar dentro del CLASSPATH del servidor Weblogic
Hay varias formas de hacer esto, pero la más simple es poner el fichero Demo.jar en el directorio /export/weblogic/classes, luego editar el script /export/weblogic/startTengah.sh para incluir el fichero Demo.jar.
/export/weblogic/startTengah.sh
#!/bin/sh
#
# Shell script to manually start Weblogic
# Server on UNIX systems
CLASSPATH=$CLASSPATH:/export/weblogic/classes/Demo.jar
echo $CLASSPATH
java -ms16m -mx16m -verbosegc weblogic.Server
6.3. Editar el Fichero weblogic.properties
Incluimos las instrucciones de carga y arranque para los nuevos JavaBeans Enterprise.
/export/weblogic/weblogic.properties
# # # # # # # # # # # # # # # # # # # # # # # # # #
# Weblogic Enterprise JavaBeans DEMO PROPERTIES
# -------------------------------------------------
# Uncomment the appropriate lines below and modify
# DBMS-related info and paths to match your particular
# installation.
#
# Deploys the Enterprise JavaBean examples.
Uncomment to use.
weblogic.ejb.deploy=\
/export/weblogic/classes/beanManaged.jar,\
/export/weblogic/classes/containerManaged.jar,\
/export/weblogic/classes/statefulSession.jar,\
/export/weblogic/classes/DemoBeanDD.jar
#
# weblogic.properties file continues below...
#
6.4. Parar y re-arrancar el servidor Weblogic
Podemos usar las herramientas de Bea WebLogic para parar y re-arrancar el servidor WebLogic o en un entorno simplemente eliminamos el proceso principal de WebLogic, y usamos el script /expot/weblogic/startTengah.sh para re-arrancarlo. Para más detalles puedes ver la documentación sobre las Herramietnas de BEA Weblogic.
Paso 7: Escribir el Cliente JavaBean Enterprise
Si hemos completado con éxito los pasos del 1 al 6, el DemoBean debería estar desplegado dentro del contenedor de JavaBeans Enterprise y estará listo para aceptar llamadas de un cliente a cualquiera de los métodos especificados en el interface remoto.
Escribir el Cliente
La escritura del cliente es otra de las partes del proceso donde tendremos que escribir algún código, aparte de la propia lógica de negocio del Bean JavaBean Enterprise.
El cliente de un JavaBean Enterprise puede ser una gran variedad de cosas: por ejemplo, un servelt, un applet, o quizás un programa C/C++. El ejemplo DemoClient.java es el cliente para el JavaBean Enterprise DemoBean, creado en los pasos anteriores. Las cosas más importantes a observar en este programa son.
- Establecer el contexto inicial JNDI.
- Localizar el interface home del JavaBean Enterprise usando JNDI.
- Usar el interface home para instruir al Contenedor para que cree un ejemplar del JavaBean Enterprise.
- Usar el interface remoto para instruir al Contenedor de que ejecute los métodos del JavaBean Enterprise.
Otra cosa a observar es que como hemos desplegado el Bean en diferentes servidores/contenedores, necesitaremos diferentes versiones del código del cliente. Las diferencias en este código no se espera que sean importantes, pero podrían crear problemas, como los strings correctos para la conexión inicial. Por ejemplo, consideremos el siguiente código, que configura el objeto Properties para que el Bea WebLogic recupere el objeto initialContext JNDI. Podría diferir del string Properties de Oracle para obtener el objeto initialContext.
p.put(Context.INITIAL_CONTEXT_FACTORY,
"weblogic.jndi.T3InitialContextFactory");
Hay una gran variedad de pequeños problemas que podrían requerir algún ajuste o recompilación del código del cliente, pero no se espera que se necesiten grandes cantidades de trabajo.
El siguiente cliente demuestra cómo localizar el JavaBean Enterprise y como invocar a su métodos remotos.
(Código fuente) de DemoClient.java
/**
* DemoClient -- demonstrates using a minimal
* Java application to talk to the DemoBean
* stateless session bean
*/
package ejb.demo;
import javax.ejb.*;
import javax.naming.*;
import java.rmi.*;
import java.util.Properties;
/**
* DemoClient demonstrates using a minimal stateless
* session bean.
* Remember view session beans as an extension of your
* client running in the server.
*/
public class DemoClient {
public static void main(String[] args) {
System.out.println("\nBegin DemoClient...\n");
parseArgs(args);
try {
// Create A DemoBean object, in the server
// Note: the name of the class corresponds to the
// JNDI property declared in the
// DeploymentDescriptor
// From DeploymentDescriptor ...
// beanHomeName demo.DemoHome
Context ctx = getInitialContext();
DemoHome dhome = (DemoHome)
ctx.lookup("demo.DemoHome");
// Now you have a reference to the DemoHome object
// factory use it to ask the container to creat an
// instance of the Demo bean
System.out.println("Creating Demo\n");
Demo demo = dhome.create();
// Here is the call that executes the method on the
// server side object
System.out.println("The result is "
+ demo.demoSelect());
}
catch (Exception e) {
System.out.println(" => Error <=");
e.printStackTrace();
}
System.out.println("\nEnd DemoClient...\n");
}
static void parseArgs(String args[]) {
if ((args == null) || (args.length == 0))
return;
for (int i = 0; i < args.length; i++) {
if (args[i].equals("-url"))
url = args[++i];
else if (args[i].equals("-user"))
user = args[++i];
else if (args[i].equals("-password"))
password = args[++i];
}
}
static String user = null;
static String password = null;
static String url = "t3://localhost:7001";
/**
* Gets an initial context.
*
* @return Context
* @exception java.lang.Exception if there is
* an error in getting a Context
*/
static public Context getInitialContext()
throws Exception {
Properties p = new Properties();
p.put(Context.INITIAL_CONTEXT_FACTORY,
"weblogic.jndi.T3InitialContextFactory");
p.put(Context.PROVIDER_URL, url);
if (user != null) {
System.out.println ("user: " + user);
p.put(Context.SECURITY_PRINCIPAL, user);
if (password == null)
password = "";
p.put(Context.SECURITY_CREDENTIALS, password);
}
return new InitialContext(p);
}
}
Paso 8: Compilar y Ejecutar el Cliente
Todo lo que queda por hacer es compilar y ejecutar el programa cliente para asegurarnos de que los JavaBeans Enterprise, instalados en el servidor, funcionan correctamente.
La compilación y ejecución del cliente son idénticos para todas las plataformas, y también lo deberían ser los resultados del cliente.
8.1. Compilar el Cliente
javac ejb/demo/DemoClient.java
8.2. Ejecutar el Cliente
El string "Hello World" viene del método DemoSelect() del JavaBean Enterprise. Al ejecutarlo deberíamos ver los siguientes mensajes.
java ejb.demo.DemoClient <cr>
Begin DemoClient...
Creating Demo
The result is hello world
End DemoClient...
Tutoriales
