Añadir JDBC
Hasta ahora, la aplicación de ejemplo J2EE ha escrito y leído los datos desde una base de datos Cloudscape subyancente sin que hayamos escrito código SQL. Esto es porque el contenedor ha estado manejando el almacenamiento y recuperación de los datos a través del bean de entidad. La persistencia controlada por el contenedor es el termino usado para describir la situación donde el contenedor maneja el almacenamiento y la recuperación. Esta lección nos muestra como sobreescribir la persistencia controlada por el contenedor por defecto e implementar la persistencia controlada por el bean.
La persistencia controlada por el bean es cuando nosotros escribimos métodos de los beans de entidad o de sesión para usar los comandos SQL que le proporcionamos. La peristencia controlada por el bean puede ser util si necesitamos mejorar el rendimiento o mapear datos de varios beans en un fila de una tabla de base de datos.
Esta lección modifica el bean de entidad de la aplicación de ejemplo J2EE para usar persistencia controlada por el bean.
Ciclo de Vida del Bean
La Lección 3 mostraba la clase BonusBean manejada por el contenedor. Los únicos métodos con implementaciones eran getBonus para devolver el valor del bono, getSocSec para devolver el número de la seguridad social, y ejbCreate para crear un bean de entidad y pasarle los valores bonus y socsec. El contenedor tenía en cuenta cosas como la creacción de la fila en la tabla de la base de datos, y asegurarse de que los datos en memoria era consistentes con los datos de la fila de la tabla. Con la persistencia controlada por el bean nosotros tenemos que implementar todos
estos comportamientos, lo que significa añadir codigo JDBC™ y SQL, e implementar los métodos vacíos del ejemplo controlado por el contenedor.
Un bean de sesión o de entidad consiste en métodos de negocio y métodos de ciclo de vida. en el ejemplo, CalcBean tiene dos métodos de negocio, calcBean y getRecord , y BonusBean tiene dos métodos de negocio getBonus y getSocsec. Tanto CalcBean como BonusBean tienen los siguientes métodos de ciclo de vida. A los métodos de negocio los llama el cliente y a los métodos del ciclo de vida los llama el contenedor del bean.
- setEntityContext: El contenedor llama primero a este método para pasar un objeto contexto al bean de entidad. El contexto de entidad lo actualiza dinamicamente el contenedor incluso si muchos clientes llaman al bean de entidad a la vez, el contexto contiene datos actuales para cada llamada. Un bean de sesión tiene un método setSessionContext correspondiente que realiza una función similar a la del método setEntityContext.
- ejbCreate: El contenedor llama a este método cuando un cliente llama al método create del interface home del bean. Por cada método create en el interface home, el bean tiene un método ejbCreate correspondiente con la misma firma (parámetros y valor de retorno).
- ejbPostCreate: El contenedor llama a este método después de que se complete el método ejbCreate. Hay un método ejbPostCreate por cada método ejbCreate que toma los mismos argumentos que su método create.
Sin embargo, ejbPostCreate no tiene valor de retorno. Usamos ejbPostCreate para implementar cualquier procesamiento especial que necesitemos hacer después de crear el bean y antes de que esté disponible para el cliente. Lo podemos
dejar en blanco si no necesitamos procesamiento especial.
- ejbRemove: El contenedor llama a este método cuando un cliente llama al método remove del interface home del bean. La aplicación de ejemplo J2EE para este tutorial no incluye ningún método remove en el interface home.
- unsetEntityContext: El contenedor llama a este método después de que se haya llamado a ejbRemove para eliminar el bean de entidad. Sólo los beans de entidad tienen un método unsetEntityContext. Un bean de sesión no tiene el correspondiente método unsetSessionContext.
- ejbFindByPrimaryKey: El contenedor llama a este método cuando un cliente llama al método findByPrimaryKey del interface home del bean. Por cada método find del interface home del bean, tiene su correspondiente método ejbFind< type > con la misma firma (parámetros y valor de retorno).
- ejbLoad y ejbStore : El contenedor llama a estos métodos para sincronizar el estado del bean con la base de datos subyacente. Cuando un cliente selecciona u obtiene los datos de un bean como en el caso de un método get, el contenedor llama al método ejbStore para envíar el objeto a la base de datos y llama a ejbLoad para leerlo de nuevo. Cuando un cliente llama a un método find, el contenedor llama a ejbLoad para inicializar el bean con los datos desde la base de datos subyacente.
- ejbActivate y ejbPassivate: El contenedor llama a estos métodos para activar o desactivar el estado del bean. La activación o desactivación se refieren al intercambio del bean dentro y fuera del almacenamiento temporal para liberar memoria, que podría ocurrir si un bean dado no ha sido llamado por un cliente desde hace mucho tiempo. Las implementaciones de ejbPassivate podrían incluir cosas como el cierre de conexiones o ficheros usados por el bean, y para ejbActivate podría incluir cosas como la reapertura de las mismas conexiones o ficheros.
Modificar el código de BonusBean
Esta sección nos lleva a través del código de BonusBean con persistencia controlada por el bean. Lo primero que observaremos es que hay mucho más código que en la versión con persistencia controlada por el contenedor.
Sentencias Import
Los interfaces InitialContext, DataSource, y Connection se importan para establecer conexiones con la base de datos. El interface PreparedStatement se importa para usarlo como plantilla para crear una petición SQL. El interface ResultSet se importa para manejar accesos a filas de datos devueltas por una consulta. Las clases FinderException y SQLException se importan para manejar excepciones de búsqueda y accesos a bases de datos.
package Beans;
import java.rmi.RemoteException;
import javax.ejb.CreateException;
import javax.ejb.EntityBean;
import javax.ejb.EntityContext;
import javax.naming.InitialContext;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import javax.ejb.FinderException;
import java.sql.SQLException;
Variables de Ejemplar
Las variables de ejemplar añadidas en esta lección nos permiten establecer y cerrar conexiones con bases de datos. El string java:comp/env/jdbc/BonusDB indica el nombre de referencia para el recurso, que también deberíamos especificar cuando añadamos el bean de entidad a la aplicación J2EE usando la herramienta Deploy. En este ejemplo, la referencia de recursos es un alias a la base de datos Cloudscape (CloudscapeDB) donde está almacenada la tabla de datos.
Después crearemos la tabla BONUS en CloudscapeDB, y durante el despliegue mapearemos jdbc/BonusDB a jdbc/CloudscapeDB .
public class BonusBean implements EntityBean {
private EntityContext context;
private Connection con;
private String dbName =
"java:comp/env/jdbc/BonusDB";
private InitialContext ic = null;
private PreparedStatement ps = null;
private double bonus;
private String socsec;
Métodos de Negocio
Los métodos de negocio no han cambiado para esta lección excepto en las llamadas a System.out.println, que nos permiten ver el orden en que se llaman los métodos de negocio y ciclo de vida durante la ejecución.
public double getBonus() {
System.out.println("getBonus");
return this.bonus;
}
public String getSocSec() {
System.out.println("getSocSec");
return this.socsec;
}
Métodos de Ciclo de Vida
Estos métodos incluyen llamadas a System.out.println para que podamos ver en que orden se llaman durante la ejecución.
ejbCreate
La firma del método ejbCreate para esta lección lanza RemoteException y SQLException además de CreateException. SQLException es necesaria porque el método ejbCreate proporciona su propio código SQL,
y RemoteException es necesaria porque ese método realiza acceso remoto
Una cosa a observar de esta clase es que devuelve un valor String que es la clave primaria, pero la declaración para este método en el interface home espera recibir un ejemplar de la clase Bonus. El contenedor usa la clave primaria devuelta por este método para crear un ejemplar de Bonus.
public String ejbCreate(double bonus, String socsec)
throws RemoteException,
CreateException,
SQLException {
this.socsec=socsec;
this.bonus=bonus;
System.out.println("Create Method");
try {
//Establish database connection
ic = new InitialContext();
DataSource ds = (DataSource) ic.lookup(dbName);
con = ds.getConnection();
//Use PreparedStatement to form SQL INSERT statement
//to insert into BONUS table
ps = con.prepareStatement(
"INSERT INTO BONUS VALUES (? , ?)");
//Set 1st PreparedStatement value marked by ? , with
//socsec and the 2nd value marked by ?) with bonus
ps.setString(1, socsec);
ps.setDouble(2, bonus);
ps.executeUpdate();
} catch (javax.naming.NamingException ex) {
ex.printStackTrace();
} finally {
//Close database connection
ps.close();
con.close();
}
//Return primary key
return socsec;
}
ejbPostCreate
Este método tiene la misma firma que ejbCreate, pero no tiene implementación porque nuestro ejemplo no realiza procesamientos o inicializaciones posteriores a la creacción.
public void ejbPostCreate(double bonus,
String socsec)
throws RemoteException,
CreateException,
SQLException {
System.out.println("Post Create");
}
ejbFindByPrimaryKey
La versión controlada por el contenedor de BonusBean no incluia una implementación de ejbFindByPrimaryKey porque el contenedor podría localizar los registros de la base de datos por su clave primaria si especificamos persistencia controlada por el contenedor y proporcionamos un campo de clave primaria durante el despliegue. En esta lección, BonusBean se despliega con persistencia controlada por el bean por eso debemos proporcionar una implementación para este método y lanzar una SQLException. La versión controlada por contenedor sólo lanzaba RemoteException y FinderException.
Si la operación find localiza un registro con la clave primaria pasada a ejbFindByPrimaryKey, se devuelve el valor de la clave primaria para que el contenedor pueda llamar al método ejbLoad para inicializar BonusBean con los datos bonus y socsec recuperados.
Una cosa a observar sobre esta clase es que devuelve un valor String
que es la clave primaria, pero la declaración para este método en el interface home espera recibir un ejemplar de la clase Bonus. El contenedor usa la clave primaria devuelta por este método para crear un ejemplar de Bonus.
public String ejbFindByPrimaryKey(String primaryKey)
throws RemoteException,FinderException,
SQLException {
System.out.println("Find by primary key");
try {
//Establish database connection
ic = new InitialContext();
DataSource ds = (DataSource) ic.lookup(dbName);
con = ds.getConnection();
//Use PreparedStatement to form SQL SELECT statement
//to select from BONUS table
ps = con.prepareStatement(
"SELECT socsec FROM BONUS WHERE socsec = ? ");
ps.setString(1, primaryKey);
//Use ResultSet to capture SELECT statement results
ResultSet rs = ps.executeQuery();
//If ResultSet has a value, the find was successful,
//and so initialize and return key
if(rs.next()) {
key = primaryKey;
} else {
System.out.println("Find Error");
}
} catch (javax.naming.NamingException ex) {
ex.printStackTrace();
} finally {
//Close database connection
ps.close();
con.close();
}
//Return primary key
return key;
}
ejbLoad
Este método se llama después de una llamada exitosa a ejbFindByPrimaryKey para cargar y recuperar datos y sincronizar los datos del bean con los de la base de datos.
public void ejbLoad() {
System.out.println("Load method");
try {
//Establish database connection
ic = new InitialContext();
DataSource ds = (DataSource) ic.lookup(dbName);
con = ds.getConnection();
//Use PreparedStatement to form SQL SELECT statement
//to select from BONUS table
ps = con.prepareStatement(
"SELECT * FROM BONUS WHERE SOCSEC = ?");
ps.setString(1, this.socsec);
//Use ResultSet to capture SELECT statement results
ResultSet rs = ps.executeQuery();
//If ResultSet has a value, the find was successful
if(rs.next()){
this.bonus = rs.getDouble(2);
} else {
System.out.println("Load Error");
}
} catch (java.sql.SQLException ex) {
ex.printStackTrace();
} catch (javax.naming.NamingException ex) {
ex.printStackTrace();
} finally {
try {
//Close database connection
ps.close();
con.close();
} catch (java.sql.SQLException ex) {
ex.printStackTrace();
}
}
}
ejbStore
Se llama a este método cuando un cliente selecciona u obtiene datos en el bean para envíar el objeto a la base de datos y mantener el bean y la base de datos sincronizados.
public void ejbStore() {
System.out.println("Store method");
try {
//Establish database connection
DataSource ds = (DataSource)ic.lookup(dbName);
con = ds.getConnection();
//Use PreparedStatement to form SQL UPDATE statement
//to update BONUS table
ps = con.prepareStatement(
"UPDATE BONUS SET BONUS = ? WHERE SOCSEC = ?");
//Set 1st PreparedStatement value marked by ? with
//bonus and the 2nd value marked by ?) with socsec
ps.setDouble(1, bonus);
ps.setString(2, socsec);
int rowCount = ps.executeUpdate();
} catch (javax.naming.NamingException ex) {
ex.printStackTrace();
} catch (java.sql.SQLException ex) {
ex.printStackTrace();
} finally {
try {
//Close database connection
ps.close();
con.close();
} catch (java.sql.SQLException ex) {
ex.printStackTrace();
}
}
}
ejbRemove
Se llama a este método cuando un cliente llama al método remove del interface home del bean. El cliente JavaBean de este ejemplo no proporciona un método remove que el cliente pueda llamar para eliminar BonusBean desde su contenedor. De todas formas, aquí podemos ver la implementación de un método ejbRemove. cuando el contenedor llama a ejbRemove, éste obtiene la clave primaria (socsec) de la variable de ejemplar socsec, elimina el bean de su contenedor, y borra la correspondiente fila de la base de datos.
public void ejbRemove()
throws RemoteException {
System.out.println("Remove method");
try {
DataSource ds = (DataSource)ic.lookup(dbName);
con = ds.getConnection();
ps = con.prepareStatement(
"DELETE FROM BONUS WHERE SOCSEC = ?");
ps.setString(1, socsec);
ps.executeUpdate();
} catch (java.sql.SQLException ex) {
ex.printStackTrace();
} catch (Exception ex) {
ex.printStackTrace();
try {
ps.close();
con.close();
} catch (java.sql.SQLException ex) {
ex.printStackTrace();
}
}
ejbActivate
Cuando un bean no se ha utilizado durante mucho tiempo, el contenedor lo desactiva o lo mueve a un almacenamiento temporal donde el contenedor puede rápidamente reactivar el bean en el caso de que algún cliente llame a un método de negocio del bean. Este método llama al método getPrimaryKey en el contexto de entidad para que la clave primaria esté disponible para los clientes del bean.
Cuando se hace una petición, el contenedor usa la clave primaria para cargar los datos del bean.
public void ejbActivate() {
System.out.println("Activate method");
socsec = (String)context.getPrimaryKey();
}
ejbPassivate
Cuando un bean no se ha utilizado durante mucho tiempo, el contenedor lo desactiva o lo mueve a un almacenamiento temporal donde el contenedor puede rápidamente reactivar el bean en el caso de que algún cliente llame a un método de negocio del bean. Este método selecciona la clave primaria a null para liberar memoria mientras el bean está desactivado.
public void ejbPassivate() {
System.out.println("Passivate method");
socsec = null;
}
setEntityContext
El contenedor llama a este método para inicializar la variable de ejemplar context del bean. Es necesario porque el método ejbActivate llama al método getPrimarykey sobre la variable de ejemplar context para pasar el bean del estado
desactivado al de activado.
public void setEntityContext(
javax.ejb.EntityContext ctx){
System.out.println("setEntityContext method");
this.context = ctx;
}
unsetEntityContext
El contenedor llama a este método para poner a null la variable de ejemplar context después de que se haya llamado al método ejbRemove para eliminar el bean. Sólo los beans de entidad tienen un método unsetEntityContext.
public void unsetEntityContext(){
System.out.println("unsetEntityContext method");
ctx = null;
}
}
Modificar el Código de CalcBean y JBonusBean
Como BonusBean proporciona su propio código SQL, el método CalcBean.calcbonus, que crea ejemplares de BonusBean, tiene que modificarse para lanzar la excepción java.sql.SQLException. Aquí tenemos la forma de hacer este
cambio:
public class CalcBean implements SessionBean {
BonusHome homebonus;
public Bonus calcBonus(int multiplier,
double bonus, String socsec)
throws RemoteException,
SQLException,
CreateException {
Bonus theBonus = null;
double calc = (multiplier*bonus);
try {
InitialContext ctx = new InitialContext();
Object objref = ctx.lookup("bonus");
homebonus = (BonusHome)
PortableRemoteObject.narrow(
objref, BonusHome.class);
} catch (Exception NamingException) {
NamingException.printStackTrace();
}
//Store data in entity Bean
theBonus=homebonus.create(calc, socsec);
return theBonus;
}
La clase JBonusBean tiene que modificarse para capturar la SQLException lanzada por CalcBean. DuplicateKeyExcpetion es una subclase de CreateException, por eso será capturada por la sentencia catch (javax.ejb.CreateExceptione).
public double getBonusAmt() {
if(strMult != null){
Integer integerMult = new Integer(strMult);
int multiplier = integerMult.intValue();
try {
double bonus = 100.00;
theCalculation = homecalc.create();
Bonus theBonus = theCalculation.calcBonus(
multiplier, bonus, socsec);
Bonus record = theCalculation.getRecord(
socsec);
bonusAmt = record.getBonus();
socsec = record.getSocSec();
} catch (java.sql.SQLException e) {
this.bonusAmt = 0.0;
this.socsec = "000";
this.message = e.getMessage();
} catch (javax.ejb.CreateException e) {
this.bonusAmt = 0.0;
this.socsec = "000";
this.message = e.getMessage();
} catch (java.rmi.RemoteException e) {
this.bonusAmt = 0.0;
this.socsec = "000";
this.message = e.getMessage();
}
genXML();
return this.bonusAmt;
} else {
this.bonusAmt = 0;
this.message = "None.";
return this.bonusAmt;
}
}
Crear la Tabla de la Base de Datos
Como este ejemplo usa persistencia controlada por el bean, tenemos que crear la tabla BONUS en la base de datos CloudscapeDB. Con persistencia controladda por el contenedor, la tabla se creaba automáticamente.
Para mantener las cosas sencillas, la tabla de la base de datos se crea con dos scripts: createTable.sql y cloudTable.sh (Unix) o cloudTable.bat (Windows/NT). Para este ejemplo, el escript createTable.sql va en nuestro directorio ~/J2EE/Beans, y el script cloudTable.sh (Unix) o cloudTable.bat (Windows/NT) va en nuestro directorio ~/J2EE.
Para ejecutar estos scripts, vamos al directorio Beans y tecleamos los siguiente:
Unix:
../cloudTable.sh
Windows/NT:
..\cloudTable.bat
createTable.sql
Este fichero se proporciona con los ficheros fuentes de esta leccción.
drop table bonus;
create table bonus
(socsec varchar(9) constraint pk_bonus primary key,
bonus decimal(10,2));
exit;
cloudTable.bat
Este fichero se proporciona con los ficheros fuentes de esta leccción.
rem cloudTable.bat
rem Creates BONUS table in CloudscapeDB.
rem
rem Place this script in ~\J2EE
rem To run: cd ~\J2EE\cloudTable.sh
rem
rem Change this next line to point to *your*
rem j2sdkee1.2.1 installation
rem
set J2EE_HOME=\home\monicap\J2EE\j2sdkee1.2.1
rem
rem Everything below goes on one line
java -Dij.connection.CloudscapeDB=
jdbc:rmi://localhost:1099/jdbc:cloudscape:
CloudscapeDB\;create=true -Dcloudscape.system.home=
%J2EE_HOME%\cloudscape -classpath %J2EE_HOME%iib\cloudscape\client.jar;
%J2EE_HOME%iib\cloudscape\ tools.jar;
%J2EE_HOME%iib\cloudscape\cloudscape.jar;
%J2EE_HOME%iib\cloudscape\RmiJdbc.jar;
%J2EE_HOME%iib\cloudscapeiicense.jar;
%CLASSPATH% -ms16m -mx32m
COM.cloudscape.tools.ij createTable.sql
cloudTable.sh
Este fichero se proporciona con los ficheros fuentes de esta leccción.
#!/bin/sh
J2EE_HOME=/home/monicap/J2EE/j2sdkee1.2
java -Dij.connection.CloudscapeDB=jdbc:rmi:
//localhost:1099/jdbc:cloudscape:CloudscapeDB\;
create=true -Dcloudscape.system.home=
$J2EE_HOME/cloudscape -classpath
$J2EE_HOME/lib/cloudscape/client.jar:
$J2EE_HOME/lib/cloudscape/tools.jar:
$J2EE_HOME/lib/cloudscape/cloudscape.jar:
$J2EE_HOME/lib/cloudscape/RmiJdbc.jar:
$J2EE_HOME/lib/cloudscape/license.jar:
${CLASSPATH} -ms16m -mx32m
COM.cloudscape.tools.ij createTable.sql
Eliminar el Fichero JAR
Tenemos que actualizar el fichero JAR con el nuevo código del Bean. Si tenemos los dos beans en un sólo fichero JAR, tenemos que borrar 2BeansJar y crear uno nuevo. Los pasos para añadir CalcBean son los mismos que los de la lección Comunicaciones entre Beans. Los pasos para añadir BonusBean son ligeramente diferentes como se describe aquí.
Si tenemos los beans en ficheros JAR separados, tenemos que borrar el fichero JAR con BonusBean y crear uno nuevo como se describe aquí.
Estas instrucciones empiezan en el momento de añadir los interfaces y las clases de BonusBean al fichero JAR.
EJB JAR :
- Pulsamos Add (el más cercano a la ventana Contents).
- Cambiamos de directorio para que el directorio Beans muestre su contenido.
- Seleccionamos Bonus.class
- Pulsamos Add .
- Seleccionamos BonusBean.class
- Pulsamos Add .
- Seleccionamos BonusHome.class
- Pulsamos Add .
Clases Enterprise Bean JAR :
- Nos aseguramos de ver Beans/Bonus.class, Beans/BonusHome.class, y Beans/BonusBean.class en el display.
- Pulsamos OK.
EJB JAR :
General :
- Nos aseguramos de que Beans.BonusBean es el nombre de clase, Beans.BonusHome es el interface Home, y Beans.Bonus es el interface Remoto.
- Introducimos BonusBean como nombre de display.
- Pulsamos Entity .
- Pulsamos Next .
Selecciones de Entidad:
- Seleccionamos Bean-managed persistence .
- La clase de clave primaria es java.lang.String, Observa que la clave primaria tiene que ser un tipo de clase, los tipos primitivos no son válidos como claves primarias.
- Pulsamos Next .
Entradas de Entornio:
- Pulsamos Next. Este sencillo bean no usa propiedades (entradas de entorno).
Referencias a Beans Enterprise:
Referencias a Recursos:
- Pulsamos Add
- Tecleamos jdbc/BonusDB en la primera columna, debajo de Coded Name. Nos aseguramos de que Type es javax.sql.DataSource, y Authentication es Container .
- Pulsamos Next.
Seguridad:
- Pulsamos Next. Este sencillo bean no usa roles de seguridad.
Control de Transación :
- Seleccionamos Container-managed transactions (si no lo está ya).
- En la lista de abajo , marcamos como necesarios create , findByPrimaryKey, getBonus y getSocSec. Esto significa que el contenedor arranca una nueva transación antes de ejecutar estos métodos. La transación se envía justo antes de que los métodos terminen.
- Pulsamos Next .
Revisión de Selecciones:
Ventana Inspecting:
- Con 2BeansApp seleccionado pulsamos JNDI names.
- Asignamos calcs a CalcBean , bonus a BonusBean , y jdbc/Cloudscape a jdbc/BonusDB.
Verificar y Desplegar la Aplicación
Antes de desplegar la aplicación, es una buena idea ejecutar el verificador. El verificador mostrará los errores en los componentes de la aplicación como métodos inexistentes que el compilador no captura.
Verificar:
- Con 2BeansApp seleccionado, elegimos Verifier desde el menú Tools.
- En el diálogo que aparece, pulsamos OK. La ventana debería decir que no hay ningún fallo.
- Cerramos la ventana del verificador porque ahora estamos listos para desplegar la aplicación.
Nota:
En la versión 1.2.1 del software podríamos obtener un error tests app.WebURI. Esto significa que la herramienta DeployTool no puso la extensión .war al fichero WAR durante su creacción. Es un error menor y la aplicación J2EE se despliega sin problemas. |
Desplegar:
- Desde el menú Tools, elegimos Deploy Application. Se mostrará una caja de diálogo Deploy BonusApp.
- Verificar que la selección de Target Server es un host local o el nombre de un host donde se está ejecutando el servidor J2EE.
- Marcar la caja Return Client Jar. Al marcar esta caja se crea un ficher JAR con la información de despliegue necesaria por el bean de entidad.
- Pulsamos Next .
- Nos aseguramos de que los nombres JNDI muestran calcs para CalcBean, bonus para BonusBean y jdbc/Cloudscape para BonusDB. Si no es así, tecleamos los nombres JNDI nosotros mismos, y pulsamos la tecla Return.
- Pulsamos Next. Nos aseguramos de que el nombre Context Root muestra JSPRoot. Si no es así, lo tecleamos nosotros mismos y pulsamos la tecla Return.
- Pulsamos Next .
- Pulsamos Finish para empezar el despliegue. Se mostrará una caja de diálogo que mostrará el estado de la operación de despliegue.
- Cuando se haya completado,pulsamos OK.
Ejecutar la Aplicación
El servidor web se ejecuta por defecto en el puerto 8000. Para abrir la página bonus.html apuntamos nuestro navegador a http://localhost:8000/JSPRoot/bonus.html, que es dónde la herramienta de despliegue puso el fichero HTML.
- Rellenamos un número de la seguridad social y un multiplicador.
- Pulsamos el botón Submit. Bonus.jsp procesa nuestros datos y devuelve una página HTML con el bono calculado.
La salida del servidor J2EE podría mostrar los siguientes mensajes cada vez que se intente un acceso a la base de
datos. Estos mensajes significan que no se suministraron nombres de usuarios ni passwords para acceder a la base de datos. Podemos ignorar estos mensajes porque los nombres de usuario y las passwords no son necesarios para acceder a la base de datos Cloudscape, y este ejemplo funciona bien sin importarle estos mensajes
Cannot find principal mapping information for data source with JNDI name
jdbc/Cloudscape
Aquí tenemos una versión más limpia de la salida del servidor J2EE (el mensaje de arriba fue editado)
setEntityContext method
Create Method
Post Create
setEntityContext method
Find by primary key
Load method
getBonus
Store method
Load method
getSocSec
Store method
Find by primary key
Load method
getSocSec
Store method
Load method
getBonus
Store method
<?xml version="1.0"?>
<report>
<bonusCalc ssnum="777777777" bonusAmt="300.0" />
</report>
Código Fuente de los Ejemplos
Aquí tienes un fichero Zip con los ficheros fuente de los ejemplos de esta página:
fuentes_L7.zip
Tutoriales
