Guía de Cliente Servidor Codigo

GUA DE CLIENTE SERVIDOR
Programacin paso a paso.

CONCEPTOS PREVIOS.
Generacin de pginas en forma dinmica utilizando Apache Tomcat.
El servidor Tomcat es una aplicacin web basada en Java creada para ejecutar servlets y
pginas JSP, siendo la implementacin oficial de referencia de las especificaciones Servlet 2.3 y
JavaServer Pages 1.2.
Java Servelt. Los servlets son objetos que corren dentro y fuera del contexto de
un contenedor de servlets (ej: Tomcat) y extienden su funcionalidad.
La palabra servlet deriva de otra anterior, applet, que se refera a pequeos programas que se
ejecutan en el contexto de un navegador web. Por contraposicin, un servlet es un programa
que se ejecuta en un servidor.
El uso ms comn de los servlets es generar todas pginas web de forma dinmica a partir de
los parmetros de la peticin que enve el navegador web.
Aspectos tcnicos
Un servlet es un objeto que se ejecuta en un servidor o contenedor JEE, especialmente
diseado para ofrecer contenido dinmico desde un servidor web, generalmente HTML. Otras
opciones que permiten generar contenido dinmico son los lenguajes ASP, PHP, JSP (un caso
especial de servlet), Ruby y Python. Forman parte de JEE (Java Enterprise Edition), que es una
ampliacin de JSE (Java Standard Edition).
Un servlet implementa la interfaz javax.servlet.Servlet o hereda alguna de las clases ms
convenientes para un protocolo especfico (ej: javax.servlet.HttpServlet). Al implementar esta
interfaz
el
servlet
es
capaz
de
interpretar
los
objetos
de
tipo HttpServletRequest y HttpServletResponse quienes contienen la informacin de la pgina
que invoc al servlet.
Entre el servidor de aplicaciones (o web content) y el servlet existe un contrato que determina
cmo han de interactuar. La especificacin de ste se encuentra en los JSR (Java Specification
Requests) del JCP (Java Community Process).
Descriptor de despliegue
El descriptor de despliegue es un archivo que se localiza en el directorio WEB-INF y se
llama web.xml. En l es donde se controla el comportamiento de los Servlet y pginas JSP.
Ejemplo sencillo de un Descriptor de despliegue
<?xml version="1.0" encoding="UTF-8"?>
<web-app
version="3.0"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
<servlet>
<servlet-name>HolaMundoServlet</servlet-name>
<servlet-class>org.pruebas.HolaMundoServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HolaMundoServlet</servlet-name>
<url-pattern>/HolaMundoServlet</url-pattern>
</servlet-mapping>
<session-config>
<session-timeout>30</session-timeout>
</session-config>
</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;
public class HolaMundoServlet extends HttpServlet {

/**
* Servlet de ejemplo que procesa una peticin GET
* @param request
* @param response
* @throws ServletException
* @throws IOException
*/
@Override
public void doGet(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
PrintWriter out = response.getWriter();
out.println("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\">");
out.println("<html>");
out.println("<head><title>Ejemplo Hola Mundo</title></head>");
out.println("<body>");
out.println("<h1>Hola Mundo!</h1>");
out.println("</body></html>");
}
DIFERENCIAS ESTRE LAS TECNOLOGIAS CGI Y SERVLET

La tecnologa Servlet proporciona las mismas ventajas del lenguaje Java en cuanto a
portabilidad (write once, run anywhere) y seguridad, ya que un Servlet es una clase de Java
igual que cualquier otra, y por tanto tiene en ese sentido todas las caractersticas del lenguaje,
Esto es algo de lo que carecen los programas CGI, ya que hay que compilarlos para el sistema
operativo del servidor y no disponen en muchos casos de tcnicas de comprobacin dinmica
de errores en tiempo de ejecucin.
Otra de las principales ventajas de los Servlets con respecto a los programas CGI, es la del
rendimiento y esto a pesar de que java no es un lenguaje particularmente rpido, Mientras que
es necesario cargar los programas CGI tantas veces como peticiones del servicio existan por
parte de los clientes, los Servlets, una vez que son llamados por primera vez, quedan activos
en la memoria del servidor hasta que el programa que controla el servidor los desactiva. De
esta manera se minimiza en gran medida el tiempo de respuesta.
Adems, los Servlets se benefician de la gran capacidad de Java para ejecutar mtodos en
ordenadores remotos, para conectar bases de datos, para la seguridad de la informacin, ect.
Se podra decir que las clases estndar de Java ofrecen resueltos muchos problemas que con
otros lenguajes tiene que resolver el programador.
Java EE.
Java Platform, Enterprise Edition o Java EE (anteriormente conocido como Java 2 Platform,
Enterprise Edition o J2EE hasta la versin 1.4), es una plataforma de programacinparte de
la Plataforma Javapara desarrollar y ejecutar software de aplicaciones en el lenguaje de
programacin Java con arquitectura de N capas distribuidas y que se apoya ampliamente en
componentes de software modulares ejecutndose sobre un servidor de aplicaciones. La
plataforma Java EE est definida por una especificacin. Similar a otras especificaciones
del Java Community Process, Java EE es tambin considerada informalmente como un estndar
debido a que los proveedores deben cumplir ciertos requisitos de conformidad para declarar
que sus productos son conformes a Java EE; estandarizado por The Java Community Process /
JCP.
Java EE tiene varias especificaciones de API, tales como JDBC, RMI, e-mail, JMS, Servicios
Web, XML, etc y define cmo coordinarlos. Java EE tambin configura algunas especificaciones
nicas
para
Java
EE
para
componentes.
Estas
incluyen Enterprise
JavaBeans, servlets, portlets (siguiendo la especificacin de Portlets Java), JavaServer Pages y
varias tecnologas de servicios web. Ello permite al desarrollador crear una Aplicacin de
Empresa portable entre plataformas y escalable, a la vez que integrable con tecnologas
anteriores. Otros beneficios aadidos son, por ejemplo, que el servidor de aplicaciones puede
manejar transacciones, la seguridad, escalabilidad, concurrencia y gestin de los componentes
desplegados, significando que los desarrolladores pueden concentrarse ms en la lgica de
negocio de los componentes en lugar de en tareas de mantenimiento de bajo nivel.
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.
Open DataBase Connectivity (ODBC) es un estndar de acceso a bases de

datos desarrollado por SQL Access Group en 1992, el objetivo de ODBC es hacer posible el
acceder a cualquier dato desde cualquier aplicacin, sin importar qu sistema de gestin de
bases de datos (DBMS) almacene los datos, ODBC logra esto al insertar una capa intermedia
(CLI) denominada nivel de Interfaz de Cliente SQL, entre la aplicacin y el DBMS, el propsito
de esta capa es traducir las consultas de datos de la aplicacin en comandos que el DBMS
entienda. Para que esto funcione tanto la aplicacin como el DBMS deben ser compatibles con
ODBC, esto es que la aplicacin debe ser capaz de producir comandos ODBC y el DBMS debe
ser capaz de responder a ellos. Desde la versin 2.0 el estndar soporta SAG y SQL.
El software funciona de dos modos, con un software manejador en el cliente, o una filosofa
cliente-servidor. En el primer modo, el driver interpreta las conexiones y llamadas SQL y las
traduce desde el API ODBC hacia el DBMS. En el segundo modo para conectarse a la base de
datos se crea una DSN dentro del ODBC que define los parmetros, ruta y caractersticas de la
conexin segn los datos que solicite el creador o fabricante.
Java Database Connectivity (JDBC) es un derivado inspirado en el mismo, una interfaz de
programacin de aplicaciones 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.
Interfaz (Java)
Una interfaz en Java es una coleccin de mtodos abstractos y propiedades. En ellas se
especifica qu se debe hacer pero no su implementacin. Sern las clases que implementen
estas interfaces las que describan la logica del comportamiento de los mtodos.
Ventajas
El uso de interfaces proporciona las siguientes ventajas:
Organizar la programacin(IAJU).
Obligar a que ciertas clases utilicen los mismos mtodos (nombres y parmetros).
Establecer relaciones entre clases que no estn relacionadas.
Uso
Java proporciona dos palabras reservadas para trabajar con interfaces: interface e implements.
Para declarar una interfaz se utiliza:
modificador_acceso interface NombreInterfaz {
....
}
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.*;
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).
// Use "out" to send content to browser
}
}
(Descarga
la plantilla de cdigo fuente -- pulsa con el botn derecho del ratn
sobre el enlace o mantn pulsada la tecla SHIFT mientras pulsas sobre el enlace).
import java.io.*;
public class SomeServlet extends HttpServlet {
// 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).

// Use "out" to send content to browser
}
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.*;
public class HelloWorld extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)

out.println("Hello World");
}
COMPILAR E INSTALAR EL SERVLET

Debemos observar que los detalles especficos para instalar servlets varian de servidor en
servidor. Los ejemplos se han probado sobre Java Web Server (JWS) 2.0, donde se espera que
los servlets estn en un directorio llamado servlets en el rbol de instalacin del JWS. Sin
embargo, hemos situado este servlet en un paquete separado (hall) para evitar conflictos con
otros servlets del servidor; querrs hacer lo mismo si usas un servidor Web que es usado por
otras personas y no tiene buena estructura para "servlets virtuales" para evitar
automticamente estos conflictos. As, HelloWorld.java realmente va en un sudirectorio
llamado hall en el directorio servlets. Observa que la configuracin de la mayora de los
servidores, y los ejemplos de este turtorial tambin se han probado usando BEA WebLogic e
IBM WebSphere 3.0. WebSphere tiene un excelente mecanismo para servlets virtuales, y no es
necesario usar paquetes, slo para evitar conflictos de nombres con otros usuarios.
Una forma de configurar nuestro CLASSPATH es apuntar al directorio superior al que contiene
realmente nuestros servlets. Entonces podemos compilar normalmente desde dentro del
directorio. Por ejemplo, si nuestro directorio base es C:\JavaWebServer\servlets y el nombre
de nuestro paquete es (y por lo tanto el del subdirectorio) es hall, y trabajamos bajo Windows,
deberiamos hacer:
DOS> set CLASSPATH=C:\JavaWebServer\servlets;%CLASSPATH%
DOS> cd C:\JavaWebServer\servlets\hall
DOS> javac YourServlet.java
La
primea
parte,
configura
el CLASSPATH,
probablemente
querremos
hacerlo
permanentemente, en vez de hacerlo cada que arrancamos una nueva ventana del DOS. En
Windows 95/98 pondremos la sentencia "set CLASSPATH=..." en algn lugar de nuestro
fichero autoexec.bat despus de la lnea que selecciona nuestro CLASSPATH para apuntar
aservlet.jar y jsp.jar.
Una segunda forma de compilar las clases que estn en paquetes es ir al directorio superior del
que contiene los Servlets, y luego hacer "javac directory\YourServlet.java". Por ejemplo,
supongamos de nuevo que nuestro directorio base es C:\JavaWebServer\servlets y que el
nombre de nuestro paquete (y del directorio) es hall, y que estamos trabajando en Windows.
En este caso, haremos los siguiente:
DOS> cd C:\JavaWebServer\servlets
DOS> javac hall\YourServlet.java
Finalmente otra opcin avanzada es mantener el cdigo fuente en una localizacin distinta de
los ficheros .class. y usar la opcin "-d" de javac para instalarlos en la localizacin que espera
el servidor Web.
EJECUTAR EL SERVLET
Con el Java Web Server, los servlets se sitan en el directorio servlets dentro del directorio
principal
de
la
instalacin
del
JWS,
y
son
invocados
mediantehttp://host/servlet/ServletName. Observa que el directorio es servlets, plural,
mientras que la referencia URL es servlet, singular. Como este ejemplo se situ en el paquete
hall, sera invocado mediante http://host/servlet/hall.HelloWorld. Otros servidores podran
tener convenciones diferentes sobre donde instalar los servlets y como invocarlos. La mayora
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.
Un Servlet que Genera HTML

La mayora de los Servlets generan HTML, no texto normal como el ejemplo anterior. Para hacer
esto, necesitamos dos pasos adicionales, decirle al navegador que estmos devolviendo HTML.
y modificar la sentencia println para construir una pgina Web legal. El primer paso se hace
configurando la cabecera de respuesta Content-Type. En general, las cabeceras de respuesta se
configuran mendiante el mtodo setHeader de HttpServletResponse, pero seleccionar el tipo
de contenido es una tarea muy comn y por eso tiene un mtodo especialsetContentType slo
para este propsito. Observa que necesitamos configurar las cabeceras de respuesta antes, de
devolver algn contenido mediante PrintWriter. Aqu hay un ejemplo:
HelloWWW.java
Tambin puedes descargar
El Cdigo fuente.
package hall;
import java.io.*;
public class HelloWWW extends HttpServlet {
response.setContentType("text/html");
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
UTILIDADES DE CONSTRUCCIN DE HTML SENCILLO

Es un poco aburrido generar HTML con sentencias println. La solucin real es usar Java Server
Pages (JSP), que se describen ms adelante. Sin embargo, para Servlets estndards, hay dos
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
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");
}
}
// Other utilities will be shown later...

HelloWWW2.java
El Cdigo fuente.
Aqu tenemos una nueva versin de la clase HelloWWW que usa esto
package hall;
import java.io.*;
public class HelloWWW2 extends HttpServlet {
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.
protected void doGet(HttpServletRequest request, HttpServletResponse
response) throws ServletException, IOException {
...
}
protected void doPost(HttpServletRequest request, HttpServletResponse
...
}
}
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)
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");
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.
Ahora solo quedar el ir volcando informacin mediante mtodos .println(). El cual tiene como parmetro el
texto a volcar a la pgina.
11
out.println("<head><title>Enviar parametros a un Servlet</title></head>");

out.println("<h1>Enviar parametros a un Servlet</h1>");
out.println("La primera palabra pasada como parmetro es <strong>" + parametro1
+ "</strong><br>");
out.println("La segunda palabra pasada como parmetro es <strong>" + parametro2
+ "</strong>");
Java Crear un mapping a un servlet

El proceso de puesta en servicio de un servlet podramos resumirlo en dos pasos. El primero de
ellos es crear el servlet. Para ello implementaremos una clase java que extienda
de HttpServlet, la cual implementar la funcionalidad de negocio que estemos resolviendo.
Pero de nada nos sirve el crear un servlet si no lo publicicamos al exterior. Este mecanismo de
publicacin es lo que se conoce como mapping.
La idea del mapping es la de asociar una URL o un patrn de una URL a un servlet.
Para ello deberemos de configurar el descriptor de despliegue de la aplicacin. Este es el
fichero que encontramos en /WEB-INF/web.xml
En este fichero necesitaremos de la etiqueta <servlet-mapping>. Esta etiqueta nos permitir
definir un nuevo mapping. Anidado a esta etiqueta encontramos dos: la primera especificar el
nombre del servlet sobre el que queremos establecer el mapping <servlet-name>, mientras
que la segunda especificar sobre que URL se realiza el mapping <url-pattern>.
<servlet-mapping>
<servlet-name>MiServlet</servlet-name>
<url-pattern>/URLDelServlet</url-pattern>
</servlet-mapping>
Con este mapping toda las peticiones que se hagan a la URL http://miservidor/URLDelServet
sern procesadas por el Servlet "MiServlet".
<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/webapp_2_4.xsd">
<display-name>
lineadecodigo_servlet</display-name>
<servlet>
<description>
Servlet que devuelve un XML</description>
<display-name>
RespuestaXML</display-name>
<servlet-name>RespuestaXML</servlet-name>
<servlet-class>
com.lineadecodigo.java.servlet.RespuestaXML</servlet-class>
</servlet>
<servlet>
<description>
Servlet que accede a la cabecera http X-Forwarded-For</description>
<display-name>
ObtenerXForwardedFor</display-name>
<servlet-name>ObtenerXForwardedFor</servlet-name>
<servlet-class>
com.lineadecodigo.java.servlet.ObtenerXForwardedFor</servlet-class>
</servlet>
<servlet>
<description>
</description>
<display-name>ServletForward</display-name>
<servlet-name>ServletForward</servlet-name>
<servlet-class>
com.lineadecodigo.java.servlet.ServletForward</servlet-class>
</servlet>
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>
<url-pattern>/MiPrimerServlet</url-pattern>
</servlet-mapping>
<servlet-mapping>
<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>
Java Mi primer servlet

En este ejemplo vamos a desarrollar nuestro primer servlet, el cual nos de como respuesta la frase "Este es
mi primer Servlet".
Crear el Servlet
13
La clase Java que implemente el servlet deber de extender la clase javax.servlet.HttpServlet.
1. public class MiPrimerServlet extends javax.servlet.http.HttpServlet

implements javax.servlet.Servlet {
2.
...
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
...
}
}
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.
Ahora solo nos quedar ir invocando al mtodo .println con el texto que conforme la pgina web.
14
out.println("<head><title>Mi Primer Servlet </title></head>");
out.println("<h1>Este es mi Primer Servlet</h1>");
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
description, descripcin del servlet
display-name, nome del servlet
servlet-class, clase del servlet. Con el nombre del paquete por delante.
<servlet>
<description>Mi primer Servlet</description>
<display-name>
MiPrimerServlet</display-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
servlet-name, que es el nombre definido anteriormente.
url-pattern, que es el patrn de URL al que atender las petciones. En nuestro caso ser
/MiPrimerServlet.
<servlet-mapping>
<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
public class MiPrimerServlet extends javax.servlet.http.HttpServlet implements

private static final long serialVersionUID = 1L;
public MiPrimerServlet() {
super();
}
PrintWriter out;
out.println("<head><title>Mi Primer Servlet </title></head>");
out.println("<h1>Este es mi Primer Servlet</h1>");
out.println("<br><br><hr>");
out.println("Artículo disponible en: <a href=''></a><br/><a
href='http://lineadecodigo.com' title='Linea de Codigo'>lineadecodigo.com</a>");
}
/* (non-Java-doc)
* @see javax.servlet.http.HttpServlet#doPost(HttpServletRequest request,
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response)
doGet(request,response);
}
}
Java Reenviar peticin a otro Servlet
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:
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
* @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

/**
*
*/
public RecibirParametros() {
super();
}
doPost(request,response);
}
//Capturamos los parmetros
PrintWriter out;
out.println("<head><title>Enviar parametros a un Servlet</title></head>");
out.println("<h1>Enviar parametros a un Servlet</h1>");
out.println("La primera palabra pasada como parámetro es <strong>" +
parametro1 + "</strong><br>");
out.println("La segunda palabra pasada como parámetro es <strong>" +
parametro2 + "</strong><br>");
out.println("<hr>");
out.println("<a href='index.html'>Indice de ejemplos</a> | <a
href='EnviarParametros.html'>Enviar parametros</a>");
}
}
Java Obtener la IP que invoca al servlet
Mediante el siguiente cdigo podremos recuperar la IP del usuario que est realizando la peticin sobre el
servlet. Dadas todas las circunstancias que pueden rodear a la topologa de las redes la IP que
obtendremos no tiene porque ser la IP del usuario final, sino que fcilmente podra ser la IP de un proxy
intermedio,... Es por ello que el ejemplo hay que utilizarle con fines didcticos y si lo usamos para
produccin, con un gran cuidado.
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:
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);
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.
Siempre suelen ser cosas relativas a la configuracin del servlet.

Lo primero que tenemos que hacer es definir en el descriptor de despliegue (/WEB-INF/web.xml) del servlet:
<servlet>
<description>Ejemplo ...bla bla bla.</description>
<display-name>ParametrosInicio</display-name>
<servlet-class>com.lineadecodigo.ParametrosInicio</servlet-class>
</servlet>
El servlet se define mediante la etiqueta <servlet>. Anidada a esta tenemos dos etiquetas importantes.
<servlet-name> ser el nombre de referencia del servlet y <servlet-class> ser la clase java que implementa
dicho servlet.
Los parmetros del servlet
En nuestro ejemplo vamos a definir dos parmetros. El primero ser NivelLog que almacenar el tipo de log
con el que grabaremos y NumeroPeticiones que nos pasar un indicador de limitacin.
<servlet>
<init-param>
<description>Nivel de log a aplicar</description>
<param-name>NivelLog</param-name>
<param-value>DEBUG</param-value>
</init-param>
<init-param>
<description>Nmero de peticiones para atender</description>
<param-name>NumeroPeticiones</param-name>
<param-value>8</param-value>
</init-param>
</servlet>
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
* @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
javax.servlet.ServletConfig;
javax.servlet.http.HttpServlet;
public class ParametrosInicio extends HttpServlet {

private String _nivelLog;
private int _numeroPeticiones;
public ParametrosInicio() {
super();
}
PrintWriter out;
out.println("<head><title>Valor parametros inicializacin</title></head>");
out.println("<h1>Valor parametros inicializacin</h1>");
out.println("Nivel Log: " + _nivelLog + "<br/>");
out.println("Numero Peticiones: " + _numeroPeticiones);
out.println("<br><br><hr>");
out.println("Artículo disponible en: <a href=''></a><br/><a
href='http://lineadecodigo.com/java/leer-parametros-de-inicializacion-de-un-servlet/'
title='Linea de Codigo'>http://lineadecodigo.com/java/leer-parametros-de-inicializacion-de-unservlet/</a>");
20

doGet(request,response);
}
public void init(ServletConfig config){
try{
_nivelLog = config.getInitParameter("NivelLog");
_numeroPeticiones =
Integer.parseInt(config.getInitParameter("NumeroPeticiones"));
} catch(NullPointerException npe){
npe.printStackTrace();
}
}
}
Qu es JSP?
Java Server Pages (JSP) es una tecnologa que nos permite mezclar HTML esttico con HTML
generado dinmicamente. Muchas pginas Web que estn construidas con programas CGI son
casi estticas, con la parte dinmica limitada a muy pocas localizaciones. Pero muchas
variaciones CGI, incluyendo los servlets, hacen que generemos la pgina completa mediante
nuestro programa, incluso aunque la mayora de ella sea siempre lo mismo. JSP nos permite
crear dos partes de forma separada. Aqu tenemos un ejemplo:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD><TITLE>Welcome to Our Store</TITLE></HEAD>
<BODY>
<H1>Welcome to Our Store</H1>
<SMALL>Welcome,

<% out.println(Utils.getUserNameFromCookie(request)); %>
To access your account settings, click
<A HREF="Account-Settings.html">here.</A></SMALL>
<P>
Regular HTML for all the rest of the on-line store's Web page.
</BODY></HTML>
Cules son las Ventajas de JSP?
Contra Active Server Pages (ASP). ASP es una tecnologa similar de Microsoft. Las ventajas de
JSP estan duplicadas. Primero, la parte dinmica est escrita en Java, no en Visual Basic, otro
lenguaje especfico de MS, por eso es mucho ms poderosa y fcil de usar. Segundo, es
portable a otros sistemas operativos y servidores Web.
Contra los Servlets. JSP no nos da nada que no pudiermos en principio hacer con un servlet.
Pero es mucho ms conveniente escribir (y modificar!) HTML normal que tener que hacer un
billn de sentencias println que generen HTML. Adems, separando el formato del contenido
podemos poner diferentes personas en diferentes tareas: nuestros expertos en diseo de
pginas Web pueden construir el HTML, dejando espacio para que nuestros programadores de
servlets inserten el contenido dinmico.
Contra Server-Side Includes (SSI). SSI es una tecnologa mpliamente soportada que incluye
piezas definidas externamente dentro de una pgina Web esttica. JSP es mejor porque nos
permite usar servlets en vez de un programa separado para generar las partes dinmicas.
Adems, SSI, realmente est diseado para inclusiones sencillas, no para programas "reales"
que usen formularios de datos, hagan conexiones a bases de datos, etc.
Contra JavaScript. JavaScript puede general HTML dinmicamente en el cliente. Este una
capacidad til, pero slo maneja situaciones donde la informacin dinmica est basada en el
entorno del cliente. Con la excepcin de las cookies, el HTTP y el envi de formularios no estn
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
instalacin de Tomcat principal (por ejemplo, d: \ Archivos de programa \ Apache Group \

jakarta- tomcat-3.2.3 \ lib \ servlet.jar ). Para el compilador de Java para poder compilar
servlets, es necesario aadir este archivo a su Java ruta de clase . Por defecto, Java busca la
clases en el directorio actual ( "." ) solamente. Por lo tanto, "." es la ruta de la clase por
defecto. Si cambia la ruta de clase para incluir el servlet.jar archivo ("d:. \ ... \ lib \
servlet.jar" en Windows, ".. :/ usr / .. / lib / servlet.jar" en el Unix), entonces el servlet debera
compilar bien.
Puede especificar una ruta de clase que se utiliza cuando se ejecuta javac.exe de la siguiente
manera:
D: "., d: \ Archivos de programa \ Apache Group \ jakarta-tomcat-3.2.3 \ lib \ servlet.jar" \
javadev> javac-classpath MyServlet.java
Obviamente, el camino hacia la servlet.jar puede ser muy largo y doloroso de escribir cada vez
que queremos compilar un servlet. Como alternativa, puede establecer una variable de entorno
llamadaCLASSPATH a su ruta de la clase deseada. Esta decisin es el mismo que hacer
el CAMINO medio ambiente en el sistema operativo que est utilizando (las instrucciones para
el ajuste de la RUTA variable de entorno en varios sistemas operativos se proporcionan en las
instrucciones de instalacin para el JDK si los necesita).Para establecer temporalmente
el CLASSPATH variable de entorno en Windows, puede utilizar el SET de comandos en el
smbolo del sistema MS-DOS de comandos:
d:. \ javadev> SET CLASSPATH =, d: \ Archivos de programa \ Apache Group \ jakarta-tomcat3.2.3 \ lib \ servlet.jar d: \ javadev> javac MyServlet.java
Cualquiera que sea la forma de ir sobre la configuracin de la ruta de clase, ahora debera ser
capaz de compilar con xito MyServlet.java para obtener MyServlet.class (o descargarlo aqu ).
DESPLIEGUE DE UN SERVLET
En su configuracin predeterminada, Tomcat espera que se coloque en los servlets
compilados webapps \ ROOT \ WEB-INF \ classes subdirectorio del directorio de instalacin de
Tomcat para desplegarlas. Coloca el compilado MyServlet.class archivo en ese directorio,
entonces (suponiendo que Tomcat se est ejecutando en el equipo local) de
carga http://localhost:8080/servlet/MyServlet . Si has hecho todo bien, deberas ver una pgina
Web muy similar a esta:
Si tienes instalado Apache Tomcat para

interactuar con usar mod_jk , tambin debe ser capaz de ver el servlet
con http://localhost/servlet/MyServlet (ohttp://localhost:8000/servlet/MyServlet si ha
configurado Apache para ejecutar en el puerto 8000).
La mayora de las veces, eso es todo lo que necesita hacer para implementar un servlet! Hay
algunas situaciones, sin embargo, el lugar donde quiere hacer su Servlet disponible en una
direccin diferente. Un caso comn es cuando se asigna un nombre de paquete a un
servlet. Por ejemplo, consideremos qu pasara si se coloca el MyServlet clase del
paquete com.sitepoint.web mediante la adicin de la lnea
paquete de com.sitepoint.web;
a la parte superior de la MyServlet.java archivo. Para implementar el MyServlet.class archivo,
que la colocara en webapps \ ROOT \ WEB-INF \ classes \ com \ SitePoint \ web (recordemos
que la ubicacin de la clase. archivos deben reflejar sus nombres de paquetes), y cargarlo con
su plena nombre completo de clase
( http://localhost:8080/servlet/com.sitepoint.web.MyServlet ). Ya se trata de una URL bastante
feo, y las cosas pueden ser mucho ms compleja con el paquete de registro o de nombres de
clase.
Por esta razn, es posible que desee asignar un nombre alternativo a su Servlet. Esto se hace
con elweb.xml archivo en el directorio WEB-INF directorio (por ejemplo, webapps \ ROOT \ WEBINF \ web.xml ). Este es un archivo XML que permite configurar los servlets se han
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:
Haga clic en Actualizar un par de veces

en su navegador y ver la pgina cambia cada vez.
RESUMEN Y RECURSOS PARA L A LECTURA
En este artculo, hemos aprendido los conceptos bsicos de Java Servlets: pequeos programas
de Java que se ejecutan dentro de su servidor web y tramitar las solicitudes del navegador y
volver generadas dinmicamente pginas Web en respuesta. Hemos visto cmo escribir,
compilar y desplegar un servlet simple utilizando mtodos estndar soportados por todos los
servidores web habilitados para Servlet.Finalmente, vimos un ejemplo un poco ms complejo
que muestra la hora actual cada vez que se carga.
Hay mucho ms para Servlets de lo que vimos aqu! En la Parte 2, vamos a ver cmo utilizar
elHttpServletRequest objeto para procesar los envos de formularios con un servlet. Tambin
veremos en elHttpServletResponse objeto para ver qu ms es capaz de hacer. Por ltimo,
vamos a aprender algunos trucos ms que pueden ser utilizados en el web.xml para afinar los
Servlets instalados en nuestro servidor web.
EJEMPLOS DE SERVLET.
Ejemplo sencillo servlet
Un sencillo ejemplo de un servlet
[java]
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
public class HelloWorldServlet extends HttpServlet{
protected void doGet(HttpServletRequest httpServletRequest,
HttpServletResponse httpServletResponse)
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 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
En la seccin de compilacin y ejecucin de servlets creamos un servlet

llamado HolaMundo.java cuyo cdigo fuente era el siguiente:
import java.io.*;
public class HolaMundo extends HttpServlet {
public void init(ServletConfig conf)
throws ServletException {
super.init(conf);
28
}
PrintWriter out = res.getWriter();
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 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).
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).
29
out.println("<h1>Hola Mundo</h1>");
}
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".
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++):
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 java.io.*;
public class GetPost extends HttpServlet {
super.init(conf);
}
public void doGet(HttpServletRequest req, HttpServletResponse res)
{
out.println("<h1>Hola Mundo (llamada GET)</h1>");
}
public void doPost(HttpServletRequest req, HttpServletResponse res)
{
30

out.println("<h1>Hola Mundo (llamada POST)</h1>");
}
}
Para llamar al servlet con un tipo de llamada get, podemos usar el ejemplo get.html. Que
podemos colocar en el directorio C:\java\tomcat\webapps\tutorial\ y cuyo cdigo es:
<html>
<body>
<h1>Mtodo GET</h1>
<form method="GET" action="/tutorial/servlet/GetPost">
<input type="submit">
</form>
</body>
</html>
Para llamar al servlet con un tipo de llamada post, podemos usar el ejemplo post.html. Que
podemos colocar en el directorio C:\java\tomcat\webapps\tutorial\ y cuyo cdigo es:
<html>
<body>
<h1>Mtodo POST</h1>
<form method="POST" action="/tutorial/servlet/GetPost">
<input type="submit">
</form>
</body>
</html>
3 Ciclo de vida de un Servlet
Como hemos visto antes, cuando se crea un servlet, el servidor llama al mtodo init y cada vez
que un cliente acceda al servlet el servidor llamar al mtodo service que se encargar de
redirigir la llamada doGet o a doPost. Esto nos quiere decir que cuando se llama por primera
vez a un servlet se ejecutara primero init y despus service, pero ... Y la segunda vez y
sucesivas tambin se llama a init o slo a service?.
Normalmente, el servidor crea el servlet (llama, por tanto, al mtodo init) y lo mantiene
funcionando, si ha pasado un tiempo suficiente (y que puede ir desde unos segundos a nunca)
sin que el servlet se llame lo deja de ejecutar. Es decir, un servlet se empieza a ejecutar con la
primera llamada y, normalmente, se seguir ejecutando.
De esta forma, vamos a crear un servlet que cuente el nmero de visitas que recibe, para ello
nos bastar crear una variable contador que inicializaremos en el mtodo init y que
incrementaremos en doPost/doGet. Por lo que, el contador se inicializar cuando se llame por
primera vez al servlet y se ir incrementando en llamadas sucesivas. Este ejemplo, lo
llamaremos Contador.java y su cdigo fuente era el siguiente:
import java.io.*;
public class Contador extends HttpServlet {
//variable contador
int contador;
super.init(conf);
//inicializamos la variable contador
contador = 1;
}
31

int tmp = contador;
//incrementamos la variable contador
contador++;
out.println("<h1>Numero de peticiones " + tmp +"</h1>");
}
doGet(req, res);
}
}
NOTA: Observa que un mismo servlet puede ser llamado por ms de un cliente a la vez. En
este caso, el servidor crea una hebra del servlet por cada peticin y esas dos hebras accedern
concurrentemente a los mismos datos (la variable contador). Como la lectura e incremento de
contador no es una operacin atmica, se podra utilizar la primitiva de
sincronizacin syncronized para que se realice de forma atmica:
.....
int tmp;
synchronized(this) {
//leemos el contador
tmp = contador;
//incrementamos la variable contador
contador++;
}
.....
4 Parmetros desde un formulario HTML
Normalmente los servlets tendrn parmetros o fuentes de informacin que le darn su
aspecto dinmico. Es decir, para generar una simple pgina HTML no nos complicamos tanto la
vida, se escribe la pgina HTML y se ha terminado. Las fuentes de informacin de las que un
servlet hace uso, pueden ser varias: el propio servlet, el servidor web, ficheros o bases de
datos a los que pueda acceder o parmetros que le pase el cliente. De todas estas fuentes, nos
interesan los accesos a bases de datos que veremos ms adelante y los pa;rmetros que nos
pasa el cliente mediante formularios HTML.
Cuando pasamos parmetros a travs de un formulario, en los Servlets a travs de la
clase ServletRequest, disponemos de los siguientes mtodos para su tratamiento:
String getParameter(String nombre): Nos devuelve el valor del parmetro cuyo nombre le
indicamos. Si la variable no existiera o no tuviese ningn valor, devolvera null
Enumerate getParameterNames(): Nos devuelve una enumeracin de los nombres de los
parmetros que recibe el servlet.
Enumerate getParameterValues(String): Nos devuelve los valores que toma un parmetro
dado, esto es til para listas de seleccin mltiple donde un parmetro tiene ms de un valor.
Veamos un ejemplo de un pequeo formulario que tenga distintos tipos de parmetros, se los
enve a nuestro servlet y ste los muestre por pantalla (an no sabemos guardarlos en la base
de datos). El formulario los llamaremos formulario.html. Que podemos colocar en el
directorio C:\java\tomcat\webapps\tutorial\ y cuyo cdigo es:
<html>
<title>Formulario de ejemplo</title>
<body>
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 java.io.*;
public class Parametros extends HttpServlet {
super.init(conf);
}
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") );
}
33

doGet(req, res);
}
}
Si en la lista de de seleccin mltiple escogemos ms de un valor en la implementacin actual
slo mostrara la primera eleccin, si quisiramos mostrar todos los valores deberamos de
usar getParameterValues("intereses") e ir recorriendo y mostrando cada uno de los valores
seleccionados del parmetro intereses.
Otra posible implementacin del servlet Parametros.java sera uno que mostrase los
parmetros y sus valores sin tener que conocerlos previamente. El cdigo sera:
import java.io.*;
import java.util.*;
public class Parametros extends HttpServlet
{
throws ServletException
{
super.init(conf);
}
//Escribimos el principio de la pgina HTML
out.println("<h1>Parmetros del servlet desde un formulario HTML</h1>");
//cogemos los nombres de los parametros
Enumeration paramNames = request.getParameterNames();
//vamos mostrando los parmetros en unwhile
while(paramNames.hasMoreElements()) {
//cogemos el siguiente parmetro
String paramName = (String)paramNames.nextElement();
//Mostramos el nombre del parmetro
out.print(paramName + " = ");
//Cogemos los valores del parmetro
String[] paramValues = request.getParameterValues(paramName);
//Miramos si tiene ms de un valor
if (paramValues.length == 1) {
//Si tiene un slo valor, miramos si est vaco o no
String paramValue = paramValues[0];
if (paramValue.length() == 0)
out.println("<i>Sin valor</i><br>");
else
out.println(paramValue + "<br>");
}
else {
34
//Si tiene ms de un slo valor, los mostramos

for(int i=0; i<paramValues.length; i++)
out.println(paramValues[i] + ", ");
out.println("<br>");
}
}//end while
//Escribimos el final de la pgina HTML
}
public void doPost(HttpServletRequest request,
doGet(request, response);
}
}
CON NETBEANS
Iniciamos NetBeans y seleccionamos File \ New Project...
Se abre un dilogo que nos solicita el tipo de proyecto, seleccionamos Web Application
En el siguiente paso, nos solicita el nombre del proyecto (Project Name), en nuestro caso
ingresamos Servlet_HelloWorld
El siguiente paso, nos solicita el servidor de aplicaciones (contenedor de Servlets a utilizar).

As, del combo Server, seleccionamos Tomcat (segn la versin que yo tengo instalada, Tomcat
6.0.16)
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.
<form action="Servlet_Hola" method="POST">

Ingrese su
nombre: <input type="text" name="nombre" value="" size="45" />
<input type="submit" value="Enviar" name="enviar" />
</form>
Luego, desde el explorador de proyectos, luego de hacer clic derecho en la carpeta Source
Packages, seleccionamos New \ Servlet...
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
Dados el nombre del servlet y el paquete, hacemos clic sobre Finish.

Finalizado esto, automticamente crea una clase con el nombre de servlet dado (Servlet_Hola
para nosotros), que hereda de HttpServlet. Adems redefine (override) algunos mtodos
(doGet, doPost, getServletInfo) y los rellena con un poco de cdigo. Adems, crea un
mtodo processRequest (invocado desde los mtodos doGet y doPost) para procesar los
formularios que llegan por los mtodos GET y POST.
Nosotros, en este ejemplo, nos limitaremos completar con unas pocas lneas (pues la mayora
la complet automticamente el NetBeans) el mtodo processRequest para que cree una
pgina HTML que ser la respuesta del formulario enviado:
package com.luauf.servlet;
import java.io.*;
public class Servlet_Hola extends HttpServlet {
/**
* Processes requests for both HTTP <code>GET</code> and <code>POST</code>
methods.
* @param request servlet request
* @param response servlet response
*/
protected void processRequest(HttpServletRequest request,
response.setContentType("text/html;charset=UTF-8");
try {
/*
TODO output your page here
*/
out.println("<head>");
out.println("<title>Servlet Servlet_Hola</title>");
out.println("</head>");
out.println("<p>");
out.println("Hola <strong>" +
request.getParameter("nombre").toString() + "<strong>");
out.println("</p>");
} finally {
out.close();
}
}
// <editor-fold defaultstate="collapsed" desc="HttpServlet methods. Click on
the + sign on the left to edit the code.">
/**
* Handles the HTTP <code>GET</code> method.
37

*/
response)
processRequest(request, response);
}
/**
* Handles the HTTP <code>POST</code> method.
*/
protected void doPost(HttpServletRequest request, HttpServletResponse
response)
processRequest(request, response);
}
/**
* Returns a short description of the servlet.
*/
public String getServletInfo() {
return "Short description";
}
// </editor-fold>
}
Para finalizar, vamos a ejecutar el proyecto, podemos hacerlo desde el men Run o haciendo
abriendo el men contextual del proyecto (desde el explorador de proyectos) y
seleccionando Run.
Al ejecutar una aplicacin web con NetBeans, lo primero que hace el mismo es un Deploy, algo
as como distribuir la aplicacin en el servidor. Por ms que nuestro servidor sea local y que el
NetBeans lo haga transparente para nosotros, debemos entender que el Tomcat se ejecuta
cuando ejecutamos la aplicacin y que adems posee una estructura de directorios (distinta a
nuestra estructura de carpetas del proyecto) donde almacena las aplicaciones web que corre,
archivos de configuracin, paquetes de clases, etc.
Al ejecutar el proyecto se abrir el browser predeterminado con la pgina index.jsp (la que
tiene el formulario):
Si ingresamos nuestro nombre en la caja de texto y apretamos Enviar, el formulario se enva al

servlet, quien se ejecuta y nos devuelve una nueva pgina, con un dato, en particular, cargado
dinmicamente: nuestro nombre:
38

Guía de Cliente Servidor Codigo

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Guía de Cliente Servidor Codigo

Hochgeladen von

Copyright:

Verfügbare Formate

GUA DE CLIENTE SERVIDOR

Programacin paso a paso.

public class HolaMundoServlet extends HttpServlet {

DIFERENCIAS ESTRE LAS TECNOLOGIAS CGI Y SERVLET

Open DataBase Connectivity (ODBC) es un estndar de acceso a bases de

public class SomeServlet extends HttpServlet {

la plantilla de cdigo fuente -- pulsa con el botn derecho del ratn

PrintWriter out = response.getWriter();

PrintWriter out = response.getWriter();

COMPILAR E INSTALAR EL SERVLET

Un Servlet que Genera HTML

UTILIDADES DE CONSTRUCCIN DE HTML SENCILLO

// Other utilities will be shown later...

Tambin puedes descargar

out.println("<head><title>Enviar parametros a un Servlet</title></head>");

Java Crear un mapping a un servlet

Java Mi primer servlet

La clase Java que implemente el servlet deber de extender la clase javax.servlet.HttpServlet.

1. public class MiPrimerServlet extends javax.servlet.http.HttpServlet

description, descripcin del servlet

display-name, nome del servlet

servlet-name, que es el nombre definido anteriormente.

public class MiPrimerServlet extends javax.servlet.http.HttpServlet implements

public class RecibirParametros extends javax.servlet.http.HttpServlet implements

Siempre suelen ser cosas relativas a la configuracin del servlet.

public class ParametrosInicio extends HttpServlet {

protected void doPost(HttpServletRequest request, HttpServletResponse response)

instalacin de Tomcat principal (por ejemplo, d: \ Archivos de programa \ Apache Group \

Si tienes instalado Apache Tomcat para

Haga clic en Actualizar un par de veces

En la seccin de compilacin y ejecucin de servlets creamos un servlet

PrintWriter out = res.getWriter();

throws ServletException, IOException {

public void doPost(HttpServletRequest req, HttpServletResponse res)

//Si tiene ms de un slo valor, los mostramos

El siguiente paso, nos solicita el servidor de aplicaciones (contenedor de Servlets a utilizar).

<form action="Servlet_Hola" method="POST">

Dados el nombre del servlet y el paquete, hacemos clic sobre Finish.

* @param request servlet request

Si ingresamos nuestro nombre en la caja de texto y apretamos Enviar, el formulario se enva al

Das könnte Ihnen auch gefallen