Un componente software es una clase creada para ser reutilizada y que puede ser manipulada por una herramienta de desarrollo de aplicaciones visual. Se define por su estado que se almacena en un conjunto de propiedades, las cuales pueden ser modificadas para adaptar el componente al programa en el que se inserte. También tiene un comportamiento que se define por los eventos ante los que responde y los métodos que ejecuta ante dichos eventos.

Los componentes tienen una interfaz bien definida formada por sus propiedades y métodos, y se distribuyen mediante un paquete instalable que contiene todo lo necesario para su funcionamiento. Además, deben ser independientes de otras bibliotecas o componentes.

Para que una clase sea considerada un componente debe cumplir ciertas normas:

• Debe poder modificarse para adaptarse a la aplicación en la que se integra.
• Debe tener persistencia, es decir, debe poder guardar el estado de sus propiedades cuando han sido modificadas.
• Debe tener introspección, es decir, debe permitir a un IDE que pueda reconocer ciertos elementos de diseño como los nombres de las funciones miembros o métodos y definiciones de las clases, y devolver esa información.
• Debe poder gestionar eventos.

El desarrollo basado en componentes tiene, además, las siguientes ventajas:

• Es mucho más sencillo y se realiza en menos tiempo y con un coste inferior.
• Se disminuyen los errores en el software ya que los componentes se deben someter a un riguroso control de calidad antes de ser utilizados.

Una de las principales características de un componente es que una vez instalado en un entorno de desarrollo, éste debe ser capaz de identificar sus propiedades simplemente detectando parejas de operaciones get/ set, mediante la capacidad denominada introspección.

El entorno de desarrollo podrá editar automáticamente cualquier propiedad de los tipos básicos o de las clases Color y Font. Aunque no podrá hacerlo si el tipo de datos de la propiedad es algo más complejo, por ejemplo, si usamos otra clase, como Cliente. Para poder hacerlo tendremos que crear nuestro propio editor de propiedades.

Un editor de propiedad es una herramienta para personalizar un tipo de propiedad en particular. Los editores de propiedades se utilizan en la ventana Propiedades, que es donde se determina el tipo de la propiedad, se busca de un editor de propiedades apropiado, y se muestra el valor actual de la propiedad de una manera apropiada.

public Editor implements PropertyEditor {…}

Se puede programar un componente para que reaccione ante determinadas acciones del usuario, como un clic del ratón o la pulsación de una tecla del teclado. Cuando estas acciones se producen, se genera un evento que el componente puede capturar y procesar ejecutando alguna función. Pero no solo eso, un componente puede también lanzar un evento cuando sea necesario y que su tratamiento se realice en otro objeto.

Los eventos que lanza un componente, se reconocen en las herramientas de desarrollo y se pueden usar para programar la realización de acciones.

Para que el componente pueda reconocer el evento y responder ante el tendrás que hacer lo siguiente:

• Crear una clase para los eventos que se lancen.
• Definir una interfaz que represente el oyente (listener) asociado al evento. Debe incluir una operación para el procesamiento del evento.efinir dos operaciones, para añadir y eliminar oyentes. Si queremos tener más de un oyente para el evento tendremos que almacenar internamente estos oyentes en una estructura de datos como ArrayList o LinkedList:

public void add<Nombre>Listener(<Nombre>Listener l)

public void remove<Nombre>Listener(<Nombre>Listener l)

Finalmente, recorrer la estructura de datos interna llamando a la operación de procesamiento del evento de todos los oyentes registrados. En resumen:

Resumen textual alternativo

Un componente, como cualquier otra clase dispone de una interfaz, que es el conjunto de métodos y propiedades accesibles desde el entorno de programación. Normalmente, la interfaz la forman los atributos y métodos públicos.

La introspección es una característica que permite a las herramientas de programación visual arrastrar y soltar un componente en la zona de diseño de una aplicación y determinar dinámicamente qué métodos de interfaz, propiedades y eventos del componente están disponibles.

Esto se puede conseguir de diferentes formas, pero en el nivel más bajo se encuentra una característica denominada reflexión, que busca aquellos métodos definidos como públicos que empiezan por get o set, es decir, se basa en el uso de patrones de diseño, es decir, en establecer reglas en la construcción de la clase de forma que mediante el uso de una nomenclatura específica se permita a la herramienta encontrar la interfaz de un componente.

En JavaBeans la introspección se puede conseguir de varias maneras:

• Reflexión de bajo nivel, que utiliza patrones de diseño para descubrir las características del componente por medio de las posibilidades de reflexión del paquete java.lang.reflect.
• Examinando una clase asociada de información del componente (BeanInfo) que describe explícitamente sus características para que puedan ser reconocidas.

Una propiedad simple representa un único valor, un número, verdadero o falso o un texto por ejemplo.

Tiene asociados los métodos getter y setter para establecer y rescatar ese valor. Por ejemplo, si un componente de software tiene una propiedad llamada peso de tipo real susceptible de ser leída o escrita, deberá tener los siguientes métodos de acceso:

private void writeObject(java.io.ObjectOutputStream out) throws IOException;

private void readObject(java.io.ObjectInputStream in) throws IOExcept;

Una propiedad simple es de sólo lectura o sólo escritura si falta uno de los mencionados métodos de acceso.

Una propiedades indexadas representa un conjunto de elementos, que suelen representarse mediante un vector y se identifica mediante los siguientes patrones de operaciones para leer o escribir elementos individuales del vector o el vector entero (fíjate en los corchetes del vector):

public <TipoProp>[] get<NombreProp>()
public void set<NombreProp> (<TipoProp>[] p)
public <TipoProp> get<NombreProp>(int posicion)
public void set<NombreProp> (int posicion, <TipoProp> p)

Aquí tienes un ejemplo de propiedad indexada. El componente almacena un conjunto de miembros, a los que puedes acceder en conjunto o de uno en uno.

A continuación puedes descargar el código asociado para que lo estudies:

BeanBox

Es la primera herramienta que se creó para trabajar con componentes de JavaBeans y se podría definir como un contenedor de Beans. Se proporcionaba desde la página web de Sun, y la documentación sobre JavaBeans se basaba en esta herramienta.

En BeanBox se pueden escribir los Beans, para luego arrastrarlos dentro de BeanBox y comprobar si funcionan como se esperaba.

El BeanBox también puede verse como una demostración de cómo deben comportarse las herramientas de desarrollo compatibles con los JavaBeans. El BeanBox es una buena herramienta para aprender a trabajar con Beans, aunque hoy en día ha sido sustituida por NetBeans.

Bean Builder

En una versión mejorada del BeanBox. Con esta aplicación se comenzó a dar un enfoque al proyecto que se desarrollaba, puesto que al igual que el BeanBox permitía el enlazado de componentes de manera gráfica y ver sus propiedades en tiempo que diseño, pero a diferencia de él y lo que más interesante resultaba era que no creaba archivos .ser para la serialización de los objetos sino que utiliza archivos XML que podían ser entendidos por cualquier aplicación.

NetBeans

Es la apuesta actual de Oracle para crear y utilizar Beans. Proporciona una base completa para todo el ciclo de vida de creación del Bean, y ayudas para la escritura de código para añadir propiedades, métodos getter y setter en propiedades simples, complejas, compartidas o ligadas, o para la generación de eventos. Además desde el administrador de la paleta es extremadamente sencillo incorporar nuevos beans desde sus archivos .jar, e incorporarlos a una aplicación solo precisa de un par de clics.

Una de las características que aporta NetBeans es la creación de la clase BeanInfo para el componente. Una clase BeanInfo puede gestionar el modo en que el componente aparece en la herramienta de desarrollo de aplicaciones, indicando que propiedades deben aparecer, en primer lugar, cual es deben estar ocultas, si existe un editor de propiedades asociado, etc, siendo además una de las bases de la introspección en Java.

Puedes generar un BeanInfo automáticamente desplegando el menú contextual de la clase que implementa el componente en el inspector de proyectos de NetBeans y seleccionar Editor BeanInfo, si no existe te preguntará si quieres crearlo, cuando lo hagas se creará la clase BeanInfo y se mostrará el código, si cambias al diseño visual verás un panel que te permite gestionar gráficamente las propiedades de tu componente.

La principal ventaja de utilizar este método es que cuando nuestro componente hereda de una clase del tipo JPanel o JFrame, que son bastante complejas, el manejo de las propiedades heredadas es automático en el BeanInfo.

Una vez creado el componente, es necesario empaquetarlo para poder distribuirlo y utilizarlo después. Para ello necesitarás el paquete jar que contiene todas las clases que forman el componente:

• El propio componente.
• Objetos BeanInfo.
• Objetos Customizer.
• Clases de utilidad o recursos que requiera el componente, etc.

Puedes incluir varios componentes en un mismo jar.

El paquete jar debe incluir un fichero de manifiesto (con extensión .mf) que describa su contenido, por ejemplo:

Manifest-Version: 1.0
Name: demo/Componente.class
Java-Bean: True
Name: demo/ComponenteBeanInfo.class
Java-Bean: False
Name: demo/ClaseAuxiliar.class
Java-Bean: False
Name: demo/Imagen.png
Java-Bean: False

La forma más sencilla de generar el archivo jar es utilizar la herramienta Limpiar y construir del proyecto en NetBeans, que deja el fichero .jar perfectamente en el directorio /dist del proyecto, aunque siempre puedes recurrir a la orden jar y crearlo tu directamente:

jar cfm Componente.jar manifest.mf Componente.class ComponenteBEanInfo.class ClaseAuxiliar.class Imagen.png proyecto.jar

En el ámbito del acceso a datos que estudiamos en este módulo formativo el uso de componentes está muy relacionado con el mundo de la creación de aplicaciones web. La tecnología JSP utiliza una arquitectura denominado MVC (Modelo-Vista-Controlador), cuya misión fundamental es separar el desarrollo de la base de datos (Modelo), creada por ejemplo en MySQL o cualquier otro gestor de bases de datos, de la interfaz (Vista), que puede hacerse usando HTML en combinación con JSP, de la lógica de negocio (Controlador) cuya implementación más sencilla y fácil de gestionar por JSP es un JavaBean que acceda a la base de datos y permita recuperar fácilmente la información que contiene.

En el esquema el modelo sería la base de datos, la vista el apartado de presentación de datos y el controlador está formado por la lógica de la aplicación y acceso a datos.

Para ejemplificar el uso de componentes JavaBean de acceso a datos, supondremos que queremos crear una aplicación web que muestre información de los alumnos del ciclo que mantendremos almacenados en una base de datos. De momento, nos encargaremos de los apartados Modelo y Controlador, dejando la vista para otros módulos del ciclo.

Nos basaremos en una base de datos muy sencilla que tendremos almacenada en un servidor MySql. El código SQL para crear la base de datos sería:

Base de datos: 'alumnos'
Estructura de tabla para la tabla 'alumnos'
CREATE TABLE IF NOT EXISTS `alumnos' (
     DNI varchar2(9) NOT NULL,
     Nombre varchar2(50) NOT NULL,
     Apellidos varchar2(70) NOT NULL,
     Direccion varchar2(100) NOT NULL,
     FechaNac date NOT NULL,
PRIMARY KEY (DNI)) ENGINE=MyISAM DEFAULT CHARSET=latin1;
Volcar la base de datos para la tabla 'alumnos'
INSERT INTO 'alumnos' VALUES
('12345678A', 'José Alberto', 'González Pérez', 'C/Albahaca, nº14, 1ºD', '1986-07-15'),
('23456789B', 'Almudena', 'Cantero Verdemar', 'Avd/ Profesor Alvarado, n27, 8ºA', '1988-11-04'),
('14785236d', 'Martín', 'Díaz Jiménez', 'C/Luis de Gongora, nº2.', '1987-03-09'),
('96385274f', 'Lucas', 'Buendia Portes', 'C/Pintor Sorolla, nº 16, 4ºB', '1988-07-10');

La base de datos se compone de una sola tabla de alumnos. Para cada alumno almacenamos su DNI, nombre, apellidos, dirección y fecha de nacimiento.

En el entrono de la arquitectura MVC el controlador representa la lógica de negocio de una aplicación. Encapsula las reglas de negocio en componentes que son fáciles de probar, permiten mejorar la calidad del software y promueven la reutilización.

El estado del define el conjunto actual de valores del modelo e incluye métodos para cambiar estos valores. Estos métodos recogen parte de la lógica de negocio. Deberían de ser independientes del protocolo que se utilizara para acceder a ellos. Si resumimos la encapsulación, calidad del software, reutilización e independencia del protocolo obtenemos que los JavaBeans son la elección lógica para implementar estos componentes.

El componente se encarga de conectar con la base de datos y ejecutar la sentencia deseada. A través de los métodos puede posicionarse en cada fila de la consulta y almacena en las propiedades cada uno de los campos.

Las acciones definen los cambios permitidos para los estados en respuesta a los eventos.

El componente a crear dispondrá de un constructor con las siguientes características:

• Propiedades que se corresponden con los campos de la tabla alumnos.
• Clase auxiliar llamada Alumno que usaremos para crear un vector de alumnos donde cargaremos el contenido de la tabla.
• Vector de alumnos.
• Constructor (sin argumentos):
  • Realiza la conexión a la base de datos.
  • Realiza la consulta.
  • Guarda los resultados en una estructura local al componente.
  • Establece los valores de las propiedades.
  • Cierra la conexión.
• Métodos para recorrer los resultados, recargando las propiedades cada vez que cambie. Usaremos los siguientes métodos:
  • obtenerFilas(): hace la consulta sobre la base de datos y almacena los resultados sobre un vector interno actualizando los valores de las propiedades.
  • SeleccionarFilas/(i): se posiciona en el elemento i del vector y actualiza los valores de las propiedades.
  • seleccionarDNI(String DNI): busca en el vector interno el registro que coincide con el valor del DNI y actualiza los valores de las propiedades.
  • 

Comenzamos creando un proyecto NetBeans nuevo de tipo Java Application. Nos aseguramos de desmarcar las opciones Crear clase principal y Configurar como proyecto principal y ponemos de nombre al proyecto AlumnoBean, por ejemplo.

Una vez creado el proyecto, le añadimos un archivo nuevo de tipo Componente JavaBeans (si no lo encuentras en la lista que sale en el menú contextual, haz clic en la opción Otros... para acceder al resto de tipos de archivos). Puedes llamar a la clase AlumnoBean y al paquete en el que se ubicará Alumno.

Para que una clase se pueda considerar un componente debe implementar la interfaz Serializable y, además, tener un constructor sin argumentos que vimos eran requisitos para la creación de componentes.

El proyecto cuenta con una propiedad de ejemplo que puedes eliminar (su declaración y los métodos get y set de la propiedad), así como un gestor de escuchadores de cambio de propiedades que no necesitaremos, quedando el siguiente código para empezar:

public class AlumnoBean implements Serializable {
     private PropertyChangeSupport propertySupport;
     public TemporizadorBean() {
          propertySupport = new PropertyChangeSupport(this);
     }
}

El componente tendrá como propiedades las mismas que los campos de la base de datos: DNI, nombre, apellidos, dirección y fecha de nacimiento.

La adición de propiedades en una clase Java se realiza simplemente escribiendo el código de declaración del atributo privado (o protegido) y los métodos getter y setter que son la base de la instrospección.

Si bien NetBeans proporciona una ayuda especial para realizar esta tarea. Con el cursor posicionado dentro de la clase (puedes reservar una zona para el código de propiedades), haz clic con el botón secundario y selecciona la opción Insertar Código..., en la lista que te saldrá elige Agregar propiedad. Se desplegará el siguiente cuadro de diálogo en el que puedes escribir el nombre de la propiedad y su tipo, e insertar los métodos get y set de manera automática:

Fíjate que si quisieras crear una propiedad indexada o restringida es muy sencillo de hacer, sólo hay que marcar la opción correspondiente y la herramienta genera el código base de los métodos necesarios.

Con las propiedades listas, tenemos que programar el comportamiento del componente. En principio la idea es que al crear el componente se cargue el contenido de la tabla alumno de la base de datos en un vector de uso interno que nos va a servir para no tener que estar conectándonos constantemente, recuerda que estos componentes se usan en entornos cliente servidor con gran cantidad de accesos por parte de múltiples usuarios que pueden llegar a saturar la base de datos. Por este motivo programaremos el constructor para que realice la carga de datos. En un primer momento los valores de las propiedades serán los del primer alumno recuperado.

También generaremos un par de métodos para recuperar información de un registro según su posición o según su clave.

A continuación tienes el enlace al código de la clase con lo visto hasta el momento:

Añadiremos el siguiente código:

Los componentes usan los eventos para generar acciones en respuesta a los cambios del estado permitidos.

Los componentes Java utilizan el modelo de delegación de eventos para gestionar la comunicación entre objetos como hemos visto. Para ilustrar el uso de los eventos en un componente JavaBean añadiremos le añadiremos un comportamiento extra que añadirá un nuevo alumno a la base de datos. Tendrá como especial característica que cada vez que se inserte un alumno nuevo que generará un evento que alerte de esta modificación. Esto que en principio puede parecer redundante no lo es en un entorno multiusuario en el que varios clientes se conecten simultáneamente a la base de datos. Para poder implementar esto necesitarás varias cosas:

• Una clase que implemente los eventos. Esta clase hereda de java.util.EventObject. En el ejemplo se llamará BDModificadaEvent.
• Una interfaz que defina los métodos a usar cuando se genere el evento. Implementa java.util.EventListener. En este caso la gestión del evento se hará a través del método capturarBDModificada de la interfaz BDModificadaListener. También tenemos un objeto de tipo DBModificadaListener llamado receptor que representa aquellos programas que contienen al componente AlumnosBean susceptibles de recibir el evento.
• Dos métodos, addEventoListener y removeEventoListener que permitan al componente añadir oyentes y eliminarlos. En principio se deben encargar de que pueda haber varios oyentes. En nuestro caso sólo vamos a tener un oyente, pero se suele implementar para admitir a varios.
• Implementar el método que lanza el evento, asegurándonos de todos los oyentes reciban el aviso. En este caso lo que se ha hecho es lanzar el método que se creó en la interfaz que describe al oyente.

Finalmente el código de la clase componente queda como aparece en el siguiente enlace:

Una vez construido el componente es sencillo incorporarlo a la paleta de NetBeans. Podemos hacerlo de diferentes formas:

• Si lo hemos desarrollado nosotros mismos (con NetBeans) basta con utilizar Limpiar y Construir para generar el fichero .jar con el componente.
• Si es un componente generado por otras personas, es preciso disponer de la distribución en un fichero .jar.

Para probar el componente tendrás que importar el fichero .jar desde las propiedades del proyecto con la nueva aplicación.

La gestión de eventos pasa por crear una clase que implemente la interfaz BDModificadaListener.

public class AccedeBD implements BDModificadaListener{

en el constructor indicamos que vamos a estar escuchando si se produce el evento:

AccedeBD()
     {
          alumnos = new AlumnoBean();
          alumnos.addBDModificadaListener( (BDModificadaListener)this );
     }

y sobreescribimos el método capturarBDModificada(BDModificadaEvent ev) para escribir un mensaje cuando se produzca el evento.

public void capturarBDModificada(BDModificadaEvent ev)
    {
        System.out.println("Se ha añadido un elemento a la base de datos");
    }