Mio Mi Blog

un blog de un ubuntero… para ubunteros =)

Archivo de Junio 2007

11. JMS

Publicado por velorek en Junio 7, 2007

¿Que es JMS?

Servicio de Mensajes Java.En las comunicaciones cliente servidor, los datos que se intercambian entre las dos partes necesitan de una comunicación sincrona, es decir, que las dos partes esten presentes en el momento de la comunicación. Los sistemas de mensajes aportan una serie de mejoras a la comunicación entre aplicaciones que no tienen por que residir en la misma máquina.

JMS se situa como middleware en medio de la comunicación de dos aplicaciones. En entornos cliente servidor, cuando la aplicación A quiere comunicarse con la Aplicación B, necesita saber donde esta B (su IP por ejemplo) y que B esté escuchando en ese momento. Cuando se usa un sistema de mensajes, la aplicación A envía un mensaje, el sistema de mensajes lo recibe y se lo envía a B cuando se conecte al servicio. De esta manera se consigue una comunicación asíncrona entre A y B, es decir no hace falta que B esté presente en el momento del envío del mensaje, y no por ello va a dejar de recibirlo.

Arquitectura de JMS

Una aplicación JMS consta de los siguientes elementos:

Clientes JMS Aplicaciones que envian o reciben mensajes a través de JMS
Mensajes Los mensajes que se intercambian
Objetos administrados Los objetos JMS a los que se dirigen las comunicaciones
  • Objetos administrados

Los objetos administrados son el punto al que se comunican los clientes JMS para enviar o recibir mensajes, se denominan objetos administrados por que los crea el administrador. Implementan las interfaces JMS y se sitúan en el espacio de nombres de JNDIpara que los clientes puedan solicitarlos.

Hay dos tipos de objetos administrados en JMS:

ConectionFactory: Se usa para crear una conexión al proveedor del sistema de mensajes.

Destination: Son los destinos de los mensajes que se envían y el recipiente de los mensajes que se reciben.

  • Mensajes

Es el corazón del sistema de mensajes. Estan formados por tres elementos:

Header: Es la cabecera del mensaje, contiene una serie de campos que le sirven a los clientes y proveedores a identificar a los mensajes.

Properties: Son propiedades personalizadas para un mensaje en particular.

Body: Es el mensaje en si, hay distintos tipos:

StreamMessage:Contiene un stream de datos que se escriben y leen de manera secuencial.
MapMessage: Contiene pares nombre-valor.
TextMessage: Contiene un String.
ObjectMessage: Contiene un objeto que implemente la interfaz Serializable.
BytesMessage: Contiene un stream de bytes.

Clientes JMS

Son clientes de JMS tanto el que suministra mensajes como el que los recibe. Todos tienen una serie de pasos en común antes de lograr enviar o recibir un mensaje:

  • Conseguir un objeto ConnectionFactory a través de JNDI.
  • Conseguir un destino, mediante el objeto Destination a través de JNDI.
  • Usar ConnectionFactory para conseguir un objeto Connection
  • Usar Destination para crear un objeto Session.

Aplicaciones punto a punto

En las conexiones punto a punto, es decir, con solo dos extremos en la comunicación, el que envía y el que recibe, el destino en el que se reciben los mensajes enviados y de donde se recogen los mensajes recibidos recibe el nombre de Cola de mensajes (en inglés Queue) y actúa como una cola FIFO (el primer mensaje que llega es el primer mensaje que se recoge).

Vamos a seguir los pasos que necesita un cliente JMS para conseguir una conexión a una cola de mensajes.

  • Primero debemos crear un contexto inicial para JNDI:

InitialContext contextoInicial = new InitialContext();

  • Recuperamos de este contexto el objeto QueueConnectionFactory
   QueueConnectionFactory factory =
               (QueueConnectionFactory)contextoInicial.lookup("QueueConnectionFactory");
  • Recuperamos de la JNDI la cola de mensajes
   Queue cola = (Queue)contextoInicial.lookup("Cola");
  • Mediante el metodo createQueueConnection() de factory conseguimos un objeto QueueConnection.
   QueueConnection conexion = factory.createQueueConnection();
  • El objeto anterior nos sirve ahora para crear una sesión, los parámetros los comentaremos mas tarde:
   QueueSession sesion =
               conexion.createQueueSession(false,sesion.AUTO_ACKNOWLEDGE);

A partir de ahora ya podriamos crear mensajes y enviarlos. Vamos a ver un ejemplo sencillo de una comunicación punto a punto.

Ejemplo de una comunicación punto a punto

Para poder probar los ejemplos, necesitamos tener instalada la J2EE 1.3 o superior (es donde viene la api JMS, en el paquete javax.jms) y el classpath debe incluir a j2ee.jar. Esto será requisito previo para la compilación y ejecución de todos los ejemplos.

Antes de compilar y ejecutar los ejemplos, debemos crear los objetos administrados que usaremos en los ejemplos:

  • Ejecutamos el servidor J2EE: j2ee -verbose
  • Entre el montón de mensajes que imprime, divisamos QueueConnectionFactory, es el ConnectionFactory por defecto.
  • Crearemos un destino para nuestros mensajes: j2eeadmin -addJmsDestination Cola queue
  • Esto crea un Destination llamado Cola del tipo queue, comprobamos que esta creado: j2eeadmin -listJmsDestination

Esta es la clase que envía mensajes a la cola Envia Cola [ver codigo]

mn

Publicado en Invest. J2EE | Deja un Comentario »

10. JNDI

Publicado por velorek en Junio 6, 2007

¿Qué es JNDI?

Es el sistema de nombrado en Java.

Un sistema de nombrado significa qué nombres están asociados con objetos y cómo se localizan los objetos basándose en sus nombres.

Cuando usamos cualquier programa o sistema, estamos nombrando un objeto u otro. Por ejemplo, cuando usamos un sistema de correo electrónico, debemos proporcionar el nombre del recipiente al que queremos enviar el correo. Para acceder a un fichero en el pc, debemos suministrar su nombre, entonces,un servicio de nombres nos permite localizar un objeto dando su nombre.

Arquitectura

JNDI es un API genérico, de tal manera que es necesario integrarlo con otros sistemas de nombres. Para ellos, la arquitectura JNDI incluye una interfaz de provision del servicio (SPI), que sirve como intermediario con otros proveedores de servicios de nombres.


Estos proveedores traducen las llamadas al API JNDI en llamadas reales sobre un servidor de nombres o directorios.

Necesitamos las clases del proveedor de servicio que hayamos elegido. Desde la versión 1.4.1 el JDK cuenta con los siguientes proveedores de servicio de nombres:

* Lightweight Directory Access Protocol (LDAP)
* DNS
* Common Object Request Broker Architecture (CORBA)
* Remote Method Invocation (RMI)

Cuando usamos como proveedor de servicios el sistema de ficheros, no necesitamos configurar el servidor, ya que el sistema de ficheros actúa como servidor.

Para bajar un proveedor de servicios pincha aquí.

Primeros Pasos con JNDI

Buscaremos un objeto,

Vamos a pedir al usuario un nombre de archivo o de directorio por teclado. La finalidad es que podamos obtener el objeto asociado. El inicio es utilizar un stream de teclado para pedir el nombre:

import java.util.*;
import javax.naming.*;
import java.io.*;

public class primeros_pasos01 {
public static void main(String[] args) {

BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));

try {

/* Pedir por teclado un nombre

System.out.print( “Indique un nombre:”);
String name = entrada.readLine();

Lo siguiente es definir una Hashtable en la que indicamos que usaremos un sistema de archivos. A continuación usamos el método lookup() para buscar el nombre. Este método devuelve el objeto asociado o produce una excepción:

/* Indicamos que el contexto tiene como proveedor de servicio el sistema de archivos (fsContext)*/

Hashtable env = new Hashtable();

env.put(Context.INITIAL_CONTEXT_FACTORY, “com.sun.jndi.fscontext.RefFSContextFactory”);

Context ctx = new InitialContext(env);

/*Buscar el objeto*/

Object obj = ctx.lookup(name);

/ *Mostrar

System.out.println(“El nombre ” + name + ” esta ligado al objeto ” + obj.toString());

Evidentemente debemos manejar las excepciones:

catch ( NamingException e ) {
System.out.println( e.toString() ); }

catch ( IOException e ) {
System.out.println( e.toString() );
}

Si hemos indicado el directorio /Temporal obtenemos:

El nombre /Temporal esta ligado al objeto com.sun.jndi.fscontext.RefFSContext@15b7986

Si hemos indicado el archivo /Temporal/Presentacion.ppt obtenemos:

El nombre /Temporal/Presentacion.ppt esta ligado al objeto \Temporal\Presentacion.ppt


JNDI: acceso a propiedades de entorno (web.xml)

Ahora vamos a mostrar un servlet que usa de JNDI para acceder a propiedades definidas en el archivo web.xml. Supongamos que tenemos una serie de propiedades definidas en web.xml con la forma env-entry:

ejemplos/server
http://chunda.com
java.lang.String

El servlet en doGet() toma un contexto inicial vacio o “por defecto”, es decir, el conjunto de nombres definido en web.xml. Observar que llamamos a InitialContext() sin argumentos; esto implica pedir un contexto vacio de propiedades o, lo que es lo mismo, el contexto de nombres definido en web.xml.

Con lookup() buscamos la entrada “ejemplos/server”:


try {

contexto = new InitialContext(); /*Equivalente: new InitialContext(null).*/

/* Busca propiedad de entorno*/

servidorHttp = (String) contexto.lookup(“java:comp/env/ejemplos/server”);}
catch(NamingException e) {
resultado = new String(e.toString()); } /*Ha fallado lookup()*/

Invocar al servlet de ejemplo.

Código fuente.

Enumerar los vínculos
Podemos enumerar todos los vinculos (bindings):

NamingEnumeration bindings = contexto.listBindings(“java:comp/env/ejemplos”);
while (bindings.hasMore()) {

Binding bd = (Binding) bindings.next();
out.println( ”
” + bd.getName() + “: ” + bd.getObject() + “, ” +
bd.getObject().getClass().getName() +”");

}

Publicado en Invest. J2EE | Deja un Comentario »

09. Beans – Parte III

Publicado por velorek en Junio 6, 2007

ROLES EJB, la arquitectura define seis papeles principales, estos son:

  • Desarrollador de beans: desarrolla los componentes enterprise bean.
  • Ensamblador de aplicaciones: compone los enterprise beans y las aplicaciones cliente para conformar una aplicación completa.
  • Desplegador: despliega la aplicación en un entorno operacional particular (servidor de aplicaciones)
  • Administrador del sistema: configura y administra la infraestructura de computación y de red del negocio.
  • Proporcionador del Contenedor EJB y Proporcionador del Servidor EJB: un fabricante (o fabricantes) especializado en manejo de transacciones y de aplicaciones y otros servicios de bajo nivel. Desarrollan el servidor de aplicaciones.

EVOLUCIÓN DE LA ESPECIFICACION DE EJB
La arquitectura Enterprise JavaBeans es una arquitectura de componentes para el desarrollo y despliegue de aplicaciones de empresa distribuidas y orientadas a objetos. Las aplicaciones escritas usando la arquitectura Enterprise JavaBeans son escalables, transaccionales y seguras para multi usuarios. Estas aplicaciones pueden escribirse una vez y luego desplegarse en cuaquier servidor que soporte la especificación Enterprise JavaBeans.

Algunas de las revisiones que han sufrido la especificación de la arquitectura EJB.

  1. EJB 1.0 (Marzo 1998): propuesta inicial, se introducen los beans de entidad y de sesion.
  2. EJB 1.1 (Diciembre 1999): implementación obligatoria de los beans de entidad y acceso al entorno de los beans mediante JNDI.
  3. EJB 2.0 (Agosto 2001): manejo de mensajes con los beans dirigidos por mensajes. Relaciones entre los beans manejadas por el contenedor.
  4. EJB 2.1 (Agosto 2002): soporte para servicios web. Temporizador manejado por el contenedor de beans.

VENTAJAS DE LA TECNOLOGÍA EJB
Las ventajas que ofrece la arquitectura Enterprise Java Beans a un desarrollador de aplicaciones se listan a continuación.

  • Simplicidad.
  • Portabilidad de la Aplicación.
  • Reusabilidad de componentes.
  • Posibilidad de construcción de aplicaciones complejas.
  • Separación de la lógica de presentación de la lógica de negocio.
  • Despliegue en muchos entornos operativos.
  • Despliegue distribuido.
  • Interoperabilidad entre aplicaciones.
  • Integración con sistemas No-Java.
  • Recursos educativos y herramientas de desarrollo.

Entre las ventajas que aporta esta arquitectura al cliente final:

  • Elección del servidor.
  • Gestión de las aplicaciones.
  • Integración con aplicaciones y datos ya existentes.
  • Seguridad.

Publicado en Invest. J2EE | Deja un Comentario »

08. Beans – Parte II (BSesion)

Publicado por velorek en Junio 6, 2007

DESARROLLO DE BEANS el desarrollo y programación de los beans suele ser un proceso bastante similar sea cual sea el tipo de bean. Consta de los siguientes 5 pasos:
  1. Escribe y compila la clase bean que contiene a todos los métodos de negocio.
  2. Escribe y compila las dos interfaces del bean home y componente.
  3. Crea un descriptor XML del despliegue en el que se describa qué es el bean y como debe manejarse. Este fichero debe llamarse ejb-jar.xml
  4. Pon la clase bean, los interfaces y el descriptor XML del despliegue en un fichero EJB JAR. Podría haber más de un bean en el mismo fichero EJB JAR, pero nunca habrña mas de un descritpor de despliegue.
  5. Despliega el bean en el servidor usando las herramientas proporcionadas por el servidor de aplicaciones.
Para ver el detalle de estos pasos vamos a utilizar un ejemplo sencillo de un bean de sesión sin estado el que implementa el metodo de negocio saluda() y que devuelve un string con un saludo.

CLASE BEAN, en esta clase se encuentran los denominados métodos de negocio. Son los métodos finales a los que el cliente quiere acceder y los que se deben programar. Son también los métodos definidos en la interfaz del componente.
Lo primero que hay que decidir es que tipo de bean queremos hacer, estos se definen con tres interfaces distintas:

  • SessionBean
  • EntityBean
  • MessageBean
Cualquier bean debe implementar uno de estos tipos, ahora en este caso vamos a definir un bean sin sesión sin estado, por lo que la clase SaludoBean implementara la interfaz SessionBean. Para crar el bean en el NetBeans lo hacemos de la siguiente forma. Primero creamos un nuevo modulo EJB


Presionamos siguiente, y tenemos la siguiente pantallita

Aca elegiremos el servidor con el que trabajaremos, que será JBOOS, pueden descargarlo de aca http://www.jboss.com, y le colocaremos a nuestro proyecto SaludoEJBS, ahora es necesario que creemos un bean de entidad para eso hacemos click con el botón derecho sobre el proyecto y elegimos Session Bean

Y le colocaremos SaludoEJB, y en el nombre del paquete que se guardara colocamos beanSesion click en la imagen para verla más grande


Ahora nos fijamos que se crean un par de archivos por defecto que son los siguientes

Bueno los codigos de cada uno pueden descargalos aca: SaludoEJBBean, SaludoEJBRemote y SaludoEJBRemoteHome.

Una vez echo eso eso necesario que creemos el cliente el cual se encargara de llamar al bean de sesión creado para eso creamos una nueva clase java y la guardamos en un paquete llamado cliente descargar el codigo aca: SaludoCliente, el codigo del cliente fue hecho por Ricardo Rodriguez el ayudante del curso, aca esta la pagina de ayuda del curso para que la vean ahy http://www.inf.uct.cl/~rarodrig/pag_j2ee/ ay un ejemplo tb, este lo saque de la pagina que puse en la primera parte de los beans, y el codigo del cliente tenia errores asi ke use el de Ricardo.

Como vemos además, en el punto 3 de las acciones que se realizan al crear un beans, tenemos que se genera un archivo XML el cual podemos verlo al hacer click en Configuration Files hacer doble click en el y aparecera lo siguiente:

Deben fijarse siempre que en la clase cliente donde dice Object ref = jndiCotext.lookup(“SaludoEJBBean”); ese nombre que se le pasa por parametro a lookup es el mismo que aparece en el archivo de configuracion XML.

Ahora que ya tenemos creado todos el paquete Cliente y el Bean de Sesión procedemos a compilar el proyecto de la siguiente forma

Y luego ejecutamos el SaludoCliente de la siguiente forma

Una véz hecho todos estos pasos deberiamos ver en la ventanita de ejecución lo siguiente

En donde se ve como se va ejecutando el cliente y como se va obteniendo una referencia al beans de sesión.

Explicaciones:

  • SaludoEJBBean es en el cual se define el beans, se tienen que definiri las interfaces componente y home.
  • SaludoEJBRemote (o interfaz componente) es en la cual se definen los métodos de negocio del beans, los que va a poder llamar el cliente para pedir al bean que realice sus funciones y todos van a ser remotos ya se van a implantar en una maquina virtual java distinta de la maquina, por ello todos estos métodos deben declarar la excepción RemoteException.
  • SaludoEJBRemoteHome esta interfaz hereda de la interfaz EJBHome, el cliente usa los métodos de esta interfaz para obtener una referencia a la interfaz componente. Se puede pensar en el home como en una especie de fabrica que construye referencias a los beans y las distribuye entre los clientes. el método create() se corresponde con el método ejbCreate() definido en la clase SaludoEJBBean y debe devolver el tipo SaludoEJBRemote de la interfaz componente, la interfaz también va a ser remota y por lo tanto debe declarar la expeción RemoteException. Además el método create debe declarar la excepción CreateException.
  • Cuando se despliega un bean en el contenedor EJB, este crea dos objetos que llamaremos EJBObject y EJBHome que implementarán estas interfaces. Estos objetos separan el bean del cliente, de forma que el cliente nunca accede directamente al bean, asi el contenedor puede incorporar sus servicios a los métodos de negocio.
  • SaludoCliente: cuando ya se ha desplegado en el contenedor, ya podemos usarlo desde un cliente. El cliente puede ser una clase Java cualquiera, ya sea un cliente aislado o un servlet que se esta ejecutando en el contenedor web del servidor de aplicaciones. El codigo que debe ejecutar los clientes del bean es básicamente el mismo en cualquier caso.
    Básicamente el cliente debe realizar estas cinco tareas.
  1. Acceder al servicio JNDI, obtendiendo el contexto JNDI inicial.
  2. Localizar el bean proporcionado a JNDI en este caso el JNDI del bean es SaludoEJBBean.
  3. Hacer un casting del objecto que devuelve JNDI para comvertirlo en un objeto de la clase SaludoEJBRemoteHome.
  4. Llamar almétodo create() del objeto home para crear un objeto de tipo SaludoEJBBEan.
  5. Llamar a los mñetdos de negocio del Bean.
  • Descriptor de Del Despliegue: son ficheros XML en el que se detalla todo lo que el servidor necesita saber para gestionar el bean, el nombre de este fichero siempre debe ser ejb-jar.xml

Ya eso mas menos en esta parte, uta ke hay que leer weas wn….

ya eso no ma FUCKIN’s BEANS!

… =)

Publicado en Invest. J2EE | Deja un Comentario »

07. Beans – Parte I

Publicado por velorek en Junio 2, 2007

Bueno aca debemos comenzar por investigar ¿que son los Beans? ¿como conecto los servlet con la BD?¿como utilizo los Beans para poder conectarme con una BD?¿como hago los ingresos y las lecturas?, bueno eso eso mas menos lo que tenemos que investigar. Bueno para poder descubrir que son, investigue en internet y me pille con una página que contenia un texto llamado INTRODUCCIÓN A LA TECNOLOGIA EJB por eso intentare hacer un resumen de lo que sale.

Los temas que aca se taratan son
  • Desarrollo Basado en componentes
  • Servicios proporcionados por el contenedor EJB
  • Funcionamiento de componentes EJB
  • Tipos de beans
  • Desarrollo de beans
  • Clientes de los beans
  • Roles EJB
  • Evolución de la especificación EJB
  • ventajas de la tecnológía EJB

Desarrollo basado en componentes
Debido al gran avance que ha tenido la programación a objetos, se ha podido ir abriendo camino en el desarrollo de componentes (enterprise beans), los cuales nos permiten poder ir reutilizando codigo, adaptarlos a otros prgramas sin nisikiera tener que modificar nuestros códigos, por ejemplo podriamos desarrollar un bean cliente que represente un a un cliente en una BD, el cual podriamos volver a reutilizarlo en un nuevo programa de contablidad.

Por ahora podemos ver un componente como un objeto tradicional con un conjunto de servicios adicionales soportados por el contenedor de componentes. El contenedor de componentes se denomina contenedor EJB y es algo asi como el sistema operativo en el que estos residen. Además tenemos que todas las características de los beans se definen mediante un archivo XML.

Servicios proporcionados por el contenedor EJB
Hemos visto que la diferencia entre los objetos y los componentes es que los componentes viven en un contenedor EJB que los envuelve proporcionando una capa de servicios añadidos. ¿cuales son estos servicios? los mas importantes son los siguientes:

  • Manejo de Transacciones (llamadas a los métodos del bean)
  • Seguridad (permisos de acceso a los métodos del bean)
  • Concurrencia (llamadas a los beans desde multiples clientes)
  • Servicios de Red (comunicación bean-cliente)
  • Gestión de recursos
  • Persistencia (sincronización bean-tablas de una BD)
  • Gestión de Mensajes manejo de Java Message Service (JMS)
  • Escalabilidad (aumenta host en caso de aumentos repentinos de carga de la aplicación)
  • Adaptación en tiempo de despliegue (modificación de todas las caracteristicas en el momento del despliegue del bean)

Entenderemos por Despliegue a la incorporación del componente a nuestro contenedor EJB y a nuestro entorno de trabajo

Ahora si la aplicación que uno esta desarrollando no va a necesitar de esos servicios y va a tener una interfaz web, se puede simplemente utilizar paginas JSP y JDBC.

Funcionamiento de los componentes EJB

El funcionamiento de los componentes EJB se basa fundamentalmente en el trabajo del contenedor EJB. El contenedor EJB es un programa JAVA que corre en el servidor y que contiene todas las clases y objetos necesarios para el correcto funcionamiento de los EJB.

En la siguiente figura podemos ver muy claramente el funcionamiento basico de los EJB.

Aca podemos ver que el cliente realiza peticiones al bean y el servidor contiene el bean estan ejecutandose en maquinas virtuales java distintas, incluso pueden estar en distintos host. Ademas hay que decir que el cliente nunca se comunica directamte con el bean sino que el contenedor EJB proporciona un EJBObject que hace de interfaz. asi tenemos que todas las peticiones se deben hacer a través del objeto EJB el cual se comunica con el bean el cual por ultimo realiza las peticiones a la BD.

¿De que cosas se preocupa el contenedor EJB?

  • ¿Tiene permisos el cliente para llamar al método?
  • Hay que abrir la transacción al comienzo de la llamada y cerarla al terminar.
  • ¿es necesario refrescar el bean con los datos de la BD?

EJEMPLO: imaginemos que tenemos una aplicación de ventas con un beans llamado Personas la cual tiene varios metodos entre ellos compra. Supongamos que desde el objeto cliente queremos llamar al método compra, esto va a provocar que se realizen los siguientes pasos:

  1. Cliente: “Necesito hacer una peticiñon de compra al bean Personas”
  2. EJBObject: “Espera un momento, tengo que comprobar que tienes permisos”
  3. Contenedor EJB: “Si, tienes permisos para hacer la llamada al método compra”
  4. Contenedor EJB: “Necesito un bean Personas para realizar la operación de compra, no se olviden de comenzar la transacción”
  5. (Reserva) Pool de Beans: “A quien le toca esta vez”
  6. Contenedor EJB: “Ya tengo un bean Personas, pasale la petición al cliente”

Tipos de Beans

La tecnología EJB define tres tipos de beans:

  1. Beans de Entidad: representan un objeto concreto que tiene existencia en alguna BD.
  2. Beans de Sesion: representa un proceso o una acción de negocio, normalmente cualquier llamada a un servicio del servidor debería comenzar con una llamada a un bean de sesión.
  3. Beans Dirigidos por Mensajes: pueden escuchar mensajes de un servicio de mensajes JMS, estos nunca se comunican directamente con el cliente y no necesitan objetos EJBObjct, un ejemplo podria ser ListenerNuevoCliente que se activa cada vez que se envia un mensaje que se ha ingresado un nuevo cliente.

Descripción Individual
Los BEANS DE SESIÓN representan sesiones interactivas con uno o mas clientes, pueden mantener un estado, pero solo durante el tiempo que el cliente interactua con el bean. Esto significa que los beans de sesión no almacenan sus datos en una BD despues que el cliente termine el proceso.

Estos beans no se comparten entre mas de un cliente, sino que ecxiste una correspondencia 1-1 entre beans de sesión y clientes.

Existen dos tipos de beans de sesión: con estado y sin estado.

Los beans de sesión sin estado no se modifican con las llamadas de los clientes solo reciben datos y devuelven resultados pero no modifican internamente el estdo del bean. Estos beans por lo general son usados para encapsular procesos de negocio, mas que datos de negocio (tarea de los beans de entidad), también puede usarse como puente de acceso a una BD o a un bean de entidad. Cuando trabajamos con cliente-servidor estos beans podrian proporcionar al interface de usuario los datos necesarios, estos beans de sesión sin estado son de uso muy frecuente.

Los beans de sesión con estado almacenan datos especificos obtenidos durante la conexión con el cliente, cada bean de sesión con estado por lo tanto almacena el estado conversacional de un cliente con el que interactua. Este estado conversacional se modifica conforme el cliente va realizando llamadas a los métodos de negocio del bean. El estado conversacional no se guarda cuando el cliente termina la sesión.

Osea este beans usado va cambiando conforme el cliente lo necesite, algunos metodos que contienen estos son los set y los get, un ejemplo claro es el carrito de compras que a medida que vamos avanando se le van agregando mas cosas, o en un inicio de sesión cuando necesitamos tener en alguna parte los datos de la persona que ha hecho login.

Los BEANS DE ENTIDAD modelan conceptos o datos de negocio, que pueden expresarse como nombres. Representan “cosas”: objetos del mundo real como Hoteles, habitaciones, expedientes, estudiantes y demases. Un bean de entidad puede representar incluso cosas abstractas como una reserva, describen tanto el estado como la conducta de objetos del mundo real y permite a los desarrolladores encapsular reglas de datos y negocio asociadas con un concepto especifico. Por ejemplo un bean de entidad Estudiante encapsula los datos y reglas de negocio asociadas a un estudiante. esto hace posible manejar de forma consistente y segura los datos asociados a un concepto.

Los beans puden contener información por ejemplo de un estudiante sin necesariamente estar conectados con una BD. El contenedor se encarga de sincronicar las variables de instancia del bean con la BD.

Debido a que los beans de entidad se guardan en un mecanismo de almacenamiento se dice que es persistente, Persistente significa que el estado del bean existe mas tiempo que la duraciñon de la aplicación.

El uso de los beans de entidad conllevan los siguientes pasos:

  1. El cliente debe encontrar una referencia a la instania concreta del bean de entidad que se esta buscando, mediante el metodo finder, estos se encuentran definidos en la interfaz home y son implementados en la clase bean, los metodos finder pueden devolver uno o varios beans de entidad.
  2. el cliente interactua con la instancia del bean usando los metodos get y set. El estado del bean se carga de la base de datos antes de procesar llamadas a los métodos. Esto se encarga de hacerlo el contenedor de forma automatica o el propio bean en la funciñon ejbLoad().
  3. Por ultimo, cuando se termina la intercacción con la instancia del bean sus contenidos se vuelvan en el almacen persistente, o bien lo hace de forma automática el contenedor o bien este llama al método ejbStore().

Datos persistentes: datos que se almacenan en una base de datos.

Los beans de entidad tienen dos tipos de persistencias:

  1. Persistencia gestionada por el Bean (BMP, Bean-Managed Persistence): contienen el código que accede a la BD.
  2. Persistencia Gestionada por el Contenedor (CMP Container-Managed Persistence): la relación entre las columnas de la BD y el bean se describe en el fichero de propiedades del bean, y el contenedor EJB se ocupa de la implementación
  3. Acceso compartido: los clientes pueden compartir beans de entidad asi el contenedor EJB debe gestionar el acceso concurrente a los mismo y por ello debe usar transacciones.
  4. Clave Primaria: cada beans de entidad tiene un identificador único, este identificador único permite al cliente localizar a un bean de entidad particular.
  5. Relaciones: de la misma forma que una tabla en una base de datos relacional, un bean de entidad puede estar relacionado con otros EJB.

Los BEANS DIRIGIDOS POR MENSAJES estos beans permiten que las aplicaciones J2EE reciban mensajes JMS de forma asincrona. Así la ejecución de un cliente no se bloquea cuando está esperando que se complete algún método de negocio de otro bean. Los mensajes pueden enviarse desde cualquier otro componente J2EE (un beans, un cliente, otro EJB o un componente Web).

Pueden contener una conexión JMS, una conexión de base de datos o una referencia a un objeto EJB.

Cuando llega un mensaje, el contenedor llama al método onMessage del bean. El método onMessage suele realizar un casting del mensaje a uno de los cinco tipos de mensaje de JMS y manejarlo de forma acorde con la lógica de negocio de la aplicación. El método onMessage puede llamar métodos auxiliares, o invocar a un bean de sesión o de entidad para procesar la información del mensaje o para almacenarlo en una base de datos.

Resumen:

  1. Los de entidad, representan una tabla.
  2. Los de sesión, pueden almacenar datos temporalmente o solo procesar datos.
  3. Los de mensajes envian mensajes cuando se requiere informar algo.

Creo mas menos es eso.

En la segunda parte veremos los otros puntos, que son:

  • Desarrollo de beans y Clientes
  • Roles EJB
  • Evolución de la especificación EJB
  • Ventajas de la tecnológía EJB

Ya eso sería no ma joajao!

Publicado en Invest. J2EE | 1 comentario