Linea de Codigo

Cuando nos comunicamos con sistemas legados nos encontramos muchos casos en los cuales los tamaños de los números son fijos. Y en estos casos hay que rellenar la información con ceros a la izquierda para que el sistema pueda dar una respuesta.

Para estos casos podemos jugar con la clase Formatter, la cual nos ayudará a formatear diferentes elementos, aplicando una cadena de formato y mediante el método .format().

Dos simples líneas de código. La primera será intanciar la clase:

Formatter fmt = new Formatter();

La segunda, aplicar el formato:

fmt.format("%08d",numero);

Lo importante para añadir ceros a la izquierda es el formato a aplicar "%08d". Si entramos en detalle en este formato vemos que en todo formato se identifican las siguientes partes:

%[argument_index$][flags][width]conversion

1. argument_index, es el id del argumento al que queremos aplicar el formato. Esto se aplica si tenemos varios elementos a formatear a la vez.
Por ejemplo:

int numero = 425;
fmt.format("Primer número %1$08d - Segundo número %2$08d ",numero,numero2);

Vemos que el formateador empieza por %1$ o %2$ indicando el elemento (numero o numero2) sobre el que aplica el formato.

2. flags, son las conversiones a aplicar al elemento. Las conversiones dependen del tipo de conversión que efectuemos. La indicada en la parte de conversión. Algunos tipos de flags son: '-' para la justificación a izquierda, '+' para incluir los signos,... y el que nos interesa en nuestro caso '0' que rellena el tamaño a ceros.

3. width, es el tamaño que le queremos dar al resultado. En nuestro caso le damos un tamaño de 8 dígitos. Y como el número es de 3 dígitos, tendremos 5 ceros a la izquierda

4. conversion, tipo de conversión a realizar: 'd' para enteros (nuestro caso), 'o' para octales,...

Veamos el código completo:

int numero = 425;
 
Formatter fmt = new Formatter();
fmt.format("%08d",numero);
 
System.out.println("El numero formateado " + fmt);

Una de las cosas útiles en los lenguajes de programación es saber en que directorios concretos tenemos ciertas instalaciones. Por ejemplo, si estamos codificando una página ASP y queremos generar ficheros podríamos tener la necesidad de saber cual es el directorio dónde se dejan los ficheros temporales en la máquina que nos ejecutamos.

De esta manera, en ASP y mediante el objeto FileSystemObject podemos tener conocimiento donde estan instaladas algunas de las carpetas de Windows. Para ello simplemente tenemos que utilizar el método .GetSpecialFolder(). Este método puede recibir como parámetro tres números

• 0. Carpeta donde está instalado Windows.
• 1. Carpeta del sistema.
• 2. Carpeta del directorio de temporales.

Así el código en ASP que necesitamos sería algo parecido a:

<%
  Response.Write "Carpeta de Windows " & fso.GetSpecialFolder (0) & "<br>"
  Response.Write "Carpeta del Sistema " & fso.GetSpecialFolder (1)  & "<br>"
  Response.Write "Carpeta Temporal "  & fso.GetSpecialFolder (2)  & "<br>"
%>

El siguiente ejemplo nos muestra que tenemos que hacer para guardar información del usuario en una variable de sesión con ASP. Esto nos va a ser muy útil ya que podremos disponer de dicha información mientras el usuario esté conectado a nuestra web.

En este punto hay que aclaran un poco el concepto sesión. Y es, ¿qué consideramos como estar conectado a nuestra web?. Pues a un cliente que se identifique de forma unívoca mediante todas sus peticiones. Por ejemplo, en el caso de los navegadores, mantendremos activa la sesión siempre y cuando naveguemos con la misma pantalla del navegador o cuando abramos una nueva ventana a partir de la ventana anterior. Si ejecutamos de nuevo nuestro navegador, este al ser un proceso nuevo, tiene un identificador nuevo, y por lo tanto crea una nueva sesión en el servidor.

Una vez que tenemos estos conceptos básicos para poner un dato en sesión utilizamos el objeto Session de la siguiente forma:

Session("usuario") = "Víctor"

Este valor guardado durante la vida de la sesión se podrá recuperar de la siguiente forma:

Session("usuario")

y lo podremos volcar por pantalla si ponemos

Response.Write (Session("usuario"))

Una cosa que tenemos que tener en cuenta es el tiempo de vida de la sesión. Porque, claro, si el usuario se fuese a tomar un café, a dar un paseo y volviese al ordenador tras una hora, no sería de recibo seguir manteniéndole la sesión. Y es que, al fin y al cabo, estos datos ocupan lugar en la memoria del servidor. Además, si guardamos datos sensibles, estos, ante la ausencia del usuario, podrían ser utilizamos maliciosamente.

Aunque el tiempo de la sesión viene configurado en el servidor, podemos modificar el tiempo de vida de la sesión mediante la propiedad TimeOut de la siguiente forma:

Session.TimeOut = 10 '10 minutos

Y podríamos forzar el abandono de sesión del usuario mediante la función Abandon()

Session.Abandon()

Ahora codificaremos un pequeño ejemplo de tres página. En la primera de ellas crearemos los datos asociados al usuario, el nombre y el número de páginas vistas por ese usuario (otro ejemplo de utilización de los datos de sesión)

<%
  Session("usuario") = "Victor Cuervo"
  Session("paginas") = Session("paginas") + 1
 
  Response.Write("Usuario:" + Session("usuario") + "<br>")
  Response.Write("Paginas vistas:" + CStr(Session("paginas")))
%>

En la segunda simularemos todas las páginas intermedias de nuestra web. Así que solo le incrementaremos la información de páginas vistas

<%
  Session("paginas") = Session("paginas") + 1
 
  Response.Write("Usuario:" + Session("usuario") + "<br>")
  Response.Write("Paginas vistas:" + CStr(Session("paginas")))
%>

Y en la tercera y última permitiremos que el usuario abandone y cierre la sesión.

<%
  Response.Write("Usuario:" + Session("usuario") + "<br>")
  Response.Write("Paginas vistas:" + CStr(Session("paginas")))
 
  Session.Abandon()
%>

Hace poco tiempo estaba inmerso en una pruebas de carga dentro de las cuales existia un punto donde se generaba un fichero de texto en ASP mediante el objeto FileSystemObject. El problema se nos planteaba cuando simulabamos grandes volumenes de peticiones con el mismo proceso ya que todas intentaban generar el mismo fichero. A si que el sistema de archivos de las máquinas se volvia loco.

Como la creación del fichero no era el fin último de las pruebas se opto por generar un fichero de nombre aleatorio. Llegados a este punto nos podemos llegar a pensar la necesidad de creación de algún procedimiento que nos genere nombres de fichero de forma aleatorio.

Pero la solución es mucho más sencilla ya que el objeto FileSystemObject nos ofrece el procedimiento GetTempName que nos devolverá el nombre de un fichero aleatorio para usar de manera temporal.

<%
 
 Set fso = Server.CreateObject("Scripting.FileSystemObject")
 Response.Write("El fichero temporal a usar es: " + fso.GetTempName())
 
%>

Algo muy sencillo y realmente útil. Se te ocurre alguna otra forma de usar ficheros temporales en ASP. Cuéntanosla...

¿Para qué nos puede servir el uso de un fichero de texto en la web?. Hay que partir de la base que los accesos a disco son mucho menos costosos que los accesos a bases de datos ya que nos evitamos el abrir una conexión sobre otro servidor. A si que es muy normal el uso de fichero para el almacenamiento de información, que posiblemente sea cargada en una base de datos por un proceso batch. Lo que vendría a ser una cache.

La información que podemos guardar en los ficheros puede ser de diferente indole. Así podemos usar ficheros para:

• Crear un contador de visitas. Leeremos el fichero y actualizaremos el contador de visitas.
• Generar datos de acceso a la web. Quien accede, su IP, el tipo de navegador que usa,....
• Trazas de ejecución de la página. Para ver que código se ejecuto y cual no y así evaluarlo posteriormente.
• Datos de mucho acceso. Información estática que es accedida muchas veces.
• ....

Vamos a utilizar un objeto FileSystemObject para generar un fichero de texto. Una vez generado el fichero podremos escribir en el todo el contenido que queramos. El método que nos va a servir para crear el fichero es CreateTextFile() al cual podemos pasarle tres parámetros:

• Nombre del fichero, ruta y nombre del fichero que queremos crear. Hay que validar si el directorio donde queremos crear el fichero tiene permisos de escritura. Es muy posible que el webmaster de nuestro servidor tenga que habilitarnos un directorio a tal efecto, ya que por defecto la escritura la tendremos prohibida en todo o casi todo el sevidor.
• Sobrescribir, es un valor booleano mediante el cual podemos indicar que se sobrescriba el fichero aunque exista (valor true, es el valor por defecto) o que se deje como está (valor false)
• Unicode, es otro valor booleano que nos sirve para indicar si el fichero va a ser UNICODE (valor true) o ASCII (valor false, es el valor por defecto).

La ejecución de este método nos va a devolver un objeto TextStream sobre el cual realizaremos las escrituras. A si que tendremos una primera línea que será algo similar a esta...

Set salida = fso.CreateTextFile ("c:\temp\victor.txt")

Una vez creado el fichero y obtenida una referencia al TextStream solamente nos quedará lanzar sentencias de escritura. Para ello podemos ejecutar sobre el TextStream los métodos Write(texto) y WriteLine(Texto). El segundo escribe un texto y un salto de línea.

salida.Write ("Texto Normal")
salida.WriteLine ("Texto acompañado por un salto de línea")

Por último, y una vez que hayamos escrito todo lo que queramos solo nos quedará cerrar el TextStream.Close(). Y si somos muy puristas desalojamos los objetos creados de memoria asignandoles el valor Nothing.

Set fso = Nothing
Set salida = Nothing

En el artículo Invertir una cadena con Java veíamos la forma en la cual podíamos dar la vuelta a una palabra. Lo mismo que podríamos hacer con el método .reverse() de StringBuilder.

Ahora vamos un paso más allá y vamos a ver como podemos invertir el orden de las palabras de una frase. Para ellos nos apoyaremos en una estructura de tipo pila. Puedes ver más información de qué es una pila en Crear una pila en Java.

La idea inicial es quedarnos con las palabras. Para poder acometer este primer paso tenemos que desmontar la frase en palabras. Para ellos nos vamos a apoyar en la clase StringTokenizer. La cual, mediante la simple instanciación de la misma, nos convierte la frase en un array de palabras.

String sTexto = "En un lugar de la mancha de cuyo nombre no quiero acordarme";
StringTokenizer frase = new StringTokenizer(sTexto);

Ahora creamos nuestra pila...

Stack<String> pila = new Stack<String>();

E iremos insertando cada uno de los elementos del StringTokenizer.

while (frase.hasMoreTokens()) {
  pila.push(frase.nextToken());
}

Nos apoyamos el el método .hasMoreTokens() de la clase StringTokenizer, para ver si hemos extraído todos los elementos de la misma. La extracción de elementos de la clase StringTokenizer lo haremos mediante .nextToken(), el cual extrae y pasa al siguiente elemento.

Para insertar los elementos en la pila nos apoyamos en el método push().

Una vez cargada la pila, procederemos a la extracción de los elementos de la misma. El hecho de que la pila sea una estructura LIFO (Last In First Out) hace que lo insertado quede en orden inverso. Es por ello que tendremos la frase invertida de una forma muy sencilla.

while (!pila.empty())
  System.out.print(pila.pop() + " ");

Cada elemento de la pila se extrae con el método .pop(). Un ejemplo muy útil de para qué utilizar una pila.

¿Se te ocurre otra forma de invertir una frase en Java?

X-Forwarded-For es una cabecera HTTP que nos permite conocer la IP origen de la petición. Y es que hasta ahora se utilizaba REMOTE_ADDR, la cual solo nos devolvía la IP de la última máquina por la que había pasado. A todas luces poco útil de cara a conocer el origen de la petición.

El formato de la cabecera X-Forwarded-For es el siguiente:

X-Forwarded-For: client1, proxy1, proxy2

En nuestro caso vamos a montar un servlet en Java que acceda a esta cabecera. Para acceder a los datos de la cabecera nos apoyaremos en el método .getHeader() del objeto HttpServletRequest. En este caso el nombre de la cabecera es "X-Forwarded-For", así que el código será el siguiente:

String sIP = request.getHeader("X-FORWARDED-FOR");

Ahora, con esta ristra de datos podemos hacer lo que queramos. Posiblemente necesitemos apoyarnos en StringTokenizer para desmontar la cadena de IP. O, por lo menos, volcar el contenido a la pantalla:

PrintWriter out = response.getWriter();
out.print("La IP origen ha llegado por: " + sIP);

¿Conocías la existencia de X-Forwarded-For? ¿Crees que puede ayudarte en algo en tus programas?

Normalmente, las páginas ASP tienen como respuesta una salida de texto que conforma una página web o parte de ella. Incluso puede ser que usen la página web para redirigirnos a otra URL. Esta salida, la mayoría de las veces, es texto puro y duro, o bien aderezado con etiquetas HTML. Pero existe la posibilidad de que la respuesta que genere el ASP sea de otro tipo: código XML, una imagen,...

En el caso de que queramos devolver código XML deberemos de informar al navegador o al programa que esta esperando la respuesta de la página ASP que la respuesta generada es del tipo texto XML. Para ello utilizaremos el conten-type de la cabecera de respuesta. El content-type lo podemos especificar indicando que el tipo de contenido es igual a "text/xml". Esto lo podemos realizar mediante la propiedad Response.ContentType

Response.ContentType="text/xml"

Posteriormente, el contenido que devolmamos deberá de ser un fichero XML válido. Para crear el fichero nos valdrá el utilizar el objeto Response e ir volcando diferentes etiquetas con una cierta lógica.

Response.Write("<datos><nombre edad='31'>Victor</nombre></datos>")

Aunque no es necesario, es muy recomendable devolver la etiqueta XML donde indicamos la versión XML que estamos utilizando, así como la codificación usada.

Response.Write("<?xml version='1.0' encoding=utf-8?>")

Vemos que responder XML en ASP es muy sencillo y que lo podemos hacer con unas pocas líneas. Utilidades hay muchas, entre ellas, por ejemplo, crear páginas que respondan a peticiones AJAX,... Y si te gusta más Java que ASP, puedes crear un Servlet que devuelva XML.

¿Qué casos de uso se te ocurren para tener que responder XML en ASP?

Una pila es una estructura que nos permite apilar elementos y recopilarlos en el orden inverso al cual los apilamos mediante operaciones de desapilar. Esto es lo que se conoce como estructuras LIFO (Last In First Out). De esta manera una pila suele tener 3 operaciones básicas:

• apilar, añade un elemento a la lista.
• desapilar, retira un elemento de la lista
• ¿está vacía?, comprueba si la lista está vacía.

En el lenguaje Java contamos con la clase Stack en la librería java.util. Es importante saber que la pila hereda de la pila (aka Vector). Y que por lo tanto podemos utilizar los elementos del Vector sobre la pila.

En nuestro ejemplo vamos a insertar 10 elementos, que serán números, y los recuperaremos en su orden inverso.

Lo primero será definir la pila, es decir, instanciar la clase Stack.

Stack<String> pila = new Stack<String>();

Como vemos el tipo de elementos que insertaremos en la pila serán String -cadenas-.

Una vez instanciada vamos a ir creando los elementos e insertándolos en la pila. El método que inserta elementos en la pila es .push(). Este método recibirá como parámetro el elemento a insertar.

for (int x=1;x<=10;x++)
  pila.push(Integer.toString(x));

Hemos creado un bucle que nos vaya creando los números y nos hemos apoyado en la clase Integer y su método .toString() para convertir los números en cadena.

Una vez que tenemos todos los elementos, procedemos al vaciado de la pila. Tendremos que interactuar sobre la pila hasta que esta esté vacía, cosa que nos dice el método .empty(). En cada una de las iteraciones extraeremos un elemento de la pila mediante el método .pop()

while (!pila.empty())
  System.out.println(pila.pop());

Pocas líneas de código que nos ayudan a crear una pila en Java.

¿Qué cosas se te ocurren resolver mediante el uso de una pila en Java? Proponed casos e iremos resolviéndolos mediante el uso de una pila.

La clase InetAddress es la clase Java que nos permite obtener el nombre de un host y su IP. Esta clase no tiene un constructor, sino que para incializarla deberemos de pasarle el nombre o la IP de un host en concreto o bien indicarle que la maquina de la cual queremos obtener los parametros es la maquina local. Para esto último utilizaremos el método getLocalHost().

InetAddress address = InetAddress.getLocalHost();

Una vez inicializada InetAdress pasaremos a obtener el nombre e IP del servidor local. Para ello nos valdremos de las siguientes funciones:

1. String getHostName(), que nos devolverá una cadena con el nombre de la dirección InetAddress seleccionada. En nuestro caso nos devolverá el nombre de la maquina local.

String sHostName;
sHostName = address.getHostName();

2. byte[] getAddress(), para obtener la IP del servidor. El método devolverá un array de bytes de 4 posiciones, cada una de las cuales equivale a un campo del número IP (A.B.C.D). Los números vienen en formato binario con signo a si que tendremos que "descifrarlo".

 // Cogemos la IP
byte[] bIPAddress = address.getAddress();
 
// IP en formato String
String sIPAddress = "";
 
for (int x=0; x<bIPAddress.length; x++) {
  if (x > 0) {
    // A todos los numeros les anteponemos
    // un punto menos al primero
    sIPAddress += ".";
  }
  // Jugamos con los bytes y cambiamos el bit del signo
  sIPAddress += bIPAddress[x] & 255;
}

Este proceso se explica en detalle en el artículo Obtener la IP de un Host.