|
Process XML with JavaBeans, Part 3
This final article in the XML JavaBeans series builds on the previous two parts. Part 1 discussed nonvisual JavaBeans that parse XML documents into DOM trees, and Part 2 explained how Integrated Development Environments (IDEs) interconnect JavaBeans with event and property change relationships.
|
|
Process XML with JavaBeans, Part 2
This article assumes you've read Part 1 of this series and that you're familiar with the basics of XML, the Document Object Model (DOM), and JavaBeans, as well as the concept of building applications in an IDE.
|
|
Process XML with JavaBeans, Part 1
The expression "eating your own dog food" has gained currency over the last few years. It means taking the product you're selling in your daily business and using it yourself, so that you understand it from the consumer's point of view.
|
|
JavaBeansTM 101, Part III:
Writing Advanced JavaBeans
Advanced Bean programming is about customization. Customization entails providing a basic behavior for a Bean and allow its specific behavior to be controlled by end users who interact with the Bean, typically through application builder tools.
|
|
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
|
|
Make a sweep with clean beans
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.
|
|
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
|
|
BeanLint: A JavaBeans troubleshooting tool, Part 2
Last month, Mark looked at some of the problems that can prevent Java class files from operating as JavaBeans. He also discussed a tool, BeanLint, that analyzes class files in order to point out some of these danger spots. In this second article of a two-part series, he continues his discussion of the BeanLint tool and shows how it analyzes and reports potential JavaBeans problems
|
|
A fistful of values
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
|
|
Turn Java classes into JavaBeans
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.
|
|
Serialization grab bag
The past three JavaBeans columns on object persistence and serialization have inspired some interesting questions from readers. This month we'll answer a few of those questions, with a detailed exploration of JavaBeans serialization
|
|
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.
|
|
Serialization and the JavaBeans Specification
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
|
|
Do it the "Nescafé" 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
|
|
The trick to controlling bean customization
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
|
|
Netscape plans include slimline JavaBeans-based client
September 15, 1997 -- Netscape is developing one of the thinnest Web clients yet, a container for JavaBeans that will render images and content based on the types of data being accessed.
|
>
|
"Keep listening for upcoming events"
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.
|
|
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.
|
|
Reflections on Java, Beans, and relational databases
The 1.1 version of the Java Development Kit (JDK) contains new APIs for database access (JDBC) and components (JavaBeans). Together, these two APIs allow for the development of generic database code. A single class to access any JDBC database -- with the code specific to each individual application isolated in separate components. This means you won't have to update any database code with each minor change in a database's structure
|
|
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.
|
|
"Double Shot, Half Decaf, Skinny Latte" -- Customize your Java
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
|
|
The BeanBox: Sun's JavaBeans test container
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.
|
|
Building a bevy of beans
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
|
|
A walking tour of JavaBeans
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
|
|
JavaBeans make their debut at JavaOne
By now you've heard about Sun's JavaBeans components. This article describes the current state of JavaBeans, including the possibilities beans open up for developers and non-developers alike as well as the potential problems they introduce. The article ends with a roadmap outlining future bean developments.
|
|
JavaSoft cooking up some next-generation JavaBeans
San Mateo (April 26, 1997) -- As reported previously in JavaWorld, JavaSoft currently is collecting ideas and industry input for the next two generations of its JavaBeans specification, the first of which is slated for release next quarter.
|
|
Competing components make for prickly panelists
After a slow and uninspired start, the session "Competing Components: ActiveX and Java Technologies for Web Enhancement and Application Engineering" turned into a tense wrangle over component camps between two panelists, Charles Fitzgerald, program manager of Microsoft's Java team, and Mansour Safai, Symantec's general manager of Internet Development Tools. Theresa Lanowitz, group product marketing manager of Internet Tools at Borland International, fleshed out the sparse panel, which was moderated by Peter Coffee of PC Week Labs.
|
|
JavaBeans and ActiveX go head to head
On the off chance that you've spent the past several months offline, you may not be aware of the raging battle over component frameworks. As is often the case with such battles, the opponents have a lot at stake, and the information they offer may not be altogether objective. This can be confusing. And that's a shame.
|
|
Beta 3 of JDK 1.1 is chock fulla beans -- and more
Last week Sun Microsystems quietly published the beta 3 release of the Java Developer Kit (JDK) 1.1. There is, however, much for Sun to boast about in the new upgrade.
|
|
JavaBeans vs. ActiveX: Strategic analysis
JavaSoft and Microsoft currently are battling to get you to buy into JavaBeans and ActiveX, their respective component frameworks. At stake for JavaSoft and Microsoft is a large portion of the software infrastructure of the Internet and corporate intranets. At stake for software developers large and small is the future viability of the codebase they develop today. Choosing the correct model now increases value later. Backing the wrong horse could prove disastrous.
|
|
IBM's AppletAuthor grinds JavaBeans
New York -- IBM has released the beta of AppletAuthor, a Java application for creating dynamic multimedia Web content. AppletAuthor is targeted at those who wish to deploy Java applets for such purposes as multimedia, special effects, smart forms, and live data in Web sites, but who do not wish to grind their own pure code. The new product is touted by IBM as the first visual authoring tool for the Web that is completely compliant with Sun Microsystems' JavaBeans component API.
|
|
A portable hill of beans
Java is expanding so fast there's a chance it could run out of control. Javasoft's new Java Beans application programming interface (API) is an attempt to make a uniform interface to applets and Java objects irrespective of the environment they are placed in. The Java Beans API will make Java code written for Netscape, Microsoft, or OpenDoc environments interoperable without the need for any changes. This article previews the highlights of Java Beans
|
|
Java Beans glue applets together
Microsoft has ActiveX (nee OLE). Unix has CORBA. Now an initiative called "Java Beans" is brewing a similar set of APIs that will make it easy to create Java applications from reusable components. Java Beans will be used in a wide range of applications, from simple widgets to full-scale, mission-critical applications. Many of the major software development tool vendors, including IBM, Netscape, Borland, Symantec, and Oracle, have announced plans to support Java Beans.
|
|
Java Beans. The Only component Architecture for Java Technology
More than 1,000,000 developers around the world have already embraced the JavaTM platform. And no wonder. The Java platform has opened up an entirely new world of opportunities for building fully portable network-aware applications. Yet many developers are not yet sure how best to take advantage of the capabilities and benefits the Java platform delivers without sacrificing their existing investment in legacy applications.
|
|
Reflections on Java, Beans, and relational databases
The 1.1 version of the Java Development Kit (JDK) contains new APIs for database access (JDBC) and components (JavaBeans). Together, these two APIs allow for the development of generic database code. A single class to access any JDBC database -- with the code specific to each individual application isolated in separate components. This means you won't have to update any database code with each minor change in a database's structure
|
|
Site User Logon with XML, Java Beans and JSPs
|
|
Component-Based Software with Java Beans and ActiveX
The landscape of today's corporate computing environment is changing rapidly. With the marketplace becoming ever more competitive, companies today are feeling genuine incentive to re-evaluate the real costs of networked personal computers. A 1996 Gartner Group study determined the total cost of maintaining a networked PC in a large business environment to be as much as US$11,900. per year.
|
|
Growing Java Beans
JavaBeans is the Java component architecture. This article discusses and demonstrates how to write several simple components (hereafter referred to as Beans). The reader should have a general familiarity with Java. The code in this article was developed using the Apple Mac OS Runtime for Java (MRJ) version 2.0 and the MRJ SDK 2.0.1 ea2.
|
|
A Collaboration-Enabling Framework for Java Beans
This paper presents a JavaBeans framework to support realtime collaborative applications. The paper contributes a generic collaboration bus to which any (including singleuser) applications can be plugged in as is and made collaborative with no modifications to the application or to the collaboration bus. It also provides the design guidelines for developing collaboration-aware applications to take advantage of the cooperative features of the bus. Unlike most of the existing collaboration toolkits and frameworks, the application does not explicitly establish relationship to any of the framework classes, and is thus independent of the framework. The framework supports multi-user visual programming using JavaBeans: the users at geographically separate locations can collaboratively compose a...
|
|
JAVABEANSTM ACTIVATION FRAMEWORK (JAF)
This paper presents a JavaBeans framework to support realtime collaborative applications. The paper contributes a generic collaboration bus to which any (including singleuser) applications can be plugged in as is and made collaborative with no modifications to the application or to the collaboration bus. It also provides the design guidelines for developing collaboration-aware applications to take advantage of the cooperative features of the bus. Unlike most of the existing collaboration toolkits and frameworks, the application does not explicitly establish relationship to any of the framework classes, and is thus independent of the framework. The framework supports multi-user visual programming using JavaBeans: the users at geographically separate locations can collaboratively compose a...
|