Comunicación entre TAGs, Beans y JSPs

1
37780

Comunicación entre elementos en páginas JSP 

Creación de JSPs

Los JSP, ya sabemos que son plantillas donde podemos utilizar distintos tipos
de componentes (JavaBeans y TagsLibs) o insertar porciones de Java utilizando
Scriplets ….

Aquí es donde debemos aportar nuestro conocimiento y sentido común,
definiendo que elementos se deben utilizar en cada caso.

Os vamos a mostrar como, utilizar cada uno de los componentes y como
interactúan entre sí y en función de la situación, proporcionaremos
distintas directivas.

Vamos a partir de un JSPs que pone datos a la sesión y en la petición y que
delega sobre otro, nuestro JSP objeto de estudio.

(Tanto las pantallas como el código están generados desde NetBeans 3.5 y no
se han capturado más pasos porque ya existen otros tutoriales en este Web que
muestran paso a paso cada una de las tareas realizadas)

Mostramos el código de nuestro BeanBasico

Y creamos un JSP que use este Bean

<%@page contentType=»text/html»%>
<html>
<head><title>JSP Page</title></head>
<body>

<jsp:useBean id=»beansimple» scope=»page» class=»roberto.rcbean» />
<jsp:getProperty name=»beansimple» property=»propiedadBasica» /> 

</body>
</html>

Y vemos que se muestra el valor de la propiedad

Acceder a un Bean desde un Scriptles

Desde cualquier parte de la página podemos acceder al Bean, a traves del id
que le hemos asignado.

<%@page contentType=»text/html»%>
<html>
<head><title>JSP Page</title></head>
<body>

<jsp:useBean id=»beansimple» scope=»page» class=»roberto.rcbean» />
<jsp:getProperty name=»beansimple» property=»propiedadBasica» /> 

<% String sCadena = beansimple.getPropiedadBasica();
out.print(«<br> <b>Volvemos a mostrar la cadana </b><br>» + sCadena); 
%>

</body>
</html>

Vemos el resultado

Todo tiene su explicación, si vemos el código que genera el JSP

 

Lectura de parámetros desde un Bean

Un Bean, deber ser un componente generico que deberiámos poder
reutilizar en muchos tipos de aplicaciones distintas.

Si alguien nos pasa un parámetro (desde un CGI), podemos de un
modo sencillo pasárselo a nuestro Bean a través de la propia etiqueta.

<%@page contentType=»text/html»%>
<html>
<head><title>JSP Page</title></head>
<body>

<jsp:useBean id=»beansimple» scope=»page» class=»roberto.rcbean» />
<jsp:setProperty name=»beansimple» property=»propiedadBasica» param=»cadenapasada» />

<% String sCadena = beansimple.getPropiedadBasica();
out.print(«<b>Volvemos a mostrar la cadena </b><br>» + sCadena); 
%>

</body>
</html>

Si pasamos el parámetro, aparecerá

 

Paso de un parámetro de petición a un Bean

El parámetro los enviamos desde el primer JSP

<%@page contentType=»text/html»%>
<html>
<head><title>JSP Page</title></head>
<body>
Este JSP los usaremos como punto de entrada

<% 
request.setAttribute(«valorpasado»,»Parametro enviado desde JSPINICIAL»); 
%>

<jsp:forward page=»/jspobjetivo.jsp» /> 

</body>
</html>

Y lo leemos desde el segundobJSP

<%@page contentType=»text/html»%>
<html>
<head><title>JSP Page</title></head>
<body>

<jsp:useBean id=»beansimple» scope=»page» class=»roberto.rcbean» />
<jsp:setProperty name=»beansimple» property=»propiedadBasica» 

value=‘<%= request.getAttribute(«valorpasado») %>’ />

<% String sCadena = beansimple.getPropiedadBasica();
out.print(«<b>Volvemos a mostrar la cadena </b><br>» + sCadena); 
%>

</body>
</html>

 

TagLibs simples y procesamiento de parámetros

Para simplificar la complejidad de las páginas JSPs, se crean
nuevas etiquetas, de tal modo que los diseñadores gráficos no tienen necesidad
de  conocer Java para interactuar con los objetos que deben formatear.

Vamos a crear una etiqueta que muestre un mensaje en pantalla,
concatenando un valor recogido como parámetro. Es decir, esta etiqueta hace
transparente al diseñador como se adquiere, valida o transforma. 

Creamos el JSP. Como podemos observar, no hay Scriptlet por
ningún lado.

<%@page contentType=»text/html»%>
<%@taglib uri=»rctags.tld» prefix=»rc»%>

<html>
<head><title>JSP Page</title></head>
<body>

Vamos a recoger un parametro y pasárselo al Tag
<br>

<b>
<rc:rctagsimple parametro=»parametropasado» />
</b>

</body>
</html>

Y la página resultante:

No olvidar que hace falta el descriptor para que funcione el tag
…..
rctags.tld

<?xml version=»1.0″ encoding=»UTF-8″ ?>

<!DOCTYPE taglib
PUBLIC «-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN»
«http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd»>

<taglib>
<tlib-version>1.0</tlib-version>
<jsp-version>1.2</jsp-version>
<short-name>rctags</short-name>
<uri>/rctags</uri>
<display-name>rctags</display-name>
<small-icon></small-icon>
<large-icon></large-icon>
<description>A blank tag library template. 
</description> 
<!– Forte4J_TLDX: This comment contains code generation information. Do not delete.
<tldx>
<tagHandlerGenerationRoot>classes</tagHandlerGenerationRoot>
<JarFile></JarFile>
</tldx>
–> <tag>
<name>rctagsimple</name>
<tag-class>roberto.RctagsimpleTag</tag-class>
<body-content>empty</body-content>
<small-icon></small-icon>
<large-icon></large-icon>
<description></description>
<!– Forte4J_TLDX: This comment contains code generation information. Do not delete.
<tldx>
<packagename>roberto</packagename>
<extendsSupportClass>TRUE</extendsSupportClass>
<supportClass>BodyTagSupport</supportClass>
<implementsTryCatchFinally>FALSE</implementsTryCatchFinally>
<findparent>FALSE</findparent>
<parenttype></parenttype>
<parentvariable></parentvariable>
</tldx>
–>
<attribute>
<name>parametro</name>
<required>false</required>
<rtexprvalue>true</rtexprvalue>
<type>String</type>
<!– Forte4J_TLDX: This comment contains code generation information. Do not delete.
<tldx>
<javaVariable></javaVariable>
<IsReferenceID>FALSE</IsReferenceID>
<ReferencesTag>FALSE</ReferencesTag>
<ReferenceScope>Session</ReferenceScope>
<ReferencesTagType></ReferencesTagType>
<ReferencesTagVariable></ReferencesTagVariable>
<ReferencesTagReferentFirst>TRUE</ReferencesTagReferentFirst>
</tldx>
–>
</attribute>
<example></example>
</tag>

<!– Validators are new in JSP1.2. You may have zero or one validator
in a tag library. They look like this:
<validator>
<validator-class>org.your.web.app.ValidateTaglibUsage</validator-class>
<init-param>
<param-name>aparameter</param-name>
<param-value>value</param-value>
<description>Describe this parameter</description>
</init-param>
</validator>
–>

<!– listeners are new in JSP1.2. You may have as many listeners as you like
in a tag library. They look like this:
<listener>
<listener-class>org.your.web.app.TaglibListener1</listener-class> 
</listener>
–>
</taglib>

Y tambien hay que incluir un par de lineas en el web.xml

<?xml version=»1.0″ encoding=»UTF-8″?>

<!DOCTYPE web-app
PUBLIC «-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN»
«http://java.sun.com/dtd/web-app_2_3.dtd»>

<web-app>
<session-config>
<session-timeout>
30
</session-timeout>
</session-config>
<welcome-file-list>
<welcome-file>
index.jsp
</welcome-file>
<welcome-file>
index.html
</welcome-file>
<welcome-file>
index.htm
</welcome-file>
</welcome-file-list>
<taglib>
    <taglib-uri>rctags.tld</taglib-uri>
    <taglib-location>rctags.tld</taglib-location>
</taglib>

</web-app>

Como sabemos…. todo tiene un porqué … así que … si vemos el código
del servlet que se genera

Para descargarnos los ficheros que hemos manejado hasta ahora pulsaraquí.

 

Comunicación entre un TAG y un JavaBean

Podemos crear variables dentro de nuestros tags  y luego hacerlos
accesibles desde nuestro código JSP. 

El procedimiento es bastante simple ….

Creamos nuestro JSP, donde podemos ver que hemos creado un cadena de
caracteres como un bean … y mostramos en pantalla el valor

<%@page contentType=»text/html»%>
<%@taglib uri=»rctags.tld» prefix=»rc»%>

<html>
<head><title>JSP Page</title></head>
<body>

<rc:rctagsimple parametro=»parametropasado» />
<br> Y se lo proporcionamos a un Bean, en mayúsculas
<b>
<jsp:useBean id=»valorsimple» scope=»page» class=»java.lang.String» />
<%= valorsimple %>

</b>

</body>
</html>

En nuestro TAG, podemos introducir un nuevo valor con el mismo ID y
ámbito
… y ya hemos resuelto el problema

Si vemos el código que se genera a partir del servlet .. entenderemos el
porqué

Y podemos ver que obtenemos el resultado deseado

¿para que podríamos necesitar esto por ahora? pues supongo que
realmente para poco…. si no queremos ser un poco chapuzas…. aunque esta
técnica podría sernos útil para otras cosas  … aunque ya veremos que
todo puede ser útil.

Variables de Scripting

Hemos visto en el ejemplo anterior que creamos una variable en nuestro TAG y
la hacemos pública (indirectamente a través de un Bean) a nuestro JSP.

Esto se puede mejorar, haciendo directamente pública la variables utilizando
una técnica que se llama variables de Scripting.

Si vamos a NetBeans.. podemos hacerlo de un modo automático … ya que hay
que realizar varios pasos.

 

Le damos un nombre

Y decimos al sistema que regenere el código

Vemos que se ha creado una nueva clase …. RCtagsimpleTagTEI ..
necesaria para hacer pública esta variable.

Y en nuestra clase principal han aparecido nuevos métodos

Ahora cambiaremos el código de nuestra tag para establecer el
valor …

Y modificamos la página JSP

<%@page contentType=»text/html»%>
<%@taglib uri=»rctags.tld» prefix=»rc»%>

<html>
<head><title>JSP Page</title></head>
<body>

<rc:rctagsimple parametro=»parametropasado»>
<br> Y se lo proporcionamos a un Bean, en mayúsculas: —
<b>
<%= variableDelTag %>
</b>

</rc:rctagsimple>

</body>
</html>

y vemos que somos capaces de recuperar el valor sin necesidad de usar la
declaración del bean …..

Podemos recuperar todo el código aquí

Conclusiones

Posibilidades de interacción entre elementos hay muchas.

Lo único que tenemos que tener en cuenta es que debemos proporcionar un
juego de componentes, fundamentalmente de TAG, muy básicos y simples y que no
requieran que los maquetadores deban saber demasiados tecnicismos.

Sobre el
Autor ..

1 Comentario

Dejar respuesta

Please enter your comment!
Please enter your name here