Oracle JHeadstart 11.1.2 Feature List

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.

Runtime Features

          

Developer Features and Benefits

          

Page Layout Styles

  • Data collections can be displayed in any combination of table layout, form layout, select list layout, shuttle layout, tree or wizard layout.
  • Table layouts can have an overflow area displayed below or at the right of the table, or inline using the "detail disclosure" feature of an ADF Faces table. Overflow areas below or at the right can be separated using a panel splitter component.
  • Multiple data collections can be displayed on the same page, with or without a parent-child relationship.
  • Flexible positioning of data collections relative to each other: right, below, nested, or stacked. They can be separated using panel splitters allowing to resize the panel used to display a specific data collection.
  • Items within a data collection can be grouped into regions. Flexible positioning of regions: right, below, nested, stacked (using tabs or accordion) or on separate pages (useful for wizard layout). Regions can be separated using panel splitters.
  • Regions of a page can be dynamically shown/hidden based on user roles/permissions, or any boolean JSF EL expression.
  • JHeadstart ships with sophisticated ADF Faces page templates that can easily be customized to suit your specific needs.
  • To prototype various look and feels, you can generate a page template switcher and a skin switcher to change the layout and look and feel of your application at runtime.
  • Using custom velocity templates, any layout can be generated should the declarative layout features not be sufficient.

Menu Navigation

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.

Page and Taskflow Navigation

  • Based on the layout styles, and parent-child group relations, JHeadstart will generate the required navigation buttons or hyperlinks and parent context information.
  • Using custom templates, custom navigation buttons with associated ADF taskflow control flow rules can be generated easily.
  • Support for deep linking accross task flows, allowing for context-aware page navigation where the data auto-queried in the page of the destination taskflow depends on the data in the page of the source taskflow. The target taskflow can be displayed "in-page" replacing the current page, in a modal or modeless popup window, or in a anew dynamic tab. Deep linking can also be used to enter the application from an external source, for example other applications, or email notifications that require some action within the application.
  • When navigating between pages, the pages previously visited become accessible through so-called breadcrumbs: hyperlinks that allow the user to navigate back to a previous page. These breadcrumbs are completely dynamic and work within taskflows as well as accross task flows.

User Interface Items

  • Supported item display styles in table, form and search area include: text input, drop down list, list box, radio group (horizontal/vertical), file upload, file download, command button, graph, image, checkbox, list of values, multi-select list box, multi-select checkboxes, hyperlink, email address. Custom display types can easily be added.
  • Allowable values displayed in user interface elements that support this (like LOV's dropdown lists and radio groups) can be static or dynamic, and can be defined in the web tier, or using model-based LOV's in ADF Business Components.
  • Hint texts can be added as a tooltip popup.
  • Items can have a literal default value or complex default values based on a JSF EL expression. Default values are supported both in form layout, and in new rows of a table layout.

Conditionally Dependent Items

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.

List of Values

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-defined LOV's support multi-select and can be used to populate intersection tables.
  • LOV can be based on (read-only) lookup items
  • LOV can return multiple values to base and "lookup" items.
  • LOV can be used to validate the value in the LOV item: when the value is invalid, or matches multiple rows, the LOV is automatically displayed. If the value matches one row, the item value is auto-completed.
  • JHeadstart-defined LOV's are reusable: the same LOV can be attached to multiple items on different pages.
  • Search and query behavior as described below is also available in LOV pages.

Search and Query Behaviors

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-search supports auto-query on/off and maximum number of query hits, quick search using a single search field, quick search using a drop down list to pick the quick search item, advanced search on multiple items with option to search case insensitive, using AND or OR operators, and using any combination of wildcards. Range searches on number fields.
  • JHeadstart-search supports query operators set by the user at runtime using a drop down list that contains values like "starts with", contains" and "does not contain".
  • JHeadstart-search supports indexed and named query bind variables that can be set using a literal value, or any valid JSF EL Expression, allowing for search using sub queries.
  • Ability to conditionally requery data collections on a page using requery condition: each time the user re-enters the page, after committing the page, or based on a custom boolean JSF EL expression.

Transactional Behaviors

  • Support for single row insert, update and delete, multi-row insert, update and delete, add row and duplicate row buttons.
  • Mass update of intersection table using intersection-shuttle layout. Mass update of parent foreign key using parent-shuttle layout.
  • All transactional behaviors can be enabled/disabled or shown/hidden based on user roles or permissions granted through user roles.
  • Individual items can be made updateable/read-only based on user roles/permissions and boolean JSF EL expressions.

Messaging and User Assistance

  • When the user attempts to save data on a page, the user always gets feedback: either the message "No Changes to Save" or message "Transaction Completed Successful" is displayed, or when the data entered is invalid, appropriate error messages are displayed. These messages can easily be replaced with custom messages.
  • When the user navigates away from a page that has pending, non-committed changes, an alert is raised warning the user that pending changes will be lost.
  • If the transaction fails because of a database key constraint violation, the user will be presented with a user-friendly error message instead of the underlying ORA error. JHeadstart implements this by mapping the database constraint name to a resource bundle message entry. Default messages are generated for all database key constraints, and can be customized easily.
  • JHeadstart provides out-of-the-box integration with CDM RuleFrame. The error stack built in the database by CDM RuleFrame is cleanly displayed in the browser page.
  • JHeadstart provides out-of-the-box integration with ADF Faces Online Help Providers. It can generate helpTopicId properties against alle applicable elements and will generate resource bundle entries for online help text when the help provider is set to resource bundle
  • JHeadstart provides support for context-sensitive function keys. The mapping between keyboard keys and logical action can easily be customized.

Application Security

  • JHeadstart supports both ADF/JAAS-based authentication and authorization, as well as custom security using database tables.
  • JHeadstart can generate all artifacts required to enable and use the security features, including a login page, jazn-data and web.xml configuration, an application to administer the users, roles and permissions, and even SQL scripts to populate the security tables with sample data to ease development.
  • Authorization can be implemented using user roles, or even more flexible, using fine-grained permissions a user is granted for using JAAS-provided or custom roles.
  • Authorization rules can be applied to whole pages, regions of a page, or single items.
  • JHeadstart security can easily be integrated with Single Sign-On, ADF Security, ADF Business Components security and Virtual Private Database (VPD) security.

National Language Support

  • JHeadstart fully supports multi-lingual applications. JHeadstart will generate the resource bundles for each language that must be supported, and each translatable text string on the page will read its value from the appropriate resource bundle.
  • The resource bundle entries can be stored in a java class, property file, or in database tables.
  • JHeadstart provides a maintenance screen on the databaseTable resource bundle, which can be used for in-page editing and translation of a page: the maintenance screen is displayed as a dialog window, showing all translatable strings for the current page.
  • A language switcher drop down list can be generated which can be used to quickly switch the language of the page instead of reading the language from the browser locale.

Flex Items

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.


Developer Productivity

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:

  • The JHeadstart meta data is defined through an easy-to-use editor: property sheets with search and online help for properties, possibility to change properties for multiple objects simultaneously, possibility to copy and paste (groups of) properties, drag-and-drop support in structure of meta data, support for duplicating meta data elements, support for synchronization of items with ADF Business Components.
  • A JHeadstart-generated ADF application has exactly the same structure as an application developed manually with drag and drop. You can open generated pages, page fragments page definitions or ADF taskflow files in the (visual) editor in JDeveloper and modify them as desired.
  • To preserve post-generation changes, you have the ability to turn off generation of certain file types, for the whole application or for one or more specific files/pages.
  • The JHeadstart generator architecture is extremely flexible. All generated content is 100% driven by generator templates that use the open source Velocity template engine. Each default template can be replaced by a custom template at the level of your choice: service, data collection group, region, item, domain, etc. By moving your post-generation changes to custom templates, and configuring JHeadstart to use your custom templates, you can keep your application 100% generatable, no matter what your functional and layout requirements are. The advantage of this template-based approach to customization over the option to switch of generation for certain files is agility: you keep all the benefits of agile development as described below. In addition, upgrading to new JDeveloper releases is much easier, when all "post-generation" changes are self-documented in custom templates.
  • Oracle JHeadstart does not generate Java code. It generates XML files that configure and wire reusable components (JSF managed bean classes included in the JHeadstart Runtime) together in ADF controller files. This approach dramatically simplifies customization and maintenance of the generated application.

Best-practice ADF architecture Maximizing Reuse

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:

  • Optimal performance: only the dynamic region part of the page needs to be refreshed when clicking on another menu tab, and user actions within a region only update the region in the page, not the page as a whole.
  • Optimal reuse: Since bounded taskflow based on page fragments can be embedded in any page using an ADF faces (dynamic) region, it very easy to reuse JHeadstart groups across pages. Furthermore, using drag-and-drop, it is as easy to include a JHeadstart-generated taskflow as a region in a handbuilt page. In summary: JHeadstart generates a menu-driven application out of the box, but you can easily reuse the generated artifacts in other user interaction patterns, for example in a workflow-driven application where the transactions are launched from a personal task list.

Agile Development

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:

  • Data model changes are processed with unprecedented productivity: You can synchronize the metadata with the underlying ADF Business Components and generate your application again, the data model changes are automatically carried forward to all pages.
  • Look and feel changes can easily be made at any time in the development cycle. You can start developing your application while the design agency is still designing the user interface guidelines. Once the design is available, you can easily implement the desired look and feel using a combination of ADF Faces skinning and a set of JHeadstart custom templates, and then regenerate your application.
  • Functional changes in the user interface, for example splitting a page into multiple pages, merging multiple pages into one, changing the display type of one or more items, or changing the layout style of a data collection, are implemented within minutes: just change the JHeadstart metadata according to the new requirements and generate again.

Configuration of ADF Business Components

  • Automatically set locking mode to optimistic
  • Automatically allow partial last page in ADF BC View Objects
  • Automatically enforce centralized date / datetime format
  • Support for nested Application Modules
  • Support for inheritance in Entity Objects, View Objects and Application Modules
  • Support for imported ADF Business Components

Documentation

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.

Oracle Forms to ADF Generator

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.

Upgrading to new JDeveloper releases

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.