|
| Servlets (Siguiente) |
|
Composición
Un JSP ("Java Server Page") es uno de los componentes más básicos empleados para aplicaciones de Servidor en Java. Su composición consta de dos grandes partes: HTML y lenguaje Java.
Mediante HTML se especifica el contenido estático de despliegue y es mediante fragmentos del lenguaje Java que se genera contenido dinámico en efecto cumpliendo la definición de aplicación de Servidor; a continuación se ilustra una porción de un JSP:
<HTML>
<BODY>
<%
out.println("Pagina Básica");
%>
</BODY>
</HTML>
|
Los elementos que se encuentran entre <% y %> son elementos Java , mientras el resto es considerado HTML puro. El comando/método Java utilizado en la porción anterior (out.println) imprime el texto correspondiente; al ejecutarse este JSP da como resultado final :
<HTML> <BODY> Pagina Básica </BODY> </HTML> |
La ejecución y/o transformación de elementos Java es trabajo de un "Servlet Engine" y para este curso es utilizado el "Servlet Engine" Tomcat; el JSP anterior es extremadamente sencillo ya que el código Java solo imprime un mensaje estático , las ventajas de utilizar Java se hacen más evidentes al emplear Java accesando Bases de Datos y/o ejecutando cierta lógica de negocios, lo cual será descrito a fondo en este curso.
|
En la instalación de su "Servlet Engine" Tomcat, coloquese dentro del directorio Para generar sus JSP's y Servlets puede hacer uso de un editor de Texto disponible en su ambiente.
Para observarlos basta colocarse bajo el URL : |
Secuencia de Ejecución ("Lifecycle")
La secuencia de ejecución para un JSP es la siguiente (partiendo de la requisición de página):
- Compilar JSP a Servlet.
- Cargar/Compilar el JSP(Servlet).
- Inicializar el JSP(Servlet).
- Ejecutar el JSP(Servlet).
- Limpiar el JSP(Servlet).
El primer paso puede ser sorprendente, pero efectivamente todo JSP es convertido a un Servlet , la razón de esto es que el surgimiento de JSP's se debió a la necesidad de facilitar un formato programático sencillo para personal no familiarizado con Java, esto es, el uso de JSP's permite eliminar visualmente funciones de arranque, ejecución y terminación , la inclusión de éstas se lleva acabo en la conversión de JSP a Servlet; el JSP declarado anteriormente es convertido en el siguiente Servlet:
package org.apache.jsp;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import org.apache.jasper.runtime.*;
public class index_jsp extends HttpJspBase {
private static java.util.Vector _jspx_includes;
public java.util.List getIncludes() {
return _jspx_includes;
}
public final void _jspx_init()
throws org.apache.jasper.runtime.JspException { }
public void _jspService(HttpServletRequest request,
HttpServletResponse response)
throws java.io.IOException, ServletException {
JspFactory _jspxFactory = null;
javax.servlet.jsp.PageContext pageContext = null;
HttpSession session = null;
ServletContext application = null;
ServletConfig config = null;
JspWriter out = null;
Object page = this;
JspWriter _jspx_out = null;
try {
_jspxFactory = JspFactory.getDefaultFactory();
response.setContentType("text/html;charset=ISO-8859-1");
pageContext = _jspxFactory.getPageContext(this, request,
response, null, true, 8192, true);
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;
out.write("<HTML>\n");
out.write("<BODY>\n ");
out.println("Pagina Basica");
out.write("\n");
out.write("</BODY>\n");
out.write("</HTML>\n");
} catch (Throwable t) {
out = _jspx_out;
if (out != null && out.getBufferSize() != 0)
out.clearBuffer();
if (pageContext != null) pageContext.handlePageException(t);
} finally {
if (_jspxFactory != null) _jspxFactory.releasePageContext(pageContext);
}
}
public final void _jspx_destroy()
throws org.apache.jasper.runtime.JspException { }
}
|
Desde luego generar el Servlet anterior requiere conocimientos programáticos, a través de un JSP personal poco familiarizado con el lenguaje Java ( Diseñadores Gráficos, Programadores experimentados en otro lenguaje) pueden generar el mismo resultado escribiendo dos o tres lineas.Una vez convertido el JSP a Servlet, este Servlet(JSP) debe ser compilado para continuar con el proceso, esta compilación también es tarea del "Servlet Engine".
Compilado el Servlet (JSP) se inicializa, ejecuta y limpia, estos tres pasos son llevados acabo por las funciones: _jspx_init(), _jspService(), _jspx_Destroy() respectivamente; si analiza el código del Servlet (JSP) presentado anteriormente se pueden observar estas funciones. Estas mismas funciones son parte central de cualquier Servlet, sin embargo, estas se explorarán a fondo en la sección de Servlets.
|
El "Servlet Engine" Tomcat coloca los JSP's convertidos a Servlets así como las clases compiladas bajo un directorio llamado NOTA: La ubicación de estos archivos puede variar de acuerdo al "Servlet Engine"/"Application Server" |
Variaciones de <% y %> , "Directives", Acciones y Objetos.
En un JSP además de los Tags <% y %> existen otras variaciones que son las siguientes.
- <%= Expresión Java %>
- <%! Declaración Java %>
- <%-- Comentario Java --%>
<HTML>
<BODY>
<%!
public String lafuncion(String elenvio)
{
return "El parámetro enviado fue: " + elenvio;
}
int valor = 8;
%>
<%-- Funciones en JSP's --%>
Dentro de HTML <%= lafuncion("UNICO") %>
También se encontró el numero <%= valor %>
</BODY>
</HTML>
|
El JSP de la parte superior hace uso de <%= %> que es utilizado para evaluar métodos o variables; <%! %> empleado para declarar funciones y/o clases, mientras <%-- --%> indica un comentario dentro del código Java, al ejecutarse este JSP da como resultado final :
<HTML> <BODY> Dentro de HTML El parámetro enviado fue: UNICO También se encontró el numero 8 </BODY> </HTML> |
Además de la Sintaxis descrita anteriormente que generalmente ocupa la mayor parte de un JSP, también existen otros elementos empleados en JSP's que son descritos a continuación.
"Directives"
Los "Directives" en un JSP son aquellos colocados al inicio de la página y representan actividades de inicialización, entre ellos se encuentran:
| Sintaxis | Funcionamiento | Opciones más comunes |
|---|---|---|
| <%@ page opciones %> | Utilizado para importar clases Java que serán utilizadas por el JSP, parámetros de error, coordinación de "Threads" y otros elementos. |
|
| <%@ include opciones %> | Empleado para colocar archivos estáticos dentro de JSP's, estos generalmente son encabezados o pies de pagina escritos en HTML |
|
| <%@ taglib opciones %> | Utilizado para incluir librerías de Tags hechos a medida en JSP's |
|
Acciones
Otros elementos empleados en JSP's son denominados Acciones, aunque por ahora entrar en su sintaxis especifica sería prematuro, vale mencionar que son ampliamente utilizados en conjunción de Java Beans, los cuales serán descritos en una futura sección del curso.
Un "Java Bean" no es lo mismo que un "Enterprise Java Bean"A lo largo de este curso será descrito el uso de "Java Beans", este tipo de diseño permite encapsular diversos valores en una Clase Java y que su contenido sea manipulable fácilmente en JSP's/Servlets. Lo anterior es muy diferente al uso de "Enterprise Java Beans" los cuales son complementarios a JSP'/Servlets; el uso de "Enterprise Java Beans" se da en ambientes que requieren controles transaccionales y de seguridad más avanzados que lo que ofrecen JSP's/Servlets. |
| Sintaxis | Funcionamiento | Atributos más comunes |
|---|---|---|
| <jsp:useBean atributos > | Utilizado para importar Java Beans a un JSP. |
|
| <jsp:setProperty atributos> | Empleado para colocar valores a un Java Bean en un JSP. |
|
| <jsp:getProperty atributos> | Empleado para extraer valores de un Java Bean a un JSP. |
|
| <jsp:include atributos> | Empleado para colocar archivos estáticos dentro de JSP's, estos generalmente son encabezados o pies de pagina escritos en HTML. |
|
| <jsp:forward atributos> | Empleado para redireccionar el control de un JSP a determinada página. |
|
Objetos
Debido a que un JSP ofrece una abstracción por arriba de un Servlet, y éste último es un Objeto (Clase) Java, también se tienen acceso a diversos Objetos dentro de un JSP sin la necesidad de realizar declaraciones complejas, al igual que el uso de Acciones, su descripción puede ser prematura, sin embargo, el uso de estos objetos será descrito a detalle conforme se avance en el curso.
| Objeto | Uso | Clase Base |
|---|---|---|
request | Representa el Objeto de Solicitud dentro de un JSP/Servlet. | HttpServletRequest |
response | Representa el Objeto de Respuesta dentro de un JSP/Servlet. | HttpServletResponse |
pageContext | Representa el Contexto del JSP/Servlet. | PageContext |
session | Representa la sesión del Usuario en un JSP/Servlet. | HttpSession |
application | Representa el Objeto de aplicación (Contexto) para un JSP/Servlet. | ServletContext |
out | Representa el Objeto de Escritura (Para enviar a pantalla) en un JSP/Servlet. | JspWriter |
config | Representa el Objeto de Configuración para un JSP/Servlet. | ServletConfig |
page | Representa el Objeto del JSP/Servlet en sí. | Object |
exception | Representa el Objeto de errores para un JSP/Servlet. | Throwable |