Java Bean Definition “A Java Bean is a reusable software component that can be manipulated visually in a builder tool.”

JavaBean Properties –Similar to instance variables. Methods –Same as normal Java methods. –Every property should have accessor (get) and mutator (set) –method. Events –Similar to Swing/AWT event handling.

Features of a Java Bean Support for “introspection” so that a builder tool can analyze how a bean works. Support for “customization” to allow the customisation of the appearance and behaviour of a bean. Support for “events” as a simple communication metaphor than can be used to connect up beans. Support for “properties”, both for customization and for programmatic use. Support for “persistence”, so that a bean can save and restore its customized state.

Why use JavaBeans? Component Granularity Portability Simplicity Uniform, high-quality API that will enable developers to write programs that will perform consistently everywhere.

JavaBeans Vs Class Libraries Beans should be used for software components that can be visually manipulated and customized. Class libraries should be used to provide functionality to programmers, but which doesn't benefit from visual manipulation.

Java Beans Concepts 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.

Java Bean Characteristics a public class with 0-argument constructor it has properties with access methods it has events it can be customized its state can be saved it can be analyzed by a builder tool

Key Concepts 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.

Key Concepts…. 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. Beans will also be running in a multi-threaded environment

Security Issues JavaBeans are subject to the standard Java security model The security model has neither been 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.

Beans Development Kit (BDK) –To start the BeanBox: run.bat (Windows) run.sh (Unix)

BDK Tool Box contains the beans available Bean Box window is the form where you visually wire beans together. Properties sheet: – displays the properties for the Bean currently selected within the BeanBoxwindow.

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

First Bean Compile: javac FirstBean.java Create a manifest file: –manifest.txt (jar file metadata) Name: FirstBean.Class Java-Bean: True Create a jar file: –jar cfm FirstBean.jar mani.txt FirstBean.class

Properties 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)

Design Patterns for properties Property is a subset of a bean’s state –Simple properties Has a single value –Public T getN(); –Public void setN(T arg); –Public boolean isN(); ( isdotted) –Indexed properties Consists of multiple values –Public T getN(index); –Public void setN(int index, T value); –Public T[ ] getN(); –Public void setN(T values[ ]);

Introspection Process of analyzing a bean to determine its capabilities Allows an application builder tool to present information about a software component to the designer –Simple naming conventions –A class that explicitly supplies this information

Properties 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

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

Simple Properties 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.

Simple Properties…. 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(); }

Indexed Properties An indexed property is for when a single property can hold an array of values. –The design pattern for these properties is: public void setPropertyName (PropertyType[] list) public void setPropertyName ( PropertyType element, int position) public PropertyType[] getPropertyName () public PropertyType getPropertyName (int position)

For instance, if you were to complete the item indexed property for the AWT List component, it might look something like this: public class ListBean extends List { public String[] getItem () { return getItems (); } public synchronized void setItem (String item[]) { removeAll(); for (int i=0;i<item.length;i++) addItem (item[i]); } public void setItem (String item, int position) { replaceItem (item, position) } The String getItem (int position) routine already exists for List

Bound Properties Provide event notification when value changes In order for the notification to happen, you need to maintain a watch list for PropertyChangeEvents via the PropertyChangeSupport class.PropertyChangeEventPropertyChangeSupport First, you have to create a list of listeners to maintain: private PropertyChangeSupport changes = new PropertyChangeSupport (this); And then, you have to maintain the list: public void addPropertyChangeListener (PropertyChangeListener p) { changes.addPropertyChangeListener (p); } public void removePropertyChangeListener ( PropertyChangeListener p) { changes.removePropertyChangeListener (p); }

Constrained properties Constrained properties are similar to bound properties. In addition to maintaining a list of PropertyChangeListeners, the Bean maintains a list of VetoableChangeListeners.VetoableChangeListener Prior to the Bean changing a property value, it asks the VetoableChangeListeners if its okay. If it isn't, the listener throws a PropertyVetoException, which you declare the set routine to throw. PropertyVetoException

Adding… private VetoableChangeSupport vetoes = new VetoableChangeSupport (this); public void addVetoableChangeListener ( VetoableChangeListener v) { vetoes.addVetoableChangeListener (v); } public void removeVetoableChangeListener ( VetoableChangeListener v) { vetoes.removeVetoableChangeListener (v); }