feed twitter facebook LinkedIn facebook

Java » Evitar que un programa Java se cargue dos veces

febrero 22, 2012 por Víctor Cuervo 13 Comentarios Imprimir Imprimir

Algunos de vosotros nos habéis preguntado sobre cómo controlar que un programa Java se cargue dos veces. Es decir, que si ya lo hemos lanzado, evitemos que se vuelva a lanzar.

Existen formas desde Java Web Start y el modo SingleInstanceService para evitar que un programa se cargue dos veces. Pero en nuestro caso vamos a realizarlo de una forma "más manual" en Java, pero muy efectiva.

El truco es que el programa Java cree un objeto que esté escuchando a un puerto específico del ordenador. Para ello utilizamos un ServerSocket, objeto que nos permite crear un objeto escuchando a un determinado puerto.

  1. private static ServerSocket SERVER_SOCKET;
  2. SERVER_SOCKET = new ServerSocket(1334);

Escoge un puerto que no sea el estándar de los protocolos: 80 para el http, 21 para el ftp,... Vamos elige un número de puerto "raro".

Además vemos que el objeto ServerSocket que hemos instanciado es un objeto estático dentro de nuestro programa. Así, nuestro programa tendrá un listener sobre un puerto, al que nadie dirá nada, pero que lo dejará como reservado.

Lo que sucede es que si intentamos volver a crear un escuchador sobre ese puerto, saldrá una excepción indicando que el puerto ya está en uso. Esto nos permite controlar que ya hay una instancia de nuestro programa ejecutándose.

  1. try {
  2. SERVER_SOCKET = new ServerSocket(1334);
  3. System.out.println("Es la primera instancia de la aplicación...");
  4. System.out.println("Pulsa OK para terminar");
  5. System.in.read();
  6. } catch (IOException x) {
  7. System.out.println("Otra instancia de la aplicación se está ejecutando...");
  8. }

Con este simple código podemos evitar que un programa Java se ejecute dos veces.

Java » Guardar unos Properties con Java

febrero 21, 2012 por Víctor Cuervo 5 Comentarios Imprimir Imprimir

Hemos visto varios ejemplos sobre cómo leer el contenido de unos Properties o cómo modificar el contenido de unos Properties. Pero, qué tenemos que hacer si una vez modificados queremos guardarlos en el fichero. Ya que la modificación solo se aplica al tiempo de vida de la ejecución del programa Java.

Veamos ahora como podemos guardar unos Properties con Java. Lo primero será definir unos Properties mediante la clase Properties. Los vamos a generar vía código, aunque podíamos haberlos leído de un fichero.

  1. Properties prop = new Properties();
  2. prop.setProperty("nombre","Linea de Código");
  3. prop.setProperty("url","http://lineadecodigo.com");

El siguiente paso será definir el fichero el cual queremos guardar los Properties. Y como todo manejo de ficheros deberemos de abrirle un FileOutputStream.

  1. FileOutputStream os = FileOutputStream("fichero.prop");

Ahora va lo más importante, y es que dentro de Properties tenemos el método .store() el cual persistirá los datos sobre un FileOutputStream que le pasemos como parámetro. Curiosamente el que acabamos de crear.

  1. prop.store(os, "Fichero de Propiedades de la Web");

Una de las cosas que tienes que tener en cuenta es que en los manejos de stream puede saltar siempre la IOException. Así que nos crearemos nuestro bloque try-catch.

  1. FileOutputStream os = null;
  2. try {
  3. os=new FileOutputStream("fichero.prop");
  4. prop.store(os, "Fichero de Propiedades de la Web");
  5. } catch(IOException ioe) {ioe.printStackTrace();}

Java » Obtener directorio padre de un fichero

enero 20, 2012 por Víctor Cuervo 3 Comentarios Imprimir Imprimir

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.

  1. 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:

  1. 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.

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

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

Java » Obtener fecha de modificación de un fichero con Java

enero 19, 2012 por Víctor Cuervo 1 Comentario Imprimir Imprimir

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.

  1. 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.

  1. 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().

  1. Date d = new Date(ms);
  2. 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.

  1. dia = Integer.toString(c.get(Calendar.DATE));
  2. mes = Integer.toString(c.get(Calendar.MONTH));
  3. annio = Integer.toString(c.get(Calendar.YEAR));
  4. hora = Integer.toString(c.get(Calendar.HOUR_OF_DAY));
  5. minuto = Integer.toString(c.get(Calendar.MINUTE));
  6. segundo = Integer.toString(c.get(Calendar.SECOND));

Java » Convertir un fichero ISO en UTF-8

enero 14, 2012 por Víctor Cuervo 1 Comentario Imprimir Imprimir

Apoyándonos en los ejemplos que nos enseñaban a generar ficheros en ISO y a generar ficheros en UTF-8, así como en los que leian de un fichero en ISO y leian un fichero en UTF-8 vamos a construir un código que nos permita hacer la conversión. Es decir, convertir un fichero ISO en un fichero UFT-8.

La idea es muy sencilla, lo que tendremos que hacer es abrir un stream de lectura sobre un fichero ISO y un stream de escritura sobre un fichero UTF-8.

Para realizar la escritura del fichero ISO utilizamos un BufferedReader sobre un InputStreamReader. Será en el InputStreamReader dónde indicaremos la codificación del fichero a leer. La codificación "8859_1" es la que representa el ISO.

El código será el siguiente:

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

La apertura del stream de escritura será muy similar, pero en este caso utilizando un BufferedWriter y un OutputStreamWriter. Al igual que en la anterior línea de código, es el OutputStreamWriter con el que indicamos la codificación. Esta será utf-8.

  1. Writer out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("FicheroSalidaUTF8"), "utf-8"));

Ya solo nos queda ir leyendo del BufferedReader y volcando sobre el .

  1. String sCadena;
  2. while ((sCadena = in.readLine())!=null) {
  3. System.out.println(sCadena);
  4. out.write(sCadena);
  5. }

El último paso de nuestro código de conversión es el cierre de los ficheros.

  1. in.close();
  2. out.close();

Con una lectura/escritura y teniendo en cuenta las codificaciones de los ficheros, hemos conseguido, de una forma sencilla, convertir un fichero de ISO a UTF-8.

Java » Obtener la ruta absoluta de un fichero con Java

enero 7, 2012 por Víctor Cuervo 15 Comentarios Imprimir Imprimir

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.

  1. 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:

  1. 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.

Java » Crear un fichero temporal con Java

noviembre 23, 2011 por Víctor Cuervo 3 Comentarios Imprimir Imprimir

Ayer nos interesábamos por saber cual es el directorio temporal del sistema con Java. Y es que hoy vamos a generar un fichero temporal con Java y claro está, deberíamos saber dónde ir a buscarlo.

Creo que no hace falta explicar la utilidad de los ficheros temporales. Simplemente tenemos que saber que no todos los datos que utilizamos en nuestros programas tienes porqué ser guardados. En esos casos, utiliza ficheros temporales.

Java nos ofrece un conjunto de métodos muy extensos en la clase File y uno de ellos es createTempFile(). El método createTempFile() nos crea un fichero temporal en el directorio que le digamos o en el directorio temporal del sistema.

Creemos el fichero...

  1. File tempFile = File.createTempFile("mificherotemporal",null);

Es muy importante que el fichero creador por createTempFile() tendrá un número generado aleatoriamente. A dicho número le podemos añadir un prefijo o sufijo para añadirlo. En nuestro caso le hemos antepuesto 'mificherotemporal' y no le hemos asignado sufijo.

Siempre que crees ficheros en Java con la clase File recuerda el manejar la excepción IOException.

Una cosa importante cuando trabajamos con ficheros temporales en Java es que, estos, por defecto no se borran. Si lo que queremos es borrar el fichero cuando termine nuestro programa deberemos de llamar al método .deleteOnExit().

  1. tempFile.deleteOnExit();

Ya solo nos queda volcar algo de contenido sobre nuestro fichero temporal.

  1. BufferedWriter out = new BufferedWriter(new FileWriter(tempFile));
  2. out.write("Esto es un fichero temporal");
  3. out.close();

Y trabajo hecho. Ya tenemos creado nuestro fichero temporal con Java.

Java » Directorio Temporal del Sistema en Java

noviembre 22, 2011 por Víctor Cuervo 3 Comentarios Imprimir Imprimir

El directorio temporal del sistema será aquel directorio dónde volquemos los ficheros que no tengan utilidad final, aquellos que solo estemos utilizando para fines temporales.

Si queremos saber cual es el directorio temporal del sistema en Java deberemos de utilizar la clase System y acceder a las propiedades del sistema. En concreto deberemos de acceder a la propiedad java.io.tmpdir. Para ello utilizamos el método .getProperty().

Solo tenemos que volcarlo por la consola:

  1. System.out.println("El directorio temporal del sistema es "
  2. + System.getProperty("java.io.tmpdir"));

En sucesivos artículos trabajaremos con ficheros temporales que dejaremos en el directorio temporal del sistema.

Java » Convertir de Fichero a URL con Java

octubre 13, 2011 por Víctor Cuervo 1 Comentario Imprimir Imprimir

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.

  1. 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.

  1. URL url = null;
  2. 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.

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

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

Java » Escribir un fichero UTF-8

octubre 12, 2011 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Si ya escribimos un fichero en ISO Latin 1, ahora vamos con el encoding UTF-8. Y es que el procedimiento es similar, y solo tendremos que prestar atención al encoding a utilizar.

El encoding utf-8 lo vamos a indicar en el OutputStream. Y es que nuestro stream de datos de salida en Java o OutputStream recibirá el encoding "utf-8" y el fichero dónde escribiremos mediante una instancia de FileOutputStream.

  1. ew OutputStreamWriter(new FileOutputStream("FicheroSalidaUTF8.txt"), "utf-8");

Ahora solo necesitaremos un Buffer Java de salida, un BufferedWriter para ir volcandole los datos.

  1. BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("FicheroSalidaUTF8.txt"), "utf-8"));

En este tipo de manipulaciones tienes que tener cuidado con las excepciones Java UnsupportedEncodingException e IOException.

Los datos los volcamos con el método .write():

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

Por último cerraremos el fichero mediante un método .close():

  1. out.close();