# Servelts y JSP

# JavaServer Pages (JSP) 1.0

1. Introducción
2. Sumario de síntaxis
3. Plantilla de Texto (HTML estático)
4. Elementos de Script JSP: Expresiones, Scriptlets, y Declaraciones
5. Directivas JSP
6. Ejemplo: usar Elementos de Script y Directivas
7. Variables Predefinidas
8. Acciones JSP
   - 8.1 jsp:include
   - 8.2 jsp:useBean (introducción)
   - 8.3 jsp:useBean (detalles)
   - 8.4 jsp:setProperty
   - 8.5 jsp:getProperty
   - 8.6 jsp:forward
   - 8.7 jsp:plugin
9. Convenciones sobre comentarios y caracteres de Escape en JSP

## 1. Introducción

Las JavaServer Pages (JSP) nos permiten separar la parte dinámica de nuestras páginas Web del HTML estático. Simplemente escribimos el HTML regular de la forma normal, usando cualquier herramienta de construcción de paginas Web que usemos normalmente. Encerramos el código de las partes dinámicas en unas etiquetas especiales, la mayoría de las cuales empiezan con "<%" y terminan con "%>". Por ejemplo, aquí tenemos una sección de una página JSP que resulta en algo así como "Thanks for ordering Core Web Programming" para una URL como http://host/OrderConfirmation.jsp?title=Core+Web+Programming:

>     Thanks for ordering
>     <I><%= request.getParameter("title") %></I>

Normalmente daremos a nuestro fichero una extensión .jsp, y normalmente lo instalaremos en el mismo sitio que una página Web normal. Aunque lo que escribamos frecuentemente se parezca a un ficheor HTML normal en vez de un servelt, detrás de la escena, la página JSP se convierte en un servlet normal, donde el HTML estático simplemente se imprime en el stream de salida estándard asociado con el método service del servlet. Esto normalmente sólo se hace la primera vez que se solicita la página, y los desarrolladores pueden solicitar la página ellos mismos cuando la instalan si quieren estar seguros de que el primer usuario real no tenga un retardo momentáneo cuando la página JSP sea traducida a un servlet y el servlet sea compilado y cargado. Observa también, que muchos servidores Web nos permiten definir alias para que una URL que parece apuntar a un fichero HTML realmente apunte a un servelt o a una página JSP.

Además de el HTML normal, hay tres tipos de construcciones JSP que embeberemos en una página: elementos de script, directivas y acciones. Los elementos de script nos permiten especificar código Java que se convertirá en parte del servlet resultante, las directivas nos permiten controlar la estructura general del servlet, y las acciones nos permiten especificar componentes que deberían ser usuados, y de otro modo controlar el comportamiento del motor JSP. Para simplificar los elementos de script, tenemos acceso a un número de variables predefinidas como request del fragmento de código anterior.

Nota: este tutorial cubre la versión 1.0 de la especificación JSP 1.0.

## 2. Sumario de Síntaxis

Elemento JSP | Síntaxis | Interpretación | Notas
--- | --- | --- | ---
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>.
Directiva page JSP |
    <%@ page att="val" %>
| Dirige al motor servlet sobre la configuración general. | El equivalente XML es: <jsp:directive.page att="val"\>. Los atributos legales son (con los valores por defecto en negrita): import="package.class" contentType="MIME-Type" isThreadSafe="true|false" session="true|false" buffer="sizekb|none" autoflush="true|false" extends="package.class" info="message" errorPage="url" isErrorPage="true|false" language="java"
Directiva include JSP |
    <%@ include file="url" %>
| Un fichero del sistema local se incluirá cuando la página se traduzca a un Servlet. | El equivalente XML es: <jsp:directive.include file="url"\>. La URL debe ser relativa. Usamos la acción jsp:include para incluir un fichero en el momento de la petición en vez del momento de la tradución.
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 síntaxis de comentario normal del HTML <-- comment -->.
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).
Acción jsp:useBean |
    <jsp:useBean att=val*/>
          o
    <jsp:useBean att=val*>
    ...
    </jsp:useBean>
| Encuentra o construye un Java Bean. | Los posibles atributos son: id="name" scope="page|request|session|application" class="package.class" type="package.class" beanName="package.class"
Acción jsp:setProperty |
    <jsp:setProperty att=val*/>
| Selecciona las propiedades del bean, bien directamenteo o designando el valor que viene desde un parámetro de la petición. | Los atributos legales son: name="beanName" property="propertyName|*" param="parameterName" value="val"
Acción jsp:getProperty |
    <jsp:getProperty
        name="propertyName"
        value="val"/>
| Recupera y saca las propiedades del Bean. |
Acción jsp:forward |
    <jsp:forward
        page="relative URL"/>
| Reenvía la petición a otra página. |
Acción jsp:plugin |
    <jsp:plugin
        attribute="value"*>
      ...
    </jsp:plugin>
| Genera etiquetas OBJECT o EMBED, apropiadas al tipo de navegador, pidiendo que se ejecute un applet usando el Java Plugin. |

## 3. Plantilla de Texto: HTML estático

En muchos casos, un gran porcentaje de nuestras páginas JSP consistirá en HTML estático, conocido como plantilla de texto. En casi todos lo aspectos, este HTML se parece al HTML normal, sigue la mismas reglas de síntaxis, y simplemente "pasa a través" del cliente por el servlet creado para manejar la página. No sólo el aspecto del HTML es normal, puede ser creado con cualquier herramienta que usemos para generar páginas Web. Por ejemplo, yo he usado Homesite de Allaire, para la mayoría de las páginas de este tutorial.

La única excepción a la regla de que "la plantilla de texto se pasa tal y como es" es que, si queremos tener "<%" en la salida, necesitamos poner "<\%" en la plantilla de texto.

## 4. Elementos de Script JSP

Los elementos de script nos permiten insertar código Java dentro del servlet que se generará desde la página JSP actual. Hay tres formas:

1. Expresiones de la forma <%= expresión %> que son evaluadas e insertadas en la salida.
2. Scriptlets de la forma <% codido %> que se insertan dentro del método service del servlet, y
3. Declaraciones de la forma <%! codigo %> que se insertan en el cuerpo de la clase del servlet, fuera de cualquier método existente.

### 4.1 Expresiones JSP

Una expresión JSP se usa para insertar valores Java directamente en la salida. Tiene la siguiente forma:

>     <%= expresión Java %>

La expresión Java es evaluada, convertida a un string, e insertada en la página. Esta evaluación se ejecuta durante la ejecución (cuando se solicita la página) y así tiene total acceso a la información sobre la solicitud. Por ejemplo, esto muestra la fecha y hora en que se solicitó la página:

>     Current time: <%= new java.util.Date() %>

Para simplificar estas expresiones, hay un gran número de variables predefinidas que podemos usar. Estos objetos implícitos se describen más adelante con más detalle, pero para el propósito de las expresiones, los más importantes son:

- request, el HttpServletRequest;
- response, el HttpServletResponse;
- session, el HttpSession asociado con el request (si existe), y
- out, el PrintWriter (una versión con buffer del tipo JspWriter) usada para envíar la salida al cliente.

Aquí tenemos un ejemplo:

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

Finalmente, observa que los autores de XML pueden usar una síntaxis alternativa para las expresiones JSP:

>     <jsp:expression>
>     Expresión Java
>     </jsp:expression>

Recuerda que los elementos XML, al contrario que los del HTML, son sensibles a las mayúsculas; por eso asegúrate de usar minúsculas.

### 4.2 Scriptlets JSP

Si queremos hacer algo más complejo que insertar una simple expresión, los scriptlets JSP nos permiten insertar código arbitrario dentro del método servlet que será construido al generar la página. Los Scriptlets tienen la siguiente forma:

>     <% Código Java  %>

Los Scriptlets tienen acceso a las mismas variables predefinidas que las expresiones. Por eso, por ejemplo, si queremos que la salida aparezca en la página resultante, tenemos que usar la variable out:

>     <%
>     String queryData = request.getQueryString();
>     out.println("Attached GET data: " + queryData);
>     %>

Observa que el código dentro de un scriptlet se insertará exactamente como está escrito, y cualquier HTML estático (plantilla de texto) anterior o posterior al scriptlet se convierte en sentencias print. Esto significa que los scriptlets no necesitan completar las sentencias Java, y los bloques abiertos pueden afectar al HTML estático fuera de los scriplets. Por ejemplo, el siguiente fragmento JSP, contiene una mezcla de texto y scritplets:

>     <% if (Math.random() < 0.5) { %>
>     Have a <B>nice</B> day!
>     <% } else { %>
>     Have a <B>lousy</B> day!
>     <% } %>

que se convertirá en algo como esto:

>     if (Math.random() < 0.5) {
>       out.println("Have a <B>nice</B> day!");
>     } else {
>       out.println("Have a <B>lousy</B> day!");
>     }

Si queremos usar los caracteres "%>" dentro de un scriptlet, debemos poner "%\>". Finalmenten, observa que el equivalente XML de <% Código %> es

>     <jsp:scriptlet>
>     Código
>     </jsp:scriptlet>

### 4.3 Declaraciones JSP

Una declaration JSP nos permite definir métodos o campos que serán insertados dentro del cuerpo principal de la clase servlet (fuera del método service que procesa la petición). Tienen la siguiente forma:

>     <%! Código Java%>

Como las declaraciones no generan ninguna salida, normalmente se usan en conjunción con expresiones JSP o escriptlets. Por ejemplo, aquí tenemos un fragmento de JSP que imprime el número de veces que se ha solicitado la página actual desde que el servidor se arrancó (o la clase del servelt se modificó o se recargó):

>     <%! private int accessCount = 0; %>
>     Accesses to page since server reboot:
>     <%= ++accessCount %>

Como con los scriptlet, si queremos usar los caracteres "%>", ponemos "%\>". Finalmente, observa que el equivalente XML de <%! Código %> es:

>     <jsp:declaration>
>     Código
>     </jsp:declaration>

## 5. Directivas JSP

Una directiva JSP afecta a la estructura general de la clase servlet. Normalmente tienen la siguiente forma:

>     <%@ directive attribute="value" %>

Sin embargo, también podemos combinar múltiples selecciones de atributos para una sola directiva, de esta forma:

>     <%@ directive attribute1="value1"
>                   attribute2="value2"
>                   ...
>                   attributeN="valueN" %>

Hay dos tipos principales de directivas: page, que nos permite hacer cosas como importar clases, personalizar la superclase del servlet, etc. e include, que nos permite insertar un fichero dentro de la clase servlet en el momento que el fichero JSP es traducido a un servlet. La especificación también menciona la directiva taglib, que no está soportada en JSP 1.0, pero se pretende que permita que los autores de JSP definan sus propias etiquetas. Se espera que sea una de las principales contribuciones a JSP 1.1.

### 5.1 La directiva page

La directiva page nos permite definir uno o más de los siguientes atributos sensibles a las mayúsculas:

- import="package.class" o import="package.class1,...,package.classN".
  Esto nos permite especificar los paquetes que deberían ser importados. Por ejemplo:
  <%@ page import="java.util.*" %>
  El atributo import es el único que puede aparecer múltiples veces.

- contentType="MIME-Type" o
  contentType="MIME-Type; charset=Character-Set"
  Esto especifica el tipo MIME de la salida. El valor por defecto es text/html. Por ejemplo, la directiva:
  <%@ page contentType="text/plain" %>
  tiene el mismo valor que el scriptlet
  <% response.setContentType("text/plain"); %>

- isThreadSafe="true|false".
  Un valor de true (por defecto) indica un procesamiento del servlet normal, donde múltiples peticiones pueden procesarse simultáneamente con un sólo ejemplar del servlet, bajo la suposición que del autor sincroniza las variables de ejemplar. Un valor de false indica que el servlet debería implementar SingleThreadModel, con peticiones enviadas serialmente o con peticiones simultáneas siendo entregadas por ejemplares separados del servelt.

- session="true|false".
  Un valor de true (por defecto) indica que la variable predefinida session (del tipo HttpSession) debería unirse a la sesión existente si existe una, si no existe se debería crear una nueva sesión para unirla. Un valor de false indica que no se usarán sesiones, y los intentos de acceder a la variable session resultarán en errores en el momento en que la página JSP sea traducida a un servlet.

- buffer="sizekb|none".
  Esto especifica el tamaño del buffer para el JspWriter out. El valor por defecto es específico del servidor, debería ser de al menos 8kb.

- autoflush="true|false".
  Un valor de true (por defecto) indica que el buffer debería desacargase cuando esté lleno. Un valor de false, raramente utilizado, indica que se debe lanzar una excepción cuando el buffe se sobrecargue. Un valor de false es ilegal cuando usamos buffer="none".

- extends="package.class".
  Esto indica la superclase del servlet que se va a generar. Debemos usarla con extrema precaución, ya el servidor podría utilizar una superclase personalizada.

- info="message".
  Define un string que puede usarse para ser recuperado mediante el método getServletInfo.

- errorPage="url".
  Especifica una página JSP que se debería procesar si se lanzará cualquier Throwable pero no fuera capturado en la página actual.

- isErrorPage="true|false".
  Indica si la página actual actúa o no como página de error de otra página JSP. El valor por defecto es false.

- language="java".
  En algunos momentos, esto está pensado para especificar el lenguaje a utilizar. Por ahora, no debemos precuparnos por él ya que java es tanto el valor por defecto como la única opción legal.

La síntaxis XML para definir directivas es:

>     <jsp:directive.TipoDirectiva atributo=valor />

Por ejemplo, el equivalente XML de:

>     <%@ page import="java.util.*" %>

es:

>     <jsp:directive.page import="java.util.*" />

### 5.2 La directiva include JSP

Esta directiva nos permite incluir ficheros en el momento en que la página JSP es traducida a un servlet. La directiva se parece a esto::

>     <%@ include file="url relativa" %>

La URL especificada normalmente se interpreta como relativa a la página JSP a la que se refiere, pero, al igual que las URLs relativas en general, podemos decirle al sistema que interpreta la URL reltativa al directorio home del servidor Web empezando la URL con una barra invertida. Los contenidos del fichero incluido son analizados como texto normal JSP, y así pueden incluir HTML estático, elementos de scdript, directivas y acciones.

Por ejemplo, muchas sites incluyen una pequeña barra de navegación en cada página. Debido a los problemas con los marcos HTML, esto normalmente se implementa mediante una pequeña tabla que cruza la parte superior de la página o el lado izquierdo, con el HTML repetido para cada página de la site. La directiva include es una forma natural de hacer esto, ahorrando a los desarroladores el mantenimiento engorroso de copiar realmente el HTML en cada fichero separado. Aquí tenemos un código representativo:

>     <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
>     <HTML>
>     <HEAD>
>     <TITLE>Servlet Tutorial: JavaServer Pages (JSP) 1.0</TITLE>
>     <META NAME="author" CONTENT="webmaster@somesite.com">
>     <META NAME="keywords" CONTENT="...">
>     <META NAME="description" CONTENT="...">
>     <LINK REL=STYLESHEET
>           HREF="Site-Styles.css"
>           TYPE="text/css">
>     </HEAD>

>     <BODY>
>     <%@ include file="/navbar.html" %>

>     <!-- Part specific to this page ... -->

>     </BODY>
>     </HTML>

Observa que como la directiva include inserta los ficheros en el momento en que la página es traducida, si la barra de navegación cambia, necesitamos re-traducir todas las páginas JSP que la refieren. Esto es un buen compromiso en una situación como esta, ya las barras de navegación no cambian frecuentemente, y queremos que el proceso de inclusión sea tan eficiente como sea posible. Si, sin embargo, los ficheros incluidos cambian de forma más frecuente, podríamos usar la acción jsp:include en su lugar. Esto incluye el fichero en el momento en que se solicita la página JSP, como se describe en la sección 8.

## 6. Ejemplo: Usar Elementos de Script y Directivas

Aquí tenemos un sencillo ejemplo que muestra el uso de expresiones, scriptlets, declaraciones y directivas JSP. También puedes descargar el código fuente

>     <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
>     <HTML>
>     <HEAD>
>     <TITLE>Using JavaServer Pages</TITLE>

>     <META NAME="author" CONTENT="Marty Hall -- hall@apl.jhu.edu">
>     <META NAME="keywords"
>           CONTENT="JSP,JavaServer Pages,servlets">
>     <META NAME="description"
>           CONTENT="A quick example of the four main JSP tags.">
>     <LINK REL=STYLESHEET
>           HREF="My-Style-Sheet.css"
>           TYPE="text/css">
>     </HEAD>

>     <BODY BGCOLOR="#FDF5E6" TEXT="#000000" LINK="#0000EE"
>           VLINK="#551A8B" ALINK="#FF0000">

>     <CENTER>
>     <TABLE BORDER=5 BGCOLOR="#EF8429">
>       <TR><TH CLASS="TITLE">
>           Using JavaServer Pages</TABLE>
>     </CENTER>
>     <P>

>     Some dynamic content created using various JSP mechanisms:
>     <UL>
>       <LI><B>Expression.</B><BR>
>           Your hostname: <%= request.getRemoteHost() %>.
>       <LI><B>Scriptlet.</B><BR>
>           <% out.println("Attached GET data: " +
>                          request.getQueryString()); %>
>       <LI><B>Declaration (plus expression).</B><BR>
>           <%! private int accessCount = 0; %>
>           Accesses to page since server reboot: <%= ++accessCount %>
>       <LI><B>Directive (plus expression).</B><BR>
>           <%@ page import = "java.util.*" %>
>           Current date: <%= new Date() %>
>     </UL>

>     </BODY>
>     </HTML>

Aquí tenemos un resultado típico:

## 7. Variables Predefinidas

Para simplififar el código en expresiones y scriplets JSP, tenemos ocho variables definidas automáticamente, algunas veces llamadas objetos implícitos. Las variables disponibles son: request, response, out, session, application, config, pageContext, y page.

### 7.1 request

Este es el HttpServletRequest asociado con la petición, y nos permite mirar los parámetros de la petición (mediante getParameter), el tipo de petición (GET, POST, HEAD, etc.), y las cabeceras HTTP entrantes (cookies, Referer, etc.). Estrictamente hablando, se permite que la petición sea una subclase de ServletRequest distinta de HttpServletRequest, si el protocolo de la petición es distinto del HTTP. Esto casi nunca se lleva a la práctica.

### 7.2 response

Este es el HttpServletResponse asociado con la respuesta al cliente. Observa que, como el stream de salida (ver out más abajo) tiene un buffer, es legal seleccionar los códigos de estado y cabeceras de respuesta, aunque no está permitido en los servlets normales una vez que la salida ha sido envíada al cliente.

### 7.3 out

Este es el PrintWriter usado para envíar la salida al cliente. Sin embargo, para poder hacer útil el objeto response (ver la sección anterior), esta es una versión con buffer de PrintWriter llamada JspWriter. Observa que podemos ajustar el tamaño del buffer, o incluso desactivar el buffer, usando el atributo buffer de la directiva page. Esto se explicó en la Sección 5. También observa que out se usa casi exclusivamente en scriptlets ya que las expresions JSP obtienen un lugar en el stream de salida, y por eso raramente se refieren explícitamente a out.

### 7.4 session

Este es el objeto HttpSession asociado con la petición. Recuerda que las sesiones se crean automáticamente, por esto esta variable se une incluso si no hubiera una sesión de referencia entrante. La única excepción es usar el atributo session de la directiva page (ver la Sección 5) para desactivar las sesiones, en cuyo caso los intentos de referenciar la variable session causarán un error en el momento de traducir la página JSP a un servlet.

### 7.5 application

Este es el ServletContext obtenido mediante getServletConfig().getContext().

### 7.6 config

Este es el objeto ServletConfig para esta página.

### 7.7 pageContext

JSP presenta una nueva clase llamada PageContext para encapsular características de uso específicas del servidor como JspWriters de alto rendimiento. La idea es que, si tenemos acceso a ellas a través de esta clase en vez directamente, nuestro código seguirá funcionando en motores servlet/JSP "normales".

### 7.8 page

Esto es sólo un sinónimo de this, y no es muy útil en Java. Fue creado como situación para el día que el los lenguajes de script puedan incluir otros lenguajes distintos de Java.

## 8. Accciones

Las acciones JSP usan construcciones de síntaxis XML para controlar el comportamiento del motor de servelts. Podemos insertar un fichero dinámicamente, reutilizar componentes JavaBeans, reenviar al usuario a otra página, o generar HTML para el plug-in Java. Las acciones disponibles incluyen:

- jsp:include - Incluye un fichero en el momento de petición de esta página. Ver la Sección 8.1.

- jsp:useBean - Encuentra o ejemplariza un JavaBean. Ver la Sección 8.2 para una introducción, y la Sección 8.3 para los detalles.

- jsp:setProperty - Selecciona la propiedad de un JavaBean. Ver la Sección 8.4.

- jsp:getProperty - Inserta la propiedad de un JavaBean en la salida. Ver la Sección 8.5.

- jsp:forward - Reenvía al peticionario a una nueva página. Ver la Sección 8.6.

- jsp:plugin - Genera código específico del navegador que crea una etiqueta OBJECT o EMBED para el plug-in Java. Ver la Sección 8.7.

Recuerda que, como en XML, los nombre de elementos y atributos son sensibles a las mayúsculas.

### 8.1 Acción jsp:include

Esta acción nos permite insertar ficheros en una página que está siendo generada. La síntaxis se parece a esto:

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

Al contrario que la directiva include, que inserta el fichero en el momento de la conversión de la página JSP a un Servlet, esta acción inserta el fichero en el momento en que la página es solicitada. Esto se paga un poco en la eficiencia, e imposiblita a la página incluida de contener código JSP general (no puede seleccionar cabeceras HTTP, por ejemplo), pero se obtiene una significante flexibilidad. Por ejemplo, aquí tenemos una página JSP que inserta cuatro puntos diferentes dentro de una página Web "What's New?". Cada vez que cambian las líneas de cabeceras, los autores sólo tienen que actualizar los cuatro ficheros, pero pueden dejar como estaba la página JSP principal.

### WhatsNew.jsp

También puedes descargar el código fuente.

>     <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
>     <HTML>
>     <HEAD>
>     <TITLE>What's New</TITLE>
>     <LINK REL=STYLESHEET
>           HREF="My-Style-Sheet.css"
>           TYPE="text/css">
>     </HEAD>

>     <BODY BGCOLOR="#FDF5E6" TEXT="#000000" LINK="#0000EE"
>           VLINK="#551A8B" ALINK="#FF0000">

>     <CENTER>
>     <TABLE BORDER=5 BGCOLOR="#EF8429">
>       <TR><TH CLASS="TITLE">
>           What's New at JspNews.com</TABLE>
>     </CENTER>
>     <P>

>     Here is a summary of our four most recent news stories:
>     <OL>
>       <LI><jsp:include page="news/Item1.html" flush="true"/>
>       <LI><jsp:include page="news/Item2.html" flush="true"/>
>       <LI><jsp:include page="news/Item3.html" flush="true"/>
>       <LI><jsp:include page="news/Item4.html" flush="true"/>
>     </OL>
>     </BODY>
>     </HTML>

Aquí tenemos un resultado típico:

### 8.2 Acción jsp:useBean

Esta acción nos permite cargar y utilizar un JavaBean en la página JSP. Esta es una capacidad muy útil porque nos permite utilizar la reusabilidad de las clases Java sin sacrificar la conveniencia de añadir JSP sobre servlets solitarios. El síntaxis más simple para especificar que se debería usar un Bean es:

>     <jsp:useBean id="name" class="package.class" />

Esto normalmente significa "ejemplariza un objeto de la clase especificada por class, y unelo a una variable con el nombre especificado por id". Sin embargo, también podemos especifar un atributo scope que hace que ese Bean se asocie con más de una sóla página. En este caso, es útil obtener referencias a los beans existentes, y la acción jsp:useBean especifica que se ejemplarizará un nuevo objeto si no existe uno con el el mismo nombre y ámbito.

Ahora, una vez que tenemos un bean, podemos modificar sus propiedades mediante jsp:setProperty, o usando un scriptlet y llamando a un método explícitamente sobre el objeto con el nombre de la variable especificada anteriormente mediante el atributo id. Recuerda que con los beans, cuando decimos "este bean tiene una propiedad del tipo X llamada foo", realmente queremos decir "Esta clase tiene un método getFoo que devuelve algo del tipo X, y otro método llamado setFoo que toma un X como un argumento". La acción jsp:setProperty se describe con más detalle en la siguiente sección, pero ahora observemos que podemos suministrar un valor explícito, dando un atributo param para decir que el valor está derivado del parámetro de la petición nombrado, o sólo lista las propiedades para indicar que el valor debería derivarse de los parámetros de la petición con el mismo nombre que la propiedad. Leemos las propiedades existentes en una expresión o scriptlet JSP llamando al método getXxx, o más comunmente, usando la acción jsp:getProperty.

Observa que la clase especifica por el bean debe estar en el path normal del servidor, no en la parte reservada que obtiene la recarga automática cuando se modifican. Por ejemplo, en el Java Web Server, él y todas las clases que usa deben ir en el directorio classes o estar en un fichero JAR en el directorio lib, no en el directorio servlets.

Aquí tenemos un ejemplo muy sencillo que carga un bean y selecciona y obtiene un sencillo parámetro String.

### BeanTest.jsp

También puedes descargar el código fuente.

>     <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
>     <HTML>
>     <HEAD>
>     <TITLE>Reusing JavaBeans in JSP</TITLE>
>     <LINK REL=STYLESHEET
>           HREF="My-Style-Sheet.css"
>           TYPE="text/css">
>     </HEAD>

>     <BODY>

>     <CENTER>
>     <TABLE BORDER=5>
>       <TR><TH CLASS="TITLE">
>           Reusing JavaBeans in JSP</TABLE>
>     </CENTER>
>     <P>

>     <jsp:useBean id="test" class="hall.SimpleBean" />
>     <jsp:setProperty name="test"
>                      property="message"
>                      value="Hello WWW" />

>     <H1>Message: <I>
>     <jsp:getProperty name="test" property="message" />
>     </I></H1>

>     </BODY>
>     </HTML>

### SimpleBean.java

Aquí está el código fuente usado para el Bean usado en la página BeanTest. También puedes descargar el código fuente.

>     package hall;

>     public class SimpleBean {
>       private String message = "No message specified";

>       public String getMessage() {
>         return(message);
>       }

>       public void setMessage(String message) {
>         this.message = message;
>       }
>     }

Aquí tenemos un resultado típico:

### 8.3 Más detalles de jsp:useBean

La forma más sencilla de usar un Bean es usar:

>     <jsp:useBean id="name" class="package.class" />

para cargar el Bean, luego usar jsp:setProperty y jsp:getProperty para modificar y recuperar propiedades del bean. Sin embargo, tenemos dos opciones. Primero, podemos usar un formato de contenedor, llamado:

>     <jsp:useBean ...>
>     Body
>     </jsp:useBean>

Para indicar que la porción Body sólo se debería ejecutar cuando el bean es ejemplarizado por primera vez, no cuando un bean existente se encuentre y se utilice. Como se explica abajo, los bean pueden ser compartidos, por eso no todas las sentencias jsp:useBean resultan en la ejemplarización de un Bean. Segundo, además de id y class, hay otros tres atributos que podemos usar: scope, type, y beanName.

Atributo | Uso
--- | ---
id | Da un nombre a la variable que referenciará el bean. Se usará un objeto bean anterior en lugar de ejemplarizar uno nuevo si se puede encontrar uno con el mismo id y scope.
class | Designa el nombre completo del paquete del bean.
scope | Indica el contexto en el que el bean debería estar disponible. Hay cuatro posibles valores: page, request, session, y application. El valor por defecto, page, indica que el bean estará sólo disponible para la página actual (almacenado en el PageContext de la página actual). Un valor de request indica que el bean sólo está disponible para la petición actual del cliente (almacenado en el objeto ServletRequest). Un valor de session indica que el objeto está disponible para todas las páginas durante el tiempo de vida de la HttpSession actual. Finalmente, un valor de application indica que está disponible para todas las páginas que compartan el mismo ServletContext. La razón de la importancia del ámbito es que una entrada jsp:useBean sólo resultará en la ejemplarización de un nuevo objeto si no había objetos anteriores con el mismo id y scope. De otra forma, se usarán los objetos existentes, y cualquier elemento jsp:setParameter u otras entradas entre las etiquetas de inicio jsp:useBean y la etiqueta de final, serán ignoradas.
type | Especifica el tipo de la variable a la que se referirá el objeto. Este debe corresponder con el nombre de la clase o ser una superclase o un interface que implemente la clase. Recuerda que el nombre de la variable se designa mediante el atributo id.
beanName | Da el nombre del bean, como lo suministraríamos en el método instantiate de Beans. Esta permitido suministrar un type y un beanName, y omitir el atributo class.

### 8.4 Acción jsp:setProperty

Usamos jsp:setProperty para obtener valores de propiedades de los beans que se han referenciado anteriormente. Podemos hacer esto en dos contextos. Primero, podemos usar antes jsp:setProperty, pero fuera de, un elemento jsp:useBean, de esta forma:

>     <jsp:useBean id="myName" ... />
>     ...
>     <jsp:setProperty name="myName"
>                      property="someProperty" ... />

En este caso, el jsp:setProperty se ejecuta sin importar si se ha ejemplarizado un nuevo bean o se ha encontrado uno ya existente. Un segundo contexto en el que jsp:setProperty puede aparecer dentro del cuerpo de un elemento jsp:useBean, de esta forma:

>     <jsp:useBean id="myName" ... >
>       ...
>       <jsp:setProperty name="myName"
>                        property="someProperty" ... />
>     </jsp:useBean>

Aquí, el jsp:setProperty sólo se ejecuta si se ha ejemplarizado un nuevo objeto, no si se encontró uno ya existente.

Aquí tenemos los cuatro atributos posibles de jsp:setProperty:

Atributo | Uso
--- | ---
name | Este atibuto requerido designa el bean cuya propiedad va a ser seleccionada. El elemento jsp:useBean debe aparecer antes del elemento jsp:setProperty.
property | Este atributo requerido indica la propiedad que queremos seleccionar. Sin embargo, hay un caso especial: un valor de "*" significa que todos los parámetros de la petición cuyos nombres correspondan con nombres de propiedades del Bean serán pasados a los métodos de selección apropiados.
value | Este atributo opcional especifica el valor para la propiedad. Los valores string son convertidos automáticamente a números, boolean, Boolean, byte, Byte, char, y Character mediante el método estándard valueOf en la fuente o la clase envolvente. Por ejemplo, un valor de "true" para una propiedad boolean o Boolean será convertido mediante Boolean.valueOf, y un valor de "42" para una propiedad int o Integer será convertido con Integer.valueOf. No podemos usar value y param juntos, pero si está permitido no usar ninguna.
> param | Este parámetro opcional designa el parámetro de la petición del que se debería derivar la propiedad. Si la petición actual no tiene dicho parámetro, no se hace nada: el sistema no pasa null al método seleccionador de la propiedad. Así, podemos dejar que el bean suministre los valores por defecto, sobreescribiendolos sólo cuando el parámetro dice que lo haga. Por ejemplo, el siguiente código dice "selecciona el valor de la propiedad numberOfItems a cualquier valor que tenga el perámetro numItems de la petición, si existe dicho parámetro, si no existe no se hace nada"
>     <jsp:setProperty name="orderBean"
>                      property="numberOfItems"
>                      param="numItems" />
Si omitimos tanto value como param, es lo mismo que si suministramos un nombre de parámetro que corresponde con el nombre de una propiedad. Podremo tomar esta idea de automaticidad usando el parámetro de la petición cuyo nombre corresponde con la propiedad suministrada un nombre de propiedad de "*" y omitir tanto value como param. En este caso, el servidor itera sobre las propiedades disponibles y los parámetros de la petición, correspondiendo aquellas con nombres idénticos.

Aquí tenemos un ejemplo que usa un bean para crear una tabla de números primos. Si hay un parámetro llamado numDigits en los datos de la petición, se pasa dentro del bean a la propiedad numDigits. Al igual que en numPrimes.

### JspPrimes.jsp

Para descargar el código JSP, pulsa con el botón derecho sobre el enlace.

>     <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
>     <HTML>
>     <HEAD>
>     <TITLE>Reusing JavaBeans in JSP</TITLE>
>     <LINK REL=STYLESHEET
>           HREF="My-Style-Sheet.css"
>           TYPE="text/css">
>     </HEAD>

>     <BODY>

>     <CENTER>
>     <TABLE BORDER=5>
>       <TR><TH CLASS="TITLE">
>           Reusing JavaBeans in JSP</TABLE>
>     </CENTER>
>     <P>

>     <jsp:useBean id="primeTable" class="hall.NumberedPrimes" />
>     <jsp:setProperty name="primeTable" property="numDigits" />
>     <jsp:setProperty name="primeTable" property="numPrimes" />

>     Some <jsp:getProperty name="primeTable" property="numDigits" />
>     digit primes:
>     <jsp:getProperty name="primeTable" property="numberedList" />

>     </BODY>
>     </HTML>

Aquí tenemos un resultado típico:

### 8.5 Acción jsp:getProperty

Este elemento recuperar el valor de una propiedad del bean, lo convierte a un string, e inserta el valor en la salida. Los dos atributos requeridos son name, el nombre de un bean referenciado anteriormente mediante jsp:useBean, y property, la propiedad cuyo valor debería ser insertado. Aquí tenemos un ejemplo:

>     <jsp:useBean id="itemBean" ... />
>     ...
>     <UL>
>       <LI>Number of items:
>           <jsp:getProperty name="itemBean" property="numItems" />
>       <LI>Cost of each:
>           <jsp:getProperty name="itemBean" property="unitCost" />
>     </UL>

### 8.6 Acción jsp:forward

Esta acción nos permite reenviar la petición a otra página. Tiene un sólo atributo, page, que debería consistir en una URL relativa. Este podría ser un valor estático, o podría ser calculado en el momento de la petición, como en estos dos ejemplo:

>     <jsp:forward page="/utils/errorReporter.jsp" />
>     <jsp:forward page="<%= someJavaExpression %>" />

### 8.7 Acción jsp:plugin

Esta acción nos permite insertar un elemento OBJECT o EMBED específico del navegador para especificar que el navegador debería ejecutar un applet usando el Plug-in Java.

## 9. Convenciones de Comentarios y Caracteres de Escape

Hay un pequeño número de construcciones especiales que podemos usar en varios casos para insertar comentarios o caracteres que de otra forma serían tratados especialmente:

Síntaxis | Propósito
--- | ---
    <%-- comment --%>
| Un comentario JSP. Ignorado por el traductor JSP-a-scriptlet. Cualquier elemento de script, directivas o acciones embebidas son ignorados.
    <!-- comment -->
| Un comentario HTML. Se pasa al HTML resultante. Cualquier elemento de script, directivas o acciones embebidas se ejecutan normalmente.
    <\%
| Usado en plantillas de texto (HTML estático) donde realmente queremos "<%".
    %\>
| Usado en elementos de script donde realmente queremos "%>".
    \'
| Una sola comilla en un atributo que usa comillas simples. Sin embargo, recuerda que podemos usar comillas dobles o simples, y que otros tipos de comillas serán caracteres regulares.
    \"
| Una doble comilla un un atributo que usa comillas dobles. Sin embargo, recuerda que podemos usar comillas dobles o simples, y que otros tipos de comillas serán caracteres regulares.
    %\>
| %> en un atributo.
    <\%
| <% en un atributo.

Ozito