Servlets - Guía rápida
¿Qué son los servlets?
Los servlets Java son programas que se ejecutan en un servidor web o de aplicaciones y actúan como una capa intermedia entre las solicitudes que provienen de un navegador web u otro cliente HTTP y las bases de datos o aplicaciones en el servidor HTTP.
Con Servlets, 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.
Los servlets de Java a menudo tienen el mismo propósito que los programas implementados utilizando la Interfaz de puerta de enlace común (CGI). Pero los Servlets ofrecen varias ventajas en comparación con CGI.
El rendimiento es significativamente mejor.
Los servlets se ejecutan dentro del espacio de direcciones de un servidor web. No es necesario crear un proceso separado para manejar cada solicitud de cliente.
Los servlets son independientes de la plataforma porque están escritos en Java.
El administrador de seguridad de Java en el servidor impone un conjunto de restricciones para proteger los recursos en una máquina servidor. Entonces los servlets son confiables.
La funcionalidad completa de las bibliotecas de clases de Java está disponible para un servlet. Puede comunicarse con applets, bases de datos u otro software a través de los mecanismos de conexión y RMI que ya ha visto.
Arquitectura de servlets
El siguiente diagrama muestra la posición de los servlets en una aplicación web.
Tareas de servlets
Los servlets realizan las siguientes tareas principales:
Leer los datos explícitos enviados por los clientes (navegadores). Esto incluye un formulario HTML en una página web o también podría provenir de un subprograma o un programa cliente HTTP personalizado.
Lea los datos de solicitud HTTP implícitos enviados por los clientes (navegadores). Esto incluye cookies, tipos de medios y esquemas de compresión que el navegador comprende, etc.
Procese los datos y genere los resultados. Este proceso puede requerir hablar con una base de datos, ejecutar una llamada RMI o CORBA, invocar un servicio web o calcular la respuesta directamente.
Envíe los datos explícitos (es decir, el documento) a los clientes (navegadores). Este documento se puede enviar en una variedad de formatos, incluidos texto (HTML o XML), binarios (imágenes GIF), Excel, etc.
Envíe la respuesta HTTP implícita a los clientes (navegadores). Esto incluye decirle a los navegadores u otros clientes qué tipo de documento se está devolviendo (por ejemplo, HTML), configurar cookies y parámetros de almacenamiento en caché y otras tareas similares.
Paquetes de servlets
Los Java Servlets son clases de Java ejecutadas por un servidor web que tiene un intérprete que admite la especificación de Java Servlet.
Los servlets se pueden crear usando el javax.servlet y javax.servlet.http paquetes, que son una parte estándar de la edición empresarial de Java, una versión ampliada de la biblioteca de clases de Java que admite proyectos de desarrollo a gran escala.
Estas clases implementan las especificaciones Java Servlet y JSP. En el momento de escribir este tutorial, las versiones son Java Servlet 2.5 y JSP 2.1.
Los servlets de Java se han creado y compilado como cualquier otra clase de Java. Después de instalar los paquetes de servlets y agregarlos al Classpath de su computadora, puede compilar los servlets con el compilador Java del JDK o cualquier otro compilador actual.
¿Lo que sigue?
Lo guiaría paso a paso para configurar su entorno para comenzar con Servlets. Así que abróchese el cinturón para disfrutar de un buen viaje con Servlets. Estoy seguro de que disfrutarás mucho de este tutorial.
Un entorno de desarrollo es donde desarrollaría su Servlet, lo probaría y finalmente lo ejecutaría.
Como cualquier otro programa de Java, necesita compilar un servlet usando el compilador de Java javac y después de compilar la aplicación de servlet, se implementaría en un entorno configurado para probar y ejecutar.
Esta configuración del entorno de desarrollo 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 las variables de entorno PATH y JAVA_HOME para hacer referencia al directorio que contiene java y javac, normalmente java_install_dir / bin y java_install_dir respectivamente.
Si está ejecutando Windows e instaló el SDK en C: \ jdk1.8.0_65, colocaría la siguiente línea en su archivo C: \ autoexec.bat.
set PATH = C:\jdk1.8.0_65\bin;%PATH%
set JAVA_HOME = C:\jdk1.8.0_65Alternativamente, en Windows NT / 2000 / XP, también puede hacer clic con el botón derecho en Mi PC, seleccionar Propiedades, luego Avanzado, luego Variables de entorno. 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.8.0_65 y usa el shell C, pondría lo siguiente en su archivo .cshrc.
setenv PATH /usr/local/jdk1.8.0_65/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.8.0_65Alternativamente, si usa un entorno de desarrollo integrado (IDE) como Borland JBuilder, Eclipse, IntelliJ IDEA o 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
En el mercado hay disponibles varios servidores web que admiten servlets. Algunos servidores web se pueden descargar gratuitamente y Tomcat es uno de ellos.
Apache Tomcat es una implementación de software de código abierto de las tecnologías Java Servlet y Java Server Pages y puede actuar como un servidor independiente para probar 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 desde https://tomcat.apache.org/.
Una vez que descargó la instalación, descomprima la distribución binaria en una ubicación conveniente. Por ejemplo, en C: \ apache-tomcat-8.0.28 en Windows, o /usr/local/apache-tomcat-8.0.289 en Linux / Unix y cree la variable de entorno CATALINA_HOME apuntando 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-8.0.28\bin\startup.batTomcat se puede iniciar ejecutando los siguientes comandos en una máquina Unix (Solaris, Linux, etc.):
$CATALINA_HOME/bin/startup.sh
or
/usr/local/apache-tomcat-8.0.28/bin/startup.shDespués del inicio, las aplicaciones web predeterminadas incluidas con Tomcat estarán disponibles visitando http://localhost:8080/. Si todo está bien, debería mostrar 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: http://tomcat.apache.org
Tomcat se puede detener ejecutando los siguientes comandos en la máquina con Windows:
C:\apache-tomcat-8.0.28\bin\shutdownTomcat se puede detener ejecutando los siguientes comandos en una máquina Unix (Solaris, Linux, etc.):
/usr/local/apache-tomcat-8.0.28/bin/shutdown.shConfiguració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 archivo C: \ autoexec.bat.
set CATALINA = C:\apache-tomcat-8.0.28
set CLASSPATH = %CATALINA%\common\lib\servlet-api.jar;%CLASSPATH%Alternativamente, en Windows NT / 2000 / XP, puede ir a Mi PC -> Propiedades -> Avanzado -> Variables de entorno. 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 colocar las siguientes líneas en su archivo .cshrc.
setenv CATALINA = /usr/local/apache-tomcat-8.0.28
setenv CLASSPATH $CATALINA/common/lib/servlet-api.jar:$CLASSPATHNOTE - Suponiendo que su directorio de desarrollo es C: \ ServletDevel (Windows) o / usr / ServletDevel (Unix), entonces necesitaría agregar estos directorios también en CLASSPATH de manera similar a como lo ha agregado anteriormente.
El ciclo de vida de un servlet se puede definir como el proceso completo desde su creación hasta su destrucción. Las siguientes son las rutas seguidas por un servlet.
El servlet se inicializa llamando al init() método.
El servlet llama service() método para procesar la solicitud de un cliente.
El servlet se termina llamando al destroy() método.
Finalmente, el servlet es basura recolectada por el recolector de basura de la JVM.
Ahora analicemos los métodos del ciclo de vida en detalle.
El método init ()
El método init se llama solo una vez. Solo se llama cuando se crea el servlet y no se llama para solicitudes de usuario posteriormente. Por lo tanto, se usa para inicializaciones únicas, al igual que con el método init de los applets.
El servlet normalmente se crea cuando un usuario invoca por primera vez una URL correspondiente al servlet, pero también puede especificar que el servlet se cargue cuando el servidor se inicia por primera vez.
Cuando un usuario invoca un servlet, se crea una única instancia de cada servlet, y cada solicitud de usuario da como resultado un nuevo hilo que se pasa a doGet o doPost según corresponda. El método init () simplemente crea o carga algunos datos que se utilizarán durante la vida útil del servlet.
La definición del método init se ve así:
public void init() throws ServletException {
// Initialization code...
}El método service ()
El método service () es el método principal para realizar la tarea real. El contenedor de servlets (es decir, el servidor web) llama al método service () para manejar las solicitudes provenientes del cliente (navegadores) y para escribir la respuesta formateada al cliente.
Cada vez que el servidor recibe una solicitud de un servlet, el servidor genera un nuevo hilo y llama al servicio. El método service () verifica el tipo de solicitud HTTP (GET, POST, PUT, DELETE, etc.) y llama a los métodos doGet, doPost, doPut, doDelete, etc., según corresponda.
Aquí está la firma de este método:
public void service(ServletRequest request, ServletResponse response)
throws ServletException, IOException {
}El método service () es llamado por el contenedor y el método service invoca los métodos doGet, doPost, doPut, doDelete, etc., según corresponda. Por lo tanto, no tiene nada que ver con el método service (), pero anula doGet () o doPost () según el tipo de solicitud que reciba del cliente.
DoGet () y doPost () son los métodos más utilizados en cada solicitud de servicio. Aquí está la firma de estos dos métodos.
El método doGet ()
Una solicitud GET es el resultado de una solicitud normal de una URL o de un formulario HTML que no tiene METHOD especificado y debe ser manejado por el método doGet ().
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Servlet code
}El método doPost ()
Una solicitud POST resulta de un formulario HTML que enumera específicamente POST como METHOD y debe ser manejado por el método doPost ().
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Servlet code
}El método destroy ()
El método destroy () se llama solo una vez al final del ciclo de vida de un servlet. Este método le da a su servlet la oportunidad de cerrar conexiones de base de datos, detener subprocesos en segundo plano, escribir listas de cookies o conteos de visitas al disco y realizar otras actividades de limpieza.
Después de que se llama al método destroy (), el objeto servlet se marca para la recolección de basura. La definición del método de destrucción se ve así:
public void destroy() {
// Finalization code...
}Diagrama de arquitectura
La siguiente figura muestra un escenario típico del ciclo de vida de un servlet.
Primero, las solicitudes HTTP que llegan al servidor se delegan al contenedor de servlets.
El contenedor de servlets carga el servlet antes de invocar el método service ().
Luego, el contenedor de servlets maneja múltiples solicitudes generando múltiples subprocesos, cada subproceso ejecuta el método service () de una sola instancia del servlet.
Los servlets son clases de Java que atienden solicitudes HTTP e implementan javax.servlet.Servletinterfaz. Los desarrolladores de aplicaciones web suelen escribir servlets que amplían javax.servlet.http.HttpServlet, una clase abstracta que implementa la interfaz Servlet y está especialmente diseñada para manejar solicitudes HTTP.
Código de muestra
A continuación se muestra la estructura de código fuente de muestra de un ejemplo de servlet para mostrar Hello World:
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class HelloWorld extends HttpServlet {
private String message;
public void init() throws ServletException {
// Do required initialization
message = "Hello World";
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
// Actual logic goes here.
PrintWriter out = response.getWriter();
out.println("<h1>" + message + "</h1>");
}
public void destroy() {
// do nothing.
}
}Compilar un servlet
Creemos un archivo con el nombre HelloWorld.java con el código que se muestra arriba. Coloque este archivo en C: \ ServletDevel (en Windows) o en / usr / ServletDevel (en Unix). Esta ubicación de ruta debe agregarse a CLASSPATH antes de continuar.
Suponiendo que su entorno está configurado correctamente, ingrese ServletDevel directorio y compile HelloWorld.java de la siguiente manera:
$ javac HelloWorld.javaSi el servlet depende de otras bibliotecas, también debe incluir esos archivos JAR en su CLASSPATH. Solo he incluido el archivo JAR servlet-api.jar porque no estoy usando ninguna otra biblioteca en el programa Hello World.
Esta línea de comandos utiliza el compilador javac integrado que viene con el kit de desarrollo de software Java de Sun Microsystems (JDK). Para que este comando funcione correctamente, debe incluir la ubicación del SDK de Java que está utilizando en la variable de entorno PATH.
Si todo va bien, la compilación anterior produciría HelloWorld.classarchivo en el mismo directorio. La siguiente sección explicaría cómo se implementaría un servlet compilado en producción.
Implementación de servlet
De forma predeterminada, una aplicación de servlet se encuentra en la ruta <Tomcat-installationdirectory> / webapps / ROOT y el archivo de clase residiría en <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes.
Si tiene un nombre de clase completamente calificado de com.myorg.MyServlet, entonces esta clase de servlet debe estar ubicada en WEB-INF / classes / com / myorg / MyServlet.class.
Por ahora, copiemos HelloWorld.class en <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes y creemos las siguientes entradas en web.xml archivo ubicado en <Tomcat-installation-directory> / webapps / ROOT / WEB-INF /
<servlet>
<servlet-name>HelloWorld</servlet-name>
<servlet-class>HelloWorld</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloWorld</servlet-name>
<url-pattern>/HelloWorld</url-pattern>
</servlet-mapping>Las entradas anteriores se crearán dentro de las etiquetas <web-app> ... </web-app> disponibles en el archivo web.xml. Podría haber varias entradas en esta tabla ya disponibles, pero no importa.
Ya casi ha terminado, ahora iniciemos el servidor Tomcat usando <Tomcat-installationdirectory> \ bin \ startup.bat (en Windows) o <Tomcat-installationdirectory> /bin/startup.sh (en Linux / Solaris, etc.) y finalmente escriba http://localhost:8080/HelloWorlden el cuadro de dirección del navegador. Si todo va bien, obtendría el siguiente resultado
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.
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? (signo de interrogación) símbolo de la siguiente manera:
http://www.test.com/hello?key1 = value1&key2 = value2El 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 cuadro Ubicación: de su navegador. Nunca use el método GET si tiene una contraseña u otra información confidencial para pasar al servidor. El método GET tiene una limitación de tamaño: solo se pueden usar 1024 caracteres en una cadena de solicitud.
Esta información se pasa usando el encabezado QUERY_STRING y será accesible a través de la variable de entorno QUERY_STRING y Servlet maneja este tipo de solicitudes usando doGet() método.
Método POST
Un método generalmente más confiable para pasar información a un programa de backend es el método POST. Esto 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? (signo de interrogación) 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. Servlet maneja este tipo de solicitudes usandodoPost() método.
Lectura de datos de formulario usando Servlet
Servlets maneja el análisis de datos de formularios automáticamente usando los siguientes métodos dependiendo de la situación:
getParameter() - Llamas al método request.getParameter () 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.
Ejemplo de método GET usando URL
Aquí hay una URL simple que pasará dos valores al programa HelloForm usando el método GET.
http://localhost:8080/HelloForm?first_name = ZARA&last_name = ALIA continuación se muestra el HelloForm.javaprograma servlet para manejar la entrada proporcionada por el navegador web. Vamos a usargetParameter() método que hace que sea muy fácil acceder a la información transmitida -
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class HelloForm extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Using GET Method to Read Form Data";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<ul>\n" +
" <li><b>First Name</b>: "
+ request.getParameter("first_name") + "\n" +
" <li><b>Last Name</b>: "
+ request.getParameter("last_name") + "\n" +
"</ul>\n" +
"</body>" +
"</html>"
);
}
}Suponiendo que su entorno esté configurado correctamente, compile HelloForm.java de la siguiente manera:
$ javac HelloForm.javaSi todo va bien, la compilación anterior produciría HelloForm.classarchivo. A continuación, tendría que copiar este archivo de clase en <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes y crear las siguientes entradas enweb.xml archivo ubicado en <Tomcat-installation-directory> / webapps / ROOT / WEB-INF /
<servlet>
<servlet-name>HelloForm</servlet-name>
<servlet-class>HelloForm</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloForm</servlet-name>
<url-pattern>/HelloForm</url-pattern>
</servlet-mapping>Ahora escriba http: // localhost: 8080 / HelloForm? First_name = ZARA & last_name = ALI en el cuadro Ubicación: de su navegador y asegúrese de haber iniciado el servidor Tomcat, antes de activar el comando anterior en el navegador. Esto generaría el siguiente resultado:
Using GET Method to Read Form Data
- First Name: ZARA
- Last Name: ALI
Ejemplo de método GET usando formulario
Aquí hay un ejemplo simple que pasa dos valores usando FORMATO HTML y el botón Enviar. Vamos a utilizar el mismo Servlet HelloForm para manejar esta entrada.
<html>
<body>
<form action = "HelloForm" 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>Guarde este HTML en un archivo Hello.htm y colóquelo en el directorio <Tomcat-installationdirectory> / webapps / ROOT. Cuando acceda a http: // localhost: 8080 / Hello.htm , aquí está el resultado real del formulario anterior.
Intente ingresar el nombre y 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 entrada proporcionada, generará un resultado similar al mencionado en el ejemplo anterior.
Ejemplo de método POST usando formulario
Hagamos una pequeña modificación en el servlet anterior, para que pueda manejar los métodos GET y POST. A continuación esHelloForm.java programa servlet para manejar la entrada proporcionada por el navegador web usando métodos GET o POST.
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class HelloForm extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Using GET Method to Read Form Data";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " +
"transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<ul>\n" +
" <li><b>First Name</b>: "
+ request.getParameter("first_name") + "\n" +
" <li><b>Last Name</b>: "
+ request.getParameter("last_name") + "\n" +
"</ul>\n" +
"</body>"
"</html>"
);
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}Ahora compile e implemente el Servlet anterior y pruébelo usando Hello.htm con el método POST de la siguiente manera:
<html>
<body>
<form action = "HelloForm" 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>Aquí está el resultado real del formulario anterior, intente ingresar el nombre y 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, generaría un resultado similar al mencionado en los ejemplos anteriores.
Pasar datos de casilla de verificación al programa de servlet
Las casillas de verificación se utilizan cuando se requiere seleccionar más de una opción.
A continuación se muestra un código HTML de ejemplo, CheckBox.htm, para un formulario con dos casillas de verificación
<html>
<body>
<form action = "CheckBox" 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 resultado de este código es el siguiente formulario
A continuación se muestra el programa servlet CheckBox.java para manejar la entrada proporcionada por el navegador web para el botón de casilla de verificación.
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class CheckBox extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Reading Checkbox Data";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<ul>\n" +
" <li><b>Maths Flag : </b>: "
+ request.getParameter("maths") + "\n" +
" <li><b>Physics Flag: </b>: "
+ request.getParameter("physics") + "\n" +
" <li><b>Chemistry Flag: </b>: "
+ request.getParameter("chemistry") + "\n" +
"</ul>\n" +
"</body>"
"</html>"
);
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}Para el ejemplo anterior, mostraría 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 el 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 manera estándar usando el método hasMoreElements () para determinar cuándo parar y usando el método nextElement () para obtener cada nombre de parámetro.
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class ReadParams extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Reading All Form Parameters";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<table width = \"100%\" border = \"1\" align = \"center\">\n" +
"<tr bgcolor = \"#949494\">\n" +
"<th>Param Name</th>"
"<th>Param Value(s)</th>\n"+
"</tr>\n"
);
Enumeration paramNames = request.getParameterNames();
while(paramNames.hasMoreElements()) {
String paramName = (String)paramNames.nextElement();
out.print("<tr><td>" + paramName + "</td>\n<td>");
String[] paramValues = request.getParameterValues(paramName);
// Read single valued data
if (paramValues.length == 1) {
String paramValue = paramValues[0];
if (paramValue.length() == 0)
out.println("<i>No Value</i>");
else
out.println(paramValue);
} else {
// Read multiple valued data
out.println("<ul>");
for(int i = 0; i < paramValues.length; i++) {
out.println("<li>" + paramValues[i]);
}
out.println("</ul>");
}
}
out.println("</tr>\n</table>\n</body></html>");
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}Ahora, pruebe el servlet anterior con el siguiente formulario:
<html>
<body>
<form action = "ReadParams" 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 llamar al servlet usando el formulario anterior generaría el siguiente resultado:
Reading All Form Parameters
Param Name
Param Value(s)
maths
on
chemistry
on
Puede probar el servlet anterior para leer los datos de cualquier otro formulario que tenga otros objetos como cuadro de texto, botón de radio o cuadro desplegable, etc.
Cuando un navegador solicita una página web, envía mucha información al servidor web que 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.
A continuación se muestra la información importante del encabezado que proviene del lado del navegador y que usaría con mucha frecuencia en la programación web:
| No Señor. | Encabezado y descripción |
|---|---|
| 1 | Accept Este encabezado especifica los tipos MIME 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 ejemplo en, en-us, ru, etc. |
| 5 | Authorization Los clientes utilizan este encabezado para identificarse cuando acceden a páginas web protegidas por 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 las solicitudes POST y proporciona 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 la página web de referencia. Por ejemplo, si se encuentra 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 de referencia 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. |
Métodos para leer el encabezado HTTP
Existen los siguientes métodos que pueden usarse para leer el encabezado HTTP en su programa de servlet. Estos métodos están disponibles con el objeto HttpServletRequest
| No Señor. | 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 objetos String que contiene 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 el valor de 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 el cliente envió cuando realizó esta solicitud. |
| 18 | String getProtocol() Devuelve el nombre y la versión del protocolo de 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 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 HttpServletRequest para 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, usando el método hasMoreElements () para determinar cuándo detenerse y usando el método nextElement () para obtener cada nombre de parámetro
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class DisplayHeader extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "HTTP Header Request Example";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n"+
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<table width = \"100%\" border = \"1\" align = \"center\">\n" +
"<tr bgcolor = \"#949494\">\n" +
"<th>Header Name</th><th>Header Value(s)</th>\n"+
"</tr>\n"
);
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");
}
out.println("</table>\n</body></html>");
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}Ahora, llamar al servlet anterior generaría el siguiente resultado:
HTTP Header Request Example
Header Name
Header Value(s)
accept
*/*
accept-language
en-us
user-agent
Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; InfoPath.2; MS-RTC LM 8)
accept-encoding
gzip, deflate
host
localhost:8080
connection
Keep-Alive
cache-control
no-cache
Como se discutió en el capítulo anterior, cuando un servidor web responde a una solicitud HTTP, la respuesta generalmente consiste en 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 en el ejemplo), un código de estado (200 en el ejemplo) y un mensaje muy corto correspondiente al código de estado (OK en el ejemplo).
A continuación se muestra un resumen de los encabezados de respuesta HTTP 1.1 más útiles que regresan al navegador desde el lado del servidor web y los usaría con mucha frecuencia en la programación web:
| No Señor. | 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 usar persistente en las conexiones HTTP o no. Un valor declose indica al navegador que no utilice conexiones HTTP persistentes y keepalive 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 proporciona el tipo MIME (Extensión multipropósito de correo de Internet) del 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 usar junto con una respuesta 503 (Servicio no disponible) para indicarle al cliente qué tan pronto puede repetir su solicitud. |
| 14 | Set-Cookie Este encabezado especifica una cookie asociada con la página. |
Métodos para establecer el encabezado de respuesta HTTP
Existen los siguientes métodos que se pueden usar para configurar el encabezado de respuesta HTTP en su programa de servlet. Estos métodos están disponibles con el objeto HttpServletResponse .
| No Señor. | Método y descripción |
|---|---|
| 1 | String encodeRedirectURL(String url) Codifica la URL especificada para usar en el método 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 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 los servlets HTTP, este método 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
Ya ha visto el método setContentType () funcionando en ejemplos anteriores y el siguiente ejemplo también usaría el mismo método, además, usaríamos setIntHeader() método para configurar Refresh encabezamiento.
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class Refresh extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set refresh, autoload time as 5 seconds
response.setIntHeader("Refresh", 5);
// Set response content type
response.setContentType("text/html");
// 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;
PrintWriter out = response.getWriter();
String title = "Auto Refresh Header Setting";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n"+
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<p>Current Time is: " + CT + "</p>\n"
);
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}Ahora, llamar al servlet anterior mostraría la hora actual del sistema después de cada 5 segundos de la siguiente manera. Simplemente ejecute el servlet y espere a ver el resultado:
Auto Refresh Header Setting
Current Time is: 9:44:50 PM
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 tiene el siguiente aspecto:
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 en el ejemplo), un código de estado (200 en el ejemplo) y un mensaje muy corto correspondiente al código de estado (OK en el ejemplo).
A continuación se muestra una lista de códigos de estado HTTP y 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 | Todavía 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. Ocurre cuando convierte una solicitud de "publicación" en una solicitud de "obtención" 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 admite la versión "protocolo http". |
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 .
| No Señor. | 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 llamar a setStatus antes 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 es el ejemplo que enviaría un código de error 407 al navegador del cliente y el navegador le mostraría "¡Necesita autenticación!" mensaje.
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class showError extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set error code and reason.
response.sendError(407, "Need authentication!!!" );
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}Ahora llamar al servlet anterior mostraría el siguiente resultado:
HTTP Status 407 - Need authentication!!!
type Status report
messageNeed authentication!!!
descriptionThe client must first authenticate itself with the proxy (Need authentication!!!).
Apache Tomcat/5.5.29
Los filtros de servlet son clases de Java que se pueden usar en la programación de servlet para los siguientes propósitos:
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 TIPO MIME.
- Filtros de tokenización.
- Filtros XSL / T que transforman el contenido XML.
Los filtros se implementan en el archivo descriptor de implementación web.xml y luego mapee a nombres de servlet o patrones de URL en el descriptor de implementación de su aplicación.
Cuando el contenedor web 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 interfaz javax.servlet.Filter. La interfaz javax.servlet.Filter define tres métodos:
| No Señor. | 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. |
Filtro de servlet - Ejemplo
A continuación se muestra el ejemplo de filtro de servlet que imprimiría la dirección IP del cliente y la fecha y hora actual. Este ejemplo le daría una comprensión básica de Servlet Filter, pero puede escribir aplicaciones de filtro más sofisticadas usando 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 coloque su archivo de clase en <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes
Asignación de filtros de servlet en Web.xml
Los filtros se definen y luego se asignan a una URL o Servlet, de la misma manera que se define Servlet y luego se asigna a un patrón de URL. 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 a todos los servlets porque especificamos /*en nuestra configuración. Puede especificar una ruta de servlet en particular si desea aplicar el filtro solo en algunos servlets.
Ahora intente llamar a cualquier servlet de la forma habitual y verá el registro generado en el registro de su servidor web. Puede usar el registrador Log4J 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 permanecería 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. Para invertir el orden del filtro, solo necesita invertir los elementos de mapeo de filtro en el archivo web.xml.
Por ejemplo, el ejemplo anterior aplicaría LogFilter primero y luego aplicaría AuthenFilter a cualquier servlet, pero el siguiente ejemplo invertiría 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>Cuando un servlet lanza una excepción, el contenedor web busca las configuraciones en web.xml que utilizan el elemento de tipo de excepción para una coincidencia con el tipo de excepción lanzada.
Tendrías que usar el error-page elemento en web.xml para especificar la invocación de servlets en respuesta a ciertos exceptions o HTTP status codes.
Configuración web.xml
Considere que tiene un servlet ErrorHandler al que se llamaría siempre que hubiera una excepción o error definido. La siguiente sería la entrada creada en web.xml.
<!-- servlet definition -->
<servlet>
<servlet-name>ErrorHandler</servlet-name>
<servlet-class>ErrorHandler</servlet-class>
</servlet>
<!-- servlet mappings -->
<servlet-mapping>
<servlet-name>ErrorHandler</servlet-name>
<url-pattern>/ErrorHandler</url-pattern>
</servlet-mapping>
<!-- error-code related error pages -->
<error-page>
<error-code>404</error-code>
<location>/ErrorHandler</location>
</error-page>
<error-page>
<error-code>403</error-code>
<location>/ErrorHandler</location>
</error-page>
<!-- exception-type related error pages -->
<error-page>
<exception-type>
javax.servlet.ServletException
</exception-type >
<location>/ErrorHandler</location>
</error-page>
<error-page>
<exception-type>java.io.IOException</exception-type >
<location>/ErrorHandler</location>
</error-page>Si desea tener un controlador de errores genérico para todas las excepciones, debe definir la siguiente página de error en lugar de definir elementos de página de error separados para cada excepción:
<error-page>
<exception-type>java.lang.Throwable</exception-type >
<location>/ErrorHandler</location>
</error-page>Los siguientes son los puntos que deben tenerse en cuenta sobre el web.xml anterior para el manejo de excepciones:
El servlet ErrorHandler se define de forma habitual como cualquier otro servlet y se configura en web.xml.
Si hay algún error con el código de estado 404 (No encontrado) o 403 (Prohibido), se llamará al servlet ErrorHandler.
Si la aplicación web lanza ServletException o IOException, el contenedor web invoca el servlet / ErrorHandler.
Puede definir diferentes controladores de errores para manejar diferentes tipos de errores o excepciones. El ejemplo anterior es muy genérico y espero que sirva para explicarle el concepto básico.
Solicitar atributos: errores / excepciones
A continuación se muestra la lista de atributos de solicitud a los que un servlet de manejo de errores puede acceder para analizar la naturaleza del error / excepción.
| No Señor. | Atributo y descripción |
|---|---|
| 1 | javax.servlet.error.status_code Este atributo proporciona un código de estado que se puede almacenar y analizar después de almacenarlo en un tipo de datos java.lang.Integer. |
| 2 | javax.servlet.error.exception_type Este atributo proporciona información sobre el tipo de excepción que se puede almacenar y analizar después de almacenar en un tipo de datos java.lang.Class. |
| 3 | javax.servlet.error.message Este atributo proporciona información sobre el mensaje de error exacto que se puede almacenar y analizar después de almacenar en un tipo de datos java.lang.String. |
| 4 | javax.servlet.error.request_uri Este atributo proporciona información sobre la URL que llama al servlet y se puede almacenar y analizar después de almacenarlo en un tipo de datos java.lang.String. |
| 5 | javax.servlet.error.exception Este atributo proporciona información sobre la excepción generada, que se puede almacenar y analizar. |
| 6 | javax.servlet.error.servlet_name Este atributo proporciona un nombre de servlet que se puede almacenar y analizar después de almacenarlo en un tipo de datos java.lang.String. |
Ejemplo de servlet de controlador de errores
Este ejemplo le brindaría una comprensión básica del manejo de excepciones en Servlet, 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.*;
// Extend HttpServlet class
public class ErrorHandler extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Analyze the servlet exception
Throwable throwable = (Throwable)
request.getAttribute("javax.servlet.error.exception");
Integer statusCode = (Integer)
request.getAttribute("javax.servlet.error.status_code");
String servletName = (String)
request.getAttribute("javax.servlet.error.servlet_name");
if (servletName == null) {
servletName = "Unknown";
}
String requestUri = (String)
request.getAttribute("javax.servlet.error.request_uri");
if (requestUri == null) {
requestUri = "Unknown";
}
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Error/Exception Information";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " +
"transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n");
if (throwable == null && statusCode == null) {
out.println("<h2>Error information is missing</h2>");
out.println("Please return to the <a href=\"" +
response.encodeURL("http://localhost:8080/") +
"\">Home Page</a>.");
} else if (statusCode != null) {
out.println("The status code : " + statusCode);
} else {
out.println("<h2>Error information</h2>");
out.println("Servlet Name : " + servletName + "</br></br>");
out.println("Exception Type : " + throwable.getClass( ).getName( ) + "</br></br>");
out.println("The request URI: " + requestUri + "<br><br>");
out.println("The exception message: " + throwable.getMessage( ));
}
out.println("</body>");
out.println("</html>");
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}Compilar ErrorHandler.java de la manera habitual y ponga su archivo de clase en
Agreguemos la siguiente configuración en web.xml para manejar excepciones:
<servlet>
<servlet-name>ErrorHandler</servlet-name>
<servlet-class>ErrorHandler</servlet-class>
</servlet>
<!-- servlet mappings -->
<servlet-mapping>
<servlet-name>ErrorHandler</servlet-name>
<url-pattern>/ErrorHandler</url-pattern>
</servlet-mapping>
<error-page>
<error-code>404</error-code>
<location>/ErrorHandler</location>
</error-page>
<error-page>
<exception-type>java.lang.Throwable</exception-type >
<location>/ErrorHandler</location>
</error-page>Ahora intente usar un servlet que genere una excepción o escriba una URL incorrecta, esto haría que Web Container llame ErrorHandlerservlet y mostrar un mensaje apropiado según lo programado. Por ejemplo, si escribe una URL incorrecta, se mostrará el siguiente resultado:
The status code : 404Es posible que el código anterior no funcione con algunos navegadores web. Así que prueba con Mozilla y Safari y debería funcionar.
Las cookies son archivos de texto almacenados en la computadora del cliente y se guardan para varios propósitos de rastreo de información. Java Servlets admite de forma transparente las cookies HTTP.
Hay tres pasos involucrados en la identificación de usuarios recurrentes:
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.
La próxima vez que el navegador envíe una solicitud al servidor web, enviará la información de las cookies al servidor y el servidor utilizará esa información para identificar al usuario.
Este capítulo le enseñará cómo configurar o restablecer las cookies, cómo acceder a ellas y cómo eliminarlas.
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). Un servlet 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/htmlComo puede ver, el encabezado Set-Cookie contiene un par de nombre-valor, una fecha GMT, una ruta y un dominio. El nombre y el valor estarán codificados en URL. El campo de caducidad es una instrucción para que el navegador "olvide" 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 = xyzUn servlet tendrá acceso a la cookie a través del método de solicitud request.getCookies () que devuelve una matriz de objetos Cookie .
Métodos de cookies de servlet
A continuación se muestra la lista de métodos útiles que puede utilizar al manipular las cookies en el servlet.
| No Señor. | 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 antigüedad máxima de la cookie, especificada en segundos. De forma predeterminada, -1 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 servlet
La configuración de cookies con servlet implica tres pasos:
(1) Creating a Cookie object - Llamas al constructor de cookies con un nombre de cookie y un valor de cookie, ambos 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:
[ ] ( ) = , " / ? @ : ;(2) Setting the maximum age- Utiliza setMaxAge para especificar cuánto tiempo (en segundos) debe ser válida la cookie. Lo siguiente configuraría una cookie durante 24 horas.
cookie.setMaxAge(60 * 60 * 24);(3) Sending the Cookie into the HTTP response headers - Utiliza 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.
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class HelloForm extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// 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 );
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Setting Cookies Example";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head>
<title>" + title + "</title>
</head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<ul>\n" +
" <li><b>First Name</b>: "
+ request.getParameter("first_name") + "\n" +
" <li><b>Last Name</b>: "
+ request.getParameter("last_name") + "\n" +
"</ul>\n" +
"</body>
</html>"
);
}
}Compila el servlet anterior HelloForm y cree la entrada adecuada en el archivo web.xml y finalmente intente seguir la página HTML para llamar al servlet.
<html>
<body>
<form action = "HelloForm" 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.htm y colóquelo en el directorio <Tomcat-installationdirectory> / webapps / ROOT. Cuando acceda a http: // localhost: 8080 / Hello.htm , aquí está el resultado real del formulario anterior.
Intente ingresar el nombre y apellido y luego haga clic en el botón enviar. Esto mostraría el nombre y apellido en su pantalla y al mismo tiempo establecería dos cookies firstName y lastName que serían devueltas al servidor la próxima vez que presione el botón Enviar.
La siguiente sección le explicaría cómo accedería a estas cookies en su aplicación web.
Leer cookies con Servlet
Para leer las cookies, debe crear una matriz de objetos javax.servlet.http.Cookie llamando algetCookies()método de HttpServletRequest . Luego, recorra la matriz y use los métodos getName () y getValue () para acceder a cada cookie y valor asociado.
Ejemplo
Leamos las cookies que hemos establecido en el ejemplo anterior:
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class ReadCookies extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Cookie cookie = null;
Cookie[] cookies = null;
// Get an array of Cookies associated with this domain
cookies = request.getCookies();
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Reading Cookies Example";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " +
"transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" );
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>");
}
out.println("</body>");
out.println("</html>");
}
}Compilar el servlet anterior ReadCookiesy cree la entrada adecuada en el archivo web.xml. Si hubiera configurado la cookie first_name como "John" y la cookie last_name como "Player", al ejecutar http: // localhost: 8080 / ReadCookies se mostraría el siguiente resultado:
Found Cookies Name and Value
Name : first_name, Value: John
Name : last_name, Value: PlayerEliminar cookies con Servlet
Eliminar las cookies es muy sencillo. Si desea eliminar una cookie, simplemente debe seguir tres pasos:
Leer una cookie ya existente y almacenarla en el objeto Cookie.
Establecer la edad de la cookie como cero usando setMaxAge() método para eliminar una cookie existente
Vuelva a agregar esta cookie al encabezado de respuesta.
Ejemplo
El siguiente ejemplo eliminaría una cookie existente llamada "first_name" y cuando ejecutara el servlet ReadCookies la próxima vez, devolvería un valor nulo para first_name.
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class DeleteCookies extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Cookie cookie = null;
Cookie[] cookies = null;
// Get an array of Cookies associated with this domain
cookies = request.getCookies();
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Delete Cookies Example";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" );
if( cookies != null ) {
out.println("<h2> 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>");
}
out.println("</body>");
out.println("</html>");
}
}Compilar el servlet anterior DeleteCookiesy cree la entrada adecuada en el archivo web.xml. Ahora ejecutando http: // localhost: 8080 / DeleteCookies mostraría el siguiente resultado:
Cookies Name and Value
Deleted cookie : first_name
Name : first_name, Value: John
Name : last_name, Value: Player
Ahora intente ejecutar http: // localhost: 8080 / ReadCookies y solo mostraría una cookie de la siguiente manera:
Found Cookies Name and Value
Name : last_name, Value: PlayerPuede eliminar sus cookies en Internet Explorer manualmente. Comience en el menú Herramientas y seleccione Opciones de Internet. Para eliminar todas las cookies, presione Eliminar cookies.
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.
Aún así, existen las siguientes tres formas de 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, se pueden reconocer utilizando la cookie recibida.
Es posible que esta no sea una forma eficaz porque muchas veces el navegador no admite cookies, por lo que no recomendaría 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 los datos GET o POST. Cada vez que el navegador web devuelve la solicitud, se puede usar el valor de session_id para realizar un seguimiento de los diferentes navegadores web.
Esta podría ser una forma eficaz de realizar un seguimiento de la sesión, pero hacer clic en un enlace de hipertexto normal (<A HREF...>) no da como resultado el envío de 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 que identifica la sesión, y 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 incluso cuando los navegadores no admiten cookies. El inconveniente de la reescritura de URL es que tendría que generar cada URL de forma dinámica para asignar un ID de sesión, incluso en el caso de una página HTML estática simple.
El objeto HttpSession
Además de las tres formas mencionadas anteriormente, servlet proporciona una interfaz HttpSession que proporciona una forma de identificar a un usuario en más de una solicitud de página o visita a un sitio web y para almacenar información sobre ese usuario.
El contenedor de servlets utiliza esta interfaz para crear una sesión entre un cliente HTTP y un servidor HTTP. La sesión persiste durante un período de tiempo específico, en más de una conexión o solicitud de página del usuario.
Obtendría el objeto HttpSession llamando al método público getSession() de HttpServletRequest, como se muestra a continuación:
HttpSession session = request.getSession();Debe llamar a request.getSession () antes de enviar el contenido del documento al cliente. Aquí hay un resumen de los métodos importantes disponibles a través del objeto HttpSession:
| No Señor. | 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 hora de acceso de la sesión, en el formato 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 (segundos) que el contenedor de servlets mantendrá abierta la 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.
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class SessionTrack extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Create a session object if it is already not created.
HttpSession session = request.getSession(true);
// Get session creation time.
Date createTime = new Date(session.getCreationTime());
// Get last access time of this web page.
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 web page.
if (session.isNew()) {
title = "Welcome to my website";
session.setAttribute(userIDKey, userID);
} else {
visitCount = (Integer)session.getAttribute(visitCountKey);
visitCount = visitCount + 1;
userID = (String)session.getAttribute(userIDKey);
}
session.setAttribute(visitCountKey, visitCount);
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " +
"transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<h2 align = \"center\">Session Infomation</h2>\n" +
"<table border = \"1\" align = \"center\">\n" +
"<tr bgcolor = \"#949494\">\n" +
" <th>Session info</th><th>value</th>
</tr>\n" +
"<tr>\n" +
" <td>id</td>\n" +
" <td>" + session.getId() + "</td>
</tr>\n" +
"<tr>\n" +
" <td>Creation Time</td>\n" +
" <td>" + createTime + " </td>
</tr>\n" +
"<tr>\n" +
" <td>Time of Last Access</td>\n" +
" <td>" + lastAccessTime + " </td>
</tr>\n" +
"<tr>\n" +
" <td>User ID</td>\n" +
" <td>" + userID + " </td>
</tr>\n" +
"<tr>\n" +
" <td>Number of visits</td>\n" +
" <td>" + visitCount + "</td>
</tr>\n" +
"</table>\n" +
"</body>
</html>"
);
}
}Compila el servlet anterior SessionTracky cree la entrada adecuada en el archivo web.xml. Ahora, al ejecutar http: // localhost: 8080 / SessionTrack, se mostrará el siguiente resultado cuando se ejecute por primera vez:
Welcome to my website
Session Infomation
Session info
value
id
0AE3EC93FF44E3C525B4351B77ABB2D5
Creation Time
Tue Jun 08 17:26:40 GMT+04:00 2010
Time of Last Access
Tue Jun 08 17:26:40 GMT+04:00 2010
User ID
ABCD
Number of visits
0
Ahora intente ejecutar el mismo servlet por segunda vez, mostrará el siguiente resultado.
Welcome Back to my website
Session Infomation
info type
value
id
0AE3EC93FF44E3C525B4351B77ABB2D5
Creation Time
Tue Jun 08 17:26:40 GMT+04:00 2010
Time of Last Access
Tue Jun 08 17:26:40 GMT+04:00 2010
User ID
ABCD
Number of visits
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- Puede llamar al método public void removeAttribute (String name) para eliminar el valor asociado con una clave en particular.
Delete the whole session- Puede llamar al método public void invalidate () para descartar una sesión completa.
Setting Session timeout- Puede llamar al método public void setMaxInactiveInterval (int interval) para establecer el tiempo de espera de 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.
El método getMaxInactiveInterval () 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.
Este tutorial asume que comprende cómo funciona la aplicación JDBC. Antes de comenzar con el acceso a la base de datos a través de un servlet, 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 simple y creemos algunos registros en esa tabla de la siguiente manera:
Crear mesa
Para crear el Employees tabla en la base de datos TEST, utilice 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 la tabla Employee en 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
Finalmente, crea algunos registros en la tabla Empleado 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>Acceder a una base de datos
Aquí hay un ejemplo que muestra cómo acceder a la base de datos TEST usando Servlet.
// Loading required libraries
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.sql.*;
public class DatabaseAccess extends HttpServlet{
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL="jdbc:mysql://localhost/TEST";
// Database credentials
static final String USER = "root";
static final String PASS = "password";
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Database Result";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n");
try {
// Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");
// Open a connection
Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
// Execute SQL query
Statement stmt = conn.createStatement();
String sql;
sql = "SELECT id, first, last, age FROM Employees";
ResultSet rs = stmt.executeQuery(sql);
// Extract data from result set
while(rs.next()){
//Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");
//Display values
out.println("ID: " + id + "<br>");
out.println(", Age: " + age + "<br>");
out.println(", First: " + first + "<br>");
out.println(", Last: " + last + "<br>");
}
out.println("</body></html>");
// Clean-up environment
rs.close();
stmt.close();
conn.close();
} catch(SQLException se) {
//Handle errors for JDBC
se.printStackTrace();
} catch(Exception e) {
//Handle errors for Class.forName
e.printStackTrace();
} finally {
//finally block used to close resources
try {
if(stmt!=null)
stmt.close();
} catch(SQLException se2) {
} // nothing we can do
try {
if(conn!=null)
conn.close();
} catch(SQLException se) {
se.printStackTrace();
} //end finally try
} //end try
}
}Ahora compilemos el servlet anterior y creemos las siguientes entradas en web.xml
....
<servlet>
<servlet-name>DatabaseAccess</servlet-name>
<servlet-class>DatabaseAccess</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>DatabaseAccess</servlet-name>
<url-pattern>/DatabaseAccess</url-pattern>
</servlet-mapping>
....Ahora llame a este servlet usando la URL http: // localhost: 8080 / DatabaseAccess que mostraría la siguiente respuesta:
Database Result
ID: 100, Age: 18, First: Zara, Last: Ali
ID: 101, Age: 25, First: Mahnaz, Last: Fatma
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: MittalSe puede usar un servlet con una etiqueta de formulario HTML para permitir que los usuarios carguen archivos en el servidor. Un archivo cargado puede ser un archivo de texto o un archivo de imagen o cualquier documento.
Crear un formulario de carga de archivos
El siguiente código HTM a continuación 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 servlet que manejaría la carga de archivos en el servidor backend. El siguiente ejemplo está usandoUploadServlet servlet para cargar el archivo.
Para cargar un solo archivo, debe usar una sola etiqueta <input ... /> 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 que permitirá seleccionar un archivo de la PC local y cuando el usuario haga clic en "Cargar archivo", el formulario se enviará junto con el archivo seleccionado.
File Upload:
Select a file to upload:
NOTE: This is just dummy form and would not work.Servlet de backend de escritura
Lo siguiente es el servlet UploadServletque se encargaría de aceptar el archivo cargado y de almacenarlo en el directorio <Tomcat-installation-directory> / webapps / data. 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 UploadServlet que puede manejar la carga de varios archivos a la vez. Antes de continuar, debe asegurarse de lo siguiente:
El siguiente ejemplo depende de FileUpload, así que asegúrese de tener la última versión de commons-fileupload.x.x.jararchivo en su classpath. Puedes descargarlo desdehttps://commons.apache.org/fileupload/.
FileUpload depende de Commons IO, así que asegúrese de tener la última versión de commons-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ía .
Asegúrese de haber creado los directorios c: \ temp y c: \ apache-tomcat8.0.28 \ webapps \ data con suficiente antelación.
// Import required java libraries
import java.io.*;
import java.util.*;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.io.output.*;
public class UploadServlet extends HttpServlet {
private boolean isMultipart;
private String filePath;
private int maxFileSize = 50 * 1024;
private int maxMemSize = 4 * 1024;
private File file ;
public void init( ){
// Get the file location where it would be stored.
filePath = getServletContext().getInitParameter("file-upload");
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, java.io.IOException {
// Check that we have a file upload request
isMultipart = ServletFileUpload.isMultipartContent(request);
response.setContentType("text/html");
java.io.PrintWriter out = response.getWriter( );
if( !isMultipart ) {
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>");
return;
}
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>Servlet 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();
String contentType = fi.getContentType();
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: " + fileName + "<br>");
}
}
out.println("</body>");
out.println("</html>");
} catch(Exception ex) {
System.out.println(ex);
}
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, java.io.IOException {
throw new ServletException("GET method used with " +
getClass( ).getName( )+": POST method required.");
}
}
}Compilar y ejecutar servlet
Compile el servlet UploadServlet anterior y cree la entrada requerida en el archivo web.xml de la siguiente manera.
<servlet>
<servlet-name>UploadServlet</servlet-name>
<servlet-class>UploadServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>UploadServlet</servlet-name>
<url-pattern>/UploadServlet</url-pattern>
</servlet-mapping>Ahora intente cargar archivos utilizando el formulario HTML que creó anteriormente. Cuando intentara http: // localhost: 8080 / UploadFile.htm, mostraría el siguiente resultado que lo ayudaría a cargar cualquier archivo desde su máquina local.
File Upload:
Select a file to upload:
Si su secuencia de comandos de servlet funciona bien, su archivo debe cargarse en el directorio c: \ apache-tomcat8.0.28 \ webapps \ data \.
Una de las ventajas más importantes de usar Servlet es que puede usar la mayoría de los métodos disponibles en el núcleo de Java. Este tutorial lo llevará a través de Java proporcionadoDate clase que está disponible en java.util paquete, 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 equivale 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:
| No Señor. | 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 el 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
Es muy fácil obtener la fecha y hora actual en Java Servlet. Puede usar un objeto Date simple con el método toString () para imprimir la fecha y hora actual de la siguiente manera:
// Import required java libraries
import java.io.*;
import java.util.Date;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class CurrentDate extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Display Current Date & Time";
Date date = new Date();
String docType = "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<h2 align = \"center\">" + date.toString() + "</h2>\n" +
"</body>
</html>"
);
}
}Ahora compilemos el servlet anterior y creemos las entradas apropiadas en web.xml y luego llamemos a este servlet usando la URL http: // localhost: 8080 / CurrentDate. Esto produciría el siguiente resultado:
Display Current Date & Time
Mon Jun 21 21:46:49 GMT+04:00 2010
Intente actualizar la URL http: // localhost: 8080 / CurrentDate y encontrará la diferencia en segundos cada vez que actualice.
Comparación de fechas
Como mencioné anteriormente, puede usar todos los métodos Java disponibles en su Servlet. En caso de que necesite comparar dos fechas, los siguientes son los métodos:
Puede 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.
Puede utilizar los métodos before (), after () y equals (). Dado que el día 12 del mes es anterior al 18, por ejemplo, new Date (99, 2, 12) .before (new Date (99, 2, 18)) devuelve verdadero.
Puede utilizar el método compareTo (), que está definido por la interfaz Comparable e implementado por Date.
Formato de fecha usando SimpleDateFormat
SimpleDateFormat es una clase concreta para formatear y analizar fechas de una manera sensible al entorno local. 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:
// Import required java libraries
import java.io.*;
import java.text.*;
import java.util.Date;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class CurrentDate extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Display Current Date & Time";
Date dNow = new Date( );
SimpleDateFormat ft = new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
String docType = "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<h2 align = \"center\">" + ft.format(dNow) + "</h2>\n" +
"</body>
</html>"
);
}
}Compile el servlet anterior una vez más y luego llame a este servlet usando la URL http: // localhost: 8080 / CurrentDate. Esto produciría 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 | 10 |
| h | Hora en AM / PM (1 ~ 12) | 12 |
| 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 | 1 |
| un | Marcador AM / PM | PM |
| k | Hora del día (1 ~ 24) | 24 |
| K | Hora en AM / PM (0 ~ 11) | 10 |
| 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.
La redirección de página es una técnica en la que se envía al cliente a una nueva ubicación distinta a la solicitada. La redirección de página se usa generalmente cuando un documento se mueve a una nueva ubicación o puede deberse al equilibrio de carga.
La forma más sencilla de redirigir una solicitud a otra página es mediante el método sendRedirect()del objeto de respuesta. A continuación se muestra la firma de este método:
public void HttpServletResponse.sendRedirect(String location)
throws IOExceptionEste 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 usar los métodos setStatus () y setHeader () juntos para lograr lo mismo:
....
String site = "http://www.newpage.com" ;
response.setStatus(response.SC_MOVED_TEMPORARILY);
response.setHeader("Location", site);
....Ejemplo
Este ejemplo muestra cómo un servlet realiza la redirección de página a otra ubicación:
import java.io.*;
import java.sql.Date;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class PageRedirect extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
// New location to be redirected
String site = new String("http://www.photofuntoos.com");
response.setStatus(response.SC_MOVED_TEMPORARILY);
response.setHeader("Location", site);
}
}Ahora compilemos el servlet anterior y creemos las siguientes entradas en web.xml
....
<servlet>
<servlet-name>PageRedirect</servlet-name>
<servlet-class>PageRedirect</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>PageRedirect</servlet-name>
<url-pattern>/PageRedirect</url-pattern>
</servlet-mapping>
....Ahora llame a este servlet usando la URL http: // localhost: 8080 / PageRedirect. Esto le redirigirá a la URL http://www.photofuntoos.com.
Contador de visitas para una página web
Muchas veces le interesaría conocer el número total de visitas en una página en particular de su sitio web. Es muy sencillo contar estos hits utilizando un servlet porque el ciclo de vida de un servlet está controlado por el contenedor en el que se ejecuta.
A continuación se muestran los pasos que se deben seguir para implementar un contador de visitas de página simple que se basa en el ciclo de vida de Servlet:
Inicialice una variable global en el método init ().
Aumente la variable global cada vez que se llame al método doGet () o doPost ().
Si es necesario, puede usar una tabla de base de datos para almacenar el valor de la variable global en el método destroy (). Este valor se puede leer dentro del método init () cuando el servlet se inicializaría la próxima vez. Este paso es opcional.
Si desea contar solo las visitas a páginas únicas dentro de una sesión, puede usar el método isNew () para verificar si la misma página ya ha sido visitada dentro de esa sesión. Este paso es opcional.
Puede mostrar el valor del contador global para mostrar el número total de visitas en su sitio web. Este paso también es opcional.
Aquí asumo que el contenedor web no se reiniciará. Si se reinicia o se destruye el servlet, el contador de visitas se restablecerá.
Ejemplo
Este ejemplo muestra cómo implementar un contador de visitas de página simple:
import java.io.*;
import java.sql.Date;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class PageHitCounter extends HttpServlet {
private int hitCount;
public void init() {
// Reset hit counter.
hitCount = 0;
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
// This method executes whenever the servlet is hit
// increment hitCount
hitCount++;
PrintWriter out = response.getWriter();
String title = "Total Number of Hits";
String docType = "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<h2 align = \"center\">" + hitCount + "</h2>\n" +
"</body>
</html>"
);
}
public void destroy() {
// This is optional step but if you like you
// can write hitCount value in your database.
}
}Ahora compilemos el servlet anterior y creemos las siguientes entradas en web.xml
<servlet>
<servlet-name>PageHitCounter</servlet-name>
<servlet-class>PageHitCounter</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>PageHitCounter</servlet-name>
<url-pattern>/PageHitCounter</url-pattern>
</servlet-mapping>
....Ahora llame a este servlet usando la URL http: // localhost: 8080 / PageHitCounter. Esto aumentaría el contador en uno cada vez que esta página se actualice y mostraría el siguiente resultado:
Total Number of Hits
6
Hit Counter for a Website:
Muchas veces le interesaría conocer el número total de visitas en todo su sitio web. Esto también es muy simple en Servlet y podemos lograrlo usando filtros.
A continuación se detallan los pasos que se deben seguir para implementar un contador de visitas de sitios web simple que se basa en el ciclo de vida del filtro:
Inicializa una variable global en el método init () de un filtro.
Aumente la variable global cada vez que se llame al método doFilter.
Si es necesario, puede usar una tabla de base de datos para almacenar el valor de la variable global en el método de filtro destroy (). Este valor se puede leer dentro del método init () cuando el filtro se inicializaría la próxima vez. Este paso es opcional.
Aquí asumo que el contenedor web no se reiniciará. Si se reinicia o se destruye el servlet, el contador de visitas se restablecerá.
Ejemplo
Este ejemplo muestra cómo implementar un contador de visitas de un sitio web simple:
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
public class SiteHitCounter implements Filter {
private int hitCount;
public void init(FilterConfig config) throws ServletException {
// Reset hit counter.
hitCount = 0;
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws java.io.IOException, ServletException {
// increase counter by one
hitCount++;
// Print the counter.
System.out.println("Site visits count :"+ hitCount );
// Pass request back down the filter chain
chain.doFilter(request,response);
}
public void destroy() {
// This is optional step but if you like you
// can write hitCount value in your database.
}
}Ahora compilemos el servlet anterior y creemos las siguientes entradas en web.xml
....
<filter>
<filter-name>SiteHitCounter</filter-name>
<filter-class>SiteHitCounter</filter-class>
</filter>
<filter-mapping>
<filter-name>SiteHitCounter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
....Ahora llame a cualquier URL como URL http: // localhost: 8080 /. Esto aumentaría el contador en uno cada vez que una página recibe un golpe y mostraría el siguiente mensaje en el registro:
Site visits count : 1
Site visits count : 2
Site visits count : 3
Site visits count : 4
Site visits count : 5
..................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 todo este tipo de páginas, necesitará actualizar su página web con regularidad usando el botón de actualización o recarga de su navegador.
Java Servlet 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 método setIntHeader()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
Este ejemplo muestra cómo un servlet realiza la actualización automática de la página usando setIntHeader() método para configurar Refresh encabezamiento.
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class Refresh extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set refresh, autoload time as 5 seconds
response.setIntHeader("Refresh", 5);
// Set response content type
response.setContentType("text/html");
// 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;
PrintWriter out = response.getWriter();
String title = "Auto Page Refresh using Servlet";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n"+
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<p>Current Time is: " + CT + "</p>\n"
);
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}Ahora compilemos el servlet anterior y creemos las siguientes entradas en web.xml
....
<servlet>
<servlet-name>Refresh</servlet-name>
<servlet-class>Refresh</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Refresh</servlet-name>
<url-pattern>/Refresh</url-pattern>
</servlet-mapping>
....Ahora llame a este servlet usando la URL http: // localhost: 8080 / Refresh que mostraría la hora actual del sistema después de cada 5 segundos de la siguiente manera. Simplemente ejecute el servlet y espere a ver el resultado:
Auto Page Refresh using Servlet
Current Time is: 9:44:50 PM
Enviar un correo electrónico usando su Servlet es bastante simple, pero para empezar debe tener JavaMail API y Java Activation Framework (JAF) instalado en su máquina.
Puede descargar la última versión de JavaMail (Versión 1.2) desde el sitio web estándar de Java.
Puede descargar la última versión de JAF (Versión 1.1.1) del 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 agregarmail.jar y 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. Aquí se supone que sulocalhostestá conectado a Internet y tiene la capacidad suficiente para enviar un correo electrónico. Al mismo tiempo, asegúrese de que todos los archivos jar del paquete Java Email API y el paquete JAF estén disponibles en CLASSPATH.
// File Name SendEmail.java
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
public class SendEmail extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// 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
Properties properties = System.getProperties();
// Setup mail server
properties.setProperty("mail.smtp.host", host);
// Get the default Session object.
Session session = Session.getDefaultInstance(properties);
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
try {
// Create a default MimeMessage object.
MimeMessage message = new MimeMessage(session);
// 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);
String title = "Send Email";
String res = "Sent message successfully....";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<p align = \"center\">" + res + "</p>\n" +
"</body>
</html>"
);
} catch (MessagingException mex) {
mex.printStackTrace();
}
}
}Ahora compilemos el servlet anterior y creemos las siguientes entradas en web.xml
....
<servlet>
<servlet-name>SendEmail</servlet-name>
<servlet-class>SendEmail</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>SendEmail</servlet-name>
<url-pattern>/SendEmail</url-pattern>
</servlet-mapping>
....Ahora llame a este servlet usando la URL http: // localhost: 8080 / SendEmail que enviaría un correo electrónico al ID de correo electrónico dado [email protected] y mostraría la siguiente respuesta:
Send Email
Sent message successfully....
Si desea enviar un correo electrónico a varios destinatarios, se utilizarán los siguientes métodos para especificar varias ID de correo electrónico:
void addRecipients(Message.RecipientType type, Address[] addresses)
throws MessagingExceptionAquí 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. Aquí se supone que sulocalhostestá conectado a Internet y tiene la capacidad suficiente para enviar un correo electrónico. Al mismo tiempo, asegúrese de que todos los archivos jar del paquete Java Email API y el paquete JAF estén disponibles en CLASSPATH.
Este ejemplo es muy similar al anterior, excepto que aquí estamos usando el método setContent () para configurar el contenido cuyo segundo argumento es "texto / html" para especificar que el contenido HTML está incluido en el mensaje.
Con este ejemplo, puede enviar contenido HTML tan grande como desee.
// File Name SendEmail.java
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
public class SendEmail extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// 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
Properties properties = System.getProperties();
// Setup mail server
properties.setProperty("mail.smtp.host", host);
// Get the default Session object.
Session session = Session.getDefaultInstance(properties);
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
try {
// Create a default MimeMessage object.
MimeMessage message = new MimeMessage(session);
// 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);
String title = "Send Email";
String res = "Sent message successfully....";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<p align = \"center\">" + res + "</p>\n" +
"</body>
</html>"
);
} catch (MessagingException mex) {
mex.printStackTrace();
}
}
}Compile y ejecute el servlet anterior para enviar un mensaje HTML en una ID de correo electrónico determinada.
Enviar archivo adjunto por correo electrónico
Aquí hay un ejemplo para enviar un correo electrónico con un archivo adjunto desde su máquina. Aquí se supone que sulocalhost está conectado a Internet y tiene la capacidad suficiente para enviar un correo electrónico.
// File Name SendEmail.java
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
public class SendEmail extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// 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
Properties properties = System.getProperties();
// Setup mail server
properties.setProperty("mail.smtp.host", host);
// Get the default Session object.
Session session = Session.getDefaultInstance(properties);
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
try {
// Create a default MimeMessage object.
MimeMessage message = new MimeMessage(session);
// 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 multipar 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";
String res = "Sent message successfully....";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<p align = \"center\">" + res + "</p>\n" +
"</body>
</html>"
);
} catch (MessagingException mex) {
mex.printStackTrace();
}
}
}Compile y ejecute el servlet 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 la ID de usuario y la 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ía como se explicó anteriormente.
La estructura de la aplicación web que involucra el subdirectorio WEB-INF es estándar para todas las aplicaciones web Java y está especificada por la especificación de la API del servlet. Dado un nombre de directorio de nivel superior de myapp. Así es como se ve esta estructura de directorio:
/myapp
/images
/WEB-INF
/classes
/libEl subdirectorio WEB-INF contiene el descriptor de implementación de la aplicación, denominado web.xml. Todos los archivos HTML deben mantenerse en el directorio de nivel superior que es myapp . Para el usuario administrador, encontrará el directorio ROOT como directorio principal.
Creación de servlets en paquetes
El directorio WEB-INF / classes contiene todas las clases de servlet y otros archivos de clase, en una estructura que coincide con el nombre de su paquete. Por ejemplo, si tiene un nombre de clase completo decom.myorg.MyServlet, entonces esta clase de servlet debe estar ubicada en el siguiente directorio:
/myapp/WEB-INF/classes/com/myorg/MyServlet.classA continuación se muestra el ejemplo para crear la clase MyServlet con un nombre de paquete com.myorg
// Name your package
package com.myorg;
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class MyServlet extends HttpServlet {
private String message;
public void init() throws ServletException {
// Do required initialization
message = "Hello World";
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
// Actual logic goes here.
PrintWriter out = response.getWriter();
out.println("<h1>" + message + "</h1>");
}
public void destroy() {
// do nothing.
}
}Compilación de servlets en paquetes
No hay nada muy diferente para compilar una clase disponible en paquete. La forma más sencilla es mantener su archivo java en una ruta totalmente calificada, como se mencionó anteriormente, la clase se mantendría en com.myorg. También necesitaría agregar este directorio en CLASSPATH.
Suponiendo que su entorno está configurado correctamente, ingrese <Tomcat-installationdirectory>/ webapps / ROOT / WEB-INF / classes y compile MyServlet.java de la siguiente manera
$ javac MyServlet.javaSi el servlet depende de otras bibliotecas, también debe incluir esos archivos JAR en su CLASSPATH. Solo he incluido el archivo JAR servlet-api.jar porque no estoy usando ninguna otra biblioteca en el programa Hello World.
Esta línea de comandos utiliza el compilador javac integrado que viene con el kit de desarrollo de software Java de Sun Microsystems (JDK). Para que este comando funcione correctamente, debe incluir la ubicación del SDK de Java que está utilizando en la variable de entorno PATH.
Si todo va bien, la compilación anterior produciría MyServlet.classarchivo en el mismo directorio. La siguiente sección explicaría cómo se implementaría un servlet compilado en producción.
Implementación de servlets empaquetados
De forma predeterminada, una aplicación de servlet se encuentra en la ruta <Tomcat-installationdirectory> / webapps / ROOT y el archivo de clase residiría en <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes.
Si tiene un nombre de clase completamente calificado de com.myorg.MyServlet, entonces esta clase de servlet debe estar ubicada en WEB-INF / classes / com / myorg / MyServlet.class y necesitaría crear las siguientes entradas en web.xml archivo ubicado en <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF /
<servlet>
<servlet-name>MyServlet</servlet-name>
<servlet-class>com.myorg.MyServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>MyServlet</servlet-name>
<url-pattern>/MyServlet</url-pattern>
</servlet-mapping>Las entradas anteriores se crearán dentro de las etiquetas <web-app> ... </web-app> disponibles en el archivo web.xml. Podría haber varias entradas en esta tabla ya disponibles, pero no importa.
Ya casi ha terminado, ahora iniciemos el servidor Tomcat usando <Tomcat-installationdirectory> \ bin \ startup.bat (en Windows) o <Tomcat-installationdirectory> /bin/startup.sh (en Linux / Solaris, etc.) y finalmente escriba http://localhost:8080/MyServleten el cuadro de dirección del navegador. Si todo va bien, obtendría el siguiente resultado:
Hello World
Siempre es difícil probar / depurar un servlets. Los servlets tienden a involucrar una gran cantidad de interacción cliente / servidor, lo que hace que los errores sean probables pero difíciles de reproducir.
A continuación, se incluyen algunos consejos y sugerencias que pueden ayudarlo en la depuración.
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. Además -
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 incluye Servlets, JSP, RMI, EJB, Beans y clases ordinarios y aplicaciones independientes.
La técnica de detenerse en los puntos de interrupción detiene la ejecución normal, por lo que lleva más tiempo. Mientras que escribir en System.out no interfiere mucho con el flujo de ejecución normal de la aplicación, lo que lo hace muy valioso cuando el tiempo es crucial.
A continuación se muestra la sintaxis para usar System.out.println () -
System.out.println("Debugging message");Todos los mensajes generados por la sintaxis anterior se registrarán en el archivo de registro del servidor web.
Registro de mensajes
Siempre es una buena idea utilizar el método de registro adecuado para registrar todos los mensajes de depuración, advertencia y error utilizando un método de registro estándar. Utilizo log4J para registrar todos los mensajes.
La API de Servlet también proporciona una forma sencilla de generar información mediante el método log () de la siguiente manera:
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class ContextLog extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, java.io.IOException {
String par = request.getParameter("par1");
//Call the two ServletContext.log methods
ServletContext context = getServletContext( );
if (par == null || par.equals(""))
//log version with Throwable parameter
context.log("No message received:", new IllegalStateException("Missing parameter"));
else
context.log("Here is the visitor's message: " + par);
response.setContentType("text/html");
java.io.PrintWriter out = response.getWriter( );
String title = "Context Log";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<h2 align = \"center\">Messages sent</h2>\n" +
"</body>
</html>"
);
} //doGet
}El ServletContext registra sus mensajes de texto en el archivo de registro del contenedor de servlets. Con Tomcat, estos registros se encuentran en <Tomcat-installation-directory> / logs.
Los archivos de registro dan una indicación de nuevos errores emergentes o la frecuencia de los problemas. Por esa razón, es bueno usar la función log () en la cláusula catch de excepciones que normalmente no deberían ocurrir.
Utilizando JDB Debugger
Puede depurar servlets con los mismos comandos jdb que usa para depurar un applet o una aplicación.
Para depurar un servlet, depuramos sun.servlet.http.HttpServer y observamos detenidamente cómo HttpServer ejecuta los servlets en respuesta a las solicitudes HTTP realizadas desde el 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 es sun.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 los servlets, debe ayudar a su depurador haciendo lo siguiente:
Configure la ruta de clase de su depurador para que pueda encontrar sun.servlet.http.Http-Server y las clases asociadas.
Configure la ruta de clases de su depurador para que también pueda encontrar sus servlets y clases de soporte, normalmente raíz_servidor / servlets y raíz_servidor / clases.
Normalmente no querría server_root / servlets en su classpath porque deshabilita la recarga de servlets. Sin embargo, esta inclusión es útil para depurar. Permite que su depurador establezca puntos de interrupción en un servlet antes de que el cargador de servlet personalizado en HttpServer cargue el servlet.
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 servlet que esté interesado en depurar, luego use un navegador web para realizar una solicitud al HttpServer para el servlet dado (http: // localhost: 8080 / servlet / ServletToDebug). Debería ver que la ejecución se detiene en sus 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.
El servlet utiliza comentarios de Java y comentarios de una sola línea (// ...) y de varias líneas (/ * ... * /) 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 un servlet 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 exactamente 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 servlets:
Recuerde que server_root / classes no se recarga y que server_root / servlets probablemente lo haga.
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. Con Netscape Navigator, use Shift-Reload; con Internet Explorer use Shift-Refresh.
Verifique que el método init () de su servlet tome un parámetro ServletConfig y llame a super.init (config) de inmediato.
Antes de continuar, permítame explicarle 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 adaptarse a una región geográfica o cultural en particular.
locale- Ésta es una región geográfica o cultural particular. Por lo general, se denomina símbolo de idioma seguido de un símbolo de país separado 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.
Un servlet puede recoger la versión adecuada del sitio según la configuración regional del solicitante y proporcionar la versión adecuada del sitio según 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 la ubicación, el idioma y, por supuesto, la configuración regional del solicitante. Todos los métodos a continuación muestran el nombre del país y el nombre del idioma establecidos en el navegador del solicitante.
| No Señor. | 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
Este ejemplo muestra cómo se muestra un idioma y un país asociado para una solicitud:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
public class GetLocale extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//Get the client's Locale
Locale locale = request.getLocale();
String language = locale.getLanguage();
String country = locale.getCountry();
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Detecting Locale";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + language + "</h1>\n" +
"<h2 align = \"center\">" + country + "</h2>\n" +
"</body>
</html>"
);
}
}Configuración de idiomas
Un servlet 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 ContentLanguage para mostrar todos los caracteres correctamente.
El segundo punto es mostrar todos los caracteres especiales utilizando entidades HTML, por ejemplo, "& # 241;" representa "ñ" y "& # 161;" representa "¡" de la siguiente manera:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
public class DisplaySpanish extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
// Set spanish language code.
response.setHeader("Content-Language", "es");
String title = "En Español";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1>" + "En Español:" + "</h1>\n" +
"<h1>" + "¡Hola Mundo!" + "</h1>\n" +
"</body>
</html>"
);
}
}Fechas específicas de la configuración regional
Puede utilizar la clase java.text.DateFormat y su método estático getDateTimeInstance () 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:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
import java.text.DateFormat;
import java.util.Date;
public class DateLocale extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
//Get the client's Locale
Locale locale = request.getLocale( );
String date = DateFormat.getDateTimeInstance(DateFormat.FULL,
DateFormat.SHORT, locale).format(new Date( ));
String title = "Locale Specific Dates";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + date + "</h1>\n" +
"</body>
</html>"
);
}
}Moneda específica de la configuración regional
Puede usar la clase java.txt.NumberFormat y su método estático getCurrencyInstance () 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:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
import java.text.NumberFormat;
import java.util.Date;
public class CurrencyLocale extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
//Get the client's Locale
Locale locale = request.getLocale( );
NumberFormat nft = NumberFormat.getCurrencyInstance(locale);
String formattedCurr = nft.format(1000000);
String title = "Locale Specific Currency";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + formattedCurr + "</h1>\n" +
"</body>
</html>"
);
}
}Porcentaje específico de la configuración regional
Puede usar la clase java.txt.NumberFormat y su método estático getPercentInstance () para obtener un porcentaje específico de la configuración regional. A continuación se muestra el ejemplo que muestra cómo formatear el porcentaje específico de una configuración regional determinada:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
import java.text.NumberFormat;
import java.util.Date;
public class PercentageLocale extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
//Get the client's Locale
Locale locale = request.getLocale( );
NumberFormat nft = NumberFormat.getPercentInstance(locale);
String formattedPerc = nft.format(0.51);
String title = "Locale Specific Percentage";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + formattedPerc + "</h1>\n" +
"</body>
</html>"
);
}
}Hasta ahora, ha aprendido cómo Servlet usa el descriptor de implementación (archivo web.xml) para implementar su aplicación en un servidor web. Servlet API 3.0 ha introducido un nuevo paquete llamado javax.servlet.annotation. Proporciona tipos de anotaciones que se pueden utilizar para anotar una clase de servlet. Si usa la anotación, el descriptor de implementación (web.xml) no es necesario. Pero debería usar tomcat7 o cualquier versión posterior de tomcat.
Las anotaciones pueden reemplazar la configuración XML equivalente en el archivo descriptor de implementación web (web.xml), como la declaración de servlet y la asignación de servlet. Los contenedores de servlet procesarán las clases anotadas en el momento de la implementación.
Los tipos de anotaciones introducidos en Servlet 3.0 son:
| No Señor. | Anotación y descripción |
|---|---|
| 1 | @WebServlet Declarar un servlet. |
| 2 | @WebInitParam Para especificar un parámetro de inicialización. |
| 3 | @WebFilter Para declarar un filtro de servlet. |
| 4 | @WebListener Para declarar un WebListener |
| 5 | @HandlesTypes Declarar los tipos de clases que puede manejar un ServletContainerInitializer. |
| 6 | @HttpConstraint Esta anotación se utiliza dentro de la anotación ServletSecurity para representar las restricciones de seguridad que se aplicarán a todos los métodos de protocolo HTTP para los que NO se produce un elemento HttpMethodConstraint correspondiente dentro de la anotación ServletSecurity. |
| 7 | @HttpMethodConstraint Esta anotación se utiliza dentro de la anotación ServletSecurity para representar restricciones de seguridad en mensajes de protocolo HTTP específicos. |
| 8 | @MultipartConfig Anotación que se puede especificar en una clase de Servlet, que indica que las instancias del Servlet esperan solicitudes que se ajusten al tipo MIME multipart / form-data. |
| 9 | @ServletSecurity Esta anotación se utiliza en una clase de implementación de Servlet para especificar las restricciones de seguridad que debe imponer un contenedor de Servlet en los mensajes del protocolo HTTP. |
Aquí hemos discutido algunas de las anotaciones en detalle.
@WebServlet
El @WebServlet se usa para declarar la configuración de un Servlet con un contenedor. La siguiente tabla contiene la lista de atributos utilizados para la anotación de WebServlet.
| No Señor. | Atributo y descripción |
|---|---|
| 1 | String name Nombre del servlet |
| 2 | String[] value Matriz de patrones de URL |
| 3 | String[] urlPatterns Matriz de patrones de URL a los que se aplica este filtro |
| 4 | Int loadOnStartup El valor entero le da la sugerencia de orden de inicio |
| 5 | WebInitParam[] initParams Matriz de parámetros de inicialización para este servlet |
| 6 | Boolean asyncSupported Operación asíncrona admitida por este servlet |
| 7 | String smallIcon Icono pequeño para este servlet, si está presente |
| 8 | String largeIcon Icono grande para este servlet, si está presente |
| 9 | String description Descripción de este servlet, si está presente |
| 10 | String displayName Nombre para mostrar de este servlet, si está presente |
DEBE declararse al menos un patrón de URL en el value o urlPattern atributo de la anotación, pero no ambos.
los value Se recomienda utilizar el atributo cuando el patrón de URL es el único atributo que se establece; de lo contrario, urlPattern debe utilizarse el atributo.
Ejemplo
El siguiente ejemplo describe cómo usar la anotación @WebServlet. Es un servlet simple que muestra el textoHello Servlet.
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet(value = "/Simple")
public class Simple extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.print("<html><body>");
out.print("<h3>Hello Servlet</h3>");
out.print("</body></html>");
}
}Compilar Simple.java de la forma habitual y coloque su archivo de clase en <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes.
Ahora intente llamar a cualquier servlet simplemente ejecutando http: // localhost: 8080 / Simple . Verá el siguiente resultado en la página web.
Hello servlet@WebInitParam
La anotación @WebInitParam se utiliza para especificar un parámetro de inicialización para un servlet o un filtro. Se utiliza dentro de anotaciones WebFilter o WebSevlet. La siguiente tabla contiene la lista de atributos utilizados para la anotación WebInitParam.
| No Señor. | Atributo y descripción |
|---|---|
| 1 | String name Nombre del parámetro de inicialización |
| 2 | String value Valor del parámetro de inicialización |
| 3 | String description Descripción del parámetro de inicialización |
Ejemplo
El siguiente ejemplo describe cómo usar la anotación @WeInitParam junto con la anotación @WebServlet. Es un servlet simple que muestra el textoHello Servlet y el valor de la cadena Hello World! que se toman de la init parámetros.
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet(value = "/Simple", initParams = {
@WebInitParam(name = "foo", value = "Hello "),
@WebInitParam(name = "bar", value = " World!")
})
public class Simple extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.print("<html><body>");
out.print("<h3>Hello Servlet</h3>");
out.println(getInitParameter("foo"));
out.println(getInitParameter("bar"));
out.print("</body></html>");
}
}Compilar Simple.java de la forma habitual y coloque su archivo de clase en <Tomcat-installationdirectory>; / webapps / ROOT / WEB-INF / classes.
Ahora intente llamar a cualquier servlet simplemente ejecutando http: // localhost: 8080 / Simple . Verá el siguiente resultado en la página web.
Hello Servlet
Hello World!@Webfilter
Esta es la anotación que se usa para declarar un filtro de servlet. El contenedor lo procesa en el momento de la implementación y el filtro correspondiente se aplica a los patrones de URL, servlets y tipos de despachador especificados.
los @WebFilteranotación define un filtro en una aplicación web. Esta anotación se especifica en una clase y contiene metadatos sobre el filtro que se declara. El filtro anotado debe especificar al menos un patrón de URL. La siguiente tabla enumera los atributos utilizados para la anotación de WebFilter.
| No Señor. | Atributo y descripción |
|---|---|
| 1 | String filterName Nombre del filtro |
| 2 | String[] urlPatterns Proporciona una matriz de valores o urlPatterns a los que se aplica el filtro. |
| 3 | DispatcherType[] dispatcherTypes Especifica los tipos de despachador (solicitud / respuesta) a los que se aplica el filtro |
| 4 | String[] servletNames Proporciona una variedad de nombres de servlets. |
| 5 | String displayName Nombre del filtro |
| 6 | String description Descripción del filtro |
| 7 | WebInitParam[] initParams Matriz de parámetros de inicialización para este filtro |
| 8 | Boolean asyncSupported Operación asincrónica admitida por este filtro |
| 9 | String smallIcon Icono pequeño para este filtro, si está presente |
| 10 | String largeIcon Icono grande para este filtro, si está presente |
Ejemplo
El siguiente ejemplo describe cómo usar la anotación @WebFilter. Es un LogFilter simple que muestra el valor de Init-paramtest-paramy la marca de tiempo actual en la consola. Eso significa que el filtro funciona como una capa de interfaz entre la solicitud y la respuesta. Aquí usamos "/ *" para urlPattern. Es decir, este filtro es aplicable a todos los servlets.
import java.io.IOException;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.*;
import java.util.*;
// Implements Filter class
@WebFilter(urlPatterns = {"/*"}, initParams = {
@WebInitParam(name = "test-param", value = "Initialization Paramter")})
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 IOException, ServletException {
// Log the current timestamp.
System.out.println("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 Simple.java de la forma habitual y coloque su archivo de clase en <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes.
Ahora intente llamar a cualquier servlet simplemente ejecutando http: // localhost: 8080 / Simple . Verá el siguiente resultado en la página web.
Hello Servlet
Hello World!Ahora, abra la consola del servlet. Allí, encontrará el valor de lainit parámetro testparam y el current timestamp junto con los mensajes de notificación de servlet.