JBoss

JBoss es una implementación Open-Source de un "EJB Container"; es mediante este tipo de productos que es posible llevar acabo un desarrollo con EJB's "Enterprise Java Bean's" . Este tipo de producto ("EJB Container") generalmente no es distribuido como producto individual y por esta razón se le pudiera considerar a "JBoss" como un producto diferente mas no único

La declaración anterior merece un poco más detalle, la gran gamma de productos en este ramo de Java ( J2EE para ser más exactos ) han sido comercializados como "Java Application Servers"

Como se observa en la siguiente gráfica un "Java Application Server" se encuentra compuesto por dos partes: un "Servlet Engine" y un "EJB Engine", dentro del "Servlet Engine" se ejecutan exclusivamente las clásicas aplicaciones de Servidor (JSP's ("Java Server Pages") y Servlets) , mientras el "EJB Engine(Container)" es reservado para aplicaciones desarrolladas alrededor de EJB's "Enterprise Java Bean's" .

Casi todos los "Application Servers" en el mercado hoy en día son conocidos como "Fully J2EE Compliant", este termino implica que se cumplen todas las especificaciones J2EE definidas por "Sun" y es aquí donde es notable la diferencia con JBoss।

Cuando utiliza un "Application Server" como alguno de los siguientes ("Fully J2EE Compliant"):

· WebLogic

· Websphere

· Oracle 9i Application Server

· Sun Application Server (Previamente Netscape Enterprise o Kiva)

No existe una clara distinción entre el "Web-Container" y "EJB Container", esto es, es posible ejecutar tanto JSP/Servlets así como EJB's, sin embargo, el ambiente se encuentra altamente integrado para que sea transparente (al menos para el programador final) la comunicación entre JSP/Servlets y EJB'

El producto JBoss es únicamente un "EJB Container" y es por esto que generalmente se utiliza en conjunción con un "Web-Container", el "Web-Container" puede ser cualquiera disponible en el mercado, sin embargo, cuando obtenga JBoss incluirá Tomcat proporcionado como "Web-Container", aunque lo anterior no restringe a JBoss para operar con otro "Web Container" como ServletExec , la única ventaja de utilizar el "Web Container" incluido con JBoss será en tiempo de coordinación/configuración entre JBoss|"x" Web-Container, y siendo que un ambiente utilizando EJB's es altamente complejo es preferible concentrarse en algo que ya ha sido utilizado y depurado.

El resto de esta guia se basa en la utilización de JBoss con el "Servlet Engine" Tomcat y/o estableciendo comunicación directa con JBoss como lo demuestra la linea roja punteada de la gráfica inicial

Message Driven Bean

Este tipo de beans ( MDB ) permite a las aplicaciones procesar mensajes de forma asíncrona a través del servicio JMS ( Java Messaging Service ). Este servicio funciona a través de colas de mensajes, que es donde los clientes envían sus peticiones, y estas colas son controladas por los Message Driven Beans, los cuales procesan los mensajes que hay en ellas y ejecutan ciertos servicios dependiendo del mensaje procesado. Este tipo de beans se aproximan más a la forma conceptual de los Stateless Session Bean en el sentido que son beans que no deben almacenar estado alguno. Cuando un mensaje llega a la cola el contenedor hace una llamada al método onMessage del Message Driven Bean y en este método el bean debería invocar a métodos de otros sesión bean o realizar la lógica de negocio de debiera ejecutar ( es más conveniente no tener aquí lógica de negocio, sino hacer invocaciones a métodos de otras clases que sí se encarguen de realizar lógica de negocio ). Para declarar un MDB sólo hemos de establecer la anotación @MessageDriven a una clase que implemente la interface MessageListener, e indicar el nombre de la cola del contenedor ( la cuál es accesible vía JNDI ) que va a controlar el MDB. Veamos un ejemplo :

@MessageDriven( mappedName = "jms/Queue" )
public class AsynchronousService implements MessageListener {

 public void onMessage( Message message ) {
  TextMessage textMessage = (TextMessage)message;
  System.out.println( textMessage.getText() );
 }
}

Entity Bean

Un Entity Bean es una clase ( POJO ) que representa una tabla de una base de datos, y cada instancia de esta clase representa un registro de la tabla, es decir, con los entity beans lo que conseguimos es crear un mapeo entre las propiedades de una clase y los campos de una tabla। Además de este mapeo también vamos a poder especificar las relaciones que tienen las clases entre sí ( uno a uno, uno a muchos, muchos a uno y muchos a muchos ). Todo Entity Bean debe de tener una clave primaria que identifica a ese registro de forma única dentro de la tabla. Todas estas configuraciones las vamos a realizar a través de anotaciones, y el API que se encarga de gestionar todos los aspectos relativos a la persistencia es JPA ( Java Persistent API ). Vamos a ver un ejemplo. Vamos a crear una entidad llamada Team, para lo cual veremos que lo único que vamos a tener en cuenta es establecer una anotación @Entity al principio de la clase, una anotación @Id para indicar cuál es la propiedad que representa la clave primaria, y por último una anotación @OneToMany para indicar que un equipo puede estar compuesto por muchos jugadores y que éstos sólo pueden pertenecer a un equipo :

@Entity
public class Team {
 
 private int id;
 private String name;
 private Date foundationDate;
 private Collection players;

 @Id
public int getId() {
 return id;
}

public void setId( int value ) {
 id = value;
}

public String getName() {
 return name;
}

public void setName( String value ) {
 name = value;
}

public Date getFoundationDate() {
 return foundationDate;
}

public void setFoundationDate( Date value ) {
 foundationDate = value;
}

@OneToMany
public Collection getPlayers() {
 return players;
}

public void setPlayers( Collection value ) {
 players = value;
}

}

A continuación vamos a crear la Entidad Player, que al igual que la entidad anterior va a tener una anotación @Entity, otra anotación @Id, y por último una anotación @ManyToOne para establecer una relación bidireccional entre las dos entidades :

public class Player {

 private int id;
 private String name;
 private Team team;

 @Id
 public int getId() {
  return id;
 }

 public void setId( int value ) {
  id = value;
 }
 
 public String getName() {
  return name;
 }

 public void setName( String value ) {
  name = value;
 }

 @ManyToOne
 public Team getTeam() {
  return team;
 }

 public void setTeam( Team value ) {
  team = value;
 }

}

Stateful Session Bean

Al contrario que en los beans de sesión sin estado, los stateful session bean, como su nombre indica, sí tienen estado. Lo que esto significa es que dentro de la sesión del usuario estos beans van a almacenar datos en variables de instancia, y esos datos van a tener un significado concreto durante toda la convesación mantenida entre el cliente y el bean. Un ejemplo típico de bean de sesión con estado es un carro de la compra, en el cual, durante la sesión de usuario, éste va agregando productos en el carro a través de una lista. Tras ir agregando productos llegará un momento en el que el usuario quiera efectuar la compra, para lo cuál tendrá que realizar previamente un registro de sus datos, especificar la dirección de entrega, indicar el número de su tarjeta de crédito, etcétera, y finalmente confirmará la compra de los productos seleccionados. Como vemos, todos estos datos hay que almacenarlos en unas variables, que son las que conforman el estado del bean. Al igual que los Stateless Session Bean, los Stateful también deben de implementar una interface que puede ser Local o Remote :
@Local
public interface CartServiceLocal {

public void addProduct( Product product );
public void removeProduct( Product product );
public Collection getProducts();
}
Y la implementación de esta interface sería el Stateful Session Bean :
@Stateful
public class CartService implements CartServiceLocal {

private List products;


public void addProduct( Product product ) {
products.add( product );
}

public void removeProduct( Product product ) {
products.remove( product );
}

public Collection getProducts() {
return products;
}

}

Stateless Session Bean

Un bean de sesión sin estado es aquél que no dispone de variables de instancia en las cuales se guarden datos que puedan ser compartidos entre los distintos métodos del bean. Es decir, se trata de un bean que por lo general contará con una serie de métodos que realizarán un trabajo determinado e independiente y que el resultado de las operaciones realizadas dentro de cada uno de los métodos no dependerá de ningún ?estado? relativo a la conversación que mantiene el cliente con el bean. Como puede ser que a través de mis palabras no quede suficientemente claro a qué me refiero creo que va a ser mejor que veamos un ejemplo. Tomemos como ejemplo un bean que se encarga de gestionar las operaciones básicas que podemos realizar con un cliente, como son consultar un cliente, guardar un cliente y borrarlo. En primer lugar tendríamos que crear una interface :

public interface CustomerServiceLocal {

 public void saveCustomer( Customer customer );
 public Customer getCustomer( Long id );
 public Collection getAllCustomers();
 public void deleteCustomer( Long id );

}

Podemos ver que se trata de una simple interface que no tiene ninguna característica particular. Todo bean de sesión sin estado es necesario que disponga de una interface y la que hemos definido arriba es perfectamente válida para nuestro servicio de clientes. Si no la hubiéramos creado y hubiéramos definido directamente el bean sin la creación de la interface, hubiera sido el propio contenedor quién la hubiera creado por nosotros. La intefaz debiera de tener una anotación, que le indicara si se trata de una interface Local o Remote. Si el bean va a ser utilizado por una clase que se ejecute dentro de la misma JVM en la que se ejecuta el bean de sesión entonces la interface podría ser Local, y si el bean va a ser llamado por una clase que se ejecuta en una JVM distinta entonces la interface tendría que ser Remote. Por defecto, si no se indica nada, será tratada como una interface Local. Ejemplo de interface local :

@Local
public interface CustomerServiceLocal {

 public void saveCustomer( Customer customer );
 public Customer getCustomer( Long id );
 public Collection getAllCustomers();
 public void deleteCustomer( Customer customer );

}

Ejemplo de interface remota :

@Remote
public interface CustomerServiceRemote{

 public void saveCustomer( Customer customer );
 public Customer getCustomer( Long id );
 public Collection getAllCustomers();
 public void deleteCustomer( Customer customer );

}

Ahora nos faltaría crear el bean propiamente dicho :

@Stateless
public class CustomerService implements CustomerServiceLocal {

 @PersistenceContext()
 private EntityManager em;

 
 public void saveCustomer( Customer customer ) {
  em.persist( customer );
 }

 public Customer getCustomer( Long id ) {
Query q = em.createQuery( "SELECT c FROM Quiz c WHERE c.id = :id" ).
            setParameter( "id", id );

         return (Customer)q.getSingleResult();
}

 public Collection getAllCustomers() {
  return em.createQuery( "SELECT c from Customer c" ).getResultList();
 }

 public void deleteCustomer( Customer customer ) {
  em.remove( customer );  
 }

}

EJB

Por todos es sabido que el modelo de programación propuesto por la versión 2.1 de EJB conllevaba una serie de inconvenientes que limitaron mucho el uso de esta especificación y conllevó la aparición de soluciones open source que suplían las carencias que presentaba EJB 2.1. Bajo mi punto de vista las soluciones open source que más han marcado el desarrollo empresarial dentro de la plataforma Java han sido Hibernate y Spring Framework, y en la nueva versión de Java Enterprise Edition se han incorporado muchas de las características de estos frameworks para procurar a los desarrolladores una plataforma de desarrollo bastante más sencilla que su predecesora versión 1.4. En este post voy a tratar de explicar cuáles son los distintos tipos de Enterprise Java Bean y cuáles son los propósitos de cada uno de ellos : Stateless Session Bean, Stateful Session Bean, Entity Bean y Message Driven Bean. Debido a que éste pretende ser una breve explicación a los tipos de Entreprise Bean existentes, no voy a entrar en detalles tales como ciclo de vida de los mismos y otros tipos de características.

easyMock

EasyMock es una libreria muy util para hacer pruebas unitarias con JUnit. Nos sirve para crear cualquier objeto fantasma (mock) y hacer que devuelva un resultado concreto para una entrada concreta.

Ejemplo de test


import junit.framework.TestCase;
import org.easymock.EasyMock;


public class AutoTest extends TestCase{

private Fabrica fabrica;

@Override
protected void setUp() throws Exception {
super.setUp();

fabrica = EasyMock.createMock(Fabrica.class);

Motor motorFerrari = new MotorImpl(2500);
Ferrari ferrari = new Ferrari();
ferrari.setMotor(motorFerrari);
EasyMock.expect(fabrica.getFerrari()).andReturn(ferrari).times(5);

Motor motorPorche = new MotorImpl(1000);
Porche porche = new Porche();
porche.setMotor(motorPorche);
EasyMock.expect(fabrica.getPorche()).andReturn(porche).times(5);

EasyMock.replay(fabrica);
}

public void testCilindrada() {

Automovil porche = fabrica.getPorche();
Motor motorPorche = porche.getMotor();
assertEquals(motorPorche.getCilindrada(), 1000);

Automovil ferrari = fabrica.getFerrari();
Motor motorFerrari = ferrari.getMotor();
assertTrue(motorFerrari.getCilindrada() > motorPorche.getCilindrada());
}
}


Interfaz fábrica

public interface Fabrica {

Automovil getPorche();

Automovil getFerrari();

}

Clase Auto

public abstract class Auto {

private Motor motor;

public Motor getMotor() {
return this.motor;
}

public void setMotor(Motor motor) {

this.motor = motor;
}
}


Interfaz Automovil

public interface Automovil {

public Motor getMotor();

}

Clase Ferrari

public class Ferrari extends Auto implements Automovil { }


Clase Porche

public class Porche extends Auto implements Automovil { }


Interfaz Motor

public interface Motor {

public int getCilindrada();

}


Clase Motor

public class MotorImpl implements Motor {

private int cilindrada;

public MotorImpl(int cilindrada) {

this.cilindrada = cilindrada;
}

public int getCilindrada() {
return this.cilindrada;
}
}