Linea de Codigo

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
 

La clase File nos permite en Java instanciar cualquier elemento del sistema de ficheros y trabajar con él de una forma genérica. A la hora de instanciar el elemento podremos pasar al constructor bien un directorio o bien un fichero.

La instanciación de un objeto File sería de la siguiente forma:

File fRuta = new File("c:\\prueba");

Solo tendremos que apoyarnos en el método .isDirectory() para saber si una ruta es un directorio con Java :

if (fRuta.isDirectory())
  System.out.println("Es un directorio");
else
  System.out.println(" NO es un directorio");

Una de las operaciones que podemos hacer cuando estemos trabajando con un fichero será lde borrado. Borrar un fichero con ASP será tan sencillo como invocar al método DeleteFile.

El método DeleteFile depende del objeto FileSystemObjet. Es por ello que lo primero que tendremos que hacer será instanciar el fichero FileSystemObjet.

Set fso = Server.CreateObject("Scripting.FileSystemObject")

El método DeleteFile lleva dos argumentos. El primero es el nombre del fichero que queremos borrar y el segundo es una condición booleana que indica que hacer en caso de que el fichero sea de solo lectura. Indicando un valor true el fichero se eliminará independientemente de si es de lectura o no. Si bien, por defecto, el valor de este campo es false.

DeleteFile(fichero, obligatorio)

Además debemos de tener en cuenta que en el caso de que intentemos borrar un fichero que no existe nos dará fallo. Es por ello que deberemos de comprobar la existencia del mismo mediante el método FileExists al cual le pasamos la ruta con el nombre del fichero.

El código nos quedará de la siguiente forma:

if (fso.FileExists(sFichero)) then
  fso.DeleteFile sFichero,true
  Response.Write "Borrado el fichero " & sFichero
else
  Response.Write "No existe el fichero " & sFichero
end if

Ya están lejos los tiempos dónde un site de Internet estaba compuesto solo por páginas estáticas HTML. Ahora la mayoría se componen en los servidores, mezclando información, ficheros, datos almacenados,... Si bien podemos tener la necesidad de tener dinamismo en la carga de datos de la parte cliente. Para ello, jQuery nos dará la capacidad de cargar un fichero de forma dinámica.

Lo primero que tenemos que hacer es crear un fichero HTML de test. Este lo llamaremos test.html. Ahora pasamos a crear la página que nos permite cargar un fichero con jQuery. En esta, lo primero que vamos a hacer es cargar la librería jQuery.

<script type="text/javascript" src="jquery.js"></script>

Como en la mayoría de las ocasiones utilizamos la función ready para esperar que se cargue la página. Dentro de la función ready será donde insertemos nuestro código jQuery.

$(document).ready(function(){
 $("#carga").click(function() {
	// Código
   });
});

Vemos que el código que nos va a permitir cargar un fichero con jQuery se lo asociaremos al evento click de un elemento que llevará el ID carga. Por ejemplo, pondremos un botón...

<button id="carga">Cargar fichero</button>

Además añadiremos una capa, a la cual daremos el ID texto, sobre la cual cargaremos el fichero HTML.

 
<div id="texto"></div>
 

Ya solo nos quedará cargar el fichero. Para ello utilizamos la función .load(), a la cual pasamos el nombre del fichero a cargar. En nuestro caso el fichero test.html

 $("#carga").click(function() {
	 $("div#texto").load("test.html");
   });