Alejandro es socio fundador de Autentia y nuestro experto en J2EE, Linux y optimización de aplicaciones empresariales.
Ingeniero en Informática y Certified ScrumMaster
Si te gusta lo que ves, puedes contratarle para darte ayuda con soporte experto, impartir cursos presenciales en tu empresa o para que realicemos tus proyectos como factoría (Madrid).
Puedes encontrarme en Autentia: Ofrecemos servicios de soporte a desarrollo, factoría y formación.
Fecha de publicación del tutorial: 2007-08-06
EJB
3.0,
un ejemplo práctico con Maven y JBoss
Creación: 02-08-2007
Índice de contenidos
1. Introducción
Este tutorial presenta un ejemplo sencillo donde se verá como desarrollar EJBs de sesión y de entidad, inyección de dependencias, llamar a los EJBs desde una aplicación Web, definición de un DataSource, y como configurarlo y hacerlo funcionar en JBoss, y todo compilando con Maven.
Este tutorial pretende llenar un hueco que dejan otros tutoriales de EJB 3.0 ya publicados en www.adictosaltrabajo.com como:
http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=EJB3Resurrection
http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=AnotacionesEJB3
http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=hibernateAnnotations
Ya que en todos estos tutoriales se han visto partes concretas de los EJBs 3.0, con ejemplos de código, pero no se ha visto un ejemplo completo y funcionando en un servidor de aplicaciones.
Puedo recomendar especialmente el primero: EJB3 Resurrecction (de Francisco Javier Martínez Páez), ya que expone de forma clara y breve las bondades de esta nueva versión, y porque parece que por fin los EJBs empiezan a ser realmente útiles y sencillos de utilizar (en las versiones anteriores la especificación era complicada y el desarrollo de los EJBs tedioso. Si se usaban bien se les podía sacar mucho partido, pero era bastante fácil meter la pata si no se tenía un amplio conocimiento).
Espero que os resulte útil, sobre todo para los primeros contactos con EJB 3.0 y perder el miedo al "folio en blanco".
Aquí podéis encontrar un .tar.gz con todo el código del ejemplo !!!
2. Entorno
El tutorial está escrito usando el siguiente entorno:
Hardware: Portátil Asus G1 (Core 2 Duo a 2.1 GHz, 2048 MB RAM, 120 GB HD).
Sistema Operativo: GNU / Linux, Debian (unstable), Kernel 2.6.21, KDE 3.5
Jboss 4.2.1.GA
Maven 2.0.7
Java 1.6.0_02
3. Instalación del JBoss
Nos bajamos la última versión estable del JBoss (en el momento de escribir este tutorial la 4.2.1.GA) de http://labs.jboss.com/jbossas/downloads
Lo descomprimimos donde queramos, por ejemplo en /opt
$ cd /opt
$ tar -xzf
<ruta_a_la_descarga>/jboss-4.2.1.GA.zip
Probamos a ejecutarlo:
$ cd /jboss-4.2.1.GA/bin
$
./run.sh
Al final del log (lo podemos ver por consola o en <JBOSS_HOME>/server/default/log) dará un mensaje del estilo:
18:32:35,822 INFO [Server] JBoss
(MX MicroKernel) [4.2.1.GA (build: SVNTag=JBoss_4_2_1_GA
date=200707131605)] Started in 14s:854ms
Probamos a entrar con el navegador en la dirección http://localhost:8080, y deberíamos ver:
4. El proyecto de Maven
Vamos a tener dos proyectos, uno con los EJBs y otro con la aplicación Web. Como ya hemos visto en otros tutoriales (http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=mavenRelease) vamos a crear la siguiente estructura de directorios (en cada uno tendremos un proyecto de Maven):
autentia-parent
|--
pom.xml
|
|-- autentia-ejb
| `-- pom.xml
|
`--
autentia-web
`-- pom.xml
4.1 autentia-parent
Es el proyecto padre donde definimos configuración común y los módulos que componen la aplicación. Veamos el pom.xml:
<?xml version="1.0" encoding="UTF-8" ?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.autentia.demo</groupId>
<artifactId>autentia-parent</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<name>autentia-parent</name>
<description>Autentia Parent</description>
<modules>
<module>autentia-ejb</module>
<module>autentia-web</module>
</modules>
<build>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.5</source>
<target>1.5</target>
</configuration>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<id>jboss-repository</id>
<name>JBoss Repository</name>
<url>http://repository.jboss.com/maven2</url>
<layout>default</layout>
</repository>
</repositories>
</project>Lo más interesante es ver como estamos dando de alta un repositorio de JBoss. Esto es necesario porque actualmente en los repositorio oficiales de Maven (www.ibiblio.org/maven2) no se encuentran los jar necesarios (persistencia, anotaciones, ...) para trabajar con EJB 3.0. Todas estas dependencias las podremos encontrar en el repositorio de JBoss.
4.2 autentia-ejb
Es el proyecto donde tendremos nuestros EJBs con la lógica de negocio. Veamos el pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.autentia.demo</groupId>
<artifactId>autentia-parent</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<groupId>com.autentia.demo.ejb</groupId>
<artifactId>autentia-ejb</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>autentia-ejb</name>
<url>http://maven.apache.org</url>
<dependencies>
<!-- ================= Internal dependecies ================= -->
<!-- ================= External dependecies ================= -->
<dependency>
<groupId>javax.persistence</groupId>
<artifactId>persistence-api</artifactId>
<version>1.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>jboss</groupId>
<artifactId>jboss-ejb-api</artifactId>
<version>4.2.0.GA</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
Aquí podríamos destacar como las dependencias están
con scope provided. Esto es porque los jar sólo
se necesitan para compilar, pero en ningún caso se deben
empaquetar con la aplicación aplicación Web que use
este proyecto. Los EJBs se tienen que desplegar en un servidor de
aplicaciones (por supuesto compatible con EJB 3.0 JEE5) y será
este el que proporciones todas estas librerías.
4.3 autentia-web
Es la aplicación Web que usará a autentia-ejb para resolver los problemas de negocio (como siempre, desde Autentia www.autentia.com, os recordamos e insistimos en la importancia de separar presentación, control y negocio: patron MVC). Veamos el pom.xml:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.autentia.demo</groupId>
<artifactId>autentia-parent</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<groupId>com.autentia.demo.web</groupId>
<artifactId>autentia-web</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<name>autentia-web Maven Webapp</name>
<url>http://maven.apache.org</url>
<build>
<finalName>autentia-web</finalName>
</build>
<dependencies>
<!-- ================= Internal dependecies ================= -->
<dependency>
<groupId>com.autentia.demo.ejb</groupId>
<artifactId>autentia-ejb</artifactId>
<version>1.0-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<!-- ================= External dependecies ================= -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>jboss</groupId>
<artifactId>jboss-ejb-api</artifactId>
<version>4.2.0.GA</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
Nuevamente destacamos como el scope de las dependencias es provided,
incluso de la dependencia interna. Esto es porque los EJBs se
desplegarán en el servidor de aplicaciones de forma
independiente a la aplicación Web. Es decir, cuando instalemos
la aplicación Web, el servidor de aplicaciones ya debe tener
los EJBs disponibles.
5. Creando el primer EJB de sesión
Vamos a crear un EJB de sesión sin estado (Stateless). Son los más sencillos y los ideales para implementar nuestras clases de servicios (lógica de negocio sin estado, que se puede invocar de forma simultánea por muchos clientes).
Todo EJB de sesión puede tener dos interfaces, una local (obligatoria) y otra remota (opcional):
La interfaz local define los métodos del EJB que se pueden invocar desde cualquier otro componente (otro EJB, un Servlet, ...) que se encuentre en el mismo servidor de aplicaciones donde está desplegado el EJB.
La interfaz remota define los métodos del EJB que se pueden invocar por componentes que se encuentren fuera del servidor de aplicaciones donde esté desplegado el EJB. La interfaz remota sólo será necesaria si vamos a llamar al EJB desde otro sitio que no sea el propio servidor de aplicaciones donde está desplegado el EJB. Mi recomendación es no crearla si no la necesitamos realmente (menos código = más sencillo = más fácil de mantener).
Si más tarde queremos añadirla y va tener los mismos método que la local, bastaría con que la interfaz remota extendiera de la interfaz local.
5.1 Greeter.java
Definimos el contrato que debe cumplir un "Saludador". El
código completo se puede ver en el .tar.gz que se puede
descargar en la introducción (aplicable al resto de ejemplos
que veamos, marcaré con ... para indicar que en
el .tar.gz se puede encontrar más código)
...
@Local
public interface Greeter {
public String sayHi();
public void addGreeting(String message) throws InvalidGreetingMessageException;
}
Lo importante es ver como hemos anotado la clase con @Local.
Esto indica al contenedor que se trata de la interfaz local.
Si quisiéramos implementar la interfaz remota tendríamos
que hacer otra interfaz y anotarla con @Remote.
¡¡¡ Ojo, una
misma interfaz no puede esta anotada a la vez con @Local
y @Remote !!!
5.2 DummyGreeterBean
Es nuestro primer EJB. Es un saludador un poco "tonto", que sólo sabe dar un saludo y no es capaz de acordarse de nuevos saludos:
...
@Stateless
public class DummyGreeterBean implements Greeter {
public String sayHi() {
return "Hi !!! Hello World !!!";
}
public void addGreeting(String message) throws InvalidGreetingMessageException {
// I can't remember more greetings :'(
}
}
Vemos como la clase está anotada como @Stateless,
de esta forma el servidor de aplicaciones la reconoce como un EJB de
sesión sin estado.
También vemos como el EJB implementa la interfaz local
Greeter. Un EJB puede implementar tantas interfaces
locales y/o remotas como necesitemos.
6. Creando un Servlet que use nuestro EJB
En la aplicación Web tendremos el siguiente Servlet:
6.1. GreeterServlet.java
...
public class GreeterServlet extends HttpServlet {
private static final long serialVersionUID = 3031665322987189909L;
private Greeter greeter = null;
public GreeterServlet() {
final Context context;
try {
context = new InitialContext();
greeter = (Greeter)context.lookup("DummyGreeterBean/local");
} catch (NamingException e) {
e.printStackTrace();
}
}
public void service(HttpServletRequest req, HttpServletResponse res) throws IOException, ServletException {
final PrintWriter out = res.getWriter();
final String newGreeting = req.getParameter("addGreeting");
try {
greeter.addGreeting(newGreeting);
out.println(greeter.sayHi());
} catch (InvalidGreetingMessageException e) {
out.println("El saludador no admite ese mensaje de saludo. El saludador dice: " + e.getMessage());
}
}
}
Se puede ver como el Servlet tiene una referencia (greeter)
a la interfaz. Esta referencia se inicializa en la construcción
del Servlet haciendo un lookup por el nombre JNDI del EJB.
El nombre JNDI será el nombre de la clase EJB (la clase que
implementa la interfaz, la que está marcada con @Stateless)
+ "/" + "local" o "remote",
dependiendo de si queremos acceder mediante la interfaz local o la
interfaz remota.
Por supuesto, para poder usar el nombre JNDI ".../remote"
tendremos que haber creado la interfaz que comentábamos en el
punto 5.1. anotada con @Remote.
A lo largo de los demás ejemplos que vamos a realizar, en este Servlet lo único que habría que cambiar es el nombre JNDI para ir llamando al EJBs correspondiente.
¡¡¡ Ojo, JEE 5 soporta inyección de dependencias en los Servlets, Filtros, Tags, ... es decir, no sería necesario hacer el loockup en el Servlet; pero JBoss 4.2.1.GA todavía no soporta esta funcionalidad (no es totalmente JEE 5 "compliant"). JBoss 4.2.1.GA sólo soporta inyección de dependencias entre EJBs. Luego veremos un ejemplo de ello !!!
6.2. Configurando las propiedades de JNDI
Para que en el Servlet anterior funcione correctamente el lookup
en el contexto, debemos poner en el CLASSPATH el fichero
jndi.properties. Este fichero contiene la
configuración de JNDI.
Para nuestra aplicación Web colocaremos este fichero en el directorio autentia-parent/autentia-web/src/main/resources. Cuando hagamos el empaquetado con Maven, este se encargará de poner el fichero en autentia-web/WEB-INF/classes; directorio que estará en el CLASSPATH una vez se despliegue la aplicación en el servidor de aplicaciones.
El fichero tendrá el siguiente contenido:
java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory java.naming.factory.url.pkgs=org.jboss.naming:org.jnp.interfaces java.naming.provider.url=localhost:1099
7. Creando un EJB de entidad
Bueno, nuestro "Saludador" es un poco "torpe" y no es capaz de recordar nada más que un saludo, así que vamos a crear uno nuevo con algo más de memoria ;) Para ello vamos a usar un EJB de entidad que se encargará de guardar los mensajes de saludo en la base de datos.
Vamos a usar la tabla que ya habíamos creado en el tutorial de DTP (http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=eclipseDtp)
7.1. Greeting.java
...
@Entity
public class Greeting {
public static final String DEFAULT_MESSAGE = "Hi !!! Hello World !!!";
private Integer id = null;
private String message = null;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
Así de sencillo, sólo tenemos un POJO anotado con @Entity
y hemos indicado cual es su id con la anotación @Id.
Además también hemos indicado que los valores de este
campo ¡d serán generados por la base de datos (auto
incremental de MySQL en nuestro caso) con la anotación
@GeneratedValue.
7.2. SmartGreeterBean.java
...
@Stateless
public class SmartGreeterBean implements Greeter {
...
@PersistenceContext
private EntityManager em;
public String sayHi() {
final List<Greeting> greetings = em.createQuery("from Greeting").getResultList();
String message = Greeting.DEFAULT_MESSAGE;
if (greetings.size() > 0) {
final int randomMessage = random.nextInt(greetings.size());
message = greetings.get(randomMessage).getMessage();
}
return message;
}
public void addGreeting(String message) throws InvalidGreetingMessageException {
if (message == null) {
return;
}
final Greeting greeting = new Greeting();
greeting.setMessage(message);
em.persist(greeting);
}
}
Como antes, con la notación @Stateless
estamos indicando que se trata de EJB de sesión sin estado, e
igual que antes implementa la interfaz local Greeter.
Con la notación @PersistenceContext le
estamos indicando al servidor de aplicaciones que nos inyecte un
EntityManager para poder acceder a JPA (Java Persistence
Api).
Con los métodos createQuery y persist
del EntityManager es como hacemos consultas o guardamos
nuevos objetos en la capa de persistencia.
7.3. Configuración del proveedor de JPA
Para que nuestro EJB de entidad funcione correctamente necesitamos
indicar cual será el proveedor JPA. En definitiva lo que
tenemos que indicar es que "conexión" nos tienen que
inyectar a través de la notación @PersistenceContext.
Para ello vamos a escribir el fichero persistence.xml.
Este fichero lo colocaremos dentro de del directorio
autentia-parent/autentia-ejb/src/main/resources/META-INF, de
forma que cuando empaquetemos con Maven, el fichero quedará
dentro del jar, en el directorio META-INF.
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0"
xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
<persistence-unit name="autentia">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<jta-data-source>java:/autentiaDataSource</jta-data-source>
<properties>
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQLInnoDBDialect"/>
</properties>
</persistence-unit>
</persistence>
En el fichero podemos ver como indicamos el proveedor con el elemento
provider. Estamos indicando que nuestro proveedor
de JPA será Hibernate. Este es el valore recomendado para usar
con JBoss.
A continuación, con el elemento jta-data-source,
estamos indicando cual será el DataSource a utilizar. Más
adelante, en el punto 10.1.
Dando de alta en el DataSource veremos como damos de alta este el
DataSource "autentiaDataSource".
Por último estamos indicando algunas propiedades para el proveedor de JPA. Como en nuestro caso estamos usando Hibernate, podemos pasarle cualquier propiedad típica de Hibernate, por ejemplo el dialecto de la base de datos que debe utilizar.
8. Inyección de dependencias
Ciertamente, en el punto anterior, ya hemos visto una inyección de dependencia con la anotación @PersistenceContext. Ahora vamos a ver como inyectar a un EJB otro EJB.
8.1. GreetingModerator.java
Este interfaz define el contrato que deben cumplir todos los moderadores. Simplemente tiene un método que, dado un mensaje, nos dice si este es correcto o no, según los criterios que implemente el EJB que implementa la interfaz.
...
@Local
public interface GreetingModerator {
public boolean isValid(String message);
}
8.2. GreetingModeratorBean.java
EJB de sesión sin estado se encarga de validar si un mensaje es políticamente correcto o no. Para ello busca si en el mensaje de saludo se encuentra alguna palabra "prohibida".
...
@Stateless
public class GreetingModeratorBean implements GreetingModerator {
final private List<String> forbiddenWords = Arrays.asList("caca", "culo", "pedo", "pis");
public boolean isValid(String message) {
final String[] words = message.split(" ");
for (String w : words) {
if (forbiddenWords.contains(w)) {
return false;
}
}
return true;
}
}Es igual que los EJBs que hemos hecho hasta ahora. No hay nada que destacar.
8.3. PoliteSmartGreeterBean.java
EJB de sesión sin estado, que usa un moderador para saber si los mensajes, que va a mostrar o que le están añadiendo, son políticamente correctos.
...
@Stateless
public class PoliteSmartGreeterBean implements Greeter {
...
@PersistenceContext
private EntityManager em = null;
@EJB
private GreetingModerator moderator = null;
public String sayHi() {
final List<Greeting> greetings = em.createQuery("from Greeting").getResultList();
String message = Greeting.DEFAULT_MESSAGE;
if (greetings.size() > 0) {
for (int chance = 0; chance < 3; chance++) {
final int randomMessage = random.nextInt(greetings.size());
final String storedMessage = greetings.get(randomMessage).getMessage();
if (moderator.isValid(storedMessage)) {
message = storedMessage;
break;
}
}
}
return message;
}
public void addGreeting(String message) throws InvalidGreetingMessageException {
if (message == null) {
return;
}
if (!moderator.isValid(message)) {
throw new InvalidGreetingMessageException("The greeting message is not enough polite!!!");
}
final Greeting greeting = new Greeting();
greeting.setMessage(message);
em.persist(greeting);
}
}
Mediante la notación @EJB en el atributo
moderator, es como el contenedor sabe que nos tiene que
inyectar la dependencia. El contenedor determina el EJB que nos tiene
que inyectar por le tipo del atributo marcado con la notación
@EJB, en este caso nos inyectará un EJB de tipo
GreetingModerator.
Como ya hemos indicado antes, la notación @EJB de JEE 5 también debería funcionar para Servlets, filtros, tags, ... pero esta funcionalidad no está soportada por JBoss 4.2.1.GA. Por esto en el Servlet tenemos que hacer directamente un lookup en el contexto.
9.Gestión de excepciones
En el ejemplo anterior, en el EJB PoliteSmartGreeterBean,
también podemos destacar como en el método addGreeting
se lanza la excepción InvalidGreetinfMessageException
en caso de que el moderador considere que el mensaje de saludo no es
adecuado.
Podemos ver como el método addGreeting lanza
directamente esta excepción, y por ningún lado vemos la
típica RemoteException de versiones anteriores de
EJBs.
¿Qué está pasando?
Bien, para EJB 3.0 todas las excepciones que lance un método
de un EJB que sean subclases de RuntimeException
o de RemoteException serán consideradas
excepciones del sistema, y serán tratadas por el propio
contenedor.
Por el contrario, las excepciones que sean subclases de Exception
(han de ser tratadas por el "llamante" del método) serán
consideradas como excepciones de la aplicación. Estas
excepciones no serán tratadas por el contenedor y llegarán
al cliente, sea este local o remoto, de forma que se puedan tratar
(en nuestro ejemplo, en el Servlet, vemos como se hace el tratamiento
de la excepción InvalidGreetingMessageException).
Precaución especialmente con los EJB dirigidos por mensaje (MDB) ya que estos no deben lanzar excepción. Será nuestra responsabilidad controlarlas.
10. Desplegando la aplicación en el JBoss
10.1. Dando de alta en el DataSource
Tenemos que configurar en el JBoss el DataSource que usarán los EJBs para acceder a la base de datos (hemos visto como lo usábamos en el punto 7.3. Configuración del proveedor de JPA). Para ello echamos en /opt/jboss-4.2.1.GA/server/default/deploy el fichero autentia-ds.xml
<?xml version="1.0" encoding="UTF-8"?>
<datasources>
<local-tx-datasource>
<jndi-name>autentiaDataSource</jndi-name>
<connection-url>jdbc:mysql://localhost:3306/AUTENTIA</connection-url>
<driver-class>com.mysql.jdbc.Driver</driver-class>
<user-name>autentia</user-name>
<password>autentia</password>
</local-tx-datasource>
</datasources>Como se puede ver, en este fichero definimos la conexión a la base de datos.
¡¡¡ Ojo, es muy
importante que el nombre del fichero sea ...-ds.xml,
si no acaba en -ds.xml JBoss no lo reconocerá como la
configuración de un DataSource !!!
10.2. Desplegando los EJBs
Basta con echar el jar en /opt/jboss-4.2.1.GA/server/default/deploy. Si JBoss está arrancado, enseguida veremos en el log un mensaje del estilo:
19:03:26,831 INFO [EJB3Deployer]
Deployed:
file:/opt/jboss-4.2.1.GA/server/default/deploy/autentia-ejb-1.0-SNAPSHOT.jar
10.3. Desplegando la aplicación Web
Igualmente echamos el war en en /opt/jboss-4.2.1.GA/server/default/deploy. Si JBoss está arrancado, enseguida veremos el resultado en log.
11. Listos para probar
Ya está todo desplegado y tenemos el JBoss arrancado. Ahora para probar sólo hace falta invocar nuestro Servlet. Para ello podemos usar la URL: http://localhost:8080/autentia-web/greeterServlet.
Si lo que queremos es añadir es nuevos mensajes de saludo podemos usar la URL: http://localhost:8080/autentia-web/greeterServlet?addGreeting=Hola%20Amigo. Donde "Hola%20Amigo" será el mensaje de saludo que queremos añadir.
Si estamos probando el "Saludador Educado" podemos probar a usar la URL: http://localhost:8080/autentia-web/greeterServlet?addGreeting=Hola%20caca.
12. Conclusiones
Con este tutorial hemos podido ver como desarrollar con EJB 3.0 es infinitamente más sencillo que con sus versiones anteriores.
Incluso puede resultar más sencillo que desarrollar con su equivalente: Hibernate + Spring, ya que nos ahorramos bastantes ficheros xml de configuración. Esto no quiere decir que Hibernate o Spring vayan a desaparecer, al contrario, son robustos frameworks de desarrollo, ampliamente probados y extendidos, que seguirán evolucionando, innovando, y aportando cantidad de buenas ideas a la comunidad (claramente, si EJB 3.0 ha llegado a ser lo que es, ha sido gracias a ellos).
Ahora nos podríamos hacer la pregunta ¿he de ponerme como loco a desarrollar con EJB 3.0?, bueno, creo no, por lo menos no a lo loco. Deberíamos tener en cuenta los siguientes puntos:
Si ya tenemos aplicaciones desarrolladas con Hibernate y/o Spring, puede no tener sentido reescribirlas con EJB 3.0, ya que haremos un esfuerzo para obtener lo mismo. Tendremos que tener muy clara la ventaja que nos aporta para asumir el cambio.
Si vamos a empezar nuevos desarrollos y ya conocemos Hibernate y/o Spring, tiene mucho sentido seguir con estas tecnologías y evitar los riesgos de empezar a trabajar con una tecnología nueva para nosotros. De nuevo tendremos que tener claras las ventajas que nos aporta EJB 3.0 para afrontar el aprendizaje de esta nueva tecnología.
Si no sabemos ni Hibernate ni Spring ni EJB 3.0, si podría ser recomendable ir por el camino de los EJBs 3.0 ya que estos son el estándar al formar parte de la especificación de JEE.
Desde luego a lo que si que os animo es a que hagáis alguna prueba, aunque sólo sean los ejemplos de este tutorial; porque es una tecnología que realmente merece la pena, y de la que creo que vamos a oír hablar mucho, y esta vez para bien (no como sus versiones anteriores ;)
13. Sobre el autor
Alejandro Pérez García, Ingeniero en Informática (especialidad de Ingeniería del Software)
Socio fundador de Autentia (Formación, Consultoría, Desarrollo de sistemas transaccionales)
mailto:alejandropg@autentia.com
Autentia Real Business Solutions S.L. - "Soporte a Desarrollo"
A continuación puedes evaluarlo:
Fecha publicación: 2012-01-31-11:56:02
Autor: fumandito
Fecha publicación: 2009-02-04-09:56:24
Autor:
