2/9 Curso JEE5, Soa, Web Services, ESB y XML

COMPONENTES: PRÁCTICAS

• Enterprise Java Beans (II): Entorno:

• Netbeans

• Sun Application Server

• Web Services.

Práctica 1

• Práctica número 1:
− Descripción: Creación de un JavaBean
− Objetivos:
• Primera toma de contacto con Netbeans como IDE
• Primera toma de contacto con Sun Application Server 9 como Servidor
de Aplicaciones
• Conocer las características principales de un JavaBean, para entender
a diferenciar los casos en los que es conveniente usar JavaBeans, y
cuándo usar EJB’s.

Práctica 1

• Arrancamos Netbeans.

• Creamos un nuevo proyecto: ejb01-javabean:

Práctica 1

• En el asistente, elegimos una aplicación Web:

Práctica 1

• Elegimos el nombre ejb01-javabean

Luego NEXT y FINISH

Práctica 1
• Modificamos el archivo:index.jsp
<jsp:useBean id="libro" class="cursoEjb.LibroListenerBean" scope="session" />
<%=session.getAttribute("libro") + "<br>" %>
<html>
<head>
<title>JavaBeans - Curso EJB</title>
</head>

<body>
<b>Guardamos los datos...</b><p>
<jsp:setProperty name="libro" property="titulo" value="Avanced JavaServer Pages" />
<jsp:setProperty name="libro" property="autor" value="David M. Geary" />
<b>Recuperamos los datos...</b><br>
<jsp:getProperty name="libro" property="titulo" /><br>
<jsp:getProperty name="libro" property="autor" /><br>
</body>
</html>

Práctica 1
• Creamos una nueva clase Java: cursoEjb.LibroListenerBean

package cursoEjb;

import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

/**
*
* @author jcarlos
*/
public class LibroListenerBean implements HttpSessionListener {

private String titulo; public String getTitulo() {
private String autor;
return titulo;
public void setTitulo(String titulo) {
this.titulo = titulo; }
} public String getAutor() {
public void setAutor(String autor) { return autor;
this.autor = autor; }
}
public void sessionCreated(HttpSessionEvent se) {
}

public void sessionDestroyed(HttpSessionEvent se) {
}
}

Práctica 1

• Su ahora ejecutamos la opción “Run”, en un entorno
UNIX, obtendremos esto:

• Podemos corregirlo aquí:
− Tools
• Options
− Advanced Menu
» Eliminamos Mozilla y firefox, y nos quedamos sólo con el browser de
swing.

Práctica 1

• En esta versión de guadalinex, hay un problema con los
navegadores basados en Mozilla (mozilla, firefox,
galeon, epiphany). Suele ocurrir cuando andamos
cortos de RAM.

• Instalamos konqueror:
− sudo aptitude install konqueror
• Creamos una configuración de navegador para
konqueror, tal como se muestra en la figura siguiente, y
la ponemos en primer lugar, indicando que se use esa
configuración de forma preferente.

Práctica 1

• Configuración de konqueror:

Práctica 1

• Y en la opción de configuración básica (pinchamos en
basic options), debemos tener el selector de navegador
a konqueror:

Práctica 1

• Resultados esperados tras un deploy + Run:

PRÁCTICA 2: CREACIÓN DE UN STATELESS EJB

Práctica 2
− Descripción: Creación de un Stateless EJB
• Primera toma de contacto con los EJBs dentro del entorno Netbeans
• Primera toma de contacto con las anotaciones, y cómo pueden facilitarnos la
vida.
• Construcción de un EJB simple, que realice las funciones de una calculadora.
• Será una aplicación que tenga un Servlet que haga la llamada al EJB

• REIVINDIQUEMOS LO SIMPLE:
− No hay Xdoclet.
− El packaging es automático.
− No hay que crear descriptores (el entorno o el contenedor -según el caso- lo hacen
de manera automática)
− No hay que crear interfaces HOME como hacíamos en eclipse a través de la
herramienta Xdoclet y la opción PackageSubstitution cuando creamos EJB’s.
− Crear EJB con anotaciones es fácil y rápido.
− No tenemos la obligación de que los nombres de los Servlets terminen en Servlet, ni
que los nombres de los Beans terminen en Bean.
− No hay que crear los métodos ejbActivate y ejbPassivate; el contenedor realiza el
trabajo “sucio”.

Práctica 2

• Primero: Creamos un proyecto de tipo Enterprise:

Práctica 2

• Le pedimos al asistente que cree el módulo WAR y el
EJB:

Práctica 2

• Ahora, en el cuadro de proyectos, pulsamos click derecho sobre
“ejb02-calculadora-ejb”, y elegimos New=>Session Bean

Práctica 2

• El asistente debe haber • El EJB propiamente dicho, es
dejado lo siguiente: la clase “CalculadoraBean”
• CalculadoraRemote, es un
interfaz, ya que los clientes
nunca se comunican
directamente contra el Bean
• La comunicación directa sólo
la tiene el Contenedor, para
controlar el Passivate y el
Activate.

Práctica 2

• Una vez hecho esto, nos • Con esa etiqueta, el
fijamos en la annotation contenedor se encargará
que tenemos justo en la de crear un EJB sin
cabecera de la clase: estado.
• No tenemos tampoco
que crear el archivo
ejb-jar.xml
• No necesitamos el
interfaz home.
• No hay Xdoclets
• ¡Fácil!

Práctica 2

• Empezamos a codificar los métodos de la calculadora, y
observamos que Netbeans ya nos empieza a mostrar
un asistente de ayuda que solicita incorporar esos
métodos al interfaz:

(Prestar atención al icono de la bombilla)

Práctica 2

• El resultado final de CalculadoraBean debe ser el que
package ejb02;
sigue: import javax.ejb.Stateless;

@Stateless
public class CalculadoraBean implements ejb02.CalculadoraRemote {

/** Creates a new instance of CalculadoraBean */
public CalculadoraBean() {
}

suma(int a, int b) {
public int suma
return a+b;
}

public int resta
resta(int a, int b) {
return a-b;
}

public int divide
divide(int a, int b) {
if (b == 0) {
throw new IllegalArgumentException("No puedo dividir por 0");
}
return a / b;
}

public int multiplica
multiplica(int a, int b) {
return a*b;
}

}

Práctica 2

• El resultado final de CalculadoraRemote debe ser el
que sigue:
package ejb02;

import javax.ejb.Remote;

@Remote
public interface CalculadoraRemote {
int multiplica(int a, int b);

int divide(int a, int b);

int resta(int a, int b);

int suma(int a, int b);

}

Práctica 2

• Ahora vamos a crear un servlet. Más adelante crearemos un
formulario en el index.jsp que enviará el submit a este servlet,
que a su vez, usará al EJB para operar con las operaciones de la
calculadora:

Práctica 2

• Seguimos el asistente, tecleando lo siguiente:

Práctica 2

• El código del servlet donde hay cambios es:
@EJB
private CalculadoraRemote calcu;

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
Integer arg0 = Integer.parseInt(request.getParameter("arg0"));
Integer arg1 = Integer.parseInt(request.getParameter("arg1"));

out.println("<html>");
out.println("<head>");
out.println("<title>Servlet que suma dos argumentos</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>Servlet que suma dos argumentos</h1>");
out.println("</body>");
out.println("La suma de: "+arg0+" Y: "+arg1+" es: "+calcu.suma(arg0,arg1)
calcu.suma(arg0,arg1)
calcu.suma(arg0,arg1));
out.println("</html>");
out.close();
}

• Y además hay que añadir dos imports.

Práctica 2

• Ahora retocamos el index.jsp que ha creado netbeans en la
carpeta “ejb02-calculadora-war/Web Pages” para que incluya
un formulario que envíe dos argumentos numéricos al servlet,
que a su vez usa al EJB para los cálculos:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Práctica 2</title>
</head>
<body>
<h1>Practica 2 - Curso EJB</h1>
<form name="formulario" action="Resultados method="POST">
Resultados"
Resultados
Introduce dos argumentos numericos, y haremos calculos:<BR>
<input type="text" name="arg0" value="1" />
<input type="text" name="arg1" value="2" />
<input type="submit" value="Enviar" name="enviar" />
</form>

</body>
</html>

Práctica 2

• Para acabar, sólo nos queda testearlo. Para ello, le decimos a
Netbeans que ejecute un Run, que es lo mismo que
build+deploy+Run.

Práctica 2

• Una vez visto los resultados, cambiar el código
necesario para que el proyecto reste y multiplique.

• Objetivo: repetir conceptos y fijar el conocimiento del
entorno Netbeans para la generación de proyectos
Enterprise Edition.

PRÁCTICA 3: CREACIÓN DE UN STATEFUL EJB

Práctica 3

− Descripción: Creación de un Stateful EJB
• Primera toma de contacto con los EJBs de tipo statefull
− Los stateful beans, además de tener métodos de negocio, tienen variables
de estado (variables que tomar valor al instanciar un objeto y usarlo, y que
representan un determinado estado del objeto).
• Construcción de un EJB simple, que realice las funciones de una mini-
carrito de la compra (en este caso, de libros).
• Será una aplicación que tenga una aplicación de consola que haga la
llamada al EJB

Práctica 3

• Primero: creamos una aplicación de tipo Enterprise:

Práctica 3

• En el asistente, comprobamos que los parámetros
queden EXACTAMENTE como en la figura:

Práctica 3

• Una vez de
pulsemos Finish,
desplegamos el
árbol de proyectos y
pulsamos click
derecho sobre
ejb03-carro-ejb tal
como en la figura:

Práctica 3

• Continuamos con el asistente, con estos parámetros:

Práctica 3

• Una vez finalizado, navegamos por el árbol de directorios.
Netbeans nos ha creado automáticamente la plantilla del Bean y
el Interfaz. La renombraremos y ejecutaremos un Refactoring:
<= Teniendo esta selección activa,
pulsamos F2, o bien botón
derecho, menú, y rename.

Práctica 3

• Ahora observamos que Netbeans nos muestra una nueva
subventana, en la que espera confirmación para ejecutar el proceso
de refactoring:

Práctica 3

• Cremos ahora una nueva clase tal como en la figura:

Práctica 3

• En el asistente, • Y este código:
proporcionamos estos
datos: package util;

public class LibroException
extends Exception {
public LibroException() {
}

public LibroException(String
msg) {
super(msg);
}
}

Práctica 3
• Volvemos a crear una • Y este código:
package util;
nueva clase, esta vez
/**
con estos datos: *
* @author jcarlos
*/
public class IdVerificador {

public IdVerificador() {
}

public boolean validar(String id) {
boolean result = true;

for (int i = 0; i < id.length(); i++) {
if (Character.isDigit(id.charAt(i))
== false) {
result = false;
}
}

return result;
}

}

Práctica 3

• El código del @Stateful
public class CarroBean implements ejb03.Carro {
Bean es el /** Creates a new instance of CarroBean */
List<String> contenidos;
siguiente String IdCliente;
String nombreCliente;
(1/2):
public CarroBean
CarroBean() {
}

inicializar(String persona) throws LibroException {
public void inicializar
if (persona == null) {
throw new LibroException("No se permite persona con
valor Null");
} else {
nombreCliente = persona;
}

IdCliente = "0";
contenidos = new ArrayList<String>();
}

--->
// ---> Continua en la siguiente pagina

Práctica 3

• Código del bean (2/3)
public void inicializar
inicializar(String persona,String id) throws LibroException {
if (persona == null) {
throw new LibroException("No esta permitida persona con valor Null");
} else {
nombreCliente = persona;
}

IdVerificador compruebaId = new IdVerificador();

if (compruebaId.validar(id)) {
IdCliente = id;
} else {
throw new LibroException("Codigo de ID invalido: " + id);
}

contenidos = new ArrayList<String>();
}

--->
// ---> Continua en la siguiente pagina

Práctica 3

• Código del bean (3/3)
public void anadirLibro
anadirLibro(String titulo) {
contenidos.add(titulo);
}

public void borrarLibro
borrarLibro(String titulo) throws LibroException {
boolean result = contenidos.remove(titulo);

if (result == false) {
throw new LibroException(""" + titulo + "" no esta en el carro.");
}
}

public List<String> getcontenidos
getcontenidos() {
return contenidos;
}

@Remove()
@Remove()
public void borrado
borrado() {
contenidos = null;
}
}

Práctica 3

• Se pide lo siguiente en este punto:
− Solucionar los problemas de referencias no satisfechas
usando la ayuda de Netbeans (presentará un icono de
bombilla para elegir los imports que el entorno crea que
necesitamos)
• import java.rmi.RemoteException;
• import java.util.ArrayList;
• import java.util.List;
• import javax.ejb.Remove;
• import javax.ejb.Stateful;
• import util.IdVerificador;
• import util.LibroException;
− Usar el asistente Netbeans para definir los métodos en el
interfaz del Bean de forma automática.

Práctica 3
• Nos movemos por el menú de proyectos hasta el cliente
del EJB que hemos creado (1/2):
public class ClienteCarro {
@EJB
private static Carro carro;

public ClienteCarro
ClienteCarro(String[] args) {
}

/**
* @param args the command line arguments
*/
public static void main
main(String[] args) {
ClienteCarro client = new ClienteCarro(args);
client.doTest();
}

public void doTest
doTest() {
try {
carro.inicializar("Mi carro de la compra", "123");
carro.anadirLibro("El nombre de la Rosa");

carro.anadirLibro("La ciudad de la algegria");
carro.anadirLibro("La metamorfosis de Kafka");

List<String> bookList = carro.getcontenidos();

// ---> Continua en la pagina siguiente
--->

Práctica 3

• El código continúa así:
bookList = carro.getcontenidos();

Iterator<String> iterator = bookList.iterator();

while (iterator.hasNext()) {
String titulo = iterator.next();
System.out.println("Obteniendo titulo del libro del carro: " + titulo);
}
System.out.println("Borrando "El nombre de la Rosa" from carro.");
carro.borrarLibro("El nombre de la Rosa");

System.out.println("Borrando "El resplandor" del carro.");
carro.borrarLibro("El nombre de la Rosa");

System.exit(0);
} catch (LibroException ex) {
System.err.println("Se elevo una LibroException: " + ex.getMessage());
System.exit(1);
} catch (Exception ex) {
System.err.println("Se elevo una excepcion inesperada");
ex.printStackTrace();
System.exit(1);
}
}
}

Práctica 3
• Se pide, en este caso:
− Resolver las referencias no satisfechas, usando el asistente
de Netbeans, y comprobar que no existe ningún aviso de
error en el código y ejecutar la aplicación:
Hemos provocado una excepción de manera
intencional al borrar un libro inexistente en el
carro.

PRÁCTICA 4: CREACIÓN DE UN MESSAGE DRIVEN BEAN

Práctica 4

− Descripción: Creación de un Message Driven Bean y conocer
usando el sistema pb-project (Java Blue Prints Project).
− Objetivos:
• Primera toma de contacto con los MDB
• Primera toma de contacto con el sistema pb-project
• Conocer las características principales de un MDB, para entender
cuándo puede compensarnos el usarlo.

Práctica 4

• Los proyectos que usan el sistema Java Blue Prints
Project (bp-project) tienen las siguientes ventajas:
− Pueden crear proyectos Java basados en la herramienta ANT
− Pueden cargarse y usarse como proyectos nativos en IDE’s
como Netbeans
− Pueden ser ejecutados (y desplegados) desde la línea de
comandos
− Permiten que un conjunto de proyectos compartan una misma
configuración.

Práctica 4
• Instrucciones de uso de bp-project de un proyecto con código
fuente existente
− Descargar bp-project y descomprirlo ejecutando el fichero JAR. Este proceso,
genera una nueva carpeta llamada “bp-project-vXX” (llamaremos a este directorio
bp-project.home). Nos dirigimos al directorio bp-project.home/bp-project.
− Nos aseguramos de tener ANT instalado. Si no lo tenemos, lo descargamos.
− Creamos el proyecto Netbeans si aún no está creado.
− Abrimos el fichero build.xml generado por NetBeans y reemplazamos la línea:
<import file="nbproject/build-impl.xml"/>
Por:
<property name="bp-project.home" value=“poner el path <bp-project.home>"/>
<import file="${bp-project.home}/main.xml" />
− Observar que podemos compartir un único directorio bp-project/ entre muchas
aplicaciones simplemente copiándolo a un lugar común, y ajustando la línea de
import a la carpeta o ubicación que corresponda.
− También será necesario definir una nueva propiedad en el fichero build.xml que
defina el tipo de proyecto. Por ejemplo, si es un proyecto Web, tendremos que
añadir la siguiente línea a build.xml:
Justo antes del import de ${bp-project.home}/main.xml Ponemos:
<property name="is.war.module" value="true"/>

Práctica 4

• Ejemplo de un caso concreto:
− Abrimos build.xml y reemplazamos:

− Por:
<property name="bp-project.home" value="path de <bp-project.home>"/>
<import file="${bp-project.home}/main.xml" />

− Nosotros copiaremos la carpeta bp-project al path del proyecto, de modo
que esas tres líneas quedarán en dos:
./bp
./bp-project.home/main.xml" />
<import file="./bp-project.home

• En el directorio <bp-project.home> copiamos el fichero
build.properties.sample a build.properties y corregimos los valores de
las propiedades javaee.home, y javaee.server.passwordfile.

Práctica 4

• Instrucciones para proyectos nuevos
− Crear la estructura de directories del proyecto siguiendo las
Reglas de proyecto Java BluePrints. Si estamos creando el
proyecto con Netbeans, no hay problema, ya que NB sigue
esas reglas.
− Copiamos el directorio bp-project/ en el home del directorio del
proyecto.
− Creamos un fichero build.xml adecuado para un war, ear o
ejb-jar siguiendo los ejemplos que se describen en las
siguientes diapositivas.

Práctica 4

• Proyecto EAR (enterprise archive)
<?xml version="1.0"?>
<project name="bp-web-project" default="default" basedir=".">
<property name="is.ear.module value="true"/>
is.ear.module"
is.ear.module
<import file="bp-project/main.xml"/>
</project>

• Proyecto Web
<project name="bp-web-project" default="default" basedir=".">
<property name="is.war.module value="true"/>
is.war.module"
is.war.module
</project>

• Proyecto EJB Jar
<?xml version="1.0" encoding="UTF-8"?>
<project name="hello-ejb" default="default" basedir="."
xmlns:ejbjarproject="http://www.netbeans.org/ns/j2ee-ejbjarproject/2">
<property name="is.ejb-jar.module value="true"/>
is.ejb-
is.ejb jar.module"
</project>

Práctica 4

• Proyecto Java Persistente Unit.
<project name="hello-pu" default="default" basedir=".">
<description>Builds, tests, and runs the project hello-pu.</description>
<property name="is.jar.module value="true"/>
is.jar.module"
is.jar.module
<property name="is.persistence-unit.module value="true"/>
is.persistence-
is.persistence unit.module"
</project>

• Proyecto Web que depende la la JPU declarada encima de estas líneas
<project name="hello-servlet" default="default" basedir=".">
is.war.module"
is.war.module

<property name="hello-pu.home" value="${home.dir}/../hello-pu"/>

<property name="extra.classpath value="${hello-pu.home}/dist/hello-pu.jar"/>
extra.classpath"
extra.classpath

<target name="-post-compile" depends="init">
<copy file="${hello-pu.home}/dist/hello-pu.jar" todir="${build.dir}/web/WEB-INF/lib"/>
</target>

</project>

Práctica 4

• Proyecto Web que depende de una librería de
componentes JSF
<project name="bp-slider-navigator" default="default" basedir=".">

is.war.module"
is.war.module

<property name="project.ui value="../../../components/ui"/>
project.ui"
project.ui
<property name="reference.ui.jar value="${project.ui}/dist/ui.jar
reference.ui.jar"
reference.ui.jar ui.jar"/>
ui.jar

<target name="-pre-compile" depends="init">
<copy file="${reference.ui.jar
reference.ui.jar}" todir="${build.web.dir}/WEB-INF/lib"/>
reference.ui.jar
</target>
</project>

Práctica 4

• TARGETs típicos de compilación: Estos son algunos
target’s típicos de compilación (build) que está
disponibles automáticamente cuando usamos
bp-project:
− all: Compila, empaqueta el archive, despliega la aplicación y
ejecuta.
− compile: Compila a aplicación.
− package-module: Empaqueta el archivo.
− default: Compila y empaqueta el archivo.
− run: Ejecuta la aplicación
− undeploy: repliega la aplicación.
− clean: Borra los directories generados, como build y dist

Práctica 4

• Valores de variables en el fichero build.properties (1/3)

Práctica 4

• Comenzamos la construcción de nuestro proyecto.

• Será un proyecto de tipo Enterprise Application, con un
módulo EJB y con un módulo de aplicación que actuará
como cliente del Message Driven Bean.

• Posteriormente a la ejecución del cliente,
chequearemos el fichero de log el Application Server,
que se encuentra en el path:

C:SunAppServerdomainsdomain1logs
/opt/SUNWApp/domains/domain1/logs

Práctica 4

• Creamos nuestro proyecto
Enterprise, llamado
ejb04-mensajesimple.
• El path de ese proyecto,
debería ser uno de estos:

C:CursoEJBproyectosejb04-mensajesimple
O en otro caso:
/root/ejb04-mensajesimple
root/ejb04
/ejb04-

Práctica 4

• Copiamos la carpeta bp-project ya preparada, y la
pegamos en el directorio de nuestro proyecto.

• En el fichero build.xml de nuestro proyecto, abrimos
build.xml y reemplazamos:

− Por:
<property name="is.ear.module" value="true"/>
<import file=“./bp-project/main.xml" />

• Lo podemos hacer desde el propio Netbeans o desde
fuera.

Práctica 4

• Creamos un nuevo MDB tal como en la figura:

Práctica 4

• Elegimos estos datos en el asistente:

NOTA: en los MDB, Netbeans no añade el sufijo Bean a
la clase; hay que ponerlo de forma explícita. No es
obligatorio

• El código del MDB debe ser el siguiente: Práctica 4

@MessageDriven(mappedName = "jms/MensajeSimpleBean", activationConfig = {
@ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-
acknowledge"),
@ActivationConfigProperty(propertyName = "destinationType", propertyValue =
"javax.jms.Queue")
}) public void onMessage(Message
mensajeEntrante) {
public class MensajeSimpleBean implements MessageListener {
TextMessage msg = null;
static final Logger logger =
Logger.getLogger("SimpleMessageBean");
try {
@Resource
if (mensajeEntrante instanceof
TextMessage) {
private MessageDrivenContext mdc;
msg = (TextMessage) mensajeEntrante;
public MensajeSimpleBean() {
logger.info("BEAN DE MENSAJE:
} Mensaje recibido: " +
msg.getText());
} else {
logger.warning("Mensaje de tipo
erroneo: “ +
mensajeEntrante.getClass().getName());
}
} catch (JMSException e) {
e.printStackTrace();
mdc.setRollbackOnly();
} catch (Throwable te) {
te.printStackTrace();
}
}
}

Práctica 4
•El código del cliente, debe ser el siguiente:
public class ClienteMensajeSimple { System.out.println("Para ver si el bean recibio”+
@Resource(mappedName = "jms/ConnectionFactory") +“mensajes,");
private static ConnectionFactory connectionFactory; System.out.println(“ mirar en el fichero: “+
@Resource(mappedName = "jms/MensajeSimpleBean") “<install>/domains/domain1/logs/server.log.");
private static Queue queue; } catch (JMSException e) {
public static void main(String[] args) { System.out.println("Se elevo una excepcion: “+
Connection connection = null; e.toString());
Session session = null; } finally {
MessageProducer messageProducer = null; if (connection != null) {
TextMessage message = null; try {
final int NUM_MSGS = 3; connection.close();
try { } catch (JMSException e) {
connection = connectionFactory.createConnection(); }
session = connection.createSession(false, } // if
Session.AUTO_ACKNOWLEDGE);
messageProducer = session.createProducer(queue); System.exit(0);
message = session.createTextMessage(); } // finally
} // main
for (int i = 0; i < NUM_MSGS; i++) {
message.setText("Este es el mensaje numero: " +public void onMessage(Message message) {
(i + 1));
System.out.println("Enviando mensaje: " + }
message.getText()); } // class
messageProducer.send(message);
}

Práctica 4

• Ahora que ya tenemos el código de nuestra aplicación, vamos a
preparar el entorno antes de lanzarla.

• Este proyecto, requiere lo siguiente:
− Un recurso JMS destination (la cola o ‘queue’)
• Usado en el MDB en la línea:
@MessageDriven(mappedName = "jms/MensajeSimpleBean", […]
• Referenciado por el cliente en la línea:
@Resource(mappedName = "jms/MensajeSimpleBean")
− Un recurso JMS Connection Factory
• Usado en el cliente, en la línea:
@Resource(mappedName = "jms/ConnectionFactory")

• Para crear estos recursos, usaremos al herramienta ANT.

Práctica 4
Una vez más, editaremos nuestro fichero build.xml, para añadir lo siguiente:
<target name="create-queue description="create JMS queue">
create-
create queue"
<antcall target="create-jms-resource">
<param name="jms.restype" value="javax.jms.Queue" />
<param name="jms.resource.property" value="Name=PhysicalQueue" />
<param name="jms.resource.name" value="jms/MensajeSimpleBean />
jms/
jms MensajeSimpleBean"
</antcall>
</target>

<target name="create-cf description="create JMS connection factory">
create-
create cf"
<antcall target="create-jms-connection-factory">
<param name="jms.restype" value="javax.jms.ConnectionFactory />
javax.jms.ConnectionFactory"
javax.jms.ConnectionFactory
<param name="jms.resource.name" value="jms/ConnectionFactory" />
</antcall>
</target>
<target name="delete-queue
delete-
delete queue"
description="delete JMS queue">
<antcall target="delete-jms-resource">
<param name="jms.resource.name" value="jms/MensajeSimpleBean" />
</antcall>
</target>

delete-
delete cf"
<target name="delete-cf
description="delete JMS connection factory">
<antcall target="delete-jms-resource">
<param name="jms.resource.name" value="jms/ConnectionFactory" />
</antcall>
</target>

Práctica 4
• Abrimos una shell, y desde la carpeta de nuestro proyecto,
ejecutamos:
– $sudo su
– #export PATH=/opt/SUNWapp/lib/ant/bin:/opt/jdk/bin:$PATH
– #export JAVA_HOME=/opt/jdk
– #ant create-cf
– #ant create-queue

• Debemos obtener
lo siguiente:

Práctica 4

• Ahora ya estamos listos para lanzar nuestro proyecto
(Run):

• Buscamos en los logs, como en la figura:

Práctica 4

• Una vez finalizada la ejecución de la práctica, borramos
los recursos connection factory y queue.
− #ant delete-cf
− #ant delete-queue

PRÁCTICA 5: CREACIÓN DE UN BEAN DE ENTIDAD

Práctica 5

− Descripción: Creación de un bean de entidad, y primer
acercamiento a la base de datos derby para la función de
almacén de datos.
− Objetivos:
• Primera toma de contacto con los entity beans.
• Primera toma de contacto con derby
• Conocer las características principales de un entity bean.

Práctica 5

• Creamos un nuevo proyecto, de tipo Web Application, y
lo llamamos ejb05-jpa

Práctica 5

• La base de datos DERBY se arranca al iniciar Sun App.
Server, aunque puede iniciarse de forma independiente
desde el menú Tools -> Start Java DB Server.

Práctica 5

• Creamos una nueva unidad de persistencia (I). En
netbeans para windows, podríamos hacerlo así:

Práctica 5
• En la versión para linux, tendremos que hacerlo así:

Práctica 5

• Creamos una nueva unidad de persistencia (II)

Práctica 5

• Creamos ahora una nueva Entity Class:

Práctica 5

• Damos a esa esa entity class los siguientes valores:

Práctica 5

• Nos encontramos con un comportamiento por defecto
de Netbeans que en este caso, no nos conviene.
Netbeans ha asumido
que nuestra intención
por defecto va a ser la
de otorgar una clave
automática y
autoincremental para la
persistencia de nuestro
objeto, pero HEMOS
ELEGIDO UN TIPO
String, no un tipo
numérico.

Práctica 5
• El código fuente de CredencialUsuario debe ser:
@Entity
public class CredencialUsuario implements Serializable {
@Id // nombre es la PK de esta entity.
private String nombre;
private String password;

protected CredencialUsuario() {
}

public CredencialUsuario(String nombre, String password) {
if ( (nombre == null || nombre.length() == 0) ||
(password == null || password.length() == 0)) {
throw new IllegalArgumentException("El nombre o la password esta en blanco");
}
this.nombre = nombre;
this.password = password;
}

public boolean esMismaPassword(String password) {
return this.password.equals(password);
}
}

Práctica 5

• Creamos ahora el servlet login:

Práctica 5
• El servlet login debe tener este código
public class login extends HttpServlet {
@PersistenceUnit
private EntityManagerFactory emf;

public void service ( HttpServletRequest req , HttpServletResponse resp)
EntityManager em = emf.createEntityManager();
try {
resp.setContentType("text/html");
PrintWriter out = resp.getWriter();
out.println("<HTML> <HEAD> <TITLE> Login correcto " +
"</TITLE> </HEAD> <BODY BGCOLOR=white>");
String nombre = req.getParameter("nombre");
String password = req.getParameter("password");
CredencialUsuario credencial = em.find(CredencialUsuario.class, nombre);

// em.find devuevle null si no encuentra el usuario.
if (credencial != null && credencial.esMismaPassword(password)) {
out.println("Bienvenido " + nombre);
} else {
out.println("Nombre o password erronea.");
}

Práctica 5

out.println("</BODY> </HTML> ");
} finally {
em.close();
}
}

public void init( ServletConfig config) throws ServletException {
super.init(config);
}

}

Práctica 5

• Creamos un nuevo servlet, esta vez, registro:

Práctica 5
• El servlet registro debe tener este código:
public class registro extends HttpServlet {
@PersistenceUnit
private EntityManagerFactory emf;

// Inyecta un objeto transacción de usuario.
@Resource
private UserTransaction utx;

public void service (HttpServletRequest req , HttpServletResponse resp)

try {
// Comenzamos una transaccion porque usamos un Entity Manager JTA.
utx.begin();
} catch (Exception e) {
throw new ServletException(e);
}

EntityManager em = emf.createEntityManager();
try {
resp.setContentType("text/html");
PrintWriter out = resp.getWriter();
out.println("<HTML> <HEAD> <TITLE>Registro de nuevo usuario " +
"</TITLE> </HEAD> <BODY BGCOLOR=white>");

Práctica 5
String nombre = req.getParameter("nombre");
String password = req.getParameter("password");
CredencialUsuario credencial = new CredencialUsuario(nombre, password);
// em.persist hace que el objeto se vuelva persistente.
em.persist(credencial);
out.println("Se ha creado correctamente el nuevo usuario. " +
"Haz click <A HREF="login.html"> aqui </A> para logarte.");
out.println("</BODY> </HTML> ");
utx.commit();
} catch (Exception e) {
try {
utx.rollback();
} catch (Exception ee) {
// Excepcion
}
throw new ServletException(e);
} finally {
em.close();
}
}

public void init( ServletConfig config) throws ServletException {
super.init(config);
}
}

Práctica 5

• Creamos ahora el documento HTML login.html:

Práctica 5

• Login.html debe tener este código:
<html>
<head>
<title>Pagina de Login</title>
</head>

<body>
<form method="post" action="login">
<p>Nombre de Usuario: <input type="text" name="nombre" size="10"> </p>
<p>Password: <input type="password" name="password" size="10"> </p>
<br>
<p>
<input type="submit" value="login"/>
<A href="registro.html"> Nuevo usuario? </A>
</form>
</body>
</html>

Práctica 5

• Creamos ahora el documento html registro.html:

Práctica 5

• Registro.html debe tener el siguiente código:
<html>
<head>
<title>Pagina de alta de nuevo usuario</title>
</head>

<body>
<form method="post" action="registro">
<p>Nombre de Usuario: <input type="text" name="nombre" size="10">
</p>
<p>Password: <input type="password" name="password" size="10"> </p>
<br>
<p>
<input type="submit" value="registro"/>
<input type="reset" value="cancelar"/>
</form>
</body>
</html>

Práctica 5

• Por último, sólo nos queda hacer un cambio en el
archivo index.jsp que tenemos por defecto. Cambiamos
el código a este:

<%
String URLRedireccion = "/ejb05-jpa/login.html";
response.sendRedirect(URLRedireccion);
%>

• Por último, hacemos un Run de la aplicación:

Práctica 5

• Debemos obtener lo siguiente:

Práctica 5

• Ahora probamos que no acepta credenciales erróneas;
sólo podemos entrar con usuario “paquito” y password
“chocolatero”.

Práctica 5

• Probamos también que nos permite acceder con el
usuario “paquito” y la password “chocolatero”.

Práctica 5

• ¿Qué esta ocurriendo aquí? Si recordamos los checks
en la creación de la unidad de persitencia:

Práctica 5

• Existe una característica en Sun Application Server y en
Glassfish llamada: Java2DB
− Esta característica es permite que el esquema de la base de
datos se cree automáticamente en Derby.
− El nombre de la tabla es en este caso, el mismo que el de la
clase entidad, en MAYÚSCULAS: “CREDENCIALUSUARIO”.
− El nombre de las columnas es el nombre de los atributos de la
clase, en MAYÚSCULAS:
• “NOMBRE”
• “PASSWORD”

− Si recordamos el
código fuente de
la clase:

Práctica 5
• ¿Cómo podríamos nosotros consultar esa base de datos?

• ¿Disponemos de un entorno amigable para hacerlo?

• Sí, dicha funcionalidad está INTEGRADA en Netbeans.

Práctica 5

• Abrimos el árbol hasta encontrarnos con la situación
descrita en la imagen siguiente (usuario “app” password
“app”):

Práctica 5

• Ahora abrimos nuevamente el árbol hasta encontrarnos
en esta situación:

Práctica 5

• Hemos reutilizado una base de datos que viene
incorporada en DERBY para hacer pruebas.

• Ahora vamos a crear nuestra propia base de datos para
almacenar la persistencia de nuestros objetos.

• Para ello, nos movemos
por los menús de
netbeans como en
la figura:

Práctica 5
• Proporcionamos estos datos:
NOTA: la ubicación de la BD
puede cambiarse para que
resida donde queramos
(siempre y cuando
dispongamos de permisos).

Práctica 5

• Borramos la configuración de unidad de persistencia
que hemos creado anteriormente.

Práctica 5

• Creamos una nueva unidad de persistencia:

Práctica 5

• Pero esta vez, creamos además una nueva fuente de
datos; la correspondiente a la nueva BD que hemos
creado:

Práctica 5

• EL nuevo Data Source debe llevar estos parámetros:

Práctica 5

• AL final, la unidad de persistencia (archivo
persistence.xml) debe quedar como muestra la figura:

Práctica 5

• Ejecutamos un Clean an build, seguido de un Run:
Ejecutamos la aplicación, y comprobamos
en la nueva base de datos si se ha
generado la tabla a través de una
consulta SQL (opción view data).

2/9 Curso JEE5, Soa, Web Services, ESB y XML

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a 2/9 Curso JEE5, Soa, Web Services, ESB y XML

Semelhante a 2/9 Curso JEE5, Soa, Web Services, ESB y XML (20)

Mais de Juan Carlos Rubio Pineda

Mais de Juan Carlos Rubio Pineda (20)

2/9 Curso JEE5, Soa, Web Services, ESB y XML