Level: Introductory Tim deBoer (deboer@ca.ibm.com), Software Developer, IBM Canada
Rob Stevenson (rstevens@ca.ibm.com), Information Developer, IBM
01 Nov 2001 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.
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:
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
About the authors  | | |
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 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.
|
Rate this page
| 
