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 Creating Use Cases
  • 1.3.3 Designing Application Control and Navigation Using ADF Task Flows
  • 1.3.4 Identifying Shared Resources
  • 1.3.5 Creating ADF Business Components to Access Data
    • 1.3.5.1 Creating a Layer of Business Domain Objects for Tables
    • 1.3.5.2 Building the Business Services
    • 1.3.5.3 Testing Business Services with the Business Component Browser
  • 1.3.6 Implementing the User Interface with JSF
  • 1.3.7 Data Binding with Oracle ADF Model Layer
  • 1.3.8 Validation and Error Handling
  • 1.3.9 Adding Security
  • 1.3.10 Testing and Debugging the Web Client Application
  • 1.3.11 Refactoring Application Artifacts
  • 1.3.12 Deploying 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

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 Application
  • 2.2.3 How to Run the Fusion Order Demo Application
• 2.3 Taking a Look at the Fusion Order Demo Application
  • 2.3.1 Anonymous Browsing
    • 2.3.1.1 Viewing Product Details
    • 2.3.1.2 Browsing the Product Catalog
    • 2.3.1.3 Searching for Products
  • 2.3.2 The Login Process
  • 2.3.3 The Ordering Process
  • 2.3.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 Working Programmatically with Entity Objects and Associations
  • 4.11.1 How to Find an Entity Object by Primary Key
  • 4.11.2 How to Access an Associated Entity Using the Accessor Attribute
  • 4.11.3 How to Update or Remove an Existing Entity Row
  • 4.11.4 How to Create a New Entity Row
  • 4.11.5 Assigning the Primary Key Value Using an Oracle Sequence
• 4.12 Generating Custom Java Classes for an Entity Object
  • 4.12.1 How to Generate Custom Classes
  • 4.12.2 What Happens When You Generate Custom Classes
  • 4.12.3 What Happens When You Generate Entity Attribute Accessors
  • 4.12.4 How to Navigate to Custom Java Files
  • 4.12.5 What You May Need to Know About Custom Java Classes
    • 4.12.5.1 About the Framework Base Classes for an Entity Object
    • 4.12.5.2 You Can Safely Add Code to the Custom Component File
    • 4.12.5.3 Configuring Default Java Generation Preferences
    • 4.12.5.4 Attribute Indexes and InvokeAccessor Generated Code
  • 4.12.6 Programmatic Example for Comparison Using Custom Entity Classes
• 4.13 Adding Transient and Calculated Attributes to an Entity Object
  • 4.13.1 How to Add a Transient Attribute
  • 4.13.2 What Happens When You Add a Transient Attribute
  • 4.13.3 How to Base a Transient Attribute On a Groovy Expression
  • 4.13.4 What Happens When You Base a Transient Attribute on Groovy Expression
  • 4.13.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 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 View Objects in Declarative SQL Mode
  • 5.7.1 How to Create SQL-Independent View Objects with Declarative SQL Mode
  • 5.7.2 How to Filter Declarative SQL-Based View Objects When Table Joins Apply
  • 5.7.3 How to Filter Master-Detail Related View Objects with Declarative SQL Mode
  • 5.7.4 How to Force Attribute Queries for Declarative SQL Mode View Objects
  • 5.7.5 What Happens When You Create a View Object in Declarative SQL Mode
  • 5.7.6 What Happens at Runtime
  • 5.7.7 What You May Need to Know About Overriding Declarative SQL Mode Defaults
  • 5.7.8 What You May Need to Know About Working Programmatically with Declarative SQL Mode View Objects
• 5.8 Working with View Objects in Expert Mode
  • 5.8.1 How to Customize SQL Statements in Expert Mode
  • 5.8.2 How to Name Attributes in Expert Mode
  • 5.8.3 What Happens When You Enable Expert Mode
  • 5.8.4 What You May Need to Know About Expert Mode
    • 5.8.4.1 Expert Mode Provides Limited Attribute Mapping Assistance
    • 5.8.4.2 Expert Mode Drops Custom Edits
    • 5.8.4.3 Expert Mode Ignores Changes to SQL Expressions
    • 5.8.4.4 Expert Mode Returns Error for SQL Calculations that Change Entity Attributes
    • 5.8.4.5 Expert Mode Retains Formatting of SQL Statement
    • 5.8.4.6 Expert Mode Wraps Queries as Inline Views
    • 5.8.4.7 Limitation of Inline View Wrapping at Runtime
    • 5.8.4.8 Expert Mode Changes May Affect Dependent Objects
• 5.9 Working with Bind Variables
  • 5.9.1 How to Add Bind Variables to a View Object Definition
  • 5.9.2 What Happens When You Add Named Bind Variables
  • 5.9.3 How to Test Named Bind Variables
  • 5.9.4 How to Add a WHERE Clause with Named Bind Variables at Runtime
  • 5.9.5 How to Set Existing Bind Variable Values at Runtime
  • 5.9.6 What Happens at Runtime
  • 5.9.7 What You May Need to Know About Named Bind Variables
    • 5.9.7.1 An Error Related to Clearing Bind Variables
    • 5.9.7.2 A Helper Method to Remove Named Bind Variables
    • 5.9.7.3 Errors Related to Naming Bind Variables
    • 5.9.7.4 Default Value of NULL for Bind Variables
• 5.10 Working with Named View Criteria
  • 5.10.1 How to Create Named View Criteria Declaratively
  • 5.10.2 How to Set User Interface Hints on View Criteria
  • 5.10.3 How to Test View Criteria Using the Business Component Browser
  • 5.10.4 How to Create View Criteria Programmatically
  • 5.10.5 What Happens at Runtime
  • 5.10.6 What You May Need to Know About the View Criteria API
    • 5.10.6.1 Referencing Attribute Names in View Criteria
    • 5.10.6.2 Referencing Bind Variables in View Criteria
    • 5.10.6.3 Altering Compound Search Conditions Using Multiple View Criteria Rows
    • 5.10.6.4 Searching for a Row Whose Attribute Value Is NULL Value
    • 5.10.6.5 Searching Case-Insensitively
    • 5.10.6.6 Clearing View Criteria in Effect
  • 5.10.7 What You May Need to Know About Query-By-Example Criteria
• 5.11 Working with List of Values (LOV) in View Object Attributes
  • 5.11.1 How to Define a Single LOV-Enabled View Object Attribute
  • 5.11.2 How to Define Cascading Lists for LOV-Enabled View Object Attributes
  • 5.11.3 How to Set User Interface Hints on a View Object LOV-Enabled Attribute
  • 5.11.4 How to Test LOV-Enabled Attributes Using the Business Component Browser
  • 5.11.5 What Happens When You Define an LOV for a View Object Attribute
  • 5.11.6 What Happens at Runtime: When an LOV Queries the List Data Source
  • 5.11.7 What You May Need to Know About Lists
    • 5.11.7.1 Inheritance of AttributeDef Properties from Parent View Object Attributes
    • 5.11.7.2 Using Validators to Validate Attribute Values
• 5.12 Defining Attribute Control Hints for View Objects
  • 5.12.1 How to Add Attribute Control Hints
  • 5.12.2 What Happens When You Add Attribute Control Hints
  • 5.12.3 What You May Need to Know About Resource Bundles
• 5.13 Adding Calculated and Transient Attributes to a View Object
  • 5.13.1 How to Add a SQL-Calculated Attribute
  • 5.13.2 What Happens When You Add a SQL-Calculated Attribute
  • 5.13.3 How to Add a Transient Attribute
  • 5.13.4 What Happens When You Add a Transient Attribute
  • 5.13.5 Adding Java Code in the View Row Class to Perform Calculation
  • 5.13.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.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.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 Order
  • 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.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.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.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.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.3.5 What You May Need to Know About Application Module Connections
• 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 What You May Need to Know About Application Module Diagrams
    • 9.5.3.1 Using the Diagram for Editing the Application Module
    • 9.5.3.2 Controlling Display Options
    • 9.5.3.3 Filtering Method Names
    • 9.5.3.4 Showing Related Objects and Implementation Files
    • 9.5.3.5 Publishing the Application Module Diagram
    • 9.5.3.6 Testing 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.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 Shared Application Module Instances
    • 10.2.3.1 Design Time Scope of the Shared Application Module
    • 10.2.3.2 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
  • 10.4.8 What You May Need to Know About Lists
    • 10.4.8.1 Inheritance of AttributeDef Properties from Parent View Object Attributes
    • 10.4.8.2 Using Validators to Validate Attribute Values
• 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 Using Oracle ADF Model in a Fusion Web Application

• 11.1 Introduction to ADF Data Binding
• 11.2 Exposing Application Modules with Oracle ADF Data Controls
  • 11.2.1 How an Application Module Data Control Appears in the Data Controls Panel
    • 11.2.1.1 How the Data Model and Service Methods Appear in the Data Controls Panel
    • 11.2.1.2 How Transaction Control Operations Appear in the Data Controls Panel
    • 11.2.1.3 How View Objects Appear in the Data Controls Panel
    • 11.2.1.4 How Nested Application Modules Appear in the Data Controls Panel
  • 11.2.2 How to Open the Data Controls Panel
  • 11.2.3 How to Refresh the Data Control
  • 11.2.4 Packaging a Data Control for Use in Another Project
• 11.3 Using the Data Controls Panel
  • 11.3.1 How to Use the Data Controls Panel
  • 11.3.2 What Happens When You Use the Data Controls Panel
  • 11.3.3 What Happens at Runtime: How the Binding Context Works
• 11.4 Working with the DataBindings.cpx File
  • 11.4.1 How JDeveloper Creates a DataBindings.cpx File
  • 11.4.2 What Happens When JDeveloper Creates a DataBindings.cpx File
• 11.5 Configuring the ADF Binding Filter
  • 11.5.1 How JDeveloper Configures the ADF Binding Filter
  • 11.5.2 What Happens When JDeveloper Configures an ADF Binding Filter
  • 11.5.3 What Happens at Runtime: How the ADF Binding Filter Works
• 11.6 Working with Page Definition Files
  • 11.6.1 How JDeveloper Creates a Page Definition File
  • 11.6.2 What Happens When JDeveloper Creates a Page Definition File
    • 11.6.2.1 Bindings Binding Objects
    • 11.6.2.2 Executable Binding Objects
• 11.7 Creating ADF Data Binding EL Expressions
  • 11.7.1 How to Create an ADF Data Binding EL Expression
    • 11.7.1.1 Opening the Expression Builder from the Property Inspector
    • 11.7.1.2 Using the Expression Builder
  • 11.7.2 What You May Need to Know About ADF Binding Properties
• 11.8 Using Simple UI First Development
  • 11.8.1 How to Apply ADF Model Data Binding to Existing UI Components
  • 11.8.2 What Happens When You Apply ADF Model Data Binding to UI Components

12 Integrating Web Services Into a Fusion Web Application

• 12.1 Introduction to Web Services in Fusion Web Applications
• 12.2 Calling a Web Service from an Application Module
  • 12.2.1 How to Call an External Service Programmatically
    • 12.2.1.1 Creating a Web Service Proxy Class to Programmatically Access the Service
    • 12.2.1.2 Calling the Web Service Proxy Template to Invoke the Service
    • 12.2.1.3 Calling a Web Service Method Using the Proxy Class in an Application Module
  • 12.2.2 What Happens When You Create the Web Service Proxy
  • 12.2.3 What Happens at Runtime: When You Call a Web Service Using a Web Service Proxy Class
  • 12.2.4 What You May Need to Know About Web Service Proxies
    • 12.2.4.1 Using a Try-Catch Block to Handle Web Service Exceptions
    • 12.2.4.2 Separating Application Module and Web Services Transactions
    • 12.2.4.3 Setting Browser Proxy Information
    • 12.2.4.4 Invoking Application Modules with a Web Service Proxy Class
• 12.3 Creating Web Service Data Controls
  • 12.3.1 How to Create a Web Service Data Control
  • 12.3.2 How to Adjust the Endpoint for a Web Service Data Control
  • 12.3.3 What You May Need to Know About Web Service Data Controls
• 12.4 Securing Web Service Data Controls
  • 12.4.1 WS-Security Specification
  • 12.4.2 How to Create and Use Key Stores
    • 12.4.2.1 Creating a Key Store
    • 12.4.2.2 Requesting a Certificate
    • 12.4.2.3 Exporting a Public Key Certificate
  • 12.4.3 How to Define Web Service Data Control Security
    • 12.4.3.1 Setting Authentication
    • 12.4.3.2 Setting Digital Signatures
    • 12.4.3.3 Setting Encryption and Decryption
    • 12.4.3.4 Using a Key Store

Part III Creating ADF Task Flows

13 Getting Started with ADF Task Flows

• 13.1 Introduction to ADF Task Flows
  • 13.1.1 Task Flow Advantages
  • 13.1.2 Task Flow Types
    • 13.1.2.1 ADF Unbounded Task Flows
    • 13.1.2.2 ADF Bounded Task Flows
  • 13.1.3 Control Flows
• 13.2 Creating Task Flows
  • 13.2.1 How to Create an ADF Task Flow
  • 13.2.2 How to Add an Activity to an ADF Task Flow
  • 13.2.3 How to Add Control Flows
  • 13.2.4 How to Add a Wildcard Control Flow Rule
  • 13.2.5 What Happens When You Create a Control Flow Rule
  • 13.2.6 What Happens at Runtime
  • 13.2.7 What Happens When You Create an ADF Task Flow
  • 13.2.8 What Happens at Runtime: Using ADF Task Flows
  • 13.2.9 What You May Need to Know About Managed Beans
  • 13.2.10 What You May Need to Know About Memory Scopes
    • 13.2.10.1 View Scope
    • 13.2.10.2 Backing Bean Scope
• 13.3 Adding a Bounded Task Flow to a Page
• 13.4 Designating a Default Activity in an ADF Bounded Task Flow
• 13.5 Running ADF Task Flows
  • 13.5.1 How to Run a Task Flow Definition That Contains Pages
  • 13.5.2 How to Run a Task Flow Definition That Uses Page Fragments
  • 13.5.3 How to Run a Task Flow Definition That Has Parameters
  • 13.5.4 How to Run a JSF Page
  • 13.5.5 How to Run an ADF Unbounded Task Flow
  • 13.5.6 How to Set a Run Configuration for a Project
• 13.6 Setting Project Properties for ADF Task Flows
• 13.7 Refactoring to Create New ADF Task Flows and Templates
  • 13.7.1 How to Create an ADF Bounded Task Flow from Selected Activities
  • 13.7.2 How to Create a Task Flow from JSF Pages
  • 13.7.3 How to Convert ADF Bounded Task Flows
• 13.8 What You Should Know About Task Flow Constraints

14 Working with Task Flow Activities

• 14.1 Introduction to Activity Types
• 14.2 Using View Activities
  • 14.2.1 Adding a View Activity
  • 14.2.2 Transitioning Between View Activities
    • 14.2.2.1 How to Transition to a View Activity
    • 14.2.2.2 What Happens When You Transition Between Activities
  • 14.2.3 Bookmarking View Activities
    • 14.2.3.1 How to Create a Bookmarkable View Activity
    • 14.2.3.2 How to Specify HTTP Redirect
    • 14.2.3.3 What Happens When You Designate a View as Bookmarkable
• 14.3 Using URL View Activities
  • 14.3.1 Constructing a URL for Use Within a Portlet
• 14.4 Using Router Activities
• 14.5 Using Method Call Activities
  • 14.5.1 How to Add a Method Call Activity
  • 14.5.2 How to Specify Method Parameters and Return Values
  • 14.5.3 What Happens When You Add a Method Call Activity
• 14.6 Using Task Flow Call Activities
  • 14.6.1 How to Call an ADF Bounded Task Flow
  • 14.6.2 How to Specify Input Parameters on a Task Flow Call Activity
  • 14.6.3 How to Call an ADF Bounded Task Flow Located in Another Web Application
  • 14.6.4 How to Call a Bounded Task Flow with a URL
  • 14.6.5 Specifying a Parameter Converter
  • 14.6.6 How to Specify Before and After Listeners
  • 14.6.7 What Happens When You Add a Task Flow Call Activity
  • 14.6.8 What Happens at Runtime: Using a Task Flow Call Activity
• 14.7 Using Task Flow Return Activities
• 14.8 Using Save Point Restore Activities
• 14.9 Using Parent Action Activities

15 Using Parameters in Task Flows

• 15.1 Passing Parameters to a View Activity
• 15.2 Passing Parameters to an ADF Bounded Task Flow
• 15.3 Sharing Data Control Instances
  • 15.3.1 What You May Need to Know About Managing Transactions
• 15.4 Specifying Return Values
• 15.5 Specifying EL Binding Expressions

16 Using ADF Task Flows as Regions

• 16.1 Introduction to ADF Regions
  • 16.1.1 How to Create an ADF Region
  • 16.1.2 How to Add a Task Flow Binding Declaratively
  • 16.1.3 How to Specify Parameters for an ADF Region
  • 16.1.4 What Happens When You Create an ADF Region
  • 16.1.5 What Happens at Runtime: Executing an ADF Region
  • 16.1.6 How to Trigger Navigation of an ADF Region's Parent Task Flow
  • 16.1.7 What You May Need to Know About Refreshing an ADF Region
  • 16.1.8 What You May Need to Know About Returning from an ADF Region
  • 16.1.9 What You May Need to Know About Page Fragments
  • 16.1.10 What You May Need to Know about ViewPorts
  • 16.1.11 What You May Need to Know about Securing ADF Regions
• 16.2 Creating ADF Dynamic Regions
  • 16.2.1 How to Create an ADF Dynamic Region
  • 16.2.2 How to Override Parameter Values
• 16.3 Creating Dynamic Region Links

17 Creating Complex Task Flows

• 17.1 Using Initializers and Finalizers
• 17.2 Managing Transactions
  • 17.2.1 How to Enable Transactions in an ADF Bounded Task Flow
  • 17.2.2 What Happens When You Specify Transaction Options
• 17.3 Reentering an ADF Bounded Task Flow
  • 17.3.1 How to Set Reentry Behavior
  • 17.3.2 How to Set Outcome-Dependent Options
  • 17.3.3 What You Should Know About Managed Bean Values Upon Task Flow Reentry
• 17.4 Handling Exceptions
  • 17.4.1 Handling Exceptions During Transactions
  • 17.4.2 What Happens When You Designate an Exception Handler
  • 17.4.3 What You May Need to Know About Handling Validation Errors
• 17.5 Saving for Later
  • 17.5.1 How to Add Save For Later Capabilities
  • 17.5.2 How to Restore Save Points
  • 17.5.3 How to Use the Save Point Restore Finalizer
  • 17.5.4 How to Enable Implicit Save For Later
  • 17.5.5 How to Set the Time-to-Live Period
  • 17.5.6 What You Need to Know about Using Save for Later with BC4J
• 17.6 Creating a Train
  • 17.6.1 ADF Bounded Task Flows as Trains
  • 17.6.2 Train Sequences
  • 17.6.3 How to Create a Train
  • 17.6.4 What You May Need to Know About Grouping Activities
  • 17.6.5 What You May Need to Know About Grouping Activities in Child Task Flows
  • 17.6.6 What You May Need To Know About Using Child Trains
  • 17.6.7 What You May Need to Know About Branching
• 17.7 Running an ADF Bounded Task Flow as a Modal Dialog
  • 17.7.1 How to Run an ADF Bounded Task Flow in a Modal Dialog
  • 17.7.2 How to Pass Back a Return Value
• 17.8 Creating an ADF Task Flow Template
  • 17.8.1 Copying and Referencing an ADF Task Flow Template
  • 17.8.2 Creating an ADF Task Flow Template from Another Task Flow
  • 17.8.3 How to Use an ADF Task Flow Template
  • 17.8.4 How to Create an ADF Task Flow Template
  • 17.8.5 What Happens When You Create an ADF Task Flow Template
  • 17.8.6 What You Need to Know About ADF Task Flow Templates That Use Bindings
• 17.9 Creating a Page Hierarchy
  • 17.9.1 XML Menu Model
  • 17.9.2 How to Create a Page Hierarchy
• 17.10 How to Specify Bootstrap Configuration Files
• 17.11 Using the adf-config.xml File to Configure ADF Controller
  • 17.11.1 Specifying Save for Later Settings
  • 17.11.2 Validating ADF Controller Metadata
  • 17.11.3 Searching for adf-config.xml
  • 17.11.4 Replicating Memory Scopes in a Server-Cluster Environment

Part IV Creating a Databound Web User Interface

18 Getting Started with Your Web Interface

• 18.1 Introduction to Developing a Web Application with ADF Faces
• 18.2 Using Page Templates
  • 18.2.1 How to Use ADF Data Binding in ADF Page Templates
  • 18.2.2 What Happens When You Use ADF Model Layer Bindings on a Page Template
  • 18.2.3 What Happens at Runtime: How Pages Use Templates
• 18.3 Creating a Web Page
• 18.4 Using a Managed Bean in a Fusion Web Application
  • 18.4.1 How to Use a Managed Bean to Store Information
  • 18.4.2 What Happens When You Create a Managed Bean

19 Understanding the Fusion Page Lifecycle

• 19.1 Introduction to the Fusion Page Lifecycle
• 19.2 The JSF and ADF Page Lifecycles
  • 19.2.1 What You May Need to Know About Using the Refresh Property Correctly
  • 19.2.2 What You May Need to Know About Task Flows and the Lifecycle
• 19.3 Object Scope Lifecycles
  • 19.3.1 What You May Need to Know About Object Scopes and Task Flows
• 19.4 Customizing the ADF Page Lifecycle
  • 19.4.1 How to Create a Custom Phase Listener
  • 19.4.2 How to Register a Listener Globally
  • 19.4.3 What You May Need to Know About Listener Order
  • 19.4.4 How To Register a Lifecycle Listener for a Single Page
  • 19.4.5 What You May Need to Know About Extending RegionController for Page Fragments

20 Creating a Basic Databound Page

• 20.1 Introduction to Creating a Basic Databound Page
• 20.2 Using Attributes to Create Text Fields
  • 20.2.1 How to Create a Text Field
  • 20.2.2 What Happens When You Create a Text Field
    • 20.2.2.1 Creating and Using Iterator Bindings
    • 20.2.2.2 Creating and Using Value Bindings
    • 20.2.2.3 Using EL Expressions to Bind UI Components
• 20.3 Creating a Basic Form
  • 20.3.1 How to Create a Form
  • 20.3.2 What Happens When You Create a Form
• 20.4 Incorporating Range Navigation into Forms
  • 20.4.1 How to Insert Navigation Controls into a Form
  • 20.4.2 What Happens When You Create Command Buttons
    • 20.4.2.1 Using Action Bindings for Built-in Navigation Operations
    • 20.4.2.2 Iterator RangeSize Attribute
    • 20.4.2.3 Using EL Expressions to Bind to Navigation Operations
    • 20.4.2.4 Using Automatic Partial Page Rendering
  • 20.4.3 What Happens at Runtime: How Action Events and Action Listeners Work
  • 20.4.4 What You May Need to Know About the Browser Back Button and Navigating Through Records
• 20.5 Creating a Form to Edit an Existing Record
  • 20.5.1 How to Create Edit Forms
  • 20.5.2 What Happens When You Use Built-in Operations to Change Data
• 20.6 Creating an Input Form
  • 20.6.1 How to Create an Input Form Using a Task Flow
  • 20.6.2 What Happens When You Create an Input Form Using a Task Flow
  • 20.6.3 What Happens At Runtime: CreateInsert Action from the Method Activity
  • 20.6.4 What You May Need to Know About Displaying Sequence Numbers
• 20.7 Using a Dynamic Form to Determine Data to Display at Runtime
  • 20.7.1 How to Use Dynamic Forms
  • 20.7.2 What Happens When You Use Dynamic Components
  • 20.7.3 What Happens at Runtime: How Attribute Values are Dynamically Determined
• 20.8 Modifying the UI Components and Bindings on a Form
  • 20.8.1 How to Modify the UI Components and Bindings
  • 20.8.2 What Happens When You Modify Attributes and Bindings

21 Creating ADF Databound Tables

• 21.1 Introduction to Adding Tables
• 21.2 Creating a Basic Table
  • 21.2.1 How to Create a Basic Table
  • 21.2.2 What Happens When You Create a Table
    • 21.2.2.1 Iterator and Value Bindings for Tables
    • 21.2.2.2 Code on the JSF Page for an ADF Faces Table
  • 21.2.3 What You May Need to Know About Setting the Current Row in a Table
• 21.3 Creating an Editable Table
  • 21.3.1 How to Create an Editable Table
  • 21.3.2 What Happens When You Create an Editable Table
• 21.4 Creating an Input Table
  • 21.4.1 How to Create an Input Table
  • 21.4.2 What Happens When You Create an Input Table
  • 21.4.3 What Happens at Runtime: How CreateInsert and Partial Page Refresh Work
  • 21.4.4 What You May Need to Know About Create and CreateInsert
• 21.5 Providing Multiselect Capabilities
  • 21.5.1 How to Add Multiselect Capabilities
  • 21.5.2 What Happens at Runtime: How an Operation Executes Against Multiple Rows
• 21.6 Modifying the Attributes Displayed in the Table
  • 21.6.1 How to Modify the Displayed Attributes
  • 21.6.2 How to Change the Binding for a Table
  • 21.6.3 What Happens When You Modify Bindings or Displayed Attributes

22 Displaying Master-Detail Data

• 22.1 Introduction to Displaying Master-Detail Data
• 22.2 Identifying Master-Detail Objects on the Data Controls Panel
• 22.3 Using Tables and Forms to Display Master-Detail Objects
  • 22.3.1 How to Display Master-Detail Objects in Tables and Forms
  • 22.3.2 What Happens When You Create Master-Detail Tables and Forms
    • 22.3.2.1 Code Generated in the JSF Page
    • 22.3.2.2 Binding Objects Defined in the Page Definition File
  • 22.3.3 What Happens at Runtime
  • 22.3.4 What You May Need to Know About Master-Detail on Separate Pages
• 22.4 Using Trees to Display Master-Detail Objects
  • 22.4.1 How to Display Master-Detail Objects in Trees
  • 22.4.2 What Happens When You Create ADF Databound Trees
    • 22.4.2.1 Code Generated in the JSF Page
    • 22.4.2.2 Binding Objects Defined in the Page Definition File
  • 22.4.3 What Happens at Runtime
• 22.5 Using Tree Tables to Display Master-Detail Objects
  • 22.5.1 How to Display Master-Detail Objects in Tree Tables
  • 22.5.2 What Happens When You Create a Databound Tree Table
    • 22.5.2.1 Code Generated in the JSF Page
    • 22.5.2.2 Binding Objects Defined in the Page Definition File
  • 22.5.3 What Happens at Runtime
  • 22.5.4 Using the TargetIterator Property

23 Creating Databound Selection Lists and Shuttles

• 23.1 Creating a Selection List
  • 23.1.1 How to Create a Single Selection List
  • 23.1.2 How to Create a Model-Driven List
  • 23.1.3 How to Create a Selection List Containing Fixed Values
  • 23.1.4 How to Create a Selection List Containing Dynamically Generated Values
  • 23.1.5 What Happens When You Create a Model-driven Selection List
  • 23.1.6 What Happens When You Create a Fixed Selection List
  • 23.1.7 What You May Need to Know About Values in a Selection List
  • 23.1.8 What Happens When You Create a Dynamic Selection List
• 23.2 Creating a List with Navigation List Binding
• 23.3 Creating a Databound Shuttle
  • 23.3.1 How to Create a Shuttle

24 Creating Databound ADF Data Visualization Components

• 24.1 Introduction to Creating ADF Data Visualization Components
• 24.2 Creating Databound Graphs
  • 24.2.1 How to Create a Graph
  • 24.2.2 What Happens When You Use the Data Controls Panel to Create a Graph
  • 24.2.3 What You May Need to Know About Using a Graph's Row Selection Listener for Master-Detail Processing
• 24.3 Creating Databound Gauges
  • 24.3.1 How to Create a Databound Dial Gauge
  • 24.3.2 What Happens When You Create a Dial Gauge from a Data Control
  • 24.3.3 How to Create a Databound Status Meter Gauge Set
  • 24.3.4 What Happens When You Create a Status Meter Gauge from a Data Control
• 24.4 Creating Databound Pivot Tables
  • 24.4.1 How to Create a Pivot Table
  • 24.4.2 What Happens When You Use the Data Controls Panel to Create a Pivot Table
    • 24.4.2.1 Bindings for Pivot Tables
    • 24.4.2.2 Code on the JSF Page for an ADF Pivot Table
  • 24.4.3 What You May Need to Know About Aggregating Attributes in the Pivot Table
    • 24.4.3.1 Default Aggregation of Duplicate Data Rows
    • 24.4.3.2 Custom Aggregation of Duplicate Rows
  • 24.4.4 What You May Need to Know About Specifying an Initial Sort for a Pivot Table
• 24.5 Creating Databound Geographic Maps
  • 24.5.1 How to Create a Geographic Map with a Point Theme
  • 24.5.2 How to Create Point Style Items for a Point Theme
  • 24.5.3 What Happens When You Create a Geographic Map with a Point Theme
    • 24.5.3.1 Binding XML for a Point Theme
    • 24.5.3.2 XML Code on the JSF Page for a Geographic Map and Point Theme
  • 24.5.4 What You May Need to Know About Adding Custom Point Style Items to a Map Point Theme
  • 24.5.5 How to Add a Databound Color Theme to a Geographic Map
  • 24.5.6 What Happens When You Add a Color Theme to a Geographic Map
    • 24.5.6.1 Binding XML for a Color Theme
    • 24.5.6.2 XML Code on the JSF Page for a Color Theme
  • 24.5.7 What You May Need to Know About Customizing Colors in a Map Color Theme
  • 24.5.8 How to Add a Databound Pie Graph Theme to a Geographic Map
  • 24.5.9 What Happens When You Add a Pie Graph Theme to a Geographic Map
    • 24.5.9.1 Binding XML for a Pie Graph Theme
    • 24.5.9.2 Code on the JSF Page for a Pie Graph Theme
• 24.6 Creating Databound Gantt Charts
  • 24.6.1 How to Create a Databound Project Gantt
  • 24.6.2 What Happens When You Create a Project Gantt from a Data Control
  • 24.6.3 What You May Need to Know About Summary Tasks in a Project Gantt
  • 24.6.4 What You May Need to Know About Percent Complete in a Project Gantt
  • 24.6.5 What You May Need to Know About Variance in a Project Gantt
  • 24.6.6 How to Create a Databound Resource Utilization Gantt
  • 24.6.7 What Happens When You Create a Resource Utilization Gantt
  • 24.6.8 How to Create a Databound Scheduling Gantt
  • 24.6.9 What Happens When You Create a Scheduling Gantt

25 Creating ADF Databound Search Forms

• 25.1 Introduction to Creating Search Forms
  • 25.1.1 Query Search Forms
  • 25.1.2 Quick Query Search Forms
  • 25.1.3 Named Bind Variables in Query Search Forms
  • 25.1.4 Filtered Table and Query-by-Example Searches
  • 25.1.5 Implicit and Named View Criteria
  • 25.1.6 List of Values (LOV) Input Fields
• 25.2 Creating Query Search Forms
  • 25.2.1 How to Create a Query Search Form with a Results Table or Tree Table
  • 25.2.2 How to Create a Query Search Form and Add a Results Component Later
  • 25.2.3 How to Track Initial Query Execution
  • 25.2.4 What Happens When You Create a Query Form
  • 25.2.5 What Happens at Runtime: Creating a Search Form
• 25.3 Setting Up Search Form Properties
  • 25.3.1 How to Set Search Form Properties on the View Criteria
  • 25.3.2 How to Set Search Form Properties on the Query Component
  • 25.3.3 How to Create Custom Operators or Remove Standard Operators
• 25.4 Creating Quick Query Search Forms
  • 25.4.1 How to Create a Quick Query Search Form with a Results Table or Tree Table
  • 25.4.2 How to Create a Quick Query Search Form and Add a Results Component Later
  • 25.4.3 How to Set the Quick Query Layout Format
  • 25.4.4 What Happens When You Create a Quick Query Search Form
  • 25.4.5 What Happens at Runtime: Creating a Quick Query
• 25.5 Creating Filtered Search Tables

26 Creating More Complex Pages

• 26.1 Introduction to More Complex Pages
• 26.2 Creating Command Components to Execute Methods
  • 26.2.1 How to Create a Command Component Bound to a Custom Method
  • 26.2.2 What Happens When You Create Command Components Using a Method
    • 26.2.2.1 Using Parameters in a Method
    • 26.2.2.2 Using EL Expressions to Bind to Methods
    • 26.2.2.3 Using the Return Value from a Method Call
  • 26.2.3 What Happens at Runtime: Binding a Method to a Command Button
• 26.3 Setting Parameter Values Using a Command Component
  • 26.3.1 How to Set Parameters Using setPropertyListener Within a Command Component
  • 26.3.2 What Happens When You Set Parameters
  • 26.3.3 What Happens at Runtime: Setting Parameters Using Command Component
• 26.4 Overriding Declarative Methods
  • 26.4.1 How to Override a Declarative Method
  • 26.4.2 What Happens When You Override a Declarative Method
• 26.5 Creating Contextual Events
  • 26.5.1 How to Create Contextual Events
  • 26.5.2 How to Manually Create the Event Map
  • 26.5.3 What Happens When You Create Contextual Events
  • 26.5.4 What Happens at Runtime: Contextual Events
• 26.6 Adding ADF Model Layer Validation
  • 26.6.1 How to Add Validation
  • 26.6.2 What Happens at Runtime: Model Validation Rules
• 26.7 Displaying Error Messages
• 26.8 Customizing Error Handling
  • 26.8.1 Writing an Error Handler to Deal with Multiple Threads

27 Designing a Page Using Placeholder Data Controls

• 27.1 Introduction to Placeholder Data Controls
• 27.2 Creating Placeholder Data Controls
  • 27.2.1 How to Create a Placeholder Data Control
  • 27.2.2 What Happens When You Create a Placeholder Data Control
• 27.3 Creating Placeholder Data Types
  • 27.3.1 How to Create a Placeholder Data Type
  • 27.3.2 What Happens When You Create a Placeholder Data Type
  • 27.3.3 How to Configure a Placeholder Data Type Attribute to Be an LOV
  • 27.3.4 How to Create Master-Detail Data Types
  • 27.3.5 What Happens When You Create a Master-Detail Data Type
  • 27.3.6 How to Add Sample Data
  • 27.3.7 What Happens When You Add Sample Data
• 27.4 Using Placeholder Data Controls
  • 27.4.1 Limitations of Placeholder Data Controls
  • 27.4.2 Creating Layout
  • 27.4.3 Creating a Search Form
  • 27.4.4 Binding Components
  • 27.4.5 Rebinding Components
  • 27.4.6 Packaging Placeholder Data Controls to ADF Library JARs

Part V Completing Your Application

28 Adding Security to a Fusion Web Application

• 28.1 Introduction to ADF Security for Fusion Web Applications
• 28.2 Choosing ADF Security Authentication and Authorization
  • 28.2.1 How to Enable Only ADF Authentication
  • 28.2.2 What Happens When You Choose Not to Enforce Authorization
  • 28.2.3 What You May Need to Know About the valid-users Role
  • 28.2.4 How to Enable ADF Authentication and Authorization
  • 28.2.5 What Happens When You Choose to Enforce Authorization
  • 28.2.6 How to Disable ADF Security
  • 28.2.7 What Happens When You Disable ADF Security
  • 28.2.8 What Happens at Runtime: How Oracle ADF Security Handles Authentication
  • 28.2.9 What Happens at Runtime: How Oracle ADF Security Handles Authorization
• 28.3 Defining Users and Roles for a Fusion Web Application
  • 28.3.1 How to Enable the test-all Application Role in JDeveloper
  • 28.3.2 How to Define Application Roles in JDeveloper
  • 28.3.3 How to Configure the Identity Store with Test Users in JDeveloper
• 28.4 Defining ADF Security Access Policies
  • 28.4.1 How to Grant Permissions on ADF Bounded Task Flows
  • 28.4.2 How to Grant Permissions on Individual Web Pages Using ADF Page Definitions
  • 28.4.3 How to Secure Row Data Using ADF Business Components
    • 28.4.3.1 Defining a Permission on ADF Business Component Entity Objects
    • 28.4.3.2 Granting Permissions on ADF Business Components
  • 28.4.4 What Happens When You Define a Security Policy for ADF Resources
  • 28.4.5 What You May Need to Know About ADF Resource Grants
  • 28.4.6 How to Use Regular Expressions to Define Policies on Groups of Resources
• 28.5 Handling User Authentication in a Fusion Web Application
  • 28.5.1 How to Create a Login Component for Your Application
  • 28.5.2 How to Add a Login Component to a Web Page
  • 28.5.3 How to Create a Login Page for Your Application
    • 28.5.3.1 Creating an Oracle ADF Faces--Based Login Page
    • 28.5.3.2 Creating Login Code for the Backing Bean
    • 28.5.3.3 Configuring the web.xml File for an Oracle ADF Faces-Based Login Page
    • 28.5.3.4 Ensuring That the Login Page Is Public
  • 28.5.4 How to Create a Public Welcome Page for Your Application
    • 28.5.4.1 Ensuring That the Welcome Page Is Public
    • 28.5.4.2 Adding Login and Logout Links
    • 28.5.4.3 Hiding Links to Secured Pages
  • 28.5.5 What You May Need to Know About the Anonymous User
• 28.6 Performing Authorization Checks in a Fusion Web Application
  • 28.6.1 How to Evaluate Policies Using Expression Language (EL)
  • 28.6.2 What You May Need to Know About Delayed Evaluation of EL
  • 28.6.3 How to Evaluate Policies Using Java
• 28.7 Getting Other Information from the Oracle ADF Security Context
  • 28.7.1 How to Determine Whether Security Is Enabled
  • 28.7.2 How to Determine Whether the User Is Authenticated
  • 28.7.3 How to Determine the Current User Name
  • 28.7.4 How to Determine Membership of a Java EE Security Role
• 28.8 Testing ADF Security with Integrated WLS in JDeveloper
• 28.9 Preparing for Deployment to a Production Environment

29 Testing and Debugging ADF Components

• 29.1 Introduction to Oracle ADF Debugging
• 29.2 Correcting Simple Oracle ADF Compilation Errors
• 29.3 Correcting Simple Oracle ADF Runtime Errors
• 29.4 Using the ADF Logger and Business Component Browser
  • 29.4.1 How to Turn On Diagnostic Logging
  • 29.4.2 How to Create an Oracle ADF Debugging Configuration
  • 29.4.3 How to Use the Business Component Browser with the Debugger
• 29.5 Using the ADF Declarative Debugger
  • 29.5.1 Using ADF Source Code with the Debugger
  • 29.5.2 How to Set Up the ADF Source User Library
  • 29.5.3 How to Add the ADF Source Library to a Project
  • 29.5.4 How to Use the EL Expression Evaluator
  • 29.5.5 How to View and Export Stack Trace Information
• 29.6 Setting ADF Declarative Breakpoints
  • 29.6.1 How to Set Task Flow Activity Breakpoints
  • 29.6.2 How to Set Page Definition Executable Breakpoints
  • 29.6.3 How to Set Page Definition Action Binding Breakpoints
  • 29.6.4 How to Set Page Definition Attribute Value Binding Breakpoints
  • 29.6.5 How to Use the ADF Structure Window
  • 29.6.6 How to Use the ADF Data Window
• 29.7 Setting Java Code Breakpoints
  • 29.7.1 How to Set Java Breakpoints on Classes and Methods
  • 29.7.2 How to Optimize Use of the Source Editor
  • 29.7.3 How to Set Breakpoints and Debug Using ADF Source Code
  • 29.7.4 How to Use Debug Libraries for Symbolic Debugging
  • 29.7.5 How to Use Different Kinds of Breakpoints
  • 29.7.6 How to Edit Breakpoints for Improved Control
  • 29.7.7 How to Filter Your View of Class Members
  • 29.7.8 How to Use Common Oracle ADF Breakpoints
• 29.8 Regression Testing with JUnit
  • 29.8.1 How to Obtain the JUnit Extension
  • 29.8.2 How to Create a JUnit Test Case
  • 29.8.3 How to Create a JUnit Test Fixture
  • 29.8.4 How to Create a JUnit Test Suite
  • 29.8.5 How to Run a JUnit Test Suite as Part of an Ant Build Script

30 Refactoring a Fusion Web Application

• 30.1 Introduction to Refactoring a Fusion Web Application
• 30.2 Renaming Files
• 30.3 Moving JSF Pages
• 30.4 Refactoring pagedef.xml Bindings Objects
• 30.5 Refactoring ADF Business Components
• 30.6 Refactoring Attributes
• 30.7 Refactoring Named Elements
• 30.8 Refactoring ADF Task Flows
• 30.9 Refactoring the DataBindings.cpx File
• 30.10 Refactoring Across Abstraction Layers
• 30.11 Refactoring Limitations
• 30.12 Refactoring the .jpx Project File

31 Reusing Application Components

• 31.1 Introduction to Reusable Components
  • 31.1.1 Creating Reusable Components
    • 31.1.1.1 Naming Conventions
    • 31.1.1.2 The Naming Process for the ADF Library JAR Deployment Profile
    • 31.1.1.3 Keeping the Relevant Project
    • 31.1.1.4 Selecting the Relevant Technology Scope
    • 31.1.1.5 Selecting Paths and Folders
    • 31.1.1.6 Including Connections Within Reusable Components
  • 31.1.2 Using the Resource Palette
  • 31.1.3 Extension Libraries
• 31.2 Packaging a Reusable ADF Component into an ADF Library
  • 31.2.1 How to Package a Component into an ADF Library JAR
  • 31.2.2 What Happens When You Package a Project to an ADF Library JAR
    • 31.2.2.1 Application Modules
    • 31.2.2.2 Data Controls
    • 31.2.2.3 Task Flows
    • 31.2.2.4 Page Templates
    • 31.2.2.5 Declarative Components
• 31.3 Adding ADF Library Components into Projects
  • 31.3.1 How to Add an ADF Library JAR into a Project using the Resource Palette
  • 31.3.2 How to Add an ADF Library JAR into a Project Manually
  • 31.3.3 What Happens When You Add an ADF Library JAR to a Project
  • 31.3.4 What You May Need to Know About Using ADF Library Components
    • 31.3.4.1 Using Data Controls
    • 31.3.4.2 Using Application Modules
    • 31.3.4.3 Using Business Components
    • 31.3.4.4 Using Task Flows
    • 31.3.4.5 Using Page Templates
    • 31.3.4.6 Using Declarative Components
  • 31.3.5 What You May Need to Know About Differentiating ADF Library Components
  • 31.3.6 What Happens at Runtime: Adding ADF Libraries
• 31.4 Removing an ADF Library JAR from a Project
  • 31.4.1 How to Remove an ADF Library JAR from a Project Using the Resource Palette
  • 31.4.2 How to Remove an ADF Library JAR from a Project Manually

32 Deploying Fusion Web Applications

• 32.1 Introduction to Deploying Fusion Web Applications
• 32.2 Creating a Connection to the Target Application Server
• 32.3 Creating a Deployment Profile
  • 32.3.1 How to Create Deployment Profiles
  • 32.3.2 How to View and Change Deployment Profile Properties
• 32.4 Creating and Editing Deployment Descriptors
  • 32.4.1 How to Create Deployment Descriptors
  • 32.4.2 How to View or Change Deployment Descriptor Properties
  • 32.4.3 How to Create or Configure the application.xml file for WebLogic Compatibility
  • 32.4.4 How to Create or Configure the web.xml file for WebLogic Compatibility
  • 32.4.5 How to Create Deployment Descriptors for Applications with ADF Faces Components
• 32.5 Installing the ADF Runtime to the WebLogic Installation
  • 32.5.1 How to Install the ADF Runtime into an Existing WebLogic Server
  • 32.5.2 What You May Need to Know About ADF Libraries
• 32.6 Creating and Extending WebLogic Domains
  • 32.6.1 How to Create a WebLogic Domain for Oracle ADF
  • 32.6.2 How to Extend a WebLogic Domain for Oracle ADF
• 32.7 Creating a JDBC Data Source for a WebLogic Domain Server
• 32.8 Deploying the Application
  • 32.8.1 How to Deploy to a WebLogic Server from JDeveloper
  • 32.8.2 How to Create an EAR File for Deployment
  • 32.8.3 How to Deploy an Application Using Ant
• 32.9 Testing the Application and Verifying Deployment

Part VI Advanced Topics

33 Advanced Business Components Techniques

• 33.1 Globally Extending ADF Business Components Functionality
  • 33.1.1 What Are ADF Business Components Framework Extension Classes?
  • 33.1.2 How To Create a Framework Extension Class
  • 33.1.3 What Happens When You Create a Framework Extension Class
  • 33.1.4 How to Base an ADF Component on a Framework Extension Class
  • 33.1.5 What Happens When You Base a Component on a Framework Extension Class
    • 33.1.5.1 Basing an XML-Only Component on a Framework Extension Class
    • 33.1.5.2 Basing a Component with a Custom Java Class on a Framework Extension Class
  • 33.1.6 What You May Need to Know
    • 33.1.6.1 Don't Update the Extends Clause in Custom Component Java Files By Hand
    • 33.1.6.2 You Can Have Multiple Levels of Framework Extension Classes
    • 33.1.6.3 Setting up Project-Level Preferences for Framework Extension Classes
    • 33.1.6.4 Setting Up Framework Extension Class Preferences at the IDE Level
• 33.2 Creating a Layer of Framework Extensions
  • 33.2.1 How to Create Your Layer of Framework Extension Layer Classes
  • 33.2.2 How to Package Your Framework Extension Layer in a JAR File
  • 33.2.3 How to Create a Library Definition for Your Framework Extension JAR File
• 33.3 Customizing Framework Behavior with Extension Classes
  • 33.3.1 How to Access Runtime Metadata For View Objects and Entity Objects
  • 33.3.2 Implementing Generic Functionality Using Runtime Metadata
  • 33.3.3 Implementing Generic Functionality Driven by Custom Properties
  • 33.3.4 What You May Need to Know
    • 33.3.4.1 Determining the Attribute Kind at Runtime
    • 33.3.4.2 Configuring Design Time Custom Property Names
    • 33.3.4.3 Setting Custom Properties at Runtime
• 33.4 Creating Generic Extension Interfaces
• 33.5 Invoking Stored Procedures and Functions
  • 33.5.1 Invoking Stored Procedures with No Arguments
  • 33.5.2 Invoking Stored Procedure with Only IN Arguments
  • 33.5.3 Invoking Stored Function with Only IN Arguments
  • 33.5.4 Calling Other Types of Stored Procedures
• 33.6 Accessing the Current Database Transaction
• 33.7 Working with Libraries of Reusable Business Components
  • 33.7.1 How To Create a Reusable Library of Business Components
  • 33.7.2 How To Import a Package of Reusable Components from a Library
  • 33.7.3 How to Remove an Imported Package from a Project
  • 33.7.4 What Happens When You Import a Package of Reusable Components from a Library
  • 33.7.5 What You May Need to Know
    • 33.7.5.1 Components in Imported Libraries Are Not Editable
    • 33.7.5.2 Have to Close/Reopen to See Changes from a JAR
• 33.8 Customizing Business Components Error Messages
  • 33.8.1 How to Customize Base ADF Business Components Error Messages
  • 33.8.2 What Happens When You Customize Base ADF Business Components Error Messages
  • 33.8.3 How to Customize Error Messages for Database Constraint Violations
  • 33.8.4 How to Implement a Custom Constraint Error Handling Routine
    • 33.8.4.1 Creating a Custom Database Transaction Framework Extension Class
    • 33.8.4.2 Configuring an Application Module to Use a Custom Database Transaction Class
• 33.9 Creating Extended Components Using Inheritance
  • 33.9.1 How To Create a Component That Extends Another
  • 33.9.2 How To Extend a Component After Creation
  • 33.9.3 What Happens When You Create a Component That Extends Another
    • 33.9.3.1 Understanding an Extended Component's XML Descriptor
    • 33.9.3.2 Understanding Java Code Generation for an Extended Component
  • 33.9.4 What You May Need to Know
    • 33.9.4.1 You Can Use Parent Classes and Interfaces to Work with Extended Components
    • 33.9.4.2 Class Extends is Disabled for Extended Components
    • 33.9.4.3 Interesting Aspects You Can Extend for Key Component Types
    • 33.9.4.4 Extended Components Have Attribute Indices Relative to Parent
• 33.10 Substituting Extended Components In a Delivered Application
  • 33.10.1 Extending and Substituting Components Is Superior to Modifying Code
  • 33.10.2 How To Substitute an Extended Component
  • 33.10.3 What Happens When You Substitute
  • 33.10.4 Enabling the Substituted Components in the Base Application

34 Advanced Entity Object Techniques

• 34.1 Creating Custom, Validated Data Types Using Domains
  • 34.1.1 What Are Domains?
  • 34.1.2 How To Create a Domain
  • 34.1.3 What Happens When You Create a Domain
  • 34.1.4 What You May Need to Know About Domains
    • 34.1.4.1 Using Domains for Entity and View Object Attributes
    • 34.1.4.2 Validate Method Should Throw DataCreationException If Sanity Checks Fail
    • 34.1.4.3 String Domains Aggregate a String Value
    • 34.1.4.4 Other Domains Extend Existing Domain Type
    • 34.1.4.5 Simple Domains are Immutable Java Classes
    • 34.1.4.6 Creating Domains for Oracle Object Types When Useful
    • 34.1.4.7 Quickly Navigating to the Domain Class
    • 34.1.4.8 Domains Get Packaged in the Common JAR
    • 34.1.4.9 Entity and View Object Attributes Inherit Custom Domain Properties
    • 34.1.4.10 Domain Settings Cannot Be Less Restrictive at Entity or View Level
• 34.2 Updating a Deleted Flag Instead of Deleting Rows
  • 34.2.1 How to Update a Deleted Flag When a Row is Removed
  • 34.2.2 Forcing an Update DML Operation Instead of a Delete
• 34.3 Using Update Batching
• 34.4 Advanced Entity Association Techniques
  • 34.4.1 Modifying Association SQL Clause to Implement Complex Associations
  • 34.4.2 Exposing View Link Accessor Attributes at the Entity Level
  • 34.4.3 Optimizing Entity Accessor Access By Retaining the Row Set
• 34.5 Basing an Entity Object on a PL/SQL Package API
  • 34.5.1 How to Create an Entity Object Based on a View
  • 34.5.2 What Happens When You Create an Entity Object Based on a View
  • 34.5.3 Centralizing Details for PL/SQL-Based Entities into a Base Class
  • 34.5.4 Implementing the Stored Procedure Calls for DML Operations
  • 34.5.5 Adding Select and Lock Handling
    • 34.5.5.1 Updating PLSQLEntityImpl Base Class to Handle Lock and Select
    • 34.5.5.2 Implementing Lock and Select for the Product Entity
    • 34.5.5.3 Refreshing the Entity Object After RowInconsistentException
• 34.6 Basing an Entity Object on a Join View or Remote DBLink
• 34.7 Using Inheritance in Your Business Domain Layer
  • 34.7.1 Understanding When Inheritance Can be Useful
  • 34.7.2 How To Create Entity Objects in an Inheritance Hierarchy
    • 34.7.2.1 Start By Identifying the Discriminator Column and Distinct Values
    • 34.7.2.2 Identify the Subset of Attributes Relevant to Each Kind of Entity
    • 34.7.2.3 Creating the Base Entity Object in an Inheritance Hierarchy
    • 34.7.2.4 Creating a Subtype Entity Object in an Inheritance Hierarchy
  • 34.7.3 How to Add Methods to Entity Objects in an Inheritance Hierarchy
    • 34.7.3.1 Adding Methods Common to All Entity Objects in the Hierarchy
    • 34.7.3.2 Overriding Common Methods in a Subtype Entity
    • 34.7.3.3 Adding Methods Specific to a Subtype Entity
  • 34.7.4 What You May Need to Know About Using Inheritance
    • 34.7.4.1 Sometimes You Need to Introduce a New Base Entity
    • 34.7.4.2 Finding Subtype Entities by Primary Key
    • 34.7.4.3 You Can Create View Objects with Polymorphic Entity Usages
• 34.8 Controlling Entity Posting Order to Avoid Constraint Violations
  • 34.8.1 Understanding the Default Post Processing Order
  • 34.8.2 How Compositions Change the Default Processing Ordering
  • 34.8.3 Overriding postChanges() to Control Post Order
    • 34.8.3.1 Observing the Post Ordering Problem First Hand
    • 34.8.3.2 Forcing the Supplier to Post Before the Product
    • 34.8.3.3 Understanding Associations Based on DBSequence-Valued Primary Keys
    • 34.8.3.4 Refreshing References to DBSequence-Assigned Foreign Keys
• 34.9 Implementing Automatic Attribute Recalculation
• 34.10 Implementing Custom Validation Rules
  • 34.10.1 How To Create a Custom Validation Rule
  • 34.10.2 Adding a Design Time Bean Customizer for Your Rule
  • 34.10.3 Registering and Using a Custom Rule in JDeveloper
• 34.11 Creating New History Types
  • 34.11.1 How to Create New History Types
  • 34.11.2 How to Remove a History Type

35 Advanced View Object Techniques

• 35.1 Advanced View Object Concepts and Features
  • 35.1.1 Using a Max Fetch Size to Only Fetch the First N Rows
  • 35.1.2 Consistently Displaying New Rows in View Objects Based on the Same Entity
    • 35.1.2.1 How View Link Consistency Mode Works
    • 35.1.2.2 Understanding the Default View Link Consistency Setting and How to Change It
    • 35.1.2.3 Using a RowMatch to Qualify Which New, Unposted Rows Get Added to a Row Set
    • 35.1.2.4 Setting a Dynamic Where Clause Disables View Link Consistency
    • 35.1.2.5 New Row from Other View Objects Added at the Bottom
    • 35.1.2.6 New, Unposted Rows Added to Top of RowSet when Re-Executed
  • 35.1.3 Understanding View Link Accessors Versus Data Model View Link Instances
    • 35.1.3.1 Enabling a Dynamic Detail Row Set with Active Master/Detail Coordination
    • 35.1.3.2 Accessing a Stable Detail Row Set Using View Link Accessor Attributes
    • 35.1.3.3 Accessor Attributes Create Distinct Row Sets Based on an Internal View Object
  • 35.1.4 Presenting and Scrolling Data a Page at a Time Using the Range
  • 35.1.5 Efficiently Scrolling Through Large Result Sets Using Range Paging
    • 35.1.5.1 Understanding How to Oracle Supports "TOP-N" Queries
    • 35.1.5.2 How to Enable Range Paging for a View Object
    • 35.1.5.3 What Happens When You Enable Range Paging
    • 35.1.5.4 What Happens When View Rows are Cached When Using Range Paging
    • 35.1.5.5 How to Scroll to a Given Page Number Using Range Paging
    • 35.1.5.6 Estimating the Number of Pages in the Row Set Using Range Paging
    • 35.1.5.7 Understanding the Tradeoffs of Using a Range Paging Mode
  • 35.1.6 Setting Up a Data Model with Multiple Masters
  • 35.1.7 Understanding When You Can Use Partial Keys with findByKey()
  • 35.1.8 Creating Dynamic Attributes to Store UI State
  • 35.1.9 Working with Multiple Row Sets and Row Set Iterators
  • 35.1.10 Optimizing View Link Accessor Access By Retaining the Row Set
• 35.2 Tuning Your View Objects for Best Performance
  • 35.2.1 Use Bind Variables for Parameterized Queries
    • 35.2.1.1 Use Bind Variables to Avoid Re-parsing of Queries
    • 35.2.1.2 Use Bind Variables to Prevent SQL-Injection Attacks
  • 35.2.2 Consider Using Entity-Based View Objects for Read-Only Data
  • 35.2.3 Use SQL Tracing to Identify Ill-Performing Queries
  • 35.2.4 Consider the Appropriate Tuning Settings for Every View Object
    • 35.2.4.1 Set the Database Retrieval Options Appropriately
    • 35.2.4.2 Consider Whether Fetching One Row at a Time is Appropriate
    • 35.2.4.3 Specify a Query Optimizer Hint if Necessary
  • 35.2.5 Creating View Objects at Design Time
  • 35.2.6 Use Forward Only Mode to Avoid Caching View Rows
• 35.3 Using Expert Mode for Full Control Over SQL Query
  • 35.3.1 How to Enable Expert Mode for Full SQL Control
  • 35.3.2 What Happens When You Enable Expert Mode
  • 35.3.3 What You May Need to Know
    • 35.3.3.1 You May Need to Perform Manual Attribute Mapping
    • 35.3.3.2 Disabling Expert Mode Loses Any Custom Edits
    • 35.3.3.3 Once In Expert Mode, Changes to SQL Expressions Are Ignored
    • 35.3.3.4 Don't Map Incorrect Calculated Expressions to Entity Attributes
    • 35.3.3.5 Expert Mode SQL Formatting is Retained
    • 35.3.3.6 Expert Mode Queries Are Wrapped as Inline Views
    • 35.3.3.7 Disabling the Use of Inline View Wrapping at Runtime
    • 35.3.3.8 Enabling Expert Mode May Impact Dependent Objects
• 35.4 Generating Custom Java Classes for a View Object
  • 35.4.1 How To Generate Custom Classes
    • 35.4.1.1 Generating Bind Variable Accessors
    • 35.4.1.2 Generating View Row Attribute Accessors
    • 35.4.1.3 Exposing View Row Accessors to Clients
    • 35.4.1.4 Configuring Default Java Generation Preferences
  • 35.4.2 What Happens When You Generate Custom Classes
    • 35.4.2.1 Seeing and Navigating to Custom Java Files
  • 35.4.3 What You May Need to Know About Custom Classes
    • 35.4.3.1 About the Framework Base Classes for a View Object
    • 35.4.3.2 You Can Safely Add Code to the Custom Component File
    • 35.4.3.3 Attribute Indexes and InvokeAccessor Generated Code
• 35.5 Working Programmatically with Multiple Named View Criteria
  • 35.5.1 Applying One or More Named View Criteria
  • 35.5.2 Removing All Applied Named View Criteria
  • 35.5.3 Using the Named Criteria at Runtime
• 35.6 Performing In-Memory Sorting and Filtering of Row Sets
  • 35.6.1 Understanding the View Object's SQL Mode
  • 35.6.2 Sorting View Object Rows In Memory
    • 35.6.2.1 Combining setSortBy and setQueryMode for In-Memory Sorting
    • 35.6.2.2 Extensibility Points for In-Memory Sorting
  • 35.6.3 Performing In-Memory Filtering with View Criteria
  • 35.6.4 Performing In-Memory Filtering with RowMatch
    • 35.6.4.1 Applying a RowMatch to a View Object
    • 35.6.4.2 Using RowMatch to Test an Individual Row
    • 35.6.4.3 How a RowMatch Affects Rows Fetched from the Database
• 35.7 Using View Objects to Work with Multiple Row Types
  • 35.7.1 Working with Polymorphic Entity Usages
  • 35.7.2 How To Create a View Object with a Polymorphic Entity Usage
  • 35.7.3 What Happens When You Create a View Object with a Polymorphic Entity Usage
  • 35.7.4 What You May Need to Know
    • 35.7.4.1 Your Query Must Limit Rows to Expected Entity Subtypes
    • 35.7.4.2 Exposing Selected Entity Methods in View Rows Using Delegation
    • 35.7.4.3 Creating New Rows With the Desired Entity Subtype
  • 35.7.5 Working with Polymorphic View Rows
  • 35.7.6 How to Create a View Object with Polymorphic View Rows
  • 35.7.7 What You May Need to Know
    • 35.7.7.1 Selecting Subtype-Specific Attributes in Extended View Objects
    • 35.7.7.2 Delegating to Subtype-Specific Methods After Overriding the Entity Usage
    • 35.7.7.3 Working with Different View Row Interface Types in Client Code
    • 35.7.7.4 View Row Polymorphism and Polymorphic Entity Usage are Orthogonal
• 35.8 Reading and Writing XML
  • 35.8.1 How to Produce XML for Queried Data
  • 35.8.2 What Happens When You Produce XML
  • 35.8.3 What You May Need to Know
    • 35.8.3.1 Controlling XML Element Names
    • 35.8.3.2 Controlling Element Suppression for Null-Valued Attributes
    • 35.8.3.3 Printing or Searching the Generated XML Using XPath
    • 35.8.3.4 Using the Attribute Map For Fine Control Over Generated XML
    • 35.8.3.5 Use the Attribute Map Approach with Bi-Directional View Links
    • 35.8.3.6 Transforming Generated XML Using an XSLT Stylesheet
    • 35.8.3.7 Generating XML for a Single Row
  • 35.8.4 How to Consume XML Documents to Apply Changes
  • 35.8.5 What Happens When You Consume XML Documents
    • 35.8.5.1 How ViewObject.readXML() Processes an XML Document
    • 35.8.5.2 Using readXML() to Processes XML for a Single Row
• 35.9 Using Programmatic View Objects for Alternative Data Sources
  • 35.9.1 How to Create a Read-Only Programmatic View Object
  • 35.9.2 How to Create an Entity-Based Programmatic View Object
  • 35.9.3 Key Framework Methods to Override for Programmatic View Objects
  • 35.9.4 How to Create a View Object on a REF CURSOR
    • 35.9.4.1 The Overridden create() Method
    • 35.9.4.2 The Overridden executeQueryForCollection() Method
    • 35.9.4.3 The Overridden createRowFromResultSet() Method
    • 35.9.4.4 The Overridden hasNextForCollectionMethod()
    • 35.9.4.5 The Overridden releaseUserDataForCollection() Method
    • 35.9.4.6 The Overridden getQueryHitCount() Method
• 35.10 Creating a View Object with Multiple Updatable Entities
• 35.11 Declaratively Preventing Insert, Update, and Delete

36 Application State Management

• 36.1 Understanding Why State Management is Necessary
  • 36.1.1 Examples of Multi-Step Tasks
  • 36.1.2 Stateless HTTP Protocol Complicates Stateful Applications
  • 36.1.3 How Cookies Are Used to Track a User Session
  • 36.1.4 Performance and Reliability Impact of Using HttpSession
• 36.2 About Fusion Web Application State Management
  • 36.2.1 Basic Architecture of the Save for Later Facility
  • 36.2.2 Basic Architecture of the Application Module State Management Facility
    • 36.2.2.1 Understanding When Passivation and Activation Occurs
    • 36.2.2.2 How Passivation Changes When Optional Failover Mode is Enabled
    • 36.2.2.3 About State Management Release Levels
• 36.3 Using Save For Later
• 36.4 Setting the Application Module Release Level at Runtime
  • 36.4.1 How to Set Unmanaged Level
  • 36.4.2 How to Set Reserved Level
  • 36.4.3 How to Set Managed Level
  • 36.4.4 How to Set Release Level in a JSF Backing Bean
  • 36.4.5 How to Set Release Level in an ADF PagePhaseListener
  • 36.4.6 How to Set Release Level in an ADF PageController
  • 36.4.7 How to Set Release Level in an Custom ADF PageLifecycle
• 36.5 What Model State Is Saved and When It Is Cleaned Up
  • 36.5.1 What State is Saved?
  • 36.5.2 Where is the Model State Saved?
    • 36.5.2.1 How Database-Backed Passivation Works
    • 36.5.2.2 Controlling the Schema Where the State Management Table Resides
    • 36.5.2.3 Configuring the Type of Passivation Store
  • 36.5.3 When is the Model State Cleaned Up?
    • 36.5.3.1 Previous Snapshot Removed When Next One Taken
    • 36.5.3.2 Passivation Snapshot Removed on Unmanaged Release
    • 36.5.3.3 Passivation Snapshot Retained in Failover Mode
  • 36.5.4 Cleaning Up Temporary Storage Tables
• 36.6 Timing Out the HttpSession
  • 36.6.1 How to Configure the Implicit Timeout Due to User Inactivity
  • 36.6.2 How to Code an Explicit HttpSession Timeout
• 36.7 Managing Custom User-Specific Information
  • 36.7.1 How to Passivate Custom User-Specific Information
    • 36.7.1.1 What Happens When You Passivate Custom Information
• 36.8 Managing the State of View Objects
  • 36.8.1 How to Manage the State of View Objects
  • 36.8.2 What You May Need to Know About Passivating View Objects
  • 36.8.3 How to Manage the State of Transient View Objects and Attributes
  • 36.8.4 What You May Need to Know About Passivating Transient View Objects
  • 36.8.5 How to Use Transient View Objects to Store Session-level Global Variables
• 36.9 Using State Management for Middle-Tier Savepoints
  • 36.9.1 How to Use State Management for Savepoints
• 36.10 Testing to Ensure Your Application Module is Activation-Safe
  • 36.10.1 Understanding the jbo.ampool.doampooling Configuration Parameter
  • 36.10.2 Disabling Application Module Pooling to Test Activation
• 36.11 Keeping Pending Changes in the Middle Tier
  • 36.11.1 How to Set Applications to Use Optimistic Locking
  • 36.11.2 How to Avoid Clashes Using the postChanges() Method
  • 36.11.3 How to Use the Reserved Level For Pending Database States

37 Understanding Application Module Pooling

• 37.1 Overview of Application Module Pooling
• 37.2 Understanding Configuration Property Scopes
• 37.3 Setting Pool Configuration Parameters
  • 37.3.1 Setting Configuration Properties Declaratively
  • 37.3.2 Setting Configuration Properties as System Parameters
  • 37.3.3 Programmatically Setting Configuration Properties
• 37.4 How Many Pools are Created, and When?
  • 37.4.1 Application Module Pools
  • 37.4.2 Database Connection Pools
  • 37.4.3 Understanding Application Module and Connection Pools
    • 37.4.3.1 Single Oracle Application Server Instance, Single Oracle WebLogic Server Instance, Single JVM
    • 37.4.3.2 Multiple Oracle Application Server Instances, Single Oracle WebLogic Server Instance, Multiple JVMs
• 37.5 Application Module Pool Parameters
  • 37.5.1 Pool Behavior Parameters
  • 37.5.2 Pool Sizing Parameters
  • 37.5.3 Pool Cleanup Parameters
• 37.6 Database Connection Pool Parameters
• 37.7 How Database and Application Module Pools Cooperate
• 37.8 Database User State and Pooling Considerations
  • 37.8.1 How Often prepareSession() Fires When jbo.doconnectionpooling = false
  • 37.8.2 How to Set Database User State When jbo.doconnectionpooling = true
  • 37.8.3 How to Set Database State

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 adfm.xml
• A.4 modelProjectName.jpx
• A.5 bc4j.xcfg
• A.6 DataBindings.cpx
  • A.6.1 DataBindings.cpx Syntax
  • A.6.2 DataBindings.cpx Sample
• A.7 pageNamePageDef.xml
  • A.7.1 PageDef.xml Syntax
• A.8 adfc-config.xml
• A.9 task-flow-definition.xml
• A.10 adf-config.xml
• A.11 adf-settings.xml
• A.12 web.xml
• A.13 logging.xml

B Oracle ADF Binding Properties

• B.1 EL Properties of Oracle ADF Bindings

C Oracle ADF Permission Grants

• C.1 Grantable Actions of ADF Components

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 on EntityImpl
  • E.2.5 EntityDefImpl Class
    • E.2.5.1 Methods You Typically Call on EntityDefImpl
    • E.2.5.2 Methods You Typically Write on EntityDefImpl
    • E.2.5.3 Methods You Typically Override on 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 on ViewRowImpl
    • 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

• F.1 Java EE Design Patterns Implemented by ADF Business Components

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