Oracle JDeveloper and ADF allow you to build your web application taskflow by taskflow and page (fragment) by page (fragment) in a visual and partly declarative manner. JHeadstart is a JDeveloper extension for template-based automation of these ADF development tasks. JHeadstart takes declarative development to the next level by specifying meta data and generating a complete ADF web application at once. Oracle JHeadstart automatically creates initial meta data. Based on data collections defined in your model layer, your first application can be running in a matter of minutes. By refining your meta data via a simple property editor, you can create sophisticated web applications with many advanced features that are discussed below.
Traditional application generators often limit flexibility during application development and maintenance by producing thousands of lines of code that are hard to understand and change. Oracle JHeadstart actually increases your flexibility. JHeadstart does not generate Java code, all generated output is XML (facelets or jspx pages or jsff page fragments, faces-config files,(un)bounded taskflows and ADFm page definitions). This XML output is 100% driven by generator templates, using the open source Velocity templating framework. Changes made to generated pages or taskflows to meet requirements not provided out-of-the-box are easily moved to custom generator templates. This allows 100% generation of very sophisticated user interfaces. It allows changes on any level of the user interface ranging from a customized button to changing the entire look-and-feel of the application. These changes can be made at any stage during development or maintenance, allowing you to apply agile development in its purest form.
This document is divided into design-time features and benefits for the developer when building ADF applications, and runtime features you can add to your ADF web application without coding nor generating a single line of Java. For screen shots of the main runtime features, see the JHeadstart Overview Presentation.
Developer Features and Benefits
JHeadstart supports both static and dynamic menu structures. The static menu structure, using the Trinidad XMLMenuModel, is based on the group structure of the meta data used to generate the application, and can be customized using custom templates. The sample page templates that ship with JHeadstart allow display of the menu structure using tabs or using a tree control. The dynamic, runtime configurable, menu structure is implemented using a set of database tables. A maintenance application on the menu tables can be generated in minutes: the underlying ADF Business Components that access the menu tables are included in the JHeadstart Runtime, and a sample meta data ("service definition") file to generate the menu administration pages is supplied as well. Both the static and dynamic menu's can be displayed in various ways. The sample page templates that ship with JHeadstart include a tree-style menu, and a tabbed menu. Both menu stylyes can also be combined with dynamic tabs, the menu is then shown in tree-style, and clicking on a node in the menu tree will open a new dynamic tab, with its own transaction boundaries. This allows end users to perform multiple independent tasks simultaneously, by opening multiple dynamic tabs.
Declarative support for creating dependencies between items, where the item properties of one item or group of items, depend on the value(s) of another item or group of items. For example, items can be enabled/disabled, shown/hidden, made optional or required based on the values of other items. When a "depends on" item value changes, the dependent items are immediately refreshed in the user interface. This functionality can also be used to implement cascading dropdown lists, both in table and form layout. Regions can also be made conditionally dependent, allowing several items to be "refreshed" together when necessary.
JHeadstart supports both web-tier LOV's defined in the JHeadstart Application Definition Editor ("JHeadstart-LOV's"), or model-based LOV's defined in ADF Business Components.
JHeadstart supports both web-tier search behavior implemented in the JHeadstart Runtime library ("JHeadstart-search") as well as model-based search behavior defined in ADF Business Components.
JHeadstart includes support for so-called flex items, items that can be added at runtime using flex item administration pages. This feature is particularly useful for independent software vendors (ISV's) who develop applications for multiple customers. Each customer might have specific requirements for additional items not present in the core data model. Using JHeadstart, these additional items can be defined at runtime. JHeadstart provides a table structure to store the flex item definitions and values, and JHeadstart can generate flex item administration pages that can be invoked as a dialog window on top of the page that requires the additional flex items. All aforementioned item display styles are available for flex items, including the functionality to make flex items conditionally dependent on each other.
The productivity you can achieve with Oracle JHeadstart is similar to or exceeds the productivity levels of 4GL tools like Oracle Designer and Developer. And to achieve this level of productivity, you don't need to be a JEE or ADF guru.
We already discussed the numerous runtime features that can easily be generated by specifying the appropriate meta data. In addition, the JHeadstart development environment, fully integrated in JDeveloper, offers various features to further enhance productvity:
A host of best practices is auto-implemented in JHeadstart-generated ADF applications. For example, JHeadstart generates by default a so-called one-page application. There is one UIShell page based on an ADF Faces page template, and within this UIShell page an ADF Faces dynamic region is used to display actual page content. When clicking on a menu tab, the current region displayed within the dynamic region switches. Each region displays a bounded taskflow with page fragments. The advantages of this structure include:
In traditional development methods, the analysis phase often results in massive piles of papers that should be read and signed-off by the user community. The disadvantages of this approach are widely known: if read at all, the requirements are easily misunderstood or misinterpreted by the users resulting in a system that does not meet expectations. JHeadstart allows for a better and faster approach: by quickly generating fully functional prototypes the user has a much better understanding of the functionality you will be providing. But agile development methods are much more than just rapid prototyping: rather than avoiding changing requirements as much as possible by signing off user requirements, they take change as a given, and even embrace change. JHeadstart embraces change as well. The more changes you have, the more JHeadstart shines:
JHeadstart ships with a comprehensive Developer's Guide which thoroughly describes how to use all the design-time features, and how to generate all the runtime features. The guide starts with an end-to-end roadmap for developing ADF applications using JHeadstart. A chapter on team-based development is also included, containing guidelines on setting up your JDeveloper development environment, including version control, as well as suggested project standards and guidelines.
The JHeadstart Forms2ADF Generator (JFG) enables you to reuse Oracle Forms elements and properties when creating Oracle ADF applications. The JFG creates the Business Services (ADF Business Components) and the JHeadstart meta data (Application Definition). After that you can run the JHeadstart Application Generator to generate an ADF web application based on the User Interface definitions that have been extracted from the Oracle Form.
One of the biggest longer-term advantages of generating applications using a technology-agnostic meta data layer is the ease of leveraging new JDeveloper/ADF releases or even new technologies. In the past, the use of JHeadstart has already enabled customers to smoothly migrate from Struts to JSF and from UIX to (Rich) ADF Faces, and from the JSF controller to ADF task flows. Upgrading to a new JDeveloper release and leveraging new features in such a release, is simply done by regenerating the application with the JHeadstart release that is compliant with the new JDeveloper release.