¿Qué es JavaServer Pages?

JavaServer Pages (JSP) es una tecnología para desarrollar páginas web que admite contenido dinámico. Esto ayuda a los desarrolladores a insertar código Java en páginas HTML mediante el uso de etiquetas JSP especiales, la mayoría de las cuales comienzan con <% y terminan con%>.

Un componente JavaServer Pages es un tipo de servlet Java que está diseñado para cumplir el rol de una interfaz de usuario para una aplicación web Java. Los desarrolladores web escriben JSP como archivos de texto que combinan código HTML o XHTML, elementos XML y acciones y comandos JSP incrustados.

Con JSP, puede recopilar información de los usuarios a través de formularios de páginas web, presentar registros de una base de datos u otra fuente y crear páginas web de forma dinámica.

Las etiquetas JSP se pueden usar para una variedad de propósitos, como recuperar información de una base de datos o registrar las preferencias del usuario, acceder a componentes de JavaBeans, pasar el control entre páginas y compartir información entre solicitudes, páginas, etc.

¿Por qué utilizar JSP?

Las páginas de JavaServer a menudo tienen el mismo propósito que los programas implementados Common Gateway Interface (CGI). Pero JSP ofrece varias ventajas en comparación con CGI.

• El rendimiento es significativamente mejor porque JSP permite incrustar elementos dinámicos en las páginas HTML en lugar de tener archivos CGI separados.

• Los JSP siempre se compilan antes de que el servidor los procese, a diferencia de CGI / Perl, que requiere que el servidor cargue un intérprete y el script de destino cada vez que se solicita la página.

• Las páginas de JavaServer están construidas sobre la API de Java Servlets, por lo que, al igual que los Servlets, JSP también tiene acceso a todas las potentes API de Enterprise Java, incluidas JDBC, JNDI, EJB, JAXP, etc.

• Las páginas JSP se pueden utilizar en combinación con servlets que manejan la lógica empresarial, el modelo soportado por los motores de plantilla de servlet de Java.

Finalmente, JSP es una parte integral de Java EE, una plataforma completa para aplicaciones de clase empresarial. Esto significa que JSP puede participar desde las aplicaciones más simples hasta las más complejas y exigentes.

Ventajas de JSP

La siguiente tabla enumera las otras ventajas de usar JSP sobre otras tecnologías:

frente a páginas Active Server (ASP)

Las ventajas de JSP son dobles. Primero, la parte dinámica está escrita en Java, no en Visual Basic u otro lenguaje específico de MS, por lo que es más potente y fácil de usar. En segundo lugar, es portátil a otros sistemas operativos y servidores web que no son de Microsoft.

vs Servlets puros

Es más conveniente escribir (¡y modificar!) HTML regular que tener muchas declaraciones println que generen el HTML.

vs.Incluye del lado del servidor (SSI)

En realidad, SSI solo está diseñado para inclusiones simples, no para programas "reales" que usan datos de formularios, hacen conexiones a bases de datos y similares.

vs JavaScript

JavaScript puede generar HTML de forma dinámica en el cliente, pero difícilmente puede interactuar con el servidor web para realizar tareas complejas como el acceso a la base de datos y el procesamiento de imágenes, etc.

vs HTML estático

El HTML normal, por supuesto, no puede contener información dinámica.

¿Lo que sigue?

Lo guiaría paso a paso para configurar su entorno para comenzar con JSP. Supongo que tiene buenas prácticas con la programación de Java para continuar con el aprendizaje de JSP.

Si no conoce el lenguaje de programación Java, le recomendamos que consulte nuestro Tutorial de Java para comprender la programación de Java.

Un entorno de desarrollo es donde desarrollaría sus programas JSP, los probaría y finalmente los ejecutaría.

Este tutorial lo guiará para configurar su entorno de desarrollo JSP que incluye los siguientes pasos:

Configuración del kit de desarrollo de Java

Este paso implica descargar una implementación del kit de desarrollo de software (SDK) de Java y configurar la variable de entorno PATH de manera adecuada.

Puede descargar SDK desde el sitio Java de Oracle - Descargas de Java SE .

Una vez que descargue su implementación de Java, siga las instrucciones dadas para instalar y configurar la instalación. Finalmente configure elPATH and JAVA_HOME variables de entorno para hacer referencia al directorio que contiene java y javac, típicamente java_install_dir/bin y java_install_dir respectivamente.

Si está ejecutando Windows e instala el SDK en C:\jdk1.5.0_20, debe agregar la siguiente línea en su C:\autoexec.bat archivo.

set PATH = C:\jdk1.5.0_20\bin;%PATH%
set JAVA_HOME = C:\jdk1.5.0_20

Alternativamente, en Windows NT/2000/XP, también puede hacer clic derecho en My Computer, Seleccione Properties, luego Advanced, seguido por Environment Variables. Luego, actualizaría el valor PATH y presionaría el botón OK.

En Unix (Solaris, Linux, etc.), si el SDK está instalado en /usr/local/jdk1.5.0_20 y usa el shell C, pondrá lo siguiente en su .cshrc archivo.

setenv PATH /usr/local/jdk1.5.0_20/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.5.0_20

Alternativamente, si usa un Integrated Development Environment (IDE) me gusta Borland JBuilder, Eclipse, IntelliJ IDEAo Sun ONE Studio, compile y ejecute un programa simple para confirmar que el IDE sabe dónde instaló Java.

Configuración del servidor web: Tomcat

Hay disponibles en el mercado varios servidores web que admiten el desarrollo de JavaServer Pages y Servlets. Algunos servidores web se pueden descargar de forma gratuita y Tomcat es uno de ellos.

Apache Tomcat es una implementación de software de código abierto de las tecnologías JavaServer Pages y Servlet y puede actuar como un servidor independiente para probar JSP y Servlets, y puede integrarse con el servidor web Apache. Estos son los pasos para configurar Tomcat en su máquina:

• Descargue la última versión de Tomcat de https://tomcat.apache.org/.

• Una vez que descargó la instalación, descomprima la distribución binaria en una ubicación conveniente. Por ejemplo, enC:\apache-tomcat-5.5.29 on windows, or /usr/local/apache-tomcat-5.5.29 en Linux / Unix y cree CATALINA_HOME variable de entorno que apunta a estas ubicaciones.

Tomcat se puede iniciar ejecutando los siguientes comandos en la máquina con Windows:

%CATALINA_HOME%\bin\startup.bat
 
or
 
C:\apache-tomcat-5.5.29\bin\startup.bat

Tomcat se puede iniciar ejecutando los siguientes comandos en la máquina Unix (Solaris, Linux, etc.):

$CATALINA_HOME/bin/startup.sh
 
or
 
/usr/local/apache-tomcat-5.5.29/bin/startup.sh

Después de un inicio exitoso, las aplicaciones web predeterminadas incluidas con Tomcat estarán disponibles visitando http://localhost:8080/.

Tras la ejecución, recibirá el siguiente resultado:

Puede encontrar más información sobre la configuración y ejecución de Tomcat en la documentación incluida aquí, así como en el sitio web de Tomcat: https://tomcat.apache.org/.

Tomcat se puede detener ejecutando los siguientes comandos en la máquina con Windows:

%CATALINA_HOME%\bin\shutdown
or

C:\apache-tomcat-5.5.29\bin\shutdown

Tomcat se puede detener ejecutando los siguientes comandos en una máquina Unix (Solaris, Linux, etc.):

$CATALINA_HOME/bin/shutdown.sh

or

/usr/local/apache-tomcat-5.5.29/bin/shutdown.sh

Configuración de CLASSPATH

Dado que los servlets no son parte de la plataforma Java, Standard Edition, debe identificar las clases de servlets en el compilador.

Si está ejecutando Windows, debe poner las siguientes líneas en su C:\autoexec.bat archivo.

set CATALINA = C:\apache-tomcat-5.5.29
set CLASSPATH = %CATALINA%\common\lib\jsp-api.jar;%CLASSPATH%

Alternativamente, en Windows NT/2000/XP, también puede hacer clic derecho en My Computer, Seleccione Properties, luego Advanced, luego Environment Variables. Luego, actualizaría el valor de CLASSPATH y presionaría el botón OK.

En Unix (Solaris, Linux, etc.), si está utilizando el shell C, debe poner las siguientes líneas en su .cshrc archivo.

setenv CATALINA = /usr/local/apache-tomcat-5.5.29
setenv CLASSPATH $CATALINA/common/lib/jsp-api.jar:$CLASSPATH

NOTE - Suponiendo que su directorio de desarrollo es C:\JSPDev (Windows) o /usr/JSPDev (Unix), entonces necesitaría agregar estos directorios también en CLASSPATH.

El servidor web necesita un motor JSP, es decir, un contenedor para procesar páginas JSP. El contenedor JSP es responsable de interceptar solicitudes de páginas JSP. Este tutorial hace uso de Apache, que tiene un contenedor JSP incorporado para admitir el desarrollo de páginas JSP.

Un contenedor JSP trabaja con el servidor web para proporcionar el entorno de ejecución y otros servicios que necesita una JSP. Sabe cómo comprender los elementos especiales que forman parte de las JSP.

El siguiente diagrama muestra la posición del contenedor JSP y los archivos JSP en una aplicación web.

Procesamiento JSP

Los siguientes pasos explican cómo el servidor web crea la página web usando JSP:

• Al igual que con una página normal, su navegador envía una solicitud HTTP al servidor web.

• El servidor web reconoce que la solicitud HTTP es para una página JSP y la reenvía a un motor JSP. Esto se hace usando la URL o la página JSP que termina con.jsp en vez de .html.

• El motor JSP carga la página JSP desde el disco y la convierte en un contenido de servlet. Esta conversión es muy simple en la que todo el texto de la plantilla se convierte en declaraciones println () y todos los elementos JSP se convierten a código Java. Este código implementa el correspondiente comportamiento dinámico de la página.

• El motor JSP compila el servlet en una clase ejecutable y reenvía la solicitud original a un motor de servlet.

• Una parte del servidor web llamada motor de servlet carga la clase Servlet y la ejecuta. Durante la ejecución, el servlet produce una salida en formato HTML. La salida se transmite posteriormente al servidor web por el motor de servlets dentro de una respuesta HTTP.

• El servidor web envía la respuesta HTTP a su navegador en términos de contenido HTML estático.

• Finalmente, el navegador web maneja la página HTML generada dinámicamente dentro de la respuesta HTTP exactamente como si fuera una página estática.

Todos los pasos mencionados anteriormente se pueden ver en el siguiente diagrama:

Normalmente, el motor JSP comprueba si ya existe un servlet para un archivo JSP y si la fecha de modificación en la JSP es anterior a la del servlet. Si la JSP es más antigua que su servlet generado, el contenedor JSP asume que la JSP no ha cambiado y que el servlet generado aún coincide con el contenido de la JSP. Esto hace que el proceso sea más eficiente que con los otros lenguajes de programación (como PHP) y, por lo tanto, más rápido.

Entonces, de alguna manera, una página JSP es realmente solo otra forma de escribir un servlet sin tener que ser un experto en programación Java. Excepto por la fase de traducción, una página JSP se maneja exactamente como un servlet normal.

En este capítulo, discutiremos el ciclo de vida de JSP. La clave para comprender la funcionalidad de bajo nivel de JSP es comprender el ciclo de vida simple que siguen.

Un ciclo de vida de JSP se define como el proceso desde su creación hasta su destrucción. Esto es similar al ciclo de vida de un servlet con un paso adicional que se requiere para compilar un JSP en un servlet.

Rutas seguidas por JSP

Las siguientes son las rutas seguidas por una JSP:

• Compilation
• Initialization
• Execution
• Cleanup

Las cuatro fases principales del ciclo de vida de una JSP son muy similares al ciclo de vida de un servlet. Las cuatro fases se describen a continuación:

Compilación JSP

Cuando un navegador solicita una JSP, el motor JSP primero verifica si necesita compilar la página. Si la página nunca se ha compilado o si la JSP se ha modificado desde la última vez que se compiló, el motor JSP compila la página.

El proceso de compilación consta de tres pasos:

• Analizando el JSP.
• Convirtiendo el JSP en un servlet.
• Compilando el servlet.

Inicialización JSP

Cuando un contenedor carga una JSP, invoca la jspInit()antes de atender cualquier solicitud. Si necesita realizar una inicialización específica de JSP, anule lajspInit() método -

public void jspInit(){
   // Initialization code...
}

Por lo general, la inicialización se realiza solo una vez y, al igual que con el método de inicio del servlet, generalmente inicializa las conexiones de la base de datos, abre archivos y crea tablas de búsqueda en el método jspInit.

Ejecución JSP

Esta fase del ciclo de vida de JSP representa todas las interacciones con solicitudes hasta que se destruye la JSP.

Siempre que un navegador solicita una JSP y la página se ha cargado e inicializado, el motor JSP invoca la _jspService() método en la JSP.

El método _jspService () toma una HttpServletRequest y un HttpServletResponse como sus parámetros de la siguiente manera:

void _jspService(HttpServletRequest request, HttpServletResponse response) {
   // Service handling code...
}

los _jspService()El método de una JSP se invoca a petición. Este es responsable de generar la respuesta para esa solicitud y este método también es responsable de generar respuestas a los siete métodos HTTP, es decir,GET, POST, DELETEetc.

Limpieza JSP

La fase de destrucción del ciclo de vida de JSP representa cuando un contenedor deja de utilizar una JSP.

los jspDestroy()método es el equivalente JSP del método de destrucción para servlets. Anule jspDestroy cuando necesite realizar una limpieza, como liberar conexiones de base de datos o cerrar archivos abiertos.

El método jspDestroy () tiene la siguiente forma:

public void jspDestroy() {
   // Your cleanup code goes here.
}

En este capítulo, discutiremos la sintaxis en JSP. Comprenderemos el uso básico de sintaxis simple (es decir, elementos) involucrados con el desarrollo de JSP.

Elementos de JSP

Los elementos de JSP se describen a continuación:

El Scriptlet

Un scriptlet puede contener cualquier número de declaraciones en lenguaje JAVA, declaraciones de variables o métodos, o expresiones que sean válidas en el lenguaje de secuencias de comandos de página.

A continuación se muestra la sintaxis de Scriptlet:

<% code fragment %>

Puede escribir el equivalente XML de la sintaxis anterior de la siguiente manera:

<jsp:scriptlet>
   code fragment
</jsp:scriptlet>

Cualquier texto, etiquetas HTML o elementos JSP que escriba deben estar fuera del scriptlet. A continuación se muestra el primer y sencillo ejemplo de JSP:

<html>
   <head><title>Hello World</title></head>
   
   <body>
      Hello World!<br/>
      <%
         out.println("Your IP address is " + request.getRemoteAddr());
      %>
   </body>
</html>

NOTE - Suponiendo que Apache Tomcat está instalado en C: \ apache-tomcat-7.0.2 y su entorno está configurado según el tutorial de configuración del entorno.

Mantengamos el código anterior en un archivo JSP hello.jsp y poner este archivo en C:\apache-tomcat7.0.2\webapps\ROOTdirectorio. Navega por el mismo usando URLhttp://localhost:8080/hello.jsp. El código anterior generará el siguiente resultado:

Declaraciones JSP

Una declaración declara una o más variables o métodos que puede utilizar en el código Java más adelante en el archivo JSP. Debe declarar la variable o el método antes de usarlo en el archivo JSP.

A continuación se muestra la sintaxis de las declaraciones JSP:

<%! declaration; [ declaration; ]+ ... %>

Puede escribir el equivalente XML de la sintaxis anterior de la siguiente manera:

<jsp:declaration>
   code fragment
</jsp:declaration>

A continuación se muestra un ejemplo de declaraciones JSP:

<%! int i = 0; %> 
<%! int a, b, c; %> 
<%! Circle a = new Circle(2.0); %>

Expresión JSP

Un elemento de expresión JSP contiene una expresión de lenguaje de secuencias de comandos que se evalúa, se convierte en una cadena y se inserta donde aparece la expresión en el archivo JSP.

Como el valor de una expresión se convierte en una cadena, puede utilizar una expresión dentro de una línea de texto, esté o no etiquetada con HTML, en un archivo JSP.

El elemento de expresión puede contener cualquier expresión que sea válida de acuerdo con la Especificación del lenguaje Java, pero no puede usar un punto y coma para finalizar una expresión.

A continuación se muestra la sintaxis de la expresión JSP:

<%= expression %>

Puede escribir el equivalente XML de la sintaxis anterior de la siguiente manera:

<jsp:expression>
   expression
</jsp:expression>

El siguiente ejemplo muestra una expresión JSP:

<html> 
   <head><title>A Comment Test</title></head> 
   
   <body>
      <p>Today's date: <%= (new java.util.Date()).toLocaleString()%></p>
   </body> 
</html>

El código anterior generará el siguiente resultado:

Today's date: 11-Sep-2010 21:24:25

Comentarios JSP

El comentario JSP marca texto o declaraciones que el contenedor JSP debe ignorar. Un comentario JSP es útil cuando desea ocultar o "comentar" una parte de su página JSP.

A continuación se muestra la sintaxis de los comentarios JSP:

<%-- This is JSP comment --%>

El siguiente ejemplo muestra los comentarios JSP:

<html> 
   <head><title>A Comment Test</title></head> 
   
   <body> 
      <h2>A Test of Comments</h2> 
      <%-- This comment will not be visible in the page source --%> 
   </body> 
</html>

El código anterior generará el siguiente resultado:

A Test of Comments

Hay una pequeña cantidad de construcciones especiales que puede usar en varios casos para insertar comentarios o caracteres que de otra manera serían tratados de manera especial. Aquí hay un resumen:

S.No.	Sintaxis y propósito
1	<%-- comment --%> Un comentario JSP. Ignorado por el motor JSP.
2	<!-- comment --> Un comentario HTML. Ignorado por el navegador.
3	<\% Representa estático <% literal.
4	%\> Representa%> literal estático.
5	\' Una comilla simple en un atributo que usa comillas simples.
6	\" Una comilla doble en un atributo que utiliza comillas dobles.

Directivas JSP

Una directiva JSP afecta la estructura general de la clase de servlet. Suele tener la siguiente forma:

<%@ directive attribute="value" %>

Hay tres tipos de etiquetas de directiva:

S.No.	Directiva y descripción
1	<%@ page ... %> Define atributos que dependen de la página, como el lenguaje de secuencias de comandos, la página de error y los requisitos de almacenamiento en búfer.
2	<%@ include ... %> Incluye un archivo durante la fase de traducción.
3	<%@ taglib ... %> Declara una biblioteca de etiquetas, que contiene acciones personalizadas, utilizadas en la página.

Explicaríamos la directiva JSP en un capítulo separado JSP - Directivas

Acciones JSP

Uso de acciones JSP constructsen sintaxis XML para controlar el comportamiento del motor de servlets. Puede insertar dinámicamente un archivo, reutilizar componentes JavaBeans, reenviar al usuario a otra página o generar HTML para el complemento Java.

Solo hay una sintaxis para el elemento Action, ya que cumple con el estándar XML:

<jsp:action_name attribute="value" />

Los elementos de acción son básicamente funciones predefinidas. La siguiente tabla enumera las acciones JSP disponibles:

S.No.	Sintaxis y propósito
1	jsp:include Incluye un archivo en el momento en que se solicita la página.
2	jsp:useBean Busca o crea una instancia de un JavaBean.
3	jsp:setProperty Establece la propiedad de un JavaBean.
4	jsp:getProperty Inserta la propiedad de un JavaBean en la salida.
5	jsp:forward Reenvía al solicitante a una nueva página.
6	jsp:plugin Genera código específico del navegador que crea una etiqueta OBJECT o EMBED para el complemento de Java.
7	jsp:element Define elementos XML de forma dinámica.
8	jsp:attribute Define el atributo del elemento XML definido dinámicamente.
9	jsp:body Define el cuerpo del elemento XML definido dinámicamente.
10	jsp:text Se utiliza para escribir texto de plantilla en páginas y documentos JSP.

Explicaríamos las acciones de JSP en un capítulo separado JSP - Acciones

Objetos implícitos JSP

JSP admite nueve variables definidas automáticamente, que también se denominan objetos implícitos. Estas variables son:

S.No.	Descripción del objeto
1	request Este es el HttpServletRequest objeto asociado con la solicitud.
2	response Este es el HttpServletResponse objeto asociado a la respuesta al cliente.
3	out Este es el PrintWriter objeto utilizado para enviar salida al cliente.
4	session Este es el HttpSession objeto asociado con la solicitud.
5	application Este es el ServletContext objeto asociado con el contexto de la aplicación.
6	config Este es el ServletConfig objeto asociado a la página.
7	pageContext Esto encapsula el uso de funciones específicas del servidor como un mayor rendimiento JspWriters.
8	page Esto es simplemente un sinónimo de this, y se utiliza para llamar a los métodos definidos por la clase de servlet traducida.
9	Exception los Exception El objeto permite acceder a los datos de excepción mediante JSP designado.

Explicaríamos JSP Implicit Objects en un capítulo separado JSP - Implicit Objects .

Declaraciones de flujo de control

Puede usar todas las API y los bloques de construcción de Java en su programación JSP, incluidas las declaraciones de toma de decisiones, los bucles, etc.

Declaraciones para la toma de decisiones

los if...else El bloque comienza como un Scriptlet normal, pero el Scriptlet se cierra en cada línea con texto HTML incluido entre las etiquetas de Scriptlet.

<%! int day = 3; %> 
<html> 
   <head><title>IF...ELSE Example</title></head> 
   
   <body>
      <% if (day == 1 || day == 7) { %>
         <p> Today is weekend</p>
      <% } else { %>
         <p> Today is not weekend</p>
      <% } %>
   </body> 
</html>

El código anterior generará el siguiente resultado:

Today is not weekend

Ahora mira lo siguiente switch...case bloque que se ha escrito un poco diferente usando out.println() y dentro de Scriptletas -

<%! int day = 3; %> 
<html> 
   <head><title>SWITCH...CASE Example</title></head> 
   
   <body>
      <% 
         switch(day) {
            case 0:
               out.println("It\'s Sunday.");
               break;
            case 1:
               out.println("It\'s Monday.");
               break;
            case 2:
               out.println("It\'s Tuesday.");
               break;
            case 3:
               out.println("It\'s Wednesday.");
               break;
            case 4:
               out.println("It\'s Thursday.");
               break;
            case 5:
               out.println("It\'s Friday.");
               break;
            default:
               out.println("It's Saturday.");
         }
      %>
   </body> 
</html>

El código anterior generará el siguiente resultado:

It's Wednesday.

Declaraciones de bucle

También puede utilizar tres tipos básicos de bloques de bucle en Java: for, while, and do…while bloques en su programación JSP.

Veamos lo siguiente for ejemplo de bucle -

<%! int fontSize; %> 
<html> 
   <head><title>FOR LOOP Example</title></head> 
   
   <body>
      <%for ( fontSize = 1; fontSize <= 3; fontSize++){ %>
         <font color = "green" size = "<%= fontSize %>">
            JSP Tutorial
      </font><br />
      <%}%>
   </body> 
</html>

El código anterior generará el siguiente resultado:

JSP Tutorial 


 JSP Tutorial 


 JSP Tutorial 

El ejemplo anterior se puede escribir usando el while bucle de la siguiente manera:

<%! int fontSize; %> 
<html> 
   <head><title>WHILE LOOP Example</title></head> 
   
   <body>
      <%while ( fontSize <= 3){ %>
         <font color = "green" size = "<%= fontSize %>">
            JSP Tutorial
         </font><br />
         <%fontSize++;%>
      <%}%>
   </body> 
</html>

El código anterior generará el siguiente resultado:

JSP Tutorial 

 JSP Tutorial 

 JSP Tutorial

Operadores JSP

JSP admite todos los operadores lógicos y aritméticos compatibles con Java. La siguiente tabla enumera todos los operadores con la mayor precedencia que aparecen en la parte superior de la tabla, los que tienen la menor prioridad aparecen en la parte inferior.

Dentro de una expresión, los operadores de mayor precedencia se evaluarán primero.

Categoría	Operador	Asociatividad
Sufijo	() []. (operador de punto)	De izquierda a derecha
Unario	++ - -! ~	De derecha a izquierda
Multiplicativo	* /%	De izquierda a derecha
Aditivo	+ -	De izquierda a derecha
Cambio	>> >>> <<	De izquierda a derecha
Relacional	>> = <<=	De izquierda a derecha
Igualdad	==! =	De izquierda a derecha
Y bit a bit	Y	De izquierda a derecha
XOR bit a bit	^	De izquierda a derecha
O bit a bit	|	De izquierda a derecha
Y lógico	&&	De izquierda a derecha
OR lógico	||	De izquierda a derecha
Condicional	?:	De derecha a izquierda
Asignación	= + = - = * = / =% = >> = << = & = ^ = | =	De derecha a izquierda
Coma	,	De izquierda a derecha

Literales JSP

El lenguaje de expresión JSP define los siguientes literales:

• Boolean - verdadero y falso

• Integer - como en Java

• Floating point - como en Java

• String- con comillas simples y dobles; "se escapa como \", 'se escapa como \' y \ se escapa como \\.

• Null - nulo

En este capítulo, discutiremos las Directivas en JSP. Estas directivas proporcionan direcciones e instrucciones al contenedor, indicándole cómo manejar ciertos aspectos del procesamiento JSP.

Una directiva JSP afecta la estructura general de la clase de servlet. Suele tener la siguiente forma:

<%@ directive attribute = "value" %>

Las directivas pueden tener una serie de atributos que puede enumerar como pares clave-valor y separados por comas.

Los espacios en blanco entre el símbolo @ y el nombre de la directiva, y entre el último atributo y el%> de cierre, son opcionales.

Hay tres tipos de etiquetas de directiva:

S.No.	Directiva y descripción
1	<%@ page ... %> Define atributos que dependen de la página, como el lenguaje de secuencias de comandos, la página de error y los requisitos de almacenamiento en búfer.
2	<%@ include ... %> Incluye un archivo durante la fase de traducción.
3	<%@ taglib ... %> Declara una biblioteca de etiquetas, que contiene acciones personalizadas, utilizadas en la página.

JSP: la directiva de páginas

los pageLa directiva se utiliza para proporcionar instrucciones al contenedor. Estas instrucciones pertenecen a la página JSP actual. Puede codificar directivas de página en cualquier lugar de su página JSP. Por convención, las directivas de página se codifican en la parte superior de la página JSP.

A continuación se muestra la sintaxis básica de la directiva de página:

<%@ page attribute = "value" %>

Puede escribir el equivalente XML de la sintaxis anterior de la siguiente manera:

<jsp:directive.page attribute = "value" />

Atributos

La siguiente tabla enumera los atributos asociados con la directiva de página:

S.No.	Atributo y propósito
1	buffer Especifica un modelo de almacenamiento en búfer para el flujo de salida.
2	autoFlush Controla el comportamiento del búfer de salida del servlet.
3	contentType Define el esquema de codificación de caracteres.
4	errorPage Define la URL de otra JSP que informa sobre las excepciones de tiempo de ejecución no comprobadas de Java.
5	isErrorPage Indica si esta página JSP es una URL especificada por el atributo errorPage de otra página JSP.
6	extends Especifica una superclase que debe ampliar el servlet generado.
7	import Especifica una lista de paquetes o clases para su uso en JSP como lo hace la declaración de importación de Java para las clases de Java.
8	info Define una cadena a la que se puede acceder con el servlet getServletInfo() método.
9	isThreadSafe Define el modelo de subprocesamiento para el servlet generado.
10	language Define el lenguaje de programación utilizado en la página JSP.
11	session Especifica si la página JSP participa o no en sesiones HTTP.
12	isELIgnored Especifica si se ignorará o no la expresión EL dentro de la página JSP.
13	isScriptingEnabled Determina si se permite el uso de los elementos de secuencias de comandos.

Verifique más detalles relacionados con todos los atributos anteriores en Directiva de página .

La Directiva de inclusión

los includeLa directiva se utiliza para incluir un archivo durante la fase de traducción. Esta directiva le dice al contenedor que combine el contenido de otros archivos externos con la JSP actual durante la fase de traducción. Puede codificar elinclude directivas en cualquier lugar de su página JSP.

La forma de uso general de esta directiva es la siguiente:

<%@ include file = "relative url" >

El nombre de archivo en la directiva de inclusión es en realidad una URL relativa. Si solo especifica un nombre de archivo sin una ruta asociada, el compilador JSP asume que el archivo está en el mismo directorio que su JSP.

Puede escribir el equivalente XML de la sintaxis anterior de la siguiente manera:

<jsp:directive.include file = "relative url" />

Para obtener más detalles relacionados con la directiva de inclusión, consulte la directiva de inclusión .

La Directiva taglib

La API de JavaServer Pages le permite definir etiquetas JSP personalizadas que se parecen a etiquetas HTML o XML y una biblioteca de etiquetas es un conjunto de etiquetas definidas por el usuario que implementan un comportamiento personalizado.

los taglib La directiva declara que su página JSP utiliza un conjunto de etiquetas personalizadas, identifica la ubicación de la biblioteca y proporciona los medios para identificar las etiquetas personalizadas en su página JSP.

La directiva taglib sigue la sintaxis que se indica a continuación:

<%@ taglib uri="uri" prefix = "prefixOfTag" >

Aquí el uri El valor del atributo se resuelve en una ubicación que el contenedor comprende y el prefix El atributo informa a un contenedor qué bits de marcado son acciones personalizadas.

Puede escribir el equivalente XML de la sintaxis anterior de la siguiente manera:

<jsp:directive.taglib uri = "uri" prefix = "prefixOfTag" />

Para obtener más detalles relacionados con la directiva taglib, consulte la directiva Taglib .

En este capítulo, discutiremos las acciones en JSP. Estas acciones utilizan construcciones en sintaxis XML para controlar el comportamiento del motor de servlets. Puede insertar dinámicamente un archivo, reutilizar componentes JavaBeans, reenviar al usuario a otra página o generar HTML para el complemento Java.

Solo hay una sintaxis para el elemento Action, ya que cumple con el estándar XML:

<jsp:action_name attribute = "value" />

Los elementos de acción son básicamente funciones predefinidas. La siguiente tabla enumera las acciones JSP disponibles:

S.No.	Sintaxis y propósito
1	jsp:include Incluye un archivo en el momento en que se solicita la página.
2	jsp:useBean Busca o crea una instancia de un JavaBean.
3	jsp:setProperty Establece la propiedad de un JavaBean.
4	jsp:getProperty Inserta la propiedad de un JavaBean en la salida.
5	jsp:forward Reenvía al solicitante a una nueva página.
6	jsp:plugin Genera código específico del navegador que crea una etiqueta OBJECT o EMBED para el complemento de Java.
7	jsp:element Define elementos XML de forma dinámica.
8	jsp:attribute Define el atributo del elemento XML definido dinámicamente.
9	jsp:body Define el cuerpo del elemento XML definido dinámicamente.
10	jsp:text Se utiliza para escribir texto de plantilla en páginas y documentos JSP.

Atributos comunes

Hay dos atributos que son comunes a todos los elementos de Acción: el id atributo y el scope atributo.

Atributo de identificación

El atributo id identifica de forma única el elemento Action y permite que se haga referencia a la acción dentro de la página JSP. Si la acción crea una instancia de un objeto, el valor de id se puede utilizar para hacer referencia a él a través del objeto implícito PageContext.

Atributo de alcance

Este atributo identifica el ciclo de vida del elemento Action. El atributo id y el atributo scope están directamente relacionados, ya que el atributo scope determina la vida útil del objeto asociado con el id. El atributo de alcance tiene cuatro valores posibles:(a) page, (b)request, (c)sessiony (d) application.

La acción <jsp: include>

Esta acción le permite insertar archivos en la página que se está generando. La sintaxis se ve así:

<jsp:include page = "relative URL" flush = "true" />

A diferencia del include directiva, que inserta el archivo en el momento en que la página JSP se traduce en un servlet, esta acción inserta el archivo en el momento en que se solicita la página.

La siguiente tabla enumera los atributos asociados con la acción de inclusión:

S.No.	Atributo y descripción
1	page La URL relativa de la página que se incluirá.
2	flush El atributo booleano determina si el recurso incluido tiene su búfer vaciado antes de que se incluya.

Ejemplo

Definamos los siguientes dos archivos (a)date.jsp y (b) main.jsp como sigue -

A continuación se muestra el contenido de la date.jsp archivo -

<p>Today's date: <%= (new java.util.Date()).toLocaleString()%></p>

A continuación se muestra el contenido de la main.jsp archivo -

<html>
   <head>
      <title>The include Action Example</title>
   </head>
   
   <body>
      <center>
         <h2>The include action Example</h2>
         <jsp:include page = "date.jsp" flush = "true" />
      </center>
   </body>
</html>

Ahora mantengamos todos estos archivos en el directorio raíz e intentemos acceder main.jsp. Recibirá el siguiente resultado:

 
       
The include action Example
 Today's date: 12-Sep-2010 14:54:22 
      

La acción <jsp: useBean>

los useBeanla acción es bastante versátil. Primero busca un objeto existente utilizando las variables id y scope. Si no se encuentra un objeto, intenta crear el objeto especificado.

La forma más sencilla de cargar un bean es la siguiente:

<jsp:useBean id = "name" class = "package.class" />

Una vez que se carga una clase de frijol, puede usar jsp:setProperty y jsp:getProperty acciones para modificar y recuperar las propiedades del bean.

La siguiente tabla enumera los atributos asociados con la acción useBean:

S.No.	Atributo y descripción
1	class Designa el nombre completo del paquete del bean.
2	type Especifica el tipo de variable que hará referencia al objeto.
3	beanName Da el nombre del bean como lo especifica el método instantiate () de la clase java.beans.Beans.

Analicemos ahora el jsp:setProperty y el jsp:getProperty acciones antes de dar un ejemplo válido relacionado con estas acciones.

La acción <jsp: setProperty>

los setPropertyaction establece las propiedades de un Bean. El Bean debe haber sido definido previamente antes de esta acción. Hay dos formas básicas de utilizar la acción setProperty:

Puedes usar jsp:setProperty después, pero fuera de un jsp:useBean elemento, como se indica a continuación:

<jsp:useBean id = "myName" ... />
...
<jsp:setProperty name = "myName" property = "someProperty" .../>

En este caso, el jsp:setProperty se ejecuta independientemente de si se creó una instancia de un nuevo bean o si se encontró un bean existente.

Un segundo contexto en el que puede aparecer jsp: setProperty es dentro del cuerpo de un jsp:useBean elemento, como se indica a continuación:

<jsp:useBean id = "myName" ... >
   ...
   <jsp:setProperty name = "myName" property = "someProperty" .../>
</jsp:useBean>

Aquí, jsp: setProperty se ejecuta solo si se creó una instancia de un nuevo objeto, no si se encontró uno existente.

La siguiente tabla enumera los atributos asociados con el setProperty acción -

S.No.	Atributo y descripción
1	name Designa el bean cuya propiedad se establecerá. El Bean debe haber sido definido previamente.
2	property Indica la propiedad que desea establecer. Un valor de "*" significa que todos los parámetros de solicitud cuyos nombres coincidan con los nombres de las propiedades del bean se pasarán a los métodos de establecimiento apropiados.
3	value El valor que se asignará a la propiedad dada. Si el valor del parámetro es nulo o el parámetro no existe, la acción setProperty se ignora.
4	param El atributo param es el nombre del parámetro de solicitud cuyo valor va a recibir la propiedad. No puede usar tanto value como param, pero está permitido no usar ninguno.

La acción <jsp: getProperty>

los getProperty La acción se usa para recuperar el valor de una propiedad dada, lo convierte en una cadena y finalmente lo inserta en la salida.

La acción getProperty tiene solo dos atributos, ambos obligatorios. La sintaxis de la acción getProperty es la siguiente:

<jsp:useBean id = "myName" ... />
...
<jsp:getProperty name = "myName" property = "someProperty" .../>

La siguiente tabla enumera los atributos requeridos asociados con el getProperty acción -

S.No.	Atributo y descripción
1	name El nombre del Bean que tiene una propiedad para recuperar. El Bean debe haber sido definido previamente.
2	property El atributo de propiedad es el nombre de la propiedad Bean que se va a recuperar.

Ejemplo

Definamos un bean de prueba que se utilizará más adelante en nuestro ejemplo:

/* File: TestBean.java */
package action;
 
public class TestBean {
   private String message = "No message specified";
 
   public String getMessage() {
      return(message);
   }
   public void setMessage(String message) {
      this.message = message;
   }
}

Compile el código anterior en el generado TestBean.class archivo y asegúrese de haber copiado el TestBean.class en C:\apache-tomcat-7.0.2\webapps\WEB-INF\classes\action carpeta y el CLASSPATH La variable también debe establecerse en esta carpeta:

Ahora use el siguiente código en main.jsparchivo. Esto carga el bean y establece / obtiene un parámetro de cadena simple:

<html>
   
   <head>
      <title>Using JavaBeans in JSP</title>
   </head>
   
   <body>
      <center>
         <h2>Using JavaBeans in JSP</h2>
         <jsp:useBean id = "test" class = "action.TestBean" />
         <jsp:setProperty name = "test"  property = "message" 
            value = "Hello JSP..." />
            
         <p>Got message....</p>
         <jsp:getProperty name = "test" property = "message" />
      </center>
   </body>
</html>

Intentemos ahora acceder main.jsp, mostraría el siguiente resultado:

 
       
Using JavaBeans in JSP
 Got message.... Hello JSP... 
      

La acción <jsp: forward>

los forward action finaliza la acción de la página actual y reenvía la solicitud a otro recurso, como una página estática, otra página JSP o un servlet Java.

A continuación se muestra la sintaxis del forward acción -

<jsp:forward page = "Relative URL" />

La siguiente tabla enumera los atributos necesarios asociados con la acción de reenvío:

S.No.	Atributo y descripción
1	page Debe constar de una URL relativa de otro recurso, como una página estática, otra página JSP o un servlet Java.

Ejemplo

Reutilicemos los siguientes dos archivos (a) date.jsp y (b) main.jsp como sigue -

A continuación se muestra el contenido de la date.jsp archivo -

<p>Today's date: <%= (new java.util.Date()).toLocaleString()%></p>

A continuación se muestra el contenido de la main.jsp archivo -

<html>
   <head>
      <title>The include Action Example</title>
   </head>
   
   <body>
      <center>
         <h2>The include action Example</h2>
         <jsp:forward page = "date.jsp" />
      </center>
   </body>
</html>

Ahora mantengamos todos estos archivos en el directorio raíz e intentemos acceder main.jsp. Esto mostraría un resultado similar al siguiente.

Aquí descartó el contenido de la página principal y mostró el contenido de la página reenviada solamente.

        Today's date: 12-Sep-2010 14:54:22 
      

La acción <jsp: plugin>

los pluginLa acción se utiliza para insertar componentes Java en una página JSP. Determina el tipo de navegador e inserta el<object> o <embed> etiquetas según sea necesario.

Si el complemento necesario no está presente, descarga el complemento y luego ejecuta el componente Java. El componente Java puede ser un Applet o un JavaBean.

La acción del complemento tiene varios atributos que corresponden a las etiquetas HTML comunes que se utilizan para formatear los componentes de Java. los<param> El elemento también se puede utilizar para enviar parámetros al Applet o Bean.

A continuación se muestra la sintaxis típica del uso de la acción del complemento:

<jsp:plugin type = "applet" codebase = "dirname" code = "MyApplet.class"
   width = "60" height = "80">
   <jsp:param name = "fontcolor" value = "red" />
   <jsp:param name = "background" value = "black" />
 
   <jsp:fallback>
      Unable to initialize Java Plugin
   </jsp:fallback>
 
</jsp:plugin>

Puede probar esta acción utilizando algún subprograma si está interesado. Un nuevo elemento, el<fallback> , se puede utilizar para especificar una cadena de error que se enviará al usuario en caso de que falle el componente.

The <jsp:element> Action
The <jsp:attribute> Action
The <jsp:body> Action

los <jsp:element>, <jsp:attribute> y <jsp:body>las acciones se utilizan para definir elementos XML de forma dinámica. La palabra dinámicamente es importante, porque significa que los elementos XML se pueden generar en el momento de la solicitud en lugar de de forma estática en el momento de la compilación.

A continuación se muestra un ejemplo simple para definir elementos XML de forma dinámica:

<%@page language = "java" contentType = "text/html"%>
<html xmlns = "http://www.w3c.org/1999/xhtml"
   xmlns:jsp = "http://java.sun.com/JSP/Page">
   
   <head><title>Generate XML Element</title></head>
   
   <body>
      <jsp:element name = "xmlElement">
         <jsp:attribute name = "xmlElementAttr">
            Value for the attribute
         </jsp:attribute>
         
         <jsp:body>
            Body for XML element
         </jsp:body>
      
      </jsp:element>
   </body>
</html>

Esto produciría el siguiente código HTML en tiempo de ejecución:

<html xmlns = "http://www.w3c.org/1999/xhtml" xmlns:jsp = "http://java.sun.com/JSP/Page">
   <head><title>Generate XML Element</title></head>
   
   <body>
      <xmlElement xmlElementAttr = "Value for the attribute">
         Body for XML element
      </xmlElement>
   </body>
</html>

La acción <jsp: text>

los <jsp:text>La acción se puede utilizar para escribir el texto de la plantilla en páginas y documentos JSP. A continuación se muestra la sintaxis simple para esta acción:

<jsp:text>Template data</jsp:text>

El cuerpo de la plantilla no puede contener otros elementos; solo puede contener texto y expresiones EL (Nota: las expresiones EL se explican en un capítulo posterior). Tenga en cuenta que en los archivos XML, no puede utilizar expresiones como${whatever > 0}, porque los signos mayores que son ilegales. En su lugar, use elgt forma, como ${whatever gt 0} o una alternativa es incrustar el valor en un CDATA sección.

<jsp:text><![CDATA[<br>]]></jsp:text>

Si necesita incluir un DOCTYPE declaración, por ejemplo para XHTML, también debe utilizar el <jsp:text> elemento de la siguiente manera -

<jsp:text><![CDATA[<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
   "DTD/xhtml1-strict.dtd">]]></jsp:text>

   <head><title>jsp:text action</title></head>
   
   <body>
      <books><book><jsp:text>  
         Welcome to JSP Programming
      </jsp:text></book></books>
   </body>
</html>

Pruebe el ejemplo anterior con y sin <jsp:text> acción.

En este capítulo, discutiremos los objetos implícitos en JSP. Estos Objetos son los objetos Java que JSP Container pone a disposición de los desarrolladores en cada página y el desarrollador puede llamarlos directamente sin ser declarados explícitamente. Los objetos implícitos JSP también se denominanpre-defined variables.

La siguiente tabla enumera los nueve objetos implícitos que admite JSP:

S.No.	Descripción del objeto
1	request Este es el HttpServletRequest objeto asociado con la solicitud.
2	response Este es el HttpServletResponse objeto asociado a la respuesta al cliente.
3	out Este es el PrintWriter objeto utilizado para enviar salida al cliente.
4	session Este es el HttpSession objeto asociado con la solicitud.
5	application Este es el ServletContext objeto asociado con el contexto de la aplicación.
6	config Este es el ServletConfig objeto asociado a la página.
7	pageContext Esto encapsula el uso de funciones específicas del servidor como un mayor rendimiento JspWriters.
8	page Esto es simplemente un sinónimo de this, y se utiliza para llamar a los métodos definidos por la clase de servlet traducida.
9	Exception los Exception El objeto permite acceder a los datos de excepción mediante JSP designado.

El objeto de solicitud

El objeto de solicitud es una instancia de un javax.servlet.http.HttpServletRequestobjeto. Cada vez que un cliente solicita una página, el motor JSP crea un nuevo objeto para representar esa solicitud.

El objeto de solicitud proporciona métodos para obtener la información del encabezado HTTP, incluidos datos de formulario, cookies, métodos HTTP, etc.

Podemos cubrir un conjunto completo de métodos asociados con el objeto de solicitud en un capítulo posterior: JSP - Solicitud de cliente .

El objeto de respuesta

El objeto de respuesta es una instancia de un javax.servlet.http.HttpServletResponseobjeto. Así como el servidor crea el objeto de solicitud, también crea un objeto para representar la respuesta al cliente.

El objeto de respuesta también define las interfaces que se ocupan de la creación de nuevos encabezados HTTP. A través de este objeto, el programador JSP puede agregar nuevas cookies o sellos de fecha, códigos de estado HTTP, etc.

Cubriremos un conjunto completo de métodos asociados con el objeto de respuesta en un capítulo posterior - JSP - Respuesta del servidor .

El objeto de salida

El objeto implícito out es una instancia de un javax.servlet.jsp.JspWriter objeto y se utiliza para enviar contenido en una respuesta.

El objeto JspWriter inicial se crea de forma diferente dependiendo de si la página está almacenada en búfer o no. El almacenamiento en búfer se puede desactivar fácilmente mediante elbuffered = 'false' atributo de la directiva de página.

El objeto JspWriter contiene la mayoría de los mismos métodos que el java.io.PrintWriterclase. Sin embargo, JspWriter tiene algunos métodos adicionales diseñados para lidiar con el almacenamiento en búfer. A diferencia del objeto PrintWriter, JspWriter lanzaIOExceptions.

La siguiente tabla enumera los métodos importantes que usaremos para escribir boolean char, int, double, object, Stringetc.

S.No.	Método y descripción
1	out.print(dataType dt) Imprimir un valor de tipo de datos
2	out.println(dataType dt) Imprima un valor de tipo de datos y luego termine la línea con un carácter de nueva línea.
3	out.flush() Descarga la corriente.

El objeto de la sesión

El objeto de sesión es una instancia de javax.servlet.http.HttpSession y se comporta exactamente de la misma manera que los objetos de sesión en Java Servlets.

El objeto de sesión se utiliza para rastrear la sesión del cliente entre las solicitudes del cliente. Cubriremos el uso completo del objeto de sesión en un capítulo posterior - JSP - Seguimiento de sesión .

El objeto de la aplicación

El objeto de la aplicación es un envoltorio directo alrededor del ServletContext objeto para el Servlet generado y, en realidad, una instancia de un javax.servlet.ServletContext objeto.

Este objeto es una representación de la página JSP durante todo su ciclo de vida. Este objeto se crea cuando se inicializa la página JSP y se eliminará cuando la página JSP sea eliminada por eljspDestroy() método.

Al agregar un atributo a la aplicación, puede asegurarse de que todos los archivos JSP que componen su aplicación web tengan acceso a él.

Comprobaremos el uso del objeto de aplicación en el capítulo JSP - Contador de visitas.

El objeto de configuración

El objeto de configuración es una instanciación de javax.servlet.ServletConfig y es una envoltura directa alrededor del ServletConfig objeto para el servlet generado.

Este objeto permite al programador JSP acceder a los parámetros de inicialización del motor Servlet o JSP, como las rutas o ubicaciones de archivos, etc.

El seguimiento config El método es el único que podría usar, y su uso es trivial:

config.getServletName();

Esto devuelve el nombre del servlet, que es la cadena contenida en el <servlet-name> elemento definido en el WEB-INF\web.xml archivo.

El objeto pageContext

El objeto pageContext es una instancia de un javax.servlet.jsp.PageContextobjeto. El objeto pageContext se utiliza para representar la página JSP completa.

Este objeto está destinado a ser un medio para acceder a información sobre la página, evitando la mayoría de los detalles de implementación.

Este objeto almacena referencias a los objetos de solicitud y respuesta para cada solicitud. losapplication, config, session, y los objetos out se obtienen accediendo a los atributos de este objeto.

El objeto pageContext también contiene información sobre las directivas emitidas a la página JSP, incluida la información de almacenamiento en búfer, errorPageURL y el alcance de la página.

La clase PageContext define varios campos, incluidos PAGE_SCOPE, REQUEST_SCOPE, SESSION_SCOPE, y APPLICATION_SCOPE, que identifican los cuatro ámbitos. También admite más de 40 métodos, aproximadamente la mitad de los cuales se heredan deljavax.servlet.jsp.JspContext class.

Uno de los métodos importantes es removeAttribute. Este método acepta uno o dos argumentos. Por ejemplo,pageContext.removeAttribute ("attrName") elimina el atributo de todos los ámbitos, mientras que el siguiente código solo lo elimina del ámbito de la página:

pageContext.removeAttribute("attrName", PAGE_SCOPE);

El uso de pageContext se puede verificar en el capítulo JSP - Carga de archivos .

El objeto de la página

Este objeto es una referencia real a la instancia de la página. Se puede considerar como un objeto que representa toda la página JSP.

El objeto de página es realmente un sinónimo directo de this objeto.

El objeto de excepción

El objeto de excepción es un contenedor que contiene la excepción lanzada desde la página anterior. Suele utilizarse para generar una respuesta adecuada a la condición de error.

Cubriremos el uso completo de este objeto en el capítulo JSP - Manejo de excepciones .

En este capítulo, analizaremos la solicitud del cliente en JSP. Cuando un navegador solicita una página web, envía mucha información al servidor web. Esta información no se puede leer directamente porque esta información viaja como parte del encabezado de la solicitud HTTP. Puede consultar el Protocolo HTTP para obtener más información al respecto.

La siguiente tabla enumera la información importante del encabezado que proviene del navegador. Esta información se utiliza con frecuencia en la programación web:

S.No.	Encabezado y descripción
1	Accept Este encabezado especifica el MIMEtipos que el navegador u otros clientes pueden manejar. Valores deimage/png o image/jpeg son las dos posibilidades más comunes.
2	Accept-Charset Este encabezado especifica los juegos de caracteres que el navegador puede usar para mostrar la información. Por ejemplo,ISO-8859-1.
3	Accept-Encoding Este encabezado especifica los tipos de codificaciones que el navegador sabe cómo manejar. Valores degzip o compress son las dos posibilidades más comunes.
4	Accept-Language Este encabezado especifica los idiomas preferidos del cliente en caso de que el servlet pueda producir resultados en más de un idioma. Por ejemploen, en-us, ruetc.
5	Authorization Los clientes utilizan este encabezado para identificarse cuando acceden a páginas web protegidas con contraseña.
6	Connection Este encabezado indica si el cliente puede manejar conexiones HTTP persistentes. Las conexiones persistentes permiten que el cliente u otro navegador recupere varios archivos con una sola solicitud. Un valor deKeep-Alive significa que deben usarse conexiones persistentes.
7	Content-Length Este encabezado es aplicable solo a POST solicita y da el tamaño de los datos POST en bytes.
8	Cookie Este encabezado devuelve las cookies a los servidores que las enviaron previamente al navegador.
9	Host Este encabezado especifica el host y el puerto como se indica en la URL original.
10	If-Modified-Since Este encabezado indica que el cliente desea la página solo si se ha cambiado después de la fecha especificada. El servidor envía un código, 304 que significaNot Modified encabezado si no hay ningún resultado más reciente disponible.
11	If-Unmodified-Since Este encabezado es el reverso de If-Modified-Since; especifica que la operación debe realizarse correctamente solo si el documento es anterior a la fecha especificada.
12	Referer Este encabezado indica la URL de las páginas web de referencia. Por ejemplo, si está en la página web 1 y hace clic en un enlace a la página web 2, la URL de la página web 1 se incluye en el encabezado Referer cuando el navegador solicita la página web 2.
13	User-Agent Este encabezado identifica el navegador u otro cliente que realiza la solicitud y se puede utilizar para devolver contenido diferente a diferentes tipos de navegadores.

El objeto HttpServletRequest

El objeto de solicitud es una instancia de un javax.servlet.http.HttpServletRequestobjeto. Cada vez que un cliente solicita una página, el motor JSP crea un nuevo objeto para representar esa solicitud.

El objeto de solicitud proporciona métodos para obtener información de encabezado HTTP, incluido form data, cookies, HTTP methodsetc.

La siguiente tabla enumera los métodos importantes que se pueden usar para leer el encabezado HTTP en su programa JSP. Estos métodos están disponibles con el objeto HttpServletRequest que representa la solicitud del cliente al servidor web.

S.No.	Método y descripción
1	Cookie[] getCookies() Devuelve una matriz que contiene todos los objetos Cookie que el cliente envió con esta solicitud.
2	Enumeration getAttributeNames() Devuelve una enumeración que contiene los nombres de los atributos disponibles para esta solicitud.
3	Enumeration getHeaderNames() Devuelve una enumeración de todos los nombres de encabezado que contiene esta solicitud.
4	Enumeration getParameterNames() Devuelve una enumeración de los objetos String que contienen los nombres de los parámetros contenidos en esta solicitud.
5	HttpSession getSession() Devuelve la sesión actual asociada con esta solicitud, o si la solicitud no tiene una sesión, crea una.
6	HttpSession getSession(boolean create) Devuelve la HttpSession actual asociada con esta solicitud o, si no hay una sesión actual y create es verdadero, devuelve una nueva sesión.
7	Locale getLocale() Devuelve la configuración regional preferida en la que el cliente aceptará contenido, según el encabezado Accept-Language.
8	Object getAttribute(String name) Devuelve el valor del atributo nombrado como un Objeto, o nulo si no existe ningún atributo del nombre dado.
9	ServletInputStream getInputStream() Recupera el cuerpo de la solicitud como datos binarios mediante ServletInputStream.
10	String getAuthType() Devuelve el nombre del esquema de autenticación utilizado para proteger el servlet, por ejemplo, "BASIC" o "SSL", o nulo si la JSP no estaba protegida.
11	String getCharacterEncoding() Devuelve el nombre de la codificación de caracteres utilizada en el cuerpo de esta solicitud.
12	String getContentType() Devuelve el tipo MIME del cuerpo de la solicitud, o nulo si no se conoce el tipo.
13	String getContextPath() Devuelve la parte del URI de la solicitud que indica el contexto de la solicitud.
14	String getHeader(String name) Devuelve el valor del encabezado de solicitud especificado como una cadena.
15	String getMethod() Devuelve el nombre del método HTTP con el que se realizó esta solicitud, por ejemplo, GET, POST o PUT.
dieciséis	String getParameter(String name) Devuelve el valor de un parámetro de solicitud como una cadena, o nulo si el parámetro no existe.
17	String getPathInfo() Devuelve cualquier información de ruta adicional asociada con la URL que envió el cliente cuando realizó esta solicitud.
18	String getProtocol() Devuelve el nombre y la versión del protocolo que usa la solicitud.
19	String getQueryString() Devuelve la cadena de consulta contenida en la URL de la solicitud después de la ruta.
20	String getRemoteAddr() Devuelve la dirección de Protocolo de Internet (IP) del cliente que envió la solicitud.
21	String getRemoteHost() Devuelve el nombre completo del cliente que envió la solicitud.
22	String getRemoteUser() Devuelve el inicio de sesión del usuario que realiza esta solicitud, si el usuario ha sido autenticado, o nulo si el usuario no ha sido autenticado.
23	String getRequestURI() Devuelve la parte de la URL de esta solicitud desde el nombre del protocolo hasta la cadena de consulta en la primera línea de la solicitud HTTP.
24	String getRequestedSessionId() Devuelve el ID de sesión especificado por el cliente.
25	String getServletPath() Devuelve la parte de la URL de esta solicitud que llama al JSP.
26	String[] getParameterValues(String name) Devuelve una matriz de objetos String que contiene todos los valores que tiene el parámetro de solicitud dado, o nulo si el parámetro no existe.
27	boolean isSecure() Devuelve un valor booleano que indica si esta solicitud se realizó mediante un canal seguro, como HTTPS.
28	int getContentLength() Devuelve la longitud, en bytes, del cuerpo de la solicitud y que el flujo de entrada pone a disposición, o -1 si no se conoce la longitud.
29	int getIntHeader(String name) Devuelve el valor del encabezado de solicitud especificado como un int.
30	int getServerPort() Devuelve el número de puerto en el que se recibió esta solicitud.

Ejemplo de solicitud de encabezado HTTP

A continuación se muestra el ejemplo que utiliza getHeaderNames() método de HttpServletRequestpara leer la información del encabezado HTTP. Este método devuelve una enumeración que contiene la información del encabezado asociada con la solicitud HTTP actual.

Una vez que tenemos una enumeración, podemos recorrer la enumeración de la manera estándar. Usaremos elhasMoreElements() método para determinar cuándo detenerse y el nextElement() método para obtener el nombre de cada parámetro.

<%@ page import = "java.io.*,java.util.*" %>

<html>
   <head>
      <title>HTTP Header Request Example</title>
   </head>

   <body>
      <center>
         <h2>HTTP Header Request Example</h2>
         
         <table width = "100%" border = "1" align = "center">
            <tr bgcolor = "#949494">
               <th>Header Name</th>
               <th>Header Value(s)</th>
            </tr>
            <%
               Enumeration headerNames = request.getHeaderNames();
               while(headerNames.hasMoreElements()) {
                  String paramName = (String)headerNames.nextElement();
                  out.print("<tr><td>" + paramName + "</td>\n");
                  String paramValue = request.getHeader(paramName);
                  out.println("<td> " + paramValue + "</td></tr>\n");
               }
            %>
         </table>
      </center>
   
   </body>
</html>

Pongamos ahora el código anterior en main.jsp e intenta acceder a él.

Ejemplo de solicitud de encabezado HTTP

Nombre del encabezado	Valor (es) de encabezado
aceptar	* / *
aceptar-idioma	en-us
agente de usuario	Mozilla / 4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident / 4.0; InfoPath.2; MS-RTC LM 8)
aceptar codificación	gzip, desinflar
anfitrión	localhost: 8080
conexión	Mantener viva
control de caché	sin caché

Puede intentar trabajar en todos los métodos de forma similar.

En este capítulo, discutiremos la respuesta del servidor en JSP. Cuando un servidor web responde a una solicitud HTTP, la respuesta generalmente consta de una línea de estado, algunos encabezados de respuesta, una línea en blanco y el documento. Una respuesta típica se ve así:

HTTP/1.1 200 OK
Content-Type: text/html
Header2: ...
...
HeaderN: ...
   (Blank Line)
<!doctype ...>

<html>
   <head>...</head>
   <body>
      ...
   </body>
</html>

La línea de estado consta de la versión HTTP (HTTP/1.1 in the example), un código de estado (200 in the example), y un mensaje muy breve correspondiente al código de estado (OK in the example).

A continuación se muestra un resumen de los encabezados de respuesta HTTP 1.1 más útiles que regresan al navegador desde el servidor web. Estos encabezados se utilizan con frecuencia en la programación web:

S.No.	Encabezado y descripción
1	Allow Este encabezado especifica los métodos de solicitud (GET, POST, etc.) que admite el servidor.
2	Cache-Control Este encabezado especifica las circunstancias en las que el documento de respuesta se puede almacenar en caché de forma segura. Puede tener valorespublic, private o no-cache etc. Público significa que el documento se puede almacenar en caché, Privado significa que el documento es para un solo usuario y solo se puede almacenar en cachés privados (no compartidos) y sin caché significa que el documento nunca debe almacenarse en caché.
3	Connection Este encabezado indica al navegador si debe utilizar conexiones HTTP persistentes o no. Un valor declose indica al navegador que no utilice conexiones HTTP persistentes y keep-alive significa usar conexiones persistentes.
4	Content-Disposition Este encabezado le permite solicitar que el navegador le pida al usuario que guarde la respuesta en el disco en un archivo con el nombre dado.
5	Content-Encoding Este encabezado especifica la forma en que se codificó la página durante la transmisión.
6	Content-Language Este encabezado significa el idioma en el que está escrito el documento. Por ejemplo,en, en-us, ru, etc.
7	Content-Length Este encabezado indica el número de bytes en la respuesta. Esta información es necesaria solo si el navegador está utilizando una conexión HTTP persistente (mantener viva).
8	Content-Type Este encabezado da el MIME (Multipurpose Internet Mail Extension) tipo de documento de respuesta.
9	Expires Este encabezado especifica el momento en el que el contenido debe considerarse desactualizado y, por lo tanto, ya no se debe almacenar en caché.
10	Last-Modified Este encabezado indica cuándo se modificó por última vez el documento. Luego, el cliente puede almacenar en caché el documento y proporcionar una fechaIf-Modified-Since encabezado de solicitud en solicitudes posteriores.
11	Location Este encabezado debe incluirse con todas las respuestas que tengan un código de estado en los 300. Esto notifica al navegador de la dirección del documento. El navegador se vuelve a conectar automáticamente a esta ubicación y recupera el nuevo documento.
12	Refresh Este encabezado especifica qué tan pronto el navegador debe solicitar una página actualizada. Puede especificar el tiempo en segundos después del cual se actualizará una página.
13	Retry-After Este encabezado se puede utilizar junto con un 503 (Service Unavailable) respuesta para decirle al cliente cuándo puede repetir su solicitud.
14	Set-Cookie Este encabezado especifica una cookie asociada con la página.

El objeto HttpServletResponse

El objeto de respuesta es una instancia de un javax.servlet.http.HttpServletResponse object. Así como el servidor crea el objeto de solicitud, también crea un objeto para representar la respuesta al cliente.

El objeto de respuesta también define las interfaces que se ocupan de la creación de nuevos encabezados HTTP. A través de este objeto, el programador JSP puede agregar nuevas cookies o sellos de fecha, códigos de estado HTTP, etc.

Los siguientes métodos se pueden utilizar para configurar el encabezado de respuesta HTTP en su programa de servlet. Estos métodos están disponibles con el objeto HttpServletResponse . Este objeto representa la respuesta del servidor.

S.No.	Método y descripción
1	String encodeRedirectURL(String url) Codifica la URL especificada para su uso en el sendRedirect o, si no se necesita codificación, devuelve la URL sin cambios.
2	String encodeURL(String url) Codifica la URL especificada al incluir la ID de sesión en ella o, si no se necesita codificación, devuelve la URL sin cambios.
3	boolean containsHeader(String name) Devuelve un valor booleano que indica si el encabezado de respuesta con nombre ya se ha establecido.
4	boolean isCommitted() Devuelve un booleano que indica si la respuesta se ha confirmado.
5	void addCookie(Cookie cookie) Agrega la cookie especificada a la respuesta.
6	void addDateHeader(String name, long date) Agrega un encabezado de respuesta con el nombre dado y el valor de la fecha.
7	void addHeader(String name, String value) Agrega un encabezado de respuesta con el nombre y el valor proporcionados.
8	void addIntHeader(String name, int value) Agrega un encabezado de respuesta con el nombre dado y el valor entero.
9	void flushBuffer() Obliga a que cualquier contenido del búfer se escriba en el cliente.
10	void reset() Borra todos los datos que existen en el búfer, así como el código de estado y los encabezados.
11	void resetBuffer() Borra el contenido del búfer subyacente en la respuesta sin borrar los encabezados ni el código de estado.
12	void sendError(int sc) Envía una respuesta de error al cliente utilizando el código de estado especificado y borrando el búfer.
13	void sendError(int sc, String msg) Envía una respuesta de error al cliente utilizando el estado especificado.
14	void sendRedirect(String location) Envía una respuesta de redireccionamiento temporal al cliente mediante la URL de ubicación de redireccionamiento especificada.
15	void setBufferSize(int size) Establece el tamaño de búfer preferido para el cuerpo de la respuesta.
dieciséis	void setCharacterEncoding(String charset) Establece la codificación de caracteres (juego de caracteres MIME) de la respuesta que se envía al cliente, por ejemplo, en UTF-8.
17	void setContentLength(int len) Establece la longitud del cuerpo del contenido en la respuesta En servlets HTTP; este método también establece el encabezado HTTP Content-Length.
18	void setContentType(String type) Establece el tipo de contenido de la respuesta que se envía al cliente, si la respuesta aún no se ha confirmado.
19	void setDateHeader(String name, long date) Establece un encabezado de respuesta con el nombre dado y el valor de fecha.
20	void setHeader(String name, String value) Establece un encabezado de respuesta con el nombre y el valor proporcionados.
21	void setIntHeader(String name, int value) Establece un encabezado de respuesta con el nombre dado y el valor entero.
22	void setLocale(Locale loc) Establece la configuración regional de la respuesta, si la respuesta aún no se ha confirmado.
23	void setStatus(int sc) Establece el código de estado para esta respuesta.

Ejemplo de respuesta de encabezado HTTP

El siguiente ejemplo usaría setIntHeader() método para configurar Refresh encabezado para simular un reloj digital -

<%@ page import = "java.io.*,java.util.*" %>

<html>
   
   <head>
      <title>Auto Refresh Header Example</title>
   </head>
   
   <body>
      <center>
         <h2>Auto Refresh Header Example</h2>
         <%
            // Set refresh, autoload time as 5 seconds
            response.setIntHeader("Refresh", 5);
            
            // Get current time
            Calendar calendar = new GregorianCalendar();
            
            String am_pm;
            int hour = calendar.get(Calendar.HOUR);
            int minute = calendar.get(Calendar.MINUTE);
            int second = calendar.get(Calendar.SECOND);
            
            if(calendar.get(Calendar.AM_PM) == 0) 
               am_pm = "AM";
            else
               am_pm = "PM";
               String CT = hour+":"+ minute +":"+ second +" "+ am_pm;
               out.println("Current Time is: " + CT + "\n");
         %>
      </center>
   
   </body>
</html>

Ahora ponga el código anterior en main.jspe intenta acceder a él. Esto mostrará la hora actual del sistema después de cada 5 segundos de la siguiente manera. Ejecute JSP. Recibirá el siguiente resultado: -

 
       
Auto Refresh Header Example
 Current Time is: 9:44:50 PM 
      

Puede intentar trabajar con los otros métodos de manera similar.

En este capítulo, discutiremos los códigos de estado Http en JSP. El formato de la solicitud HTTP y los mensajes de respuesta HTTP son similares y tendrán la siguiente estructura:

• Una línea de estado inicial + CRLF (retorno de carro + salto de línea, es decir, nueva línea)

• Cero o más líneas de encabezado + CRLF

• Una línea en blanco, es decir. un CRLF

• Un cuerpo de mensaje opcional como archivo, datos de consulta o salida de consulta.

Por ejemplo, un encabezado de respuesta del servidor se parece a lo siguiente:

HTTP/1.1 200 OK
Content-Type: text/html
Header2: ...
...
HeaderN: ...
   (Blank Line)
<!doctype ...>

<html>
   <head>...</head>
   
   <body>
      ...
   </body>
</html>

La línea de estado consta de HTTP version (HTTP/1.1 in the example), un código de estado (200 en el ejemplo) y un mensaje muy corto correspondiente al código de estado (OK in the example).

La siguiente tabla enumera los códigos de estado HTTP y los mensajes asociados que pueden devolverse desde el servidor web:

Código	Mensaje	Descripción
100	Seguir	El servidor solo ha recibido una parte de la solicitud, pero mientras no haya sido rechazada, el cliente debe continuar con la solicitud.
101	Protocolos de conmutación	El servidor cambia de protocolo.
200	Okay	La solicitud está bien
201	Creado	La solicitud está completa y se crea un nuevo recurso
202	Aceptado	La solicitud se acepta para su procesamiento, pero el procesamiento no está completo.
203	Información no autorizada
204	Sin contenido
205	Restablecer contenido
206	Contenido parcial
300	Múltiples opciones	Una lista de enlaces; el usuario puede seleccionar un enlace e ir a esa ubicación. Máximo cinco direcciones.
301	Movido permanentemente	La página solicitada se ha movido a una nueva URL.
302	Encontró	La página solicitada se ha movido temporalmente a una nueva URL.
303	Ver otros	La página solicitada se puede encontrar en una URL diferente.
304	No modificado
305	Usa proxy
306	No usado	Este código se utilizó en una versión anterior. Ya no se usa, pero el código está reservado.
307	Redireccionamiento temporal	La página solicitada se ha movido temporalmente a una nueva URL.
400	Solicitud incorrecta	El servidor no entendió la solicitud.
401	No autorizado	La página solicitada necesita un nombre de usuario y una contraseña.
402	pago requerido	Aún no puedes usar este código.
403	Prohibido	Prohibido el acceso a la página solicitada
404	Extraviado	El servidor no puede encontrar la página solicitada.
405	Método no permitido	El método especificado en la solicitud no está permitido.
406	Inaceptable	El servidor solo puede generar una respuesta que no es aceptada por el cliente.
407	Se requiere autenticación proxy	Debe autenticarse con un servidor proxy antes de que se pueda atender esta solicitud.
408	Pide tiempo fuera	La solicitud tardó más de lo que el servidor estaba preparado para esperar.
409	Conflicto	La solicitud no se pudo completar debido a un conflicto.
410	Ido	La página solicitada ya no está disponible.
411	Longitud requerida	La "Longitud del contenido" no está definida. El servidor no aceptará la solicitud sin ella.
412	Condición previa Falló	La condición previa dada en la solicitud evaluada como falsa por el servidor.
413	Solicitar entidad demasiado grande	El servidor no aceptará la solicitud porque la entidad de la solicitud es demasiado grande.
414	URL de solicitud demasiado larga	El servidor no aceptará la solicitud porque la URL es demasiado larga. Esto ocurre cuando convierte una solicitud "publicar" en una solicitud "obtener" con una información de consulta larga.
415	Tipo de papel no admitido	El servidor no aceptará la solicitud porque el tipo de medio no es compatible.
417	Expectativa fallida
500	error de servidor interno	La solicitud no se completó. El servidor encontró una condición inesperada.
501	No se ha implementado	La solicitud no se completó. El servidor no admitía la funcionalidad requerida.
502	Puerta de enlace incorrecta	La solicitud no se completó. El servidor recibió una respuesta no válida del servidor ascendente.
503	Servicio no disponible	La solicitud no se completó. El servidor se está sobrecargando o cayendo temporalmente.
504	Tiempo de espera de puerta de enlace	Se agotó el tiempo de espera de la puerta de enlace.
505	Versión HTTP no compatible	El servidor no es compatible con "http protocol" versión.

Métodos para establecer el código de estado HTTP

Los siguientes métodos se pueden utilizar para configurar el código de estado HTTP en su programa de servlet. Estos métodos están disponibles con el objeto HttpServletResponse .

S.No.	Método y descripción
1	public void setStatus ( int statusCode ) Este método establece un código de estado arbitrario. El método setStatus toma un int (el código de estado) como argumento. Si su respuesta incluye un código de estado especial y un documento, asegúrese de llamarsetStatusantes de devolver el contenido con PrintWriter .
2	public void sendRedirect(String url) Este método genera una respuesta 302 junto con un encabezado de ubicación que proporciona la URL del nuevo documento.
3	public void sendError(int code, String message) Este método envía un código de estado (generalmente 404) junto con un mensaje corto que se formatea automáticamente dentro de un documento HTML y se envía al cliente.

Ejemplo de código de estado HTTP

El siguiente ejemplo muestra cómo se envía un código de error 407 al navegador del cliente. Después de esto, el navegador le mostrará "Need authentication!!!"mensaje.

<html>
   <head>
      <title>Setting HTTP Status Code</title>
   </head>
   
   <body>
      <%
         // Set error code and reason.
         response.sendError(407, "Need authentication!!!" );
      %>
   </body>
</html>

Recibirá el siguiente resultado:

HTTP Status 407 - Need authentication!!!
type Status report
message Need authentication!!!
description The client must first authenticate itself with the proxy (Need authentication!!!).
Apache Tomcat/5.5.29

Para sentirse más cómodo con los códigos de estado HTTP, intente establecer diferentes códigos de estado y su descripción.

En este capítulo, analizaremos el procesamiento de formularios en JSP. Debe haberse encontrado con muchas situaciones en las que necesita pasar cierta información de su navegador al servidor web y, en última instancia, a su programa de backend. El navegador utiliza dos métodos para pasar esta información al servidor web. Estos métodos son el método GET y el método POST.

Los métodos en el procesamiento de formularios

Analicemos ahora los métodos en Procesamiento de formularios.

Método GET

El método GET envía la información de usuario codificada adjunta a la solicitud de página. La página y la información codificada están separadas por? personaje de la siguiente manera:

http://www.test.com/hello?key1=value1&key2=value2

El método GET es el método predeterminado para pasar información del navegador al servidor web y produce una cadena larga que aparece en el Location:box. Se recomienda no utilizar el método GET. si tiene contraseña u otra información confidencial para pasar al servidor.

El método GET tiene una limitación de tamaño: only 1024 characters can be in a request string.

Esta información se pasa usando QUERY_STRING header y será accesible a través de la variable de entorno QUERY_STRING que se puede manejar usando getQueryString() y getParameter() métodos de objeto de solicitud.

Método POST

Un método generalmente más confiable para pasar información a un programa de backend es el método POST.

Este método empaqueta la información exactamente de la misma manera que el método GET, pero en lugar de enviarla como una cadena de texto después de? en la URL lo envía como un mensaje separado. Este mensaje llega al programa backend en forma de entrada estándar que puede analizar y utilizar para su procesamiento.

JSP maneja este tipo de solicitudes usando getParameter() método para leer parámetros simples y getInputStream() método para leer el flujo de datos binarios provenientes del cliente.

Lectura de datos de formulario usando JSP

JSP maneja el análisis de datos de formularios automáticamente usando los siguientes métodos dependiendo de la situación:

• getParameter() - tu llamas request.getParameter() método para obtener el valor de un parámetro de formulario.

• getParameterValues() - Llame a este método si el parámetro aparece más de una vez y devuelve varios valores, por ejemplo, casilla de verificación.

• getParameterNames() - Llame a este método si desea una lista completa de todos los parámetros en la solicitud actual.

• getInputStream() - Llame a este método para leer el flujo de datos binarios provenientes del cliente.

Ejemplo de método GET usando URL

La siguiente URL pasará dos valores al programa HelloForm utilizando el método GET.

http://localhost:8080/main.jsp?first_name=ZARA&last_name=ALI

abajo esta el main.jspPrograma JSP para manejar la entrada proporcionada por el navegador web. Vamos a utilizar elgetParameter() método que hace que sea muy fácil acceder a la información transmitida -

<html>
   <head>
      <title>Using GET Method to Read Form Data</title>
   </head>
   
   <body>
      <h1>Using GET Method to Read Form Data</h1>
      <ul>
         <li><p><b>First Name:</b>
            <%= request.getParameter("first_name")%>
         </p></li>
         <li><p><b>Last  Name:</b>
            <%= request.getParameter("last_name")%>
         </p></li>
      </ul>
   
   </body>
</html>

Ahora escribe http://localhost:8080/main.jsp?first_name=ZARA&last_name=ALI en tu navegador Location:box. Esto generará el siguiente resultado:

Uso del método GET para leer datos de formularios First Name: ZARA Last Name: ALI

Ejemplo de método GET usando formulario

A continuación se muestra un ejemplo que pasa dos valores usando el FORMULARIO HTML y el botón de enviar. Vamos a utilizar el mismo JSP main.jsp para manejar esta entrada.

<html>
   <body>
      
      <form action = "main.jsp" method = "GET">
         First Name: <input type = "text" name = "first_name">
         <br />
         Last Name: <input type = "text" name = "last_name" />
         <input type = "submit" value = "Submit" />
      </form>
      
   </body>
</html>

Mantenga este HTML en un archivo Hello.htm y colóquelo en <Tomcat-installation-directory>/webapps/ROOT directory. Cuando accederíashttp://localhost:8080/Hello.htm, recibirá el siguiente resultado.

Ejemplo de método POST usando formulario

Hagamos una pequeña modificación en el JSP anterior para manejar tanto el método GET como el POST. abajo esta elmain.jsp Programa JSP para manejar la entrada proporcionada por el navegador web utilizando los métodos GET o POST.

De hecho, no hay cambios en la JSP anterior porque se cambia la única forma de pasar parámetros y no se pasan datos binarios al programa JSP. Los conceptos relacionados con el manejo de archivos se explicarán en un capítulo separado donde necesitamos leer el flujo de datos binarios.

<html>
   <head>
      <title>Using GET and POST Method to Read Form Data</title>
   </head>
   
   <body>
      <center>
      <h1>Using POST Method to Read Form Data</h1>
      
      <ul>
         <li><p><b>First Name:</b>
            <%= request.getParameter("first_name")%>
         </p></li>
         <li><p><b>Last  Name:</b>
            <%= request.getParameter("last_name")%>
         </p></li>
      </ul>
   
   </body>
</html>

A continuación se muestra el contenido de la Hello.htm archivo -

<html>
   <body>
      
      <form action = "main.jsp" method = "POST">
         First Name: <input type = "text" name = "first_name">
         <br />
         Last Name: <input type = "text" name = "last_name" />
         <input type = "submit" value = "Submit" />
      </form>
      
   </body>
</html>

Ahora mantengamos main.jsp y hola.htm en <Tomcat-installationdirectory>/webapps/ROOT directory. Cuando accedeshttp://localhost:8080/Hello.htm, recibirá el siguiente resultado.

Intente ingresar el Nombre y el Apellido y luego haga clic en el botón Enviar para ver el resultado en su máquina local donde se está ejecutando Tomcat.

Según la información proporcionada, recibirá resultados similares a los de los ejemplos anteriores.

Pasar datos de casilla de verificación al programa JSP

Las casillas de verificación se utilizan cuando se requiere seleccionar más de una opción.

A continuación se muestra un ejemplo HTML code, CheckBox.htm, para un formulario con dos casillas de verificación.

<html>
   <body>
      
      <form action = "main.jsp" method = "POST" target = "_blank">
         <input type = "checkbox" name = "maths" checked = "checked" /> Maths
         <input type = "checkbox" name = "physics"  /> Physics
         <input type = "checkbox" name = "chemistry" checked = "checked" /> Chemistry
         <input type = "submit" value = "Select Subject" />
      </form>
      
   </body>
</html>

El código anterior generará el siguiente resultado:

A continuación se muestra el programa JSP main.jsp para manejar la entrada proporcionada por el navegador web para el botón de casilla de verificación.

<html>
   <head>
      <title>Reading Checkbox Data</title>
   </head>
   
   <body>
      <h1>Reading Checkbox Data</h1>
      
      <ul>
         <li><p><b>Maths Flag:</b>
            <%= request.getParameter("maths")%>
         </p></li>
         <li><p><b>Physics Flag:</b>
            <%= request.getParameter("physics")%>
         </p></li>
         <li><p><b>Chemistry Flag:</b>
            <%= request.getParameter("chemistry")%>
         </p></li>
      </ul>
   
   </body>
</html>

El programa anterior generará el siguiente resultado:

Reading Checkbox Data

      
 
       
Maths Flag :: on
 
       
Physics Flag:: null
 
       
Chemistry Flag:: on
 
      

Leer todos los parámetros de formulario

A continuación se muestra un ejemplo genérico que usa getParameterNames()método de HttpServletRequest para leer todos los parámetros de formulario disponibles. Este método devuelve una enumeración que contiene los nombres de los parámetros en un orden no especificado.

Una vez que tenemos una enumeración, podemos recorrer la enumeración de la manera estándar, usando el hasMoreElements() método para determinar cuándo detenerse y usar el nextElement() método para obtener el nombre de cada parámetro.

<%@ page import = "java.io.*,java.util.*" %>

<html>
   <head>
      <title>HTTP Header Request Example</title>
   </head>

   <body>
      <center>
         <h2>HTTP Header Request Example</h2>
         <table width = "100%" border = "1" align = "center">
            <tr bgcolor = "#949494">
               <th>Param Name</th>
               <th>Param Value(s)</th>
            </tr>
            <%
               Enumeration paramNames = request.getParameterNames();
               while(paramNames.hasMoreElements()) {
                  String paramName = (String)paramNames.nextElement();
                  out.print("<tr><td>" + paramName + "</td>\n");
                  String paramValue = request.getHeader(paramName);
                  out.println("<td> " + paramValue + "</td></tr>\n");
               }
            %>
         </table>
      </center>
   
   </body>
</html>

A continuación se muestra el contenido de la Hello.htm -

<html>
   <body>
      
      <form action = "main.jsp" method = "POST" target = "_blank">
         <input type = "checkbox" name = "maths" checked = "checked" /> Maths
         <input type = "checkbox" name = "physics"  /> Physics
         <input type = "checkbox" name = "chemistry" checked = "checked" /> Chem
         <input type = "submit" value = "Select Subject" />
      </form>
   
   </body>
</html>

Ahora intente llamar a JSP usando el Hello.htm anterior; esto generaría un resultado similar al siguiente en función de la entrada proporcionada:

Leer todos los parámetros de formulario

Nombre de parámetro	Valor (es) de parámetro
matemáticas	en
química	en

Puede probar el JSP anterior para leer los datos de cualquier otro formulario que tenga otros objetos como cuadro de texto, botón de opción o menú desplegable, etc.

En este capítulo, analizaremos los filtros en JSP. Los filtros de servlet y JSP son clases de Java que se pueden utilizar en la programación de servlet y JSP para los siguientes fines:

• Para interceptar solicitudes de un cliente antes de que accedan a un recurso en el back-end.

• Para manipular las respuestas del servidor antes de que se envíen de vuelta al cliente.

Hay varios tipos de filtros sugeridos por las especificaciones:

• Filtros de autenticación
• Filtros de compresión de datos
• Filtros de cifrado
• Filtros que desencadenan eventos de acceso a recursos
• Filtros de conversión de imágenes
• Filtros de registro y auditoría
• Filtros de cadena MIME-TYPE
• Filtros de tokenización
• Filtros XSL / T que transforman el contenido XML

Los filtros se implementan en el archivo descriptor de implementación web.xmly luego mapear a nombres de servlet o JSP o patrones de URL en el descriptor de implementación de su aplicación. El archivo descriptor de implementación web.xml se puede encontrar en el directorio <Tomcat-installation-directory> \ conf .

Cuando el contenedor JSP inicia su aplicación web, crea una instancia de cada filtro que haya declarado en el descriptor de implementación. Los filtros se ejecutan en el orden en que se declaran en el descriptor de implementación.

Métodos de filtro de servlet

Un filtro es simplemente una clase Java que implementa la javax.servlet.Filterinterfaz. La interfaz javax.servlet.Filter define tres métodos:

S.No.	Método y descripción
1	public void doFilter (ServletRequest, ServletResponse, FilterChain) El contenedor llama a este método cada vez que se pasa un par de solicitud / respuesta a través de la cadena debido a una solicitud del cliente de un recurso al final de la cadena.
2	public void init(FilterConfig filterConfig) El contenedor web llama a este método para indicar a un filtro que se está poniendo en servicio.
3	public void destroy() El contenedor web llama a este método para indicar a un filtro que se está poniendo fuera de servicio.

Ejemplo de filtro JSP

El siguiente ejemplo muestra cómo imprimir la dirección IP del cliente y la fecha y hora actual, cada vez que accedería a cualquier archivo JSP. Este ejemplo le dará una comprensión básica del filtro JSP, pero puede escribir aplicaciones de filtro más sofisticadas utilizando el mismo concepto:

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
 
// Implements Filter class
public class LogFilter implements Filter  {
   public void  init(FilterConfig config) throws ServletException {
      // Get init parameter 
      String testParam = config.getInitParameter("test-param"); 
 
      //Print the init parameter 
      System.out.println("Test Param: " + testParam); 
   }
   public void  doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
      throws java.io.IOException, ServletException {
      
      // Get the IP address of client machine.   
      String ipAddress = request.getRemoteAddr();
      
      // Log the IP address and current timestamp.
      System.out.println("IP "+ ipAddress + ", Time "+ new Date().toString());
      
      // Pass request back down the filter chain
      chain.doFilter(request,response);
   }
   public void destroy( ) {
      /* Called before the Filter instance is removed 
      from service by the web container*/
   }
}

Compilar LogFilter.java de la forma habitual y pon tu LogFilter.class presentar en <Tomcat-installation-directory>/webapps/ROOT/WEB-INF/classes.

Asignación de filtros JSP en Web.xml

Los filtros se definen y luego se asignan a una URL o nombre de archivo JSP, de la misma manera que se define Servlet y luego se asigna a un patrón de URL en web.xmlarchivo. Cree la siguiente entrada para la etiqueta de filtro en el archivo descriptor de implementaciónweb.xml

<filter>
   <filter-name>LogFilter</filter-name>
   <filter-class>LogFilter</filter-class>
   
   <init-param>
      <param-name>test-param</param-name>
      <param-value>Initialization Paramter</param-value>
   </init-param>
</filter>

<filter-mapping>
   <filter-name>LogFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>

El filtro anterior se aplicará a todos los servlets y JSP porque especificamos /*en nuestra configuración. Puede especificar un servlet particular o la ruta JSP si desea aplicar un filtro en algunos servlets o solo en JSP.

Ahora intente llamar a cualquier servlet o JSP y verá el registro generado en el registro del servidor web. Puedes usarLog4J logger para registrar el registro anterior en un archivo separado.

Usar varios filtros

Su aplicación web puede definir varios filtros diferentes con un propósito específico. Considere que define dos filtros AuthenFilter y LogFilter . El resto del proceso seguirá siendo como se explicó anteriormente, excepto que necesita crear un mapeo diferente como se menciona a continuación:

<filter>
   <filter-name>LogFilter</filter-name>
   <filter-class>LogFilter</filter-class>
   
   <init-param>
      <param-name>test-param</param-name>
      <param-value>Initialization Paramter</param-value>
   </init-param>
</filter>
 
<filter>
   <filter-name>AuthenFilter</filter-name>
   <filter-class>AuthenFilter</filter-class>
   <init-param>
      <param-name>test-param</param-name>
      <param-value>Initialization Paramter</param-value>
   </init-param>
</filter>
 
<filter-mapping>
   <filter-name>LogFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>
 
<filter-mapping>
   <filter-name>AuthenFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>

Orden de aplicación de filtros

El orden de los elementos de mapeo de filtros en web.xml determina el orden en el que el contenedor web aplica el filtro al servlet o JSP. Para invertir el orden del filtro, solo necesita invertir los elementos de mapeo de filtro en elweb.xml archivo.

Por ejemplo, el ejemplo anterior aplicará LogFilter primero y luego aplicará AuthenFilter a cualquier servlet o JSP; el siguiente ejemplo invertirá el orden:

<filter-mapping>
   <filter-name>AuthenFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>
 
<filter-mapping>
   <filter-name>LogFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>

En este capítulo, analizaremos el manejo de cookies en JSP. Las cookies son archivos de texto almacenados en la computadora del cliente y se guardan para varios propósitos de rastreo de información. JSP admite de forma transparente las cookies HTTP utilizando tecnología de servlet subyacente.

Hay tres pasos involucrados en la identificación y retorno de los usuarios:

• La secuencia de comandos del servidor envía un conjunto de cookies al navegador. Por ejemplo, nombre, edad o número de identificación, etc.

• El navegador almacena esta información en la máquina local para uso futuro.

• Cuando la próxima vez que el navegador envía una solicitud al servidor web, envía la información de las cookies al servidor y el servidor utiliza esa información para identificar al usuario o puede ser también para algún otro propósito.

Este capítulo le enseñará cómo configurar o restablecer cookies, cómo acceder a ellas y cómo eliminarlas utilizando programas JSP.

La anatomía de una galleta

Las cookies generalmente se establecen en un encabezado HTTP (aunque JavaScript también puede configurar una cookie directamente en un navegador). Una JSP que establece una cookie puede enviar encabezados que se parecen a esto:

HTTP/1.1 200 OK
Date: Fri, 04 Feb 2000 21:03:38 GMT
Server: Apache/1.3.9 (UNIX) PHP/4.0b3
Set-Cookie: name = xyz; expires = Friday, 04-Feb-07 22:03:38 GMT; 
   path = /; domain = tutorialspoint.com
Connection: close
Content-Type: text/html

Como puede ver, el Set-Cookie header contiene a name value pair, a GMT date, a path y a domain. El nombre y el valor estarán codificados en URL. losexpires campo es una instrucción para el navegador para "forget" la cookie después de la fecha y hora indicadas.

Si el navegador está configurado para almacenar cookies, conservará esta información hasta la fecha de caducidad. Si el usuario apunta el navegador a cualquier página que coincida con la ruta y el dominio de la cookie, reenviará la cookie al servidor. Los encabezados del navegador pueden verse así:

GET / HTTP/1.0
Connection: Keep-Alive
User-Agent: Mozilla/4.6 (X11; I; Linux 2.2.6-15apmac ppc)
Host: zink.demon.co.uk:1126

Accept: image/gif, */*
Accept-Encoding: gzip
Accept-Language: en
Accept-Charset: iso-8859-1,*,utf-8
Cookie: name = xyz

Un script JSP tendrá acceso a las cookies a través del método de solicitud. request.getCookies()que devuelve una matriz de objetos Cookie .

Métodos de cookies de servlet

La siguiente tabla enumera los métodos útiles asociados con el objeto Cookie que puede usar mientras manipula cookies en JSP:

S.No.	Método y descripción
1	public void setDomain(String pattern) Este método establece el dominio al que se aplica la cookie; por ejemplo, tutorialspoint.com.
2	public String getDomain() Este método obtiene el dominio al que se aplica la cookie; por ejemplo, tutorialspoint.com.
3	public void setMaxAge(int expiry) Este método establece cuánto tiempo (en segundos) debe transcurrir antes de que caduque la cookie. Si no configura esto, la cookie durará solo durante la sesión actual.
4	public int getMaxAge() Este método devuelve la edad máxima de la cookie, especificada en segundos, por defecto, -1 lo que indica que la cookie persistirá hasta que se apague el navegador.
5	public String getName() Este método devuelve el nombre de la cookie. El nombre no se puede cambiar después de la creación.
6	public void setValue(String newValue) Este método establece el valor asociado con la cookie.
7	public String getValue() Este método obtiene el valor asociado con la cookie.
8	public void setPath(String uri) Este método establece la ruta a la que se aplica esta cookie. Si no especifica una ruta, la cookie se devuelve para todas las URL en el mismo directorio que la página actual, así como para todos los subdirectorios.
9	public String getPath() Este método obtiene la ruta a la que se aplica esta cookie.
10	public void setSecure(boolean flag) Este método establece el valor booleano que indica si la cookie solo debe enviarse a través de conexiones cifradas (es decir, SSL).
11	public void setComment(String purpose) Este método especifica un comentario que describe el propósito de una cookie. El comentario es útil si el navegador presenta la cookie al usuario.
12	public String getComment() Este método devuelve el comentario que describe el propósito de esta cookie, o nulo si la cookie no tiene comentarios.

Configuración de cookies con JSP

La configuración de cookies con JSP implica tres pasos:

Paso 1: crear un objeto Cookie

Llamas al constructor de cookies con un nombre de cookie y un valor de cookie, los cuales son cadenas.

Cookie cookie = new Cookie("key","value");

Tenga en cuenta que ni el nombre ni el valor deben contener espacios en blanco ni ninguno de los siguientes caracteres:

[ ] ( ) = , " / ? @ : ;

Paso 2: Establecer la edad máxima

Tu usas setMaxAgepara especificar cuánto tiempo (en segundos) debe ser válida la cookie. El siguiente código configurará una cookie durante 24 horas.

cookie.setMaxAge(60*60*24);

Paso 3: enviar la cookie a los encabezados de respuesta HTTP

Tu usas response.addCookie para agregar cookies en el encabezado de respuesta HTTP de la siguiente manera

response.addCookie(cookie);

Ejemplo

Modifiquemos nuestro Ejemplo de formulario para configurar las cookies para el nombre y apellido.

<%
   // Create cookies for first and last names.      
   Cookie firstName = new Cookie("first_name", request.getParameter("first_name"));
   Cookie lastName = new Cookie("last_name", request.getParameter("last_name"));
   
   // Set expiry date after 24 Hrs for both the cookies.
   firstName.setMaxAge(60*60*24); 
   lastName.setMaxAge(60*60*24); 
   
   // Add both the cookies in the response header.
   response.addCookie( firstName );
   response.addCookie( lastName );
%>

<html>
   <head>
      <title>Setting Cookies</title>
   </head>
   
   <body>
      <center>
         <h1>Setting Cookies</h1>
      </center>
      <ul>
         <li><p><b>First Name:</b>
            <%= request.getParameter("first_name")%>
         </p></li>
         <li><p><b>Last  Name:</b>
            <%= request.getParameter("last_name")%>
         </p></li>
      </ul>
   
   </body>
</html>

Pongamos el código anterior en main.jsp archivo y utilícelo en la siguiente página HTML:

<html>
   <body>
      
      <form action = "main.jsp" method = "GET">
         First Name: <input type = "text" name = "first_name">
         <br />
         Last Name: <input type = "text" name = "last_name" />
         <input type = "submit" value = "Submit" />
      </form>
      
   </body>
</html>

Mantenga el contenido HTML anterior en un archivo hello.jsp y pon hello.jsp y main.jsp en <Tomcat-installation-directory>/webapps/ROOTdirectorio. Cuando accederáshttp://localhost:8080/hello.jsp, aquí está la salida real del formulario anterior.

Intente ingresar el Nombre y el Apellido y luego haga clic en el botón Enviar. Esto mostrará el nombre y el apellido en su pantalla y también establecerá dos cookiesfirstName y lastName. Estas cookies se devolverán al servidor la próxima vez que haga clic en el botón Enviar.

En la siguiente sección, explicaremos cómo puede acceder a estas cookies en su aplicación web.

Leer cookies con JSP

Para leer las cookies, debe crear una matriz de objetos javax.servlet.http.Cookie llamando algetCookies( )método de HttpServletRequest . Luego recorre la matriz y usagetName() y getValue() métodos para acceder a cada cookie y valor asociado.

Ejemplo

Leamos ahora las cookies que se establecieron en el ejemplo anterior:

<html>
   <head>
      <title>Reading Cookies</title>
   </head>
   
   <body>
      <center>
         <h1>Reading Cookies</h1>
      </center>
      <%
         Cookie cookie = null;
         Cookie[] cookies = null;
         
         // Get an array of Cookies associated with the this domain
         cookies = request.getCookies();
         
         if( cookies != null ) {
            out.println("<h2> Found Cookies Name and Value</h2>");
            
            for (int i = 0; i < cookies.length; i++) {
               cookie = cookies[i];
               out.print("Name : " + cookie.getName( ) + ",  ");
               out.print("Value: " + cookie.getValue( )+" <br/>");
            }
         } else {
            out.println("<h2>No cookies founds</h2>");
         }
      %>
   </body>
   
</html>

Pongamos ahora el código anterior en main.jsparchivo e intente acceder a él. Si configura elfirst_name cookie como "John" y el last_name cookie como "Jugador" y luego ejecuta http://localhost:8080/main.jsp mostrará el siguiente resultado:

 Found Cookies Name and Value
Name : first_name, Value: John
Name : last_name, Value: Player

Eliminar cookies con JSP

Eliminar las cookies es muy sencillo. Si desea eliminar una cookie, simplemente debe seguir estos tres pasos:

• Leer una cookie ya existente y almacenarla en el objeto Cookie.

• Establezca la edad de la cookie como cero usando el setMaxAge() método para eliminar una cookie existente.

• Vuelva a agregar esta cookie al encabezado de respuesta.

Ejemplo

El siguiente ejemplo le mostrará cómo eliminar una cookie existente llamada "first_name" y cuando ejecute main.jsp JSP la próxima vez, devolverá un valor nulo para first_name.

<html>
   <head>
      <title>Reading Cookies</title>
   </head>
   
   <body>
      <center>
         <h1>Reading Cookies</h1>
      </center>
      <%
         Cookie cookie = null;
         Cookie[] cookies = null;
         
         // Get an array of Cookies associated with the this domain
         cookies = request.getCookies();
         
         if( cookies != null ) {
            out.println("<h2> Found Cookies Name and Value</h2>");
            
            for (int i = 0; i < cookies.length; i++) {
               cookie = cookies[i];
               
               if((cookie.getName( )).compareTo("first_name") == 0 ) {
                  cookie.setMaxAge(0);
                  response.addCookie(cookie);
                  out.print("Deleted cookie: " + 
                  cookie.getName( ) + "<br/>");
               }
               out.print("Name : " + cookie.getName( ) + ",  ");
               out.print("Value: " + cookie.getValue( )+" <br/>");
            }
         } else {
            out.println(
            "<h2>No cookies founds</h2>");
         }
      %>
   </body>
   
</html>

Pongamos ahora el código anterior en el main.jsparchivo e intente acceder a él. Mostrará el siguiente resultado:

Cookies Name and Value
Deleted cookie : first_name
Name : first_name, Value: John
Name : last_name, Value: Player

Ahora ejecute http: // localhost: 8080 / main.jsp una vez más y debería mostrar solo una cookie de la siguiente manera:

 Found Cookies Name and Value
Name : last_name,  Value: Player

Puede eliminar sus cookies en Internet Explorer manualmente. Comience en el menú Herramientas y seleccione Opciones de Internet. Para eliminar todas las cookies, haga clic en el botón Eliminar cookies.

En este capítulo, discutiremos el seguimiento de sesiones en JSP. HTTP es un protocolo "sin estado", lo que significa que cada vez que un cliente recupera una página web, el cliente abre una conexión separada al servidor web y el servidor automáticamente no guarda ningún registro de la solicitud anterior del cliente.

Mantenimiento de la sesión entre el cliente web y el servidor

Analicemos ahora algunas opciones para mantener la sesión entre el cliente web y el servidor web:

Galletas

Un servidor web puede asignar un ID de sesión único como una cookie a cada cliente web y para las solicitudes posteriores del cliente, pueden ser reconocidos utilizando la cookie recibida.

Es posible que esta no sea una forma eficaz, ya que el navegador a veces no admite cookies. No se recomienda utilizar este procedimiento para mantener las sesiones.

Campos de formulario ocultos

Un servidor web puede enviar un campo de formulario HTML oculto junto con una ID de sesión única de la siguiente manera:

<input type = "hidden" name = "sessionid" value = "12345">

Esta entrada significa que, cuando se envía el formulario, el nombre y el valor especificados se incluyen automáticamente en el GET o la POSTdatos. Cada vez que el navegador web devuelve la solicitud, elsession_id value se puede utilizar para realizar un seguimiento de diferentes navegadores web.

Esta puede ser una forma eficaz de realizar un seguimiento de la sesión, pero al hacer clic en un enlace de hipertexto normal (<A HREF...>) no se envía un formulario, por lo que los campos de formulario ocultos tampoco pueden admitir el seguimiento general de la sesión.

Reescritura de URL

Puede agregar algunos datos adicionales al final de cada URL. Estos datos identifican la sesión; el servidor puede asociar ese identificador de sesión con los datos que ha almacenado sobre esa sesión.

Por ejemplo, con http://tutorialspoint.com/file.htm;sessionid=12345, el identificador de sesión se adjunta como sessionid = 12345 al que se puede acceder en el servidor web para identificar al cliente.

La reescritura de URL es una mejor manera de mantener sesiones y funciona para los navegadores cuando no admiten cookies. El inconveniente aquí es que tendrá que generar cada URL de forma dinámica para asignar una ID de sesión, aunque la página es una página HTML estática simple.

El objeto de la sesión

Aparte de las opciones mencionadas anteriormente, JSP hace uso de la interfaz HttpSession proporcionada por el servlet. Esta interfaz proporciona una forma de identificar a un usuario.

• una solicitud de una página o
• visita a un sitio web o
• almacenar información sobre ese usuario

De forma predeterminada, las JSP tienen habilitado el seguimiento de sesiones y se crea una instancia de un nuevo objeto HttpSession para cada nuevo cliente automáticamente. Para deshabilitar el seguimiento de sesiones, es necesario desactivarlo explícitamente estableciendo el atributo de sesión de directiva de página en falso de la siguiente manera:

<%@ page session = "false" %>

El motor JSP expone el objeto HttpSession al autor JSP a través de la implícita sessionobjeto. Ya quesession El objeto ya está provisto al programador JSP, el programador puede comenzar a almacenar y recuperar datos inmediatamente del objeto sin ninguna inicialización o getSession().

A continuación, se muestra un resumen de los métodos importantes disponibles a través del objeto de sesión:

S.No.	Método y descripción
1	public Object getAttribute(String name) Este método devuelve el objeto vinculado con el nombre especificado en esta sesión, o nulo si no hay ningún objeto vinculado con el nombre.
2	public Enumeration getAttributeNames() Este método devuelve una Enumeración de objetos String que contiene los nombres de todos los objetos vinculados a esta sesión.
3	public long getCreationTime() Este método devuelve la hora en la que se creó esta sesión, medida en milisegundos desde la medianoche del 1 de enero de 1970 GMT.
4	public String getId() Este método devuelve una cadena que contiene el identificador único asignado a esta sesión.
5	public long getLastAccessedTime() Este método devuelve la última vez que el cliente envió una solicitud asociada con esta sesión, como el número de milisegundos desde la medianoche del 1 de enero de 1970 GMT.
6	public int getMaxInactiveInterval() Este método devuelve el intervalo de tiempo máximo, en segundos, que el contenedor de servlets mantendrá abierta esta sesión entre accesos de clientes.
7	public void invalidate() Este método invalida esta sesión y desvincula cualquier objeto vinculado a ella.
8	public boolean isNew() Este método devuelve verdadero si el cliente aún no conoce la sesión o si el cliente elige no unirse a la sesión.
9	public void removeAttribute(String name) Este método elimina el objeto vinculado con el nombre especificado de esta sesión.
10	public void setAttribute(String name, Object value) Este método vincula un objeto a esta sesión, utilizando el nombre especificado.
11	public void setMaxInactiveInterval(int interval) Este método especifica el tiempo, en segundos, entre las solicitudes del cliente antes de que el contenedor de servlets invalide esta sesión.

Ejemplo de seguimiento de sesiones

Este ejemplo describe cómo utilizar el objeto HttpSession para averiguar la hora de creación y la hora de último acceso para una sesión. Asociaríamos una nueva sesión con la solicitud si aún no existe una.

<%@ page import = "java.io.*,java.util.*" %>
<%
   // Get session creation time.
   Date createTime = new Date(session.getCreationTime());
   
   // Get last access time of this Webpage.
   Date lastAccessTime = new Date(session.getLastAccessedTime());

   String title = "Welcome Back to my website";
   Integer visitCount = new Integer(0);
   String visitCountKey = new String("visitCount");
   String userIDKey = new String("userID");
   String userID = new String("ABCD");

   // Check if this is new comer on your Webpage.
   if (session.isNew() ){
      title = "Welcome to my website";
      session.setAttribute(userIDKey, userID);
      session.setAttribute(visitCountKey,  visitCount);
   } 
   visitCount = (Integer)session.getAttribute(visitCountKey);
   visitCount = visitCount + 1;
   userID = (String)session.getAttribute(userIDKey);
   session.setAttribute(visitCountKey,  visitCount);
%>

<html>
   <head>
      <title>Session Tracking</title>
   </head>
   
   <body>
      <center>
         <h1>Session Tracking</h1>
      </center>
      
      <table border = "1" align = "center"> 
         <tr bgcolor = "#949494">
            <th>Session info</th>
            <th>Value</th>
         </tr> 
         <tr>
            <td>id</td>
            <td><% out.print( session.getId()); %></td>
         </tr> 
         <tr>
            <td>Creation Time</td>
            <td><% out.print(createTime); %></td>
         </tr> 
         <tr>
            <td>Time of Last Access</td>
            <td><% out.print(lastAccessTime); %></td>
         </tr> 
         <tr>
            <td>User ID</td>
            <td><% out.print(userID); %></td>
         </tr> 
         <tr>
            <td>Number of visits</td>
            <td><% out.print(visitCount); %></td>
         </tr> 
      </table> 
   
   </body>
</html>

Ahora ponga el código anterior en main.jsp e intenta acceder http://localhost:8080/main.jsp. Una vez que ejecute la URL, recibirá el siguiente resultado:

Bienvenidos a mi sitio web

Session Information

Información de la sesión	valor
carné de identidad	0AE3EC93FF44E3C525B4351B77ABB2D5
Tiempo de creación	Martes 08 de junio 17:26:40 GMT + 04: 00 2010
Hora del último acceso	Martes 08 de junio 17:26:40 GMT + 04: 00 2010
ID de usuario	A B C D
Número de visitas	0

Ahora intente ejecutar el mismo JSP por segunda vez, recibirá el siguiente resultado.

Bienvenido de nuevo a mi sitio web

Session Information

tipo de información	valor
carné de identidad	0AE3EC93FF44E3C525B4351B77ABB2D5
Tiempo de creación	Martes 08 de junio 17:26:40 GMT + 04: 00 2010
Hora del último acceso	Martes 08 de junio 17:26:40 GMT + 04: 00 2010
ID de usuario	A B C D
Número de visitas	1

Eliminar datos de la sesión

Cuando haya terminado con los datos de sesión de un usuario, tiene varias opciones:

• Remove a particular attribute - Puedes llamar al public void removeAttribute(String name) método para eliminar el valor asociado con una clave en particular.

• Delete the whole session - Puedes llamar al public void invalidate() método para descartar una sesión completa.

• Setting Session timeout - Puedes llamar al public void setMaxInactiveInterval(int interval) método para establecer el tiempo de espera para una sesión individualmente.

• Log the user out - Los servidores que admiten servlets 2.4, puede llamar logout para cerrar la sesión del cliente en el servidor web e invalidar todas las sesiones que pertenecen a todos los usuarios.

• web.xml Configuration - Si está utilizando Tomcat, además de los métodos mencionados anteriormente, puede configurar el tiempo de espera de la sesión en el archivo web.xml de la siguiente manera.

<session-config>
   <session-timeout>15</session-timeout>
</session-config>

El tiempo de espera se expresa en minutos y anula el tiempo de espera predeterminado, que es de 30 minutos en Tomcat.

los getMaxInactiveInterval( )El método en un servlet devuelve el período de tiempo de espera para esa sesión en segundos. Entonces, si su sesión está configurada en web.xml durante 15 minutos,getMaxInactiveInterval( ) devuelve 900.

En este capítulo, analizaremos la carga de archivos en JSP. Se puede usar una JSP con una etiqueta de formulario HTML para permitir a los usuarios cargar archivos al servidor. Un archivo cargado puede ser un archivo de texto o un archivo binario o de imagen o simplemente cualquier documento.

Crear un formulario de carga de archivos

Ahora entendamos cómo crear un formulario de carga de archivos. El siguiente código HTML crea un formulario de carga. Los siguientes son los puntos importantes que se deben anotar:

• La forma method el atributo debe establecerse en POST El método y el método GET no se pueden utilizar.

• La forma enctype el atributo debe establecerse en multipart/form-data.

• La forma actionEl atributo debe establecerse en un archivo JSP que manejaría la carga de archivos en el servidor backend. El siguiente ejemplo está usandouploadFile.jsp archivo de programa para cargar el archivo.

• Para cargar un solo archivo, debe usar un solo <input .../> etiqueta con atributo type = "file". Para permitir la carga de varios archivos, incluya más de una etiqueta de entrada con diferentes valores para el atributo de nombre. El navegador asocia un botón Examinar con cada uno de ellos.

<html>
   <head>
      <title>File Uploading Form</title>
   </head>
   
   <body>
      <h3>File Upload:</h3>
      Select a file to upload: <br />
      <form action = "UploadServlet" method = "post"
         enctype = "multipart/form-data">
         <input type = "file" name = "file" size = "50" />
         <br />
         <input type = "submit" value = "Upload File" />
      </form>
   </body>
   
</html>

Esto mostrará el siguiente resultado. Ahora puede seleccionar un archivo de la PC local y cuando el usuario hace clic en "Cargar archivo", el formulario se envía junto con el archivo seleccionado.

File Upload − 
Select a file to upload −
 
 

 
 

NOTE - El formulario anterior es solo un formulario ficticio y no funcionaría, debe probar el código anterior en su máquina para que funcione.

Escritura de secuencia de comandos JSP de backend

Definamos ahora una ubicación donde se almacenarán los archivos cargados. Puede codificar esto en su programa o este nombre de directorio también se puede agregar usando una configuración externa como uncontext-param elemento en web.xml de la siguiente manera:

<web-app>
....
<context-param> 
   <description>Location to store uploaded file</description> 
   <param-name>file-upload</param-name> 
   <param-value>
      c:\apache-tomcat-5.5.29\webapps\data\
   </param-value> 
</context-param>
....
</web-app>

A continuación se muestra el código fuente de UploadFile.jsp. Esto puede manejar la carga de varios archivos a la vez. Consideremos ahora lo siguiente antes de continuar con la carga de archivos.

• El siguiente ejemplo depende de FileUpload; asegúrese de tener la última versión decommons-fileupload.x.x.jararchivo en su classpath. Puedes descargarlo desdehttps://commons.apache.org/fileupload/.

• FileUpload depende de Commons IO; asegúrese de tener la última versión decommons-io-x.x.jararchivo en su classpath. Puedes descargarlo desdehttps://commons.apache.org/io/.

• Mientras prueba el siguiente ejemplo, debe cargar un archivo que tenga un tamaño menor que maxFileSize; de ​​lo contrario, el archivo no se cargará.

• Asegúrese de haber creado directorios c:\temp y c:\apache-tomcat5.5.29\webapps\data con mucha antelación.

<%@ page import = "java.io.*,java.util.*, javax.servlet.*" %>
<%@ page import = "javax.servlet.http.*" %>
<%@ page import = "org.apache.commons.fileupload.*" %>
<%@ page import = "org.apache.commons.fileupload.disk.*" %>
<%@ page import = "org.apache.commons.fileupload.servlet.*" %>
<%@ page import = "org.apache.commons.io.output.*" %>

<%
   File file ;
   int maxFileSize = 5000 * 1024;
   int maxMemSize = 5000 * 1024;
   ServletContext context = pageContext.getServletContext();
   String filePath = context.getInitParameter("file-upload");

   // Verify the content type
   String contentType = request.getContentType();
   
   if ((contentType.indexOf("multipart/form-data") >= 0)) {
      DiskFileItemFactory factory = new DiskFileItemFactory();
      // maximum size that will be stored in memory
      factory.setSizeThreshold(maxMemSize);
      
      // Location to save data that is larger than maxMemSize.
      factory.setRepository(new File("c:\\temp"));

      // Create a new file upload handler
      ServletFileUpload upload = new ServletFileUpload(factory);
      
      // maximum file size to be uploaded.
      upload.setSizeMax( maxFileSize );
      
      try { 
         // Parse the request to get file items.
         List fileItems = upload.parseRequest(request);

         // Process the uploaded file items
         Iterator i = fileItems.iterator();

         out.println("<html>");
         out.println("<head>");
         out.println("<title>JSP File upload</title>");  
         out.println("</head>");
         out.println("<body>");
         
         while ( i.hasNext () ) {
            FileItem fi = (FileItem)i.next();
            if ( !fi.isFormField () ) {
               // Get the uploaded file parameters
               String fieldName = fi.getFieldName();
               String fileName = fi.getName();
               boolean isInMemory = fi.isInMemory();
               long sizeInBytes = fi.getSize();
            
               // Write the file
               if( fileName.lastIndexOf("\\") >= 0 ) {
                  file = new File( filePath + 
                  fileName.substring( fileName.lastIndexOf("\\"))) ;
               } else {
                  file = new File( filePath + 
                  fileName.substring(fileName.lastIndexOf("\\")+1)) ;
               }
               fi.write( file ) ;
               out.println("Uploaded Filename: " + filePath + 
               fileName + "<br>");
            }
         }
         out.println("</body>");
         out.println("</html>");
      } catch(Exception ex) {
         System.out.println(ex);
      }
   } else {
      out.println("<html>");
      out.println("<head>");
      out.println("<title>Servlet upload</title>");  
      out.println("</head>");
      out.println("<body>");
      out.println("<p>No file uploaded</p>"); 
      out.println("</body>");
      out.println("</html>");
   }
%>

Ahora intente cargar archivos utilizando el formulario HTML que creó anteriormente. Cuando lo intentashttp://localhost:8080/UploadFile.htm, mostrará el siguiente resultado. Esto le ayudará a cargar cualquier archivo desde su máquina local.

File Upload − 
Select a file to upload −
 
 

 

Si su script JSP funciona bien, su archivo debe cargarse en c:\apache-tomcat5.5.29\webapps\data\ directorio.

En este capítulo, discutiremos cómo manejar datos en JSP. Una de las ventajas más importantes de usar JSP es que puede usar todos los métodos disponibles en el núcleo de Java. Lo llevaremos a través delDate clase que está disponible en el java.utilpaquete; esta clase encapsula la fecha y hora actuales.

La clase Date admite dos constructores. El primer constructor inicializa el objeto con la fecha y hora actuales.

Date( )

El siguiente constructor acepta un argumento que es igual al número de milisegundos que han transcurrido desde la medianoche del 1 de enero de 1970.

Date(long millisec)

Una vez que tenga un objeto Fecha disponible, puede llamar a cualquiera de los siguientes métodos de soporte para jugar con fechas:

S.No.	Métodos y descripción
1	boolean after(Date date) Devuelve verdadero si el objeto Date que invoca contiene una fecha posterior a la especificada por fecha; de lo contrario, devuelve falso.
2	boolean before(Date date) Devuelve verdadero si el objeto Date que invoca contiene una fecha anterior a la especificada por fecha; de lo contrario, devuelve falso.
3	Object clone( ) Duplica el objeto Date que invoca.
4	int compareTo(Date date) Compara el valor del objeto que invoca con el de la fecha. Devuelve 0 si los valores son iguales. Devuelve un valor negativo si el objeto que invoca es anterior a la fecha. Devuelve un valor positivo si el objeto que lo invoca es posterior a la fecha.
5	int compareTo(Object obj) Funciona de forma idéntica a compareTo (Date) si obj es de la clase Date. De lo contrario, arroja una ClassCastException.
6	boolean equals(Object date) Devuelve verdadero si el objeto Date que invoca contiene la misma hora y fecha que la especificada por fecha; de lo contrario, devuelve falso.
7	long getTime( ) Devuelve el número de milisegundos que han transcurrido desde el 1 de enero de 1970.
8	int hashCode( ) Devuelve un código hash para el objeto que lo invoca.
9	void setTime(long time) Establece la fecha y la hora especificadas por la hora, que representa un tiempo transcurrido en milisegundos desde la medianoche del 1 de enero de 1970.
10	String toString( ) Convierte el objeto Date que invoca en una cadena y devuelve el resultado.

Obtener fecha y hora actuales

Con el programa JSP, es muy fácil obtener la fecha y la hora actuales. Puede utilizar un objeto Date simple con eltoString() método para imprimir la fecha actual y la hora de la siguiente manera:

<%@ page import = "java.io.*,java.util.*, javax.servlet.*" %>

<html>
   <head>
      <title>Display Current Date & Time</title>
   </head>
   
   <body>
      <center>
         <h1>Display Current Date & Time</h1>
      </center>
      <%
         Date date = new Date();
         out.print( "<h2 align = \"center\">" +date.toString()+"</h2>");
      %>
   </body>
</html>

Ahora mantengamos el código en CurrentDate.jsp y luego llame a esta JSP usando la URL http://localhost:8080/CurrentDate.jsp. Recibirá el siguiente resultado:

Display Current Date & Time
Mon Jun 21 21:46:49 GMT+04:00 2010

Actualiza la página con el URL http://localhost:8080/CurrentDate.jsp. Encontrará la diferencia en segundos cada vez que actualice.

Comparación de fechas

Como se discutió en las secciones anteriores, puede usar todos los métodos Java disponibles en sus scripts JSP. En caso de que necesite comparar dos fechas, considere los siguientes métodos:

• Puedes usar getTime( ) para obtener el número de milisegundos que han transcurrido desde la medianoche del 1 de enero de 1970 para ambos objetos y luego comparar estos dos valores.

• Puedes usar los métodos before( ), after( )y equals( )porque el 12 del mes es anterior al 18; por ejemplo,new Date(99, 2, 12).before(new Date (99, 2, 18)) devuelve verdadero.

• Puedes usar el compareTo( )método; este método está definido por elComparable interface e implementado por fecha.

Formato de fecha usando SimpleDateFormat

SimpleDateFormat es una clase concreta para formatear y analizar fechas de manera sensible a la configuración regional. SimpleDateFormat le permite comenzar eligiendo cualquier patrón definido por el usuario para el formato de fecha y hora.

Modifiquemos el ejemplo anterior de la siguiente manera:

<%@ page import = "java.io.*,java.util.*" %>
<%@ page import = "javax.servlet.*,java.text.*" %>

<html>
   <head>
      <title>Display Current Date & Time</title>
   </head>
   
   <body>
      <center>
         <h1>Display Current Date & Time</h1>
      </center>
      <%
         Date dNow = new Date( );
         SimpleDateFormat ft = 
         new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
         out.print( "<h2 align=\"center\">" + ft.format(dNow) + "</h2>");
      %>
   </body>
</html>

Compile el servlet anterior una vez más y luego llame a este servlet usando la URL http://localhost:8080/CurrentDate. Recibirá el siguiente resultado:

Display Current Date & Time
Mon 2010.06.21 at 10:06:44 PM GMT+04:00

Códigos de formato de formato de fecha simple

Para especificar el formato de hora, utilice una cadena de patrón de tiempo. En este patrón, todas las letras ASCII se reservan como letras de patrón, que se definen de la siguiente manera:

Personaje	Descripción	Ejemplo
GRAMO	Designador de era	ANUNCIO
y	Año en cuatro dígitos	2001
METRO	Mes del año	Julio o 07
re	Día en mes	0
h	Hora en AM / PM (1 ~ 12)	2
H	Hora del día (0 ~ 23)	22
metro	Minuto en hora	30
s	Segundo en minuto	55
S	Milisegundo	234
mi	Día de la semana	martes
re	Día del año	360
F	Día de la semana en el mes	2 (segundo miércoles de julio)
w	Semana del año	40
W	Semana en mes
un	Marcador AM / PM	PM
k	Hora del día (1 ~ 24)	24
K	Hora en AM / PM (0 ~ 11)	0
z	Zona horaria	hora estándar del Este
'	Escape por texto	Delimitador
"	Una frase	'

Para obtener una lista completa de los métodos disponibles constantes para manipular la fecha, puede consultar la documentación estándar de Java.

En este capítulo, discutiremos la redirección de páginas con JSP. La redirección de página se usa generalmente cuando un documento se mueve a una nueva ubicación y necesitamos enviar al cliente a esta nueva ubicación. Esto puede deberse al equilibrio de carga o a una simple aleatorización.

La forma más sencilla de redirigir una solicitud a otra página es mediante sendRedirect()método de objeto de respuesta. A continuación se muestra la firma de este método:

public void response.sendRedirect(String location)
throws IOException

Este método envía la respuesta al navegador junto con el código de estado y la ubicación de la nueva página. También puede utilizar elsetStatus() y el setHeader() métodos juntos para lograr el mismo ejemplo de redirección -

....
String site = "http://www.newpage.com" ;
response.setStatus(response.SC_MOVED_TEMPORARILY);
response.setHeader("Location", site); 
....

Ejemplo

Este ejemplo muestra cómo una JSP realiza la redirección de página a otra ubicación:

<%@ page import = "java.io.*,java.util.*" %>

<html>
   <head>
      <title>Page Redirection</title>
   </head>
   
   <body>
      <center>
         <h1>Page Redirection</h1>
      </center>
      <%
         // New location to be redirected
         String site = new String("http://www.photofuntoos.com");
         response.setStatus(response.SC_MOVED_TEMPORARILY);
         response.setHeader("Location", site); 
      %>
   </body>
</html>

Pongamos ahora el código anterior en PageRedirect.jsp y llamemos a este JSP usando la URL http://localhost:8080/PageRedirect.jsp. Esto lo llevará a la URL proporcionadahttp://www.photofuntoos.com.

En este capítulo, discutiremos Hits Counter en JSP. Un contador de visitas le informa sobre el número de visitas en una página en particular de su sitio web. Por lo general, adjunta un contador de visitas con su página index.jsp asumiendo que las personas llegan primero a su página de inicio.

Para implementar un contador de visitas, puede hacer uso del objeto Application Implicit y los métodos asociados. getAttribute() y setAttribute().

Este objeto es una representación de la página JSP durante todo su ciclo de vida. Este objeto se crea cuando se inicializa la página JSP y se eliminará cuando la página JSP sea eliminada por eljspDestroy() método.

A continuación se muestra la sintaxis para establecer una variable a nivel de aplicación:

application.setAttribute(String Key, Object Value);

Puede utilizar el método anterior para establecer una variable de contador de visitas y restablecer la misma variable. A continuación se muestra el método para leer la variable establecida por el método anterior:

application.getAttribute(String Key);

Cada vez que un usuario accede a su página, puede leer el valor actual del contador de visitas y aumentarlo en uno y volver a configurarlo para uso futuro.

Ejemplo

Este ejemplo muestra cómo puede usar JSP para contar el número total de visitas en una página en particular. Si desea contar el número total de visitas de su sitio web, deberá incluir el mismo código en todas las páginas JSP.

<%@ page import = "java.io.*,java.util.*" %>

<html>
   <head>
      <title>Application object in JSP</title>
   </head>
   
   <body>
      <%
         Integer hitsCount = (Integer)application.getAttribute("hitCounter");
         if( hitsCount ==null || hitsCount == 0 ) {
            /* First visit */
            out.println("Welcome to my website!");
            hitsCount = 1;
         } else {
            /* return visit */
            out.println("Welcome back to my website!");
            hitsCount += 1;
         }
         application.setAttribute("hitCounter", hitsCount);
      %>
      <center>
         <p>Total number of visits: <%= hitsCount%></p>
      </center>
   
   </body>
</html>

Pongamos ahora el código anterior en main.jsp y llamar a esta JSP usando la URL http://localhost:8080/main.jsp. Esto mostrará el valor del contador de visitas que aumenta a medida que actualiza la página. Puede intentar acceder a la página utilizando diferentes navegadores y encontrará que el contador de visitas seguirá aumentando con cada visita y recibirá el resultado de la siguiente manera:

 
       
Welcome back to my website!
 
       
Total number of visits: 12
 
      

Reinicio del contador de visitas

¿Qué ocurre cuando reinicia su aplicación, es decir, el servidor web, esto restablecerá la variable de su aplicación y su contador se restablecerá a cero? Para evitar esta pérdida, considere los siguientes puntos:

• Defina una tabla de base de datos con un solo recuento, digamos hitcount. Asígnele un valor cero.

• Con cada visita, lea la tabla para obtener el valor del recuento de visitas.

• Aumente el valor del recuento de visitas en uno y actualice la tabla con un nuevo valor.

• Muestra el nuevo valor del recuento de visitas como recuento total de visitas a la página

• Si desea contar las visitas de todas las páginas, implemente la lógica anterior para todas las páginas.

En este capítulo, analizaremos la actualización automática en JSP. Considere una página web que muestre la puntuación del juego en vivo o el estado del mercado de valores o la ración de cambio de moneda. Para todos estos tipos de páginas, necesitaría actualizar su página web regularmente usando el botón de actualización o recarga de su navegador.

JSP facilita este trabajo al proporcionarle un mecanismo en el que puede crear una página web de tal manera que se actualice automáticamente después de un intervalo determinado.

La forma más sencilla de actualizar una página web es mediante el setIntHeader()método del objeto de respuesta. A continuación se muestra la firma de este método:

public void setIntHeader(String header, int headerValue)

Este método devuelve el encabezado "Actualizar" al navegador junto con un valor entero que indica el intervalo de tiempo en segundos.

Ejemplo de actualización automática de página

En el siguiente ejemplo, usaremos el setIntHeader() método para configurar Refreshencabezamiento. Esto ayudará a simular un reloj digital.

<%@ page import = "java.io.*,java.util.*" %>

<html>
   <head>
      <title>Auto Refresh Header Example</title>
   </head>
   
   <body>
      <center>
         <h2>Auto Refresh Header Example</h2>
         <%
            // Set refresh, autoload time as 5 seconds
            response.setIntHeader("Refresh", 5);
            
            // Get current time
            Calendar calendar = new GregorianCalendar();
            String am_pm;
            
            int hour = calendar.get(Calendar.HOUR);
            int minute = calendar.get(Calendar.MINUTE);
            int second = calendar.get(Calendar.SECOND);
            
            if(calendar.get(Calendar.AM_PM) == 0)
               am_pm = "AM";
            else
               am_pm = "PM";
            String CT = hour+":"+ minute +":"+ second +" "+ am_pm;
            out.println("Crrent Time: " + CT + "\n");
         %>
      </center>
   
   </body>
</html>

Ahora ponga el código anterior en main.jspe intenta acceder a él. Esto mostrará la hora actual del sistema después de cada 5 segundos de la siguiente manera. Simplemente ejecute JSP y espere a ver el resultado:

Auto Refresh Header Example
Current Time is: 9:44:50 PM

En este capítulo, discutiremos cómo enviar correos electrónicos usando JSP. Para enviar un correo electrónico usando una JSP, debe tener elJavaMail API y el Java Activation Framework (JAF) instalado en su máquina.

• Puede descargar la última versión de JavaMail (Versión 1.2) del sitio web estándar de Java.

• Puede descargar la última versión de JavaBeans Activation Framework JAF (Versión 1.0.2) desde el sitio web estándar de Java.

Descargue y descomprima estos archivos, en los directorios de nivel superior recién creados. Encontrará varios archivos jar para ambas aplicaciones. Necesitas agregar elmail.jar y el activation.jar archivos en su CLASSPATH.

Envíe un correo electrónico simple

Aquí hay un ejemplo para enviar un correo electrónico simple desde su máquina. Se supone que sulocalhostestá conectado a Internet y tiene la capacidad suficiente para enviar un correo electrónico. Asegúrese de que todos los archivos jar del paquete Java Email API y el paquete JAF estén disponibles en CLASSPATH.

<%@ page import = "java.io.*,java.util.*,javax.mail.*"%>
<%@ page import = "javax.mail.internet.*,javax.activation.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>

<%
   String result;
   
   // Recipient's email ID needs to be mentioned.
   String to = "[email protected]";

   // Sender's email ID needs to be mentioned
   String from = "[email protected]";

   // Assuming you are sending email from localhost
   String host = "localhost";

   // Get system properties object
   Properties properties = System.getProperties();

   // Setup mail server
   properties.setProperty("mail.smtp.host", host);

   // Get the default Session object.
   Session mailSession = Session.getDefaultInstance(properties);

   try {
      // Create a default MimeMessage object.
      MimeMessage message = new MimeMessage(mailSession);
      
      // Set From: header field of the header.
      message.setFrom(new InternetAddress(from));
      
      // Set To: header field of the header.
      message.addRecipient(Message.RecipientType.TO,
                               new InternetAddress(to));
      // Set Subject: header field
      message.setSubject("This is the Subject Line!");
      
      // Now set the actual message
      message.setText("This is actual message");
      
      // Send message
      Transport.send(message);
      result = "Sent message successfully....";
   } catch (MessagingException mex) {
      mex.printStackTrace();
      result = "Error: unable to send message....";
   }
%>

<html>
   <head>
      <title>Send Email using JSP</title>
   </head>
   
   <body>
      <center>
         <h1>Send Email using JSP</h1>
      </center>
      
      <p align = "center">
         <% 
            out.println("Result: " + result + "\n");
         %>
      </p>
   </body>
</html>

Pongamos ahora el código anterior en SendEmail.jsp archivo y llame a esta JSP usando la URL http://localhost:8080/SendEmail.jsp. Esto ayudará a enviar un correo electrónico al ID de correo electrónico proporcionado.[email protected]. Recibirá la siguiente respuesta:

Send Email using JSP
Result: Sent message successfully....

Si desea enviar un correo electrónico a varios destinatarios, utilice los siguientes métodos para especificar varios ID de correo electrónico:

void addRecipients(Message.RecipientType type, Address[] addresses)
throws MessagingException

Aquí está la descripción de los parámetros:

• type- Esto se establecería en TO, CC o BCC. Aquí CC representa Carbon Copy y BCC representa Black Carbon Copy. Ejemplo Message.RecipientType.TO

• addresses- Esta es la matriz de ID de correo electrónico. Debería utilizar el método InternetAddress () mientras especifica las ID de correo electrónico

Envíe un correo electrónico HTML

Aquí hay un ejemplo para enviar un correo electrónico HTML desde su máquina. Se supone que sulocalhostestá conectado a Internet y tiene la capacidad suficiente para enviar un correo electrónico. Asegúrese de que todos los archivos jar delJava Email API package y el JAF package están disponibles en CLASSPATH.

Este ejemplo es muy similar al anterior, excepto que aquí estamos usando el setContent() método para establecer contenido cuyo segundo argumento es "text/html" para especificar que el contenido HTML está incluido en el mensaje.

Con este ejemplo, puede enviar un contenido HTML tan grande como necesite.

<%@ page import = "java.io.*,java.util.*,javax.mail.*"%>
<%@ page import = "javax.mail.internet.*,javax.activation.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>

<%
   String result;
   
   // Recipient's email ID needs to be mentioned.
   String to = "[email protected]";

   // Sender's email ID needs to be mentioned
   String from = "[email protected]";

   // Assuming you are sending email from localhost
   String host = "localhost";

   // Get system properties object
   Properties properties = System.getProperties();

   // Setup mail server
   properties.setProperty("mail.smtp.host", host);

   // Get the default Session object.
   Session mailSession = Session.getDefaultInstance(properties);

   try {
      // Create a default MimeMessage object.
      MimeMessage message = new MimeMessage(mailSession);
      
      // Set From: header field of the header.
      message.setFrom(new InternetAddress(from));
      
      // Set To: header field of the header.
      message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
      
      // Set Subject: header field
      message.setSubject("This is the Subject Line!");
     
      // Send the actual HTML message, as big as you like
      message.setContent("<h1>This is actual message</h1>", "text/html" );
      
      // Send message
      Transport.send(message);
      result = "Sent message successfully....";
   } catch (MessagingException mex) {
      mex.printStackTrace();
      result = "Error: unable to send message....";
   }
%>

<html>
   <head>
      <title>Send HTML Email using JSP</title>
   </head>

   <body>
      <center>
         <h1>Send Email using JSP</h1>
      </center>
      
      <p align = "center">
         <% 
            out.println("Result: " + result + "\n");
         %>
      </p>
   </body>
</html>

Usemos ahora la JSP anterior para enviar un mensaje HTML en una ID de correo electrónico determinada.

Enviar archivo adjunto por correo electrónico

A continuación se muestra un ejemplo para enviar un correo electrónico con un archivo adjunto desde su máquina:

<%@ page import = "java.io.*,java.util.*,javax.mail.*"%>
<%@ page import = "javax.mail.internet.*,javax.activation.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>

<%
   String result;
   
   // Recipient's email ID needs to be mentioned.
   String to = "[email protected]";

   // Sender's email ID needs to be mentioned
   String from = "[email protected]";

   // Assuming you are sending email from localhost
   String host = "localhost";

   // Get system properties object
   Properties properties = System.getProperties();

   // Setup mail server
   properties.setProperty("mail.smtp.host", host);

   // Get the default Session object.
   Session mailSession = Session.getDefaultInstance(properties);

   try {
      // Create a default MimeMessage object.
      MimeMessage message = new MimeMessage(mailSession);

      // Set From: header field of the header.
      message.setFrom(new InternetAddress(from));

      // Set To: header field of the header.
      message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));

      // Set Subject: header field
      message.setSubject("This is the Subject Line!");

      // Create the message part 
      BodyPart messageBodyPart = new MimeBodyPart();

      // Fill the message
      messageBodyPart.setText("This is message body");
      
      // Create a multipart message
      Multipart multipart = new MimeMultipart();

      // Set text message part
      multipart.addBodyPart(messageBodyPart);

      // Part two is attachment
      messageBodyPart = new MimeBodyPart();
      
      String filename = "file.txt";
      DataSource source = new FileDataSource(filename);
      messageBodyPart.setDataHandler(new DataHandler(source));
      messageBodyPart.setFileName(filename);
      multipart.addBodyPart(messageBodyPart);

      // Send the complete message parts
      message.setContent(multipart );

      // Send message
      Transport.send(message);
      String title = "Send Email";
      result = "Sent message successfully....";
   } catch (MessagingException mex) {
      mex.printStackTrace();
      result = "Error: unable to send message....";
   }
%>

<html>
   <head>
      <title>Send Attachment Email using JSP</title>
   </head>
   
   <body>
      <center>
         <h1>Send Attachment Email using JSP</h1>
      </center>
      
      <p align = "center">
         <%out.println("Result: " + result + "\n");%>
      </p>
   </body>
</html>

Ejecutemos ahora el JSP anterior para enviar un archivo como archivo adjunto junto con un mensaje en una ID de correo electrónico determinada.

Parte de autenticación de usuario

Si es necesario proporcionar una ID de usuario y una contraseña al servidor de correo electrónico con fines de autenticación, puede configurar estas propiedades de la siguiente manera:

props.setProperty("mail.user", "myuser");
props.setProperty("mail.password", "mypwd");

El resto del mecanismo de envío de correo electrónico permanecerá como se explicó anteriormente.

Uso de formularios para enviar correo electrónico

Puede usar el formulario HTML para aceptar parámetros de correo electrónico y luego puede usar el request objeto para obtener toda la información de la siguiente manera:

String to = request.getParameter("to");
String from = request.getParameter("from");
String subject = request.getParameter("subject");
String messageText = request.getParameter("body");

Una vez que tenga toda la información, puede utilizar los programas antes mencionados para enviar correo electrónico.

En este capítulo, entenderemos las diferentes etiquetas en JSP. La biblioteca de etiquetas estándar de JavaServer Pages (JSTL) es una colección de etiquetas JSP útiles que encapsula la funcionalidad principal común a muchas aplicaciones JSP.

JSTL tiene soporte para tareas estructurales comunes como iteración y condicionales, etiquetas para manipular documentos XML, etiquetas de internacionalización y etiquetas SQL. También proporciona un marco para integrar las etiquetas personalizadas existentes con las etiquetas JSTL.

Instalar la biblioteca JSTL

Para comenzar a trabajar con etiquetas JSP, primero debe instalar la biblioteca JSTL. Si está utilizando el contenedor Apache Tomcat, siga estos dos pasos:

Step 1- Descargue la distribución binaria de Apache Standard Taglib y descomprima el archivo comprimido.

Step 2 - Para utilizar el Taglib estándar de su Jakarta Taglibs distribution, simplemente copie los archivos JAR en el directorio 'lib' de la distribución al de su aplicación webapps\ROOT\WEB-INF\lib directorio.

Para usar cualquiera de las bibliotecas, debe incluir una directiva <taglib> en la parte superior de cada JSP que usa la biblioteca.

Clasificación de las etiquetas JSTL

Las etiquetas JSTL se pueden clasificar, según sus funciones, en los siguientes grupos de bibliotecas de etiquetas JSTL que se pueden utilizar al crear una página JSP:

• Core Tags

• Formatting tags

• SQL tags

• XML tags

• JSTL Functions

Etiquetas principales

El grupo principal de etiquetas son las etiquetas JSTL más utilizadas. A continuación se muestra la sintaxis para incluir la biblioteca principal JSTL en su JSP:

<%@ taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/core" %>

La siguiente tabla enumera las etiquetas JSTL principales:

S.No.	Etiqueta y descripción
1	Como <% = ...>, pero para expresiones.
2	Establece el resultado de una evaluación de expresión en un 'scope'
3	Elimina un scoped variable (de un ámbito particular, si se especifica).
4	Atrapa cualquier Throwable que ocurre en su cuerpo y opcionalmente lo expone.
5	Etiqueta condicional simple que evalúa su cuerpo si la condición proporcionada es verdadera.
6	Etiqueta condicional simple que establece un contexto para operaciones condicionales mutuamente excluyentes, marcada por <when> y <otherwise>.
7	Subetiqueta de <choose> que incluye su cuerpo si su condición se evalúa a 'true'.
8	Subetiqueta de <choose> que sigue al <when> etiquetas y se ejecuta solo si todas las condiciones anteriores se evaluaron para 'false'.
9	Recupera una URL absoluta o relativa y expone su contenido a la página, una cadena en 'var', o un lector en 'varReader'.
10	La etiqueta de iteración básica, que acepta muchos tipos de colecciones diferentes y admite subconjuntos y otras funciones.
11	Itera sobre tokens, separados por los delimitadores suministrados.
12	Agrega un parámetro a un contenedor 'import' URL de la etiqueta.
13	Redirige a una nueva URL.
14	Crea una URL con parámetros de consulta opcionales.

Etiquetas de formato

Las etiquetas de formato JSTL se utilizan para formatear y mostrar texto, la fecha, la hora y los números de los sitios web internacionalizados. A continuación se muestra la sintaxis para incluir la biblioteca de formato en su JSP:

<%@ taglib prefix = "fmt" uri = "http://java.sun.com/jsp/jstl/fmt" %>

La siguiente tabla enumera las etiquetas de formato JSTL:

S.No.	Etiqueta y descripción
1	Para representar valores numéricos con precisión o formato específicos.
2	Analiza la representación de cadena de un número, moneda o porcentaje.
3	Formatea una fecha y / o hora usando los estilos y patrones proporcionados.
4	Analiza la representación de cadena de una fecha y / o hora
5	Carga un paquete de recursos para que lo utilice el cuerpo de su etiqueta.
6	Almacena la localidad dada en la variable de configuración local.
7	Carga un paquete de recursos y lo almacena en la variable de ámbito nombrada o en la variable de configuración del paquete.
8	Especifica la zona horaria para cualquier acción de análisis o formato de hora anidada en su cuerpo.
9	Almacena la zona horaria dada en la variable de configuración de zona horaria
10	Muestra un mensaje internacionalizado.
11	Establece la codificación de caracteres de la solicitud

Etiquetas SQL

La biblioteca de etiquetas SQL de JSTL proporciona etiquetas para interactuar con bases de datos relacionales (RDBMS) como Oracle, mySQLo Microsoft SQL Server.

A continuación se muestra la sintaxis para incluir la biblioteca JSTL SQL en su JSP:

<%@ taglib prefix = "sql" uri = "http://java.sun.com/jsp/jstl/sql" %>

La siguiente tabla enumera las etiquetas SQL JSTL:

S.No.	Etiqueta y descripción
1	Crea una fuente de datos simple adecuada solo para la creación de prototipos
2	Ejecuta la consulta SQL definida en su cuerpo o mediante el atributo sql.
3	Ejecuta la actualización de SQL definida en su cuerpo o mediante el atributo sql.
4	Establece un parámetro en una declaración SQL en el valor especificado.
5	Establece un parámetro en una instrucción SQL en el valor java.util.Date especificado.
6	Proporciona elementos de acción de base de datos anidados con una conexión compartida, configurada para ejecutar todas las declaraciones como una transacción.

Etiquetas XML

Las etiquetas XML de JSTL proporcionan una forma centrada en JSP de crear y manipular los documentos XML. A continuación se muestra la sintaxis para incluir la biblioteca XML de JSTL en su JSP.

La biblioteca de etiquetas XML de JSTL tiene etiquetas personalizadas para interactuar con los datos XML. Esto incluye analizar el XML, transformar los datos XML y el control de flujo basado en las expresiones XPath.

<%@ taglib prefix = "x" 
   uri = "http://java.sun.com/jsp/jstl/xml" %>

Antes de continuar con los ejemplos, deberá copiar las siguientes dos bibliotecas relacionadas con XML y XPath en su <Tomcat Installation Directory>\lib -

• XercesImpl.jar - Descárgalo desde https://www.apache.org/dist/xerces/j/

• xalan.jar - Descárgalo desde https://xml.apache.org/xalan-j/index.html

A continuación se muestra la lista de etiquetas XML JSTL:

S.No.	Etiqueta y descripción
1	Como <% = ...>, pero para expresiones XPath.
2	Se utiliza para analizar los datos XML especificados mediante un atributo o en el cuerpo de la etiqueta.
3	Establece una variable en el valor de una expresión XPath.
4	Evalúa una expresión XPath de prueba y, si es verdadera, procesa su cuerpo. Si la condición de prueba es falsa, se ignora el cuerpo.
5	Para recorrer los nodos en un documento XML.
6	Etiqueta condicional simple que establece un contexto para operaciones condicionales mutuamente excluyentes, marcada por <when> y <otherwise> etiquetas.
7	Subetiqueta de <choose> que incluye su cuerpo si su expresión se evalúa como 'verdadera'.
8	Subetiqueta de <choose> que sigue al <when> etiquetas y se ejecuta solo si todas las condiciones anteriores se evalúan como 'falsas'.
9	Aplica una transformación XSL en un documento XML
10	Usado junto con el transform etiqueta para establecer un parámetro en la hoja de estilo XSLT

Funciones JSTL

JSTL incluye una serie de funciones estándar, la mayoría de las cuales son funciones comunes de manipulación de cadenas. A continuación se muestra la sintaxis para incluir la biblioteca de funciones JSTL en su JSP:

<%@ taglib prefix = "fn" 
   uri = "http://java.sun.com/jsp/jstl/functions" %>

La siguiente tabla enumera las diversas funciones JSTL:

S.No.	Función descriptiva
1	fn: contiene () Comprueba si una cadena de entrada contiene la subcadena especificada.
2	fn: containsIgnoreCase () Comprueba si una cadena de entrada contiene la subcadena especificada sin distinción entre mayúsculas y minúsculas.
3	fn: termina con () Prueba si una cadena de entrada termina con el sufijo especificado.
4	fn: escapeXml () Escapa caracteres que se pueden interpretar como marcado XML.
5	fn: indexOf () Devuelve el índice dentro de una cadena de la primera aparición de una subcadena especificada.
6	fn: unirse () Une todos los elementos de una matriz en una cadena.
7	fn: longitud () Devuelve el número de elementos de una colección o el número de caracteres de una cadena.
8	fn: reemplazar () Devuelve una cadena resultante de reemplazar en una cadena de entrada todas las ocurrencias con una cadena determinada.
9	fn: dividir () Divide una cadena en una matriz de subcadenas.
10	fn: startsWith () Prueba si una cadena de entrada comienza con el prefijo especificado.
11	fn: subcadena () Devuelve un subconjunto de una cadena.
12	fn: substringAfter () Devuelve un subconjunto de una cadena que sigue a una subcadena específica.
13	fn: substringBefore () Devuelve un subconjunto de una cadena antes de una subcadena específica.
14	fn: toLowerCase () Convierte todos los caracteres de una cadena a minúsculas.
15	fn: toUpperCase () Convierte todos los caracteres de una cadena a mayúsculas.
dieciséis	fn: recortar () Elimina los espacios en blanco de ambos extremos de una cadena.

En este capítulo, discutiremos cómo acceder a la base de datos con JSP. Suponemos que comprende bien cómo funciona la aplicación JDBC. Antes de comenzar con el acceso a la base de datos a través de una JSP, asegúrese de tener la configuración adecuada del entorno JDBC junto con una base de datos.

Para obtener más detalles sobre cómo acceder a la base de datos utilizando JDBC y su configuración de entorno, puede consultar nuestro Tutorial de JDBC .

Para comenzar con el concepto básico, creemos una tabla y creemos algunos registros en esa tabla de la siguiente manera:

Crear mesa

Para crear el Employees tabla en la base de datos EMP, siga los siguientes pasos:

Paso 1

Abre un Command Prompt y cambie al directorio de instalación de la siguiente manera:

C:\>
C:\>cd Program Files\MySQL\bin
C:\Program Files\MySQL\bin>

Paso 2

Inicie sesión en la base de datos de la siguiente manera:

C:\Program Files\MySQL\bin>mysql -u root -p
Enter password: ********
mysql>

Paso 3

Crea el Employee mesa en el TEST base de datos de la siguiente manera - -

mysql> use TEST;
mysql> create table Employees
   (
      id int not null,
      age int not null,
      first varchar (255),
      last varchar (255)
   );
Query OK, 0 rows affected (0.08 sec)
mysql>

Crear registros de datos

Creemos ahora algunos registros en el Employee tabla de la siguiente manera - -

mysql> INSERT INTO Employees VALUES (100, 18, 'Zara', 'Ali');
Query OK, 1 row affected (0.05 sec)
 
mysql> INSERT INTO Employees VALUES (101, 25, 'Mahnaz', 'Fatma');
Query OK, 1 row affected (0.00 sec)
 
mysql> INSERT INTO Employees VALUES (102, 30, 'Zaid', 'Khan');
Query OK, 1 row affected (0.00 sec)
 
mysql> INSERT INTO Employees VALUES (103, 28, 'Sumit', 'Mittal');
Query OK, 1 row affected (0.00 sec)
 
mysql>

SELECCIONAR Operación

El siguiente ejemplo muestra cómo podemos ejecutar el SQL SELECT declaración usando JTSL en programación JSP -

<%@ page import = "java.io.*,java.util.*,java.sql.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix = "c"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix = "sql"%>
 
<html>
   <head>
      <title>SELECT Operation</title>
   </head>

   <body>
      <sql:setDataSource var = "snapshot" driver = "com.mysql.jdbc.Driver"
         url = "jdbc:mysql://localhost/TEST"
         user = "root"  password = "pass123"/>
 
      <sql:query dataSource = "${snapshot}" var = "result">
         SELECT * from Employees;
      </sql:query>
 
      <table border = "1" width = "100%">
         <tr>
            <th>Emp ID</th>
            <th>First Name</th>
            <th>Last Name</th>
            <th>Age</th>
         </tr>
         
         <c:forEach var = "row" items = "${result.rows}"> <tr> <td><c:out value = "${row.id}"/></td>
               <td><c:out value = "${row.first}"/></td> <td><c:out value = "${row.last}"/></td>
               <td><c:out value = "${row.age}"/></td>
            </tr>
         </c:forEach>
      </table>
 
   </body>
</html>

Acceda a la JSP anterior, se mostrará el siguiente resultado:

 
       

        
 
         
Emp ID
 
         
First Name
 
         
Last Name
 
         
Age
 
        
 
        
 
         
100
 
         
Zara
 
         
Ali
 
         
18
 
        
 
        
 
         
101
 
         
Mahnaz
 
         
Fatma
 
         
25
 
        
 
        
 
         
102
 
         
Zaid
 
         
Khan
 
         
30
 
        
 
        
 
         
103
 
         
Sumit
 
         
Mittal
 
         
28
 
        
 
       
      

INSERTAR Operación

El siguiente ejemplo muestra cómo podemos ejecutar la instrucción SQL INSERT usando JTSL en la programación JSP:

<%@ page import = "java.io.*,java.util.*,java.sql.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix = "c"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix = "sql"%>
 
<html>
   <head>
      <title>JINSERT Operation</title>
   </head>
   
   <body>
      <sql:setDataSource var = "snapshot" driver = "com.mysql.jdbc.Driver"
         url = "jdbc:mysql://localhost/TEST"
         user = "root"  password = "pass123"/>
         <sql:update dataSource = "${snapshot}" var = "result">
         INSERT INTO Employees VALUES (104, 2, 'Nuha', 'Ali');
      </sql:update>
 
      <sql:query dataSource = "${snapshot}" var = "result"> SELECT * from Employees; </sql:query> <table border = "1" width = "100%"> <tr> <th>Emp ID</th> <th>First Name</th> <th>Last Name</th> <th>Age</th> </tr> <c:forEach var = "row" items = "${result.rows}">
            <tr>
               <td><c:out value = "${row.id}"/></td> <td><c:out value = "${row.first}"/></td>
               <td><c:out value = "${row.last}"/></td> <td><c:out value = "${row.age}"/></td>
            </tr>
         </c:forEach>
      </table>
 
   </body>
</html>

Acceda a la JSP anterior, se mostrará el siguiente resultado:

 
       

        
 
         
Emp ID
 
         
First Name
 
         
Last Name
 
         
Age
 
        
 
        
 
         
100
 
         
Zara
 
         
Ali
 
         
18
 
        
 
        
 
         
101
 
         
Mahnaz
 
         
Fatma
 
         
25
 
        
 
        
 
         
102
 
         
Zaid
 
         
Khan
 
         
30
 
        
 
        
 
         
103
 
         
Sumit
 
         
Mittal
 
         
28
 
        
 
        
 
         
104
 
         
Nuha
 
         
Ali
 
         
2
 
        
 
       
      

Operación DELETE

El siguiente ejemplo muestra cómo podemos ejecutar el SQL DELETE declaración usando JTSL en programación JSP -

<%@ page import = "java.io.*,java.util.*,java.sql.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix = "c"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix = "sql"%>
 
<html>
   <head>
      <title>DELETE Operation</title>
   </head>
   
   <body>
      <sql:setDataSource var = "snapshot" driver = "com.mysql.jdbc.Driver"
         url = "jdbc:mysql://localhost/TEST"
         user = "root" password = "pass123"/>
 
      <c:set var = "empId" value = "103"/>
 
      <sql:update dataSource = "${snapshot}" var = "count"> DELETE FROM Employees WHERE Id = ? <sql:param value = "${empId}" />
      </sql:update>
 
      <sql:query dataSource = "${snapshot}" var = "result"> SELECT * from Employees; </sql:query> <table border = "1" width = "100%"> <tr> <th>Emp ID</th> <th>First Name</th> <th>Last Name</th> <th>Age</th> </tr> <c:forEach var = "row" items = "${result.rows}">
            <tr>
               <td><c:out value = "${row.id}"/></td> <td><c:out value = "${row.first}"/></td>
               <td><c:out value = "${row.last}"/></td> <td><c:out value = "${row.age}"/></td>
            </tr>
         </c:forEach>
      </table>
 
   </body>
</html>

Acceda a la JSP anterior, se mostrará el siguiente resultado:

 
       

        
 
         
Emp ID
 
         
First Name
 
         
Last Name
 
         
Age
 
        
 
        
 
         
100
 
         
Zara
 
         
Ali
 
         
18
 
        
 
        
 
         
101
 
         
Mahnaz
 
         
Fatma
 
         
25
 
        
 
        
 
         
102
 
         
Zaid
 
         
Khan
 
         
30
 
        
 
       
      

Operación ACTUALIZAR

El siguiente ejemplo muestra cómo podemos ejecutar el SQL UPDATE declaración usando JTSL en programación JSP -

<%@ page import = "java.io.*,java.util.*,java.sql.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>
<%@ taglib uri = "http://java.sun.com/jsp/jstl/core" prefix = "c"%>
<%@ taglib uri = "http://java.sun.com/jsp/jstl/sql" prefix = "sql"%>
 
<html>
   <head>
      <title>DELETE Operation</title>
   </head>
   
   <body>
      <sql:setDataSource var = "snapshot" driver = "com.mysql.jdbc.Driver"
         url = "jdbc:mysql://localhost/TEST"
         user = "root" password = "pass123"/>
 
      <c:set var = "empId" value = "102"/>
 
      <sql:update dataSource = "${snapshot}" var = "count"> UPDATE Employees SET WHERE last = 'Ali' <sql:param value = "${empId}" />
      </sql:update>
 
      <sql:query dataSource = "${snapshot}" var = "result"> SELECT * from Employees; </sql:query> <table border = "1" width = "100%"> <tr> <th>Emp ID</th> <th>First Name</th> <th>Last Name</th> <th>Age</th> </tr> <c:forEach var = "row" items = "${result.rows}">
            <tr>
               <td><c:out value = "${row.id}"/></td> <td><c:out value = "${row.first}"/></td>
               <td><c:out value = "${row.last}"/></td> <td><c:out value = "${row.age}"/></td>
            </tr>
         </c:forEach>
      </table>
 
   </body>
</html>

Acceda a la JSP anterior, se mostrará el siguiente resultado:

 
       

        
 
         
Emp ID
 
         
First Name
 
         
Last Name
 
         
Age
 
        
 
        
 
         
100
 
         
Zara
 
         
Ali
 
         
18
 
        
 
        
 
         
101
 
         
Mahnaz
 
         
Fatma
 
         
25
 
        
 
        
 
         
102
 
         
Zaid
 
         
Ali
 
         
30
 
        
 
       
      

Cuando envía los datos XML a través de HTTP, tiene sentido usar JSP para manejar documentos XML entrantes y salientes; por ejemplo, documentos RSS. Como un documento XML es simplemente un montón de texto, crear uno a través de una JSP es mucho más fácil que crear un documento HTML.

Enviar XML desde una JSP

Puede enviar el contenido XML utilizando JSP de la misma forma que envía HTML. La única diferencia es que debe establecer el tipo de contenido de su página en texto / xml. Para configurar el tipo de contenido, use el<%@page%> etiqueta, así -

<%@ page contentType = "text/xml" %>

El siguiente ejemplo mostrará cómo enviar contenido XML al navegador:

<%@ page contentType = "text/xml" %>

<books>
   <book>
      <name>Padam History</name>
      <author>ZARA</author>
      <price>100</price>
   </book>
</books>

Acceda al XML anterior utilizando diferentes navegadores para ver la presentación del árbol del documento del XML anterior.

Procesamiento de XML en JSP

Antes de continuar con el procesamiento de XML usando JSP, deberá copiar las siguientes dos bibliotecas relacionadas con XML y XPath en su <Tomcat Installation Directory>\lib -

• XercesImpl.jar - Descárgalo desde https://www.apache.org/dist/xerces/j/

• xalan.jar - Descárgalo desde https://xml.apache.org/xalan-j/index.html

Pongamos el siguiente contenido en el archivo books.xml:

<books>
   <book>
      <name>Padam History</name>
      <author>ZARA</author>
      <price>100</price>
   </book>
   
   <book>
      <name>Great Mistry</name>
      <author>NUHA</author>
      <price>2000</price>
   </book>
</books>

Prueba lo siguiente main.jsp, manteniéndose en el mismo directorio -

<%@ taglib prefix = "c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix = "x" uri="http://java.sun.com/jsp/jstl/xml" %>
 
<html>
   <head>
      <title>JSTL x:parse Tags</title>
   </head>

   <body>
      <h3>Books Info:</h3>
      <c:import var = "bookInfo" url="http://localhost:8080/books.xml"/>
 
      <x:parse xml = "${bookInfo}" var = "output"/> <b>The title of the first book is</b>: <x:out select = "$output/books/book[1]/name" />
      <br>
      
      <b>The price of the second book</b>: 
      <x:out select = "$output/books/book[2]/price" />
   </body>
</html>

Acceda a la JSP anterior usando http://localhost:8080/main.jsp, se mostrará el siguiente resultado:

Books Info:
The title of the first book is:Padam History

The price of the second book: 2000

Formateo de XML con JSP

Considere la siguiente hoja de estilo XSLT style.xsl -

<?xml version = "1.0"?>
<xsl:stylesheet xmlns:xsl = "http://www.w3.org/1999/XSL/Transform" 
   version = "1.0">
 
   <xsl:output method = "html" indent = "yes"/>
   <xsl:template match = "/">
      <html>
         <body>
            <xsl:apply-templates/>
         </body>
      </html>
   </xsl:template>
    
   <xsl:template match = "books">
      <table border = "1" width = "100%">
         <xsl:for-each select = "book">
            <tr>
               <td>
                  <i><xsl:value-of select = "name"/></i>
               </td>
               
               <td>
                  <xsl:value-of select = "author"/>
               </td>
               
               <td>
                  <xsl:value-of select = "price"/>
               </td>
            </tr>
         </xsl:for-each>
      </table>
   
   </xsl:template>
</xsl:stylesheet>

Ahora considere el siguiente archivo JSP:

<%@ taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix = "x" uri = "http://java.sun.com/jsp/jstl/xml" %>
 
<html>
   <head>
      <title>JSTL x:transform Tags</title>
   </head>
   
   <body>
      <h3>Books Info:</h3>
      <c:set var = "xmltext">
         <books>
            <book>
               <name>Padam History</name>
               <author>ZARA</author>
               <price>100</price>
            </book>
            
            <book>
               <name>Great Mistry</name>
               <author>NUHA</author>
               <price>2000</price>
            </book>
         </books>
      </c:set>
 
      <c:import url = "http://localhost:8080/style.xsl" var = "xslt"/>
      <x:transform xml = "${xmltext}" xslt = "${xslt}"/>
   </body>
</html>

Se mostrará el siguiente resultado:

Books Info:

      
 
       

        
 
         
Padam History
 
         
ZARA
 
         
100
 
        
 
        
 
         
Great Mistry
 
         
NUHA
 
         
2000
 
        
 
       
      

Para saber más sobre el procesamiento de XML usando JSTL, puede consultar JSP Standard Tag Library .

Un JavaBean es una clase de Java especialmente construida escrita en Java y codificada de acuerdo con las especificaciones de la API de JavaBeans.

A continuación se presentan las características únicas que distinguen a un JavaBean de otras clases de Java:

• Proporciona un constructor predeterminado sin argumentos.

• Debe ser serializable y lo que puede implementar el Serializable interfaz.

• Puede tener varias propiedades que se pueden leer o escribir.

• Puede tener varios "getter"y"setter"métodos para las propiedades.

Propiedades de JavaBeans

Una propiedad de JavaBean es un atributo con nombre al que puede acceder el usuario del objeto. El atributo puede ser de cualquier tipo de datos Java, incluidas las clases que defina.

Una propiedad JavaBean puede ser read, write, read onlyo write only. Se accede a las propiedades de JavaBean a través de dos métodos en la clase de implementación de JavaBean:

S.No.	Método y descripción
1	obtenerPropertyName() Por ejemplo, si el nombre de la propiedad es firstName , el nombre de su método seríagetFirstName()para leer esa propiedad. Este método se llama acceso.
2	conjuntoPropertyName() Por ejemplo, si el nombre de la propiedad es firstName , el nombre de su método seríasetFirstName()escribir esa propiedad. Este método se llama mutador.

Un atributo de solo lectura tendrá solo un getPropertyName() método, y un atributo de solo escritura tendrá solo un setPropertyName() método.

Ejemplo de JavaBeans

Considere una clase de estudiantes con pocas propiedades:

package com.tutorialspoint;

public class StudentsBean implements java.io.Serializable {
   private String firstName = null;
   private String lastName = null;
   private int age = 0;

   public StudentsBean() {
   }
   public String getFirstName(){
      return firstName;
   }
   public String getLastName(){
      return lastName;
   }
   public int getAge(){
      return age;
   }
   public void setFirstName(String firstName){
      this.firstName = firstName;
   }
   public void setLastName(String lastName){
      this.lastName = lastName;
   }
   public void setAge(Integer age){
      this.age = age;
   }
}

Accediendo a JavaBeans

los useBeanaction declara un JavaBean para su uso en una JSP. Una vez declarado, el bean se convierte en una variable de secuencia de comandos a la que se puede acceder mediante elementos de secuencia de comandos y otras etiquetas personalizadas utilizadas en el JSP. La sintaxis completa de la etiqueta useBean es la siguiente:

<jsp:useBean id = "bean's name" scope = "bean's scope" typeSpec/>

Aquí los valores para el atributo de alcance pueden ser un page, request, session o application baseden su requerimiento. El valor de laid El atributo puede ser cualquier valor siempre que sea un nombre único entre otros useBean declarations en la misma JSP.

El siguiente ejemplo muestra cómo utilizar la acción useBean:

<html>
   <head>
      <title>useBean Example</title>
   </head>
   
   <body>
      <jsp:useBean id = "date" class = "java.util.Date" /> 
      <p>The date/time is <%= date %>
   </body>
</html>

Recibirá el siguiente resultado - -

The date/time is Thu Sep 30 11:18:11 GST 2010

Acceder a las propiedades de JavaBeans

Junto con <jsp:useBean...> acción, puede utilizar la <jsp:getProperty/> acción para acceder a los métodos get y <jsp:setProperty/>acción para acceder a los métodos establecidos. Aquí está la sintaxis completa:

<jsp:useBean id = "id" class = "bean's class" scope = "bean's scope">
   <jsp:setProperty name = "bean's id" property = "property name"  
      value = "value"/>
   <jsp:getProperty name = "bean's id" property = "property name"/>
   ...........
</jsp:useBean>

El atributo de nombre hace referencia al ID de un JavaBean introducido previamente en la JSP mediante la acción useBean. El atributo de propiedad es el nombre delget o la set métodos que deben invocarse.

El siguiente ejemplo muestra cómo acceder a los datos utilizando la sintaxis anterior:

<html>
   <head>
      <title>get and set properties Example</title>
   </head>
   
   <body>
      <jsp:useBean id = "students" class = "com.tutorialspoint.StudentsBean"> 
         <jsp:setProperty name = "students" property = "firstName" value = "Zara"/>
         <jsp:setProperty name = "students" property = "lastName" value = "Ali"/>
         <jsp:setProperty name = "students" property = "age" value = "10"/>
      </jsp:useBean>

      <p>Student First Name: 
         <jsp:getProperty name = "students" property = "firstName"/>
      </p>
      
      <p>Student Last Name: 
         <jsp:getProperty name = "students" property = "lastName"/>
      </p>
      
      <p>Student Age: 
         <jsp:getProperty name = "students" property = "age"/>
      </p>

   </body>
</html>

Hagamos el StudentsBean.classdisponible en CLASSPATH. Acceda a la JSP anterior. se mostrará el siguiente resultado:

Student First Name: Zara 

Student Last Name: Ali 

Student Age: 10

En este capítulo, analizaremos las etiquetas personalizadas en JSP. Una etiqueta personalizada es un elemento de lenguaje JSP definido por el usuario. Cuando una página JSP que contiene una etiqueta personalizada se traduce a un servlet, la etiqueta se convierte en operaciones en un objeto llamado controlador de etiquetas. Luego, el contenedor web invoca esas operaciones cuando se ejecuta el servlet de la página JSP.

Las extensiones de etiquetas JSP le permiten crear nuevas etiquetas que puede insertar directamente en una página JavaServer. La especificación JSP 2.0 introdujo los manejadores de etiquetas simples para escribir estas etiquetas personalizadas.

Para escribir una etiqueta personalizada, simplemente puede extender SimpleTagSupport clase y anular la doTag() método, donde puede colocar su código para generar contenido para la etiqueta.

Crear etiqueta "Hola"

Considere que desea definir una etiqueta personalizada llamada <ex: Hello> y desea usarla de la siguiente manera sin un cuerpo:

<ex:Hello />

Para crear una etiqueta JSP personalizada, primero debe crear una clase Java que actúe como un controlador de etiquetas. Creemos ahora elHelloTag clase de la siguiente manera -

package com.tutorialspoint;

import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;

public class HelloTag extends SimpleTagSupport {
   public void doTag() throws JspException, IOException {
      JspWriter out = getJspContext().getOut();
      out.println("Hello Custom Tag!");
   }
}

El código anterior tiene una codificación simple donde el doTag() El método toma el objeto JspContext actual usando el getJspContext() método y lo usa para enviar "Hello Custom Tag!" a la corriente JspWriter objeto

Compilemos la clase anterior y la copiemos en un directorio disponible en la variable de entorno CLASSPATH. Finalmente, cree el siguiente archivo de biblioteca de etiquetas:<Tomcat-Installation-Directory>webapps\ROOT\WEB-INF\custom.tld.

<taglib>
   <tlib-version>1.0</tlib-version>
   <jsp-version>2.0</jsp-version>
   <short-name>Example TLD</short-name>
   
   <tag>
      <name>Hello</name>
      <tag-class>com.tutorialspoint.HelloTag</tag-class>
      <body-content>empty</body-content>
   </tag>
</taglib>

Usemos ahora la etiqueta personalizada definida anteriormente Hello en nuestro programa JSP de la siguiente manera:

<%@ taglib prefix = "ex" uri = "WEB-INF/custom.tld"%>

<html>
   <head>
      <title>A sample custom tag</title>
   </head>
   
   <body>
      <ex:Hello/>
   </body>
</html>

Llame a la JSP anterior y esto debería producir el siguiente resultado:

Hello Custom Tag!

Acceder al cuerpo de la etiqueta

Puede incluir un mensaje en el cuerpo de la etiqueta como ha visto con las etiquetas estándar. Considere que desea definir una etiqueta personalizada llamada<ex:Hello> y quieres usarlo de la siguiente manera con un cuerpo:

<ex:Hello>
   This is message body
</ex:Hello>

Hagamos los siguientes cambios en el código de etiqueta anterior para procesar el cuerpo de la etiqueta:

package com.tutorialspoint;

import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;

public class HelloTag extends SimpleTagSupport {
   StringWriter sw = new StringWriter();
   public void doTag()
   
   throws JspException, IOException {
      getJspBody().invoke(sw);
      getJspContext().getOut().println(sw.toString());
   }
}

Aquí, la salida resultante de la invocación se captura primero en un StringWriterantes de escribirse en el JspWriter asociado con la etiqueta. Necesitamos cambiar el archivo TLD de la siguiente manera:

<taglib>
   <tlib-version>1.0</tlib-version>
   <jsp-version>2.0</jsp-version>
   <short-name>Example TLD with Body</short-name>
   
   <tag>
      <name>Hello</name>
      <tag-class>com.tutorialspoint.HelloTag</tag-class>
      <body-content>scriptless</body-content>
   </tag>
</taglib>

Ahora llamemos a la etiqueta anterior con el cuerpo adecuado de la siguiente manera:

<%@ taglib prefix = "ex" uri = "WEB-INF/custom.tld"%>

<html>
   <head>
      <title>A sample custom tag</title>
   </head>
   
   <body>
      <ex:Hello>
         This is message body
      </ex:Hello>
   </body>
</html>

Recibirá el siguiente resultado:

This is message body

Atributos de etiquetas personalizados

Puede utilizar varios atributos junto con sus etiquetas personalizadas. Para aceptar un valor de atributo, una clase de etiqueta personalizada debe implementar lasetter métodos, idénticos a los métodos de establecimiento de JavaBean como se muestra a continuación:

package com.tutorialspoint;

import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;

public class HelloTag extends SimpleTagSupport {
   private String message;

   public void setMessage(String msg) {
      this.message = msg;
   }
   StringWriter sw = new StringWriter();
   public void doTag()
   
   throws JspException, IOException {
      if (message != null) {
         /* Use message from attribute */
         JspWriter out = getJspContext().getOut();
         out.println( message );
      } else {
         /* use message from the body */
         getJspBody().invoke(sw);
         getJspContext().getOut().println(sw.toString());
      }
   }
}

El nombre del atributo es "message", por lo que el método de establecimiento es setMessage(). Agreguemos ahora este atributo en el archivo TLD usando el<attribute> elemento de la siguiente manera -

<taglib>
   <tlib-version>1.0</tlib-version>
   <jsp-version>2.0</jsp-version>
   <short-name>Example TLD with Body</short-name>
   
   <tag>
      <name>Hello</name>
      <tag-class>com.tutorialspoint.HelloTag</tag-class>
      <body-content>scriptless</body-content>
      
      <attribute>
         <name>message</name>
      </attribute>
   
   </tag>
</taglib>

Sigamos JSP con el atributo de mensaje de la siguiente manera:

<%@ taglib prefix = "ex" uri = "WEB-INF/custom.tld"%>

<html>
   <head>
      <title>A sample custom tag</title>
   </head>
   
   <body>
      <ex:Hello message = "This is custom tag" />
   </body>
</html>

Esto producirá el siguiente resultado:

This is custom tag

Considere incluir las siguientes propiedades para un atributo:

S.No.	Propiedad y propósito
1	name El elemento de nombre define el nombre de un atributo. Cada nombre de atributo debe ser único para una etiqueta en particular.
2	required Esto especifica si este atributo es obligatorio o es opcional. Sería falso para opcional.
3	rtexprvalue Declara si un valor de expresión en tiempo de ejecución para un atributo de etiqueta es válido
4	type Define el tipo de clase Java de este atributo. Por defecto se asume comoString
5	description Se puede proporcionar una descripción informativa.
6	fragment Declara si este valor de atributo debe tratarse como un JspFragment.

A continuación se muestra el ejemplo para especificar propiedades relacionadas con un atributo:

.....
   <attribute>
      <name>attribute_name</name>
      <required>false</required>
      <type>java.util.Date</type>
      <fragment>false</fragment>
   </attribute>
.....

Si está utilizando dos atributos, puede modificar su TLD de la siguiente manera:

.....
   <attribute>
      <name>attribute_name1</name>
      <required>false</required>
      <type>java.util.Boolean</type>
      <fragment>false</fragment>
   </attribute>
   
   <attribute>
      <name>attribute_name2</name>
      <required>true</required>
      <type>java.util.Date</type>
   </attribute>
.....

JSP Expression Language (EL) hace posible acceder fácilmente a los datos de la aplicación almacenados en componentes JavaBeans. JSP EL te permite crear expresiones tanto(a) aritmética y (b)lógico. Dentro de una expresión JSP EL, puede usarintegers, floating point numbers, strings, the built-in constants true and false para valores booleanos y nulo.

Sintaxis simple

Normalmente, cuando especifica un valor de atributo en una etiqueta JSP, simplemente usa una cadena. Por ejemplo

<jsp:setProperty name = "box" property = "perimeter" value = "100"/>

JSP EL le permite especificar una expresión para cualquiera de estos valores de atributo. Una sintaxis simple para JSP EL es la siguiente:

${expr}

aquí exprespecifica la expresión en sí. Los operadores más comunes en JSP EL son. y []. Estos dos operadores le permiten acceder a varios atributos de Java Beans y objetos JSP integrados.

Por ejemplo, la sintaxis anterior <jsp:setProperty> La etiqueta se puede escribir con una expresión como -

<jsp:setProperty name = "box" property = "perimeter" 
   value = "${2*box.width+2*box.height}"/>

Cuando el compilador JSP ve el ${} forma en un atributo, genera código para evaluar la expresión y sustituye el valor de expresson.

También puede utilizar las expresiones JSP EL dentro del texto de la plantilla para una etiqueta. Por ejemplo, el<jsp:text>etiqueta simplemente inserta su contenido dentro del cuerpo de una JSP. El seguimiento<jsp:text> inserciones de declaración <h1>Hello JSP!</h1> en la salida JSP -

<jsp:text>
   <h1>Hello JSP!</h1>
</jsp:text>

Ahora puede incluir una expresión JSP EL en el cuerpo de un <jsp:text> etiqueta (o cualquier otra etiqueta) con la misma ${}sintaxis que utiliza para los atributos. Por ejemplo

<jsp:text>
   Box Perimeter is: ${2*box.width + 2*box.height}
</jsp:text>

Las expresiones EL pueden usar paréntesis para agrupar subexpresiones. Por ejemplo,${(1 + 2) * 3} equals 9, but ${1 + (2 * 3)} equals 7.

Para desactivar la evaluación de expresiones EL, especificamos el isELIgnored atributo de la directiva de la página como se muestra a continuación:

<%@ page isELIgnored = "true|false" %>

Los valores válidos de este atributo son verdadero y falso. Si es cierto, las expresiones EL se ignoran cuando aparecen en texto estático o atributos de etiqueta. Si es falso, el contenedor evalúa las expresiones EL.

Operadores básicos en EL

JSP Expression Language (EL) es compatible con la mayoría de los operadores lógicos y aritméticos compatibles con Java. La siguiente tabla enumera los operadores más utilizados:

S.No.	Operador y descripción
1	. Acceder a una propiedad de bean o entrada de mapa
2	[] Acceder a una matriz o elemento de lista
3	( ) Agrupar una subexpresión para cambiar el orden de evaluación
4	+ Adición
5	- Resta o negación de un valor
6	* Multiplicación
7	/ or div División
8	% or mod Modulo (resto)
9	== or eq Prueba de igualdad
10	!= or ne Prueba de desigualdad
11	< or lt Prueba por menos de
12	> or gt Prueba para mayor que
13	<= or le Prueba por menor o igual
14	>= or ge Prueba para mayor o igual que
15	&& or and Prueba de AND lógico
dieciséis	|| or or Prueba de OR lógico
17	! or not Complemento booleano unario
18	empty Prueba de valores de variable vacíos

Funciones en JSP EL

JSP EL también le permite usar funciones en expresiones. Estas funciones deben definirse en las bibliotecas de etiquetas personalizadas. El uso de una función tiene la siguiente sintaxis:

${ns:func(param1, param2, ...)}

Dónde ns es el espacio de nombres de la función, func es el nombre de la función y param1es el primer valor de parámetro. Por ejemplo, la funciónfn:length, que forma parte de la biblioteca JSTL. Esta función se puede utilizar de la siguiente manera para obtener la longitud de una cadena.

${fn:length("Get my length")}

Para utilizar una función de cualquier biblioteca de etiquetas (estándar o personalizada), debe instalar esa biblioteca en su servidor y debe incluir la biblioteca en su JSP utilizando el <taglib> directiva como se explica en el capítulo JSTL.

Objetos implícitos JSP EL

El lenguaje de expresión JSP admite los siguientes objetos implícitos:

S. No	Objeto implícito y descripción
1	pageScope Variables de ámbito del ámbito de la página
2	requestScope Variables de alcance del alcance de la solicitud
3	sessionScope Variables de alcance del alcance de la sesión
4	applicationScope Variables de ámbito del ámbito de la aplicación
5	param Solicitar parámetros como cadenas
6	paramValues Solicitar parámetros como colecciones de cadenas
7	header Encabezados de solicitud HTTP como cadenas
8	headerValues Encabezados de solicitud HTTP como colecciones de cadenas
9	initParam Parámetros de inicialización de contexto
10	cookie Valores de las cookies
11	pageContext El objeto JSP PageContext para la página actual

Puede utilizar estos objetos en una expresión como si fueran variables. Los ejemplos que siguen le ayudarán a comprender los conceptos:

El objeto pageContext

El objeto pageContext le da acceso al objeto JSP pageContext. A través del objeto pageContext, puede acceder al objeto de solicitud. Por ejemplo, para acceder a la cadena de consulta entrante para una solicitud, puede usar la siguiente expresión:

${pageContext.request.queryString}

Los objetos de alcance

los pageScope, requestScope, sessionScopey applicationScope Las variables proporcionan acceso a las variables almacenadas en cada nivel de alcance.

Por ejemplo, si necesita acceder explícitamente a la variable box en el ámbito de la aplicación, puede acceder a ella a través de la variable applicationScope como applicationScope.box.

Los objetos param y paramValues

Los objetos param y paramValues ​​le dan acceso a los valores de los parámetros normalmente disponibles a través del request.getParameter y request.getParameterValues métodos.

Por ejemplo, para acceder a un parámetro llamado orden, use la expresión ${param.order} o ${param["order"]}.

A continuación se muestra el ejemplo para acceder a un parámetro de solicitud llamado nombre de usuario:

<%@ page import = "java.io.*,java.util.*" %>
<%String title = "Accessing Request Param";%>

<html>
   <head>
      <title><% out.print(title); %></title>
   </head>
   
   <body>
      <center>
         <h1><% out.print(title); %></h1>
      </center>
      
      <div align = "center">
         <p>${param["username"]}</p>
      </div>
   </body>
</html>

El objeto param devuelve valores de cadena única, mientras que el objeto paramValues ​​devuelve matrices de cadenas.

Objetos header y headerValues

Los objetos header y headerValues ​​le dan acceso a los valores de encabezado normalmente disponibles a través del request.getHeader y el request.getHeaders métodos.

Por ejemplo, para acceder a un encabezado llamado user-agent, use la expresión ${header.user-agent} o ${header["user-agent"]}.

A continuación se muestra el ejemplo para acceder a un parámetro de encabezado llamado user-agent:

<%@ page import = "java.io.*,java.util.*" %>
<%String title = "User Agent Example";%>

<html>
   <head>
      <title><% out.print(title); %></title>
   </head>
   
   <body>
      <center>
         <h1><% out.print(title); %></h1>
      </center>
      
      <div align = "center">
         <p>${header["user-agent"]}</p>
      </div>
   </body>
</html>

La salida será similar a la siguiente:

User Agent Example

      
 
       
Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; WOW64; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; HPNTDF; .NET4.0C; InfoPath.2)
 
      

El objeto de encabezado devuelve valores de cadena única, mientras que el objeto headerValues ​​devuelve matrices de cadenas.

En este capítulo. discutiremos cómo manejar excepciones en JSP. Cuando escribe un código JSP, puede cometer errores de codificación que pueden ocurrir en cualquier parte del código. Puede ocurrir el siguiente tipo de errores en su código JSP:

Excepciones marcadas

Una excepción marcada es una excepción que suele ser un error del usuario o un problema que el programador no puede prever. Por ejemplo, si se va a abrir un archivo, pero no se puede encontrar, se produce una excepción. Estas excepciones no pueden simplemente ignorarse en el momento de la compilación.

Excepciones de tiempo de ejecución

Una excepción de tiempo de ejecución es una excepción que probablemente el programador podría haber evitado. A diferencia de las excepciones marcadas, las excepciones en tiempo de ejecución se ignoran en el momento de la conformidad.

Errores

Estos no son excepciones en absoluto, sino problemas que surgen más allá del control del usuario o del programador. Los errores generalmente se ignoran en su código porque rara vez puede hacer algo al respecto. Por ejemplo, si se produce un desbordamiento de pila, surgirá un error. También se ignoran en el momento de la compilación.

Más adelante discutiremos las formas de manejar las excepciones / errores de tiempo de ejecución que ocurren en su código JSP.

Usar objeto de excepción

El objeto de excepción es una instancia de una subclase de Throwable (por ejemplo, java.lang. NullPointerException) y solo está disponible en las páginas de error. La siguiente tabla enumera los métodos importantes disponibles en la clase Throwable.

S.No.	Métodos y descripción
1	public String getMessage() Devuelve un mensaje detallado sobre la excepción que se ha producido. Este mensaje se inicializa en el constructor Throwable.
2	public Throwable getCause() Devuelve la causa de la excepción representada por un objeto Throwable.
3	public String toString() Devuelve el nombre de la clase concatenada con el resultado de getMessage().
4	public void printStackTrace() Imprime el resultado de toString() junto con el seguimiento de la pila para System.err, el flujo de salida de error.
5	public StackTraceElement [] getStackTrace() Devuelve una matriz que contiene cada elemento del seguimiento de la pila. El elemento en el índice 0 representa la parte superior de la pila de llamadas y el último elemento de la matriz representa el método en la parte inferior de la pila de llamadas.
6	public Throwable fillInStackTrace() Rellena el seguimiento de la pila de este objeto Throwable con el seguimiento de la pila actual, añadiendo a cualquier información anterior en el seguimiento de la pila.

JSP le ofrece una opción para especificar Error Pagepara cada JSP. Siempre que la página arroja una excepción, el contenedor JSP invoca automáticamente la página de error.

A continuación se muestra un ejemplo para especificar una página de error para un main.jsp. Para configurar una página de error, utilice el<%@ page errorPage = "xxx" %> directiva.

<%@ page errorPage = "ShowError.jsp" %>

<html>
   <head>
      <title>Error Handling Example</title>
   </head>
   
   <body>
      <%
         // Throw an exception to invoke the error page
         int x = 1;
         
         if (x == 1) {
            throw new RuntimeException("Error condition!!!");
         }
      %>
   </body>
</html>

Ahora escribiremos un Error Handling JSP ShowError.jsp, que se proporciona a continuación. Tenga en cuenta que la página de manejo de errores incluye la directiva<%@ page isErrorPage = "true" %>. Esta directiva hace que el compilador JSP genere la variable de instancia de excepción.

<%@ page isErrorPage = "true" %>

<html>
   <head>
      <title>Show Error Page</title>
   </head>
   
   <body>
      <h1>Opps...</h1>
      <p>Sorry, an error occurred.</p>
      <p>Here is the exception stack trace: </p>
      <pre><% exception.printStackTrace(response.getWriter()); %></pre>
   </body>
</html>

Acceder al main.jsp, recibirá una salida similar a la siguiente:

java.lang.RuntimeException: Error condition!!!
......

Opps...
Sorry, an error occurred.

Here is the exception stack trace:

Uso de etiquetas JSTL para la página de error

Puede hacer uso de etiquetas JSTL para escribir una página de error ShowError.jsp. Esta página tiene casi la misma lógica que en el ejemplo anterior, con mejor estructura y más información -

<%@ taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/core" %>
<%@page isErrorPage = "true" %>

<html>
   <head>
      <title>Show Error Page</title>
   </head>
   
   <body>
      <h1>Opps...</h1>
      <table width = "100%" border = "1">
         <tr valign = "top">
            <td width = "40%"><b>Error:</b></td>
            <td>${pageContext.exception}</td>
         </tr>
            
         <tr valign = "top">
            <td><b>URI:</b></td>
            <td>${pageContext.errorData.requestURI}</td> </tr> <tr valign = "top"> <td><b>Status code:</b></td> <td>${pageContext.errorData.statusCode}</td>
         </tr>
            
         <tr valign = "top">
            <td><b>Stack trace:</b></td>
            <td>
               <c:forEach var = "trace" 
                  items = "${pageContext.exception.stackTrace}"> <p>${trace}</p>
               </c:forEach>
            </td>
         </tr>
      </table>

   </body>
</html>

Acceda al main.jsp, se generará lo siguiente:

Opps...

      
 
       

        
 
         
Error:
 
         
java.lang.RuntimeException: Error condition!!!
 
        
 
        
 
         
URI:
 
         
/main.jsp
 
        
 
        
 
         
Status code:
 
         
500
 
        
 
        
 
         
Stack trace:
 
         
 
org.apache.jsp.main_jsp._jspService(main_jsp.java:65)
 
org.apache.jasper.runtime.HttpJspBase.service(HttpJspBase.java:68)
 
javax.servlet.http.HttpServlet.service(HttpServlet.java:722)
 
org.apache.jasper.servlet.JspServlet.service(JspServlet.java:265)
 
javax.servlet.http.HttpServlet.service(HttpServlet.java:722)
 
 
        
 
       
      

Usando Try ... Catch Block

Si desea manejar errores dentro de la misma página y desea realizar alguna acción en lugar de activar una página de error, puede utilizar la try....catch bloquear.

A continuación se muestra un ejemplo sencillo que muestra cómo utilizar el bloque try ... catch. Pongamos el siguiente código en main.jsp -

<html>
   <head>
      <title>Try...Catch Example</title>
   </head>
   
   <body>
      <%
         try {
            int i = 1;
            i = i / 0;
            out.println("The answer is " + i);
         }
         catch (Exception e) {
            out.println("An exception occurred: " + e.getMessage());
         }
      %>
   </body>
</html>

Acceda a main.jsp, debería generar una salida similar a la siguiente:

An exception occurred: / by zero

En este capítulo, analizaremos la depuración de una JSP. Siempre es difícil probar / depurar un JSP y servlets. JSP y los servlets tienden a implicar una gran cantidad de interacción cliente / servidor, lo que hace que los errores sean probables pero difíciles de reproducir.

Los siguientes son algunos consejos y sugerencias que pueden ayudarle en la depuración.

Usando System.out.println ()

System.out.println()es fácil de usar como marcador para probar si una determinada pieza de código se está ejecutando o no. También podemos imprimir valores de variables. Considere los siguientes puntos adicionales:

• Dado que el objeto System es parte de los objetos principales de Java, se puede usar en todas partes sin la necesidad de instalar clases adicionales. Esto incluyeServlets, JSP, RMI, EJB's, ordinary Beans y classesy standalone applications.

• En comparación con detenerse en puntos de interrupción, escribir en System.out no interfiere mucho con el flujo de ejecución normal de la aplicación, lo que la hace muy valiosa cuando el iming es crucial.

A continuación se muestra la sintaxis a utilizar System.out.println() -

System.out.println("Debugging message");

El siguiente ejemplo muestra cómo usar System.out.print() -

<%@taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/core" %>

<html>
   <head><title>System.out.println</title></head>
   <body>
      <c:forEach var = "counter" begin = "1" end = "10" step = "1" >
      
         <c:out value = "${counter-5}"/></br>
         <% System.out.println( "counter = " + pageContext.findAttribute("counter") ); %>
      </c:forEach>
      
   </body>
</html>

Acceda a la JSP anterior, el navegador mostrará el siguiente resultado:

-4
-3
-2
-1
0
1
2
3
4
5

Si está utilizando Tomcat, también encontrará estas líneas adjuntas al final de stdout.log en el directorio de registros.

counter = 1
counter = 2
counter = 3
counter = 4
counter = 5
counter = 6
counter = 7
counter = 8
counter = 9
counter = 10

De esta manera, puede traer variables y otra información al registro del sistema que se puede analizar para descubrir la causa raíz del problema o por varias otras razones.

Usando el JDB Logger

los J2SEEl marco de trabajo de registro está diseñado para proporcionar servicios de registro para cualquier clase que se ejecute en la JVM. Podemos hacer uso de este marco para registrar cualquier información.

Reescribamos el ejemplo anterior usando la API del registrador JDK -

<%@taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/core" %>
<%@page import = "java.util.logging.Logger" %>

<html>
   <head><title>Logger.info</title></head>
   
   <body>
      <% Logger logger = Logger.getLogger(this.getClass().getName());%>

      <c:forEach var = "counter" begin = "1" end = "10" step = "1" >
      <c:set var = "myCount" value = "${counter-5}" />
      <c:out value = "${myCount}"/></br>
         <% String message = "counter = "
            + pageContext.findAttribute("counter") + "myCount = "
            + pageContext.findAttribute("myCount");
            logger.info( message );
         %>
      </c:forEach>
      
   </body>
</html>

El código anterior generará un resultado similar en el navegador y en stdout.log, pero tendrá información adicional en stdout.log. Usaremos elinfométodo del registrador porque y registrar el mensaje solo con fines informativos. A continuación se muestra una instantánea del archivo stdout.log:

24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 1 myCount = -4
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 2 myCount = -3
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 3 myCount = -2
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 4 myCount = -1
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 5 myCount = 0
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 6 myCount = 1
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 7 myCount = 2
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 8 myCount = 3
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 9 myCount = 4
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 10 myCount = 5

Los mensajes se pueden enviar a varios niveles utilizando las funciones de conveniencia severe(), warning(), info(), config(), fine(), finer(), y finest(). Aquí se puede utilizar el método finest () para registrar la información más fina y el método grave () se puede utilizar para registrar información grave.

Puede usar Log4J Framework para registrar mensajes en diferentes archivos según sus niveles de gravedad e importancia.

Herramientas de depuración

NetBeans es un entorno de desarrollo integrado Java gratuito y de código abierto que admite el desarrollo de aplicaciones Java independientes y aplicaciones web que admiten las especificaciones JSP y servlet, e incluye también un depurador JSP.

NetBeans admite las siguientes funcionalidades básicas de depuración:

• Breakpoints
• Pasando por el código
• Watchpoints

Puedes referirte a NetBeans documentation para comprender las funcionalidades de depuración anteriores.

Utilizando JDB Debugger

Puede depurar JSP y servlets con el mismo jdb comandos que utiliza para depurar un subprograma o una aplicación.

Para depurar un JSP o servlet, puede depurar sun.servlet.http.HttpServer, luego observe cómo HttpServer ejecuta JSP / servlets en respuesta a las solicitudes HTTP que hacemos desde un navegador. Esto es muy similar a cómo se depuran los subprogramas. La diferencia es que con los applets, el programa real que se está depurando essun.applet.AppletViewer.

La mayoría de los depuradores ocultan este detalle al saber automáticamente cómo depurar los subprogramas. Hasta que hagan lo mismo con JSP, debe ayudar a su depurador considerando lo siguiente:

• Establezca la ruta de clases de su depurador. Esto te ayuda a encontrarsun.servlet.http.Http-Server y las clases asociadas.

• Establezca la ruta de clases de su depurador. Esto le ayuda a encontrar su JSP y clases de soporte, normalmenteROOT\WEB-INF\classes.

Una vez que haya configurado la ruta de clases adecuada, comience a depurar sun.servlet.http.HttpServer. Puede establecer puntos de interrupción en cualquier JSP que le interese depurar, luego usar un navegador web para realizar una solicitud al HttpServer para el JSP dado(http://localhost:8080/JSPToDebug). La ejecución aquí se detiene en puntos de interrupción.

Uso de comentarios

Los comentarios en su código pueden ayudar al proceso de depuración de varias formas. Los comentarios se pueden utilizar de muchas otras formas en el proceso de depuración.

La JSP utiliza comentarios de Java y single line (// ...) y multiple line (/* ... */)Los comentarios se pueden utilizar para eliminar temporalmente partes de su código Java. Si el error desaparece, eche un vistazo más de cerca al código que acaba de comentar y descubra el problema.

Encabezados de cliente y servidor

A veces, cuando una JSP no se comporta como se esperaba, es útil observar la solicitud y respuesta HTTP sin procesar. Si está familiarizado con la estructura de HTTP, puede leer la solicitud y la respuesta y ver qué sucede exactamente con esos encabezados.

Consejos importantes de depuración

Aquí hay una lista de algunos consejos de depuración más sobre la depuración de JSP:

• Pídale a un navegador que muestre el contenido sin procesar de la página que se muestra. Esto puede ayudar a identificar problemas de formato. Suele ser una opción del menú Ver.

• Asegúrese de que el navegador no almacena en caché el resultado de una solicitud anterior forzando una recarga completa de la página. ConNetscape Navigator, utilizar Shift-Reload; conInternet Explorer utilizar Shift-Refresh.

JavaServer Pages y servlets ponen a disposición de los desarrolladores web varios mecanismos para proteger las aplicaciones. Los recursos se protegen de forma declarativa identificándolos en el descriptor de implementación de la aplicación y asignándoles un rol.

Hay varios niveles de autenticación disponibles, que van desde la autenticación básica mediante identificadores y contraseñas hasta la autenticación sofisticada mediante certificados.

Autenticación basada en roles

El mecanismo de autenticación en la especificación del servlet utiliza una técnica llamada role-based security. La idea es que en lugar de restringir los recursos a nivel de usuario, cree roles y restrinja los recursos por rol.

Puede definir diferentes roles en el archivo tomcat-users.xml, que se encuentra fuera del directorio de inicio de Tomcat en conf. A continuación se muestra un ejemplo de este archivo:

<?xml version = '1.0' encoding = 'utf-8'?>
<tomcat-users>
   <role rolename = "tomcat"/>
   <role rolename = "role1"/>
   <role rolename = "manager"/>
   <role rolename = "admin"/>
   <user username = "tomcat" password = "tomcat" roles = "tomcat"/>
   <user username = "role1" password = "tomcat" roles = "role1"/>
   <user username = "both" password = "tomcat" roles = "tomcat,role1"/>
   <user username = "admin" password = "secret" roles = "admin,manager"/>
</tomcat-users>

Este archivo define un mapeo simple entre username, passwordy role. Tenga en cuenta que un usuario determinado puede tener varios roles; por ejemplo,username = "both" está en el rol "tomcat" y el rol "role1".

Una vez que haya identificado y definido diferentes roles, las restricciones de seguridad basadas en roles se pueden colocar en diferentes recursos de la aplicación web utilizando el <security-constraint> elemento en web.xml archivo disponible en el directorio WEB-INF.

A continuación se muestra una entrada de muestra en web.xml:

<web-app>
   ...
   <security-constraint>
      <web-resource-collection>
         <web-resource-name>SecuredBookSite</web-resource-name>
         <url-pattern>/secured/*</url-pattern>
         <http-method>GET</http-method>
         <http-method>POST</http-method>
      </web-resource-collection>
      
      <auth-constraint>
         <description>
            Let only managers use this app
         </description>
         <role-name>manager</role-name>
      </auth-constraint>
   </security-constraint>
   
   <security-role>
      <role-name>manager</role-name>
   </security-role>
   
   <login-config>
      <auth-method>BASIC</auth-method>
   </login-config>
   ...
</web-app>

Las entradas anteriores significarían:

• Cualquier solicitud HTTP GET o POST a una URL que coincida con / secure / * estaría sujeta a la restricción de seguridad.

• Una persona con el rol de administrador tiene acceso a los recursos asegurados.

• los login-config El elemento se utiliza para describir el BASIC forma de autenticación.

Si intenta navegar por cualquier URL, incluida la /securitydirectorio, se mostrará el siguiente cuadro de diálogo solicitando nombre de usuario y contraseña. Si proporciona un usuario"admin" y contraseña "secret", entonces tendrás acceso a la URL que coincide con /secured/* como hemos definido el administrador de usuario con rol de administrador que tiene permiso para acceder a este recurso.

Autenticación basada en formularios

Cuando utiliza el método de autenticación de FORMULARIO, debe proporcionar un formulario de inicio de sesión para solicitar al usuario un nombre de usuario y una contraseña. A continuación se muestra un código simple delogin.jsp. Esto ayuda a crear un formulario con el mismo propósito:

<html>
   <body bgcolor = "#ffffff">
      
      <form method = "POST" action ="j_security_check">
         <table border = "0">
            <tr>
               <td>Login</td>
               <td><input type = "text" name="j_username"></td>
            </tr>
            <tr>
               <td>Password</td>
               <td><input type = "password" name="j_password"></td>
            </tr>
         </table>
         <input type = "submit" value = "Login!">
      </form>
      
   </body>
</html>

Aquí debe asegurarse de que el formulario de inicio de sesión debe contener los elementos del formulario llamados j_username y j_password. La acción en el<form> la etiqueta debe ser j_security_check. POSTdebe utilizarse como método de formulario. Al mismo tiempo, deberá modificar el<login-config> etiqueta para especificar el método de autenticación como FORM -

<web-app>
   ...
   <security-constraint>
      <web-resource-collection>
         <web-resource-name>SecuredBookSite</web-resource-name>
         <url-pattern>/secured/*</url-pattern>
            <http-method>GET</http-method>
            <http-method>POST</http-method>
      </web-resource-collection>
      
      <auth-constraint>
         <description>Let only managers use this app</description>
         <role-name>manager</role-name>
      </auth-constraint>
   </security-constraint>
   
   <security-role>
      <role-name>manager</role-name>
   </security-role>
   
   <login-config>
      <auth-method>FORM</auth-method>
      <form-login-config>
         <form-login-page>/login.jsp</form-login-page>
         <form-error-page>/error.jsp</form-error-page>
      </form-login-config>
   </login-config>
   ...
</web-app>

Ahora, cuando intente acceder a cualquier recurso con URL /secured/*, mostrará el formulario anterior solicitando la identificación de usuario y la contraseña. Cuando el contenedor ve el "j_security_check", utiliza algún mecanismo interno para autenticar a la persona que llama.

Si el inicio de sesión se realiza correctamente y la persona que llama está autorizada a acceder al recurso seguro, el contenedor utiliza un identificador de sesión para identificar una sesión de inicio de sesión para la persona que llama a partir de ese momento. El contenedor mantiene la sesión de inicio de sesión con una cookie que contiene el ID de sesión. El servidor envía la cookie al cliente y, siempre que la persona que llama presente esta cookie con las solicitudes posteriores, el contenedor sabrá quién es la persona que llama.

Si el inicio de sesión falla, el servidor devuelve la página identificada por la configuración de página de error de formulario

Aquí, j_security_checkes la acción que las aplicaciones que utilizan el inicio de sesión basado en formulario deben especificar para el formulario de inicio de sesión. De la misma forma, también debería tener un control de entrada de texto llamadoj_username y un password input control llamado j_password. Cuando vea esto, significa que la información contenida en el formulario se enviará al servidor, que verificará el nombre y la contraseña. Cómo se hace esto es específico del servidor.

Consulte Implementaciones de reino estándar para comprender cómoj_security_check funciona para el contenedor Tomcat.

Seguridad programática en un servlet / JSP

los HttpServletRequest El objeto proporciona los siguientes métodos, que se pueden utilizar para extraer información de seguridad en tiempo de ejecución:

S.No.	Método y descripción
1	String getAuthType() los getAuthType() El método devuelve un objeto String que representa el nombre del esquema de autenticación utilizado para proteger el Servlet.
2	boolean isUserInRole(java.lang.String role) los isUserInRole() El método devuelve un valor booleano: verdadero si el usuario está en el rol dado o falso si no lo está.
3	String getProtocol() los getProtocol()El método devuelve un objeto String que representa el protocolo que se utilizó para enviar la solicitud. Este valor se puede verificar para determinar si se utilizó un protocolo seguro.
4	boolean isSecure() los isSecure()El método devuelve un valor booleano que representa si la solicitud se realizó mediante HTTPS. Un valor de verdadero significa que lo fue y la conexión es segura. Un valor de falso significa que la solicitud no lo fue.
5	Principle getUserPrinciple() los getUserPrinciple() El método devuelve un objeto java.security.Principle que contiene el nombre del usuario autenticado actual.

Por ejemplo, para una página de JavaServer que enlaza con páginas para administradores, es posible que tenga el siguiente código:

<% if (request.isUserInRole("manager")) { %>
   <a href = "managers/mgrreport.jsp">Manager Report</a>
   <a href = "managers/personnel.jsp">Personnel Records</a>
<% } %>

Al verificar el rol del usuario en un JSP o servlet, puede personalizar la página web para mostrar al usuario solo los elementos a los que puede acceder. Si necesita el nombre del usuario tal como se ingresó en el formulario de autenticación, puede llamar algetRemoteUser método en el objeto de solicitud.

En este capítulo, discutiremos el concepto de internacionalización en JSP. Antes de continuar, comprendamos los siguientes tres términos importantes:

• Internationalization (i18n) - Esto significa permitir que un sitio web proporcione diferentes versiones de contenido traducidas al idioma o nacionalidad del visitante.

• Localization (l10n) - Esto significa agregar recursos a un sitio web para adaptarlo a una región geográfica o cultural en particular, por ejemplo, la traducción del hindi a un sitio web.

• locale- Ésta es una región geográfica o cultural particular. Por lo general, se lo conoce como un símbolo de idioma seguido de un símbolo de país que están separados por un guión bajo. Por ejemplo, "en_US"representa la configuración regional en inglés de EE. UU.

Hay una serie de elementos que deben tenerse en cuenta al crear un sitio web global. Este tutorial no le dará detalles completos sobre esto, pero le dará un buen ejemplo de cómo puede ofrecer su página web en diferentes idiomas a la comunidad de Internet al diferenciar su ubicación, es decir, la configuración regional.

Una JSP puede elegir la versión adecuada del sitio según la configuración regional del solicitante y proporcionar la versión adecuada del sitio de acuerdo con el idioma, la cultura y los requisitos locales. A continuación se muestra el método del objeto de solicitud que devuelve el objeto Locale.

java.util.Locale request.getLocale()

Detectando la configuración regional

A continuación se muestran los métodos de configuración regional importantes que puede utilizar para detectar requester's location, language y por supuesto locale. Todos los métodos siguientes muestran el nombre del país y el nombre del idioma establecidos en el navegador del solicitante.

S.No.	Método y descripción
1	String getCountry() Este método devuelve el código de país / región en mayúsculas para esta configuración regional en formato ISO 3166 de 2 letras.
2	String getDisplayCountry() Este método devuelve un nombre para el país de la configuración regional que es apropiado para mostrar al usuario.
3	String getLanguage() Este método devuelve el código de idioma en minúsculas para esta configuración regional en formato ISO 639.
4	String getDisplayLanguage() Este método devuelve un nombre para el idioma de la configuración regional que es apropiado para mostrar al usuario.
5	String getISO3Country() Este método devuelve una abreviatura de tres letras para el país de esta configuración regional.
6	String getISO3Language() Este método devuelve una abreviatura de tres letras para el idioma de esta configuración regional.

Ejemplo

El siguiente ejemplo muestra cómo mostrar un idioma y un país asociado para una solicitud en una JSP:

<%@ page import = "java.io.*,java.util.Locale" %>
<%@ page import = "javax.servlet.*,javax.servlet.http.* "%>
<%
   //Get the client's Locale
   Locale locale = request.getLocale();
   String language = locale.getLanguage();
   String country = locale.getCountry();
%>

<html>
   <head>
      <title>Detecting Locale</title>
   </head>

   <body>
      <center>
         <h1>Detecting Locale</h1>
      </center>
      
      <p align = "center">
         <% 
            out.println("Language : " + language  + "<br />");
            out.println("Country  : " + country   + "<br />");
         %>
      </p>
   </body>
</html>

Configuración de idiomas

Una JSP puede generar una página escrita en un idioma de Europa occidental como inglés, español, alemán, francés, italiano, holandés, etc. Aquí es importante configurar el encabezado Content-Language para mostrar todos los caracteres correctamente.

Otro punto importante es mostrar todos los caracteres especiales usando entidades HTML; por ejemplo,"&#241;" representa "ñ"y "&#161;" representa "¡" como sigue -

<%@ page import = "java.io.*,java.util.Locale" %>
<%@ page import = "javax.servlet.*,javax.servlet.http.* "%>

<%
   // Set response content type
   response.setContentType("text/html");
   
   // Set spanish language code.
   response.setHeader("Content-Language", "es");
   String title = "En Español";
%>

<html>
   <head>
      <title><%  out.print(title); %></title>
   </head>
   
   <body>
      <center>
         <h1><%  out.print(title); %></h1>
      </center>
      
      <div align = "center">
         <p>En Español</p>
         <p>¡Hola Mundo!</p>
      </div>
   </body>
</html>

Fechas específicas de la configuración regional

Puedes usar el java.text.DateFormat clase y su estática getDateTimeInstance( )método para formatear la fecha y la hora específicas de la configuración regional. A continuación se muestra el ejemplo que muestra cómo formatear fechas específicas para una configuración regional determinada:

<%@ page import = "java.io.*,java.util.Locale" %>
<%@ page import = "javax.servlet.*,javax.servlet.http.* "%>
<%@ page import = "java.text.DateFormat,java.util.Date" %>

<%
   String title = "Locale Specific Dates";
   
   //Get the client's Locale
   Locale locale = request.getLocale( );
   
   String date = DateFormat.getDateTimeInstance(
      DateFormat.FULL, 
      DateFormat.SHORT, 
      locale).format(new Date( ));
%>

<html>
   
   <head>
      <title><% out.print(title); %></title>
   </head>
   
   <body>
      <center>
         <h1><% out.print(title); %></h1>
      </center>
      
      <div align = "center">
         <p>Local Date: <%  out.print(date); %></p>
      </div>
   </body>
</html>

Moneda específica de la configuración regional

Puedes usar el java.txt.NumberFormat clase y su estática getCurrencyInstance( )método para formatear un número, como un tipo largo o doble, en una moneda específica de la configuración regional. A continuación se muestra el ejemplo que muestra cómo formatear una moneda específica para una configuración regional determinada:

<%@ page import = "java.io.*,java.util.Locale" %>
<%@ page import = "javax.servlet.*,javax.servlet.http.* "%>
<%@ page import = "java.text.NumberFormat,java.util.Date" %>

<%
   String title = "Locale Specific Currency";
   
   //Get the client's Locale
   Locale locale = request.getLocale( );
   
   NumberFormat nft = NumberFormat.getCurrencyInstance(locale);
   String formattedCurr = nft.format(1000000);
%>

<html>
   
   <head>
      <title><% out.print(title); %></title>
   </head>
   
   <body>
      <center>
         <h1><% out.print(title); %></h1>
      </center>
      
      <div align = "center">
         <p>Formatted Currency: <%  out.print(formattedCurr); %></p>
      </div>
   </body>
</html>

Porcentaje específico de la configuración regional

Puedes usar el java.txt.NumberFormat clase y su estática getPercentInstance( )método para obtener el porcentaje específico de la configuración regional. El siguiente ejemplo muestra cómo formatear el porcentaje específico de una configuración regional determinada:

<%@ page import = "java.io.*,java.util.Locale" %>
<%@ page import = "javax.servlet.*,javax.servlet.http.* "%>
<%@ page import = "java.text.NumberFormat,java.util.Date" %>

<%
   String title = "Locale Specific Percentage";
   
   //Get the client's Locale
   Locale locale = request.getLocale( );
   
   NumberFormat nft = NumberFormat.getPercentInstance(locale);
   String formattedPerc = nft.format(0.51);
%>

<html>
   
   <head>
      <title><% out.print(title); %></title>
   </head>
   
   <body>
      <center>
         <h1><% out.print(title); %></h1>
      </center>
      
      <div align = "center">
         <p>Formatted Percentage: <%  out.print(formattedPerc); %></p>
      </div>
   </body>
</html>