jueves, 5 de diciembre de 2013

Dar formato a código JSP (Java) en Eclipse








Todos los que hemos programado sabemos lo que pasa cuando añades, borras, modificas y haces pruebas con código: que al final se queda en un montón de líneas casi ilegibles. Para ello, por ejemplo, el IDE Eclipse incluye una opción que permite formatear nuestro código Java, creando las identaciones y dejándolo mucho más agradable de leer y facilitando su mantenimiento. ¿Pero qué pasa si estamos trabajando con código JSP?. Pues que esta opción no funcionará correctamente. En este artículo se explicará cómo formatear código JSP desde Eclipse.

Lo primero que hay que hacer es ejecutar Eclipse e instalar el plugin Web Tools Platform (WTP) de la siguiente forma:
  • Pulsamos en el menú "Help" / "Install New Software ...".
  • En "Work with" añadimos la siguiente URL: http://download.eclipse.org/webtools/updates y la seleccionamos.
  • Debajo marcaremos "Web Tools Plataform 3.1.2" (podemos marcar la versión que queramos dentro de las disponibles).

  • Tendremos que pulsar "Next" varias veces hasta la úlima pantalla, en la que hay que aceptar las condiciones y pulsar "Finish".


Y ya tendremos instalado WTP. Ahora ya podremos pulsar en "Sourse" / "Format" e inmediatamente tendremos nuestra JSP formateada. También se puede formatear solamente una parte del código, seleccionándola y pulsando en "Sourse" / "Format". 

Si queremos personalizar la forma en la que formatea el código, podemos hacerlo desde “Window” / “Preferences” / “Web” / “JSP Files” / “Editor”.

Conclusión: con esta herramienta podemos ahorrarnos mucho tiempo que podemos utilizar en cosas más productivas.



Fuentes:





miércoles, 4 de diciembre de 2013

Organizar archivos en carpetas según su fecha (consola Linux)








En una entrada anterior vimos cómo Organizar / mover archivos a distintas carpetas según su extensión (Bash Script). Hoy veremos un caso parecido, pero esta vez nos fijaremos en la fecha del archivo. Por ejemplo, queremos ordenar nuestro directorio de fotos por meses. Pues ésto lo podemos hacer de forma sencilla desde la consola de linux.

Lo primero es abrir el terminal y situarnos en el directorio que queremos ordenar y crear los directorios. Para simplificar el ejemplo crearemos solo dos:
mkdir noviembre

mkdir diciembre


A continuación crearemos un archivo auxiliar que nos servirá de margen inferior para mover las fotos. Es decir, moveremos a una carpeta todos los archivos cuya fecha de modificación sea más reciente que la fecha del archivo auxiliar. Por tanto, deberemos empezar por los archivos más recientes (en este caso por el més más reciente: Diciembre, después Noviembre, ...).

Empezaremos por el mes de diciembre, fijando la fecha del archivo auxiliar al 1 de diciembre:
touch -t 201312010000 auxiliar

Y moveremos todos los archivos más recientes que el archivo auxiliar a la carpeta diciembre:
find -maxdepth 1 -type f -newer auxiliar -exec mv {} diciembre \;

Procederemos de forma similar con el mes de noviembre
touch -t 201311010000 auxiliar

find -maxdepth 1 -type f -newer auxiliar -exec mv {} noviembre \;

Y haremos lo mismo con el resto de meses.

Explicación detallada de los comandos:

touch -t 201312010000 auxiliar

Crea un archivo con la fecha y hora de modificación 01/12/2013 00:00

find -maxdepth 1 -type f -newer auxiliar -exec mv {} diciembre \;

Ésta instrucción se puede dividir en dos*
  • “find -maxdepth 1 -type f -newer auxiliar” lo que hace es listar los archivos del directorio actual (pero no los de los subdirectorios) que sean más recientes que la fecha de modificación que el archivo auxiliar.
  • “-exec mv {} diciembre \;” mueve los archivos listados por find a la carpeta diciembre.

Acabamos de ver una forma de organizar nuestros archivos utilizando solamente la consola. Aunque en principio parezca engorroso, resulta mucho más sencillo y cómodo que hacerlo de forma gráfica (utilizando Nemo o Nautilus), si tenemos un gran número de archivos que ordenar. Espero que os sirva.




Fuentes:







lunes, 30 de septiembre de 2013

Terminal linux desde el navegador web













Hace un tiempo estaba buscando una utilidad que me permitiera ejecutar un terminal Linux (también conocido como consola Linux) desde un navegador web. Lo necesitaba ya que quería hacer unas pruebas y no tenía ningún equipo con Linux. El hecho de que se pueda ejecutar desde el navegador es importante, porque no necesitaría instalación y sabemos cualquier equipo (que no sea demasiado antiguo) tiene un navegador instalado.

Mi búsqueda llegó a buen puerto cuando encontré la página:  

http://bellard.org/jslinux/  

Esta pequeña maravilla creada por Fabrice Bellard es capaz de emular un terminal Linux y nos permite jugar con los comandos Linux sin miedo a cargarnos algo.

Para mí, es una herramienta imprescindible a la que de vez en cuando vuelvo. Sí es cierto que tiene ciertas limitaciones con respecto a un terminal real. Por ejemplo, no permite hacer un copy/paste directamente con Ctrl+C y Ctrl+V, sino que hay que pegarlo en un campo de texto que hay en la página y ejecutar “cat < /dev/clipboard > /tmp/myfile”, para que el contenido del portapapeles quede guardado en un archivo temporal (todo ésto está explicado aquí: http://bellard.org/jslinux/faq.html). Tampoco están implementados comandos como “man”. Como veréis, la página es bastante simple, sólo con acceder os aparecerá el prompt.




 












Por todo ello, sólo me queda felicitar al creador por su excelente trabajo. Aun más si tenemos en cuenta que este proyecto ha sido programado en Javascript, un lenguaje que para muchos resulta engorroso y poco amigable.

Espero que le déis una oportunidad y hagáis algunas pruebas. Estoy seguro de que vais a guardarla en los marcadores de vuestro navegador.




Buscar un proceso entre los que se están ejecutando. Comandos ps y grep











A continuación voy a describir cómo buscar un proceso dentro de la lista de procesos que se están ejecutando. Ésto puede ser útil si existen muchos procesos y queremos buscar uno o varios de los que sepamos su nombre o parte de su nombre. Para ello utilizaremos conjuntamente los comandos ps y fgrep. Se haría de la siguiente forma:
ps -ef | grep (cadena)


Con “ps -ef” obtenemos un listado de todos los procesos que se están ejecutando. Luego con grep (cadena) filtramos esa lista y nos quedamos sólo con los que contengan la cadena.

Ejemplo:
ps -ef | grep sh


Ésto nos mostrará todos los procesos que se están ejecutando y que contengan la cadena sh. La salida que daría sería parecida a ésta (las columnas de izquierda a derecha serían: PID, usuario, tiempo, comando):
    1 root       0:00 /bin/sh /sbin/init                                       
   36 root       0:00 [pdflush]                                                
   37 root       0:00 [pdflush]                                                
  155 root       0:00 sh                                                       
  161 root       0:00 grep sh




Podemos ir un paso más allá y quitar algunas entradas del listado que no nos interesen. Por ejemplo, si queremos que se muestren todos los procesos que contengan la cadena “ap” pero que se omitan los que contienen la cadena “grep”. El comando para hacer eso sería así:
ps -ef | grep ap | grep -v grep


Como podemos ver, los comandos ps y grep utilizados en conjunción suponen una herramienta imprescindible y potente en la administración de un equipo o sistema.




Revisar archivos de log mediante Tail (Linux)










Un archivo de log es una especie de registro donde quedan guardados los distintos eventos que ocurren en un equipo. En cada entrada de ese registro se pueden guardan datos como la fecha y hora, usuario, procesos, mensajes de error, warnings, ... Los archivos de log son muy importantes para saber qué está pasando o ha pasado y de este modo depurar y solucionar errores. Éstos archivos suelen contener mucha información y leerlos e interpretarlos puede ser una tarea complicada y tediosa. El comando que veremos a continuación nos facilitará bastante las cosas, y no es otro que "tail".

Veamos las operaciones más frecuentes de éste comando (por defecto mostrará las diez últimas líneas):
  • Muestra las últimas líneas del archivo:
tail archivo.log



  • Muestra las N últimas líneas del archivo (sustituir N por el número que deseemos):
tail -n N archivo.log



  • Muestra el contenido del archivo en tiempo real. Esto es útil cuando el archivo de log está creciendo continuamente. Para pararlo basta con hacer un CTRL+C :
tail -f archivo.log


Puede resultar muy útil también el redirigir la salida hacia otro archivo:


  • Redirecciona las N últimas líneas al archivo depurar.txt :
tail -N  archivo.log > depurar.txt



  • Redirecciona la salida al archivo depurar.txt :
tail -f  archivo.log > depurar.txt


Como vemos, el comando tail nos ayuda a centrarnos solo en la información que nos interesa del archivo de log. Espero que os haya sido de ayuda.

 

 

Fuentes:

http://www.thegeekstuff.com/2010/11/50-linux-commands/




martes, 11 de junio de 2013

JUnit en Eclipse. Pruebas Unitarias en Java (ejemplo sencillo)

Documento sin título










Una prueba unitaria según Wikipedia es “una forma de probar el correcto funcionamiento de un módulo de código. Esto sirve para asegurar que cada uno de los módulos funcione correctamente por separado.”. Para algunos, este tipo de pruebas es una pérdida de tiempo o una inutilidad. Hay que decir que crear las pruebas supone un tiempo adicional al que dedicamos a programar la aplicación en sí. Debemos valorar si merece la pena o no, según las dimensiones y la complejidad de nuestro proyecto. Lo cierto es que si las hacemos, dependiendo del caso, podemos ahorrarnos mucho tiempo, ya que habremos automatizado las pruebas e instantáneamente sabremos si nuestra aplicación cumple con los resultados correctos. Mejoraremos la calidad del software, asegurándonos de que aunque hagamos cambios en nuestro código, cumpliremos con los requisitos esperados. En un futuro podremos modificar, ampliar o eliminar código y las pruebas unitarias seguirán sirviéndonos para realizar las comprobaciones pertinentes.


Para empezar, vamos a ver el ejemplo más simple posible, para que podamos centrarnos en la comprensión de lo que son las pruebas unitarias y de la herramienta para llevarlas a cabo: JUnit. El IDE que utilizaremos será Eclipse.



1. Empezaremos creando la clase que queremos probar. Tendrá el siguiente código:

public class Suma {

    private int num1;

   private int num2;

   public Suma(int n1, int n2) {
       num1 = n1;
       num2 = n2;
   }
   public int sumar() {
       int resultado = num1 + num2;
       return resultado;
   }
}

Como vemos, es una clase muy sencilla que dispone de un método que permite sumar dos números.

2. Lo siguiente es crear la clase que nos servirá para probar la clase Suma. Queremos saber si la suma se hace correctamente en tres casos: sumando dos números positivos, sumando dos números negativos y sumando un número positivo y un número negativo. El código será el siguiente:

public class SumaTest {

   @Test
   public void sumaPositivos() {
      System.out.println("Sumando dos números positivos ...");
       Suma S = new Suma(2, 3);
       assertTrue(S.sumar() == 5);
   }

   @Test
   public void sumaNegativos() {
       System.out.println("Sumando dos números negativos ...");
       Suma S = new Suma(-2, -3);
       assertTrue(S.sumar() == -5);
   }

   @Test
   public void sumaPositivoNegativo() {
       System.out.println("Sumando un número positivo y un número negativo ...");
       Suma S = new Suma(2, -3);
       assertTrue(S.sumar() == -1);
   }
} 


3. Activamos la vista “JUnit” en Eclipse. Para ello hay que pulsar en: “Window”; “Show View”; “Other...”; “Java”; “JUnit”.

4. Y ejecutamos el proyecto como test JUnit, pulsando sobre el proyecto con el botón derecho, luego pulsamos “Run as” y finalmente “JUnit Test”.
Ahora podremos ver los resultados. Si todo hay ido bien, en la vista JUnit nos aparecerá ésto: 



Si ha habido algún fallo nos aparecerá lo siguiente:


Como vemos, en el primer caso el test ha sido completado sin fallos. Sin embargo, en el segundo ejemplo (he modificado el código a conciencia para que falle) se ha encontrado un error en “sumaPositivoNegativo”.

Estamos ante un ejemplo poco práctico, por su simplicidad. Pero lo importante es comprender el concepto de pruebas unitarias y aprender a manejar JUnit dentro de Eclipse. Para obtener más información de cómo hacer los test, recomiento la lectura de la API de JUnit http://junit.sourceforge.net/javadoc/org/junit/package-summary.html .

Si tenéis alguna pregunta, podéis utilizar los comentarios.

 

Fuentes:




viernes, 10 de mayo de 2013

Añadir un salto de línea a un String (Java)











Si quieres mostrar un texto (mediante una variable String o poniendo el texto "a piñón") en tu aplicación Java, y tienes que introducir uno o varios saltos de línea, puedes crear una variable así:
public static String nuevalinea = System.getProperty("line.separator");


Y luego concatenarla con el texto, ejemplo:
public static String nuevalinea = System.getProperty("line.separator");System.out.println(“Ésta es la primera línea.” + nuevalinea + “Ésta es la segunda línea.” + nuevalinea + “Ésta es la tercera línea.”);

La otra forma es utilizando sucesivos System.out.println() , pero me parece que ésta forma es más limpia y legible.

 

 

Fuente:

http://stackoverflow.com/questions/9093765/how-to-add-a-line-break-to-a-string




jueves, 11 de abril de 2013

Diferencia entre comparar con == y con equals() en Java













 Alguien podría preguntarse que cual es la diferencia entre comparar objetos String utilizando el operador igual ( == ) y utilizando el método equals(). La respuesta es sencilla, pero hay que tener claros los conceptos:

  • El operador == realiza la comparación a nivel de objeto. Es decir, determina si ambos objetos son iguales.
  • El método equals() compara los caracteres dentro del objeto String. 

 Veamos un ejemplo:

public static void main(String[] args) {

        String c1 = "Hola";

        String c2 = new String(c1);

        System.out.println(c1 + " == " + c2 + " -> " + (c1 == c2));

        System.out.println(c1 + " equals " + c2 + " -> " + c1.equals(c2));

    }


Si lo ejecutamos veremos que:


  • c1 == c2 devuelve false (ambos objetos no son iguales).
  • c1.equals(c2) devuelve true (sus caracteres son iguales: “Hola”).


Ahora vamos a instanciar un nuevo objeto apartir de c1 (exactamente como hemos hecho con c2). El nuevo objeto lo vamos a comparar con c2:



String c3 = c1;

System.out.println(c1 + " == " + c3 + " -> " + (c1 == c3)); 


Osea, hemos comparado dos objetos iguales y lo que devuelve sería ésto:
    • c1 == c3 devuelve true.


    Espero que haya quedado claro. Como siempre, para cualquier duda podéis utilizar los comentarios.



    Fuente:

    http://www.java-samples.com/showtutorial.php?tutorialid=221




    lunes, 4 de febrero de 2013

    Ejecutar un comando linux dentro de otro comando linux.




    En este caso vamos a ver cómo ejecutar un comando linux dentro de otro comando linux. En concreto, en el ejemplo veremos como copiar todos los archivos resultantes de hacer un búsqueda con el comando grep. Primero veamos sólo la parte de la búsqueda:


    Buscar todos los archivos que contengan una palabra determinada:

    
    grep -r -l "palabra" ruta
    
    


    Ejemplo:
    
    grep -r -l "tomate" /home/usuario/
    
    


    Copiar todos los archivos que contengan una palabra determinada:

    Aquí es cuando vamos a embeber (osea, incrustar o insertar) el comando grep dentro del comando cp, es decir vamos a ejecutar la salida del comando grep como parte del comando cp:
    
    cp $(grep -r -l "palabra" ruta1) ruta2
    
    

     
    Ejemplo:
    
    cp $(grep -r -l "tomate") /home/usuario
    
    


    Tomando como ejemplo lo anterior, podemos construir comandos que a su vez contengan internamente otros, lo que da lugar a crear operaciones complejas a partir de comandos sencillos.




    Felinfo: Java, Linux, Virtualización. Open Source.  ©Template Blogger Green by Dicas Blogger .

    TOPO