Empower your JavaBeans to handle data conversion to and from their XML document format without complicating the code. This tip shows you how to write and use a component to convert a JavaBean to its XML document representation and vice versa. (1,000 words; May 9, 2003)
The bean is the cornerstone of the Java component architecture. Unfortunately, the current bean specification does not guarantee that a bean will behave correctly when imported into an application. In this article, Philippe suggests some design rules that allow your applications to trust beans. (2,500 words)
Customizable components allow you, as a developer, to "have it your way." Customizable JavaBeans have properties that an application developer can modify -- for example, changing the appearance and/or operation of a particular bean. In this article, you'll read about how JavaBeans customization works. We'll discuss properties, getter and setter methods, bound and constrained properties, and design patterns that make customization a snap. Then, we'll look at property editors and customizers. As we go along, we'll add customization to an existing JavaBean. (4,400 words)
4. It's in the contract! Object versions for JavaBeans
As we've seen in the past two months of the JavaBeans column, object persistence lets a Java developer convert a Java object into a bytestream that can be saved to disk or transported across a network and recreated in another time and place. But what if the class changes somehow between storage and retrieval of the stream? Or if different versions of the same class were used to write and read the stream? In this month's column, we'll discuss how to use object versioning to safely change or update existing Java classes without compromising compatibility with previously-written serialized files. (3,400 words)
5. Generate JavaBean classes dynamically with XSLT
For some projects, you need a more flexible business object structure. For example, different companies may have different requirements for Product bean properties. Without a proper framework, you may end up spending long hours customizing your data structures for every new customer, soon finding yourself with parallel software versions. This article lays a foundation for a simple framework to build truly adaptive systems, saving you hours of routine programming. As a bonus, you get a refresher on JDBC (Java Database Connectivity) and JSPs (JavaServer Pages), and you'll also learn how to use XSLT (Extensible Stylesheet Language for Transformations) to generate Java source code. (4,800 words; February 1, 2002)
With JavaBeans, simple properties correspond to a single value within a bean -- such as a color, an integer, or a string. JavaBeans may also have indexed properties; that is, properties whose values are arrays. This month, we'll see why indexed properties are useful, and learn how to add an indexed property to a bean. We'll also learn how to provide an application builder tool with a complex editor for the new property. (3,275 words)
The success of rapid application development (RAD) systems like Borland's Delphi and Microsoft's Visual Basic have brought a great deal of attention to the concept of software components. Java has now entered the ring with its own component software specification, JavaBeans. This article -- the first of many JavaBeans columns -- gives a high-level description of JavaBeans, explains why it's useful to developers, and introduces basic JavaBeans concepts. (2,800 words)
JavaBeans has ushered Java into a whole new era. Not only does it provide a rapid application development (RAD) environment, but it also offers a general framework for the development of reusable code libraries. And reusability is what it's all about. In this article, the first of two, we will step through the development of two JavaBeans components. We will cover, along the way, general issues of JavaBeans programming, properties, and custom events; beans customizers; and the use of the BeanBox. Next month's installment will conclude this series with a discussion of more beans and more advanced JavaBeans development topics. (6,000 words)
9. Building a bevy of beans: Create reusable JavaBeans components
JavaBeans: visual, reusable software components. We can rebuild them. We have the technology. We can make them better than before -- better, stronger, faster. More powerful than any bean alive -- the six-million dollar JavaBean. Well, maybe not six million, but who knows what can happen if you play your cards (I mean your beans) right. JavaBeans, the important new component software model from Sun, introduces the rapid applications development methodology to Java and presents a standard framework for the development of reusable software components. In this, the conclusion of our two-part mini-series, we finish the development of our suite of beans by looking at constructing beans from other beans. We also examine a simple application written using these components that further demonstrates software use of JavaBeans. Along the way, we'll encounter more beans, observable properties, inner classes, and programmatic access to JavaBeans components. (4,800 words)
10. JavaBeans: properties, events, and thread safety
The JavaBeans standard is a 100% Pure Java creature, which means that the standard exists on top of established Java programming rules and conventions -- not alongside them. One technicality that Java programmers must always take into consideration is code reentrancy, or multithread safety. With bean properties and bean events, the two pillars of the JavaBeans standard, you must be keenly aware of this potential pitfall. The following article shows you why. (3,700 words) Editor's Note: This article is adapted from "Chapter 4: Bean Properties" from Mastering JavaBeans by Laurence Vanhelsuwe (Sybex, May 1997, ISBN 0-7821-2097-0).
To ease JavaBeans development, Sun has created the BeanBox, a test container for JavaBeans. Although the BeanBox is far from being a full-blown development environment, it's quite adequate for testing your bean code to see if it works when the bean is actually inside a container. In this mini-tutorial, you'll download and install the BeanBox. Then you'll learn how to use the BeanBox to change a bean's properties, produce a report of the a bean's methods, "wire" beans together into small applications, and then save these little applications to disk files. (2,000 words)
JavaBeans-aware Integrated Development Environments (IDEs) know how to "dissect" a bean class file and generate a dialog box full of properties, which a developer can then use to customize the bean. But these "standard" customization dialogs leave a lot to be desired in terms of flexibility, configurability, and aesthetics. This article discusses how to control bean customization at design-time (and, occasionally, at runtime). This month and next, you'll learn how to customize the customization of your beans. (3,670 words)
JavaBeans communicate with other software components by using events -- objects that encapsulate data about something that has occurred. This article will show you how to use Java's new event structure to wire Beans together to produce new Beans or complete applications. Along the way, we'll touch on some new Java language features. (4,200 words)
14. Do it the "Nescafe" way -- with freeze-dried JavaBeans
Making software components mobile is a crucial part of any software component technology, and JavaBeans component technology is no exception. The ability to "freeze-dry" and then "reconstitute" software components (such as JavaBeans) adds a great deal of flexibility and power to the system architect's toolbox. This month we'll discuss some of the reasons for making software objects persistent, and we'll create our first persistent JavaBeans. (3,600 words)
The "options" for JavaBean customization are brutally functional: there's just nothing exciting about a property sheet. This month's column describes how to put racing stripes on your beans by controlling bean customization. Last month's JavaBeans column presented an overview of your JavaBean customization options. From simple naming schemes through writing classes that customize other objects, the JavaBeans framework lets you select the appropriate level of customization control for your application. This month, we'll have a detailed look at how to use the interfaces in the JavaBeans API to make your beans customizable. (3,400 words)
Java has been around long enough that you probably have quite a few classes under your belt. How do you turn these classes into JavaBeans? It's amazingly easy. In fact, there's very little to do. In this month's column, Mark Johnson pulls together concepts from past JavaBeans columns to "beanify" an existing class. (2,500 words)
Last month we talked about how and why to "freeze-dry" JavaBeans by serializing them. The JavaBeans Specification gives you all the serialization control you need for your application. This month, we'll look at serializing whole structures of related objects, we'll check out an interface that gives you complete control of serialization format, and we'll discuss ways of preventing serialization when necessary. (2,800 words)
In this installment of the Design Techniques column, Bill proposes the "event generator" as a Java idiom. The article provides a background on the concepts of patterns and idioms, describes the observer pattern, and demonstrates the idiomatic way to implement the observer pattern in Java. (3,000 words)
Last month we talked about how and why to "freeze-dry" JavaBeans by serializing them. The JavaBeans Specification gives you all the serialization control you need for your application. This month, we'll look at serializing whole structures of related objects, we'll check out an interface that gives you complete control of serialization format, and we'll discuss ways of preventing serialization when necessary. (2,800 words)
20. BeanLint: A JavaBeans troubleshooting tool, Part 1
Too often, JavaBeans containers refuse to load some of your beans, but provide little or no error information. At best, they print a cryptic exception message, and at worst they silently ignore the bean, leaving you in the dark about the nature of the problem. This month, Mark introduces the BeanLint class, which analyzes and alerts you to potential problems with your JavaBeans. In this first of a two-part series, Mark discusses decompressing classes from a jar file, and creating a class loader to load the classes into the Java virtual machine. (4,000 words)
The past three installments of the JavaBeans column have dealt with XML JavaBeans, a Java package that allows encoding and decoding of JavaBeans hierarchies between XML and JavaBeans instances in program memory. This month, Mark looks at a commercial version of the same idea -- IBM's Bean Markup Language, or BML. BML goes beyond the capabilities of XML JavaBeans, and provides some interesting implications for rapid application development. (3,000 words)
In August's JavaBeans column, Mark Johnson explained how to use IBM's Bean Markup Language (BML) to configure instances of JavaBean components. This month, he shows how you can wire JavaBeans together into a running application, execute JavaBeans methods, and bind JavaBeans to JavaScript. (4,300 words)
The bean is the cornerstone of the Java component architecture. Unfortunately, the current bean specification does not guarantee that a bean will behave correctly when imported into an application. In this article, Philippe suggests some design rules that allow your applications to trust beans. (2,500 words)
24. Script JavaBeans with the Bean Scripting Framework
Sometimes a problem you'd like to solve in Java has already been solved in some other language. Or sometimes you'd like to use some of your great Java code from another language. The Bean Scripting Framework (BSF) from IBM's alphaWorks lets Java classes call functions written in several scripting languages. It also extends those scripting languages, letting them use Java classes and Java beans transparently. This article introduces the BSF, with sample programs and descriptions of possible applications. (3,600 words)
