Corporate Headquarters EMEA Headquarters Asia-Pacific Headquarters 100 California Street, 12th Floor San Francisco, California 94111

51  Download (0)

Full text


Corporate Headquarters EMEA Headquarters Asia-Pacific Headquarters 100 California Street, 12th Floor

San Francisco, California 94111

York House 18 York Road Maidenhead, Berkshire SL6 1SF, United Kingdom L7. 313 La Trobe Street Melbourne VIC 3000 Australia



2008 R2

Product Review Guide

March 2009




Thank you for your time and interest in JBuilder 2008 R2 from Embarcadero, the first application server-independent, enterprise-class IDE built on Eclipse.  

JBuilder 2008 R2 brings the power of accelerated development tools to the Eclipse platform with its renowned rapid application development (RAD) and team collaboration capabilities, making Java development fast, reliable, and economical. JBuilder 2008 R2 combines benefits derived from the Eclipse open source platform, with enhanced reliability, functionality and quality professional developers expect from an enterprise-class Java IDE.

In JBuilder 2008 R2, Embarcadero has reinvented the Java IDE with Application Factories, a new approach to software development and code reuse that is introduced in this guide. JBuilder 2008 R2 also includes robust team development and collaboration features, full UML modeling capabilities, and powerful code coverage and performance analysis tools. JBuilder 2008 R2 gives organizations confidence by bringing manageability to the world of open source downloads, plug-in tools and frameworks all within a trusted, turn-key solution. 





The reviewer’s guide will give an overview of some of the key benefits that Java developers will gain from JBuilder 2008 R2. This guide is not intended as a best practices guide, nor does it cover all the new enhancements in JBuilder 2008 R2. Instead, this guide focuses on the new capabilities with the greatest benefits to Java developers. Appendix A includes a complete list of features for JBuilder 2008 R2 across all editions. 











JBuilder 2008 R2 is the latest release of Embarcadero’s enterprise-class, Eclipse-based Java™ IDE which supports the leading commercial and open source Java EE 5 application servers. Based on Eclipse 3.3 (Europa) and Web Tools Platform (WTP) 2.0, this release of JBuilder includes:

Application Factories: A new approach to software development and code reuse. This

innovative development metaphor and associated collection of tools allows developers to focus more on the nature and purpose of the application, and less on the underlying platform,

framework, and technologies.

Visual Swing Designer: A new, comprehensive set of user interface construction tools for creating Java Swing applications. The visual WYSIWYG designer, wizards, editors, and intelligent layout assistance supports Swing/AWT development including the most popular controls and layout managers.

Struts 1.x: JBuilder 2008 R2 now has full support for Struts 1.x applications including graphical editing and Web flow development.

Updated application server support: JBuilder 2008 R2 supports the latest commercial and open source Java application servers including Borland Enterprise Server, BEA WebLogic Application Server, IBM WebSphere, JBoss, Oracle Application Server, Oracle Containers for Java (OC4J), Apache Geronimo, Apache Tomcat, and Sun GlassFish.

Enhancements to TeamInsight™ and ProjectAssist™: JBuilder 2008 R2 Enterprise edition supports the ProjectAssist installation or assimilation features for the following software products: Version Control (CVS or Subversion), Build System (Continuum), Defect Tracking (Bugzilla) or Task Provider (XPlanner). An open API allows the easy integration of third-party life-cycle management tools is now supported in ProjectAssist and TeamInsight.

Code Coverage and Performance Analysis Improvements: The new Progress Tracker enables development teams to continuously monitor and measure the impact of performance changes by allowing them to compare visual snapshots of their progress. The new CPU root filter enables developers to isolate and narrow down profiling. The New ProbeKit functionality enables dynamic and static instrumentation of the application.

This guide highlights the most exciting new features in JBuilder 2008 R2: the new Swing Designer and Application Factories. We also provide an overview of the advanced features for productivity and also for performance analysis and tuning.










JBuilder 2008 R2 is available in three versions to meet the varying needs of developers and organizations:

JBuilder 2008 R2 Enterprise provides a complete, enterprise-class Java IDE with collaboration and team development support, full support for UML modeling and code archeology, and the newly introduced JBuilder Application Factories which delivers unprecedented developer productivity and code reuse. 

JBuilder 2008 R2 Professional adds expanded support for Java EE 5 and Web services, as well as code profiling and performance tuning tools, sophisticated Swing design capabilities, and basic UML modeling features.

JBuilder 2008 R2 Turbo provides the basic features and functions needed to create and deploy Java applications to today’s leading commercial and open source application servers. Turbo Edition provides a freely downloadable, certified Eclipse bundle. 






JBuilder 2008 R2 introduces a new concept called Application Factories that helps reduce the complexity of software development. With Application Factories, JBuilder 2008 R2 provides a collection of tools that help to address many of the challenges faced by Java developers, including choosing an appropriate framework, managing open source code, managing internal code, as well as how to integrate and reuse existing code. Application Factories help

developers deliver high-quality applications under ever-increasing time pressures. Embarcadero designed Application Factories around four core concepts:

1. Application Modules: The Application Modules save time and effort by giving developers a “jump start” in creating new applications. The modules provide an assembled component containing an application-specific Eclipse project (or projects) along with a set of scripts (described above) for implementing specific features and functionality. JBuilder 2008 R2 includes several pre-built application modules to get started. For instance, Data aware application modules provide a quick start for development of web based applications that utilize a database. JBuilder includes three application modules for three major web

application frameworks: JSF, Struts2 and Spring MVC.

2. Application Resource Classification: Tagging can significantly reduce the time that developers spend to enhance or debug specific application functionality within an existing application. Every resource included in a project (whether a source code file or a library) can be classified by several categories (tags). Developers can assign tags to their code and then subsequently search on those tags to locate specific functionality within the application. JBuilder will then focus on the resources associated with the tag.

3. Task Scripting: Scripts allow developers to implement common features, or sets of features, across multiple projects. As a result, they spend less time on repeatedly developing the same functions over and over, across different applications. For instance, a developer can write a script that generates the Java application code for user authentication, and then share this script across multiple application factory projects.

4. Application Change History: Change history logs can significantly reduce the learning curve for new developers on a project. New developers can review the logs to understand previous enhancements or bug fixes, gaining a better understanding of the application and how to implement additions or modifications to the code. All changes in the application are logged in a repository that lives along with the application itself.

The sections below highlight several of these concepts associated with Application Factories in JBuilder.








To start, open the Application Factory Explorer view. If you are starting with the new workspace it should be open by default. Otherwise, select File > Switch Workspace > Other and provide a directory name for the new workspace when prompted.


The left part of Application Factory Explorer shows a set of filters that could be applied to the list of all available preconfigured application modules (shown in the right part of this view). To select the Struts2 application module, scroll the right part of the view down or select

“Struts2” checkbox in the left part of the view and then select “Struts2 Data-Aware Application 1.0” item.

The Application Module Editor will open and will preview images for the application to be created.

Figure 2: Application Module Editor

Press the Create Application… button. The information dialog tells you that an Application Factory project is going to be created.


After pressing Yes, an application factory project is imported into a workspace and the second dialog is shown asking about running “Create Struts2 Data-Aware Application.js” script that will create a new application. Note: Every application module contains an application factory

project that holds all scripts and resources necessary for a creation of an application.

Figure 4: Creating a new application using an Application Factory script







Now that you have created an application module, you may explore the different components of the module using the tabs at the bottom of the application view.

The Preview tab shows preview images for an application. The top row contains thumbnails for all screenshots available. The bottom row shows the selected image. There are two icons at the top right corner that switch the scale for the selected image: reduced and full size.

The Diagram tab shows the preview of an application diagram of this module.

The Tags tab shows the structure of tags used to classify resources of an application to be created.

The License tab shows the licensing information and overview tab gives a brief description of this module.










The Application Factory Modeling perspective combines views enabling data aware application development. The top left corner shows the Model Navigator view that helps navigate through the modeling element hierarchy at JPA entity modeling. In this case you can see that two projects were created: an Application Factory project and a Struts2Application project.






From within the modeling perspective, you can use the Package Explorer view to see the content of an Application Factory project. In the figure below, notice that the explorer shows two projects: the application itself and the associated Application Factory (containing all the additional Application Factory components). In this instance, the root level consists of 4 folders and 3 files.

Figure 7: Application Factory Project

The Licenses folder contains information about licensing used with this application factory module.

The Preview folder holds images of application screenshots, application diagrams and the tags view snapshots.

The Scripts folder contains the JavaScript shipped with this module. Some of the scripts are invoked at module install time, others can be invoked during the application development phase to automate complex tasks.

The Tags folder holds data about all tags defined for this application and information about resources associated with particular tags.

application.adex is the application module configuration file. It describes where snapshots are located, what script should be called at install time, and the preferred perspective for this module.

cheatsheet.xml is a cheatsheet with helpful information about the module. readme.html is a readme file that contains a module description and notes.




The Tags view resides at the bottom left corner of the Application Factory Modeling

Perspective and shows all tags defined for particular application. The size of a tag depends on the number of resources tagged with it. To make the main views (package explorer, etc.) show only resources associated with a particular tag (tag filtering), select this tag in the Tags view and press the IDE button in the view’s toolbar.






The application diagram visually displays the application architecture and provides navigation to the most important resources (such as configuration files and scripts). To open a resource select it on the application diagram, right-click and pick up the desired editor.

Figure 10: Application diagram








The new Swing Designer in JBuilder 2008 R2 saves developers time and effort in creating GUI interfaces for their applications. The new Swing Designer allows developers to focus on creating application-specific functionality rather than coding the low-level logic of the graphical user interface.

JBuilder’s comprehensive UI construction tools enable rapid development of Java Swing and AWT applications. The visual designer, wizards, editors, and intelligent layout assistance support the most popular controls and layout managers. Swing Designer provides full bi-directional code generation ensuring that the visual design and the source remain in 100% synchronization.

This introduction will provide an example of the ease and simplicity to create a Java form using the new Swing Designer feature of JBuilder 2008 R2. The Swing Designer will automatically generate the source code for you as you add, edit, and delete objects on the form. For this particular demo, we will show you how to create a simple cascading menu on a Java form. To start, we create an empty java project by selecting from the JBuilder menu: File > New > Java Project. In this case, we have named the project “Swing101”.

Figure 12: New Java project

For the demonstration, we have also added a folder for this package, com.codegear.sample. Now, we will create a new window for the application. Selecting control-N on the keyboard brings up the New Project Wizard. In the pop-up window under the Designer folder,


“Application Window” creates an empty application window. Using the “New Swing Object” pop-up, we have created a class called “Sample 1”.

Figure 13: New application window

Opening “” in the Swing Designer, the developer can choose from a “Design” mode and a “Source” mode at the bottom of the screen. Selecting the Source tab displays the source code for the application. The Swing Designer also displays the Properties that may be set for the selected object (in this case the application window). The Swing Designer is all source-based, so that a developer may switch between the source code and the form layout at any time.


Now to create a menu bar, select the “Menu Bar” item from the “Menu Controls” folder in the Palette. Move the mouse to the top of the application window, where JBuilder will automatically highlight the location for the menu bar. Click to add the menu bar. The application window will then display “Add Items Here”.


Next, select “Cascaded Menu” from the Palette, and move the cursor over the menu bar that you just created in the application window. A vertical red bar will indicate the location where JBuilder will insert the cascaded menu object. When you click to insert the cascaded menu, you will see “New Submenu” displayed in the menu bar. You can rename the menu from the within “Properties” panel in the lower left corner of the screen, under “text”. In this case, change the text property to “File”.


To add entries under the File menu, select “Menu Item” from the Palette and then move the cursor over the File menu item in the application window. You will see a horizontal red bar appear under the File menu. Click the mouse to add the menu item that displays as “New Item.” To rename the item, change the text in the Property box to “Open”.

Figure 16: Adding a cascaded menu item

Repeat the above process to add another menu item. However, this time we will show you how to rename the menu item by editing the source code directly. After adding the menu item to the application window, select the “Source Code” tab in the lower left hand corner of the screen. Here, you can change the title of the menu item by editing the source code directly. In this case, change the text property to “Close.”


Figure 17: Editing the source for a cascaded menu item

Move back to the designer by selecting the Design tab in the lower left hand corner of the screen, and you will now see the application window with the File menu including menu items Open and Close.


You can add event handlers to each of the items in a menu. For example, in the application window select Open from the File menu. You will then see a cascading menu, including “Event Handlers” that lists all of the different events that you may assign. From the cascading menu, you can also link actions as an action handler for the item.

Figure 18: Adding an event handler to a menu item

In sum, JBuilder’s new Swing Designer provides a very simple yet powerful way to create compelling, graphical Java applications. JBuilder allows you to drag and drop graphical elements onto the application window and then easily customize the elements based on your specific application requirements. With a robust collection of WYSIWYG features, this












ProjectAssist provides simple, single point installation and configuration of a complete application lifecycle management (ALM) stack for bug tracking, source code management, project planning/tracking, requirements management and continuous integration builds. ProjectAssist dramatically reduces the time and complexity for startup of new projects by guiding the setup process for new team and project environment definitions. Wizards help to create new deployment models – with options for deep and shallow scanning to discover pre-existing services that can be reused. ProjectAssist can save days or even weeks of manual configuration and integration. 

Figure 19: ProjectAssist dramatically reduces the time and complexity for startup of new projects by guiding the setup process for new team and project environment definitions


Without Project Assist, it can take many hours or even days to set up project environments for new team members.  The TeamInsight tools that can enhance the development team

experience are (by category):

• Version Control: CVS, Subversion. • Build System: Continuum.

• Defect Tracking: Bugzilla. • Task Provider: XPlanner

• Web Portlet Server: LifeRay (surfaces the current status of your project using information from other TeamAssist components and provides a comprehensive understanding of how a project is performing)

In addition, an open API now allows the easy integration of other third-party life-cycle management tools with ProjectAssist and TeamInsight.





TeamInsight provides team collaboration capabilities on top of commonly available ALM tools – both open source and proprietary. Development teams can select the individual ALM

components that they prefer and then easily integrate across them.

With TeamInsight, individual developers have a real-time, task-oriented view of their project responsibilities for bugs, change requests, code notes, tasks and requirements. TeamInsight provides an automatic configuration utility that will set up JBuilder to work with all of the bug, task, source and requirements systems for each project automatically. Within a project, the developer can then select any item as their active task and “pin” on it, allowing them to focus the IDE on the resources related to that task.

TeamInsight also includes a web-based team portal that provides charts and reports of project activity including feature burn down, bug find/fix rates, code coverage reports, code health analysis, repository tracking and more. Entire teams share a web portal with live data and statistics for each project. JBuilder 2008 R2 includes collaboration features that allow local and remote developers to jointly design, edit and debug applications in real time. And TeamInsight automatically discovers other clients on the network, allowing users to easily form ad-hoc collaboration sessions. 


  Figure 20: TeamInsight web portal






The new Graphical EJB Workbench in JBuilder 2008 R2 provides a simplified RAD development experience for both novice and experienced JEE developers alike. Legacy projects using EJB 2.x are easily converted to the new annotation-based EJB 3 specification, full LiveSource capabilities let developers use either a code-centric or RAD visual environment. Easily create EJBs and model relationships, security and OCL constraints. Changes to the source code, annotations, properties view and graphical view are always in sync through JBuilder's patented LiveSource technology. JBuilder allows targeting and re-targeting app servers including Borland Enterprise Server, BEA WebLogic Application Server, IBM WebSphere, JBoss, Oracle Application Server, Oracle Containers for Java (OC4J), Apache Geronimo, Apache Tomcat, and Sun GlassFish. 

Using the Workbench to create an EJB is tremendously easy. The workbench allows the

developer to configure each and every option. In addition it has most every option available for each EJB Container. The LiveSource feature has an immediate effect on the EJB code. In fact, through LiveSource the graphical views are just another rendering of the source code and annotations. LiveSource permits JBuilder to add multiple visualizations of the same source code. In Figure 21: EJB Workspace below, we can see that JBuilder can create session EJBs as well as entity EJBs. CMP beans for both EJB2 and EJB3 style persistence (as well as JPA) can be visually modeled or created directly from existing database tables. 


relationships between them. A picture is worth literally thousands of lines of Java code and annotations.  

Figure 21: EJB Workspace

Building a J2EE™/EJB solution in JBuilder is simply creating a project from an EJB Model. The process for creating this project is as follows: 

1. Choose ‘file | new | others’ 2. Select ‘EJB Modeling Project’

3. The wizard will prompt you for project information, target J2EE server and available (see Figure 22 below):



Figure 22 EJB Modeling Project

Use of the EJB Workbench is identical for both EJB2 and EJB3, the graphical view will abstract away whether the source code is using XDoclet or Java Annotations. Of course the source code can be changed and the diagram is always in sync. JBuilder also provides migration tools to make it trivial for developers to migrate applications to EJB3 and annotation-based 


You can now develop your J2EE/EJB application. Session Beans, Entity Beans, Message-Driven Beans and all of the relationships and constraints may be created using the modeling surface. Double-clicking on an element on the modeling surface will take you to its source code view. You can also use Alt + Enter to access the properties view.

If you need to create CMP beans for an existing database table you can do this automatically by right clicking on the project in the model navigator and selecting “Import Entity Beans from Database” 


members of a development team can individually choose to work graphically or using the source view – whichever is best for the job at hand.

Figure 23: EJB Workspace

Sample projects for both EJB 2 and EJB 3 are available on These samples have step-by-step instructions for configuration. 








The Web Services Workbench for JBuilder was developed to provide productivity enhancements expected by JBuilder developers. JBuilder includes several wizards and

modelers that make JBuilder the most productive environment for building Web Services. With the  workbench, it’s possible to perform the following actions inside JBuilder: 

• Import a WSDL document to build a test client for a Web Service that you’ve found through the UDDI registry 

• Build a SOAP server to act as the base for your Web Services  • Expose a simple Java class as a Web Service 

• Expose an EJB Session Bean as a Web Service 

• Debug a Web service and a Web Service client concurrently   








The Java language removes several problem areas for developers, compared to C++ development, by its elimination of memory allocation and pointer management. While this generally makes Java programs more stable than their C++ brethren, it can often lead to the misconception that Java programs don't need to be optimized or profiled. Nothing could be further from the truth, especially when you consider that Java is being used to build enterprise-class applications, which require high performance. With JBuilder, a developer is able to get the profile configured in a matter of minutes. He can then evaluate any number of different statistics about the profiled application.  

JBuilder provides high-level performance-related data displayed in real time that allows

developers to understand whether a performance issue is related to CPU, memory, or both. The Automatic Memory Leak Detector monitors the evolution of memory usage over time for the immediate identification of potential memory leaks. It also allows real-time monitoring of object allocations to understand how the profiled program uses the virtual machine memory.

Allocation Backtrace View allows developers to identify the code or part of the program responsible for instance allocations. The Thread Debugger gives real-time display of the

progress of all threads running within the Virtual Machine. Code Coverage provides a Real-time Class Coverage View to quickly see the coverage for each class and identify classes not fully covered. JBuilder 2008 R2’s new Progress Tracker enables development teams to continuously monitor and measure the impact of performance changes by allowing them to compare visual snapshots of their progress. These features are completely integrated in-shell for Eclipse, and only available in JBuilder. 







Java as both a platform and a language offers a number of advantages in terms of portability and standardization. Programmers across the globe are migrating to Java from a variety of other languages and platforms. For some, the move to Java may also be their first real, hard-core experience with object-oriented programming.  

As a result, the programs written may have hidden performance bottlenecks that slow down processing and eat memory. JBuilder’s performance tuning features are designed to uncover these hidden performance anomalies including such common problems as excessive object  creation, method calling and thread creation, and inefficient memory usage. The Profiler collects timing information and memory data as Java programs are run. As shown in the following figure you will see that once the “Profiler” had been compiled and started, you are able to search for possible performance problems in the code by using the "Instance


Figure 25 JBuilder 2008 R2 Profiling

The “Memory” used by the program is generally the first place to start when using the Profiler. JBuilder includes a number of sample program trace collections. You may want to start by using these examples with the Profiler's online help to get an overview of the Profiler's capabilities.  You have a choice of running a program through to conclusion as one long run, or you can divide the performance data into specific chunks by using “snapshots.” Snapshots can be invaluable as a tool for comparing the first pass of a program with subsequent executions through the same set of code. They are especially helpful for tracking down problems with event-driven code. Use the memory monitor to drill down into details of the code quickly and easily. The snapshots can then be used to track calling relationships. If you want to identify leaks within the same run, the “Memory Leak Detector” creates heap “snapshots” to compare memory heaps during the same execution. 

You can see in the diagram that the profiler can show a hierarchical display of method calls, which can help you expose the most expensive methods. If you need to, you can click down to the source code directly from the diagram, and the graphical interface uses colors to highlight the more expensive method calls.  

At any point in time you can choose to view the source within the tool, you can see how much resource is used by each routine in a panel next to the source window. The tool makes it easy to shift between multiple snapshots, and you can save the entire set of snapshots and program definitions for reuse at a later time. 

New in JBuilder 2008 R2, the CPU root filter capability enables developers to isolate and narrow down profiling, and the new ProbeKit functionality enables dynamic and static instrumentation of the application. 






Request Analyzer is one of the most valuable tools for developers. This feature breaks every transaction down to its individual components. You can run a simple J2EE application through the analyzer and break down the transaction into the following components: 

• JSP™ Page Performance – This includes the total time the transaction spent in the WebContainer 

• JNDI Lookup – the total time spent looking up a remote component  • Session Bean – All time spent within the session bean component  • JDBC™ – total time spent communicating to the SQL data source 

As compared to having to read through log files, add System.out.println’s and crossing your fingers, you can within a matter of minutes integrate request analyzer into most of the major commercial and open source containers.






Software development organizations face the daunting task of creating software that meets best practice standards of code quality while still delivering the software product on time and within budget. Too often, valuable developer and engineering time is spent in code reviews and trying to find errors in the software code which often leads to both project and cost over-runs—while still producing software with errors. According to the Washington D.C. National Institute of Standards and Testing (NIST), “Software errors cost the U.S. economy $60 billion per year. There are many reasons that projects fail: poor management, unrealistic expectations, complex customization, market changes, etc. But more often than not, poor-quality software is to blame. Blame is directed at the software provider—whether it is a commercial software vendor, an outside tech vendor or a company's IT department—because they are the ones responsible for code quality.” 

With “Audits and Metrics”, JBuilder can be used to solve the code quality, code review and code dependency issues typically faced in software development. JBuilder’s audits and metrics are designed to aid developers in finding and fixing problems in their code earlier in the

development process. It embodies the principals of finding problems early that is a perfect complement to the JBuilder IDE. The following figure for Audits and Metrics shows a sample solution that has been audited for frequent and common problems.  

JBuilder’s Audits perform a static analysis of your source code, identifying coding problems like potential race conditions, unchecked exceptions and more. JBuilder’s Metrics provide a like analysis for design problems in your project. 


Historically, early error detection has required software developers to change their processes, think harder, use better methodologies, create better architectures, and the like. The

complexity introduced by far-flung development teams, downsizing, outsourcing, open source, feature-rich software systems and complex development environments all increase the difficulty of building high-quality software systems on time and within budget.  

Pushing the resolution of software quality issues into a Quality Assurance (QA) or Testing

organization, or worst case, onto customers, is at best expensive and can certainly be damaging to the software producer’s reputation. It’s common knowledge that if problems can be found and fixed early in the development process, it will result in better software, lower costs, faster time-to-market, and most importantly, happier users. JBuilder’s Audits and Metrics software development technology has advanced to the point where maximum quality can be

automatically and efficiently built into software as it is being developed. 

With the direct integration of the Audits and Metrics within the IDE it is very easy for the developer to correct their issues. The “Quick Fix” dialog provides options and a preview for the changes recommended. 






LiveSource technology simultaneously replicates changes to models in the code, and vice versa. This ensures system architects and developers are closely aligned in the development process, thereby reducing costs associated with software rework. LiveSource replaces the traditional round-trip engineering methods, which usually cause models and code to go out of synch. Failure to keep models and code in synch often leads to disparity between business needs and the resulting software. 

Figure 28: LiveSource technology simultaneously replicates changes to models in the code, and vice versa.

If you have used Borland Together technology you are very familiar with LiveSource. However it plays a new and critical roll into building effective and efficient Java applications. LiveSource allows you to build solutions visually from UML diagrams and have those changes reflected in the code immediately.  


Figure 29: LiveSource replaces the traditional round-trip engineering methods, which usually cause models and code to become out of synch

LiveSource allows JBuilder to provide multiple visualizations of source code, enabling rapid comprehension of unfamiliar projects. One of the features is the simultaneous roundtrip engineering, which is the ability to immediately synchronize diagrams with their source code.  Traditional roundtrip engineering is the combination of: 

• Reverse engineering (drawing models from code) 

• Forward engineering (generating code from visual models) 

Simultaneous roundtrip engineering means that when you change a code-centric diagram, JBuilder immediately updates the corresponding source code, and when you change the code, JBuilder updates the visual model. This way diagrams are always synchronized with the source code that implements them. You can customize forward and reverse engineering and/or source code formatting.



















Integrated Installation

Sample Applications

Eclipse 3.3.2 (Europa) Framework with WTP 2.0, including: Business Intelligence and Reporting Tools (BIRT)

CVS plug-in

Dali Java Persistence Tools

Data Tools Platform (DTP)

Eclipse Modeling Framework (EMF)

Graphical Editing Framework (GEF) ✔ ✔ ✔

J2EE Standard Tools (JST) ✔ ✔ ✔

Java Development Tools (JDT) ✔ ✔ ✔

Mylyn (formerly Mylyr) ✔ ✔ ✔

Plug-in Development Environment (PDE) ✔ ✔ ✔

Rich Client Platform (RCP) ✔ ✔ ✔

Test and Performance Tools Platform (TPTP) ✔ ✔ ✔

Visual Editor (VE) ✔ ✔ ✔

Web Standard Tools (WST) ✔ ✔ ✔

Additional Eclipse and Third-Party Plug-Ins (partial list):

Apache ✔ ✔

Apache Ant ✔ ✔ ✔

Apache Maven 2.0 Integration ✔ ✔ ✔

Apache Xerces ✔ ✔ ✔

Eclipse AspectJ Development Tools (AJDT) ✔ ✔ ✔


Eclipse Graphical Modeling Framework (GMF) ✔ ✔ ✔

Eclipse JavaServer Faces Tools (JSF) ✔ ✔ ✔

Eclipse Modeling Framework Technology (EMFT) ✔ ✔ ✔

Eclipse UML 2 ✔ ✔ ✔

Eclipse XSD (part of Eclipse MDT) ✔ ✔ ✔

Hibernate ✔ ✔ ✔

JUnit ✔ ✔ ✔

MySQL ✔ ✔ ✔

Spring IDE ✔ ✔ ✔






LiveSource graphical view of EJB 2.1 projects ✔ ✔

LiveSource graphical view of EJB 3.0 projects ✔ ✔

LiveSource graphical view of JPA (Hibernate/TopLink) projects ✔ ✔ Visual point-and-click two-way designer of Entity, Session, and

Message Beans.

Two-way generation of classes and annotations

✔ ✔

Visually design CMP 2.x relationships and configure database mapping

✔ ✔

Visually design EJB 3.0/JPA entity relationships and configure database mapping

✔ ✔

Configure XDoclet task properties for server runtimes supported in JBuilder

✔ ✔

Visually configure persistence properties for EJB 3.0/JPA ✔ ✔

Full build/deploy/redeploy capabilities ✔ ✔

Visually create Session Beans ✔ ✔

Automatically arrange Beans on design panes ✔ ✔

Create multiple design panes to logically group Beans in an EJB group

✔ ✔

Adjust filtering to hide or show generated classes ✔ ✔


Import EJB descriptors, including vendor-specific descriptors, for all supported servers

✔ ✔

Visually create Message-Driven Beans ✔ ✔

Visually create Entity Beans ✔ ✔

Convert descriptor-based source to XDoclet or Java EE 5 annotations

✔ ✔

Import multi-module Java EE projects from earlier versions of JBuilder and convert them to native Eclipse projects

✔ ✔

Generate EJB 2.x Entity Beans from existing database schema ✔ ✔ Generate EJB 3.x Entity Beans from existing database schema ✔ ✔ Instant navigation between visual EJB components in designer

and source

✔ ✔

Visually create OCL constraints ✔ ✔

Fully integrated with Eclipse 3.3 framework and Eclipse WTP 2.0 ✔ ✔ VisiBroker builder - integration to VisiBroker tools ✔ ✔ Visual representation of Java/EJB with methods and operations ✔ ✔







Apache Geronimo 1.1.1 ✔ ✔ ✔

Apache Geronimo 2.0 ✔ ✔ ✔

Apache Tomcat 6.0 ✔ ✔ ✔

BEA WebLogic Application Server 10.0 ✔ ✔ ✔

BEA WebLogic Application Server 8.1 ✔ ✔ ✔

BEA WebLogic Application Server 9.2 ✔ ✔ ✔

Borland Enterprise Server 6.7 ✔ ✔ ✔

IBM WebSphere 6.0 ✔ ✔ ✔

IBM WebSphere 6.1 (with EJB 3 feature pack) ✔ ✔ ✔

JBoss 3.2.3 ✔ ✔ ✔

JBoss 4.0.5 ✔ ✔ ✔

JBoss 4.2.2 ✔ ✔ ✔


Sun GlassFish 1.0 ✔ ✔ ✔

Sun GlassFish 1.1 ✔ ✔ ✔

Sun GlassFish 2.0 ✔ ✔ ✔







Web Services Designer 

Visual two-way designer for creating Axis based Web Service-enabled applications

✔ ✔

Streamlined user interface and wizards ✔ ✔

Visual representation of WSDL with methods and operations ✔ ✔ Activate or deactivate services without removing components

from the designer

✔ ✔

Instant navigation between visual Web Services components in designer and source

✔ ✔

Import Web services projects from earlier versions of JBuilder, and convert them to native Eclipse projects

✔ ✔

Deploy an EJB as a Web Service ✔ ✔

Build, Debug, and Run Web Services 

Create an Axis deployment environment ✔ ✔

Dynamic generation and deployment of Web Services components during project builds

✔ ✔

Deploy Axis runtime to Tomcat, JBoss, WebLogic, WebSphere, Geronimo, GlassFish, or Oracle

✔ ✔

















Create New Team Project Environment Definition 

Wizard to create a new deployment model ✔

Options for deep and shallow scanning for pre-existing services ✔ Create new installation or assimilate existing installation for:

Source code management ✔

Turbo Professional Enterprise

Turbo Professional Enterprise


Defect tracking ✔

Requirements management and project planning ✔

Continuous integration builds ✔

Create new projects on a new or existing server deployment, across all services

Create new users, add users to new or existing projects ✔

Mylyn (OSS) ✔ ✔ ✔

XPlanner Mylyn Connector ✔ ✔ ✔

StarTeam Mylyn Connector ✔

Install New TeamInsight Stack

Deep or shallow scan of target server for potential conflicts ✔ Full deployment and automated configuration of all services ✔ Automated test of deployment to verify the system is operational ✔

Supported Tools for TeamInsight  Bugzilla ✔ Continuum ✔ CVS ✔ Borland® StarTeam® ✔ Subversion ✔ XPlanner ✔ Project Portal 

Monitor activity in source code repository for project, track recent check-ins

Monitor quality metrics including tables of bugs by severity, by product area, by owner, newest bugs, and bug find/fix rates

Monitor team velocity via live burn-down charts ✔

Monitor team progress against committed features, feature-by-feature

Monitor continuous integration builds, track failed builds to identify root-cause

Turbo Professional Enterprise

Turbo Professional Enterprise


IDE Integration 

Automatic configuration of IDE to pull project from CVS ✔ Automatic configuration of IDE to pull project from Subversion ✔ Single-pane view of individual’s project responsibilities: Assigned

Tasks, Requirements Owned, Requirements Tracked, Assigned Bugs, Reported Bugs, and Code To-Dos

Project portal and all services available via integrated, tabbed browser in IDE

Integrated creation and editing of bug reports ✔

Integrated creation and editing of requirements and tasks ✔ Full off-line mode for persistent access to requirements, tasks,

defects with automated synchronization

Serverless LAN peer discovery and chat ✔ ✔ ✔

Peer code reviews ✔

Open API to enable integration with other popular version control systems such as Perforce, ClearCase, and ClearQuest

✔ ✔







RMI builder ✔ ✔

JNI builder ✔ ✔

Import JBuilder 2006 projects ✔ ✔ ✔

Quality Assurance: Code audits and metrics ✔

Design Patterns support, including GoF patterns with code template design and re-use

✔ ✔









Seamless integration with JBuilder ✔ ✔

Complete code profiling and performance management capabilities for identifying and solving code-level performance issues.

✔ ✔

Improve performance and reliability of any Java code: Java applications, Java EE applications, servlets, applets, EJBs, JavaBeans, JSP applications, and Java Tag Libraries

✔ ✔

Turbo Professional Enterprise


Easily connects to a remote Java process to test a program running on a different machine or a program launched outside of JBuilder

✔ ✔

Memory and CPU Profiling 

High-level performance-related data displayed in real time in order to determine whether a performance issue is related to CPU, memory, or both

✔ ✔

Automatic Memory Leak Detector monitors the evolution of memory usage over time for the immediate identification of potential memory leaks

✔ ✔

Real-time monitoring of object allocations to understand how the profiled program uses the virtual machine memory; Allocation Backtrace View enables identification of the code or part of the program responsible for object allocations

✔ ✔

Object Size Display automatically computes and displays, in real time, the amount of memory being consumed by all instances of a class; then sort and view by object size to prioritize objects

consuming the most memory

✔ ✔

Reduced reference graph provides a transitive closure of the full reference graph to display only references that should be removed in order to free the object for garbage collection

✔ ✔

CPU Profiler measures pure CPU usage or time usage during a profiling session, with option to use sampling-based or

instrumentation-based profiler

✔ ✔

Display profiling information per thread and thread groups, with color highlighting of threads that were busy during profiling session

✔ ✔

HotSpot Display lists methods where most time was spent, to help identify bottlenecks due to single methods

✔ ✔

Scalable call graph visually isolates critical code. Select a string allocation and highlight the flow of a method call to see where memory and time are being spent

✔ ✔

Automatic Application Quality Analyzer supports performance-error prevention and coding standards by automatically detecting VM-level performance bugs

✔ ✔

Export views in XML, HTML and CSV format ✔ ✔

Thread Debugging 

Real-time display of the progress of all threads running within the ✔ ✔

Turbo Professional Enterprise


panels of the Contention View

Wait state monitoring to understand why a thread is not making progress with the Waiting View and I/O Waiting View

✔ ✔

Identify and correct excessive locking where a thread enters and holds monitors using the Monitor Enter View reports

✔ ✔

Analyze deadlocks using graphical view of the relationships between threads and monitors to quickly understand deadlock situations

✔ ✔

Predict deadlocks with Monitor Usage Analyzer which generates full list of warnings and errors that might lead to deadlocks and performance bottlenecks, such as lock order warnings, lock and wait warnings, and lock and I/O wait warnings

✔ ✔

Code Coverage 

Real-time Class Coverage View to quickly see the coverage for each class and identify classes not fully covered

✔ ✔

Real-time display of all classes and interfaces used by the tested program and real-time percentage of lines covered per class

✔ ✔

Method Coverage View displays the methods and lines of code for a selected class that have not been used, allowing developers to modify test plans to cover all areas of the code

✔ ✔

Source Code Viewer shows lines of code that have never been executed, making it easier to spot dead code

✔ ✔

Option to display the interfaces that have been loaded by the virtual machine and those that have not been loaded

✔ ✔

Batch-mode support to easily include code coverage in any batch-mode testing process

✔ ✔

Request Analyzer 

Profile the performance behavior of your Java EE application code across the following Java EE components: JDBC, JSP, JNDI, Enterprise JavaBeans, and JMS containers

✔ ✔

Improve performance and reliability of Java EE-related application code earlier in development with drill-down performance

information for Java EE components

✔ ✔

Visual interface simplifies the complexity of Java EE application interactions using graphical representation

✔ ✔

Turbo Professional Enterprise


System Dashboard view provides a graphical display of the application time spent in Java EE components and total number of requests. Shows the percentage of use for each server module to quickly detect any major component-level performance issues

✔ ✔

System Composite view displays all of the Java EE events that have occurred in an application, in real time, in their proper hierarchy. Hierarchy shows the relationship of events in terms of which events spawn others

✔ ✔








Generate HTML documentation ✔ ✔

Documentation template designer ✔ ✔

Generate documentation using template ✔ ✔

Generate image files from UML diagrams ✔ ✔

Automatic generation of sequence diagrams ✔ ✔

XMI import and export ✔ ✔

Use Case diagrams >>

Activity diagrams ✔ ✔

Sequence diagrams ✔ ✔

Class diagrams ✔ ✔

Component diagrams ✔

Deployment diagrams ✔

State Machine diagrams ✔

Composite Structure diagrams ✔

Communication diagrams ✔

Web services diagrams ✔ ✔

Requirements management using ReqPro ✔ ✔

Requirements management using CaliberRM ✔ ✔





Visually organize code ✔

Turbo Professional Enterprise


Data mine actions from the past ✔ Associate all project artifacts in the context of the desired user

story or task

Application Module Designer ✔

Application Module Runtime ✔

Application Factory Explorer ✔

Recipe Editor ✔

Data-aware Web application modules for Struts 2, Spring MVC, JSF

E-commerce application module based on OFBiz ✔

Template application modules for PetStore and Struts-BookStore ✔ Support for 3 user roles: Consumer Role, Producer Role, and

Ad-hoc Developer Role

Code generation/templating mechanisms that provide a way to generate template code via Application Module Scripts





Code Generation Options 

Bi-Directional Code Generation ✔ ✔ ✔

Read & write almost any style ✔ ✔ ✔

Block mode (default) ✔ ✔ ✔

Flat mode ✔ ✔ ✔

Prefix component creation ✔ ✔ ✔

Share variables ✔ ✔

Control variable declaration ✔ ✔

Create event handler stubs ✔ ✔

Define default variable names ✔ ✔

Make selected widgets fields by default ✔ ✔

Make all widgets fields by default ✔ ✔


Event handlers as anonymous classes ✔ ✔

Event handlers as inner classes ✔ ✔

Implement listener interface in parent class ✔ ✔

Special Features 

Reverse engineer hand-written code ✔ ✔ ✔

Supports user code refactoring ✔ ✔ ✔

Free-form code editing ✔ ✔ ✔

Visual Inheritance ✔ ✔

Custom widget support ✔ ✔

Palette Manager ✔ ✔

Embedded Composite support ✔ ✔

Custom Widget Templates ✔ ✔

Widget Morphing ✔ ✔

Layout Assistant ✔ ✔

Graphical Tab Order Editing ✔ ✔

Multi-Widget Select & Edit ✔ ✔

Marquee Select ✔ ✔

Align multiple widgets ✔ ✔

Replicate width and height ✔ ✔

Gradient Editor for CLabels ✔ ✔

Unlimited Undo/Redo ✔ ✔ ✔

Cut/Copy/Paste ✔ ✔ ✔

Sticky Mode for multi-widget add ✔ ✔ ✔

Show externalized strings ✔ ✔ ✔

Display labels in multiple locales ✔ ✔

Internationalization tools & wizards ✔ ✔

Auto-update resource bundles ✔ ✔

Control editor layout ✔ ✔ ✔


SWT Special Features 


Extract Composite Refactoring ✔ ✔

Gradient Editor for CLabels ✔ ✔

Draft Mode ✔ ✔ ✔ Swing Wizards  Swing JFrame ✔ ✔ ✔ Swing JDialog ✔ ✔ Swing JPanel ✔ ✔ Swing JApplet ✔ ✔ Swing JInternalFrame ✔ ✔ Swing Application

Turbo Professional Enterprise

Turbo Professional Enterprise

✔ ✔ Swing Containers  JPanel ✔ ✔ ✔ JScrollPane ✔ ✔ ✔ JSplitPane ✔ ✔ ✔ JTabbedPane ✔ ✔ ✔ JToolBar ✔ ✔ ✔ JDesktopPane ✔ ✔ JInternalFrame ✔ ✔ Swing Layouts 

Graphical Layout Feedback ✔ ✔ ✔

Null/Absolute ✔ ✔ ✔ FlowLayout ✔ ✔ ✔ BorderLayout ✔ ✔ ✔ GridLayout ✔ ✔ ✔ CardLayout ✔ ✔ GridBagLayout ✔ ✔

Turbo Professional Enterprise


BoxLayout / Struts & Glue ✔ ✔

SpringLayout ✔ ✔

JGoodies FormLayout ✔ ✔

Java 6 GroupLayout ✔ ✔

Swing Controls 

Support for custom / 3rd party widgets ✔ ✔

JButton ✔ ✔ ✔ JCheckBox ✔ ✔ ✔ JRadioButton ✔ ✔ ✔ JToggleButton ✔ ✔ ✔ JLabel ✔ ✔ ✔ JTextField ✔ ✔ ✔ JPasswordField ✔ ✔ ✔ JTestArea ✔ ✔ ✔ JFormattedTextField ✔ ✔ JSlider ✔ ✔ JScrollBar ✔ ✔ JList ✔ ✔ ✔ JComboBox ✔ ✔ ✔ JSpinner ✔ ✔ JTree ✔ ✔ ✔ JTable ✔ ✔ ✔ JToolBar.Separator ✔ ✔ ✔ JSeparator ✔ ✔ JProgessBar ✔ ✔ JOptionPane ✔ ✔ JTestPane ✔ ✔ JEditorPane ✔ ✔


ButtonGroup ✔ ✔

Swing Menus 

Graphical Menu Editing ✔ ✔

JMenuBar ✔ ✔ JMenu ✔ ✔ JPopupMenu ✔ ✔ JMenuItem ✔ ✔ JCheckBoxMenuItem ✔ ✔ JRadioButtonMenuItem ✔ ✔ Menu Separator ✔ ✔ AWT Widgets  Panel ✔ ✔ ScrollPane ✔ ✔ Button ✔ ✔ Label ✔ ✔ Checkbox ✔ ✔ Choice ✔ ✔ List ✔ ✔ Scrollbar ✔ ✔ TextField ✔ ✔ TextArea ✔ ✔ Swing Look and Feel  Windows ✔ ✔ ✔ CDE/Motif ✔ ✔ ✔ Metal ✔ ✔ ✔ JGoodies Plastic ✔ ✔ JGoodies Plastic 3D ✔ ✔

Turbo Professional Enterprise

Turbo Professional Enterprise


JGoodies Plastic XP ✔ ✔

JGoodies Windows ✔ ✔

Liquid ✔ ✔

Kunststoff ✔ ✔

Embarcadero Technologies, Inc. is a leading provider of award-winning tools for application developers and database professionals so they can design systems right, build them faster and run them better, regardless of their platform or programming language. Ninety of the Fortune 100 and an active community of more than three million users worldwide rely on Embarcadero products to increase productivity, reduce costs, simplify change management and compliance and accelerate innovation. The

company’s flagship tools include: Embarcadero® Change Manager™, CodeGear™ RAD

Studio, DBArtisan®, Delphi®, ER/Studio®, JBuilder® and Rapid SQL®. Founded in 1993,

Embarcadero is headquartered in San Francisco, with offices located around the world. Embarcadero is online at




Related subjects :