luauf.com » Java

Descompilar bytecodes de Java desde Eclipse

Luciano — Thu, 14 May 2009 09:00:31 +0000

JD-Core es una librería libre que reconstruye el código fuente de Java de uno o más bytecodes .class.

Hace mucho tiempo habiamos hablado de DJ Java Decompiler, otra opción para los mismos fines. Sin embargo JD-Core posee nuevas características, como anotaciones, generics o tipos “enum”, etc. además de ser más moderno.

Como si fuera poco JD-Core viene en dos sabores:

Una aplicación Stand-Alone con GUI propia, JD-GUI, disponible para Windows, Linux y Mac.
O como plugin para Eclipse, JD-Eclipse

Si optamos por la segunda opción, debemos instalar el plugin de la forma clásica:

Menú Help, opciones Software Updates \ Find and install…
Search for new features to install..
Agregamos un nuevo sitio remoto, JD-Eclipse con la URL http://java.decompiler.free.fr/jd-eclipse/update y finalizamos
Luego seleccionamos el plugin JD-Eclipse, aceptamos términos y condiciones, esperamos la descarga y reiniciamos el IDE

Luego, desde una ventana de navegación (navigator) estamos en condiciones de abrir cualquier bytecode .class y verlo como si fuera un fuente normal .java.

Ejemplo sencillo para consumir feeds con Java

Luciano — Sat, 09 May 2009 03:10:49 +0000

Las líneas que escribo en Java son cada vez más esporádicas y eso se nota al momento de empezar, porque cada vez que abro el Eclipse (para trabajar en Java, pues para C lo uso más seguido) es un volver a empezar.
El motivo que me llevó esta vez a escribir algo fue la liberación de Rome 1.0, una librería que se ha convertido hace tiempo en un estándar de facto para consumir y producir feeds.

El ejemplo será básicamente un lector sencillo de feeds. Para empezar el mismo ¿Que necesitamos?

J2SE 1.4 o superior
Rome: RSS/Atom syndication and publishing tools, puedes descargar rome-1.0.jar directamente desde aqui
JDOM 1.0 o superior, que puedes descargar de aquí.

El ejemplo consiste en una clase Consumer con su constructor y un método print. Además, un método main para instanciar a Consumer con una URL (que recibirá como argumento) del feed que deseamos leer.
El código es bastante legible y fácil de digerir. Consiste en crear un feed (SyndFeed) y llenar el objeto a partir de una “entrada de feed” (SyndFeedInput) que completará las propiedades del objeto a partir de la lectura de un XML (XmlReader) que no es otro que el de la URL enviada por argumento.
Finálmente, para leer las entradas del feed creamos una lista de “entradas de feeds” y un iterador sobre la misma para obtener datos como el título, descripción, autor, etc.

import java.net.URL;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import com.sun.syndication.feed.synd.SyndEntry;
import com.sun.syndication.feed.synd.SyndFeed;
import com.sun.syndication.io.SyndFeedInput;
import com.sun.syndication.io.XmlReader;

/**
* Consumer class from RSS/Atom feed type.
*
* @author LuAuF
*/

public class Consumer {

SyndFeed feed;

/**
* Class constructor
*
* @param url: url path to consume
*/
public Consumer(String url) {
super();
try {
URL feedUrl = new URL(url);

SyndFeedInput input = new SyndFeedInput();
feed = input.build(new XmlReader(feedUrl));

} catch (Exception ex) {
ex.printStackTrace();
System.out.println(“ERROR: “+ex.getMessage());
}
}

/**
* print method
* Scroll down the list of entries and displays the feed title, author and description
*/
void print () {

//feeds list
List entradas = new ArrayList();
entradas = feed.getEntries();

//list iterator
Iterator it = entradas.iterator();

while (it.hasNext()) {
SyndEntry entrada = it.next();
System.out.println(“Titulo……: “ + entrada.getTitle() );
System.out.println(“Descripción.: “ + entrada.getDescription() );
System.out.println(“Autor…….: “ + entrada.getAuthor() );
}
}

public static void main(String[] args) {

Consumer feed = new Consumer (args[0]);
feed.print();
}
}

Recuerda, si corres el código desde Eclipse, pasar un argumento (por ejemplo: http://feeds.feedburner.com/luauf) en la solapa “Arguments” de la ventana de “Creación, administración y cofiguración de ejecución” luego de ejecutar “Run…”

Matemáticas en Java

Luciano — Wed, 01 Apr 2009 04:00:08 +0000

Como todo lenguaje, Java también se dedica a las Matemáticas y lo hace a través de la clase java.lang.Math, con la particularidad que todos sus métodos son estáticos.

Además, la clase java.lang.Math tiene algo de historia, ya que mientras antes implementaba por su cuenta todos los métodos, hoy utiliza la clase java.lang.StrictMath para implementarlos. La clase StrictMath utiliza para sus cálculos librerías nativas escritas en C, lo que le asegura mejor perfonmance en varias operaciones.

Ahora, para conocer un poco mejor a la clase veremos algunos ejemplos:

Constantes matemáticas

System.out.println(“pi = “ + Math.PI);
System.out.println(“e = “ + Math.E);

Funciones trigonométricas

double val = 0;
double ang = 45;

double rad = Math.toRadians(ang);

val = Math.cos(rad);
System.out.println(“Coseno de “ + ang + “º = “ + val);

val = Math.sin(rad);
System.out.println(“Seno de “ + ang + “º = “ + val);

val = Math.tan(rad);
System.out.println(“Tangente de “ + ang + “º = “ + val);

val = 0.707;
rad = Math.acos(val);
ang = Math.toDegrees(rad);
System.out.println(“Arco Coseno de “ + val + ” = “ + ang + “º”);

rad = Math.asin(val);
ang = Math.toDegrees(rad);
System.out.println(“Arco Seno de “ + val + ” = “ + ang + “º”);

rad = Math.atan(val);
ang = Math.toDegrees(rad);
System.out.println(“Arco Tangente de “ + val + ” = “ + ang + “º”);

Potenciación, radicación y logaritmos

int val=2;
int exp=6;

System.out.println( val + ” elevado “ + exp + ” = “ + java.lang.Math.pow(val,exp) );

val=64;
System.out.println( “Raiz cuadrada de “ + val + ” = “ + java.lang.Math.sqrt(val) );

val = 256;
System.out.println( “Logaritmo en base 2 de “ + val + ” = “ + java.lang.Math.log10(val)/java.lang.Math.log10(2) );

System.out.println( “Logaritmo natural de “ + java.lang.Math.E + ” = “ + java.lang.Math.log(java.lang.Math.E) + “(¿acaso esperabas otra resultado?)” );

Vía: Le Funes

Manipular las palabras de un texto con Java

Luciano — Sat, 28 Mar 2009 11:00:06 +0000

Puede ser un requerimiento, cuando se trabajan con textos, conocer la cantidad de palabras del mismo (inclusive las palabras). Ejemplo típico de este requerimiento es para contar las palabras que componen un determinado texto.

Hacer eso en Java es juego de niños gracias a la clase StringTokenizer.

En el siguiente ejemplo veremos la clase StringTokenizer recibe en su constructor el texto y luego con los métodos countTokens, hasMoreElements y nextElement conocemos la cantidad de palabras, recorremos la colección de palabras y obtenemos las mismas, respectivamente.

public class WordTokenizer {

public static void main(final String[] args) {
int i;
String frase = “Que piensas hacer mañana”;

StringTokenizer palabras = new StringTokenizer(frase);

System.out.println (“Cantidad de palabras de frase: \”“ + frase + “\” es “ + palabras.countTokens() );
i=0;
while (palabras.hasMoreElements()) {
i++;
System.out.println( i + “-” + palabras.nextElement());
}
}
}

Para sumarle algo de acción al ejemplo, les presento un pequeño ejemplo visto en Java Tips. El siguiente código, basado en lo que aprendimos recién, divide la cadena en palabras (usando StringTokenizer) y luego invierte el orden de la misma utilizando una pila LIFO:

public class StringReverseWord {

public static void main(String[] args) {

String frase = “Y que hacemos hoy”;
Stack pila = new Stack();

StringTokenizer tempStringTokenizer = new StringTokenizer(frase);

while (tempStringTokenizer.hasMoreTokens()) {
pila.push(tempStringTokenizer.nextElement());
}

System.out.println(“Cadena original: “ + frase);
System.out.println(“Cadena invertida: “);

while(!pila.empty()) {
System.out.println(stack.pop());
}
}

}

Vía: LinuxParaTodos

Plugin de Eclipse para chequear el estilos del código

Luciano — Wed, 25 Mar 2009 15:00:12 +0000

Me declaro obsesivo en la prolijidad y la belleza del código así como de los estándares. Incluso, alguna vez traté en este blog el tema de los estilos de código.

Para quienes trabajen en equipo, para quienes deseen códigos uniformes y para quienes deseen dar un paso hacia la estandarización de los fuentes de sus proyectos, no hay nada mejor que dotar a nuestro IDE de algún plugin que se encargue de delatar los errores de estilo del código.

Eclipse Checkstyle Plugin es la solución recomendada para chequear en Eclipse el estilo de tus códigos escritos en Java.

¿Cómo instalarlo?

Como cualquier otro plugin, desde el menú Help \ Software updates \ Find and Install agregas la siguiente URL: http://eclipse-cs.sourceforge.net/update y lo descargas.

¿Cómo configurarlo?

Desde Window \ Preferences \ Checkstyle podremos configurar las opciones del plugin. Por defecto, Checkstyle adopta las convenciones de estilo de Sun para Java. De todas formas se pueden editar y/o agregar (pues tales configuración se almacenan en archivos xml).

¿Cómo activarlo?

El el Package Explorer haz clic con el botón derecho del mouse sobre un proyecto y selecciona “Activate Checkstyle” de la opción Checkstyle del menú contextual.

Se puede hacer lo mismo y editar algunas opciones del plugin (como por ejemplo algunas excepciones) para el proyecto seleccionando las propiedades del proyecto y revisando la sección Checkstyle.

¿Cómo funciona?

Apenas activado el plugin, se encargará de resaltar el código que viola las convenciones así como de generar tantos warnings como violaciones encuentre. Los warnings los puedes ver donde aparecen los mismos warnings o errores de compilación: en la ventana Problems.

También podemos ver las violaciones desde la ventana Checkstyle violations (Window \ Show view\ Other \ Checkstyle\ Checkstyle violations)

Vía: Mundo geek

Instalar la documentación de Java en Ubuntu

Luciano — Sun, 22 Feb 2009 17:04:22 +0000

A días de su lanzamiento recuerdo haber instalado NetBeans 6.5 en mi Ubuntu. Hoy, complementando dicha instalación instalé la documentación de Java, que enriqueció mucho mi trabajo en el IDE.

Veamos detalladamente, en principio, de que se trata instalar la documentación de Java y donde vamos a notar su presencia en NetBeans.

Si no tienes instalada la documentación del JDK de Java verás, al momento que se abre el cuadro de sugerencias con los métodos u objetos de una clase que por encima del cuadro se visualiza otro cuadro con un breve “help” del mismo. Lo que digo se observa en la captura de pantalla de a continuación, pero si prestan atención en el cuadro superior además de la firma de la clase dice en color rojo dice “javadoc not found“.

Para instalar la documentación de Java deberemos hacer un apt-get, que buscará un ZIP que descargaremos antes de la página oficial de Java, y que se encargará de extraer y ubicar los archivos del comprimido en el lugar necesario para que el IDE pueda hacer uso de los mismos.

Por lo tanto, primer paso, descargamos de la página de descargas oficial de Java la documentación (te adjunto un par de screenshots para que no te pierdas):

Terminada la descarga, abriremos una consola y renombraremos el archivo ZIP obtenido, lo moveremos al directorio /tmp y haremos el apt-get. Finalmente podemos eliminar (por consejo del mismo apt-get) el archivo ZIP. Continuando el mismo criterio que en la descarga, adjunto el standard output de mi consola:

$ mv jdk-6u10-docs.zip jdk-6-doc.zip

$ mv jdk-6-doc.zip /tmp/

$ sudo apt-get install sun-java6-doc
[sudo] password for mi_usuario:
Leyendo lista de paquetes… Hecho
Creando árbol de dependencias
Leyendo la información de estado… Hecho
Se instalarán los siguientes paquetes NUEVOS:
sun-java6-doc
0 actualizados, 1 se instalarán, 0 para eliminar y 0 no actualizados.
Necesito descargar 33,9kB de archivos.
Se utilizarán 168kB de espacio de disco adicional después de desempaquetar.
Des:1 http://ar.archive.ubuntu.com hardy-updates/multiverse sun-java6-doc 6-07-3ubuntu2 [33,9kB]
Descargados 33,9kB en 1s (19,5kB/s)
Seleccionando el paquete sun-java6-doc previamente no seleccionado.
(Leyendo la base de datos …
179171 ficheros y directorios instalados actualmente.)
Desempaquetando sun-java6-doc (de …/sun-java6-doc_6-07-3ubuntu2_all.deb) …
Configurando sun-java6-doc (6-07-3ubuntu2) …
/tmp/jdk-6-doc.zip has been unpacked and installed.
You can now delete it, if you wish.

$ rm /tmp/jdk-6-doc.zip

Sin más, ahora podemos abrir el IDE y verificar que la documentación de Java ya se encuentra instalada y en utilización del IDE. Adjunto otra captura de pantalla para que puedas comparar con la primer imagen de esta publicación cuando teniamos que “javadoc not found“.

Vía: eOs’s BLOG

Obtener la IP de un sitio de Internet con Java

Luciano — Wed, 18 Feb 2009 03:00:19 +0000

Mi trabajo me está haciendo olvidar poco a poco que hay vida más allá de QNX, C y MySQL. Por lo tanto, hoy, para salir de contexto en media hora libre antes de descansar volví a abrir la perspectiva de Java de mi Eclipse para probar un pequeño ejemplo.

El ejemplo en cuestión es muy sencillo, pero no descarto que a alguien le pueda servir. En resumen, lo que hace es, dado un sitio de Internet (pasado como argumento) nos devuelve la dirección IP del host. Como verán, nada de otro mundo (de hecho el mismo ping se encarga de hacer lo mismo antes del envío de paquetes) de todas formas a mi me sirvió para ejecutar el Eclipse y para correr un proceso desarrollado en Java luego de bastante tiempo.

¿Que necesitaremos? Simplemente el objeto InetAddress de la librería java.net.

Vamos al ejemplo:

package miscelaneos;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class Web {

public static void main(String[] args) {

String webpage = args[0];
try {
InetAddress dirIp = InetAddress.getByName(webpage);
System.out.println( dirIp.getHostName() + “[" + dirIp.getHostAddress() + "]“);
} catch (UnknownHostException e) {
System.out.println(“No se puedo encontrar “ + webpage);
}
}
}

Luego, para ejecutarlo, desde una consola probamos:

~/workspace/Ejemplos $ java miscelaneos.Web google.com
google.com[209.85.171.100]

Tener en cuenta que en mi caso, la clase de ejemplo se llama Web y pertenece al paquete miscelaneos del proyecto Ejemplos.

Vía: Seraphinux

ls (list directory) recursivo en Java

Luciano — Mon, 05 Jan 2009 03:00:14 +0000

Motivado por las publicación Listar un directorio y Listar un directorio de forma recursiva (siempre en Java) de Linea de Codigo, volví a abrir mi IDE para escribir algo de Java y refrescar la memoria un poco.

El resultado fue una pequeña aplicación que no incorpora mucho más que las publicaciones originales, pero que me ha servido para renovar un poco el código de Java que circula perdido por mi cabeza, conocer algo más de la clase File, algo de la clase Date y el ingreso y visualización por consola.

A continuación veremos una descripción de la pequeña aplicación y el código de la misma con algún que otro comentario pertinente.

package directorios;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
*
* @author luciano
*/
public class Main {

/**
* List a directory
* @param f Directory path
*/
public static void lsDirectory ( File dir ) {

File[] archivos = dir.listFiles();
for ( int i=0 ; ilength ; i++ ) {
System.out.print( i +“) “ + archivos[i].getName() + “t” );
if ( archivos[i].isDirectory() ) {
lsDirectory( archivos[i] );
}
String date = new SimpleDateFormat(“dd/MM/yyyy HH:mm:ss”).format(new Date ( archivos[i].lastModified() ));
System.out.println(date);
}
}

/**
* main method
* @param args argumentos de línea de comandos
*/
public static void main(String[] args) {
String path = null;
try {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
System.out.print(“Ingrese directorio:”);
path = in.readLine();
} catch (IOException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}

File dir = new File(path);
if (!dir.exists()) {
System.out.println(“Directorio no existe”);
} else {
lsDirectory(dir);
}
}
}

Leer variables de entorno en Java

Luciano — Tue, 28 Oct 2008 02:16:09 +0000

Para los conocedores de C, la función getenv de la stdlib es una función de mucha utilidad para obtener información acerca del entorno donde se ejecute el proceso y/o aplicación. getenv, es una función que devuelve el valor de una determinada variable de entorno pasando el nombre de la misma como parámetro.

En Java, la clase System dispone de un método getenv, idéntico al conocido en C. Mediante este método se puede acceder a variables de entorno del sistema.

Sin embargo, el método getenv es obsoleto y probablemente el compilador nos muestre algún warning al momento de compilar. Por tal motivo, más de una vez debemos utilizar el método getProperty para “lograr el mismo efecto”.

La razón por la cual getenv es obsoleto se debe a que el concepto de “variable de entorno” no es portable. Es decir, no existe ninguna garantía que los Sistemas Operativos soporten las mismas variables de entorno.

A continuación, un breve ejemplo de lo hablado (ten en cuenta lo que dije acerca de las variables de entorno leídas con getenv):




class MyComputerInfo {
    public static void main(String args[]) {

       System.out.println("PC name..........: " + pcName());

       System.out.println("User name........: " + userName());

       System.out.println("Processor........: " + procesadorInfo());

       System.out.println("Operating System.: " + osInfo());

       System.out.println("JDK version......: " + jdkVersion());

    }
    public static String pcName() {

       return System.getenv("COMPUTERNAME");

    }

   

    public static String userName() {

       return System.getProperty("user.name");

    }

       

    public static String procesadorInfo() {

       return System.getenv("PROCESSOR_IDENTIFIER");

    }

   

    public static String osInfo() {

         return System.getProperty("os.name");

    }

   

    public static String jdkVersion() {

         return System.getProperty("java.version");      

    }

   

}

Vía: El blog de Casidiablo

Una maquina virtual de Java implementada en Java

Luciano — Wed, 17 Sep 2008 03:24:15 +0000

Maxine, es un curioso desarrollo que implementa la máquina virtual de Java en Java. Maxine fue desarrollada por Sun Microsystems y distribuida bajo licencia GPL, pero lo más llamativo es que está escrita en Java. Maxine se encuentra disponible en java.net

A los fines prácticos, no tiene mucho sentido una máquina virtual de Java que corra sobre Java, pero en realidad el proyecto tiene como fin, más que nada, su uso docente. El código de Maxine, dado que está escrito en Java, es mucho más fácil de entender y de manipular que la máquina HotSpot (la conocida máquina ritual de Java producida por Sun para escritorios y servidores)

La máquina virtual es casi cinco veces más lenta que HotSpot.

Según opnion de los lectores de javaHispano, ya surgen preguntas como “¿Qué tal correra Maxine en Maxine?”

Es necesario aclarar, que Maxine está en estado alfa y presenta “severas” limitaciones, por lo tanto aún no hay que pedirle nada.

Vía: javaHispano