Escolar Documentos
Profissional Documentos
Cultura Documentos
</web-app>
Ciclo de vida
El ciclo de vida de un Servlet se divide en los siguientes puntos:
El cliente solicita una peticin a un servidor va URL.
El servidor recibe la peticin.
Si es la primera, se utiliza el motor de Servlets para cargarlo y se llama al mtodo init().
Si ya est iniciado, cualquier peticin se convierte en un nuevo hilo. Un Servlet puede manejar
mltiples peticiones de clientes.
Se llama al mtodo service() para procesar la peticin devolviendo el resultado al cliente.
Cuando se apaga el motor de un Servlet se llama al mtodo destroy(), que lo destruye y libera
los recursos abiertos.
Clases y objetos necesarios
Podemos crear un Servlet haciendo uso del paquete javax.servlet.
Interface HttpServletRequest
Sigue
este
enlace
para
ver
su
definicin
detallada
(en
ingls): http://java.sun.com/j2ee/sdk_1.3/techdocs/api/javax/servlet/http/HttpServletRequest.ht
ml
Interface HttpServletResponse
Sigue
este
enlace
para
ver
su
especificacin
detallada
(en
ingls): http://java.sun.com/j2ee/sdk_1.3/techdocs/api/javax/servlet/http/HttpServletResponse.h
tml
Beneficios de utilizar Servlets en lugar de CGI
Son ms eficientes y utilizan menos recursos. CGI utiliza un nuevo proceso por cada peticin.
En cambio en los Servlets slo existe una copia cargada en la mquina virtual y por cada
peticin se inicia un hilo, lo cual reduce el uso de memoria del servidor y el tiempo de
respuesta.
Tienen persistencia, por lo que siguen "vivos" una vez terminada la peticin.
Ejemplo
Cdigo de ejemplo de un Servlet que procesa una peticin GET y devuelve una pgina
web HTML sencilla:
package org.pruebas;
import
import
import
import
import
import
java.io.IOException;
java.io.PrintWriter;
javax.servlet.ServletException;
javax.servlet.http.HttpServlet;
javax.servlet.http.HttpServletRequest;
javax.servlet.http.HttpServletResponse;
out.println("<h1>Hola Mundo!</h1>");
out.println("</body></html>");
}
2 APIs
o
o
o
o
o
o
o
generales
javax.ejb.*
javax.naming
java.sql
java.transaction.*
javax.xml.*
javax.jms.*
javax.persistence
Java Database Connectivity (JDBC) Java Database Connectivity, ms conocida por sus siglas JDBC1 2 , es
una API que permite la ejecucin de operaciones sobre bases de datos desde el lenguaje de programacin
Java, independientemente del sistema operativo donde se ejecute o de la base de datos a la cual se
accede, utilizando el dialecto SQL del modelo de base de datos que se utilice.
El API JDBC se presenta como una coleccin de interfaces Java y mtodos de gestin de manejadores de
conexin hacia cada modelo especfico de base de datos. Un manejador de conexiones hacia un modelo de
base de datos en particular es un conjunto de clases queimplementan las interfaces Java y que utilizan los
mtodos de registro para declarar los tipos de localizadores a base de datos ( URL) que pueden manejar.
Para utilizar una base de datos particular, el usuario ejecuta su programa junto con la biblioteca de conexin
apropiada al modelo de su base de datos, y accede a ella estableciendo una conexin, para ello provee el
localizador a la base de datos y los parmetros de conexin especficos. A partir de all puede realizar con
cualquier tipo de tareas con la base de datos a las que tenga permiso: consulta, actualizacin, creacin,
modificacin y borrado de tablas, ejecucin de procedimientos almacenados en la base de datos, etc.
Paquete java.sql
JDBC ofrece el paquete java.sql, en el que existen clases muy tiles para trabajar con bases de
datos.
Clase
DriveManager
Connection
Statement
ResultSet
Descripcin
Para cargar un driver
Para establecer conexiones con las bases de datos.
Para ejecutar sentencias SQL y enviarlas a las
BBDD
Para almacenar el resultado de la consulta.
modificador_acceso puede ser public o no existir, siendo entonces por defecto package. Los
atributos que definamos en el cuerpo de la interfaz sern atributos de tipo constante en las
clases en las que se implemente.
Para implementarla en una clase, se utiliza la forma:
modificador_acceso NombreClase implements NombreInterfaz1 [, NombreInterfaz2]
Una clase puede implementar varias interfaces, separando los nombres por comas.
Ejemplo
Definicin de una interfaz:
interface Nave {
//public static final int VIDA = 100; por definicin todos los atributos de una interface son
pblicos y estticos
// por ese motivo es redundante aunque si se escribe no genera ningn tipo de error
final int VIDA = 100;
public abstract void moverPosicion (int x, int y);
public abstract void disparar();
.....
}
Uso de la interfaz definida:
public class NaveJugador implements Nave {
public void moverPosicion (int x, int y){
//Implementacin del mtodo
}
public void disparar(){
//Implementacin del mtodo
}
.....
}
Introduccin a los Servlets
Los Servlets son mdulos que extienden los servidores orientados a peticin-respuesta, como
los servidores web compatibles con Java. Por ejemplo, un servlet podra ser responsable de
tomar los datos de un formulario de entrada de pedidos en HTML y aplicarle la lgica de
negocios utilizada para actualizar la base de datos de pedidos de la compaia.
Los Servlets son para los servidores lo que los applets son para los navegadores. Sin embargo,
al contrario que los applets, los servlets no tienen interface grfico de usuario.
Los servelts pueden ser incluidos en muchos servidores diferentes porque el API Servlet, el que
se utiliza para escribir Servlets, no asume nada sobre el entorno o protocolo del servidor. Los
servlets se estn utilizando ampliamente dentro de servidores HTTP; muchos servidores Web
soportan el API Servlet.
ESTRUCTURA BSICA DE UN SERVLET
Aqu tenemos un servlet bsico que maneja peticiones GET. Las peticiones GET, para aquellos
que no estemos familiarizados con HTTP, son peticiones hechas por el navegador cuando el
usuario teclea una URL en la lnea de direcciones, sigue un enlace desde una pgina Web, o
rellena un formulario que no especifica un METHOD. Los Servlets tambin pueden manejar
peticiones POST muy fcilmente, que son generadas cuando alguien crea un formulario HTML
que especifica METHOD="POST". Los discutiremos en una seccin posterior.
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
}
(Descarga
sobre el enlace o mantn pulsada la tecla SHIFT mientras pulsas sobre el enlace).
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class SomeServlet extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
// Use "request" to read incoming HTTP headers (e.g. cookies)
// and HTML form data (e.g. data the user entered and submitted)
// Use "response" to specify the HTTP response line and headers
// (e.g. specifying the content type, setting cookies).
Para ser un servlet, una clase debera extender HttpServlet y sobreescribir doGet o doPost (o
ambos), dependiendo de si los datos estn siendo enviados mediante GET o POST. Estos
mtodos toman dos argumentos: un HttpServletRequest y un HttpServletResponse.
El HttpServletRequest tiene mtodos que nos permiten encontrar informacin entrante como
datos de un FORM, cabeceras de peticin HTTP, etc. El HttpServletResponse tiene mtodos que
nos permiten especificar lneas de respuesta HTTP (200, 404, etc.), cabeceras de respuesta
(Content-Type, Set-Cookie, etc.), y, todava ms importante, nos permiten obtener
un PrintWriter usado para envar la salida de vuelta al cliente. Para servlets sencillos, la
mayora del esfuerzo se gasta en sentencias println que generan la pgina deseada.
Observamos quedoGet y doPost lanzan dos excepciones, por eso es necesario incluirlas en la
declaracin. Tambin observamos que tenemos que importar las clases de los
paquetes java.io (paraPrintWriter, etc.), javax.servlet (para HttpServlet, etc.),
y javax.servlet.http(para HttpServletRequest y HttpServletResponse). Finalmente, observamos
que doGet ydoPost son llamados por el mtodo service, y algunas veces queremos
sobreescribir directamente el mtodo service, por ejemplo, para un servlet que maneje tanto
peticionesGET como POST.
Un Sencillo Servlet que Genera Texto Normal
Aqu tenemos un servlet que slo genera texto normal. La siguiente seccin mostrar el caso
ms usual donde se generar HTML.
HelloWorld.java
package hall;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class HelloWorld extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
de los servidores nos permiten definir alias para nuestros servlets, para que un servlet pueda
ser invocado mediante http://host/any-path/any-file.html.
El Cdigo fuente.
package hall;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class HelloWWW extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 " +
"Transitional//EN\">\n" +
"<HTML>\n" +
"<HEAD><TITLE>Hello WWW</TITLE></HEAD>\n" +
"<BODY>\n" +
"<H1>Hello WWW</H1>\n" +
"</BODY></HTML>");
}
}
Resultado de HelloWWW
partes de la pgina Web que no cambian (DOCTYPE y HEAD) y que podra beneficiarnos el
incluirlas en un fichero de utilidades.
La lnea DOCTYPE es tcnicamente requerida por la especificacin HTML, y aunque la mayora
de los navegadores Web la ignoran, es muy til cuando se envan pginas a validadores de
formato HTML. Estos validadores comparan la sntaxis HMTL de las pginas comparndolas con
la especificacin formal del HTML, y usan la lnea DOCTYPE para determinar la versin de HTML
con la que comparar.
En muchas pginas web, la lnea HEAD no contiene nada ms que el TITLE, aunque los
desarrolladores avanzados podran querer incluir etiquetas META y hojas de estilo. Pero para el
caso sencillo, crearemos un mtodo que crea un ttulo y devuelve las entradas DOCTYPE, HEAD,
y TITLE como salida. Aqu est el cdigo:
ServletUtilities.java
Tambin puedes descargar
El Cdigo fuente.
package hall;
public class ServletUtilities {
public static final String DOCTYPE =
"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\">";
public static String headWithTitle(String title) {
return(DOCTYPE + "\n" +
"<HTML>\n" +
"<HEAD><TITLE>" + title + "</TITLE></HEAD>\n");
}
}
El Cdigo fuente.
Aqu tenemos una nueva versin de la clase HelloWWW que usa esto
package hall;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class HelloWWW2 extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println(ServletUtilities.headWithTitle("Hello WWW") +
"<BODY>\n" +
"<H1>Hello WWW</H1>\n" +
"</BODY></HTML>");
}
}
A la hora de enviar informacin a un servlet tenemos dos formas: mediante el mtodo GET y mediante el
mtodo POST. Existen una serie de diferencias entre pasarlos de una forma u otra:
Metodo POST. Este mtodo solo esta accesible desde los formularios. Se envan los parmetros de forma
implcita junto a la pgina, es decir, al pasar los parmetros, nosotros no vemos reflejado en ningn sitio qu
parmetros son y cual es su valor.
Mtodo GET. Este mtodo enva los parmetros de forma explicita junto a la pgina, mostrando en la barra
de navegacin los parmetros y sus valores. Son esas largas cadenas que aparecen en algunas pginas en
nuestra barra de navegacin, del estilo: buscar?id=1806&valor=0987&texto=todo&...
Las cadenas toman el aspecto parametro1=valor1metro2=valor2&....metroN=valorN. Es decir es una
concatenacin a travs de & de pares parmetro-valor.
Preparando la pgina de envo
La pgina de envo ser una simple pgina HTML. Lo primero que tenemos que hacer es montar las URL de
envo. La URL est compuesta por el nombre del servidor, en nuestro caso localhost, el puerto (8080), el
nombre de la aplicacin web, en nuestro caso "lineadecodigo_j2ee" y el nombre del servlet.
As la URL quedar de la siguiente forma:
http://localhost:8080/lineadecodigo_j2ee
/RecibirParametros
La URL la montaremos en un formulario:
<form action="http://localhost:8080/lineadecodigo_j2ee
/RecibirParametros" method="post">
<label for="texto1">Texto 1</label><input type="text" id="texto1"
name="texto1" size=20><br>
<label for="texto2">Texto 2</label><input type="text" id="texto2"
name="texto2" size=20>
<input type="submit" value="Enviar">
</form>
y en un enlace:
<a href="http://localhost:8080/lineadecodigo_j2ee/RecibirParametros?
texto1=lineadecodigo&texto2=imagen">Mandar parametros por GET</a>
Codificando el Servlet
Lo primero que hay que saber es que la clase que implemente el Servlet extiende de HttpServlet. As el
cdigo ser el siguiente:
public class RecibirParametros extends javax.servlet.http.HttpServlet implements
javax.servlet.Servlet {
...
}
10
Dentro del Servlet hay dos mtodos importantes: doGet y doPost. Estos mtodos son los que atienden las
peticiones POST y GET de la pgina, respectivamente.
public class RecibirParametros extends javax.servlet.http.HttpServlet implements
javax.servlet.Servlet {
protected void doGet(HttpServletRequest request, HttpServletResponse
response) throws ServletException, IOException {
...
}
protected void doPost(HttpServletRequest request, HttpServletResponse
response) throws ServletException, IOException {
...
}
}
Ambos mtodos reciben como parmetros los datos de la peticin HttpServletRequest y el flujo de la salida
de respuesta HttpServletResponse.
Podemos codificar los dos mtodos para hacer cosas diferentes si viene una peticin POST u otra GET. O
bien, como en nuestro caso, encaminar una peticin a la otra para tratarlas de una misma forma.
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doPost(request,response);
}
Para recibir los parmetros nos vamos a apoyar en el objeto HttpServletRequest y en concreto en el mtodo
.getParameter(). En este mtodo indicaremos el nombre del parmetro que queremos recuperar.
String parametro1 = request.getParameter("texto1");
String parametro2 = request.getParameter("texto2");
En este caso los parmetros se llaman texto1 y texto2.
Lo siguiente que haremos ser montar la respuesta. Ahora nos apoyaremos en el objeto
HttpServletResponse. Mediante el mtodo .getWriter() obtendremos el stream de salida. Esto lo manejamos
mediante el objeto PrintWriter.
PrintWriter out;
out = response.getWriter();
Antes de empezar a volcar texto en el flujo de salida tenemos que indicar el tipo de contenido que se vuelca.
En este caso es "text/html". Es lo que se denomina content-type.
response.setContentType("text/html");
Ahora solo quedar el ir volcando informacin mediante mtodos .println(). El cual tiene como parmetro el
texto a volcar a la pgina.
out.println("<html>");
11
12
<servlet>
<description>
</description>
<display-name>MiPrimerServlet</display-name>
<servlet-name>MiPrimerServlet</servlet-name>
<servlet-class>
com.lineadecodigo.java.servlet.MiPrimerServlet</servlet-class>
</servlet>
<servlet>
<description>
</description>
<display-name>ParametrosInicio</display-name>
<servlet-name>ParametrosInicio</servlet-name>
<servlet-class>
com.lineadecodigo.java.servlet.ParametrosInicio</servlet-class>
<init-param>
<description>
Nivel al que establecemos los logs</description>
<param-name>NivelLog</param-name>
<param-value>DEBUG</param-value>
</init-param>
<init-param>
<description>
Nmero de peticiones que vamos a aceptar</description>
<param-name>NumeroPeticiones</param-name>
<param-value>8</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>RespuestaXML</servlet-name>
<url-pattern>/RespuestaXML</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>ObtenerXForwardedFor</servlet-name>
<url-pattern>/ObtenerXForwardedFor</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>ServletForward</servlet-name>
<url-pattern>/ServletForward</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>MiPrimerServlet</servlet-name>
<url-pattern>/MiPrimerServlet</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>ParametrosInicio</servlet-name>
<url-pattern>/ParametrosInicio</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
<session-config>
<session-timeout>10</session-timeout>
</session-config>
</web-app>
13
...
3. }
Dentro de esta clase tenemos que codificar, al menos, un mtodo. El mtodo doGet. Este mtodo es el que
se ejecuta cuando el servlet recibe una peticin del tipo GET (las ms normales en Internet).
public class MiPrimerServlet extends javax.servlet.http.HttpServlet implements
javax.servlet.Servlet {
protected void doGet(HttpServletRequest request, HttpServletResponse
response) throws ServletException, IOException {
...
}
}
El mtodo doGet recibe dos parmetros: HttpServletRequest y HttpServletResponse. Estos dos parmetros
representan el stream de peticin y el stream de respuesta. Y ambos llevan los datos intrnsecos a la
peticin o respuesta.
Por ejemplo, si la peticin viene con parmetros, estos los encontraremos en el objeto HttpServletRequest.
De igual manera, si queremos establecer el tipo de contenido de respuesta, lo podremos hacer manipulando
el objeto HttpServletResponse.
Para nuestro ejemplo de Mi primer servlet, vamos a centrarnos en el objeto HttpServletResponse. Y es que
lo que vamos a realizar ser un volcado de datos sobre el flujo de salida.
Lo primero que haremos ser el definir una clase PrintWriter a la que asociar el flujo de salida.
1. PrintWriter out;
2. out = response.getWriter();
Una vez establecida esta relacin, lo primero que haremos ser indicar el tipo de contenido que queremos
volcar. En este caso, ser una pgina web. Es por ello que el contenido ser text/html. En otros casos
podremos devolver otros mime-types como images/jpeg para las imgenes JPEG o application/x-gzip
para los ficheros ZIP.
response.setContentType("text/html");
Ahora solo nos quedar ir invocando al mtodo .println con el texto que conforme la pgina web.
14
out.println("<html>");
out.println("<head><title>Mi Primer Servlet </title></head>");
out.println("<body>");
out.println("<h1>Este es mi Primer Servlet</h1>");
out.println("</body></html>");
Como se puede ver en el cdigo, se vuelcan todas las etiquetas que conforman la pgina web HTML,
BODY, TITLE, y nuestro texto.
Configurar el descriptor de despliegue
Una vez desarrollado y compilado nuestro servlet, tendremos que configurar el descriptor de despliegue.
Este es el fichero web.xml. Dicho fichero indicar los servlets que hay desplegados en nuestra aplicacin
web y bajo que URL van a atender las peticiones.
Tendremos que definir dos etiquetas. La primera es la etiqueta servlet. Esta etiqueta sirve para definir el
servlet. Tiene las siguientes etiquetas anidadas:
o
servlet-class, clase del servlet. Con el nombre del paquete por delante.
<servlet>
<description>Mi primer Servlet</description>
<display-name>
MiPrimerServlet</display-name>
<servlet-name>MiPrimerServlet</servlet-name>
<servlet-class> aulambra.com.lineadecodigo.j2ee.servlets.MiPrimerServlet
</servlet-class>
</servlet>
Una vez definido el servlet, solo nos quedar realizar la asociacin entre la URL que atender las peticiones
del servlet y el servlet definido. Esto lo hacemos mediante la etiqueta servlet-mapping.
En ella encontramos dos etiquetas anidadas:
o
url-pattern, que es el patrn de URL al que atender las petciones. En nuestro caso ser
/MiPrimerServlet.
<servlet-mapping>
<servlet-name>MiPrimerServlet</servlet-name>
<url-pattern>/MiPrimerServlet</url-pattern>
</servlet-mapping>
15
De esta manera, una vez desplegada la aplicacin en un contenedor web, podremos acceder al servlet de la
siguiente manera:
http://servidor:8080/nombre_app_web/MiPrimerServlet
package aulambra.com.lineadecodigo.j2ee.servlets;
/**
* @file MiPrimerServlet.java
* @version 1.1
* @author Linea de Codigo (http://lineadecodigo.com)
* @date 27-diciembre-2007
* @url http://lineadecodigo.com/2007/12/27/mi-primer-servlet/
* @description Como construir y desplegar tu primer servlet
*/
import
import
import
import
import
java.io.IOException;
java.io.PrintWriter;
javax.servlet.ServletException;
javax.servlet.http.HttpServletRequest;
javax.servlet.http.HttpServletResponse;
16
No siempre un Servlet estar codificado para atender a una peticin. Sino que muchas veces y por muchos
motivos tendr que reenviar la peticin para que la siga procesando otro Servlet.
Uno de estos casos claros es cuando estamos implementando un patrn Controller. Donde ese punto de
acceso redirigir las peticiones a diferentes Servlets.
Para redirigir la peticin necesitaremos de una simple lnea de cdigo. En esta lnea recuperaremos el
manejador de uno de los Servlets de la aplicacin web y le reenviaremos los objetos peticin y respuesta
para que los maneje.
Esto lo haremos mediante el mtodo forward(request, response) de RequestDispatcher:
El cdigo nos quedara de la siguiente forma:
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.getRequestDispatcher("NombreDelServlet").forward(request, response);
}
Java Recibir parametros en una JSP
Una pgina JSP nos permite combinar la tecnologa de las pginas web con la tecnologa de las pginas de
servidor.
Es por ello que en una pgina JSP siempre veremos dos partes bien diferenciadas. El cdigo relativo a la
tecnologa cliente: HTML, XHTML, SVG,... y lo que denominaremos scriptlet. Estos scriptlet no deja de ser
cdigo Java que se ejecutar en el lado del servidor para aadirse al cdigo cliente ya existente.
Es decir, el navegador que ejecute nuestra JSP solo ver una pgina web (sea la tecnologa que sea). Dicha
pgina web se habr compuesto en el servidor mediante cdigo Java y cdigo cliente.
Una de las primera cosas que querremos hacer ser pasarle informacin a esta pgina. Lo primero que
conocer son las formas de pasar informacin a una pgina web (va POST y va GET). Las diferencias, a
grandes rasgos, son que las peticiones va GET encadenan los valores a pasar a la pgina web en la URL,
mientras que si hacemos una peticin va POST se pasar la informacin de forma implcita.
En el primer caso veremos URL del tipo...
ObtenerParametros.jsp?dato1=pagina&dato2=lineadecodigo
Lgicamente nuestro cometido ser el recuperar la informacin que llega como parmetro para utilizarla
dentro de nuestra pgina web.
Dentro del contexto de la pgina JSP tenemos disponible la variable request. Dicha variable viene a
representar la peticin que es recibida en la pgina. Y consecuentemente los parmetros y valores que la
llegan.
Si queremos recuperar el valor de los parmetros, simplemente deberemos de utilizar el mtodo
.getParameter(String parametro). Donde indicaremos el nombre del parmetro a recuperar.
As, en la anterior peticin podremos recuperar los valores de los parmetros dato1 y dato2 mediante la
siguiente linea de codigo:
String datoUno = request.getParameter("dato1");
String datoDos = request.getParameter("dato2");
Ahora solo nos quedar el utilizar los valores de los datos recibidos como parmetro donde y como
queramos. Por ejemplo para, simplemente, mostrarlos por pantalla.
out.println(datoUno);
out.println(datoDos);
package aulambra.com.lineadecodigo.j2ee.servlets;
/**
* @file RecibirParametros.java
* @version 1.1
* @author Linea de Codigo (http://lineadecodigo.com)
* @date 25-dic-2007
17
* @url http://lineadecodigo.com/2007/12/25/recibir-parametros-en-un-servlet/
* @description Servlet que procesa una peticin de parmetros via POST y GET
*/
import
import
import
import
import
java.io.IOException;
java.io.PrintWriter;
javax.servlet.ServletException;
javax.servlet.http.HttpServletRequest;
javax.servlet.http.HttpServletResponse;
18
La IP de la mquina que invoca es una informacin que al servlet le llega en la peticin, consecuentemente
sus mtodos doGet y doPost lo tendrn en el objeto HttpServletRequest.
Los mtodos que nos permiten recuperar la informacin de la IP y el nombre de la mquina peticionaria son:
getRemoteHost() y getRemoteAddr(). Simplemente les invocamos sobre el mtodo HttpServletRequest.
String ip = null; // IP del cliente
String host = null; // Host del cliente
ip = request.getRemoteAddr();
host = request.getRemoteHost();
Una vez obtenida la informacin, simplemente tendremos que devolverla por respuesta. Para ello nos
apoyamos sobre los objetos PrintWriter y HttpServletResponse.
Veamos el cdigo:
PrintWriter out = response.getWriter();
response.setContentType("text/html");
out.println("<html><head><title>Obtener IP del cliente</title></head><body>");
out.println("<strong>Obtener la IP del cliente </strong>");
out.println("La ip del cliente es " + ip + "<br>");
out.println("El host del cliente es " + host);
out.println("</body></html>");
Java Leer parmetros de inicializacin de un servlet
(http://manuales.dgsca.unam.mx/webdina/escribiendo.htm )
En la vida de ejecucin de un servlet, este, recuperar informacin de mltiples sitios. Por ejemplo recibir
en la peticin informacin va parmetros, recuperar datos de mltiples orgenes: bases de datos, ficheros,
Uno de los sitios de donde podr recuperar informacin son los parmetros de inicializacin del servlet.
Cuando creamos un servlet y lo definimos en el descriptor de despliegue, podemos indicarle que
el servletlleva asociado parmetros de inicializacin y los valores de dichos parmetros.
El uso de estos parmetros es muy potente, ya que se pueden modificar sus valores, con el fin de obtener
un comportamiento diferente del servlet, sin necesidad de recompilar este.
Algunos de los usos de los parmetros de inicializacin podran ser:
Tiempos de control de peticiones
Nombres de recursos externos a los que acceder: ficheros, bases de datos,
Nivel de log que se quiere aplicar al programa.
19
Una vez que hemos definido esto en el descriptor de despliegue, tendremos que acceder a los valores
desde el servlet.
Lo ms normal es acceder a esta informacin en el mtodo init(). Si es que la informacin aplica a todas las
peticiones del servlet.
Para recuperar los parmetros tenemos que acceder a el mtodo .getInitParameter(String parmetro) que
permite acceder al valor del parmetro pasado como argumento a dicho mtodo.
As, para recuperar los valores de nuestro ejemplo tendremos el siguiente cdigo:
_nivelLog = getInitParameter("NivelLog");
_numeroPeticiones = Integer.parseInt(getInitParameter("NumeroPeticiones"));
Hay que fijarse que los valores de los parmetros de inicio son devueltos como cadenas de texto. Es por
ello que tendremos que hacer el tratamiento necesario para convertirlo en otro tipo de dato.
En nuestro caso convertirlo a entero mediante Integer.parseInt(String cadena).
Tanto _nivelLog como _numeroPeticiones lo hemos definido como atributos generales del servlet para que
puedan ser utilizados en todo momento.
package com.lineadecodigo.java.servlet;
/**
* @file ParametrosInicio.java
* @version 1.0
* @author Linea de Codigo (http://lineadecodigo.com)
* @date 26-marzo-2011
* @url http://lineadecodigo.com/java/leer-parametros-de-inicializacion-de-un-servlet/
* @description Servlet que obtiene los parmetros del fichero de configuracin
*/
import
import
import
import
import
import
import
java.io.IOException;
java.io.PrintWriter;
javax.servlet.ServletConfig;
javax.servlet.ServletException;
javax.servlet.http.HttpServlet;
javax.servlet.http.HttpServletRequest;
javax.servlet.http.HttpServletResponse;
20
out.println("</body></html>");
21
disponibles con JavaScript. Y, como se ejecuta en el cliente, JavaScript no puede acceder a los
recursos en el lado del servidor, como bases de datos, catlogos, informacin de precios, etc.
UN SENCILLO SERVLET
Cuando se trata a fin de cuentas, un servlet es una clase Java, y usted ya debe saber cmo
escribir una clase Java:
MyClassName public class {/ / ... propiedades y mtodos ... }
Pero no cualquier clase va a hacer. Servlets para su uso en la Web debe ser subclases de
lajavax.servlet.http.HttpServlet clase, que est integrada en cada servidor web que soporte
servlets.Aunque los servidores diferentes pueden implementar esta clase de otra manera, las
propiedades y mtodos que apoyan estn dictadas por la especificacin de servlets de Java . Al
escribir estas lneas, la versin 2.2 es la ltima versin de la especificacin, aunque la versin
2.3 se encuentra en la fase de proyecto final. La documentacin que conforma la especificacin
incluye una referencia de todas las clases que Servlet servidores compatibles deben
proporcionar.
Por lo tanto la creacin de un servlet es tan simple como crear una subclase de HttpServlet :
import java.io. *; javax.servlet importacin *,. importacin javax.servlet.http *;. MyServlet
public class HttpServlet {/ / ... propiedades y mtodos ... }
Tenga en cuenta que estamos importando los tres
paquetes java.io , javax.servlet yjavax.servlet.http en el anterior. javax.servlet.http contiene
el HttpServlet clase que estamos ampliando, mientras que javax.servlet contiene una serie de
clases relacionado con el trabajo con Servlets y java.io contiene todas las clases estndar de
Java para llevar a cabo la entrada y salida. Dado que la gran mayora de los Servlets hacer uso
de las clases en los dos ltimos paquetes, lo mejor es simplemente incluir la derecha del palo,
as que no se olvide despus.
Un servlet debe proporcionar al menos un mtodo que se utiliza por el servidor web para
manejar las peticiones. El nombre del mtodo (s) depende del tipo de peticin que queremos
manejar. Una peticin HTTP GET es la forma ms simple de solicitud de la pgina, y se produce
ya sea como resultado de que el usuario escribe una direccin URL o hacer clic en un
enlace. Para permitir que el servlet manejar peticiones GET, debe proporcionar un mtodo
llamado doGet de la siguiente manera:
public void doGet (HttpServletRequest req, HttpServletResponse RSP) lanza ServletException,
IOException {/ / ... gestionar las peticiones GET}
Como puede ver, doGet debe ser un pblico mtodo que no devuelve nada ( void ), y toma dos
parmetros:
Un HttpServletRequest objeto (esta clase es parte de la javax.servlet.http paquete), que en el
ejemplo anterior que le asignamos a una variable llamada req .
Un HttpServletResponse objeto (tambin en javax.servlet.http ), que le asignamos a la RSP .
Cuando se invoca este mtodo, el HttpServletRequest ( REQ ) se pasa como parmetro ser un
objeto que proporciona acceso a toda la informacin relacionada con la solicitud del explorador
que dio origen a este servlet. Utilizando varios mtodos de HttpServletRequest , usted puede
encontrar cosas como la direccin IP del navegador solicitante, o de los valores enviados en la
cadena de consulta URL (por ejemplo,index.html? nombre = valor ). Mientras tanto,
el HttpServletResponse ( RSP ) representa la respuesta que se enva al navegador. Este es el
objeto que nos permite enviar el cdigo HTML de vuelta al navegador, por ejemplo. Pero ms
en req y el RSP en un momento.
Si usted est preocupado acerca de la lanza ServletException, IOException parte de la
declaracin de la funcin, no se. No hemos cubierto esto en cualquiera de los artculos
anteriores de esta serie, pero en realidad es bastante simple. Todo esto hace es indicar los
tipos de excepciones (errores) que pueden ocurrir como resultado de llamar a este
mtodo. En este caso, cuando el servidor Web llama al mtodo doGet la funcin con el fin de
procesar una peticin GET, debe estar preparado para el hecho de que unServletException o
una IOException puede ocurrir, y que debe manejar estos errores con gracia. Si bien esto suena
horrible, lo que realmente hace nuestro trabajo ms fcil. Una excepcin IOException , por
ejemplo, podra ocurrir si el navegador de Internet se cerr antes de que termine la descarga
de la respuesta de nuestro servlet se va a enviar. Pero desde el doGet funcin se declara de tal
manera que puede lanzar (causa) IOException s, no tiene que preocuparse por estos errores,
ya que el servidor Web a manejar para nosotros cuando se produzcan!
Ahora, en este ejemplo, vamos a hacer que nuestro servlet enviar una simple pgina HTML al
navegador en respuesta a su solicitud. Aqu est el cdigo completo para el doGet mtodo:
public void doGet (HttpServletRequest req, HttpServletResponse RSP) lanza ServletException,
IOException {rsp.setContentType ("text / html"); PrintWriter a cabo rsp.getWriter = ();
22
out.println ("<html>"); out.println ( "<head> <title> Servlet simple </ title> </ head>");
out.println ("<body>"); out.println ("! <p> Este es un Servlet simple </ p>" ); out.println ("</
body> </ html>");}
De nuevo, esto no es tan complicado como puede parecer a primera vista. Demos un paso a
travs del cuerpo de este mtodo una lnea a la vez:
rsp.setContentType ("text / html");
En esta lnea, estamos llamando a la setContentType mtodo de la RSP variable (que como se
recordar contiene un HttpServletResponse objeto). Este mtodo establece el HTTP ContentType de la cabecera"text / html" ; tipo MIME, que indica al navegador Web de esperar que una
pgina Web HTML. Cualquier Servlet que genera una pgina Web debe comenzar por
establecer este tipo de contenido. Del mismo modo, un servlet que genera un archivo de texto
que establezca el tipo de contenido a "text / plain" , y un servlet que genera un archivo GIF
usara "image / gif" .
PrintWriter a cabo rsp.getWriter = ();
Ahora bien, como vamos a generar una pgina web, vamos a querer enviar cdigo HTML en el
explorador Web. El cdigo HTML es simplemente texto plano, y el estndar de Java E / S de
clase para la salida de datos de texto sin formato es java.io.PrintWriter . En esta lnea, se
declara una variable llamada a cabopara almacenar un PrintWriter (recordemos que hemos
importado de la java.io paquete, as que podemos referirnos a esta clase directamente sin dar
su nombre completo). Para obtener un PrintWriterobjeto que est configurado para el texto de
salida como la respuesta al navegador Web, simplemente llame a la getWriter mtodo de RSP ,
que contiene nuestro objeto de respuesta, y asignar el valor devuelto a nuestro
nuevo cabo variable.
out.println ("<html>");
El resto de la doGet mtodo simplemente utiliza el PrintWriter ( a ) para la salida de cdigo
HTML en el navegador. Al igual que en los programas de ejemplo en los artculos anteriores, en
donde pudimos salida de texto a la pantalla con System.out.println ( System.out es tambin
un PrintWriter ), se puede dar salida a las lneas de texto en el navegador Web con
el println mtodo de nuestra a objeto. Recordemos que println se inicia automticamente una
nueva lnea al final de la cadena que se le dice a la salida. Si no desea iniciar una nueva lnea
en el cdigo HTML, puede utilizar la impresin mtodo en lugar de println .
Descargue la plena MyServlet.java archivo o escriba a cabo a partir de los listados anteriores y
gurdelo en algn lugar conveniente en su equipo (yo uso un directorio llamado C: \ JavaDev ,
por ejemplo). A continuacin, veremos cmo compilar e implementar un servlet.
COMPILACIN DE UN SERVLET
Todos los programas de Java que hemos visto hasta ahora eran muy fcil de compilar. Por
desgracia, si se intenta compilar el MyServlet.java archivo que se produce en la seccin
anterior, obtendr una serie de mensajes de error bastante feo:
D: \ javadev> javac MyServlet.java MyServlet.java: 2: javax.servlet paquete no existe
javax.servlet import *; ^ MyServlet.java:. 3: paquete javax.servlet.http no existe javax.servlet
de importacin. http *; ^ MyServlet.java:. 5: no se puede resolver el smbolo smbolo: ubicacin
de la clase HttpServlet: MyServlet MyServlet clase public class HttpServlet {^ ...
Ahora, la mejor tctica me parece la hora de abordar los errores de compilacin es mirar los
errores enumerados en la parte superior primero, ya que los errores de hecho podra ser la
causa de algunos de los errores de otros que estn apareciendo ms abajo. En este caso, por
ejemplo, los cuatro "no puede resolver el smbolo" errores es muy probable que vea en realidad
son el resultado de los dos "paquete no existe" errores en la parte superior. Mirando ms de
cerca, te dars cuenta de que el compilador se est asfixiando a las dos de
importacin comandos que se utilizan para importar
los javax.servlet yjavax.servlet.http paquetes. Dado que no puede importar los paquetes, no
vamos a poder utilizar cualquiera de las clases que residen en ellos, y resulta que todos los "no
puede resolver el smbolo" los errores se refieren a lugares en los que estamos tratando de
hacer as.
Por qu no puedo encontrar esos dos paquetes? Pues bien, estos dos paquetes que no son en
realidad construida en Java, como java.io es. En cambio, vienen con el servidor Web Servlet con
capacidad (por ejemplo Tomcat). As que antes de que el compilador de Java ser capaz de
compilar el servlet, necesitamos hacerle saber dnde encontrar las clases de estos dos
paquetes.
Los cursos requeridos normalmente se almacenan en un archivo llamado servlet.jar . La
ubicacin exacta de este archivo depende del software de servidor Web en particular que usted
utilice, pero en el caso de Tomcat se puede encontrar en el lib subdirectorio del directorio de
23
24
implementado. Dado que los archivos XML son texto plano, slo tiene que abrirlo en el Bloc de
notas para hacer los cambios necesarios.La primera vez que instalar Tomcat, web.xml no
contiene ninguna informacin de configuracin:
<DOCTYPE web-app PUBLIC <xml version = "1.0" encoding = "ISO-8859-1"?>! "- / / Sun
Microsystems, Inc. / / DTD Web Application 2.2 / / EN" "http:// java.sun.com/j2ee/dtds/webapp_2_2.dtd "> <web-app> </ web-app>
Mediante la adicin de etiquetas entre <web-app> y </ aplicacin web-> , usted puede
agregar informacin de configuracin de los servlets. Aqu es cmo asignar el nombre de 'mi'
a MyServlet :
<web-app> <servlet> <servlet-name> mi </ servlet-name> <servlet-class> MyServlet </
servlet-class> </ servlet> </ web-app>
Si guarda los cambios mencionados, a continuacin, cierre y reinicie Tomcat, usted ser capaz
de acceder a su servlet como http://localhost:8080/servlet/my . Esto puede no parecer gran
cosa, pero cuando el nombre de su Servlet de clase es de 25 caracteres de longitud y est
profundamente anidado en un paquete, se le aprecian la posibilidad de darle un nombre
bonito, corto.
Asignar un nombre a su Servlet tambin le permite usar ese nombre para especificar los
parmetros de configuracin adicionales para el servlet. El <servlet-mapping> etiqueta, por
ejemplo, le permite mapear nuestro servlet a cualquier direccin URL o el patrn de URL en el
servidor:
<web-app> <servlet> <servlet-name> mi </ servlet-name> <servlet-class> MyServlet </
servlet-class> </ servlet> <servlet-mapping> <servlet-name> mi </ servlet -name> <urlpattern> / my.html </ url-pattern> </ servlet-mapping> </ web-app>
El cdigo anterior le permitir acceder a servlet como http://localhost:8080/my.html escondiendo por completo el hecho de que usted est utilizando un Servlet en
absoluto! Tambin puede especificar un <url-pattern> con un carcter comodn, como / mi * / ,
que utilizara el Servlet para mostrar cualquier URL que se inici
con "http://localhost:8080/my/" , o *. bla , que se asignara todas las solicitudes de nombres de
archivos que terminan en . bla, a su Servlet. Desde el HttpServletRequest objeto que el servlet
recibe le permite a su Servlet examinar la direccin URL que se solicita, que posiblemente
podra asignar un Servlet solo / * y se manejar todas las peticiones en su sitio web, el envo de
respuestas diferentes en funcin de la direccin URL solicitada!
Si usted tiene Apache configurado como el servidor web principal con mod_jk para reenviar las
solicitudes de Servlets y JavaServer Pages (JSP) de Tomcat, usted encontrar que <urlpattern> no funciona como se esperaba. Esto es as porque, por defecto, Apache slo enviar
las solicitudes de archivos que terminan en . jsp o archivos en el / servlet a Tomcat directorio
para su procesamiento. Para reenviar los patrones de URL adicionales a Tomcat, debe utilizar
el JkMount directiva en el archivo de configuracin de Apache.Asegrese de hacer esto despus
de la lnea en la que incluir Tomcat mod_jk.conf auto- archivo (que se carga el mdulo
necesario para JkMount a trabajar). . Por ejemplo, al mapa / mi / * bla (todos bla. los archivos
de la mi / directorio) de Tomcat, debe agregar lo siguiente:
JkMount / mi / *. Bla ajp13
Tenga en cuenta que se especifica el ms eficiente ajp13 protocolo para la comunicacin entre
Apache y Tomcat para esta aplicacin (Tomcat mod_jk.conf auto- archivo que se utiliza el ms
antiguo y menos eficiente ajp12 para las asignaciones por defecto). Con ese cambio realizado,
reiniciar Tomcat y Apache y su asignacin debe ahora trabajar a travs de su servidor Apache.
Como puedes ver, todo este despliegue y la configuracin de Servlets es un negocio bastante
sucio cuando se hace por mtodos convencionales. Servidores Web comerciales, como los que
mencion en la introduccin a menudo ofrecen las interfaces de administracin grficas
bonitas, que hacen que todas estas modificaciones de bajo nivel para que en el fondo. El
formato del archivo web.xml archivo, sin embargo, se define en el estndar de Servlets, y con
el apoyo de todos los servidores de servlets habilitado, aunque ms fciles se proporcionan
mtodos para la gestin de la configuracin que contiene.
UN EJEMPLO DINMICO
El servlet simple ( MyServlet ) que hemos trabajado hasta ahora no es muy emocionante, ya
que muestra lo mismo cada vez que se carga. El poder de los servlets es que se puede generar
una respuesta nueva dinmica cada vez que se cargan. Los usos ms comunes de los Servlets
incluyen la recuperacin de contenido dinmico a partir de una base de datos, visualizacin de
documentos XML en HTML utilizando hojas de estilo XSL, y el procesamiento de los envos de
formularios y tomar las medidas apropiadas (por ejemplo, aplicaciones de comercio
electrnico).
25
Para nuestro Servlet primera dinmica, vamos a mostrar la fecha y la hora actuales del
servidor. Aqu est el cdigo del servlet ( Time.java ):
import java.io. *; importacin javax.servlet *,. importacin javax.servlet.http *,. importacin
java.util.Date; Tiempo public class HttpServlet {public void doGet (HttpServletRequest req,
HttpServletResponse RSP) lanza ServletException, IOException {rsp.setContentType ("text /
html"); PrintWriter a cabo rsp.getWriter = (); Fecha de hoy = new Date (); / / La fecha / hora
actual out.println ("<html>"); out.println ("Time Check <head> <title> </ title> </ head>");
out.println ("<body>"); out.println ("<p> La hora es:" + ahora + "< / p> "); out.println (" </
body> </ html> ");}}
Con todo, este servlet es muy similar a MyServlet . Echemos un vistazo a lo que hay de nuevo:
la importacin java.util.Date;
Importamos integrado de Java Fecha de la clase de java.util paquete. Usted puede leer acerca
de esta clase en la documentacin del API de Java, si eres curioso acerca de sus propiedades y
mtodos.
Fecha de hoy = new Date (); / / La fecha / hora actual
Creamos una nueva variable llamada ahora y almacenar una nueva Fecha de objetos en
ella. Cuando un objeto Date se crea, contiene la fecha y la hora en que fue creado, y los
mostrar cuando se imprime como parte de una cadena :
out.println ("<p> La hora es:" + ahora + "</ p>");
Compilar el archivo (o descargar Time.class ) e implementarlo como se muestra en la seccin
anterior.Ahora, cuando se carga http://localhost:8080/servlet/Time vers una pgina como esta:
26
httpServletResponse.setContentType(text/plain);
PrintWriter out = httpServletResponse.getWriter();
out.println(Hello World!);
out.close();
}
}
[/java]
ESCRIBIENDO UN SERVLET SIMPLE
En seguida se proporcionan los pasos necesarios para hacer funcionar sin problemas un
Servlet, y realizar un primer anlisis de su estructura bsica.
Para comenzar, escribiremos un ejemplo sencillo que nos va a servir para entender la forma
bsica de un servlet. El ejemplo consiste en una forma HTML en la que existir un campo de
entrada, con los correspondientes botones Submit y Reset tpicos de cualquier formulario de
entrada de datos.
A oprimir sobre el botn Submit se producir la ejecucin del Servlet en el servidor, que
procesar la informacin recibida, y mostrar como resultado una pgina HTML con el texto
introducido con anterioridad.
Cdigo HTML
<html>
<head>
<title>Ejemplo de un Servlet simple</title>
</head>
<body>
<form action=http://servidor:8080/servlet/ServletSimple method=POST>
<BR>
<BR>Introduzca un texto en el cuadro y oprima el botn "Aceptar"
<BR>
<input type=text name=TEXTO>
<p>
<input type=submit value=Aceptar><input type=reset value=Limpiar>
</form>
</body>
</html>
En el cdigo HTML necesario para implementar el ejemplo destacan dos partes. En primer lugar
la cabecera delform, que indica la accin a desencadenar en el servidor al pulsar el botn de
Submit, y en segundo lugar la parte en que se define el form propiamente. El archivo que
contiene la pgina HTML lo llamaremos ServletSmiple.htm.
Cdigo del Servlet
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public class ServletSimple extends HttpServlet
{
public void service(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException
{
ServletOutputStream salida = res.getOutputStream();
res.setContentType("text/html");
String cadena = req.getParameter("TEXTO");
salida.println ("<p>Datos capturados : "+ cadena + "</p>");
}
}
Los datos enviados desde la forma son recibidos por el servlet que fue invocado por la misma.
El cdigo java del servlet es el siguiente:
Para este primer ejemplo, el cdigo necesario fue mnimo, lo cual es una prueba de la enorme
potencia y simplicidad que se deriva de la utilizacin de los Servlets.
En el programa destaca principalmente la utilizacin de los
paquetes javax.servlet.* y javax.servlet.http.*, y la clusula extends que define el programa
como una extensin de HttpServlet. El archivo que contiene el Servlet lo
27
llamaremos ServletSimple.java. Una vez que ha sido compilado, usando javac , almacenaremos
el archivo .class resultante en el directorio /servlets dentro del directorio donde hayamos
instalado el servidor de servlets.
Descripcin del cdigo
Dentro del cdigo java se observa el mtodo principal, el mtodo service, el cual es
implementado hasta por el servlet ms simple. Este mtodo se encarga de procesar la peticin
del cliente, y utiliza dos parmetros, uno de peticin y otro de respuesta:
En el caso particular del protocolo http se utilizan interfaces
de HttpServletRequest y HttpServletResponserespectivamente. Estos parmetros encapsulan
los datos que son mandados tanto desde el cliente, como desde el servidor. De hecho,
normalmente se utilizan mtodos de entrada para recuperar datos desde el cliente, y mtodos
de salida para responder. Nosotros utilizamos ServletOutputSteram para responder al cliente.
Para recuperar los datos que nos manda el cliente, utilizamos el mtodo getParameter.
Finalmente, utilizando elstream de salida le mandamos la respuesta al cliente.
Realmente, el programa es muy sencillo, pero la funcionalidad muy alta.
Ejecucin de los servlets
Como se muestra en la forma html el servlet es invocado como la accin a llevara cabo. El
servlet es habilitado por la utilera servletrunner que es un programa encargado de probar y
ejecutar los servlets.
El servletrunner habilita un puerto por defecto, el 8080, en el servidor de web que se est
utilizando para ejecutar al servlet. Para invocar entonces al servlet debemos emplear el url con
la siguiente forma:http://nombre_servidor:8080/servlet/nombre_servlet
nombre_servidor Direccin del host que alberga al servidor de web
:8080 Puerto asignado por defecto por el servletrunner
/servlet Directorio virtual donde residirn los servlets
nombre_servlet Nombre del programa que identifica al servlet
Entonces, la ejecucin de servlet ejemplo aparece mostrada en la figura 1, que es la forma
html que recibe la captura del texto.
La ejecucin del servlet arroja la siguiente salida en el navegador como resultado. Ver Figura
Figura 1. Forma
html para
llamar al
servlet ServletS
imple
28
}
public void service(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
res.setContentType("text/html");
PrintWriter out = res.getWriter();
out.println("<html>");
out.println("<body>");
out.println("<h1>Hola Mundo</h1>");
out.println("</body>");
out.println("</html>");
}
}
Comentemos un poco nuestro este primer servlet. Lo primero que nos aparece son las clases
que utiliza (las bibliotecas o includes de C):
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
Vemos que utiliza las clases correspondientes a servlets (javax.servlet.*), las clases
correspondientes a servlets que utilizan el protocolo HTTP (javax.servlet.http.*). El protocolo
HTTP es el protocolo estndar en la web (o WWW - World Wide Web). Por eso, cuando en un
navegador abrimos una direccin, la mayora empieza por http://. Tambin utiliza clases de
entrada/salida (java.io.* - io viene input/output) para poder escribir en pantalla.
Lo segundo que vemos es el nombre de la clase (class HolaMundo) que es pblica (public), en
el sentido de que cualquiera puede usarla sin ningn tipo de restriccin) y que hereda
(extends) de la clase HttpServlet.
public class HolaMundo extends HttpServlet {
Algo que debemos saber es que toda clase, para que se considere un servlet, debe
implementar el interfaz javax.servlet.Servlet. Para conseguirlo lo ms sencillo es hacer que
nuestra clase herede o bien de la
clase javax.servletGenericServlet o javax.servlet.http.HttpServlet. Con la primera obtendremos
un servlet independiente del protocolo, mientras que con la segunda tendremos un servlet
HTTP. En este tutorial, slo vamos a ver servlets que funcionen con el protocolo HTTP as que,
por tanto, siempre heredarn de HttpServlet. Resumiendo, slo cambiar el nombre de la clase
para cada servlet que hagamos.
El siguiente trozo de cdigo que aparece (y que tenemos que implementar siempre) es la
redefinicin del mtodo init. El servidor invoca a este mtodo cuando se crea el servlet y en
este mtodo podemos hacer todas las operaciones de inicializacin que queramos. Como en
este servlet no nos hace falta inicializacin ninguna, lo nico que hacemos es llamar al mtodo
init por defecto (al de la superclase).
public void init(ServletConfig conf)
throws ServletException {
super.init(conf);
}
Podemos observar que el mtodo init es pblico, no devuelve ningn tipo (void), que puede
lanzar una excepcin (ServletException) y que tiene un parmetro (ServletConfig conf). De
estos dos ltimos aspectos (excepcin y parmetro) no nos tenemos que preocupar pues es el
servidor quien ejecuta el mtodo init. En el peor de los casos, tendramos que lanzar la
excepcin (si sabemos hacerlo), si por algn motivo el mtodo init que nosotros
implementemos falle (por ejemplo, que no se pueda conectar a la base de datos y evitamos
mostrar un mensaje de error)
Lo siguiente que hacemos redefinir el mtodo service, cuando el servidor web recibe una
peticin para un servlet llama al mtodo public void service(HttpServletRequest req,
HttpServletResponse res) con dos parmetros: el primero, de la clase HttpServletRequest,
representa la peticin del cliente y el segundo, de la clase HttpServletResponse, representa
la respuesta del servidor (del servlet, ms concretamente).
public void service(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
res.setContentType("text/html");
PrintWriter out = res.getWriter();
29
out.println("<html>");
out.println("<body>");
out.println("<h1>Hola Mundo</h1>");
out.println("</body>");
out.println("</html>");
}
Como en este primer ejemplo no necesitamos ninguna informacin del cliente, no usaremos
para nada el parmetro HttpServletRequest, ms adelante veremos como hacerlo. De la
clase HttpServletResponse usamos dos mtodos:
setContextType(String str) para establecer el tipo de respuesta que vamos a dar. Para
indicar que se trata de una pgina web, como haremos siempre, usamos el tipo "text/html".
res.setContentType("text/html");
PrinterWriter getWriter(void) con el que obtendremos una clase PrinterWriter en donde
iremos escribiendo los datos que queremos que el cliente reciba (como podra ser el stdout de
C o el cout de C++):
PrintWriter out = res.getWriter();
Una vez que hemos establecido el tipo de respuesta (text/html)y tenemos el flujo de salida
(variable out) slo nos queda utilizar el mtodo println de la clase PrinterWriter para ir
escribiendo en dicho flujo de salida la pgina HTML que queremos que visualice el cliente.
2 Servlet GetPost
Vamos a ver un ejemplo, un poco ms complicado. Si llamamos un servlet desde un formulario
HTML, podremos hacerlo de dos formas: GET y POST. Con la primera los parmetros del
formulario estn incluidos la url que se utiliza para invocar el servlet y en el segundo caso los
parmetros se almacenan en un buffer especial del servidor.
Para procesar el primer tipo de peticiones (GET) est el mtodo doGet mientras que para el
segundo tenemos el mtodo doPost . La implementacin por defecto del mtodoservice es
capaz de determinar el tipo de peticin HTTP que en un momento dado recibe el servlet. Una
vez identificada llama o al mtodo doGet o al doPost segn el caso. Como, en la mayora de
los casos, seremos nosotros quien programe el formulario que llame al servlet, sabremos que
tipo de llamada se har, por lo que podemos optar por redefinir uno slo de los mtodos. En el
caso de que no lo supiramos se deben implementar los mtodos doGet y doPost.
Un servlet que tiene diferente respuesta en funcin de la llamada que se le hace es el
ejemplo GetPost.java cuyo cdigo fuente era el siguiente:
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public class GetPost extends HttpServlet {
public void init(ServletConfig conf)
throws ServletException {
super.init(conf);
}
public void doGet(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException
{
res.setContentType("text/html");
PrintWriter out = res.getWriter();
out.println("<html>");
out.println("<body>");
out.println("<h1>Hola Mundo (llamada GET)</h1>");
out.println("</body>");
out.println("</html>");
}
public void doPost(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException
{
res.setContentType("text/html");
30
31
32
<h1>Formulario</h1>
<form method="POST" action="/tutorial/servlet/Parametros">
Nombre: <INPUT TYPE="TEXT" NAME="nombre"><BR>
Primer Apellido:<INPUT TYPE="TEXT" NAME="apellido1"><BR>
Segundo Apellido:<INPUT TYPE="TEXT" NAME="apellido2"><BR>
<hr>
Correo electronico: <INPUT TYPE="TEXT" NAME="email"><BR>
Clave: <INPUT TYPE="PASSWORD" NAME="clave"><BR>
<hr>
Comentario: <TEXTAREA NAME="comenta" ROWS=3 COLS=40>
</TEXTAREA><BR>
<hr>
Sexo:<BR>
<INPUT TYPE="RADIO" NAME="sexo" VALUE="hombre">Hombre<BR>
<INPUT TYPE="RADIO" NAME="sexo" VALUE="mujer">Mujer<BR>
Areas de inters:<br>
<SELECT NAME="intereses" MULTIPLE>
<OPTION>Informatica</OPTION>
<OPTION>Derecho</OPTION>
<OPTION>Matematicas</OPTION>
<OPTION>Fisica</OPTION>
<OPTION>Musica</OPTION>
</SELECT>
<center><input type="submit" value="Enviar"></center>
</form>
</body>
</html>
Veamos primero un servlet que conociendo de antemano los distintos parmetros que va a
recibir los vaya mostrando en una pgina HTML. El servlet lo llamaremosParametros.java y
su cdigo es:
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public class Parametros extends HttpServlet {
public void init(ServletConfig conf)
throws ServletException {
super.init(conf);
}
public void doGet(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
res.setContentType("text/html");
PrintWriter out = res.getWriter();
out.println("<html>");
out.println("<body>");
out.println("<h1>Parmetros del servlet desde un formulario HTML</h1>");
out.println("<br> Nombre:"+req.getParameter("nombre") );
out.println("<br> Primer apellido:"+req.getParameter("apellido1") );
out.println("<br> Segundo apellido:"+req.getParameter("apellido2") );
out.println("<br> Correo electrnico:"+req.getParameter("email") );
out.println("<br> Contrasea:"+req.getParameter("clave") );
out.println("<br> Comentario:"+req.getParameter("comenta") );
out.println("<br> Sexo:"+req.getParameter("sexo") );
out.println("<br> Areas de inters:"+req.getParameter("intereses") );
out.println("</body>");
out.println("</html>");
}
33
34
En el siguiente paso, nos solicita el nombre del proyecto (Project Name), en nuestro caso
ingresamos Servlet_HelloWorld
35
Finalmente, nos permite seleccionar el o los frameworks a utilizar (Spring, Struts, JSF, etc). No
seleccionamos nada pues, por ahora, para este ejempo, no vale la pena.
NetBeans crea por su cuenta el proyecto, una estructura de directorios, y dentro de la
carpeta Web Pages un arhivo index.jsp, que ser el punto de partida de nuestra aplicacin.
Si bien es de extensin JSP, por ahora no escribiremos cdigo JSP, sin simplemente un
formulario HTML. En este formulario HTML definiremos en el atributo action el nombre
del servlet que se ejecutar al enviar (submit) el formulario.
Aqu, se abre un dilogo que nos solicita nombre y paquete del servlet.
En nombre, hay que ingresar el mismo nombre del atributo action del formulario creado
anteriormente, pues este ser el servlet que recibir los datos enviados por el formulario
HTML. En nuestro caso, segn indicamos en el form: Servlet_Hola.
En paquete se puede ingresar el nombre que se quiera, ahora no es de importancia.
36
37
38