- A definition --" A Java Bean is a resuable software component that can be manipulated visually in a builder tool."
- a software component model
- reusable -- third party developers can individually create Java components and that these components can be composed to form end-user applications.
- can be visually manipulated in a builder tool -- these components can be visually manipulated and composed in any one of a number of integrated development environments
- platform neutral
- extends Java's "Write Once, Run Anywhere" capability to reusable component development.
- small to medium sized controls
- not required to inherit from any particular base class or interface
- although visible beans must inherit from java.awt.Component
- primarily targeted at builder tools they are also entirely usable by human programmers
- not all useful software modules should turn into beans
- Borland’s J Builder
- IBM’s Visual Age for Java
- Penumbra Software’s Mojo
- Sunsoft’s Java Workshop
- Symantec’s Visual Café
- Sybase's PowerJ
- and dozens more
- Used as application building blocks.
- As a full application, which may then be composed with another (by the end user) to form a compound document.
- Those two aspects overlap
- Simple GUI elements such as buttons and sliders
- Sophisticated visual software components -- such as database viewers, data feeds
- May have no GUI appearence of their own, but may still be composed together visually using an application builder.
- Persistence - A Bean can serialise itself for storage reasons. Its internal state is stored away so that it can be reincarnated at a later stage with similar appearance and behaviour.
- Properties - These are named attributes that can affect the appearance or behaviour of a Bean. Typically they are persistent so that their state can be stored as part of the persistent state of the Bean. They are accessed through get and set methods so that the Bean has full control over any property changes.
- Events - An event is a notification between a source and one or more listeners. It provides a mechanism for connecting Beans. A listener can express interest in a particular event and will subsequently be notified when that event occurs.
- Introspection - This is the ability for an external piece of software to analyse a bean to determine its properties, events and methods.
- Customisation - It is unlikely that a Bean, as distributed, will exactly match the requirements of a particular application. This is, in fact, a good thing. Users need to be able to customise the appearance and behaviour of the various Beans they are using. This can happen in two ways:
1.A builder can construct a property
sheet for a Bean based on the Beans properties.
The user can then
use the property sheet to update the various properties of the Bean.
2.A Bean can have an associated customiser
class that controls customisation. This can
provide whatever
User Interface behaviour it wishes and can be run in order to
customise the Bean.
The JFC (Java Foundation Classes) is based upon the AWT (Abstract Windowing Toolkit), which has been part of the Java platform from the beginning. JFC effectively adds a richer set of visual elements for building JavaBeans components and applications.
- The way the Beans talk to the servers is not specified and therefore
not restricted, however, three mechanisms will be made available to developers
on all Java platforms.
- Java IDL(Interface Definition Language) - Allows method invocation on CORBA 2.0 compliant object servers using IIOP (Internet Inter Orb Protocol)
- Java RMI - Remote Method Invocation for native Java object servers
- JDBC - Java DataBase Connectivity allows Java Bean components to access SQL databases. A Java Bean could be written to provide tailored access to particular database tables.
- a bean must be capable of running inside a builder tool==design environment :: design time
- each bean msut be usable at run-time within the generated application. :: run time
- need to split betwwen the two aspects of a bean
- should be possible to deploy a bean at run-time without needing to download all its design time code
- neither extended nor relaxed the standard Java security mdel
- bean as an untrusted applet will not be allowed to read or write arbitrary files, or to connect to arbitrary network hosts.
- beans as a Java application or as part of a trusted (signed) applet will be treated as a normal Java application and allowed normal access to files and network hosts.
- Recommendation: build your beans as part of untrasted applets
- Introspection: Bean developers should assume that they have limited access in the run-time environment
- Persistence: in run-time environment, Beans should expect the serialization stream to be created and controlled by their parent application and should not assume that they can control where serialized data is read from or written to.
- GUI merging: In general untrusted applets will not be permitted to perform any kind of GUI merging with their parent application.
- JDK-- need JDK 1.1
- Beans Development Kit (BDK)
The Beans Development Kit (BDK) is a pure Java application whose only dependency is the Java Development Kit (JDK) 1.1. The BDK provides support for the JavaBeans APIs and a BeanBox. - The BeanBox, provided as part of the BDK, is provided as a test container to allow JavaBeans developers to test and evaluate Bean behavior.
- A Bean is an autonomous component that potentially has its own configuration User Interface.
- Your code runs on every OS and also within any application environment.
- ideal choice for developing or assembling network-aware solutions for heterogeneous hardware and operating system environments. -- well , in Java world.