Detector de Musica

FACULTAD DE INGENIERIA
LENGUAJE DE PROGRAMACION II
Desarrollo Web con JAVA 2
Separata
Prof. Ing. Alberto Moreno
Separata
Desarrollo Web con Java 2
Indice
1 Fundamentos de Internet, HTML y
JavaScript 5
1.1 Objetivo .......................................................................................................................... 5
1.2 Internet ........................................................................................................................... 5
Historia ................................................................................................................................... 5
Internet vs Intranet .................................................................................................................. 5
Como Funciona Internet .......................................................................................................... 5
1.3 Documento HTML .......................................................................................................... 6
Qué es HTML? ....................................................................................................................... 6
Estructura de un documento HTML ......................................................................................... 6
Cabecera ................................................................................................................................ 6
Cuerpo del Documento ........................................................................................................... 6
Tablas ..................................................................................................................................... 7
Enlaces (Links) ....................................................................................................................... 7
Imágenes ................................................................................................................................ 7
Marcos .................................................................................................................................... 7
1.4 Trabajando con Formularios ......................................................................................... 7
Definición de Formularios ........................................................................................................ 7
Elementos cajas de texto ........................................................................................................ 8
Elementos opción múltiple ...................................................................................................... 8
Elementos opción única .......................................................................................................... 8
Elementos combos y listas ...................................................................................................... 8
Elementos botones ................................................................................................................. 9
Otros Controles ....................................................................................................................... 9
1.5 Fundamentos de Java Script ......................................................................................... 9
Requerimientos de Java Script ................................................................................................ 9
¿Qué es Java Script?.............................................................................................................. 9
Usando Java Script ................................................................................................................. 9
Elementos Básicos ................................................................................................................. 9
Tipos de Dato ....................................................................................................................... 10
Operadores ........................................................................................................................... 10
Sentencias de Control Java Script ......................................................................................... 10
Funciones Java Script ........................................................................................................... 11
Funciones PreDefinidas ........................................................................................................ 11
1.6 Laboratorio: .................................................................................................................. 11
2 Bases de Datos con JAVA 12

2.1 Objetivos ...................................................................................................................... 12
2.2 Qué es un JDBC? ......................................................................................................... 12
Tipos de Driver JDBC ........................................................................................................... 12
Drivers para principales RDBGS: .......................................................................................... 12
Drivers para principales RDBGS: .......................................................................................... 13
2.4 Conexión a un RDBMS ................................................................................................ 13
Objeto Connection ................................................................................................................ 13
Objeto Statement .................................................................................................................. 14
2.5 Ejecución de sentencias SQL ...................................................................................... 15
Objeto ResultSet ................................................................................................................... 15
Objeto PreparedStatement .................................................................................................... 17
Llamada a Procesos Almacenados ....................................................................................... 17
Ejecución y Control de Transacciones ................................................................................... 17
2.6 Manejo de Cursores JDBC 2.0 ..................................................................................... 18
2
Resumiendo.......................................................................................................................... 19
2.7 Laboratorio: .................................................................................................................. 19
Base de datos ....................................................................................................................... 19
Librería del Driver de Base Datos SQLServer........................................................................ 19
Conexión a la BD .................................................................................................................. 19
Bean Cheque ........................................................................................................................ 20
Lista de Objetos Cheque ....................................................................................................... 20
Mantenimiento de Data Cheque ............................................................................................ 20
3 Java Servlet 24
3.1 Objetivos ...................................................................................................................... 24
3.2 HTTP ............................................................................................................................. 24
Headers Request .................................................................................................................. 24
Métodos GET y POST.......................................................................................................... 26
3.3 Servlets......................................................................................................................... 26
Conceptos Fundamentales de un Servlet .............................................................................. 26
Características ...................................................................................................................... 26
Software para Servlet ............................................................................................................ 27
Estructura de un Servlet ........................................................................................................ 27
Ejemplo de un Servlet Básico ................................................................................................ 27
Ciclo de Vida de un Servlet ................................................................................................... 27
Comunicación con HTML ...................................................................................................... 27
Formularios y Servlet ............................................................................................................ 28
3.4 Laboratorio: .................................................................................................................. 29
Servlet de mantenimiento de Cheques .................................................................................. 29
4 Java Server Pages (JSP) 32

4.1 Objetivos ...................................................................................................................... 32
4.2 Concepto de JSP.......................................................................................................... 32
Características ...................................................................................................................... 32
Ventajas de un JSP............................................................................................................... 32
Arquitectura de un JSP ......................................................................................................... 32
4.3 Tags de un JSP --- Directiva ...................................................................................... 33
Directiva Page ...................................................................................................................... 33
Directiva Include ................................................................................................................... 34
4.4 Tags de un JSP --- Scripts ......................................................................................... 34
Expresiones .......................................................................................................................... 34
Scriplets ................................................................................................................................ 34
Declaraciones ....................................................................................................................... 34
4.5 Tags de un JSP --- Objetos Implícito ......................................................................... 35
Request ................................................................................................................................ 35
Response ............................................................................................................................. 35
Exception .............................................................................................................................. 35
Session ................................................................................................................................. 35
out ........................................................................................................................................ 35
page ..................................................................................................................................... 35
4.6 Tags de un JSP --- Acciones ..................................................................................... 35
Forward ................................................................................................................................ 35
Include .................................................................................................................................. 35
4.7 Programación con Java Beans.................................................................................... 35
4.8 Excepciones en JSP .................................................................................................... 37
Ejemplo ................................................................................................................................ 38
4.9 Laboratorio: .................................................................................................................. 38
Mantenimiento de cheques ................................................................................................... 38
3
Detalle de Cheque ................................................................................................................ 39

Listado de Cheques lstCheques.jsp ...................................................................................... 41
5 Sessiones 43
5.1 Objetivos ...................................................................................................................... 43
5.2 HttpSession .................................................................................................................. 43
Algo de Historia..................................................................................................................... 43
Obtener la sesión del usuario desde un servlet ..................................................................... 44
Buscar la información Asociada con un sesión ...................................................................... 44
Variables de Sesión ............................................................................................................. 45
Sesiones en JSP................................................................................................................... 45
5.3 Laboratorio: .................................................................................................................. 47
Interfaz LogOn.jsp ................................................................................................................. 47
UserData .............................................................................................................................. 47
Servlet LogOn ....................................................................................................................... 48
Página Principal .................................................................................................................... 48
6 Appendice 50
6.1 Archivo de texto para leer parámetros de configuración ........................................... 50
4
1 Fundamentos
undamentos de Internet, HTML y JavaScript
1.1 Objetivo
• Conocer el funcionamiento y características de Internet
• Conocer la estructura de un documento HTML
• Crear documentos HTML
• Conocer la definición
finición de un formulario
• Identificar los controles que se utilizan dentro de un formulario
• Conocer la definición de un javaScript y diferencia con JAVA
1.2 Internet
Historia
El origen de Internet fue un proyecto de defensa de los Estados Unidos. A finales de los años 60, la
ARPA (Agencia de Proyectos de Investigación Avanzados) del Departamento de Defensa definió el
protocolo TCP/IP para garantizar la comunicación entre lugares
lugares alejados en caso de ataque
nuclear siguiendo cualquier ruta disponible. Internet une muchas redes, incluyendo como más
importantes la que proporciona acceso a los grupos de noticias (Usenet), que data de 1979 y
(conceptualmente) la World Wide Web, diseñada
diseñada por Tim Berners Lee del CERN a principios de los
90. Actualmente hay varios miles de redes de todos los tamaños conectadas a Internet, pudiendo
compartir datos en base al protocolo TCP/IP.
• Internet no es de nadie y es de todos
• La conexión entre redes es posible gracias a protocolos comunes(TCP/IP)
(TCP/IP) y organismos
como NIC y ISOC
• Cualquier persona puede acceder a Internet y decidir a que información acceder desde
cualquier parte del mundo utilizando cualquier plataforma.
Internet vs Intranet
Una intranet es una red interna que utiliza la tecnologia internet.
Se utiliza para el desarrollo de aplicaciones privadas como:
• Almacenamiento
lmacenamiento de publicaciones corporativas
• Sistema de directorios común
• Sistema de mensajeria interna fácil y cómoda
• Sistema de noticias y foros
f de discusión de interés corporativo
Como Funciona Internet
5
• Host : Es cualquier computadora conectada a Interent y que dispone de un número IP

• Número IP :Es un número de 32(=4*8) bits que identifica a cada host en la Internet Ej.
200.28.117.13
• Arquitectura Cliente Servidor : EL servidor (con # IP) presta servicios (www, email, ftp,
etc) a los clientes
• Protocolo TCP/IP : EL protocolo TCP del remitente divide la infomación enviada en
pequeños paquetes de información (datagramas), los numera y los pasa al protocolo IP.
• El protocolo IP etiqueta cada datagrama con la dirección de origen y de destino, luego los
datagramas son enviados.
• En Internet, los Routers se encargan de redirigir los paquetes o datagramas para que
lleguen a su destino, según el número IP del destino
• Al recibir datagramas, el protocolo TCP del destinatario chequea los paquetes por errores
de transmisión, y los ordena por su numeración. Luego reconstruye la información recibida.
• DNS : Ademas del número IP cada Host puede ser identificado por su nombre de dominio
Ej. idat.edu.pe = 200.0.118.6
• Es un conjunto de servicios basados en hipervinculos, ofrecidos en todo el mundo a través
de Internet, se lo llama WWW (World Wide Web - Telaraña de Cobertura Mundial). No
existe un centro que administre esta red de información, sino más bien está constituida por
muchos servicios distintos que se conectan entre sí a través de referencias en los distintos
documentos
1.3 Documento HTML

Qué es HTML?
• Lenguaje de Marcación de Hipertexto
• No es un Lenguaje de Programación
• Es un sistema de etiquetas
• Define la forma de presentar información
• No presenta ningún compilador
• Es Interpretado por un Browser (Internet Explorer, Netscape, etc).
Estructura de un documento HTML

<HTML>
<HEAD>
<TITLE>Titulo de la página</TITLE>
</HEAD>
<BODY parámetros>
Contenido de la Página
</BODY>
</HTML>
Cabecera
Elementos que no alteran el contenido de la página.
Ejemplo :
<TITLE> Titulo Documento </TITLE>
<META AUTHOR=“Idat” KEYWORDS=“Java”>
<BASE HREF=“http://www.mitienda.com”>
Cuerpo del Documento

Contenido de la Página:
<BODY parámetros> Contenido </BODY>
Elementos dentro de BODY:
6
<br>
<hr>
<center></center>
<strong></strong>
<h1></h1>
Tablas
Organizan la información.
<TABLE>
<TR>
<TD>1.1</TD><TD>1.2</TD>
</TR>
<TR>
<TD>2.1</TD><TD>2.2</TD>
</TR>
</TABLE>
Enlaces (Links)
Incorporar enlaces a otras zonas u otras páginas.
<A HREF =”http://www.idat.edu.pe”>Enlace a idat</A>

<a href="mailto:mtraverzo@repsat.com">Enviar e-mail </a>
Imágenes
Inclusión de imágenes, los formatos permitidos son GIF, JPG y PNG.
<IMG SRC=“archivo” ALT=“Mi Foto”>

Atributos:
<IMG SRC=“archivo”
ALT=“Mi Foto”
WIDTH=“88”
HEIGHT=“30”
BORDER=“1”
ALIGN=“MIDDLE”>
Marcos
Es una o varias paginas web independientes dentro de una ventana general del navegador.
<frameset rows=“20%,80%”>
<frame name=“cabecera" src="header.html">
<frame name=“cuerpo" src=“body.html">
</frameset>
Es una pagina web independiente dentro de un documento html.

<iframe name=“paginainterna" src="inbody.html"></iframe>
1.4 Trabajando con Formularios

Definición de Formularios
Medio de comunicación entre las páginas y el servidor
<form action = ”procesaVenta.html” method = “post” name = “frmVenta” >
7
... Elementos del Formulario...

</form>
Elementos cajas de texto

Para el uso de cajas de texto se tiene:<INPUT> y <TEXTAREA>
<INPUT TYPE=“TEXT”> : Define una caja donde se puede escribir un texto de una línea, atributos:
<input type=“text”
name=“identificador”
size=“30”
maxlength=“30”
value=“Contenido” >
<TEXTAREA> : Define una caja donde se puede escribir un texto de multiples lineas, atributos:
<textarea name=“identificador”
rows=“3”
cols=“40” >
Valor del TextArea
</textarea>
Elementos opción múltiple
Para el uso de opciones múltiples tenemos:

<input type=“checkbox”
name=“identificador”
checked >
Elementos opción única

Para el uso de opciones discriminantes tenemos:
Sexo: <br>
Femenino : <input type=“radio” name=“identificador” value=“F”>
Masculino : <input type=“radio” name=“identificador” value=“M” checked>
Elementos combos y listas

Para selección simple o múltiple, mostradas en una lista (Combos y Listas):
<select name=“identificador” size=“20” multiple >

<option value=”1” selected>valor1
<option value=”2”>valor2
<option value=”3”>valor3
</select>
8
Elementos botones
Sirven para disparar un evento, el cual puede producir el envio de la información o la realización de
un proceso
<input type=“submit” name=”nom del boton” value=“valor Boton1”>

<input type=“reset” name=”nom del boton” value=“valor Boton2”>
<input type=“button” name=”nom del boton” value=“valor Boton3”>
Otros Controles
Existe otros controles para Ocultar Variables, Mostrar asteriscos o Mostrar el explorador de
Archivos los cuales son respectivamente:
<input type=“hidden” name=”” value=””>
<input type=“password” name=”” value=””>
<input type=“file” name=”” value=””>
1.5 Fundamentos de Java Script

Requerimientos de Java Script
Para la Ejecución :
Netscape 2.0 o superior
Internet Explorer 4.0 o superior
Para el Edición (cualquier editor de Texto plano)
Notepad
Edit
Vi
¿Qué es Java Script?

Es un lenguaje de tipo script compacto, basado en objetos y responden al trabajo de eventos, esta
diseñado específicamente para el desarrollo de aplicaciones cliente-servidor (trabaja el lado
cliente) dentro del ámbito de Internet.
Los programas Java Script van incrustados en los documentos HMTL, y se encargan de realizar
acciones en el cliente, como pueden ser pedir datos, confirmaciones, mostrar mensajes, crear
animaciones, comprobar campos
Usando Java Script

La forma mas frecuente de hacerlo es utilizando la directiva <script> en un documento HTML (se
pueden incluir tantas directivas <script> como se quiera dentro de un documento).
<script language="JavaScript">
//codigo javascript
</script>
Para insertar el código desde un archive externo:
<script language="JavaScript" src ="archivo.js"> </script>
Puede incluirse también código JavaScript como respuesta a algún evento en el documento HTML:
<input type="submit"
onclick="alert('Acabas de hacer click');return false;"
value="Click">
Elementos Básicos
Comentarios :
// Comentar una linea
/* Comentar
9
un bloque */
Literales : Valores que puede tomar una varible

“Cadena”
3.1415
true, false
moneda =[“soles”, “dolares”,”pesos”,”euros”];
\n, \t, \’, \”, \\
Sentencias y Bloques : Se separan con punto y coma (;) y se agrupan con llaves ({ })
Tipos de Dato
Variables : El nombre de una variable deben empezar con una letra o “_”, no es necesario declarar
la variable.
var x;
x = 0;
Tipos de Dato Arrays conocidos tambien como Vectores:

distritos = new Array(20);
distrito[5] = "San Miguel";
Operadores
Operadores Aritméticos :
+,-,*,/,%,++,--
Operadores de Comparación :
==, !=, ===, !==, >,<,>=,<=
Operadores Lógicos:
!,&&,||
Operadores de Asignación :
x+=10, x/=2
Operadores de Especiales :
indice = condicion?valor1:valor2
Sentencias de Control Java Script
Sentencias Condicionales
If (condicion){
bloque si es verdadero
}
else{
bloque si es falso
}
switch(variable a evaluar){
case”Trujillo”: alert(“Norte”); break;
case “Arequipa”: alert(“Sur”); break;
default: alert(“??”);
}
Bucles
var encontro = false;
while(!encontro){
alert(“Procesara Nueva Busqueda”);
busqueda();
10
var distritos = new Array(10);

for(i=0;i<distritos.length;i++){
alert(distritos[i]);
}
Funciones Java Script

Declaración de Funciones
function nombre(argumento, argumento2, .....) {
//codigo de función
}
Los parámetros de una función son por valor.

Cuando son referencias se manejan como si fuesen por valor.
Cuando deseamos devolver un valor lo regresamos con la palabra return.
function nombre(argumento, argumento2, .....) {
//codigo de función
return valor;
}
Funciones PreDefinidas
Numéricas : Convierte en objeto el número pasado como argumento.
var num = new Number(valor);
Conversión : Convierte una cadena a un formato numérico respectivo.
parseInt(cadena) //convierte en un número entero la cadena.
parseFloat(cadena) //convierte en un número real la cadena que recibe.
Manejo de Cadenas :
nombre = new String ("Juan")
x="Netscape"
alert(“El tamaño de la cadena es " + x.length)
alert(“El Carácter 1 es: " + x.charAt(0))
Otras Funciones :
indexOf
lastIndexOf
substr
Evaluación Evalúa una expresión.
var producto = eval(5*5) //devuelve 25
if (eval(5 > 20)) { } //devuelve true o false
1.6 Laboratorio:
Nombre: Fundamentos de HTML y JavaSccript
Descripción:
Configuración entorno desarrollo web(Instalación de Contenedor Web Tomcat, Configuración IDE,
Testeo)
Desarrollo de una aplicación web
Prerrequisitos: Disponibilidad de instaladores y privilegios de instalación
11
2 Bases de Datos con JAVA

2.1 Objetivos
• Identificar los tipos de driver JDBC.
• Conectarse a cualquier Base de Datos.
• Aplicar el API JDBC.
• Manipular transacciones y procedimientos almacenados.
2.2 Qué es un JDBC?

Es una API de JAVA la cual permite la ejecución de instrucciones SQL.
Para que una aplicación pueda hacer operaciones en una RDBMS (sistema sistema gestionador de base
de datos relacional),
), ha de tener el correspondiente
correspondiente Driver que conecte la aplicación con la Base
de Datos Respectiva.
Así pues la API JDBC es básicamente un paquete de JAVA (java.sql)
( ) que contiene un conjunto de
clases y interfaces escritas en JAVA para manejar la conexión a una Base de Datos.
Datos
Dos conjuntos de Interfaces:

JDBC API para aplicaciones.
JDBC Driver para manejadores o drivers.
Los drivers son programas de bajo nivel que se encargan de mantener la comunicación entre la
API de aplicaciones y el RDBMS.
Tipos de Driver JDBC

Tipo 1 : JDBC-ODBC
ODBC Driver : ODBC deberá ser cargado en la máquina del cliente. No es óptimo
ya que utiliza muchas librerías dependientes del sistema operativo.
Tipo 2 : Driver Puro en Java Acceso Directo a la BD. Convierte las llamadas de JDBC en el
protocolo de reded utilizado por el servidor RDBMS, permitiendo una llamada directa desde la
maquina del cliente al servidor de BD. Soluciones intranet.
12
Drivers para principales RDBGS:

Existen muchas empresas externas además de los mismos fabricantes del RDBGS que ofrecen las
librerías para conexión con una base de datos determinada desde java (Driver).
SQL SERVER
www.jturbo.com : Ashna Inc.
www.inetsoftware.de : I-Net Software
www.avenir.net/jdbc2 : Avenir Inc.
ORACLE
http://technet.oracle.com : Oracle Corporation
www.openlinksw.com : Openlink
INFORMIX
www.informix.com : Informix Corporation
www.openlinksw.com : Openlink
2.4 Conexión a un RDBMS
Objeto Connection
El objeto connection representa una conexión con la BD. La sesión incluye las sentencias SQL que
ejecuto Objeto
Objeto ResultSet
Statement
• Cargar Driver Voy a ejecutar ejecuto
• Conectarse a DML,DDL
DB
Objeto
Voy a ejecutar ejecuto
Connection Liberar
DML,DDL stm Objeto
Preparada(?) PreparedStatement
Voy a trabajar
con Stored ejecuto
Procedures
Objeto
CallableStatement
se ejecuten así como los resultados que se obtengan. Una aplicación puede tener una o más
conexiones con una BD o puede tener conexiones con diferentes BD.
Podemos abrir una conexión :
DriverManager.getConnection(url,usr,pwd);
Busca la clase del Driver (identificado por url) y lo instancia para poder trabajarlo.
Para registrar un driver utilizamos :
Class.forName(clase.del.driver);
13
JDBC URL
Proporciona una forma de identificar una fuente de datos. Es particular para cada tipo y fabricante
de Driver. Pueden identificarse a través de servicios como DNS, NIS, NIS+, etc
jdbc : <subprotocolo>:<subnombre>
jdbc : Protocolo. Es un valor fijo.

<subprotocolo> : El nombre del driver o el nombre de un mecanismo de conexión que puede ser
soportado por uno o más drivers.
<subnombre> : El nombre que identifica a la fuente de datos. Puede tener diferentes sintaxis de
acuerdo al fabricante del driver.
jdbc:odbc:Base_datos
jdbc:inetdae:200.11.50.25:1433?database=nombreBD
Por ejemplo para conectarse a una base datos con los siguientes datos:
Servidor= rs-bd1
Puerto TCP x Defecto SQLServer =1433 Puerto TCP x Defecto ORACLE =1521
Base de Datos=caja
Login= uscaj
Password=123
Conexión con SQLServer:

Class.forName("com.inet.tds.TdsDriver"); //Carga el driver
String url = "jdbc:inetdae:rs-bd1:1433?database=caja";
Connection con = DriverManager.getConnection(url,"uscaj","123");
Conexión con Oracle:

Class.forName("oracle.jdbc.driver.OracleDriver"); //Carga el driver
String url = "jdbc:oracle:thin:@rs-bd1:1521:caja";
Connection con=DriverManager.getConnection(url,"uscaj","123");
Conexión con ODBC: (Primero crear un Data Source Name (DSN) con nombre DSNcaj)
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); //Carga el driver
String url = "jdbc:odbc:DSNcaj";
Connection con = DriverManager.getConnection(url,"uscaj","123");
Objeto Statement
El objeto statement se utiliza para enviar instrucciones SQL a la BD.
Existen tres tipos de Statement :
Statement : Instrucciones SQL

PreparedStatement : Instrucciones SQL PreCompiladas o preparadas
CallableStatement : StoreProcedures
Connection con = DriverManager.getConnection(url, usr, pwd);

Statement stmt = con.createStatement();
Una vez terminada su utilización el objeto statement es recogido por el recolector de basura, pero
podemos cerrarlo con el método
stmt.close();
14
2.5 Ejecución de sentencias SQL

La sentencias SQL se ejecutan normalmente con:
executeUpdate() : INSERT, UPDATE, DELETE, CREATE TABLE, DROP TABLE.

Retorna el número de filas que han sido alteradas.
stmt.executeUpdate("INSERT INTO Detalles VALUES(10,10,’A’)");
executeQuery() : Para utilizarlo con sentencias SELECT

stmt.executeQuery("SELECT a, b, c FROM Table2");
También podemos ejecutar sentencias en batch con el método :

executeBatch() : Podemos enviar múltiples sentencias SQL y tratarlas como una unidad.
Statement stmt = con.createStatement();
con.setAutoCommit(false);
stmt.addBatch("INSERT INTO employees VALUES (1000, 'Joe Jones')");
stmt.addBatch("INSERT INTO departments VALUES (260, 'Shoe')");
stmt.addBatch("INSERT INTO emp_dept VALUES (1000, '260')");
int [ ] updateCounts = stmt.executeBatch();
Objeto ResultSet
El resultSet contiene los resultados de la ejecución de un query SQL en un cursor que apunta a
la fila actual de datos. El desplazamiento se da cada vez que se llama al metodo next().
Por default el desplazamiento es hacia delante solamente.
JDBC 2.0 permite diversos desplazamientos : previous, first, last, absolute, relative, afterLast, and
beforeFirst.
java.sql.Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table1");
while (rs.next()) {
...// realizamos diversas operaciones con el cursor
}
Número de filas en un ResultSet :

String sql = "SELECT LAST_NAME, FIRST_NAME FROM EMPLOYEES";
ResultSet rs = stmt.executeQuery(sql);
rs.last();
int numberOfRows = rs.getRow();
System.out.println("Existen " + numberOfRows + "employees");
rs.beforeFirst();
while (rs.next()) {
. . . // operaciones con el cursor
}
Obteniendo Datos de un ResultSet :

Utilizamos los métodos getXXX() : Donde XXX indica el tipo de dato que queremos obtener a
partir del Cursor.
String s = rs.getString(2);
String s = rs.getString("TITLE");
El parámetro dentro del getXXX() si es un numero hará referencia al campo que ocupa esa
posición en el registro actual, cuando se trata de una cadena esta referirá al nombre del campo
obtenido en la consulta.
Ver en el siguiente cuadro los distintos métodos getXXX() adecuados por cada tipo de dato en
una Base de Datos
15
16
Objeto PreparedStatement
Contiene una sentencia SQL que ha sido previamente compilada.
Pueden contener varios parámetros que no necesariamente se especifican al momento de crear la
sentencia, sino cuando se ejecutan.
Hereda de la clase Statement.
PreparedStatement pstmt;
pstmt = con.prepareStatement( "UPDATE table4 SET m = ? WHERE x = ?");
pstmt.setLong(1, 123456789);
pstmt.setLong(2, 100000000);
pstmt.executeUpdate();
Llamada a Procesos Almacenados

Llamada a un Store Procedure usando Parámetros :
CallableStatement cstmt = con.prepareCall("{call updatePrices(?, ?)}");
cstmt.setString(1, "Colombian");
cstmt.setFloat(2, 8.49f);
Salida de Parámetros :
Debemos de registrar el tipo de cada parámetro antes de ejecutarlo. Para ello utilizamos el
método:registerOutParameter()
CallableStatement cstmt = con.prepareCall("{call getTestData(?, ?)}");

cstmt.registerOutParameter(1, java.sql.Types.TINYINT);
cstmt.registerOutParameter(2, java.sql.Types.DECIMAL, 3);
ResultSet rs = cstmt.executeQuery(); // . . . retrieve result set values
with rs.getXXX methods
byte x = cstmt.getByte(1);
java.math.BigDecimal n = cstmt.getBigDecimal(2);
Ejecución y Control de Transacciones

Primero debemos de deshabilitar el autocommit para poder realizar la transacción y ejecutar las
sentencias SQL de la transacción :
PreparedStatement updateSales = con.prepareStatement("UPDATE COFFEES SET
SALES = ? WHERE COF_NAME LIKE ?");
updateSales.setInt(1, 50);
updateSales.setString(2, "Colombian");
updateSales.executeUpdate();
con.commit(); // Realizamos la transacción
con.setAutoCommit(true);
PreparedStatement updateTotal = con.prepareStatement("UPDATE COFFEES SET
TOTAL = TOTAL + ? WHERE COF_NAME LIKE ?");
updateTotal.setInt(1, 50);
updateTotal.setString(2, "Colombian");
updateTotal.executeUpdate();
con.commit(); // Realizamos la transacción
try{
// ........
updateSales.executeUpdate();
con.commit();
17
// ........
}
catch(SQLException ex) {
System.err.println("SQLException: " + ex.getMessage());
if (con != null) {
try {
System.err.print("Transaction is being rolled back");
con.rollback();
}
catch(SQLException excep){
}
} //fin del catch
2.6 Manejo de Cursores JDBC 2.0

Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
ResultSet srs = stmt.executeQuery("SELECT COF_NAME,PRICE FROM COFFEES");
El tipo de ResulSet lo determina la primera constante:

TYPE_FORWARD_ONLY : No es desplazable
TYPE_SCROLL_INSENTITIVE : Desplazable, pero no muestra los updates.
TYPE_SCROLL_SENSITIVE : Desplazable y establece conexión viva.
El segundo argumento especifica si es de Lectura o Actualizable:

CONCUR_READ_ONLY : Sólo lectura.
CONCUR_UPDATABLE : Actualizable.
Métodos para desplazarse:

previous() next() last()
first() beforeFirst() afterLast()
absolute(n) : Se desplaza n registros desde el inicio(+) o desde el final(-)
Cursores Actualizables
Updates
uprs.last();
uprs.updateFloat("PRICE", 10.99f);
uprs.updateRow();
Podemos cancelar el Update llamando a:
cancelRowUpdates();
Antes de llamar a updateRow(), de lo contrario no trabajará.
Si movemos el cursor antes de llamar a updateRow() los nuevos valores se perderán y se
restaurarán los antiguos.
Inserts
uprs.moveToInsertRow();
uprs.updateString("COF_NAME", "Kona");
uprs.updateInt("SUP_ID", 150);
uprs.updateFloat("PRICE", 10.99f);
uprs.updateInt("SALES", 0);
uprs.updateInt("TOTAL", 0);
uprs.insertRow();Deletes
uprs.absolute(4);
uprs.deleteRow();
18
Resumiendo
- JDBC es un API que nos permite conectarnos a cualquier RDBMS.
- Nos valemos de drivers para lograr una comunicación.
- Es potestad de cada fabricante cumplir con las especificaciones de la API.
- Para un aplicación debemos de “cargar” la clase del driver, en primer lugar.
- Generamos el objeto Connection.
- Si ejecutamos SELECT : Objeto Statement y Objeto ResultSet
- Si ejecutamos INSERT, UPDATE, etc. : Objeto Statement
- Si ejecutamos sentencias precompiladas : Objeto PreparedStatement.
- Si trabajamos con Stored Procedures : Objeto CallableStatement.
- Podemos controlar el nivel de Transacción. ( de acuerdo al driver)
- Podemos utilizar todos los tipos SQL standard (ANSI)
- En todo momento debemos de controlar los posibles errores en la ejecución.
2.7 Laboratorio:
Nombre: Aplicación Mantenimiento de Cheques
Descripción: Implementación de Capa Manejo de Base de Datos.
Prerrequisitos: Implementación de la BD Cash Flow la cual contiene tabla Cheque y Usuarios.
Base de datos
La base de datos cashflow Contiene las siguientes dos tablas:
Librería del Driver de Base Datos SQLServer

Sprinta_1000Users.jar
Conexión a la BD
package sys.data;
import java.sql.*;
public class DataBase {
public DataBase() {
}
public static Connection getConnection(){
Connection con = null;
try{
String url="jdbc:inetdae:127.0.0.1:1433?database=caja");
String us="sa";
String ps="1234";
Class.forName(rb.getString("com.inet.tds.TdsDriver"));
19
con = DriverManager.getConnection(url,us,ps);
System.out.println("DB Connection [OK]");
}
catch (Exception e){
e.printStackTrace();
}
return con;
}
}
Bean Cheque
package sys.bean;
import java.beans.*;
import java.io.Serializable;
public class Cheque extends Object implements Serializable {

private int cheque;
private String nro;
private int tip;
private double monto;
private int estado;
private String FHIni;
private String FHFin;
private String obs;
private String xbco;
public int getCheque() {

return this.cheque;
}
public void setCheque(int cheque) {
this.cheque = cheque;
}
//…
public String getXbco() {

return this.xbco;
}
public void setXbco(String xbco) {
this.xbco = xbco;
}
Lista de Objetos Cheque

package sys.list;
import java.util.ArrayList;
import sys.bean.Cheque;
public class ChequeList extends ArrayList{
public ChequeList() {
super();
}
public Cheque getCheque(int i){
return (Cheque)get(i);
}
}
Mantenimiento de Data Cheque

package sys.data;
import java.sql.*;
import sys.bean.*;
import sys.list.*;
public class ChequeData {

public ChequeData() {
}
public static boolean insert(Cheque o){
boolean ok = false;
20
Connection c = null;
Statement stm = null;
try{
c = DataBase.getConnection();
stm=c.createStatement();
String sql ="INSERT INTO Cheque (" +
"che_nro,det_tip,che_monto,che_estado,che_fhini,che_fhfin,che_obs) " +
"VALUES(" +
"'"+o.getNro()+"',"+
""+o.getTip()+"," +
""+o.getMonto()+"," +
""+o.getEstado()+"," +
"'"+o.getFHIni()+"'," +
"'"+o.getFHFin()+"'," +
"'"+o.getObs()+"'" +
")";
System.out.println(sql);
stm.executeUpdate(sql);
ok = true;
stm.close();
c.close();
}
}
return ok;
}
public static boolean update(Cheque o){

boolean ok = false;
try{
String sql =
"update Cheque set " +
"che_nro='"+o.getNro()+"',"+
"det_tip="+o.getTip()+","+
"che_monto="+o.getMonto()+"," +
"che_estado="+o.getEstado()+"," +
"che_fhini='"+o.getFHIni()+"'," +
"che_fhfin='"+o.getFHFin()+"'," +
"che_obs='"+o.getObs()+"'" +
" WHERE che_codigo="+o.getCheque();
stm.executeUpdate(sql);
ok = true;
stm.close();
c.close();
}
}
return ok;
}
public static boolean delete(String id){

boolean ok=false;
try{
String sql = "DELETE FROM dbo.Cheque where CHE_CODIGO="+id;
stm = c.createStatement();
if(stm.executeUpdate(sql)>0)
ok=true;
stm.close();
c.close();
}
21
}
return ok;
}
public static ChequeList listCheque(){

ChequeList lista = new ChequeList();
try{
String sql = "SELECT " +
"a.che_codigo,a.che_nro,a.det_tip,a.che_monto,a.che_estado,a.che_fhini," +
"a.che_fhfin,a.che_obs,b.tip_desc" +
" from dbo.CHEQUE a,dbo.CAJBCO b" +
" where a.det_tip=b.det_tip" +
" order by che_fhini desc";
System.out.print(sql);
ResultSet rs = stm.executeQuery(sql);
while(rs.next()){
Cheque o = new Cheque();
o.setCheque(rs.getInt("che_codigo"));
o.setNro(rs.getString("che_nro"));
o.setTip(rs.getInt("det_tip"));
o.setMonto(rs.getDouble("che_monto"));
o.setEstado(rs.getInt("che_estado"));
o.setFHIni(rs.getString("che_fhini"));
o.setFHFin(rs.getString("che_fhfin"));
o.setObs(rs.getString("che_obs"));
o.setXbco(rs.getString("tip_desc"));
lista.add(o);
}
stm.close();
c.close();
}
}
return lista;
}
public static Cheque getCheque(String id){
Cheque o = new Cheque();
try{
String sql = "SELECT " +
"a.che_codigo,a.che_nro,a.det_tip,a.che_monto,a.che_estado,a.che_fhini," +
"a.che_fhfin,a.che_obs,b.tip_desc" +
" from dbo.CHEQUE a,dbo.CAJBCO b" +
" where a.det_tip=b.det_tip AND che_codigo=" +id;
ResultSet rs = stm.executeQuery(sql);
if (rs.next()){
o.setCheque(rs.getInt("che_codigo"));
o.setNro(rs.getString("che_nro"));
o.setTip(rs.getInt("det_tip"));
o.setMonto(rs.getDouble("che_monto"));
o.setEstado(rs.getInt("che_estado"));
o.setFHIni(rs.getString("che_fhini"));
o.setFHFin(rs.getString("che_fhfin"));
o.setObs(rs.getString("che_obs"));
o.setXbco(rs.getString("tip_desc"));
}
stm.close();
c.close();
}
22
}
return o;
}
}
23
3 Java Servlet
3.1 Objetivos
• Conocer los fundamentos del Http
• Describir la arquitectura y funcionamiento de los servlets
• Identificar las ventajas del servlet
3.2 HTTP
HTTP es un simple protocolo de comunicación.
Cuando un cliente con su browser realiza una petición o requerimiento, entonces el web servlet
responde y la transacción se hace. En este requerimiento el cliente especifica un comando http
denominado método que le indica al servidor el tipo de acción que necesita ejecutar, esta primera
línea también indica la dirección del documento (URL: ejm. http://www.mttv.edu.pe/lista.html) y la
versión del protocolo:
Pero lo que en realidad se enviara será no solo la dirección URL sino además se envía otra
información (header) que el browser adiciona, dentro del cual encontramos por ejemplo:
User-Agent: Mozilla/4.0(compatble con MSIE 4.0) Windows 98)
Accept:image/gif,image/jpg,text/*,*/*
Donde:
User Agent es la versión, tipo de browser y de sistema operativo inclusive
Accept especifica el tipo de media MIME que el cliente soporta, Excel, Word, etc.
Después de que el cliente envía el request, el servlets procesa y retorna como respuesta un
response. La primera línea del response es una línea de status que especifica la versión del
protocolo http del servidor, un código status y una descripción del código status.
HTTP/1.0 200 OK
La línea de status incluye un código 200, el cual indica que request ha sido exitoso con la
descripción OK común status el código 500 el cual indica not found, el documento no ha sido
encontrado.
Anexa también la siguiente información en unas variables denominadas CGI que son variables del
servidor, por ejemplo.
Date:Monday,21-Abr-2000 09:30:00 GMT

Server: JavaWebServer/1.1.3
MIME-version:1.0
Content-type: text/html
Content-length : 1029
Last-modified:Wednesday, 5-Oct-99 11:22:30 GMT
Headers Request
Desde el Java se podrá acceder a toda esta información de los headers, para esto, hay métodos
predefinidos, es una información rica que servirá para el desarrollo de una aplicación web.
Los headers están definidos en variables denominadas CGI y aprovecharemos en ver el
significado y como se accedan desde Java a algunos de ellos en el siguiente cuadro.
Variable CGI Significado Acceso desde doGet o doPost
24
AUTH_TYPE Si se suministro una cabecera request.getAuthType()

Authorization, este es el esquema
especificado (basic o digest)
CONTENT_LENGTH Solo para peticiones POST, el Técnicamente el equivalente es:
número de bytes enviados. String.valueOf(request.getConte
ntLength())
pero probablemente queremos solo llamar
a: request.getContentLength()
Que devuelve un int.
CONTENT_TYPE El tipo MIME de los datos adjuntos, si Request.getContentType()
se especifica.
DOCUMENT_ROOT Path al directorio que corresponde con getServletContext()
http: /host/ getRealPath(“/”)
Observa que era:
request.getRealPath (“/”)
en especificaciones servlet anteriores.
HTTP_XXX_YYY Acceso a cabeceras arbitrarias HTTP request.getHeader(“Xxx-Yyy”)
PATH_INFO Información de Path adjunto a URL request.getPathInfo()
como los servlet. Al contrario que los
programas estándar CGI, pueden
hablar con el servidor, no necesitan
tratar esto de forma separada. la
información del Path podría ser
enviada como parte normal de los
datos de formulario
PATH_TRANSLATED La información del Path mapeado la request.getPathTranslated()
path real en el servidor. De nuevo, los
Servlet no necesitan tener un caso
espacial para esto.
PATH_TRANSLATED La información del Path mapeado la request.getPathTranslated()
path real en el servidor. De nuevo, los
Servlet no necesitan tener un caso
espacial para esto.
QUERY_STRING Para peticionar GET, son los datos request.getQueryString()
adjuntos como un gran string, con los
valores codificados. Raramente
querremos una fila de datos en los
servlets; en su lugar, usaremos
request.getParameter para acceder
a parámetros individuales.
REMOTE_ADDR La dirección IP, del cliente que hizo la request.getRemoteAddr()
petición, por ejemplo “192.9.48.9”.
REMOTE_HOST El nombre de dominio totalmente request.getRemoteHost()
cualificado(por ejemplo
“java.sum.com”) del cliente que hizo
la petición. Se devuelve la dirección IP
si no se puede determinar.
REMOTE_USER Si se suministro una cabecera request.getRemoteUser()
Authorization, la parte del usuario.
REQUEST_METHOD El tipo de petición, que normalmente request.getMethod()
es GET o POST, pero ocasionalmente
puede ser
HEAD,PUT.DELETE,OPTIONS, o
TRACE.
SCRIPT_NAME Path del servlet. request.getServletPath()
25
SERVER_NAME Nombre del servidor Web. request.getServertName()

SERVER_PORT Puerto por el que escucha el servidor Técnicamente el equivalente es:
String.valueOf(request.getServe
rPort()), que devuelve String.
Normalmente solo querremos llamar a
request.getServerPort().
Métodos GET y POST
Cuando el cliente quiere comunicarse con el servidor (solicitarle algo) entonces lo puede hacer de
dos formas, o métodos GET y POST.
GET
Se llama así cuando se realiza la petición directamente desde el URL.
Se usa cuando se envía información no confidencial, poca cantidad y es ideal cuando no se
realiza accesos a base de datos.
En términos técnicos la información que se envía NO forma parte del cuerpo del request.
POST
Se usa cuando se envía la información por medio de un formulario del HTML, la información que
viaja no se visualiza (mantiene discreción), es usado para enviar bastante información y cuando se
procesara con un motor de base de datos o cuando se envía files, imágenes, etc.
3.3 Servlets
Conceptos Fundamentales de un Servlet
Son Clases java residentes en un contenedor Web (Web Server).
Actúan como intermediarios entre los pedidos de un cliente WEB o HTTP y una Base de Datos u
otras aplicaciones en el servidor.
Se encargan de:
• Leer los datos enviados por el usuario.
• Capturar cualquier información proveniente de un HTTP request.
• Procesar y Generar resultados.
• Formatear documentos y enviar documentos de regreso al cliente.
Características
Eficiencia
• La JVM lanza sólo un thread (hilo de proceso) principal para manejar el servlet.
• El servlet lanza n threads (uno por cada requerimiento o cliente) pero solo una copia del
servlet en memoria.
• Termina el request, el servlet se mantiene en memoria en espera nuevos requerimientos.
Conveniencia :
• Java puro, decodificación automática de HTML
Poder
• Servlets pueden comunicarse directamente con el Web Server o Contenedor web sin
necesidad de una API.
Portable
• Cumple con todas las características y estándares del lenguaje Java.
• Web Server que cumpla con las especificaciones de Servlets:
26
Software para Servlet

Apache Tomcat : Versiones 5.5. Puede utilizarse sólo o como complemento de un Web Server
(Apache) . Es Libre.
http://jakarta.apache.org
JWSDK : Versiones 2.1. Es free.
http://java.sun.com/products/servlet/download.html
Allaire JRun : Para Netscape Enterprise, IIS, Personal Web Server, Apache.
http://www.allaire.com/products/jrunLiteWebServer (LWS) : Versiones 2.2. Es free. Para
Netscape Fast Track y Enterprise.
http://www.gefionsoftware.comJava Web Server: Versiones 2.2. Es free por 30 días.
http://www.sun.com/software/jwebserver/try/
Estructura de un Servlet
• La clase debe de heredar de HttpServlet
• Debe sobrescribir sus métodos doGet y doPost, dependiendo si los datos son enviados
con GET o POST desde el formulario HTML.
• Estos métodos tiene dos argumentos de tipo: HttpServletRequest y
HttpServletResponse
• HttpServletRequest: cabeceras de request HTTP, Nombre del host cliente, datos del
formulario, etc.
• HttpServletResponse: códigos HTTP, cabeceras de respuestas, PrintWriter para enviar
HTML al cliente.
Ejemplo de un Servlet Básico

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class ModeloServlet extends HttpServlet {
public void doGet(HttpServletRequest request,
ttpServletResponse response) throws ServletException, IOException {
PrintWriter out = response.getWriter();
out.println(“Hola Mundo”);
}
}
Ciclo de Vida de un Servlet

Se hereda de la calse HttpServlet los metodos init(),service(),y destroy() los
cuales pos su puesto pueden ser sobrescritos.
La secuencia del ciclo de vida de todo servlet es la siguiente:
• Cuando el servlet es creado, se invoca al método init()
• Cuando cada usuario requiere resultados en el thread del servicio llama al método
service()
• El método service() llama a doGet() o doPost() dependiendo del tipo de pedido
HTTP.
• Cuando el servlet ha decidido terminar se llama a su método destroy()
Comunicación con HTML

Para que un servlet pueda enviar (devolver al browser del cliente) código HTML sin ningún
problema debemos tener en cuenta:
Indicar al browser que tipo de contenido es HTML:
response.setContentType (“text/html”);
Modificar las sentencias println para construir una página HTML.
27
Nota: Puede devolverse otros tipos de contenido como para resultados XML o Excel
respectivamente:
response.setContentType (“text/xml”);
response.setContentType (“application/vnd.ms-excel”);
Ejemplo:
import java.io.*;
public class ModeloServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse
response)throws ServletException, IOException {
response.setContentType(“text/html”);
String docType = “<!DOCTYPE HTML PUBLIC \”-//W3C//DTD HTML 4.0 Transitional/EN\”>\n”;
PrinterWriter out = response.getWriter();
out.println(docType + “<HTML>\n” +” <HEAD> <TITLE> Hola</TITLE> </HEAD>\n”);

}
}
Formularios y Servlet
El código para que un cliente llame un servlet enviándole parámetros desde un formulario html se
verá más o menos así:
<FORM ACTION = “/servlet/miServlet”>
Parámetro:
<INPUT TYPE = “text” NAME = “Parametro_1” ><BR>
<INPUT TYPE = “submit”
</FORM>
Este formulario hace un request a servlet miServlet enviándole un parámetro llamado Parametro_1.
En el servlet, para leer parámetros tenemos el método getParameter() de la clase

HttpServletRequest. Este método devuelve uno de los siguientes valores:
• un valor de tipo String si el parámetro tiene un valor.
• “” (Cadena vacía) si el parámetro existe y no tiene valor
• null (Nulo) si el parámetro no existe.
El argumento para este método es el nombre del parámetro y es case sensitive.
String valParam;
valParam=request.getParameter(“Parametro_1”);
Un esquema de todo lo visto hasta aquí se describe en la siguiente figura:
28
cliente web server servlet
Contenedor web
GET
Request doGet()
Response
service()
POST
Request doPost()
Response
3.4 Laboratorio:
Nombre: Servlets
Descripción: Implementación de Servlet para la manipulación de cheques
Prerrequisitos: Haber realizado Lab DB
Servlet de mantenimiento de Cheques

package sys.servlet;
import java.io.*;
import java.net.*;
import sys.bean.*;
import sys.data.*;
import sys.list.*;
import sys.logic.*;
public class ManCheque extends HttpServlet {

public void init(ServletConfig config) throws ServletException {
super.init(config);
}
public void destroy() {
}
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
System.out.println("servlet ini");
int opt=Integer.parseInt(request.getParameter("opt"));
System.out.println("opt:"+opt);
switch (opt)
{
case 1: insert(request, response); break;
case 2: edit(request, response); break;
case 3: delete(request, response); break;
case 4: list(request, response); break;
case 10: getEntity(request, response); break;
}
}
protected void doGet(HttpServletRequest request, HttpServletResponse response)

processRequest(request, response);
}
protected void doPost(HttpServletRequest request, HttpServletResponse response)
29

processRequest(request, response);
}
public String getServletInfo() {

return "Short description";
}
protected void insert(HttpServletRequest request, HttpServletResponse response)

response.setContentType("text/html");
Cheque o=new Cheque();
o.setNro(request.getParameter("che_nro"));
o.setTip(Integer.parseInt(request.getParameter("det_tip")));
o.setMonto(Double.parseDouble(request.getParameter("che_monto")));
o.setEstado(Integer.parseInt(request.getParameter("che_estado")));
o.setFHIni(request.getParameter("che_fhini"));
o.setFHFin(request.getParameter("che_fhfin"));
o.setObs(request.getParameter("che_obs"));
if (ChequeLogic.chkUnique(o)){
ChequeData od= new ChequeData();
if (od.insert(o))
out.println("<center>Ok</center>");
else
out.println("<center><font color='#FF0000'>Error: Datos Invalidos</font></center>");
out.close();
}
else{
request.setAttribute("Cheque", o);
request.setAttribute("ER", "UN");
String ruta = "/ManChequeDet.jsp";
this.getServletContext().getRequestDispatcher(ruta).forward(request, response);
}
}
protected void edit(HttpServletRequest request, HttpServletResponse response)

System.out.println(request.getParameter("che_codigo"));
Cheque o=new Cheque();
o.setCheque(Integer.parseInt(request.getParameter("che_codigo")));
o.setNro(request.getParameter("che_nro"));
o.setTip(Integer.parseInt(request.getParameter("det_tip")));
o.setMonto(Double.parseDouble(request.getParameter("che_monto")));
o.setEstado(Integer.parseInt(request.getParameter("che_estado")));
o.setFHIni(request.getParameter("che_fhini"));
o.setFHFin(request.getParameter("che_fhfin"));
o.setObs(request.getParameter("che_obs"));
ChequeData od= new ChequeData();

if (od.update(o))
out.println("<center>Ok</center>");
else
out.close();
}
protected void delete(HttpServletRequest request, HttpServletResponse response)
if (ChequeData.delete(request.getParameter("Cheque")))
out.println("Ok del");
else
out.close();
}
protected void list(HttpServletRequest request, HttpServletResponse response)

30
ChequeList lista= ChequeData.listCheque();

request.setAttribute("lstCheque", lista);
String ruta = "/lstCheque.jsp";
}
protected void getEntity(HttpServletRequest request, HttpServletResponse response)

System.out.println(request.getParameter("Cheque"));
Cheque o=ChequeData.getCheque(request.getParameter("Cheque"));
request.setAttribute("Cheque", o);
String ruta = "/ManChequeDet.jsp?edit=1";
}
}
31
4 Java Server Pages (JSP)

4.1 Objetivos
• Desarrollar paginas dinámicas
• Acceder a bases de datos con JDBC desde JSP
• Conocer la sintaxis de JSP
• Controlar Excepciones con JSP Excepción
• Manipular excepciones en documentos Jsp
• Acceder a Beans desde Jsp
• Identificar tipos de alcance (scope)
4.2 Concepto de JSP

Características
Nos permite mezclar HTML estático con contenido generado dinámicamente a través de Servlets.
Es competencia directa frente a ASP, PHP.
Para crear una JSP simplemente se requiere que el archivo tenga extensión .jsp.
No hay compilación, ni CLASSPATH
El seteo se da en el lado del servidor y depende de cada Servidor Web.
Ventajas de un JSP
ASP
• Las páginas JSP están hechas en Java(Lenguaje de propósito general) y no en
VBScript(sublenguaje limitado).
• Portabilidad: JSP funciona sobre cualquier plataforma mientras que asp solo sobre windows.
PHP
• Se requiere aprender nuevo lenguaje (PHP).
• Con JSP acceso directo a las API´s JDBC, RMI, MAIL, etc.
SERVLETS
• Todo JSP son transformados al final en Servlets.
• Es más fácil el mantenimiento de las páginas HTML.
• Separamos la presentación del contenido o lógica de negocio.
JAVASCRIPT
• JavaScript genera HTML dinámico en el cliente.
• No podemos acceder a recursos de la res como BD, catálogos, información de precios, etc.
• JavaScript puede utilizarse en servidores, pero solo en Netscape.
• JSP es más portable, poderoso, flexible y confiable.
HTML
• El HTML estático no puede ser utilizada para responder a peticiones o situaciones en el cliente.
• JSP permite el acceso dinámico a datos y configuraciones de páginas.
Arquitectura de un JSP
En un primer escenario, la página JSP accesa a un Bean que realiza una tarea bien definida como
el acceso a una BD. El resultado de esta consulta se almacena en las propiedades del Bean. La
página utiliza el Bean para generar páginas HTML dinámicas y presentarlas al cliente.
En un segundo escenario, el servlet genera el contenido dinámico. Para manejar la respuesta al

cliente, genera un Bean y almacena el resultado en sus propiedades. El servlet invoca luego a una
JSP y le pasa como parámetro el Bean que presentará el contenido utilizando para ello el Bean.
32
Si es necesaria una GUI para recoger los datos, utilizaremos el primer caso.
Si el request y sus parámetros
metros se encuentran disponibles para el servlet, pero los resultados del
servlet necesitan de un GUI, utilizamos el segundo caso.
Si la presentación
n por GUI es mínima
m y no es necesaria la presentaciónn de la lógica
l al cliente o al
HTML, el segundo sería adecuado.
adecuado
Primer Escenario Segundo Escenario
4.3 Tags de un JSP --- Directiva

Esta directiva afecta la estructura del Servlet que resulta de una página
p JSP.
<%@ directiva atributo = “valor” %>
<%@ directiva atributo1 = “valor” atributo2 = “valor valor” %>
Existen tres tipos de directivas:
• page
• include
• taglib
Directiva Page
Permite controlar las estructura de un servlet mediante la importación
importaci n de clases, seteando el tipo
de contenido, etc.
Puede ser utilizada en cualquier parte del documento.
Entre las principales tenemos:
import
Es la única
nica que puede aparecer muchas veces en la p
página.
gina. Permite especificar las clases a
importar.
<%@ page import = “java.util.*” %>
<%@ page import = “java.util.*, intranet.procesos.*” ” %>
contentType
Establece el tipo de documento que está siendo enviado al cliente.
<%@ page contentType = “text/plain” %>
info
Define una cadena que es recuperada por el servlet al llamar al m
método
todo getServletInfo()
<%@ page info = “Esto es un mensaje” %>
errorPage
Especifica la página
gina a utilizar cuando ocurre una excepción
n que no ha sido recogida por el catch
respectivo.
<%@ page errorPage = “ManejaErrorres.jsp” %>
33
isErrorPage
Define si la página manejará errores de otras páginas.
<%@ page isErrorPage = “true” %>
Directiva Include
Permite incluir un archivo al momento de conversión en servlet.
Podemos incluir páginas HTML y JSP.
Si modificamos las páginas que son incluidas, debemos de actualizar la página que las incluye.
Entre las principales tenemos:
<%@ include file = “NavBar.jsp” %>
También podemos incluir archivos al momento en el que el cliente realiza el pedido. Para ello
utilizamos la directiva:
< jsp : include page = “URL” flush = “true” />
La página a incluir de esa manera puede ser de cualquier extensión.
4.4 Tags de un JSP --- Scripts

Expresiones: Son evaluadas e insertadas en la salida del servlet.
<%= expresion %>
Scriplets: Que son insertadas en el método _jspService (llamado por service() cada ves que se
atiende algun request)
<% código %>
Declaraciones: Que se insertan en la clase del servlet como una propiedad, fuera de los métodos.
<%! código %>
Expresiones
Imprime el resultado de la expresión indicada:
La Fecha es: <%= new java.util.Date() %>
El nombre del host es: <%= request.getRemoteHost() %>
Ejemplo de variables:
<%! static public counter = 0; %>
Ejemplo de métodos:
<%! public long fact(long x) {
if (x==0) return 1;
else return x*fact(x-1);
}
%>
Scriplets
<%
String queryData = request.getQueryString();
out.println(“La data del GET es : “ + queryData);
%>
<% response.setContentType(“text/html”); %>
Declaraciones
<%! private int accessCount = 0; %>
El acceso a la pagina es :
<%= ++accessCount; %>
34
4.5 Tags de un JSP --- Objetos Implícito

request
Este objeto permite tener acceso a headers, URL, cookies y parámetros.
Ejm:
<% String numero = request.getParameter(“num”); %>
Obtiene el valor del parámetro num del request. Todos los valores de los parámetros se guardan
como cadenas.
response
Es lo que se envía al usuario como resultado de procesar la página JSP.
Incluye métodos para agregar cookies y headers.
exception
Objeto que sólo está disponible en las páginas designadas como páginas de error:
<%@ page isErrorPage=“true” %>
Permite tener acceso a información sobre el error producido.
session
HttpSession, asociado al request se almacenarán la variables que el usuario considere de
sesión esta tendrá un comportamiento similar a la de un arreglo de objetos.
out
PrinterWriter, para enviar la salida al cliente, Se comporta como un buffer que almacena la
salida para el cliente.
page
Sinónimo de this, indica la página actual.
4.6 Tags de un JSP --- Acciones

forward
Se utiliza para transferir control permanentemente de una página JSP a otro destino en el servidor
local. El destino puede ser un documento estático, un CGI, un servlet u otra página JSP.
<jsp:forward page=“pagina.html”>.
include
Permite incorporar el contenido generado por otro documento local en la página actual. El control
es transferido temporalmente de la página JSP a otro destino en el servidor local.
<jsp:include page=“pagina.html” >
4.7 Programación con Java Beans

Podemos cargar un bean en una página JSP con la etiqueta:
<% jsp:usebean id=“nombre” class=“paquete.clase” />
Esto es:
“Instancias un objeto de la clase especificada por class y asignado a la variable con el nombre
especificado por id”
Para poder leer las propiedades de un bean utilizamos:
35
<jsp:getProperty name=“nombre” property=“titulo” />

Para poder setear las propiedades de un bean utilizamos:
<jsp:setProperty name=“nombre” property=“titulo” value = “El titulo
de mi libro” />
Esto es esquivalente a:
<% nombre.setTitle(“El titulo de mi libro”); %>
Definición del Bean StringBean:

public class StringBean {
private String mensaje = “No existe ninguno”;
public String getMensaje { return (mensaje); }
public void setMensaje(String mensaje) { this.mensaje = mensaje; }
}
Ejemplo de un JSP que utiliza un bean:

<HTML>
<HEAD><TITLE>Prueba con Beans</TITLE></HEAD>
<BODY>
<H1>Utilizando JavaBeans con JSP</H1>
<jsp:useBean id = “stringBean” class=“StringBean” />
Valor inicial de getProperty() : <jsp:getProperty name = “stringBean”
property=“mensaje” />
Valor inicial del mensaje en JSP :<%= stringBean.getMensaje() %>
<jsp:setProperty name=“stringBean” property = “mensaje” value = “El mejor

de todos” />
Valor nuevo del mensaje :<jsp:getProperty name=“stringBean” property =
“mensaje” />
Utilizando los scriplets

<%= stringBean.setMensaje(“Siguiente mensaje dentro del JSP”) %>
Valor despues de haber asignado el valor con el scriplet :<%=
stringBean.getMensaje() %>
</BODY>
</HTML>
Podemos setear las propiedades de los Beans utilizando también expresiones en la etiqueta de
asignación. De esta manera:
<jsp:setProperty name=“Bean” property = “mensaje” value = ‘<%=

request.getParameter(“msgID”) %>’ />
Los tipos de datos que se encuentren asociados a los parámetros son inmediatamente convertidos
a String.
Podemos asociar directamente los parámetros que le enviemos con las propiedades de los beans.
Para ello nos ayudamos de la etiqueta param:
<jsp:setProperty name=“stringBean” property = “mensaje” param =
“miParametro” />
Los tipos de datos que se encuentren asociados a los parámetros son inmediatamente convertidos
al tipo de dato de la propiedad del Bean.
Los beans se tratan como si fueran variables locales. Pero podemos hacer que se encuentren en
diferentes contextos para la aplicación. Para ello utilizamos el parámetro scope:
application : El bean será almacenado en el contexto del Servlet (ServletContext) Este será
compartido por todos los servlets en el mismo Servidor.
Session: El bean será almacenado en un objeto HttpSession asociado por el request respectivo.
Page: Valor por default. Indica que los bean serán sólo para esa página.
36
request: El bean será colocado en objeto ServletRequest durante la duración del request
especificado, donde estará disponible a través del método getAttribute
Ejemplo:
package paquete;
public class AccessCountBean {
private String firstPage;
private int accessCount = 1;
public String getFirstPage() {

return(firstPage);
}
public void setFirstPage(String firstPage) {
this.firstPage = firstPage;
}
public int getAccessCount() {
return (accessCount++);
}
}
<HTML>
<HEAD>
<TITLE>Pagina de Prueba en JSP con un Bean Compartido</TITLE>
</HEAD>
<BODY>
<TABLE BORDER =5 ALIGN = "CENTER" >
<TR> <TH CLASS = "TITLE">
Numero de Accesos Compartidos : Pagina 1
</TABLE>
<P>
<jsp:useBean id="counter" class="paquete.AccessCountBean"
scope="application" >
<jsp:setProperty name ="counter" property = "firstPage" value =
"acceso1.jsp" />
</jsp:useBean>
Desde la Pagina acceso1.jsp (esta),
<A HREF="acceso2.jsp">Pagina2</A>, y
<A HREF="acceso3.jsp">Pagina3</A>
<jsp:getProperty name="counter" property="firstPage" />
fue la primera pagina visitada.
<P>
Compartidamente, las tres paginas han sido visitadas :
<jsp:getProperty name="counter" property="accessCount" /> veces
</BODY>
</HTML>
4.8 Excepciones en JSP

• El fichero de error JSP usa una directiva page con errorPage que selecciona el nombre
de un fichero JSP que mostrara un mensaje al usuario cuando ocurre una excepción.
• Escribir un fichero de pagina de error, usando una directiva page con isErrorPage= “true”.
• En el fichero de la pagina de error, usa el objeto exception para obtener información sobre
la excepción.
37
• Usamos mensajes informativos, en nuestra pagina de error o incluida desde otros ficheros,
para darle al usuario un mensaje relevantemente informativo sobre lo que el usuario estaba
haciendo cuando se lanzo la excepción.
Ejemplo
En el proyecto del capitulo anterior en el fichero ManInserta.jsp se debería poner errorPage

en el tag <%@...%>, de la siguiente manera
<%@page import= “java.sql.*” errorPage= “errormant.jsp” %>

<html>
<head>
<title> inserta Articulos</title>
<meta http-equiv= “Expires=-1” content= “text/html;charset=iso-8859-1”>
<%! Connection con=null;
preparedStatement stmlnsert=null;
Statement stm=null;
String sglGeneral=null, sqllnsert=null;
Public void jsplnit()
{
try
{
sqlGenera= “select*from Articulos”;
sqllnsert= “Insert into Articulos values(?,?,?,?)”;
etc...
Y la pagina a la que se hace referencia (errormant,jsp) seria:
<%@page import= “java.sql.*” isErrorPage= “true”%>

<html>
<body bgcolor= “#FF8000”>
<center>
<font size= “+2” face= “arial”><b>Error de Aplicacion</B></FONT>
<p>
<%
out.print(“Error que origino:”+exception.getMessager());
%>
<tt>Disculpe la molestia vuelva a intentarlo</TT></P></CENTER>
</body>
</html>
Notar que existe un objeto implícito para que capture las excepciones y permita registrar el
contenido de la excepción
4.9 Laboratorio:
Nombre: Interfaz para Cheques
Descripción: Implementacion de Capa Interfaz.
Prerrequisitos: Laboratorio de BD y Servlet.
Mantenimiento de cheques
<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>
<%@page errorPage="/Error.jsp"%>
<html>
38
<head><title>JSP Page</title></head>
<link href="General.css" rel="stylesheet" type="text/css">
<BODY bgColor="#ffffff" leftMargin=0 topMargin=0 marginwidth="0" marginheight="0">
<TABLE align=center border=0 cellPadding=0 cellSpacing=0 width="100%">
<TR>
<td align="left"><b>Cheques</b></td>
<td align="right">
<form method='POST' action="sys.servlet.ManCheque" target='ManChequeDet'>
<input type=hidden name='opt' value='4'>
Estado
<select id='msg' name='msg'>
<option value='0'>Girados Sin Cobrar</option>
<option value='1'>Girados y Cobrados</option>
<option value='2'>Anulados</option>
</select>
<INPUT name=go type=submit value=">>">
<a href="ManChequeDet.jsp" target='ManChequeDet' >[New]</a>
</form>
</td>
</TR>
<TR>
<td align="center" colspan='2'>
<iframe name='ManChequeDet' height='355' width='756' frameborder=0>
</iframe>
</td>
</TR>
<TABLE>
</body>
</html>
Detalle de Cheque
<%@page pageEncoding="UTF-8"%>
<%@page import="sys.bean.*" %>
<%@page import="sys.data.*" %>
<html>
<%
String er=(String)request.getAttribute("ER");
String ermsg="";
Cheque o =null;
o=(Cheque)request.getAttribute("Cheque");
int opt;
if (o != null){
opt=2;
if (er!=null) {opt=1;ermsg="Error: ya Existe Cheque con Mismo Número Para este Banco";}
}
else {
opt=1;
o=new Cheque();
o.setCheque(0);
o.setNro("001");
o.setTip(1);
o.setMonto(100.0);
39
o.setEstado(0);
o.setFHIni(new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new
java.util.Date()));
o.setFHFin(new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new
java.util.Date()));
o.setObs("Ninguna");
}
System.out.println(opt);
%>
<BODY onload='javascript: init(); window.document.frm.det_tip.focus(); '>
<FORM NAME='frm' method="POST" action="sys.servlet.ManCheque">

<input type="hidden" name="opt" id="opt" value='<%=opt%>'>
<div align=center>
<TABLE class=textog cellSpacing=0 cellPadding=0 width=560>
<TBODY>
<TR><TD class=titn colSpan='4'>
Cheque<input type="hidden" name="che_codigo"
value='<%=o.getCheque()%>'>(<%=o.getCheque()%>)
</TD>
</TR>
<TR><TD colspan='4'><font color="#FF0000"><%=ermsg%></font></TD></TR>
<TR><TD colspan='4'><BR><IMG src="img/pto.gif" height=1 border=0 width='100%'></TD></TR>
<tr align="left" id="rowCalc" name="rowCalc" style="{display:none}" bgcolor='#FEFFBF'>

<td colspan='4' align=center > Dolares:
<input type="Text" name="dol" size="10" value='0'>x(<input type="Text"
name="tc" size="5" value='3.250'>)
<input type="button" value="<<" onclick="dol.value=sol.value/tc.value;">
<input type="button" value=">>" onclick="sol.value=dol.value*tc.value;">
Soles:
<input type="Text" name="sol" size="10" value='0'>
</td>
</tr>
<tr align="left">
<td class=textogn width='10'> Banco/Número*:</td>
<td colspan='1'>
<select name="det_tip" tabindex='1'>
<OPTION VALUE='1' <%if (o.getTip()==1) {%> selected <%}%>>bcp S/.</OPTION>
<OPTION VALUE='2' <%if (o.getTip()==2) {%> selected <%}%>>bcp $.</OPTION>
<OPTION VALUE='3' <%if (o.getTip()==3) {%> selected <%}%>>bif S/.</OPTION>
<OPTION VALUE='4' <%if (o.getTip()==4) {%> selected <%}%>>bif $.</OPTION>
<OPTION VALUE='5' <%if (o.getTip()==5) {%> selected <%}%>>bct S/.</OPTION>
</select>
<input tabindex='6' type="Text" name="che_nro" size="20"
value='<%=o.getNro()%>'>
</td>
<td class=textogn width='10'> Monto*:</td>
<td colspan='1'>
<input tabindex='6' type="Text" name="che_monto" size="20"
value='<%=o.getMonto()%>'>
</td>
</tr>
<tr align="left">
<td class=textogn width='10'> Estado*:</td>
<td colspan='1'>
<select name="che_estado" tabindex='1'>
<OPTION VALUE='0' <%if (o.getEstado()==0) {%> selected <%}%>>No Cobrado</OPTION>
<OPTION VALUE='1' <%if (o.getEstado()==1) {%> selected <%}%>>Cobrado</OPTION>
<OPTION VALUE='2' <%if (o.getEstado()==2) {%> selected <%}%>>Anulado</OPTION>
</select>
</td>
<td class=textogn width='10'> FH Emisión/Finalización*:</td>
<td colspan='1'>
<input tabindex='6' type="Text" name="che_fhini" size="10" value='<%=o.getFHIni()%>'>
<input tabindex='6' type="Text" name="che_fhfin" size="10" value='<%=o.getFHFin()%>'>
</td>
</tr>
40
<TR align=right>
<TD align=left>Nota Adicional: </TD>
<TD colspan='3' align=left><input type="Text" name="che_obs" size="60"
value='<%=o.getObs()%>'></TD>
</TR>
<TR><TD colspan='4'><BR><IMG src="img/pto.gif" height=1 border=0 width='100%'></TD></TR>
<TR align=right>
<TD align=left>
<input type="checkbox" name="chkCalc" value="0" onClick="return chkFiltro()"
title='Cambio $->S/.'>
<A href='#' tabindex='8' onfocus='javascript:
window.document.frm.det_tip.focus();' >$</A>
</TD>
<TD colspan='3'>
<input tabindex='7' type="submit" name="submit" value="OK!"
onClick="validate();return returnVal;">
</TD>
</TR>
</TBODY>
</TABLE>
</div>
<FORM>
</body>
</html>
Listado de Cheques lstCheques.jsp
<%@page import="sys.data.*" %>
<%@page import="sys.bean.*" %>
<%@page import="sys.list.*" %>
<html>
<link href="General.css" rel="stylesheet" type="text/css">
<body>
<%ChequeList lista = (ChequeList)request.getAttribute("lstCheque");%>
<table align=center border='1'>
<tr bgcolor="#FFEEEE" align=center>
<td>M</td>
<td>Banco</td>
<td>Número</td>
<td>Monto</td>
41
<td>Estado</td>
<td>FH Emitido</td>
<td>FH Cobrado/Anulado</td>
<td>Observaciones</td>
</tr>
<%for(int i=0;i<lista.size();i++){
String color = ((i%2)==0)?"FFFFFF":"DDDDDD";
Cheque o = (Cheque)lista.get(i);
%>
<tr bgcolor='<%=color%>'>
<td align=center>
<a href="sys.servlet.ManCheque?opt=3&Cheque=<%=o.getCheque()%>"
target='ManChequeDet' >.x.</a>
</td>
<td><%=o.getXbco()%></td>
<td><a href="sys.servlet.ManCheque?opt=10&Cheque=<%=o.getCheque()%>"
target='ManChequeDet' ><%=o.getNro()%></a></td>
<td><%=o.getMonto()%></td>
<td><%=o.getEstado()%></td>
<td><%=o.getFHIni()%></td>
<td><%=o.getFHFin()%></td>
<td><%=o.getObs()%></td>
</tr>
<%}%>
</table>
</body>
</html>
xx
42
5 Sessiones
5.1 Objetivos
• Controlar una Sesión
• Conocer la API HttpSession
5.2 HttpSession
Hay un número de problemas que vienen del hecho que http es un protocolo “sin estado”. En
particular, cuando estamos haciendo una compra online, es una molestia real que el servidor Web
no pueda reacordar fácilmente transacciones anteriores.
Esto hace que las aplicaciones como los “carritos de compras” sean muy problemáticas: cuándo
añadimos una entrada en nuestra carta, ¿como sabe el servidor que es realmente nuestro carrito?.
Incluso si son servidores no retienen información contextual, tendremos además problemas con el
comercio electrónico. Por ejemplo cuando nos movemos desde una página donde hemos
especificado que queremos comprar( almacenada en un servidor Web normal) a la pagina que
toma nuestro número de la tarjeta de crédito y la dirección de envío ( almacenada en un servidor
seguro que usa SSL), ¿ cómo recuerda el servidor lo que hemos comprado?
La reapuesta esta en que el servlet engine asigna a cada usuario un id de sesión. De esta manera
se pueden recordar variables asociadas a la sesión siendo útiles para controlar carritos de compra,
permisos de sesión y demás características que una aplicación personalizada necesita.
Algo de Historia
Estén tres soluciones típicas al problema de recordar variables en una sesión de un usuario:
1. Cookies. Podemos usar cookies http para almacenar información sobre una sesión de
compra, y cada conexión subsecuente puede buscar la sesión actual y luego extraer la
información sobre esa sesión desde un localización en la maquina del servidor. Esta es una
excelente alternativa, y es la aproximación mas ampliamente utilizada. Sin embargo, auque
los servlet tienen una interface de alto nivel para usar cookies, existen unos tediosos
detalles que necesitan ser controlados:
• Extraer el cookie que almacena el identificador de sesión desde los otros cookies (puede
haber muchos, después de todo),
• Seleccionar un tiempo de expiración apropiado para el cookie (las sesiones
interrumpidas durante 24 horas probablemente debería ser peseteadas), y
• Asociar la información en el servidor con el identificador de sesión ( podría haber
demasiada información que se almacena en el cookie, pero los datos sensibles como los
números de las tarjetas de crédito nunca deben ir en cookies).
2. Rescribir la URL. Podemos añadir una información extra al final de cada URL que identifique
la sesión, y el servidor puede asociar ese identificador de sesión con los datos que ha
almacenado sobre la sesión. Esta también es una excelente solución, e incluso tiene la
ventaja que funciona con navegadores que no soportan cookies o cuando el usuario las ha
desactivado. Sin embargo, tienen casi los mismo problemas que los cookies, a saber que
los programas del lado del servidor tienen mucho proceso que hacer, pero tedioso. Además
tenemos que ser muy cuidadosos con que cada URL que le devolvamos al usuario tiene
añadida la información extra. Y si el usuario deja la sesión y vuelve mediante un bookmark
o un enlace, la información de sesión puede perderse.
3. Campos de formulario ocultos. los formulario HTML tienen una entrada que se aparece a
esto: <INPUT TYPE=“HIDDEN” NAME = “SESION ” VALUE= “...”>. Esto significa que,
cuando el formulario se envié, el nombre y el valor especificado se incluirán en los datos
43
GET o POST. esto puede usarse para almacenar información si cada página se genera
dinámicamente, ya que el punto negro es que cada sesión tiene un único identificador.
Los servlet proporcionan una solución técnica. AI API HttpSession, este en un interface de alto
nivel construido sobre los cookies y la reestructura de URL. De hecho, muchos servidores, usan
cookies si el navegador la soporta, pero automáticamente se convierten a reescritura de URL
cuando las cookies no son soportadas o están desactivadas. Pero el autor del servlets no
necesita molestarse con muchos detalles, no tiene que manipular explícitamente las cookies o la
información añadida a la URL, y se les da automáticamente un lugar conveniente para almacenar
los datos asociados con cada sesión.
Usar sesiones en servlets es bastante sencillo, envolver la búsqueda del objeto sesión asociada
con la petición actual, crear un nuevo objeto sesión cuando sea necesario, buscar la información
asociada con una sesión, almacenar la información de una sesión, y descargar las sesiones
completas o abandonadas.
Obtener la sesión del usuario desde un servlet

Esto se hace llamando al método getSession de HttpServeletRequest. Si devuelve null, podemos
crear una nueva sesión, pero están comúnmente usada que hay una opción que crea
automáticamente una sesión si ni existe una ya. Solo pasamos get a getSession. Así nuestro
primer paso normalmente se parecerá a esto:
HttpSession session = request.getSession(true);
Buscar la información Asociada con una sesión

Los objetos HttpSession viven en el servidor; son asociados automáticamente con el peticionario
mediante un mecanismo detrás de la escena como los cookies o la reescritura de URL. Estos
objetos sesión tienen una escritura de datos interna que nos permite almacenar un numero de
claves y valores asociados. En la versión 2.1 y anteriores del API servlet, usamos getValue( “key”)
para buscar un valor previamente almacenado. El tipo de retorno es Object, por eso tenemos que
forzarlo aun tipo mas especifico de datos. El valor de retorno es null si no existe dicho atributo. En
la versión 2.2 getValue esta obsoleto a favor de getAttribute, por el mejor nombrado
correspondiente con serAttribute ( el correspondiente para getValue es putValue, no setValue), y
porque setAttribute nos permite usar un HttpsessionBindingListener asociado para monitorizar los
valores, mientras que put Value no. Aquí tenemos un ejemplo representativo, asumiendo que
ShoppingCart es alguna clase que hemos definido y que almacena información de items para su
venta.
HttpSession session = request.getSession();

ShoppingCart previousltems;
previousltems =(ShoppingCart)session.get.attribute(“previousltems”);
if (previousltems !=null){
doSomethingWith(previousltems);
}
else{
previousltems = new shoppingCart(...);
doSomethingElseWith(previousltems);
}
en la mayoría de los casos, tenemos un nombre atributo especifico en mente, y queremos

encontrar el valor (si existe) ya asociado con el, sin embargo, también podemos descubrir todos
los nombres de atributos en una sesión dada, llamado a getAttributeNames, que tienen un
nombre mejor y que es mas consistente ya que getParameterNames de HttpServletRequest.
Auque los datos que fueron asociados explícitamente con una sesión son la parte en la que
debemos tener mas cuidado, hay otra partes de información que son muy útiles también.
44
• GetID. Este método devuelve un identificador único generando para cada sesión algunas
veces es usado como el nombre clave cuando hay un solo valor asociado con una sesión,
o cuando se uso la información de logging en sesiones anteriores.
• IsNew. Esto devuelve true si el cliente (navegador) nunca ha visto la sesión,
normalmente por que acaba de ser creada en vez de empezar una referencia a una
petición de cliente entrante. Devuelve false para sesiones preexistentes.
• GetCreationTime. Devuelve la hora, en milisegundos desde 1970, en la que se creo la
sesión. Para obtener un valor útil para impresión, pasamos el valor al constructor de Date
o al método setTimeInMillis de GregorianCalendar.
• GetLastAccessedTime. Esto devuelve la hora, en milisegundos desde 1970, en que la
sesión fue enviada por ultima vez al cliente.
• GetMaxInactiveInterval. Devuelve la cantidad de tiempo, en segundos, que la sesión
deberá seguir sin accesos antes de ser invalidada automáticamente. Un valor negativo
indica que la sesión nunca se debe desactivar.
Variables de Sesión
Como se describió en la sesión anterior, leemos la información asociada con una sesión usando
getAttribute. Observa que setAttribute reemplaza cualquier valor anterior. Algunas veces esto
seria lo que queremos pero otras veces queremos recuperar un valor anterior y aumentarlo. Aquí
tenemos un ejemplo:
HttpSession session = request.getSession();

Session.putValue(“referringPage”, request.getHeader(“Reafer”));
ShoppingCart previousltems;
previousltems=(shoppingCart)session.getAttribute(“previousltems”);
If (previousltems = = null){
Previousltems = new shoppingCart(...);
}
String itemID = request.getParameter(“itemID”);
previousltems.addEntry(catalog.getEntry(itemID));
// actuallizando
session.seAttribute(“previousltems”, previousltems);
Sesiones en JSP
Para acceder al sesión del usuario en un documento jsp solo es necesario hacer referencia a la
variable implícita sesión, por ejemplo:
session.getAttribute(“idObjeto”);
obtendría cualquier variable de sesión definida en un servlet o en otro documento jsp de la sesión
del usuario. Esta característica hace que podamos compartir objetos y variables en general en
cualquier documento jsp y servelet de la sesión del usuario.
Lo mismo es si se quiere definir una variable se sesión en jsp.

session.getAttribute(“idObjeto”);
una sesión expira automáticamente cuando el usuario a entrado en inactividad por mas de 30
minutos, pero esto se puede modificar con el método setMaxInactiveInterval (tiempo_segundos).
Ejemplo:
Import java.io.*;
Import javax.servlet.*;
Import javax.servlet.http-*;
Import java.net.*;
45
Import java.util.*;
Public class showSession extends Httpservlet{

Public void diGet(HttpServletRequest request,
HttoServletResponse response)
Throws ServletException, Ioexception{
HttpSession session 0 request,get Session(true);
Response.setContentType(“text/html”);
PrintWriter out = reponse,getWriter();
String title = “buscando en la web”;
String heading
Integer accessCount = mew Interger(0);;
If (Session.isNew()){
Heading = “Bienvenido”;
} else {
heading = “Gracias por regresar ”;
integer oldAccsessCount = (integer)session.getAttribute(“accessCount”);
if (oldAccsessCount= new integer (oldAccsessCount.intValue()+1);
}
}
session.setAttribute(“accessCount”, accessCount);
out.println(servletUtilities.headWithTitle(title)+
“<BODY BGCOLOR= /”#FDF5E6/”>/n”+
“<H1 ALIGN = / “CENTER/ “>” +heading + “</H1>/n”+
“<H2> información de tu sesión:</H2>/n”+
“<TABLE BORDER=1 ALIGN=CENTER>/n”+
“<TR BGCOLOR=/ ”#FFADO00/”>/n+
“<TH>info Type<TH>Value/n”+
“<TR>/n”+
“<TD>ID/n”+
“<TD>”+session.getld()+ “/n”+
“<TR>/n”+
“<TD>CREATIOM TIME/n”+
“<TD>” +new Date(session.getLastAccessedTime())+ “/n”+
“<TR>/n”+
“<TD> Time of LastAccess/n”
“<TD> “ + new Date (session.getLastAccessedTime())+ “/n”+
“<TR>/n”
“<TD> Numero de accesos previos/n”+
“<TD> “+accessCount+ “/n”+
“</TABLE>/n”+
“</BODY></HTML>”);
}
public void doPost(HttpSrvletRequest request,

HttpServletResponse response)
Throws SevletException, IOException{
DoGet(request,response);
}
}
46
5.3 Laboratorio:
Nombre: sesiones
Descripción: Implementación ventana de validación por sesiones.
Prerrequisitos: Laboratorio de BD, Servlet y JSP.
Interfaz LogOn.jsp
<html>
<head><title>Logon</title></head>
<body onload='javascript:window.document.frm.login.focus();'>
<FORM name="frm" method="POST" action="sys.servlet.LogoOn">
<table align=center>
<tr>
<td>Usuario:</td>
<td><input type="text" name="login" id="login"></td>
</tr>
<tr>
<td>Clave:</td>
<td><input type="password" name="password" id="password"></td>
</tr>
<tr align=center>
<td colspan='2'><input type=submit value='OK!'
onclick='javascript:wopen();'></td>
</tr>
</table>
<FORM>
</body>
</html>
UserData
package sys.data;
import java.sql.*;
import sys.bean.*;
import sys.list.*;
public class UserData {
public static boolean isUser(User u){

boolean ok = false;
Statement stm=null;
ResultSet rs=null;
try{
String sql = "select nombre,cod_grupo from Usuarios where login = '"+u.getLogin()+"' and
password = '"+u.getPassword()+"'";
rs=stm.executeQuery(sql);
stm.close();
47
c.close();
if (rs.next()){
u.setNombre(rs.getString("nombre"));
u.setGrupo(rs.getString("cod_grupo"));
return true;
}
else
return false;
}
}
return ok;
}
}
Servlet LogOn
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
String us,ps;
us=request.getParameter("login");
ps=request.getParameter("password");
User u = new User();
u.setLogin(us);
u.setPassword(ps);
String ruta;
if (UserData.isUser(u)){
HttpSession session=request.getSession(true);
session.setAttribute("usuario",u);
ruta = "/navigation.jsp";
}
else
ruta = "/LogOn.jsp";
Página Principal
48
<%@page import="sys.bean.*"%>
<%@page import="sys.list.*"%>
<%@page import="sys.data.*"%>
<%
session=request.getSession(false);
User ux=new User();
ux=(User)session.getAttribute("usuario");
OptList ol=new OptList();
ol=UserData.optionsList(ux);
sys.bean.Option o=new Option();
%>
<HTML>
<HEAD>
<TITLE>Cash Flow system 0.1</TITLE>
<STYLE>
A.menu:hover{COLOR: #ffcc66; FONT-FAMILY: verdana,arial; FONT-SIZE: 11px; FONT-WEIGHT: bold;
TEXT-DECORATION: none}
A.menu {COLOR: #ffffff; FONT-FAMILY: verdana,arial; FONT-SIZE: 11px; FONT-WEIGHT: bold;
A.sub { COLOR: #000000; FONT-FAMILY: verdana,arial; FONT-SIZE: 8px; FONT-WEIGHT: normal;
TABLE { COLOR: #000000; FONT-FAMILY: verdana,arial; FONT-SIZE: 10px; FONT-WEIGHT: normal}
</STYLE>
<LINK media=all href="tim.css" type=text/css rel=StyleSheet>
</HEAD>
<BODY bgColor="#F7F9F8" leftMargin=0 topMargin=0 marginwidth="0" marginheight="0">

<TABLE align=center border=0 cellPadding=0 cellSpacing=0 width=760>
<TR>
<TD align=center height=10>
<A class=menu href="sys.servlet.Close" target=body>Cheques</A><font
color="#000000">|</font>
<A class=menu href="#" onclick="">Ayuda</A><font color="#000000">|</font>
<A class=menu href="sys.servlet.Close" title='Cerrar Aplicación'>[x]</A><font
color="#000000"></font>
</TD>
</TR>
<TR>
<TD>
<iframe align=center height=400 width=760 src='<%=(lastlk+"&caja="+caj)%>'
name=body frameborder='0'>
</iframe>
</TD>
</TR>
<TR>
<TD align=center>Copy right C 2005 MTTV corp.</TD>
</TR>
</TBODY>
</TABLE>
</BODY>
</HTML>
49
6 Appendice
6.1 Archivo de texto para leer parámetros de configuración
Es posible usar un archivo de texto para leer parámetros de configuración para ello en java se usa
archivos de texto plano con la extensión properties y en el programa se usa la clase
ResourceBundle, a continuación un ejemplo aplicado a leer parámetros de configuración para
establecer una conexión a una base de datos.
Archivo de Configuración SysConf.Proerties

#Connection Driver
DBDriver=com.inet.tds.TdsDriver
#DataBase URL contiene básicamente :Protocolo,Servidor,Puerto y BaseDatos
DBURL=jdbc:inetdae:127.0.0.1:1433?database=caja
#DataBase User
DBUs=sa
#Database password
DBPs=1234
Conexión a la BD
//Autor=
package sys.data;
import java.sql.*;
import java.util.*;
public class DataBase {
public DataBase() {
}
public static Connection getConnection(){
Connection con = null;
try{
ResourceBundle rb=ResourceBundle.getBundle("SysConf");
String url= rb.getString("DBURL");
String us= rb.getString("DBUs");
String ps= rb.getString("DBPs");
Class.forName(rb.getString("DBDriver"));
con = DriverManager.getConnection(url,us,ps);
System.out.println("DB Connection [OK]");
}
}
return con;
}
}
50

Detector de Musica

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Detector de Musica

Cargado por

Copyright:

Formatos disponibles

FACULTAD DE INGENIERIA

Desarrollo Web con JAVA 2

2 Bases de Datos con JAVA 12

4 Java Server Pages (JSP) 32

Detalle de Cheque ................................................................................................................ 39

Como Funciona Internet

• Host : Es cualquier computadora conectada a Interent y que dispone de un número IP

1.3 Documento HTML

Estructura de un documento HTML

Cuerpo del Documento

<A HREF =”http://www.idat.edu.pe”>Enlace a idat</A>

<IMG SRC=“archivo” ALT=“Mi Foto”>

Es una pagina web independiente dentro de un documento html.

1.4 Trabajando con Formularios

<form action = ”procesaVenta.html” method = “post” name = “frmVenta” >

... Elementos del Formulario...

Elementos cajas de texto

Elementos opción múltiple

Para el uso de opciones múltiples tenemos:

Elementos opción única

Elementos combos y listas

<select name=“identificador” size=“20” multiple >

<input type=“submit” name=”nom del boton” value=“valor Boton1”>

1.5 Fundamentos de Java Script

¿Qué es Java Script?

Usando Java Script

Literales : Valores que puede tomar una varible

Tipos de Dato Arrays conocidos tambien como Vectores:

Sentencias de Control Java Script

var distritos = new Array(10);

Funciones Java Script

Los parámetros de una función son por valor.

2 Bases de Datos con JAVA

2.2 Qué es un JDBC?

Dos conjuntos de Interfaces:

Tipos de Driver JDBC

Drivers para principales RDBGS:

2.4 Conexión a un RDBMS

jdbc : Protocolo. Es un valor fijo.

Conexión con SQLServer:

Conexión con Oracle:

Statement : Instrucciones SQL

Connection con = DriverManager.getConnection(url, usr, pwd);

2.5 Ejecución de sentencias SQL

executeUpdate() : INSERT, UPDATE, DELETE, CREATE TABLE, DROP TABLE.

executeQuery() : Para utilizarlo con sentencias SELECT

También podemos ejecutar sentencias en batch con el método :

Número de filas en un ResultSet :

Obteniendo Datos de un ResultSet :

Llamada a Procesos Almacenados

CallableStatement cstmt = con.prepareCall("{call getTestData(?, ?)}");

Ejecución y Control de Transacciones

2.6 Manejo de Cursores JDBC 2.0

El tipo de ResulSet lo determina la primera constante:

El segundo argumento especifica si es de Lectura o Actualizable:

Métodos para desplazarse:

Librería del Driver de Base Datos SQLServer

public class Cheque extends Object implements Serializable {

public int getCheque() {

public String getXbco() {

Lista de Objetos Cheque

Mantenimiento de Data Cheque

public class ChequeData {

public static boolean update(Cheque o){