Linea de Codigo

En este ejemplo vamos a ver como obtener el directorio padre de un fichero con Java. Es decir, el directorio del cual depende el fichero que instanciemos.

Lo primero será instanciar un fichero mediante la clase File.

File fichero = new File("test.txt");

Ahora se podría pensar que es tan sencillo como utilizar el método .getParent() y ya obtendríamos el directorio padre del fichero. Es decir, que el siguiente código:

fichero.getParent();

Ya nos retornará el directorio. Pero, por desgracia, no funciona ya que no hemos instanciado el fichero con un path y por lo tanto el método .getParent() devolverá null.

Así que, dado el fichero text.txt, vamos a obtener su ruta absoluta mediante .getAbsolutePath() e instanciaremos el fichero.

File fichero = new File("test.txt");
File fichero2 = new File(fichero.getAbsolutePath());
System.out.println("El directorio padre del fichero es " + fichero.getParent());

Con esas líneas ya podremos obtener el directorio padre de un fichero con Java.

Trabajando con ficheros en Java nos puede ser de utilidad obtener fecha de modificación de un fichero. Los pasos para conseguirlo son sencillos.

En primer lugar deberemos de acceder al fichero mediante la clase File.

File fichero = new File("test.txt");

Ahora que ya tenemos instanciada la clase File utilizaremos el método .lastModified(), el cual nos devolverá la fecha de la modificación pero en formato de milisegundos.

long ms = fichero.lastModified();

Así, las siguientes líneas tendrán que servirnos para convertir los milisegundos en una fecha. Esto, en Java, lo podemos conseguir mediante una clase Calendar, la cual instanciaremos mediante un Date y el resultado devuelto por .lastModified().

Date d = new Date(ms);
Calendar c = new GregorianCalendar();
c.setTime(d);

Por último nos apoyaremos en las constantes Calendar.DATE, Calendar.MONTH, Calendar.MINUTE,... para sacar los valores que nos ayuden a obtener la fecha de modificación de un fichero con Java.

dia = Integer.toString(c.get(Calendar.DATE));
mes = Integer.toString(c.get(Calendar.MONTH));
annio = Integer.toString(c.get(Calendar.YEAR));
hora = Integer.toString(c.get(Calendar.HOUR_OF_DAY));
minuto = Integer.toString(c.get(Calendar.MINUTE));
segundo = Integer.toString(c.get(Calendar.SECOND));

Si queremos saber dónde se encuentra un fichero ubicado en el disco duro deberemos de obtener la ruta absoluta del fichero. Para poder llevar a cabo esto nos vamos a basar en los métodos de la clase File de Java.

Lo primero será instanciar la clase File con el fichero del que queremos obtener la ruta absoluta.

File fichero = new File("test.txt");

Ahora simplemente deberemos de apoyarnos en el método .getAbsolutePath() para obtener la ruta absoluta. La línea de código será la siguiente:

System.out.println("La ruta del fichero es: " + fichero.getAbsolutePath());

Como vemos, en un simple método tenemos la ruta absoluta de un fichero con Java.

Cuando manejamos ficheros de configuración una buena idea es tratar todos los ficheros como si fuesen URL. Así evitaremos el estar chequeando si el fichero de acceso está en nuestra máquina os es una URL destino. Por lo tanto vamos a convertir de Path a una URL utilizando el lenguaje Java.

Lo primero será partir de un fichero, el cual instanciaremos mediante una clase File.

File fichero = new File("test.txt");

Si vemos el path del fichero veremos que es una cosa así:

C:\Users\lineadecodigo\files\test.txt

El siguiente paso será realizar la conversión de fichero a URL. Esto lo hacemos mediante el método .toURL() que trae la clase File.

URL url = null;
url = fichero.toURL();

Tenemos que tener cuidado en esta conversión ya que podemos tener una MalformedURLException y habrá que controlarla mediante un bucle try-catch

Si ahora volcamos el contenido de la URL veremos que tenemos una cosa así:

file:/C:/Users/lineadecodigo/files/test.txt

La conversión de Path a URL la podemos hacer a la inversa, es decir de URL a Path. Para ello utilizamos el método .getFile() de la clase URL.

File fichero2 = new File(url.getFile());

Pero como decíamos al principio, lo mejor tratar con las URL de los ficheros.

Si aprendiste a leer un fichero con un enconding ISO Latin 1, ahora vamos a ver cómo podemos escribir un fichero ISO Latin 1 con Java.

El punto en el que hay que especificar el encoding es con la clase OutputStreamWriter. Y es que la clase OutputStreamWriter recibe el fichero al que queremos escribir y el encoding con el que escribimos.

OutputStreamWriter(new FileOutputStream("FicheroSalidaISO1.txt"), "8859_1")

Como vemos el fichero al que escribimos lo instanciamos mediante FileOutputStream. Y el encoding utilizado para escribir un fichero ISO Latin 1 es "8859_1".

Solo nos quedará apoyarnos en un Buffer, en concreto en un BufferedWriter para enviar el texto al fichero.

BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("FicheroSalidaISO1.txt"), "8859_1"));

Una vez que hemos abierto el BufferedWriter, empezamos a ejecutar sentencias de escritura mediante el método .write().

out.write("Esto es un fichero ISO Latin 1");

Por último tenemos que cerrar el stream sobre el fichero. Para esto nos apoyamos en el método .close().

out.close();

Si vemos el código completo veremos que hay que controlar las excepciones UnsupportedEncodingException e IOException.

try {
  BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("FicheroSalidaISO1.txt"), "8859_1"));
  out.write("Esto es un fichero ISO Latin 1");
  out.close();
} catch (UnsupportedEncodingException e) {
  e.printStackTrace();
} catch (IOException e) {
  e.printStackTrace();
}

Con pocas líneas hemos escrito un fichero ISO Latin 1.

El lenguaje Java nos da la capacidad de acceder a ficheros que tengan diferentes codificaciones. Posiblemente, muchos de nuestros ficheros vengan codificados en ISO Latin 1, o lo que es lo mismo ISO-8859-1, Latin Alphabet No. 1.

Al existir diferentes codificaciones para el contenido, Java nos permite indicar el tipo de contenido al que accedemos, para poderlo leer los ficheros de la forma correcta.

Pero vamos por partes, lo primero que haremos será abrir el fichero. Para ello y como vimos en el artículo leer un fichero de texto con Java, necesitaremos de un BufferedReader.

BufferedReader in = new BufferedReader();

Al BufferedReader tendremos que proveerlo de un stream de entrada, o lo que es lo mismo un InputStreamReader.

BufferedReader in = new BufferedReader(new InputStreamReader());

El InputStreamReader será la clave, ya al InputStreamReader podemos indicarle un charset de entrada. Es decir, el tipo de codificación que queremos.

En este caso, si queremos leer un fichero en ISO Latin 1 deberemos de utilizar el charset "8859_1". Pero al InputStreamReader le falta el origen, el nombre del fichero. Es decir, será de la siguiente forma:

 new InputStreamReader(new FileInputStream("FicheroISO1.txt"), "8859_1")

Asegúrate que el fichero tiene un encoding ISO-8859-1, Latin Alphabet No. 1.

El código de la instanciación incial quedaría de la siguiente forma:

BufferedReader in = new BufferedReader(
   new InputStreamReader(new FileInputStream("FicheroISO1.txt"), "8859_1"));

Ahora solo nos quedará leer el contenido del fichero, como hacíamos en leer un fichero de texto con Java.

String sCadena;
while ((sCadena = in.readLine())!=null) {
  System.out.println(sCadena);
} 

Puedes echar un vistazo a los encodings soportados en Java 7.

En este ejemplo vamos a ver como podemos copiar un fichero mediante Java. De tal manera que acabemos teniendo un segundo fichero con el mismo contenido del primer fichero.

Lo primero que haremos será crear dos objetos de tipo File, los cuales representarán al fichero origen y al fichero destino:

File origen = new File("origen.txt");
File destino = new File("destino.txt");

La idea principal de la copia será la de abrir un stream de lectura, es decir, un InputStream, sobre el fichero origen, realizar la lectura a la vez que abrimos un stream de escritura sobre el fichero destino, es decir, un OutputStream. Sobre este OutputStream realizaremos la escritura.

Nos apoyamos en los objetos File creados anteriormente, así como en las clases FileInputStream y FileOutputStream para abrir los stream a los ficheros:

InputStream in = new FileInputStream(origen);
OutputStream out = new FileOutputStream(destino);

Realizamos la lectura y escritura mientras existan datos en el stream de lectura

byte[] buf = new byte[1024];
int len;
 
while ((len = in.read(buf)) > 0) {
  out.write(buf, 0, len);
}

Las lecturas las hacemos mediante el método .read().

Ya solo nos quedará cerrar los stream mediante el método .close() para finalizar el código de nuestro programa.

in.close();
out.close();

Cabe notar que necesitamos controlar la excepción IOException en todo el código. Es por ello, que todo el código lo tendremos en una estructura try-catch.

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

Una de las cosas que nos permite el objeto FileSystemObject es listar el contenido de un directorio.
Esto nos puede servir si queremos implementar mediante ASP una especie de navegador de carpetas del servidor o algo por el estilo. De esta manera y junto con el resto de características del objeto FileSystemObject podemos llegar a implementar un verdadero gestor de los ficheros de nuestro servidor.

Lo primero que tenemos que hacer es obtener una referencia a dicho objeto:

Set fso = CreateObject("Scripting.FileSystemObject")

Una vez instanciado el objeto FileSystemObject, lo que tenemos que hacer es recuperar una referencia a la carpeta de la cual queremos listar los archivos. Para ello nos apoyamos en el método .GetFolder().

Set directorio = fso.GetFolder ("C:\windows")

Esta referencia, en si, es otro objeto, el cual contendrá el listado de ficheros. A si que, lo que pasaremos a hacer es recorrer dicho objeto ayudándonos de un bucle for..each.

For Each fichero IN directorio.Files
   ...
Next

Directamente podemos volcar el contenido de la variable fichero, lo cual nos dará información sobre el mismo. Por otro lado, si queremos obtener solo el nombre del fichero, podemos crear un objeto File. Del objeto file podemos utilizar la propiedad Name para obtener únicamente el nombre del fichero, sin la ruta.

Set file = fso.GetFile(fichero)
Response.Write fichero.Name &"<BR>"

El código completo nos quedaría de la siguiente forma:

For Each fichero IN directorio.Files
   Set file = fso.GetFile(fichero)
   Response.Write (fichero.Name)&"<BR>"
Next