Uso de JNDI, includes y cookies en Servlets

0
37174

Servlets Intermedio

Hay otras características de los servlets, de las cuales normalmente se saca
poco partido,  que nos pueden ser muy útiles.

 

Accesos a propiedades a través de JNDI

Como
por ejemplo el uso de constantes o literales definidas en el propio descriptor web.xml
y que hacen innecesario el uso de ficheros de propiedades adicionales

Desde nuestros servlets podemos, con esta simple sentencia, recuperar los
valores.

Creamos el servlet de prueba

Modificamos nuestro código para realizar mostrar los datos introducidos.

import javax.servlet.*;
import javax.servlet.http.*;
import javax.naming.*;

public class servletJNDI extends HttpServlet {

public void init(ServletConfig config) throws ServletException {
super.init(config);

}

public void destroy() {

}

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, java.io.IOException {
    response.setContentType(«text/html»);
    java.io.PrintWriter out = response.getWriter();

    String autor = «»;
    String contacto = «»;

    try
    {
     Context ctx = new InitialContext();
     if(ctx == null )
          { throw new Exception(«Error
al crear el contexto»); }

     autor = (String)ctx.lookup(«java:comp/env/misapps/autor»);
     contacto = (String)ctx.lookup(«java:comp/env/misapps/contacto»);

    }
    catch(Exception e)
    {    }

     out.println(«<html>»);
     out.println(«<head>»);
     out.println(«<title>Servlet</title>»);
     out.println(«</head>»);
     out.println(«<body>»);
     out.println(«<center>»);
     out.println(«El autor es: » + autor);
     out.println(«<br><a href=\»mailto:» + contacto + «\»>Contactar en</a>»);
  
   out.println(«</center>»);
     out.println(«</body>»);
     out.println(«</html>»);
     out.close();
}

protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, java.io.IOException {
processRequest(request, response);
}

protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, java.io.IOException {
processRequest(request, response);
}
}

Y la página resultante sería 

 

Include Servlet

Quien a programado utilizando ASP, JSP o PHP, esta acostumbrado a crear una
plantilla que a su ver incluye a otras. Un ejemplo puede ser meter la cabecera
de nuestro Web (o un menú) en una plantilla y que este sea incluida por muchas
otras, de modo que cuando tengamos que realizar algún cambio, solo se tenga que
realizar en un punto.

El código es bastante sencillo:

getServletConfig().getServletContext().getRequestDispatcher(«/servlet/contador«).include(request, response);

Vamos a introducir un contador en nuestros servlets de un modo sencillo. Tened
en cuenta que esto es un ejemplo … en un entorno multi-máquina virtual,
debería ser construido de otro modo
.

Nuestro servlet utilizará un fichero llamado contadores.txt
para almacenar los contadores, cada N peticiones.

Estos contadores, son almacenado en una tabla Hashtable tablaContadores 

 

/*
*
* Created on June 28, 2003, 7:25 PM
*/
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.*;

/**
* @author Roberto Canales
* @version
*/
public class contador extends HttpServlet 
{
Hashtable tablaContadores = new Hashtable();
int usosContador = 0;

public void init(ServletConfig config) throws ServletException 
{
     super.init(config);

     try
     {
          FileInputStream ficheroEntrada = new
FileInputStream(«contadores.txt«);
          ObjectInputStream bufferEntrada = new ObjectInputStream(ficheroEntrada);
          tablaContadores = (Hashtable)bufferEntrada.readObject();
          Date fechaContadores = (Date)bufferEntrada.readObject();
     }
     catch (Exception e)
     {
          getServletContext().log(«Error al leer contadores\n» + e.getMessage());
     }
}

boolean escribirContadores()
{
     try
     {
          getServletContext().log(«Volcamos contadores a fichero»);

          FileOutputStream ficheroEscritura = new
FileOutputStream(«contadores.txt«);
          ObjectOutputStream bufferSalida = new ObjectOutputStream(ficheroEscritura);
          bufferSalida.writeObject(tablaContadores);
          bufferSalida.writeObject(new Date());
          bufferSalida.flush();
    }
    catch (Exception e)
    {
          getServletContext().log(«Error al escribir contadores\n» + e.getMessage());
          return false;
      }

          return true;
}

public void destroy() 

}

protected int recuperaContador(String nombreContador)

          int contador = 0;
          Object objetoTemporal = tablaContadores.get(nombreContador);

          if(objetoTemporal != null)
          { 
                   
contador = ((Integer)objetoTemporal).intValue() + 1;
          }

          tablaContadores.put(nombreContador,new Integer(contador));

          usosContador++;
          if(usosContador> 3)
          {
                    escribirContadores();
                   
usosContador = 0;
          }

          return contador;
}

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, java.io.IOException 

{
          response.setContentType(«text/html»);
         
java.io.PrintWriter out = response.getWriter();

          Object atributoPasado =
request.getAttribute(«contadorservlet»);

          if(atributoPasado == null)
                    out.println(«No se proporcionó identificador de Contador»);

          String nombreContador = atributoPasado.toString();
          int contadorNuevo =
recuperaContador(nombreContador);

          out.println(«El contador es: » + contadorNuevo);
}

/** Handles the HTTP <code>GET</code> method.
* @param request servlet request
* @param response servlet response
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, java.io.IOException {
processRequest(request, response);
}

/** Handles the HTTP <code>POST</code> method.
* @param request servlet request
* @param response servlet response
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, java.io.IOException {
processRequest(request, response);
}

/** Returns a short description of the servlet.
*/
public String getServletInfo() {
return «Short description»;
}

}

 

Ahora debemos añadir en el servlet principal el código
necesario para incluir nuestro servlet contador.

Partimos del ejemplo servletJNDI (más arriba en este
documento) 

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, java.io.IOException {
response.setContentType(«text/html»);
java.io.PrintWriter out = response.getWriter();

String autor = «»;
String contacto = «»;

try
{
Context ctx = new InitialContext();
if(ctx == null )
{ throw new Exception(«Imposible crear contexto»); }

autor = (String)ctx.lookup(«java:comp/env/misapps/autor»);
contacto = (String)ctx.lookup(«java:comp/env/misapps/contacto»);
}
catch(Exception e)
{

}

out.println(«<html>»);
out.println(«<head>»);
out.println(«<title>Servlet</title>»);
out.println(«</head>»);
out.println(«<body>»);
out.println(«<center>»);
out.println(«El autor es: » + autor);
out.println(«<br><a href=\»mailto:» + contacto + «\»>Contactar en</a>»);
out.println(«<br>»);

request.setAttribute («contadorservlet», «servletJNDI»);
getServletConfig().getServletContext().getRequestDispatcher(«/servlet/contador»).include(request, response);

out.println(«<br>No olvide visitarnos en <a href=\»www.adictosaltrabajo.com\»>www.adictosaltrabajo.com</a>»);
out.println(«</center>»);
out.println(«</body>»);
out.println(«</html>»);
out.close();
}

Y el resultado es ….. 

Uso de cookies

Un cookie es un valor que se arrastra en cada una de las
peticiones, a través de las cabeceras HTTP sin necesidad de que hagamos nada.

Cuando nos conectamos a un servidor, nomalmente se usa un cookie
para simular una sesión entre el cliente y el servidor, ya que el protocolo
HTTP no es orientado a conexión y cada petición no recuerda nada de la
anterior.

Los datos que viajan por la cookie suelen ser una información
que solo sabe interpretar el servidor …… 

Por distintos motivos, se desaconseja el uso e cookies en los
sistemas aunque si no nos queda más remedio …. podemos usarlos tal y como
podemos ver en el siguiente ejemplo.

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, java.io.IOException {
response.setContentType(«text/html»);
java.io.PrintWriter out = response.getWriter();

out.println(«<html>»);
out.println(«<head>»);
out.println(«<title>Servlet</title>»);
out.println(«</head>»);
out.println(«<body>»);
out.println(«<center>»);
out.println(«Grabamos un cookie: nombre=\»cookiepersonal\» valor =\»1234\» «);

response.addCookie(new Cookie(«cookiepersonal»,»1234″));

out.println(«</center>»);
out.println(«</body>»);
out.println(«</html>»);

out.close();
}

Podemos monitorizar la petición y comprobar el cookie generado View->HTTP
Monitor
 

Si simulamos la navegación desde una consola telnet, desde la
linea de comando arrancamos la aplicación

Simulamos la petición que haría un navegador. Podemos ver como
en la cabecera viene el cookie.

Set-Cookie: cookiepersonal=1234

Para recuperar el valor:

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, java.io.IOException {
response.setContentType(«text/html»);
java.io.PrintWriter out = response.getWriter();

out.println(«<html>»);
out.println(«<head>»);
out.println(«<title>Servlet</title>»);
out.println(«</head>»);
out.println(«<body>»);

Cookie arrayCookies[] = request.getCookies();
if (arrayCookies != null)
{
     for(int i = 0; i< arrayCookies.length; i++)
     {
          String nombreCookie = arrayCookies[i].getName();

         
if(nombreCookie.compareTo(«cookiepersonal») == 0)
          {
                   
String valorCookie = arrayCookies[i].getValue();
                   
out.println(«El valor del cookie cookiepersonal es: » + valorCookie);
          }
     }
}

out.println(«</body>»);
out.println(«</html>»);

out.close();
}

 Podemos comprobar que leemos fácilmente el valor del
cookie en nuestro servlet

Sobre el
Autor ..

Dejar respuesta

Please enter your comment!
Please enter your name here