¿Qué es JSP?
La tecnología Java para la creación de páginas web con programación en el servidor.
JSP es un acrónimo de Java Server Pages, que en castellano vendría a decir algo como Páginas de Servidor Java. Es, pues, una tecnología orientada a crear páginas web con programación en Java.
Con JSP podemos crear aplicaciones web que se ejecuten en variados servidores web, de múltiples plataformas, ya que Java es en esencia un lenguaje multiplataforma. Las páginas JSP están compuestas de código HTML/XML mezclado con etiquetas especiales para programar scripts de servidor en sintaxis Java. Por tanto, las JSP podremos escribirlas con nuestro editor HTML/XML habitual.
Motor JSP
El motor de las páginas JSP está basado en los servlets de Java -programas en Java destinados a ejecutarse en el servidor-, aunque el número de desarrolladores que pueden afrontar la programación de JSP es mucho mayor, dado que resulta mucho más sencillo aprender que los servlets.
En JSP creamos páginas de manera parecida a como se crean en ASP o PHP -otras dos tecnologías de servidor-. Generamos archivos con extensión .jsp que incluyen, dentro de la estructura de etiquetas HTML, las sentencias Java a ejecutar en el servidor. Antes de que sean funcionales los archivos, el motor JSP lleva a cabo una fase de traducción de esa página en un servlet, implementado en un archivo class (Byte codes de Java). Esta fase de traducción se lleva a cabo habitualmente cuando se recibe la primera solicitud de la página .jsp, aunque existe la opción de precompilar en código para evitar ese tiempo de espera la primera vez que un cliente solicita la página.
Ventajas y desventajas de JSP
Ventajas
La principal ventaja de JSP frente a otros lenguajes es que el lenguaje Java es un lenguaje de propósito general que excede el mundo web y que es apto para crear clases que manejen lógica de negocio y acceso a datos de una manera prolija. Esto permite separar en niveles las aplicaciones web, dejando la parte encargada de generar el documento HTML en el archivo JSP.
Otra ventaja es que JSP hereda la portabilidad de Java, y es posible ejecutar las aplicaciones en múltiples plataformas sin cambios. Es común incluso que los desarrolladores trabajen en una plataforma y que la aplicación termine siendo ejecutada en otra.
Etiquetas JSP para simplificar el código y dar mayor funcionalidad.Desarrollar sitios web utilizando etiquetas presenta ciertas ventajas como; facilitar el aprendizaje, facilitar el mantenimiento, fomentar la modularidad y la reutilización y simplificar el código y reducir el número de líneas necesarias.
Otras de las ventajas de JSP es que es un lenguaje totalmente escrito, fuerte capacidad de manipulación de gráficos, cargas de APIs: Interfaz de programación de aplicaciones.
También tenemos el Open source; código abierto es la expresión con la que se conoce al software distribuido y desarrollado libremente.
La ventaja que también es fundamental de JSP es que tenemos el lenguaje java a nuestro alcance. JSP tiene robustez y es multiplataforma.
Desventajas
Una de las desventajas que JSP tiene es que no posee una interfaz, ya que la interfaz web es limitada, la codificación de interfaces elaboradas lleva muchas líneas de código, y la mayoría debe hacerse usando scripts (javascript). No tiene tipo VARIANT de variables, tampoco soporta Switchs o arrays con índices alfanuméricos, y la carga de la interfaz es más lenta que la de una aplicación de escritorio.
Otra desventaja que también tiene es que la mayor parte de la lógica de la aplicación se ejecuta en el servidor, por lo que se corre el riesgo de sobrecargar al mismo y, la aplicación no está disponible si ocurre algún problema con el servidor o con la conexión de red.
API JSP
API significa Interfaz de programación de aplicaciones que permite a los programadores crear aplicaciones de software en Java. La API de JSP se clasifica en los siguientes paquetes:
| PAQUETES | DESCRIPCIÓN |
|---|---|
| javax.el | Proporciona clases e interfaces utilizadas por JSP para evaluar expresiones. |
| javax.servelt.jsp | Contiene clases e interfaces que describen la implementación de la página JSP. |
| javax.servlet.jsp.el | Contiene clases y interfaces que definen la implementación de la página JSP soportada por el contenedor JSP. |
| javax.servlet.jsp.tagext | Se utiliza para definir bibliotecas de etiquetas, lo que significa identificar etiquetas personalizadas en la página JSP. |
Formas de utilizar JSP
Declaraciones
Las declaraciones de variables o métodos se hacen en JSP en la forma
<%! declaración de variable o método; %>
Note el signo (!) de admiración que acompaña justo detrás del signo porcentaje (%), allí donde comienza del código JSP.
Estas variables o métodos así definidos serán globales y por tanto accesibles desde cualquier lugar de la página JSP. Hay que tener en cuenta que el servidor a través del motor JSP transforma la página JSP en un servlet, y éste es usado por múltiples peticiones, lo que provoca que este tipo de variables conserven su valor entre sucesivas llamadas o ejecuciones. Las declaraciones se ejecutan una única vez, en la primera llamada al servlet equivalente.
En el caso de una declación múltiple,
<%! variable1; [variable2;] … %>
También puede inicializarse las variables en el momento de la declaración, como por ejemplo:
<%! int contador = 0; %>
Los ocho tipos de datos primitivos incluidos en el lenguaje de programación Java que pueden declararse para una variable son: byte, short, int, long, float, double, boolean y char.
También puede usarse esta otra sintaxis
Ejemplo1:
Queremos declarar y asignar valores a tres variables numéricas a través de declaraciones JSP para calcular finalmente el valor medio.
Iniciamos una nueva sesión con Netbeans IDE, abrimos un proyecto nuevo del tipo “Java Web” – “Web Application”, le damos por nombre declaraciones1 y sustituimos el archivo index.jsp por el siguiente código:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| <%-- Document : index Created on : 09-dic-2007, 20:16:33 Author : jtagua--%><%@page contentType="text/html" pageEncoding="UTF-8"%><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Ejemplo Declaraciones1</title> </head> <body> <%! double num1=2.2, num2=4.4, num3=6.0;%> <h2> <center> Los números a promediar son: <%=num1%>, <%=num2%> y <%=num3%><br><hr> <%! public double media(double n1,double n2,double n3){ return (n1+n2+n3)/3; } %> Media = <%=media(num1,num2,num3)%> </center> </h2> </body></html> |
En el ejemplo anterior, puede verse la declaración de las variables en la línea 17, la declaración del método media en la línea 21, la utilización de las variables en la línea 20 y finalmente la utilización de la media en la línea 22. En los dos últimos casos y para mostrar los valores tanto de las variables como de la media se han utilizado expresiones JSP. Ver Tutorial JSP(3) – Expresiones.
Si ahora ejecuta el programa (Ejecutar en el menú principal o F6) aparecerá en el navegador:
Scriptlet
Un scriplet en JSP es un fragmento de código Java escrito entre los símbolos <% y %>, es decir
<% código Java %>
en general, puede escribir cualquier código Java y esto, el hecho de disponer de todo el lenguaje Java detrás, es precisamente lo que hace que JSP sea el lenguaje de script de servidor mas potente. Más que ASP o PHP.
Ejemplo1:
Queremos producir un programa JSP que devuelva al cliente la fecha y hora del servidor, produciendo la salida,
Para hacer esto iniciamos una sesión de NetBeans y hacemos desde el menú principal “Archivo”, “Proyecto Nuevo”, “Java Web”, “Web Application” y damos nombre al archivo jsp en la forma de scriplet1, finalmente sustituimos el archivo index.jsp por el siguiente código,
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| <%-- Document : index Created on : 23-sep-2009, 19:45:27 Author : Juan Tagua--%><%@page contentType="text/html" pageEncoding="UTF-8"%><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Scriplet en páginas JSP</title> </head> <body bgcolor="ffffcc"> <center> <% java.util.Date FechaHora = new java.util.Date(); out.print("La fecha y Hora son: "+ FechaHora); %> </center> </body></html> |
Expresiones
En JSP se utilizan las expresiones para insertar valores, obtenidos con Java, directamente a la salida que se envía al cliente o solicitante.
Tiene dos sintaxis:
<%= expresión Java %>
(Note el signo igual (=) que acompaña justo detrás del inicio de código JSP y asegúrese que dicho signo acompaña al de porcentaje (%)).
Existe otra sintaxis que es la siguiente
Cualquiera de las dos sintaxis se corresponde con una expresión en JSP. ¿Cómo funcionan las expresiones?. Pues muy sencillo, la expresión es evaluada en el Motor de JSP, se obtiene un valor de la expresión y éste se sustituye justo donde se utiliza.
Veamos un ejemplo sencillo, abrimos una nueva sesión de NetBeans 6.9, hacemos Nuevo Proyecto, Java Web, Web Application y le damos nombre expresiones1, cuando NetBeans 6.9 nos muestre la plantilla del archivo index.jsp lo cambiamos por este otro código.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| <%-- Document : index Created on : 12-ene-2013, 21:34:25 Author : Jtaguaa--%><%@page contentType="text/html" pageEncoding="UTF-8"%><!DOCTYPE html><html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP (Expresiones)</title> </head> <body> <h1> <center> Hola. La fecha y la hora son <%= new java.util.Date() %> </center> </h1> </body></html> |
En el código anterior, en la línea 19 tenemos una expresión. Esta expresión básicamente consiste en crear una nueva instancia de la clase Date, con lo cual la expresión new java.util.Date() producirá una llamada a la fecha del sistema por parte del Motor JSP desde el servidor, y esa fecha obtenida se sustituirá por todo lo que hay entre las etiquetas de comienzo y fin del lenguaje JSP.
La salida en el navegador será similar a la siguiente (con el correspondiente cambio de fecha y hora).
Tal como puede verse, el formato de fecha y hora no se ajusta al utilizado en España, cambiaremos el código de la página index.jsp por otro algo mas usual en España en otro ejemplo posterior.
Directivas JSP
Directiva @include
La directiva include inserta el contenido de otro fichero en el fichero principal JSP, en la línea donde está situada y antes de ser procesada o traducida a servlet. Su sintaxis es la siguiente.
<%@ include file=”url relativa” %>
En otras palabras, la directiva include simplemente copia el contenido del archivo incluido byte a byte, siendo el resultado similar a si copiamos el texto del archivo incluido y lo pegamos en el JSP.
Es muy importante señalar que dado que la directiva include incluye el fichero en el momento de la compilación, si la página incluida cambia después de la compilación, los cambios no se verán reflejados en la página actual hasta que se vuelva a compilar. Por esta razón si una página incluida cambia, es necesario re-compilar la página que la contiene.
La URL se interpreta relativa al directorio home del servidor Web empezando la URL (Web Pages del proyecto, el lugar donde debe encontrarse index.jsp). Los contenidos del fichero incluido son analizados como texto normal, y así pueden incluir JSP, HTML estático, elementos de script, directivas, acciones o fichero TXT de texto convencional.
Tenga especial cuidado en estas inclusiones de fragmentos de código, porque la página final resultante debe ser coherente respecto a las etiquetas
<html> , </html> , <body> o </body>, ya que no deben repetirse cuando se construya la página principal con las inclusiones.
Es útil para incluir información que se quiere reutilizar en otras páginas u aplicaciones. Por ejemplo, el fichero incluido pudiera ser
1.- Una tabla con un banner gráfico fijo, o
2.- Información de pie de página con el copyright, o
3.- Una cabecera idéntica para un grupo de páginas de una aplicación, etc.
Ejemplo:
Deseamos producir una página JSP que contenga tres partes funcionales, una cabecera, un cuerpo y un pie. Deseamos que el aspecto final sea el siguiente:
Directiva @taglib
La directiva taglib indica al motor jsp que la página va a utilizar “tag libraries” o librerías de etiquetas . Estas librerías contienen etiquetas creadas por el propio programador con sus correspondientes atributos que encapsulan determinada funcionalidad.
La sintaxis es
<%@taglib uri=“ . . . . . ” prefix = “ . . . . . ” %>
donde
- el atributo uri permite localizar el fichero descriptor de la librería de extensión tld.
- el atributo prefix especifica el identificador que todas las etiquetas de la librería deben incorporar y que no puede coincidir con las palabras reservadas jsp:, jspx:, java:, javax:, servlet:, sun:, and sunw:
Como cabe esperar existe un procedimiento para crear estas librerías y que aquí no vamos a analizar, lo que si haremos es utilizar un par de ellas previamente construidas.
EJEMPLO 1:
Vamos a utilizar la librería de etiquetas strtag.jar diseñada para manejar fundamentalmente cadenas de texto. Esta librería tiene etiquetas tales como
- Replace, Replace string
- toUpperCase, converts body to the uppercase
- toLowerCase, converts body to the lower case
- Capitalize, capitalizes first char
- Ltrim, removes a pattern from the left
- Rtrim, removes a pattern from the right
- Trim, removes a pattern from the left and right
- stripTags, removes tags
- cleanXSS, cleans XSS
- leftPad, pads body from the left
- rightPad, pads body from the right
- cutString, converts body to the upper case
- parseString, Iterates over string tokens
- getToken, Reads current token
- forEachLine, Iterates over lines
- addslashes, adds slashes to the body
- stripslashes, strips slashes in the body
- filter, filters string according to RegExp pattern
Utilizaremos la librería de etiquetas strtag.lib con su correspondiente descriptor. (Una vez bajado el descriptor hay que renombrarlo a tablib.tld)
Directiva @page
Esta directiva se usa para establecer las propiedades generales de una página JSP. Podemos usar esta directiva varias veces a lo largo de la pagina JSP, pero sólo podemos asignar el valor de un atributo una vez por cada una, excepto para el atributo import. Los valores de la directiva se aplicarán a toda la pagina.
Sintaxis
Aquí podemos ver la sintaxis de la directiva page con todos sus atributos. Los valores por defecto se muestran en negrita. Los corchetes ([…]) indican un término opcional. La barra vertical (|) proporciona una elección entre dos valores como true y false.
<%@ page
[ languaje=”java”]
[ extends=”package.class“]
[ import= “{ package.class|package.*}, …” ]
[ session=”true|false”]
[ buffer=”none|8kb|sizekb”]
[ autoFlush=”true|false”]
[ isThreadSafe=”true|false”]
[ info=”text“]
[ errorPage=”URLrelativa“]
[ contentType=”mimeType[ ;charset=characterSet]” | “text/html; charset=ISO-8859-1”]
[ isErrorPage=”true|false“]
%>
Atributos
language=”java”
Este atributo define el lenguaje de script usado en los scriptlet, declaraciones y expresiones en el fichero JSP y en cualquier fichero incluido. En JSP 1.0 el único lenguaje permitido es Java.
extends=”package.class”
Este atributo especifica un nombre totalmente cualificado de una superclase que será extendida por la clase Java en el fichero JSP. Sun recomienda que usemos este atributo con cuidado, ya puede limitar la habilidad del motor del JSP a proporcionar la superclase especializada que mejora la calidad del fichero compilado.
import= “{ package.class | package.* }, …”
Esta lista especifica una lista separada por comas de uno o más paquetes o clases que el fichero JSP debería importar. Las clases de los paquetes se ponen a disposición de los scriptlets, expresiones, declaraciones y etiquetas dentro del fichero JSP.
Como cabría esperar, el atributo import debe aparecer antes de cualquier etiqueta que refiera la clase importada. Para importar varios paquetes, podemos usar una lista separada por comas, más de una directiva import o una combinación de ambas.
session=“true|false”
Todo cliente debe unirse a una sesión HTTP para poder usar una página JSP. Si el valor es true, el objeto sessionse refiere a la sesión actual o a una nueva sesión. Si el valor es false, no podemos utilizar el objeto session en el fichero JSP. El valor por defecto es true.
buffer=”none|8kb|sizekb”
Este atributo especifica el tamaño del buffer en kilobytes que será usado por el objeto out para manejar la salida enviada desde la página JSP compilada hasta el navegador cliente. El valor por defecto es 8 kb.
autoFlush=“true|false”
Este atributo especifica si la salida sería enviada o no cuando el buffer esté lleno. Por defecto, el valor es true, el buffer será descargado. Si especificamos false, se lanzará una excepción cuando el buffer se sobrecargue.
isThreadSafe=“true|false”
Este atributo especifica si la seguridad de threads está implementada en el fichero JSP. El valor por defecto, true, significa que el motor puede enviar múltiples solicitudes concurrentes a la página.
Si usamos el valor por defecto, varios threads pueden acceder a la página JSP. Por lo tanto, debemos sincronizar nuestros métodos para proporcionar seguridad de threads.
Con false, el motor JSP no envía solicitudes concurrentes a la página JSP. Probablemente no querremos forzar esta restricción en servidores de gran volumen porque puede dañar la habilidad del servidor de enviar nuestra página JSP a múltiples clientes.
info=“text”
Este atributo nos permite especificar una cadena de texto que es incorporada en el página JSP compilada. Podemos recuperar el string más tarde con el método getServletInfo().
errorPage=“URLrelativa”
Este atributo especifica un path a un fichero JSP al que este fichero JSP envía excepciones. Si el path empieza con una “/”, el path es relativo al directorio raíz de documentos de la aplicación JSP y es resuelto por el servidor Web. Si no, el path es relativo al fichero JSP actual.
isErrorPage=”true|false”
Este atributo especifica si el fichero JSP muestra una página de error. Si es true, podemos usar el objeto exception, que contiene una referencia a la excepción lanzada, en el fichero JSP. Si es false (el valor por defecto), significa que no podemos usar el objeto exception en el fichero JSP.
contentType=”mimeType [ ; charset=characterSet ]” | “text/html;charset=ISO-8859-1”
Este atributo especifica el tipo MIME y la codificación de caracteres que use el fichero JSP cuando se envía la respuesta al cliente. Podemos usar cualquier tipo MIME o conjunto de caracteres que sean válidos para el motor JSP.
El tipo MIME por defecto es text/html, y el conjunto de caracteres por defecto es ISO-8859. (En el IDE de Netbeans es UTF-8).
Los atributos contentType, pageEncoding e import son los mas usados. De hecho la plantilla básica que proporciona el IDE de NetBeans incorpora siempre la directiva <%@page contentType=”text/html” pageEncoding=”UTF-8″ %>
Los atributos contentType, pageEncoding e import son los mas usados. De hecho la plantilla básica que proporciona el IDE de NetBeans incorpora siempre la directiva <%@page contentType=”text/html” pageEncoding=”UTF-8″ %>
Los atributos language y extends no suele utilizarse. El resto de los atributos se utilizan para situaciones muy concretas.
EJEMPLO 1:
Veamos un ejemplo relacionado con el atributo import. Aunque ya conocemos este atributo por problemas anteriores, aprovecharemos aquí para conocer cómo se crean paquetes dentro del entorno IDE de NetBeans.
1.- Iniciamos un nuevo proyecto “Java Web” y “Web Application”.
2.- Llamamos al proyecto “DirPage_import1”.
3.- Sustituimos el código de la plantilla index.jsp por este otro
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| <%-- Document : index Created on : 24-sep-2008, 21:28:00 Author : Juan Tagua--%><%@page contentType="text/html" pageEncoding="UTF-8"%><%@page import="JTagua.EjemploClase" %><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Ejemplo de directiva page con atributo import con nueva clase dentro de un nuevo paquete</title> </head> <body> <font size="20" color="red"> <% EjemploClase ejemplo = new EjemploClase(); out.print(ejemplo.presentar()); %> </font></html> |
En la línea 8 estamos incluyendo una directiva page con un atributo import que hace referencia al paquete (contenedor de clases) denominado JTagua y a la clase EjemploClase incluida dentro de dicho paquete.
¿Qué es JSTL? (JSP Standard Tag Library)
La librería JSTL es un componente dentro de la especificación del Java 2 Enterprise Edition (J2EE) y es controlada por Sun MicroSystems. JSTL no es más que un conjunto de librerías de etiquetas simples y estándares que encapsulan la funcionalidad principal que es usada comúnmente para escribir páginas JSP. Las etiquetas JSTL están organizadas en 4 librerías:
- core: Comprende las funciones script básicas como loops, condicionales, y entrada/salida.
- xml: Comprende el procesamiento de xml
- fmt: Comprende la internacionalización y formato de valores como de moneda y fechas.
- sql: Comprende el acceso a base de datos.
Importancia de JSTL
La especificación JSP ahora se ha convertido en una tecnología estándar para la creación de sitios Web dinámicos en Java, y el problema es que han aparecido algunas debilidades:
- El código Java embebido en scriptlets es desordenado.
- Un programador que no conoce Java no puede modificar el código Java embebido, anulando uno de los mayores beneficios de los JSP: permitir a los diseñadores y personas que escriben la lógica de presentación que actualicen el contenido de la página.
- El código de Java dentro de scriptlets JSP no pueden ser reutilizados por otros JSP, por lo tanto la lógica común termina siendo re-implementado en múltiples páginas.
- La recuperación de objetos fuera del HTTP Request y Session es complicada. Es necesario hacer el Casting de objetos y esto ocasiona que tengamos que importar más Clases en los JSP.
Etiquetas JSTL
etiquetas básicas
etiquetas básicas son las etiquetas JSTL más comúnmente utilizados. sintaxis de referencia de biblioteca de códigos de la base es de la siguiente manera:
<%@ taglib prefix="c"
uri="http://java.sun.com/jsp/jstl/core" %>
| etiqueta | descripción |
|---|---|
| <C: out> | Para la visualización de los datos en un JSP, como <% = ...> |
| <C: set> | Para el almacenamiento de datos |
| <C: extraer> | Para la eliminación de datos |
| <C: catch> | Para hacer frente a condición de excepción de error, y un almacén de mensajes de error |
| <C: if> | Y si estamos en el mismo procedimiento general que se usa |
| <C: choose> | Sí sólo como <c: when> y <c: otherwise> marca para padres |
| <C: when> | <C: choose> pestaña secundaria se utiliza para determinar si las condiciones establecidas |
| <C: de otro modo> | <C: choose> pestaña secundaria, a continuación, en <c: when> etiqueta después, cuando <c: when> etiqueta es juzgado como falso es ejecutado |
| <C: import> | Recuperando una URL absoluta o relativa y, a continuación, se expone a la página de contenidos |
| <C: forEach> | base etiqueta iterativo, aceptar una variedad de tipos de colección |
| <C: forTokens> | De acuerdo con el delimitador especificado para separar contenido y los resultados iterativo |
| <C: param> | Se utiliza para contener o redirigir la página para pasar parámetros |
| <C: redirigir> | Redireccionado a una nueva URL. |
| <C: url> | Utilice los parámetros de consulta opcionales para crear una URL |
mas:
¿Qué es una Sesión?
Una sesión es una serie de comunicaciones entre un cliente y un servidor en la que se realiza un intercambio de información. Por medio de una sesión se puede hacer un seguimiento de un usuario a través de la aplicación. El tiempo de vida de una sesión comienza cuando un usuario se conecta por primera vez a un sitio web pero su finalización puede estar relacionada con tres circunstancias:
-Cuando se abandona el sitio web.
-Cuando se alcanza un tiempo de inactividad que es previamente establecido, en este caso la sesión es automáticamente eliminada. Si el usuario siguiera navegando se crearía una nueva sesión.
-Se ha cerrado o reiniciado el servidor.
Una posible aplicación de las sesiones es en el comercio electrónico. En este caso una sesión permite ir eligiendo una serie de productos e irlos añadiendo a nuestro “carrito” y así hasta finalizar la compra. Sin el uso de sesiones no se podría hacer porque al ir navegando de una página a otra se iría perdiendo toda la información. También se utilizan para la identificación de usuarios, en la que se deben de introducir un login y un password. Después de haber hecho esto el usuario tendrá una serie de permisos sobre las páginas que va a visitar, de tal forma que si un usuario intenta pasar a una página si haberse identificado, el sistema comprobará que no se ha identificado y sería redireccionado a la página de identificación. Para poder realizarse estas operaciones es necesario almacenar en unas tipo sesión la información necesaria para saber que el usuario se ha identificado correctamente. Para poder hacer uso de las sesiones en JSP hay que poner el atributo session de la directiva page a true, de esta forma se notifica al contenedor que la página interviene en un proceso que utiliza las sesiones del protocolo HTTP:
<%@page session=’true’%>
El manejo de las sesiones impide el intercambio de datos entre ellas ya que se trata información específica para cada usuario e incluso si se trata del mismo usuario.
mas:
http://dis.um.es/~lopezquesada/documentos/IES_1213/IAW/curso/UT5/ActividadesAlumnos/12/sesiones.html
Qué es un JavaBeans
Un JavaBean o bean es un componente hecho en software que se puede reutilizar y que puede ser manipulado visualmente por una herramienta de programación en lenguaje Java.
Para ello, se define un interfaz para el momento del diseño (design time) que permite a la herramienta de programación o IDE, interrogar (query) al componente y conocer las propiedades (properties) que define y los tipos de sucesos (events) que puede generar en respuesta a diversas acciones.
Aunque los beans individuales pueden variar ampliamente en funcionalidad desde los más simples a los más complejos, todos ellos comparten las siguientes características:
- Introspection: Permite analizar a la herramienta de programación o IDE como trabaja el bean
- Customization: El programador puede alterar la apariencia y la conducta del bean.
- Events: Informa al IDE de los sucesos que puede generar en respuesta a las acciones del usuario o del sistema, y también los sucesos que puede manejar.
- Properties: Permite cambiar los valores de las propiedades del bean para personalizarlo (customization).
- Persistence: Se puede guardar el estado de los beans que han sido personalizados por el programador, cambiando los valores de sus propiedades.
En general, un bean es una clase que obedece ciertas reglas:
- Un bean tiene que tener un constructor por defecto (sin argumentos)
- Un bean tiene que tener persistencia, es decir, implementar el interface Serializable.
- Un bean tiene que tener introspección (instrospection). Los IDE reconocen ciertas pautas de diseño, nombres de las funciones miembros o métodos y definiciones de las clases, que permiten a la herramienta de programación mirar dentro del bean y conocer sus propiedades y su conducta.
mas:
Patrón de diseño de modelo-vista-controlador
El patrón de diseño de modelo-vista-controlador (MVC) especifica que una aplicación consta de un modelo de datos, de información de presentación y de información de control. El patrón requiere que cada uno de estos elementos esté separado en distintos objetos.
El modelo (por ejemplo, la información de datos) contiene únicamente los datos puros de aplicación; no contiene lógica que describe cómo pueden presentarse los datos a un usuario.
La vista (por ejemplo, la información de presentación) presenta al usuario los datos del modelo. La vista sabe cómo acceder a los datos del modelo, pero no sabe el significado de estos datos ni lo que el usuario puede hacer para manipularlos.
Por último, el controlador (por ejemplo, la información de control) está entre la vista y el modelo. Escucha los sucesos desencadenados por la vista (u otro origen externo) y ejecuta la reacción apropiada a estos sucesos. En la mayoría de los casos, la reacción es llamar a un método del modelo. Puesto que la vista y el modelo están conectados a través de un mecanismo de notificación, el resultado de esta acción se reflejará automáticamente en la vista.
La mayoría de las aplicaciones hoy en día siguen este patrón, muchas con ligeras variaciones. Por ejemplo, algunas aplicaciones combinan la vista y el controlador en una clase porque ya están estrechamente unidos. Todas las variaciones recomiendan enérgicamente la separación de los datos de su presentación. Esto no sólo simplifica la estructura de una aplicación sino que también permite reutilizar el código.
Puesto que hay muchas publicaciones que describen el patrón, así como numerosos ejemplos, este documento no describe el patrón con mucho detalle.
El diagrama siguiente muestra cómo se aplica el patrón de diseño MVC a WebSphere Commerce. Este patrón se utiliza para las aplicaciones web y para los Rich Client y se puede utilizar la infraestructura de servicios web o Struts.
puede interesarte:
GRACIAS POR LA INFROMACION, ENCONTRE LO QUE BUSCABA.
ResponderBorrar