Escribir un Bean Sencillo

En ésta página aprenderemos algo más sobre los Beans y BeanBox:

Creando un Bean sencillo.
Compilando y guardando el Bean en un archivo JAR.
Cargaando el Bean en el ToolBox
Arrastrando un ejemplar del Bean dentro del BeanBox.
Inspeccionando las propiedades del Beans, los métodos y los eventos.
Generando un informe de introspección.

Nuestro Bean se llamará SimpleBean. Aquí tienes los pasos para crearlo y verlo en el BeanBox:

Escribir el código de SimpleBean. Ponerlo en un fichero llamado SimpleBean.java, en cualquier directorio. Aquí tienes el código:
```
   
import java.awt.*;
import java.io.Serializable;
         
public class SimpleBean extends Canvas
                     implements Serializable{
 
  //Constructor sets inherited properties
  public SimpleBean(){
   setSize(60,40);
   setBackground(Color.red);
  }
}
```
SimpleBean desciende del componente java.awt.Canvas. También implementa el interface java.io.Serializable, que es requerido por todos los beans. Seleccionar el color del fondo y el tamaño del componente es todo lo que hace SimpleBean.
Asegurate de que la variable de entorno CLASSPATH apunta a todos ficheros .class (o .jar) necesarios.
Compila el Bean:
```
      javac SimpleBean.java
```
Esto produce el fichero de clase SimpleBean.class
Crea un fichero de manifiesto. Utiliza tu editor de texto favorito para crear un fichero, que llamaremos manifest.tmp, que contenga el siguiente texto:
```
     Name: SimpleBean.class
     Java-Bean: True
```
Crea el fichero JAR. Este fichero contendrá el manifiesto y el fichero de clase SimpleBean:
```
     jar cfm SimpleBean.jar manifest.tmp SimpleBean.class
```
Carga el fichero JAR en el ToolBox. Despliega el menú File|LoadJar... Esto traerá un navegador de ficheros. Busca la posición del fichero SimpleBean.jar y seleccionalo. SimpleBean aparecerá en la parte inferior del ToolBox. (Observa que cuando arranca el BeanBox, todos los beans que haya en el directorio beans/jars se cargan automáticamente en el ToolBox).
Arrastra un ejemplar de SimpleBean dentro del BeanBox. Pulsa sobre la palabra SimpleBean en el ToolBox. El cursor cambia a un punto de mira. Mueve el cursor al punto del BeanBox donde quieres situar el Bean y pulsa de nuevo el ratón. SimpleBean aparecerá como un rectángulo pintado con un borde marcado. Esto borde significa que está seleccionado. Las propiedades de SimpleBean aparecerán en la hoja de propiedades.

Se puede redimensionar el SimpleBean, ya que desciende de Canvas, arrastrando una esquina de la ventana. Veras como el cursor cambia a un ángulo recto cuando pasa sobre una esquina. También se puede reposicionar dentro del BeanBox, arrastando desde cualquier parte del borde que no sea una esquina. Verás que el cursor cambia a una flechas cruzadas cuando pasa por estas posiciones.

Makefiles de SimpleBean

Abajo tienes dos MakeFiles (Unix y Windows) configurados para crear SimpleBean.


# gnumake file

CLASSFILES= SimpleBean.class

JARFILE= SimpleBean.jar

all: $(JARFILE)

# Create a JAR file with a suitable manifest.
$(JARFILE): $(CLASSFILES) $(DATAFILES)
        echo "Name: SimpleBean.class" >> manifest.tmp
        echo "Java-Bean: True" >> manifest.tmp
        jar cfm $(JARFILE) manifest.tmp *.class
        @/bin/rm manifest.tmp

# Compile the sources
%.class: %.java
        export CLASSPATH; CLASSPATH=. ; \
        javac $<

# make clean
clean:
        /bin/rm -f *.class
        /bin/rm -f $(JARFILE)

Aquí tienes la versión Windows de nmake:


# nmake file
CLASSFILES= simplebean.class

JARFILE= simplebean.jar

all: $(JARFILE)

# Create a JAR file with a suitable manifest.

$(JARFILE): $(CLASSFILES) $(DATAFILES)
        jar cfm $(JARFILE) << manifest.tmp *.class
Name: SimpleBean.class
Java-Bean: True
<<

.SUFFIXES: .java .class

{sunw\demo\simple}.java{sunw\demo\simple}.class :
        set CLASSPATH=.
        javac $<

clean:
        -del sunw\demo\simple\*.class
        -del $(JARFILE)

Se pueden utilizar estos makefiles como plantillas para crear los tuyos propios. Los makefiles de ejemplo, situados en el directorio beans/demo también te enseñan como utilizar los makefiles para construir y mantener tus Beans.

Inspeccionar las Propiedades y Eventos de SimpleBean

La hoja de propiedades muestra las propiedades del Bean seleccionado. Si seleccionamos SimpleBean, la hoja de propiedades mostrará cuatro propiedades: foreground, background, font, y name. Nosotros no declaramos propiedades en SimpleBean (lo verás más adelante), por eso estas propiedades son heredadas de Canvas. Pulsando sobre cada propiedad se lanza un editor de propiedad. El BeanBox proporcionar editores por defecto para los tipos primitivos, además de los tipos Font y Color. Puedes encontrar los fuentes para estos editores de propiedades en beans/apis/sun/beans/editors.

Los Beans se comunican unos con otros enviando y recibiendo notificaciones de eventos. Para ver los eventos que SimpleBean puede enviar, elige el menú Edit|Events. Se mostrará una lista de eventos agrupados por interfaces. Bajo cada grupo de interface hay una lista de métodos de evento. Todos estos son heredados de Canvas.

Podrás aprender más sobre propiedades y eventos en próximas secciones.

Generar un Informe de Introspección del Bean

La introspección es el proceso de descubrir las características de un Bean en tiempo de diseño por uno de estos dos métodos:

Reflexión de bajo nivel, que utiliza patrones de diseño para descubrir las características del Bean.
Examinando una clase asociadd de información del Bean que describe explícitamente las características del Bean.

Se puede generar un informe de introspección elegiendo el menú Edit|Report. El informe lista los eventos, las propiedades y los métodos del Bean además de sus características.

Por defecto los informes son enviados a la salida estándard del intérprete Java, que es la ventana donde has arrancado BeanBox. Se puede redireccionar el informe a un fichero cambiando el comando del intérprete Java en beanbox/run.sh o run.bat:

java sun.beanbox.BeanBoxFrame > beanreport.txt

Ozito