Acciones Estandar

Acciones estndar de JSP - JSP
Esta vez hablaremos de las acciones JSP, Y que es eso? Pues, bsicamente, las acciones, son
etiquetas predefinidas en una JSP, las cuales proveen algunas funcionalidades como por ejemplo
trabajar con beans o incluir contenido en una jsp. Las acciones estndar de JSP son de la forma
<jsp:accin>, las cuales son las siguientes:
<jsp:forward>
<jsp:include>
<jsp:plugin>
<jsp:param>
<jsp:useBean>
<jsp:setProperty>
<jsp:getProperty>
Cabe destacar que las tres ltimas etiquetas son las utilizadas para la manipulacin de JavaBeans.
Para los ejemplos de este post, creamos nuestro proyecto JSP llamado AccionesEstandar:
-----------------------------------------------------------------------------------------
1. <jsp:include>
La etiqueta <jsp:include> funciona igual que la directiva Include. Dicha etiqueta nos permite
incluir contenido de otro archivo en nuestra JSP. Pero entonces cul es la diferencia? La diferencia
radica en si el archivo a incluir cambia, cuando usemos la etiqueta <jsp:include> dichos
cambios se vern reflejados, en cambio no ocurrir lo mismo con la directiva include. Vamos al
ejemplo, el cual es muy parecido al que hicimos en el post anterior:

Crea el archivo, cabecera.jsp:

Y el cdigo de cabecera.jsp:

<p>Este escrito est contenido en el archivo <b>cabecera.jsp</b></P>

Como ves, solamente es una sola lnea. Sin embargo, si vas a incluir ms contenido en ese archivo,
trata de que las etiquetas HTML, sean coherentes, por ejemplo, no debes incluir la etiqueta
<body> en cabecera.jsp pues, el index.jsp, ya tiene una etiqueta body. Para que me entiendas un
poco mejor, modifiquemos el cabecera.jsp y tambin crearemos el pieDePagina.jsp:

Nuestro archivo cabecera.jsp:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
Este escrito est contenido en el archivo <b>cabecera.jsp</b>
Y ahora el pieDePagina.jsp:
Este es el archivo <b>PieDePagina.jsp</b>
</body>
</html>

Finalmente, nuestro index.jsp (Solamente estas tres lneas):

<jsp:include page="cabecera.jsp" flush="true"/>
<p>
Aqu debe ir algn contenido del <b>index.jsp</b>
</p>
<jsp:include page="pieDePagina.jsp" flush="true"/>

Veamos entonces, en la lnea <jsp:include page="cabecera.jsp" flush="true"/>
El atributo page es el archivo a incluir en nuestra JSP, mientras que el atributo flush, es para
limpiar el buffer una vez que se haya incluido dicho archivo en nuestra JSP. La accin jsp:include
requiere ms sobrecarga que la directiva include, es por eso que el atributo flush siempre debe
ser true. Por defecto, la JSP configura el atributo flush de jsp:include como false. Solo menciono
esa parte, por cuestiones de rendimiento.

Ahora ejecutamos, como ves, se incluyen tanto las etiquetas HTML y JSP de los dos archivos y se
mezclan con nuestro archivo index.jsp.
---------------------------------------------------------------------------------
2. <jsp:useBean>, <jsp:getProperty> y <jsp:setProperty>

La accin useBean simplemente nos permite usar un Bean (una clase de Java) en una pgina JSP.
Mientras que las acciones setProperty y getProperty nos permiten establecer un valor en una
propiedad del bean y obtener un valor de una propiedad del bean, respectivamente.
Veamos el ejemplo:

Creamos una clase llamada Persona en el paquete beans:

Ahora veamos el cdigo, crearemos una propiedad nombre con sus respectivos mtodos get y
set, para que el ejemplo funcione, debemos seguir ciertas reglas de los JavaBeans, y es que el
mtodo para obtener un valor de un campo de nuestra clase debe ser getNombreDeLaPropiedad,
para nuestro caso sera getNombre() nos devuelve el valor que tiene la propiedad nombre de
nuestro bean. Mientras que para establecer valores debe ser
setNombreDeLaPropiedad(tipoDeDato valor), para nuestra propiedad nombre sera
setNombre(String valor), veamos :

package beans;
public class Persona {

private String nombre;
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
}
Ahora en nuestro index.jsp usaremos las etiquetas useBean, setProperty y getProperty:

<jsp:useBean class="beans.Persona" id="persona" scope="page"/>
<html>
<head>
</head>
<body>
<jsp:setProperty name="persona" property="nombre" value="Maria"/>
<%="El nombre de la persona es : "%>
<h1><jsp:getProperty name="persona" property="nombre"/></h1>
</body>
</html>
--------------------------------
En la lnea,
<jsp:useBean class="beans.Persona" id="persona"scope=page/>

No era necesario incluir el atributo scope en este ejemplo, pero lo puse para aclarar algo. Scope
literalmente significa alcance, pues bien, en JSP, existen diferentes tipos de alcance para los
beans, los cuales son page, request, sesin y application.

Los beans que tienen el alcance de tipo page, solo puede ser accedidos desde la misma pgina
donde se est haciendo uso de l. En este caso, el bean persona solo est disponible para
nuestro index.jsp, pero no para otras JSP que definamos en nuestro proyecto.

Si un bean tiene alcance de tipo request, sus datos (o propiedades, como quieras llamarlos) solo
pueden ser accedidos durante la peticin en la que fue creado, por ejemplo, si en el index yo creo
el bean persona, pero quiero que los datos de ese bean se muestren en un pagina llamada
resultados.jsp entonces dicho bean, solo existir en el momento en que index.jsp le enve los
datos a resultados.jsp, y una vez que se muestren los datos en la pagina resultados.jsp el bean
desaparecer de la memoria inmediatamente, as entonces, los datos no pueden ser accedidos
luego de eso.

El alcance tipo session permite que los datos del bean sean ledos las veces que yo guste, por las
pginas que traten de usarlo, mientras exista todava una sesin, es decir, mientras el navegador
no se cierre.

Por ltimo, si un bean tiene un alcance de tipo application, el bean estar disponible para todas
las paginas JSP de nuestra aplicacin, sin embargo, se debe tener cuidado con no repetir el
identificador de nuestros beans y tener en cuenta cuidadosamente qu pagina cambia los valores
del bean, para no llegar a cometer errores lgicos en nuestra aplicacin.
Volvamos al ejemplo.
Ahora, simplemente creamos un objeto de la clase Persona, cuyo identificador en nuestra pgina
jsp ser persona, aunque puedes usar el nombre que gustes como identificador.

Ahora, la lnea,
<jsp:setProperty name="persona" property="nombre" value="Maria"/>

Simplemente pone el valor Maria en la propiedad nombre del objeto persona.
Y finalmente, la lnea

<jsp:getProperty name="persona" property="nombre"/>

Obtiene el valor de la propiedad nombre del objeto persona y ejecutamos.
----------------------------------------------------------------------------------------------------------------------
3. <jsp:forward> y <jsp:param>
La accion forward nos adyuda a redirigir la peticin hacia una nueva jsp. Mientras que la accin
param, nos permite pasar parmetros entre dos jsp, Pero se requiere que la accin jsp:param est
incluida dentro de una accin jsp:forward veamos el ejemplo:

Crea una jsp llamada Resultado:

Ahora, nuestro index jsp:

<html>
<head>
<meta http-equiv="Content-Type" content="text/html;
charset=UTF-8">
</head>
<body>
<jsp:forward page="resultado.jsp">
<jsp:param name="parametro" value="Valor_del_parametro"/>
</jsp:forward>
</body>
</html>

La lnea,

<jsp:forward page="resultado.jsp">

Como vers al ejecutar el ejemplo, al abrirse el index.jsp, inmediatamente nos va a redirigir a la
pgina resultados.jsp. y se le enviar un parmetro llamado parametro por medio de la lnea que
dice:

<jsp:param name="parametro" value="Valor_del_parametro"/>

Ahora, nuestro resultados.jsp:

<html>
<head>
</head>
<body>
El parametro enviado por index.jsp es:
<h1><%=request.getParameter("parametro")%></h1>
</body>
</html>

En el cdigo anterior, simplemente mostramos el valor del parmetro recibido,Ejecutamos
-------------------------------------------------------------------------------------------------------
4. <jsp:plugin>
Generalmente, esta etiqueta se usa para mostrar un Applet en un archivo JSP. Para este ejemplo
gener por aparte un .class del siguiente Applet (solo necesitamos el .class):

import java.awt.Graphics;
import javax.swing.JApplet;
public class AppletDeEjemplo extends JApplet {
public void paint( Graphics g ) {
super.paint(g);
g.drawString("Esto es un applet de ejemplo", 100, 100);
} }

Arrastra ese .class desde donde lo tengas guardado, hasta esta carpeta en Netbeans que dice
Web Pages o ve al directorio del proyecto, y pgalo en la carpeta web:

Normalmente el applet se ejecuta a travs de una pgina HTML, con la etiqueta <applet>(lo
recuerdas?....), as que en nuestro index.jsp, tendramos algo as, por ejemplo:

<html>
<head>
</head>
<body>
<applet code = "AppletDeEjemplo.class" width="400" height="200">
</applet>
</body>
</html>
Al ejecutarlo vemos el resultado.

Pero como estamos trabajando la etiqueta <jsp:plugin> escribimos esto:
<jsp:plugin type="applet" code="AppletDeEjemplo.class"
width="400" height="200"/>
Por lo que nuestro index.jsp, ahora se ve as:
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;
charset=UTF-8">
</head>
<body>
<jsp:plugin type="applet"
code="AppletDeEjemplo.class" width="400" height="200"/>
</body>
</html>

Nuevamente ejecutamos y obtenemos el mismo resultado que con la etiqueta <applet>.

Acciones Estandar

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Acciones Estandar

Cargado por

Copyright:

Formatos disponibles

Acciones estndar de JSP - JSP

También podría gustarte