Download Programación en Java2 - Universidad de La Serena

Prof. Dr. Eric Jeltsch F.
Programación en Java2
Cap 16:JavaBeans
Capitulo 16. JavaBeans
La idea es ahora utilizar las componentes de Java, la pregunta que surge entonces es como
poder tener un almacén de recursos que sea capaz de responder a estos requerimientos. En
parte esta inquietud la soluciona JavaBeans que es una herramienta en el contexto de
ensamblaje de componentes de software o en el desarrollo de software basados en
componentes.
La idea es reutilizar los componentes de software de Java, a menudo estos son componentes
GUI que están visibles, en resumen es el modelo de componentes de software que empezara
VisualBasic y Delphi, que son modelos que se centran en el uso de los componentes y
contenedores. Para entender mejor estos términos digamos que los componentes son entidades
de software especializadas que pueden ser reproducidas, personalizadas e insertadas en
aplicaciones y applets, y los contenedores son simplemente componentes que contienen otros
componentes, estos últimos se usan como estructura para organizar los componentes de una
manera visual, estas herramientas de desarrollo visual permiten arrastrar y soltar, cambiar de
tamaño y colocar los componentes en un contenedor. Los componentes y contenedores de
JavaBeans son similares en gran medida a las clases Component y Container de l AWT. En
resumen estas capacidades ofrecen a los programadores de software la posibilidad de
reutilñizar al máximo los componentes de software a la hora de crear o mejorar el existente.
La idea en este capítulo es saber como utilizar el BDK(herramientas de desarrollo de
JavaBeans)para crear nuestros propios componentes o mejorar algunos otros. Para ello deberá
descargar el BDK1.1 desde http://www.java.sun.com/beans/index.html .
BeanBox
El BDK proporciona varios ejemplos de componentes de software de Java, lecciones y
documentos de apoyo, pero lo más importante es la herramienta BeanBox, que se puede usar
para mostrar, personalizar y probar los componentes de software que se vayan desarrollando.
Además BDK, sirve como una herramienta primitiva de desarrollo visual. Para ver como
trabaja vayamos a la distribución BDK1.1 que contiene una serie de archivos, se supone que
Ud. habrá podido instalarlo de la forma que lo recomienda la distribución.
1
Area de Computación , Universidad de La Serena
Prof. Dr. Eric Jeltsch F.
Programación en Java2
Cap 16:JavaBeans
El archivo se ve de esta manera, en donde beanbox tiene un archivo ejecutable
Al ingresar al directorio \beanbox podrá ver los siguientes archivos, si Ud. nota existe un
archivo ejecutable llamado run.
2
Area de Computación , Universidad de La Serena
Prof. Dr. Eric Jeltsch F.
Programación en Java2
Cap 16:JavaBeans
Al ejecutarlo podra ver que se despliegan 4 interfaces gráficas asociada a distintos eventos,
que luego explicaremos.
3
Area de Computación , Universidad de La Serena
Prof. Dr. Eric Jeltsch F.
Programación en Java2
Cap 16:JavaBeans
La ventana ToolBox contiene una lista de los componentes de software de Java que están a su
disposición, estos componentes se pueden usar para construir otros componentes más
complejos, aplicaciones de Java o applets.
Las herramientas de desarrollo visual de software, como BeanBox, permiten que los
componentes de software estén visualmente organizados colocándolos en la posición deseada.
Si Ud. pulsa Juggler de la ventana ToolBox y luego pulse en el BeanBox; el componente
Juggler se depositará en el BeanBox, haciéndo malabares.
Observar que la Properties Juggler se actualiza para mostrar las propiedades del componente
Juggler. Puede personalizar éste componente cambiando sus propiedades, por ejemplo note
como disminuye la intensidad de los malabares para cuando animationRate es 500.
Ahora con el fin de formar un componente propio añadiremos un par de botones al BeanBox,
para ello seleccionamos un componente OurButton del ToolBox y lo colocamos en BeanBox,
como se muestra, generando un botón con label press. Utilicemos ahora la hoja de
propiedades para cambiar su etiqueta a comenzar
4
Area de Computación , Universidad de La Serena
Prof. Dr. Eric Jeltsch F.
Programación en Java2
Cap 16:JavaBeans
Si cambia la propiedad label press a label comenzar, Ud. verá en BeanBox el botón con el
nuevo rótulo.
Ahora cree un segundo botón, llamado terminar, haciéndo el mismo procedimiento anterior,
con la diferencia que ahora en las Properties le alteramos los colores.
5
Area de Computación , Universidad de La Serena
Prof. Dr. Eric Jeltsch F.
Programación en Java2
Cap 16:JavaBeans
Ahora veremos como hacer efectivo que estos botones habiliten al malabarista a comenzar y
terminar el malabarismo según presionemos el botón correspondiente. Para hacerlo
necesitamos conectar un manipulador de eventos, se recuerdan de actionPerformed(), bien
este será el manipulador de evento del botón comenzar al método startJuggling() del
componente Juggler y el manipulador de eventos del botón terminar al método stopJuggling()
del componente Juggler.
6
Area de Computación , Universidad de La Serena
Prof. Dr. Eric Jeltsch F.
Programación en Java2
Cap 16:JavaBeans
Tras de haber escogido el boton comenzar, y luego ir a Edit | Events | action | actionPerformed
de la barra de menú de BeanBox, como se muestra en la figura anterior, le aparece una línea
roja que procede del botón comenzar, esta línea representa una conexión lógica desde el
manipulador de eventos actionPerformed() del botón comenzar. Pulse el componente Juggler
para cerrar la conexión. Al hacerlo aparecerá el EventTargetDialog box que se ve así
Este cuadro de diálogo lista los métodos de interfaz del componente Juggler. Seleccione
startJuggling, pues al hacerlo estará conectando la pulsación del botón comenzar al método
startJuggling() a través del manipulador de eventos actionPerformed() del componente de
botón comenzar. El cuadro EventTargetDialog le informa que está compilando una clase de
adaptador, el BeanBox crea una clase especial, que se denomina clase adaptador, para
conectar la pulsación del botón con el método startJuggling() del Juggler, éste debe compilar
esta clase y agregarla al BeanBox que está corriendo para admitir esta conexión.
Analogamente lo podrá hacer con el botón terminar, pero esta vez deberá conectarlo a
stopJuggling(). Lista la animación !!
7
Area de Computación , Universidad de La Serena
Prof. Dr. Eric Jeltsch F.
Programación en Java2
Cap 16:JavaBeans
Notar que no ha escrito ni una sola línea de código y ya tiene una animación, éste es en parte
el poder que tiene el desarrollo de software basados en componentes. Con un buen conjunto
de componentes de software, puede ensamblar rápida y fácilmente una gran variedad de
aplicaciones. En la aplicación anterior, hemos aprendido a utilizar los componentes OurButton
y Juggler. El ToolBox que trae BeanBox incluye 16 componentes de software.
Recomendamos que los utilice para ir ganando confianza en la forma de generar nuevos
componentes a partir de los ya existentes. Ahora damos una breve descripción de los
componentes que vienen en el ToolBox.
 BlueButton, un botón azul sencillo, que cuenta con propiedades para fondo, frente,
etiqueta y fuente.
 OrangeButton, analogo al anterior.
 OurButton, un botón gris que tiene propiedades de fuentes adicionales.
 ExplicitButton, un botón gris sencillo que cuenta con propiedades para fondo, frente,
etiqueta y fuente.
 EventMonitor, un área de texto que se utiliza para visualizar los eventos a medida que
estos se van produciendo.
 JellyBean, una componente particular.
 Juggler, nuestro malabarista.
 TickTock, un contador de intervalos.
 Voter, un componente que mantiene un estado si o no.
 ChangeReporter, un campo de texto.
 Molecule, un campo gráfico que muestra imágenes 3D de moléculas.
 QuoteMonitor, un componente que muestra las cotizaciones de Bolsa que se reciben de un
servidor de cotizaciones.
 JDBC SELECT, una interfaz SQL de una BD.
 SorterBean, animación de una burbuja.
 BridgeTester, componente que se utiliza para verificar puentes de componentes de
software(uso del InfoBus).
 TransitionalBean, un botón que cambia los colores.
El BeanBox es una herramienta de diseño visual bastante elemental, pero ofrece
características importantes del desarrollo visual de software basados en componentes. Así
como estas existen otras herramientas comerciales, por ejemplo, Java Studio (Sun), Java
Workshop2.0(Sun), Visual J++(Microsoft), Forte(Sun, por ahora gratuito), Jbuilder(Borland).
Formas de salvar los JavaBean
El BeanBox proporciona varias formas para salvar los diseños incluyendo:
a) almacenar el diseño para ser cargado más tarde en el BeanBox(archivo Menu |
Save...menuitem)
b) almacenar el diseño como un Java applet(archivo Menu | MakeApplet...menuitem.
c) Existe incluso una tercera opción SerializeComponent, que puede ser usada para ayudar a
crear un nuevo JavaBean. Para más información remitase a doc de la distribución
BDK1.1.
8
Area de Computación , Universidad de La Serena
Prof. Dr. Eric Jeltsch F.
Programación en Java2
Cap 16:JavaBeans
Para salvar las aplicaciones según a), seleccionamos del menu File y Save..menuitem, a lo que
se desplegará un cuadro de diálogo llamado Save BeanBox File. Como lo muestra la figura
siguiente.
Esta opción usa un objeto serialization para salvar el beans en el diseño, hemos llamado a
nuestro archivo miJuggler.ser (hemos usado la extensión .ser para indicar que el diseño es un
archivo serializado), el que por defecto será guardado en el directorio beanbox de la
distribución BDK1.1, si lo desea guardar en otra parte, use el dialogo para cambiarlo antes de
pulsar Save. Para verificar, que lo ha hecho bien vaya a File de BeanBox, pulse Load y
nombre de su archivo, a lo que se visualizará en BeanBox automáticamente lo que Ud. desea
guardar. Una vez verificado pulse en File, clear. En estos instantes el beans miJuggler es un
applet, y su actuación es similar a cuando abrimos un applet desde un Browser.
Para salvarlo como applet, seleccionamos MakeApplet, a lo que se despliega lo siguiente
El nombre por defecto es MyApplet, pero evidentemente Ud. tiene su propio nombre,
entonces pulse el botón Choose JAR File...para desplegar el siguiente diálogo.
9
Area de Computación , Universidad de La Serena
Prof. Dr. Eric Jeltsch F.
Programación en Java2
Cap 16:JavaBeans
Y procede a poner el nombre que desea, para mi miJuggler.jar es apropiado.
Luego de pulsar el botón OK, verá
Como Ud. ve JavaBeans son almacenados en archivos JAR, Ud. puede cambiar el directorio
en el cual los archivos han sido almacenados. Por defecto, los applet son almacenados en el
directorio BDK1.1\beanbox\tmp\myApplet
Si trata de ejecutar miAni.html que es otra animación a través de TextPad le sale el
siguiente mensaje:
<html>
<head>
<title>Test page for MiAni as an APPLET</Title>
</head>
<body>
10
Area de Computación , Universidad de La Serena
Prof. Dr. Eric Jeltsch F.
Programación en Java2
Cap 16:JavaBeans
<h1>Test for MiAni as an APPLET</h1>
This is an example of the use of the generated
MiAni1 applet. Notice the Applet tag requires several
archives, one per JAR used in building the Applet
<p>
<applet
archive="./miAni.jar,./support.jar
,./juggler.jar
,./buttons.jar
" /* son las propiedades del archivo del tag <applet>*/
code="MiAni" /* especifica el nombre de la clase applet con la que comenzará la
ejecución de nuestro applet*/
width=382
height=513
>
Trouble instantiating applet MiAni!!
</applet>
para visualizar el applet, vaya a C:\BDK1.1\beanbox\tmp\myApplet e inserte el comando
>appletviewer miAni.html
Desarrollo de Componentes de Software
Es el momento de aprender a desarrollar nuestros propios componentes de software, para tal
efecto debe saber que JDK1.2 presenta el paquete java.beans.beancontext, que ofrece las
clases e interfaces que sirven para hacer que los componentes de software accedan a su
entorno de ejecución, al que se llama contexto de componente de software. En primer lugar,
pediremos un marcador sencillo llamado Gauge y otro lienzo llamado Tcanvas. Examine cada
uno de ellos.
Gauge
Asi se ve el BeanBox y ToolBox, luego de haber cargado los archivos Gauge.jar y
TCanvas.jar en el directorio jars de la distribución BDK1.1
11
Area de Computación , Universidad de La Serena
Prof. Dr. Eric Jeltsch F.
Programación en Java2
Cap 16:JavaBeans
Ud. notará que se cambio el sentido del “campo de texto” y se ensancho su magnitud, a eso
me refiero con practicar con los beans. A través de los cambios que puede realizar sobre
Properties Gauge, podrá darse cuenta de otras “gracias” que Gauge posee.
Por ejemplo, cambie currentValue a 0.7, horizontal a false, height a 200, gaugeColor a
verde(green) y valueColor a naranja(orange), a lo que se obtiene,
12
Area de Computación , Universidad de La Serena
Prof. Dr. Eric Jeltsch F.
Programación en Java2
Cap 16:JavaBeans
Lo que debemos observar es que en el código fuente del componente de software Gauge este
la línea java.io.Serializable. Todas las clases de componentes de software implementan
Serializable o Externalizable. Estas interfaces admiten la persistencia en los componentes de
software, permitiendo que éstos se lean y se escriban, almacenándose de forma
permanente(por ejemplo, en disco duro). Cuando un componente de software implementa
Serializable, la serialización de los datos de un componente los ejecuta Java automáticamente,
lo cual implica que no tiene que figurarse como escribir objetos en los flujos o cómo leerlos
en él. Por otra parte un componente de software es Externalizable, el componente es el que
ejecuta toda la serialización. Serializable es una de las más fácil, basta con agregar
Serializable a la cláusula implements de la clase y la serialización quedará admitida
automáticamente. El icono en ToolBox es originado por el archivo GaugeBeanInfo para que
pueda desplegarse el icono, es decir implementa solo el método getIcon(), vea el archivo. Por
otra parte el archivo Gauge.mf se usa para construir el archivo Gauge.jar. Identifica el archivo
Gauge.class como un componente de software. Para crear el archivo Gauge.jar, utilizar
>jar cfm Gauge.jar Gauge.mf Gauge*.class gauge*.gif
De la misma manera, habrá notado que TCanvas se encuentra en ToolBox.
13
Area de Computación , Universidad de La Serena
Prof. Dr. Eric Jeltsch F.
Programación en Java2
Cap 16:JavaBeans
Para distinguirlo del resto del BeanBox y mostrar como funcionan sus propiedades veamos los
siguientes cambios: text a Esto es una prueba, leftMargin y topMargin a 20, font a 14 pt(pulse
la propiedad font para abrir el cuadro de dialogo FontEditor), y background a amarillo. Asi se
ven los efectos, tras los cambios.
14
Area de Computación , Universidad de La Serena
Prof. Dr. Eric Jeltsch F.
Programación en Java2
Cap 16:JavaBeans
Ahora que se ha familiarizado con un par de componentes de software, vamos a utilizarlos en
un applet. El applet se llama Test, el cual emplea ambos componentes de software Gauge y
TCanvas.
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class Test extends Applet {
TCanv pregunta = new TCanv();
Gauge miGauge = new Gauge();
String labels[]={"
A
","
B
","
C
","
Button button[] = new Button[labels.length];
TCanv estatus=new TCanv();
int preguntas = 0;
int respCorrecta = 0;
int respActual;
D
"};
public void init() {
Panel mainPanel = new Panel();
Panel gaugePanel = new Panel();
Panel bottomPanel = new Panel();
Panel buttons = new Panel();
pregunta.setLeftMargin(20);
15
Area de Computación , Universidad de La Serena
Prof. Dr. Eric Jeltsch F.
Programación en Java2
Cap 16:JavaBeans
pregunta.setTopMargin(20);
miGauge.setHorizontal(false);
miGauge.setMaxValue(100.0);
miGauge.setCurrentValue(100.0);
miGauge.setHeight(200);
miGauge.setWidth(20);
estatus.setHeight(20);
estatus.setWidth(200);
estatus.setTopMargin(0);
estatus.setBorder(false);
mainPanel.setLayout(new BorderLayout());
mainPanel.add("Center",pregunta);
gaugePanel.add(new Label("Marcador: (0-100%)"));
gaugePanel.add(miGauge);
mainPanel.add("East",gaugePanel);
bottomPanel.setLayout(new BorderLayout());
for(int i=0;i<labels.length;++i){
button[i] = new Button(labels[i]);
button[i].addActionListener(new BotonTrato());
buttons.add(button[i]);
}
buttons.add(estatus);
bottomPanel.add("Center",buttons);
mainPanel.add("South",bottomPanel);
add(mainPanel);
}
public void start(){
displayPregunta();
}
void displayPregunta() {
pregunta.setText(nextPregunta());
if(preguntas==0) estatus.setText("Click la respuesta
correcta.");
else{
String s="Preguntas: "+String.valueOf(preguntas);
s+=" Correcta: "+String.valueOf(respCorrecta);
estatus.setText(s);
}
}
String nextPregunta() {
String q = "Cuánto es ";
String operand[] = {"+","-","*"};
int op1 = randomInt(100);
int op2 = randomInt(100);
int op = randomInt(3);
String operador = operand[op];
int resp=0;
switch(op){
16
Area de Computación , Universidad de La Serena
Prof. Dr. Eric Jeltsch F.
Programación en Java2
Cap 16:JavaBeans
case 0:
resp=op1+op2;
break;
case 1:
resp=op1-op2;
break;
case 2:
resp=op1*op2;
break;
}
respActual=randomInt(labels.length);
q+=String.valueOf(op1)+operador+String.valueOf(op2)+"?| ";
for(int i=0;i<labels.length;++i){
q+="|"+labels[i];
if(i==respActual) q+=String.valueOf(resp);
else{
int delta = randomInt(10);
if(delta==0) delta=1;
int add = randomInt(2);
if(add==1) q+=String.valueOf(resp+delta);
else q+=String.valueOf(resp-delta);
}
}
return q;
}
int randomInt(int max){
int r = (int) (max*Math.random());
r %= max;
return r;
}
void respuesta(int i){
++preguntas;
if(i==respActual){
++respCorrecta;
displayPregunta();
}else{
estatus.setText("Trate nuevamente!");
}
double marcador = (double) respCorrecta/(double) preguntas;
miGauge.setCurrentValue(marcador*100.0);
miGauge.repaint();
pregunta.repaint();
estatus.repaint();
}
class BotonTrato implements ActionListener {
public void actionPerformed(ActionEvent e){
String s = e.getActionCommand();
for(int i=0;i<labels.length;++i){
17
Area de Computación , Universidad de La Serena
Prof. Dr. Eric Jeltsch F.
Programación en Java2
Cap 16:JavaBeans
if(labels[i].equals(s)){
respuesta(i);
break;
}
}
}
}
}
Las preguntas se presentan en forma aleatoria con el objeto de reducir la probabilidad de que
una pregunta se formule 2 veces. Cuando se pulsa en una respuesta, las componentes de
software de Tcanvas se actualizan con nuevas preguntas e información del estado. El
componente Gauge actualiza el resultado de las respuestas del usuario. Tcanvas y Gauge han
sido importadas para ver su aplicación en el contexto del archivo test.java.
18
Area de Computación , Universidad de La Serena