Acceso a datos. Introducción a los JavaBeans

En la industria electrónica como en otras industrias se está acostumbrando a utilizar componentes para construir placas, tarjetas, etc. En el campo del software la idea es la misma. Se puede crear un interfaz de usuario en un programa Java en base a componentes: paneles, botones, etiquetas, caja de listas, barras de desplazamiento, diálogos, menús, etc.

Si se ha utilizado Delphi o Visual Basic, ya estamos familizarizados con la idea de componente, aunque el lenguaje de programación sea diferente.

Existen componentes que van desde los más simples como un botón hasta otros mucho más complejos como un calendario, una hoja de cálculo, etc.

Los primeros componentes que tuvieron gran éxito fueron los VBX (Visual Basic Extension), seguidos a continuación por los componentes OCX (OLE Custom Controls). Ahora bien, la principal ventaja de los JavaBeans es que son independientes de la plataforma.

Muchos componentes son visibles cuando se corre la aplicación, pero no tienen porqué serlo, solamente tienen que ser visibles en el momento de diseño, para que puedan ser manipulados por el Entorno de Desarrollo de Aplicaciones (IDE).

Podemos crear una aplicación en un IDE, seleccionando los componentes visibles e invisibles en una paleta de herramientas y situarlas sobre un panel o una ventana. Con el ratón unimos los sucesos (events) que genera un objeto (fuente), con los objetos (listeners) interesados en responder a las acciones sobre dicho objeto. Por ejemplo, al mover el dedo en una barra de desplazamiento (fuente de sucesos) con el ratón, se cambia el texto (el número que indica la posición del dedo) en un control de edición (objeto interesado en los sucesos generados por la barra de desplazamiento).

Definición de JavaBean

Un JavaBean o vean es un componente hecho en software que se puede reutilizar y que puede ser manipulado visualmente por una herramienta de programación en lenguaje Java. Ejemplos de JavaBeans son, por ejemplo, las librerías gráficas AWT.

Para ello, se define un interfaz para el momento de diseño (design time) que permite a la herramienta de programación o IDE, interrogar (query) al componente y conocer las propiedades (properties) que define y los tipos de sucesos (events) que puede generar en respuesta a diversas acciones.

Aunque los beans individuales pueden variar ampliamenete en funcionalidad desde los más simples a los mas complejos, todos ellos comparten las siguientes características:

• Introspection. Permite analizar a la herramienta de programación o IDE como trabaja el bean.
• Customization. El programador puede alterar la apariencia y la conducta del bean.
• Events. Los beans se comunican con otros beans utilizando los eventos.
• Properties. Permite cambiar los valres de las propiedades del bean para personalizarlo (customization).
• Persistence. Se puede guardar el estado de los beans que han sido personalizados por el programador, cambiando los valores de sus propiedades.

En general, un bean es una clase que obedece ciertas reglas:

• Un bean tiene que tener un constructor por defecto (sin argumentos).
• Un bean tiene que tener persistencia, es decir, implementar el interface Serializable.
• Un bean tiene que tener instrospección (introspection). Los IDE reconocen ciertas pautas de diseño, nombres de las funciones miembros o métodos y definiciones de las clases, que permiten a la herramienta de programación mirar dentro del bean y conocer sus propiedades y su conducta.

Propiedades

Una propiedad es un atributo del JavaBean que afecta a su apariencia o a su conducta. Por ejemplo, un boton puede tener las siguientes propiedades: el tamaño, la posición, el título, el color de fondo, el color del texto, si está o no habilitado, etc.

Las propiedades de un bean pueden examinarse y modificarse mediante métodos o funciones miembro, que acceden a dicha propiedad, y pueden ser de dos tipos:

• getter method: Lee el valor de la propiedad
• setter methon: Cambia el valor de la propiedad

Un IDE que cumpla con las especificaciones de los JavaBeans sabe como analizar un bean y conocer sus propiedades. Además, crea una representación visual para cada uno de los tipos de propiedades, denominadas editor de propiedades, para que el programador pueda modificarlas fácilmente en el momento del diseño.

Cuando un programador coge un bean de la paleta de componentes y lo deposita en un panel, el IDE muestra el bean sobre el panel. Cuando seleccionamos el bean aparece una hoja de propiedades, que es una lista de las propiedades del bean, con sus editores asociados para cada una de ellas.

El IDE llama a los métodos o funciones miembro que empiezan por get, para mostrar en los editores los valores de las propiedades. Si el programador cambia el valor de una propiedad se llama a un método cuyo nombre empieza por set, para actualizar el valor de dicha propiedad y que puede o no afectar al aspecto visual del bean en el momento del diseño.

Las especificaciones JavaBeans definen un conjunto de convenciones (design patterns) que el IDE usa para inferir qué métodos corresponden a propiedades.

public void setNombrePropiedad(TipoPropiedad valor)

public TipoPropiedad getNombrePropiedad()

Cuando el IDE carga un bean, usa el mecanismo denominado reflection para examinar todos los métodos, fijándose en aquellos que empiezan por set y get. El IDE añade las propiedades que encuentra a la hoja de propiedades para que el programador personalice el bean.

Propiedades simples

Una propiedad simple representa un único valor.

// miembro de la clase que se usa para guardar el valor de la propiedad

private String nombre;

// métodos set y get de la propiedad denominada Nombre

public void setNombre(String nuevoNombre){

       nombre = nuevoNombre;

}

public String getNombre(){

       return nombre;

}

En el caso de que dicha propiedad sea booleana se escribe

// miembro de la clase que se usa para guardar el valor de la propiedad

private boolean conectado = false;

// métodos set y get de la propiedad denominada Conectado

public void setNombre(Boolean nuevoValor){

       conectado = nuevoValor;

}

public String isConectado(){

       return conectado;

}

Propiedades indexadas

Una propiedad indexada representa un array de valores.

// miembro de la calse que se usa para guardar el valor de la propiedad

private int[] numeros = {1, 2, 3, 4};

// métodos set y get de la propiedad denominada Numeros, para el array completo

public void setNumeros(int[] nuevoValor){

       numeros = nuevoValor;

}

public int[] getNumeros(){

       return numeros;

}

// métodos get y set para un elemento de array

public void setNumeros(int indice, int nuevoValor){

       numeros[indice] = nuevoValor;

}

public int getNumeros(int indice){

       return numeros[indice];

}

Propiedades ligadas (bound)

Los objetos de una clase que tiene una propiedad ligada notifican a otros objetos (listeners) interesados, cuando el valor de dicha propiedad cambia, permitiendo a estos objetos realizar alguna acción. Cuando la propiedad cambia, se crea un objeto (event) que contiene información acerca de la propiedad (su nombre, el valor previo y el nuevo valor), y lo pasa a los otros objetos (listeners) interesados en el cambio.

Propiedades restringidas (constrained)

Una propiedad restringida es similar a un propiedad ligada salvo que los objetos (listeners) a los que se les notifica el cambio de valor de la propiedad tienen la opción de vetar (veto) cualquier cambio en el valor de dicha propiedad. (Este tipo de propiedad no se estudiará en este tema).

Ventajas

• Reutilización de software
• Disminución de la complejidad del software
• Mejoras en el mantenimiento
• Incremento de la calidad del software

Eventos

Ejemplo

Asalariado.java

package proyectoxhacienda;

import java.beans.*;

import java.io.Serializable;

import java.util.*;

public class Asalariado implements Serializable{

       // Propiedades

       private PropertyChangeSupport propertySupport;

       private int sueldo;

      

       // Constructor

       public Asalariado(){

             propertySupport = new PropertyChangeSupport(this);

             sueldo = 20;

       }

      

       // Métodos

       public void addPropertyChangeListener(PropertyChangeListener listener){

             propertySupport.addPropertyChangeListener(listener);

       }

      

       public void removePropertyChangeListener(PropertyChangeListener listener){

             propertySupport.removePropertyChangeListener(listener);

       }

      

       public void setSueldo(int nuevoSueldo){

             int anteSueldo = sueldo;

             sueldo = nuevoSueldo;

             if (anteSueldo != nuevoSueldo){

                    propertySupport.firePropertyChange("sueldo", anteSueldo, sueldo);

             }

       }

      

       public int getSalario(){

             return sueldo;

       }

}

Hacienda.java

package proyectoxhacienda;

import java.beans.*;

import java.io.Serializable;

import java.util.*;

public class Hacienda implements Serializable, PropertyChangeListener{

      

       // Constructor

       public Hacienda(){}

      

       // Métodos

       public void propertyChage(PropertyChangeEvent evt){

             System.out.println("Hacienda: nuevo sueldo " + evt.getNewValue());

             System.out.println("Hacienda: sueldo anterior " + evt.getOldValue());

       }

}

ProyectoxHacienda.java

package proyextoxhacienda;

public class ProyectoxHacienda{

       public static void main(String[] args){

            

             Hacienda funcionario1 = new Hacienda();

             Asalariado empleado = new Asalariado();

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

             empleado.addPropertyChangeListener(funcionario1);

             empleado.setSueldo(50);

       }

}

Crear JavaBeans con NetBeans

• Arrancar NetBeans
• Menú Archivo à Proyecto nuevo à Java à Java ClassLibrary – botón Siguiente
• Escribir el nombre de la librería, ubicación y carpeta… y botón Terminar.

Una vez creado el proyecto se crearían los JavaBeans:

• Botón derecho sobre el proyecto, opción Nuevo à Componente JavaBeans
• Escribir nombre del Bean y nombre del paquete. Botón Terminar
• Se creará el Bean con un código por defecto en el cual puedo eliminar el atributo sampleProperty y sus métodos get y set (getsampleProperty y setsampleProperty). Se añadirán los atributos que sean necesarios así como el constructor… dentro de este último volver a incluir propertySupport = new … que aparece en el constructor vacío. Generar los getter y setter para los atributos añadidos (clic con el botón derecho del ratón debajo de los constructores y seleccionar Insertar código à Getter y Setter). Completar / cambiar el código que sea necesario.
• Crear los siguientes Beans del mismo modo que antes.
• Una vez que se tengan todos los BEans, generar el JAR (botón derecho sobre el proyecto y elegir del menú la opción Generar).

Si todo ha ido bien, se generará un archivo .jar en la carpeta dist del proyecto.

Una vez desarrollado, se debe empaquetar para su distribución y utilización por las aplicaciones. La forma habitual de distribución es mediante un archivo JAR que debe contener un fichero de manifiesto (MANIFEST.MF) que describa su contenido, por ejemplo aquí se define un Bean de nombre miBean, una clase auxiliar para el Bean y una imagen:

Manifest-Version: 1.0

Name: ejemploBeans/miBean.class

Java-Bean: True

Name: ejemploBeans/auxiliar.class

Java-Bean: False

Name: ejemploBeans/imagen.png

Java-Bean: False

Empaquetaremos el Bean utiliando el comando jar de java:

jar cfm archivogenerado.jar META-INT/MANIFEST.MF carpetadeclases/*.class

Donde:

• c indica qu ese creará un fichero
• f que la salida va a un fichero y no a la salida estándar
• m que se deben añadir las líneas del fichero manifiesto que especifique el usuario
• archivogenerado.jar es el nombre del jar que contendrá todas las clases de la carpeta carpetadeclases.
• META-INT/MANIFEST.MF indica el lugar donde se encuentran las líneas que se quieren añadir al fichero de manifiesto que se genera por defecto con la orden jar.
• Carpetadeclases/*.class indica dónde están los ficheros de entrada (los que tienen la extensión class de la carpetadeclases). 

Recuerda que puedes compilar los JavaBeans utilizando por ejemplo desde la línea de comando javac… clase.java.