A diferencia de los elementos de directiva JSP, los elementos de acción JSP funcionan durante la fase de procesamiento de solicitudes. Los elementos de acción JSP están escritos en sintaxis XML.
Utilice acciones JSP para insertar archivos dinámicamente, reutilizar componentes JavaBean, redirigir a los usuarios a otras páginas y generar código HTML para complementos Java.
Sólo hay una sintaxis para los elementos de acción y se ajusta al estándar XML:
<jsp:nombre_acción atributo="valor" />
Los elementos de acción son básicamente funciones predefinidas. La especificación JSP define una serie de acciones estándar, que utilizan JSP como prefijo. Los elementos de acción estándar disponibles son los siguientes:
| gramática | describir |
|---|---|
| jsp: incluir | Importe un archivo cuando se solicite la página. |
| jsp:useBean | Encuentre o cree una instancia de un JavaBean. |
| jsp: establecer propiedad | Establezca las propiedades de JavaBean. |
| jsp:getPropiedad | Genera las propiedades de un JavaBean. |
| jsp: adelante | Envíe la solicitud a una nueva página. |
| jsp: complemento | Genera etiquetas OBJECT o EMBED para complementos de Java según el tipo de navegador. |
| jsp:elemento | Definir elementos XML dinámicos |
| jsp:atributo | Establezca atributos de elementos XML definidos dinámicamente. |
| jsp:cuerpo | Establece el contenido de un elemento XML definido dinámicamente. |
| jsp:texto | Usar plantillas que escriben texto en páginas y documentos JSP |
Todos los elementos de acción tienen dos atributos: atributo de identificación y atributo de alcance.
atributo de identificación:
El atributo id es el identificador único del elemento de acción y se puede hacer referencia a él en la página JSP. El valor de identificación creado por el elemento de acción se puede llamar a través de PageContext.
atributo de alcance:
Este atributo se utiliza para identificar el ciclo de vida del elemento de acción. El atributo de identificación está directamente relacionado con el atributo de alcance, y el atributo de alcance define la vida útil del objeto de identificación asociado. El atributo de alcance tiene cuatro valores posibles: (a) página, (b) solicitud, (c) sesión y (d) aplicación.
El elemento de acción <jsp:include> se utiliza para incluir archivos estáticos y dinámicos. Esta acción inserta el archivo especificado en la página que se está generando. El formato de sintaxis es el siguiente:
<jsp:include page="URL relativa" flush="true" />
La directiva de inclusión se introdujo anteriormente. Introduce archivos cuando el archivo JSP se convierte en un servlet. La acción jsp:include aquí es diferente. El momento en que se inserta el archivo es cuando se solicita la página.
La siguiente es una lista de propiedades relacionadas con la acción de inclusión.
| propiedad | describir |
|---|---|
| página | La dirección URL relativa contenida en la página. |
| enjuagar | Propiedad booleana que define si se debe vaciar la caché antes de incluir el recurso. |
A continuación definimos dos archivos date.jsp y main.jsp, el código es el siguiente:
Código del archivo date.jsp:
<p> Fecha de hoy: <%= (new java.util.Date()).toLocaleString()%></p>
Código del archivo principal.jsp:
<html><head><title>Ejemplo de acción de inclusión</title></head><body><center><h2>Ejemplo de acción de inclusión</h2><jsp:include page="date.jsp" flux ="verdadero" /></center></body></html>
Ahora coloque los dos archivos anteriores en el directorio raíz del servidor y acceda al archivo main.jsp. Los resultados mostrados son los siguientes:
Ejemplo de acción de inclusiónFecha de hoy: 12 de septiembre de 2013 14:54:22
La acción jsp:useBean se utiliza para cargar un JavaBean que se utilizará en la página JSP.
Esta característica es muy útil porque nos permite aprovechar la reutilización de componentes Java evitando la pérdida de la conveniencia que distingue a JSP de los Servlets.
La sintaxis más sencilla para la acción jsp:useBean es:
<jsp:useBean id="nombre" />
Una vez cargada la clase, podemos modificar y recuperar las propiedades del bean mediante las acciones jsp:setProperty y jsp:getProperty.
La siguiente es una lista de propiedades relacionadas con la acción useBean.
| propiedad | describir |
|---|---|
| clase | Especifique el nombre completo del paquete del bean. |
| tipo | Especifica el tipo que hará referencia a la variable de objeto. |
| nombre del frijol | Especifique el nombre del Bean mediante el método instantiate() de java.beans.Beans. |
Antes de dar ejemplos específicos, veamos primero los elementos de acción jsp:setProperty y jsp:getProperty:
jsp:setProperty se usa para establecer las propiedades del objeto Bean instanciado. Hay dos formas de usarlo. Primero, puedes usar jsp:setProperty fuera (detrás) del elemento jsp:useBean, así:
<jsp:useBean id="miNombre" ... />...<jsp:setProperty nombre="miNombre" propiedad="algunaPropiedad" .../>
En este momento, ya sea que jsp:useBean encuentre un Bean existente o cree una nueva instancia de Bean, se ejecutará jsp:setProperty. El segundo uso es colocar jsp:setProperty dentro del elemento jsp:useBean, como se muestra a continuación:
<jsp:useBean id="miNombre" ... >... <jsp:setProperty nombre="miNombre" propiedad="algunaPropiedad" .../></jsp:useBean>
En este momento, jsp:setProperty solo se ejecutará al crear una nueva instancia de Bean. Si se utiliza una instancia existente, jsp:setProperty no se ejecutará.
| propiedad | describir |
|---|---|
| nombre | El atributo de nombre es obligatorio. Indica en qué Bean se establecerá la propiedad. |
| propiedad | El atributo de propiedad es obligatorio. Indica qué propiedad establecer. Hay un uso especial: si el valor de la propiedad es "*", significa que todos los parámetros de solicitud cuyos nombres coincidan con los nombres de las propiedades del Bean se pasarán al método de conjunto de propiedades correspondiente. |
| valor | El atributo de valor es opcional. Esta propiedad se utiliza para especificar el valor de la propiedad Bean. Los datos de cadena se convertirán automáticamente en números, booleanos, booleanos, bytes, bytes, caracteres y caracteres mediante el método valueOf estándar en la clase de destino. Por ejemplo, los valores de atributos de tipo booleano y booleano (como "verdadero") se convierten mediante Boolean.valueOf, y los valores de atributos de tipo int e Integer (como "42") se convierten mediante Integer.valueOf. El valor y el parámetro no se pueden usar al mismo tiempo, pero se puede usar cualquiera de ellos. |
| parámetro | El parámetro es opcional. Especifica qué parámetro de solicitud se utiliza como valor de la propiedad Bean. Si la solicitud actual no tiene parámetros, no se hará nada y el sistema no pasará nulo al método establecido de la propiedad Bean. Por lo tanto, puede dejar que el bean proporcione el valor de propiedad predeterminado y solo modifique el valor de propiedad predeterminado cuando el parámetro de solicitud especifique explícitamente un nuevo valor. |
La acción jsp:getProperty extrae el valor de la propiedad Bean especificada, lo convierte en una cadena y luego lo genera. El formato de sintaxis es el siguiente:
<jsp:useBean id="miNombre" ... />...<jsp:getProperty nombre="miNombre" propiedad="algunaPropiedad" .../>
La siguiente tabla son las propiedades asociadas con getProperty:
| propiedad | describir |
|---|---|
| nombre | El nombre de la propiedad Bean que se va a recuperar. Se debe definir el frijol. |
| propiedad | Indica que se va a extraer el valor de la propiedad Bean. |
En los siguientes ejemplos utilizamos Beans:
/* Archivo: TestBean.java */paquete acción; public class TestBean { mensaje de cadena privado = "No se ha especificado ningún mensaje"; cadena pública getMessage() { return(mensaje } setMessage público void (mensaje de cadena) { this.message); mensaje; }}Compile el ejemplo anterior y genere el archivo TestBean.class. Copie el archivo en el directorio donde el servidor almacena oficialmente las clases Java, en lugar del directorio reservado para las clases que se pueden cargar automáticamente después de la modificación (por ejemplo: C:apache-tomcat). -7.0.2 directorio webappsWEB-INFclassesaction, la variable CLASSPATH debe contener esta ruta). Por ejemplo, para Java Web Server, los beans y todas las clases utilizadas por los beans deben colocarse en el directorio de clases, o encapsularse en archivos jar y colocarse en el directorio lib, pero no deben colocarse bajo servlets. El siguiente es un ejemplo muy simple. Su función es cargar un Bean y luego configurar/leer su propiedad de mensaje.
Ahora llamemos al Bean en el archivo main.jsp:
<html><head><title>Usar JavaBeans en JSP</title></head><body><center><h2>Usar JavaBeans en JSP</h2> <jsp:useBean id="test" /> < jsp:setProperty name="test" property="message" value="Hola JSP..." /> <p>Recibido el mensaje...</p> <jsp:getProperty name="test" property="mensaje " /> </center></body></html>
Ejecute el archivo anterior y el resultado será el siguiente:
Usando JavaBeans en JSP Mensaje recibido....Hola JSP...
La acción jsp:forward reenvía la solicitud a otra página. La etiqueta jsp:forward tiene un solo atributo, página. El formato de sintaxis es el siguiente:
<jsp:forward page="URL relativa" />
Los siguientes son los atributos asociados con el reenvío:
| propiedad | describir |
|---|---|
| página | El atributo de página contiene una URL relativa. El valor de la página se puede proporcionar directamente o calcularse dinámicamente durante la solicitud. Puede ser una página JSP o un servlet Java. |
Usamos dos archivos en los siguientes ejemplos: date.jsp y main.jsp.
El código del archivo date.jsp es el siguiente:
<p> Fecha de hoy: <%= (new java.util.Date()).toLocaleString()%></p>
Código del archivo principal.jsp:
<html><head><title>Ejemplo de acción de reenvío</title></head><body><center><h2>Ejemplo de acción de reenvío</h2><jsp:forward page="date.jsp" / </center></body>
Ahora coloque los dos archivos anteriores en el directorio raíz del servidor y acceda al archivo main.jsp. Los resultados mostrados son los siguientes:
Fecha de hoy: 12-sep-2010 14:54:22
La acción jsp:plugin se utiliza para insertar los elementos OBJECT o EMBED necesarios para ejecutar el subprograma de Java a través del complemento de Java, según el tipo de navegador.
Si el complemento requerido no existe, lo descarga y luego ejecuta el componente Java. Un componente de Java puede ser un subprograma o un JavaBean.
La acción del complemento tiene múltiples atributos correspondientes a elementos HTML utilizados para formatear componentes Java. El elemento param se puede utilizar para pasar parámetros a Applet o Bean.
El siguiente es un ejemplo típico del uso del elemento de acción del complemento:
<jsp:plugin type="applet" codebase="dirname" code="MyApplet.class" > <jsp:param name="fontcolor" value="red" /> <jsp:param name="fondo" value=" black" /> <jsp:fallback> No se puede inicializar el complemento Java </jsp:fallback> </jsp:plugin>
Si está interesado, puede intentar usar un subprograma para probar el elemento de acción jsp:plugin. El elemento <fallback> es un elemento nuevo. Cuando el componente falla, se envía un mensaje de error al usuario.
Los elementos de acción <jsp:element>, <jsp:attribute>, <jsp:body> definen dinámicamente elementos XML. La dinámica es muy importante, lo que significa que los elementos XML se generan dinámicamente en tiempo de compilación en lugar de estáticos.
El siguiente ejemplo define dinámicamente elementos XML:
<%@page language="java" contentType="text/html"%><html xmlns="http://www.w3c.org/1999/xhtml" xmlns:jsp="http://java.sun. com/JSP/Page"><head><title>Generar elemento XML</title></head><body><jsp:element name="xmlElement"><jsp:attribute name="xmlElementAttr"> Valor para el atributo</jsp:attribute><jsp:body> Cuerpo del elemento XML</jsp:body></jsp:element></body></html>
El código HTML generado durante la ejecución es el siguiente:
<html xmlns="http://www.w3c.org/1999/xhtml" xmlns:jsp="http://java.sun.com/JSP/Page"> <head><title>Generar elemento XML</ title></head><body><xmlElement xmlElementAttr="Valor del atributo"> Cuerpo del elemento XML</xmlElement></body></html>
El elemento de acción <jsp:text> permite el uso de plantillas para escribir texto en páginas y documentos JSP. El formato de sintaxis es el siguiente:
<jsp:text>Datos de plantilla</jsp:text>
La plantilla de texto anterior no puede contener otros elementos, solo puede contener texto y expresiones EL (Nota: las expresiones EL se introducirán en capítulos posteriores). Tenga en cuenta que en archivos XML no puede utilizar expresiones como ${whatever > 0} porque el símbolo > es ilegal. Puede utilizar la expresión ${whatever gt 0} o el valor incrustado en una sección CDATA.
<jsp:text><![CDATA[<br>]]></jsp:text>
Si necesita declarar DOCTYPE en XHTML, debe utilizar el elemento de acción <jsp:text>. Un ejemplo es el siguiente:
<jsp:text><![CDATA[<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//ES" "DTD/xhtml1-strict.dtd">]]></jsp:text>< head><title>jsp:text action</title></head><body><books><book><jsp:text> Bienvenido a JSP Programación</jsp:text></book></books></body></html>
Puede probar el ejemplo anterior para ver la diferencia entre usar <jsp:text> y no usar este elemento de acción.