Guia Practicas Introduccion Desarrollo Web

CURSO
INTRODUCCION AL DESARROLLO WEB

CON JDEVELOPER 11G
Guia de Pract
Practicas
Contenido
Instalación ............................................................................................................................. 2
Instalación de JDeveloper .............................................................................................. 2
Test de Prueba “Hello J2EE World” .............................................................................. 3
Java Server Pages .............................................................................................................. 5
Ejercicio 1 .......................................................................................................................... 5
Ejercicio 2 .......................................................................................................................... 8
Ejercicio 3 ........................................................................................................................ 11
Servlets ................................................................................................................................ 18
Ejercicio 4 ........................................................................................................................ 18
Ejercicio 5 ........................................................................................................................ 22
Enterprise Java Beans EJB 3.0 ....................................................................................... 24
Ejercicio 6 ........................................................................................................................ 24
Ejercicio 7 ........................................................................................................................ 28
Ejercicio 8 ........................................................................................................................ 31
Ejercicio 9 ........................................................................................................................ 35
Introducción al Oracle ADF .............................................................................................. 38
Ejercicio 10 ..................................................................................................................... 38
Instalación
Instalación de JDeveloper
JDeveloper es un entorno de trabajo (IDE) distribuido por Oracle, libre y gratuito, que sirve
para la construcción de aplicaciones J2EE y Web Services y usa los últimos standares
para Java, XML y SQL. JDeveloper soporta el ciclo de vida de desarrollo completo con
características como el modelado, codificación, depuración, testeo e implementación de
aplicaciones.
JDeveloper ofrece una extensión de Java SDK, el cual permite adicionar capacidades y
customizar el ambiente de desarrollo, es por esa razón que no se requiere instalar
previamente Java SDK en la maquina, para poder bajar este producto visite el sitio
http://otn.oracle.com/products/jdev.
La versión con la cual se trabajara en el curso es la 11g, se recomienda seguir los

siguientes pasos de instalación:
• Bajar JDeveloper 11g (versión 11.1.1.2.0) de http://otn.oracle.com/products/jdev.

para Windows, viene empaquetado en el archivo jdevstudio11112install.exe (993
MB).
• Instalar Oracle Fusion Middleware que es el nombre completo del producto

JDeveloper 11g en un directorio especifico (por ejemplo C:\Oracle\Middleware).
• Opcional: Instalar un cliente Oracle Net80 para la coneccion a una Base de Datos
Oracle, puede instalar por ejemplo Oracle Developer Suite 10g (ODS) u otro
software en una ORACLE_HOME particular. Crear una entrada en el archivo
TNSNAMES.ORA dentro el directorio de instalación de ODS, subdirectorio
Network\Admin, para la conección a una Base de Datos de trabajo Oracle (por
ejemplo el archivo estará ubicado en
C:\Oracle\DevSuite10g\network\admin\tnsnames.ora). Un ejemplo a una entrada
en el archivo será:
HOME =
(DESCRIPTION =
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST = home)(PORT = 1521))
)
(CONNECT_DATA =
(SERVER = DEDICATED)
(SERVICE_NAME = HOME)
)
)
• Probar la conección a la Base de Datos de trabajo, para esto abrir una ventana
DOS y ejecutar el comando tnsping, por ejemplo:
C:\>tnsping design
TNS Ping Utility for 32-bit Windows: Version 9.2.0.1.0 - Production on 02-MAR-2006
13:09:59
Copyright (c) 1997 Oracle Corporation. All rights reserved.
Used parameter files:

C:\Oracle\DevSuite10g\network\admin\sqlnet.ora
Used TNSNAMES adapter to resolve the alias

Attempting to contact (DESCRIPTION = (ADDRESS_LIST = (ADDRESS = (PROTOCOL = TCP)
(HOST = home)(PORT = 1521))) (CONNECT_DATA = (SERVER = DEDICATED) (SERVICE_NAME
= HOME)))
OK (20 msec)
Test de Prueba “Hello J2EE World”
1.- Ingresar desde el menú de inicio de Windows a Oracle Fusion Middleware 11.1.1.2.0
JDeveloper Studio 11.1.1.2.0, aparecerá la pantalla de Selección de Role, seleccionar la opción
Default Role Enables all Technologies, presionar el botón Ok de bienvenida a JDeveloper
2.- Ahora se creara una aplicación Web:

Ingresar a la opcion: File New
En la ventana New Gallery, seleccionar la opcion General Applications Java EE Web
Aplication.
Presionar el boton Aceptar
3.- Ingresar un nombre para la aplicación y un directorio para el espacio de trabajo.

Presione el Boton Finish.
4.- JDeveloper creara una aplicación con dos proyectos que siguen el patrón MVC (Model-View-
Con troller), los proyectos tiene los nombres por defecto Model y ViewController.
5.- A continuación se creará una Pagina JSP dentro el proyecto

Seleccione el proyecto ViewController
Ingrese a: File New o click derecho New
En la ventana “New Gallery”, seleccione la categoría “Web Tier”, subcategoría “JSP” y luego el item
“JSP”.
Presione el boton Ok.
6.- En la ventana Create JSP, ingrese el nombre Hello.jsp en el campo File Name, y presione el
boton Ok
7.- Se le habilitara un área de diseño en blanco, en la cual usted puede editar libremente el texto
“Hello World J2EE”.
8.- A continuación, se ejecutara la pagina JSP creada.
Seleccione la pagina Hello.jsp
Presione click derecho y seleccione la opción Run
9.- JDeveloper empezara a implementar o desplegar la aplicación usando el servidor integrado

Integrated Web Logic configurado en la etapa de instalación del producto.
10.- Una vez que la aplicación, se compilo y desplego satistactoriamente en la ventala Log del
servidor integrado apecera el mensaje:
Run startup time: 1078 ms.

[Application Capitulo1 deployed to Server Instance IntegratedWebLogicServer]
Target URL -- http://127.0.0.1:7101/Capitulo1-ViewController-context-root/Hello.jsp
Java Server Pages

Ejercicio 1
Con el siguiente ejercicio, se pretende crear una pagina Web de Bienvenida con
información de las Carreras disponibles de una Universidad. Las Carreras disponibles en
la Universidad se crearan a través de una clase Java, que devolverá un vector a la pagina
JSP.
1.- Crear una nueva aplicación llamada Capitulo2:

File New Categories: General Applications Java EE Web Application
Application Name: Capitulo2
Directory Name: D:\Curso_J2EE\Capitulo2
Presione boton: Next
Ingrese en el campo Project Name: Universidad
Directory: D:\Curso_J2EE\Capitulo2\Universidad
Presione boton: Finish
2.-Crear una pagina JSP de Bienvenida (Bienvenido.jsp)
Seleccione el proyecto: Universidad
File New Categories: Web Tier JSP Item: JSP
Presione boton: Ok
File Name: Bienvenido.jsp
Directory Name: D:\Curso_J2EE\Capitulo2\Universidad\public_html
Presione boton: Ok
3.- Crear una pagina JSP de Error (Error.jsp)
Seleccione proyecto: Universidad WEB-INF
File New Categories: Web Tier JSP Item: JSP
Presione boton: Ok
File Name: Error.jsp
Directory Name: D:\Curso_J2EE\Capitulo2\Universidad\public_html\WEB-INF
Presione boton: Ok
4.- Crear un pie de pagina JSP (PiePagina.jspf)
Seleccione proyecto: Universidad WEB-INF
File New Categories: Web Tier JSP JSP Segment
File Name: PiePagina.jspf
Presione boton: Ok
5.- Crear la clase Carreras.java
Seleccione el proyecto: Universidad
File New Categories: General Java Java Class
Presione boton: Ok
Name: Carreras
Package: Paquetes
Extends: java.lang.Object
Public (chequeado)
Presione boton: Ok
Editar el siguiente código:
package Paquetes;
import java.util.Iterator;
import java.util.Vector;
public class Carreras
{
private Vector carreras = new Vector();
public Carreras()
{
carreras.add("Ingenieria Industrial");
carreras.add("Ingenieria de Sistemas");
carreras.add("Ingenieria Agronomica");
carreras.add("Medicina");
carreras.add("Enfermeria");
carreras.add("Arquitectura");
carreras.add("Licenciatura en Derecho");
}
public Iterator getAllCarreras()

{
return carreras.iterator();
}
}
6.- Del panel central seleccione el tabpage Bienvenido.jsp, realice lo siguiente:
Seleccione modo Source (vera el codigo fuente de la pagina)
Seleccione la directiva <%@ page … %>
En la ventana Page Directory – Property Inspector, seleccione:
Error Page: /WEB-INF/Error.jsp
Import: java.util.Iterator,Paquetes.Carreras
Modifique y agreque el siguiente código:
<%@ page contentType="text/html;charset=windows-1252" errorPage="/WEB-INF/Error.jsp"
import="java.util.Iterator,Paquetes.Carreras"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
<title>Pagina de Bienvenida Universidad Santo Tomas</title>
</head>
<body>
<h1 align="center">Pagina de Bienvenida</h1>
<h2 align="center">Universidad Santo Tomas</h2>
<P> </P>
<P> </P>
Carreras Disponibles en nuestra Universidad<P> </P>
<%! Carreras carreras = new Carreras(); %>
<%
Iterator carreras_disponibles = carreras.getAllCarreras();
while (carreras_disponibles.hasNext())
{
String c = (String) carreras_disponibles.next();
%>
<p>
<a href="<%= reemplazarUnderScore(c) %>.jsp"><%= c %></a>
</p>
<%
}
%>
<%@ include file="/WEB-INF/PiePagina.jspf"%>
</body>
</html>
<%!
public String reemplazarUnderScore(String s)
{
return s.replace(' ','_');
}
%>
7.- Del panel central seleccione el tabpage Error.jsp, realice lo siguiente:
Seleccione modo Source (vera el código fuente de la página)
Seleccione la directiva <%@ page … %>
En la ventana Page directive – Property Inspector, seleccione:
isErrorPage: true
import: java.io.PrintWriter
Modifique y agregué el siguiente código:
<%@ page contentType="text/html;charset=windows-1252" isErrorPage="true" import="java.io.PrintWriter"%>
<html>
<head>
<title>Error</title>
</head>
<body>
<h1 align="center">Error</h1>
<P>Ocurrio un error en la aplicacion</P>
<P> </P>
<p><% exception.printStackTrace(new PrintWriter(out)); %>
<%@ include file="PiePagina.jspf"%>
</body>
</html>
8.- Del panel central seleccione el tabpage PiePagina.jsp, agregue el siguiente código:
<hr>
Pagina generada en <%= (new java.util.Date()).toString() %>
9.- A continuación, se ejecutara la pagina JSP creada.

Seleccione la pagina Bienvenido.jsp
10.- Una vez que la aplicación, se compilo y desplego satistactoriamente en la ventana Log del
servidor integrado apecera el mensaje:
[Application Capitulo2 deployed to Server Instance IntegratedWebLogicServer]
Target URL -- http://127.0.0.1:7101/Capitulo2-Universidad-context-root/Bienvenido.jsp

Ejercicio 2
Con este ejercicio ampliaremos el anterior. Añadiremos una pagina de registro a la
aplicación, de esta forma veremos el uso de JavaBeans y de los objetos implícitos.
1.- Seleccionando el proyecto Universidad, añadir un JavaBean que permita almacenar información
del usuario.
Seleccione: Universidad
Ingrese a: File New All Techologies Categories: General Java Bean
Name: Usuario
Package: Paquetes
Modificar el código de la clase bean Usuario:
package Paquetes;
public class Usuario

{
private String nombresUsuario;
private String apellidosUsuario;
private String loginUsuario;
private String edad;
public Usuario()
{
}
public String getApellidosUsuario()
{
return apellidosUsuario;
}
public void setApellidosUsuario(String apellidosUsuario)
{
this.apellidosUsuario = apellidosUsuario;
}
public String getEdad()
{
return edad;
}
public void setEdad(String edad)
{
this.edad = edad;
}
public String getLoginUsuario()
{
return loginUsuario;
}
public void setLoginUsuario(String loginUsuario)
{
this.loginUsuario = loginUsuario;
}
public String getNombresUsuario()
{
return nombresUsuario;
}
public void setNombresUsuario(String nombresUsuario)
{
this.nombresUsuario = nombresUsuario;
}
}
2.- Crear un Formulario de Registro (FormRegistro.html)
Seleccione: Universidad Web Content
Ingrese a: File New Categories: Web Tier HTML HTML Page
File Name: FormRegistro.html
3.- Del panel central seleccione el tabpage FormRegistro.html, realice lo siguiente:
Seleccione modo Source (vera el código fuente de la pagina)
<html>
<head>
<meta HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=windows-1252"></meta>
<title>Pagina de Registro de Usuarios</title>
</head>
<body>
<h1>Pagina de Registro de Usuarios</h1>
<form method="POST" action="Registro.jsp">
<table cellspacing="2" cellpadding="3" border="1" width="100%">
<tr>
<td align="right">Login Usuario:</td>
<td align="left"><input type="text" name="loginUsuario" size="30" /></td>
</tr>
<tr>
<td align="right">Nombres:</td>
<td align="left"><input type="text" name="nombresUsuario" size="50"/></td>
</tr>
<tr>
<td align="right">Apellidos:</td>
<td align="left"><input type="text" name="apellidosUsuario" size="50"/></td>
</tr>
<tr>
<td align="right">Edad:</td>
<td align="left"><input type="text" name="edad" size="5"/></td>
</tr>
</table>
En que carreras esta interesado?
<br><input type="checkbox" name="carreras_interes"
value="Ingenieria de Sistemas">Ingenieria de Sistemas</input>
value="Medicina">Medicina</input>
value="Arquitectura">Arquitectura</input>
<p><input type="submit" value="Procesar" /></p>
</form>
</body>
</html>
4.- Crear la pagina de registro de la aplicación (Registro.jsp), donde se usara el JavaBean Usuario:
Ingrese a: File New Categories: Web Tier JSP JSP
File Name: Registro.jsp
5.- Del panel central seleccione el tabpage Registro.jsp, realice lo siguiente:
Seleccione modo Source (vera el código fuente de la página)
Modifique y agregue el siguiente código:
<%@ page contentType="text/html;charset=windows-1252"%>
<html>
<head>
<title>Registro de Usuario</title>
</head>
<body>
<h1>Registro de Usuario</h1>
<jsp:useBean id="usr" class="Paquetes.Usuario" scope="session">
<jsp:setProperty name="usr" property="*"/>
</jsp:useBean>
Bienvenido nuevo Usuario, los valores ingresados son:
<p>Login de Usuario: <%= usr.getLoginUsuario() %></p>
<p>Sus nombres: <%= usr.getNombresUsuario() %></p>
<p>Sus apellidos: <%= usr.getApellidosUsuario() %></p>
<p>Su Edad: <%= usr.getEdad() %></p>
Usted esta interesado en las siguientes Carreras:
<%
String[] carreras = request.getParameterValues("carreras_interes");
if (carreras == null) { carreras = new String[] {"Ninguna carrera"}; }
for (int i=0; i < carreras.length; i++)
{
out.println("<br>"+ carreras[i]);
}
%>
<p>Ir a: <a href="Bienvenido.jsp ">Pagina de Bienvenida</a></p>
<%@ include file="/WEB-INF/PiePagina.jspf" %>
</body>
</html>
6.- Modifique la página Bienvenido.jsp, para que verifique si el usuario esta o no registrado:
import="java.util.Iterator,Paquetes.*"%>
<html>
<head>
<title>Pagina de Bienvenida Universidad XXX</title>
</head>
<body>
<P> </P>
<P> </P>
<%
Usuario usr = (Usuario) session.getAttribute("usr");
if (usr == null)
{
%>
Usted no esta registrado en el sistema, por favor <a href="FormRegistro.html">registrese</a>
<%
} else {
%>
<%
{
%>
<p>
</p>
<%
}
%>
<%
}
%>
</body>
</html>
<%!
{
}
%>
7.- Compile toda la aplicación: Build Make Universidad.jpr
8.- A continuación, se ejecutara la pagina JSP principal.
9.- Probar la aplicación, abriendo una ventana en el Navegador, usando la dirección:
http://localhost/Capitulo2-Universidad-context-root/Bienvenido.jsp
Ejercicio 3
En este ejercicio veremos el manejo de errores y excepciones, inclusión y
redireccionamiento de páginas, expresiones EL, manejo de Librería de Tags con acceso a
base de Datos.
1.- Crear la página de error cuando la aplicación no encuentre una pagina (PaginaInexistente.jsp):
Seleccione: Universidad Web Content WEB-INF
File Name: PaginaInexistente.jsp
2.- Del panel central seleccione el tabpage PaginaInexistente.jsp, realice lo siguiente:
<html>
<head>
<title>Pagina Inexistente</title>
</head>
<body>
<h1>Pagina Inexistente</h1>
Usted trato de ingresar a una pagina que no existe en la aplicacion
o que no esta habilitada.
Ingrese a la pagina de <a href="Bienvenido.jsp">Bienvenida</a>
<p>Si hace click en uno de sus enlaces y le sale esta pagina la misma
esta deshabilitada temporalmente. Trate mas tarde.
</body>
</html>
3.- Crear la página de error cuando la aplicación produzca un error numerico (ErrorNumerico.jsp):
Ingrese a: File New Categoría: Web Tier JSP JSP
File Name: ErrorNumerico.jsp
4.- Del panel central seleccione el tabpage ErrorNumerico.jsp, realice lo siguiente:
<html>
<head>
<title>Error Numerico</title>
</head>
<body>
<h1>Error Numerico</h1>
La aplicacion genero un error numerico en alguna operacion aritmetica
Solo digitos numericos son permitidos.
</body>
</html>
5.- Crear la pagina de la carrera de Ingenieria Industrial (Ingenieria_Industrial.jsp), en la misma

generaremos un error numérico para mostrar el control de este tipo de excepciones.
Ingrese a: File New Categoría: Web Tier JSP JSP
File Name: Ingenieria_Industrial.jsp
6.- Del panel central seleccione el tabpage Ingenieria_Industrial.jsp, realice lo siguiente:
<html>
<head>
<title>Carrera de Ingenieria Industrial</title>
</head>
<body>
<h1>Carrera de Ingenieria Industrial</h1>
<p> Esta carrera tiene como objetivo .....
<% Integer i= new Integer("Inge"); %>
</body>
</html>
7.- Modifique el archivo web.xml (descriptor de implementación) para que la aplicación pueda
capturar los errores producidos cuando se produzca un error numérico o que no exista una pagina.
<?xml version = '1.0' encoding = 'windows-1252'?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
….
….
<error-page>
<exception-type>java.lang.NumberFormatException</exception-type>
<location>/WEB-INF/ErrorNumerico.jsp</location>
</error-page>
<error-page>
<error-code>404</error-code>
<location>/WEB-INF/PaginaInexistente.jsp</location>
</error-page>
</web-app>
8.- Ahora modificaremos la pagina Bienvenido.jsp, utilizando la tecnica del redireccionamiento para
llamar al formulario de registro de usuario (FormRegistro.html).
import="java.util.Iterator,Paquetes.*"%>
<%
Usuario usr = (Usuario) session.getAttribute("usr");
String reqTipo = request.getParameter("reqTipo");
if (usr == null && reqTipo == null)
{
%>
<jsp:forward page="FormRegistro.html" />
<%
} else if (usr== null && reqTipo != null)
{
%>
<jsp:forward page="Registro.jsp">
<jsp:param name = "fechaRegistro" value="<%= (new java.util.Date()).toString()%>"/>
</jsp:forward>
<%
}
%>
<html>
<head>
<title>Pagina de Bienvenida Universidad XXX</title>
</head>
<body>
<P> </P>
<P> </P>
<%
{
%>
<p>
</p>
<%
}
%>
</body>
</html>
<%!
{
}
%>
9.- Ahora modificamos el archivo FormRegistro.html para que el formulario de registro llame a la
pagina de bienvenida pero con el parámetro reqTipo= registro
<form action="Bienvenido.jsp?reqTipo=registro" method="POST">
10.- Ahora modificamos la pagina Registro.jsp para mostrar la fecha de registro del usuario
….
….
<p>Esta es la Fecha en la que se registro el usuario:
<%= request.getParameter("fechaRegistro") %>
<p>Ir a: <a href="Bienvenido.jsp?reqTipo=registrado">Pagina de Bienvenida</a></p>
11.- Ahora modificamos la pagina ErrorNumerico.jsp para que muestre el stack de error producido
de forma comprensible.
<%@ page contentType="text/html;charset=windows-1252" isErrorPage="true"%>
<html>
<head>
<title>Error Numerico</title>
</head>
<body>
<h1>Error Numerico</h1>
La aplicacion genero un error numerico en alguna operacion aritmetica
Solo digitos numericos son permitidos.
<p> Este es el Stack de Errores
<p><% request.setAttribute("ex",exception); %>
<jsp:include page="/WEB-INF/StackTrace.jsp"/>
</body>
</html>
12.- Creamos la página StackTrace.jsp:

File Name: StackTrace.jsp
El codigo de la pagina es:
<%@ page contentType="text/html;charset=windows-1252" import="java.io.PrintWriter"%>
<%
out.println("<pre>");
Throwable stack = (Throwable) request.getAttribute("ex");
if(stack != null)
{
stack.printStackTrace(new PrintWriter(out));
}
out.println("</pre>");
%>
13.- Compile toda la aplicación: Build Make Universidad.jpr y ejecute la pagina JSP principal.
Probar la aplicación, abriendo una ventana en el Navegador, usando la dirección:
14.- Seguidamente utilizaremos JavaBeans y objetos implícitos para generar una pagina
dicanicamente. Para tal fin se creara un JavaBean que contenga en Pensum de la Carrera de
Ingeniería Agronómica (IngAgronomica.java).
Seleccione: Universidad Paquetes
Ingrese a: File New Categories: General Java Bean
Name: IngAgronomica
Package: Paquetes
Modifique el codigo de la clase:
package Paquetes;
import java.util.Map;
import java.util.HashMap;
public class IngAgronomica
{
private int numMaterias;
private Map ListaMaterias = new HashMap();
public Map getListaMaterias()
{
return ListaMaterias;
}
public void setListaMaterias(Map ListaMaterias)
{
this.ListaMaterias = ListaMaterias;
}
public int getNumMaterias()
{
return numMaterias;
}
public void setNumMaterias(int numMaterias)
{
this.numMaterias = numMaterias;
}
public IngAgronomica()
{
ListaMaterias.put(“IA-11101”,”BOTANICA GENERAL”);
ListaMaterias.put(“IA-11706”,”FISICA GENERAL”);
ListaMaterias.put(“IA-11807”,”QUIMICA GENERAL E INORGANICA”);
ListaMaterias.put(“IA-12102”,”BOTANICA SISTEMATICA”);
ListaMaterias.put(“IA-12601”,”TOPOGRAFIA Y DIBUJO TECNICO”);
ListaMaterias.put(“IA-11204”,”QUIMICA ORGANICA”);
setNumMaterias(ListaMaterias.size());
}
}
15.- Ahora se creara la página de Pensum de Materias para la Carrera de Ingeniería Agronómica
(Ingenieria_Agronomica.jsp).
File Name: Ingenieria_Agronomica.jsp
<%@ page contentType="text/html;charset=windows-1252" import="java.util.*" %>
<html>
<head>
<title>Pensum Carrera de Ingenieria Agronomica</title>
</head>
<body>
<h1>Pensum Carrera de Ingenieria Agronomica</h1>
<jsp:useBean id="pensum" class="Paquetes.IngAgronomica" scope="page"/>
<p>Lista de Materias (<%= pensum.getNumMaterias() %>):</p>
<%
Set materias = pensum.getListaMaterias().entrySet();
for (Iterator i = materias.iterator(); i.hasNext();)
{
Map.Entry m = (Map.Entry)i.next();
Object cod_materia = m.getKey();
Object nom_materia = m.getValue();
pageContext.setAttribute("cod_materia",cod_materia.toString() );
pageContext.setAttribute("nom_materia",nom_materia.toString() );
%>
<p><a href="Pensum.jsp?materia=<%= pageContext.getAttribute("cod_materia") %> ">
<%= pageContext.getAttribute("cod_materia") %>
<%= pageContext.getAttribute("nom_materia") %></a>
<%
}
%>
</body>
16.- Ahora crearemos una Libreria de Tags, para utilizarlo en nuestras paginas JSP de tal manera
que se construirá una pagina dinámica con el tag (taglib_varios.tld).
Ingrese a: File New Categories: Web Tier JSP JSP Tag Library
En la ventana Create Java Server Page Tag Library Step 1 of 5 Type, seleccione opcion:
Deployable
En la pagina Step 2 of 5 General Descriptor Information, ingrese:
Short Name: taglib_varios
Tag Library URI: /taglib_varios
Presionar Boton: Finish
(Se creara el archivo tablib_varios.tld en la carpeta META-INF del proyecto)
17.- A continuación crearemos un tag que permita desplegar la lista de Materias para la Carrera de
Medicina (pensumMedicina.java)
Seleccionar el archivo: taglib_varios.tld
Presionar click derecho
Seleccionar la opcion: New Tag
En la ventana Create JSP Tag - Step 1 of 3 General Information, ingrese:
Tag Name: pensumMedicina
Tag Class: pensumMedicina
Package Name: Paquetes
Body Content: empty
En la pagina Create JSP Tag - Step 2 of 3 Code Generation, seleccione:
Extend Tag Class: Tag Support (Esta opcion permite crear una tag simple)
En la pagina Create JSP Tag - Step 3 of 3 Tag Description, ingrese:
Display Name: pensumMedicina
Example: <x:pensumMedicina>
Presionar Boton: Finish
Modifique el codigo de la clase pensumMedicina.java
package Paquetes;
import java.util.Iterator;
import java.util.Set;
import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.PrintWriter;
public class pensumMedicina extends TagSupport

{
private int numMaterias;
private Map ListaMaterias = new HashMap();
/**
* Method called at start of tag.
* @return SKIP_BODY
*/
public int doStartTag() throws JspException
{
ListaMaterias.put("MD-12201","MEDICINA GENERAL");
ListaMaterias.put("MD-12306","ANATOMIA I");
ListaMaterias.put("MD-11501","FISIOLOGIA II");
ListaMaterias.put("MD-13108","QUIMICA ORGANICA");
ListaMaterias.put("MD-13456","QUIMICA INORGANICA");
numMaterias = ListaMaterias.size();
try
{
JspWriter out = pageContext.getOut();
out.write("<p>Lista de Materias (" + numMaterias +"):</p>");
Set materias = ListaMaterias.entrySet();
for (Iterator i = materias.iterator(); i.hasNext();)
{
Map.Entry m = (Map.Entry)i.next();
Object cod_materia = m.getKey();
Object nom_materia = m.getValue();
out.write("<p><a href=\"Pensum.jsp?materia=" + cod_materia.toString() + "\">" +
cod_materia.toString() + " " +
nom_materia.toString() + "</a>");
}
}
catch(Exception e)
{
throw new JspException("Error al escribir");
}
return SKIP_BODY;
}
/**
* Method called at end of tag.
* @return EVAL_PAGE
*/
public int doEndTag()
{
return EVAL_PAGE;
}
}
18.- A continuaron se implementara la Librería de Tags en un archivo Jar (taglib_varios.jar)
Seleccione:Universidad
Presione click derecho.
Seleccione la opción: Deploy taglib_varios…
Presione botón: Finish
Se creara un archivo JAR en la ruta
D:\Curso_J2EE\Capitulo2\Universidad\deploy\taglib_varios.jar
19.- Luego de crear la Librería de Tags, se debe registrar la misma como una librería del proyecto
Universidad para lo cual debe realizar los siguientes pasos:
Ingrese a: Application Project Properties
Seleccione opción : JSP Tag Libraries
Presione de la lista JSP Tag Libraries el botón: Add
De la lista Choose Tag Libraries, seleccione opción Project
Seleccione archivo: D:\Curso_J2EE\Capitulo2\Universidad\deploy\taglib_varios.jar
Presionar botón: OK
(Notara que en la lista JSP Tag Libraries se adiciono el item taglib_varios 1.0
Presione botón: OK
20.- Ahora se creara la página de Pensum de Materias para la Carrera de Medicina (Medicina.jsp).
File Name: Medicina.jsp
Modifique el codigo de la pagina a:
<%@ taglib uri="/taglib_varios" prefix="med"%>
<html>
<head>
<title>Carrera de Medicina</title>
</head>
<body>
<h1>Carrera de Medicina</h1>
<med:pensumMedicina></med:pensumMedicina>
</body>
</html>
Probar la aplicación, abriendo una ventana en el Navegador, usando la dirección:
Debera ingresar a la pagina del Pensum de Medicina
22.- Finalmente utilizaremos lenguaje de expresiones EL y tags de la librería JSTL, para acceder a
una base de datos y recuperar información del pensum de la carrera de Enfermeria
(Enfermeria.jsp). Debemos asumir que tenemos creada una conección a una base de datos Oracle
en JDeveloper, en la misma se deberá crear la tabla MATERIAS con la siguiente estructura:
CREATE TABLE materias
(carrera VARCHAR2(20) NOT NULL,
cod_materia VARCHAR2(20) NOT NULL,
nom_materia VARCHAR2(60) NOT NULL);
Nota.- Utilizar los scripts materia.sql y datos_materias.sql, para crear y llenar dos registros
A continuación crearemos la pagina Enfermeria.jsp
File Name: Enfermeria.jsp
Agregue el siguiente código:
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql"%>
<html>
<head>
<title>Carrera de Enfermeria</title>
</head>
<body>
<h1>Pensum Carrera de Enfermeria</h1>
<sql:setDataSource dataSource="jdbc:oracle:thin:@localhost:1521:HOME,oracle.jdbc.driver.OracleDriver,hr,hr"
user="hr" password="hr" scope="page" var="ds"/>
<sql:query scope="page" dataSource="${ds}" var="qTotal" maxRows="1">
select count(*) total from materias where carrera='ENFERMERIA'
</sql:query>
<c:forEach var="n" items="${qTotal.rows}">
<p>Lista de Materias (<c:out value='${n.total}'/>):</p>
</c:forEach>
<sql:query scope="page" sql="select cod_materia,nom_materia from materias where carrera='ENFERMERIA'"
dataSource="${ds}" var="qEnfermeria"></sql:query>
<c:forEach var="i" items="${qEnfermeria.rows}">
<p><a href="Pensum.jsp?materia=<c:out value='${i.cod_materia}' />">
<c:out value='${i.cod_materia}' />
<c:out value='${i.nom_materia}' /></a>
</c:forEach>
</body>
</html>
Registre las librerías JSTL Core 1.2 y JSTL Sql 1.2 en el proyecto Universidad:
Ingrese a: Application Project Properties
Seleccione opción JSP Tag Libraries
Seleccione las librerias JSTL Core 1.2 y JSTL Sql 1.2
Presione botón: OK
Probamos la aplicación con:
En este caso deberá aparecer la página de la carrera de Enfermeria con los datos de la tabla
MATERIAS.
Servlets
Ejercicio 4
El objetivo de este ejercicio es el de crear una aplicación que permita implementar una
pantalla de Login de usuario. Para tal fin se creara una aplicación y un nuevo proyecto.
1.- Crear una nueva Aplicacion (Capitulo3.jws) y un nuevo proyecto (Login.prj)

Application New
Application Name: Capitulo3
Directory Name: D:\Curso_J2EE\Capitulo3
Application Template: Generic Application
Presione botón: Next
Project Name: Login
Directory Name: D:\Curso_J2EE\Capitulo3\Login
Seleccione las siguientes tencologias a utilizar en el proyecto: HTLM, Java, JSP y Servlets
Presionar botón: Finish
2.- Crear la lista de usuarios validos para la aplicación (usuariosValidos.java)

File New Categories: General Java Java Class
Name: usuariosValidos
Package: Paquetes
Presionar botón: OK
Modificar el codigo:
package Paquetes;
public class usuariosValidos

{
private Map usrValidos = new HashMap();
public usuariosValidos()
{
usrValidos.put("JVARGAS",new String[]{"JUAN VARGAS","X2345"});
usrValidos.put("MZARABIA",new String[]{"MIKAELA ZARABIA","MKAB23"});
usrValidos.put("HGOMEZ",new String[]{"HECTOR GOMEZ","HG3456"});
usrValidos.put("DSALAS",new String[]{"DANIEL SALAS","DN2006"});
}
public Map getUsuariosValidos()
{
return usrValidos;
}
}
3.- Crear el Servlet Login.java
File New Categories: Web Tier Servlets HTTP Servlet
En la ventana Web Application seleccione la opcion: Servlet 2.5\JSP 2.1 (Java EE1.5)
Presionar boton: Next
Class: Login
Package: Paquetes
Generate Content Type: HTML
doGet() chequeado
doPost() chequeado()
En la ventana Create HTTP Servlet – Step 2 of3: Mapping Information, ingrese:
Specify a name and mapping for the servlet: chequeado
Name: Login
URL Pattern: /Login
Presionar botón: Next
En la ventana Create HTTP Servlet – Step 3 of3: Servlet Parameters, ingrese:
Name: Type: Variable:
usuario String usuario
password String password
Presionar boton: Finish
Modifique el codigo del Servlet:
package Paquetes;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.IOException;
public class Login extends HttpServlet

{
private static final String CONTENT_TYPE = "text/html; charset=windows-1252";
public void init(ServletConfig config) throws ServletException
{
super.init(config);
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
IOException
{
String usuario = "";
String password = "";
String[] usr_validado;
try
{
usuario = request.getParameter("usuario");
password = request.getParameter("password");
response.setContentType(CONTENT_TYPE);
PrintWriter out = response.getWriter();
Map lista_usuarios = (new usuariosValidos()).getUsuariosValidos();

usr_validado=(String[])lista_usuarios.get(usuario.toUpperCase());
if (usr_validado==null)
{ //Cuenta de usuario no existe
out.println("<html>");
out.println("<body>");
out.println("<p>Lo siento usuario no autorizado para utilizar la aplicacion.</p>");
out.println("</body></html>");
out.close();
return;
}
if (!password.toUpperCase().equals(usr_validado[1]))
{ //Password invalido
out.println("<p>Lo siento password incorrecto, intente de nuevo.</p>");
out.close();
return;
}
//Todo correcto se crea el objeto sesion
HttpSession session = request.getSession(true);
session.setAttribute("usuario_sesion",usuario);
session.setAttribute("password_sesion",password);
session.setAttribute("nombre_sesion",usr_validado[0]);
out.println("<head><title>Login</title></head>");
out.println("<p>Gracias:"+ usuario +" Usted esta conectado correctamente a nuestro sistema.</p>");
String newURL = response.encodeURL("/Capitulo3/despliegaSesion");
out.println("Presione <a href=\"" + newURL + "\">aqui</a> para ver informacion de Login ");
out.close();
}
catch(Exception e)
{
e.printStackTrace();
}
}
public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException,
IOException
{
this.doGet(request,response);
}
}
4.- Crear el Servlet que desplegara los valores de la sesion DespliegaSesion.java
File New Categories: Web Tier Servlets HTTP Servlet
Class: despliegaSesion
Package: Paquetes
Generate Content Type: HTML
doGet() chequeado
Mapping Details:
Specify a name and mapping for the servlet: chequeado
Name: despliegaSesion
URL Pattern: /despliegaSesion
Modificar el codigo:
package Paquetes;
import java.util.Enumeration;
import javax.servlet.*;
import javax.servlet.http.*;
public class despliegaSesion extends HttpServlet

{
public void init(ServletConfig config) throws ServletException

{
super.init(config);
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
IOException
{
try
{
HttpSession session = request.getSession();
if(session == null)
{
out.println("Usted no esta conectado...");
}
else
{
out.println("<p>Estos son los datos de su loggin.</p>");
Enumeration parametros = session.getAttributeNames();
while(parametros.hasMoreElements())
{
String param = (String) parametros.nextElement();
Object valor = session.getAttribute(param);
out.println("<p> parametro=" + param + " valor=" + valor);
}
}
out.println("<p><a href=\"/Capitulo3/Login.html\">Retornar a la pagina de Login</a>");
out.close();
}
catch(Exception e)
{
}
}
}
5.- Finalmente se crea la pagina Login.html
File New Categories: Web Tier HTML HTTP Page
File Name: Login.html
Directory Name: D:\Curso_J2EE\Capitulo3\Login\public_html
Modificar el codigo Source de la pagina:
<html>
<head>
<meta HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=windows-1252"></meta>
<title>Login</title>
</head>
<body>
<h1>Login</h1>
Ingrese cuenta de usuario y password
<form action="/Capitulo3/Login" method="POST">
<p>Usuario:<input type="text" name="usuario" maxlength="40">
<p>Password:<input type="password" name="password" maxlength="40">
<p><input type="submit" value="Enviar">
</form>
</body>
</html>
6.- Ahora se cambiara el nombre de la aplicación Web y la ruta de acceso (context root) de todos
los elementos de la aplicación
Application Project Properties
Seleccione la opción: Java EE Application
Ingrese en la opción Java EE Application Name: Capitulo3
Ingrese en la opción Java EE Web Context Root: Capitulo3
7.- Abra el archivo web.xml y verifique la definicion de los servlets: Login y despliegaSesion.
8.- Compile toda la aplicación: Build Make Login.jpr y ejecute la pagina Login.html.
http://localhost/Capitulo3/Login.html
Ejercicio 5
En este ejercicio se implementaran dos filtros adicionales al servlet de Login de Usuario,
desarrollado en el anterior ejercicio, el primer filtro verificara que la longitud de login de
usuario contenga siempre caracteres alfabeticos y su longitud sea mayor a 4 caracteres, y
el segundo filtro verificara que el password tenga por lo menos un carácter alfabetico y un
carácter numerico.
1.- Crear el filtro LoginA:

Capitulo3 Login
File New Categories: Web Tier Servlets Servlet Filter
Presionar boton: OK
Filter Name: LoginA
Filter Classname: LoginA
Package: Paquetes
Seleccion de Map to Servlet or JSP la opcion: Login
Enter Filter Initialization Parameter(s): Lista Vacia
Modificar el Codigo :
package Paquetes;
import javax.servlet.ServletResponse;
import javax.servlet.Filter;
import javax.servlet.ServletException;
import javax.servlet.FilterConfig;
import javax.servlet.ServletRequest;
import javax.servlet.FilterChain;
public class LoginA implements Filter

{
private FilterConfig _filterConfig = null;
public void init(FilterConfig filterConfig) throws ServletException

{
_filterConfig = filterConfig;
}
public void destroy()

{
_filterConfig = null;
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException,
ServletException
{
//Aqui validamos que el login de usuario contenga solo caracteres alfabeticos
// y cuya longitud sea mayor a 4 caracteres
String usuario = "";
try
{
usuario = request.getParameter("usuario");
if(!verificaDatoAlfabetico(usuario))
{
out.println("<p>Lo siento el login de usuario:" + usuario + " debe contener datos alfabeticos.</p>");
out.close();
return;
}
if(usuario.length()<4)
{
out.println("<p>Lo siento el login de usuario:" + usuario + " debe contener por lo menos 4 digitos.</p>");
out.close();
return;
}
chain.doFilter(request, response);
}
catch(Exception e)
{
}
}
private boolean verificaDatoAlfabetico(String cadena)

{
for(int i=0;i<cadena.length();i++)
{
char c = cadena.toUpperCase().charAt(i);
if(!(c>=65 && c<=90)) return false;
}
return true;
}
}
2.- Crear el filtro LoginB:

Capitulo3 Login
File New Categories: Web Tier Servlets Servlet Filter
Presionar boton: OK
Filter Name: LoginB
Filter Classname: LoginB
Package: Paquetes
Seleccion de Map to Servlet or JSP la opcion: Login
Enter Filter Initialization Parameter(s): Lista Vacia
Modificar el Codigo :
package Paquetes;
import javax.servlet.ServletResponse;
import javax.servlet.Filter;
import javax.servlet.ServletException;
import javax.servlet.FilterConfig;
import javax.servlet.ServletRequest;
import javax.servlet.FilterChain;
public class LoginB implements Filter

{
private FilterConfig _filterConfig = null;
public void init(FilterConfig filterConfig) throws ServletException

{
_filterConfig = filterConfig;
}
public void destroy()

{
_filterConfig = null;
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException,
ServletException
{
//Aqui validamos que el password contenga al menos un digito alfabetico y numerico
String password = "";
try
{
password = request.getParameter("password");
if(!verificaDatoAlfabeticoNumerico(password))
{
out.println("<p>Lo siento el password:" + password + " debe contener un dato alfabetico y uno
numerico.</p>");
out.close();
return;
}
chain.doFilter(request, response);
}
catch(Exception e)
{
}
}
private boolean verificaDatoAlfabeticoNumerico(String cadena)

{
int alfabetico=0,numerico=0;
for(int i=0;i<cadena.length();i++)
{
char c = cadena.toUpperCase().charAt(i);
if((c>=65 && c<=90)) alfabetico++;
else if((c>=48 && c<=57)) numerico++;
}
if(alfabetico>0 && numerico>0) return true;
return false;
}
}
3.- Abra el archivo web.xml y verifique la definicion de los servlets: LoginA y LoginB.
4.- Compile toda la aplicación: Build Make Login.jpr y ejecute la pagina Login.html.
http://localhost/Capitulo3/Login.html
Enterprise Java Beans EJB 3.0

Ejercicio 6
Creacion de un Session Bean sin estado.
1.- Crear una nueva aplicacion (Capitulo4-1.jws) y un nuevo proyecto (Bean.prj)
Aplication New
Application Name: Capitulo4-1
Directory Name: D:\Curso_J2EE\Capitulo4-1
Application Template: Generic Application
Presionar botón: Next
Project Name: Bean
Directory: D:\Curso_J2EE\Capitulo4-1\Bean
Seleccione las siguientes tecnologías de la lista Project Technologies: EJB, Java,
Swing/AWT.
Presionar: Finish
2.- Crear un Session Bean llamado ListaAlumnos
Seleccionar proyecto: Bean
Ingresar a: FileNewCategories: Bussiness Tier EJB Session Bean (Se invocara al
Wizard de creación de EJB)
EJB Name: ListaAlumnos
Session Type: Stateless
Transaction Type: Container
Mapped Name: ListaAlumnos
Bean Class: Paquetes.ListaAlumnosBean
Source Directory: D:\Curso_J2EE\Capitulo4-1\Bean\src
Implement a Remote Interface: Chequeado
Remote Interface: Paquetes.ListaAlumnos
Implement a Local Interface: Chequeado
Local Interface: Paquetes.ListaAlumnosLocal
(El wizard les desplegara la estructura de creación del session bean)
Nota.- Notara que el wizard creo en Paquetes el session bean ListaAlumnosBean.java, y dos
interfaces ListaAlumnos.java (interface remota) y ListaAlumnosLocal.java (interface local)
3.- A continuacion, se definirán 3 metodos de negocio que permitirán inicializar una lista de
alumnos de tipo vector, llenar la lista de alumnos y finalmente recuperar dicha lista para que el
cliente la despliegue. Todas estas operaciones se las realizara a partir de la clase bean
ListaAlumnosBean.java
Selecione la clase Bean: BeanPaquetesListaAlumnosBean.java
En la ventana de estructura de la clase seleccione: ListaAlumnosBean
Presione click derecho
Seleccione la opción: EJB(N) New Method…
En la ventana Bean Method Details ingrese:
Name: initListaAlumnos
Return Type: void
Marque opción: Expose through Local interface
Marque opción: Expose through Remote interface
Presione botón: OK
De la misma forma crear dos métodos llamados:
setListaAlumnos con Return Type: void
getListaAlumnos con Return Type: java.util.Vector
(No olvide marcar Expose through Local y Remote interface)
Modifique y agregue el código de ListaAlumnosBean.java de la siguiente forma:

package Paquetes;
import javax.ejb.Local;
import javax.ejb.Remote;
import javax.ejb.Stateless;
@Stateless(name = "ListaAlumnos", mappedName = "ListaAlumnos")

@Remote
@Local
public class ListaAlumnosBean implements ListaAlumnos, ListaAlumnosLocal {
private Vector alumnos;
public ListaAlumnosBean() {
alumnos = new Vector();
}
public void initListaAlumnos() {

alumnos.clear();
}
public void setListaAlumnos() {

alumnos.add("Juan Daniel Vargas");
alumnos.add("Isabel Gomez Loayza");
alumnos.add("Pedro Alvarez");
alumnos.add("Julia Beatriz Maldonado");
alumnos.add("Marco Antonio Agreda");
alumnos.add("Vilma Escalante");
alumnos.add("Erick Reyes");
}
public Vector getListaAlumnos() {

return alumnos;
}
}
4.- Compile toda la aplicación: Build Make Bean.jpr y ejecute el sesión bean
ListaAlumnosBean.java.
5.- A continuación creamos un Cliente Swing/AWT que invoque al session bean (ClienteEJB.java)
Ingrese a: FileNewCategories: Client Tier Swing/AWT Frame
Name: ClienteEJB
Package: Cliente
Extends: javax.swing.JFrame
Title: Cliente Swing para Bean ListaAlumnos
Presionar boton: OK
Añada al Frame los componentes Swing: un JList, un JLabel y 3 Botones de tal forma que
aparezca con la siguiente apariencia:
6.- Ahora se añadira un metodo para recuperar el contexto inicial del bean (getInitialContext), a
traves de una coneccion al servidor de aplicaciones Web Logic, se usara el protocolo RMI para tal
efecto, tambien se crearan variables privadas para manejar el bean y se inicializara el contexto de
busqueda del bean.
Seleccionar clase: ClienteEJB.java
Seleccionar modo: Source (codigo fuente)
En la parte superior de la clase, seccion imports, añadir el siguiente codigo:
import java.util.Hashtable;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
Luego al final de la clase añadir el siguiente metodo:
private static Context getInitialContext() throws NamingException {
Hashtable env = new Hashtable();
// WebLogic Server 10.x connection details
env.put( Context.INITIAL_CONTEXT_FACTORY, "weblogic.jndi.WLInitialContextFactory" );
env.put(Context.PROVIDER_URL, "t3://127.0.0.1:7101");
return new InitialContext( env );
}
Se crearan variables de contexto y de interface para el bean:
public class ClienteEJB extends JFrame
{
private XYLayout xYLayout1 = new XYLayout();
private JLabel jLabel1 = new JLabel();
….
private Context context;
private ListaAlumnos listaAlumnos;
…
Se inicializaran estas variables del bean en el metodo constructor de la clase:
public ClienteEJB() {
try {
jbInit();
context = getInitialContext();
listaAlumnos = (ListaAlumnos)context.lookup("ListaAlumnos#Paquetes.ListaAlumnos");
} catch (Exception e) {
}
}
7.- A continuación se programará el boton “Inicializar Lista” que invocara al metodo

initListaAlumnos del session bean.
Seleccionar modo: Design (vista de diseño de la clase ClienteEJB.java)
Presionar doble click sobre el boton: Inicializar Lista (button1)
Añadir el siguiente codigo al metodo button1_actionPerformed
private void jButton1_actionPerformed(ActionEvent e) {
try
{
// Se llama al metodo de inicializar la Lista
listaAlumnos.initListaAlumnos();
DefaultListModel modelo = new DefaultListModel();
jList1.setModel(modelo);
}
catch(Throwable ex)
{
ex.printStackTrace();
}
}
8.- Seguidamente se programará el boton “Setear Lista” que invocara al metodo setListaAlumnos
del session bean.
Presionar doble clic sobre el boton: Setear Lista (button2)
try
{
// Se llama al metodo de Seteo de la Lista
listaAlumnos.setListaAlumnos();
}
catch(Throwable ex)
{
}
}
9.- Seguidamente se programará el boton “Mostrar Lista” que invocara al metodo getListaAlumnos
del session bean.
Presionar doble clic sobre el boton: Setear Lista (button3)
try
{
// Se llama al metodo recuperar la Lista
Vector v=new Vector();
v=listaAlumnos.getListaAlumnos();
Iterator i = v.iterator();
DefaultListModel modelo = new DefaultListModel();
while (i.hasNext())
{
String c = (String) i.next();
modelo.addElement(c);
}
jList1.setModel(modelo);
}
catch(Throwable ex)
{
}
}
10.- Finalmente se construira una clase de tipo aplicación (AppCliente.java) el cual contendra el
metodo main e invocara a la clase ClienteEJB.java.
Ingresar a:FileNewCategories: Client TierSwing/AWTJava Application
Name: AppCliente
Package: Cliente
Add Default Frame: Chequeado
Existing Frame: Radio Group Seleccionado
Existing Frame: Cliente.ClienteEJB
Presionar boton: OK
11.- Ejecutar AppCliente.java
Ejercicio 7
Creación de un Session Bean con estado.
1.- Crear un Session Bean llamado CarritoComprasBean, que simulara las acciones de añadir,
eliminar y guardar información en un sistema de Carrito de Compras por Internet.
Ingresar a: FileNewCategories: Bussiness TierEJB Session Bean
EJB Name: CarritoCompras
Session Type: Stateful
Transaction Type: Container
Mapped Name: CarritoCompras
Bean Class: Paquetes.CarritoComprasBean
Source Directory: D:\Curso_J2EE\Capitulo4-1\Bean\src
Implement a Remote Interfaces: Chequeado
Implement a Local Interfaces: Chequeado
(El wizard les desplegara la estructura de creación del session bean)
2.- A continuacion, se definirán 5 metodos de negocio que permitirán interactuar con el Carrito de
Compras. Todas estas operaciones se las realizara a partir de la clase bean
CarritoComprasBean.java, de forma similar al anterior ejercicio:
public void addItem(String item);
public void removeItem(String item);
public Collection getItems();
public void confirmOrder();
public int totalItems();
Modifique y agregue el siguiente código en la clase CarritoComprasBean:
package Paquetes;
import java.util.ArrayList;
import java.util.Collection;
import javax.annotation.PostConstruct;
import javax.ejb.Remove;
import javax.ejb.Stateful;
@Stateful(name = "CarritoCompras", mappedName = "CarritoCompras")

@Remote
@Local
public class CarritoComprasBean implements CarritoCompras,
CarritoComprasLocal {
private ArrayList items;
@PostConstruct
public void initialize() {
items = new ArrayList();
}
public void addItem(String item) {
items.add(item);
}
public void removeItem(String item) {
items.remove(item);
}
public Collection getItems() {
return items;
}
@Remove
public void confirmOrder() {
//Aqui se coloca codigo para guardar los datos del
//session bean
}
public int totalItems() {
return items.size();
}
}
4.- Agrege a la aplicación la tecnología “JSP and Servlets”, ya que el cliente que invocara al sesión
bean será una pagina JSP. Luego creese una pagina JSP llamada CarritoCompras.jsp con el
siguiente código:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<%@ page contentType="text/html;charset=windows-1252"
import="Paquetes.CarritoComprasLocal,
javax.naming.Context,javax.naming.InitialContext,
javax.naming.NamingException,java.util.Collection, java.util.Iterator"%>
<%
CarritoComprasLocal carrito =
(CarritoComprasLocal) session.getAttribute("carritoCompras");
if (carrito == null) {
try {
InitialContext ctx = new InitialContext();
carrito = (CarritoComprasLocal) ctx.lookup("java:comp/env/ejb/local/CarritoCompras");
session.setAttribute ("carritoCompras", carrito);
e.printStackTrace ();
}
}
String operacion=(String) request.getParameter("operacion");
if (operacion==null) operacion="NULO";
if(operacion.equalsIgnoreCase("ADD"))
{
try {
String item=(String) request.getParameter("item");
carrito.addItem(item);
} catch (Exception ex) {
}
}
if(operacion.equalsIgnoreCase("REMOVE"))
{
try {
String item=(String) request.getParameter("item");
carrito.removeItem(item);
}
}
%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252"/>
<title>Carrito de Compras usando Statefull Session Beans</title>
</head>
<body>
<h1>Carrito de Compras usando Statefull Session Beans</h1>
<%
try {
Collection items = carrito.getItems();
out.println("<table border=1>");
out.println("<tr><td><b>Items en el Carrito ("+carrito.totalItems()+")</b></td></tr>");
for (Iterator i = items.iterator(); i.hasNext();) {
String item = (String) i.next();
out.println("<tr><td>"+item+"</td></tr>");
}
out.println("</table>");
}
%>
<form action="CarritoCompras.jsp" method="GET">
<input type="hidden" name="operacion" value="ADD"><br>
Item a Adicionar = <input type="text" name="item"><br>
<input type="submit" value="Adicionar">
</form>
<form action="CarritoCompras.jsp" method="GET">
<input type="hidden" name="operacion" value="REMOVE"><br>
Item a Eliminar = <input type="text" name="item"><br>
<input type="submit" value="Eliminar">
</form>
</body>
</html>
5.- Abra el archivo web.xml y añada la siguiente referencia para la interface local del session bean
CarritoCompras (esto permitirá a la página JSP realizar la búsqueda utilizando JNDI Lookup del
sesión bean, en los recursos habilitados del servidor WLS):
<?xml version = '1.0' encoding = 'windows-1252'?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
version="2.5" xmlns="http://java.sun.com/xml/ns/javaee">
<ejb-local-ref>
<ejb-ref-name>ejb/local/CarritoCompras</ejb-ref-name>
<ejb-ref-type>Session</ejb-ref-type>
<local>Paquetes.CarritoComprasLocal</local>
<ejb-link>CarritoCompras</ejb-link>
</ejb-local-ref>
</web-app>
6.- Compile toda la aplicación: Build Make Bean.jpr y ejecute la pagina JSP CarritoCompras.jsp.
Ejercicio 8
En este ejercicio, se creara una aplicación ABM (Altas-Bajas-Modificaciones), para la
tabla Carreras, se crearan un Session Bean, un Entity Bean, y una aplicación Swing/AWT
para el cliente.
1.- Crear una nueva Aplicacion (Capitulo4-2.jws) y un nuevo proyecto (ABM_Carreras.prj), que
incluya las tecnologías: EJB, Java, Swing/AWT, el paquete por defecto (default package) sea
modelo, la versión EJB sea la 3.0.
2.- Crear una coneccion a la Base de Datos Oracle
Seleccionar proyecto: ABM_Carreras
Del panel Application Resources seleccione: Connections
Presione click derecho y seleccione: New Connection Database
Connection Name: DBCOGNOS
Connection Type: Oracle (JDBC)
Username: <nombre_usuario>
Password: <password>
Host name: <Direccion IP Servidor BD>
JDBC Port: 1521
SID:<identificador de BD>
Presione botón: Test Connection
Si la coneccion es correcta saldrá el mensaje Success!
Presione botón: OK
3.- Crear un Entity Bean llamado Carreras_EB.
Seleccionar proyecto: ABM_Carreras
Ingresar a: FileNewCategories:Bussiness Tier EJB Entity Beans from Tables
En la ventana Create Entities From Tables – Step 3 of 8 seleccione opcion: Online En En la
ventana Create Entities From Tables – Step 4 of 8 en la opcion Connection seleccione:
DBCOGNOS
En la ventana Create Entities From Tables – Step 5 of 8 presionar boton: Query y
seleccione la tabla: CARRERAS
En la ventana Create Entities From Tables – Step 6 of 8 ingrese en Package Name:
modelo
Modifique el código de Carreras.java:
package modelo;
import java.io.Serializable;
import java.sql.Timestamp;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.SequenceGenerator;
@Entity
@NamedQueries({
@NamedQuery(name = "Carreras.findAll", query = "select o from Carreras o"),
@NamedQuery(name = "Carreras.findById", query = "select o from Carreras o where o.idCarrera=:pa_id"),
@NamedQuery(name = "Carreras.findByCarrera", query = "select o from Carreras o where
o.carrera=:pa_carrera")
})
@SequenceGenerator(name = "carrera_seq",sequenceName="CARR_SEQ",allocationSize=1)
public class Carreras implements Serializable {
@Column(nullable = false, unique = true, length = 20)
private String carrera;
@Column(name="DESC_CARRERA", length = 200)
private String descCarrera;
@Column(nullable = false, length = 50)
private String facultad;
@Column(name="FEC_CRE", nullable = false)
private Timestamp fecCre;
@Column(name="FEC_MOD")
private Timestamp fecMod;
@Id
@Column(name="ID_CARRERA", nullable = false)
@GeneratedValue(strategy = GenerationType.SEQUENCE,generator="carrera_seq")
private Long idCarrera;
@Column(name="USU_CRE", nullable = false, length = 30)
private String usuCre;
@Column(name="USU_MOD", length = 30)
private String usuMod;
public Carreras() {
}
public Carreras(String carrera, String descCarrera, String facultad,
Timestamp fecCre, Timestamp fecMod, Long idCarrera,
String usuCre, String usuMod) {
this.carrera = carrera;
this.descCarrera = descCarrera;
this.facultad = facultad;
this.fecCre = fecCre;
this.fecMod = fecMod;
this.idCarrera = idCarrera;
this.usuCre = usuCre;
this.usuMod = usuMod;
}
public String getCarrera() {
return carrera;
}
public void setCarrera(String carrera) {
this.carrera = carrera;
}
public String getDescCarrera() {
return descCarrera;
}
public void setDescCarrera(String descCarrera) {
this.descCarrera = descCarrera;
}
public String getFacultad() {
return facultad;
}
public void setFacultad(String facultad) {
this.facultad = facultad;
}
public Timestamp getFecCre() {
return fecCre;
}
public void setFecCre(Timestamp fecCre) {
this.fecCre = fecCre;
}
public Timestamp getFecMod() {
return fecMod;
}
public void setFecMod(Timestamp fecMod) {
this.fecMod = fecMod;
}
public Long getIdCarrera() {
return idCarrera;
}
public void setIdCarrera(Long idCarrera) {
this.idCarrera = idCarrera;
}
public String getUsuCre() {
return usuCre;
}
public void setUsuCre(String usuCre) {
this.usuCre = usuCre;
}
public String getUsuMod() {
return usuMod;
}
public void setUsuMod(String usuMod) {
this.usuMod = usuMod;
}
}
4.- Crear un Session Bean llamado Carreras_SBBean.java, de tipo Stateless, almacenado en el
paquete modelo, con interfaces Remotas, sin ningún método de negocio de fachada del entity bean
Carreras.java, pero con los siguientes métodos de negocio de usuario: addCarrera(),
updateCarrera(), delCarrera() y findCarrera(), con el siguiente código:
package modelo;
import java.sql.Timestamp;
import java.util.Date;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
@Stateless(name = "Carreras_SB", mappedName = "Carreras_SB")

@Remote
@Local
public class Carreras_SBBean implements Carreras_SB, Carreras_SBLocal {
@PersistenceContext(unitName="ABM_Carreras")
private EntityManager em;
public Carreras_SBBean() {
}
public Carreras addCarrera(Long idCarrera, String carrera, String facultad,

String descCarrera) {
Carreras adicionar = new Carreras();
adicionar.setIdCarrera(new Long(0)); //ID se calcula por un generador de secuencias
adicionar.setCarrera(carrera);
adicionar.setFacultad(facultad);
adicionar.setDescCarrera(descCarrera);
adicionar.setUsuCre("COGNOS");
Date dateValue = new Date();
Timestamp sqlDate = new Timestamp(dateValue.getTime());
adicionar.setFecCre(sqlDate);
em.persist(adicionar);
return adicionar;
}
public void delCarrera(Long idCarrera) {

Carreras borrar=((Carreras) em.find(Carreras.class, idCarrera));
em.remove(borrar);
}
public Carreras updateCarrera(Long idCarrera, String carrera, String facultad,

String descCarrera) {
Carreras actualizar=((Carreras) em.find(Carreras.class, idCarrera));
actualizar.setCarrera(carrera);
actualizar.setFacultad(facultad);
actualizar.setDescCarrera(descCarrera);
actualizar.setUsuMod("COGNOS");
Date dateValue = new Date();
Timestamp sqlDate = new Timestamp(dateValue.getTime());
actualizar.setFecMod(sqlDate);
em.merge(actualizar);
return actualizar;
}
public Carreras findCarrera(String carrera) {

return (Carreras) em.createNamedQuery("Carreras.findByCarrera").setParameter("pa_carrera",
carrera).getSingleResult();
}
public Carreras findCarrera(Long idCarrera) {

return (Carreras) em.createNamedQuery("Carreras.findById").setParameter("pa_id",
idCarrera).getSingleResult();
}
}
5.- Compile todo el proyecto y ejecute el sesión bean Carreras_SBBean.java, en el Servidor Web
Logic
6.- A continuación se creara un Cliente Swing/AWT que invoque al session bean (ClienteEJB.java),
este programa se almacenara en el paquete vista con el titulo “ABM para Carreras con EJB's” que
tendra la siguiente apariencia:
7.- Añada toda la funcionalidad necesaria para que el ClienteEJB.java interactue con los métodos
de negocio implementados en el sesión bean Carreras_SBBean.java (de forma similar al anterior
ejercicio). Esta funcionalidad consistiría en:
• Crear una variable local para instanciar la interface remota Carreras_SB.java
• Crear una variable local de la clase Carreras.java para almacenar la información del
registro actual que edita el usuario.
• Crear una rutina que permita instanciar el contexto inicial del ambiente EJB
getInitialContext()
• Instanciar la variable local creada para la interface remota, hacer una búsqueda JNDI del
sesión bean
• Crear la funcionalidad para los botones de Buscar, Adicionar, Modificar y Eliminar, como
ejemplo el botón Buscar tendrá la siguiente funcionalidad:
//Buscar Carrera
Long idCarrera = Long.parseLong(jTextField1.getText());
if (idCarrera == null || idCarrera == 0) {
JOptionPane.showMessageDialog(this,
"Es necesario ingresar el codigo de la Carrera");
return;
}
try {
registro = carrerasBean.findCarrera(idCarrera);
//Se muestra el registro
mostrarRegistro();
} catch (EJBException fe) {
if (fe.getCausedByException() instanceof NoResultException)
JOptionPane.showMessageDialog(this, "Registro no encontrado!");
else JOptionPane.showMessageDialog(this, "Error al recurperar registro! "+fe.getCause().getMessage());
}
}
11.- Finalmente se construira una clase de tipo aplicación (AppCliente.java) el cual contendra el
metodo main e invocara a la clase ClienteEJB.
12.- Ejecutar AppCliente.java
Ejercicio 9
En el ejercicio se creara una aplicación Maestro Detalle que despliegue la información
contenida en las tablas Departments (Departamentos) y Employees (Empleados).
1.- Crear una aplicación llamado Capitulo4-3.jws

2.- Crear un proyecto llamado ABM_empleados.prj
3.- Crear una coneccion a la Base de Datos Oracle llamado DBCOGNOS
4.- Crear dos entity beans para las tablas Departments y Employees utilizando EJB Wizard, en el
paquete llamado modelo, asegurese que se tiene activa la coneccion a la Base de Datos
COGNOS. El wizard creara dos POJOS llamados Departments.java y Employees.java.
Si edita Departments.java vera la definición de One-to-many:
@OneToMany(mappedBy = "departments")
private List<Employees> employeesList;
Modifique el mapeo a:
@OneToMany(mappedBy = "departments",fetch=FetchType.EAGER)
Si edita Employees.java vera la definición de:
@ManyToOne
@JoinColumn(name = "MANAGER_ID")
private Employees employees;
@OneToMany(mappedBy = "employees")
private List<Employees> employeesList;
@OneToMany(mappedBy = "employees")
private List<Departments> departmentsList;
@ManyToOne
@JoinColumn(name = "DEPARTMENT_ID")
private Departments departments;
5.- Crear un Sesion Bean llamado Servicio de tipo Stateless en el paquete modelo, que tenga como
referencia los entity beans Departments y Employees, haga que implemente los métodos de
fachada (persistencia por defecto de JPA) persist(), merge(), remove, getXXXFindAll(), e
implementa interfaces Locales y Remotas. El wizard creara los archivos Servicio.java,
ServicioBean.java y ServicioLocal.java.
6.- Ejecute el sesión bean ServicioBean.java en el Servidor Integrado Web Logic.
7.- Crear una clase JFrame llamada Cliente.java en un paquete llamado vista que invoque al sesión
bean ServicioBean.java por medio de la interfaz remota (Servicio.java). Despliegue la información
de Departamentos utilizando getDepartmentsFindAll() en un esquema de Formulario y utilize el
atributo employeesList para despliegar en una tabla los datos de Empleados. El siguiente grafico
muestra la construcción del mencionado frame:
8.- Crear una clase llamada EmployeeModel.java en el paquete vista, que permita definir el modelo
de datos de la tabla que desplegara la lista de empleados:
public class EmployeeModel extends AbstractTableModel {
protected Vector columnHeaders;
protected Vector tableData;
public EmployeeModel(List<Employees> dept) {

Vector rowData;
Iterator rset;
columnHeaders = new Vector(5);
tableData = new Vector();
columnHeaders.addElement("Emp");
columnHeaders.addElement("Primer Nombre");
columnHeaders.addElement("Segundo Nombre");
columnHeaders.addElement("Telefono");
columnHeaders.addElement("E-mail");
rset=dept.iterator();
while(rset.hasNext()){
Employees e = (Employees)rset.next();
rowData = new Vector(5);
rowData.addElement(e.getEmployeeId());
rowData.addElement(e.getFirstName());
rowData.addElement(e.getLastName());
rowData.addElement(e.getPhoneNumber());
rowData.addElement(e.getEmail());
tableData.addElement(rowData);
}
}
public int getRowCount() {

return tableData.size();
}
public int getColumnCount() {
return columnHeaders.size();
}
public Object getValueAt(int rowIndex, int columnIndex) {
Vector rowData = (Vector) tableData.elementAt(rowIndex);
return rowData.elementAt(columnIndex);
}
public boolean isCellEditable(int rowIndex, int columnIndex) {
return false;
}
public String getColumnName(int columnIndex){
return (String)columnHeaders.elementAt(columnIndex);
}
}
9.- Modifique Cliente.java para que incluya las siguientes variables de clase y métodos para
conectarse al sesión bean y mostrar la información en el formulario y tabla detalle:
private Context context; //Variable de Contexto
private Servicio servicio; //Variable del Stateless Session Bean Servicio.java
private List<Departments> deptList; //Lista de Departamentos

private Departments deptReg; //Registro actual de departamentos a mostrar
private int pDeptList; //Puntero al n-esimo registro de la lista de Departamentos
private List<Employees> empList; //Lista de Empleados
private static Context getInitialContext() throws NamingException {

Hashtable env = new Hashtable();
// WebLogic Server 10.x connection details
env.put( Context.INITIAL_CONTEXT_FACTORY, "weblogic.jndi.WLInitialContextFactory" );
env.put(Context.PROVIDER_URL, "t3://127.0.0.1:7101");
return new InitialContext( env );
}
private void MuestraDatos(){

//Recupera el registro activo
deptReg=(Departments)deptList.get(pDeptList);
//Se muestra datos del departamento
jTextField1.setText(deptReg.getDepartmentId().toString());
jTextField2.setText(deptReg.getDepartmentName());
jTextField3.setText(deptReg.getLocationId().toString());
//Se recupera datos de Empleados
empList=((Departments)deptList.get(pDeptList)).getEmployeesList();
//Se muestra datos de Empleados en la Tabla
EmployeeModel empModel=new EmployeeModel(empList);
jTable1.setModel(empModel);
}
Modifique el contructor de la clase Cliente.java para que realice la conneccion y muestre el primer
registro::
public Cliente() {
try {
jbInit();
LookAndFeel();
//Recuperamos el contexto inicial
context = getInitialContext();
//recuperamos el Session Bean Servicio
servicio = (Servicio)context.lookup("Servicio#modelo.Servicio");
//Se recupera datos de Departamentos
deptList=servicio.getDepartmentsFindAll();
//Ubicamos el puntero al primer registro
pDeptList=0;
//Se muestra los datos
MuestraDatos();
}
}
8.- Finalmente, crear una clase llamada AppCliente.java, que invoque a la clase Cliente.java.
Ejecute dicha clase, el resultado esperado es:
Nota.- Implemente la funcionalidad necesaria para los botones Primero, Anterior,
Siguiente, Ultimo.
Introducción al Oracle ADF
Ejercicio 10
Con este ejercicio se pretende rear una aplicación Web que permita administrar la Lista
Empleados de una Empresa, los componentes a utilizar seran:
• El Servicio de negocios de la aplicacion se basara en EJB 3.0
• Para la capa Modelo de la aplicación, se utilizara Bindings y Data Controls
• Para la capa Controlador se utilizara ADF Task Flow
• Para la capa Vista se utilizara ADF Faces y paginas JSF
1.- Crear una aplicación (Capitulo6.wks) de tipo Java EE Web Aplication

• El proyecto Model estará basado en la tecnología EJB
• El proyecto ViewController estará basado en paginas JSF, ADF Task Flow y DataBindings..
2.- Crear una coneccion de Base de Datos para la aplicación llama HRConn.
3.- Crear dos entity beans para las tablas Departments y Employees utilizando EJB Wizard, en el
paquete llamado modelo, asegurese que se tiene activa la coneccion a la Base de Datos HRConn.
4.- Crear un session bean llamado Servicio de tipo Stateless en el paquete modelo, que tenga
como referencia los entity beans Departments y Employees, haga que implemente los métodos de
fachada (persistencia por defecto de JPA) persist(), merge(), remove, getXXXFindAll(), e
implementa solo interfaces Locales. El wizard creara los archivos ServicioBean.java y
ServicioLocal.java.
5.- Crear el controlador de datos (Data Control) del framework “Bindings” de Oracle que permite
enlazar fácilmente los elementos del modelo de datos al modelo de la vista.
• Seleccione el sesión vean modelo.ServicioBean.java
• Presione click-derecho
• Seleccione opción: Create Data Control
• JDeveloper creara los siguientes archivos XML: Departaments.xml, Employees.xml,
ServicioLocal.xml
• Tambien vera que en la pagina Data Controls de la aplicación, se creo el Binding
ServicioLocal, desde este control se podrán enlazar facilemente los elementos del modelo
a elementos de la vista (solo realizando una operación drag-and-drop):
6.- Creación de la página principal de la aplicación, con Data Binding, JSF y ADF Task
• Seleccionar el proyecto: ViewController
• Seleccione el archivo: adfc-config.xml
• Presione doble-click
• Hacer un drag-and-drop del elemento View de la ventana Component Pallete al area de
edición de adfc-config.xml
• Cambiar el nombre del elemento a Principal.jspx
7.- Creación del flujo de tareas para listar, adicionar, editar y eliminar un empleado, aca
utilizaremos ADF Task Flow y DataBindings
• Seleccione: File New Tabpage: All Technologies Categories: Web Tier JSF
ADF Task Flow
• Presione botón: OK
• En la ventana Create Task Flow, ingrese en el campo File Name: flujoEmpleados.xml
• Directory: D:\Curso_J2EE\Capitulo6\ViewController\public_html\WEB-INF
• Presione botón: OK
• Haga un drag-and-drop del elemento View de la Paleta de Componentes a
flujoEmpleados.xml, coloque el nombre de ListaEmpleados
• Haga un drag-and-drop del elemento Router de la Paleta de Componentes a
flujoEmpleados.xml, coloque el nombre de EjecutarAccion
• Seleccione de la pagina Data Controls: ServicioLocal departmentsFindAll
EmployeesList Operations Create
• Haga un drag-and-drop a flujoEmpleados.xml
flujoEmpleados.xml, coloque el nombre de AdicionarEmpleado
flujoEmpleados.xml, coloque el nombre de EditarEmpleado
• Una los elementos creados con el elemento Control Flow Case de la Paleta de
Componentes, de tal forma que el diagrama resultante quede de la siguiente forma:
8.- Creación de la pagina ListaEmpleados.jsff.
• Editando el archivo: flujoEmpleados.xml
• Presione doble-click sobre el elemento ListaEmpleados
• En la ventana Create New JSF Page Fragmente ingrese:
o File Name: ListaEmpleados.jsff
o Directory: D:\Curso_J2EE\Capitulo6\ViewController\public_html
o Presionar boton: OK
• Editando el archivo ListaEmpleados.jsff
EmployeesList
• Haga un drag-and-drop a la pagina ListaEmpleados.jsff
• En el pop-up del drag-and-drop seleccionar la opcion: Master-DetailADF Master Form,
Detail Table.
• Mejore la apariencia de la tabla de Empleados, eliminando y reordenado las columna. Solo
deje las columnas employeeId, firstName, lastName, email, hireDate, jobId, phoneNumber,
salary en ese orden.
• Seguidamente insertar tres botones debajo de la tabla de Empleados, haciendo un drag-
and-drop de la Paleta de Componentes, luego cambie la propiedad Text de los mismos a:
Adicionar, Editar y Eliminar respectivamente.
• Posteriormente se dara la funcionalidad respectiva a dichos botones
9.- Ahora se definirán las acciones necesarias del Router EjecutarAccion

• Editando el archivo flujoEmpleados.xml
• Seleccione el Router: EjecutarAccion
• En la ventana de propiedades ingrese los casos de decisión del Router, estos casos se
basaran en la variable #{pageFlowScope.accion}, que será instanciada en la pagina de
ListaEmpleados.jspx, utilice el botón Add (+), de tal forma que esta propiedad que asi:
• Tambien coloque la propiedad Default Outcome a desconocido.
10.- Ahora se definirán las acciones necesarias para instanciar la variable

#{pageFlowScope.accion} y dar la funcionalidad necesaria a los botones Adicionar y Editar de la
paquina ListaEmpleados.jsff.
• Edite la pagina ListaEmpleados.jsff.
• Haga un drag-and-drop del elemento Set Property Listener de la Paleta de Componentes al
botón Adicionar
• En la ventana Insert Set Property Listener, ingreso en los campos:
o From : #{‘CREAR’}
o To: #{pageFlowScope.accion}
o Type: action
o Presione botón: OK
• Seleccione el botón Adcionar y coloque en la propiedad Action: ejecutar
• Haga un drag-and-drop del elemento Set Property Listener de la Paleta de Componentes al
botón Editar
• En la ventana Insert Set Property Listener, ingreso en los campos:
o From : #{‘EDITAR’}
o To: #{pageFlowScope.accion}
o Type: action
• Seleccione el botón Editar y coloque en la propiedad Action: ejecutar
11.- Creación de la pagina AdicionarEmpleado.jsff.

• Presione doble-click solbre el elemento AdicionarEmpleado.
• En la ventana Create new JSF Page Fragment ingrese:
o File Name: AdicionarEmpleado.jsff
EmployeesList
• Haga un drag-and-drop a la pagina AdicionarEmpleado.jsff
• En el pop-up del drag-and-drop seleccionar la opcion: FormADF Form.
• En la ventana Edit Form Fields, solo deje los campos employeeId, firstName. lastName,
departmentId, comissionPct, email, hireDate, jobId, phoneNumber, salary, createdBy,
createdDate (los demas campos borrelos con el boton Delete (X)).
• Seleccione ademas el check box: Include Submit Button
• Presione boton: OK
• A continuación se le dara la funcionalidad de grabar la información del formulario a la Base
de Datos utilizando el servicio persistEmployees para el botón submit.
o Seleccione de la pagina Data Controls: ServicioLocal
persistEmployees(Employees)
o Haga un drag-and-drop hacia el botón Submit
o En la ventana Edit Action Binding, seleccione el parámetro employees (Type:
modelo.Employees)
o En el parámetro Value ingrese:
#{bindings.employeesListIterator.currentRow.dataProvider}
12.- Creación de la pagina EditarEmpleado.jsff.

• Presione doble-click solbre el elemento EditarEmpleado.
• En la ventana Create new JSF Page Fragment ingrese:
o File Name: EditarEmpleado.jsff
EmployeesList
• Haga un drag-and-drop a la pagina EditarEmpleado.jsff
• En el pop-up del drag-and-drop seleccionar la opcion: FormADF Form.
• En la ventana Edit Form Fields, solo deje los campos employeeId, firstName. lastName,
departmentId, comissionPct, email, hireDate, jobId, phoneNumber, salary.
• Seleccione ademas el check box: Include Submit Button
• Presione boton: OK
• A continuación se le dara la funcionalidad de grabar la información del formulario a la Base
de Datos utilizando el servicio mergeEmployees para el botón submit.
o Seleccione de la pagina Data Controls: ServicioLocal
mergeEmployees(Employees)
o Haga un drag-and-drop hacia el botón Submit
o En la ventana Edit Action Binding, seleccione el parámetro employees (Type:
modelo.Employees)
o En el parámetro Value ingrese:
#{bindings.employeesListIterator.currentRow.dataProvider}
13.- Creación del archivo flujoEmpleados.xml como una región dentro el archivo Principal.jspx.
• Editando el archivo Principal.jspx
• Seleccione el archivo flujoEmpleados.xml, que se encuentra en la carpeta WEB-INF.
• Haga un drag-and-drop a la pagina Principal.jspx
• En el pop-up del drag-and-drop seleccionar la opcion: Region.
14.- Ejecute la página principal del proyecto

• Seleccione: Principal.jspx
• Presione click-derecho, selecione opción: Run
• Una vez construida la aplicación puede hacer la prueba abriendo una ventana de
navegador e ingresando la siguiente direccion URL:
o http://127.0.0.1:7101/Capitulo6-ViewController-context-root/faces/Principal.jspx
Nota.- Complete la aplicación implementando la operación de eliminacion de registro de empleado.

Guia Practicas Introduccion Desarrollo Web

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Guia Practicas Introduccion Desarrollo Web

Загружено:

Авторское право:

Доступные форматы

CURSO

INTRODUCCION AL DESARROLLO WEB

La versión con la cual se trabajara en el curso es la 11g, se recomienda seguir los

• Bajar JDeveloper 11g (versión 11.1.1.2.0) de http://otn.oracle.com/products/jdev.

• Instalar Oracle Fusion Middleware que es el nombre completo del producto

Copyright (c) 1997 Oracle Corporation. All rights reserved.

Used parameter files:

Used TNSNAMES adapter to resolve the alias

Test de Prueba “Hello J2EE World”

2.- Ahora se creara una aplicación Web:

3.- Ingresar un nombre para la aplicación y un directorio para el espacio de trabajo.

5.- A continuación se creará una Pagina JSP dentro el proyecto

9.- JDeveloper empezara a implementar o desplegar la aplicación usando el servidor integrado

Run startup time: 1078 ms.

Target URL -- http://127.0.0.1:7101/Capitulo1-ViewController-context-root/Hello.jsp

Java Server Pages

1.- Crear una nueva aplicación llamada Capitulo2:

public Iterator getAllCarreras()

9.- A continuación, se ejecutara la pagina JSP creada.

[Application Capitulo2 deployed to Server Instance IntegratedWebLogicServer]

Target URL -- http://127.0.0.1:7101/Capitulo2-Universidad-context-root/Bienvenido.jsp

public class Usuario

5.- Crear la pagina de la carrera de Ingenieria Industrial (Ingenieria_Industrial.jsp), en la misma

<form action="Bienvenido.jsp?reqTipo=registro" method="POST">

12.- Creamos la página StackTrace.jsp:

public class pensumMedicina extends TagSupport

1.- Crear una nueva Aplicacion (Capitulo3.jws) y un nuevo proyecto (Login.prj)

2.- Crear la lista de usuarios validos para la aplicación (usuariosValidos.java)

public class usuariosValidos

public class Login extends HttpServlet

Map lista_usuarios = (new usuariosValidos()).getUsuariosValidos();

public class despliegaSesion extends HttpServlet

public void init(ServletConfig config) throws ServletException

HttpSession session = request.getSession();

1.- Crear el filtro LoginA:

public class LoginA implements Filter

public void init(FilterConfig filterConfig) throws ServletException

public void destroy()

private boolean verificaDatoAlfabetico(String cadena)

2.- Crear el filtro LoginB:

public class LoginB implements Filter

public void init(FilterConfig filterConfig) throws ServletException

public void destroy()

private boolean verificaDatoAlfabeticoNumerico(String cadena)

Enterprise Java Beans EJB 3.0

Modifique y agregue el código de ListaAlumnosBean.java de la siguiente forma:

@Stateless(name = "ListaAlumnos", mappedName = "ListaAlumnos")

public void initListaAlumnos() {

public void setListaAlumnos() {

public Vector getListaAlumnos() {

7.- A continuación se programará el boton “Inicializar Lista” que invocara al metodo

@Stateful(name = "CarritoCompras", mappedName = "CarritoCompras")

@Stateless(name = "Carreras_SB", mappedName = "Carreras_SB")

public Carreras addCarrera(Long idCarrera, String carrera, String facultad,

public void delCarrera(Long idCarrera) {

public Carreras updateCarrera(Long idCarrera, String carrera, String facultad,

public Carreras findCarrera(String carrera) {

public Carreras findCarrera(Long idCarrera) {

1.- Crear una aplicación llamado Capitulo4-3.jws

6.- Ejecute el sesión bean ServicioBean.java en el Servidor Integrado Web Logic.

public EmployeeModel(List<Employees> dept) {

public int getRowCount() {

private List<Departments> deptList; //Lista de Departamentos

private static Context getInitialContext() throws NamingException {