Guia Java (JSP)

Universidad de Sonsonate - FICN

GUÍA 3 – DESARROLLO DEL SOFTWARE I 1

Ingenierí a en Sistemas Computacionales Desarrollo del Software I Guí a #3

Swing de Java

JSP es una especificación de Sun Microsystems, sirve para crear y gestionar páginas web

dinámicas.

Las paginas JSP permiten mezclar en una página código HTML para generar la parte estática,

con contenido dinámico generado a partir de marcas especiales <% .... %>; el contenido

dinámico se obtiene, en esencia, gracias a la posibilidad de incrustar dentro de la página

código Java de diferentes formas y su objetivo final es separar la interfaz (presentación visual)

de la implementación (lógica de ejecución)

Una página JSP puede contener dos tipos de elementos bien diferenciados, por un lado

tenemos los elementos estáticos como etiquetas HTML, texto, script de cliente, etiquetas XML,

etc., que no necesitan de ningún procesamiento por parte del contenedor de páginas JSP, sino

que son traducidos en el servlet correspondiente mediante sentencias out.print(), es decir, se

devolvían directamente a la respuesta que se enviaba al cliente.

Por otro lado tenemos otro grupo de elementos los cuales son: las directivas, elementos de

scripting (elementos para construir script de servidor con sentencias Java), acciones y objetos

integrados. Este grupo de elementos necesitan de un procesamiento en el servidor

(contenedor de páginas JSP) ya que son los encargados de generar el contenido dinámico, es

decir, son los elementos que en forma de etiquetas similares a XML nos permiten programar

nuestras páginas JSP.

Es por eso que se debe comenzar a tratar elementos de las páginas JSP y el primero será las

directivas, que se corresponden con una etiqueta especial de JSP que puede utilizarse

utilizando la sintaxis XML.



Expresión JSP

<%= expression %>;

La Expresión es evaluada y situada en la salida.

El equivalente XML es

<jsp:expression> expression </jsp:expression>

Las variables predefinidas son request, response, out, session, application, config, y

pageContext.

Scriptlet JSP

<% code %>;

El código se inserta en el método service.

El equivalente XML es:

<jsp:scriptlet>code</jsp:scriptlet>

Declaración JSP

<%! code %>

El código se inserta en el cuerpo de la clase del servlet, fuera del método service.

El equivalente XML es:

<jsp:declaration> code </jsp:declaration>.

Comentario JSP

<%-- comment --%>

Comentario ignorado cuando se traduce la página JSP en un servlet.

Si queremos un comentario en el HTML resultante, usamos la sintaxis de comentario normal

del HTML .

Expresiones JSP

<%= expresión %>

Se evalúan y se insertan en la salida.

Se tiene acceso a variables:

request, el HttpServletRequest

response, el HttpServletResponse

session, el HttpSession asociado con el request (si existe)

out, el PrintWriter (una versión con buffer del tipo JspWriter) usada para enviar la salida al

cliente.

Your hostname: <%= request.getRemoteHost() %>

El equivalente en XML es usar una sintaxis alternativa para las expresiones JSP:

<jsp:expression>

Expresión Java

</jsp:expression>



Declaraciones

Los elementos XML, al contrario que los del HTML, son sensibles a las mayúsculas.

DECLARACIONES: <%! codigo %> que se insertan en el cuerpo de la clase del servlet, fuera

de cualquier método existente. Permite insertar métodos, variables... No generan salida

alguna. Se usan combinadas con scriptlets.

<%! private int accessCount = 0; %>

Accesses to page since server reboot:

<%= ++accessCount %>

Las directivas son un conjunto de etiquetas JSP que ofrecen al contenedor de páginas JSP

instrucciones específicas de cómo se debe procesar una página determinada. Las directivas

definen propiedades generales que afectan a la página, incluso algunas de estas directivas se

pueden utilizar para generar de forma indirecta contenido dinámico que será devuelto como

parte de la respuesta enviada al cliente, y por lo tanto tienen una traducción correspondiente

dentro del servlet equivalente a la página JSP. Las directivas sirven como mensajes que se

envían desde la página JSP al contendor JSP que la ejecuta.

Afectan a la estructura general de la clase servlet. Normalmente tienen la siguiente forma:

<%@ directive attribute="value" %>

También podemos combinar múltiples selecciones de atributos para una sola directiva:

<%@ directive attribute1="value1“

attribute2="value2“

...

attributeN="valueN" %>



Directiva page JSP (@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 página 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

página.

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"]

%>

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

session se 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 la 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

objetoexception, 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 más 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.

Directiva include JSP

Esta directiva permite a los autores de páginas incluir el contenido de un recurso dentro del

contenido generado por una página JSP. Elrecurso a incluir dentro de la página JSP se indica

mediante una URL relativa o absoluta, pero que debe hacer referencia la servidor en el que se

ejecutan las páginas JSP. La sintaxis general de esta directiva será la siguiente.

<%@ include file=”URLlocal”%>



Y su sintaxis equivalente en XML es:

<jsp:directiva.include file=”URLlocal”/>

Acción jsp:include

<jsp:include page="relative URL" flush="true"/>

Incluye un fichero en el momento en que la página es solicitada.

Aviso: en algunos servidores, el fichero incluido debe ser un fichero HTML o JSP, según

determine el servidor (normalmente basado en la extensión del fichero).



El primer paso es crear un proyecto web, para crearlo hay que ir al menú File opción New

Project…

Elegimos la carpeta Web y la opción Web Application como se muestra en la imagen:

Ahora hacemos click en Next, asignamos o buscamos la localización del proyecto o Project

Location y le asignamos el nombre o Project Name, el cual en nuestro caso tendrá Prueba.

Como se muestra en la siguiente imagen:



Luego hacemos clic en siguiente y establecemos el servidor GlassFish Server, si no es la

opción por defecto.



Al hacer clic en Finish o Finalizar nos creara todo el proyecto web el cual por defecto ya

contendrá una carpeta Web Pages y una página jsp llamada index que será la principal o la

primera en ejecutarse. Si queremos agregar más paginas JSP o HTML tenemos que hacer clic

derecho sobre la carpeta Web Pages, elegir la opción New y luego seleccionar que tipo de

página queremos si es JSP o HTML.

Con todo lo anterior aclarado ya podemos utilizar NetBeans y comenzar con nuestro primer

ejercicio que se define a continuación:

Primer Ejercicio de JSP (Primera página)

Ejemplo de página dinámica que dice Hola y escribe la fecha actual (fichero Primera.jsp)

<%@page contentType="text/html" pageEncoding="UTF-8"%>

<%@ page info="Un ejemplo Hola Mundo"

import="java.util.Date" %>

<!DOCTYPE html>

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>JSP Page</title>

</head>



<body>

<h1> ¡Hola, Mundo! </h1>

La fecha de hoy es: <strong><%= new Date().toString() %> </strong>

</body>

</html>

En esta página se mezcla código HTML con código Java incrustado con unas marcas

especiales.

En este caso es una expresión, que se sustituye en la página por el resultado de evaluarla.

En otros casos es un trozo de código Java que simplemente se ejecuta.

Segundo Ejercicio de JSP (Directiva Page)

Muestra el uso de la directiva page. Agregar al proyecto Creado, Segunda.jsp. Es muy similar

a Primera.jsp, pero con dos directivas page. Su Localización será la misma que Primera.jsp,

es decir, dentro de la carpeta web.

Código de Segunda.jsp:



Tercer Ejercicio de JSP (Directiva Include)

Muestra el uso de la directiva include. Se trata de acceder a una jsp que incluye otra jsp con

información de la fecha actual y una página htm con información de copyright. Para ejecutar

el ejemplo, agregar al proyecto Creado, DirectivaInclude.jsp, Fecha.jsp y Copyright.html



Código de DirectivaInclude.jsp

Código de Fecha.jsp

Código de Copyright.html



Ejercicio 4: Para el ejercicio 2. Mostrar en vez de la palabra “Mundo”, en el texto mostrado

“HOLA Mundo, ¿cómo te va la vida?”, tu primer nombre. Sin modificar el código del ejercicio.

Ejercicio 5: Hacer una página utilizando la directiva <%@Include%>, separando la

principal e incluyendo una página para el encabezado, una para el menú, una para el cuerpo y

otra para el pie (utilizando la estructura de HTML5).

El menú debe tener las tres opciones y funcionar para mostrar uno de los 3 ejercicios anteriores

en la parte del <section> según sea la opción cliqueada. Recordar que se hará una sola página

jsp llamada Principal.jsp. (tip: request.getParameter)

Ejercicio 6: modificar el archivo index para que sea un formulario login para un usuario admin,

y otro user (pass admin y user). Al logearse de forma correcta debe dirigirse a la página

Principal.jsp (<% response.sendRedirect("url");%> ) y mostrar un menú diferente si es admin

(incluir un botón más para regresar al login).

Guia Java (JSP)

Documents

Transcript of Guia Java (JSP)