Developing Fusion Web Applications with Oracle Application Development Framework
Table of Contents
Show All | Collapse- Title and Copyright Information
- Preface
- What's New in This Guide
- 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.3 Overview of Building an Application with Oracle ADF
- 1.3.1 Creating an Application Workspace
- 1.3.2 Modeling with Database Object Definitions
- 1.3.3 Creating Use Cases
- 1.3.4 Designing Application Control and Navigation Using ADF Task Flows
- 1.3.5 Identifying Shared Resources
- 1.3.6 Creating a Data Model to Access Data with ADF Business Components
- 1.3.7 Implementing the User Interface with JSF
- 1.3.8 Data Binding with ADF Model
- 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.5 Generation of Complete Web Tier Using Oracle JHeadstart
- 1.6 Other Resources for Learning Oracle ADF
- 2 Introduction to the ADF Sample Application
- 2.1 About the Summit Sample Applications for Oracle ADF
- 2.2 Setting Up the Summit Sample Applications for Oracle ADF
- 2.3 Running the Core Summit ADF Sample Application in the SummitADF Workspace
- 2.4 Running the Standalone Samples from the SummitADF_Examples Workspace
- 2.5 Running the Sample Application in the SummitADF_TaskFlows Workspace
- 2.6 Running the Standalone Samples in the SummitADF_DVT Workspace
- 1 Introduction to Building Fusion Web Applications with Oracle ADF
- Part II Building Your Business Services
- 3 Getting Started with ADF Business Components
- 3.1 About ADF Business Components
- 3.2 Creating the ADF Business Components Data Model Project
- 3.2.1 How to Create a Data Model Project for ADF Business Components
- 3.2.2 How to Add an ADF Business Components Data Model Project to an Existing Application
- 3.2.3 How to Initialize the Data Model Project With a Database Connection
- 3.2.4 How to Change the Data Model Project to Work With Offline Database Objects
- 3.2.5 What You May Need to Know About Application Server or Database Independence
- 3.2.6 What You May Need to Know About Basic Data Types
- 3.2.7 What You May Need to Know About Displaying Numeric Values
- 3.2.8 How to Customize Model Project Properties for ADF Business Components
- 3.2.9 How to Customize ADF Business Components Preferences
- 3.3 Creating and Editing Business Components
- 3.3.1 How to Create New Components Using Wizards
- 3.3.2 How to Create New Components Using the Context Menu
- 3.3.3 What Happens When You Create Business Components
- 3.3.4 What You May Need to Know About the Model Project Organization
- 3.3.5 What You May Need to Know About Package Naming Conventions
- 3.3.6 What You May Need to Know About Renaming Components
- 3.3.7 How to Edit Components Using the Component Overview Editor
- 3.4 Testing, Refactoring, and Visualizing Business Components
- 3.4.1 How to Use the Oracle ADF Model Tester
- 3.4.2 What You May Need to Know About Obtaining Oracle ADF Source Code
- 3.4.3 How to Find Business Component Usages in the Data Model Project
- 3.4.4 How to Refactor Business Components in the Data Model Project
- 3.4.5 How to Refactor Offline Database Objects and Update Business Components
- 3.4.6 How to Display Related Business Components Using Diagrams
- 3.4.7 What You May Need to Know About Using UML Diagrams
- 3.5 Customizing Business Components
- 3.5.1 How to Generate Business Component Java Subclasses
- 3.5.2 How to Expose Business Component Methods to Clients
- 3.5.3 What Happens When You Generate Custom Classes
- 3.5.4 What You May Need to Know About Custom Interface Support
- 3.5.5 What You May Need to Know About Generic Versus Strongly Typed APIs
- 3.5.6 How to Use Groovy Scripting Language With Business Components
- 3.5.7 What You May Need to Know About Referencing Business Components in Groovy Expressions
- 3.5.8 What You May Need to Know About Referencing Custom Business Components Methods and Attributes in Groovy Expressions
- 3.5.9 What You May Need to Know About Manipulating Business Component Attribute Values in Groovy Expressions
- 4 Creating a Business Domain Layer Using Entity Objects
- 4.1 About 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.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.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 a Diagram of Entity Objects for Your Business Layer
- 4.5 Defining Property Sets
- 4.6 Defining Attribute Control Hints for Entity Objects
- 4.7 Working with Resource Bundles
- 4.8 Defining Business Logic Groups
- 4.8.1 How to Create a Business Logic Group
- 4.8.2 How to Create a Business Logic Unit
- 4.8.3 How to Add Logic to a Business Logic Unit
- 4.8.4 How to Override Attributes in a Business Logic Unit
- 4.8.5 What Happens When You Create a Business Logic Group
- 4.8.6 What Happens at Runtime: How Business Logic Groups Are Invoked
- 4.9 Configuring Runtime Behavior Declaratively
- 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 an 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.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 Adding Transient and Calculated Attributes to an Entity Object
- 4.11.1 How to Add a Transient Attribute
- 4.11.2 What Happens When You Add a Transient Attribute
- 4.11.3 How to Base a Transient Attribute on a Groovy Expression
- 4.11.4 What Happens When You Base a Transient Attribute on a Groovy Expression
- 4.11.5 How to Add Java Code in the Entity Class to Perform Calculation
- 4.12 Creating Business Events
- 4.12.1 Introducing Event Definitions
- 4.12.2 Introducing Event Points
- 4.12.3 What You May Need to Know About Event Points
- 4.12.4 How to Create a Business Event
- 4.12.5 What Happens When You Create a Business Event
- 4.12.6 What You May Need to Know About Payload
- 4.12.7 How to Define a Publication Point for a Business Event
- 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.6 Programmatic Example for Comparison Using Custom Entity Class References
- 4.14 Working Programmatically with Entity Objects and Associations
- 4.14.1 How to Find an Entity Object by Primary Key
- 4.14.2 How to Access an Associated Entity Using the Accessor Attribute
- 4.14.3 How to Update or Remove an Existing Entity Row
- 4.14.4 How to Create a New Entity Row
- 4.14.5 Assigning the Primary Key Value Using an Oracle Sequence
- 4.14.6 How to Update a Deleted Flag Instead of Deleting Rows
- 4.14.7 How to Control Entity Posting Order to Prevent Constraint Violations
- 4.14.8 Advanced Entity Association Techniques
- 4.14.9 What You May Need to Know About Custom Entity Object Methods
- 4.15 Creating Custom, Validated Data Types Using Domains
- 4.16 Creating New History Types
- 4.17 Basing an Entity Object on a PL/SQL Package API
- 4.17.1 How to Create an Entity Object Based on a View
- 4.17.2 What Happens When You Create an Entity Object Based on a View
- 4.17.3 How to Centralize Details for PL/SQL-Based Entities into a Base Class
- 4.17.4 How to Implement the Stored Procedure Calls for DML Operations
- 4.17.5 How to Add Select and Lock Handling
- 4.18 Basing an Entity Object on a Join View or Remote DBLink
- 4.19 Using Inheritance in Your Business Domain Layer
- 5 Defining SQL Queries Using View Objects
- 5.1 About View Objects
- 5.2 Populating View Object Rows from a Single Database Table
- 5.3 Creating View Objects Populated With Static Data
- 5.4 Adding Calculated and Transient Attributes to a View Object
- 5.4.1 How to Add a SQL-Calculated Attribute
- 5.4.2 What Happens When You Add a SQL-Calculated Attribute
- 5.4.3 What You May Need to Know About SQL-Calculated Attributes
- 5.4.4 How to Add a Transient Attribute
- 5.4.5 How to Add a Transient Attribute Defined by an Entity Object
- 5.4.6 How to Add a Validation Rule to a Transient Attribute
- 5.4.7 What Happens When You Add a Transient Attribute
- 5.4.8 What You May Need to Know About Transient Attributes and Calculated Values
- 5.5 Limiting View Object Rows Using Effective Date Ranges
- 5.5.1 How to Create a Date-Effective View Object
- 5.5.2 How to Create New View Rows Using Date-Effective View Objects
- 5.5.3 How to Update Date-Effective View Rows
- 5.5.4 How to Delete Date-Effective View Rows
- 5.5.5 What Happens When You Create a Date-Effective View Object
- 5.5.6 What You May Need to Know About Date-Effective View Objects and View Links
- 5.6 Working with Multiple Tables in Join Query Results
- 5.6.1 How to Create Joins for Entity-Based View Objects
- 5.6.2 How to Modify a Default Join Clause to Be an Outer Join When Appropriate
- 5.6.3 How to Select Additional Attributes from Reference Entity Usages
- 5.6.4 How to Remove Unnecessary Key Attributes from Reference Entity Usages
- 5.6.5 How to Hide the Primary Key Attributes from Reference Entity Usages
- 5.6.6 What Happens When You Reference Multiple Entities in a View Object
- 5.6.7 What You May Need to Know About Outer Joins
- 5.6.8 What You May Need to Know About Entity Based Joins and Entity Cardinality
- 5.6.9 What You May Need to Know About Entity Based Joins and Participates in Row Delete
- 5.6.10 What You May Need to Know About Composition Associations and Joins
- 5.6.11 How to Create Joins for Read-Only View Objects
- 5.6.12 How to Test the Join View
- 5.6.13 How to Use the SQL Statement Dialog with Read-Only View Objects
- 5.7 Working with View Objects in Declarative SQL Mode
- 5.7.1 How to Create Declarative SQL View Objects
- 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 Support Programmatic Execution of 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: Declarative SQL Mode Queries
- 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.9 Working with Named View Criteria
- 5.9.1 How to Create Named View Criteria Declaratively
- 5.9.2 What Happens When You Create a Named View Criteria
- 5.9.3 What You May Need to Know About Bind Variables in View Criteria
- 5.9.4 What You May Need to Know About Nested View Criteria Expressions
- 5.9.5 How to Set User Interface Hints on View Criteria to Support Search Forms
- 5.9.6 How to Test View Criteria Using the Oracle ADF Model Tester
- 5.9.7 How to Use View Criteria to Filter a View Object for the Current User
- 5.9.8 How to Create View Criteria Programmatically
- 5.9.9 What Happens at Runtime: How the View Criteria Is Applied to a View Object
- 5.9.10 What You May Need to Know About the View Criteria API
- 5.9.11 What You May Need to Know About Query-by-Example Criteria
- 5.10 Working with Bind Variables
- 5.10.1 How to Add View Criteria Bind Variables to a View Object Definition
- 5.10.2 How to Add WHERE Clause Bind Variables to a View Object Definition
- 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 WHERE Clause Bind Variable Values at Runtime
- 5.10.7 What Happens at Runtime: Dynamic Read-Only View Object WHERE Clause
- 5.10.8 What You May Need to Know About Named Bind Variables
- 5.11 Working with Row Finders
- 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.3 How to Specify Multiple LOVs for a Single LOV-Enabled View Object Attribute
- 5.12.4 How to Define an LOV to Display a Reference Attribute
- 5.12.5 How to Set User Interface Hints on a View Object LOV-Enabled Attribute
- 5.12.6 How to Handle Date Conversion for List Type UI Components
- 5.12.7 How to Automatically Refresh the View Object of the View Accessor
- 5.12.8 How to Test LOV-Enabled Attributes Using the Oracle ADF Model Tester
- 5.12.9 What Happens When You Define an LOV for a View Object Attribute
- 5.12.10 What Happens at Runtime: How an LOV Queries the List Data Source
- 5.12.11 What You May Need to Know About Lists
- 5.13 Defining UI Hints for View Objects
- 5.13.1 How to Add Attribute-Specific UI Hints
- 5.13.2 How to Add View Object UI Hints
- 5.13.3 How to Access UI Hints Using EL Expressions
- 5.13.4 What Happens When You Add UI Hints
- 5.13.5 How to Define UI Category Hints
- 5.13.6 What Happens When You Assign Attributes to UI Categories
- 5.13.7 What You May Need to Know About Resource Bundles
- 6 Defining Master-Detail Related View Objects
- 6.1 About Master-Detail View Objects
- 6.2 Working with Multiple Tables in a Master-Detail Hierarchy
- 6.2.1 How to Create a Master-Detail Hierarchy Based on Entity Associations
- 6.2.2 How to Create a Master-Detail Hierarchy Based on View Objects Alone
- 6.2.3 What Happens When You Create Master-Detail Hierarchies Using View Links
- 6.2.4 How to Enable Active Master-Detail Coordination in the Data Model
- 6.2.5 How to Test Master-Detail Coordination
- 6.2.6 How to Access the Detail Collection Using the View Link Accessor
- 6.2.7 How to Create a Master-Detail Hierarchy for Entity Objects Consisting of Transient-Only Attributes
- 6.2.8 How to Find Rows of a Master View Object Using Row Finders
- 6.3 Working with a Single Table in a Recursive Master-Detail Hierarchy
- 6.4 Working with Master-Detail Related View Objects in View Criteria
- 7 Defining Polymorphic View Objects
- 8 Testing View Instance Queries
- 8.1 About View Instance Queries
- 8.2 Creating an Application Module to Test View Instances
- 8.3 Testing View Object Instances Using the Oracle ADF Model Tester
- 8.3.1 How to Run the Oracle ADF Model Tester
- 8.3.2 How to Run the Oracle ADF Model Tester Using Configurations
- 8.3.3 How to Test Language Message Bundles and UI Hints
- 8.3.4 How to Test Entity-Based View Objects Interactively
- 8.3.5 How to Update the Oracle ADF Model Tester to Display Project Changes
- 8.3.6 What Happens When You Use the Oracle ADF Model Tester
- 8.3.7 How to Simulate End-User Interaction in the Oracle ADF Model Tester
- 8.3.8 How to Test Multiuser Scenarios in the Oracle ADF Model Tester
- 8.3.9 How to Customize Configuration Options Before Running the Tester
- 8.3.10 How to Enable ADF Business Components Debug Diagnostics
- 8.3.11 What Happens at Runtime: How View Objects and Entity Objects Cooperate
- 8.3.12 What You May Need to Know About Optimizing View Object Runtime Performance
- 8.4 Testing View Object Instances Programmatically
- 8.4.1 ViewObject Interface Methods for Working with the View Object's Default RowSet
- 8.4.2 How to Create a Command-Line Java Test Client
- 8.4.3 What Happens When You Run a Test Client Program
- 8.4.4 What You May Need to Know About Running a Test Client
- 8.4.5 How to Count the Number of Rows in a Row Set
- 8.4.6 How to Access a Detail Collection Using the View Link Accessor
- 8.4.7 How to Iterate Over a Master-Detail-Detail Hierarchy
- 8.4.8 How to Find a Row and Update a Foreign Key Value
- 8.4.9 How to Create a New Row for a View Object Instance
- 8.4.10 How to Retrieve the Row Key Identifying a Row
- 8.4.11 How to Authenticate Test Users in the Test Client
- 9 Tuning View Object Performance
- 9.1 About View Object Tuning
- 9.1.1 Limiting the Maximum Number of Records Fetched for a View Object
- 9.1.2 Maintaining New Row Consistency in View Objects Based on the Same Entity
- 9.1.3 Understanding View Link Accessors Versus Data Model View Link Instances
- 9.1.4 Presenting and Scrolling Data a Page at a Time Using the Range
- 9.1.5 Efficiently Scrolling Through Large Result Sets Using Range Paging
- 9.1.6 Setting Up a Data Model with Multiple Masters
- 9.1.7 Understanding When You Can Use Partial Keys with findByKey()
- 9.1.8 Handling View Object Queries with Primary Keys Defined by Transient Attributes
- 9.1.9 Creating Dynamic Attributes to Store UI State
- 9.1.10 Working with Multiple Row Sets and Row Set Iterators
- 9.1.11 Optimizing View Link Accessor Access By Retaining the Row Set
- 9.2 Tuning Your View Objects for Best Performance
- 9.1 About View Object Tuning
- 10 Working Programmatically with View Objects
- 10.1 Generating Custom Java Classes for a View Object
- 10.2 Working Programmatically with Multiple Named View Criteria
- 10.3 Performing In-Memory Sorting and Filtering of Row Sets
- 10.4 Reading and Writing XML
- 10.5 Using Programmatic View Objects for Alternative Data Sources
- 10.6 Creating a View Object with Multiple Updatable Entities
- 10.7 Programmatically Creating View Definitions and View Objects
- 10.8 Declaratively Preventing Insert, Update, and Delete
- 11 Defining Validation and Business Rules Declaratively
- 11.1 About Declarative Validation
- 11.2 Understanding the Validation Cycle
- 11.2.1 Types of Entity Object Validation Rules
- 11.2.2 Understanding Commit Processing and Validation
- 11.2.3 Understanding the Impact of Composition on Validation Order
- 11.2.4 Avoiding Infinite Validation Cycles
- 11.2.5 What Happens When Validations Fail
- 11.2.6 Understanding Entity Objects Row States
- 11.2.7 Understanding Bundled Exception Mode
- 11.3 Adding Validation Rules to Entity Objects and Attributes
- 11.3.1 How to Add a Validation Rule to an Entity or Attribute
- 11.3.2 How to View and Edit a Validation Rule on an Entity Object or Attribute
- 11.3.3 What Happens When You Add a Validation Rule
- 11.3.4 What You May Need to Know About Entity and Attribute Validation Rules
- 11.3.5 What You May Need to Know About List of Values and Attribute Validation Rules
- 11.4 Using the Built-in Declarative Validation Rules
- 11.4.1 How to Ensure That Key Values Are Unique
- 11.4.2 What Happens When You Use a Unique Key Validator
- 11.4.3 How to Validate Based on a Comparison
- 11.4.4 What Happens When You Validate Based on a Comparison
- 11.4.5 How to Validate Using a List of Values
- 11.4.6 What Happens When You Validate Using a List of Values
- 11.4.7 What You May Need to Know About the List Validator
- 11.4.8 How to Make Sure a Value Falls Within a Certain Range
- 11.4.9 What Happens When You Use a Range Validator
- 11.4.10 How to Validate Against a Number of Bytes or Characters
- 11.4.11 What Happens When You Validate Against a Number of Bytes or Characters
- 11.4.12 How to Validate Using a Regular Expression
- 11.4.13 What Happens When You Validate Using a Regular Expression
- 11.4.14 How to Use the Average, Count, or Sum to Validate a Collection
- 11.4.15 What Happens When You Use Collection Validation
- 11.4.16 How to Determine Whether a Key Exists
- 11.4.17 What Happens When You Use a Key Exists Validator
- 11.4.18 What You May Need to Know About Declarative Validators and View Accessors
- 11.5 Using Groovy Expressions For Validation and Business Rules
- 11.6 Triggering Validation Execution
- 11.6.1 How to Specify Which Attributes Fire Validation
- 11.6.2 What Happens When You Constrain Validation Execution with Triggering Attributes
- 11.6.3 How to Set Preconditions for Validation
- 11.6.4 How to Set Transaction-Level Validation
- 11.6.5 What You May Need to Know About the Order of Validation Execution
- 11.7 Creating Validation Error Messages
- 11.8 Setting the Severity Level for Validation Exceptions
- 11.9 Bulk Validation in SQL
- 12 Implementing Validation and Business Rules Programmatically
- 12.1 About Programmatic Business Rules
- 12.2 Using Method Validators
- 12.2.1 How to Create an Attribute-Level Method Validator
- 12.2.2 What Happens When You Create an Attribute-Level Method Validator
- 12.2.3 How to Create an Entity-Level Method Validator
- 12.2.4 What Happens When You Create an Entity-Level Method Validator
- 12.2.5 What You May Need to Know About Translating Validation Rule Error Messages
- 12.3 Assigning Programmatically Derived Attribute Values
- 12.4 Undoing Pending Changes to an Entity Using the Refresh Method
- 12.5 Using View Objects for Validation
- 12.6 Accessing Related Entity Rows Using Association Accessors
- 12.7 Referencing Information About the Authenticated User
- 12.8 Accessing Original Attribute Values
- 12.9 Storing Information About the Current User Session
- 12.10 Accessing the Current Date and Time
- 12.11 Sending Notifications Upon a Successful Commit
- 12.12 Conditionally Preventing an Entity Row from Being Removed
- 12.13 Determining Conditional Updatability for Attributes
- 12.14 Implementing Custom Validation Rules
- 13 Implementing Business Services with Application Modules
- 13.1 About Application Modules
- 13.2 Creating and Modifying an Application Module
- 13.2.1 How to Create an Application Module
- 13.2.2 What Happens When You Create an Application Module
- 13.2.3 How to Add a View Object Instance to an Application Module
- 13.2.4 What Happens When You Add a View Object Instance to an Application Module
- 13.2.5 How to Edit an Existing Application Module
- 13.2.6 How to Change the Data Control Name Before You Begin Building Pages
- 13.2.7 What You May Need to Know About Application Module Granularity
- 13.2.8 What You May Need to Know About View Object Components and View Object Instances
- 13.3 Configuring Your Application Module Database Connection
- 13.3.1 How to Use a JDBC Data Source Connection Type
- 13.3.2 How to Use a JDBC URL Connection Type
- 13.3.3 What Happens When You Create an Application Module Database Connection
- 13.3.4 How to Change Your Application Module's Runtime Configuration
- 13.3.5 How to Change the Database Connection for Your Project
- 13.4 Defining Nested Application Modules
- 13.5 Creating an Application Module Diagram for Your Business Service
- 13.5.1 How to Create an Application Module Diagram
- 13.5.2 What Happens When You Create an Application Module Diagram
- 13.5.3 How to Use the Diagram to Edit the Application Module
- 13.5.4 How to Control Diagram Display Options
- 13.5.5 How to Filter Method Names Displayed in the Diagram
- 13.5.6 How to Show Related Objects and Implementation Files in the Diagram
- 13.5.7 How to Publish the Application Module Diagram
- 13.5.8 How to Test the Application Module from the Diagram
- 13.6 Supporting Multipage Units of Work
- 13.7 Customizing an Application Module with Service Methods
- 13.7.1 How to Generate a Custom Class for an Application Module
- 13.7.2 What Happens When You Generate a Custom Class for an Application Module
- 13.7.3 What You May Need to Know About Default Code Generation
- 13.7.4 How to Add a Custom Service Method to an Application Module
- 13.7.5 How to Test the Custom Application Module Using a Static Main Method
- 13.7.6 What You May Need to Know About Programmatic Row Set Iteration
- 13.8 Customizing Application Module Message Strings
- 13.9 Publishing Custom Service Methods to UI Clients
- 13.9.1 How to Publish a Custom Method on the Application Module's Client Interface
- 13.9.2 What Happens When You Publish Custom Service Methods
- 13.9.3 How to Generate Client Interfaces for View Objects and View Rows
- 13.9.4 How to Test Custom Service Methods Using the Oracle ADF Model Tester
- 13.9.5 What You May Need to Know About Method Signatures on the Client Interface
- 13.9.6 What You May Need to Know About Passing Information from the Data Model
- 13.10 Working Programmatically with an Application Module's Client Interface
- 13.11 Overriding Built-in Framework Methods
- 13.12 Calling a Web Service from an Application Module
- 13.12.1 How to Call an External Service Programmatically
- 13.12.2 What Happens When You Create the Web Service Proxy
- 13.12.3 How to Create a New Web Service Connection
- 13.12.4 What Happens at Runtime: How the Web Service Proxy Handles a Web Service Invocation
- 13.12.5 What You May Need to Know About Web Service Proxies
- 14 Sharing Application Module View Instances
- 14.1 About Shared Application Modules
- 14.2 Sharing an Application Module Instance
- 14.2.1 How to Create a Shared Application Module Instance
- 14.2.2 What Happens When You Define a Shared Application Module
- 14.2.3 What You May Need to Know About Design Time Scope of the Shared Application Module
- 14.2.4 What You May Need to Know About the Design Time Scope of View Instances of the Shared Application Module
- 14.2.5 What You May Need to Know About Managing the Number of Shared Query Collections
- 14.2.6 What You May Need to Know About Shared Application Modules and Connection Pooling
- 14.3 Defining a Base View Object for Use with Lookup Tables
- 14.3.1 How to Create a Base View Object Definition for a Lookup Table
- 14.3.2 What Happens When You Create a Base View Object
- 14.3.3 How to Define the WHERE Clause of the Lookup View Object Using View Criteria
- 14.3.4 What Happens When You Create a View Criteria with the Editor
- 14.3.5 What Happens at Runtime: How a View Instance Accesses Lookup Data
- 14.4 Accessing View Instances of the Shared Service
- 14.4.1 How to Create a View Accessor for an Entity Object or View Object
- 14.4.2 How to Validate Against the Attribute Values Specified by a View Accessor
- 14.4.3 What Happens When You Define a View Accessor Validator
- 14.4.4 What You May Need to Know About Dynamic Filtering with View Accessors
- 14.4.5 How to Create an LOV Based on a Lookup Table
- 14.4.6 What Happens When You Define an LOV for a View Object Attribute
- 14.4.7 How to Automatically Refresh the View Object of the View Accessor
- 14.4.8 What Happens at Runtime: How the Attribute Displays the List of Values
- 14.4.9 What You May Need to Know About Displaying List of Values From a Lookup Table
- 14.4.10 What You May Need to Know About Programmatically Invoking Database Change Notifications
- 14.4.11 What You May Need to Know About Inheritance of AttributeDef Properties
- 14.4.12 What You May Need to Know About Using Validators
- 14.5 Testing View Object Instances in a Shared Application Module
- 14.5.1 How to Test the Base View Object Using the Oracle ADF Model Tester
- 14.5.2 How to Test LOV-Enabled Attributes Using the Oracle ADF Model Tester
- 14.5.3 What Happens When You Use the Oracle ADF Model Tester
- 14.5.4 What Happens at Runtime: How Another Service Accesses the Shared Application Module Cache
- 15 Integrating Service-Enabled Application Modules
- 15.1 About Service-Enabled Application Modules
- 15.2 Publishing Service-Enabled Application Modules
- 15.2.1 How to Enable the Application Module Service Interface
- 15.2.2 What Happens When You Create an Application Module Service Interface
- 15.2.3 What You May Need to Know About Method Signatures on the ADF Web Service Interface
- 15.2.4 What You May Need to Know About Row Finders and the ADF Web Service Operations
- 15.2.5 How to Service-Enable Individual View Objects
- 15.2.6 How to Customize the SDO Properties of Service-Enabled View Objects
- 15.2.7 How to Support Nested Processing in Service-Enabled Master-Detail View Objects
- 15.2.8 What Happens When You Create SDO Classes
- 15.2.9 How to Expose a Declarative Find Operation Filtered By a Required Bind Variable
- 15.2.10 How to Expose a Custom Find Method Filtered By a Required Bind Variable
- 15.2.11 How to Generate Asynchronous ADF Web Service Methods
- 15.2.12 What Happens When You Generate Asynchronous ADF Web Service Methods
- 15.2.13 What Happens at Runtime: How the Asynchronous Call Is Made
- 15.2.14 How to Set Preferences for Generating the ADF Web Service Interface
- 15.2.15 How to Secure the ADF Web Service for Access By SOAP Clients
- 15.2.16 How to Secure the ADF Web Service for Access By RMI Clients
- 15.2.17 How to Grant Test Users Access to the Service
- 15.2.18 How to Enable Support for Binary Attachments for SOAP Clients
- 15.2.19 How to Test the Web Service Using Integrated WebLogic Server
- 15.2.20 How to Prevent Custom Service Methods from Timing Out
- 15.2.21 How to Deploy Web Services to Oracle WebLogic Server
- 15.3 Accessing Remote Data Over the Service-Enabled Application Module
- 15.3.1 How to Use Service-Enabled Entity Objects and View Objects
- 15.3.2 What Happens When You Create Service-Backed Business Components
- 15.3.3 How to Update the Data Model for Service-Backed Business Components
- 15.3.4 How to Configure the Service-Backed Business Components Runtime
- 15.3.5 How to Test the Service-Backed Components in the Oracle ADF Model Tester
- 15.3.6 How to Invoke Operations of the Service-Backed Components in the Consuming Application
- 15.3.7 What You May Need to Know About Creating Service Data Objects in the Consuming Application
- 15.3.8 What Happens at Runtime: How the Application Accesses the Published Application Module
- 15.3.9 What You May Need to Know About Service-Backed Entity Objects and View Objects
- 16 Extending Business Components Functionality
- 16.1 About Extending Business Components Functionality
- 16.2 Creating ADF Business Components Extension Classes
- 16.2.1 How To Create a Framework Extension Class
- 16.2.2 What Happens When You Create a Framework Extension Class
- 16.2.3 What You May Need to Know About Customizing Framework Extension Bases Classes
- 16.2.4 How to Base a Business Component on a Framework Extension Class
- 16.2.5 How to Define Framework Extension Classes for All New Components
- 16.2.6 How to Define Framework Extension Classes for All New Projects
- 16.2.7 What Happens When You Base a Component on a Framework Extension Class
- 16.2.8 What You May Need to Know About Updating the Extends Clause in Custom Component Java Files
- 16.2.9 How to Package Your Framework Extension Layer in a JAR File
- 16.2.10 How to Create a Library Definition for Your Framework Extension JAR File
- 16.3 Customizing Framework Behavior with Extension Classes
- 16.3.1 How to Access Runtime Metadata For View Objects and Entity Objects
- 16.3.2 How to Implement Generic Functionality Using Runtime Metadata
- 16.3.3 How to Implement Generic Functionality Driven by Custom Properties
- 16.3.4 What You May Need to Know About the Kinds of Attributes
- 16.3.5 What You May Need to Know About Custom Properties
- 16.4 Creating Generic Extension Interfaces
- 16.5 Invoking Stored Procedures and Functions
- 16.6 Accessing the Current Database Transaction
- 16.7 Customizing Business Components Error Messages
- 16.7.1 How to Customize Base ADF Business Components Error Messages
- 16.7.2 What Happens When You Customize Base ADF Business Components Error Messages
- 16.7.3 How to Display Customize Error Messages as Nested Exceptions
- 16.7.4 How to Customize Error Messages for Database Constraint Violations
- 16.7.5 How to Implement a Custom Constraint Error Handling Routine
- 16.8 Creating Extended Components Using Inheritance
- 16.9 Substituting Extended Components in a Delivered Application
- 3 Getting Started with ADF Business Components
- Part III Using the ADF Model Layer
- 17 Using ADF Model in a Fusion Web Application
- 17.1 About Using ADF Model in a Fusion Web Application
- 17.2 Additional Functionality
- 17.3 Exposing Application Modules with ADF Data Controls
- 17.4 Using the Data Controls Panel
- 17.5 Working with the DataBindings.cpx File
- 17.6 Configuring the ADF Binding Filter
- 17.7 Working with Page Definition Files
- 17.8 Creating ADF Data Binding EL Expressions
- 17.9 Using Simple UI First Development
- 18 Using Validation in the ADF Model Layer
- 19 Designing a Page Using Placeholder Data Controls
- 19.1 About Placeholder Data Controls
- 19.2 Creating Placeholder Data Controls
- 19.3 Creating Placeholder Data Types
- 19.3.1 How to Create a Placeholder Data Type
- 19.3.2 How to Add Attributes and Sample Data to a Placeholder Data Type
- 19.3.3 What Happens When You Create a Placeholder Data Type
- 19.3.4 How to Configure a Placeholder Data Type Attribute to Be a List of Values
- 19.3.5 How to Create Master-Detail Data Types
- 19.3.6 What Happens When You Create a Master-Detail Data Type
- 19.4 Using Placeholder Data Controls
- 17 Using ADF Model in a Fusion Web Application
- Part IV Creating ADF Task Flows
- 20 Getting Started with ADF Task Flows
- 20.1 About ADF Task Flows
- 20.2 Creating a Task Flow
- 20.2.1 How to Create a Task Flow
- 20.2.2 What Happens When You Create a Task Flow
- 20.2.3 What You May Need to Know About the Default Activity in a Bounded Task Flow
- 20.2.4 What You May Need to Know About Memory Scope for Task Flows
- 20.2.5 What You May Need to Know About the Source Files for Task Flows
- 20.3 Adding Activities to a Task Flow
- 20.4 Adding Control Flow Rules to Task Flows
- 20.5 Testing Task Flows
- 20.5.1 How to Run a Bounded Task Flow That Contains Pages
- 20.5.2 How to Run a Bounded Task Flow That Uses Page Fragments
- 20.5.3 How to Run a Bounded Task Flow That Has Parameters
- 20.5.4 How to Run a JSF Page When Testing a Task Flow
- 20.5.5 How to Run an Unbounded Task Flow
- 20.5.6 How to Set a Run Configuration for a Project
- 20.5.7 What Happens at Runtime: Testing Task Flows
- 20.6 Refactoring to Create New Task Flows and Task Flow Templates
- 21 Working with Task Flow Activities
- 21.1 About Task Flow Activities
- 21.2 Using View Activities
- 21.3 Using URL View Activities
- 21.4 Using Router Activities
- 21.5 Using Method Call Activities
- 21.6 Using Task Flow Call Activities
- 21.6.1 How to Call a Bounded Task Flow Using a Task Flow Call Activity
- 21.6.2 What Happens When You Call a Bounded Task Flow Using a Task Flow Call Activity
- 21.6.3 How to Specify Input Parameters on a Task Flow Call Activity
- 21.6.4 How to Call a Bounded Task Flow Using a URL
- 21.6.5 What Happens When You Configure a Bounded Task Flow to be Invoked by a URL
- 21.6.6 What You May Need to Know About Calling a Bounded Task Flow Using a URL
- 21.6.7 How to Specify Before and After Listeners on a Task Flow Call Activity
- 21.6.8 What Happens When You Add a Task Flow Call Activity
- 21.6.9 What Happens at Runtime: How a Task Flow Call Activity Invokes a Task Flow
- 21.7 Using Task Flow Return Activities
- 21.8 Using Task Flow Activities with Page Definition Files
- 22 Using Parameters in Task Flows
- 23 Using Task Flows as Regions
- 23.1 About Using Task Flows in ADF Regions
- 23.2 Creating an ADF Region
- 23.3 Specifying Parameters for an ADF Region
- 23.4 Specifying Parameters for ADF Regions Using Parameter Maps
- 23.5 Configuring an ADF Region to Refresh
- 23.6 Configuring Activation of an ADF Region
- 23.7 Navigating Outside an ADF Region's Task Flow
- 23.8 Configuring Transaction Management in an ADF Region
- 23.9 Creating ADF Dynamic Regions
- 23.10 Adding Additional Task Flows to an ADF Dynamic Region
- 23.11 Configuring a Page To Render an Unknown Number of Regions
- 23.12 Handling Access to Secured Task Flows by Unauthorized Users
- 24 Creating Complex Task Flows
- 24.1 About Creating Complex Task Flows
- 24.2 Sharing Data Controls Between Task Flows
- 24.3 Managing Transactions in Task Flows
- 24.3.1 How to Enable Transactions in a Bounded Task Flow
- 24.3.2 What Happens When You Specify Transaction Options
- 24.3.3 What You May Need to Know About Sharing Data Controls and Managing Transactions
- 24.3.4 What You May Need to Know About ADF Business Component Database Connections and Task Flow Transaction Options
- 24.4 Reentering Bounded Task Flows
- 24.5 Handling Exceptions in Task Flows
- 24.5.1 How to Designate an Activity as an Exception Handler
- 24.5.2 What Happens When You Designate an Activity as an Exception Handler
- 24.5.3 How to Designate Custom Code as an Exception Handler
- 24.5.4 What Happens When You Designate Custom Code as an Exception Handler
- 24.5.5 What You May Need to Know About Handling Exceptions During Transactions
- 24.5.6 What You May Need to Know About Handling Validation Errors
- 24.6 Configuring Your Application to Use Save Points
- 24.7 Using Save Points in Task Flows
- 24.7.1 How to Add a Save Point to a Task Flow
- 24.7.2 What Happens When You Add Save Points to a Task Flow
- 24.7.3 How to Restore a Save Point
- 24.7.4 What Happens When You Restore a Save Point
- 24.7.5 How to Use the Save Point Restore Finalizer
- 24.7.6 What Happens When a Task Flow Invokes a Save Point Restore Finalizer
- 24.7.7 How to Enable Implicit Save Points
- 24.7.8 What You May Need to Know About Enabling Implicit Save Points
- 24.7.9 What You May Need to Know About the Time-to-Live Period for a Save Point
- 24.8 Using Train Components in Bounded Task Flows
- 24.8.1 Creating a Task Flow as a Train
- 24.8.2 Invoking a Child Bounded Task Flow from a Train Stop
- 24.8.3 Grouping Task Flow Activities to Execute Between Train Stops
- 24.8.4 Disabling the Sequential Behavior of Train Stops in a Train
- 24.8.5 Changing the Label of a Train Stop
- 24.8.6 Configuring a Train to Skip a Train Stop
- 24.9 Creating Task Flow Templates
- 24.10 Creating a Page Hierarchy Using Task Flows
- 25 Using Dialogs in Your Application
- 25.1 About Using Dialogs in Your Application
- 25.2 Running a Bounded Task Flow in a Modal Dialog
- 25.3 Using the ADF Faces Dialog Framework Instead of Bounded Task Flows
- 25.3.1 How to Define a JSF Navigation Rule for Opening a Dialog
- 25.3.2 How to Create the JSF Page That Opens a Dialog
- 25.3.3 How to Create the Dialog Page and Return a Dialog Value
- 25.3.4 What Happens at Runtime: How to Raise the Return Event from the Dialog
- 25.3.5 How to Pass a Value into a Dialog
- 25.3.6 What Happens at Runtime: How the LaunchEvent is Handled
- 25.3.7 How to Handle the Return Value
- 25.3.8 What Happens at Runtime: How the Launching Component Handles the ReturnEvent
- 20 Getting Started with ADF Task Flows
- Part V Creating a Databound Web User Interface
- 26 Getting Started with Your Web Interface
- 27 Understanding the Fusion Page Lifecycle
- 28 Creating a Basic Databound Page
- 28.1 About Creating a Basic Databound Page
- 28.2 Creating Text Fields Using Data Control Attributes
- 28.3 Creating Basic Forms Using Data Control Collections
- 28.4 Creating Command Components Using Data Control Operations
- 28.5 Incorporating Range Navigation into Forms
- 28.5.1 How to Manually Insert Navigation Controls into a Form
- 28.5.2 What Happens When You Manually Add Navigation Buttons
- 28.5.3 What Happens at Runtime: Navigation Controls
- 28.5.4 What You May Need to Know About the Browser Back Button and Navigating Through Records
- 28.5.5 What You May Need to Know About the CacheResults Property
- 28.6 Creating a Form to Edit an Existing Record
- 28.7 Using Parameters to Create a Form
- 28.8 Creating an Input Form
- 28.8.1 How to Create an Input Form
- 28.8.2 What Happens When You Create an Input Form
- 28.8.3 What Happens at Runtime: CreateInsert Action from the Method Activity
- 28.8.4 What You May Need to Know About Displaying Sequence Numbers
- 28.8.5 What You May Need to Know About Input Forms Backed By Stateless Services
- 28.9 Creating a Form with Dynamic Components
- 28.9.1 About Dynamic Components
- 28.9.2 How to Create a Dynamic Form
- 28.9.3 What Happens When You Create Dynamic Forms
- 28.9.4 What Happens at Runtime: How Attribute Values Are Dynamically Determined
- 28.9.5 How to Apply Validators and Converters to a Dynamic Component
- 28.9.6 What You May Need to Know About Mixing Dynamic Components with Static Components
- 28.9.7 How to Programmatically Set Dynamic Component Behavior
- 28.9.8 How to Access a Dynamic Component Programmatically
- 28.9.9 How to Access a Dynamic Component's Binding Instance Programmatically
- 28.10 Modifying the UI Components and Bindings on a Form
- 29 Creating ADF Databound Tables
- 29.1 About Creating ADF Databound Tables
- 29.2 Creating a Basic Table
- 29.3 Creating an Editable Table
- 29.4 Creating an Input Table
- 29.4.1 How to Create an Input Table
- 29.4.2 What Happens When You Create an Input Table
- 29.4.3 What Happens at Runtime: How CreateInsert and Partial Page Refresh Work
- 29.4.4 What You May Need to Know About Creating a Row and Sorting Columns
- 29.4.5 What You May Need to Know About Create and CreateInsert
- 29.4.6 What You May Need to Know About Saving Multiple Rows in a JPA-Based Data Control
- 29.5 Creating a Table with Dynamic Components
- 29.6 Modifying the Attributes Displayed in the Table
- 30 Using Command Components to Invoke Functionality in the View Layer
- 31 Displaying Master-Detail Data
- 31.1 About Displaying Master-Detail Data
- 31.2 Prerequisites for Master-Detail Tables, Forms, and Trees
- 31.3 Using Tables and Forms to Display Master-Detail Objects
- 31.3.1 How to Display Master-Detail Objects in Tables and Forms Using Master-Detail Widgets
- 31.3.2 How to Create Master-Detail Forms from Separate Components
- 31.3.3 What Happens When You Create Master-Detail Tables and Forms
- 31.3.4 What Happens at Runtime: ADF Iterator for Master-Detail Tables and Forms
- 31.3.5 How to Display Master-Detail Components on Separate Pages
- 31.4 Using Trees to Display Master-Detail Objects
- 31.5 Using Tree Tables to Display Master-Detail Objects
- 31.6 About Selection Events in Trees and Tree Tables
- 32 Creating Databound Selection Lists and Shuttles
- 32.1 About Selection Lists and Shuttles
- 32.2 Creating List of Values (LOV) Components
- 32.3 Creating a Selection List
- 32.3.1 How to Create a Model-Driven List
- 32.3.2 What Happens When You Create a Model-Driven Selection List
- 32.3.3 How to Create a Selection List Containing Fixed Values
- 32.3.4 What Happens When You Create a Fixed Selection List
- 32.3.5 How to Create a Selection List Containing Dynamically Generated Values
- 32.3.6 What Happens When You Create a Dynamic Selection List
- 32.3.7 What You May Need to Know About Values in a Selection List
- 32.4 Creating a List with Navigation List Binding
- 32.5 Creating a Databound Shuttle
- 33 Creating ADF Databound Search Forms
- 33.1 About Creating Search Forms
- 33.2 Creating Query Search Forms
- 33.2.1 Named Bind Variables in Query Search Forms
- 33.2.2 How to Create a Query Search Form with a Results Table or Tree Table
- 33.2.3 How to Create a Query Search Form and Add a Results Component Later
- 33.2.4 How to Persist Saved Searches into MDS
- 33.2.5 What You May Need to Know about Default Search Binding Behavior
- 33.2.6 What You May Need to Know About Dependent Criterion
- 33.2.7 What Happens When You Create a Query Form
- 33.2.8 What Happens at Runtime: Search Forms
- 33.3 Setting Up Search Form Properties
- 33.4 Creating Quick Query Search Forms
- 33.4.1 How to Create a Quick Query Search Form with a Results Table or Tree Table
- 33.4.2 How to Create a Quick Query Search Form and Add a Results Component Later
- 33.4.3 How to Set the Quick Query Layout Format
- 33.4.4 What Happens When You Create a Quick Query Search Form
- 33.4.5 What Happens at Runtime: Quick Query
- 33.5 Creating Standalone Filtered Search Tables from Named View Criteria
- 34 Using More Complex Databound ADF Faces Components
- 35 Creating Databound Graph and Gauge Components
- 35.1 About ADF Data Visualization Graph and Gauge Components
- 35.2 Creating Databound Graphs
- 35.2.1 How to Create an Area, Bar, or Line Graph Using Data Controls
- 35.2.2 What Happens When You Use the Data Controls Panel to Create a Graph
- 35.2.3 What You May Need to Know About Using Attribute Labels
- 35.2.4 What You May Need to Know About Using a Graph's Row Selection Listener for Master-Detail Processing
- 35.2.5 What You May Need to Know About Using Name-Value Pairs
- 35.2.6 How to Create a Stock Graph Using Name-Value Pairs
- 35.2.7 Creating a Databound Spark Chart Using Data Controls
- 35.2.8 How to Create Databound Pie Graphs
- 35.2.9 Configuring Databound Graphs for Drilling
- 35.3 Creating Databound Gauges
- 36 Creating Databound Pivot Table and Pivot Filter Bar Components
- 36.1 About ADF Data Visualization Pivot Table and Pivot Filter Bar Components
- 36.2 Creating Databound Pivot Tables
- 36.2.1 How to Create a Pivot Table Using ADF Data Controls
- 36.2.2 What Happens When You Use the Data Controls Panel to Create a Pivot Table
- 36.2.3 What You May Need to Know About Aggregating Attributes in the Pivot Table
- 36.2.4 What You May Need to Know About Specifying an Initial Sort for a Pivot Table
- 36.2.5 What You May Need to Know About Configuring Editable Data Cells
- 37 Creating Databound Geographic and Thematic Map Components
- 37.1 About ADF Data Visualization Map Components
- 37.2 Creating Databound Geographic Maps
- 37.2.1 How to Configure a Geographic Base Map
- 37.2.2 How to Create a Geographic Map with a Point Theme
- 37.2.3 How to Create Point Style Items for a Point Theme
- 37.2.4 What Happens When You Create a Geographic Map with a Point Theme
- 37.2.5 What You May Need to Know About Adding Custom Point Style Items to a Map Point Theme
- 37.2.6 How to Create a Geographic Map with a Color Theme
- 37.2.7 What Happens When You Add a Color Theme to a Geographic Map
- 37.2.8 What You May Need to Know About Customizing Colors in a Map Color Theme
- 37.2.9 How to Create a Geographic Map with a Pie or Bar Graph Theme
- 37.2.10 What Happens When You Add a Pie or Bar Graph Theme to a Geographic Map
- 37.3 Creating Databound Thematic Maps
- 37.3.1 How to Create a Thematic Map Using ADF Data Controls
- 37.3.2 What Happens When You Use Data Controls to Create a Thematic Map
- 37.3.3 How to Add Data Layers to Thematic Maps
- 37.3.4 Styling Areas, Markers, and Images to Display Data
- 37.3.5 What You May Need to Know About Base Map Location Ids
- 37.3.6 What You May Need to Know About Configuring Master-Detail Relationships
- 37.3.7 How to Define a Custom Map Layer
- 37.3.8 How to Configure Drilling in Thematic Maps
- 37.3.9 Creating Databound Legends
- 38 Creating Databound Gantt Chart and Timeline Components
- 38.1 About ADF Data Visualization Components
- 38.2 Creating Databound Gantt Charts
- 38.2.1 How to Create a Databound Project Gantt Chart
- 38.2.2 What Happens When You Create a Project Gantt Chart from a Data Control
- 38.2.3 How to Create a Databound Resource Utilization Gantt Chart
- 38.2.4 What Happens When You Create a Resource Utilization Gantt Chart
- 38.2.5 How to Create a Databound Scheduling Gantt Chart
- 38.2.6 What Happens When You Create a Scheduling Gantt Chart
- 38.2.7 What You May Need to Know About Data Change Event Handling
- 38.3 Creating Databound Timelines
- 39 Creating Databound Hierarchy Viewer, Treemap, and Sunburst Components
- 40 Using Contextual Events
- Part VI Completing Your Application
- 41 Enabling ADF Security in a Fusion Web Application
- 41.1 About ADF Security
- 41.2 ADF Security Process Overview
- 41.3 Enabling ADF Security
- 41.3.1 How to Enable ADF Security
- 41.3.2 What Happens When You Enable ADF Security
- 41.3.3 What Happens When You Generate a Default Form-Based Login Page
- 41.3.4 What You May Need to Know About the Configure ADF Security Wizard
- 41.3.5 What You May Need to Know About ADF Authentication
- 41.3.6 What You May Need to Know About the Built-In test-all Role
- 41.3.7 What You May Need to Know About the valid-users Role
- 41.4 Creating Application Roles
- 41.5 Defining ADF Security Policies
- 41.5.1 How to Make an ADF Resource Public
- 41.5.2 What Happens When You Make an ADF Resource Public
- 41.5.3 What Happens at Runtime: How the Built-in Roles Are Used
- 41.5.4 How to Define Policies for ADF Bounded Task Flows
- 41.5.5 How to Define Policies for Web Pages That Reference a Page Definition
- 41.5.6 How to Define Policies to Control User Access to ADF Methods
- 41.5.7 What Happens When You Define the Security Policy
- 41.5.8 What Happens at Runtime: How ADF Security Policies Are Enforced
- 41.5.9 What You May Need to Know About Defining Policies for Pages with No ADF Bindings
- 41.5.10 How to Use Regular Expressions to Define Policies on Groups of Resources
- 41.5.11 How to Define Policies for Data
- 41.5.12 How to Aggregate Resource Grants as Entitlement Grants
- 41.5.13 What Happens After You Create an Entitlement Grant
- 41.6 Creating Test Users
- 41.7 Creating a Login Page
- 41.7.1 How to Create a Login Link Component and Add it to a Public Web Page for Explicit Authentication
- 41.7.2 How to Create a Login Page Specifically for Explicit Authentication
- 41.7.3 How to Ensure That the Custom Login Page's Resources Are Accessible for Explicit Authentication
- 41.7.4 How to Create a Public Welcome Page
- 41.7.5 How to Redirect a User After Authentication
- 41.7.6 How to Trigger a Custom Login Page Specifically for Implicit Authentication
- 41.7.7 What You May Need to Know About About Redirecting to a Different Host Server
- 41.7.8 What You May Need to Know About ADF Servlet Logout and Browser Caching
- 41.7.9 What You May Need to Know About Displaying Error Pages in Internet Explorer
- 41.8 Testing Security in JDeveloper
- 41.8.1 How to Configure, Deploy, and Run a Secure Application in JDeveloper
- 41.8.2 What Happens When You Configure Security Deployment Options
- 41.8.3 How to Use the Built-In test-all Application Role
- 41.8.4 What Happens at Runtime: How ADF Security Handles Authentication
- 41.8.5 What Happens at Runtime: How ADF Security Handles Authorization
- 41.9 Preparing the Secure Application for Deployment
- 41.10 Disabling ADF Security
- 41.11 Advanced Topics and Best Practices
- 41.11.1 Using Expression Language (EL) with ADF Security
- 41.11.2 How to Protect UI Components Using OPSS Resource Permissions and EL
- 41.11.3 How to Perform Authorization Checks for Entity Object Operations
- 41.11.4 Getting Information from the ADF Security Context
- 41.11.5 Best Practices for Working with ADF Security
- 42 Testing and Debugging ADF Components
- 42.1 About ADF Debugging
- 42.2 Correcting Simple Oracle ADF Compilation Errors
- 42.3 Correcting Simple Oracle ADF Runtime Errors
- 42.4 Reloading Oracle ADF Metadata in Integrated WebLogic Server
- 42.5 Validating ADF Controller Metadata
- 42.6 Using the ADF Logger
- 42.6.1 How to Set ADF Logging Levels
- 42.6.2 How to Create an Oracle ADF Debugging Configuration
- 42.6.3 How to Turn On Diagnostic Logging for Non-Oracle ADF Loggers
- 42.6.4 How to Use the Log Analyzer to View Log Messages
- 42.6.5 What You May Need to Know About the Logging.xml File
- 42.6.6 What You May Need to Know About ADF Logging and Oracle WebLogic Server
- 42.7 Using the Oracle ADF Model Tester for Testing and Debugging
- 42.7.1 How to Run in Debug Mode and Test with the Oracle ADF Model Tester
- 42.7.2 How to Run the Oracle ADF Model Tester and Test with a Specific Application Module Configuration
- 42.7.3 What Happens When You Run the Oracle ADF Model Tester in Debug Mode
- 42.7.4 How to Verify Runtime Artifacts in the Oracle ADF Model Tester
- 42.7.5 How to Refresh the Oracle ADF Model Tester with Application Changes
- 42.8 Using the ADF Declarative Debugger
- 42.9 Setting ADF Declarative Breakpoints
- 42.9.1 How to Set and Use Task Flow Activity Breakpoints
- 42.9.2 How to Set and Use Page Definition Executable Breakpoints
- 42.9.3 How to Set and Use Page Definition Action Binding Breakpoints
- 42.9.4 How to Set and Use Page Definition Value Binding Breakpoints
- 42.9.5 How to Set and Use Page Definition Contextual Event Breakpoints
- 42.9.6 How to Set and Use ADF Lifecycle Phase Breakpoints
- 42.9.7 How to Use the ADF Structure Window
- 42.9.8 How to Use the ADF Data Window
- 42.9.9 What Happens When You Set an ADF Declarative Breakpoint
- 42.10 Setting Java Code Breakpoints
- 42.10.1 How to Set Java Breakpoints on Classes and Methods
- 42.10.2 How to Optimize Use of the Source Editor
- 42.10.3 How to Set Breakpoints and Debug Using ADF Source Code
- 42.10.4 How to Use Debug Libraries for Symbolic Debugging
- 42.10.5 How to Use Different Kinds of Java Code Breakpoints
- 42.10.6 How to Edit Breakpoints for Improved Control
- 42.10.7 How to Filter Your View of Class Members
- 42.10.8 How to Use Common Oracle ADF Breakpoints
- 42.11 Regression Testing with JUnit
- 42.11.1 How to Obtain the JUnit Extension
- 42.11.2 How to Create a JUnit Test Case
- 42.11.3 How to Create a JUnit Test Fixture
- 42.11.4 How to Create a JUnit Test Suite
- 42.11.5 How to Create a Business Components Test Suite
- 42.11.6 How to a Create Business Components Test Fixture
- 42.11.7 How to Run a JUnit Test Suite as Part of an Ant Build Script
- 43 Refactoring a Fusion Web Application
- 43.1 About Refactoring a Fusion Web Application
- 43.2 Renaming Files
- 43.3 Moving JSF Pages
- 43.4 Refactoring pagedef.xml Bindings Objects
- 43.5 Refactoring ADF Business Components
- 43.6 Refactoring ADF Business Component Object Attributes
- 43.7 Refactoring Named Elements
- 43.8 Refactoring ADF Task Flows
- 43.9 Refactoring the DataBindings.cpx File
- 43.10 Refactoring Limitations
- 43.11 Moving the ADF Business Components Project Configuration File (.jpx)
- 44 Reusing Application Components
- 44.1 About Reusable Components
- 44.2 Packaging a Reusable ADF Component into an ADF Library
- 44.3 Adding ADF Library Components into Projects
- 44.3.1 How to Add an ADF Library JAR into a Project using the Resources Window
- 44.3.2 How to Add an ADF Library JAR into a Project Manually
- 44.3.3 What Happens When You Add an ADF Library JAR to a Project
- 44.3.4 What You May Need to Know About Using ADF Library Components
- 44.3.5 What You May Need to Know About Differentiating ADF Library Components
- 44.3.6 What Happens at Runtime: How ADF Libraries are Added to a Project
- 44.4 Removing an ADF Library JAR from a Project
- 45 Customizing Applications with MDS
- 45.1 About Customization and MDS
- 45.2 Developing a Customizable Application
- 45.2.1 How to Create Customization Classes
- 45.2.2 What You May Need to Know About Customization Classes
- 45.2.3 How to Consume Customization Classes
- 45.2.4 How to Enable Seeded Customizations for User Interface Projects
- 45.2.5 How to Enable Seeded Customizations in Existing Pages
- 45.2.6 How to Enable Customizations in Resource Bundles
- 45.2.7 How to Configure the adf-config.xml File
- 45.2.8 What Happens When You Create a Customizable Application
- 45.2.9 What You May Need to Know About Customizable Objects and Applications
- 45.3 Customizing an Application
- 45.3.1 Introducing the Customization Developer Role
- 45.3.2 How to Switch to the Customization Developer Role in JDeveloper
- 45.3.3 Introducing the Tip Layer
- 45.3.4 How to Configure Customization Layers
- 45.3.5 How to Customize Metadata in JDeveloper
- 45.3.6 What Happens When You Customize an Application
- 45.3.7 How to Customize ADF Library Artifacts in JDeveloper
- 45.3.8 How to View ADF Library Runtime Customizations from Exported JARs
- 45.3.9 What Happens When You Customize ADF Library Artifacts
- 45.3.10 What Happens at Runtime: How Customizations are Applied
- 45.3.11 What You May Need to Know About Customized Applications
- 45.4 How to Package and Deploy Customized Applications
- 45.5 Extended Metadata Properties
- 45.6 Enabling Runtime Modification of Customization Configuration
- 46 Allowing User Customizations at Runtime
- 46.1 About User Customizations
- 46.2 Enabling Runtime User Customizations for a Fusion Web Application
- 46.3 Configuring User Customizations
- 46.4 Controlling User Customizations in Individual JSF Pages
- 46.5 Implementing Custom User Customizations
- 46.6 Creating Implicit Change Persistence in Custom Components
- 47 Using the Active Data Service
- 47.1 About the Active Data Service
- 47.2 Configuring the Active Data Service
- 47.3 Configuring Components to Use the Active Data Service
- 47.3.1 How to Configure Components to Use the Active Data Service Without the Active Data Proxy
- 47.3.2 How to Configure Components to Use the Active Data Service with the Active Data Proxy
- 47.3.3 What You May Need to Know About Displaying Active Data in ADF Trees
- 47.3.4 What Happens at Runtime: How Components Render When Bound to Active Data
- 47.3.5 What You May Need to Know About Running ADS in a Google Chrome Browser
- 47.4 Using the Active Data Proxy
- 47.5 What You May Need to Know About Maintaining Read Consistency
- 47.6 Using the Active Data with a Scalar Model
- 48 Deploying Fusion Web Applications
- 48.1 About Deploying Fusion Web Applications
- 48.2 Running a Fusion Web Application in Integrated WebLogic Server
- 48.3 Preparing the Application
- 48.3.1 How to Create a Connection to the Target Application Server
- 48.3.2 How to Create Deployment Profiles
- 48.3.3 How to Create and Edit Deployment Descriptors
- 48.3.4 How to Deploy Applications with ADF Security Enabled
- 48.3.5 How to Replicate Memory Scopes in a Clustered Environment
- 48.3.6 How to Enable the Application for ADF MBeans
- 48.3.7 What You May Need to Know About JDBC Data Source for Oracle WebLogic Server
- 48.4 Deploying the Application
- 48.4.1 How to Deploy to the Application Server from JDeveloper
- 48.4.2 How to Create an EAR File for Deployment
- 48.4.3 How to Deploy New Customizations Applied to ADF Library
- 48.4.4 What You May Need to Know About ADF Libraries
- 48.4.5 What You May Need to Know About EAR Files and Packaging
- 48.4.6 How to Deploy the Application Using Scripts and Ant
- 48.4.7 How to Deploy ADF Faces Library JARs with the Application
- 48.4.8 What You May Need to Know About JDeveloper Runtime Libraries
- 48.5 Postdeployment Configuration
- 48.6 Testing the Application and Verifying Deployment
- 49 Using State Management in a Fusion Web Application
- 49.1 Understanding Why State Management is Necessary
- 49.2 Introduction to Fusion Web Application State Management
- 49.2.1 Basic Architecture of the Save for Later Facility
- 49.2.2 Basic Architecture of the Application Module State Management Facility
- 49.2.3 What You May Need to Know About Data Consistency and Application Module Affinity
- 49.2.4 What You May Need to Know About Using Application Scoped Managed Beans in a Clustered Environment
- 49.3 Using Save For Later
- 49.4 Setting the Application Module Release Level at Runtime
- 49.4.1 How to Set Unmanaged Level
- 49.4.2 How to Set Reserved Level
- 49.4.3 How to Set Managed Level
- 49.4.4 How to Set Release Level in a JSF Backing Bean
- 49.4.5 How to Set Release Level in an ADF PagePhaseListener
- 49.4.6 How to Set Release Level in an ADF PageController
- 49.4.7 How to Set Release Level in a Custom ADF PageLifecycle
- 49.5 What Model State Is Saved and When It Is Cleaned Up
- 49.6 Timing Out the HttpSession
- 49.7 Managing Custom User-Specific Information
- 49.8 Managing the State of View Objects
- 49.8.1 How to Manage the State of View Objects
- 49.8.2 What You May Need to Know About Passivating View Objects
- 49.8.3 How to Manage the State of Transient View Objects and Attributes
- 49.8.4 What You May Need to Know About Passivating Transient View Objects
- 49.8.5 How to Use Transient View Objects to Store Session-level Global Variables
- 49.9 Using State Management for Middle-Tier Savepoints
- 49.10 Testing to Ensure Your Application Module is Activation-Safe
- 49.11 Keeping Pending Changes in the Middle Tier
- 50 Tuning Application Module Pools and Connection Pools
- 50.1 About Application Module Pooling
- 50.2 Setting Pool Configuration Parameters
- 50.2.1 How to Set Configuration Properties Declaratively
- 50.2.2 What Happens When You Set Configuration Properties Declaratively
- 50.2.3 How to Set Configuration Properties as System Parameters
- 50.2.4 How to Programmatically Set Configuration Properties
- 50.2.5 What You May Need to Know About Configuration Property Scopes
- 50.2.6 What You May Need to Know About How Database and Application Module Pools Cooperate
- 50.2.7 What You May Need to Know About Application Module Pool Parameters
- 50.2.8 What You May Need to Know About Data Source Configuration
- 50.2.9 What You May Need to Know About Database Connection Pool Parameters
- 50.3 Initializing Database State and Pooling Considerations
- 50.4 Deployment Environment Scenarios and Pooling
- 41 Enabling ADF Security in a Fusion Web Application
- Part VII Appendices
- A Oracle ADF XML Files
- A.1 About ADF Metadata Files
- A.2 ADF File Overview Diagram
- A.3 ADF File Syntax Diagram
- A.4 adfm.xml
- A.5 modelProjectName.jpx
- A.6 bc4j.xcfg
- A.7 DataBindings.cpx
- A.8 pageNamePageDef.xml
- A.9 adfc-config.xml
- A.10 task-flow-definition.xml
- A.11 adf-config.xml
- A.12 adf-settings.xml
- A.13 web.xml
- A.14 logging.xml
- B Oracle ADF Binding Properties
- C ADF Security Permission Grants
- D Most Commonly Used ADF Business Components Methods
- E ADF Business Components Java EE Design Pattern Catalog
- F ADF Equivalents of Common Oracle Forms Triggers
- G Performing Common Oracle Forms Tasks in Oracle ADF
- G.1 Concepts Familiar to Oracle Forms Developers
- G.2 Performing Tasks Related to Data
- G.2.1 How to Retrieve Lookup Display Values for Foreign Keys
- G.2.2 How to Get the Sysdate from the Database
- G.2.3 How to Implement an Isolation Mode That Is Not Read Consistent
- G.2.4 How to Implement Calculated Fields
- G.2.5 How to Implement Mirrored Items
- G.2.6 How to Use Database Columns of Type CLOB or BLOB
- G.3 Performing Tasks Related to the User Interface
- G.3.1 How to Lay Out a Page
- G.3.2 How to Stack Canvases
- G.3.3 How to Implement a Master-Detail Screen
- G.3.4 How to Implement an Enter Query Screen
- G.3.5 How to Implement an Updatable Multi-Record Table
- G.3.6 How to Create a Popup List of Values
- G.3.7 How to Implement a Dropdown List as a List of Values
- G.3.8 How to Implement a Dropdown List with Values from Another Table
- G.3.9 How to Implement Immediate Locking
- G.3.10 How to Throw an Error When a Record Is Locked
- H Deploying ADF Applications to GlassFish
- H.1 About Deploying ADF Applications to GlassFish Server
- H.2 Running an ADF Application in Integrated WebLogic Server
- H.3 Preparing the Application
- H.4 Deploying the Application
- H.4.1 How to Deploy to the Application Server from JDeveloper
- H.4.2 What You May Need to Know About Deploying from JDeveloper
- H.4.3 How to Create an EAR File for Deployment
- H.4.4 What You May Need to Know About ADF Libraries
- H.4.5 What You May Need to Know About EAR Files and Packaging
- H.4.6 How to Deploy to the Application Server using asadmin Commands
- H.4.7 How to Deploy the Application Using Scripts and Ant
- H.5 Testing the Application and Verifying Deployment
- Glossary
- A Oracle ADF XML Files