ConociendoNetbeansPlatformIntroduccion

Conociendo a NetBeans Platform: Introducción

Autor: Luis Enrique Funes
Adaptado desde http://mendozajug.com.ar/portal/index.php?option=com_content&task=view&id=64&Itemid=2


Con este artículo comenzamos a descubrir lo fácil que puede ser construir plugins para NetBeans desde el más pequeño hasta directamente construir aplicaciones enteras basadas en la infraestructura de NetBeans.

Daremos un repaso general por lo que es NetBeans Platform, veremos aplicaciones ya realizadas y aprenderemos como utilizar el IDE para desarrollar sobre la plataforma a partir de un pequeño ejemplo.

[[{TableOfContentsTitle=TablaDeContenidos} | {TableOfContents title='Tabla de Contenidos'}]]


Que es NetBeans Platform?

Generalmente, cuando hablamos de NetBeans nos referimos al popular IDE sobre el cual desarrollan en la actualidad gran cantidad de usuarios a lo largo de todo el mundo (entre los que me incluyo), aunque formalmente posee el nombre de NetBeans IDE. A lo largo de este artículo nos referiremos a él indistintamente como “NetBeans IDE” ó simplemente “IDE”.

Por otro lado, NetBeans Platform es un framework con una amplia variedad de APIs que resuelven gran cantidad de problemas con los que nos encontramos a la hora de construir una aplicación. Él es el corazón sobre el cual se construye, entre otras aplicaciones, NetBeans IDE.

NetBeans Platform hace fuerte hincapié sobre la construcción del software de forma modular, módulo sobre módulo, y es ahí precisamente donde mayor provecho podremos sacar de esta plataforma, ya que nos ofrece implementados los mecanismos de descubrimiento de nuevos módulos (y de actualizaciones de los existentes) desde repositorios remotos, resolución de dependencias, activación/desactivación de módulos en caliente, comunicación entre los mismos, etc. permitiéndonos preocuparnos por la lógica y rápidamente desplegar nuestras aplicaciones, pudiendo ir extendiendo su funcionalidad a medida que pasa el tiempo.
File:01_ConociendoNetbeansPlatformIntroduccion.jpg
Una gran ventaja de la construcción modular es que podemos crear una aplicación conformada por X cantidad de módulos diferentes, cada uno responsable de llevar a cabo determinadas responsabilidades, y según el rol de la persona que la va a utilizarla solo se carga en la aplicación los módulos que permiten cumplir con su tarea, permitiéndonos tener un abanico de aplicaciones sin tener que programar una sola línea de código adicional. Por ejemplo:
File:02_ConociendoNetbeansPlatformIntroduccion.jpg
Otras características que hacen interesante la elección de NetBeans Platform como plataforma para nuestra aplicación son las siguientes:

  • Los proyectos desarrollados no dejan de ser multiplataforma, y poseen largadores (launchers) para cada plataforma.
  • Sistema de ventanas práctico para desarrollar las interfaces de usuario
  • Sistema de ficheros virtual en el cual se van montan los diferentes módulos con el cual se van adaptando automáticamente los menús, barra de herramientas, menús contextuales, etc. de la aplicación
  • Su licencia nos permite construir tanto aplicaciones open source como comerciales
  • Compatibilidad con Java Web Start
  • No es obligatorio que una aplicación deba tener interfaz de usuario grafica (GUI), ya que la plataforma permite dejar de lado la misma y seguir disfrutando del resto de los beneficio, por ejemplo la actualización de módulos desde un repositorio remoto.
  • Soporte completo para desarrollar desde NetBeans IDE, por lo que no necesitaremos otra herramienta adicional para el desarrollo




Algunas aplicaciones desarrolladas sobre NetBeans Platform


Además del IDE, existen una amplia variedad de aplicaciones desarrolladas sobre NetBeans Platform desde la edición de imágenes, pasando por aplicaciones de gestión, hasta herramientas para ingeniería. Algunos ejemplos de ellas son:

blueMarine
File:03_ConociendoNetbeansPlatformIntroduccion.jpg
Proyecto open source para la organización y edición de fotografías.

Project Xemo (eXtensible Electronic Music Object architecture)
File:04_ConociendoNetbeansPlatformIntroduccion.jpg
Proyecto open source para la edición musical.



Gentleware's Poseidon for UML
File:05_ConociendoNetbeansPlatformIntroduccion.jpg
Herramienta CASE para UML

SysUpTime
File:06_ConociendoNetbeansPlatformIntroduccion.jpg
Herramienta para la administración de sistemas/redes distribuidas.

DARPA Grand Challenger Vehicle Control
File:07_ConociendoNetbeansPlatformIntroduccion.jpg
Interfaz de monitoreo de telemetría en vehículos no tripulados para competir en DARPA Grand Challenger
Hay varios ejemplos y screenshots más en el las páginas de documentación de NetBeans Platform (ver sección Más Info)


Tipos de Proyectos

Existen cuatro tipos de proyectos que podremos comenzar a crear en la versión 6.1 del IDE:

  • Module
  • Library Wrapper Module
  • Module Suite
  • NetBeans Platform Application


Veremos cada uno en detalle.

Module (Módulo)
Un módulo es simplemente un típico JAR (Java ARchive) con cierta metainformación almacenada en el manifiesto. Los módulos poseen la extensión NBM (NetBeans Module).

Entre la metainformación se encuentra la versión del módulo, las dependencias, descripción de funcionalidad, datos del autor, etc. Un módulo puede ser usado en cualquier proyecto desarrollado sobre NetBeans Platform (siempre que se cumplan las restricciones de dependencias del mismo), incluso sobre NetBeans IDE:
File:08_ConociendoNetbeansPlatformIntroduccion.jpg
Library Wrapper Module (Módulo Envoltorio de Librería)

Un Library Wrapper Module permite que una librería externa (.JAR) sea vista desde los otros módulos como un módulo estándar. Básicamente se comporta igual que un Module, pero este no contendrá lógica alguna, simplemente expondrá la interfaz de la librería envuelta.
File:09_ConociendoNetbeansPlatformIntroduccion.jpg
Tanto a los Module como a los Library Wrapper Module se los denomina de forma genérica como módulos o plugins.

Module Suite (Suite de Módulos)
Un Module Suite es una colección de módulos sobre la cual desarrollaremos nuestra aplicación. Por defecto, un Module Suite trae habilitados todos los módulos que conforman tanto a NetBeans Platform como a NetBeans IDE.
File:10_ConociendoNetbeansPlatformIntroduccion.jpg
Nuestro trabajo consistirá en deshabilitar los módulos que no utilicemos y agregar los nuevos (Modules o Library Wrapper Module) para de esa forma crear nuestra aplicación.
File:11_ConociendoNetbeansPlatformIntroduccion.jpg
NetBeans Platform Application (Aplicación sobre NetBeans Platform)
Básicamente también crea un Module Suite, pero por defecto viene configurado con la mínima cantidad de módulos habilitados necesarios para iniciar. Por su configuración inicial lo llamaremos también como “Module Suite vacío”.
File:12_ConociendoNetbeansPlatformIntroduccion.jpg
De forma contraria a un Module Suite, nuestro trabajo consistirá en habilitar los módulos que vayamos requiriendo para que nuestros módulos (ya sean Modules o Library Wrapper Module) cumplan sus dependencias, y así crear nuestra aplicación.
File:13_ConociendoNetbeansPlatformIntroduccion.jpg
Cualquier aplicación que se desarrolle comenzando con un Module Suite puede iniciarse con un NetBeans Platform Application, solo variará la forma de realizarlo.

De ser posible, siempre que desarrollemos una aplicación basada en NetBeans Platform es preferible hacerlo con un NetBeans Platform Application ya que nos evitará olvidar deshabilitar un módulo que realmente no utilizamos.


Proyectos de Ejemplo en NetBeans IDE

El IDE trae dos ejemplos con los cuales podremos observar aplicaciones construidas sobre la plataforma, manejo de módulos, uso de librerías externas y ver varios conceptos básicos aplicados.

Para acceder a ellos simplemente creamos un nuevo proyecto (File -> New Project...) y seleccionamos Samples -> NetBeans Modules en el dialogo:
File:14_ConociendoNetbeansPlatformIntroduccion.jpg
Seleccionamos alguno de los proyectos, luego nos pedirá un nombre y un lugar donde crear el proyecto, y finalizamos el proceso, en ese momento ya estará listo para su estudio.

Paint Application
Pequeña aplicación que nos permite crear imágenes PNG a mano alzada.
File:15_ConociendoNetbeansPlatformIntroduccion.jpg
El proyecto se compone de un Module Suite vacío en el cual se agregaron dos módulos:

  • ColorChooser: Library Wrapper Module que envuelve a la librería ColorChooser.jar
  • Paint: Module que implementa toda la lógica de la aplicación y los componentes visuales. Depende del módulo ColorChooser y de librerías propias de la plataforma.


File:16_ConociendoNetbeansPlatformIntroduccion.jpg
Por lo que lo podemos resumir en:
File:17_ConociendoNetbeansPlatformIntroduccion.jpg
Feed Reader
Pequeño lector de feeds.
File:18_ConociendoNetbeansPlatformIntroduccion.jpg
El proyecto se compone de un Module Suite vacío en el cual se agregaron cuatro módulos:

  • JDOM Library: Library Wrapper Module que envuelve a la librería jdom-1.0.jar
  • ROME Library: Library Wrapper Module que envuelve a la librería rome-0.6.jar. Depende del módulo JDOM Library
  • ROME Fetcher Library: Library Wrapper Module que envuelve a la librería rome-fetcher-0.6.jar. Depende del módulo ROME Library
  • Feed Reader: Module que implementa toda la lógica de la aplicación y los componentes visuales. Depende del módulo ROME Fetcher Library y de librerías propias de la plataforma.


File:19_ConociendoNetbeansPlatformIntroduccion.jpg
Por lo que lo podemos resumir en:
File:20_ConociendoNetbeansPlatformIntroduccion.jpg


Ejemplo práctico: Codificador de Colores

Para ver como se desarrolla un módulo desde el comienzo crearemos paso a paso un pequeño plugin para el IDE. Durante este ejemplo nos concentraremos en los mecanismos y uso del IDE para desarrollar el módulo, pero no nos detendremos a ver las APIs en detalle ya que lo haremos en próximos artículos.

Manos a la obra!!!

Paso 0: Pensar la idea
Primero que nada deberemos definir que es lo queremos que haga el módulo.

El plugin que realizaremos debe permitir que al estar editando un documento de java (.java) elijamos de una paleta un color y este inserte su equivalente en Java (mediante la clase java.awt.Color) donde se encuentre el cursor. Por ejemplo si seleccionamos un color conocido como el color rojo el plugin insertará “Color.RED”, pero si seleccionamos un color cualquiera insertará su correspondiente en RGB, de la forma “new Color(125, 124, 33)”

Paso 1: Abrir el IDE
Para este ejemplo utilizaremos NetBeans IDE versión 6.1

Paso 2: Crear un nuevo proyecto
Creamos un nuevo proyecto abriendo File->New Project...
File:21_ConociendoNetbeansPlatformIntroduccion.jpg
Seleccionamos la categoría NetBeans Modules y de ahí la plantilla Module.

Hacemos click en Next.

Paso 3: Seleccionamos ubicación del módulo
Seleccionamos el nombre del proyecto y su ubicación en el disco. Luego debemos seleccionar entre dos opciones:

  • Standalone Module: Permite crear plugins para cualquier aplicación (incluido el IDE)
  • Add to Module Suite: Permite agregar un módulo a una aplicación especifica que estemos desarrollando


Como lo que queremos es crear un plugin para el IDE seleccionamos la primera opción y seleccionamos como plataforma de destino la actual (NetBeans IDE 6.1)
File:22_ConociendoNetbeansPlatformIntroduccion.jpg
Paso 4: Configuración Básica del Modulo
Para finalizar el Wizard configuraremos aspectos generales del módulo, como son el nombre para mostrar del Module, el paquete base del mismo y la ubicación del Bundle de internacionalización.
File:23_ConociendoNetbeansPlatformIntroduccion.jpg
Hacemos click en Finish para finalizar y crear el proyecto:
File:24_ConociendoNetbeansPlatformIntroduccion.jpg
Paso 5: Editar la información del Module
Hacemos click derecho sobre el proyecto y seleccionamos Properties para ver la configuración del módulo.

Dentro de la categoría Sources podemos seleccionar para que maquina virtual será el código, ó para J2SE 1.4 ó para Java SE 5.0 (1.5). Dejamos seleccionado 1.5
File:25_ConociendoNetbeansPlatformIntroduccion.jpg
Dentro de librerías podremos ver las dependencias de un módulo, en este caso aún no tenemos ninguna por lo que la dejaremos vacía.
File:26_ConociendoNetbeansPlatformIntroduccion.jpg
Dentro de Display podremos la información que se mostrará de nuestro modulo al momento de instalarlo/desinstalarlo en el Plugin Manager. Llenamos los campos.

Como nuestro plugin puede ser administrado desde el Plugin Manager es importante que este seleccionado el checkbox inferior “Show in Plugin Manager”
File:27_ConociendoNetbeansPlatformIntroduccion.jpg
La categoría API Versioning tiene la información que sirve para los otros módulos que vayan a utilizar a este, por lo que podemos indicar la versión, definir los paquetes públicos, etc. Por ahora lo dejaremos así.
File:28_ConociendoNetbeansPlatformIntroduccion.jpg
Dentro de Compiling podemos observar la configuración del compilador. No modificaremos nada aquí.
File:29_ConociendoNetbeansPlatformIntroduccion.jpg
Finalmente en Packaging tendremos la información referente a la instalación de nuestro módulo, como la licencia para utilización del mismo, datos del autor y si necesita luego de instalarlo reiniciar la aplicación antes de utilizarlo.
File:30_ConociendoNetbeansPlatformIntroduccion.jpg
Hacemos click en OK para aceptar todos los cambios.

Paso 6: Crear una Acción
Por medio de las acciones podemos agregar nuevos comportamientos a nuestra aplicación. En nuestro caso queremos agregar la acción que permita abrir el dialogo para elegir el color.

Primero creamos una nuevo Action haciendo click en File->New File.... Action se encuentra dentro de la categoría Module Development.

Hacemos click en Next.
File:31_ConociendoNetbeansPlatformIntroduccion.jpg
Deberemos definir si la acción esta siempre habilitada o solo bajo una condición determinada. Elegimos que se habilite condicionalmente (Conditionally Enabled) cuando estemos parados con el cursor sobre un editor (EditorCookie), adicionalmente, solo puede estar seleccionado un solo editor (User Selects One Node).

Hacemos click en Next.
File:32_ConociendoNetbeansPlatformIntroduccion.jpg
Existen cinco formas con las cuales una acción puede ser ejecutada:

  • Desde un elemento del menú
  • Desde un botón en el toolbar
  • Desde un elemento del menú contextual de un archivo
  • Desde un elemento del menú contextual del editor
  • Por medio de un atajo de teclado


En nuestro caso habilitaremos un elemento en el menú (dentro de Source) y en el menú contextual del editor (solo cuando sea un archivo .java)

En la categoría de nuestro módulo elegiremos Source, por ser el más representativo.

Hacemos click en Next.
File:33_ConociendoNetbeansPlatformIntroduccion.jpg
Indicamos el nombre de la clase, en que paquete se almacena y su icono.
File:34_ConociendoNetbeansPlatformIntroduccion.jpg
Hacemos click en Finish para terminar.

Nuestra acción se ha creado correctamente, aunque aún no posee comportamiento alguno.
File:35_ConociendoNetbeansPlatformIntroduccion.jpg
Si observamos ahora las dependencias del módulo observaremos que se han agregado algunas:
File:36_ConociendoNetbeansPlatformIntroduccion.jpg
Paso 7: Agregando código a la acción
Agregamos el código necesario a la acción recién creada y completando el método performAction (la única dependencia que aún no se cumplirá aun es a la clase DialogoColor):

//cadena a insertar
private String color = null;

//Dialogo para la seleccion del color
private final DialogoColor dc = new DialogoColor(this);

/**
* Asigna el color a mostrar
*
* @param color cadena que representa el color a mostrar
*/
public void setColor(final String color) {
    this.color = color;
}

protected void performAction(final Node[] activatedNodes) {
    //abre el dialogo de colores
    dc.setVisible(true);
    if (color != null) {
        //obtiene el gestor de editores actual
        final EditorCookie editorCookie = activatedNodes[0].getLookup().lookup(EditorCookie.class);
        //reemplaza el texto seleccionado en el editor por el color
        editorCookie.getOpenedPanes()[0].replaceSelection(color);
    }
}

Paso 8: Creando a DialogoColor
Creamos la clase llamada DialogoColor que será el dialogo que se abrirá a la hora de seleccionar el color.
File:37_ConociendoNetbeansPlatformIntroduccion.jpg
Insertamos en él el siguiente código:

package ar.mendozajug.selectorcolor;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JColorChooser;
import javax.swing.JPanel;

public class DialogoColor extends javax.swing.JDialog {

    //referencia a la accion
    private final SeleccionarColor cn;

    public DialogoColor(final SeleccionarColor cn) {
        super();

        this.cn = cn;

        inicializarInterfaz(); 
    }


    /**
    * cierra el dialogo sin elegir color
    * @return
    */
    private int cerrar() {
        return cerrar(null);
    }

    /**
    * cierra el dialogo con el color especificado
    *
    * @param color color seleccionado
    * @return
    */
    private int cerrar(final Color color) {
        String cad = null;
        if (color != null) {
            if (color.equals(Color.WHITE)) {
                cad = "Color.WHITE";
            } else if (color.equals(Color.BLACK)) {
                cad = "Color.BLACK";
            } else if (color.equals(Color.BLUE)) {
                cad = "Color.BLUE";
            } else if (color.equals(Color.CYAN)) {
                cad = "Color.CYAN";
            } else if (color.equals(Color.DARK_GRAY)) {
                cad = "Color.DARK_GRAY";
            } else if (color.equals(Color.GRAY)) {
                cad = "Color.GRAY";
            } else if (color.equals(Color.GREEN)) {
                cad = "Color.GREEN";
            } else if (color.equals(Color.LIGHT_GRAY)) {
                cad = "Color.LIGHT_GRAY";
            } else if (color.equals(Color.MAGENTA)) {
                cad = "Color.MAGENTA";
            } else if (color.equals(Color.ORANGE)) {
                cad = "Color.ORANGE";
            } else if (color.equals(Color.PINK)) {
                cad = "Color.PINK";
            } else if (color.equals(Color.RED)) {
                cad = "Color.RED";
            } else if (color.equals(Color.YELLOW)) {
                cad = "Color.YELLOW";
            } else {
                cad = "new Color(" + color.getRed() + ", " + color.getGreen() +
                    ", " + color.getBlue() + ")";
            }
        }

        //se indica la cadena que se mostrara en el editor
        cn.setColor(cad);

        //ocualta el panel
        setVisible(false);

        return 0;
    }

    private void inicializarInterfaz() {
        //configuracion general del dialogo
        setModal(true);
        setTitle("Elegir Color a Insertar");
        setDefaultCloseOperation(HIDE_ON_CLOSE);

        //asignamos layout
        setLayout(new BorderLayout());

        //incluimos el selector de color en el dialogo
        final JColorChooser cc = new JColorChooser();
        add(cc, BorderLayout.CENTER);

        //creamos panel inferior
        final JPanel jp = new JPanel(new BorderLayout());

        //insertamos en panel boton de seleccion
        final JButton btSeleccionar = new JButton("Seleccionar");
        btSeleccionar.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                //cierra el dialogo con el color elegido en el selector de colores
                cerrar(cc.getColor());
            }
        });
        jp.add(btSeleccionar, BorderLayout.WEST);

        //insertamos en panel boton de cerrar
        final JButton btCerrar = new JButton("Cerrar");
        btCerrar.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                //cierra el dialogo sin seleccionar ningun color adicional
                cerrar();
            }
        });
        jp.add(btCerrar, BorderLayout.EAST);

        //agregamos al dialogo el panel en la parte inferior
        add(jp, BorderLayout.SOUTH);

        //configuracion final del dialogo
        pack();
        setLocationRelativeTo(null);
    }
}

Para hacernos una idea de la interfaz, esto es lo que realizamos:
File:38_ConociendoNetbeansPlatformIntroduccion.jpg
Paso 9: Compilando el proyecto
Seleccionamos en el menú Build->Build Main Project (o simplemente presionamos F11) para compilar el proyecto. Si lo hace correctamente ya estamos en condiciones de empezar a probar nuestro módulo (en caso contrario revisar especialmente los import).

Paso 10: Probando el módulo
Para probar el módulo tenemos dos opciones, ó lo probamos en la instancia del IDE que tenemos abierta (Development IDE) ó abrimos una nueva instancia de NetBeans (Target Platform) con el plugin ya cargado.
File:39_ConociendoNetbeansPlatformIntroduccion.jpg
Yo recomiendo abrirlo aparte (si los recursos nos acompañan) para así poder trabajar tranquilo y evitar que ante una falla del plugin se no bloquee la instancia de desarrollo.

Una vez que el plugin se haya cargado (bajo cualquiera de las opciones anteriores) lo comprobaremos abriendo el menú Source:
File:40_ConociendoNetbeansPlatformIntroduccion.jpg
Como podemos observar se encuentra deshabilitado porque en el editor no tenemos seleccionado ningún archivo .java.

Abrimos un proyecto y de él un archivo .java cualquiera (en mi caso cree un proyecto nuevo con solo el main). Hacemos click en algún lugar del código donde queremos insertar el color y elegimos ahora el menú, que debe ya estar habilitado. Recordemos también que habíamos colocado en el menú contextual del editor la acción:
File:41_ConociendoNetbeansPlatformIntroduccion.jpg
De cualquiera de las dos formas se abrirá el dialogo para pedirnos elegir un color, seleccionamos uno y vemos que sucede:
File:42_ConociendoNetbeansPlatformIntroduccion.jpg
Por lo que el módulo funciono como era esperado.

Paso 11: Distribuyendo nuestros desarrollos
Una vez que nos aseguramos que todo está funcionando bien podemos construir el archivo .NBM para compartir nuestro desarrollo con quien queramos, para ello debemos seleccionar:
File:43_ConociendoNetbeansPlatformIntroduccion.jpg
Y el archivo que distribuiremos se generará dentro del directorio build de nuestro proyecto, en este caso se llama ar-mendozajug-selectorcolor.nbm

Paso 12: Instalando nuestro módulo NBM
Cuando queramos instalar el módulo simplemente nos vamos a Tools->Plugin, y en la pestaña Downloaded seleccionamos Add Plugins... Buscamos l ubicación del modulo a instalar y hacemos click en Open. Ahora el módulo se encuentra listo para instalarse:
File:44_ConociendoNetbeansPlatformIntroduccion.jpg
Hacemos click en Install y completamos el instalador (advertirá que el plugin no ha sido verificado por NetBeans, simplemente lo aceptamos).

Finalmente el modulo se encontrará instalado, lo cual podemos verificar en la pestaña Installed:
File:45_ConociendoNetbeansPlatformIntroduccion.jpg
Desde este mismo lugar se puede desinstalar o deshabilitar temporalmente el plugin.


Proceso de desarrollo de un nuevo módulo

Para finalizar vamos a repasar rápidamente los pasos para realizar el nuevo módulo:

  1. Crear el proyecto
  2. Configurar información general del modulo
  3. Utilizar plantillas para construir acciones, menus, ventanas, etc.
  4. Agregar la lógica al módulo
  5. Compilar, Debug y Prueba.
  6. Distribuir




Más Info




Bibliografía Recomendada

Rich Client Programming – Plugging into NetBeans Platform
Boudreau – Tulach – Wielenga
Prentice Hall – 2007
http://www.prenhallprofessional.com

Not logged in. Log in, Register

By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2012, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo