22 April, 2008

Ejemplo EJB stateless

Lo prometido es deuda y ahora q se me ha pasado la vagancia y además tenía un ratillo libre (combinación compleja donde las halla) ;-) os dejo un ejemplo de un ejb sin estado (stateless).

Yo he utilizado jboss en su última versión estable (4.2.2.GA) como contenedor del ejb, para utilizarlo solo teneis que descargaros una copia y arrancar ejecutando /bin/run.sh, ¿fácil verdad?. Podriamos haber utilizado glassfish, que en ubuntu se queda la instalación en un maravilloso apt-get install glassfish, pero si os parece eso lo dejamos para otro día.

Vamos con nuestro ejb.

Primero nos creamos el bean que encapsula toda nuestra lógica de negocio. En este caso tendremos solo 2 métodos, para sumar y restar 2 números (operaciones básicas de toda calculadora).

  1. package net.jsanroman.ejb3stateless.ejb.stateless;
  2. import javax.ejb.Stateless;
  3. import net.jsanroman.ejb3stateless.ejb.interfaces.CalculadoraLocal;
  4. import net.jsanroman.ejb3stateless.ejb.interfaces.CalculadoraRemote;
  5.  
  6. @Stateless
  7. public class CalculadoraBean implements CalculadoraRemote, CalculadoraLocal
  8. {
  9.     public static final String RemoteJNDIName = CalculadoraBean.class.getSimpleName()+"/remote";
  10.     public static final String LocalJNDIName = CalculadoraBean.class.getSimpleName()+"/local";
  11.  
  12.     public int add( int x, int y ){return x+y;}
  13.     public int subtract (int x,int y){return x-y;}
  14. }

Destacar el uso de la anotación @Stateless para indicar el tipo de ejb que estamos creando.

A continuación creamos las interfaces CalculadoraLocal y CalculadoraRemote para indicar que métodos serán accesibles desde el propio contenedor o desde fuera y que serán implementadas por nuestro bean anterior.

En nuestro caso solo nos interesa acceder desde remoto pues haremos las pruebas desde un script fuera de nuestro contenedor.

  1. package net.jsanroman.ejb3stateless.ejb.interfaces;
  2. import javax.ejb.Local;
  3. @Local
  4. public interface CalculadoraLocal { 
  5. }

  1. package net.jsanroman.ejb3stateless.ejb.interfaces;
  2. import javax.ejb.Remote;
  3. public interface CalculadoraRemote {
  4.     public int add(int x, int y);
  5.     public int subtract( int x, int y);
  6. }

Ya tenemos nuestro ejb creado, lo empaquetamos en un .jar (tareilla ant) y lo soltamos en jboss/server/default/deploy. Si nos fijamos en el log de jboss podremos averiguar si se ha producido algún error, pero para estar completamente seguros nos vamos a la jmx-console http://localhost:8080/jmx-console/ y comprobamos si se ha cargado nuestro ejb, en mi caso aparecen estas lineas que indican que está listo para ser utilizado:

# jar=ejb3_stateless_calculadora.jar,name=CalculadoraBean,service=EJB3
# module=ejb3_stateless_calculadora.jar,service=EJB3

Llegados a este punto tan solo nos queda desarrollar un sencillo cliente que haga uso del ejb recién creado. Con una simple clase que muestre el resultado por consola es suficiente para esta prueba:

  1. package net.jsanroman.ejb3stateless.client;
  2. import java.util.Properties;
  3. import javax.naming.Context;
  4. import javax.naming.InitialContext;
  5. import javax.naming.NamingException;
  6. import net.jsanroman.ejb3stateless.ejb.interfaces.CalculadoraRemote;
  7. import net.jsanroman.ejb3stateless.ejb.stateless.CalculadoraBean;
  8. public class CalculadoraClient {
  9.     public static void main(String [] args){
  10.         Properties properties = new Properties();
  11.         properties.put("java.naming.factory.initial","org.jnp.interfaces.NamingContextFactory");
  12.         properties.put("java.naming.factory.url.pkgs","=org.jboss.naming:org.jnp.interfaces")
  13.         properties.put("java.naming.provider.url","localhost:1099");
  14.         Context contexto = null;
  15.         try{
  16.             contexto = new InitialContext(properties);
  17.             CalculadoraRemote beanRemoto = (CalculadoraRemote)
  18.             contexto.lookup(CalculadoraBean.RemoteJNDIName);
  19.             int resultado = beanRemoto.add(1, 9);
  20.             System.out.println("El resultado es:"+resultado);
  21.         }
  22.         catch( NamingException e )
  23.         {
  24.             e.printStackTrace();
  25.         }
  26.     }
  27. }

Simplemente destacar la linea contexto.lookup(CalculadoraBean.RemoteJNDIName); causa de posibles rompederos de cabeza y que nos da acceso a nuestro ejb.

Ala y ahora a hacer pruebas con los diferentes ejb's, el ejb-ql, a probar desde otra máquina, y lo que se nos ocurra.

25 March, 2008

Curso J2EE (4ª semana) - EJB

Logo JavaComo aventuraba en el anterior post de esta serie, esta semana hemos comenzado con ejb. Después de una introducción donde se repasaron las complejidades de ejb2 y su posterior evolución a ejb3, nos centramos únicamente en ejb3 y en desarrollar algún que otro ejemplo utilizando como contenedor a jboss.

EJB forma parte de j2ee desde su versión 1.1 y mediante su especificación se detalla cómo los servidores de aplicaciones proveen objetos desde el lado del servidor. Utilizando ejb creamos componentes que encapsulan lógica de empresa y estos pueden ser de 3 tipos: de entidad, de session (con estado y sin estado) y dirigidos por mensajes.

Los componentes desarrollados bajo la especificación ejb deben ser desplegados en un contenedor de ejb para su uso. Este contenedor no es mas que una aplicación que normalmente reside en el servidor de aplicaciones y que provee de servicios a nuestros componentes (persistencia, transacciones, seguridad, servicios de red, etc).

No debemos confundir Enterprise Java Beans con Java Beans. Mientras que los primeros son componentes que almacenan lógica de empresa y deben ser desplegados en un contenedor de ejb con el que se comunica para hacer uso de sus servicios, los segundos utilizan una arquitectura para desarrollar componentes con fines generales agrupando datos y funcionalidades comunes y pueden ser ejecutados en cualquier entorno java.

Ejb2 es complejo (múltiples descriptores de despliegue para un ejb, creación de múltiples interfaces, múltiples callbacks usualmente inutilizados). Ejb3 simplifica notablemente el desarrollo, ahora los ejb son POJOs, simplifica la configuración mediante el uso de anotaciones en lugar de descriptores de despliegue, soporte de inyección de dependencias, mejoras en el lenguaje de consultas EJB-QL, no necesitamos tener interfaces de componentes para los ejb's.

En la web de jboss tenemos una interesante colección de ejemplos ejb3.

Y en la misma web un completo manual sobre ejb3.

A ver si el próximo día dejo algún ejemplillo que hoy estoy un poco vago :-).

Powered by WordPress
Bajo licencia Creative Commons
Contacto sanroman.javier at gmail.com