Descarga la aplicación para disfrutar aún más
Lea materiales sin conexión, sin usar Internet. Además de muchas otras características!
Desarrollo Web con Java
Jose ricaurte
Compartir
Vista previa del material en texto
4. DESARROLLO WEB CON JAVA – JSP & SERVLETS
La programación de aplicaciones web sobre la especificación de JSP y Servlets es un subconjunto de la
plataforma Java EE.
Existen muchas formas de estructurar una aplicación web en función de los elementos y patrones de diseño
empleados y la complejidad del propio desarrollo (Fuente: INTEGRATING SERVLETS AND JSP: THE MODEL VIEW
CONTROLLER (MVC) ARCHITECTURE).
Aplicaciones sencillas o
equipo de desarrollo
pequeño
Aplicaciones complejas o
equipo de desarrollo
grande
Invocar a clases directamente desde el código Java: el código Java estará
embebido en el JSP. En este caso se programa la lógica de negocio en el
JSP. Nada recomendable.
Invocar a clases Java de forma indirecta: se embeberá el código
necesario para invocar a las clases que formen parte de la lógica de
negocio.
Utilización de beans (MVC 1): las clases que formen parte de la lógica de
negocio serán implementadas como beans.
Utilización de una arquitectura MVC 2: un Servlet gestionará las
peticiones, invocará a la lógica de negocio, accederá a los datos y
guardará el resultado en beans. El Servlet almacenará los resultados en la
request y la redirigirá al JSP para mostrar los resultados. La página JSP
utiliza beans.
Utilización de JSP EL (Expression Language): utilización de un lenguaje
sencillo y abreviado para manejar los resultados generados por el
controlador.
Utilización de etiquetas personalizadas: se utilizará un gestor de
etiquetas basadas en XML. Se requiere de un framework que gestione
estas etiquetas de funcionalidad añadida.
QUÉ ES UN BEAN
Un bean es un objeto convencional Java, el cual tiene como propósito encapsular a otros (de ahí su nombre) o
no. Para que una clase pueda ser tratada como bean debe cumplir con una serie de requisitos básicos:
Debe tener un constructor sin argumentos.
Sus atributos (propiedades) deben ser accesibles mediante métodos getter y setters públicos.
Debe ser serializable.
4.1. SERVLETS
Programas Java que se codifican en forma de clases. Los servlets heredan de la clase HttpServlet y permiten
gestionar elementos HTTP mediante las clases:
HttpServletRequest: recibe la petición (ámbito de request).
HttpServletResponse: genera la respuesta.
HttpSession: permite crear una sesión común a un conjunto de request (ámbito de sesión).
ServletContext: gestiona la información común a todas las peticiones realizadas sobre la aplicación
(ámbito de aplicación). Se obtiene a partir del método getServletContext() de la clase HttpServlet.
4.2. JSP
http://www.apl.jhu.edu/~hall/java/Servlet-Tutorial/
4.2.1. SCRIPTLETS
Páginas HTML con código Java embebido de dos formas:
Scriptlets: código Java multi-mensaje entre los símbolos <% %>. Cada mensaje debe ir separado por
punto y coma.
Expresiones: un mensaje Java que devuelve un resultado. No finaliza con punto y coma y se escribe
entre los símbolos <%= %>.
Los elementos HTTP definidos en los servlets están predefinidos en los JSP, como:
request
response
sesión
application
Estos objetos se podrán invocar directamente sin necesidad de definirlos, como se puede ver en el siguiente
ejemplo:
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<h1>Bienvenido</h2>
La hora actual es: <%= new java.util.Date() %>
<%
Persona p = new Persona(request.getParameter(“nombre”));
session.setAttribute(“usuario”, p);
out.println(p.getNombre());
%>
</body>
</html>
Código 11. Ejemplo de JSP tratando objetos.
Se pueden manipular las diferentes peticiones HTTP mediante el método getHeader(String
nombreCabecera).
<%
if(request.getHeader("user-agent").contains("iPhone"))
response.sendRedirect("/m/index.jsp");
%>
Código 12. Ejemplo de JSP manipulando cabeceras HTTP.
http://www.apl.jhu.edu/~hall/java/Servlet-Tutorial/
4.2.2. JSP TAGS
Otra forma más estructurada y elegante de implementar el código Java en la página JSP es mediante la utilización
de etiquetas JSP, al estilo HTML. Poseen una funcionalidad muy reducida y se utilizan sobre todo para la creación
y utilización de beans. También, se puede especificar de forma añadida el ámbito del bean con el parámetro
scope.
<jsp:useBean id="hora1" class="service.ServicioHora" scope="session" />
<jsp:setProperty name="hora1" property="hora" value="12" />
<jsp:getProperty name="hora1" property="hora" />
Código 13. Utilización de un Bean mediante JSP Tags.
En el caso de que los valores a asignar a las propiedades del bean sean parámetros de una petición POST/GET, se
utilizará param para establecer un parámetro determinado o property=”*” para asignar todos los
parámetros a las propiedades. En este último caso, el nombre de los parámetros deberá coincidir con el nombre
de la propiedad.
<jsp:useBean id="hora1" class="service.ServicioHora" scope="session" />
<jsp:setProperty name="hora1" property="hora" param="time" />
<jsp:setProperty name="hora1" property="*" />
Código 14. Recuperación de parámetros y creación de un Bean mediante JSP tags.
4.3. ARQUITECTURA MVC
Fuente: http://www.oracle.com/technetwork/articles/javase/servlets-jsp-140445.html
4.3.1. MVC 1
http://www.oracle.com/technetwork/articles/javase/servlets-jsp-140445.html
4.3.2. MVC 2
4.4. SESIONES
En una aplicación web existen tres contextos diferentes de trabajo. Por un lado está el contexto de la petición
web, como una request que realiza un usuario contra un recurso del servidor web. Cada petición del usuario
tiene su propio de espacio de memoria independiente. Si se desea compartir un espacio de memoria entre todas
las peticiones realizadas por un mismo usuario, se debe trabajar con el concepto de sesión (session). Esto es muy
útil, por ejemplo, para comprobar si el usuario está accediendo a un recurso de la aplicación y previamente se ha
autenticado. Por último, se puede compartir información entre todos los usuarios de la aplicación en el espacio
de memoria de aplicación (application).
Por defecto, cuando se crea una sesión para un usuario se genera un identificador único para él en forma de
Cookie en su navegador. El nombre de esta Cookie es JSESSIONID.
El trabajar con sesiones, conlleva a que el usuario tenga habilitada la aceptación de cookies en su navegador. Por
este motivo existe otra técnica en la que se envía el identificador de sesión JSESSIONID como un parámetro más
de la URL.
Es importante destacar que esta práctica es negativa desde el punto de vista de SEO (distintas URLs, muestran el
mismo contenido) y desde el punto de vista de seguridad, por la visibilidad del identificador de la sesión.
Aplicación:
o Contenido del fichero web.xml:
<context-param>
<param-name>bd</param-name>
<param-value>personas</param-value>
</context-param>
o Código Java de acceso a los parámetros:
this.getServletContext().getInitParameter("bd");
Sesión
o Código Java de creación de la sesión:
HttpSession sesion = request.getSession();
sesion.setAttribute("persona", p1);
o Código Java de acceso a los atributos creados sobre la sesión:
HttpSession sesion = request.getSession();
if(sesion.getAttribute("persona")!=null)
Request
o Código Java de acceso a un atributo de la request:
String nombre = request.getParameter(“nombre”));
Operaciones que se pueden realizar con sesiones:
boolean isNew(): devuelve true si el cliente no tenía una previamente y el servidor la ha creado.
void setMaxInactiveInterval(int segundos): establece el tiempo máximo de inactividaden la sesión para
inhabilitar la sesión.
invalidate(): inhabilita la sesión.
4.5. COOKIES
Las cookies permiten persistir información en el lado del cliente, vinculando un servidor con el ordenador, y
nunca con el usuario. Generalmente, se utilizan para mejorar la experiencia de navegación del usuario.
La creación de la cookie se realiza en el servidor gracias a la clase Cookie, enviándosela al navegador a través
de la response, como se muestra en el código siguiente.
Cookie c = new Cookie("usuario", request.getParameter("usuario"));
c.setComment("Control de acceso");
c.setMaxAge(60*60*24); //expresado en segundos
response.addCookie(c);
Código 15. Servlet creando una cookie.
El navegador almacenará la cookie en el navegador.
Y se podrá recuperar posteriormente para procesarla.
<%
String valorUsuario = "Introduzca su usuario";
Cookie [] cookies=request.getCookies();
if(cookies!=null)
{
for(int i=0;i<cookies.length;i++)
{
Cookie c = cookies[i];
if(c.getName().equals("usuario"))
valorUsuario = c.getValue();
}
}
%>
<h1>Bienvenido</h1>
<form action="/EjemploMVC/Validar" method="POST">
Usuario: <input type="text" name="usuario" value="<%=valorUsuario%>">
<input type="submit" value="Acceder">
</form>
Código 16. Ejemplo de JSP recuperando las cookies del cliente.
A continuación se describen algunas características de las cookies y cómo se implementan en Java:
Cookies no manipulables desde Javascript en el
cliente: estás cookies mitigan los ataques del tipo XSS.
c.setHttpOnly(true);
Cookies persitentes: permanecen vivas durante el
tiempo especificado.
c.setMaxAge(Integer.MAX_VALUE);
Cookies de sesión: cuando se cierre el navegador, se
elimnará.
c.setMaxAge(-1);
Cookies seguras: se enviarán sólo mediante HTTPS. c.setSecure(true);
A continuación se muestra un ejemplo de cookies leídas mediante Javascript, definidas como HttpOnly y sin
definir esta propiedad.
Código cliente
<script>
function leerCookies()
{
alert("Cookies leidas: " + document.cookie.split(";"));
}
</script>
<small><a href="javascript:leerCookies();">leer cookies mediante
Javascript</a></small>
Código de generación de la Cookie
Cookie c = new Cookie("pag", request.getParameter("pag"));
c.setComment("aaaaaaaaaa");
c.setMaxAge(Integer.MAX_VALUE); //expresado en segundos
response.addCookie(c);
Resultado sin definir la Cookie como HttpOnly
Código de generación de la Cookie
Cookie c = new Cookie("pag", request.getParameter("pag"));
c.setComment("aaaaaaaaaa");
c.setHttpOnly(true);
c.setMaxAge(Integer.MAX_VALUE); //expresado en segundos
response.addCookie(c);
Resultado definiendo la Cookie como HttpOnly
4.6. EXPRESSION LANGUAGE (EL)
Lenguaje que simplifica el proceso de recuperación de objetos almacenados en los elementos básicos de una
aplicación web como son la request, session, cookies, etc. EL está basado en una notación sencilla identificando
los objetos entre los caracteres ${….}. La ventaja del lenguaje EL es poder utilizar cualquier objeto depositado
como atributo en la request con la expresión ${objeto.propiedad}, sin necesidad de referenciar a este
ámbito, ni realizar downcastings.
EL está incorporado por defecto en la especificación JSP 2.0.
Así, el acceso a los objetos depositados en la request (típica acción de un patrón MVC) se accederá directamente.
Para el resto de elementos (parámetros, cookies, session, etc.) se utilizarán objetos predefinidos.
JSP estándar JSP con EL
<% ArrayList<Persona> lista =
(ArrayList<Persona>)
request.getAttribute("listaResultado");
%>
${listaResultado}
<% Persona p = (Persona)
request.getAttribute ("persona");
String nombre = p.getNombre(); %>
${persona.nombre}
<%= request.getParameter("nombre") %> ${param["nombre"]}
Código 17. Comparación entre JSP estándar y EL.
Objetos predefinidos:
param
paramValues
header
headerValues
cookie
initParam
Objetos predefindos en función del ámbito que posean:
pageScope
requestScope
sessionScope
applicationScope
${sessionScope.validado}
${cookie.usuario.value}
${header['User-Agent']}
Código 18. Ejemplo de acceso a elementos Java Web mediante el lenguaje EL.
4.7. JSTL
http://download.oracle.com/docs/cd/E17802_01/products/products/jsp/jstl/1.1/docs/tlddocs/
http://www.labcom.upcomillas.es/isw2/docs/JSTL.pdf
La librería JSTL está definida en la especificación Java EE. Define un conjunto de etiquetas estandarizadas que
simplifica el desarrollo de aplicaciones MVC. Las etiquetas JSTL se organizan en 4 librerías:
core: funciones script básicas como loops, condicionales, y entrada/salida.
xml: procesamiento de xml
fmt: la internacionalización y formato de valores como de moneda y fechas.
sql: acceso a base de datos.
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Ejemplo JSTL</title>
<link rel="stylesheet" type="text/css" href="r/estilos.css" />
</head>
<body>
<p class="titulo">Información de las personas de la Base de Datos:</p>
<hr>
<table border="1" width="200">
<tr>
<th>Nombre</th>
<th>Edad</th>
<th>DNI</th>
</tr>
<c:forEach var="persona" items="${personas}">
<tr>
<td>${persona.nombre}</td>
<td>${persona.edad}</td>
<td>${persona.dni}</td>
</tr>
</c:forEach>
</table>
<br>
<a href="/ISW2EjemploMVC/index.jsp">Nueva búsqueda</a>
</body>
</html>
Código 19. Ejemplo de vista JSTL.
<c:forEach var="persona" items="${personas}" varStatus=”contador”>
<tr>
<td>${contador.count}</td>
<td>${contador.first}</td>
<td>${contador.last}</td>
</tr>
</c:forEach>
Código 20. Empleo del contador de estado varStatus en un bucle forEach.
http://download.oracle.com/docs/cd/E17802_01/products/products/jsp/jstl/1.1/docs/tlddocs/
http://www.labcom.upcomillas.es/isw2/docs/JSTL.pdf
<c:if test="${sessionScope.validado!=null}">
<h1>Bienvenido, ${sessionScope.nombre}.</h1>
<h2>Tu cookie de usuario es: ${cookie.usuario.value}</h2>
<h2>Tu información del navegador: ${header['User-Agent']}</h2>
</c:if>
Código 21. Ejemplo de JSTL manipulando distintos tipos de variables: sesión, cookies y cabeceras HTTP.
Continuar navegando
Compartir