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
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
/* * rcbean.java * * Created on July 15, 2003, 12:21 AM */ package roberto; import java.beans.*; /** * * @author Administrator */ public class <font color="#0000FF"><b>rcbean</b></font> extends Object implements java.io.Serializable { private static final String PROP_SAMPLE_PROPERTY = "PropiedadBasica"; private String <font color="#0000FF"><b>propiedadBasica = "Esta es la propiedad básica"</b></font>; private PropertyChangeSupport propertySupport; /** Creates new rcbean */ public rcbean() { propertySupport = new PropertyChangeSupport( this ); } public String <font color="#0000FF"><b>getPropiedadBasica</b></font>() { return propiedadBasica; } public void setPropiedadBasica(String value) { String oldValue = propiedadBasica; propiedadBasica = value; propertySupport.firePropertyChange(PROP_SAMPLE_PROPERTY, oldValue, propiedadBasica); } public void addPropertyChangeListener(PropertyChangeListener listener) { propertySupport.addPropertyChangeListener(listener); } public void removePropertyChangeListener(PropertyChangeListener listener) { propertySupport.removePropertyChangeListener(listener); } } |
|
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.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 |
package roberto; import java.io.IOException; import java.io.PrintWriter; import javax.servlet.ServletRequest; import javax.servlet.jsp.JspException; import javax.servlet.jsp.JspWriter; import javax.servlet.jsp.PageContext; import javax.servlet.jsp.tagext.BodyContent; import javax.servlet.jsp.tagext.BodyTag; import javax.servlet.jsp.tagext.BodyTagSupport; import javax.servlet.jsp.tagext.IterationTag; import javax.servlet.jsp.tagext.Tag; import javax.servlet.jsp.tagext.TagSupport; public class <font color="#0000FF"><b>RctagsimpleTag</b></font> extends BodyTagSupport { private String parametro; public RctagsimpleTag() { super(); } public void otherDoStartTagOperations() { try { <font color="#0000FF"><b>JspWriter out = pageContext.getOut(); String sParametro = pageContext.getRequest().getParameter(parametro); out.println("El parámetro en la tag es: " + sParametro);</b></font> } catch (java.io.IOException ex) { // do something } } public boolean theBodyShouldBeEvaluated() { return true; } public void otherDoEndTagOperations() { } public boolean shouldEvaluateRestOfPageAfterEndTag() { return true; } public int doStartTag() throws JspException, JspException { otherDoStartTagOperations(); if (theBodyShouldBeEvaluated()) { return EVAL_BODY_BUFFERED; } else { return SKIP_BODY; } } public int doEndTag() throws JspException, JspException { otherDoEndTagOperations(); if (shouldEvaluateRestOfPageAfterEndTag()) { return EVAL_PAGE; } else { return SKIP_PAGE; } } public String getParametro() { return parametro; } public void setParametro(String value) { parametro = value; } public void writeTagBodyContent(JspWriter out, BodyContent bodyContent) throws IOException { bodyContent.writeOut(out); bodyContent.clearBody(); } public void handleBodyContentException(Exception ex) throws JspException { // Since the doAfterBody method is guarded, place exception handing code here. throw new JspException("error in RctagsimpleTag: " + ex); } public int doAfterBody() throws JspException { try { JspWriter out = getPreviousOut(); BodyContent bodyContent = getBodyContent(); writeTagBodyContent(out, bodyContent); } catch (Exception ex) { handleBodyContentException(ex); } if (theBodyShouldBeEvaluatedAgain()) { return EVAL_BODY_AGAIN; } else { return SKIP_BODY; } } public boolean theBodyShouldBeEvaluatedAgain() { return false; } } |
|
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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
// begin [file="/jspcontagsimple.jsp";from=(11,0);to=(11,46)] /* ---- rc:rctagsimple ---- */ roberto.<b><font color="#0000FF">RctagsimpleTag</font></b> _jspx_th_rc_rctagsimple_0 = new roberto.<font color="#0000FF"><b>RctagsimpleTag</b></font>(); _jspx_th_rc_rctagsimple_0.setPageContext(pageContext); _jspx_th_rc_rctagsimple_0.setParent(null); _jspx_th_rc_rctagsimple_0.<font color="#0000FF"><b>setParametro</b></font>("parametropasado"); try { int _jspx_eval_rc_rctagsimple_0 = _jspx_th_rc_rctagsimple_0.<font color="#0000FF"><b>doStartTag</b></font>(); if (_jspx_eval_rc_rctagsimple_0 != javax.servlet.jsp.tagext.Tag.SKIP_BODY) { try { if (_jspx_eval_rc_rctagsimple_0 != javax.servlet.jsp.tagext.Tag.EVAL_BODY_INCLUDE) { out = pageContext.pushBody(); _jspx_th_rc_rctagsimple_0.setBodyContent((javax.servlet.jsp.tagext.BodyContent) out); _jspx_th_rc_rctagsimple_0.doInitBody(); } do { // end // begin [file="/jspcontagsimple.jsp";from=(11,0);to=(11,46)] } while (_jspx_th_rc_rctagsimple_0.doAfterBody() == javax.servlet.jsp.tagext.BodyTag.EVAL_BODY_AGAIN); } finally { if (_jspx_eval_rc_rctagsimple_0 != javax.servlet.jsp.tagext.Tag.EVAL_BODY_INCLUDE) out = pageContext.popBody(); } } if (_jspx_th_rc_rctagsimple_0.doEndTag() == javax.servlet.jsp.tagext.Tag.SKIP_PAGE) return; } finally { _jspx_th_rc_rctagsimple_0.release(); } // end // HTML // begin [file="/jspcontagsimple.jsp";from=(11,46);to=(16,0)] |
|
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
|
|
public void otherDoStartTagOperations() { try { JspWriter out = pageContext.getOut(); String sParametro = pageContext.getRequest().getParameter(parametro); <b><font color="#FF0000">String sParametroMayusculas = sParametro.toUpperCase(); pageContext.</font><font color="#008000">setAttribute</font><font color="#FF0000">("</font><font color="#0000FF">valorsimple</font><font color="#FF0000">",sParametroMayusculas); </font></b> out.println("El parámetro en la tag es: " + sParametro); } catch (java.io.IOException ex) { // do something } } |
|
Si vemos el código que se genera a partir del servlet .. entenderemos el
porqué
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// begin [file="/jspcontagybean.jsp";from=(10,0);to=(10,70)] java.lang.String <font color="#0000FF"><b>valorsimple</b></font> = null; boolean _jspx_specialvalorsimple = false; synchronized (pageContext) { valorsimple= (java.lang.String)<font color="#0000FF"><b>pageContext.getAttribute("valorsimple",PageContext.PAGE_SCOPE);</b></font> <font color="#0000FF"> if ( valorsimple == null )</font> { _jspx_specialvalorsimple = true; try { <font color="#0000FF"> valorsimple = (java.lang.String) java.beans.Beans.instantiate(this.getClass().getClassLoader(), "java.lang.String");</font> } catch (ClassNotFoundException exc) { throw new InstantiationException(exc.getMessage()); } catch (Exception exc) { throw new ServletException (" Cannot create bean of class "+"java.lang.String", exc); } pageContext.setAttribute("valorsimple", valorsimple, PageContext.PAGE_SCOPE); } } |
|
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 ..
Excelente tutorial, estab buscando algo similar en Internet