Java beans

 An introduction to component-based
development in general
 Introduction to JavaBeans
 Java components
 client-side
 Working with the BDK
 The beans development life cycle
 Writing simple and advanced beans

 All engineering discplines use components to
build systems. In SE we rely on line-by-line SD.
 We have class libraries
 create objects from class libraries
 we still need to write a large amount of code
 objects are not enough

 They are like Integrated Circuit (IC)
components
 Over 20 years ago, hardware vendors learned
how to package transistors
 Hardware Engineers integrate ICs to make a
board of chips
 In SE, we are where hardware engineers were
20 years ago
 We are building software routines

 we can buy routines and use/reuse them in our
applications (assemble applications)
 JavaBeans -- portable, platform-independent
component model
 Java components are known as beans
 A bean: a reusable software component that
can be manipulated visually in a builder tool

 Beans are appropriate for software components
that can be visually manipulated
 Class libraries are good for providing
functionality that is useful to programmers,
and doesn’t benefit from visual manipulation

 A component is a self-contained reusable
software unit
 Components expose their features (public
methods and events) to builder tools
 A builder tool maintains Beans in a palette or
toolbox.

 You can select a bean from the toolbox, drop it
in a form, and modify its appearance and
behavior.
 Also, you can define its interaction with other
beans
 ALL this without a line of code.

 a public class with 0-argument constuctor
 it has properties with accessory methods
 it has events
 it can customized
 its state can be saved
 it can be analyzed by a builder tool

 A builder tool discover a bean’s features by a
process known as introspection.
 Adhering to specific rules (design pattern) when
naming Bean features.
 Providing property, method, and event information
with a related Bean Information class.
 Properties (bean’s appearance and behavior
characteristics) can be changed at design-time.

 Properties can be customized at design-time.
Customization can be done:
 using property editor
 using bean customizers
 Events are used when beans want to
intercommunicate
 Persistence: for saving and restoring the state
 Bean’s methods are regular Java methods.

 JavaBeans are subject to the standard Java
security model
 The security model has neither extended nor
relaxed.
 If a bean runs as an untrusted applet then it
will be subject to applet security
 If a bean runs as a stand-alone application then
it will be treated as a normal Java application.

 Assume your beans will be running in a multi-
threaded environment
 It is your responsibility (the developer) to make
sure that their beans behave properly under
multi-threaded access
 For simple beans, this can be handled by
simply making all methods …...

 To start the BeanBox:
 run.bat (Windows)
 run.sh (Unix)

 ToolBox contains the beans available
 BeanBox window is the form where you
visually wire beans together.
 Properties sheet: displays the properties for the
Bean currently selected within the BeanBox
window.

 Use screen captures from Windows
 Start application, following appears:
ToolBox has 16
sample
JavaBeans
BeanBox window
tests beans.
Properties
customizes
selected bean.
Method Tracer
displays debugging
messages (not
discussed)

 Initially, background selected
 Customize in Properties box

 Now, add JavaBean in BeanBox window
 Click ExplicitButton bean in ToolBox window
 Functions as a JButton
 Click crosshair where center of button should appear
 Change label to "Start the Animation"

 Select button (if not selected) and move to corner
 Position mouse on edges, move cursor appears
 Drag to new location
 Resize button
 Put mouse in corner, resize cursor
 Drag mouse to change size

 Add another button (same steps)
 "Stop the Animation"
 Add animation bean
 In ToolBox, select Juggler and add to BeanBox
 Animation begins immediately
Properties for
juggler.

 Now, "hook up" events from buttons
 Start and stop animation
 Edit menu
 Access to events from beans that are an event source
(bean can notify listener)
 Swing GUI components are beans
 Select "Stop the Animation"
 Edit->Events->button push -> actionPerformed

 Line appears from button to mouse
 Target selector - target of event
 Object with method we intend to call
 Connect the dots programming
 Click on Juggler, brings up EventTargetDialog
 Shows public methods
 Select stopJuggling

 Event hookup complete
 Writes new hookup/event adapter class
 Object of class registered as actionListener fro
button
 Can click button to stop animation
 Repeat for "Start the Animation" button
 Method startAnimation

 Save as design
 Can reloaded into BeanBox later
 Can have any file extension
 Opening
 Applet beans (like Juggler) begin executing
immediately

 import java.awt.*;
 import java.io.Serializable;
 public class FirstBean extends Canvas implements
Serializable {
 public FirstBean() {
 setSize(50,30);
 setBackground(Color.blue);
 }
 }

 Compile: javac FirstBean.java
 Create a manifest file:
 manifest.txt
 Name: FirstBean.class
 Java-Bean: True
 Create a jar file:
 jar cfm FirstBean.jar mani.txt FirstBean.class

import java.awt.*;
public class Spectrum extends Canvas {
private boolean vertical;
public Spectrum() {
vertical=true;
setSize (100,100);
}
public boolean getVertical() {
return (vertical);
}
public void setVertical(boolean vertical) {
this.vertical=vertical;
repaint ();

public void paint(Graphics g) {
float saturation=1.0f;
float brightness=1.0f;
Dimension d=getSize ();
if (vertical) {
for (int y=0;y<d.height;y++) {
float hue=(float) y/(d.height-1);
g.setColor(Color.getHSBColor(hue,saturation,brightness));
g.drawLine (0,y, d.width-1, y);
}

}
else {
for (int x=0;x<d.width; x++) {
float hue=(float) x/(d.height-1);
g.setColor(Color.getHSBColor(hue,
saturation,brightness));
g.drawLine (x, 0,x, d.width-1);
}
}
} // method ends
}// class ends

 The above Spectrum class is a subclass of
Canvas. The private boolean variable named
vertical is one of its properties. The constructor
initializes that property to true and sets the size
of the component.

 Bean’s appearance and behavior -- changeable
at design time.
 They are private values
 Can be accessed through getter and setter
methods
 getter and setter methods must follow some
rules -- design patterns (documenting
experience)
Copyright © 2001 Qusay H. Mahmoud

 A builder tool can:
 discover a bean’s properties
 determine the properties’ read/write attribute
 locate an appropriate “property editor” for each type
 display the properties (in a sheet)
 alter the properties at design-time

 Simple
 Index: multiple-value properties
 Bound: provide event notification when value
changes
 Constrained: how proposed changes can be
okayed or vetoed by other object

 When a builder tool introspect your bean it
discovers two methods:
 public Color getColor()
 public void setColor(Color c)
 The builder tool knows that a property named
“Color” exists -- of type Color.
 It tries to locate a property editor for that type
to display the properties in a sheet.

 Adding a Color property
 Create and initialize a private instance variable
 private Color color = Color.blue;
 Write public getter & setter methods
 public Color getColor() {
 return color;
 }
 public void setColor(Color c) {
 color = c;
 repaint();
 }

 For a bean to be the source of an event, it must
implement methods that add and remove
listener objects for the type of the event:
 public void add<EventListenerType>(<EventListenerType> elt);
 same thing for remove
 These methods help a source Bean know where
to fire events.

 Source Bean fires events at the listeners using
method of those interfaces.
 Example: if a source Bean register
ActionListsener objects, it will fire events at
those objects by calling the actionPerformed
method on those listeners

 Implementing the BeanInfo interface allows
you to explicitly publish the events a Bean fires

 Question: how does a Bean exposes its features
in a property sheet?
 Answer: using java.beans.Introspector class
(which uses Core Reflection API)
 The discovery process is named
“introspection”
 OR you can associate a class that implements
the BeanInfo with your bean

 Why use BeanInfo then?
 Using BeanInfo you can:
 Expose features that you want to expose

 The appearance and behavior of a bean can be
customized at design time.
 Two ways to customize a bean:
 using a property editor
 each bean property has its own editor
 a bean’s property is displayed in a property sheet
 using customizers
 gives you complete GUI control over bean
customization
 used when property editors are not practical

 A property editor is a user interface for editing
a bean property. The property must have both,
read/write accessor methods.
 A property editor must implement the
PropertyEditor interface.
 PropertyEditorSupport does that already, so you
can extend it.

 If you provide a custom property editor class,
then you must refer to this class by calling
PropertyDescriptor.setPropertyEditorClass in a
BeanInfo class.
 Each bean may have a BeanInfo class which
customizes how the bean is to appear.
SimpleBeanInfo implements that interface

 JavaBeans are just the start of the Software
Components industry.
 This market is growing in both, quantity and
quality.
 To promote commercial quality java beans
components and tools, we should strive to
make our beans as reusable as possible.
 Here are a few guidelines...

 Creating beans
 Your bean class must provide a zero-argument
constructor. So, objects can be created using
Bean.instantiate();
 The bean must support persistence
 implement Serializable or Externalizable

Java beans

More Related Content

What's hot (20)

Viewers also liked (16)

Similar to Java beans (20)

More from Ramraj Choudhary (8)

Recently uploaded (20)

Java beans