Cannot find daemon loader org/apache/commons/daemon/support/DaemonLoader
Service exit with a return value of 1

El principal problema es que JSVC no puede “ver” el jar de Commons Daemon (por ejemplo commons-daemon.jar). El motivo de esto puede ser alguna de las siguientes:

• El usuario con el que estamos ejecutando el servicio no tiene permisos de lectura sobre la librería
• El classpath enviado a JSVC es incorrecto

Si el problema es de permisos con un simple chmod lo solucionaremos. Sino es este el caso hay que revisar el comando que se está ejecutando (prestar atención al parámetro cp pasado a jsvc). Por ejemplo:

jsvc -home $JAVA_HOME -errfile $ARCH_ERROR -pidfile $ARCH_PID -procname $NOMBRE_SERVICIO -cp $CLASSPATH $DAEMON_CLASS

Más Info

• http://commons.apache.org/daemon/jsvc.html
• http://mail-archives.apache.org/mod_mbox//tomcat-users/200609.mbox/<20060923102535.20678.qmail@web52906.mail.yahoo.com>
• http://mail-archives.apache.org/mod_mbox/commons-user/200612.mbox/<37185F81-4FF4-42B8-B80E-1DCD97792ADA@mac.com>

<?php
//...
       $array_php = array(23, 24, 33, 55, 77);
//...
?>

<script type="text/javascript">
       var array_js = new Array();
       <?php
              for($i = 0; $i<count($array_php); $i++){
                     echo 'array_js['. $i .'] = '. $array_php($i) .';\n';
              }
       ?>
</script>

generando un código similar a este:

<script type="text/javascript">
       var array_js = new Array();
       array_js[0] = 23;
       array_js[1] = 24;
       array_js[2] = 33;
       array_js[3] = 55;
       array_js[4] = 7;
</script>

Si nuestro array de PHP tiene una secuencia de indices diferente a la por defecto (de 0 a n-1) deberemos hacer algunas modificaciones:

<?php
//...
       $array_php = array(5=>23, 24, 13=>33, 74=>55, 77);
//...
?>

<script type="text/javascript">
       var array_js = new Array();
       <?php
              foreach($array_php as $indice=>$valor){
                     echo "array_js[$indice] = $valor;\n";
              }
       ?>
</script>

resultando:

<script type="text/javascript">
       var array_js = new Array();
       array_js[5] = 23;
       array_js[6] = 24;
       array_js[13] = 33;
       array_js[74] = 55;
       array_js[75] = 7;
</script>

Espero sirva.
Saludos.

Mas Info

• Assign PHP Array to Javascript Array

Logs en la barra de depuración

Para resolver el problema tenemos que cambiar las llamadas, por ejemplo si tenemos:

class detalleAction extends sfAction
{
	public function execute($request)
	{
		sfLoader::loadHelpers('NombreHelper');
		
		//...
	}
}

a la siguiente forma:

class detalleAction extends sfAction
{
	public function execute($request)
	{
		sfContext::getInstance()->getConfiguration()
				->loadHelpers('NombreHelper');
		
		//...
	}
}

Espero les sirva.
Saludos

class detalleAction extends sfAction
{
	public function execute($request)
	{
		sfContext::getInstance()->getConfiguration()
				->loadHelpers('NombreHelper');
		
		//...
	}
}

Más Info

• sfApplicationConfiguration Class
• loadhelpers Method

ORA-12560: TNS:error del adaptador de protocolo

o

ORA-12560: TNS:protocol adapter error

Generalmente esto ocurre cuando el cliente no sabe como se llama la instancia que corre en nuestro equipo. Para solucionar este problema tenemos que asignar a la variable de entorno ORACLE_SID el nombre de nuestro servicio.

Por ejemplo en Windows abrimos el diálogo de las variables de entorno del sistema (click derecho en “Mi PC”, click en propiedades, pestaña “Opciones Avanzadas”, botón “Variables de Entorno”), hacemos click en el botón “Nueva” de las variables de entorno del usuario y colocamos en nombre “ORACLE_SID” y en valor el nombre de nuestra instancia (“XE” en mi caso), y finalmente “Aceptar”, “Aceptar”, …. Luego iniciamos nuevamente el cliente

Agregando la variable de entorno

Más info

http://www.cryer.co.uk/brian/oracle/ORA12560.htm

NUXEO_PATH/server/default/deploy/jboss-web.deployer/server.xml

La linea donde se define el conector al servicio (donde address=”${jboss.bind.address}”) modificamos el valor de port y reiniciamos el servicio.

Lugar donde hay que indicar el puerto

Mas Info: [JBoss 4] How to change port 8080 in JBoss?

Saludos

El orden en que los parámetros son pasados al servidor WMS dependen del CRS que se este utilizando, siendo los más comunes:

CRS:84

El BBOX se organiza de la siguiente forma  Xmin , Ymin , Xmax , Ymax

Por lo que si queremos referirnos a toda la Tierra tenemos que pedir:

BBOX=-180,-90,180,90

EPSG:4326

El BBOX se organiza de la siguiente forma  Ymin , Xmin , Ymax , Xmax

Por lo que si queremos referirnos a toda la Tierra tenemos que pedir:

BBOX=-90,-180,90,180

Saludos

Para poder indicarle a NB donde se encuentra la Javadoc a cargar tenemos que ir al menú Tools->Java Platforms:

Tools->Java Platforms

Luego, dentro del diálogo “Java Platform Manager” elegimos la versión de JDK que utilizamos (si tubieramos varios configurados), vamos a la pestaña “Javadoc” y agregamos la ruta al archivo por medio del selector de archivos que aparece al hacer click en “Add ZIP/Folder…”

Diálogo Java Platform Manager

Cerramos el dialogo haciendo click en “Close”

Finalmente probamos que se puede visualizar la Javadoc correctamente

Comprobando Javadoc

Saludos

StrictMath utiliza librerías nativas (escritas en C) para realizar sus cálculos, asegurando entre otras cosas una mejor performance con números flotantes y repetibilidad de los resultados (si se llama un método con los mismos parámetros obtenemos exactamente el mismo resultado, bit a bit). Concretamente hace uso de la librería fdlibm (Freely Distributable Math Library) version 5.3 que es parte del proyecto netlib.

Constantes Matemáticas

Math tiene una referencia a las dos constantes más utilizadas en matemática con una precisión de 15 decimales (suficiente para la mayoría de los mortales). Si ejecutamos:

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

veremos:

e = 2.718281828459045
pi = 3.141592653589793

Conversiones Grados a Radianes, y viseversa

Tenemos dos métodos que realizan la tarea por nosotros:

double angGrados = 45; //grados

double angRadianes = Math.toRadians(angGrados);
System.out.println("Deg a Rad: " + angGrados + "º = " + angRadianes + " rad");

angGrados = Math.toDegrees(angRadianes);
System.out.println("Rad a Deg: " + angRadianes + " rad = " + angGrados + "º");

obteniendo al ejecutar:

Deg a Rad: 45.0º = 0.7853981633974483 rad
Rad a Deg: 0.7853981633974483 rad = 45.0º

Funciones Trigonométricas

Las funciones trigonométricas aceptan y devuelven los ángulos en radianes por lo que siempre hay que convertir desde/hacia grados.

Por ejemplo si ejecutamos:

double valor = 0;

double angulo = 45; //grados
double anguloRadianes = Math.toRadians(angulo);

valor = Math.cos(anguloRadianes);
System.out.println("Coseno de " + angulo + "º = " + valor);

valor = Math.sin(anguloRadianes);
System.out.println("Seno de " + angulo + "º = " + valor);

valor = Math.tan(anguloRadianes);
System.out.println("Tangente de " + angulo + "º = " + valor);

valor = 0.707;

anguloRadianes = Math.acos(valor);
angulo = Math.toDegrees(anguloRadianes);
System.out.println("Arco Coseno de " + valor + " = " + angulo + "º");

anguloRadianes = Math.asin(valor);
angulo = Math.toDegrees(anguloRadianes);
System.out.println("Arco Seno de " + valor + " = " + angulo + "º");

anguloRadianes = Math.atan(valor);
angulo = Math.toDegrees(anguloRadianes);
System.out.println("Arco Tangente de " + valor + " = " + angulo + "º");

tendremos un resultado similar al siguiente:

Coseno de 45.0º = 0.7071067811865476
Seno de 45.0º = 0.7071067811865475
Tangente de 45.0º = 0.9999999999999999
Arco Coseno de 0.707 = 45.008651662838º
Arco Seno de 0.707 = 44.991348337162016º
Arco Tangente de 0.707 = 35.2603107365587º

Funciones Hiperbólicas

Las funciones hiperbólicas están disponibles a partir de la versión 1.5 Aún no existe implementaciones para las funciones inversas (acosh, asinh y atanh)

Del siguiente ejemplo:

double valor = 0;
double x = 1.0;

valor = Math.cosh(x);
System.out.println("Coseno Hiperbolico de " + x + " = " + valor);

valor = Math.sinh(x);
System.out.println("Seno Hiperbolico de " + x + " = " + valor);

valor = Math.tanh(x);
System.out.println("Tangente Hiperbolica de " + x + " = " + valor);

obtenemos:

Coseno Hiperbolico de 1.0 = 1.543080634815244
Seno Hiperbolico de 1.0 = 1.1752011936438014
Tangente Hiperbolica de 1.0 = 0.7615941559557649

Paso de coordenadas rectangulares a polares

Para resolver la conversión de un sistema a otro, se pueden utilizar las formulas:

pero hay que hacer varios cálculos intermedios, por lo que la función atan2 y hypot (disponible desde la versión 1.5) realizan el mismo proceso pero de una forma más óptima:

double x = 4.0;
double y = 3.0;

double r = Math.hypot(x, y);
double aRad = Math.atan2(y, x);
double a = Math.toDegrees(aRad);

System.out.println("Para x = " + x + "   y = " + y);
System.out.println("r = " + r);
System.out.println("a = " + a + "º");

obteniendo:

Para x = 4.0 y = 3.0
r = 5.0
a = 36.86989764584402º

Más Info

• java.lang.Math
• java.lang.StrictMath

En el siguiente post veremos el resto de las funciones que la clase Math nos brinda.

Hasta entonces

• win32com.dll
• comm.jar
• javax.comm.properties

 
Si queremos ejecutar alguna aplicación que haga uso del puerto serie o el paralelo debemos realizar la instalación en el JRE (cuyo path es parecido a “C:\Archivos de programa\Java\jre6\” o “C:\Archivos de programa\Java\jre1.6.0_03″), para ello tenemos que colocar los archivos en:

• win32com.dll
  • PATH_JRE\bin\
• comm.jar
  • PATH_JRE\lib\ext\
• javax.comm.properties
  • PATH_JRE\lib\

Si queremos desarrollar alguna aplicación que haga uso del puerto serie o el paralelo debemos realizar la instalación en el JDK (cuyo path parecido a “C:\Archivos de programa\Java\jdk1.6.0_12″), para ello tenemos que colocar los archivos en:

• win32com.dll
  • PATH_JDK\bin\
  • PATH_JDK\jre\bin\
  • C:\WINDOWS\system32\
• comm.jar
  • PATH_JDK\lib\
  • PATH_JDK\jre\lib\ext\
• javax.comm.properties
  • PATH_JDK\lib\
  • PATH_JDK\jre\lib\

En ambos casos vamos a utilizar la clase ImageIcon para recuperar la imagen. Luego de obtener la imagen, esta clase nos permitirá utilizarla tanto para íconos, fondo de contenedores, etc.

Imágen externa al Jar

Este es el caso que se produce cuando la imagen se encuentra en alguna carpeta del sistema operativo:

Para cargarla podemos indicarle a ImageIcon tanto el path relativo (desde donde se ejecuta el Jar) como el path absoluto de la imagen.

Se realiza de la siguiente forma (ver que se utiliza getImage()):

Image imagenExterna = new ImageIcon("tierra.jpg").getImage();

Imágen interna al Jar

Este caso ocurre cuando la imagen se encuentra dentro del Jar de la aplicación:

Para cargarla podemos indicarle a ImageIcon el recurso que se quiere utilizar. Para instanciar el recurso debemos indicar el path relativo (desde la clase que quiere cargar la imagen) como el path absoluto de la imagen dentro del Jar (un path absoluto en el jar comienza con /, como por ejemplo “/ar/lefunes/recurso/imagen.png”).

Se realiza de la siguiente forma:

Image imagenInterna = new ImageIcon(
   getClass().getResource("satelite.jpg")
).getImage();

Ejemplo

Un ejemplo de como se pueden utilizar estos conceptos junto con la clase JPanelConFondo que vimos en un post anterior.

Código:

package ar.lefunes.cargarimagenes;

import java.awt.Image;
import javax.swing.ImageIcon;

public class CargaImagenes extends javax.swing.JFrame {
    private JPanelConFondo jPanelConFondo1 = new JPanelConFondo();
    private JPanelConFondo jPanelConFondo2 = new JPanelConFondo();   

    public CargaImagenes() {
        //...
        cargarImagenes();
    }

    private void cargarImagenes() {
        Image imagenInterna = new ImageIcon(
           getClass().getResource("satelite.jpg")).getImage();
        jPanelConFondo1.setImagen(imagenInterna);

        Image imagenExterna = 
            new ImageIcon("tierra.jpg").getImage();
        jPanelConFondo2.setImagen(imagenExterna);
    }

    //...             
}

Al ejecutar el código obtendremos la siguiente pantalla:

tener en cunta que la imagen externa (“tierra.jpg” en este ejemplo) tienen que estar en la misma carpeta del jar, ó en la carpeta raiz del proyecto cuando ejecutamos el proyecto desde NetBeans.

Ejemplo Descargable

Puedes descargar el ejemplo completo desde http://lefunes.googlecode.com/files/CargarImagenes.zip (aprox. 54 KB)

Espero les sirva
Saludos

Para realizar la conversión de números enteros a cadena podemos utilizar el método estático toString de la clase Integer,de la siguiente forma:

int i = 12;
String s = Integer.toString(i);

De String a int

Para realizar la conversión de una cadena a un podemos utilizar el método estático parseInt de la clase Integer,de la siguiente forma:

String s = "38";
int i = Integer.parseInt(s);

Se puede llegar a producir una excepción del tipo NumberFormatException si la cadena pasada contiene basura (espacios en blanco, caracteres, simbolos de puntuación, etc), caso en el cual deberá limpiarse antes de convertirse:

try {
   String s = "38.0";
   int i = Integer.parseInt(s);
} catch (NumberFormatException nfe) {
   System.err.println("Error de conversion de " + b + ": " + nfe.getMessage());
}

En este caso imprimirá por la consola:

Error de conversion: For input string: “38.0″

Espero les sirva
Saludos

Instalación

Ver actualización al final del post

Para instalarlo tenemos que seguir unos simples pasos:

1. Descargar el plugin según la versión del IDE que utilizemos:
   • para Netbeans 6.1: http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=6887
     (10Kb aprox)
   • para Netbeans 6.5: http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=13974
     (30,5Kb aprox)



2. Nos vamos al dialogo de Plugins de NetBeans, mediante el menú “Tools->Plugins”
3. Vamos a la pestaña “Downloaded”



4. Hacemos click en “Add Plugins…” y seleccionamos el archivo descargado



5. Hacemos click en “Install”



6. Seguimos el wizard de instalación



7. Si nos indica que el plugin no está firmado, ignoramos el aviso haciendo click en “Continue”



8. El plugin está instalado. Podemos comprobar esto en la pestaña “Installed”

Utilización

Para utilizar el plugin creamos una clase que implemente java.io.Serializable, si la instalación ha funcionado bien nos aparecerá una advertencia en la barra lateral:

La primera opción que nos muestra, nos permite colocar el valor por defecto para el serialVersionUID:

La segunda opción nos permite agregar el serialVersionUID que genera serialver para la clase:

Saludos

Más Info

• Página del plugin para NetBeans 6.1
• Página del plugin para NetBeans 6.5
• Mišo Hlaváč: Desarrollador del plugin

Actualización al 15 de Marzo de 2009

Ya es posible instalar el plugin desde Tools->Plugins en NetBeans 6.5:

Cargando el plugin desde el dialogo de Plugins de NetBeans 6.5

Actualización al 29 de Enero de 2010

El proyecto ahora está alojado en Kenai, desde donde se pueden bajar todas las versiones:

http://kenai.com/projects/nb-svuid-generator/downloads/directory/nbms

Para generar el serialVersionUID necesitamos tener la versión compilada de la clase, es decir, contar con el .class o con un .jar que lo contenga.

La sintaxis básica del comando es la siguiente:

serialver [-classpath classpath] nombre_clase

Tanto en Linux como en Windows la sintaxis es la misma.

Algunos ejemplos de uso en Linux:

lefunes@px:/algun/dir/$ serialver -classpath ./el_jar.jar ar.lefunes.paquete.LaClase
ar.lefunes.paquete.LaClase:    static final long serialVersionUID = 7531218309096113276L;

lefunes@px:/algun/dir/$ serialver ar.lefunes.paquete.LaClase.class
ar.lefunes.paquete.LaClase:    static final long serialVersionUID = 7531218309096113276L;

de modo similar, en Windows (el directorio bin del JDK debe estar incluido en el classpath para llamar de forma directa serialver.exe):

C:Algundir>serialver.exe -classpath el_jar.jar ar.lefunes.paquete.LaClase
ar.lefunes.paquete.LaClase:    static final long serialVersionUID = 7531218309096113276L;

C:Algundir>serialver.exe ar.lefunes.paquete.LaClase.class
ar.lefunes.paquete.LaClase:    static final long serialVersionUID = 7531218309096113276L;

Código:

import java.awt.Graphics;
import java.awt.Image;
import javax.swing.JPanel;
//...

public class DesktopConFondo extends JDesktopPane {

    private Image imagen;

	//...

    @Override
    public void paint(Graphics g) {
		g.drawImage(imagen, 0, 0, getWidth(), getHeight(),
                         this);

		setOpaque(false);
        super.paint(g);
    }

	//...
}

Como podemos ver en el método paint hemos especificado tres lineas:

• g.drawImage: dibujamos la imagen (guardada en el atributo “imagen”) en toda la extension del panel

• setOpaque(false): le indicamos al panel que no dibuje su fondo por defecto (sino este taparía la imagen)

• super.paint(g): le indicamos al panel que continúe dibujando el resto de los componentes

JDesktopPanel con imagen de fondo

Redimensionado

Una cosa importante a la hora de dibujar la imagen es que lo hacemos desde el pixel [0,0] hasta el pixel [getWidth(), getHeight()], esto indica que cubrirá toda la extensión del panel en ese momento, permitiéndonos que la imagen acompañe una redimension del panel.

Redimensionando MDI

Algunas Variaciones

Una variación puede ser que el panel dibuje la imagen solo si está asignada a la variable “imagen”, en caso contrario (imagen == null) se dibujara el fondo por defecto:

	//...

    @Override
    public void paint(Graphics g) {
        if (imagen != null) {
            g.drawImage(imagen, 0, 0, getWidth(), getHeight(),
                     this);

            setOpaque(false);
        } else {
            setOpaque(true);
        }

        super.paint(g);
    }

	//...

La carga de la imagen la podemos realizar en el constructor:

	//...

    public DesktopConFondo(Image imagenInicial) {
        if (imagenInicial != null) {
            imagen = imagenInicial;
        }
    }

	//...

o que la misma pueda ir variando:

	//...

    public void setImagen(Image nuevaImagen) {
        imagen = nuevaImagen;

        repaint();
    }

	//...

Cambiando la imagen dinámicamente

De este método podemos observar dos cosas:

• repaint(): Lo llamamos explícitamente para que cuando cambiemos la imagen esta se muestre inmediatamente.

• Si el parámetro nuevaImagen es null, veremos el fondo por defecto.

Fondo por defecto (imagen == null)

Código

Este es el código del panel completo:

package ar.lefunes.mdiconimagen;

import java.awt.Graphics;
import java.awt.Image;
import javax.swing.ImageIcon;
import javax.swing.JDesktopPane;

public class DesktopConFondo extends JDesktopPane {

    private Image imagen;

    public DesktopConFondo() {
    }

    public DesktopConFondo(String nombreImagen) {
        if (nombreImagen != null) {
            imagen = new ImageIcon(
                         getClass().getResource(nombreImagen)
                         ).getImage();
        }
    }

    public DesktopConFondo(Image imagenInicial) {
        if (imagenInicial != null) {
            imagen = imagenInicial;
        }
    }

    public void setImagen(String nombreImagen) {
        if (nombreImagen != null) {
            imagen = new ImageIcon(
                         getClass().getResource(nombreImagen)
                         ).getImage();
        } else {

            imagen = null;
        }

        repaint();
    }

    public void setImagen(Image nuevaImagen) {
        imagen = nuevaImagen;

        repaint();
    }

    @Override
    public void paint(Graphics g) {
        if (imagen != null) {
            g.drawImage(imagen, 0, 0, getWidth(), getHeight(),
                     this);
            setOpaque(false);
        } else{
            setOpaque(true);
        }

        super.paint(g);
    }
}

Ejemplo Descargable

Puedes descargar el ejemplo completo desde (aprox. 38,3 KB): http://lefunes.googlecode.com/files/MDI_imagen_fondo.zip

Código:

import java.awt.Graphics;
import java.awt.Image;
import javax.swing.JPanel;
//...

public class JPanelConFondo extends JPanel {

    private Image imagen;

	//...

    @Override
    public void paint(Graphics g) {
		g.drawImage(imagen, 0, 0, getWidth(), getHeight(),
                        this);

		setOpaque(false);
        super.paint(g);
    }

	//...
}

Como podemos ver en el método paint hemos especificado tres lineas:

• g.drawImage: dibujamos la imagen (guardada en el atributo “imagen”) en toda la extension del panel

• setOpaque(false): le indicamos al panel que no dibuje su fondo por defecto (sino este taparía la imagen)

• super.paint(g): le indicamos al panel que continúe dibujando el resto de los componentes

JPanel con una imagen de fondo

Redimensionado

Una cosa importante a la hora de dibujar la imagen es que lo hacemos desde el pixel [0,0] hasta el pixel [getWidth(), getHeight()], esto indica que cubrirá toda la extensión del panel en ese momento, permitiéndonos que la imagen acompañe una redimension del panel.

Efecto del redimencionado del panel en la imagen

Algunas Variaciones

Una variación puede ser que el panel dibuje la imagen solo si está asignada a la variable “imagen”, en caso contrario (imagen == null) se dibujara el fondo por defecto:

	//...

    @Override
    public void paint(Graphics g) {
        if (imagen != null) {
            g.drawImage(imagen, 0, 0, getWidth(), getHeight(), 
                             this);

            setOpaque(false);
        } else {
            setOpaque(true);
        }

        super.paint(g);
    }

	//...

La carga de la imagen la podemos realizar en el constructor:

	//...

    public JPanelConFondo(Image imagenInicial) {
        if (imagenInicial != null) {
            imagen = imagenInicial;
        }
    }

	//...

o que la misma pueda ir variando:

	//...

    public void setImagen(Image nuevaImagen) {
        imagen = nuevaImagen;

        repaint();
    }

	//...

De este método podemos observar dos cosas:

• repaint(): Lo llamamos explícitamente para que cuando cambiemos la imagen esta se muestre inmediatamente.

• Si el parámetro nuevaImagen es null, veremos el fondo por defecto.

El panel no tiene imagen de fondo (imagen == null)

Código

Este es el código del panel completo:

package ar.lefunes.jpanelconfondo;

import java.awt.Graphics;
import java.awt.Image;
import javax.swing.ImageIcon;
import javax.swing.JPanel;

public class JPanelConFondo extends JPanel {

    private Image imagen;

    public JPanelConFondo() {
    }

    public JPanelConFondo(String nombreImagen) {
        if (nombreImagen != null) {
            imagen = new ImageIcon(
                           getClass().getResource(nombreImagen)
                           ).getImage();
        }
    }

    public JPanelConFondo(Image imagenInicial) {
        if (imagenInicial != null) {
            imagen = imagenInicial;
        }
    }

    public void setImagen(String nombreImagen) {
        if (nombreImagen != null) {
            imagen = new ImageIcon(
                   getClass().getResource(nombreImagen)
                   ).getImage();
        } else {
            imagen = null;
        }

        repaint();
    }

    public void setImagen(Image nuevaImagen) {
        imagen = nuevaImagen;

        repaint();
    }

    @Override
    public void paint(Graphics g) {
        if (imagen != null) {
            g.drawImage(imagen, 0, 0, getWidth(), getHeight(),
                              this);

            setOpaque(false);
        } else {
            setOpaque(true);
        }

        super.paint(g);
    }
}

Ejemplo Descargable

Puedes descargar el ejemplo completo desde (aprox. 37,5 KB): http://lefunes.googlecode.com/files/JPanel_imagen_fondo.zip

jFrame.setUndecorated(true);

Por ejemplo:

package ar.lefunes;

import javax.swing.JFrame;
import javax.swing.JLabel;

public class Inicio {

    public static void main(String[] args) {
        JFrame sinBarraTitulo = new JFrame();
        sinBarraTitulo.setUndecorated(true);
        sinBarraTitulo.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        sinBarraTitulo.add(new JLabel("Frame sin Barra de Titulo"));
        sinBarraTitulo.setSize(250, 250);

        sinBarraTitulo.setLocationRelativeTo(null);
        sinBarraTitulo.setVisible(true);
    }
}

Obtendremos un JFrame sin la barra de título:

Ejecutando el ejemplo desde el IDE

Más Info

• Removing the Title Bar of a Frame

Por ejemplo, si hacemos:

LocalStorage storage =
      Application.getInstance(UnaClase.class).getContext().getLocalStorage();
storage.save(objeto, "archivo.xml");

El archivo (en este ejemplo “archivo.xml”) se almacenará en los siguientes sitios:

Windows XP:

C:\Documents and Settings\<NombreUsuario>\<AppData>\<VendorID>\<AppID>\archivo.xml

OS X:

/<Usuarios>/<NombreUsuario>/Library/Application Support/<AppID>/archivo.xml

Unix:

/home/<NombreUsuario>/.<AppID>/archivo.xml

De ahí podemos deducir otro buen motivo para definir bien tanto AppID como VendorID en nuestra aplicación.

NetBeans genera dos archivos de ANT:

• nbproject/build-impl.xml
• build.xml

Podremos verlos desde la pestaña de Archivos del IDE:

En el primero de ellos (build-impl) es donde realmente se implementan todas las tareas y es donde se encuentran definidos los puntos de enganche donde nosotros podremos incorporar tareas. NO es recomendable editar este archivo.

El archivo build.xml es el que se invoca cada vez que hacemos build, clean & build, run, etc. Él simplemente importa todas las tareas definidas en el archivo build-impl:

Aquí es donde podremos (y debemos) sobrescribir las tareas provistas para tal fin. Los puntos de enganche definidos son los siguientes:

• antes de la inicialización de las propiedades del proyecto (-pre-init)
• después de la inicialización de las propiedades del proyecto (-post-init)
• antes de la compilación mediante javac (-pre-compile)
• después de la compilación mediante javac (-post-compile)
• antes de la compilación de un archivo solo mediante javac (-pre-compile-single)
• después de la compilación de un archivo solo mediante javac (-post-compile-single)
• antes de la compilación de los test de JUnit mediante javac (-pre-compile-test)
• después de la compilación de los test de JUnit mediante javac (-post-compile-test)
• antes de la compilación de un archivo de test de JUnit solo mediante javac (-pre-compile-test-single)
• después de la compilación de un archivo de test de JUnit solo mediante javac (-post-compile-test-single)
• antes de construir el Jar (-pre-jar)
• después de construir el jar (-post-jar)
• después de limpiar los archivos generados anteriormente (-post-clean)

Entonces lo que hacemos es simplemente escribir la(s) tarea(s) elegida(s):

<target name="-pre-jar">
       < !—aquí incluimos el codigo -->
 </target>

Por ejemplo, modificaremos el archivo build.xml para mostrar algunos mensajes personalizados:

< ?xml version="1.0" encoding="UTF-8"?>

<project name="testANT" default="default" basedir=".">
    <description>Builds, tests, and runs the project testANT.</description>
    <import file="nbproject/build-impl.xml"/>

    <target name="-pre-compile">
        <echo>Compilando....</echo>
    </target>

    <target name="-post-compile">
        <echo>Fin de la compilacion</echo>
    </target>

    <target name="-pre-jar">
        <echo>Armando el JAR...</echo>
    </target>

    <target name="-post-jar">
        <echo>JAR construido</echo>
    </target>

    <target name="-post-clean">
        <echo>Limpieza de archivos generados anteriormente</echo>
    </target>
</project>

Ahora si realizamos “Clean and Build” obtendremos en la ventana de Output algo como esto:

Adicionalmente podemos sobrescribir cualquiera de las tareas principales de buil-impl. Por ejemplo si queremos mantener una copia del último jar generado antes de borrarlo podríamos modificar la tarea:

<target depends="init" name="-do-clean">
        <delete dir="${build.dir}"/>
        <delete dir="${dist.dir}"/>
</target>

Sobrescribiéndola de la siguiente forma en el archivo build.xml:

<target depends="init" name="-do-clean">
        <delete dir="${build.dir}"/>

        <!-- evita errores si dist.dir no existe -->
        <mkdir dir="${dist.dir}" />
        <copy todir="backup">
            <fileset dir="${dist.dir}" />
        </copy>
        <echo>Guardada copia de dist</echo>
     
        <delete dir="${dist.dir}"/>
</target>

Manteniendo una copia aún después de realizar un “clean”:

De esta forma podemos no solo agregar funcionalidades en los puntos predefinidos (anteriormente listados) sino que podemos llegar a sobrescribir por completo las tareas de ANT.

Se puede descargar el proyecto de ejemplo (aprox. 9.3kB) de: http://lefunes.googlecode.com/files/modificar_ANT_netbeans.zip. En él se incluye el proyecto en NetBeans 6.5 creado para este post.

Espero les sirva
Saludos

Basicamente para que nuestro sistema admita plugins debemos realizar una serie de pasos básicos:

1. Definir la forma en que los plugins serán agregados a nuestra aplicación
2. Crear una interface que los plugins deberán implementar
3. Crear una forma de encontrar y cargar los plugins en tiempo de ejecución
4. Crear los plugins
5. Probar que todo funcione según lo previsto

Veremos con un pequeño ejemplo para entender como llevar a cabo cada uno de estos pasos, donde los plugins de nuestra aplicación simplemente devolveran un mensaje (un String) que la aplicación principal mostrará por pantalla.

0- Creando el proyecto de ejemplo

Crearemos el proyecto principal de ejemplo de nuestra aplicación. Por ahora solo crearemos un proyecto con la calse que contiene el método main.

package ar.lefunes;

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

Proyecto Principal

1- Definir la forma en que los plugins serán agregados a nuestra aplicación

En este paso debemos dejar en claro como queremos que funcione nuestra aplicacion a la hora de cargar y utilizar los plugins. Aqui no programaremos nada, pero es importante identificar exactamente lo que queremos conseguir.

En el caso de nuestro ejemplo, lo que haremos es crear un directorio “plugins” en el directorio local de nuestra aplicación donde agregaremos los plugins (sus .jar), por lo tanto el sistema debe ser capaz de encontrarlos, cargarlos y utilizarlos desde esa ubicación.

2- Crear una interface que los plugins deberán implementar

Definimos una interface que todo plugins que quiera ser incorporado al sistema deberá implementar.

Crearemos un proyecto independiente del principal que contendrá unicamente la interface. Este será incluido tanto en los proyectos de cada plugin como asi también en el proyecto principal.

package ar.lefunes.plugins;

public interface IPluginMensaje {
    String getMensaje();
}

Proyecto de la Interface

Incluimos a este proyecto dentro del proyecto principal:

Incluyendo el proy. de la interface en el proy. principal

3- Crear una forma de encontrar y cargar los plugins en tiempo de ejecución

Para cargar los plugins utilizaremos java.util.ServiceLoader, la cual busca en el classpath todas las implementaciones declaradas de una interface determinada.

Por lo tanto, para que un plugin exponga una implementación de la interface (en nuestro ejemplo IPluginMensaje) se deben cumplir dos condiciones:

• El .jar del plugin debe estar incluido en el classpath para que ServiceLoader lo revise.
• El plugin debe indicarle a ServiceLoader que dentro de él existe una implementación de la interface y donde puede encontrarla.

Para cumplir la primera consideración deberemos buscar todos los .jars que se encuentre dentro del directorio “plugins”, incorporandolos luego al classpath mediante la clase ModificadorClassPath que vimos en un post anterior.

Para que se cumpla la segunda condición ServiceLoader tiene que encontrar un archivo dentro del plugin en la dirección “META-INF/services/” con el nombre calificado de la interface (ar.lefunes.plugins.IPluginMensaje). Dentro del archivo se lista (linea por linea) el nombre calificado de cada una de las clases dentro del plugin que implementan la interface. En el proximo punto veremos como crear este archivo.

Agregamos entonces la clase ar.lefunes.classpath.ModificadorClassPath a nuestro proyecto principal, y creaamos una clase nueva llamada CargadorPlugins:

Clase Cargadora de Plugins

Código comentado de la clase CargadorPlugins:

package ar.lefunes.plugins;

import ar.lefunes.classpath.ModificadorClassPath;
import java.io.File;
import java.io.FilenameFilter;
import java.net.MalformedURLException;
import java.util.Iterator;
import java.util.ServiceLoader;
import java.util.Vector;

public class CargadorPlugins {

    private static final String EXTENSION_JAR = ".jar";
    private static final String DIRECTORIO_PLUGINS = "plugins/";

    /**
     * carga los plugins encontrados al classpath
     * @return true si se cargaron los plugins,
     *         false en caso de existir algun error
     */
    public static boolean cargarPlugins() {
        boolean cargados = true;
        try {
            //obtiene el listado de archivos .jar dentro del directorio
            File[] jars = buscarPlugins();

            if (jars.length > 0) {
                ModificadorClassPath cp = new ModificadorClassPath();

                //a cada jar lo incluye al classpath
                for (File jar : jars) {
                    try {
                        cp.addArchivo(jar);
                    } catch (MalformedURLException ex) {
                        System.err.println("URL incorrecta: " +
                                ex.getMessage());
                    }
                }
            }
        } catch (Exception ex) {
            cargados = false;
            System.err.println(ex.getMessage());
        }
        return cargados;
    }

    /**
     * Busca todos los jars de en el directorio de plugins
     * @return jars del directorio de plugins
     */
    private static File[] buscarPlugins() {
        //crea lista vacia de archivos
        Vector< File > vUrls = new Vector< File >();

        //si existe el directorio "plugins" continua
        File directorioPlugins = new File(DIRECTORIO_PLUGINS);
        if (directorioPlugins.exists() && directorioPlugins.isDirectory()) {

            //obtiene todos los archivos con la extension .jar
            File[] jars = directorioPlugins.listFiles(new FilenameFilter() {

                @Override
                public boolean accept(File dir, String name) {
                    return name.endsWith(EXTENSION_JAR);
                }
            });

            //los agrega a la lista de archivos
            for (File jar : jars) {
                vUrls.add(jar);
            }
        }

        //retorna todos los archivos encontrados
        return vUrls.toArray(new File[0]);
    }

    /**
     * Obtiene todos los plugins IPluginMensaje encontrados en el classpath
     * @return lista de plugins encontrados e instanciados
     */
    public static IPluginMensaje[] getPlugins() {

        //cargamos todas las implementaciones de IPluginMensaje
        //encontradas en el classpath
        ServiceLoader< IPluginMensaje > sl =
                ServiceLoader.load(IPluginMensaje.class);
        sl.reload();

        //crea una lista vacia de plugins IPluginMensaje
        Vector< IPluginMensaje > vAv = new Vector< IPluginMensaje >();

        //cada plugin encontrado es agregado a la lista
        for (Iterator< IPluginMensaje  > it = sl.iterator(); it.hasNext();) {
            try {
                IPluginMensaje pl = it.next();
                vAv.add(pl);
            } catch (Exception ex) {
                System.err.println("Excepcion al obtener plugin: " +
                        ex.getMessage());
            }
        }

        //retorna los plugins encontrados y cargados
        return vAv.toArray(new IPluginMensaje[0]);
    }
}

En este punto ya podemos incorporar la funcionalidad al método main del proyecto:

package ar.lefunes;

package ar.lefunes;

import ar.lefunes.plugins.CargadorPlugins;
import ar.lefunes.plugins.IPluginMensaje;

public class Main {

    public static void main(String[] args) {
        System.out.println("-------------------------------");

        //se cargan los jars del directorio "plugins" al classpath
        boolean cargados = CargadorPlugins.cargarPlugins();

        if (cargados) {
            try {
                //obtiene una instancia de cada plugin IPluginMensaje encontrado
                IPluginMensaje[] avisadores = CargadorPlugins.getPlugins();

                if (avisadores.length > 0) {
                    for (IPluginMensaje a : avisadores) {
                        //por cada plugin muestra la clase y el mensaje que devuelve
                        System.out.println("Plugin: \t" + a.getClass().getCanonicalName());
                        System.out.println("Mensaje:\t" + a.getMensaje());
                        System.out.println();
                    }
                } else {
                    System.out.println("No se Encontraron Plugins");
                }
            } catch (Exception ex) {
                System.err.println("Excepcion: " + ex.getMessage());
                ex.printStackTrace();
            }
        } else {
            System.out.println("Plugins No Cargados");
        }

        System.out.println("-------------------------------");
    }
}

Si en este punto ejecutamos la aplicación obtendremos:

——————————-
No se Encontraron Plugins
——————————-

debido a que aún no hemos instalado ningun plugin en la misma.

4- Crear los plugins

Creamos un proyecto nuevo para nuestro primer plugin para la aplicación y agregamos la dependencia hacie el proyecto de la interface.

Proyecto del Primer Plugin

Creamos la clase PluginNumeroUno que va ha ser la implementacion de la interface:

package ar.lefunes.plugins.impl;

import ar.lefunes.plugins.IPluginMensaje;

public class PluginNumeroUno implements IPluginMensaje {
    public String getMensaje() {
        return "Este es el plugin numero uno !!!";
    }
}

De esta manera, a pesar a que funcionalmente hemos finalizado con el plugin, este no será cargado en la aplicación debido a que le falta el descriptor para la clase ServiceLoader. Para ello creamos un archivo con el nombre de la interface dentro del directorio “META-INF.services”

Agregando Descriptor de Servicio

Donde adentro del mismo colocaremos una sola linea indicando el nombre calificado de la clase que implementa la interface:

Definición del Descriptor de Servicio

5- Probar que todo funcione según lo previsto

Para probar compilamos los tres proyectos y armamos la siguiente estructura de archivos:

Estructura del Archivos del Ejemplo

Al ejecutar, el programa mostrará por la consola:

——————————-
Plugin:         ar.lefunes.plugins.impl.PluginNumeroUno
Mensaje:        Este es el plugin numero uno !!!

——————————-

con lo que podemos observar que cargo correctamente el plugin.

Más de un plugin por JAR

El paso de creación es similar al explicado para un solo plugin: Agregamos la dependencia al proyecto de la interface y creamos las clases que la  implementan:

Proyecto con Dos Plugins

La diferencia radica solamente que dentro del descriptor para ServiceLoader indicaremos las clases, una por linea:

Descriptor de los Dos Plugins

Con lo que obtendremos al incorporar el Jar a la carpeta “plugins” del proyecto principal y ejecutando este último:

——————————-
Plugin:         ar.lefunes.plugins.impl.PluginNumeroUno
Mensaje:        Este es el plugin numero uno !!!

Plugin:         ar.lefunes.plugins.multiple.PluginDos
Mensaje:        Plugin Nº 2

Plugin:         ar.lefunes.plugins.multiple.PluginTres
Mensaje:        Plugin Nº 3

——————————-

Plugin por defecto

Devido a que el propio proyecto principal se encuentra dentro del classpath (y por esto ServiceLoader lo revisará) podemos brindar un plugin que se cargará aún cuando no exista ningun jar en el directorio “plugins”.

Para ello creamos la clase que implementa el servicio y la indicamos con un descriptor dentro del proyecto:

Agregando Plugin por Defecto

Descriptor del Plugin por Defecto

Donde obtendremos en la salida al ejecutar sin ningún plugin en el directorio “plugins”:

——————————-
Plugin:         ar.lefunes.plugins.defecto.PluginDefecto
Mensaje:        PLUGIN POR DEFECTO

——————————-

Recursos

Se puede descargar el proyecto de ejemplo (aprox. 71kB) de: http://lefunes.googlecode.com/files/app_plugins.zip. En él se incluyen tanto los jars para ejecutar el ejemplo directamente como los proyectos en NetBeans 6.5 creados para este post.

Espero les sirva.
Hasta la proxima.

Más Info

• Javadoc ServiceLoader
• Using the ServiceLoader API to build a modular applications
• Java SE 6 ServiceLoader
• Modificando el classpath dinamicamente en tiempo de ejecución

El cargador de clases que la maquina virtual utiliza por defecto es una instancia de una subclase de URLClassLoader (y por ende subclase de ClassLoader también). El funcionamiento básico del URLClassLoader es buscar las clases dentro del listado de URLs que posee registrado. A este listado de URLs es lo que conocemos como classpath.

Dentro del classpath podemos encontrarnos con los siguientes tipos de URLs:

• URL hacia un directorio (ruta terminada en ‘/’): En este caso se incluyen en el classpath todos los archivos .class que se encuentren dentro del directorio
• URL a un JAR (ruta terminada con “.jar”): En este caso se incluyen al classpath todos los archivos .class que se encuentren dentro del archivo
• URL a un JAR (ruta no termina en ‘/’ o “.jar”): Se presume que es un jar por lo que antes de procesarla se le concatena “.jar”. Después se trata igual que el caso anterior.

Por defecto encontramos en el classpath al ejecutar una aplicación solo el JAR o directorio que contiene la clase con el método Main. Para ver esto podemos ejecutar el siguiente código:

	System.out.println("ClassPath:");
	for (URL url : ((URLClassLoader) ClassLoader.getSystemClassLoader()).getURLs()) {
		System.out.println("\t" + url.getFile());
	}

Lo que hacemos en este ejemplo es tomar el cargador de clases del sistema, castearlo a URLClassLoader, obtener el listado de URLs, y a cada URL la mostramos por la consola.

Agregar nuevas rutas estáticas al classpath es simple, Existen dos formas:

• agregar la opción -cp seguido de las librerías que deseamos incluir (separadas por “;”) al ejecutar el comando java:

java -cp unJar.jar;otroJar.jar;unDirectorio/ claseInicial

• otra forma es si vamos a ejecutar un JAR es incluir el nombre de las librerías en el manifiesto del archivo bajo la propiedad “Class-Path”, separando cada clase por espacio:

Class-Path: unJar.jar otroJar.jar unDirectorio/

Pero si lo que queremos es agregar nuevas rutas en tiempo de ejecución (porque solo durante la ejecución del programa podemos determinar que archivos necesitamos cargar) deberemos apelar al cargador de clases, que gracias a la interfase URLClassLoader posee un método addURL. El problema básico que nos encontramos ahora es que es un método declarado como protegido, por lo cual para poder utilizarlo deberemos apelar a reflexión. Por ejemplo:

	URL url = (new File("algunJar.jar")).toURI().toURL();

	Method metodo = URLClassLoader.class.getDeclaredMethod(
		"addURL", new Class[]{URL.class});
	metodo.setAccessible(true);
	metodo.invoke((URLClassLoader) ClassLoader.getSystemClassLoader()
		, new Object[]{url});

Donde básicamente para agregar la ruta al archivo “algunJar.jar” debemos obtener el método addURL con un parámetro del tipo URL y guardando una referencia en la variable “metodo”, lo habilitamos para poder invocarlo, y finalmente lo invocamos en el cargador de clases del sistema usando como parámetro la URL proveniente del archivo a agregar (URL que guardamos en la variable “url” en la primera linea)

Podemos preparar una clase que nos permita agregar facilmente ya sean URLs, archivos (File) o con solo el nombre del archivo:

	package ar.lefunes.classpath;

	import java.io.File;
	import java.lang.reflect.Method;
	import java.net.MalformedURLException;
	import java.net.URL;
	import java.net.URLClassLoader;

	public class ModificadorClassPath {

	    private static final String METODO_ADD_URL = "addURL";
	    private static final Class[] PARAMETRO_METODO = new Class[]{URL.class};
	    private final URLClassLoader loader;
	    private final Method metodoAdd;

	    public ModificadorClassPath() throws NoSuchMethodException {
	        loader = (URLClassLoader) ClassLoader.getSystemClassLoader();
	        metodoAdd = URLClassLoader.class.getDeclaredMethod(
                                           METODO_ADD_URL, PARAMETRO_METODO);
	        metodoAdd.setAccessible(true);
	    }

	    public URL[] getURLs() {
	        return loader.getURLs();
	    }

	    public void addURL(URL url) {
	        if (url != null) {
	            try {
	                metodoAdd.invoke(loader, new Object[]{url});
	            } catch (Exception ex) {
	                System.err.println("Excepcion al guardar URL: " + 
                                                               ex.getLocalizedMessage());
	            }
	        }
	    }

	    public void addURLs(URL[] urls) {
	        if (urls != null) {
	            for (URL url : urls) {
	                addURL(url);
	            }
	        }
	    }

	    public void addArchivo(File archivo) throws MalformedURLException {
	        if (archivo != null) {
	            addURL(archivo.toURI().toURL());
	        }
	    }

	    public void addArchivo(String nombreArchivo) throws MalformedURLException {
	        addArchivo(new File(nombreArchivo));
	    }
	}

Además con el método getURLs obtendremos el classpath actual de la aplicación.

Un ejemplo de uso sería:

	ModificadorClassPath mc = new ModificadorClassPath();

	mc.addArchivo("algunJar.jar");

	File unArchivo = new File("otroJar.jar");
	mc.addArchivo(unArchivo);

	String dir = "elPath" + File.separator + "unDirectorio" + File.separator;
	File unDirectorio = new File(dir);
	mc.addArchivo(unDirectorio);

	System.out.println("ClassPath:");
	for (URL url : mc.getURLs()) {
		System.out.println("\t" + url.getFile());
	}

Hasta la próxima
Saludos

Más Info

• Javadoc URLClassLoader
• Javadoc ClassLoader
• Funcionamiento de CLASSPATH, package y jar << chuidiang
• Java – Adding new Classpath at Runtime << Jim’s Life

Lo que podemos realizar es simular un comportamiento parecido conociendo las optimizaciones llevadas a cabo por el compilador al procesar nuestro codigo fuente.

Como hemos visto anteriormente, cada vez que el compilador tenga la posibilidad de inferir que algo va a ser invariante a lo largo de la ejecución del programa, realizara una optimización que no afecten los resultados del mismo. Por ejemplo si encuentra:

String estadoInicial = "Estado Inicial: " + 25;
int tiempoEspera = 15 * 60 * 1000; //15 minutos en milisegundos

al realizar la compilación quedará:

String estadoInicial = "Estado Inicial: 25";
int tiempoEspera = 900000;

De esta misma forma si puede resolver la condición de un if, puede decidir si la condición es true que bloque se debe ejecutar siempre:

System.out.println("Antes");
if(true){
	System.out.println("Ejecutando...");
}
System.out.println("Despues");

compilando:

System.out.println("Antes");
System.out.println("Ejecutando...");
System.out.println("Despues");

Lo interesante se produce en el caso contrario, si encuentra un false en la condición, el bloque no es incluido en los .class generados:

System.out.println("Antes");
if(false){
	System.out.println("Ejecutando...");
}
System.out.println("Despues");

dejarando:

System.out.println("Antes");
System.out.println("Despues");

Para que puede servirnos esto?

Entre otras cosas para realizar debug de la aplicación permitiendo que, según como se encuentre una costante, se incluyan ciertas sentencias o no.

Veamos un ejemplo donde se utilizan dos tipos de constantes, una booleana y otra entera:

class A{
	public static final boolean EN_DEBUG = false;
	public static final int UN_NIVEL = 25;
	//...
	public void unMetodo(){
		//...
		if(UN_NIVEL < 100) hacerAlgo1();
		if(UN_NIVEL > 75) hacerAlgo2();
		//...
	}
}

class B{
	public void unMetodo(){
		//...
		int res = otroMetodo1();
		if(A.EN_DEBUG){
			System.out.println("El resultado de otroMetodo1 es: " + res);
		}
		otroMetodo2(res);
		//...
	}
}

Al actuar el compilador nos quedará:

class A{
	public static final boolean EN_DEBUG = false;
	public static final int UN_NIVEL = 25;
	//...
	public void unMetodo(){
		//...
		hacerAlgo1();
		//...
	}
}

class B{
	public void unMetodo(){
		//...
		int res = otroMetodo1();
		otroMetodo2(res);
		//...
	}
}

permitiendonos ejecutar determinado código, que cuando la aplicación se encuentre en produccion no lo ejecutará pero tampoco tendrá problemas de rendimiento, ya que ese codigo directamente no es incluido en la solución final.

Si buscamos que NetBeans oculte nuestro código al igual que realiza con el código autogenerado debemos agregar solamente dos comentarios, que incluyen un tag de apertura y uno de cierre (al estilo XML) al inicio y fin respectivamente de la porción de código a ocultar:

comentario inicio: //<editor-fold defaultstate=”collapsed” desc=”Alguna Descripción”>

comentario fin: //</editor-fold>

en donde incluimos:

• desc = Descripción que se mostrará al ocultar el texto
• defaultstate = si es igual a “collpsed”, cuando NetBeans abra el archivo esta sección se encontrará cerrada por defecto

por ejemplo si tenemos el siguiente código al que queremos realizarle code folding:

public static void main(final String args[]) {
    java.awt.EventQueue.invokeLater(new Runnable() {

        @Override
        public void run() {
            Test011_ConfExterno t = new Test011_ConfExterno();
            t.setLocationRelativeTo(null);
            t.setVisible(true);
        }
    });
}

Simplemente agregamos los comentarios y listo:

// <editorfold defaultstate="collapsed" desc="Metodo Main">
public static void main(final String args[]) {
    java.awt.EventQueue.invokeLater(new Runnable() {

        @Override
        public void run() {
            Test011_ConfExterno t = new Test011_ConfExterno();
            t.setLocationRelativeTo(null);
            t.setVisible(true);
        }
    });
}
// </editorfold>

http://mendozajug.com.ar/portal/index.php?option=com_content&task=view&id=64&Itemid=2

Desde ya muy agradecido a los owners del Mendoza JUG: Sebastian Arbona,  Andres Ceccoli y Javier Quiroga, y felicitaciones por la labor que están realizando para la comunidad de estos lados del mundo.

Actualizado:
He dejado una copia del articulo en tutorial en el NetBeans Community Documentation (NCD): http://wiki.netbeans.org/ConociendoNetbeansPlatformIntroduccion

Para rotar se pasa a una instancia de AffineTransform a través de rotate(), pasándole el ángulo en radianes y el centro de rotación. Luego esta instancia se asigna al objeto Graphics (debemos asignársela a Graphics2D en realidad)

AffineTransform at = new AffineTransform();
at.rotate(r, 100, 100); //se asigna el angulo y centro de rotacion
((Graphics2D) g).setTransform(at);

Ejemplo

Por ejemplo creamos un panel que muestra un cuadrado girado una determinada cantidad de grados llamada JPanelImagenGiratoria.java:

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;

public class JPanelImagenGiratoria extends javax.swing.JPanel {

    private int grados = 0;

    public int getGrados() {
        return grados;
    }

    public void setGrados(int grados) {
        this.grados = grados;
        repaint();
    }

    @Override
    public void paint(Graphics g) {
        super.paint(g); //se borra el contenido anterior

        double r = Math.toRadians(grados); //se convierte a radianes lo grados

        AffineTransform at = new AffineTransform();
        at.rotate(r, 100, 100); //se asigna el angulo y centro de rotacion
        ((Graphics2D) g).setTransform(at);

        //se dibuja
        g.setColor(Color.BLUE);
        g.drawRect(50, 50, 100, 100);

    }
}

y un frame para realizar la prueba del panel llamada PruebaPanel.java. Prestar atención al observador de cambios del JSlider agregado mediante addChangeListener():

import java.awt.BorderLayout;
import javax.swing.JFrame;
import javax.swing.JSlider;

public class PruebaPanel{

    public static void main(String[] args) {
        final JFrame jf = new JFrame("Prueba Imagen Giratoria");
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.setSize(200, 250);

        final JPanelImagenGiratoria ig = new JPanelImagenGiratoria();

        final JSlider js = new JSlider(0, 360);
        js.addChangeListener(new javax.swing.event.ChangeListener() {

            public void stateChanged(javax.swing.event.ChangeEvent evt) {
                ig.setGrados(js.getValue());
            }
        });
        js.setValue(0);

        jf.setLayout(new BorderLayout());
        jf.add(ig, BorderLayout.CENTER);
        jf.add(js, BorderLayout.SOUTH);

        jf.setLocationRelativeTo(null);
        jf.setVisible(true);
    }
}

Imágenes:

Más Info

• Javadoc java.awt.geom.AffineTransform
  
• http://chuidiang.blogspot.com/2006/02/un-botn-girado.html

{PATH INSTALACION NB}/etc/netbeans.conf

y agregamos a las opciones de inicio del IDE, al final del valor del parametro netbeans_default_options la clase:

netbeans_default_options=" . . . --laf javax.swing.plaf.metal.MetalLookAndFeel"

y si tenemos que agregar un L&F desde un jar, por ejemplo de la librería NimROD, lo siguiente:

netbeans_default_options=" . . . --cp:p bin\nimrodlf-1.0c.jar --laf com.nilo.plaf.nimrod.NimRODLookAndFeel"

Acá les dejo un screenshot de NetBeans 6.1 usando NimROD como L&F:

Más Info

• NimRod LookAndFeel

• Can I run NetBeans with a custom look and feel?

En este veremos como interpretar desde Java un array de bytes (que puede provenir de un archivo, una comunicación de red, etc.) como una sucesión de datos, ya sea bytes, enteros, flotantes, etc. Para ello realizaremos las conversiones teniendo en cuenta el endianess con el cual vienen organizados los datos.

Como leer byte por byte un número

Primero que nada veremos como podemos leer cada byte de un dato. Deberemos tener en cuenta las posiciones en bits de cada byte:

Entonces si queremos leer por ejemplo el byte 2 de un entero debemos movernos al bit 16 y tomar el byte que necesitamos desde ese punto
Una forma de realizar esto en Java sería desplazando a la derecha el valor que queremos leer tantos bits como sea necesario de forma que quede ubicado en el byte inicial, luego eliminar todo lo que este fuera del primer byte con una mascara, y finalmente convertirlo a byte.
Gráficamente hacemos esto:

En resumen:

byte d = (byte)((a >> 16) & 0xFF) ;

En el caso inverso, que queramos por ejemplo almacenar un byte en el byte 1 de un entero debemos movernos al bit 8 y a partir de ahí almacenar nuestro byte.
En Java lo que hacemos es convertir el byte al tipo del objetivo (en el ejemplo es un entero), aplicar una mascara de byte para eliminar la basura generada y finalmente desplazarlo a la izquierda los bits necesarios.
Gráficamente hacemos esto:

En resumen:

int d = (a & 0xFF) < < 8;

Si deseamos combinar dos números usamos el operador OR por bits (|) entre ambos, de la forma:

Convirtiendo short

Un short ocupa 2 bytes en Java por lo que tendremos que tener en cuenta el endianess del dato al momento de convertir desde/hacia un array de bytes.

Short a byte[]

Para obtener cada uno de los bytes realizamos:

Para crear un array de bytes en big-endian, debemos almacenarlos en el orden en que los obtuvimos:

byte[] sbe = new byte[]{ b1 ,  b0 };

y para crear un array de bytes en little-endian, debemos almacenarlos en el orden inverso en que los obtuvimos:

byte[] sbe = new byte[]{ b0 ,  b1 };

En resumen, todos los conceptos en un solo método:

public byte[] shortToByteArray(short valor, boolean bigEndian){
     byte[] resultado;
     byte b1 = (byte)(( valor >> 8 ) & 0xFF) ;
     byte b0 = (byte)( valor  & 0xFF) ;
     if(bigEndian){
          resultado = new byte[]{ b1 ,  b0 };
     } else{
          resultado = new byte[]{ b0 ,  b1 };
     }
     return resultado;
}

Byte[] a short

Si queremos obtener un short desde un array de bytes que viene ordenado en big-endian, debemos:

Y en caso de que el array de bytes este ordenado como little-endian:

En resumen, todos los conceptos en un solo método:

public short byteArrayToShort(byte[] valor, boolean bigEndian){
     if(valor. length < 2){
          throw new ArrayIndexOutOfBoundsException(valor. length);
     }
     short a, b ;
     if(bigEndian){
          a = (short)((valor[0] & 0xFF) << 8 );
          b =  (short) (valor[1] & 0xFF);
     } else{
          a = (short)((valor[1] & 0xFF) << 8 );
          b =  (short) (valor[0] & 0xFF) ;
     }
     return  (short)(a | b);
}

Convirtiendo int

Un int ocupa 4 bytes en Java por lo que tendremos que tener en cuenta el endianess del dato al momento de convertir desde/hacia un array de bytes.

Int a byte[]

Para obtener cada uno de los bytes realizamos:

Para crear un array de bytes en big-endian, debemos almacenarlos en el orden en que los obtuvimos:

byte[] sbe = new byte[]{ b3 , b2 , b1 ,  b0 };

y para crear un array de bytes en little-endian, debemos almacenarlos en el orden inverso en que los obtuvimos:

byte[] sbe = new byte[]{ b0 ,  b1 , b2 , b3 };

En resumen, todos los conceptos en un solo método:

public byte[] intToByteArray(int valor, boolean bigEndian){
     byte[] resultado; 
     byte b3 = (byte)(( valor >> 24) & 0xFF) ;
     byte b2 = (byte)(( valor >> 16) & 0xFF) ;
     byte b1 = (byte)(( valor >> 8 ) & 0xFF) ;
     byte b0 = (byte)( valor  & 0xFF) ;
     if(bigEndian){
          resultado = new byte[]{ b3 , b2 , b1 , b0 };
     } else{
          resultado = new byte[]{ b0 ,  b1 , b2 , b3 };
     }
     return resultado;
}

Byte[] a int

Siguiendo el mismo concepto que cuando deseamos obtener un short, hacemos:

public int byteArrayToInt(byte[] valor, boolean bigEndian){
     if(valor. length < 4){
          throw new ArrayIndexOutOfBoundsException(valor. length);
     }
     int a, b, c, d;
     if(bigEndian){
          a = (valor[0] & 0xFF) << 24; 
          b = (valor[1] & 0xFF) << 16; 
          c = (valor[2] & 0xFF) << 8; 
          d =  valor[3] & 0xFF;
     } else{
          a = (valor[3] & 0xFF) << 24; 
          b = (valor[2] & 0xFF) << 16; 
          c = (valor[1] & 0xFF) << 8; 
          d =  valor[0] & 0xFF;
     } 
     return  a | b | c | d;
}

Convirtiendo Long

Un long ocupa 8 bytes en Java por lo que como en los casos anteriores, tendremos que tener en cuenta el endianess del dato al momento de convertir desde/hacia un array de bytes.

Long a byte[]

Para obtener cada uno de los bytes realizamos:

Para crear un array de bytes en big-endian, debemos almacenarlos en el orden en que los obtuvimos:

byte[] sbe = new byte[]{ b7 , b6 , b5 , b4 , b3 , b2 , b1 ,  b0 };

y para crear un array de bytes en little-endian, debemos almacenarlos en el orden inverso en que los obtuvimos:

byte[] sbe = new byte[]{ b0 ,  b1 , b2 , b3 , b4 , b5 , b6 , b7 };

En resumen, todos los conceptos en un solo método:

public byte[] longToByteArray(long valor, boolean bigEndian){
     byte[] resultado; 
     byte b7 = (byte)(( valor >> 56) & 0xFF) ;
     byte b6 = (byte)(( valor >> 48 ) & 0xFF) ;
     byte b5 = (byte)(( valor >> 40) & 0xFF) ; 
     byte b4 = (byte)(( valor >> 32) & 0xFF) ;
     byte b3 = (byte)(( valor >> 24) & 0xFF) ;
     byte b2 = (byte)(( valor >> 16) & 0xFF) ;
     byte b1 = (byte)(( valor >> 8 ) & 0xFF) ;
     byte b0 = (byte)( valor  & 0xFF) ;
     if(bigEndian){
          resultado = new byte[]{ b7 , b6 , b5 , b4 , b3 , b2 , b1 , b0 };
     } else{
          resultado = new byte[]{ b0 ,  b1 , b2 , b3 , b4 , b5 , b6 , b7 };
     }
     return resultado;
}

Byte[] a long

Siguiendo los mismos conceptos anteriores, hacemos:

public long byteArrayToLong(byte[] valor, boolean bigEndian){
     if(valor. length < 8 ){
          throw new ArrayIndexOutOfBoundsException(valor. length);
     }
     long a, b, c, d, e, f, g, h;
     if(bigEndian){
          a = (long)(valor[0] & 0xFF) << 56;
          b = (long)(valor[1] & 0xFF) << 48;
          c = (long)(valor[2] & 0xFF) << 40;
          d = (long)(valor[3] & 0xFF) << 32;
          e = (long)(valor[4] & 0xFF) << 24;
          f = (long)(valor[5] & 0xFF) << 16;
          g = (long)(valor[6] & 0xFF) << 8;
          h = (long)(valor[7] & 0xFF);
     } else {
          a = (long)(valor[7] & 0xFF) << 56;
          b = (long)(valor[6] & 0xFF) << 48;
          c = (long)(valor[5] & 0xFF) << 40;
          d = (long)(valor[4] & 0xFF) << 32;
          e = (long)(valor[3] & 0xFF) << 24;
          f = (long)(valor[2] & 0xFF) << 16;
          g = (long)(valor[1] & 0xFF) << 8;
          h = (long)(valor[0] & 0xFF);
     } 
     return  a | b | c | d | e | f | g | h;
} 

Convirtiendo Float

Un long ocupa 4 bytes en Java, al igual que el int, por lo que los mecanismos de conversión desde/hacia un array de bytes son también los mismos, cambiando solamente que antes debemos generar/obtener el entero equivalente a nuestro float (a nivel de bits).
Para facilitarnos las cosas la clase Float posee métodos que realizan este trabajo por nosotros.

Long a byte[]

Lo que hacemos primero es obtener el int equivalente y luego realizamos el mismo procedimiento que antes:

public byte[] floatToByteArray(float valor, boolean bigEndian){ 
     int enteroEquivalente = Float .floatToIntBits(valor);
     return intToByteArray(enteroEquivalente, bigEndian);
}

Byte[] a float

Nuevamente lo que hacemos es conseguir el int equivalente desde los bytes, y de ahí convertimos al float buscado:

public float byteArrayToFloat(byte[] valor, boolean bigEndian){
      int enteroEquivalente = byteArrayToInt (valor, bigEndian);
     return Float.intBitsToFloat(enteroEquivalente);
} 

Convirtiendo Double

Un double ocupa 8 bytes en Java, al igual que el long, repitiendo el paso anterior, asi como lo que los mecanismos de conversión desde/hacia un array de bytes son también los mismos, cambiando solamente que antes debemos generar/obtener el long equivalente a nuestro double (a nivel de bits).
Para facilitarnos las cosas la clase Double posee métodos que realizan este trabajo por nosotros.

Double a byte[]

Lo que hacemos primero es obtener el long equivalente y luego realizamos el mismo procedimiento que antes:

public byte[] doubleToByteArray(double valor, boolean bigEndian){ 
     long longEquivalente = Double.doubleToLongBits(valor);
     return longToByteArray(longEquivalente, bigEndian);
}

Byte[] a double

Nuevamente lo que hacemos es conseguir un long equivalente desde los bytes, y de ahí convertimos al double buscado:

public double byteArrayToDouble(byte[] valor, boolean bigEndian){
      long longEquivalente = byteArrayToLong (valor, bigEndian);
     return Double.longBitsToDouble(longEquivalente);
 }

Una clase de ejemplo

Para realizar una mejora podríamos definir una enumeración que indique el orden de los bytes:

public enum OrdenEndian {
    BIG_ENDIAN,
    LITTLE_ENDIAN
}

y generar una clase que contenga todos los métodos vistos anteriormente:

public class Endianness {
    private static final int MASCARA_BYTE = 0xFF;

    /**
     * Convierte short a un byte array respetando el orden asignado
     * 
     * @param valor valor a convertir
     * @param endianness orden a utilizar en la conversion
     * @return array de bytes equivalentes a valor
     */
    public static byte[] shortToByteArray(short valor, OrdenEndian endianness) {
        byte[] resultado;
        byte b1 = (byte) ((valor >> 8 ) & MASCARA_BYTE);
        byte b0 = (byte) (valor & MASCARA_BYTE);
        if (endianness == OrdenEndian.BIG_ENDIAN) {
            resultado = new byte[]{b1, b0};
        } else {
            resultado = new byte[]{b0, b1};
        }
        return resultado;
    }

    /**
     * Convierte un array de bytes a un short respetando el orden asignado
     * 
     * @param valor array de bytes a convertir
     * @param endianness orden a utilizar en la conversion
     * @return valor equivalente despues de la conversion
     */
    public static short byteArrayToShort(byte[] valor, OrdenEndian endianness) {
        if (valor.length < 2) {
            throw new ArrayIndexOutOfBoundsException(valor.length);
        }
        short a, b;
        if (endianness == OrdenEndian.BIG_ENDIAN) {
            a = (short) ((valor[0] & MASCARA_BYTE) << 8 );
            b = (short) (valor[1] & MASCARA_BYTE);
        } else {
            a = (short) ((valor[1] & MASCARA_BYTE) << 8 );
            b = (short) (valor[0] & MASCARA_BYTE);
        }
        return (short) (a | b);
    }

    /**
     * Convierte int a un byte array respetando el orden asignado
     * 
     * @param valor valor a convertir
     * @param endianness orden a utilizar en la conversion
     * @return array de bytes equivalentes a valor
     */
    public static byte[] intToByteArray(int valor, OrdenEndian endianness) {
        byte[] resultado;
        byte b3 = (byte) ((valor >> 24) & MASCARA_BYTE);
        byte b2 = (byte) ((valor >> 16) & MASCARA_BYTE);
        byte b1 = (byte) ((valor >> 8 ) & MASCARA_BYTE);
        byte b0 = (byte) (valor & MASCARA_BYTE);
        if (endianness == OrdenEndian.BIG_ENDIAN) {
            resultado = new byte[]{b3, b2, b1, b0};
        } else {
            resultado = new byte[]{b0, b1, b2, b3};
        }
        return resultado;
    }

    /**
     * Convierte un array de bytes a un int respetando el orden asignado
     * 
     * @param valor array de bytes a convertir
     * @param endianness orden a utilizar en la conversion
     * @return valor equivalente despues de la conversion
     */
    public static int byteArrayToInt(byte[] valor, OrdenEndian endianness) {
        if (valor.length < 4) {
            throw new ArrayIndexOutOfBoundsException(valor.length);
        }
        int a, b, c, d;
        if (endianness == OrdenEndian.BIG_ENDIAN) {
            a = (valor[0] & MASCARA_BYTE) << 24;
            b = (valor[1] & MASCARA_BYTE) << 16;
            c = (valor[2] & MASCARA_BYTE) << 8;
            d = valor[3] & MASCARA_BYTE;
        } else {
            a = (valor[3] & MASCARA_BYTE) << 24;
            b = (valor[2] & MASCARA_BYTE) << 16;
            c = (valor[1] & MASCARA_BYTE) << 8;
            d = valor[0] & MASCARA_BYTE;
        }
        return a | b | c | d;
    }

    /**
     * Convierte long a un byte array respetando el orden asignado
     * 
     * @param valor valor a convertir
     * @param endianness orden a utilizar en la conversion
     * @return array de bytes equivalentes a valor
     */
    public static byte[] longToByteArray(long valor, OrdenEndian endianness) {
        byte[] resultado;
        byte b7 = (byte) ((valor >> 56) & MASCARA_BYTE);
        byte b6 = (byte) ((valor >> 48 ) & MASCARA_BYTE);
        byte b5 = (byte) ((valor >> 40) & MASCARA_BYTE);
        byte b4 = (byte) ((valor >> 32) & MASCARA_BYTE);
        byte b3 = (byte) ((valor >> 24) & MASCARA_BYTE);
        byte b2 = (byte) ((valor >> 16) & MASCARA_BYTE);
        byte b1 = (byte) ((valor >> 8 ) & MASCARA_BYTE);
        byte b0 = (byte) (valor & MASCARA_BYTE);
        if (endianness == OrdenEndian.BIG_ENDIAN) {
            resultado = new byte[]{b7, b6, b5, b4, b3, b2, b1, b0};
        } else {
            resultado = new byte[]{b0, b1, b2, b3, b4, b5, b6, b7};
        }
        return resultado;
    }

    /**
     * Convierte un array de bytes a un long respetando el orden asignado
     * 
     * @param valor array de bytes a convertir
     * @param endianness orden a utilizar en la conversion
     * @return valor equivalente despues de la conversion
     */
    public static long byteArrayToLong(byte[] valor, OrdenEndian endianness) {
        if (valor.length < 8 ){
            throw new ArrayIndexOutOfBoundsException(valor.length);
        }
        long a, b, c, d, e, f, g, h;
        if (endianness == OrdenEndian.BIG_ENDIAN) {
            a = (long) (valor[0] & MASCARA_BYTE) << 56;
            b = (long) (valor[1] & MASCARA_BYTE) << 48;
            c = (long) (valor[2] & MASCARA_BYTE) << 40;
            d = (long) (valor[3] & MASCARA_BYTE) << 32;
            e = (long) (valor[4] & MASCARA_BYTE) << 24;
            f = (long) (valor[5] & MASCARA_BYTE) << 16;
            g = (long) (valor[6] & MASCARA_BYTE) << 8;
            h = (long) (valor[7] & MASCARA_BYTE);
        } else {
            a = (long) (valor[7] & MASCARA_BYTE) << 56;
            b = (long) (valor[6] & MASCARA_BYTE) << 48;
            c = (long) (valor[5] & MASCARA_BYTE) << 40;
            d = (long) (valor[4] & MASCARA_BYTE) << 32;
            e = (long) (valor[3] & MASCARA_BYTE) << 24;
            f = (long) (valor[2] & MASCARA_BYTE) << 16;
            g = (long) (valor[1] & MASCARA_BYTE) << 8;
            h = (long) (valor[0] & MASCARA_BYTE);
        }
        return a | b | c | d | e | f | g | h;
    }

    /**
     * Convierte float a un byte array respetando el orden asignado
     * 
     * @param valor valor a convertir
     * @param endianness orden a utilizar en la conversion
     * @return array de bytes equivalentes a valor
     */
    public static byte[] floatToByteArray(float valor, OrdenEndian endianness) {
        int enteroEquivalente = Float.floatToIntBits(valor);
        return intToByteArray(enteroEquivalente, endianness);
    }

    /**
     * Convierte un array de bytes a un float respetando el orden asignado
     * 
     * @param valor array de bytes a convertir
     * @param endianness orden a utilizar en la conversion
     * @return valor equivalente despues de la conversion
     */
    public static float byteArrayToFloat(byte[] valor, OrdenEndian endianness) {
        int enteroEquivalente = byteArrayToInt(valor, endianness);
        return Float.intBitsToFloat(enteroEquivalente);
    }

    /**
     * Convierte double a un byte array respetando el orden asignado
     * 
     * @param valor valor a convertir
     * @param endianness orden a utilizar en la conversion
     * @return array de bytes equivalentes a valor
     */
    public static byte[] doubleToByteArray(double valor, OrdenEndian endianness) {
        long longEquivalente = Double.doubleToLongBits(valor);
        return longToByteArray(longEquivalente, endianness);
    }

    /**
     * Convierte un array de bytes a un double respetando el orden asignado
     * 
     * @param valor array de bytes a convertir
     * @param endianness orden a utilizar en la conversion
     * @return valor equivalente despues de la conversion
     */
    public double byteArrayToDouble(byte[] valor, OrdenEndian endianness) {
        long longEquivalente = byteArrayToLong(valor, endianness);
        return Double.longBitsToDouble(longEquivalente);
    }
}

Utilizando la clase de ejemplo

Por ejemplo si necesitamos leer/escribir desde una fuente de datos una clase, por ejemplo:

public class ClaseEjemplo {
    private int a;
    private short b;
    private short c;

    public ClaseEjemplo() {
    }
    public ClaseEjemplo(int A, short B, short C) {
        this.a = A;
        this.b = B;
        this.c = C;
    }

    public int getA() {
        return a;
    }
    public void setA(int a) {
        this.a = a;
    }

    public short getB() {
        return b;
    }
    public void setB(short b) {
        this.b = b;
    }

    public short getC() {
        return c;
    }
    public void setC(short c) {
        this.c = c;
    }

    @Override
    public String toString() {
        return "ClaseEjemplo: " + a + " ; " + b + " ; " + c;
    }
}

y supongamos que poseemos la siguiente condición de formato del array de datos:

Podríamos escribir un parser valiéndonos de la clase de utilitaria que definimos recién:

public class ParserClaseEjemplo {

    public static ClaseEjemplo toClaseEjemplo(byte[] valor) {
        ClaseEjemplo ce = new ClaseEjemplo();

        byte[] ba = Arrays.copyOfRange(valor, 0, 4);
        int a = Endianness.byteArrayToInt(ba, OrdenEndian.BIG_ENDIAN);
        ce.setA(a);

        byte[] bb = Arrays.copyOfRange(valor, 4, 6);
        short b = Endianness.byteArrayToShort(bb, OrdenEndian.LITTLE_ENDIAN);
        ce.setB(b);

        byte[] bc = Arrays.copyOfRange(valor, 6, 8 );
        short c = Endianness.byteArrayToShort(bc, OrdenEndian.BIG_ENDIAN);
        ce.setC(c);

        return ce;
    }

    public static byte[] toByteArray(ClaseEjemplo valor) {
        byte[] ba = new byte[8];

        byte[] a = Endianness.intToByteArray(valor.getA(), OrdenEndian.BIG_ENDIAN);
        byte[] b = Endianness.shortToByteArray(valor.getB(), OrdenEndian.LITTLE_ENDIAN);
        byte[] c = Endianness.shortToByteArray(valor.getC(), OrdenEndian.BIG_ENDIAN);

        int ini = 0;
        ini = copiarBytes(ba, a, ini);
        ini = copiarBytes(ba, b, ini);
        ini = copiarBytes(ba, c, ini);
        
        return ba;
    }
    
    private static int copiarBytes(final byte[] destino, final byte[] origen, final int inicio) {
        for (int i = 0; i < origen.length; i++) {
            destino[i + inicio] = origen[i];
        }
        return origen.length + inicio;
    }
}

Podemos probar que funciona ejecutando:

public class Prueba {
    public static void main(String[] args) {
        byte a = (byte) 0x00;
        byte b = (byte) 0x00;
        byte c = (byte) 0x00;
        byte d = (byte) 0x01;
        byte e = (byte) 0x02;
        byte f = (byte) 0x00;
        byte g = (byte) 0x00;
        byte h = (byte) 0x03;
        byte[] bb = new byte[]{a, b, c, d, e, f, g, h};

        ClaseEjemplo ce = ParserClaseEjemplo.toClaseEjemplo(bb);
        System.out.println(ce.toString());
        
        byte[] cc = ParserClaseEjemplo.toByteArray(ce);
        System.out.println(Arrays.toString(cc));
    }
}

En un próximo post veremos como realizar lo mismo utilizando esta vez la clase ByteBuffer.
Hasta la próxima.

Más Info

Endianess: Big-Endian y Little-Endian

El contenedor que utilizaremos será el JPanel con una imagen de fondo que vimos, y el gestionará la imagen de fondo (jpg, png, gif, etc.) que queramos utilizar, quedándonos el código muy simple:

package ar.lefunes.jframeconfondo;

import java.awt.Image;
import javax.swing.JFrame;

public class JFrameConFondo extends JFrame {

    private final JPanelConFondo contenedor = new JPanelConFondo();

    public JFrameConFondo() {
        setContentPane(contenedor);
    }

    public void setImagen(String nombreImagen) {
        contenedor.setImagen(nombreImagen);
    }

    public void setImagen(Image nuevaImagen) {
        contenedor.setImagen(nuevaImagen);
    }
}

JFrame con una imagen de fondo

La imagen se redimensionará junto con el JFrame:

JFrame redimensionado

La imagen de fondo puede ir cambiando cuando deseemos mediante los métodos setImagen()

Cambiando la imagen de fondo

En caso de que no cargemos ninguna imagen (o cargemos un null como imagen), el panel contenedor mostrará su fondo por defecto:

JFrame con fondo por defecto

Se puede descargar el ejemplo de este post de la siguiente dirección (aprox. 38.7 KB): http://lefunes.googlecode.com/files/JFrame_con_imagen_fondo.zip

Espero les sirva.
Saludos

El problema se hace más evidente al almacenar elementos de más de un byte, como números enteros, flotantes, etc. Por ejemplo, si queremos almacenar el valor hexadecimal 0x1A2B3C4D podemos rápidamente diferenciar dos órdenes:

• Del byte más al menos significativo (0x1A, 0x2C, 0x3C, 0x4D)
• Del byte menos al más significativo (0x4D, 0x3C, 0x2C, 0x1A)

A los formatos en que se almacenarán los datos se los conoce como Endianess. Siendo el formato del primer ejemplo (de + a – significativo) conocido como Big-Endian, mientras que al formato del segundo ejemplo (de – a + significativo) se lo conoce como Little-Endian.

Veamos más en detalle cada uno de estos:

Big-Endian

Este formato fue promovido entre otros por Motorola, y quiere decir “Del más grande al final”.

En el se comienza almacenando del byte más al menos significativo, exactamente igual que como solemos representar los números (por lo menos por estos lados del mundo), siendo el primer byte el que tiene más peso en la secuencia.

Ejemplo 1: Array de datos de 1 Byte cada uno

Si deseamos almacenar:
0×47, 0xEF, 0×15, 0x2A, 0×89, 0×37, 0×84, 0×33

Obtendríamos:

Ejemplo 2: Array de datos de 2 Bytes cada uno

Si deseamos almacenar:
0x47EF, 0x152A, 0×8937, 0×8433

Obtendríamos:

Ejemplo 3: Array de datos de 4 Bytes cada uno

Si deseamos almacenar:
0x47EF152A, 0×89378433

Obtendríamos:

Little-Endian

Este formato fue promovido entre otros por Intel, y quiere decir “Desde el pequeño al final”.

En el se comienza almacenando del byte menos al más significativo, siendo el ultimo byte el que tiene más peso en la secuencia.

Ejemplo 4: Array de datos de 1 Byte cada uno

Si deseamos almacenar:
0×47, 0xEF, 0×15, 0x2A, 0×89, 0×37, 0×84, 0×33

Obtendríamos:

Como podemos observar no se nota la diferencia con el big-endian en este caso.

Ejemplo 5: Array de datos de 2 Bytes cada uno

Si deseamos almacenar:
0x47EF, 0x152A, 0×8937, 0×8433

Obtendríamos:

Aquí se puede apreciar como se invierte el orden de los bytes, en comparación con el mismo dato en big-endian, en cada uno de los datos de 2 bytes.

Ejemplo 6: Array de datos de 4 Bytes cada uno

Si deseamos almacenar:
0x47EF152A, 0×89378433

Obtendríamos:

Aquí se puede apreciar como se invierte el orden de los bytes, en comparación con el mismo dato en big-endian, en cada uno de los datos de 4 bytes.

Hasta la proxima.

Más Info

• Interpretando Big/Little Endian desde Java
• Endianess (wikipedia)
  

Veremos cuales son las traducciones realizadas por el compilador y como podemos aprovecharlas a nuestro favor.

Definiciones

Antes de empezar vamos a definir algunos términos, que aunque no sean definidos de una forma muy formal, permitirán una mejor comprensión del texto:

• Cadena: Una instancia de la clase String. El objeto puede estar asignado a una variable, una constante o no (cadenas anónimas)

• Cadenas Anónimas: Cadenas no asociadas a ningún objeto que se crean y utilizan en la sentencia que se declaran, y luego son descartadas. Por ejemplo en:

System.out.println("Hola Mundo");

la cadena “Hola Mundo” se crea y utiliza en el System.out.println y luego se descarta.

Caso 1: Concatenación de cadenas anónimas

Aunque muchas veces parezca incorrecta o ineficiente la realización de concatenación de dos cadenas anónimas en vez de solo utilizar una, resulta ser lo mismo luego de pasar por el compilador, ya que si tenemos por ejemplo:

//...
String a = "Hola " + "Mundo";
//...

Se convertirá en:

//...
String a = "Hola Mundo";
//...

Viendo la maquina virtual lo mismo que si hubiéramos asignado “Hola Mundo” de primera intención.

Cuál puede ser el beneficio entonces de separar una cadena anónima en dos o más pedazos?

El beneficio que encontramos no es al momento de correr nuestro programa, sino al momento de mantenerlo, ya que en varias ocasiones permitirá una mejor lectura del mismo:

String fragmento = "Por lo tanto, los que no son totalmente conscientes de"
+ " la desventaja de servirse de las armas no pueden ser totalmente conscientes"
+ " de las ventajas de utilizarlas";

Caso 2: Concatenación de constantes

Si tenemos definidas constantes y las concatenamos con alguna cadena anónima o entre si, primero que nada el compilador realizará el intercambio de las constantes por la cadena que representan y luego las trata como el caso anterior. Por ejemplo:

//...
public static final String CONSTANTE_A = "AAA";
private static final String CONSTANTE_B = "BBB";
public final String CONSTANTE_C = "CCC";
private final String CONSTANTE_D = "DDD";
//...
String a = "Mostrar " + CONSTANTE_A;
String b = "Mostrar " + CONSTANTE_B;
String c = "Mostrar " + CONSTANTE_C;
String d = "Mostrar " + CONSTANTE_D;
//...

Después de compilar tendremos:

//...
String a = "Mostrar AAA";
String b = "Mostrar BBB";
String c = "Mostrar CCC";
String d = "Mostrar DDD";
//...

Por lo que podemos ver que no importa el modificador de acceso o si es estática o no, mientras el valor de la constante este disponible a la hora de compilar, será reemplazado en la concatenación.

En este caso podemos ver que la ventaja que trae aparejado el uso de constantes, que es permitirnos hacer mas legible nuestro código no va en contraposición a la de la tener una buena eficiencia en la ejecución, ya que no se perderá tiempo realizando concatenaciones porque fueron realizadas al momento de la compilación.

Caso 3: Concatenación de variables finales

Al igual que en el caso anterior si tenemos definida un variable declarada dentro de un método como final y esta la concatenamos, el compilador la reemplazara la referencia por el valor que representa la variable final.

Por ejemplo:

//...
final String a = " AAA";
String b = "Mostrar " + a;
//...

Después de compilar obtendremos:

//...
final String a = " AAA";
String b = "Mostrar AAA";
//...

Otra vez tenemos las mismas ventajas del punto anterior.

Caso 4: Concatenación de variables

La concatenación de variables es distinta de los casos anteriores debido a que en ningún caso el compilador puede suponer el valor almacenado en las mismas. Como no sabe con que valores se contará, lo que se realiza a la hora de compilar es armar un StringBuilder e irle agregando las cadenas que queremos visualizar.

Esta vez la sentencia quedará preparada y la concatenación real se realizara durante el momento de ejecución.

Por ejemplo:

//...
String v = "Mundo";
//...
String resultado = "Hola " + v;
//...

Como se puede observar, no se puede asegurar de ninguna manera que el valor de “v” va a seguir siendo “Mundo” al momento de concatenar, por lo que el compilador genera:

//...
String resultado = (new StringBuilder()).append("Hola ").append(v).toString();
//...

Básicamente al ejecutarse realizará lo siguiente:

- creará una instancia de StringBuilder
- le agregará la cadena “Hola “
- le agregará el valor de la variable “v”
- obtendrá la cadena resultante
- asignará la cadena resultante a la variable “resultado”

Nuevamente lo que ganamos es expresión a la hora de analizar nuestro código. Veamos un ejemplo ilustrativo de esto, es más difícil entender a simple vista esto:

//...
String res = "Cantidad de tomates: ".concat(Integer.toString(cantidad));
//...

A esto:

//...
String res = "Cantidad de tomates: " + cantidad;
//...

Caso 5: Caso especial de concatenación de variables

Existe un caso especial a la hora de realizar optimizaciones que el compilador no es capaz de darse cuenta, cuando a una variable debemos concatenarle cadenas en varias sentencias, por ejemplo un caso muy simple:

//...
String e = "Hola";
for (int i = 0; i < 100; i++) {
     e += " mundo";
}
//...

En este caso el código generado será el siguiente:

//...
String e = "Hola";
for (int i = 0; i < 100; i++){
     e = (new StringBuilder()).append(e).append(" mundo").toString();
}
//...

Por lo tanto cada nueva iteración del bucle lleva aparejado la creación de un StringBuilder para agregarles las cadenas y asignárselo a la variable “e”

Lo que se puede realizar es crear un StringBuilder e irlo asignando en cada iteración, de la forma:

//...
StringBuilder sb = new StringBuilder("Hola");
for (int i = 0; i < 100; i++) {
     sb.append(" mundo");
}
String e = sb.toString();
//...

Entonces la ejecución se resume a:

- creará una instancia de StringBuilder con el texto inicial (“Hola”)
- le agregará la cadena “ mundo“ una vez por cada bucle
- obtendrá la cadena resultante
- asignará la cadena resultante a la variable “e”

Como pudimos ver en un post anterior la principal ventaja es la gran cantidad de tiempo ganado durante la ejecución.

Conclusión

Como pudimos ver a lo largo de estos casos es que es importante saber como el compilador hace las cosas para de esa forma poder preocuparnos más en el diseño/mantenimiento de nuestras aplicaciones a estar optimizando código que optimizara el compilador y que visualmente es difícil de comprender.

Si es eficiente y bello, no se puede pedir más.

Nota Final

Todo el análisis realizado sobre el funcionamiento del compilador a partir del código generado por el mismo, fue realizado utilizando Jad para descompilar los .class

En el post anterior hablamos como integrar Jad a NetBeans mediante NBJAD.

Es muy bueno el ejercicio de generar clases y analizar que optimizaciones realizo el compilador, ayudándonos esto a tener una base más amplia donde apoyarnos a la hora de desarrollar.

Espero les sirva.
Saludos.

Más Info

• Optimización al concatenar Strings en Java

• Integrar Jad a NetBeans mediante NBJAD

En este post veremos como realizar esta integración:

Bajar e Instalar Jad

1- Descargamos Jad de la página oficial: http://www.kpdus.com/jad.html#download

2- Descomprimimos el archivo descargado en un directorio cualquiera, por ejemplo: D:\jad\

Bajar e Instalar NBJAD

1- Descargamos el plugin para NetBeans de aca: http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=1177 (es un archivo .nbm)

2- Lo instalamos en NetBeans:

• Entramos a Tools->Plugins

• En la pestaña Downloaded, hacemos click en el botón Add Plugins…

• Elegimos el plugin aceptamos y elegimos Install para instalar

• Aparecerá un aviso de que ha fallado la validación del plugin, esta es solo una advertencia, pero el módulo ya ha sido instalado. Elegimos Continue y terminará la instalación.

Configurar NBJAD

Para configurar el modulo, lo que debemos realizar es acceder a Tools->Options, y una vez adentro elegir Decompile

Colocamos el path donde instalamos a Jad y las opciones que queramos utilizar al decompilar. Bajo la configuracion de las opciones se ve el listado de las mismas, esto nos ayudará en la configuración.

Una vez terminado aceptamos los cambios haciendo click en OK

Utilizando NBJAD

Para utilizar el módulo elegimos un archivo .class en Files que queramos descompilar.

Elegimos en el menú View->Decompile, y listo. aparecerá el código fuente generado por Jad.

Como última nota puedo decir que todos los archivos que vamos decompilando, NBJAD los va almacenando en ${directorio de usuario}/.nbjad

Hasta la próxima.

Más Info

• NBJAD (simple integration with Jad decompiler) module uploaded

• Jad

]]> http://lefunes.wordpress.com/2008/05/06/integrar-jad-a-netbeans-mediante-nbjad/feed/ 3 Le Funes Instalando NBJAD en NetBeans Falla la comprobación del módulo Configurando NBJAD Elegimos el archivo a descompilar Decompile !!!! http://lefunes.wordpress.com/2008/04/11/soporte-para-librerias-compartidas-en-netbeans-61/ http://lefunes.wordpress.com/2008/04/11/soporte-para-librerias-compartidas-en-netbeans-61/#comments Fri, 11 Apr 2008 13:48:53 +0000 Le Funes http://lefunes.wordpress.com/?p=96 ]]> Cuantas veces nos encontramos al compartir un proyecto con problemas de librerías no referenciadas? Ó, cuantas veces nos piden/tenemos que pedir las dependencias de un proyecto que fue compartido, finalmente pasando jars, javadoc, sources, explicaciones de cómo se tiene que llamar las librerías, etc.? Muchas veces el problema no es notorio si nosotros somos lo que lo compartimos, pero si al momento de recibir un proyecto y encontrar que algo falta para poder compilar el mismo.

Por suerte, desde NB 6.1 Beta podemos ver una luz en el horizonte: Sharable Libraries.

Veremos un repaso a los problemas comunes que nos encontramos hoy en día y como resolverlos con esta nueva característica incorporada en esta versión del IDE.

Conceptos Básicos

Antes de ver un ejemplo, nos adentrarnos en el tema repasaremos algunos conceptos.

Tipos de librerías

Existen tres tipos de librerías que se pueden insertar dentro de un proyecto de NetBeans:

• Jar/Folder: Aquí directamente se indica un .jar que se quiere agregar al proyecto.
  
• Project: Este tipo hace referencia a otro proyecto de NetBeans.
  
• Library: Las librerías son conjuntos de .jar relacionados bajo un mismo nombre, facilitando su referenciación en un proyecto. Pueden incluir no solo los binarios, sino además Javadoc y Sources que nos ayudarán al momento de programar.
  

  Este tipo de librerías a su vez pueden ser de dos tipos: definidas por NB (definidas a la hora de instalar el IDE) o definidas por el usuario. Su configuración es guardado por en un archivo de definiciones de librerías.
  

  Por ejemplo, la librería JAX-WS 2.1 encapsula los siguientes jars:
  

Archivos de definición de librerías

Es un archivo de propiedades (.properties) o XML en el cual se guarda la definición de las librerías, por ejemplo:

libs.junit.classpath=${base}/junit/junit-3.8.2.jar

libs.junit.javadoc=${base}/junit/junit-3.8.2-api.zip

libs.junit_4.classpath=${base}/junit_4/junit-4.1.jar

libs.MyLibrary_01.classpath=${base}/AbsoluteLayout.jar

Hasta NB 6.0 solo existía un archivo de definición de librerías a nivel global del IDE, que hoy es conocido como Catalogo de Librerías.

A partir de NB 6.1 Beta se pueden crear y editar archivos de definición de librerías personalizados, creando repositorios para uno o más proyectos en particular. Esto permite poder compartir no solo el proyecto, sino además este junto con a definición de las librerías y las librerías propiamente dichas que utiliza.

Para editar un archivos de definición (ya sea el global o los personalizados) se debe acceder al Library Manager (desde el menú Tools->Libraries). Una vez que elegimos la localización del archivo de definiciones, podremos ver, definir una nueva, borrar ó modificar la definición de una librería:

Catálogo de Librerías

Como vimos anteriormente, el catalogo de librerías (ó Global Libraries) es el repositorio de librerías a nivel global del IDE. En él vienen definidas las librerías por defecto creadas al momento de realizar la instalación de NB y es el que utilizan todos los proyectos por defecto, salvo que indique un archivo de definición de librerías en particular.

Se puede acceder a él mediante el Library Manager eligiendo como localidad de la librería a “Global Libraries”:

En este caso no se ha agregado ninguna definición de librería nueva, pudiendo observar el listado de librerías definidas por defecto al instalar NB 6.1 Beta.

Estructura de archivos de un proyecto

Al crear un nuevo proyecto en NB (ya sea desde cero o a partir de código existente), por defecto este generará una estructura de archivos que permiten la mejor organización, por ejemplo:

Donde:

• src: aquí se encuentra el código fuente de nuestra aplicación (.java)
  
• test: aquí está el código fuente de las pruebas (.java)
  
• build: aquí contiene los archivos generados por el compilador (.class)
  
• dist: aquí se encuentran los archivos listos para distribuir (.jar y librerías)
  
• nbproject: aquí NB guarda las configuraciones del proyecto
  
  • prívate: configuraciones propias del usuario
    

De los archivos que vemos en la figura, toma vital importancia el archivo build.xml, debido a que este es el script de Ant que configura todos los aspectos relacionados a la compilación del proyecto, indicando los pasos de construcción y empaquetado, ubicación de las librerías de dependencias, etc.

Compartiendo un proyecto

Básicamente existen dos tipos de destinatarios que pueden recibir un proyecto nuestro: otro usuario de NB o uno que no lo sea. Este último deberá valerse del script de Ant para poder realizar la compilación (build.xml).

Como podemos suponer, al compartir un proyecto, no es necesario compartir los directorios build y dist, ya que estos pueden ser generados a partir del código fuente (almacenado en src). Adicionalmente si el destinatario tiene NB no hará falta tampoco compartir el directorio con configuraciones del usuario (nbproject/private) ya que este se configurará al momento de abrir el proyecto.

Un caso extremo (e ideal a la hora de compartir) es un proyecto que no dependa de ninguna librería. No importa el tipo de destinatario del proyecto este no tendría que tener ninguna complicación a la hora de compilar y ejecutar la aplicación, ya que posee todo el código necesario y todas las librerías (es decir, ninguna).

Este no es el común de los casos, aunque sea para realizar test, para visualización, etc. siempre tendremos al menos un librería, y justamente los problemas comienzan cuando tenemos al menos una librería en el proyecto a compartir.

Los problemas más comunes que podemos tener a la hora de utilizar cada tipo de librería son los siguientes:

Librerías provistas por NB

Este tipo de librerías comúnmente no posee ningún problema entre usuarios del IDE debido a que estas librerías ya vienen definidas al instalar el mismo (salvo que la librería usada haya sido borrada del Catalogo Global). El problema que se lo encontrarán los usuarios que quieran compilar el proyecto directamente desde Ant, sin utilizar el IDE, ya que no podrán resolver las referencias a las librerías.

Librerías definidas por el usuario

Aquí la situación es la misma que la anterior para el usuario de Ant, ya que no posee la definición de las librerías.

Para otro usuario de NB que no posee las librerías definidas el IDE le indicará el problema, indicándole el nombre que debe poseer la librería que debe crear, pero no sabrá que jars incluye. En este punto es donde deberá contactarse con la persona que compartió el archivo para completar la definición de las librerías.

Un problema potencial adicional es si el usuario de NB posee definidas librerías con el nombre de las requeridas pero el contenido es totalmente diferente (jars que incluye), debiendo modificar la definición de la librería para solucionar el problema, pero seguramente trasladando los problemas al proyecto para el cual había creado la misma.

Jars

Los jars se agregan a un proyecto con paths relativos al proyecto, por lo que ambos tipos de usuario tendrán problemas si el jar en cuestión no se encuentra en la localización correcta.

Generalmente la forma de solucionar este problema hasta NB 6 era colocarlo dentro de la estructura del proyecto (en un directorio llamado lib por ejemplo), para que al compartir el proyecto el jar vaya dentro del mismo.

Otro proyecto de NB

Cuando un proyecto depende de otro ocurrirá la misma situación anterior, se utiliza el path relativo para referenciarlo, por lo que la localización del mismo será muy importante a la hora de compilar.

Otra vez, la forma de compartir los proyectos que dependen uno del otro debe hacerse de tal forma que el receptor luego no tenga problemas para reubicar los mismos en la forma adecuada. Tanto en NB 6.1 Beta como en las versiones anteriores este problema debe resolverse de esta forma, ya que la librería de la cual se depende es un proyecto en si mismo, no pudiéndose mover/copiar a una ubicación arbitrariamente.

Solución a los Problemas con NetBeans 6.1 Beta

NB 6.1 Beta resuelve los tres primeros casos vistos anteriormente creando un repositorio con todas las librerías (junto a su definición) y jars de los cual depende el proyecto.

El repositorio creado deberá ser compartido junto al proyecto.

El proyecto guarda un path relativo al repositorio, por lo que se debe elegir bien la posición donde se colocara (lo mismo que pasa al compartir un proyecto de NB que depende de otro).

Por ejemplo:

Para este ejemplo, tenemos en el directorio “ProyectoNB” el proyecto que vamos a compartir, mientras que en el directorio “libreries” el repositorio.

Dentro del directorio “Proyecto NB” tenemos la estructura de directorio de nuestro proyecto, y dentro de “libreries” tenemos la definición de las librerías (nblibreries.properties) junto con las librerías y jars requeridos por el proyecto.

Al momento de compartir lo que haríamos seria enviar el directorio “a_compartir” completo al destinatario.

Veremos un par de ejemplos para ver las pantallas que se ven implicadas en el proceso. También veremos que es muy fácil transformar un proyecto existente a compartido.

Ejemplo 1: Crear un proyecto nuevo preparado para ser compartido

En este ejemplo veremos como empezar de cero un nuevo proyecto compartido.

Creamos un nuevo proyecto:

Al llegar a este dialogo nos encontramos con dos nuevos agregados en NB 6.1 Beta:

• A: Si chequeamos indicaremos explícitamente que el proyecto es un proyecto para compartir.
• B: Al chequear A se habilita el textbox para indicar la ubicación que tendrá el repositorio de librerías. Mediante el botón “Browse…” nos facilita la búsqueda del lugar donde se encuentra un repositorio de librerías creado anteriormente.

Una vez aceptado este dialogo (haciendo click en Finish) se tendrá el proyecto listo para compartir.

Ejemplo 2: Pasar de un proyecto no compartido a hacerlo

En este ejemplo veremos como si tenemos un proyecto no compartido (nuevos o de versiones de NB previas a NB 6.1 Beta).

Al crear el nuevo proyecto no compartido:

C: Creamos el proyecto como no compartido (sin chequear la casilla)

Abrimos dentro del proyecto sus propiedades y revisamos las propiedades de las librerías:

Hacemos click en el botón se nos abrirá un dialogo de configuración del archivo de definición de librerías.

y luego de haber aceptado solo queda decir que acción se va a realizar con las librerías a las cuales el proyecto estaba apuntando.

NB nos preguntara que hacer, generalmente conviene “Use Existing Library in New Location”, ya que todas las librerías necesarias por el proyecto serán copiadas en el directorio de librerías, dejando el proyecto listo para ser compartido.

Saludos.

Hasta la próxima.

Más Info

• NetBeans.org
• Notas de Version NB 6.1 RC1
• Descargar NB 6.1 RC1
  
• Apache Ant (Wikipedia)
  

Veremos cuales son las formas más optimas de realizar esto según cada circunstancia.

Existen 3 maneras de realizar este proceso:

1. Concatenando mediante el operador +
2. Concatenando mediante la funcion concat() de la clase String
3. Utilizando la clase StringBuffer

Para realizar la comparación de rendimientos de cada método utilizaremos un algoritmo simple donde se utiliza cada una de las técnicas, y para el análisis nos valdremos del análisis del Profiler de NetBeans.

package testcadena;
public class Main {
     private static final int cantidadPrueba = 10000;

     public static void main(String[] args) {
         concatenacionBString();
         concatenacionConcat();
         concatenacionSuma();
     }

     private static void concatenacionSuma() {
         String resultado = "inicio";
         for (int i = 0; i < cantidadPrueba; i++) {
             resultado += " hola";
         }
     }

     private static void concatenacionConcat() {
         String resultado = "inicio";
         for (int i = 0; i < cantidadPrueba; i++) {
             resultado.concat(" hola");
         }
     }

     private static void concatenacionBString() {
         StringBuffer resultado = new StringBuffer("inicio");
         for (int i = 0; i < cantidadPrueba; i++) {
             resultado.append(" hola");
         }
     }
}

Mediante la constante cantidadPrueba iremos variando la cantidad de concatenaciones que se realizaran.

Concatenando 1000 cadenas

Realizando la prueba con cantidadPrueba=1000 vemos que el Profiler nos indica:

Podemos apreciar que el método que utiliza StringBuffer es el más rápido, seguido por el que utiliza concat y por último (más de 100 veces más lento que los anteriores) el método utilizando el operador “+”.

Concatenando 100 cadenas

Bajamos la cantidad de concatenaciones hechas para verificar que pasa:

Ahora el más rápido es concat seguido de cerca por StringBuffer, pero el operador de concatenación sigue siendo el más lento (aunque ahora la diferencia ya no es tan grande como en la prueba anterior)

Concatenando 10 cadenas

Seguimos bajando la cantidad de concatenaciones:

Ahora se mantiene y acentúa la tendencia de la anterior prueba, siendo concat el más rápido.

Concatenando 1 cadena

Realizamos la prueba menor, concatenandole a la cadena inicial solo una cadena.

Como era de esperar sigue siendo más rápido la solución con concat, pero ahora es más rápido la suma antes que el uso de StringBuffer (esto es debido al costo propio de crear el Buffer para la cantidad de concatenaciones realizadas)

Conclusión

De este pequeño análisis podemos obtener las siguientes conclusiones:

• Nunca es optimo realizar una concatenación de clases mediante el operador de concatenación (+)
• Para un pequeño número de concatenaciones es mejor utilizar el método concat() de la clase String
• Para gran cantidad de concatenaciones sobre una cadena, lo mejor es utilizar un StringBuffer

StringBuilder vs. StringBuffer

Agregado el 18 de Marzo de 2008:

Un cuarto método de concatenar String es usando la clase StringBuilder.

StringBuilder tiene una funcionalidad similar a la de StringBuffer, pero la principal diferencia radica en que StringBuilder no está preparada para acceso concurrente tal como lo hace StringBuffer.

Esto puede parecer una desventaja, si usamos múltiples hilos insertando sobre la misma secuencia de caracteres deberemos utilizar obligadamente StringBuffer. Sin embargo encontraremos que en la mayoría de los casos solo un hilo accede a la secuencia de caracteres, siendo todos los mecanismos de sincronización utilizados por StringBuffer completamente inútiles, siendo en estos casos StringBuilder la solución ideal.

Como vimos en los ejemplos anteriores, el StringBuffer es utilizado y consumido por un mismo hilo (el hilo que ejecuta el método), por lo cual esta es una situación ideal para reemplazar StringBuffer por StringBuilder

Creamos un nuevo método:

...
    private static void concatenacionBBuilder() {
        StringBuilder resultado = new StringBuilder("inicio");
        for (int i = 0; i < cantidadPrueba; i++) {
            resultado.append(" hola");
        }
    }
...

y comparamos este método con el que utilizaba StringBuffer, obteniendo:

pudiendo de esta forma comprobar que se ha obtenido una pequeña optimizacion, que era nuestro objetivo.

Ganando más performance

Agregado el 07 de Mayo de 2008:

Si sabemos (o sospechamos por lo menos) cuanto crecerá nuestro StringBuilder ó StringBuffer podemos indicarselo al construirlos.

El problema es que cada vez que hacemos un append() debe crecer antes de copiar la cadena.

Creamos un método nuevo para probar esto:

...
    private static void concatenacionBBuilder2() {
        StringBuilder resultado = new StringBuilder(6*cantidadPrueba);

        resultado.append("inicio");
        for (int i = 0; i < cantidadPrueba; i++) {
            resultado.append(" hola");
        }
    }
...

y estos son los resultados:

Por lo que si tenemos alguna forma de predecir cuanto crecerá, esto es importante tenerlo en cuenta.

Más Info

• Concatenación de cadenas en Java: Optimizaciones realizadas por el compilador
• Javadoc StringBuilder
• Javadoc StringBuffer
• Optimization of String Concatenation

new String(by, “UTF8");

6a 61 76 61 2f 6c 61 6e 67 2f 43 6c 61 73 73

obtendremos

java/lang/Class

Hasta la próxima

Veremos como construir un parser genérico de XML y como lo podemos adaptar a nuestras necesidades.

Entre las clases más importantes a tener en cuenta tenemos:

Interface org.xml.sax.XMLReader:
Está interfaz que debe implementar un lector de XML.
Cada vez que el XMLReader encuentra el principio del archivo, el final, un elemento, un caracter especial, un espacio, etc. notifica esto al ContentHandler asociado.
Cada vez que encuentra un error se lo notifica al ErrorHandler asociado.

Interface org.xml.sax.ContentHandler:
La clase que la implementa obtiene la capacidad de recibir todas las notificaciones de contenido de un XMLReader.
La forma de asociar este a un XMLReader es mediante el método setContentHandler.

Interface org.xml.sax.ErrorHandler:
La clase que la implementa obtiene la capacidad de recibir todas las notificaciones de error producidas por un XMLReader
La forma de asociar este a un XMLReader es mediante el método setErrorHandler.
En caso de que no exista ningun ErrorHandler asociado al XMLReader, este ultimo no reportara ningun error, salvo las excepciones SAXParseException.

Clase org.xml.sax.helpers.DefaultHandler:
Clase que implementa tanto a ContentHandler como a ErrorHandler (además de DTDHandler y EntityResolver que no veremos por ahora), proveiendo implementaciones por defectos para todos sus métodos.

Esta clase es de la que extenderemos para poder crear nuestro propio parser de XML.

Clase org.xml.sax.helpers.XMLReaderFactory:
Clase que provee métodos estáticos para la creación de XMLReaders.
Utilizaremos el método estático XMLReaderFactory.createXMLReader() que nos devuelve el XMLReader un por defecto para nuestro sistema.

Creando el Lector
Para ello haremos de la siguiente forma:

class LectorXML extends DefaultHandler {

    private final XMLReader xr;

    public LectorXML() throws SAXException {
        xr = XMLReaderFactory.createXMLReader();
        xr.setContentHandler(this);
        xr.setErrorHandler(this);
    }
}

class LectorXML extends DefaultHandler {

    private final XMLReader xr;

    public LectorXML() throws SAXException {
        xr = XMLReaderFactory.createXMLReader();
        xr.setContentHandler(this);
        xr.setErrorHandler(this);
    }

    public void leer(final String archivoXML)
             throws FileNotFoundException, IOException,
                       SAXException {
        FileReader fr = new FileReader(archivoXML);
        xr.parse(new InputSource(fr));
    }
}

public class PruebaSAX {
    public static void main(String[] args)
              throws FileNotFoundException, IOException,
                        SAXException {
        LectorXML lector = new LectorXML();
        lector.leer("test.xml");
    }
}

class LectorXML extends DefaultHandler {

    private final XMLReader xr;

    public LectorXML() throws SAXException {
        xr = XMLReaderFactory.createXMLReader();
        xr.setContentHandler(this);
        xr.setErrorHandler(this);
    }

    public void leer(final String archivoXML)
             throws FileNotFoundException, IOException,
                       SAXException {
        FileReader fr = new FileReader(archivoXML);
        xr.parse(new InputSource(fr));
    }

    @Override
    public void startDocument() {
        System.out.println("Comienzo del Documento XML");
    }

    @Override
    public void endDocument() {
        System.out.println("Final del Documento XML");
    }

    @Override
    public void startElement(String uri, String name,
              String qName, Attributes atts) {
        System.out.println("tElemento: " + name);

        for (int i = 0; i < atts.getLength(); i++) {
         System.out.println("ttAtributo: " +
          atts.getLocalName(i) + " = "+ atts.getValue(i));
        }
    }

    @Override
    public void endElement(String uri, String name,
                                 String qName) {
        System.out.println("tFin Elemento: " + name);
    }
}

De la misma forma podemos sobrescribir los métodos para ver los caracteres especiales que aparecen en el XML (espacios, saltos de lineas, etc), mostrar errores y excepciones generadas a la hora de realizar la lectura y parseo, etc.

Espero que les sirva.
Hasta la Próxima.

Más Info

• Página oficial de SAX
• Javadoc XMLReader
• Javadoc DefaultHandler
• Javadoc ContentHandler
• Javadoc ErrorHandler
• Javadoc XMLReaderFactory

]]>