Java Desktop

Allowing extensibility of a rich Java GUI is a daunting task. Each user may require slightly different functionality - this one wants to be able to import data from an Excel spreadsheet, and another wants to generate custom XML reports of particular artifacts in the application. You want to make every user happy, but you very rapidly see yourself with multiple code branches trying to satisfy those custom requirements - every Java developer's configuration management nightmare.

Not only is it undesirable to dirty the code base with customer-specific functionality, but you don't want to derail the core development team with continual disruptions for customer requests for simple enhancements to the GUI; it would be much more effective for the customer to be able to add all the functionality that is needed.

At Unicorn Solutions (www.unicorn.com), we developed a Scripting Extension Framework, developed in Jython and XML, that allows non-Java developers to easily enhance our out-of-the-box Swing-based application with custom, rich GUI features. This has greatly increased the extensibility of the Unicorn System, our platform for enterprise metadata management and semantic enterprise information management.

This article is aimed at both developers who are struggling with the task of multiple requests to customize their rich Java client for different customers, and developers who have an interest in Jython and examples of how it integrates with Java applications. It covers the requirements for the framework, and details the design and implementation of the Scripting Extension Framework with sample code. It covers both the usage of XML descriptors for extensions as well as how to call the Jython Interpreter from Java. It will give the target audience in-depth knowledge on how to implement a similar solution in any similar application.

Introduction - Flexing the Inflexible Application Release day has finally arrived - the full-featured Swing application that you've been developing for the past two years is finally going out to the customers on time. The problems start when each customer wants slightly different enhancements, most of which you'd rather not incorporate into the main product. The type of features that a customer might want could range from a simple "Find and Replace" feature, to any of the following customer-specific features (see Figure 1):

• Batch loading of data from external legacy sources (flat file, Excel)
• Verification procedures on custom data
• Wizards for automating custom tasks
• Generation of reports in different file formats (CSV, XML, or Excel)
• Automated processes to update data

If this isn't bad enough as it is, it has become apparent that the customer is not going to stop with those requests but will continue to bombard you with enhancement and utility-feature requests for the long-term future.

The traditional ways of addressing such requirements range from releasing a different version of the product for each customer to providing code-hooks that the customer can code against to add the required functionality.

Releasing a different version of the product to each customer is a Configuration Manager's biggest nightmare - the task of maintaining multiple branches of the same release, together with tracking which features are in which version, is an error-prone process that is very expensive on resources. Not only that, but the amount of R&D development time to work on non-generic customer enhancements can be a big drain on resources, both in development and testing.

Providing code-hooks are generally very limiting in the breadth of functionality that can be exposed, and, generally, most custom enhancements can't be fully implemented in this framework.

Making the Application Flexible
Before getting down to making your rich GUI application flexible, we need to understand what it means to be flexible and what we'd like to see from the framework that provides this flexibility.

1. Low levels of programming skills to develop extensions. Already at Unicorn, there are several customers writing their own extensions with minimal support required from R&D.
2. The extensions should be developed in an easy-to-learn scripting language that integrates well with the main product.
3. Customer should be able to create simple GUI dialogs for their enhancements that control user-input, display reports visually, etc.
4. Seamless integration with core product features. It should not be obvious to users of the customized application which features are part of the core product and which have been developed as custom enhancements.
5. Ease of deployment - it should be easy for developers of the custom features to deploy these features to the core product. Complicated build processes should be totally avoided.
6. Customer extensions should be guaranteed to be compatible with future versions of the core product.

The Scripting Framework
In order to answer the above list of requirements to create a flexible rich GUI, at Unicorn we developed a full-fledged scripting framework, allowing in-house developers at customer sites to to create all the extensions that were required. The Scripting Framework consists of a controller that connects all deployed extensions to the application at runtime. Each extension consists of a descriptor, written in XML, that contains relevant information about the extension; for example, display name, input parameters, and a pointer to the script that contains the execution logic of the script.

The Scripting Framework is needed to adopt a programming language. It was decided to use a language that could tightly interact with Java programs, and there were obvious advantages to an interpreted language for ease of development of scripts. This naturally led to the choice of Jython as the language for the Scripting Framework.

Jython
Jython is an implementation of the high-level, dynamic, object-oriented language Python written in 100% Pure Java, and seamlessly integrated with the Java platform. It thus allows you to run Python on any Java platform. In addition to allowing the use of regular Python syntax, it is also possible to create Java objects and call methods on them within a regular Python expression.

Jython is freely available for both commercial and non-commercial use and is distributed with source code. Jython is complementary to Java and is especially suited for the following tasks:

• Embedded scripting: Java programmers can add the Jython libraries to their system to allow end users to write simple or complicated scripts that add functionality to the application.
• Rapid application development: Jython programs are typically 2-10X shorter than the equivalent Java program. This translates directly to increased programmer productivity. The seamless interaction between Python and Java allows developers to freely mix the two languages both during development and in shipping products.
• Dynamic compilation to Java byte codes: Leads to the highest possible performance without sacrificing interactivity.
• Ability to extend existing Java classes in Jython: Allows the effective use of abstract classes.

The Python language combines remarkable power with very clear syntax. It also supports a full object-oriented programming model, making it a natural fit for Java's OO design.

Let's look at the steps needed to develop an extension, and how extensions are loaded and executed.

Extension Descriptor
The extension descriptor contains instructions on how the executable script should be bound to the application at runtime. The descriptor contains the following information:

• Display name of the extension.
• Informal description of the extension.
• Optional hotkey for the convenient quick launch of the extension.
• Menu/Toolbar location information - the extension developer can decide where the extension will appear in menus/toobars.
• Instructions for displaying a rich GUI input dialog - this will typically hold a list of parameters, each describing a single piece of input that the user of the extension can enter at runtime, which will subsequently be passed to the script. Each parameter holds the following information:
  - Internal identifier for input parameter
  - Display name of parameter
  - Type of parameter. This can be simple types such as string, password, number, boolean, string list, or this could also be application-specific objects like Employee, Address, or Company.
  
• A pointer to the location of the Jython script to be executed.

It's clear that each extension descriptor contains all of the instructions required for extending the application with the extension, including providing the user with a high-usability user interface for accessing the extension.

We chose XML as the file format for the extension descriptor for several reasons. XML is a popular format for expressing information in a structured manner - parsers and validation tools are readily available. Also, by choosing XML, we are able to validate all descriptors against the XML Schema, which allows for catching badly structured descriptors at an early stage. By publishing the XML Schemas to extension developers, we are also providing the developers with a very handy tool to help create syntactically correct descriptors.