Guia Practicas Introduccion Desarrollo Web

CURSOCURSOCURSOCURSO

INTRODUCCION AL INTRODUCCION AL INTRODUCCION AL INTRODUCCION AL DESARROLLO DESARROLLO DESARROLLO DESARROLLO WEBWEBWEBWEB

CON JDEVELOPER 11GCON JDEVELOPER 11GCON JDEVELOPER 11GCON JDEVELOPER 11G

Guia de PracGuia de PracGuia de PracGuia de Practttticasicasicasicas

ContenidoContenidoContenidoContenido

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 Directory Name: D:\Curso_J2EE\Capitulo2\Universidad\public_html\WEB-INF 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> <meta http-equiv="Content-Type" content="text/html; charset=windows-1252"> <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 Presione click derecho y seleccione la opción Run

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 Extends: java.lang.Object

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 Directory Name: D:\Curso_J2EE\Capitulo2\Universidad\public_html

3.- Del panel central seleccione el tabpage FormRegistro.html, realice lo siguiente:

Seleccione modo Source (vera el código fuente de la pagina) Modifique y agreque el siguiente código:

<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> <br><input type="checkbox" name="carreras_interes" value="Medicina">Medicina</input> <br><input type="checkbox" name="carreras_interes" 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: Seleccione: Universidad � Web Content Ingrese a: File � New � Categories: Web Tier � JSP � JSP

File Name: Registro.jsp Directory Name: D:\Curso_J2EE\Capitulo2\Universidad\public_html

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> <meta http-equiv="Content-Type" content="text/html; charset=windows-1252"> <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: <%@ page contentType="text/html;charset=windows-1252" errorPage="/WEB-INF/Error.jsp" import="java.util.Iterator,Paquetes.*"%> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=windows-1252"> <title>Pagina de Bienvenida Universidad XXX</title> </head> <body> <h1 align="center">Pagina de Bienvenida</h1> <h2 align="center">Universidad Santo Tomas</h2> <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 { %> 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.- Compile toda la aplicación: Build � Make Universidad.jpr 8.- A continuación, se ejecutara la pagina JSP principal.

Seleccione la pagina Bienvenido.jsp Presione click derecho y seleccione la opción Run

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 Ingrese a: File � New � Categories: Web Tier � JSP � JSP

File Name: PaginaInexistente.jsp Directory Name: D:\Curso_J2EE\Capitulo2\Universidad\public_html\WEB-INF

2.- Del panel central seleccione el tabpage PaginaInexistente.jsp, realice lo siguiente: Seleccione modo Source (vera el código fuente de la pagina) Modifique y agreque el siguiente código:

<%@ page contentType="text/html;charset=windows-1252"%> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=windows-1252"> <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. <%@ include file="/WEB-INF/PiePagina.jspf" %> </body> </html>

3.- Crear la página de error cuando la aplicación produzca un error numerico (ErrorNumerico.jsp): Seleccione: Universidad � Web Content � WEB-INF Ingrese a: File � New � Categoría: Web Tier � JSP � JSP

File Name: ErrorNumerico.jsp Directory Name: D:\Curso_J2EE\Capitulo2\Universidad\public_html\WEB-INF

4.- Del panel central seleccione el tabpage ErrorNumerico.jsp, realice lo siguiente: Seleccione modo Source (vera el código fuente de la pagina) Modifique y agreque el siguiente código:

<%@ page contentType="text/html;charset=windows-1252"%> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=windows-1252"> <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. <%@ include file="/WEB-INF/PiePagina.jspf" %> </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. Seleccione: Universidad � Web Content Ingrese a: File � New � Categoría: Web Tier � JSP � JSP

File Name: Ingenieria_Industrial.jsp Directory Name: D:\Curso_J2EE\Capitulo2\Universidad\public_html

6.- Del panel central seleccione el tabpage Ingenieria_Industrial.jsp, realice lo siguiente: Seleccione modo Source (vera el código fuente de la pagina) Modifique y agreque el siguiente código:

<%@ page contentType="text/html;charset=windows-1252"%> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=windows-1252"> <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).

<%@ page contentType="text/html;charset=windows-1252" errorPage="/WEB-INF/Error.jsp" 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> <meta http-equiv="Content-Type" content="text/html; charset=windows-1252"> <title>Pagina de Bienvenida Universidad XXX</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(' ','_'); } %>

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> <%@ include file="/WEB-INF/PiePagina.jspf" %>

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> <meta http-equiv="Content-Type" content="text/html; charset=windows-1252"> <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"/> <%@ include file="/WEB-INF/PiePagina.jspf" %> </body> </html>

12.- Creamos la página StackTrace.jsp: Seleccione: Universidad � Web Content � WEB-INF Ingrese a: File � New � Categories: Web Tier � JSP � JSP

File Name: StackTrace.jsp Directory Name: D:\Curso_J2EE\Capitulo2\Universidad\public_html\WEB-INF

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.

Seleccione la pagina Bienvenido.jsp Presione click derecho y seleccione la opción Run Probar la aplicación, abriendo una ventana en el Navegador, usando la dirección: http://localhost/Capitulo2-Universidad-context-root/Bienvenido.jsp

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 Extends: java.lang.Object

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). Seleccione: Universidad � Web Content Ingrese a: File � New � Categories: Web Tier � JSP � JSP

File Name: Ingenieria_Agronomica.jsp Directory Name: D:\Curso_J2EE\Capitulo2\Universidad\public_html

Modifique y agreque el siguiente código: <%@ page contentType="text/html;charset=windows-1252" import="java.util.*" %> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=windows-1252"> <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). Seleccione: Universidad 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.HashMap; import java.util.Iterator; import java.util.Map; 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: Seleccione: Universidad 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). Seleccione: Universidad � Web Content Ingrese a: File � New � Categories: Web Tier � JSP � JSP

File Name: Medicina.jsp Directory Name: D:\Curso_J2EE\Capitulo2\Universidad\public_html

Modifique el codigo de la pagina a: <%@ page contentType="text/html;charset=windows-1252"%> <%@ taglib uri="/taglib_varios" prefix="med"%> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=windows-1252"> <title>Carrera de Medicina</title> </head> <body> <h1>Carrera de Medicina</h1> <med:pensumMedicina></med:pensumMedicina> </body> </html>

21.- Compile toda la aplicación: Build � Make Universidad.jpr y ejecute la pagina JSP principal.

Seleccione la pagina Bienvenido.jsp Presione click derecho y seleccione la opción Run Probar la aplicación, abriendo una ventana en el Navegador, usando la dirección: http://localhost/Capitulo2-Universidad-context-root/Bienvenido.jsp

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 Seleccione: Universidad � Web Content Ingrese a: File � New � Categories: Web Tier � JSP � JSP

File Name: Enfermeria.jsp Directory Name: D:\Curso_J2EE\Capitulo2\Universidad\public_html

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"%> <%@ page contentType="text/html;charset=windows-1252"%> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=windows-1252"> <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 23.- Compile toda la aplicación: Build � Make Universidad.jpr y ejecute la pagina JSP principal. Probamos la aplicación con: http://localhost/Capitulo2-Universidad-context-root/Bienvenido.jsp 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 Extends: java.lang.Object Presionar botón: OK Modificar el codigo:

package Paquetes; import java.util.HashMap; import java.util.Map; 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() Presionar boton: Next 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 java.util.Map; import javax.servlet.*; import javax.servlet.http.*; import java.io.PrintWriter; 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("<html>"); out.println("<body>"); out.println("<p>Lo siento password incorrecto, intente de nuevo.</p>"); out.println("</body></html>"); 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("<html>"); out.println("<head><title>Login</title></head>"); out.println("<body>"); 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.println("</body></html>"); 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 Presionar boton: Next Mapping Details: Specify a name and mapping for the servlet: chequeado

Name: despliegaSesion URL Pattern: /despliegaSesion

Presionar boton: Finish Modificar el codigo:

package Paquetes; import java.util.Enumeration; import javax.servlet.*; import javax.servlet.http.*; import java.io.PrintWriter; import java.io.IOException; public class despliegaSesion 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 { try { response.setContentType(CONTENT_TYPE); PrintWriter out = response.getWriter(); HttpSession session = request.getSession(); out.println("<html>"); out.println("<body>"); 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.println("</body></html>"); out.close(); } catch(Exception e) { e.printStackTrace(); } } }

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. Probamos la aplicación con: 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 Presionar boton: Next Seleccion de Map to Servlet or JSP la opcion: Login Enter Filter Initialization Parameter(s): Lista Vacia Presionar boton: Finish Modificar el Codigo :

package Paquetes; import java.io.PrintWriter; import javax.servlet.ServletResponse; import javax.servlet.Filter; import javax.servlet.ServletException; import javax.servlet.FilterConfig; import javax.servlet.ServletRequest; import javax.servlet.FilterChain; import java.io.IOException; public class LoginA implements Filter { private FilterConfig _filterConfig = null; private static final String CONTENT_TYPE = "text/html; charset=windows-1252"; 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)) { response.setContentType(CONTENT_TYPE); PrintWriter out = response.getWriter();

out.println("<html>"); out.println("<body>"); out.println("<p>Lo siento el login de usuario:" + usuario + " debe contener datos alfabeticos.</p>"); out.println("</body></html>"); out.close(); return; } if(usuario.length()<4) { response.setContentType(CONTENT_TYPE); PrintWriter out = response.getWriter(); out.println("<html>"); out.println("<body>"); out.println("<p>Lo siento el login de usuario:" + usuario + " debe contener por lo menos 4 digitos.</p>"); out.println("</body></html>"); out.close(); return; } chain.doFilter(request, response); } catch(Exception e) { e.printStackTrace(); } } 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 Presionar boton: Next Seleccion de Map to Servlet or JSP la opcion: Login Enter Filter Initialization Parameter(s): Lista Vacia Presionar boton: Finish Modificar el Codigo :

package Paquetes; import java.io.PrintWriter; import javax.servlet.ServletResponse; import javax.servlet.Filter; import javax.servlet.ServletException; import javax.servlet.FilterConfig; import javax.servlet.ServletRequest; import javax.servlet.FilterChain; import java.io.IOException; public class LoginB implements Filter { private FilterConfig _filterConfig = null; private static final String CONTENT_TYPE = "text/html; charset=windows-1252"; 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)) { response.setContentType(CONTENT_TYPE); PrintWriter out = response.getWriter(); out.println("<html>"); out.println("<body>"); out.println("<p>Lo siento el password:" + password + " debe contener un dato alfabetico y uno numerico.</p>"); out.println("</body></html>"); out.close(); return; } chain.doFilter(request, response); } catch(Exception e) { e.printStackTrace(); } } 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. Probamos la aplicación con: 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: File�New�Categories: 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 Presionar boton: Next Bean Class: Paquetes.ListaAlumnosBean Source Directory: D:\Curso_J2EE\Capitulo4-1\Bean\src Presionar boton: Next Implement a Remote Interface: Chequeado Remote Interface: Paquetes.ListaAlumnos

Implement a Local Interface: Chequeado Local Interface: Paquetes.ListaAlumnosLocal

Presionar boton: Next (El wizard les desplegara la estructura de creación del session bean) Presionar boton: Finish 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: Bean�Paquetes�ListaAlumnosBean.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 java.util.Vector; 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) Seleccionar proyecto: Bean Ingrese a: File�New�Categories: 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 java.util.Vector; 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) { e.printStackTrace(); } }

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. Seleccionar modo: Design (vista de diseño de la clase ClienteEJB.java) Presionar doble clic sobre el boton: Setear Lista (button2) Añadir el siguiente codigo al metodo button2_actionPerformed

private void jButton2_actionPerformed(ActionEvent e) { try { // Se llama al metodo de Seteo de la Lista listaAlumnos.setListaAlumnos(); } catch(Throwable ex) { ex.printStackTrace(); } }

9.- Seguidamente se programará el boton “Mostrar Lista” que invocara al metodo getListaAlumnos del session bean. Seleccionar modo: Design (vista de diseño de la clase ClienteEJB.java) Presionar doble clic sobre el boton: Setear Lista (button3) Añadir el siguiente codigo al metodo button3_actionPerformed

private void jButton3_actionPerformed(ActionEvent e) { 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) { ex.printStackTrace(); } }

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. Seleccionar proyecto: Bean Ingresar a:File�New�Categories: Client Tier�Swing/AWT�Java Application Name: AppCliente Package: Cliente Extends: java.lang.Object 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. Seleccionar proyecto: Bean Ingresar a: File�New�Categories: Bussiness Tier�EJB � Session Bean EJB Name: CarritoCompras Session Type: Stateful Transaction Type: Container Mapped Name: CarritoCompras Presionar boton: Next Bean Class: Paquetes.CarritoComprasBean Source Directory: D:\Curso_J2EE\Capitulo4-1\Bean\src Presionar boton: Next Implement a Remote Interfaces: Chequeado Implement a Local Interfaces: Chequeado Presionar boton: Next (El wizard les desplegara la estructura de creación del session bean) Presionar boton: Finish

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.Local; import javax.ejb.Remote; 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); } catch (Exception e) { 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) { ex.printStackTrace(); } } if(operacion.equalsIgnoreCase("REMOVE")) { try { String item=(String) request.getParameter("item"); carrito.removeItem(item); } catch (Exception ex) { ex.printStackTrace(); } } %> <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>"); } catch (Exception ex) { ex.printStackTrace(); } %> <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: File�New�Categories: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 Presionar boton: Finish

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.Local; import javax.ejb.Remote; 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: private void jButton1_actionPerformed(ActionEvent e) { //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()); } catch (Exception ex) { ex.printStackTrace(); } }

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(); } catch (Exception e) { e.printStackTrace(); } }

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 • Haga un drag-and-drop del elemento View de la Paleta de Componentes a

flujoEmpleados.xml, coloque el nombre de AdicionarEmpleado

• Haga un drag-and-drop del elemento View de la Paleta de Componentes a 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 • Seleccione de la pagina Data Controls: ServicioLocal � departmentsFindAll �

EmployeesList

• Haga un drag-and-drop a la pagina ListaEmpleados.jsff • En el pop-up del drag-and-drop seleccionar la opcion: Master-Detail�ADF 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 o Presione botón: OK

• Seleccione el botón Editar y coloque en la propiedad Action: ejecutar 11.- Creación de la pagina AdicionarEmpleado.jsff.

• Editando el archivo flujoEmpleados.xml • Presione doble-click solbre el elemento AdicionarEmpleado. • En la ventana Create new JSF Page Fragment ingrese:

o File Name: AdicionarEmpleado.jsff o Directory: D:\Curso_J2EE\Capitulo6\ViewController\public_html o Presione botón: OK

• Seleccione de la pagina Data Controls: ServicioLocal � departmentsFindAll � EmployeesList

• Haga un drag-and-drop a la pagina AdicionarEmpleado.jsff • En el pop-up del drag-and-drop seleccionar la opcion: Form�ADF 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} o Presione botón: OK

12.- Creación de la pagina EditarEmpleado.jsff.

• Editando el archivo flujoEmpleados.xml • Presione doble-click solbre el elemento EditarEmpleado. • En la ventana Create new JSF Page Fragment ingrese:

o File Name: EditarEmpleado.jsff o Directory: D:\Curso_J2EE\Capitulo6\ViewController\public_html o Presione botón: OK

• Seleccione de la pagina Data Controls: ServicioLocal � departmentsFindAll � EmployeesList

• Haga un drag-and-drop a la pagina EditarEmpleado.jsff • En el pop-up del drag-and-drop seleccionar la opcion: Form�ADF 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} o Presione botón: OK

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

Documents

Transcript of Guia Practicas Introduccion Desarrollo Web