Skip Headers
Oracle® Fusion Middleware Fusion Developer's Guide for Oracle Application Development Framework
11
g
Release 1 (11.1.1)
B31974-03
Index
Next
Contents
Title and Copyright Information
Preface
Audience
Documentation Accessibility
Related Documents
Conventions
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 Declaratively 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 ADF Business Components to Access Data
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 Business Services with the Business Component Browser
1.3.7
Implementing the User Interface with JSF
1.3.8
Data Binding with Oracle 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
Overview of the Fusion Order Demo Schema
2.2.1
Translation Support in the Fusion Order Demo Schema
2.2.2
Lookup Tables in the Fusion Order Demo Schema
2.3
Setting Up the Fusion Order Demo Application
2.3.1
How to Download the Application Resources
2.3.2
How to Install the Fusion Order Demo Schema
2.3.3
How to Run the Fusion Order Demo Application
2.4
Taking a Look at the Fusion Order Demo Application
2.4.1
Anonymous Browsing
2.4.1.1
Viewing Product Details
2.4.1.2
Browsing the Product Catalog
2.4.1.3
Searching for Products
2.4.2
The Login Process
2.4.3
The Ordering Process
2.4.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
Creating New Components Using Wizards
3.3.3
Creating New Components Using the Context Menu
3.3.4
Editing Components Using the Component Overview Editor
3.3.5
Visualizing, Creating, and Editing Components Using UML Diagrams
3.3.6
Testing Application Modules Using the Business Component Browser
3.3.7
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
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 Create an Entity 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.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 Override Attributes in a Business Logic Unit
4.8.4
What Happens When You Create a Business Logic Group
4.8.5
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
What is an Event Definition?
4.11.2
What is an Event Point?
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.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 an Entity-Based View Object from a Single Table
5.2.1.2
Creating a View Object with All the Attributes of an Entity Object
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 Inherit Properties from Underlying Entity Object Attributes
5.2.5.2
Controlling the Length, Precision, and Scale of View Object Attributes
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 an 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 Query Builder 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 Read-Only View Objects
5.6.2
How to Create a Master-Detail Hierarchy for Entity-Based View Objects
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 SQL-Independent View Objects with Declarative SQL Mode
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
Expert Mode Retains Formatting of SQL Statement
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
A Helper Method to Remove Named Bind Variables
5.10.8.3
Errors Related to Naming Bind Variables
5.10.8.4
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 You May Need to Know About Bind Variable Options
5.11.3
What You May Need to Know About Nested Expressions
5.11.4
How to Set User Interface Hints on View Criteria
5.11.5
How to Test View Criteria Using the Business Component Browser
5.11.6
How to Create View Criteria Programmatically
5.11.7
What Happens at Runtime: When the View Criteria is Applied to a View Object
5.11.8
What You May Need to Know About the View Criteria API
5.11.8.1
Referencing Attribute Names in View Criteria
5.11.8.2
Referencing Bind Variables in View Criteria
5.11.8.3
Altering Compound Search Conditions Using Multiple View Criteria Rows
5.11.8.4
Searching for a Row Whose Attribute Value Is NULL Value
5.11.8.5
Searching Case-Insensitively
5.11.8.6
Clearing View Criteria in Effect
5.11.9
What You May Need to Know About Query-by-Example Criteria
5.12
Working with List of Values (LOV) in View Object Attributes
5.12.1
How to Define a Single LOV-Enabled View Object Attribute
5.12.2
How to Define Cascading Lists for LOV-Enabled View Object Attributes
5.12.2.1
Creating a Data Source View Object to Control the Cascading List
5.12.2.2
Creating a View Accessor to Filter the Cascading List
5.12.3
How to Specify Multiple LOVs for an LOV-Enabled View Object Attribute
5.12.4
How to Set User Interface Hints on a View Object LOV-Enabled Attribute
5.12.5
How to Test LOV-Enabled Attributes Using the Business Component Browser
5.12.6
What Happens When You Define an LOV for a View Object Attribute
5.12.7
What Happens at Runtime: When an LOV Queries the List Data Source
5.12.8
What You May Need to Know About Lists
5.12.8.1
Inheritance of AttributeDef Properties from Parent View Object Attributes
5.12.8.2
Using Validators to Validate Attribute Values
5.13
Defining Attribute Control Hints for View Objects
5.13.1
How to Add Attribute Control Hints
5.13.2
What Happens When You Add Attribute Control Hints
5.13.3
What You May Need to Know About Resource Bundles
5.14
Adding Calculated and Transient Attributes to a View Object
5.14.1
How to Add a SQL-Calculated Attribute
5.14.2
What Happens When You Add a SQL-Calculated Attribute
5.14.3
How to Add a Transient Attribute
5.14.4
What Happens When You Add a Transient Attribute
5.14.5
Adding Java Code in the View Row Class to Perform Calculation
5.14.6
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
What Happens When You Use the Business Component Browser
6.3.4
How to Simulate End-User Interaction in the Business Component Browser
6.3.4.1
Testing Master-Detail Coordination
6.3.4.2
Testing UI Control Hints
6.3.4.3
Testing Business Domain Layer Validation
6.3.4.4
Testing Alternate Language Message Bundles and Control Hints
6.3.4.5
Testing View Objects That Reference Entity Usages
6.3.4.6
Testing Row Creation and Default Value Generation
6.3.4.7
Testing That New Detail Rows Have Correct Foreign Keys
6.3.5
How to Test Multiuser Scenarios in the Business Component Browser
6.3.6
How to Customize Configuration Options Before Running the Browser
6.3.7
How to Enable ADF Business Components Debug Diagnostics
6.3.8
What Happens at Runtime: When View Objects and Entity Objects Cooperate
6.3.8.1
What Happens When a View Object Executes Its Query
6.3.8.2
What Happens When a View Row Attribute Is Modified
6.3.8.3
What Happens When a Foreign Key Attribute is Changed
6.3.8.4
What Happens When a Transaction is Committed
6.3.8.5
What Happens When a View Object Requeries Data
6.3.9
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
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.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
How to Set Preconditions for Validation
7.6.3
How to Set Transaction-Level Validation
7.6.4
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 RowSets of Rows
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 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 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
How to Change Your Application Module's Runtime Configuration
9.3.4
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 Filtering 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
Publishing Custom Service Methods to UI Clients
9.8.1
How to Publish a Custom Method on the Application Module's Client Interface
9.8.2
What Happens When You Publish Custom Service Methods
9.8.3
How to Generate Client Interfaces for View Objects and View Rows
9.8.4
What You May Need to Know About Method Signatures on the Client Interface
9.8.5
What You May Need to Know About Passing Information from the Data Model
9.9
Debugging the Application Module Using the Business Component Browser
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.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
How to Automatically Refresh the View Object of the View Accessor
10.4.7
What Happens at Runtime: When the Attribute Displays the List of Values
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
Integrating Service-Enabled 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
Remote Common Interface
11.2.2.2
Remote Service Schema File
11.2.2.3
Remote Service Definition File
11.2.2.4
Remote Server Class
11.2.2.5
connections.xml
11.2.3
What You May Need to Know About Method Signatures on the Service Interface
11.2.4
How to Service-Enable Individual View Objects
11.2.5
What Happens When You Create SDO Classes
11.2.5.1
Service Data Object Interface
11.2.5.2
Service Data Object Class
11.2.5.3
Service Data Object Schema File
11.2.5.4
Service Data Object Result Class and Interface
11.2.6
How to Expose a Declarative Find Operation Filtered By a Required Bind Variable
11.2.7
How to Expose a Custom Find Method Filtered By a Required Bind Variable
11.2.8
How to Set Preferences for Generating the Service Interface
11.2.9
How to Secure the Web Service
11.2.9.1
Enabling Authentication for the Web Service
11.2.9.2
Enabling Authorization for the Web Service
11.2.10
How to Test the Web Service Using Integrated WLS
11.2.11
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 Create Service-Enabled Entity Objects and View Objects
11.3.1.1
Creating Service-Enabled Entity Objects
11.3.1.2
Creating Service-Enabled View Objects
11.3.2
What Happens When You Create Service-Enabled Business Components
11.3.3
How to Update the Business Components Data Model
11.3.4
How to Configure the Service-Enabled Business Components Runtime
11.3.4.1
Adding the SDO Client Library to the Classpath
11.3.4.2
Registering the Business Components Service in the Consuming Application's connections.xml
11.3.5
How to Test the Service-Enabled Components in the Business Component Browser
11.3.6
What Happens at Runtime: When the Application Accesses the Published Application Module
11.3.7
What You May Need to Know About Service-Enabled Business Component Restrictions
11.3.8
What You May Need to Know About Service-Enabled Business Component Database Transactions
12
Using Oracle ADF Model in a Fusion Web Application
12.1
Introduction to ADF Data Binding
12.2
Exposing Application Modules with Oracle ADF Data Controls
12.2.1
How an Application Module Data Control Appears in the Data Controls Panel
12.2.1.1
How the Data Model and Service Methods Appear in the Data Controls Panel
12.2.1.2
How Transaction Control Operations Appear in the Data Controls Panel
12.2.1.3
How View Objects Appear in the Data Controls Panel
12.2.1.4
How Nested Application Modules Appear in the Data Controls Panel
12.2.2
How to Open the Data Controls Panel
12.2.3
How to Refresh the Data Controls Panel
12.2.4
Packaging a Data Control for Use in Another Project
12.3
Using the Data Controls Panel
12.3.1
How to Use the Data Controls Panel
12.3.2
What Happens When You Use the Data Controls Panel
12.3.3
What Happens at Runtime: How the Binding Context Works
12.4
Working with the DataBindings.cpx File
12.4.1
How JDeveloper Creates a DataBindings.cpx File
12.4.2
What Happens When JDeveloper Creates a DataBindings.cpx File
12.5
Configuring the ADF Binding Filter
12.5.1
How JDeveloper Configures the ADF Binding Filter
12.5.2
What Happens When JDeveloper Configures an ADF Binding Filter
12.5.3
What Happens at Runtime: How the ADF Binding Filter Works
12.6
Working with Page Definition Files
12.6.1
How JDeveloper Creates a Page Definition File
12.6.2
What Happens When JDeveloper Creates a Page Definition File
12.6.2.1
Bindings Binding Objects
12.6.2.2
Executable Binding Objects
12.7
Creating ADF Data Binding EL Expressions
12.7.1
How to Create an ADF Data Binding EL Expression
12.7.1.1
Opening the Expression Builder from the Property Inspector
12.7.1.2
Using the Expression Builder
12.7.2
What You May Need to Know About ADF Binding Properties
12.8
Using Simple UI First Development
12.8.1
How to Apply ADF Model Data Binding to Existing UI Components
12.8.2
What Happens When You Apply ADF Model Data Binding to UI Components
13
Integrating Web Services Into a Fusion Web Application
13.1
Introduction to Web Services in Fusion Web Applications
13.2
Calling a Web Service from an Application Module
13.2.1
How to Call an External Service Programmatically
13.2.1.1
Creating a Web Service Proxy Class to Programmatically Access the Service
13.2.1.2
Calling the Web Service Proxy Template to Invoke the Service
13.2.1.3
Calling a Web Service Method Using the Proxy Class in an Application Module
13.2.2
What Happens When You Create the Web Service Proxy
13.2.3
What Happens at Runtime: When You Call a Web Service Using a Web Service Proxy Class
13.2.4
What You May Need to Know About Web Service Proxies
13.2.4.1
Using a Try-Catch Block to Handle Web Service Exceptions
13.2.4.2
Separating Application Module and Web Services Transactions
13.2.4.3
Setting Browser Proxy Information
13.2.4.4
Invoking Application Modules with a Web Service Proxy Class
13.3
Creating Web Service Data Controls
13.3.1
How to Create a Web Service Data Control
13.3.2
How to Adjust the Endpoint for a Web Service Data Control
13.3.3
How to Refresh a Web Service Data Control
13.3.4
What You May Need to Know About Web Service Data Controls
13.4
Securing Web Service Data Controls
13.4.1
WS-Security Specification
13.4.2
Using Key Stores
13.4.3
How to Define Web Service Data Control Security
Part III Creating ADF Task Flows
14
Getting Started with ADF Task Flows
14.1
Introduction to Task Flows
14.1.1
Task Flow Advantages
14.1.2
Task Flow Types
14.1.2.1
ADF Unbounded Task Flows
14.1.2.2
ADF Bounded Task Flows
14.1.3
Control Flows
14.2
Creating Task Flows
14.2.1
How to Create an ADF Task Flow
14.2.2
How to Add an Activity to an ADF Task Flow
14.2.3
What Happens When You Add an Activity to an ADF Task Flow
14.2.4
How to Add Control Flows
14.2.5
How to Add a Wildcard Control Flow Rule
14.2.6
What Happens When You Create a Control Flow Rule
14.2.7
What Happens at Runtime
14.2.8
What Happens When You Create an ADF Task Flow
14.2.9
What Happens at Runtime: Using ADF Task Flows
14.2.10
What You May Need to Know About Managed Beans
14.2.11
What You May Need to Know About Memory Scopes
14.2.11.1
View Scope
14.2.11.2
Backing Bean Scope
14.3
Adding a Bounded Task Flow to a Page
14.4
Designating a Default Activity in an ADF Bounded Task Flow
14.5
Running ADF Task Flows
14.5.1
How to Run a Task Flow Definition That Contains Pages
14.5.2
How to Run a Task Flow Definition That Uses Page Fragments
14.5.3
How to Run a Task Flow Definition That Has Parameters
14.5.4
How to Run a JSF Page
14.5.5
How to Run an ADF Unbounded Task Flow
14.5.6
How to Set a Run Configuration for a Project
14.6
Setting Project Properties for ADF Task Flows
14.7
Refactoring to Create New ADF Task Flows and Templates
14.7.1
How to Create an ADF Bounded Task Flow from Selected Activities
14.7.2
How to Create a Task Flow from JSF Pages
14.7.3
How to Convert ADF Bounded Task Flows
14.8
What You Should Know About Task Flow Constraints
15
Working with Task Flow Activities
15.1
Introduction to Activity Types
15.2
Using View Activities
15.2.1
Adding a View Activity
15.2.2
Transitioning Between View Activities
15.2.2.1
How to Transition to a View Activity
15.2.2.2
What Happens When You Transition Between Activities
15.2.3
Bookmarking View Activities
15.2.3.1
How to Create a Bookmarkable View Activity
15.2.3.2
How to Specify HTTP Redirect
15.2.3.3
What Happens When You Designate a View as Bookmarkable
15.3
Using URL View Activities
15.3.1
Constructing a URL for Use Within a Portlet
15.4
Using Router Activities
15.5
Using Method Call Activities
15.5.1
How to Add a Method Call Activity
15.5.2
How to Specify Method Parameters and Return Values
15.5.3
What Happens When You Add a Method Call Activity
15.6
Using Task Flow Call Activities
15.6.1
How to Call an ADF Bounded Task Flow
15.6.2
How to Specify Input Parameters on a Task Flow Call Activity
15.6.3
How to Call an ADF Bounded Task Flow Located in Another Web Application
15.6.4
How to Call a Bounded Task Flow with a URL
15.6.5
Specifying a Parameter Converter
15.6.6
How to Specify Before and After Listeners
15.6.7
What Happens When You Add a Task Flow Call Activity
15.6.8
What Happens at Runtime: Using a Task Flow Call Activity
15.7
Using Task Flow Return Activities
15.8
Using Save Point Restore Activities
15.9
Using Parent Action Activities
16
Using Parameters in Task Flows
16.1
Introduction to Parameters in Task Flows
16.2
Passing Parameters to a View Activity
16.3
How to Pass Parameters to an ADF Bounded Task Flow
16.4
Sharing Data Control Instances
16.4.1
What You May Need to Know About Managing Transactions
16.5
Specifying Return Values
16.6
Specifying EL Binding Expressions
17
Using ADF Task Flows as Regions
17.1
Introduction to ADF Regions
17.1.1
How to Create an ADF Region
17.1.2
How to Add a Task Flow Binding Declaratively
17.1.3
How to Specify Parameters for an ADF Region
17.1.4
What Happens When You Create an ADF Region
17.1.5
What Happens at Runtime: How an ADF Region is Executed
17.1.6
How to Trigger Navigation of an ADF Region's Parent Task Flow
17.1.7
What You May Need to Know About Refreshing an ADF Region
17.1.8
What You May Need to Know About Returning from an ADF Region
17.1.9
What You May Need to Know About Page Fragments
17.1.10
What You May Need to Know about View Ports
17.1.11
What You May Need to Know about Securing ADF Regions
17.1.12
What You May Need to Know About Region Capabilities
17.2
Creating ADF Dynamic Regions
17.2.1
How to Create an ADF Dynamic Region
17.2.2
How to Override Parameter Values
17.2.3
What You Should Know about JSF LifeCycle Phases
17.3
Creating Dynamic Region Links
18
Creating Complex Task Flows
18.1
Introduction to Complex ADF Task Flows
18.2
Using Initializers and Finalizers
18.3
Managing Transactions
18.3.1
How to Enable Transactions in an ADF Bounded Task Flow
18.3.2
What Happens When You Specify Transaction Options
18.3.3
What You May Need to Know About Data Control Scoping with Task Flows
18.4
Reentering an ADF Bounded Task Flow
18.4.1
How to Set Reentry Behavior
18.4.2
How to Set Outcome-Dependent Options
18.4.3
What You Should Know About Managed Bean Values Upon Task Flow Reentry
18.5
Handling Exceptions
18.5.1
How to Designate an Activity as an Exception Handler
18.5.2
How to Handle Exceptions During Transactions
18.5.3
What Happens When You Designate an Exception Handler
18.5.4
What You May Need to Know About Handling Validation Errors
18.6
Saving for Later
18.6.1
How to Add Save For Later Capabilities
18.6.2
How to Restore Save Points
18.6.3
What You May Need to Know about Implicit and Explicit Save For Later
18.6.4
How to Enable Implicit Save for Later
18.6.5
What You May Need to Know About Application State
18.6.6
How to Use the Save Point Restore Finalizer
18.6.7
How to Set the Time-to-Live Period
18.6.8
What You Need to Know about Using Save for Later with BC4J
18.6.9
What You May Need to Know About Specifying the Correct JNDI Connection Name
18.7
Creating a Train
18.7.1
ADF Bounded Task Flows as Trains
18.7.2
Train Sequences
18.7.3
How to Create a Train
18.7.4
What You May Need to Know About Grouping Activities
18.7.5
What You May Need to Know About Grouping Activities in Child Task Flows
18.7.6
What You May Need To Know About Using Child Trains
18.7.7
What You May Need to Know About Branching
18.8
Running Multiple ADF Task Flows
18.8.1
Understanding How the ViewPortInstance Works in ADF Regions
18.9
Running an ADF Bounded Task Flow as a Modal Dialog
18.9.1
How to Run an ADF Bounded Task Flow in a Modal Dialog
18.9.2
How to Pass Back a Return Value
18.9.3
What You Should Know About Ctrl + N Support
18.10
Creating an ADF Task Flow Template
18.10.1
How to Copy and Reference an ADF Task Flow Template
18.10.2
How to Create an ADF Task Flow Template from Another Task Flow
18.10.3
How to Use an ADF Task Flow Template
18.10.4
How to Create an ADF Task Flow Template
18.10.5
What Happens When You Create an ADF Task Flow Template
18.10.6
What You May Need to Know About ADF Task Flow Templates That Use Bindings
18.11
Creating a Page Hierarchy
18.11.1
XML Menu Model
18.11.2
How to Create a Page Hierarchy
18.12
Specifying Bootstrap Configuration Files
18.13
Using BPEL with ADF Task Flows
18.13.1
How to Invoke a BPEL Process from an ADF Task Flow
18.13.2
How to Call an ADF Bounded Task Flow from BPEL
18.14
Using the adf-config.xml File to Configure ADF Controller
18.14.1
How to Specify Save for Later Settings
18.14.2
How to Validate ADF Controller Metadata
18.14.3
How to Search for adf-config.xml
18.14.4
Replicating Memory Scopes in a Server-Cluster Environment
Part IV Creating a Databound Web User Interface
19
Getting Started with Your Web Interface
19.1
Introduction to Developing a Web Application with ADF Faces
19.2
Using Page Templates
19.2.1
How to Use ADF Data Binding in ADF Page Templates
19.2.2
What Happens When You Use ADF Model Layer Bindings on a Page Template
19.2.3
What Happens at Runtime: How Pages Use Templates
19.3
Creating a Web Page
19.4
Using a Managed Bean in a Fusion Web Application
19.4.1
How to Use a Managed Bean to Store Information
19.4.2
What Happens When You Create a Managed Bean
20
Understanding the Fusion Page Lifecycle
20.1
Introduction to the Fusion Page Lifecycle
20.2
The JSF and ADF Page Lifecycles
20.2.1
What You May Need to Know About Using the Refresh Property Correctly
20.2.2
What You May Need to Know About Task Flows and the Lifecycle
20.3
Object Scope Lifecycles
20.3.1
What You May Need to Know About Object Scopes and Task Flows
20.4
Customizing the ADF Page Lifecycle
20.4.1
How to Create a Custom Phase Listener
20.4.2
How to Register a Listener Globally
20.4.3
What You May Need to Know About Listener Order
20.4.4
How To Register a Lifecycle Listener for a Single Page
20.4.5
What You May Need to Know About Extending RegionController for Page Fragments
21
Creating a Basic Databound Page
21.1
Introduction to Creating a Basic Databound Page
21.2
Using Attributes to Create Text Fields
21.2.1
How to Create a Text Field
21.2.2
What Happens When You Create a Text Field
21.2.2.1
Creating and Using Iterator Bindings
21.2.2.2
Creating and Using Value Bindings
21.2.2.3
Using EL Expressions to Bind UI Components
21.3
Creating a Basic Form
21.3.1
How to Create a Form
21.3.2
What Happens When You Create a Form
21.4
Incorporating Range Navigation into Forms
21.4.1
How to Insert Navigation Controls into a Form
21.4.2
What Happens When You Create Command Buttons
21.4.2.1
Action Bindings for Built-in Navigation Operations
21.4.2.2
Iterator RangeSize Attribute
21.4.2.3
EL Expressions Used to Bind to Navigation Operations
21.4.3
What You May Need to Know About Automatic Partial Page Rendering
21.4.4
What Happens at Runtime: How Action Events and Action Listeners Work
21.4.5
What You May Need to Know About the Browser Back Button and Navigating Through Records
21.5
Creating a Form to Edit an Existing Record
21.5.1
How to Create Edit Forms
21.5.2
What Happens When You Use Built-in Operations to Change Data
21.6
Creating an Input Form
21.6.1
How to Create an Input Form Using a Task Flow
21.6.2
What Happens When You Create an Input Form Using a Task Flow
21.6.3
What Happens At Runtime: CreateInsert Action from the Method Activity
21.6.4
What You May Need to Know About Displaying Sequence Numbers
21.7
Using a Dynamic Form to Determine Data to Display at Runtime
21.7.1
How to Use Dynamic Forms
21.7.2
What Happens When You Use Dynamic Components
21.7.3
What Happens at Runtime: How Attribute Values are Dynamically Determined
21.8
Modifying the UI Components and Bindings on a Form
21.8.1
How to Modify the UI Components and Bindings
21.8.2
What Happens When You Modify Attributes and Bindings
22
Creating ADF Databound Tables
22.1
Introduction to Adding Tables
22.2
Creating a Basic Table
22.2.1
How to Create a Basic Table
22.2.2
What Happens When You Create a Table
22.2.2.1
Iterator and Value Bindings for Tables
22.2.2.2
Code on the JSF Page for an ADF Faces Table
22.2.3
What You May Need to Know About Setting the Current Row in a Table
22.3
Creating an Editable Table
22.3.1
How to Create an Editable Table
22.3.2
What Happens When You Create an Editable Table
22.4
Creating an Input Table
22.4.1
How to Create an Input Table
22.4.2
What Happens When You Create an Input Table
22.4.3
What Happens at Runtime: How CreateInsert and Partial Page Refresh Work
22.4.4
What You May Need to Know About Creating a Row and Sorting Columns
22.4.5
What You May Need to Know About Create and CreateInsert
22.5
Providing Multiselect Capabilities
22.5.1
How to Add Multiselect Capabilities
22.5.2
What Happens at Runtime: How an Operation Executes Against Multiple Rows
22.6
Modifying the Attributes Displayed in the Table
22.6.1
How to Modify the Displayed Attributes
22.6.2
How to Change the Binding for a Table
22.6.3
What Happens When You Modify Bindings or Displayed Attributes
23
Displaying Master-Detail Data
23.1
Introduction to Displaying Master-Detail Data
23.2
Identifying Master-Detail Objects on the Data Controls Panel
23.3
Using Tables and Forms to Display Master-Detail Objects
23.3.1
How to Display Master-Detail Objects in Tables and Forms
23.3.2
What Happens When You Create Master-Detail Tables and Forms
23.3.2.1
Code Generated in the JSF Page
23.3.2.2
Binding Objects Defined in the Page Definition File
23.3.3
What Happens at Runtime: ADF Iterator for Master-Detail Tables and Forms
23.3.4
What You May Need to Know About Displaying Master-Detail Widgets on Separate Pages
23.4
Using Trees to Display Master-Detail Objects
23.4.1
How to Display Master-Detail Objects in Trees
23.4.2
What Happens When You Create an ADF Databound Tree
23.4.2.1
Code Generated in the JSF Page
23.4.2.2
Binding Objects Defined in the Page Definition File
23.4.3
What Happens at Runtime: Displaying an ADF Databound Tree
23.5
Using Tree Tables to Display Master-Detail Objects
23.5.1
How to Display Master-Detail Objects in Tree Tables
23.5.2
What Happens When You Create a Databound Tree Table
23.5.2.1
Code Generated in the JSF Page
23.5.2.2
Binding Objects Defined in the Page Definition File
23.5.3
What Happens at Runtime: Events
23.5.4
Using the TargetIterator Property
23.6
Using Selection Events with Trees and Tables
23.6.1
How to Use Selection Events with Trees and Tables
23.6.2
What Happens at Runtime: RowKeySet Objects and SelectionEvent Events
24
Creating Databound Selection Lists and Shuttles
24.1
Introduction to Selection Lists and Shuttles
24.2
Creating a Selection List
24.2.1
How to Create a Single Selection List
24.2.2
How to Create a Model-Driven List
24.2.3
How to Create a Selection List Containing Fixed Values
24.2.4
How to Create a Selection List Containing Dynamically Generated Values
24.2.5
What Happens When You Create a Model-Driven Selection List
24.2.6
What Happens When You Create a Fixed Selection List
24.2.7
What You May Need to Know About Values in a Selection List
24.2.8
What Happens When You Create a Dynamic Selection List
24.3
Creating a List with Navigation List Binding
24.4
Creating a Databound Shuttle
25
Creating Databound ADF Data Visualization Components
25.1
Introduction to Creating ADF Data Visualization Components
25.2
Creating Databound Graphs
25.2.1
How to Create a Graph
25.2.2
What Happens When You Use the Data Controls Panel to Create a Graph
25.2.3
What You May Need to Know About Using a Graph's Row Selection Listener for Master-Detail Processing
25.3
Creating Databound Gauges
25.3.1
How to Create a Databound Dial Gauge
25.3.2
What Happens When You Create a Dial Gauge from a Data Control
25.3.3
How to Create a Databound Status Meter Gauge Set
25.3.4
What Happens When You Create a Status Meter Gauge from a Data Control
25.4
Creating Databound Pivot Tables
25.4.1
How to Create a Pivot Table
25.4.2
What Happens When You Use the Data Controls Panel to Create a Pivot Table
25.4.2.1
Bindings for Pivot Tables
25.4.2.2
Code on the JSF Page for an ADF Pivot Table
25.4.3
What You May Need to Know About Aggregating Attributes in the Pivot Table
25.4.3.1
Default Aggregation of Duplicate Data Rows
25.4.3.2
Custom Aggregation of Duplicate Rows
25.4.4
What You May Need to Know About Specifying an Initial Sort for a Pivot Table
25.5
Creating Databound Geographic Maps
25.5.1
How to Create a Geographic Map with a Point Theme
25.5.2
How to Create Point Style Items for a Point Theme
25.5.3
What Happens When You Create a Geographic Map with a Point Theme
25.5.3.1
Binding XML for a Point Theme
25.5.3.2
XML Code on the JSF Page for a Geographic Map and Point Theme
25.5.4
What You May Need to Know About Adding Custom Point Style Items to a Map Point Theme
25.5.5
How to Add a Databound Color Theme to a Geographic Map
25.5.6
What Happens When You Add a Color Theme to a Geographic Map
25.5.6.1
Binding XML for a Color Theme
25.5.6.2
XML Code on the JSF Page for a Color Theme
25.5.7
What You May Need to Know About Customizing Colors in a Map Color Theme
25.5.8
How to Add a Databound Pie Graph Theme to a Geographic Map
25.5.9
What Happens When You Add a Pie Graph Theme to a Geographic Map
25.5.9.1
Binding XML for a Pie Graph Theme
25.5.9.2
Code on the JSF Page for a Pie Graph Theme
25.6
Creating Databound Gantt Charts
25.6.1
How to Create a Databound Project Gantt Chart
25.6.2
What Happens When You Create a Project Gantt Chart from a Data Control
25.6.3
What You May Need to Know About Summary Tasks in a Project Gantt Chart
25.6.4
What You May Need to Know About Percent Complete in a Project Gantt Chart
25.6.5
What You May Need to Know About Variance in a Project Gantt Chart
25.6.6
How to Create a Databound Resource Utilization Gantt Chart
25.6.7
What Happens When You Create a Resource Utilization Gantt Chart
25.6.8
How to Create a Databound Scheduling Gantt Chart
25.6.9
What Happens When You Create a Scheduling Gantt Chart
25.7
Creating Databound Hierarchy Viewers
25.7.1
How to Create a Databound Hierarchy Viewer
25.7.2
What Happens When You Create a Databound Hierarchy Viewer
26
Creating ADF Databound Search Forms
26.1
Introduction to Creating Search Forms
26.1.1
Query Search Forms
26.1.2
Quick Query Search Forms
26.1.3
Named Bind Variables in Query Search Forms
26.1.4
Filtered Table and Query-by-Example Searches
26.1.5
Implicit and Named View Criteria
26.1.6
List of Values (LOV) Input Fields
26.2
Creating Query Search Forms
26.2.1
How to Create a Query Search Form with a Results Table or Tree Table
26.2.2
How to Create a Query Search Form and Add a Results Component Later
26.2.3
How to Persist Saved Searches into MDS
26.2.4
How to Set Default Search Binding Behavior
26.2.5
What You May Need To Know About Dependent Criterion
26.2.6
What Happens When You Create a Query Form
26.2.7
What Happens at Runtime: Creating a Search Form
26.3
Setting Up Search Form Properties
26.3.1
How to Set Search Form Properties on the View Criteria
26.3.2
How to Set Search Form Properties on the Query Component
26.3.3
How to Create Custom Operators or Remove Standard Operators
26.4
Creating Quick Query Search Forms
26.4.1
How to Create a Quick Query Search Form with a Results Table or Tree Table
26.4.2
How to Create a Quick Query Search Form and Add a Results Component Later
26.4.3
How to Set the Quick Query Layout Format
26.4.4
What Happens When You Create a Quick Query Search Form
26.4.5
What Happens at Runtime: Creating a Quick Query
26.5
Creating Standalone Filtered Search Tables from Named View Criteria
27
Creating More Complex Pages
27.1
Introduction to More Complex Pages
27.2
Creating Command Components to Execute Methods
27.2.1
How to Create a Command Component Bound to a Custom Method
27.2.2
What Happens When You Create Command Components Using a Method
27.2.2.1
Defining Method Action Binding
27.2.2.2
Using Parameters in a Method
27.2.2.3
Adding ADF Faces Component Code to JSF Page
27.2.2.4
Using EL Expressions to Bind to Methods
27.2.2.5
Using the Return Value from a Method Call
27.2.3
What Happens at Runtime: Binding a Method to a Command Button
27.3
Setting Parameter Values Using a Command Component
27.3.1
How to Set Parameters Using setPropertyListener Within a Command Component
27.3.2
What Happens When You Set Parameters
27.3.3
What Happens at Runtime: Using setPropertyListener for a Command Component
27.4
Overriding Declarative Methods
27.4.1
How to Override a Declarative Method
27.4.2
What Happens When You Override a Declarative Method
27.5
Using the ADF Faces Calendar Component
27.5.1
How to Use the ADF Faces Calendar
27.5.2
What Happens When You Create a Calendar
27.5.3
What Happens at Runtime: How the Calendar Binding Works
27.6
Creating Contextual Events
27.6.1
How to Create Contextual Events
27.6.2
How to Manually Create the Event Map
27.6.3
How to Register a Custom Event Dispatcher
27.6.4
What Happens When You Create Contextual Events
27.6.5
What Happens at Runtime: Contextual Events
27.7
Adding ADF Model Layer Validation
27.7.1
How to Add Validation
27.7.2
What Happens at Runtime: Model Validation Rules
27.8
Displaying Error Messages
27.9
Customizing Error Handling
27.9.1
How to Customize the Detail Portion of a Message
27.9.2
How to Write an Error Handler to Deal with Multiple Threads
28
Designing a Page Using Placeholder Data Controls
28.1
Introduction to Placeholder Data Controls
28.2
Creating Placeholder Data Controls
28.2.1
How to Create a Placeholder Data Control
28.2.2
What Happens When You Create a Placeholder Data Control
28.3
Creating Placeholder Data Types
28.3.1
How to Create a Placeholder Data Type
28.3.2
What Happens When You Create a Placeholder Data Type
28.3.3
How to Configure a Placeholder Data Type Attribute to Be an LOV
28.3.3.1
Configuring an Attribute to Be a Fixed LOV
28.3.3.2
Configuring an Attribute to Be a Dynamic LOV
28.3.4
How to Create Master-Detail Data Types
28.3.5
What Happens When You Create a Master-Detail Data Type
28.3.6
How to Add Sample Data
28.3.6.1
Adding Sample Data Manually
28.3.6.2
Importing Sample Data
28.3.7
What Happens When You Add Sample Data
28.4
Using Placeholder Data Controls
28.4.1
Limitations of Placeholder Data Controls
28.4.2
Creating Layout
28.4.3
Creating a Search Form
28.4.4
Binding Components
28.4.5
Rebinding Components
28.4.6
Packaging Placeholder Data Controls to ADF Library JARs
Part V Completing Your Application
29
Enabling ADF Security in a Fusion Web Application
29.1
Introduction to Oracle ADF Security
29.1.1
Integration of Oracle ADF Security and Java Security
29.1.2
Summary of Oracle ADF Security
29.2
Oracle ADF Security Process Overview
29.3
Enabling Oracle ADF Security
29.3.1
How to Enable Oracle ADF Security
29.3.2
What Happens When You Enable Oracle ADF Security
29.3.3
What Happens When You Generate a Default Form-Based Login Page
29.3.4
What You May Need to Know About the Configure ADF Security Wizard
29.3.5
What You May Need to Know About ADF Authentication
29.3.6
What You May Need to Know About the Built-In test-all Role
29.3.7
What You May Need to Know About the valid-users Role
29.4
Creating Application Roles
29.4.1
How to Create Application Roles
29.4.2
What Happens When You Create Application Roles
29.4.3
What You May Need to Know About Enterprise Roles and Application Roles
29.5
Defining ADF Security Policies
29.5.1
How to Make an ADF Resource Public
29.5.2
What Happens When You Make an ADF Resource Public
29.5.3
What Happens at Runtime: How the Built-in Roles Are Used
29.5.4
How to Define Policies for ADF Bounded Task Flows
29.5.5
How to Define Policies for Web Pages That Reference a Page Definition
29.5.6
What Happens When You Define the Security Policy
29.5.7
What Happens at Runtime: How ADF Security Policies Are Enforced
29.5.8
What You May Need to Know About Defining Policies for Pages with No ADF Bindings
29.5.9
How to Use Regular Expressions to Define Policies on Groups of Resources
29.5.10
How to Define Policies for Data
29.5.10.1
Defining Permission Maps on ADF Entity Objects
29.5.10.2
Granting Permissions on ADF Entity Objects
29.6
Creating Test Users
29.6.1
How to Create Test Users in JDeveloper
29.6.2
What Happens When You Create Test Users
29.6.3
How to Associate Test Users with Application Roles
29.6.4
What Happens When You Configure Application Roles
29.7
Creating a Login Page
29.7.1
How to Create a Login Link Component and Add it to a Public Web Page
29.7.2
How to Create a Login Page
29.7.2.1
Creating Login Code for the Backing Bean
29.7.2.2
Creating an Oracle ADF Faces-Based Login Page
29.7.2.3
Configuring the web.xml File for an Oracle ADF Faces-Based Login Page
29.7.2.4
Ensuring That the Login Page Is Public
29.7.3
How to Create a Public Welcome Page
29.7.3.1
Ensuring That the Welcome Page Is Public
29.7.3.2
Adding Login and Logout Links
29.7.3.3
Hiding Links to Secured Pages
29.7.4
How to Redirect a User After Authentication
29.8
Testing Security in JDeveloper
29.8.1
How to Configure, Deploy, and Run a Secure Application in JDeveloper
29.8.2
What Happens When You Configure Security Deployment Options
29.8.3
How to Use the Built-In test-all Application Role
29.8.4
What Happens at Runtime: How Oracle ADF Security Handles Authentication
29.8.5
What Happens at Runtime: How Oracle ADF Security Handles Authorization
29.9
Preparing the Secure Application for Deployment
29.9.1
How to Remove the test-all Role from the Application Policy Store
29.9.2
How to Remove Test Users from the Application Identity Store
29.10
Disabling Oracle ADF Security
29.10.1
How to Disable Oracle ADF Security
29.10.2
What Happens When You Disable ADF Security
29.11
Advanced Topics and Best Practices
29.11.1
Using Expression Language (EL) with ADF Security
29.11.1.1
How to Evaluate Policies Using EL
29.11.1.2
What You May Need to Know About Delayed Evaluation of EL
29.11.2
How to Evaluate Policies Using Custom JAAS Permissions and EL
29.11.3
Getting Information from the Oracle ADF Security Context
29.11.3.1
How to Determine Whether Security Is Enabled
29.11.3.2
How to Determine Whether the User Is Authenticated
29.11.3.3
How to Determine the Current User Name
29.11.3.4
How to Determine Membership of a Java EE Security Role
29.11.3.5
How to Determine Permission Using Java
29.11.4
Best Practices for Working with Oracle ADF Security
30
Testing and Debugging ADF Components
30.1
Introduction to Oracle ADF Debugging
30.2
Correcting Simple Oracle ADF Compilation Errors
30.3
Correcting Simple Oracle ADF Runtime Errors
30.4
Using the ADF Logger and Business Component Browser
30.4.1
How to Turn On Diagnostic Logging
30.4.2
How to Create an Oracle ADF Debugging Configuration
30.4.3
How to Use the Business Component Browser with the Debugger
30.5
Using the ADF Declarative Debugger
30.5.1
Using ADF Source Code with the Debugger
30.5.2
How to Set Up the ADF Source User Library
30.5.3
How to Add the ADF Source Library to a Project
30.5.4
How to Use the EL Expression Evaluator
30.5.5
How to View and Export Stack Trace Information
30.6
Setting ADF Declarative Breakpoints
30.6.1
How to Set and Use Task Flow Activity Breakpoints
30.6.2
How to Set and Use Page Definition Executable Breakpoints
30.6.3
How to Set and Use Page Definition Action Binding Breakpoints
30.6.4
How to Set and Use Page Definition Attribute Value Binding Breakpoints
30.6.5
How to Set and Use ADF Lifecycle Phase Breakpoints
30.6.6
How to Use the ADF Structure Window
30.6.7
How to Use the ADF Data Window
30.7
Setting Java Code Breakpoints
30.7.1
How to Set Java Breakpoints on Classes and Methods
30.7.2
How to Optimize Use of the Source Editor
30.7.3
How to Set Breakpoints and Debug Using ADF Source Code
30.7.4
How to Use Debug Libraries for Symbolic Debugging
30.7.5
How to Use Different Kinds of Java Code Breakpoints
30.7.6
How to Edit Breakpoints for Improved Control
30.7.7
How to Filter Your View of Class Members
30.7.8
How to Use Common Oracle ADF Breakpoints
30.8
Regression Testing with JUnit
30.8.1
How to Obtain the JUnit Extension
30.8.2
How to Create a JUnit Test Case
30.8.3
How to Create a JUnit Test Fixture
30.8.4
How to Create a JUnit Test Suite
30.8.5
How to Create a Business Components Test Suite
30.8.6
How to a Create Business Component Test Fixture
30.8.7
How to Run a JUnit Test Suite as Part of an Ant Build Script
31
Refactoring a Fusion Web Application
31.1
Introduction to Refactoring a Fusion Web Application
31.2
Renaming Files
31.3
Moving JSF Pages
31.4
Refactoring pagedef.xml Bindings Objects
31.5
Refactoring ADF Business Components
31.6
Refactoring Attributes
31.7
Refactoring Named Elements
31.8
Refactoring ADF Task Flows
31.9
Refactoring the DataBindings.cpx File
31.10
Refactoring Across Abstraction Layers
31.11
Refactoring Limitations
31.12
Refactoring the .jpx Project File
32
Reusing Application Components
32.1
Introduction to Reusable Components
32.1.1
Creating Reusable Components
32.1.1.1
Naming Conventions
32.1.1.2
The Naming Process for the ADF Library JAR Deployment Profile
32.1.1.3
Keeping the Relevant Project
32.1.1.4
Selecting the Relevant Technology Scope
32.1.1.5
Selecting Paths and Folders
32.1.1.6
Including Connections Within Reusable Components
32.1.2
Using the Resource Palette
32.1.3
Extension Libraries
32.2
Packaging a Reusable ADF Component into an ADF Library
32.2.1
How to Package a Component into an ADF Library JAR
32.2.2
What Happens When You Package a Project to an ADF Library JAR
32.2.2.1
Application Modules
32.2.2.2
Data Controls
32.2.2.3
Task Flows
32.2.2.4
Page Templates
32.2.2.5
Declarative Components
32.3
Adding ADF Library Components into Projects
32.3.1
How to Add an ADF Library JAR into a Project using the Resource Palette
32.3.2
How to Add an ADF Library JAR into a Project Manually
32.3.3
What Happens When You Add an ADF Library JAR to a Project
32.3.4
What You May Need to Know About Using ADF Library Components
32.3.4.1
Using Data Controls
32.3.4.2
Using Application Modules
32.3.4.3
Using Business Components
32.3.4.4
Using Task Flows
32.3.4.5
Using Page Templates
32.3.4.6
Using Declarative Components
32.3.5
What You May Need to Know About Differentiating ADF Library Components
32.3.6
What Happens at Runtime: Adding ADF Libraries
32.4
Removing an ADF Library JAR from a Project
32.4.1
How to Remove an ADF Library JAR from a Project Using the Resource Palette
32.4.2
How to Remove an ADF Library JAR from a Project Manually
33
Customizing Applications with MDS
33.1
Introduction to Customization and MDS
33.1.1
Customizations and Layers
33.1.2
Static and Dynamic Customization Content
33.2
Developing a Customizable Application
33.2.1
How to Create Customization Classes
33.2.1.1
Customization Classes
33.2.1.2
Implementing the getValue() Method in Your Customization Class
33.2.1.3
Creating a Customization Class
33.2.1.4
Making Your Customization Classes Available to JDeveloper
33.2.2
What You May Need to Know About Customization Classes
33.2.3
How to Enable Seeded Customizations for View Projects
33.2.4
How to Enable Seeded Customizations in Existing Pages
33.2.5
How to Configure the adf-config.xml file
33.2.6
What Happens When You Create a Customizable Application
33.2.7
What You May Need to Know About Customizable Objects and Applications
33.3
Customizing an Application
33.3.1
Introducing the Customization Developer Role
33.3.2
The Tip Layer
33.3.3
How to Configure Customization Layers
33.3.4
How to Customize Metadata in JDeveloper
33.3.5
What Happens When You Customize an Application
33.3.6
How to Customize ADF Library Artifacts in JDeveloper
33.3.7
What Happens When You Customize ADF Library Artifacts
33.3.8
What Happens at Runtime in a Customized Application
33.3.9
What You May Need to Know About Customized Applications
33.3.9.1
Packaging and Deploying Customized Applications
33.3.9.2
Customization and Integrated Source Control
33.3.9.3
Editing Resource Bundles in Customized Applications
33.4
Extended Metadata and Annotation Properties
33.4.1
How to Edit Annotation Properties
33.4.2
How to Enable Customization for Design Time at Runtime
33.5
Enabling Runtime Modification of Customization Configuration
34
Allowing User Customizations at Runtime
34.1
Introduction to Allowing User Customizations
34.2
Enabling Runtime User Customizations for a Fusion Application
34.2.1
How to Enable Change Persistence
34.2.2
What Happens When You Enable User Customizations
34.3
Configuring User Customizations
34.3.1
How to Configure Change Persistence
34.3.2
What Happens When You Configure Change Persistence
34.4
Controlling User Customizations in Individual JSF Pages
34.4.1
How to Implement User Customizations on a JSF Page
34.4.2
What Happens at Runtime
34.4.3
What You May Need to Know About Using Change Persistence on Templates and Regions
34.5
Implementing Custom User Customizations
34.5.1
Change Persistence Framework API
34.5.2
How to Create Code for Custom User Customizations
34.6
Creating Implicit Change Persistence in Custom Components
34.6.1
How to Set Implicit Change Persistence For Attribute Values that Use Events
34.6.2
How to Set Implicit Change Persistence For Other Attribute Values
35
Deploying Fusion Web Applications
35.1
Introduction to Deploying Fusion Web Applications
35.2
Creating a Connection to the Target Application Server
35.3
Creating a Deployment Profile
35.3.1
How to Add Customization Classes into a JAR
35.3.2
How to Create Deployment Profiles
35.3.3
How to View and Change Deployment Profile Properties
35.4
Creating and Editing Deployment Descriptors
35.4.1
How to Create Deployment Descriptors
35.4.2
How to View or Change Deployment Descriptor Properties
35.4.3
How to Create or Configure the application.xml file for WebLogic Compatibility
35.4.4
How to Create or Configure the web.xml file for WebLogic Compatibility
35.4.5
How to Create Deployment Descriptors for Applications with ADF Faces Components
35.5
Deploying Applications with Security Credentials, Identities, and Policies
35.6
Installing the ADF Runtime to the WebLogic Installation
35.6.1
How to Install the ADF Runtime into an Existing WebLogic Server Using the Oracle Fusion Middleware Application Developer Installer
35.6.2
How to Install the ADF Runtime into an Existing WebLogic Server Using the Oracle Installer
35.6.3
What You May Need to Know About ADF Libraries
35.7
Creating and Extending Oracle WebLogic Server Domains
35.7.1
How to Create an Oracle WebLogic Server Domain for Oracle ADF
35.7.2
How to Extend an Oracle WebLogic Server Domain for Oracle ADF
35.7.3
How to Set Up Remote Oracle WebLogic Managed Servers for ADF
35.8
Creating a JDBC Data Source for an Oracle WebLogic Server
35.9
Deploying the Application
35.9.1
How to Deploy to a WebLogic Server from JDeveloper
35.9.2
How to Create an EAR File for Deployment
35.9.3
How to Deploy an Application Using Ant
35.9.4
How to Deploy a MAR Deployment Profile to the Integrated WLS
35.10
Testing the Application and Verifying Deployment
Part VI Advanced Topics
36
Advanced Business Components Techniques
36.1
Globally Extending ADF Business Components Functionality
36.1.1
How To Create a Framework Extension Class
36.1.2
What Happens When You Create a Framework Extension Class
36.1.3
How to Base an ADF Component on a Framework Extension Class
36.1.4
How to Define Framework Extension Classes for All New Components
36.1.5
How to Define Framework Extension Classes for All New Projects
36.1.6
What Happens When You Base a Component on a Framework Extension Class
36.1.6.1
XML-Only Components
36.1.6.2
Components with Custom Java Classes
36.1.7
What You May Need to Know About Updating the Extends Clause in Custom Component Java Files
36.2
Creating a Layer of Framework Extensions
36.2.1
How to Create Your Layer of Framework Extension Layer Classes
36.2.2
How to Package Your Framework Extension Layer in a JAR File
36.2.3
How to Create a Library Definition for Your Framework Extension JAR File
36.3
Customizing Framework Behavior with Extension Classes
36.3.1
How to Access Runtime Metadata For View Objects and Entity Objects
36.3.2
How to Implement Generic Functionality Using Runtime Metadata
36.3.3
How to Implement Generic Functionality Driven by Custom Properties
36.3.4
How to Configure Design Time Custom Property Names
36.3.5
What You May Need to Know About the Kinds of Attributes
36.3.6
What You May Need to Know About Custom Properties
36.4
Creating Generic Extension Interfaces
36.5
Invoking Stored Procedures and Functions
36.5.1
How to Invoke Stored Procedures with No Arguments
36.5.2
How to Invoke Stored Procedure with Only IN Arguments
36.5.3
How to Invoke Stored Function with Only IN Arguments
36.5.4
How to Call Other Types of Stored Procedures
36.6
Accessing the Current Database Transaction
36.7
Working with Libraries of Reusable Business Components
36.7.1
How To Create a Reusable Library of Business Components
36.7.2
How To Import a Package of Reusable Components from a Library
36.7.3
How to Remove an Imported Package from a Project
36.7.4
What Happens When You Import a Package of Reusable Components from a Library
36.7.5
What You May Need to Know About Imported Projects
36.8
Customizing Business Components Error Messages
36.8.1
How to Customize Base ADF Business Components Error Messages
36.8.2
What Happens When You Customize Base ADF Business Components Error Messages
36.8.3
How to Customize Error Messages for Database Constraint Violations
36.8.4
How to Implement a Custom Constraint Error Handling Routine
36.8.4.1
Creating a Custom Database Transaction Framework Extension Class
36.8.4.2
Configuring an Application Module to Use a Custom Database Transaction Class
36.9
Creating Extended Components Using Inheritance
36.9.1
How To Create a Component That Extends Another
36.9.2
How To Extend a Component After Creation
36.9.3
What Happens When You Create a Component That Extends Another
36.9.3.1
Understanding an Extended Component's XML Descriptor
36.9.3.2
Understanding Java Code Generation for an Extended Component
36.9.4
What You May Need to Know
36.9.4.1
You Can Use Parent Classes and Interfaces to Work with Extended Components
36.9.4.2
Class Extends is Disabled for Extended Components
36.9.4.3
Interesting Aspects You Can Extend for Key Component Types
36.9.4.4
Extended Components Have Attribute Indices Relative to Parent
36.10
Substituting Extended Components in a Delivered Application
36.10.1
How To Substitute an Extended Component
36.10.2
What Happens When You Substitute
36.10.3
How to Enable the Substituted Components in the Base Application
37
Advanced Entity Object Techniques
37.1
Creating Custom, Validated Data Types Using Domains
37.1.1
What Are Domains?
37.1.2
How To Create a Domain
37.1.3
What Happens When You Create a Domain
37.1.4
What You May Need to Know About Domains
37.1.4.1
Using Domains for Entity and View Object Attributes
37.1.4.2
Validate Method Should Throw DataCreationException If Sanity Checks Fail
37.1.4.3
String Domains Aggregate a String Value
37.1.4.4
Other Domains Extend Existing Domain Type
37.1.4.5
Simple Domains are Immutable Java Classes
37.1.4.6
Creating Domains for Oracle Object Types When Useful
37.1.4.7
Quickly Navigating to the Domain Class
37.1.4.8
Domains Get Packaged in the Common JAR
37.1.4.9
Entity and View Object Attributes Inherit Custom Domain Properties
37.1.4.10
Domain Settings Cannot Be Less Restrictive at Entity or View Level
37.2
Updating a Deleted Flag Instead of Deleting Rows
37.2.1
How to Update a Deleted Flag When a Row is Removed
37.2.2
Forcing an Update DML Operation Instead of a Delete
37.3
Using Update Batching
37.4
Advanced Entity Association Techniques
37.4.1
Modifying Association SQL Clause to Implement Complex Associations
37.4.2
Exposing View Link Accessor Attributes at the Entity Level
37.4.3
Optimizing Entity Accessor Access By Retaining the Row Set
37.5
Basing an Entity Object on a PL/SQL Package API
37.5.1
How to Create an Entity Object Based on a View
37.5.2
What Happens When You Create an Entity Object Based on a View
37.5.3
Centralizing Details for PL/SQL-Based Entities into a Base Class
37.5.4
Implementing the Stored Procedure Calls for DML Operations
37.5.5
Adding Select and Lock Handling
37.5.5.1
Updating PLSQLEntityImpl Base Class to Handle Lock and Select
37.5.5.2
Implementing Lock and Select for the Product Entity
37.5.5.3
Refreshing the Entity Object After RowInconsistentException
37.6
Basing an Entity Object on a Join View or Remote DBLink
37.7
Using Inheritance in Your Business Domain Layer
37.7.1
Understanding When Inheritance Can be Useful
37.7.2
How To Create Entity Objects in an Inheritance Hierarchy
37.7.2.1
Start By Identifying the Discriminator Column and Distinct Values
37.7.2.2
Identify the Subset of Attributes Relevant to Each Kind of Entity
37.7.2.3
Creating the Base Entity Object in an Inheritance Hierarchy
37.7.2.4
Creating a Subtype Entity Object in an Inheritance Hierarchy
37.7.3
How to Add Methods to Entity Objects in an Inheritance Hierarchy
37.7.3.1
Adding Methods Common to All Entity Objects in the Hierarchy
37.7.3.2
Overriding Common Methods in a Subtype Entity
37.7.3.3
Adding Methods Specific to a Subtype Entity
37.7.4
What You May Need to Know About Using Inheritance
37.7.4.1
Sometimes You Need to Introduce a New Base Entity
37.7.4.2
Finding Subtype Entities by Primary Key
37.7.4.3
You Can Create View Objects with Polymorphic Entity Usages
37.8
Controlling Entity Posting Order to Avoid Constraint Violations
37.8.1
Understanding the Default Post Processing Order
37.8.2
How Compositions Change the Default Processing Ordering
37.8.3
Overriding postChanges() to Control Post Order
37.8.3.1
Observing the Post Ordering Problem First Hand
37.8.3.2
Forcing the Supplier to Post Before the Product
37.8.3.3
Understanding Associations Based on DBSequence-Valued Primary Keys
37.8.3.4
Refreshing References to DBSequence-Assigned Foreign Keys
37.9
Implementing Custom Validation Rules
37.9.1
How To Create a Custom Validation Rule
37.9.2
Adding a Design Time Bean Customizer for Your Rule
37.9.3
Registering and Using a Custom Rule in JDeveloper
37.10
Creating New History Types
37.10.1
How to Create New History Types
37.10.2
How to Remove a History Type
38
Advanced View Object Techniques
38.1
Advanced View Object Concepts and Features
38.1.1
Limiting the View Object Max Fetch Size to Fetch the First n Rows
38.1.2
Maintaining New Row Consistency in View Objects Based on the Same Entity
38.1.2.1
What Happens at Runtime When View Link Consistency is Enabled
38.1.2.2
How to Change the Default View Link Consistency Setting
38.1.2.3
How to Use a RowMatch to Qualify Which New, Unposted Rows Get Added to a Row Set
38.1.2.4
What You May Need to Know About the Dynamic WHERE Clause and View Link Consistency
38.1.3
Understanding View Link Accessors Versus Data Model View Link Instances
38.1.3.1
Enabling a Dynamic Detail Row Set with Active Master-Detail Coordination
38.1.3.2
Accessing a Stable Detail Row Set Using View Link Accessor Attributes
38.1.3.3
Accessor Attributes Create Distinct Row Sets Based on an Internal View Object
38.1.4
Presenting and Scrolling Data a Page at a Time Using the Range
38.1.5
Efficiently Scrolling Through Large Result Sets Using Range Paging
38.1.5.1
Understanding How to Oracle Supports "TOP-N" Queries
38.1.5.2
How to Enable Range Paging for a View Object
38.1.5.3
What Happens When You Enable Range Paging
38.1.5.4
What Happens When View Rows are Cached When Using Range Paging
38.1.5.5
How to Scroll to a Given Page Number Using Range Paging
38.1.5.6
Estimating the Number of Pages in the Row Set Using Range Paging
38.1.5.7
Understanding the Tradeoffs of Using a Range Paging Mode
38.1.6
Setting Up a Data Model with Multiple Masters
38.1.7
Understanding When You Can Use Partial Keys with findByKey()
38.1.8
Creating Dynamic Attributes to Store UI State
38.1.9
Working with Multiple Row Sets and Row Set Iterators
38.1.10
Optimizing View Link Accessor Access By Retaining the Row Set
38.2
Tuning Your View Objects for Best Performance
38.2.1
Use Bind Variables for Parameterized Queries
38.2.1.1
Use Bind Variables to Avoid Re-parsing of Queries
38.2.1.2
Use Bind Variables to Prevent SQL-Injection Attacks
38.2.2
Consider Using Entity-Based View Objects for Read-Only Data
38.2.3
Use SQL Tracing to Identify Ill-Performing Queries
38.2.4
Consider the Appropriate Tuning Settings for Every View Object
38.2.4.1
Set the Database Retrieval Options Appropriately
38.2.4.2
Consider Whether Fetching One Row at a Time is Appropriate
38.2.4.3
Specify a Query Optimizer Hint if Necessary
38.2.5
Creating View Objects at Design Time
38.2.6
Use Forward Only Mode to Avoid Caching View Rows
38.3
Generating Custom Java Classes for a View Object
38.3.1
How To Generate Custom Classes
38.3.1.1
Generating Bind Variable Accessors
38.3.1.2
Generating View Row Attribute Accessors
38.3.1.3
Exposing View Row Accessors to Clients
38.3.1.4
Configuring Default Java Generation Preferences
38.3.2
What Happens When You Generate Custom Classes
38.3.2.1
Seeing and Navigating to Custom Java Files
38.3.3
What You May Need to Know About Custom Classes
38.3.3.1
About the Framework Base Classes for a View Object
38.3.3.2
You Can Safely Add Code to the Custom Component File
38.3.3.3
Attribute Indexes and InvokeAccessor Generated Code
38.4
Working Programmatically with Multiple Named View Criteria
38.4.1
Applying One or More Named View Criteria
38.4.2
Removing All Applied Named View Criteria
38.4.3
Using the Named Criteria at Runtime
38.5
Performing In-Memory Sorting and Filtering of Row Sets
38.5.1
Understanding the View Object's SQL Mode
38.5.2
Sorting View Object Rows In Memory
38.5.2.1
Combining setSortBy and setQueryMode for In-Memory Sorting
38.5.2.2
Extensibility Points for In-Memory Sorting
38.5.3
Performing In-Memory Filtering with View Criteria
38.5.4
Performing In-Memory Filtering with RowMatch
38.5.4.1
Applying a RowMatch to a View Object
38.5.4.2
Using RowMatch to Test an Individual Row
38.5.4.3
How a RowMatch Affects Rows Fetched from the Database
38.6
Using View Objects to Work with Multiple Row Types
38.6.1
Working with Polymorphic Entity Usages
38.6.2
How To Create a View Object with a Polymorphic Entity Usage
38.6.3
What Happens When You Create a View Object with a Polymorphic Entity Usage
38.6.4
What You May Need to Know
38.6.4.1
Your Query Must Limit Rows to Expected Entity Subtypes
38.6.4.2
Exposing Selected Entity Methods in View Rows Using Delegation
38.6.4.3
Creating New Rows With the Desired Entity Subtype
38.6.5
Working with Polymorphic View Rows
38.6.6
How to Create a View Object with Polymorphic View Rows
38.6.7
What You May Need to Know
38.6.7.1
Selecting Subtype-Specific Attributes in Extended View Objects
38.6.7.2
Delegating to Subtype-Specific Methods After Overriding the Entity Usage
38.6.7.3
Working with Different View Row Interface Types in Client Code
38.6.7.4
View Row Polymorphism and Polymorphic Entity Usage are Orthogonal
38.7
Reading and Writing XML
38.7.1
How to Produce XML for Queried Data
38.7.2
What Happens When You Produce XML
38.7.3
What You May Need to Know
38.7.3.1
Controlling XML Element Names
38.7.3.2
Controlling Element Suppression for Null-Valued Attributes
38.7.3.3
Printing or Searching the Generated XML Using XPath
38.7.3.4
Using the Attribute Map For Fine Control Over Generated XML
38.7.3.5
Use the Attribute Map Approach with Bi-Directional View Links
38.7.3.6
Transforming Generated XML Using an XSLT Stylesheet
38.7.3.7
Generating XML for a Single Row
38.7.4
How to Consume XML Documents to Apply Changes
38.7.5
What Happens When You Consume XML Documents
38.7.5.1
How ViewObject.readXML() Processes an XML Document
38.7.5.2
Using readXML() to Processes XML for a Single Row
38.8
Using Programmatic View Objects for Alternative Data Sources
38.8.1
How to Create a Read-Only Programmatic View Object
38.8.2
How to Create an Entity-Based Programmatic View Object
38.8.3
Key Framework Methods to Override for Programmatic View Objects
38.8.4
How to Create a View Object on a REF CURSOR
38.8.4.1
The Overridden create() Method
38.8.4.2
The Overridden executeQueryForCollection() Method
38.8.4.3
The Overridden createRowFromResultSet() Method
38.8.4.4
The Overridden hasNextForCollectionMethod()
38.8.4.5
The Overridden releaseUserDataForCollection() Method
38.8.4.6
The Overridden getQueryHitCount() Method
38.9
Creating a View Object with Multiple Updatable Entities
38.10
Declaratively Preventing Insert, Update, and Delete
39
Application State Management
39.1
Understanding Why State Management is Necessary
39.1.1
Examples of Multi-Step Tasks
39.1.2
Stateless HTTP Protocol Complicates Stateful Applications
39.1.3
How Cookies Are Used to Track a User Session
39.1.4
Performance and Reliability Impact of Using HttpSession
39.2
About Fusion Web Application State Management
39.2.1
Basic Architecture of the Save for Later Facility
39.2.2
Basic Architecture of the Application Module State Management Facility
39.2.2.1
Understanding When Passivation and Activation Occurs
39.2.2.2
How Passivation Changes When Optional Failover Mode is Enabled
39.2.2.3
About State Management Release Levels
39.3
Using Save For Later
39.4
Setting the Application Module Release Level at Runtime
39.4.1
How to Set Unmanaged Level
39.4.2
How to Set Reserved Level
39.4.3
How to Set Managed Level
39.4.4
How to Set Release Level in a JSF Backing Bean
39.4.5
How to Set Release Level in an ADF PagePhaseListener
39.4.6
How to Set Release Level in an ADF PageController
39.4.7
How to Set Release Level in an Custom ADF PageLifecycle
39.5
What Model State Is Saved and When It Is Cleaned Up
39.5.1
What State is Saved?
39.5.2
Where is the Model State Saved?
39.5.2.1
How Database-Backed Passivation Works
39.5.2.2
Controlling the Schema Where the State Management Table Resides
39.5.2.3
Configuring the Type of Passivation Store
39.5.3
When is the Model State Cleaned Up?
39.5.3.1
Previous Snapshot Removed When Next One Taken
39.5.3.2
Passivation Snapshot Removed on Unmanaged Release
39.5.3.3
Passivation Snapshot Retained in Failover Mode
39.5.4
Cleaning Up Temporary Storage Tables
39.6
Timing Out the HttpSession
39.6.1
How to Configure the Implicit Timeout Due to User Inactivity
39.6.2
How to Code an Explicit HttpSession Timeout
39.7
Managing Custom User-Specific Information
39.7.1
How to Passivate Custom User-Specific Information
39.7.1.1
What Happens When You Passivate Custom Information
39.8
Managing the State of View Objects
39.8.1
How to Manage the State of View Objects
39.8.2
What You May Need to Know About Passivating View Objects
39.8.3
How to Manage the State of Transient View Objects and Attributes
39.8.4
What You May Need to Know About Passivating Transient View Objects
39.8.5
How to Use Transient View Objects to Store Session-level Global Variables
39.9
Using State Management for Middle-Tier Savepoints
39.9.1
How to Use State Management for Savepoints
39.10
Testing to Ensure Your Application Module is Activation-Safe
39.10.1
Understanding the jbo.ampool.doampooling Configuration Parameter
39.10.2
Disabling Application Module Pooling to Test Activation
39.11
Keeping Pending Changes in the Middle Tier
39.11.1
How to Set Applications to Use Optimistic Locking
39.11.2
How to Avoid Clashes Using the postChanges() Method
39.11.3
How to Use the Reserved Level For Pending Database States
40
Tuning Application Module Pools
40.1
Introduction to Application Module Pooling
40.1.1
Types of Pools Created When Running the Fusion Web Application
40.1.1.1
Application Module Pools
40.1.1.2
Database Connection Pools
40.1.2
Understanding Application Module and Connection Pools
40.1.2.1
Single Oracle Application Server Instance, Single Oracle WebLogic Server Instance, Single JVM
40.1.2.2
Multiple Oracle Application Server Instances, Single Oracle WebLogic Server Instance, Multiple JVMs
40.2
Setting Pool Configuration Parameters
40.2.1
How to Set Configuration Properties Declaratively
40.2.2
What Happens When You Set Configuration Properties Declaratively
40.2.3
How to Set Configuration Properties as System Parameters
40.2.4
How to Programmatically Set Configuration Properties
40.2.5
What You May Need to Know About Configuration Property Scopes
40.2.6
What You May Need to Know About How Database and Application Module Pools Cooperate
40.2.7
What You May Need to Know About Application Module Pool Parameters
40.2.7.1
Pool Behavior Parameters
40.2.7.2
Pool Sizing Parameters
40.2.7.3
Pool Cleanup Parameters
40.2.8
What You May Need to Know About Database Connection Pool Parameters
40.3
Initializing Database State and Pooling Considerations
40.3.1
How to Set Database State Per User
40.3.2
What You May Need to Know About Database User State and jbo.doconnectionpooling = true
41
Using the Active Data Service
41.1
Introduction to the Active Data Service
41.2
Using the Active Data Service in an Application
41.2.1
How to Configure the Active Data Service
41.2.2
How to Configure Components to Display Active Data
41.2.3
What Happens When You Use the Active Data Service
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
Oracle ADF Permission Grants
D
ADF Equivalents of Common Oracle Forms Triggers
D.1
Validation & 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
Glossary
Index