Home
1/64
Contents
Title and Copyright Information
Preface
Audience
Documentation Accessibility
Related Documents
Conventions
What's New in This Guide for Release 11.1.1.7.3
Part I Getting Started with Fusion Web Applications
1
Introduction to Building Fusion Web Applications with Oracle ADF
1.1
Introduction to Oracle ADF
1.2
Oracle ADF Architecture
1.2.1
ADF Business Components
1.2.2
ADF Model Layer
1.2.3
ADF Controller
1.2.4
ADF Faces Rich Client
1.3
Developing with Oracle ADF
1.3.1
Creating an Application Workspace
1.3.2
Modeling with Database Object Definitions
1.3.3
Creating Use Cases
1.3.4
Designing Application Control and Navigation Using ADF Task Flows
1.3.5
Identifying Shared Resources
1.3.6
Creating a Data Model to Access Data with ADF Business Components
1.3.6.1
Creating a Layer of Business Domain Objects for Tables
1.3.6.2
Building the Business Services
1.3.6.3
Testing and Debugging Business Services with the Business Component Browser
1.3.7
Implementing the User Interface with JSF
1.3.8
Data Binding with ADF Model Layer
1.3.9
Validation and Error Handling
1.3.10
Adding Security
1.3.11
Testing and Debugging the Web Client Application
1.3.12
Refactoring Application Artifacts
1.3.13
Deploying a Fusion Web Application
1.3.14
Integrating a Fusion Web Application
1.4
Working Productively in Teams
1.4.1
Enforcing Standards
1.4.2
Using a Source Control System
1.5
Learning Oracle ADF
1.6
Generation of Complete Web Tier Using Oracle JHeadstart
2
Introduction to the ADF Sample Application
2.1
Introduction to the Oracle Fusion Order Demo
2.2
Setting Up the Fusion Order Demo Application
2.2.1
How to Download the Application Resources
2.2.2
How to Install the Fusion Order Demo Schema
2.2.3
Overview of the Fusion Order Demo Schema
2.2.3.1
Translation Support in the Fusion Order Demo Schema
2.2.3.2
Lookup Tables in the Fusion Order Demo Schema
2.3
Running the Fusion Order Demo Application StoreFront Module
2.4
Running the Fusion Order Demo Standalone Applications
2.4.1
How to Run the Standalone Applications
2.4.2
Standalone Applications in the DevGuideExamples Application Workspace
2.4.3
Standalone Applications in the AdvancedExamples Application Workspace
2.4.4
Standalone Applications in the AdvancedEntityExamples Application Workspace
2.4.5
Standalone Applications in the AdvancedViewObjectExamples Application Workspace
2.5
Taking a Look at the Fusion Order Demo Application
2.5.1
Anonymous Browsing
2.5.1.1
Viewing Product Details
2.5.1.2
Browsing the Product Catalog
2.5.1.3
Searching for Products
2.5.2
The Login Process
2.5.3
The Ordering Process
2.5.4
The Customer Registration Process
Part II Building Your Business Services
3
Getting Started with ADF Business Components
3.1
Introduction to ADF Business Components
3.1.1
ADF Business Components Features
3.1.2
ADF Business Components Core Objects
3.2
Comparison to Familiar 4GL Tools
3.2.1
Familiar Concepts for Oracle Forms Developers
3.2.1.1
Similarities Between the Application Module and a "Headless" Form Module
3.2.1.2
Similarities Between the Entity Object and a Forms Record Manager
3.2.1.3
Similarities Between the View Object and a Data Block
3.2.2
Familiar Concepts for PeopleTools Developers
3.2.2.1
Similarities Between the Application Module and a "Headless" Component
3.2.2.2
Similarities Between the Entity Object and a Record Definition
3.2.2.3
Similarities Between the View Object and a Row Set
3.2.3
Familiar Concepts for Siebel Tools Developers
3.2.3.1
Similarities Between the entity Object and a Table Object
3.2.3.2
Similarities Between the View Object and a Business Component
3.2.3.3
Similarities Between the Application Module and a Business Object
3.2.4
Familiar Functionality for ADO.NET Developers
3.2.4.1
Similarities Between the Application Module and a Data Set
3.2.4.2
Similarities Between the Entity Object and a Data Adapter
3.2.4.3
Similarities Between the View Object and a Data Table
3.3
Overview of Design Time Facilities
3.3.1
Choosing a Connection, SQL Flavor, and Type Map
3.3.2
What You May Need to Know About Displaying Numeric Values
3.3.3
Creating New Components Using Wizards
3.3.4
Creating New Components Using the Context Menu
3.3.5
Editing Components Using the Component Overview Editor
3.3.6
Visualizing, Creating, and Editing Components Using UML Diagrams
3.3.7
Testing Application Modules Using the Business Component Browser
3.3.8
Refactoring Components
3.4
Overview of the UI-Aware Data Model
3.4.1
A More Generic Business Service Solution
3.4.2
Typical Scenarios for a UI-Aware Data Model
3.4.3
UI-Aware Data Model Support for Custom Code
3.5
Overview of the Implementation Architecture
3.5.1
Standard Java and XML
3.5.2
Application Server or Database Independence
3.5.3
Java EE Design Pattern Support
3.5.4
Source Code Organization
3.5.5
Package Naming Conventions
3.5.6
Metadata with Optional Custom Java Code
3.5.6.1
Example of an XML-Only Component
3.5.6.2
Example of a Component with Custom Java Class
3.5.7
Basic Data Types
3.5.8
Generic Versus Strongly-Typed APIs
3.5.9
Custom Interface Support for Client-Accessible Components
3.5.9.1
Framework Client Interfaces for Components
3.5.9.2
Custom Client Interfaces for Components
3.6
Overview of Groovy Support
3.6.1
Referencing Business Components Objects in Groovy Expressions
3.6.2
Referencing Custom Business Components Methods and Attributes in Groovy Expressions
3.6.2.1
Referencing Members of the Same Business Component
3.6.2.2
Referencing Members of Other Business Components
3.6.3
Manipulating Business Component Attribute Values in Groovy Expressions
4
Creating a Business Domain Layer Using Entity Objects
4.1
Introduction to Entity Objects
4.2
Creating Entity Objects and Associations
4.2.1
How to Create Multiple Entity Objects and Associations from Existing Tables
4.2.2
How to Create Single Entity Objects Using the Create Entity Wizard
4.2.3
What Happens When You Create Entity Objects and Associations from Existing Tables
4.2.3.1
What Happens When Tables Have Foreign Key Relationships
4.2.3.2
What Happens When a Table Has No Primary Key
4.2.4
What Happens When You Create an Entity Object for a Synonym or View
4.2.5
How to Edit an Existing Entity Object or Association
4.2.6
How to Create Database Tables from Entity Objects
4.2.7
How to Synchronize an Entity with Changes to Its Database Table
4.2.7.1
Removing an Attribute Associated with a Dropped Column
4.2.7.2
Addressing a Data Type Change in the Underlying Table
4.2.8
How to Store Data Pertaining to a Specific Point in Time
4.2.9
What Happens When You Create Effective Dated Entity Objects
4.2.10
What You May Need to Know About Creating Entities from Tables
4.3
Creating and Configuring Associations
4.3.1
How to Create an Association
4.3.2
What Happens When You Create an Association
4.3.3
How to Change Entity Association Accessor Names
4.3.4
How to Rename and Move Associations to a Different Package
4.3.5
What You May Need to Know About Using a Custom View Object in an Association
4.3.6
What You May Need to Know About Composition Associations
4.4
Creating an Entity Diagram for Your Business Layer
4.4.1
How to Show Entity Objects in a Business Components Diagram
4.4.2
What Happens When You Create an Entity Diagram
4.4.3
What You May Need to Know About the XML Component Descriptors
4.4.4
What You May Need to Know About Changing the Names of Components
4.5
Defining Property Sets
4.5.1
How to Define a Property Set
4.5.2
How to Apply a Property Set
4.6
Defining Attribute Control Hints for Entity Objects
4.6.1
How to Add Attribute Control Hints
4.6.2
What Happens When You Add Attribute Control Hints
4.6.3
How to Define Formatters and Masks
4.7
Working with Resource Bundles
4.7.1
How to Set Message Bundle Options
4.7.2
How to Use Multiple Resource Bundles
4.7.3
How to Internationalize the Date Format
4.8
Defining Business Logic Groups
4.8.1
How to Create a Business Logic Group
4.8.2
How to Create a Business Logic Unit
4.8.3
How to Add Logic to a Business Logic Unit
4.8.4
How to Override Attributes in a Business Logic Unit
4.8.5
What Happens When You Create a Business Logic Group
4.8.6
What Happens at Runtime: Invoking a Business Logic Group
4.9
Configuring Runtime Behavior Declaratively
4.9.1
How to Configure Declarative Runtime Behavior
4.9.2
What Happens When You Configure Declarative Runtime Behavior
4.10
Setting Attribute Properties
4.10.1
How to Set Database and Java Data Types for an Entity Object Attribute
4.10.2
How to Indicate Data Type Length, Precision, and Scale
4.10.3
How to Control the Updatability of an Attribute
4.10.4
How to Make an Attribute Mandatory
4.10.5
How to Define the Primary Key for the Entity
4.10.6
How to Define a Static Default Value
4.10.7
How to Define a Default Value Using a Groovy Expression
4.10.8
What Happens When You Create a Default Value Using a Groovy expression
4.10.9
How to Synchronize with Trigger-Assigned Values
4.10.10
How to Get Trigger-Assigned Primary Key Values from a Database Sequence
4.10.11
How to Protect Against Losing Simultaneously Updated Data
4.10.12
How to Track Created and Modified Dates Using the History Column
4.10.13
How to Configure Composition Behavior
4.10.13.1
Orphan-Row Protection for New Composed Entities
4.10.13.2
Ordering of Changes Saved to the Database
4.10.13.3
Cascade Update of Composed Details from Refresh-On-Insert Primary Keys
4.10.13.4
Cascade Delete Support
4.10.13.5
Cascade Update of Foreign Key Attributes When Primary Key Changes
4.10.13.6
Locking of Composite Parent Entities
4.10.13.7
Updating of Composing Parent History Attributes
4.10.14
How to Set the Discriminator Attribute for Entity Object Inheritance Hierarchies
4.10.15
How to Define Alternate Key Values
4.10.16
What Happens When You Define Alternate Key Values
4.10.17
What You May Need to Know About Alternate Key Values
4.11
Creating Business Events
4.11.1
Introducing Event Definitions
4.11.2
Introducing Event Points
4.11.3
What You May Need to Know About Event Points
4.11.4
How to Create a Business Event
4.11.5
What Happens When You Create a Business Event
4.11.6
What You May Need to Know About Payload Size
4.11.7
How to Publish a Business Event
4.11.8
How to Subscribe to Business Events
4.12
Working Programmatically with Entity Objects and Associations
4.12.1
How to Find an Entity Object by Primary Key
4.12.2
How to Access an Associated Entity Using the Accessor Attribute
4.12.3
How to Update or Remove an Existing Entity Row
4.12.4
How to Create a New Entity Row
4.12.5
Assigning the Primary Key Value Using an Oracle Sequence
4.12.6
What You May Need to Know About Custom Entity Object Methods
4.13
Generating Custom Java Classes for an Entity Object
4.13.1
How to Generate Custom Classes
4.13.2
What Happens When You Generate Custom Classes
4.13.3
What Happens When You Generate Entity Attribute Accessors
4.13.4
How to Navigate to Custom Java Files
4.13.5
What You May Need to Know About Custom Java Classes
4.13.5.1
About the Framework Base Classes for an Entity Object
4.13.5.2
You Can Safely Add Code to the Custom Component File
4.13.5.3
Configuring Default Java Generation Preferences
4.13.5.4
Attribute Indexes and InvokeAccessor Generated Code
4.13.6
Programmatic Example for Comparison Using Custom Entity Classes
4.14
Adding Transient and Calculated Attributes to an Entity Object
4.14.1
How to Add a Transient Attribute
4.14.2
What Happens When You Add a Transient Attribute
4.14.3
How to Base a Transient Attribute On a Groovy Expression
4.14.4
What Happens When You Base a Transient Attribute on Groovy Expression
4.14.5
How to Add Java Code in the Entity Class to Perform Calculation
5
Defining SQL Queries Using View Objects
5.1
Introduction to View Objects
5.1.1
Overview of View Object Concepts
5.1.2
Runtime Features Unique to Entity-Based View Objects
5.2
Populating View Object Rows from a Single Database Table
5.2.1
How to Create an Entity-Based View Object
5.2.1.1
Creating a View Object with All the Attributes of an Entity Object
5.2.1.2
Creating an Entity-Based View Object from a Single Table
5.2.2
What Happens When You Create an Entity-Based View Object
5.2.3
How to Create an Expert Mode, Read-Only View Object
5.2.4
What Happens When You Create a Read-Only View Object
5.2.5
How to Edit a View Object
5.2.5.1
Overriding the Inherited Properties from Underlying Entity Object Attributes
5.2.5.2
Controlling the Length, Precision, and Scale of View Object Attributes
5.2.5.3
Converting a Read-Only View Object to Allow Attribute Updates
5.2.5.4
Customizing View Object Attribute Display in the Overview Editor
5.2.5.5
Modifying the Order of Attributes in the View Object Source File
5.2.6
How to Show View Objects in a Business Components Diagram
5.3
Populating View Object Rows with Static Data
5.3.1
How to Create Static View Objects with Data You Enter
5.3.2
How to Create Static View Objects with Data You Import
5.3.3
What Happens When You Create a Static List View Object
5.3.4
Editing Static List View Objects
5.3.5
What You May Need to Know About Static List View Objects
5.4
Limiting View Object Rows Using Effective Date Ranges
5.4.1
How to Create a Date-Effective View Object
5.4.2
How to Create New View Rows Using Date-Effective View Objects
5.4.3
How to Update Date-Effective View Rows
5.4.4
How to Delete Date-Effective View Rows
5.4.5
What Happens When You Create a Date-Effective View Object
5.4.6
What You May Need to Know About Date-Effective View Objects and View LInks
5.5
Working with Multiple Tables in Join Query Results
5.5.1
How to Create Joins for Entity-Based View Objects
5.5.2
How to Select Additional Attributes from Reference Entity Usages
5.5.3
How to Remove Unnecessary Key Attributes from Reference Entity Usages
5.5.4
How to Hide the Primary Key Attributes from Reference Entity Usages
5.5.5
How to Modify a Default Join Clause to Be an Outer Join When Appropriate
5.5.6
What Happens When You Reference Entities in a View Object
5.5.7
How to Create Joins for Read-Only View Objects
5.5.8
How to Test the Join View
5.5.9
How to Use the SQL Statement Dialog with Read-Only View Objects
5.5.10
What You May Need to Know About Join View Objects
5.6
Working with Multiple Tables in a Master-Detail Hierarchy
5.6.1
How to Create a Master-Detail Hierarchy for Entity-Based View Objects
5.6.2
How to Create a Master-Detail Hierarchy Based on View Objects Alone
5.6.3
What Happens When You Create Master-Detail Hierarchies Using View Links
5.6.4
How to Enable Active Master-Detail Coordination in the Data Model
5.6.5
How to Test Master-Detail Coordination
5.6.6
How to Access the Detail Collection Using the View Link Accessor
5.6.6.1
Accessing Attributes of Row by Name
5.6.6.2
Programmatically Accessing a Detail Collection Using the View Link Accessor
5.7
Working with a Single Table in a Recursive Master-Detail Hierarchy
5.7.1
How to Create a Recursive Master-Detail Hierarchy for an Entity-Based View Object
5.7.2
What Happens When You Create a Recursive Master-Detail Hierarchy
5.8
Working with View Objects in Declarative SQL Mode
5.8.1
How to Create Declarative SQL View Objects
5.8.2
How to Filter Declarative SQL-Based View Objects When Table Joins Apply
5.8.3
How to Filter Master-Detail Related View Objects with Declarative SQL Mode
5.8.4
How to Force Attribute Queries for Declarative SQL Mode View Objects
5.8.5
What Happens When You Create a View Object in Declarative SQL Mode
5.8.6
What Happens at Runtime: When a Declarative SQL Mode Query is Generated
5.8.7
What You May Need to Know About Overriding Declarative SQL Mode Defaults
5.8.8
What You May Need to Know About Working Programmatically with Declarative SQL Mode View Objects
5.9
Working with View Objects in Expert Mode
5.9.1
How to Customize SQL Statements in Expert Mode
5.9.2
How to Name Attributes in Expert Mode
5.9.3
What Happens When You Enable Expert Mode
5.9.4
What You May Need to Know About Expert Mode
5.9.4.1
Expert Mode Provides Limited Attribute Mapping Assistance
5.9.4.2
Expert Mode Drops Custom Edits
5.9.4.3
Expert Mode Ignores Changes to SQL Expressions
5.9.4.4
Expert Mode Returns Error for SQL Calculations that Change Entity Attributes
5.9.4.5
Formatting of the SQL Statement in Expert Mode
5.9.4.6
Expert Mode Wraps Queries as Inline Views
5.9.4.7
Limitation of Inline View Wrapping at Runtime
5.9.4.8
Expert Mode Changes May Affect Dependent Objects
5.10
Working with Bind Variables
5.10.1
How to Add Bind Variables to a View Object Definition
5.10.2
How to Reference the Current User in a Named Bind Variable Using Groovy
5.10.3
What Happens When You Add Named Bind Variables
5.10.4
How to Test Named Bind Variables
5.10.5
How to Add a WHERE Clause with Named Bind Variables at Runtime
5.10.6
How to Set Existing Bind Variable Values at Runtime
5.10.7
What Happens at Runtime: When a Read-Only View Object WHERE Clause is Set
5.10.8
What You May Need to Know About Named Bind Variables
5.10.8.1
An Error Related to Clearing Bind Variables
5.10.8.2
Errors Related to the Names of Bind Variables
5.10.8.3
Default Value of NULL for Bind Variables
5.11
Working with Named View Criteria
5.11.1
How to Create Named View Criteria Declaratively
5.11.2
What Happens When You Create a Named View Criteria
5.11.3
What You May Need to Know About Bind Variable Options
5.11.4
What You May Need to Know About Nested Expressions
5.11.5
How to Set User Interface Hints on View Criteria
5.11.6
How to Use Master-Detail Related View Objects in View Criteria
5.11.7
How to Test View Criteria Using the Business Component Browser
5.11.8
How to Create View Criteria Programmatically
5.11.9
What Happens at Runtime: When the View Criteria Is Applied to a View Object
5.11.10
What You May Need to Know About the View Criteria API
5.11.10.1
Referencing Attribute Names in View Criteria
5.11.10.2
Referencing Bind Variables in View Criteria
5.11.10.3
Altering Compound Search Conditions Using Multiple View Criteria
5.11.10.4
Searching for a Row Whose Attribute Value Is NULL
5.11.10.5
Searching for Rows Using a Date Comparison
5.11.10.6
Searching for Rows Whose Attribute Value Matches a Value in a List
5.11.10.7
Searching Case-Insensitively
5.11.10.8
Clearing View Criteria in Effect
5.11.11
What You May Need to Know About Query-by-Example Criteria
5.12
Working with Row Finders
5.12.1
How to Add Row Finders to a View Object Definition
5.12.2
What Happens When You Define a Row Finder
5.12.3
What You May Need to Know About View Criteria and Row Finder Usage
5.12.4
How to Programmatically Invoke the Row Finder
5.12.5
How to Find Rows of a Master View Object
5.12.5.1
Defining a Row Finder on the Master View Object
5.12.5.2
What Happens When You Create a Row Finder for a Master View Object
5.13
Working with List of Values (LOV) in View Object Attributes
5.13.1
How to Define a Single LOV-Enabled View Object Attribute
5.13.2
How to Define Cascading Lists for LOV-Enabled View Object Attributes
5.13.2.1
Creating a Data Source View Object to Control the Cascading List
5.13.2.2
Creating a View Accessor to Filter the Cascading List
5.13.3
How to Specify Multiple LOVs for an LOV-Enabled View Object Attribute
5.13.4
How to Set User Interface Hints on a View Object LOV-Enabled Attribute
5.13.5
How to Handle Date Conversion for List Type UI Components
5.13.6
How to Automatically Refresh the View Object of the View Accessor
5.13.7
How to Test LOV-Enabled Attributes Using the Business Component Browser
5.13.8
What Happens When You Define an LOV for a View Object Attribute
5.13.9
What Happens at Runtime: When an LOV Queries the List Data Source
5.13.10
What You May Need to Know About Lists
5.13.10.1
Inheritance of AttributeDef Properties from Parent View Object Attributes
5.13.10.2
Using Validators to Validate Attribute Values
5.13.10.3
LOV Limitation When Exposing Application Module as EJB Session Bean
5.14
Defining Control Hints for View Objects
5.14.1
How to Add Attribute-Specific Control Hints
5.14.2
How to Add View Object Control Hints
5.14.3
How to Access Control Hints Using EL Expressions
5.14.4
What Happens When You Add Control Hints
5.14.5
How to Define UI Category Hints
5.14.6
What Happens When You Assign Attributes to UI Categories
5.14.7
What You May Need to Know About Resource Bundles
5.15
Adding Calculated and Transient Attributes to a View Object
5.15.1
How to Add a SQL-Calculated Attribute
5.15.2
What Happens When You Add a SQL-Calculated Attribute
5.15.3
How to Add a Transient Attribute
5.15.4
How to Add a Validation Rule to a Transient Attribute
5.15.5
What Happens When You Add a Transient Attribute
5.15.6
Adding Java Code in the View Row Class to Perform Calculation
5.15.7
What You May Need to Know About Transient Attributes
6
Working with View Object Query Results
6.1
Introduction to View Object Runtime Behavior
6.2
Creating an Application Module to Test View Instances
6.2.1
How to Create the Application Module with Individual View Object Instances
6.2.2
How to Create the Application Module with Master-Detail View Object Instances
6.3
Testing View Object Instances Using the Business Component Browser
6.3.1
How to Run the Business Component Browser
6.3.2
How to Test Entity-Based View Objects Interactively
6.3.3
How to Update the Business Component Browser to Display Project Changes
6.3.4
What Happens When You Use the Business Component Browser
6.3.5
How to Simulate End-User Interaction in the Business Component Browser
6.3.5.1
Testing Master-Detail Coordination
6.3.5.2
Testing UI Control Hints
6.3.5.3
Testing Business Domain Layer Validation
6.3.5.4
Testing Alternate Language Message Bundles and Control Hints
6.3.5.5
Testing View Objects That Reference Entity Usages
6.3.5.6
Testing Row Creation and Default Value Generation
6.3.5.7
Testing That New Detail Rows Have Correct Foreign Keys
6.3.6
How to Test Multiuser Scenarios in the Business Component Browser
6.3.7
How to Customize Configuration Options Before Running the Browser
6.3.8
How to Enable ADF Business Components Debug Diagnostics
6.3.9
What Happens at Runtime: When View Objects and Entity Objects Cooperate
6.3.9.1
What Happens When a View Object Executes Its Query
6.3.9.2
What Happens When a View Row Attribute Is Modified
6.3.9.3
What Happens When a Foreign Key Attribute is Changed
6.3.9.4
What Happens When a Transaction is Committed
6.3.9.5
What Happens When a View Object Requeries Data
6.3.10
What You May Need to Know About Optimizing View Object Runtime Performance
6.4
Testing View Object Instances Programmatically
6.4.1
ViewObject Interface Methods for Working with the View Object's Default RowSet
6.4.1.1
The Role of the Key Object in a View Row or Entity Row
6.4.1.2
The Role of the Entity Cache in the Transaction
6.4.2
How to Create a Command-Line Java Test Client
6.4.2.1
Generating a Test Client with Skeleton Code
6.4.2.2
Modifying the Skeleton Code to Create the Test Client
6.4.3
What Happens When You Run a Test Client Program
6.4.4
What You May Need to Know About Running a Test Client
6.4.5
How to Count the Number of Rows in a Row Set
6.4.6
How to Access a Detail Collection Using the View Link Accessor
6.4.7
How to Iterate Over a Master-Detail-Detail Hierarchy
6.4.8
How to Find a Row and Update a Foreign Key Value
6.4.9
How to Create a New Row for a View Object Instance
6.4.10
How to Retrieve the Row Key Identifying a Row
6.4.11
How to Authenticate Test Users in the Test Client
7
Defining Validation and Business Rules Declaratively
7.1
Introduction to Declarative Validation
7.1.1
When to Use Business-Layer Validation or Model-Layer Validation
7.2
Understanding the Validation Cycle
7.2.1
Types of Entity Object Validation Rules
7.2.1.1
Attribute-Level Validation Rules
7.2.1.2
Entity-Level Validation Rules
7.2.2
Understanding Commit Processing and Validation
7.2.3
Understanding the Impact of Composition on Validation Order
7.2.4
Avoiding Infinite Validation Cycles
7.2.5
What Happens When Validations Fail
7.2.6
Understanding Entity Objects Row States
7.2.7
Understanding Bundled Exception Mode
7.3
Adding Validation Rules to Entity Objects and Attributes
7.3.1
How to Add a Validation Rule to an Entity or Attribute
7.3.2
How to View and Edit a Validation Rule On an Entity or Attribute
7.3.3
What Happens When You Add a Validation Rule
7.3.4
What You May Need to Know About Entity and Attribute Validation Rules
7.3.5
What You May Need to Know About List of Values and Attribute Validation Rules
7.4
Using the Built-in Declarative Validation Rules
7.4.1
How to Ensure That Key Values Are Unique
7.4.2
What Happens When You Use a Unique Key Validator
7.4.3
How to Validate Based on a Comparison
7.4.4
What Happens When You Validate Based on a Comparison
7.4.5
How to Validate Using a List of Values
7.4.6
What Happens When You Validate Using a List of Values
7.4.7
What You May Need to Know About the List Validator
7.4.8
How to Make Sure a Value Falls Within a Certain Range
7.4.9
What Happens When You Use a Range Validator
7.4.10
How to Validate Against a Number of Bytes or Characters
7.4.11
What Happens When You Validate Against a Number of Bytes or Characters
7.4.12
How to Validate Using a Regular Expression
7.4.13
What Happens When You Validate Using a Regular Expression
7.4.14
How to Use the Average, Count, or Sum to Validate a Collection
7.4.15
What Happens When You Use Collection Validation
7.4.16
How to Determine Whether a Key Exists
7.4.17
What Happens When You Use a Key Exists Validator
7.4.18
What You May Need to Know About Declarative Validators and View Accessors
7.5
Using Groovy Expressions For Validation and Business Rules
7.5.1
How to Reference Entity Object Methods in Groovy Validation Expressions
7.5.2
How to Validate Using a True/False Expression
7.5.3
What Happens When You Add a Groovy Expression
7.6
Triggering Validation Execution
7.6.1
How to Specify Which Attributes Fire Validation
7.6.2
What Happens When You Constrain Validation Execution with Triggering Attributes
7.6.3
How to Set Preconditions for Validation
7.6.4
How to Set Transaction-Level Validation
7.6.5
What You May Need to Know About the Order of Validation Execution
7.7
Creating Validation Error Messages
7.7.1
How to Create Validation Error Messages
7.7.2
How to Localize Validation Messages
7.7.3
How to Conditionally Raise Error Messages Using Groovy
7.7.4
How to Embed a Groovy Expression in an Error Message
7.8
Setting the Severity Level for Validation Exceptions
7.9
Bulk Validation in SQL
8
Implementing Validation and Business Rules Programmatically
8.1
Introduction to Programmatic Business Rules
8.2
Using Method Validators
8.2.1
How to Create an Attribute-Level Method Validator
8.2.2
What Happens When You Create an Attribute-Level Method Validator
8.2.3
How to Create an Entity-Level Method Validator
8.2.4
What Happens When You Create an Entity-Level Method Validator
8.2.5
What You May Need to Know About Translating Validation Rule Error Messages
8.3
Assigning Programmatically Derived Attribute Values
8.3.1
How to Provide Default Values for New Rows at Create Time
8.3.1.1
Choosing Between create() and initDefaultExpressionAttributes() Methods
8.3.1.2
Eagerly Defaulting an Attribute Value from a Database Sequence
8.3.2
How to Assign Derived Values Before Saving
8.3.3
How to Assign Derived Values When an Attribute Value Is Set
8.4
Undoing Pending Changes to an Entity Using the Refresh Method
8.4.1
How to Control What Happens to New Rows During a Refresh
8.4.2
How to Cascade Refresh to Composed Children Entity Rows
8.5
Using View Objects for Validation
8.5.1
How to Use View Accessors for Validation Against View Objects
8.5.2
How to Validate Conditions Related to All Entities of a Given Type
8.5.3
What You May Need to Know About Row Set Access with View Accessors
8.6
Accessing Related Entity Rows Using Association Accessors
8.6.1
How to Access Related Entity Rows
8.6.2
How to Access Related Entity Row Sets
8.7
Referencing Information About the Authenticated User
8.8
Accessing Original Attribute Values
8.9
Storing Information About the Current User Session
8.9.1
How to Store Information About the Current User Session
8.9.2
How to Use Groovy to Access Information About the Current User Session
8.10
Accessing the Current Date and Time
8.11
Sending Notifications Upon a Successful Commit
8.12
Conditionally Preventing an Entity Row from Being Removed
8.13
Determining Conditional Updatability for Attributes
9
Implementing Business Services with Application Modules
9.1
Introduction to Application Modules
9.2
Creating and Modifying an Application Module
9.2.1
How to Create an Application Module
9.2.2
What Happens When You Create an Application Module
9.2.3
How to Add a View Object Instance to an Application Module
9.2.3.1
Adding a View Object Instance to an Existing Application Module
9.2.3.2
Adding Master-Detail View Object Instances to an Application Module
9.2.3.3
Customizing a View Object Instance that You Add to an Application Module
9.2.4
What Happens When You Add a View Object Instance to an Application Module
9.2.5
How to Edit an Existing Application Module
9.2.6
How to Change the Data Control Name Before You Begin Building Pages
9.2.7
What You May Need to Know About Application Module Granularity
9.2.8
What You May Need to Know About View Object Components and View Object Instances
9.3
Configuring Your Application Module Database Connection
9.3.1
How to Use a JDBC URL Connection Type
9.3.2
How to Use a JDBC Data Source Connection Type
9.3.3
What Happens When You Create an Application Module Database Connection
9.3.4
How to Change Your Application Module's Runtime Configuration
9.3.5
How to Change the Database Connection for Your Project
9.4
Defining Nested Application Modules
9.4.1
How to Define a Nested Application Module
9.4.2
What You May Need to Know About Root Application Modules Versus Nested Application Module Usages
9.5
Creating an Application Module Diagram for Your Business Service
9.5.1
How to Create an Application Module Diagram
9.5.2
What Happens When You Create an Application Module Diagram
9.5.3
How to Use the Diagram to Edit the Application Module
9.5.4
How to Control Diagram Display Options
9.5.5
How to Filter Method Names Displayed in the Diagram
9.5.6
How to Show Related Objects and Implementation Files in the Diagram
9.5.7
How to Publish the Application Module Diagram
9.5.8
How to Test the Application Module from the Diagram
9.6
Supporting Multipage Units of Work
9.6.1
How to Simulate State Management in the Business Component Browser
9.6.2
What Happens When the Application Uses Application Module Pooling and State Management
9.7
Customizing an Application Module with Service Methods
9.7.1
How to Generate a Custom Class for an Application Module
9.7.2
What Happens When You Generate a Custom Class for an Application Module
9.7.3
What You May Need to Know About Default Code Generation
9.7.4
How to Add a Custom Service Method to an Application Module
9.7.5
How to Test the Custom Application Module Using a Static Main Method
9.7.6
What You May Need to Know About Programmatic Row Set Iteration
9.8
Customizing Application Module Message Strings
9.8.1
How to Add a Resource Bundle to an Application Module
9.8.2
What Happens When You Add a Resource Bundle to an Application Module
9.9
Publishing Custom Service Methods to UI Clients
9.9.1
How to Publish a Custom Method on the Application Module's Client Interface
9.9.2
What Happens When You Publish Custom Service Methods
9.9.3
How to Generate Client Interfaces for View Objects and View Rows
9.9.4
How to Test Custom Service Methods Using the Business Component Browser
9.9.5
What You May Need to Know About Method Signatures on the Client Interface
9.9.6
What You May Need to Know About Passing Information from the Data Model
9.10
Working Programmatically with an Application Module's Client Interface
9.10.1
How to Work Programmatically with an Application Module's Client Interface
9.10.2
What Happens When You Work with an Application Module's Client Interface
9.10.3
How to Access an Application Module Client Interface in a Fusion Web Application
9.11
Overriding Built-in Framework Methods
9.11.1
How to Override a Built-in Framework Method
9.11.2
What Happens When You Override a Built-in Framework Method
9.11.3
How to Override prepareSession() to Set Up an Application Module for a New User Session
10
Sharing Application Module View Instances
10.1
Introduction to Shared Application Modules
10.2
Sharing an Application Module Instance
10.2.1
How to Create a Shared Application Module Instance
10.2.2
What Happens When You Define a Shared Application Module
10.2.3
What You May Need to Know About Design Time Scope of the Shared Application Module
10.2.4
What You May Need to Know About the Design Time Scope of View Instances of the Shared Application Module
10.2.5
What You May Need to Know About Managing the Number of Shared Query Collections
10.2.6
What You May Need to Know About Shared Application Modules and Connection Pooling
10.3
Defining a Base View Object for Use with Lookup Tables
10.3.1
How to Create a Base View Object Definition for a Lookup Table
10.3.2
What Happens When You Create a Base View Object
10.3.3
How to Define the WHERE Clause of the Lookup View Object Using View Criteria
10.3.4
What Happens When You Create a View Criteria with the Editor
10.3.5
What Happens at Runtime: When a View Instance Accesses Lookup Data
10.4
Accessing View Instances of the Shared Service
10.4.1
How to Create a View Accessor for an Entity Object or View Object
10.4.2
How to Validate Against a View Accessor
10.4.3
What Happens When You Validate Against a View Accessor
10.4.4
How to Create an LOV Based on a Lookup Table
10.4.5
What Happens When You Define an LOV for a View Object Attribute
10.4.6
What Happens at Runtime: When the Attribute Displays the List of Values
10.4.7
What You May Need to Know About Displaying List of Values From a Lookup Table
10.4.8
What You May Need to Know About Inheritance of AttributeDef Properties
10.4.9
What You May Need to Know About Using Validators
10.5
Testing View Object Instances in a Shared Application Module
10.5.1
How to Test the Base View Object Using the Business Component Browser
10.5.2
How to Test LOV-Enabled Attributes Using the Business Component Browser
10.5.3
What Happens When You Use the Business Component Browser
10.5.4
What Happens at Runtime: When Another Service Accesses the Shared Application Module Cache
11
Creating SOAP Web Services with Application Modules
11.1
Introduction to Service-Enabled Application Modules
11.2
Publishing Service-Enabled Application Modules
11.2.1
How to Enable the Application Module Service Interface
11.2.2
What Happens When You Create an Application Module Service Interface
11.2.2.1
Annotations Generated in the Web Service Interface
11.2.2.2
Web Service Schema Generated in the Web Service Schema File
11.2.2.3
WSDL Generated in the Web Service Definition File
11.2.2.4
Stateless Session Bean Specified by the Service Implementation Class
11.2.2.5
Lookup Defined in the connections.xml File
11.2.3
What You May Need to Know About Method Signatures on the ADF Web Service Interface
11.2.4
What You May Need to Know About Row Finders and the ADF Web Service Operations
11.2.5
How to Service-Enable Individual View Objects
11.2.6
How to Customize the SDO Properties of Service-Enabled View Objects
11.2.6.1
Excluding Individual SDO Properties in a Generated SDO Component
11.2.6.2
Associating Related SDO Properties Using Complex Data Types
11.2.7
How to Support Nested Processing in Service-Enabled Master-Detail View Objects
11.2.8
What Happens When You Create SDO Classes
11.2.8.1
Property Accessors Generated in the SDO Interface
11.2.8.2
View Object Interface Implemented by SDO Class
11.2.8.3
View Object Schema Generated in the SDO Schema File
11.2.8.4
Container Object Implemented by SDO Result Class and Interface
11.2.9
How to Expose a Declarative Find Operation Filtered By a Required Bind Variable
11.2.10
How to Expose a Custom Find Method Filtered By a Required Bind Variable
11.2.11
How to Generate Asynchronous ADF Web Service Methods
11.2.12
What Happens When You Generate Asynchronous ADF Web Service Methods
11.2.13
What Happens at Runtime: How the Asynchronous Call Is Made
11.2.14
How to Set Preferences for Generating the ADF Web Service Interface
11.2.15
How to Set Display Names for Service View Instances and Attributes
11.2.16
How to Secure the ADF Web Service for Access By SOAP Clients
11.2.17
How to Secure the ADF Web Service for Access By RMI Clients
11.2.17.1
Enabling Authentication for RMI Clients
11.2.17.2
Configuring Authorization for RMI Clients
11.2.18
How to Grant Test Users Access to the Service
11.2.19
How to Enable Support for Binary Attachments for SOAP Clients
11.2.20
How to Test the Web Service Using Integrated WebLogic Server
11.2.21
How to Prevent Custom Service Methods from Timing Out
11.2.22
How to Deploy Web Services to Oracle WebLogic Server
11.3
Accessing Remote Data Over the Service-Enabled Application Module
11.3.1
How to Use Service-Enabled Entity Objects and View Objects
11.3.1.1
Creating Entity Objects Backed by SDO Services
11.3.1.2
Using Complex Data Types with Service-Backed Entity Object Attributes
11.3.1.3
Creating View Objects Backed by SDO Services
11.3.2
What Happens When You Create Service-Backed Business Components
11.3.3
How to Update the Data Model for Service-Backed Business Components
11.3.4
How to Configure the Service-Backed Business Components Runtime
11.3.4.1
Adding the SDO Client Library to the Classpath
11.3.4.2
Registering the ADF Business Components Service in the Consuming Application's connections.xml for the EJB RMI Protocol
11.3.4.3
Registering the ADF Business Components Service in the Consuming Application's connections.xml for the SOAP Protocol
11.3.4.4
Registering the ADF Business Components Service in the Consuming Application's connections.xml for Fabric SDO Binding
11.3.5
How to Test the Service-Backed Components in the Business Component Browser
11.3.6
How to Invoke Operations of the Service-Backed Components in the Consuming Application
11.3.7
What You May Need to Know About Creating Service Data Objects in the Consuming Application
11.3.8
What You May Need to Know About Invoking Built-In Service Methods in the Consuming Application
11.3.9
What Happens at Runtime: How the Application Accesses the Published Application Module
11.3.10
What You May Need to Know About Service-Backed Entity Objects and View Objects
12
Creating RESTful Web Services with Application Modules
12.1
About RESTful Web Services and ADF Business Components
12.1.1
RESTful Web Services Use Cases and Examples
12.1.2
Additional Functionality for RESTful Web Services
12.2
Creating ADF REST Resources Using the Application Module
12.2.1
How to Create ADF REST Resources from View Object Instances
12.2.2
How to Edit the Default ADF REST Resource Structure
12.2.3
What You May Need to Know About the ADF REST Resource Structure
12.2.4
What You May Need to Know About ADF REST Resources and LOB Attributes
12.3
Customizing the ADF REST Resource Representation and Methods
12.3.1
How to Expose Child Resources in the ADF REST Resource
12.3.2
How to Expose Canonical Resources in the ADF REST Resource
12.3.3
How to Expose Standard HTTP Actions in the ADF REST Resource
12.3.4
How to Expose Custom Methods in the ADF REST Resource
12.3.5
How to Expose Row Finder Keys in the ADF REST Resource
12.3.6
What You May Need to Know About Row Finders in ADF REST Resource Requests
12.4
Versioning the ADF REST Resource
12.5
Granting Client Access to the ADF REST Resource
12.5.1
How to Create a Resource Grant for ADF REST Resources
12.5.2
How to Create a Resource Grant for ADF REST Resource Custom Methods
12.6
Deploying the ADF REST Resource
12.7
Testing the ADF REST Resource
13
Using ADF Model in a Fusion Web Application
13.1
Introduction to ADF Data Binding
13.2
Exposing Application Modules with ADF Data Controls
13.2.1
How an Application Module Data Control Appears in the Data Controls Panel
13.2.1.1
How the Data Model and Service Methods Appear in the Data Controls Panel
13.2.1.2
How Transaction Control Operations Appear in the Data Controls Panel
13.2.1.3
How View Objects Appear in the Data Controls Panel
13.2.1.4
How Nested Application Modules Appear in the Data Controls Panel
13.2.2
How to Open the Data Controls Panel
13.2.3
How to Refresh the Data Controls Panel
13.2.4
Packaging a Data Control for Use in Another Project
13.3
Using the Data Controls Panel
13.3.1
How to Use the Data Controls Panel
13.3.2
What Happens When You Use the Data Controls Panel
13.3.3
What Happens at Runtime: How the Binding Context Works
13.4
Working with the DataBindings.cpx File
13.4.1
How JDeveloper Creates a DataBindings.cpx File
13.4.2
What Happens When JDeveloper Creates a DataBindings.cpx File
13.5
Configuring the ADF Binding Filter
13.5.1
How JDeveloper Configures the ADF Binding Filter
13.5.2
What Happens When JDeveloper Configures an ADF Binding Filter
13.5.3
What Happens at Runtime: How the ADF Binding Filter Works
13.6
Working with Page Definition Files
13.6.1
How JDeveloper Creates a Page Definition File
13.6.2
What Happens When JDeveloper Creates a Page Definition File
13.6.2.1
Bindings Binding Objects
13.6.2.2
Executable Binding Objects
13.7
Creating ADF Data Binding EL Expressions
13.7.1
How to Create an ADF Data Binding EL Expression
13.7.1.1
Opening the Expression Builder from the Property Inspector
13.7.1.2
Using the Expression Builder
13.7.2
What You May Need to Know About ADF Binding Properties
13.8
Using Simple UI First Development
13.8.1
How to Apply ADF Model Data Binding to Existing UI Components
13.8.2
What Happens When You Apply ADF Model Data Binding to UI Components
14
Integrating SOAP Web Services Into a Fusion Web Application
14.1
Introduction to Web Services in Fusion Web Applications
14.2
Calling a Web Service from an Application Module
14.2.1
How to Call an External Service Programmatically
14.2.1.1
Creating a Web Service Proxy Class to Programmatically Access the Service
14.2.1.2
Calling the Web Service Proxy Template to Invoke the Service
14.2.1.3
Calling a Web Service Method Using the Proxy Class in an Application Module
14.2.2
How to Create a New Web Service Connection
14.2.3
What Happens When You Create the Web Service Proxy
14.2.4
What Happens at Runtime: When You Call a Web Service Using a Web Service Proxy Class
14.2.5
What You May Need to Know About Web Service Proxies
14.2.5.1
Using a Try-Catch Block to Handle Web Service Exceptions
14.2.5.2
Separating Application Module and Web Services Transactions
14.2.5.3
Setting Browser Proxy Information
14.2.5.4
Invoking Application Modules with a Web Service Proxy Class
14.3
Creating Web Service Data Controls
14.3.1
How to Create a Web Service Data Control
14.3.2
How to Include a Header Parameter for a Web Service Data Control
14.3.3
How to Adjust the Endpoint for a Web Service Data Control
14.3.4
How to Refresh a Web Service Data Control
14.3.5
What You May Need to Know About Web Service Data Controls
14.4
Securing Web Service Data Controls
14.4.1
WS-Security Specification
14.4.2
Using Key Stores
14.4.3
How to Define Web Service Data Control Security
15
Consuming RESTful Web Services Using the ADF REST Framework
15.1
About the ADF REST Framework
15.1.1
ADF REST Resource Use Cases and Examples
15.1.2
Additional Functionality for RESTful Web Services
15.1.3
About the Resource Samples in This Chapter
15.1.3.1
Sample Project Files and Data Model
15.1.3.2
Sample Project Resources and Resource Version Identifiers
15.1.3.3
Entity Object and View Object Customization
15.2
Understanding ADF Business Components Resources
15.3
Retrieving the ADF REST Resource Describe
15.3.1
Describing All Available Resources
15.3.2
Describing a Resource Collection
15.3.3
Describing a Resource Item
15.3.4
Describing a Nested Resource
15.3.5
Understanding the links Object Structure in the ADF REST describe
15.3.5.1
rel Attribute Values
15.3.5.2
href Attribute Value
15.3.5.3
cardinality Attribute Values
15.4
Retrieving the ADF REST Resource
15.4.1
Fetching a Resource Collection
15.4.2
Paging a Resource Collection
15.4.3
Filtering a Resource Collection with a Query Parameter
15.4.4
Fetching a Resource Item
15.4.5
Fetching Nested Child Resources
15.4.6
Sorting a Resource Collection
15.5
Creating a Resource Item
15.5.1
Creating a Resource Item in Collection
15.5.2
Creating Child Resource Item
15.6
Updating a Resource Item
15.6.1
Updating a Resource Item
15.6.2
Replacing a Resource Item
15.7
Deleting a Resource Item
15.8
Checking for Data Consistency
15.8.1
Checking for Data Consistency When Updating ADF REST Resource Items
15.8.2
Checking for Data Consistency When Retrieving ADF REST Resource Items
15.9
Versioning the Resource
15.9.1
Retrieving All Available Versions
15.9.2
Retrieving a Specific Version
15.10
Working with Attachments
15.10.1
Streaming Attachments Using a Resource Item Enclosure Link
15.10.2
Replacing LOB Content Using Base64
15.11
Working with LOV
15.12
Advanced Operations
15.12.1
Querying with a Partial Get to Restrict Attributes
15.12.2
Filtering a Resource Collection with a Row Finder
15.12.3
Returning Only Resource Data in a Payload
15.12.4
Returning the Estimated Count of Resource Items
15.12.5
Executing a Custom Action
15.12.6
Overriding the HTTP Method and Performing an Update
15.12.7
Making Batch Requests
15.13
ADF REST Framework Reference
15.13.1
ADF REST Payload Compression Support
15.13.2
ADF REST Media Types
15.13.3
ADF REST HTTP Codes
15.13.4
ADF REST HTTP Headers Support
15.13.5
ADF REST HTTP Method and Payload Support
15.13.5.1
GET Method Operations
15.13.5.2
POST Method Operations
15.13.5.3
PUT Method Operations
15.13.5.4
PATCH Method Operations
15.13.5.5
DELETE Method
Part III Creating ADF Task Flows
16
Getting Started with ADF Task Flows
16.1
Introduction to ADF Task Flows
16.1.1
Task Flow Advantages
16.1.2
Task Flow Types
16.1.2.1
Unbounded Task Flows
16.1.2.2
Bounded Task Flows
16.1.3
Control Flows
16.2
Creating a Task Flow
16.2.1
How to Create a Task Flow
16.2.2
What Happens When You Create a Task Flow
16.2.3
What You May Need to Know About the Default Activity in an ADF Bounded Task Flow
16.2.4
What You May Need to Know About Memory Scope for Task Flows
16.2.5
What Happens at Runtime: Using ADF Task Flows
16.3
Adding Activities to a Task Flow
16.3.1
How to Add Additional Activities to an ADF Task Flow
16.3.2
What Happens When You Add an Activity to an ADF Task Flow
16.3.3
How to Add Control Flows
16.3.4
How to Add a Wildcard Control Flow Rule
16.3.5
What Happens When You Create a Control Flow Rule
16.3.6
What Happens at Runtime: Evaluating Control Flow Rules
16.4
Testing ADF Task Flows
16.4.1
How to Run a Bounded Task Flow That Contains Pages
16.4.2
How to Run a Bounded Task Flow That Uses Page Fragments
16.4.3
How to Run a Bounded Task Flow That Has Parameters
16.4.4
How to Run a JSF Page
16.4.5
How to Run an ADF Unbounded Task Flow
16.4.6
How to Set a Run Configuration for a Project
16.5
Refactoring to Create New ADF Task Flows and Templates
16.5.1
How to Create an ADF Bounded Task Flow from Selected Activities
16.5.2
How to Create a Task Flow from JSF Pages
16.5.3
How to Convert ADF Bounded Task Flows
16.6
What You Should Know About Task Flow Constraints
17
Working with Task Flow Activities
17.1
Introduction to Activity Types
17.2
Using View Activities
17.2.1
Adding a View Activity
17.2.2
Transitioning Between View Activities
17.2.2.1
How to Transition to a View Activity
17.2.2.2
What Happens When You Transition Between Activities
17.2.3
Bookmarking View Activities
17.2.3.1
How to Create a Bookmarkable View Activity
17.2.3.2
How to Specify HTTP Redirect
17.2.3.3
What Happens When You Designate a View as Bookmarkable
17.3
Using URL View Activities
17.3.1
How to Add a URL View Activity to a Task Flow
17.3.2
Constructing a URL for Use Within a Portlet
17.4
Using Router Activities
17.5
Using Method Call Activities
17.5.1
How to Add a Method Call Activity
17.5.2
How to Specify Method Parameters and Return Values
17.5.3
What Happens When You Add a Method Call Activity
17.6
Using Task Flow Call Activities
17.6.1
How to Call a Bounded Task Flow Using a Task Flow Call Activity
17.6.2
What Happens When You Call a Bounded Task Flow Using a Task Flow Call Activity
17.6.3
How to Specify Input Parameters on a Task Flow Call Activity
17.6.4
How to Call a Bounded Task Flow Using a URL
17.6.5
What Happens When You Configure a Bounded Task Flow to be Invoked by a URL
17.6.6
What You May Need to Know About Calling a Bounded Task Flow Using a URL
17.6.7
How to Specify Before and After Listeners
17.6.8
What Happens When You Add a Task Flow Call Activity
17.6.9
What Happens at Runtime When a Task Flow Call Activity Invokes a Task Flow
17.7
Using Task Flow Return Activities
17.8
Using Save Point Restore Activities
17.9
Using Parent Action Activities
17.10
Using Task Flow Activities with Page Definition Files
17.10.1
How to Associate a Page Definition File with a Task Flow Activity
17.10.2
What Happens When You Associate a Page Definition File with a Task Flow Activity
18
Using Parameters in Task Flows
18.1
Introduction to Parameters in Task Flows
18.2
Passing Parameters to a View Activity
18.3
How to Pass Parameters to an ADF Bounded Task Flow
18.4
Specifying Return Values
18.5
Specifying EL Binding Expressions
19
Using Task Flows as Regions
19.1
Introduction to Using Task Flows in ADF Regions
19.1.1
Benefits of Executing a Task Flow in an ADF Region
19.1.2
Task Flows and ADF Region Use Cases and Examples
19.1.3
Additional Functionality for Task Flows that Render in ADF Regions
19.1.3.1
Page Fragments and ADF Regions
19.1.3.2
View Ports and ADF Regions
19.1.3.3
Security and ADF Regions
19.1.3.4
Parent Page Determines the Capabilities of an ADF Region
19.2
Creating an ADF Region
19.2.1
How to Create an ADF Region
19.2.2
What Happens When You Create an ADF Region
19.3
Specifying Parameters for an ADF Region
19.3.1
How to Specify Parameters for an ADF Region
19.3.2
What Happens When You Specify Parameters for an ADF Region
19.4
Specifying Parameters for ADF Regions Using Parameter Maps
19.4.1
How to Create a Parameter Map to Specify Input Parameters for an ADF Region
19.4.2
What Happens When You Create a Parameter Map to Specify Input Parameters
19.5
Refreshing an ADF Region
19.5.1
How to Configure the Refresh of an ADF Region
19.5.2
What You May Need to Know About Refreshing an ADF Region
19.6
Configuring Activation of an ADF Region
19.6.1
How to Configure Activation of an ADF Region
19.6.2
What Happens When You Configure Activation of an ADF Region
19.7
Navigating Outside an ADF Region's Task Flow
19.7.1
How to Trigger Navigation Outside of an ADF Region's Task Flow
19.7.2
What Happens When You Configure Navigation Outside a Task Flow
19.8
Configuring Transaction Management in an ADF Region
19.9
Creating ADF Dynamic Regions
19.9.1
How to Create an ADF Dynamic Region
19.9.2
What Happens When You Create an ADF Dynamic Region
19.10
Adding Additional Task Flows to an ADF Dynamic Region
19.10.1
How to Create an ADF Dynamic Region Link
19.10.2
What Happens When You Create an ADF Dynamic Region
19.11
Configuring a Page To Render an Unknown Number of Regions
19.11.1
How to Configure a Page to Render an Unknown Number of Regions
19.11.2
What Happens When You Configure a Page to Render an Unknown Number of Regions
19.11.3
What You May Need to Know About Configuring a Page to Render an Unknown Number of Regions
19.12
Creating Remote Regions in a Fusion Web Application
19.12.1
How to Configure an Application to Produce Task Flows for Use in Remote Regions
19.12.2
What Happens When You Produce Task Flows for Use in Remote Regions
19.12.3
What You May Need to Know About Securing Remote Regions
19.12.4
What You May Need to Know About Managed Bean Scopes and Remote Regions
19.12.5
How to Configure an Application to Render Remote Regions
19.12.6
What Happens When You Configure an Application to Render Remote Regions
19.12.7
What Happens at Runtime: How an Application Renders Remote Regions
19.12.8
How to Add Custom Error Messages for Remote Regions
19.12.9
What You May Need to Know About ADF Skins and Remote Regions
20
Creating Complex Task Flows
20.1
Introduction to Complex Task Flows
20.2
Using Initializers and Finalizers
20.3
Sharing Data Controls Between Task Flows
20.3.1
How to Share a Data Control Between Task Flows
20.3.2
What Happens When You Share a Data Control Between Task Flows
20.3.3
What Happens at Runtime: How Task Flows Share Data Controls
20.4
Managing Transactions
20.4.1
How to Enable Transactions in a Bounded Task Flow
20.4.2
What Happens When You Specify Transaction Options
20.4.3
What You May Need to Know About Sharing Data Controls and Managing Transactions
20.4.3.1
Creating Completely Separate Transactions
20.4.3.2
Guaranteeing a Called Bounded Task Joins an Existing Transaction
20.4.3.3
Using an Existing Transaction if Possible
20.4.4
What You May Need to Know About ADF Business Component Database Connections and Task Flow Transaction Options
20.5
Reentering a Bounded Task Flow
20.5.1
How to Set Reentry Behavior
20.5.2
How to Set Outcome-Dependent Options
20.5.3
What You Should Know About Managed Bean Values Upon Task Flow Reentry
20.6
Executing a Bounded Task Flow Directly From a JSF Page
20.7
Handling Exceptions in Task Flows
20.7.1
How to Designate an Activity as an Exception Handler
20.7.2
What Happens When You Designate an Activity as an Exception Handler
20.7.3
How to Designate Custom Code as an Exception Handler
20.7.4
What Happens When You Designate Custom Code as an Exception Handler
20.7.5
What You May Need to Know About Handling Exceptions During Transactions
20.7.6
What You May Need to Know About Handling Validation Errors
20.8
Configuring Your Application to Use Save Points
20.8.1
How to Configure Your Fusion Web Application to Use Save Points
20.8.2
What Happens When You Configure a Fusion Web Application to Use Save Points
20.8.3
What You May Need to Know About the Database Table for Save Points
20.9
Using Save Points in Task Flows
20.9.1
How to Add a Save Point to a Task Flow
20.9.2
What Happens When You Add Save Points to a Task Flow
20.9.3
How to Restore a Save Point
20.9.4
What Happens When You Restore a Save Point
20.9.5
How to Use the Save Point Restore Finalizer
20.9.6
What Happens When a Task Flow Invokes a Save Point Restore Finalizer
20.9.7
How to Enable Implicit Save Points
20.9.8
What You May Need to Know About Enabling Implicit Save Points
20.9.9
What You May Need to Know About the Time-to-Live Period for a Save Point
20.10
Minimizing the Number of Active Root View Ports in an Application
20.10.1
How to Minimize the Number of Active Root View Ports
20.10.2
What Happens When You Minimize the Number of Active Root View Ports
20.11
Creating a Train
20.11.1
Bounded Task Flows as Trains
20.11.2
Train Sequences
20.11.3
How to Create a Train
20.11.4
What You May Need to Know About Grouping Activities
20.11.5
What You May Need to Know About Grouping Activities in Child Task Flows
20.11.6
What You May Need To Know About Using Child Trains
20.11.7
What You May Need to Know About Branching
20.12
Running Multiple Task Flows
20.12.1
Understanding How the ViewPortInstance Works in ADF Regions
20.13
Creating a Task Flow Template
20.13.1
How to Copy and Reference a Task Flow Template
20.13.2
How to Create a Task Flow Template from Another Task Flow
20.13.3
How to Use a Task Flow Template
20.13.4
How to Create a Task Flow Template
20.13.5
What Happens When You Create a Task Flow Template
20.13.6
What You May Need to Know About Task Flow Templates That Use Bindings
20.14
Creating a Page Hierarchy
20.14.1
How to Create a Page Hierarchy
20.14.1.1
How to Create an XMLMenuModel Metadata File
20.14.1.2
How to Create a Submenu with a Hierarchy of Group and Child Nodes
20.14.1.3
How to Attach a Menu Hierarchy to Another Menu Hierarchy
20.14.2
What Happens When You Create a Page Hierarchy
20.15
Using BPEL with Task Flows
20.15.1
How to Invoke a BPEL Process from a Task Flow
20.15.2
How to Call a Bounded Task Flow from BPEL
20.16
Reporting Incidents to the Oracle Fusion Middleware Diagnostic Framework
20.16.1
How to Configure the Number of Events to Report to the Diagnostic Framework
20.16.2
What Happens When You Configure the Number of Events to Report to the Diagnostic Framework
21
Using Dialogs in Your Application
21.1
Introduction to Using Dialogs in Your Application
21.2
Running a Bounded Task Flow in a Modal Dialog
21.2.1
How to Run a Bounded Task Flow in a Modal Dialog
21.2.2
How to Return a Value From a Modal Dialog
21.2.3
What You May Need to Know About Running a Bounded Task Flow in a Modal Dialog
21.3
Using the ADF Faces Dialog Framework
21.3.1
How to Define a JSF Navigation Rule for Opening a Dialog
21.3.2
How to Create the JSF Page That Opens a Dialog
21.3.3
How to Create the Dialog Page and Return a Dialog Value
21.3.4
What Happens at Runtime: Raising the Return Event from the Dialog
21.3.5
How to Pass a Value into a Dialog
21.3.6
What Happens at Runtime: Handling the LaunchEvent
21.3.7
How to Handle the Return Value
21.3.8
What Happens at Runtime: Handling the ReturnEvent on the Launching Component
Part IV Creating a Databound Web User Interface
22
Getting Started with Your Web Interface
22.1
Introduction to Developing a Web Application with ADF Faces
22.2
Using Page Templates
22.2.1
How to Use ADF Data Binding in ADF Page Templates
22.2.2
What Happens When You Use ADF Model Layer Bindings on a Page Template
22.2.3
How to Add a Databound Page Template to a Page Dynamically
22.2.4
What Happens at Runtime: How Pages Use Templates
22.3
Creating a Web Page
22.4
Using a Managed Bean in a Fusion Web Application
22.4.1
How to Use a Managed Bean to Store Information
22.4.2
What Happens When You Create a Managed Bean
22.4.3
How to Set Managed Bean Memory Scopes in a Server-Cluster Environment
23
Understanding the Fusion Page Lifecycle
23.1
Introduction to the Fusion Page Lifecycle
23.2
The JSF and ADF Page Lifecycles
23.2.1
What You May Need to Know About Using the Refresh Property Correctly
23.2.2
What You May Need to Know About Task Flows and the Lifecycle
23.3
Object Scope Lifecycles
23.3.1
What You May Need to Know About Object Scopes and Task Flows
23.4
Customizing the ADF Page Lifecycle
23.4.1
How to Create a Custom Phase Listener
23.4.2
How to Register a Listener Globally
23.4.3
What You May Need to Know About Listener Order
23.4.4
How to Register a Lifecycle Listener for a Single Page
24
Creating a Basic Databound Page
24.1
Introduction to Creating a Basic Databound Page
24.2
Using Attributes to Create Text Fields
24.2.1
How to Create a Text Field
24.2.2
What Happens When You Create a Text Field
24.2.2.1
Creating and Using Iterator Bindings
24.2.2.2
Creating and Using Value Bindings
24.2.2.3
Using EL Expressions to Bind UI Components
24.3
Creating a Basic Form
24.3.1
How to Create a Form
24.3.2
What Happens When You Create a Form
24.4
Incorporating Range Navigation into Forms
24.4.1
How to Insert Navigation Controls into a Form
24.4.2
What Happens When You Create Command Buttons
24.4.2.1
Action Bindings for Built-in Navigation Operations
24.4.2.2
Iterator RangeSize Attribute
24.4.2.3
EL Expressions Used to Bind to Navigation Operations
24.4.3
What You May Need to Know About Automatic Partial Page Rendering
24.4.4
What Happens at Runtime: How Action Events and Action Listeners Work
24.4.5
What You May Need to Know About the Browser Back Button and Navigating Through Records
24.5
Creating a Form to Edit an Existing Record
24.5.1
How to Create Edit Forms
24.5.2
What Happens When You Use Built-in Operations to Change Data
24.6
Creating an Input Form
24.6.1
How to Create an Input Form Using a Task Flow
24.6.2
What Happens When You Create an Input Form Using a Task Flow
24.6.3
What Happens at Runtime: CreateInsert Action from the Method Activity
24.6.4
What You May Need to Know About Displaying Sequence Numbers
24.7
Using a Dynamic Form to Determine Data to Display at Runtime
24.7.1
How to Use Dynamic Forms
24.7.2
What Happens When You Use Dynamic Components
24.7.3
What Happens at Runtime: How Attribute Values Are Dynamically Determined
24.7.4
What You May Need to Know About Converters for Dynamic Forms
24.8
Modifying the UI Components and Bindings on a Form
24.8.1
How to Modify the UI Components and Bindings
24.8.2
What Happens When You Modify Attributes and Bindings
25
Creating ADF Databound Tables
25.1
Introduction to Adding Tables
25.2
Creating a Basic Table
25.2.1
How to Create a Basic Table
25.2.2
What Happens When You Create a Table
25.2.2.1
Iterator and Value Bindings for Tables
25.2.2.2
Code on the JSF Page for an ADF Faces Table
25.2.3
What You May Need to Know About Setting the Current Row in a Table
25.3
Creating an Editable Table
25.3.1
How to Create an Editable Table
25.3.2
What Happens When You Create an Editable Table
25.4
Creating an Input Table
25.4.1
How to Create an Input Table
25.4.2
What Happens When You Create an Input Table
25.4.3
What Happens at Runtime: How CreateInsert and Partial Page Refresh Work
25.4.4
What You May Need to Know About Creating a Row and Sorting Columns
25.4.5
What You May Need to Know About Create and CreateInsert
25.5
Creating a List View of a Collection
25.5.1
How to Create a Databound List View
25.5.2
What Happens When You Create a Databound List View
25.6
Providing Multiselect Capabilities
25.6.1
How to Add Multiselect Capabilities
25.6.2
What Happens at Runtime: How an Operation Executes Against Multiple Rows
25.7
Modifying the Attributes Displayed in the Table
25.7.1
How to Modify the Displayed Attributes
25.7.2
How to Change the Binding for a Table
25.7.3
What Happens When You Modify Bindings or Displayed Attributes
26
Displaying Master-Detail Data
26.1
Introduction to Displaying Master-Detail Data
26.2
Identifying Master-Detail Objects on the Data Controls Panel
26.3
Using Tables and Forms to Display Master-Detail Objects
26.3.1
How to Display Master-Detail Objects in Tables and Forms
26.3.2
What Happens When You Create Master-Detail Tables and Forms
26.3.2.1
Code Generated in the JSF Page
26.3.2.2
Binding Objects Defined in the Page Definition File
26.3.3
What Happens at Runtime: ADF Iterator for Master-Detail Tables and Forms
26.3.4
What You May Need to Know About Displaying Master-Detail Widgets on Separate Pages
26.4
Using Trees to Display Master-Detail Objects
26.4.1
How to Display Master-Detail Objects in Trees
26.4.2
What Happens When You Create an ADF Databound Tree
26.4.2.1
Code Generated in the JSF Page
26.4.2.2
Binding Objects Defined in the Page Definition File
26.4.3
What Happens at Runtime: Displaying an ADF Databound Tree
26.5
Using Tree Tables to Display Master-Detail Objects
26.5.1
How to Display Master-Detail Objects in Tree Tables
26.5.2
What Happens When You Create a Databound Tree Table
26.5.2.1
Code Generated in the JSF Page
26.5.2.2
Binding Objects Defined in the Page Definition File
26.5.3
What Happens at Runtime: Events
26.5.4
Using the TargetIterator Property
26.6
Using List Views to Display Master-Detail Objects
26.6.1
How to Display Master-Detail Objects in List Views
26.6.2
What Happens When You Create a Master-Detail List View
26.7
Using Selection Events with Trees and Tables
26.7.1
How to Use Selection Events with Trees and Tables
26.7.2
What Happens at Runtime: RowKeySet Objects and SelectionEvent Events
27
Creating Databound Selection Lists and Shuttles
27.1
Introduction to Selection Lists and Shuttles
27.2
Creating List of Values (LOV)
27.2.1
How to Create an LOV
27.2.2
What Happens When You Create an LOV
27.3
Creating a Selection List
27.3.1
How to Create a Single Selection List
27.3.2
How to Create a Model-Driven List
27.3.3
How to Create a Selection List Containing Fixed Values
27.3.4
How to Create a Selection List Containing Dynamically Generated Values
27.3.5
What Happens When You Create a Model-Driven Selection List
27.3.6
What Happens When You Create a Fixed Selection List
27.3.7
What You May Need to Know About Values in a Selection List
27.3.8
What Happens When You Create a Dynamic Selection List
27.4
Creating a List with Navigation List Binding
27.5
Creating a Databound Shuttle
28
Creating Databound ADF Data Visualization Components
28.1
Introduction to Creating ADF Data Visualization Components
28.2
Creating Databound Charts
28.2.1
How to Create an Area, Bar, Combination, Horizontal Bar, or Line Chart Using Data Controls
28.2.2
What Happens When You Use the Data Controls Panel to Create a Chart
28.2.3
How to Create Databound Pie Charts
28.2.4
Creating a Databound Spark Chart Using Data Controls
28.2.5
How to Create Databound Bubble and Scatter Charts
28.2.6
What You May Need to Know About Using Attribute Labels
28.3
Creating Databound Graphs
28.3.1
How to Create a Stock Graph Using Name-Value Pairs
28.3.2
What You May Need to Know About Using a Graph's Row Selection Listener for Master-Detail Processing
28.3.3
What You May Need to Know About Using Name-Value Pairs
28.4
Creating Databound Gauges
28.4.1
How to Create a Databound Dial Gauge
28.4.2
What Happens When You Create a Dial Gauge from a Data Control
28.4.3
How to Create a Databound Rating Gauge
28.4.4
Including Gauges in Databound ADF Tables
28.4.4.1
How to Include a Gauge in a Databound ADF Table
28.4.4.2
What Happens When You Include a Gauge in an ADF Table
28.5
Creating Databound Pivot Tables
28.5.1
How to Create a Pivot Table
28.5.2
What Happens When You Use the Data Controls Panel to Create a Pivot Table
28.5.2.1
Bindings for Pivot Tables
28.5.2.2
Code on the JSF Page for a Pivot Table and Pivot Filter Bar
28.5.3
What You May Need to Know About Aggregating Attributes in the Pivot Table
28.5.3.1
Default Aggregation of Duplicate Data Rows
28.5.3.2
Custom Aggregation of Duplicate Rows
28.5.4
What You May Need to Know About Specifying an Initial Sort for a Pivot Table
28.6
Creating Databound Geographic Maps
28.6.1
How to Create a Geographic Map with a Point Theme
28.6.2
How to Create Point Style Items for a Point Theme
28.6.3
What Happens When You Create a Geographic Map with a Point Theme
28.6.3.1
Binding XML for a Point Theme
28.6.3.2
XML Code on the JSF Page for a Geographic Map and Point Theme
28.6.4
What You May Need to Know About Adding Custom Point Style Items to a Map Point Theme
28.6.5
How to Add a Databound Color Theme to a Geographic Map
28.6.6
What Happens When You Add a Color Theme to a Geographic Map
28.6.6.1
Binding XML for a Color Theme
28.6.6.2
XML Code on the JSF Page for a Color Theme
28.6.7
What You May Need to Know About Customizing Colors in a Map Color Theme
28.6.8
How to Add a Databound Pie Graph Theme to a Geographic Map
28.6.9
What Happens When You Add a Pie Graph Theme to a Geographic Map
28.6.9.1
Binding XML for a Pie Graph Theme
28.6.9.2
Code on the JSF Page for a Pie Graph Theme
28.7
Creating Databound Thematic Maps
28.7.1
How to Create a Thematic Map Using ADF Data Controls
28.7.2
What Happens When You Use Data Controls to Create a Thematic Map
28.7.3
How to Add Data Layers to Thematic Maps
28.7.4
Styling Areas, Markers, and Images to Display Data
28.7.4.1
How to Style Areas to Display Data
28.7.4.2
How to Style Markers to Display Data
28.7.4.3
What You May Need to Know About Styling Markers
28.7.4.4
What You May Need to Know About Default Style Values for Attribute Groups
28.7.4.5
How to Use Images to Display Data
28.7.4.6
What You May Need to Know About SVG Files
28.7.5
What You May Need to Know About Base Map Location Ids
28.7.6
What You May Need to Know About Configuring Master-Detail Relationships
28.7.7
How to Define a Custom Map Layer
28.7.8
How to Configure Drilling in Thematic Maps
28.7.9
Creating Databound Legends
28.8
Creating Databound Gantt Charts
28.8.1
How to Create a Databound Project Gantt Chart
28.8.2
What Happens When You Create a Project Gantt Chart from a Data Control
28.8.3
What You May Need to Know About Summary Tasks in a Project Gantt Chart
28.8.4
What You May Need to Know About Percent Complete in a Project Gantt Chart
28.8.5
What You May Need to Know About Variance in a Project Gantt Chart
28.8.6
How to Create a Databound Resource Utilization Gantt Chart
28.8.7
What Happens When You Create a Resource Utilization Gantt Chart
28.8.8
How to Create a Databound Scheduling Gantt Chart
28.8.9
What Happens When You Create a Scheduling Gantt Chart
28.9
Creating Databound Timelines
28.9.1
How to Create a Timeline Using ADF Data Controls
28.9.2
What Happens When You Use Data Controls to Create a Timeline
28.9.3
What You May Need to Know About Using Data Controls to Create a Dual Timeline
28.10
Creating Databound Hierarchy Viewers
28.10.1
How to Create a Databound Hierarchy Viewer
28.10.2
What Happens When You Create a Databound Hierarchy Viewer
28.10.3
How to Configure an Alternate View Object for a Databound Panel Card
28.10.3.1
What Happens When You Use an Alternate View Object for a Hierarchy Viewer Panel Card
28.10.4
How to Create a Databound Search in a Hierarchy Viewer
28.11
Creating Databound Treemaps and Sunbursts
28.11.1
How to Create Treemaps and Sunbursts Using ADF Data Controls
28.11.2
What Happens When You Create a Databound Treemap or Sunburst
28.11.3
What Happens at Runtime: How Databound Sunbursts or Treemaps Are Initially Displayed
29
Creating ADF Databound Search Forms
29.1
Introduction to Creating Search Forms
29.1.1
Query Search Forms
29.1.2
Quick Query Search Forms
29.1.3
Named Bind Variables in Query Search Forms
29.1.4
Filtered Table and Query-by-Example Searches
29.1.5
Implicit and Named View Criteria
29.1.6
List of Values (LOV) Input Fields
29.2
Creating Query Search Forms
29.2.1
How to Create a Query Search Form with a Results Table or Tree Table
29.2.2
How to Create a Query Search Form and Add a Results Component Later
29.2.3
How to Persist Saved Searches into MDS
29.2.4
How to Set Default Search Binding Behavior
29.2.5
What You May Need to Know About Dependent Criterion
29.2.6
What Happens When You Create a Query Form
29.2.7
What Happens at Runtime: Search Forms
29.3
Setting Up Search Form Properties
29.3.1
How to Set Search Form Properties on the View Criteria
29.3.2
How to Add Placeholder Text, Label, and Tooltip
29.3.3
How to Set Search Form Properties on the Query Component
29.3.4
How to Set Timezone Control Hint for Timestamp Attribute
29.3.5
How to Create Custom Operators or Remove Standard Operators
29.4
Creating Quick Query Search Forms
29.4.1
How to Create a Quick Query Search Form with a Results Table or Tree Table
29.4.2
How to Create a Quick Query Search Form and Add a Results Component Later
29.4.3
How to Set the Quick Query Layout Format
29.4.4
What Happens When You Create a Quick Query Search Form
29.4.5
What Happens at Runtime: Quick Query
29.5
Creating Standalone Filtered Search Tables from Named View Criteria
30
Creating More Complex Pages
30.1
Introduction to More Complex Pages
30.2
Creating Command Components to Execute Methods
30.2.1
How to Create a Command Component Bound to a Custom Method
30.2.2
What Happens When You Create Command Components Using a Method
30.2.2.1
Defining Method Action Binding
30.2.2.2
Using Parameters in a Method
30.2.2.3
Adding ADF Faces Component Code to JSF Page
30.2.2.4
Using EL Expressions to Bind to Methods
30.2.2.5
Using the Return Value from a Method Call
30.2.3
What Happens at Runtime: Command Button Method Bindings
30.3
Setting Parameter Values Using a Command Component
30.3.1
How to Set Parameters Using setPropertyListener Within a Command Component
30.3.2
What Happens When You Set Parameters
30.3.3
What Happens at Runtime: setPropertyListener for a Command Component
30.4
Overriding Declarative Methods
30.4.1
How to Override a Declarative Method
30.4.2
What Happens When You Override a Declarative Method
30.5
Using the ADF Faces Calendar Component
30.5.1
How to Use the ADF Faces Calendar
30.5.2
What Happens When You Create a Calendar
30.5.3
What Happens at Runtime: How the Calendar Binding Works
30.6
Using the ADF Faces Carousel Component
30.6.1
How to Create a Databound Carousel Component
30.6.2
What Happens When You Create a Carousel
30.7
Creating Contextual Events
30.7.1
How to Create Contextual Events Declaratively
30.7.1.1
Creating Contextual Events in the Publisher
30.7.1.2
Subscribing to and Consuming Events
30.7.2
How to Create Contextual Events Manually
30.7.3
How to Create Contextual Event Using Managed Beans
30.7.4
How to Create a Contextual Event from JavaScript
30.7.5
How to Manually Create the Event Map
30.7.6
How to Register a Custom Event Dispatcher
30.7.7
What Happens When You Create Contextual Events
30.7.8
How to Control Contextual Events Dispatch
30.7.9
What Happens at Runtime: Contextual Events
30.8
Adding ADF Model Layer Validation
30.8.1
How to Add Validation
30.8.2
What Happens at Runtime: Model Validation Rules
30.9
Displaying Error Messages
30.10
Customizing Error Handling
30.10.1
How to Customize the Detail Portion of a Message
30.10.2
How to Write an Error Handler to Deal with Multiple Threads
31
Designing a Page Using Placeholder Data Controls
31.1
Introduction to Placeholder Data Controls
31.2
Creating Placeholder Data Controls
31.2.1
How to Create a Placeholder Data Control
31.2.2
What Happens When You Create a Placeholder Data Control
31.3
Creating Placeholder Data Types
31.3.1
How to Create a Placeholder Data Type
31.3.2
What Happens When You Create a Placeholder Data Type
31.3.3
How to Configure a Placeholder Data Type Attribute to Be an LOV
31.3.3.1
Configuring an Attribute to Be a Fixed LOV
31.3.3.2
Configuring an Attribute to Be a Dynamic LOV
31.3.4
How to Create Master-Detail Data Types
31.3.5
What Happens When You Create a Master-Detail Data Type
31.3.6
How to Add Sample Data
31.3.6.1
Adding Sample Data Manually
31.3.6.2
Importing Sample Data
31.3.7
What Happens When You Add Sample Data
31.4
Using Placeholder Data Controls
31.4.1
Limitations of Placeholder Data Controls
31.4.2
Creating Layout
31.4.3
Creating a Search Form
31.4.4
Binding Components
31.4.5
Rebinding Components
31.4.6
Packaging Placeholder Data Controls to ADF Library JARs
Part V Completing Your Application
32
Enabling ADF Security in a Fusion Web Application
32.1
Introduction to ADF Security
32.1.1
Integration of ADF Security and Java Security
32.1.2
Summary of ADF Security
32.2
ADF Security Process Overview
32.3
Enabling ADF Security
32.3.1
How to Enable ADF Security
32.3.2
What Happens When You Enable ADF Security
32.3.3
What Happens When You Generate a Default Form-Based Login Page
32.3.4
What You May Need to Know About the Configure ADF Security Wizard
32.3.5
What You May Need to Know About ADF Authentication
32.3.6
What You May Need to Know About the Built-In test-all Role
32.3.7
What You May Need to Know About the valid-users Role
32.4
Creating Application Roles
32.4.1
How to Create Application Roles
32.4.2
What Happens When You Create Application Roles
32.4.3
What You May Need to Know About Enterprise Roles and Application Roles
32.5
Defining ADF Security Policies
32.5.1
How to Make an ADF Resource Public
32.5.2
What Happens When You Make an ADF Resource Public
32.5.3
What Happens at Runtime: How the Built-in Roles Are Used
32.5.4
How to Define Policies for ADF Bounded Task Flows
32.5.5
How to Define Policies for Web Pages That Reference a Page Definition
32.5.6
How to Define Policies to Control User Access to ADF Methods
32.5.6.1
Creating a Resource Grant to Control Access to ADF Methods
32.5.6.2
Enforcing the Resource Grant in the User Interface
32.5.7
What Happens When You Define the Security Policy
32.5.8
What Happens at Runtime: How ADF Security Policies Are Enforced
32.5.9
What You May Need to Know About Defining Policies for Pages with No ADF Bindings
32.5.10
How to Use Regular Expressions to Define Policies on Groups of Resources
32.5.11
How to Define Policies for Data
32.5.11.1
Defining Permission Maps on ADF Entity Objects
32.5.11.2
Defining Permission Maps on ADF Entity Object Attributes
32.5.11.3
Granting Permissions on ADF Entity Objects and Entity Attributes
32.5.12
How to Aggregate Resource Grants as Entitlement Grants
32.5.13
What Happens After You Create an Entitlement Grant
32.6
Creating Test Users
32.6.1
How to Create Test Users in JDeveloper
32.6.2
What Happens When You Create Test Users
32.6.3
How to Associate Test Users with Application Roles
32.6.4
What Happens When You Configure Application Roles
32.7
Creating a Login Page
32.7.1
How to Create a Login Link Component and Add it to a Public Web Page for Explicit Authentication
32.7.2
How to Create a Login Page Specifically for Explicit Authentication
32.7.2.1
Creating Login Code for the Backing Bean
32.7.2.2
Creating an ADF Faces-Based Login Page Specifically for Explicit Authentication
32.7.2.3
Ensuring That the Login Page Is Public
32.7.3
How to Ensure That the Custom Login Page's Resources Are Accessible for Explicit Authentication
32.7.4
How to Create a Public Welcome Page
32.7.4.1
Ensuring That the Welcome Page Is Public
32.7.4.2
Adding Login and Logout Links
32.7.4.3
Hiding Links to Secured Pages
32.7.5
How to Redirect a User After Authentication
32.7.6
How to Trigger a Custom Login Page Specifically for Implicit Authentication
32.7.7
What You May Need to Know About Redirecting to a Different Host Server
32.7.8
What You May Need to Know About ADF Servlet Logout and Browser Caching
32.7.9
What You May Need to Know About IBM WebSphere Application Server
32.7.10
What You May Need to Know About Displaying Error Pages in Internet Explorer
32.8
Testing Security in JDeveloper
32.8.1
How to Configure, Deploy, and Run a Secure Application in JDeveloper
32.8.2
What Happens When You Configure Security Deployment Options
32.8.3
How to Use the Built-In test-all Application Role
32.8.4
What Happens at Runtime: How ADF Security Handles Authentication
32.8.5
What Happens at Runtime: How ADF Security Handles Authorization
32.9
Preparing the Secure Application for Deployment
32.9.1
How to Remove the test-all Role from the Application Policy Store
32.9.2
How to Remove Test Users from the Application Identity Store
32.9.3
How to Secure Resource Files Using a URL Constraint
32.10
Disabling ADF Security
32.10.1
How to Disable ADF Security
32.10.2
What Happens When You Disable ADF Security
32.11
Advanced Topics and Best Practices
32.11.1
Using Expression Language (EL) with ADF Security
32.11.1.1
How to Evaluate Policies Using EL
32.11.1.2
What Happens When You Use the Expression Builder Dialog
32.11.1.3
What You May Need to Know About Delayed Evaluation of EL
32.11.2
How to Protect UI Components Using OPSS Resource Permissions and EL
32.11.2.1
Creating the Custom Resource Type
32.11.2.2
Creating a Resource Grant for a Custom Resource Type
32.11.2.3
Associating the Rendering of a UI Component with a Resource Grant
32.11.3
How to Perform Authorization Checks for Entity Object Operations
32.11.4
Getting Information from the ADF Context
32.11.4.1
How to Determine Whether Security Is Enabled
32.11.4.2
How to Determine Whether the User Is Authenticated
32.11.4.3
How to Determine the Current User Name
32.11.4.4
How to Determine Membership of a Java EE Security Role
32.11.4.5
How to Determine Permission Using Java
32.11.5
Best Practices for Working with ADF Security
33
Testing and Debugging ADF Components
33.1
Introduction to ADF Debugging
33.2
Correcting Simple Oracle ADF Compilation Errors
33.3
Correcting Simple Oracle ADF Runtime Errors
33.4
Validating ADF Controller Metadata
33.5
Using the ADF Logger
33.5.1
How to Set ADF Logging Levels
33.5.2
How to Create an Oracle ADF Debugging Configuration
33.5.3
How to Turn On Diagnostic Logging for Non-Oracle ADF Loggers
33.5.4
How to Use the Log Analyzer to View Log Messages
33.5.4.1
Viewing Diagnostic Messages in the Log Analyzer
33.5.4.2
Using the Log Analyzer to Analyze the ADF Request
33.5.4.3
Sorting Diagnostic Messages By ADF Events
33.5.5
What You May Need to Know About the Logging.xml File
33.5.6
What You May Need to Know About ADF Logging and Oracle WebLogic Server
33.6
Using the Business Component Browser for Testing and Debugging
33.6.1
How to Run in Debug Mode and Test with the Business Component Browser
33.6.2
How to Run the Business Component Browser and Test with a Specific Configuration
33.6.3
What Happens When You Run the Business Component Browser in Debug Mode
33.6.4
How to Verify Runtime Artifacts in the Business Component Browser
33.6.5
How to Refresh the Business Component Browser with Application Changes
33.7
Using the ADF Declarative Debugger
33.7.1
Using ADF Source Code with the Debugger
33.7.2
How to Set Up the ADF Source User Library
33.7.3
How to Add the ADF Source Library to a Project
33.7.4
How to Use the EL Expression Evaluator
33.7.5
How to View and Export Stack Trace Information
33.8
Setting ADF Declarative Breakpoints
33.8.1
How to Set and Use Task Flow Activity Breakpoints
33.8.2
How to Set and Use Page Definition Executable Breakpoints
33.8.3
How to Set and Use Page Definition Action Binding Breakpoints
33.8.4
How to Set and Use Page Definition Value Binding Breakpoints
33.8.5
How to Set and Use ADF Lifecycle Phase Breakpoints
33.8.6
How to Use the ADF Structure Window
33.8.7
How to Use the ADF Data Window
33.8.8
What Happens When You Set an ADF Declarative Breakpoint
33.9
Setting Java Code Breakpoints
33.9.1
How to Set Java Breakpoints on Classes and Methods
33.9.2
How to Optimize Use of the Source Editor
33.9.3
How to Set Breakpoints and Debug Using ADF Source Code
33.9.4
How to Use Debug Libraries for Symbolic Debugging
33.9.5
How to Use Different Kinds of Java Code Breakpoints
33.9.6
How to Edit Breakpoints for Improved Control
33.9.7
How to Filter Your View of Class Members
33.9.8
How to Use Common Oracle ADF Breakpoints
33.10
Regression Testing with JUnit
33.10.1
How to Obtain the JUnit Extension
33.10.2
How to Create a JUnit Test Case
33.10.3
How to Create a JUnit Test Fixture
33.10.4
How to Create a JUnit Test Suite
33.10.5
How to Create a Business Components Test Suite
33.10.6
How to a Create Business Components Test Fixture
33.10.7
How to Run a JUnit Test Suite as Part of an Ant Build Script
34
Refactoring a Fusion Web Application
34.1
Introduction to Refactoring a Fusion Web Application
34.2
Renaming Files
34.3
Moving JSF Pages
34.4
Refactoring pagedef.xml Bindings Objects
34.5
Refactoring ADF Business Components
34.6
Refactoring ADF Business Component Object Attributes
34.7
Refactoring Named Elements
34.8
Refactoring ADF Task Flows
34.9
Refactoring the DataBindings.cpx File
34.10
Refactoring Across Abstraction Layers
34.11
Refactoring Limitations
34.12
Refactoring the .jpx Project File
35
Reusing Application Components
35.1
Introduction to Reusable Components
35.1.1
Creating Reusable Components
35.1.1.1
Naming Conventions
35.1.1.2
The Naming Process for the ADF Library JAR Deployment Profile
35.1.1.3
Keeping the Relevant Project
35.1.1.4
Selecting the Relevant Technology Scope
35.1.1.5
Selecting Paths and Folders
35.1.1.6
Including Connections Within Reusable Components
35.1.2
Using the Resource Palette
35.1.3
Extension Libraries
35.2
Packaging a Reusable ADF Component into an ADF Library
35.2.1
How to Package a Component into an ADF Library JAR
35.2.2
What Happens When You Package a Project to an ADF Library JAR
35.2.2.1
Application Modules
35.2.2.2
Data Controls
35.2.2.3
Task Flows
35.2.2.4
Page Templates
35.2.2.5
Declarative Components
35.2.3
How to Place and Access JDeveloper JAR Files
35.3
Adding ADF Library Components into Projects
35.3.1
How to Add an ADF Library JAR into a Project using the Resource Palette
35.3.2
How to Add an ADF Library JAR into a Project Manually
35.3.3
What Happens When You Add an ADF Library JAR to a Project
35.3.4
What You May Need to Know About Using ADF Library Components
35.3.4.1
Using Data Controls
35.3.4.2
Using Application Modules
35.3.4.3
Using Business Components
35.3.4.4
Using Task Flows
35.3.4.5
Using Page Templates
35.3.4.6
Using Declarative Components
35.3.5
What You May Need to Know About Differentiating ADF Library Components
35.3.6
What Happens at Runtime: Adding ADF Libraries
35.4
Removing an ADF Library JAR from a Project
35.4.1
How to Remove an ADF Library JAR from a Project Using the Resource Palette
35.4.2
How to Remove an ADF Library JAR from a Project Manually
36
Customizing Applications with MDS
36.1
Introduction to Customization and MDS
36.1.1
Customizations and Layers
36.1.2
Static and Dynamic Customization Content
36.2
Developing a Customizable Application
36.2.1
How to Create Customization Classes
36.2.1.1
Customization Classes
36.2.1.2
Implementing the getValue() Method in Your Customization Class
36.2.1.3
Creating a Customization Class
36.2.2
What You May Need to Know About Customization Classes
36.2.3
How to Consume Customization Classes
36.2.3.1
Making Customization Classes Available to JDeveloper
36.2.3.2
Consuming Customization Classes from an Extension Project
36.2.4
How to Enable Seeded Customizations for View Projects
36.2.5
How to Enable Seeded Customizations in Existing Pages
36.2.6
How to Enable Customizations in Resource Bundles
36.2.7
How to Configure the adf-config.xml file
36.2.8
What Happens When You Create a Customizable Application
36.2.9
What You May Need to Know About Customizable Objects and Applications
36.3
Customizing an Application
36.3.1
Introducing the Customization Developer Role
36.3.2
How to Switch to the Customization Developer Role in JDeveloper
36.3.3
Introducing the Tip Layer
36.3.4
How to Configure Customization Layers
36.3.4.1
Configuring Layer Values Globally
36.3.4.2
Configuring Workspace-Level Layer Values from the adf-config Editor
36.3.4.3
Configuring Workspace-Level Layer Values from the Customization Context Window
36.3.5
How to Customize Metadata in JDeveloper
36.3.6
How to Fix Incongruencies Between the Tip Layer and Base Metadata
36.3.7
What Happens When You Customize an Application
36.3.8
How to Customize Business Logic using Groovy Triggers
36.3.9
How to Customize ADF Library Artifacts in JDeveloper
36.3.9.1
Specifying a Location for ADF Library Customizations
36.3.9.2
Viewing ADF Library Runtime Customizations from Exported JARs
36.3.10
What Happens When You Customize ADF Library Artifacts
36.3.11
How to Package and Deploy Customized Applications
36.3.11.1
Implicitly Creating a MAR
36.3.11.2
Explicitly Creating a MAR
36.3.12
What Happens at Runtime in a Customized Application
36.3.13
What You May Need to Know About Customized Applications
36.3.13.1
Customization and Integrated Source Control
36.3.13.2
Editing Resource Bundles in Customized Applications
36.4
Extended Metadata Properties
36.4.1
How to Edit Extended Metadata Properties
36.4.2
How to Enable Customization for Design Time at Runtime
36.5
Enabling Runtime Modification of Customization Configuration
37
Allowing User Customizations at Runtime
37.1
Introduction to Allowing User Customizations
37.2
Enabling Runtime User Customizations for a Fusion Web Application
37.2.1
How to Enable User Customizations
37.2.2
What Happens When You Enable User Customizations
37.3
Configuring User Customizations
37.3.1
How to Configure Change Persistence
37.3.2
What Happens When You Configure Change Persistence
37.4
Controlling User Customizations in Individual JSF Pages
37.4.1
How to Implement User Customizations on a JSF Page
37.4.2
What Happens at Runtime: How Changes Are Persisted and Restored
37.4.3
What You May Need to Know About Using Change Persistence on Templates, Regions, and Declarative Components
37.5
Implementing Custom User Customizations
37.5.1
Change Persistence Framework API
37.5.2
How to Create Code for Custom User Customizations
37.6
Creating Implicit Change Persistence in Custom Components
37.6.1
How to Set Implicit Change Persistence For Attribute Values that Use Events
37.6.2
How to Set Implicit Change Persistence For Other Attribute Values
38
Deploying Fusion Web Applications
38.1
Introduction to Deploying Fusion Web Applications
38.1.1
Developing Applications with Integrated WebLogic Server
38.1.2
Developing Applications to Deploy to Standalone Application Servers
38.2
Running an ADF Application in Integrated WebLogic Server
38.2.1
How to Run an Application in Integrated WebLogic Server
38.2.2
How to Run an Application with Metadata in Integrated WebLogic Server
38.3
Preparing the Application
38.3.1
How to Create a Connection to the Target Application Server
38.3.2
How to Create Deployment Profiles
38.3.2.1
Adding Customization Classes into a JAR
38.3.2.2
Creating a WAR Deployment Profile
38.3.2.3
Creating a MAR Deployment Profile
38.3.2.4
Creating an Application-Level EAR Deployment Profile
38.3.2.5
Delivering Customization Classes as a Shared Library
38.3.2.6
Viewing and Changing Deployment Profile Properties
38.3.3
How to Create and Edit Deployment Descriptors
38.3.3.1
Creating Deployment Descriptors
38.3.3.2
Viewing or Modifying Deployment Descriptor Properties
38.3.3.3
Configuring the application.xml File for Application Server Compatibility
38.3.3.4
Configuring the web.xml File for Application Server Compatibility
38.3.3.5
Enabling the Application for Real User Experience Insight
38.3.4
How to Deploy Applications with ADF Security Enabled
38.3.4.1
Applications That Will Run Using Oracle Single Sign-On (SSO)
38.3.4.2
Configuring Security for WebLogic Server
38.3.4.3
Configuring Security for WebSphere Server
38.3.5
How to Replicate Memory Scopes in a Clustered Environment
38.3.6
How to Enable the Application for ADF MBeans
38.3.7
What You May Need to Know About JDBC Data Source for Oracle WebLogic Server
38.4
Deploying the Application
38.4.1
How to Deploy to the Application Server from JDeveloper
38.4.2
How to Create an EAR File for Deployment
38.4.3
What You May Need to Know About EAR Files and Packaging
38.4.4
How to Deploy the Application Using Scripts and Ant
38.4.5
How to Deploy New Customizations Applied to ADF LIbrary
38.4.5.1
Exporting Customization to a Deployed Application
38.4.5.2
Deploying Customizations to a JAR
38.4.6
What You May Need to Know About ADF Libraries
38.4.7
How to Deploy ADF Faces JARs with the Application
38.4.8
What You May Need to Know About JDeveloper Runtime Libraries
38.5
Postdeployment Configuration
38.5.1
How to Migrate an Application
38.5.2
How to Configure the Application Using ADF MBeans
38.6
Testing the Application and Verifying Deployment
Part VI Advanced Topics
39
Advanced Business Components Techniques
39.1
Extending the ADF Business Components Framework
39.1.1
How To Create a Framework Extension Class
39.1.2
What Happens When You Create a Framework Extension Class
39.1.3
What You May Need to Know About Customizing Framework Extension Bases Classes
39.1.4
How to Base an ADF Component on a Framework Extension Class
39.1.5
How to Define Framework Extension Classes for All New Components
39.1.6
How to Define Framework Extension Classes for All New Projects
39.1.7
What Happens When You Base a Component on a Framework Extension Class
39.1.7.1
XML-Only Components
39.1.7.2
Components with Custom Java Classes
39.1.8
What You May Need to Know About Updating the Extends Clause in Custom Component Java Files
39.1.9
How to Package Your Framework Extension Layer in a JAR File
39.1.10
How to Create a Library Definition for Your Framework Extension JAR File
39.2
Customizing Framework Behavior with Extension Classes
39.2.1
How to Access Runtime Metadata For View Objects and Entity Objects
39.2.2
How to Implement Generic Functionality Using Runtime Metadata
39.2.3
How to Implement Generic Functionality Driven by Custom Properties
39.2.4
How to Configure Design Time Custom Property Names
39.2.5
What You May Need to Know About the Kinds of Attributes
39.2.6
What You May Need to Know About Custom Properties
39.3
Creating Generic Extension Interfaces
39.4
Invoking Stored Procedures and Functions
39.4.1
How to Invoke Stored Procedures with No Arguments
39.4.2
How to Invoke Stored Procedure with Only IN Arguments
39.4.3
How to Invoke Stored Function with Only IN Arguments
39.4.4
How to Call Other Types of Stored Procedures
39.5
Accessing the Current Database Transaction
39.6
Working with Libraries of Reusable Business Components
39.6.1
How To Create a Reusable Library of Business Components
39.6.2
How To Import a Package of Reusable Components from a Library
39.6.3
How to Remove an Imported Package from a Project
39.6.4
What Happens When You Import a Package of Reusable Components from a Library
39.6.5
What You May Need to Know About Imported Projects
39.7
Customizing Business Components Error Messages
39.7.1
How to Customize Base ADF Business Components Error Messages
39.7.2
What Happens When You Customize Base ADF Business Components Error Messages
39.7.3
How to Display Customize Error Messages as Nested Exceptions
39.7.4
How to Customize Error Messages for Database Constraint Violations
39.7.5
How to Implement a Custom Constraint Error Handling Routine
39.7.5.1
Creating a Custom Database Transaction Framework Extension Class
39.7.5.2
Configuring an Application Module to Use a Custom Database Transaction Class
39.8
Creating Extended Components Using Inheritance
39.8.1
How To Create a Component That Extends Another
39.8.2
How To Extend a Component After Creation
39.8.3
What Happens When You Create a Component That Extends Another
39.8.3.1
Attributes in an Extended Component Inherited from the Parent Component
39.8.3.2
Attributes Added to the Extended Component's XML Descriptor
39.8.3.3
Java Classes Generated for an Extended Component
39.8.4
What You May Need to Know About Extending Components
39.8.4.1
Parent Classes and Interfaces for Extended Components
39.8.4.2
Generated Classes for Extended Components
39.8.4.3
Business Component Types
39.8.4.4
New Attributes in an Extended Component
39.9
Substituting Extended Components in a Delivered Application
39.9.1
How To Substitute an Extended Component
39.9.2
What Happens When You Substitute
39.9.3
How to Enable the Substituted Components in the Base Application
40
Advanced Entity Object Techniques
40.1
Creating Custom, Validated Data Types Using Domains
40.1.1
How to Create a Domain
40.1.2
What Happens When You Create a Domain
40.1.3
What You May Need to Know About Domains
40.1.3.1
Using Domains for Entity and View Object Attributes
40.1.3.2
Validate Method Should Throw DataCreationException If Sanity Checks Fail
40.1.3.3
String Domains Aggregate a String Value
40.1.3.4
Other Domains Extend Existing Domain Type
40.1.3.5
Simple Domains Are Immutable Java Classes
40.1.3.6
Creating Domains for Oracle Object Types When Useful
40.1.3.7
Quickly Navigating to the Domain Class
40.1.3.8
Domains Get Packaged in the Common JAR
40.1.3.9
Entity and View Object Attributes Inherit Custom Domain Properties
40.1.3.10
Domain Settings Cannot Be Less Restrictive at Entity or View Level
40.2
Updating a Deleted Flag Instead of Deleting Rows
40.2.1
How to Update a Deleted Flag When a Row Is Removed
40.2.2
Forcing an Update DML Operation Instead of a Delete
40.3
Using Update Batching
40.4
Advanced Entity Association Techniques
40.4.1
Modifying Association SQL Clause to Implement Complex Associations
40.4.2
Exposing View Link Accessor Attributes at the Entity Level
40.5
Basing an Entity Object on a PL/SQL Package API
40.5.1
How to Create an Entity Object Based on a View
40.5.2
What Happens When You Create an Entity Object Based on a View
40.5.3
Centralizing Details for PL/SQL-Based Entities into a Base Class
40.5.4
Implementing the Stored Procedure Calls for DML Operations
40.5.5
Adding Select and Lock Handling
40.5.5.1
Updating PLSQLEntityImpl Base Class to Handle Lock and Select
40.5.5.2
Implementing Lock and Select for the Product Entity
40.5.5.3
Refreshing the Entity Object After RowInconsistentException
40.6
Basing an Entity Object on a Join View or Remote DBLink
40.7
Using Inheritance in Your Business Domain Layer
40.7.1
Understanding When Inheritance Can Be Useful
40.7.2
How to Create Entity Objects in an Inheritance Hierarchy
40.7.2.1
Start by Identifying the Discriminator Column and Distinct Values
40.7.2.2
Identify the Subset of Attributes Relevant to Each Kind of Entity
40.7.2.3
Creating the Base Entity Object in an Inheritance Hierarchy
40.7.2.4
Creating a Subtype Entity Object in an Inheritance Hierarchy
40.7.3
How to Add Methods to Entity Objects in an Inheritance Hierarchy
40.7.3.1
Adding Methods Common to All Entity Objects in the Hierarchy
40.7.3.2
Overriding Common Methods in a Subtype Entity
40.7.3.3
Adding Methods Specific to a Subtype Entity
40.7.4
What You May Need to Know About Using Inheritance
40.7.4.1
Sometimes You Need to Introduce a New Base Entity
40.7.4.2
Finding Subtype Entities by Primary Key
40.7.4.3
You Can Create View Objects with Polymorphic Entity Usages
40.8
Controlling Entity Posting Order to Avoid Constraint Violations
40.8.1
Understanding the Default Post Processing Order
40.8.2
How Compositions Change the Default Processing Ordering
40.8.3
Overriding postChanges() to Control Post Order
40.8.3.1
Observing the Post Ordering Problem First Hand
40.8.3.2
Forcing the Supplier to Post Before the Product
40.8.3.3
Understanding Associations Based on DBSequence-Valued Primary Keys
40.8.3.4
Refreshing References to DBSequence-Assigned Foreign Keys
40.9
Implementing Custom Validation Rules
40.9.1
How to Create a Custom Validation Rule
40.9.2
Adding a Design Time Bean Customizer for Your Rule
40.9.3
Registering and Using a Custom Rule in JDeveloper
40.10
Creating New History Types
40.10.1
How to Create New History Types
40.10.2
How to Remove a History Type
41
Advanced View Object Techniques
41.1
Advanced View Object Concepts and Features
41.1.1
Limiting the View Object Max Fetch Size to Fetch the First n Rows
41.1.2
Maintaining New Row Consistency in View Objects Based on the Same Entity
41.1.2.1
What Happens at Runtime When View Link Consistency is Enabled
41.1.2.2
How to Change the Default View Link Consistency Setting
41.1.2.3
How to Use a RowMatch to Qualify Which New, Unposted Rows Get Added to a Row Set
41.1.2.4
What You May Need to Know About the Dynamic WHERE Clause and View Link Consistency
41.1.3
Understanding View Link Accessors Versus Data Model View Link Instances
41.1.3.1
Enabling a Dynamic Detail Row Set with Active Master-Detail Coordination
41.1.3.2
Accessing a Stable Detail Row Set Using View Link Accessor Attributes
41.1.3.3
Accessor Attributes Create Distinct Row Sets Based on an Internal View Object
41.1.4
Presenting and Scrolling Data a Page at a Time Using the Range
41.1.5
Efficiently Scrolling Through Large Result Sets Using Range Paging
41.1.5.1
Understanding How to Oracle Supports "TOP-N" Queries
41.1.5.2
How to Enable Range Paging for a View Object
41.1.5.3
What Happens When You Enable Range Paging
41.1.5.4
What Happens When View Rows are Cached When Using Range Paging
41.1.5.5
How to Scroll to a Given Page Number Using Range Paging
41.1.5.6
Estimating the Number of Pages in the Row Set Using Range Paging
41.1.5.7
Understanding the Tradeoffs of Using a Range Paging Mode
41.1.6
Setting Up a Data Model with Multiple Masters
41.1.7
Understanding When You Can Use Partial Keys with findByKey()
41.1.8
Creating Dynamic Attributes to Store UI State
41.1.9
Working with Multiple Row Sets and Row Set Iterators
41.1.10
Optimizing View Link Accessor Access By Retaining the Row Set
41.2
Tuning Your View Objects for Best Performance
41.2.1
Use Bind Variables for Parameterized Queries
41.2.1.1
Use Bind Variables to Avoid Re-parsing of Queries
41.2.1.2
Use Bind Variables to Prevent SQL-Injection Attacks
41.2.2
Consider Using Entity-Based View Objects for Read-Only Data
41.2.3
Use SQL Tracing to Identify Ill-Performing Queries
41.2.4
Consider the Appropriate Tuning Settings for Every View Object
41.2.4.1
Set the Database Retrieval Options Appropriately
41.2.4.2
Consider Whether Fetching One Row at a Time is Appropriate
41.2.4.3
Specify a Query Optimizer Hint if Necessary
41.2.5
Creating View Objects at Design Time
41.2.6
Use Forward Only Mode to Avoid Caching View Rows
41.3
Generating Custom Java Classes for a View Object
41.3.1
How To Generate Custom Classes
41.3.1.1
Generating Bind Variable Accessors
41.3.1.2
Generating View Row Attribute Accessors
41.3.1.3
Exposing View Row Accessors to Clients
41.3.1.4
Configuring Default Java Generation Preferences
41.3.2
What Happens When You Generate Custom Classes
41.3.2.1
Seeing and Navigating to Custom Java Files
41.3.3
What You May Need to Know About Custom Classes
41.3.3.1
About the Framework Base Classes for a View Object
41.3.3.2
You Can Safely Add Code to the Custom Component File
41.3.3.3
Attribute Indexes and InvokeAccessor Generated Code
41.3.3.4
Avoid Creating Dependencies on Parent Application Module Types
41.4
Working Programmatically with Multiple Named View Criteria
41.4.1
Applying One or More Named View Criteria
41.4.2
Removing All Applied Named View Criteria
41.4.3
Using the Named Criteria at Runtime
41.5
Performing In-Memory Sorting and Filtering of Row Sets
41.5.1
Understanding the View Object's SQL Mode
41.5.2
Sorting View Object Rows In Memory
41.5.2.1
Combining setSortBy and setQueryMode for In-Memory Sorting
41.5.2.2
Simplified In-Memory Sorting
41.5.2.3
Extensibility Points for In-Memory Sorting
41.5.3
Performing In-Memory Filtering with View Criteria
41.5.4
Performing In-Memory Filtering with RowMatch
41.5.4.1
Applying a RowMatch to a View Object
41.5.4.2
Using RowMatch to Test an Individual Row
41.5.4.3
How a RowMatch Affects Rows Fetched from the Database
41.6
Using View Objects to Work with Multiple Row Types
41.6.1
Working with Polymorphic Entity Usages
41.6.2
How To Create a View Object with a Polymorphic Entity Usage
41.6.3
What Happens When You Create a View Object with a Polymorphic Entity Usage
41.6.4
What You May Need to Know About Entity Usages
41.6.4.1
Your Query Must Limit Rows to Expected Entity Subtypes
41.6.4.2
Exposing Selected Entity Methods in View Rows Using Delegation
41.6.4.3
Creating New Rows With the Desired Entity Subtype
41.6.5
Working with Polymorphic View Rows
41.6.6
How to Create a View Object with Polymorphic View Rows
41.6.7
What You May Need to Know About Polymorphic View Rows
41.6.7.1
Selecting Subtype-Specific Attributes in Extended View Objects
41.6.7.2
Delegating to Subtype-Specific Methods After Overriding the Entity Usage
41.6.7.3
Working with Different View Row Interface Types in Client Code
41.6.7.4
Polymorphic Entity Usage and Polymorphic View Rows Usages
41.7
Reading and Writing XML
41.7.1
How to Produce XML for Queried Data
41.7.2
What Happens When You Produce XML
41.7.3
What You May Need to Know About Reading and Writing XML
41.7.3.1
Controlling XML Element Names
41.7.3.2
Controlling Element Suppression for Null-Valued Attributes
41.7.3.3
Printing or Searching the Generated XML Using XPath
41.7.3.4
Using the Attribute Map For Fine Control Over Generated XML
41.7.3.5
Use the Attribute Map Approach with Bi-Directional View Links
41.7.3.6
Transforming Generated XML Using an XSLT Stylesheet
41.7.3.7
Generating XML for a Single Row
41.7.4
How to Consume XML Documents to Apply Changes
41.7.5
What Happens When You Consume XML Documents
41.7.5.1
How ViewObject.readXML() Processes an XML Document
41.7.5.2
Using readXML() to Processes XML for a Single Row
41.8
Using Programmatic View Objects for Alternative Data Sources
41.8.1
How to Create a Read-Only Programmatic View Object
41.8.2
How to Create an Entity-Based Programmatic View Object
41.8.3
Key Framework Methods to Override for Programmatic View Objects
41.8.4
How to Create a View Object on a REF CURSOR
41.8.4.1
The Overridden create() Method
41.8.4.2
The Overridden executeQueryForCollection() Method
41.8.4.3
The Overridden createRowFromResultSet() Method
41.8.4.4
The Overridden hasNextForCollectionMethod()
41.8.4.5
The Overridden releaseUserDataForCollection() Method
41.8.4.6
The Overridden getQueryHitCount() Method
41.9
Creating a View Object with Multiple Updatable Entities
41.10
Programmatically Creating View Definitions and View Objects
41.11
Declaratively Preventing Insert, Update, and Delete
42
Application State Management
42.1
Understanding Why State Management is Necessary
42.1.1
Examples of Multi-Step Tasks
42.1.2
Stateless HTTP Protocol Complicates Stateful Applications
42.1.3
How Cookies Are Used to Track a User Session
42.1.4
Performance and Reliability Impact of Using HttpSession
42.2
Introduction to Fusion Web Application State Management
42.2.1
Basic Architecture of the Save for Later Facility
42.2.2
Basic Architecture of the Application Module State Management Facility
42.2.2.1
Understanding When Passivation and Activation Occurs
42.2.2.2
How Passivation Changes When Optional Failover Mode is Enabled
42.2.2.3
About State Management Release Levels
42.2.2.4
State Management and Subclassed Entity Objects
42.2.3
What You May Need to Know About Using Application Scoped Managed Beans in a Clustered Environment
42.3
Using Save For Later
42.4
Setting the Application Module Release Level at Runtime
42.4.1
How to Set Unmanaged Level
42.4.2
How to Set Reserved Level
42.4.3
How to Set Managed Level
42.4.4
How to Set Release Level in a JSF Backing Bean
42.4.5
How to Set Release Level in an ADF PagePhaseListener
42.4.6
How to Set Release Level in an ADF PageController
42.4.7
How to Set Release Level in an Custom ADF PageLifecycle
42.5
What Model State Is Saved and When It Is Cleaned Up
42.5.1
State Information Saved During Passivation
42.5.2
Where the Model State Is Saved
42.5.2.1
How Database-Backed Passivation Works
42.5.2.2
Controlling the Schema Where the State Management Table Resides
42.5.2.3
Configuring the Type of Passivation Store
42.5.3
Cleaning Up the Model State
42.5.3.1
Previous Snapshot Removed When Next One Taken
42.5.3.2
Passivation Snapshot Removed on Unmanaged Release
42.5.3.3
Passivation Snapshot Retained in Failover Mode
42.5.4
Cleaning Up Temporary Storage Tables
42.6
Timing Out the HttpSession
42.6.1
How to Configure the Implicit Timeout Due to User Inactivity
42.6.2
How to Code an Explicit HttpSession Timeout
42.7
Managing Custom User-Specific Information
42.7.1
How to Passivate Custom User-Specific Information
42.7.2
What Happens When You Passivate Custom Information
42.7.3
What You May Need to Know About Activating Custom Information
42.8
Managing the State of View Objects
42.8.1
How to Manage the State of View Objects
42.8.2
What You May Need to Know About Passivating View Objects
42.8.3
How to Manage the State of Transient View Objects and Attributes
42.8.4
What You May Need to Know About Passivating Transient View Objects
42.8.5
How to Use Transient View Objects to Store Session-level Global Variables
42.9
Using State Management for Middle-Tier Savepoints
42.9.1
How to Use State Management for Savepoints
42.10
Testing to Ensure Your Application Module is Activation-Safe
42.10.1
Understanding the jbo.ampool.doampooling Configuration Parameter
42.10.2
Disabling Application Module Pooling to Test Activation
42.11
Keeping Pending Changes in the Middle Tier
42.11.1
How to Set Applications to Use Optimistic Locking
42.11.2
How to Avoid Clashes Using the postChanges() Method
42.11.3
How to Use the Reserved Level For Pending Database States
43
Tuning Application Module Pools and Connection Pools
43.1
Introduction to Application Module Pooling
43.1.1
Types of Pools Created When Running the Fusion Web Application
43.1.1.1
Application Module Pools
43.1.1.2
Database Connection Pools
43.1.2
Understanding Application Module and Connection Pools
43.1.2.1
Single Oracle WebLogic Server Domain, Single Oracle WebLogic Server Instance, Single JVM
43.1.2.2
Multiple Oracle WebLogic Server Domains, Multiple Oracle WebLogic Server Instance, Multiple JVMs
43.2
Setting Pool Configuration Parameters
43.2.1
How to Set Configuration Properties Declaratively
43.2.2
What Happens When You Set Configuration Properties Declaratively
43.2.3
How to Set Configuration Properties as System Parameters
43.2.4
How to Programmatically Set Configuration Properties
43.2.5
What You May Need to Know About Configuration Property Scopes
43.2.6
What You May Need to Know About How Database and Application Module Pools Cooperate
43.2.7
What You May Need to Know About Application Module Pool Parameters
43.2.7.1
Pool Behavior Parameters
43.2.7.2
Pool Sizing Parameters
43.2.7.3
Pool Cleanup Parameters
43.2.8
What You May Need to Know About Data Source Configuration
43.2.9
What You May Need to Know About Database Connection Pool Parameters
43.3
Initializing Database State and Pooling Considerations
43.3.1
How to Set Database State Per User
43.3.2
What You May Need to Know About Optimizing Connection Pooling
44
Using the Active Data Service
44.1
Introduction to the Active Data Service
44.1.1
Limitations of the Active Data Service Framework
44.1.2
Active Data Service Framework
44.1.3
Data Transport Modes
44.2
Configuring the Active Data Service
44.2.1
How to Configure the Active Data Service
44.2.2
What You May Need to Know About Transport Modes
44.2.3
How to Configure Session Timeout for Active Data Service
44.3
Configuring Components to Use the Active Data Service
44.3.1
How to Configure Components to Use the Active Data Service Without the Active Data Proxy
44.3.2
How to Configure Components to Use the Active Data Service with the Active Data Proxy
44.3.3
What You May Need to Know About Displaying Active Data in ADF Trees
44.3.4
What Happens at Runtime: How Components Render When Bound to Active Data
44.3.5
What You May Need to Know About ADS and Google Chrome
44.4
Using the Active Data Proxy
44.4.1
What You May Need to Know About Read Consistency
44.5
Using the Active Data with a Scalar Model
Part VII Appendices
A
Oracle ADF XML Files
A.1
Introduction to the ADF Metadata Files
A.2
ADF File Overview Diagram
A.2.1
Oracle ADF Data Control Files
A.2.2
Oracle ADF Data Binding Files
A.2.3
Web Configuration Files
A.3
ADF File Syntax Diagram
A.4
adfm.xml
A.5
modelProjectName
.jpx
A.6
bc4j.xcfg
A.7
DataBindings.cpx
A.7.1
DataBindings.cpx Syntax
A.7.2
DataBindings.cpx Sample
A.8
pageName
PageDef.xml
A.8.1
PageDef.xml Syntax
A.9
adfc-config.xml
A.10
task-flow-definition.xml
A.11
adf-config.xml
A.12
adf-settings.xml
A.13
web.xml
A.14
logging.xml
B
Oracle ADF Binding Properties
C
ADF Security Permission Grants
D
ADF Equivalents of Common Oracle Forms Triggers
D.1
Validation and Defaulting (Business Logic)
D.2
Query Processing
D.3
Database Connection
D.4
Transaction "Post" Processing (Record Cache)
D.5
Error Handling
E
Most Commonly Used ADF Business Components Methods
E.1
Most Commonly Used Methods in the Client Tier
E.1.1
ApplicationModule Interface
E.1.2
Transaction Interface
E.1.3
ViewObject Interface
E.1.4
RowSet Interface
E.1.5
RowSetIterator Interface
E.1.6
Row Interface
E.1.7
StructureDef Interface
E.1.8
AttributeDef Interface
E.1.9
AttributeHints Interface
E.2
Most Commonly Used Methods in the Business Service Tier
E.2.1
Controlling Custom Java Files for Your Components
E.2.2
ApplicationModuleImpl Class
E.2.2.1
Methods You Typically Call on ApplicationModuleImpl
E.2.2.2
Methods You Typically Write in Your Custom ApplicationModuleImpl Subclass
E.2.2.3
Methods You Typically Override in Your Custom ApplicationModuleImpl Subclass
E.2.3
DBTransactionImpl2 Class
E.2.3.1
Methods You Typically Call on DBTransaction
E.2.3.2
Methods You Typically Override in Your Custom DBTransactionImpl2 Subclass
E.2.4
EntityImpl Class
E.2.4.1
Methods You Typically Call on EntityImpl
E.2.4.2
Methods You Typically Write in Your Custom EntityImpl Subclass
E.2.4.3
Methods You Typically Override in Your Custom EntityImpl Subclass
E.2.5
EntityDefImpl Class
E.2.5.1
Methods You Typically Call on EntityDefImpl
E.2.5.2
Methods You Typically Write in Your Custom EntityDefImpl Class
E.2.5.3
Methods You Typically Override in Your Custom EntityDefImpl
E.2.6
ViewObjectImpl Class
E.2.6.1
Methods You Typically Call on ViewObjectImpl
E.2.6.2
Methods You Typically Write in Your Custom ViewObjectImpl Subclass
E.2.6.3
Methods You Typically Override in Your Custom ViewObjectImpl Subclass
E.2.7
ViewRowImpl Class
E.2.7.1
Methods You Typically Call on ViewRowImpl
E.2.7.2
Methods You Typically Write in Your Custom ViewRowImpl Class
E.2.7.3
Methods You Typically Override in Your Custom ViewRowImpl Subclass
E.2.8
Setting Up Your Own Layer of Framework Base Classes
F
ADF Business Components Java EE Design Pattern Catalog
G
Performing Common Oracle Forms Tasks in Oracle ADF
G.1
Performing Tasks Related to Data
G.1.1
How to Retrieve Lookup Display Values for Foreign Keys
G.1.2
How to Get the Sysdate from the Database
G.1.3
How to Implement an Isolation Mode That Is Not Read Consistent
G.1.4
How to Implement Calculated Fields
G.1.5
How to Implement Mirrored Items
G.1.6
How to Use Database Columns of Type CLOB or BLOB
G.2
Performing Tasks Related to the User Interface
G.2.1
How to Lay Out a Page
G.2.2
How to Stack Canvases
G.2.3
How to Implement a Master-Detail Screen
G.2.4
How to Implement an Enter Query Screen
G.2.5
How to Implement an Updatable Multi-Record Table
G.2.6
How to Create a Popup List of Values
G.2.7
How to Implement a Dropdown List as a List of Values
G.2.8
How to Implement a Dropdown List with Values from Another Table
G.2.9
How to Implement Immediate Locking
G.2.10
How to Throw an Error When a Record Is Locked
H
Data Controls in Oracle ADF Fusion Web Applications
H.1
Introduction to Data Controls
H.2
Data Control Feature Implementation Comparison
H.3
Data Control Objects
Glossary
Scripting on this page enhances content navigation, but does not change the content in any way.