feed twitter facebook LinkedIn facebook

Java » Como ejecutar un comando del sistema desde Java

abril 9, 2012 por Feffo 12 Comentarios Imprimir Imprimir

Hoy les traigo una forma de poder ejecutar un comando de consola en Java. La clave para ejecutar un comando en Java esta en los métodos exec(String command) y exec(String[] cmdarray).

La diferencia entre estos dos métodos Java es que el primero esta destinado a ejecutar comandos sin argumentos:

  1. try {
  2. String cmd = "halt"; //Comando de apagado en linux
  3. Runtime.getRuntime().exec(cmd);
  4. } catch (IOException ioe) {
  5. System.out.println (ioe);
  6. }

Y el segundo si, solo que deben poner cada 'palabra' en un índice distinto en el arreglo Java:

  1. try {
  2. String [] cmd = {"shutdown","-s","-t", "10"}; //Comando de apagado en windows
  3. Runtime.getRuntime().exec(cmd);
  4. } catch (IOException ioe) {
  5. System.out.println (ioe);
  6. }

Recordar que el comando se va a ejecutar en un proceso Java aparte.

Otra cosa a tener en cuenta es el retorno que brindan estos métodos. Para ello tenemos el objeto de tipo Process.

La clase Process posee algunos métodos interesantes, en especial el metodo public abstract InputStream getInputStream(), ya que con él podemos obtener un Stream para poder leer lo que el comando que ejecutamos escribío en la consola.

  1. Process process = Runtime.getRuntime().exec("lsb_release -a");
  2. InputStream inputstream = process.getInputStream();
  3. BufferedInputStream bufferedinputstream = new BufferedInputStream(inputstream);

En mi caso, obtuve el siguiente texto al leer las lineas del buffer.

Distributor ID:	Ubuntu
Description:	Ubuntu 11.10
Release:	11.10
Codename:	oneiric

Espero que les haya gustado el artículo.

Java » Convertir un número a texto con Java

abril 8, 2012 por Víctor Cuervo 3 Comentarios Imprimir Imprimir

Vamos a ver como construir un método con Java al cual le pasemos un número de tres dígitos: unidades, decenas y centenas y nos lo transforme a texto. Es decir, el 534 nos lo transforme en "quinientos treinta y cuatro".

Lo primero será crear métodos de apoyo. El primer método de apoyo es el que dado una unidad nos la transforma en texto.

  1. public static String unidadEnTexto(int iNumero){
  2. // Método que dado un número me lo devuelve en texto
  3. switch(iNumero){
  4. case 1:
  5. return "uno";
  6. case 2:
  7. return "dos";
  8. case 3:
  9. return "tres";
  10. case 4:
  11. return "cuatro";
  12. case 5:
  13. return "cinco";
  14. case 6:
  15. return "seis";
  16. case 7:
  17. return "siete";
  18. case 8:
  19. return "ocho";
  20. case 9:
  21. return "nueve";
  22. case 0:
  23. return "cero";
  24. default:
  25. return "";
  26. }
  27. }

El siguiente será el de las decenas. Es decir, le pasaremos un número que represente las decenas y nos devolverá el texto. Si le pasamos un 2 nos devolverá "veinte".

  1. public static String decenaEnTexto(int iDecena){
  2. switch (iDecena){
  3. case 1:
  4. return "diez";
  5. case 2:
  6. return "veinte";
  7. case 3:
  8. return "treinta";
  9. case 4:
  10. return "cuarenta";
  11. case 5:
  12. return "cincuenta";
  13. case 6:
  14. return "sesenta";
  15. case 7:
  16. return "setenta";
  17. case 8:
  18. return "ochenta";
  19. case 9:
  20. return "noventa";
  21. default:
  22. return "";
  23. }
  24. }

Todas las decenas las podemos montar con el texto de la decena y el texto de la unidad, añadiendo un "y" en medio. Así 22 sería "veinte y dos". Hay un caso especial a tener en cuenta y este es el de las decenas del diez. Así que para ese caso nos montamos otro método de apoyo.

  1. public static String decenas(int iDecena){
  2. switch (iDecena){
  3. case 11:
  4. return "once";
  5. case 12:
  6. return "doce";
  7. case 13:
  8. return "trece";
  9. case 14:
  10. return "catorce";
  11. case 15:
  12. return "quince";
  13. case 16:
  14. return "dieciseis";
  15. case 17:
  16. return "diecisiete";
  17. case 18:
  18. return "dieciocho";
  19. case 19:
  20. return "diecinueve";
  21. default:
  22. return "";
  23. }
  24. }

Y lo último igual para las centenas. Si bien es verdad que aquí solo se nos devolverá el relativo a los cientos, quinientos y novecientos. Ya que para el testo de centenas lo podemos montar mediante la unidad y añadiendo el sufijo cientos. Así tendremos dos-cientos, tres-cientos,...

  1. public static String centenaEnTexto(int iCentena){
  2. switch (iCentena){
  3. case 1:
  4. return "ciento";
  5. case 5:
  6. return "quinientos";
  7. case 9:
  8. return "novecientos";
  9. default:
  10. return "";
  11. }
  12. }

Ahora solo nos queda desmontar el número e ir llamando a las funciones de apoyo necesarias. Para ir obteniendo por dígitos nos apoyamos en el módulo y división de 10. Ya que el módulo nos deja el dígito y la división el resto del número.

Así, para las unidades sería:

  1. int iUnidad = iNumero%10;
  2. iNumero = iNumero/10;
  3. sTexto = unidadEnTexto(iUnidad);

La conversión de la unidad ha sido sencilla ya que solo hemos tenido que llamar al método unidadEnTexto.

Vamos con las decenas, para obtener la decena el mismo mecanismo que antes.

  1. int iDecena = iNumero%10;
  2. iNumero = iNumero/10;
  3.  
  4. if ((iUnidad==0) && (iDecena>0))
  5. sTexto = decenaEnTexto(iDecena);
  6. else if (iDecena==1)
  7. sTexto = decenas(10+iUnidad);
  8. else if (iDecena > 1)
  9. sTexto = decenaEnTexto(iDecena) + " y " + sTexto;

Aqui tenemos tres casos.

  • Si la unidad era un cero, pedimos la decena y será el texto único.
  • Si la decena empieza por uno, caso especial y por lo tantto llamamos al método de las decenas.
  • Otros casos componemos con la decena y la unidad juntas con un "y".

El último caso, las centenas.

  1. int iCentena = iNumero%10;
  2.  
  3. if ((iCentena!=1) && (iCentena!=5) && (iCentena!=9) && (iCentena!=0))
  4. sTexto = unidadEnTexto(iCentena) + "cientos" + " " + sTexto;
  5. else if ((iCentena==1) || (iCentena==5) || (iCentena==9))
  6. sTexto = centenaEnTexto(iCentena) + " " + sTexto;

En este caso solo hay el dilema del 1, 5 y 9. Así que un if y solucionado. El resto de las centenas las montamos con la unidad en texto más el texto "cientos".

Así, finalmente, hemos dejado en sTexto el número convertido a texto con Java.

Java » Acceder a un directorio de un FTP con Java

marzo 22, 2012 por Víctor Cuervo 3 Comentarios Imprimir Imprimir

Ya vimos en un ejemplo los pasos que hay que seguir para conectarse a un FTP mediante un programa en Java. Con ese código veíamos como acceder al directorio raíz del FTP. Para ello utilizábamos las librerías Apache Commons.

Ahora vamos a ver cómo podemos acceder con Java a un directorio concreto del FTP para acceder a su información.

Lo primero de todo será conectarnos al FTP. Así que creamos una clase FTPClient.

  1. FTPClient client = new FTPClient();
  2. client.connect(sFTP);
  3. boolean login = client.login(sUser,sPassword);

Los métodos connect() y login() nos permiten establecer la conexión y el login sobre el servidor del FTP.

Una vez conectados al servidor FTP podemos ver el directorio al que estamos conectados mediante el método printWorkingDirectory().

  1. System.out.println(client.printWorkingDirectory());

Ahora pasaremos a cambiar de directorio dentro del servidor. En este caso vamos a apoyarnos en el método changeWorkingDirectory() indicándole el directorio al que queremos cambiar como parámetro.

  1. client.changeWorkingDirectory("\\httpdocs");
  2. System.out.println(client.printWorkingDirectory());

De esta forma y después de acceder al directorio, ya podemos operar sobre él.

Para finalizar nuestro código Java no podemos olvidarnos de desconectarnos del servidor.

  1. client.logout();
  2. client.disconnect();

Java » Como descargar un archivo en Java

marzo 21, 2012 por Feffo 8 Comentarios Imprimir Imprimir

Como mi primera colaboración en Linea de Codigo les voy a presentar una forma muy simple para poder descargar cualquier archivo desde Java. :)

Sin duda, es una solución simple a un problema relativamente recurrente, pero que con un poco de maña pueden hacer algo muy poderoso, y quizás hasta profesional, como lo es un programa Auto-Actualizable.
(Abajo del todo les cuento un poco sobre mi experiencia sobre este tema.)

Pero primero es lo primero, y para empezar vamos a necesitar los siguientes elementos Java para realizar una descarga.
Estos son:

  1. String url = "http://i.imgur.com/HZ1hq.jpg"; //dirección url del recurso a descargar
  2. String name = "lineadecodigo.jpg"; //nombre del archivo destino

Por cuestiones de prolijidad y organización está bueno que los archivos sean destinados a una carpeta especial encargada de almacenarlos, en vez de que anden dando vueltas por ahí.

Lo siguiente que debemos hacer en nuestro programa Java es crear la carpeta destino, si es que esta no existe. En caso de no poder crearla el programa se abortará, ya que si no puede crear una carpeta, es muy probable que tampoco pueda crear el archivo destino de la descarga.

  1. //Directorio destino para las descargas
  2. String folder = "descargas/";
  3.  
  4. //Crea el directorio de destino en caso de que no exista
  5. File dir = new File(folder);
  6.  
  7. if (!dir.exists())
  8. if (!dir.mkdir())
  9. return; // no se pudo crear la carpeta de destino

Por como esta planteado, si ya existía un archivo con el mismo nombre que el archivo destino, este va a ser reemplazado, con el uso del metodo public boolean exists() se puede solucionar.

Además, tengan en cuenta que el método public boolean renameTo(File dest) no funciona bien en Windows, siempre retornara false y nunca hará su cometido. Esto lo digo por si quieren usar archivos con un nombre temporal, puede que tengan problemas a la hora de renombrarlo.

Una vez hecho esto estamos en condiciones de empezar la descarga del archivo elegido en Java.

Esto se realiza de la siguiente forma:

  1. Crear el archivo destino.
  2. Establecer la conexión con la url.
  3. Abrir los streams necesarios.
  4. Leer y escribir hasta encontrar el fin del archivo.
  5. Cerrar los streams (¡Importante!).

Creamos el archivo destino, en caso de existir lo elimina:

  1. File file = new File(folder + name);

Establece la conexion con la url mediante una clase URLConnection:

  1. URLConnection conn = new URL(url).openConnection();
  2. conn.connect();
  3. System.out.println("\nempezando descarga: \n");
  4. System.out.println(">> URL: " + url);
  5. System.out.println(">> Nombre: " + name);
  6. System.out.println(">> tamaño: " + conn.getContentLength() + " bytes");

Abrimos los Stream:

  1. InputStream in = conn.getInputStream();

Mediante un bucle vamos leyendo del InputStream y vamos escribiendo en el OutputStream. Vamos leyendo de a un byte por vez y los escribe en un archivo. El -1 significa que se llego al final.

  1. int b = 0;
  2. while (b != -1) {
  3. b = in.read();
  4. if (b != -1)
  5. out.write(b);
  6. }

Cerramos los streams:

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

En todo el código de manejo del URLConnection y de los Stream debemos de controlar las excepciones MalformedURLException e IOException.

  1. try {
  2. ...
  3. } catch (MalformedURLException e) {
  4. System.out.println("la url: " + url + " no es valida!");
  5. } catch (IOException e) {
  6. e.printStackTrace();
  7. }

Un poco mas sobre programas auto-actualizables. ¿Cuál es la clave de esto?

  1. Conseguir un servidor (como googlecode) que permita almacenar archivos en una url que no se vea modificada entre cambios.
  2. Una forma de versionado, por mas simple que sea, para poder reconocer si hay versiones nuevas o no.

De esta forma, podrían almacenar en un txt una lista de direcciones url correspondientes a los archivos que deben ser actualizados. Entonces, descargan ese txt, luego lo recorren como a cualquier archivo y por cada url que encuentre en él, inicien una descarga. Finalmente, reemplazan esos archivos con sus predecesores y mediante un dialogo le piden al usuario que reinicie el programa y luego lo cierran con:

  1. System.exit (0);

O algo por el estilo.

Esto, sinceramente, les va a solucionar muchos problemas en cuanto a tiempo, ya que pueden actualizar sus programas directamente desde la comodidad de su casa.

¿Se les ocurre alguna otra utilidad? ¿Le harían alguna modificación al código Java?

Java » Formato a Fechas en Java con DateFormat

marzo 16, 2012 por Emmanuel Ramos 1 Comentario Imprimir Imprimir

En el dia de hoy les explicare como formatear una fecha en Java. Lo primero que haremos será usar una de las clases de el paquete java.text. Esta clase es DateFormat. De igual manera utilizaremos la clase Date y Locale del paquete java.util.

Un detalle de la clase DateFormat de Java es que es abstracta por lo cual usaremos metodos estaticos para que nos devuelvan una instancia de la clase. en caso de usar el codigo les recuerdo realizar los import de las clases necesarias

Lo primero crearemos una instancia de la clase Date:

  1. Date date = new Date();

Crearemos una instancia de la clase Locale. Como ven ingrese parametros al constructor los cuales especifican el lenguaje y pais respectivamente. Ingrese al constructor parametros para que muestre la fecha en Brasil (pt,BR).

  1. Locale locBR = new Locale("pt","BR");

Ahora creamos un array de DateFormat.

  1. DateFormat[]df = new DateFormat[4];

A cada una de las posiciones le damos una instancia de DateFormat. El metodo getDateInstance regresa una instancia:

  1. df[0]= DateFormat.getDateInstance(DateFormat.MEDIUM);
  2. df[1]= DateFormat.getDateInstance(DateFormat.LONG);
  3. df[2]= DateFormat.getDateInstance(DateFormat.SHORT);
  4. df[3]= DateFormat.getDateInstance(DateFormat.LONG, locBR );

A cada una de las instancias le pasamos constantes, de cualquier forma, hay mas constantes las cuales podrias revisar en el API y hacer prueba. A la última de las instancias le pasamos el locale para que me de formato en el país.

Recordar que como DateFormat es abstracta no podemos hacer esto new DateFormat().

Por último hacemos un loop para iterar sobre el array y damos el formato a la fecha que habiamos creado arriba

  1. for(DateFormat d : df)
  2. System.out.println(d.format(date));

Java » Invertir Array

marzo 7, 2012 por Pablo Ruiz 2 Comentarios Imprimir Imprimir

Hoy les explicaré un método en Java que hice para invertir arrays simples.

En él haremos lo siguiente

  1. Clase llamada InvertirArray
  2. Declararemos un array de tipo Object llamado invertir_int
  3. Un método llamado invertir(Object[] arg0)
  4. Un método que nos devolverá el arreglo invertido llamado getArreglo_invertido()
  5. Y el Main para probar

La definición de la clase Java queda así:

  1. public class InvertirArray {}

Ya sabes que dentro de las llaves haremos todo lo demas.

Seguimos con la declaración del array de tipo Object. Este array nos servirá para invertir el array inicial.

  1. private static Object[] invertir_int;

Luego construimos el método que invertirá el array:

  1. public static void invertir(Object[] array) {
  2. invertir_int = new Object[array.length];
  3. int maximo = array.length;
  4.  
  5. for (int i = 0; i<array.length; i++) {
  6. invertir_int[maximo - 1] = array[i];
  7. maximo--;
  8. }
  9. }

Lo que hacemos es instanciar un array con el tamaño del array que hay que invertir y luego recorreremos dicho array de atrás adelante para ir creando el array invertido.

Luego el método que nos devuelve el arreglo

  1. public static Object[] getArreglo_invertido() {
  2. return InvertirArray.invertir_int;
  3. }

y finalmente una simple forma de usar este método:

  1. public static void main(String args[]) {
  2.  
  3. Object[] arreglo = new Object[5];
  4.  
  5. arreglo[0] = 0;
  6. arreglo[1] = 1;
  7. arreglo[2] = 2;
  8. arreglo[3] = 3;
  9. arreglo[4] = 4;
  10.  
  11. for (int i = 0; i < arreglo.length; i++) {
  12. Object j = arreglo[i];
  13. System.out.println("Arreglo Normal: " + j);
  14. }
  15.  
  16. try {
  17. invertir(arreglo);
  18. } catch (Exception e) {
  19. System.out.println("Error: "+e.getMessage());
  20. }
  21.  
  22. for (int i = 0; i < invertir_int.length; i++) {
  23. Object j = invertir_int[i];
  24. System.out.println("Arreglo invertido: " + j);
  25. }
  26. }

Java » Crear la ruta de un fichero con Java

febrero 25, 2012 por Víctor Cuervo 3 Comentarios Imprimir Imprimir

Hoy un artículo sencillo pero de mucha utilidad. Como bien sabéis, dependiendo del sistema operativo que estemos utilizando en Java, las rutas de los ficheros (llamados path) se crean de diferente forma.

Así cuando creemos una ruta para un sistema operativo Windows pondremos:

c:\midirectorio\mifichero.txt

Mientras que si estamos en un sistema Linux utilizaremos:

/midirectorio/mifichero.txt

Es por ello que tenemos que tener especial cuidado en construir la ruta del fichero en nuestro programa Java. Para poder resolver esto tenemos varias alternativas. La primera sería chequeando las propiedades del sistema "os.name" y "file.separator" con .getProperty().

  1. String so = System.getProperty("os.name");
  2. String separador = System.getProperty("file.separator");

En el caso de "os.name" obtenemos el nombre del sistema operativo y en el caso de "file.separator" obtenemos el separador de directorios. Así, montar nuestra ruta de un fichero sería:

  1. sPath = separador + sDirectorio + separador + sFichero;
  2. System.out.println(sPath);

Pero, si no queremos consultar las propiedades del sistema, tenemos la constante File.separator. La cual tiene almacenado el separador de directorios del sistema operativo sobre el que nos ejecutemos. De esta forma construir la ruta de un fichero se haría de la siguiente manera:

  1. String sPath = File.separator + sDirectorio + File.separator + sFichero;
  2. System.out.println(sPath);

Hay que tener un poco de cuidado con la versión de Java que utilices, ya que File.separator solo está disponible desde Java 5.

¿Cual de las dos formas utilizarías? ¿Conoces alguna más?

Java » Cambiar la fecha de modificación de un fichero con Java

febrero 24, 2012 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Ya vimos en un artículo cómo obtener la fecha de modificación de un fichero con Java. En este caso vamos a ver cómo realizar la operación contraria, el cambiar la fecha de modificación de un fichero con Java. Esto puede ser útil, por ejemplo, si estamos haciendo una revisión de ficheros y queremos utilizar la fecha de modificación del fichero como flag para siguientes revisiones.

Lo primero instanciamos un fichero con un objeto File.

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

La fecha de modificación del fichero se la vamos a pasar en milisegundos, así que utilizaremos la función currentTimeMillis() del sistema para obtener la fecha actual en milisegundos.

  1. long ms = System.currentTimeMillis();

Ya solo nos quedará volcar el contenido de la fecha sobre el fichero mediante .setLastModified() el cual recibirá los milisegundos como parámetro. En el caso de que la asignación haya ido correctamente la función devolverá true, en caso contrario devolverá false.

  1. boolean cambio = fichero.setLastModified(ms);
  2. if (cambio)
  3. System.out.println("Se ha cambiado la hora del sistema satisfactoriamente");
  4. else
  5. System.out.println("NO se ha podido cambiar la hora");

Tres pasos sencillos para cambiar la fecha de modificación de un fichero con Java.

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();}