Java Beans is the most important new development in Java this year. Beans is the next generation of Java technology that not only adds features the language lacked, but also lets Java programs interoperate with a number of development environments. The initial release includes a bridge for Microsoft's ActiveX/COM; future releases will include bridges for Netscape's LiveConnect and IBM's OpenDoc.Since it's a "component architecture" for Java, Beans can be used in graphical programming environments, like Borland's JBuilder, or IBM's VisualAge for Java. This means that someone can use a graphical tool to connect a lot of Beans together and make an application, without actually writing any Java code -- in fact, without doing any programming at all. Graphical development environments let you configure components by specifying aspects of their visual appearance (like the color or label of a button) in addition to the interactions between components (what happens when you click on a button or select a menu item).One important aspect of Java Beans is that components don't have to be visible. This sounds like a minor distinction, but it's very important: the invisible parts of an application are the parts that do the work. So, for example, in addition to manipulating graphical widgets, like checkboxes and menus, Beans allows you to develop and manipulate components that do database access, perform computations, and so on. You can build entire applications by connecting pre-built components, without writing any code.Developing Java Beansis for people who need to stay up-to-date with the latest developments in programming technology. Minimally, developing Beans means adopting several simple design patterns in your code. However, that's only the beginning. To take full advantage of the Java Beans architecture, you should understand how to write classes that are serializable, use events for communication between classes, know when and how to provide BeanInfo classes that give graphical environments more information about your components, and provide property editors and customizers that let graphical tools work with more complex Beans.The book covers: Events, event listeners, and adapters Properties, indexed properties, bound properties, constrained properties, and vetoable property changes Persistence, serialization, versioning, and object validation Packaging Beans using JAR files The BeanBox, a prototypical development tool Reflection and introspection Property editors and customizers The ActiveX bridge; using Java Beans in Visual Basic programs

Robert Englander
Robert Englander is Principal Engineer and President of MindStream Software, Inc. (www.mindstrm.com). He provides consulting services in software architecture, design, and development, as well as developing frameworks for use on client projects. His focus is in the areas of component architectures and distributed systems. Rob has built software in Java and C++ for clients ranging from small shops to large organizations. He has spoken at industry conferences, written articles for magazines and journals, and is the author of the OReilly book Developing Java Beans.

Preface

xi

1. Introduction

1

(12)

The Component Model

1

(3)

The JavaBeans Architecture

4

(3)

JavaBeans Overview

7

(4)

Using Design Patterns

11

(1)

JavaBeans vs. ActiveX

12

(1)

Getting Started

12

(1)

2. Events

13

(20)

The Java Event Model

13

(13)

Events in the AWT Package

26

(7)

3. Event Adapters

33

(26)

Demultiplexing

33

(6)

Generic Adapters

39

(7)

Event Adapters in the AWT Package

46

(4)

Event Filtering

50

(1)

Event Queuing

51

(8)

4. Properties

59

(26)

Accessing Properties

59

(3)

Indexed Properties

62

(3)

Bound Properties

65

(6)

Constrained Properties

71

(5)

Handling Events for Specific Properties

76

(1)

A java.awt Example

77

(8)

5. Persistence

85

(43)

Object Serialization

86

(1)

The java.io.Serializable Interface

87

(9)

Class-Specific Serialization

96

(1)

Walking the Class Hierarchy

97

(14)

Serializing Event Listeners

111

(3)

Versioning

114

(3)

Object Validation

117

(3)

The java.io.Externalizable Interface

120

(3)

Instantiating Serialized Objects

123

(5)

6. JAR Files

128

(9)

The jar Program

128

(2)

The Manifest

130

(3)

Using JAR Files with HTML

133

(1)

Using JAR Files on the CLASSPATH

134

(1)

An Alternative to the jar Program

135

(2)

7. The BeanBox Tool

137

(10)

Running BeanBox

137

(2)

Dropping Beans on BeanBox

139

(1)

Editing a Bean's Properties

140

(2)

Hooking Up Beans

142

(3)

Saving and Restoring the BeanBox Form

145

(1)

Adding Your Own Beans to BeanBox

145

(2)

8. Putting It All Together

147

(44)

Defining the Temperature Control Simulator

147

(3)

Building the Simulator

150

(34)

A Sample Simulator Applet

184

(2)

Creating a JAR File

186

(2)

Recreating the Sample Using BeanBox

188

(3)

9. Introspection

191

(31)

The BeanInfo Interface

191

(20)

Providing Additional BeanInfo Objects

211

(3)

Introspecting the Environment

214

(2)

The BeansBook.Simulator BeanInfo Classes

216

(6)

10. Property Editors and Customizers

222

(31)

Property Editors

222

(19)

Customizers

241

(12)

11. ActiveX

253

(20)

The JavaBeans ActiveX Bridge

254

(7)

Technology Mapping

261

(1)

Using Beans in Visual Basic

262

(11)

A. Design Patterns

273

(4)

B. The java.beans Package

277

(16)

Index

293

What is included with this book?

The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any access cards, study guides, lab manuals, CDs, etc.

The Used, Rental and eBook copies of this book are not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.