Docente: Eduardo A.
Klagges Sazo
Manual JSP y Java WEB Segunda Parte
Scriptlets y expresiones en una JSP:
Un scriptlet es un fragmento de código en Java que se incrusta en una página
JSP. Para insertar un scriptlet en una JSP, se utiliza la siguiente sintaxis:
<% código en Java%>
A continuación, se muestra un scriptlet que sirve para recuperar los parámetros
que recibe la JSP en el objeto request y guardarlas en variables String.
<%
// Este es un scriptlet
// Es código en Java que captura los parámetros
enviados
// en el objeto "request"
String nombre = request.getParameter("nombre");
String color = request.getParameter("color");
String mail = request.getParameter("mail");
%>
Expresiones en JSP:
Una expresión se utiliza para desplegar como texto, una variable Java. Para
insertar una expresión en una JSP, se usa la siguiente sintaxis:
<%= nombreVariable %>
En el siguiente ejemplo se muestran las expresiones que sirven para desplegar
el contenido de las tres variables del scriptlet anterior:
<%= nombre %>
<%= color %>
<%= mail %>
La Figura III.2 a) muestra una página JSP llamada index.jsp que captura datos
del usuario. Al oprimir el botón “enviar”, index.jsp envía los datos (parámetros)
dentro del objeto request a la paginaDestino.jsp. La paginaDestino.jsp de la
Figura III.2 b) despliega los parámetros.
Docente: Eduardo A. Klagges Sazo
recibidos. El botón “regresar” en la paginaDestino.jsp sirve para regresar a
index.jsp.
El código de index.jsp es el siguiente:
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type"
content="text/html; charset=UTF-8">
<title> Area de texto</title>
</head>
<body>
<h1> Esta es la página de inicio</h1>
<h2> Aqui se piden los datos </h2>
Docente: Eduardo A. Klagges Sazo
<p> Hola, por favor introduce la información </p>
<form action="paginaDestino.jsp" method="post">
<table cellspacing="3" cellpadding="3" border="1" >
<tr>
<td align="right"> Nombre: </td>
<td><input type="text" name="nombre"></td>
</tr>
<tr>
<td align="right"> Color favorito: </td>
<td> <input type="text" name="color"> </td>
</tr>
<tr>
<td align="right"> Correo: </td>
<td> <input type="text" name="mail"> </td>
</tr>
</table>
<input type="reset" value="Borrar">
<input type="submit" value="Enviar">
</form>
</body>
</html>
index.jsp pide los datos al usuario y las captura en los atributos llamados
nombre, color, mail. Cuando el usuario oprime el botón “Enviar”, se
ejecuta la acción “ir a pagjnaDestino.sp”. Si no se capturó un dato, se envía el
valor null.
El código de paginaDestino.jsp es el siguiente:
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type"
content="text/html; charset=UTF-8">
<title>Pagina Destino JSP</title>
</head>
<body>
<%
// Este es un scriptlet
// Es código en Javaque captura los parámetros
enviados
// en el objeto "request"
String nombre = request.getParameter("nombre");
Docente: Eduardo A. Klagges Sazo
String color = request.getParameter("color");
String mail = request.getParameter("mail");
%>
<h1> Esta es la página destino</h1>
<h2> Aqui se despliegan los datos que se
recibieron</h2>
<p> Tus datos son los siguientes: </p>
<table cellspacing="3" cellpadding="3" border="1" >
<tr>
<td align="right"> Te llamas: </td>
<td> <%= nombre %> </td>
</tr>
<tr>
<td align="right"> Tu color favorito es: </td>
<td> <%= color %> </td>
</tr>
<tr>
<td align="right"> Y tu correo es: </td>
<td> <%= mail %> </td>
</tr>
</table>
<form action="index.jsp" method="post">
<input type="submit" value="Regresar">
</form>
</body>
</html>
Comunicación entre JSPs y clases
Java
Objetivos:
- Capturar la información del usuario en una JSP inicial y enviarla a una
clase Java que procesa la información.
- Desplegar los resultados que proporciona una clase Java en una JSP.
- Utilizar un archivo de texto para guardar la información capturada.
- Leer información de un archivo de texto y desplegarla mediante una JSP.
Conceptos básicos:
Docente: Eduardo A. Klagges Sazo
Hasta el capítulo anterior hemos estudiado cómo capturar información del usuario en una
página inicial y pasarla a una página destino para que se despliegue. Sin embargo, hasta ahora
no hemos hecho ningún tipo de procesamiento a la información.
Es posible incluir código Java en las JSPs para procesar los datos, pero esto no es una buena
práctica. Lo recomendable es utilizar algún patrón que organice la aplicación en partes
independientes.
Para aplicaciones muy sencillas, utilizamos páginas JSP para capturar y mostrar
información, es decir, p ara implementar la vista. Y el procesamiento se hace con clases
normales de Java. Sin embargo, para aplicaciones reales, que tienen mayor complejidad, es
mejor utilizar un patrón de diseño, como el Modelo-Vista-Controlador MVC que algo hemos
visto, y seguiremos estudiando en capítulos futuros.
Los hilos (threads) en una JSP
Cuando se solicita una página JSP por primera vez, el motor JSP genera un
servlet correspondiente a la página (se le llama instancia de la JSP).
La instancia de la JSP se guarda en la memoria del servidor. Si la JSP contiene
código Java, también se inicia lo que se llama un hilo (thread).
Posteriormente, cada vez que hay otra petición de la página, se utiliza la
instancia de la JSP y además, se crea otro hilo por cada nueva petición de la
página, como se ilustra en la Figura IV1.
Docente: Eduardo A. Klagges Sazo
Figura IV-1. Creación de un hilo de Java por cada petición de una JSP
Para comprender el código del ejemplo, recordemos que:
Docente: Eduardo A. Klagges Sazo
En la Figura IV2 se observa que esta página se solicitó tres veces. Esta técnica
puede fallar cuando dos computadoras solicitan la página JSP exactamente al
mismo tiempo. Se le dice en inglés no thread-safe cuando se manejan las
variables globales de esta forma. En este caso, no sería grave que se perdiera
la cuenta. Para los casos en que es indispensable que no se pierda la cuenta,
existen métodos más sofisticados para manejar variables globales de forma
más segura (thread-safe).
Docente: Eduardo A. Klagges Sazo
Encapsulamiento
Uno de los principios a seguir en el desarrollo Web es el encapsulamiento. El
encapsulamiento sirve para proteger los datos de los objetos. Éste se logra
declarando los atributos de una clase como private y codificando métodos
especiales para controlar el acceso. La manera de acceder a los atributos
desde Fuera de la clase es por medio de los métodos getter. Y la manera de
Modificar los atributos desde fuera de la clase es usando los métodos setter.
Métodos getter:
Los getters no reciben parámetros y el tipo de dato que regresan es el mismo
que el del atributo correspondiente. Su nombre comienza con “get” seguido del
nombre del atributo, pero inician con mayúscula, y regresan el valor del
atributo. Por ejemplo:
private double saldo;
private int cuenta;
. . .
public double getSaldo( ){
return saldo;
}
public int getNumCuenta( ){
return numCuenta;
}
Métodos setter:
Para que otros objetos puedan modificar el valor de los atributos de una clase,
usamos los métodos setter, por ejemplo:
public void setSaldo(double s){
Docente: Eduardo A. Klagges Sazo
saldo = s;
}
public void setNumCuenta(int num){
numCuenta = num;
}
Los setters reciben como parámetro el mismo tipo de dato que el del atributo. El
nombre de los métodos setter se construye de forma análoga a la de los getters,
pero iniciando con la palabra “set”, y asignan al atributo el valor del parámetro
recibido. El parámetro recibido tiene el mismo nombre que el atributo. Para
diferenciar entre el valor enviado como parámetro y el nombre del atributo se
utiliza la palabra ‘this’. De tal forma que this.nombreAtributo se refiere al
atributo del objeto. Por ejemplo:
public void setSaldo(double saldo){
// el parámetro saldo lo asigna al atributo this.saldo
this.saldo = saldo;
}
public void setNumCuenta(int numCuenta){
// el parámetro numCuenta lo asigna al atributo this.num-
Cuenta
this.numCuenta = numCuenta;
}
Procesamiento de los datos de una JSP con una clase
normal Java
Haciendo cálculos con una clase Java
Como ya habíamos mencionado, es una buena práctica separar las
funcionalidades de tal forma que las JSP realicen las funciones de la vista y
delegar el procesamiento de los datos a las clases Java (incluyendo los
servlets). Para una aplicación sencilla, como la del siguiente ejemplo, no es
necesario utilizar servlets, basta con una clase normal de Java. En la Figura IV3
se ilustra un ejemplo de aplicación Web en la que se requiere hacer cálculos.
Docente: Eduardo A. Klagges Sazo
En la página de inicio (Figura IV3 a), se solicitan los datos. Cuando estos datos
se envían al servidor, la aplicación Web debe realizar los cálculos y después
desplegarlos, como se muestra en la Figura IV3 b). La página de inicio es muy
sencilla, y se muestra a continuación:
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type"
content="text/html; charset=UTF-8">
<title> Captura Datos </title>
</head>
<body>
<h1> Esta es la página de inicio</h1>
<h2> Aquí se piden los datos </h2>
<p> Hola, por favor introduce la información </p>
<form action="paginaDestino.jsp" method="post">
<table cellspacing="3" cellpadding="3" border="1" >
<tr>
<td align="right"> Nombre: </td>
Docente: Eduardo A. Klagges Sazo
<td><input type="text" name="nombre"></td>
</tr>
<tr>
<td align="right"> Minuto inicial: </td>
<td> <input type="text" name="tiempoIni"> </td>
</tr>
<tr>
<td align="right"> Minuto final: </td>
<td> <input type="text" name="tiempoFin"> </td>
</tr>
<tr>
<td align="right">Distancia recorrida
(en metros):</td>
<td> <input type="text" name="distancia">
</td> </tr>
</table>
<input type="reset" value="Borrar">
<input type="submit" value="Enviar">
</form>
</body>
</html>
La siguiente clase Java, llamada Calcula es la encargada de llevar a cabo los
cálculos sobre los datos proporcionados por el usuario. Es importante que
desde el principio nos acostumbremos a hacer paquetes en donde se agrupen
las funcionalidades.
Recordar que a la realización de los cálculos se le llama lógica de negocio
(business). Entonces, haremos un paquete llamado negocios dentro de los source
packages, como
Se muestra en la Figura IV4.
El código de Calcula es el siguiente:
Docente: Eduardo A. Klagges Sazo
package negocios;
public class Calcula {
// se declaran como objetos del tipo Double
// y se encapsulan
private Double tInicial;
private Double tFinal;
private Double distancia;
private Double vel;
private Double tTotal;
// constructor de la clase con tres parámetros
public Calcula(String tIni, String tFin, String dist){
tInicial = Double.parseDouble(tIni);
tFinal = Double.parseDouble(tFin);
distancia = Double.parseDouble(dist);
}
// métodos customer
public void velocidad(){
vel = distancia/(tFinal- tInicial); }
public void tiempoTotal(){
tTotal = tFinal-tInicial;
}
// métodos accesadores getter
public Double getVel(){
return vel;
}
public Double getTiempo(){
return tTotal;
}
}// fin de la clase
La paginaDestino.jsp usa la clase Calcula para obtener los resultados de los
cálculos y los despliega ( Figura IV3 b), su código es el siguiente:
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type"
content="text/html; charset=UTF-8">
Docente: Eduardo A. Klagges Sazo
<title>Pagina Destino JSP</title>
</head>
<body>
<%@ page import="negocios.Calcula" %>
<%
// Extracción de los parámetros recibidos
String nombre = request.getParameter("nombre");
String tInicial=
request.getParameter("tiempoIni");
String tFinal =
request.getParameter("tiempoFin");
String dist = request.getParameter("distancia");
Double vel, tiempo;
Calcula calcula = new Calcula(tInicial, tFinal,
dist); calcula.velocidad();
vel = calcula.getVel();
calcula.tiempoTotal();
tiempo=calcula.getTiempo();
%>
<h2> Resultado </h2>
<p> Hola <%= nombre %> </p>
<table cellspacing="3" cellpadding="3" border="1" >
<tr>
<td align="right"> Tu tiempo total fué: </td>
<td> <%= tiempo %> minutos </td>
</tr>
<tr>
<td align="right"> Y tu velocidad: </td>
<td> <%= vel %> metros/min</td>
</tr>
</table>
<form action="index.jsp" method="post">
<input type="submit" value="Regresar">
</form>
</body>
</html>
En una aplicación web, no se hace sólo una operación (como escribir en un
archivo), sino que se requiere que el usuario pueda llevar a cabo diferentes
operaciones, por ejemplo, registrarse, buscar un registro y ver todos los
registros. Para hacer esto de una forma organizada, se usan JSPs para capturar
y desplegar datos, clases para procesar los datos y servlets para controlar el
Docente: Eduardo A. Klagges Sazo
flujo de datos entre las clases y las JSPs. En el siguiente capítulo estudiaremos
qué son los servlets
y como pasar información entre un servlet y una JSP y, entre un servlet y una
clase Java.
Ejercicio:
Hacer una aplicación Web que pida al usuario su nombre, su sueldo diario y la
cantidad de días trabajados. Al seleccionar el botón “Calcular sueldo” debe
calcular y desplegar el sueldo total. Usar JSPs y una clase Java para hacer el
cálculo. La Figura IV-6 muestra un ejemplo de ejecución de esta aplicación:
A continuación, el código de index.jsp:
<%@page contentType="text/html" pageEncoding="UTF<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<h1> Página de inicio</h1>
<p> Hola, por favor introduce la información </p>
<form action="paginaDestino.jsp" method="pos <table cellspacing="3"
cellpadding="3" border="1" >
<tr>
<td align="right"> Nombre: </td>
<td><input type="text" name="nombre"></td>
</tr>
<tr>
<td align="right"> Sueldo por Dia: </td>
<td> <input type="text" name="sueldoDia"> </td>
</tr>
<tr>
<td align="right"> Dias Trabajados: </td>
<td> <input type="text" name="diasTra"> </td>
</tr>
</table>
<br>
<br>
<form action="paginaDestino.jsp" method="post">
<input type="submit" value="Calcular sueldo" </form>
Docente: Eduardo A. Klagges Sazo
</form>
</body>
</html>
El código de la clase Calcular es el siguiente:
public class Calcular {
private final Double sDiario;
private final Double dTrabajo;
private Double Stotal;
public Calcular(String sueldoDia, String diasTrab){
sDiario = Double.parseDouble(sueldoDia);
dTrabajo = Double.parseDouble(diasTrab);
}
public void sueldototal(){
Stotal = dTrabajo*sDiario;
}
public Double getSueldo(){
return Stotal;
}
}
Finalmente, la paginaDestino.jsp:
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type"
content="text/html; charset=UTF-8">
<title>Pagina Destino</title>
</head>
<body>
<%@ page import="negocios.Calcular" %>
<%
// Extracción de los parámetros recibidos
String nombre = request.getParameter("nombre"); String
sueldoDia= request.getParameter("sueldoDia"); String diasTrab =
request.getParameter("diasTra"); Double Stotal;
Calcular calcula = new Calcular(sueldoDia, diasTrab);
calcula.sueldototal(); %>
<h2> Resultado </h2>
<p> Hola <%= nombre %> </p>
<table cellspacing="3" cellpadding="3" border="1" >
<tr>
<td align="right"> Tu Sueldo total fué: </td>
<td> <%= calcula.getSueldo() %> Pesos </td>
</tr>
</table>
<form action="index.jsp" method="post">
<input type="submit" value="Regresar">
</form>
</body>
</html>
Docente: Eduardo A. Klagges Sazo
El modelo de tres capas con JSP,
servlets, y clases Java
Objetivos:
- Estructurar una aplicación web con tres capas: Modelo, Vista y
Controlador (MVC)
- Pasar correctamente la información entre cada una de las capas del
MVC.
Los servlets y sus principales métodos
En este capítulo aprenderemos a utilizar las páginas JSP para establecer la
vista, los servlets para construir el control y clases Java para conformar el modelo
de una aplicación Web. Las JSP y las clases Java ya se estudiaron en
capítulos anteriores. En esta sección estudiaremos los servlets, con los cuales
se construyen los controladores. Un controlador recibe la información de la vista,
pide a las clases del modelo que procesen la información y, posteriormente,
manda desplegar los resultados a la vista correspondiente.
Un servlet es una clase Java que hereda de la clase HttpServlet. Los cinco
métodos más comunes de un servlet son:
public void init()throws ServletException{}
public void service(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {}
public void doPost (HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {}
public void doGet (HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {}
public void destroy(){};
Docente: Eduardo A. Klagges Sazo
Observar que los métodos service(), doPost() y doGet() tienen como
parámetros los objetos request y response. El objeto request contiene la
información que se le envía al servlet para que éste se encargue de procesarla,
y en el objeto response el servlet manda la información resultante.
En la Figura V1 se ilustra el ciclo de vida de un servlet. Cuando se llama al
servlet por primera vez, es decir, se hace una petición, éste se instancia (se
dice que “se carga”) en la memoria del servidor y se invoca al método init()
el cual se encarga de inicializarlo, posteriormente se invoca al método
service(). En las siguientes peticiones, el servlet ya está cargado en la
memoria, por lo que no es necesario invocar a init(). Entonces se llama
directamente al
service(), y éste llama a los demás métodos del servlet.
Todos los métodos en la Figura V1 ya están declarados en la clase abstracta
HttpServlet, por lo que, para usarlos, es necesario sobre-escribirlos en el
servlet.
Figura V-1. Ciclo de vida de un servlet
Finalmente, cuando la aplicación finaliza, o el servidor falla, el servlet se
descarga y se invoca al método destroy():
Paso de información de una JSP a un servlet
Aunque es posible desplegar una página HTML desde un servlet, como se
ilustró en el ejemplo de la sección anterior, esto no es una buena práctica. Los
Docente: Eduardo A. Klagges Sazo
servlets deben enviar la información a una JSP, quien se encargará de mostrar
la vista, es decir, de desplegar la página para el usuario.
Transferencia de control con el objeto request
En el ejemplo de esta sección, los datos se capturan en el index.jsp de la Figura
V3 a). Al dar clic en “Enviar”, los datos capturados se pasan al servlet
RecibeDatos.java , el cual a su vez los envía a muestraDatos.jsp (Figura V3 b):
Figura V-3. index.jsp a), envía datos a un servlet, que a su vez los envía a la
JSP de b).
Las dos instrucciones que se usan para enviar datos de un servlet a una JSP
son:
request.setAttribute(“nombreAtributo”,objetoAEnviar);
request.getRequestDispatcher(“nombre.jsp”).forward(request,
response);
En el código del servlet RecibeDatos.Java tenemos un ejemplo de su uso.
package controller;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import negocios.Alumno;
@WebServlet(name = "recibeDatos", urlPatterns = {"/recibeDatos"})
public class RecibeDatos extends HttpServlet {
protected void processRequest(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8"); PrintWriter out =
response.getWriter();
try {
String nombre= request.getParameter("nombre"); String apellidos=
request.getParameter("apellidos"); Double promedio =
Docente: Eduardo A. Klagges Sazo
Double.parseDouble(request.getParameter("prom"));
Alumno alumno = new Alumno(nombre,apellidos,promedio);
request.setAttribute("atribAlumn",alumno);
request.getRequestDispatcher(
"/muestraDatos.jsp").forward(request, response);
} finally {
out.close();
}
}
El objeto request tiene los siguientes métodos para enviar información:
setAttribute(String nombre, Object o) → Sirve para guardar un
objeto en un atributo al que se le da un nombre.
getAttribute(String nombre) → Sirve recuperar el objeto guardado en el
atributo nombre.
getRequestDispatcher( String ruta) → regresa un objeto
RequestDispatcher para la ruta especificada.
forward(request, response) → re-envia los objetos request y
response a otro recurso en el servidor, que normalmente es una JSP o un
servlet.
Finalmente, muestraDatos.jsp recibe la información que le envía el servlet
recibeDatos.java, por medio de un scriptlet, como se muestra en el
siguiente código:
<%@page contentType="text/html" pageEncoding="UTF<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type"
content="text/html; charset=UTF- <title>JSP Page</title>
</head>
<body>
<%@ page import="negocios.Alumno" %>
<%
Alumno alumno = (Alumno) request.getAttribute("atribAlumn"); %>
<h1> MuestraDatos.jsp</h1>
<h2> Aqui se despliegan los datos que envió el servlet</h2> <p> Tus datos son
los siguientes: </p>
<table cellspacing="3" cellpadding="3" border="1" >
<tr>
<td align="right"> Te llamas: </td>
<td> <%= alumno.getNombre() %> </td>
</tr>
<tr>
<td align="right"> Tus apellidos: </td>
<td> <%= alumno.getApellidos() %> </td>
</tr>
<tr>
<td align="right"> Y tu promedio es: </td>
Docente: Eduardo A. Klagges Sazo
<td> <%= alumno.getPromedio() %> </td>
</tr>
</table>
<form action="index.jsp" method="post">
<input type="submit" value="Regresar">
</form>
</body>
</html>
Transferencia de control con el objeto response
También existe una forma de transferir a otra URL, y es con el siguiente
método del objeto response:
sendRedirect(String ruta) → se envía al cliente a la ruta especificada.
Este método no transfiere los objetos request y response, por lo tanto, sólo
se utiliza para re-direccionar a una URL específica, usualmente fuera de la
aplicación actual.
Comunicación entre servlets y clases Java
Los servlets constituyen el controlador de la aplicación, éstos utilizan las clases
Java para procesar la información. Estas clases conforman el modelo.
Una vez procesada la información, los servlets la mandan desplegar a la vista.
El intercambio de información entre servlets y clases Java es trivial. Sólo es
necesario importar en el servlet, la o las clases con las que trabaja. Para enviar
información a una clase, se instancia un objeto en el servlet y se envían los
parámetros en el método constructor. El resultado del procesamiento se
obtiene con los métodos de la clase diseñados para proporcionar datos Y
resultados.
Un ejemplo claro es el servlet MuestraRegistro.java de la sección V.2.
En el ejemplo de esta sección, modificaremos el proyecto anterior de tal forma
que los datos que introduce el usuario se guarden en un archivo llamado
promedios.txt, cuando el usuario haga clic en el botón “Registrar”. Después de
que los datos se guardan en el archivo, se despliega la página muestraDatos.jsp
con los datos que se
guardaron, como se aprecia en la Figura V4b).
Docente: Eduardo A. Klagges Sazo
Figura V-4. Registro de los datos del usuario en un archivo
Para procesar el registro, codificaremos el servlet RecibeDatos.java , el cual
recibe los datos proporcionados por index.jsp y encarga a la clase
EscribeArchivo.Java que los guarde en el archivo. Los datos que se
guardaron se despliegan en muestraDatos.jsp. El código de
recibeDatos.Java es el siguiente:
package controller;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import negocios.*;
@WebServlet(name = "recibeDatos", urlPatterns = {"/RecibeDatos"})
public class recibeDatos extends HttpServlet {
protected void processRequest(HttpServletRequest r
HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html;charset=UTF PrintWriter out =
response.getWriter();
try {
String nombre= request.getParameter("nombre"); String apellidos=
request.getParameter("apellidos"); Double promedio =
Double.parseDouble(request.getParameter("prom"));
Alumno alumno = new Alumno(nombre,apellidos,prom
ServletContext sc = this.getServletContext(); String path =
sc.getRealPath("/WEB-INF/Promedios.txt"); path = path.replace('\\','/');
// Guardar en archivo
EscribeArchivo.add(alumno, path);
request.setAttribute("atribAlumn",alumno);
request.getRequestDispatcher("/muestraDatos.jsp")
.forward(request, response);
} finally {
out.close(); }
}
@Override
protected void doPost(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
processRequest(request, response);
Docente: Eduardo A. Klagges Sazo
}
}
RecibeDatos.Java hace uso de las clases Alumno.Java y
EscribeArchivo.java de la sección IV.2.2.
muestraDatos.jsp tiene el siguiente código:
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type"
content="text/html; charset=UTF-8">
<title>Muestra Datos</title>
</head>
<body>
<%@ page import="negocios.Alumno" %>
<%
Alumno alumno = (Alumno) request.getAttribute("atribAlumn");
%>
<h3> MuestraDatos.jsp</h3>
<p> Se guardaron los siguientes datos: </p>
<table cellspacing="3" cellpadding="3" border="1" > <tr>
<td align="right"> Nombre: </td>
<td> <%= alumno.getNombre() %> </td>
</tr>
<tr>
<td align="right"> Apellidos: </td>
<td> <%= alumno.getApellidos() %> </td>
</tr>
<tr>
<td align="right"> Promedio: </td>
<td> <%= alumno.getPromedio() %> </td>
</tr>
</table>
<form action="index.jsp" method="post">
<input type="submit" value="Regresar">
</form>
</body>
</html>
Ahora agregaremos funcionalidad al botón “Ver alumnos”, de index.jsp (ver
Figura V4 a) con el cual se mostrarán todos los alumnos registrados en
promedios.txt. Con este botón se invoca al servlet MuestraRegistro.java,
el cual pide a la clase LeeArchivo.java que lea los datos del archivo
solicitado y los capture en un ArrayList. Posteriormente pasa esta
información a alumnosRegistrados.jsp, la
Cual despliega todos los registros recibidos. Como se muestra en la Figura V-5:
Docente: Eduardo A. Klagges Sazo
Figura V-5. Página que despliega todos los registros leidos en «promedios.txt
package controller;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import negocios.Alumno;
import negocios.LeeArchivo;
@WebServlet(name = "muestraRegistro",
urlPatterns = {"/muestraRegistro"})
public class muestraRegistro extends HttpServlet {
protected void processRequest(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try {
ArrayList <Alumno> alumnos = new ArrayList<Alumno>();
int cont=0;
String contador;
ServletContext sc = this.getServletContext();
String path = sc.getRealPath("/WEB-INF/Promedios.txt");
path = path.replace('\\','/');
Docente: Eduardo A. Klagges Sazo
alumnos = LeeAlumno.leeAlumnos(path);
// Resetea la variable estática
LeeArchivo.clearCont();
cont = LeeArchivo.getCont();
contador= String.valueOf(cont);
request.setAttribute("Alumnos",alumnos);
request.setAttribute("contador", contador);
request.getRequestDispatcher("/alumnosRegistrados.jsp")
.forward(request, response);
} finally {
out.close();
}
}
}
La clase para leer de un archivo de texto LeeArchivo.Java es la
siguiente:
package negocios;
import java.io.*;
import java.util.ArrayList;
public class LeeArchivo {
private static int cont = 0;
private static File archivo;
private static FileReader fr;
private static BufferedReader br;
static ArrayList <Alumno> alumnos = new ArrayList<Alumno>();
public static ArrayList <Alumno> leeAlumnos(String path){
try {
archivo = new File(path);
fr = new FileReader(archivo);
br = new BufferedReader(fr);
String linea=null;
String [] tokensLinea = null;
String nombre;
DRA. MARÍA DEL CARMEN GÓMEZ FUENTES Y DR. JORGE CERVANTES OJEDA
String apellido;
Double promedio;
Alumno alumno;
linea=br.readLine();
while( linea!=null){
while( linea!=null){
tokensLinea = linea.split(",");
nombre =tokensLinea[0];
apellido=tokensLinea[1];
promedio= Double.parseDouble(tokensLinea[2]);
alumno = new Alumno(nombre, apellido, promedio);
alumnos.add(alumno);
cont++;
linea=br.readLine();
}
}catch(Exception e){
e.printStackTrace();
}finally{
try{
if( null != fr )
fr.close();
}catch (Exception e2){
e2.printStackTrace();}
}
return alumnos;
Docente: Eduardo A. Klagges Sazo
public static int getCont(){
return cont;
}
public static void clearCont(){
cont=0;
}
}
cont cuenta el número de registros leídos. Nótese que cuando el servlet
pasa el contador a alumnosRegistrados.jsp, lo pasa como String (no como
un entero), por lo que hay que hacer la conversión correspondiente.
La aplicación Web de este ejemplo está organizada con el modelo de tres
capas MVC (Modelo Vista Controlador). En la Figura V6 observamos que
las páginas JSP forman la vista de la aplicación ya que son la interfaz con
el usuario, éstas se encargan de capturar y mostrar datos.
Los servlets: RecibeDatos.Java y MuestraRegistro.Java funcionan
como controladores.
Éstos hacen uso de las clases que están en el modelo para procesar los
datos Recibidos. y transferir el control a una JSP. Y el modelo y está
formado por las clases EscribeArchivo.java, Alumno.Java y
LeeArchivo.java.
Figura V-6. Modelo de tres capas MVC
A continuación, presentamos el código de la página alumnosRegistrados.jsp
a la cual el servlet MuestraRegistro.Java transfiere el control cuando
ha terminado de leer los datos del archivo.
En este caso en particular, usamos un ArrayList para guardar los objetos de
la clase Alumno leídos en el archivo. Sin embargo, puede usarse también un
LinkedList.
Docente: Eduardo A. Klagges Sazo
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type"
content="text/html; charset=UTF-8">
<title>Alumnos Registrados</title>
</head>
<body>
<%@ page import="negocios.Alumno, java.util.ArrayList" %>
<h2>Los alumnos que están registrados son: </h2>
<%
ArrayList<Alumno> alumnos = null;
alumnos =
(ArrayList<Alumno>)request.getAttribute("Alumnos");
String numReg= (String) request.getAttribute("contador");
int numRegistros = Integer.parseInt(numReg);
%>
<table border="1">
<tr>
<th>Nombre</th>
<th>Apellidos</th>
<th>Promedio</th>
</tr>
DRA. MARÍA DEL CARMEN GÓMEZ FUENTES Y DR. JORGE CERVANTES OJEDA
<%
for (Alumno alumno: alumnos)
{
%>
<tr valign="top">
<td><%=alumno.getNombre() %></td>
<td><%=alumno.getApellidos() %></td>
<td><%=alumno.getPromedio() %></td>
</tr>
<% } %>
<% alumnos.clear();%>
</table>
<p> Numero de registros : <%= numRegistros %></p>
<br>
<form action="index.jsp" method="post">
<input type="submit" value="Regresar">
</form>
</body>
</html>
El codigo de la clase Alumno.java es el siguiente:
package negocios;
public class Alumno {
private String nombre;
private String apellidos;
private Double promedio;
public Alumno(String nombre, String apellidos,
Double promedio){
this.nombre = nombre;
this.apellidos = apellidos;
this.promedio = promedio;
}
public String getNombre(){
return nombre;
}
Docente: Eduardo A. Klagges Sazo
public String getApellidos(){
return apellidos;
}
public Double getPromedio(){
return promedio;
}
public String toString(){
return (nombre+" "+apellidos+" tiene promedio: "+promedio);
}
}
La organización del proyecto en NetBeans se ilustra en la Figura V7. La
vista (páginas JSP) siempre van en la carpeta WEB-Pages. Los servlets y
clases Java deben estar agrupados en paquetes dentro de la carpeta
Source Packages.
Normalmente, se le llama “controller” al paquete en donde se encuentran
los servlets, ya que es en éste en donde se llevan a cabo las funciones del
controlador. Al paquete en donde se realizan las funciones del modelo se
le suele llamar modelo”(model) o también “negocios” (business).
Figura V-7. Estructura del proyecto en NetBeans
Planteamiento:
Hacer una aplicación Web que haga lo siguiente:
a) En la Figura V8 a) se muestra la página principal de la aplicación (index.jsp).
Cuando el usuario introduce los datos de un producto y da clic en el botón
“Registrar”, los datos se envían a un servlet llamado
Docente: Eduardo A. Klagges Sazo
RegistraProducto.java, este servlet pide a la clase
GuardaProducto.Java que guarde los datos en un archivo
llamado productos.txt. Finalmente, RegistraProducto.Java Envía los
datos que se registraron a la página muestraRegistro.jsp
como se muestra en la Figura V8 b). La página muestraRegistro.jsp tiene un
botón para regresar a la página principal.
b) Cuando el usuario oprime el botón “Mostrar Registros” en la página principal
de la aplicación (index.jsp), se invoca al servlet muestraProductos.java.
Este servlet pide a la clase leeProductos.Java que lea todos los productos
que están guardados en el archivo productos.txt. El servlet
muestraProductos.Java envía un arrayList con todos los productos del
archivo a la página despliegaProductos.jsp como en la Figura V9:
Figura V-9. despliegaProductos.jsp muestra todos los productos registrados en el archivo productos.txt
Fin de la segunda parte de esta guía manual JSP y Java WEB
