informit.com -- Your Brain is Hungry. InformIT - Tips and Techniques for Java From: SE USING CGI

Java has become almost synonymous with Internet programming. New pages appear every day containing Java applets and carrying the cup of coffee icon. The success and popularity of Java and the Web are intertwined. As you'll soon see, Java is an ideal language for Internet applications, combining the power of C and C++ with the platform independence of HTML and Web browsers.

Because of its sudden rise in popularity, tools supporting Java development are limited and relatively crude by today's standards. Although Java is changing rapidly (by the time you read this, there will be several commercial and "free" Java development environment options), the examples presented in this chapter are based on the development tools that have been available from Sun since 1995.

Introduction to Java

Rather than jump right into Java CGI and applet development, you should become familiar with Java first. Briefly, Java is an object-oriented, architecture-neutral programming language. Like C++, Java relies heavily on C. This eases the transition that C and C++ programmers must make to Java.

Java is byte-code interpreted. This means that the Java compiler doesn't generate object code that's directly executed by your computer's CPU; instead, these byte codes are executed by a java interpreter. Some Web browsers incorporate java interpreters, allowing you to include Java programs in your Web pages. This feature alone assures Java a place in your Internet programming future.

The following section looks into Java's background-where it comes from and what problems it was intended to solve. Then you'll look at the capabilities and features of the language and the Java environment.

The Origins of Java

Understanding the origins of language-particularly a programming language-reveals a great deal about the language itself. What problems encountered with other languages are solved by this new language? Was the language developed to address the specific problems of only a few application areas, or is it general purpose?

Java was developed at Sun Microsystems by a development team, headed by James Gosling, that was developing applications for consumer products. Because the breadth of these applications is large, a language was needed that would operate efficiently and reliably in many environments, on many processors. User interfaces must be simple and intuitive, and the software often interacts with real-world objects.

Although C and C++ are widely available and portable, they have some disadvantages for many consumer product applications. C and C++ are compiled languages that result in processor-specific machine code that must be linked with environment-specific libraries to create a runnable program. If any aspect of this environment changes, the program must be recompiled and relinked. C is loosely typed, allowing the programmer great flexibility but also permitting the introduction of severe bugs that may be difficult to find. Although C++ is object-oriented and addresses some of C's limitations, it has grown large and complex, losing the original simplicity and elegance of C.

In 1990, Gosling began developing a language to meet the needs of consumer product software. Much like the development of the C programming language, Java saw practical use in projects at Sun. Although these projects never resulted in commercial products, they did result in improvements to the language. This has made Java a full-featured, robust programming language with many of the best attributes of C and C++, few of their limitations, and several unique features.

The specification for the Java programming language and the Java Virtual Machine (the byte code interpreter) is open and has been made publicly available by Sun. Sun is also licensing the development and runtime software, and makes the Java sources readily available. For the latest updates and availability information, see http://www.javasoft.com/.

A Brief Overview of the Java Programming Language

Java draws heavily on C and has much in common with C++. Wherever possible, Java uses C syntax. All the basic C types and flow-control constructs are available. It's virtually impossible to distinguish small snippets of Java code from C.

Like C++, Java is object-oriented. Java supports single inheritance with a root class, and inherited functions can be overridden or overloaded.

Java implements abstract classes with interfaces, which describe how a class can be used without providing any implementation. An object in Java may implement any number of interfaces, and these interfaces are very similar to CORBA IDL interfaces. (CORBA is the Common Object Resource Broker Architecture developed by the Object Management Group (OMG). In CORBA, object interfaces are described in IDL, the Interface Description Language.)

Although similar to C++ in many respects, a major objective of Java was simplicity. Consequently, any feature of C++ that wasn't absolutely necessary was eliminated. There's no multiple inheritance. There are no structs, unions, pointer types, or multidimensional arrays, nor are there header files, templates, or implicit type conversions.

Even though it's simple, Java has added extensions beyond C++. The most significant addition is garbage collection, eliminating memory leaks.

Java is staticly typed, allowing for efficient code generation, but also supports dynamic type determination, so that programs can do different things based on the object type. Java has built-in exceptions, so you can write programs that detect and respond to errors, rather than abort, core dump, or cause general protection faults.

Because Java compiles to byte codes that run on a Java Virtual Machine, Java is architecture neutral. Word lengths and byte ordering are defined for the virtual machine and are the same regardless of the underlying machine architecture.

Java is multithreaded, eliminating the need for programs with polling loops that look for user input. Java threads are virtual threads in single processor environments, but may be truly concurrent in multiprocessor machines. Java provides thread synchronization mechanisms to support creating reliable programs using threads.

It's beyond the scope of this section to examine Java in great detail, but an example is worthwhile. Look at a listing 23.1, which is a very simple Java program-the ubiquitous "Hello World."

If you're familiar with C++, you've seen code much like this. Although quite simple, this program demonstrates some of the features of Java, as follows:

A complete discussion of the Java programming language is provided in Special Edition Using Java, published by Que Corporation.

The Java Class Libraries

Like C and C++ before it, Java relies on extensive libraries to create applications. These libraries provide utility classes for creating programs and I/O, so your program can communicate with the world. Although libraries are often considered an integral part of the language, they provide a means of extending the language and adapting applications written in the language to various environments.

Java libraries support basic Java operation, applications and applets, and application I/O, as described in briefly in table 23.1. These libraries are frequently enhanced and updated. A detailed description of the components in these libraries is provided at http://www.javasoft.com/java.

The Java Runtime Environment

Java is a compiled language, but rather than compile to object code for each individual computer type, Java compiles to a standard byte code. This code is the same regardless of the particular machine or operating system that the Java application executes on. A Java application that runs on a Sun Sparc-station running Solaris will run on an Intel platform running Windows NT without recompiling.

Platform-independent execution of a Java program requires a Java Virtual Machine to execute the compiled byte codes. As mentioned earlier, the specification of the Java Virtual Machine is open and widely available, encouraging numerous implementations. This virtual machine is provided by every machine and operating system combination that runs Java applications.

Java and the Java Virtual Machine have one requirement previously not common on personal computers: multithreading. Multithreading is not only a feature of the language, but is required for the language to execute. In particular, garbage collection is performed in a separate thread of execution from the application thread. And to be efficient, the underlying system should provide support for multithreading. This is one reason why some systems (or operating systems) don't have Java-compatible browsers or development systems.

Java Applets

Up to this point, I've discussed the Java programming language. Anyone using a computer who hasn't been in a cave for the last year has heard of Java applets. Many people believe that Java is useful only for applets.

But how do applets work? Java applets convert a relatively static presentation of HTML into an interactive system at the browser.

Java applets are incorporated into the HTML sent to the browser by the HTTP server. Once at the browser, the Java applet executes in a runtime environment established by and controlled by the user. This requires that the browser implement the Java Virtual Machine and, in most cases, requires a system that provides some of the necessary execution support, such as multithreading.

Once downloaded and executing, a Java applet is a complete application. The applet can create new windows outside the browser, as well as use space within the current HTML page. The applet has powerful URL capabilities, allowing it to load new pages based on user actions. Java provides powerful networking capabilities, allowing creation of complete client applications that are downloaded as an applet. Such a client can make a direct connection to a server without the overhead of HTTP.

What about security? I may download anything off the Internet and run it on my computer, but you may prefer applications that you know won't destroy data or inject a virus. It would seem that continually downloading applets, possibly without the user knowing, would seem a great risk. While there are known problems with Java security, known solutions are expected to be implemented in the production release. Until then, Java isn't appropriate for sensitive applications.

The Java security model places control of resource access by the applet in the hands of the browser, and consequently the person using the browser. An integral component of the Java runtime environment is the SecurityManager, which checks permissions before any I/O operations, to the Net or the local file system.

In addition to the security imposed by the browser's SecurityManager, Java provides other support for safe execution in a network environment. Java byte codes are designed to be verified and are less susceptible to covert, malicious modification than ordinary object codes. The lack of pointer types reduces risk of data corruption due to errant accesses (in systems that don't provide adequate process memory protection).

JavaScript

JavaScript is a powerful scripting language that extends the Web browser's capabilities. Developed by Netscape, JavaScript is best supported by Netscape's browser. Unlike Java, which is useful for developing stand-alone applications, JavaScript is tightly coupled with HTML and the browser. Although separate applications can't be developed in JavaScript, JavaScript has access to the objects within the browser itself and is therefore very useful in creating Web applications.

Like Java, JavaScript syntax is much like C, and although new objects aren't created, JavaScript has access to browser objects that represent the portions of the current HTML page. This allows you, as the Web application developer, to extend the capabilities of the HTML processing without requiring interaction with the HTTP server.

The Java Development Environment

The most widely distributed Java development environment is provided by Sun and consists of compatible but separate tools for compiling the Java sources, and running and debugging the resulting programs. This is much like C was in the early days but is rapidly changing as Sun and other vendors develop integrated environments.

Sun's Java Development Kit

Compiling Java Programs and Applets

The first step in creating a Java program is to edit the source files using the editor of your choice. Java source files have the extension .java, and the file name should match the name of the class in that file.

After the sources are edited, the standard compile/run/debug/edit cycle begins. The first step is to compile the Java source code, as follows:

Assuming there are no compile-time errors, javac compiles the code and creates the file:

This file is run by the Java Virtual Machine. This may be the java interpreter, or the appletviewer or browser, if the program is an applet.

Running Java Programs and Applets

Running a Java program requires running a Java Virtual Machine that interprets the byte codes. The JDK provides a java interpreter, which implements the Java Virtual Machine and is required to run java programs. Java programs are executed using the java interpreter, as follows:

This produces Hello World on-screen. Arguments are passed to your application by appending them to the end of the previous command line:

Environment variables must be explicitly passed to the java interpreter, where they're made available to your program. This is done with the -D option to the java interpreter, as follows:

After you complete your Java program, you can run it on any system that supports the Java byte code interpreter. You won't need to recompile or relink your code. You simply transfer the HelloWorld.class file and run your program.

Because the environment provides the java library set, libraries can be upgraded for bug fixes without recompilation of the applications that they support.

Soon-to-Be-Released Integrated Environments

For those of you who've been around since paper tape and punch cards, the Java Development Kit is quite nice. It's robust, produces good code, and operates well with UNIX makefiles. For the rest of us who have grown accustomed to GUIs and integrated development environments, these tools are a giant leap back in time. Sun and other tool providers are aware of the limitations of the JDK and are working toward providing fully integrated development environments for release this year. Sun will offer the Java Development Environment (not Kit) as a commercial product. This will provide an integrated code and class browser, build manager, and debugger.

Look for major vendors of PC development tools such as Borland and Symantec to distribute their own integrated development environments. Soon everyone will have access to professional Java development tools on their choice of platform, and the code they create will run on all Java-enabled computers!

Creating Java CGI Applications

Java combines the performance and object-oriented features of C++ with the portability and ease of use of typical scripting languages such as Perl. This makes Java an ideal candidate for creating CGI applications. The networking capabilities provided by the Java libraries provides the means for integrating the CGI application with commercial database systems and other distributed applications.

Executing the Java Interpreter

Because Java applications aren't directly executable by the operating system, the HTTP server can't execute a Java CGI directly. Java CGIs should be executed from a shell script, as follows:

This not only runs the CGI (in this case, HelloWorld), but also establishes the runtime environment for the java interpreter.

The java interpreter must know the locations of the CGI class(es) and the library classes to load the application. Because these vary from machine to machine, or even due to the personal preferences of the system administrator, the Java developers choose to use an environment variable to communicate this information to the java interpreter.

Accessing Standard Input and Standard Output

As demonstrated in the HelloWorld.java example, Java provides simple access to standard output. Access to standard input is provided with an equally simple interface (see listing 23.2).

This provides access to an input stream as an array of bytes. This is needed in CGI programs to handle the HTTP character translations necessary when transferring data from the server.

Accessing Environment Variables

System environment variables aren't directly accessible to Java applications. In some environments, these variables don't even exist, and their use varies from system to system. For these reasons, the mechanism provided by the java interpreter for passing these variables is an enhancement. The -D option is consistent across all platforms.

Using your CGI shell script to kick-start the Java CGI requires that you add the -D option to the interpreter command line, as follows:

This is a simple case of passing a single environment variable with no verification. A production script would add a set of standard environment variables, as well as application-specific variables, and validate each.

The Java application accesses these variables using the System.getProperty() method, as shown in the following snippet:

With access to environment variables, command-line arguments, and standard I/O, Java provides the capabilities to write any type of CGI application. In the next section, you'll look at how applets can improve the power and flexibility of CGI Web applications.

Java and JavaScript Applets

Java is an appropriate choice for your next CGI development effort, but it also provides capabilities for enhancing your existing or new CGI applications. These applets not only add flash to your Web pages, but can increase the efficiency and ease of use for anyone browsing your page. With Java, you can create Web applications that could never be created before.

In the following sections you'll look at how to incorporate Java and JavaScript into your next Web application.

Java Applets

The basic premise of a Java applet is that a small program can be downloaded as a part of your Web page and run on the client system in an environment established by the browser. This application isn't part of the browser any more than a word processor is a part of the operating system that loads and runs it.

What Java applets provide is the capability to create stand-alone or internetworked (using the internetworking I/O capabilities provided in the Java libraries) applications that are delivered to Web users. These applets aren't limited to modification of the contents of a Web page, but can open new application windows on the client, outside the browser.

Java applets can also be cleanly incorporated into your Web page because they're a component of the page and loaded by the browser. This is commonly used for sophisticated animations or presentations of data within the page. Just remember that Java applets don't modify the contents of other regions of the page.

The Web browser controls the execution of a Java applet. The applet is downloaded to the browser based on the <applet> HTML tag in the Web page, as shown in listing 23.3.

When the applet tag is processed, the Java byte code file is downloaded to the browser, where it's executed (see fig. 23.1). Notice that the applet size is controlled by the applet parameters and the position on the page matches the location of the tag in the HTML source.

Because all the Java applet parameters appear within the applet tag, any browser that doesn't support Java applets will ignore the applet section.

If your browser doesn't support Java or is simply too slow, use the Java Development Kit appletviewer (see fig. 23.2). This will only run your applet, but requires significantly less resources than most browsers. Notice that the surrounding HTML text is absent.

Parameters can be supplied to your applet and are accessed in the same manner as environment variables in a stand-alone Java application.

Once the applet is downloaded, the browser invokes the applet's init method, which establishes the initial state of the applet in preparation for execution. Once initialized, the applet is started by invoking the start method. This is done by the browser when the applet first starts and any time the page is revisited but not reloaded. When the browser navigates to a new page, the stop method is invoked, putting the applet in a suspended state. This prevents the applet from unnecessarily usi ing system resources. If the browser unloads the page or exits, the applet destroy method is invoked, freeing any resources used by the applet.

You can customize all these life-cycle methods by overriding them in your applet. The init method is overridden in any applet that accepts parameters.

Now that you know how to load an applet and how the browser should execute it, look at a simple example that draws a marble that changes color (see listing 23.4).

Listing 23.4 marble.java: A Simple Example of Java Animation

/*
 * marble.java
 */
import java.awt.*;
import java.applet.*;

public class marble extends Applet implements Runnable {
    Thread cntrl;
    Chroma sphere;

    public void init() {
        cntrl = new Thread(this);
        try {
            
            sphere.init(this);
        } catch (java.lang.ClassNotFoundException e) {
            return ;
        }
    }

    public void start() {
        if (cntrl.isAlive()) {
            cntrl.resume();
        } else {
            cntrl.start();
        }
    }

    public void stop() {
        cntrl.suspend();
    }

    public void destroy() {
        cntrl.stop();
    }

    public void run() {
        while (true) {
            repaint();
            try {
                Thread.sleep(500);
            } catch(java.lang.InterruptedException e) {
                continue;
            }
            sphere.advance();
        }
    }

    public void paint(Graphics g) {
        sphere.paintColor(g);
    }
}

abstract class Chroma {
    protected Applet app;
    /*
     * init this thread
     */
    protected void init(Applet app) {
        this.app = app;
    }
    public abstract void advance();  // next step
    public abstract void paintColor(Graphics g); // new color, repaint
}

class ColorBall extends Chroma {
    private Color bc = Color.white;
    private int cnum;

    public void advance() {
        cnum = cnum+1;
        bc = new Color(cnum);
    }

    public void paintColor(Graphics g) {
        g.setColor(bc);
        g.fillOval(40, 40, 100, 100);
    }
}

First, notice that the abstract window and applet classes are imported. Then notice that the marble class inherits from the applet class and implements the Runnable interface. Also notice that there's no main.

This applet demonstrates multithreading. One thread draws the marble with new colors; the other performs the timing and control of the applet. This is a rather tame use of threads but serves to demonstrate the underlying capability. Although this applet is very simple, the complete Java class library is available for use in your applets, allowing you to write sophisticated, interactive applications. Visit a few of the sites listed at the end of this chapter for a test drive.

JavaScript Applets

JavaScript lacks many of the sophisticated features of Java-such as multi-threading and some I/O capabilities-but it's highly integrated with the browser objects. This gives JavaScript access to Web page elements and the capability to modify variables.

JavaScript is downloaded as a part of your HTML page and is processed as it's received. If your script has a syntax error, it will be detected by the browser and you'll be alerted. Because JavaScript has many of the features of other scripting languages (Perl or C shell), writing JavaScripts not only is easier than writing HTML, it's more fun.

JavaScripts consist of functions that are called as a result of browser events. You define these functions directly within your HTML and make individual associations with specific events. You may choose to associate a function with a button click so that form validation may be performed. Listing 23.5 shows an example of this.

When this page is loaded into the browser, it appears as a regular HTML form (see fig. 23.3). The difference between the JavaScript form and a normal form becomes apparent on input. When a color value is submitted, the JavaScript function is invoked and the value is validated.

All the objects within the Web page are accessible to the JavaScript applet. For example, the HTML page above contains a FORM named sel containing an input variable named color. The value of this input variable in the FORM is accessed with this line in the script:

document refers to the entire Web page and sel is the name of the form. The specific form variable, color, matches the name given in the HTML form.

Notice that the input type of button is used rather than submit. This is because the verification function actually performs the form submission. If a submit button was used, the form would always be submitted. This script produces a browser alert in a separate window when an error is detected.

JavaScript can also produce output directly within the Web page. This can be used to produce messages or warnings without the overhead, or extra mouse click to dismiss, an alert window. You might also find this useful in sophisticated, interactive applets where most of the output is from the JavaScript.

JavaScript functions accept parameters without specific type declarations in the function definition. This allows you to write general-purpose functions (such as a date entry validation function) that can be used in many locations within your page.

Using Java with JavaScript

It might seem that using Java and JavaScript is an either-or proposition, but each has its place in Web-enabled applications. In fact, when they're used together, the relative strengths complement each other quite well. JavaScript's tight coupling with the browser makes it ideal for client-side applications that communicate data back to the HTTP server, whereas Java's robustness and efficiency makes it ideal for client-side applications that require fast interaction and animation.

By combining JavaScript and Java, it's possible to produce Web pages with unprecedented capabilities with only a single access to the HTTP server. It's now possible to create a single Web page that contains a form for the selection and purchase of a product, and simultaneously allows the product to be examined. This page would use JavaScript to validate selections, and a Java applet would allow the customer to examine the product, viewing it from different angles and changing characteristics such as color and size. All of this can be done without additional access to the HTTP server.

Integrating Applets with Traditional CGI Applications

JavaScript has immediate application with traditional CGI due to its capability to enhance the integration of the Web page with the operations of the browser. Also, JavaScript can be used to jazz up a page with simple animations, making your site more attractive to Web surfers.

JavaScript enhancements to your site can be made with no additions to the CGI back end of your site. In fact, if you use JavaScript for form entry validation and your CGI application also performs validation, you should not change your CGI. Because not all browsers support JavaScript, you'll need the CGI form-validation features for those clients. The JavaScript-capable browsers will always send back validated entries.

Java isn't as well integrated into the browser and is less appropriate for browser-oriented tasks, such as form entry validation. However, Java is a programming language and environment that supports development of sophisticated animations and complete, self-contained or networked applications. Visit almost any of the Java sites to see the kinds of animations capable with Java.

Advanced Client-Server Applications

One of the most exciting features of Java is its network I/O capabilities. Java has access to traditional TCP/IP network communication facilities that allow you to create client/server applications that use these technologies to transfer data.

We'll soon see powerful client/server applications on the Internet that use the browser for application navigation and applet download. These applications will transfer large amounts of data directly to the server-side application from the client without using the HTTP server.

Issues and Tradeoffs Related to Java

As relatively new technologies, JavaScript and Java are both undergoing development and change as their use increases. These changes continually improve the languages and most are backward compatible, so your old applications will continue to work. However, this lack of stability is a concern to many, and cautious developers might take a wait-and-see attitude rather than commit significant development resources to such new technology.

Another issue is that not all browsers support Java and JavaScript. For intra-networks this isn't a serious problem, although it may be a serious cost. In these cases, it's often acceptable to require the use of a particular browser. In cases where the service is provided to the general Internet audience, some consideration must be given to the users who don't have Java-capable browsers. Serving such a broad constituency can be costly and add to the complexity of the CGI application, which must alter the outgoing HTML based on the browser capabilities. This should be a serious consideration to anyone attempting commercial Web applications.

JavaScript source is an integral component of the HTML page sent to the browser. As such, it's accessible to anyone who accesses your page. Many mainstream commercial developers are uncomfortable with the prospect of "giving away" source code. In most cases, they're new to the Internet and not yet accustomed to the spirit of sharing that is its foundation.

Links Related to this Chapter

As Java and JavaScript become increasingly popular, Internet sites are springing up with support for users and programmers. You'll find many sites with tutorials and examples to simplify your use of this technology. Others will simply entertain. Listed here are a few sites to get you started:

http://www.javasoft.com/ is Sun Microsystems' Java home page. It's the best source of up-to-date information on the Java language, Java applets, and the HotJava browser.
http://www.javasoft.com/applets/ contains a long list of Java applets and Java home pages.
The comp.lang.java newsgroup is a discussion forum for Java language issues. Check it out if you have questions about the Java language and Java applets.
http://www.gamelan.com/ is an archive of Java resources. It's a great place for finding Java applets, Java libraries, and other Java programming tools.
http://www.netscape.com/ is Netscape Communication Inc.'s home page. This is the best source of up-to-date information on Java support in the Netscape Navigator. Check out this page to find out whether the Navigator for your favorite platform supports Java.
http://www.i5.com/forum/ is a Web conferencing system using JavaScript. This is an excellent example of a powerful and sophisticated application written in JavaScript.
http://www.cris.com/~raydaly/htmljive.html is an HTML editor written in JavaScript. You can use this page to create your own HTML documents. If you save the page containing the editor, you'll always have an HTML editor handy.
http://www.hamline.edu/personal/matjohns/webdev/java/ is an extensive listing of Java and JavaScript resources available on the Net. This is a good starting point to search for information and examples.
http://ugweb.cs.ualberta.ca/~nelson/java/JavaGuides.html provides several guides to Java, including the AWT Tutorial, some JavaScript information, and the AppletGen home page. (The AppletGen is a network resource to compile your applets.)
http://www.homepages.com/fun/1040EZ.html is a demonstration of the use of JavaScript to fill out the IRS 1040EZ tax form. This provides many useful examples of combining JavaScript and HTML forms.
http://home.netscape.com/eng/mozilla/Gold/handbook/ is the JavaScript Authoring Guide from the creators of JavaScript.
http://gmccomb.com/valid.htm provides examples of verifying form input with JavaScript. This is a good starting point for simple form-related scripts.
http://ourworld.compuserve.com/homepages/vood/script.htm is Voodoo's home site with an introduction to JavaScript. This provides a good tutorial introduction to the use and capabilities of JavaScript.
http://www.gamelan.com/Gamelan.javascript.html is another index of JavaScript sites, and is a good place to start when looking for JavaScript samples and information.
Follow the comp.lang.javascript newsgroup to stay abreast of the latest trends in JavaScript and JavaScript applets.
http://www.unt.edu/~kmiller/ is an enhanced site targeting Microsoft Internet Explorer and JavaScript-capable browsers. This site includes general MIDI demonstrations.
http://www.w3.org/ is the home page of the Web standards organization. This is a good starting point for finding information on the Web, HTML, protocols, browsers, and so on.