Getting to know WebSphere Studio Application Developer

Its capabilities, technologies, and relationship to the open-source Eclipse IDE

Tim deBoer (deboer@ca.ibm.com), Software Developer, IBM Canada

Tim deBoer is a software developer on the WebSphere Studio Application Developer, Server Tools team at the IBM Toronto Lab. With his teammates, he is currently responsible for the WebSphere and Tomcat test environments and the EJB test client. You can contact Tim at deboer@ca.ibm.com.

Rob Stevenson (rstevens@ca.ibm.com), Information Developer, IBM, Software Group

Rob Stevenson is an Information Developer for IBM Canada Ltd. He writes online help and publications for WebSphere Studio Application Developer and VisualAge for Java. You can contact Rob at rstevens@ca.ibm.com.

Summary: WebSphere Studio Application Developer is the vanguard in the new WebSphere Studio family of application development products from IBM. It is optimized for J2EE application development and evolved from VisualAge for Java Enterprise Edition and WebSphere Studio Advanced Edition. It features an array of technologies for J2EE development, including support for Enterprise JavaBeans (EJB) 1.1, XML, Web, and Web services. This article takes a look at Application Developer and examines the workbench, pluggability, perspectives, views, and specialized tools that combine to make Application Developer a very compelling product.

Date: 01 Nov 2001
Level: Introductory
Activity: 644 views
Comments:

Introduction

Application Developer is an open-standard J2EE application development product that represents the next step in an evolutionary path that began with VisualAge for Java Enterprise Edition and WebSphere Studio Advanced Edition. It is a member of the new WebSphere Studio family of application development products that also includes WebSphere Studio Homepage Builder, WebSphere Studio Site Developer, and WebSphere Studio Enterprise Developer.

Homepage Builder is a Web site development product intended for home use that is the direct descendent of the older WebSphere Homepage Builder. Site Developer is a Web application development product that has evolved from WebSphere Studio Advanced Edition. And Enterprise Developer is a cross-enterprise and integration development product intended for development needs that cannot be met with J2EE alone. The WebSphere Studio Family Web site (see Resources) provides additional information about all these products.

Although each of the products in the WebSphere Studio family deserves to have its individual story told, the remainder of this article focuses exclusively on Application Developer, which is the first professional-grade member of the WebSphere Studio family to make the transition from the IBM labs to the general marketplace.

Since Application Developer evolved from VisualAge for Java, it inherits some of the VisualAge for Java core tools. Application Developer also incorporates all of the tools found in Site Developer, which gives it a powerful Web development capability that was not available in VisualAge for Java. Other important features that are found in Application Developer (but absent from VisualAge for Java) include:

EJB 1.1 support
J2EE deployment of EAR, WAR, and EJB JAR files
XML tools
Web services tools
Role-based team development
Plug-in capability for integrating IBM and Business Partner tools
Pluggable JDK and JRE support
File-based IDE

In short, Application Developer has inherited and built on the strengths of VisualAge for Java. However, in this initial release of Application Developer, VisualAge for Java might still be required for certain activities, such as working with the Enterprise Access Builder, using Persistence Builder to generate Java beans, or building GUI Java applications using the Visual Composition Editor. To enable you to perform these activities, VisualAge for Java Enterprise Edition Version 4.0 is included in the Application Developer box. Other products included in the box are:

WebSphere Application Server AEs, Version 4.01
DB2 UDB V7.2
Rational ClearCase LT

The initial release of Application Developer is supported on Windows 2000, Windows NT 4.0, Windows 98, and Windows ME. However, a technical preview of WebSphere Studio Application Developer for Linux is planned for later this year and the full release is scheduled for 2002.

The Workbench

The WebSphere Studio Workbench is the pluggable tool development and integration platform on which Application Developer and other WebSphere Studio products are built. The Workbench was designed and developed using the platform technology of the Eclipse open-source organization, which is dedicated to providing an open-source application development environment.

Using the Workbench, IBM and IBM Business Partners can create Java and ActiveX plug-ins that enable the integration of middleware and server tools into WebSphere Studio products or into other products that are built on Eclipse platform technology. Examples of plug-ins include content creation tools, UML modeling tools, and SCM repositories. Using plug-ins, any necessary development tools can be consolidated on a single development platform. The Application Developer workbench is shown in Figure 1:

Figure 1. The workbench

Once a tool has been plugged into a WebSphere Studio product, it automatically inherits the essential frameworks and services required to support the tool, such as resource management, editor frameworks, and help systems. These services and frameworks enable developers to focus on tool creation rather than on integration details.

Perspectives and views

Another important feature in Application Developer is the use of perspectives and views. A perspective is used to customize the workbench interface so that it is optimized for working with all of the tools that are normally associated with a particular development role or task. For instance, the Debug perspective is used to customize the workbench interface so that it is optimized for debugging, as shown in Figure 2:

Figure 2. The Debug perspective

In Application Developer, you can choose from the following perspectives:

Data
Debug
Help
J2EE
Java
Java type hierarchy
Plug-in development
Profiling
Resource
Scripts
Server
Team
Web
XML

Each perspective is generally made up of several pane-like views. Each view provides you with a different way of viewing and working with resources in a more specific way in a particular perspective. For example, the Debug perspective consists of multiple views, such as the Variables view shown in Figure 3:

Figure 3. The Variables view

You can use the Variables view to browse the variables in your source code.

In the Workbench, you work with the same project artifacts regardless of the perspective. If a perspective or view doesn't quite meet your needs, you can customize it by mixing and matching other perspectives or by adding, moving, or removing views. Alternatively, you can create a perspective or view of your own directly in the Workbench or use a plug-in to integrate a perspective or view that was created in a different workbench. This lets you configure the workbench so that it has a look and feel that is similar to other tools, such as VisualAge for Java, JBuilder, or Visual Cafe.

Tools and features

In addition to its plug-in capability, perspectives, and views, Application Developer provides specialized tools and features for J2EE application development, including:

Java development environment
Integrated debugger
Relational database tools
Web tools
EJB tools
XML tools
Web services tools
Server tools
Profiling tools
Team development environment

These tools and features are described in the following sections.

Java development environment

The Java development environment provides many of the same source-level Java development tools found in VisualAge for Java, such as:

Incremental compilation
Code assist
Scrapbook
Search, compare, and merge
Syntax highlighting
Reference searching
Crash protection and auto recovery

However, in Application Developer, the Java development environment also provides new tools and enhancements. For instance, improved refactoring makes it possible to move or rename elements like packages, classes, and methods while automatically resolving all of the dependencies for any renamed element. Other new features in Application Developer include:

JDK 1.3 support
Pluggable, project-level JRE switching
Filtering
Class outlines
Task list
Edit the source of a class method-by-method or all at once

Also, since the Java files are exposed in the file system, you can use your favorite external tools, such as grep or vi.

A Java perspective is provided for working with the tools of the Java development environment, but other perspectives can be used as well.

Integrated debugger

The JDI-based integrated debugger lets you perform either local or remote debugging. It is complemented by the Debug perspective, which provides a dedicated debugging environment with multiple views to assist in your debugging activities. In addition to the usual complement of debugging tools, source-level debugging capability for JavaServer Pages (JSP) files is provided to help you resolve JSP-related errors and warnings.

Relational database tools

The relational database tools are accessible from the Data perspective of the workbench. These tools allow full access to any relational data associated with your application. Database schemas can be imported from an existing local or remote database, designed from scratch, or manipulated within the workbench. DDL files can also be generated directly from the schema design. The tools do not require a live connection, so you can continue to work even when you are offline.

An SQL Query Builder is provided for visually constructing and executing SQL statements using insert, select, update, and delete operations. The SQL Query Builder is shown in Figure 4:

Figure 4. The SQL Query Builder

When finished, the SQL-to-XML wizard can be used to generate either XML from a query statement or full DADX files for DB2 Extender from any SQL statement.

The relational database tools provide a common meta-data model for database information, which is shared by all other tools in the workbench that require database information. This allows you to use the same tools when mapping EJB beans or creating XML from an SQL query. Database connection information is also shared, even between unrelated tools, so that the information only needs to be entered once.

The relational database tools support numerous database products and handle any vendor-specific differences. The supported databases include DB2, Oracle, Sybase, MySQL, Informix, and SQL Server.

Web tools

Web development tools are inherited in their entirety from WebSphere Studio Site Developer. A dedicated Web perspective provides an optimized environment for working with these tools, and its views let you directly manage your Web resources. For instance, the Links view lets you see all of the links that are referenced in your HTML or JSP files. The Web tools also include validators to verify the correctness of your Web components. For example, a link validator automatically updates your links when you move or rename your files, and a JSP validator automatically posts any JSP-related errors or warnings to the Task list.

Page Designer is a WYSIWYG editor for creating and editing HTML and JSP pages. It supports JSP tags and tag libraries, and also supports code assist for HTML, JSP, and Java content types. To enable you to work with style sheets, a CSS editor is provided.

For J2EE development, the Web tools include wizards that let you quickly generate Java beans, HTML, servlets, and JSP files. XML deployment descriptor editors are also provided, as well as import and export wizards for moving WAR files in and out of the Workbench using HTTP or FTP.

Other Web tools and features include:

Scripting support for Visual Basic and JavaScript
WebArt Designer for creating graphic titles, logos, and photo frames
AnimatedGif Designer for creating animation from still photos or graphics
A library containing thousands of images and sounds
Support for pervasive computing devices (hand-held and wireless)

EJB tools

Most of the EJB development tools have been inherited from VisualAge for Java, but with several important enhancements. For example, the tools support both the EJB 1.1 and J2EE specifications and offer improved support for enterprise bean relationships, inheritance, and top-down, meet-in-the-middle, and bottom-up mapping. Also, EJB-related metadata is now contained in accessible open-standard XMI documents. And the EJB perspective provides an optimized environment for working with the EJB tools.

As in VisualAge for Java, the EJB tools provide an enterprise bean creation wizard, as shown in Figure 5:

Figure 5. The Enterprise Bean wizard

The EJB tools also include an access bean creation wizard, deployment descriptor editors, code validation, and wizards for importing and exporting EAR files and EJB JAR files. Using the EAR export wizard, you can deploy directly to either WebSphere AEs or AE, or to other application servers.

The new Deployment Tool for Enterprise JavaBeans provides a command-line interface that you can use to generate deployment code for your enterprise beans. And since the tool employs a command-line environment, you can run overnight build processes and have the deployment tool automatically invoked to generate your deployment code in batch mode. The tool also provides support for meet-in-the-middle mapping, EJB single and multiple table inheritance, and associations that have been defined in VisualAge for Java. Additionally, it supports the use of converters, which translate a database representation to a Java object type, and composers, used to map a single complex bean field to multiple database columns.

XML tools

The XML development tools are largely comprised of a series of editors for XML and related artifacts, including editors for XML source, schemas, mappings, and DTD files. These editors allow you to create, edit, and validate the various file types. Depending on the context, these editors will even display the valid options that you can specify as your input, which saves you time and ensures that you have a valid XML document at all times. The XML tools can also generate type-safe Java beans to access XML documents from your application code.

To handle translation or conversion between multiple formats, an XML mapping editor can be used to generate an XSL translation between two DTDs or XML schemas. As the XSL file is created, an XSL trace editor can be applied to the XSL file and an existing XML document to validate the translation and to step line-by-line through the newly generated XML or HTML file. Java beans can also be created at any time to handle the translation programmatically from your own code.

The RDB/XML mapping editor is another feature of the XML tools, which can be used to map table columns to elements and attributes in an XML document. If you are using DB2 Extender, Document Access Definition (DAD) scripts can be generated to compose or decompose XML documents to, or from, a DB2 database.

Web services tools

Creating Web services from existing business logic or services is easy with the Web service wizard. This single wizard can be used to generate a SOAP Web service from one of several component types, such as a Java bean, a stateless session EJB bean, a URL that returns XML data, or a DADX file created by the XML tools. The wizard leads you through the steps to generate the WSDL binding and service files. If you have existing WSDL files instead, it can create a Web service from the WSDL files and also create a Java bean skeleton for future implementation of the Web service.

The mapping between Java and WSDL or XSD files is also handled by the Web service wizard. Primitive type mapping or complex types are all supported. The Web service is deployed into a Web project and configured to run on WebSphere Application Server or Apache Tomcat.

Once the Web service has been successfully created, there are several options to access and test the service. A type-safe Java bean proxy for the Web service can be generated, which can be tested through a set of dynamic JSP pages or by using the EJB test client to directly invoke methods on the proxy bean. Once again, all of these options are available directly within the Web service wizard or can be invoked later using the Web service client wizard.

UDDI Explorer, a Web application, lets you locate and import the WSDL of an existing Web service from a UDDI registry or register your Web service by exporting the WSDL to the registry.

Server tools

The Server tools have a dedicated Server perspective and offer substantial improvements in testing and deployment capability over VisualAge for Java. The WebSphere AEs Version 4.0 test environment can be used to run and debug Web, EJB, and Enterprise Application projects directly in the Workbench. By incorporating the full WebSphere run time in the test environment, you can be assured that your code will run identically when moved to a production environment.

Once the code has been successfully tested in the Workbench, you can publish the J2EE projects and server configuration directly to a remote installation of WebSphere AEs and run and control the application from the workbench. The same server configuration used during local testing can be reused on the remote server, which ensures that the transition to a production environment is as effortless as possible. To help with any further testing, all of the features available in the test environment are available for use in remote profiling and remote JSP source debugging.

Application Developer also provides direct support for Apache Tomcat. Versions 3.2 and 4.0 of Tomcat are supported as test environments and you can publish, run, and debug an application on a locally installed copy of Tomcat.

Server configuration files are provided as resources directly within the Workbench. This allows servers and their configurations to be versioned along with other resources or shared among a development team. It also allows multiple servers to be configured or run at the same time. When developing multi-tier applications, all of the servers can be debugged at the same time from the same machine.

For testing EJB beans, a new Web-based EJB test client is provided that adheres to the J2EE programming model and allows multiple users to test and invoke enterprise bean methods from a Web browser, as shown in Figure 6:

Figure 6. The EJB test client

In the test client, a JNDI explorer visually shows the JNDI registry of the server and allows navigation to items within the JNDI namespace instead of through direct lookup.

Profiling tools

Application Developer provides powerful profiling tools that allow you to analyze performance problems and memory leaks in your applications. Using pattern extraction and multiple views of the profiling information, problems can be rapidly identified and isolated.

Profiling can be performed on local or remote processes or even on distributed applications. Processes can be launched for immediate profiling, or the profiling can attach to an existing process. Simple class and package filtering can be used and modified during execution to focus the information that is captured.

When identifying performance bottlenecks, the profiling tools provide method statistics and views of the method invocation and execution flow. Frequently called or slow methods are easily identified and the pattern extraction allows analysis of more complex bottlenecks. Since the profiler is fully integrated with the Java development environment, clicking on a method in one of these views will take you directly to the Java source.

By using snapshots or watching the program over a period of time, heap problems and memory leaks can also be identified. In this case, the Heap view and Object Reference view show not only the objects that cannot be garbage collected, but where they are referenced from as well. The Object Reference view is shown in Figure 7:

Figure 7. The Object References view

Team development environment

In Application Developer, you can choose to use any SCM product that provides a plug-in for the Workbench. In the initial release, plug-ins are provided for both Concurrent Versions System (CVS) and Rational ClearCase LT. If you are using CVS, a Team perspective is provided to help centralize your team development.

Both CVS and ClearCase LT are file-based rather than repository-based team development environments. A file-based team environment has the following advantages:

Easier integration of tools that can work directly in the file system
No duplication of data between the file system and the IDE workspace
Greater flexibility in workspace content; for example, packages can appear in multiple projects
Work can be stored across geographically distributed teams

For those organizations that prefer to use a repository-based team development environment, a WebDAV adapter plug-in may be offered if customer interest warrants it. As more SCM providers begin to develop adapter plug-ins for the workbench, in the future you should have even more choice in your selection of a team development environment.

Summary

As a member of the new WebSphere Studio product family, Application Developer offers J2EE application development capability and inherits the Java and Web capabilities of VisualAge for Java Enterprise Edition and WebSphere Studio Advanced Edition. Application Developer is built on the WebSphere Studio Workbench, a pluggable tool development and integration platform that incorporates the Eclipse open-source platform technology. The Workbench is complemented by a wide array of specialized tools that provide Application Developer with EJB 1.1, XML, Web, Web services, and other development capabilities. Application Developer is currently available for Windows and a technology preview of Application Developer for Linux is planned before the end of the year. The pluggability, perspectives, views, and specialized tools that characterize Application Developer should ensure that it is well-positioned to dominate the J2EE application development landscape for many years to come.

Resources