Developing Java Beans

Print $29.95

Safari Books Online

What is this?

Print £22.99

What is this?

Developing Java Beans

By: Robert Englander
Publisher:: O'Reilly Media
Released:: June 1997
Pages:: 316

Description

Developing Java Beans is a complete introduction to Java's component architecture. It describes how to write Beans, which are software components that can be used in visual programming environments. This book discusses event adapters, serialization, introspection, property editors, and customizers, and shows how to use Beans within ActiveX controls.

Full Description

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 Beans is 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

Table of Contents

Chapter 1 Introduction
1. The Component Model
2. The JavaBeans Architecture
3. JavaBeans Overview
4. Using Design Patterns
5. JavaBeans vs. ActiveX
6. Getting Started
Chapter 2 Events
1. The Java Event Model
2. Events in the AWT Package
Chapter 3 Event Adapters
1. Demultiplexing
2. Generic Adapters
3. Event Adapters in the AWT Package
4. Event Filtering
5. Event Queuing
Chapter 4 Properties
1. Accessing Properties
2. Indexed Properties
3. Bound Properties
4. Constrained Properties
5. Handling Events for Specific Properties
6. A java.awt Example
Chapter 5 Persistence
1. Object Serialization
2. The java.io.Serializable Interface
3. Class-Specific Serialization
4. Walking the Class Hierarchy
5. Serializing Event Listeners
6. Versioning
7. Object Validation
8. The java.io.Externalizable Interface
9. Instantiating Serialized Objects
Chapter 6 JAR Files
1. The jar Program
2. The Manifest
3. Using JAR Files with HTML
4. Using JAR Files on the CLASSPATH
5. Archive Signing
6. An Alternative to the jar Program
Chapter 7 The BeanBox Tool
1. Running BeanBox
2. Dropping Beans on BeanBox
3. Editing a Bean's Properties
4. Hooking Up Beans
5. Saving and Restoring the BeanBox Form
6. Adding Your Own Beans to BeanBox
Chapter 8 Putting It All Together
1. Defining the Temperature Control Simulator
2. Building the Simulator
3. A Sample Simulator Applet
4. Creating a JAR File
5. Recreating the Sample Using BeanBox
Chapter 9 Introspection
1. The BeanInfo Interface
2. Providing Additional BeanInfo Objects
3. Introspecting the Environment
4. The BeansBook.SimulatorBeanInfo Classes
Chapter 10 Property Editors and Customizers
1. Property Editors
2. Customizers
Chapter 11 ActiveX
1. The JavaBeans ActiveX Bridge
2. Technology Mapping
3. Using Beans in Visual Basic

Appendix A Design Patterns
1. Event Objects
2. Event Listeners
3. Registering for Event Notification
4. Registering for Unicast Event Notification
5. Multiple Parameter Event Methods
6. Property Access Methods
7. Indexed Property Access Methods
8. Constrained Property Access Methods
9. Registering for Bound and Constrained Property Event Notifications
10. Naming a BeanInfo Class
Appendix B The java.beans Package
Colophon

Product Details

Title:

Developing Java Beans

By:

Robert Englander

Publisher:

O'Reilly Media

Formats:

Print
Safari Books Online

Print Release:

June 1997

Pages:

316

Print ISBN:

978-1-56592-289-1

| ISBN 10:

1-56592-289-1

Customer Reviews

About the Author

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.

View Robert Englander's full profile page.

Colophon

Edie Freedman designed the cover of this book, using an image she created and shot, then manipulated in Adobe Photoshop. The cover layout was produced with Quark XPress 3.3 using the Bodoni Black font from URW Software and BT Bodoni Bold Italic from Bitstream. The inside layout was designed by Nancy Priest and implemented by Mike Sierra in FrameMaker 5.0. The heading font is Bodoni BT; the text font is New Baskerville. The illustrations that appear in the book were created in Macromedia Freehand 5.0 by Chris Reilley and Robert Romano. Whenever possible, our books use RepKover™, a durable and flexible lay-flat binding. If the page count exceeds RepKover™'s limit, perfect binding is used.

Service and support by Satisfaction

O'Reilly Books & Videos

Developing Java Beans

Chapter 1 Introduction

The Component Model

The JavaBeans Architecture

JavaBeans Overview

Using Design Patterns

JavaBeans vs. ActiveX

Getting Started

Chapter 2 Events

The Java Event Model

Events in the AWT Package

Chapter 3 Event Adapters

Demultiplexing

Generic Adapters

Event Adapters in the AWT Package

Event Filtering

Event Queuing

Chapter 4 Properties

Accessing Properties

Indexed Properties

Bound Properties

Constrained Properties

Handling Events for Specific Properties

A java.awt Example

Chapter 5 Persistence

Object Serialization

The java.io.Serializable Interface

Class-Specific Serialization

Walking the Class Hierarchy

Serializing Event Listeners

Versioning

Object Validation

The java.io.Externalizable Interface

Instantiating Serialized Objects

Chapter 6 JAR Files

The jar Program

The Manifest

Using JAR Files with HTML

Using JAR Files on the CLASSPATH

Archive Signing

An Alternative to the jar Program

Chapter 7 The BeanBox Tool

Running BeanBox

Dropping Beans on BeanBox

Editing a Bean's Properties

Hooking Up Beans

Saving and Restoring the BeanBox Form

Adding Your Own Beans to BeanBox

Chapter 8 Putting It All Together

Defining the Temperature Control Simulator

Building the Simulator

A Sample Simulator Applet

Creating a JAR File

Recreating the Sample Using BeanBox

Chapter 9 Introspection

The BeanInfo Interface

Providing Additional BeanInfo Objects

Introspecting the Environment

The BeansBook.SimulatorBeanInfo Classes

Chapter 10 Property Editors and Customizers

Property Editors

Customizers

Chapter 11 ActiveX

The JavaBeans ActiveX Bridge

Technology Mapping

Using Beans in Visual Basic

Appendix A Design Patterns

Event Objects

Event Listeners

Registering for Event Notification

Registering for Unicast Event Notification

Multiple Parameter Event Methods

Property Access Methods

Indexed Property Access Methods

Constrained Property Access Methods

Registering for Bound and Constrained Property Event Notifications

Naming a BeanInfo Class

Appendix B The java.beans Package

Colophon