[Contents] [Previous] [Next] [Index]

## Chapter 1
Introduction

This document describes how to use the Component Developer's Kit (CDK) to incorporate components into the applications you build for the Netscape ONE platform.

The CDK is a supplemental tool kit that enables you to build and extend component-based Internet, intranet, and extranet applications. It introduces the concept of the JavaScript Bean (JSB) file that serves as a Netscape ONE component wrapper so that you can use and deploy components across all your applications regardless of component origin or the language used to create it. The JSB file also enables creation of JavaScript components. Finally, the CDK describes both tool- and platform-based component requirements, and offers example components that illustrate design and implementation techniques.

In particular, this document focuses on developing and deploying components for application developed with Visual JavaScript (VJS). VJS is the first Netscape tool designed to enable incorporating Netscape ONE components into your Internet, intranet, and extranet applications. As other Netscape tools evolve to provide direct support for building component-based applications for the Netscape ONE platform, future releases of the CDK will offer development and deployment guidelines that apply specifically to those tools in addition to VJS. Developing Netscape ONE components and using VJS to develop applications with those components today gives you a jump on future development for the Netscape ONE platform.

Sections in this document include the following topics:

- What is the CDK?
- Where To Find CDK Information
- What You Should Already Know
- Tools You Need

## What is the CDK?

The CDK is a set of documents and example code that describe to developers how to shape Netscape ONE components and deploy them to applications using Netscape tools such as VJS.

A Netscape ONE component is any component that adheres to the JavaSoft Bean specification, and can be a:

- JavaScript component, coded as a JavaScript object, complete with properties, events, and methods, that is embedded in a JavaScript Bean (JSB) file.

- Java Bean component, coded in Java and supplied with a BeanInfo class.

- CORBA component, accessed through a CORBA-compliant Object Request Broker (ORB).

- Native component plug-in, such as the multi-media player in Communicator 4.0. (Not completely supported in PR3.)

- BeanConnect program, which encapsulates and controls multiple Java objects within a single execution space. (Not completely supported or tested in PR3.)

All Netscape ONE components can be described for deployment using JSB files. A JSB file is an SGML-based text file that uses a hierarchical set of tags to describes a component and its properties, events, and methods. The JSB file structure is tightly modeled on the Java Bean specification, but can sometimes contain extra tool-or platform-specific information.

Depending on the native language used to create an actual component, the contents of a JSB file either provide interface definitions for the component's actual implementation (i.e., the component is implemented in Java or C++), or interface definitions, constructor code, and helper function code (for JavaScript components).

You can create a JSB file using a text editor. Depending on the type of component and the development tools you use, a JSB file may be created automatically for you. For example, when you import a CORBA component into VJS to use in building an application, VJS uses the IDL description of the component to build a corresponding JSB file that becomes part of your VJS project. When you compile your application and deploy it, VJS uses the JSB files to generate appropriate interface code for the components.

In PR3, the CDK documentation is divided into separate, linked HTML files. Each file describes components derived from different sources (e.g., Java, CORBA, or JavaScript), and notes any tool or platform requirements specific to components of that type. For PR3, tool discussions are limited to VJS, and platform discussions are based on Netscape Communicator 4.xx unless otherwise noted.

For JavaScript components, the CDK documentation describes how to create and import components into the VJS palette. All other components are created and implemented in a native language, such as Java or C++. The CDK documentation explains how to import these externally-derived components into the VJS palette, and notes any special requirements and adaptations that are necessary.

Once a component is imported into the palette, developers can use it as an application building block, just as they can with the built-in VJS components. To the end user of a VJS application, the originating source of a component does not matter. Once incorporated, all components function transparently.

The CDK contains sample code that implement Java and CORBA objects that can be imported into VJS as components. While in general developers can import almost any Java or CORBA object into VJS as a component, the CDK sample code illustrate refinements that can be made to native object code for even tighter integration into a Netscape ONE crossware application.

## Where To Find CDK Information

The CDK documentation is divided into the following sections:

Section | Contents
--- | ---
Introduction | This document, which describes the CDK documentation, and provides an overview of adapting, developing, and using Netscape ONE components when building applications.
Creating JavaScript Components. | Describes how to create and use JavaScript components in Netscape ONE applications.
Using Java Objects as Components | Describes how to incorporate and access Java-based components in Netscape ONE crossware applications.
Using CORBA Components | Describes how to incorporate CORBA-compliant components into Netscape ONE crossware applications.
Using Plug-ins, Customizers, and Property Editors | Describes how to incorporate and interact with plug-in components, such as the multi-media player in Netscape Communicator 4.xx. Not complete for PR3.
Using BeanConnect Programs as Components | Describes how to use BeanConnect technology in Netscape ONE crossware applications. Not complete for PR3.
Packaging Components for Import | Describes how to use the JDK 1.1 command-line JAR file packager to package Netscape ONE components into JAR files for importing into a VJS palette.
JSB File Structure Reference | Provides an introduction to JSB files and a detailed syntax reference for the JSB file structure used to create Netscape ONE components.

Each of these sections contains links, as appropriate, to related documentation.

## What You Should Already Know

The CDK documentation is based on the assumption that you are familiar with the object-oriented, event-driven programming paradigm. It also assumes familiarity with the Java Beans component model, and the implementation of component properties, events, and methods. All Netscape ONE component development is based on the Java Beans component model, regardless of where a component is actually implemented.

If you are developing Java objects, components, or BeanConnect programs for use as Netscape ONE components, you should be familiar with Java programming. If you are creating JavaScript components, the CDK builds on your knowledge of JavaScript. If you are implementing CORBA components, the CDK expects that you are familiar with CORBA, IIOP, and Java or C++.

For a complete introduction to CORBA, see CORBA: Catching the Next Wave.

For more information about Netscape's BeanConnect technology, see BeanConnect: Using Java Objects to Implement Crossware Programs.

## Tools You Need

To develop and test Netscape ONE applications, you need the latest version of Visual JavaScript, and a text editor. To develop, test, and deploy components for use in the Visual JavaScript IDE and your Visual JavaScript applications, you need the CDK. To debug your components and applications, you need the Visual JavaScript debugger.

To develop Java components, you need the Java Beans Developer Kit (BDK) from Sun. If you want to develop components with the Netscape Internet Foundation Classes (IFC), you must get IFC from Netscape. In addition, you must have the Java Developer's Kit, JDK 1.1. Optionally, you may also want to use a Java development tool such as Symantec Cafe or Visual Cafe.

To test client components at run-time, you need Netscape Communicator version 4.xx. To test server components at run-time, you need Enterprise Server 3.x.

[Contents] [Previous] [Next] [Index]

Last Updated: 09/03/97 11:33:44

Copyright © 1997 Netscape Communications Corporation