book

Oracle ADF Real World Developer's Guide

Name: Oracle ADF Real World Developer's Guide
Author: Jobinesh Purushothaman
ISBN: 9781849684828

by Jobinesh Purushothaman

October 2012

Intermediate to advanced

590 pages

15h 18m

English

Packt Publishing

Read now

Unlock full access

Oracle ADF Real World Developer's Guide
Table of Contents
Oracle ADF Real World Developer's Guide
Credits
About the Author
Acknowledgement
About the Reviewers
www.PacktPub.com
Support files, eBooks, discount offers and more
Why Subscribe?
Free Access for Packt account holders

Instant Updates on New Packt Books
Preface
What this book covers
What you need for this book
Who this book is for
Conventions
Reader feedback
Customer support
Downloading the example codeErrataPiracyQuestions
1. Getting Started with Oracle ADF
Introduction to Oracle ADF
Why Oracle ADF?
Oracle ADF architecture
View layerController layerModel layerBusiness services layer
Comparing the Fusion web application technology stack to the Java EE web application
View layerController layerData binding layerBusiness service layer
Developing with ADF
Setting up the development environmentPicking up the tool for developmentSetting up the Software Configuration Management toolBuild toolTeam collaborationTaking a quick tour of the JDeveloper IDE
Your first Fusion web application
Starting JDeveloper IDE for the first timePicking up the right application templateAnalyzing the generated metadata filesConnecting to the databaseWhat happens when you create a database connection?Generating the data model and business servicesBuilding entity objects to persist your business dataBuilding view objects to shape your business dataBuilding an application module to facade your business service implementationWhat is there in your model project source now?Building user interfaces from the modelWhat have you got in your view controller project source now?Deploying and running the applicationRunning the application using an integrated webLogic serverRunning the application on a standalone application server
Summary
2. Introduction to ADF Business Components
Business service layerWhy ADF Business Components?
Overview of ADF Business Components
Oracle ADF Business Components' feature listCore building blocksEntity objectsAssociationsView objectsView linksRow setsQuery collectionsApplication modulesServices and service data objects
Building a simple business service
ADF Business Components configuration files
Oracle ADF Model Tester
Using the ADF Model Tester to test the CRUD operations on business data
Testing business methods
Java test client for ADF Business Components
Understanding the runtime behavior of ADF Business Components
Roles and responsibilities of the view object, row set, and query collectionA closer look at query collectionWhat happens when you execute an entity-based view object?What happens when you commit a transaction?
Summary
3. Introducing Entity Object
Introduction
Ingredients of an entity object
Runtime collaboration between business components
Core features of ADF entity objects
Developing entity objects
Creating a database connectionInitializing the ADF model projectCreating entity objectsChoosing the database object typeGenerating Java classes for entity componentsCommonly used properties of an entity attributeAttribute names in an entity objectAttribute types in an entity objectUsing a resource bundle to localize UI hint propertiesAccessing the resource bundle from the entity object classProperty setCreating a property setAssociating the property set with the entity object attributesUsing custom properties in business logicPersistent and transient attributesSpecifying a default value for an entity attributeEffective dated entity objectsDefining the primary keyInheritance hierarchies in entity objectsCreating inheritance hierarchies for entity objectsUpdatability of entity attributesRefreshing attributes on posting changes to the databaseMarking an attribute as mandatoryChecking data inconsistency by using the Change Indicator attributeQueriable attributesTracking change historyConfiguring UI hints for an attributeSpecifying dependency attributesCommonly used properties of an entity objectSetting an alternate key for an entity objectSpecifying custom propertiesDefining entity associationComposition associationProperties of composition associationRetaining the association accessor row setAdding validationAdding a validation rule to an attributeAdding a validation rule to an entity objectTransaction level validationDefining a custom validation ruleConcurrent access and lockingConfiguring Locking Mode for an ADF applicationSecuring entity objectsEnabling a batch update in an entity object
Working with entity objects
Programmatically creating an entity instanceEntity object in a transaction post cycle
Summary
4. Introducing View Object
Introduction
Concepts and architecture
Ingredients of a view object
Core features of ADF view objects
Developing view objects
Creating view objectsUsing the Create View Object wizardCreating a view object with entity usage mappingCreating a view object with SQL queryCreating a view object with static listCreating a programmatic view objectCreating a declarative SQL mode view objectOptionally generating Java classes for a view objectCommonly used properties of view objectsAnnotate attributes using UI hintsAdding business rules
Working with view objects
List of valuesConfiguring the list of valuesLinking two view objectsWhere clause and Reverse Where clauseInheritance hierarchies in view objectsInheritance hierarchies in view objects with non-polymorphic entity usageInheritance hierarchies in view objects with polymorphic entity usageQuerying the datasource by using a view objectSpecifying the query mode for a view objectAdding WHERE clause to a view objectAppending the WHERE clause at design timeAppending the WHERE clause at runtimeUsing bind variablesProgrammatically specifying the value for bind variablesChanging the query of a view object at runtimeProgrammatically sorting view object rowsIn-memory filtering of row setsIn-memory filtering with RowMatchIn-memory filtering by overriding rowQualifies() in ViewObjectImplView criteriaArchitecture of view criteriaEffective dated view objectsUsing alternate keys in a view objectUsing findByKey() on view objectsCreating new rows through the view objectCreating child rows in composition associationView link consistencyConfiguring view link consistencyHow view link consistency worksWhy does view link consistency fail when you add a dynamic WHERE clause?What happens when you execute a view object?
Summary
5. Advanced Concepts on Entity Objects and View Objects
Taking a closer look at entity objectsLifecycle of an entity objectReading the current state of an entity rowReading the originally retrieved attribute valueRetrieving all entity instances in the cacheLifecycle callback methods of an entity objectWhat happens when a new entity instance is created?What happens when an entity instance is modified or removed?What happens when the transaction is committed?Building programmatically managed entity objectsGenerating a database independent unique IDHow does unique ID sequencing workUsing middle tier generated unique keysRefreshing entity rows, forgetting the changesBuilding custom history types
Taking a closer look at view objects
Lifecycle callback methods of a view objectWhat happens when a client invokes executeQuery() on a view object instance?Count queries in a view objectBuilding programmatically managed view objectsIntercepting query generation for view criteriaUsing a custom view criteria adapterOverriding getViewCriteriaClause(boolean forQuery) in the view object implementation classOverriding getCriteriaItemClause(ViewCriteriaItem vci) in the view object implementation classTips on overriding getViewCriteriaClause() and getCriteriaItemClause() in the view object implementationCustomizing the query at runtimeCustomizing the query for a row setCustomizing the query for a view objectPassing parameters to a SQL IN clause using oracle.jbo.domain.ArrayUsing oracle.jbo.domain.Array as a NamedWhereClauseParam valueUsing oracle.jbo.domain.Array as a bind variable value for a view criteria itemDefining a cascading list of valuesSwitching the LOV at runtimeReading and writing XML data
Advanced data type techniques
Building custom data types using domain typeWorking with BLOB and CLOB data typesBLOB and CLOB support for alternate databases
Building business components dynamically
Building dynamic entity objects and view objectsSteps for building entity definition at runtimeSteps for building a view definition with entity usage at runtimePersonalized business components
Summary
6. Introducing the Application Module
Introduction
Concepts and architecture
Ingredients of an application moduleAdditional core components
The core features of an application module
Defining an application module
Creating application modulesOptionally generating Java classes for an application moduleAdding hierarchical view object instances to an application moduleOverriding the default properties of an application moduleCommonly used application module configuration propertiesModifying the JDBC data source name for an application moduleOverriding properties for a view object instanceDeclaratively applying view criteria to a view object instance
Sharing of application module data
An alternative option to define a shared application moduleRuntime behaviour of shared application modulesQuery execution for a shared view objectShared query collection cache managementThe maximum weight of the query collection poolQuery collection weightConsuming a shared application moduleAccessing view objects defined in a shared application module through a view accessorAssociating view criteria with shared application module instances
Nesting application modules
Accessing a nested application module from the parent
Working with an application module
Exposing the business service method through data controlWhere do you write custom business logic in a fusion web application?Invoking an application module from a Java clientInvoking a shared application module from a Java clientWhat you may need to know about programmatically releasing an application module?What happens when a client creates an application module instance?The lifecycle of an application modulePassivation activation of application modulesProgrammatic passivation and activation of custom dataStoring business data at user session levelUsing a transient view objectUsing a user session data mapUsing a client bound session map objectUsing JDBC APIs in an application moduleUsing save points for undo operationsProgrammatically configuring an application moduleProgrammatically building a master-child view objectUsing ADF Business Components with Java EE components
Summary
7. Binding Business Services with the User Interface
Introduction
Binding model data with user interfaces
Building a simple data bound web page
Is a view object really a data collection?
What happens when we drop a data collection on a page?
Taking a closer look at the ADF Model metadata filesadfm.xmlDataBindings.cpxadf-config.xmladf-settings.xml
Browsing through the page definition file
ParametersExecutablesBindingsUsing the binding editorProgrammatically accessing page binding elementsAccessing binding containerProgrammatically accessing the parameter bindingProgrammatically executing method action bindingAccessing the list control bindingAccessing the attribute bindingAccessing the iterator binding and associated view object
What happens when you access a Fusion web page?
Invoking an application module from a Java servlet
Using Configuration::createRootApplicationModule() in HttpServletUsing ADF binding APIs in an HttpServlet
Adding custom phase listeners
Summary
8. Building Data Bound Web User Interfaces
Introduction
The art of laying out pages
Organizing page contents – a case study
Adding actions to your page
Choosing between the managed bean method and the data control method as event handlersUsing managed bean methods as event handlersUsing data control methods as event handlers
Building data bound table UIs
What happens when you drop a data collection as a table on a page?Commonly used attributes of iterator bindingsWhat happens at runtime in a data bound table?Adding edit functionalities for a tableCreating a new rowDeleting a rowCommitting changesProgrammatically accessing a selected row from a tableDeclaratively reading the attribute value from the currently selected row
Building data bound master-detail UIs
Building a master-detail data modelBuilding a master-detail UIWhat happens at runtime in the master-detail UI?
Building a data bound tree table UI
Building hierarchical view objectsCreating a tree table UIWhat happens when you drop a data collection as a tree table on a page?Decorating the tree table UIWhat happens at runtime in a data bound tree table?Synchronizing UIs using the target data sourceWhat happens at runtime in the target data source?Adding edit functionalities for a tree tableConfiguring the parent view object to retain the view link accessor row setCreating utility methods for reading RowIterator and selected RowKey for the selected nodeImplementing create and delete methods in the application moduleCreating a new rowDeleting a rowProgrammatically refreshing the tree hierarchy
Accessing web tier values from business components
Using ADFContext to access client specific scoped variablesHow does ADFContext provide uniform access across layers?The pitfalls of using ADFContextPassing web tier values as parameters to business service methodsEstablishing a channel for passing web tier values to the business service layerUsing the user session data map to store values passed from the clientWhen should the client invoke the method that takes web tier values?Making the user session data map passivation safe
Building data bound query search forms
Building the view criteriaUsing UI hints to control the display for a query componentBuilding a search UIWhat happens when you drop a view criteria as a query component on a page?Commonly used properties of the search region bindingWhat is AutoQuery or ClearRowSet behavior?Initializing criteria item values using web tier valuesProgrammatically controlling the display of a query componentProgrammatically retrieving view criteria used for a query componentProgrammatically resetting a query componentSearch on a tree tableWhat happens at runtime in a tree table search?
Building a data bound multi select list
Programmatically accessing selected rows
Overriding UI hints in a view object
Summary
9. Controlling the Page Navigation
Introduction
The navigation model in the JSF framework
Rule based navigationImplicit navigationHow does implicit navigation work?
The navigation model in ADF
The ingredients of an ADF task flow
Task flow configuration filesADF managed beansWhat you need to know while using managed beans in JSF code?Task flow activitiesView activityWhat document type should you choose while creating a JSF page?Bookmarking view activityRedirect URLURL view activitySpecifying parameters for a URL view activityWhat happens when runtime invokes a URL view activity from a bounded task flow?Method call activityUsing a managed bean method in method call activityUsing data control operation in method call activityRouter activitySave point restore activityWhere are ADF Controller save points created?Using save points in a task flowWhat happens when you create an ADF Controller save point?Implicit save pointsTask flow call activityTask flow return activityParent action
Building an unbounded task flow
Using a managed bean to return a dynamic outcome for a navigation componentConditionally executing a control flow caseImproving the readability of control flow cases
Adding an exception handler
Customizing the default exception handlerBuilding a custom javax.faces.context.ExceptionHandler
Using method call activity to initialize a page
Building a task flow with method call activityWhat happens at runtime?
Building a menu model
Summary
10. Taking a Closer Look at the Bounded Task Flow
Introduction
The properties of a bounded task flow
Building a bounded task flow
Working with bounded task flow activities
Marking an activity as the default activityMarking an activity as an exception handlerCalling a bounded task flow using the task flow call activityUsing dynamic task flow callsCommonly used properties for a task flow call activityUsing remote task flow callsWhat happens at runtime when a remote task flow is called?What you may need to know when you use remote task flow
Parameterizing a bounded task flow
Defining a task flow input parameterSpecifying input parameter values for a task flowDefining the task flow return valueReading a return value from a task flow
Consuming bounded task flows as ADF regions
Dynamically displaying the task flow
Lazy loading of an ADF region
Refreshing an ADF region
Displaying task flows using a pop up component
Lazy activation for a task flow when displayed in a pop up
Using a contextual event for communicating to an ADF region
Contextual event modelUsing a contextual eventDefining an event publisherDefining an event subscriberDefining an event handler methodSubscribing to desired eventsContextual event propagation at runtime
Dynamically adding multiple regions to a page
Distributing ADF task flow as the ADF library
Packaging the task flow into the ADF libraryConsuming task flows added into an ADF library
Using a train component in a bounded task flow
Creating a train in a bounded task flowSetting display names for train stopsCustomizing the display for train stopsProgrammatically navigating between train stopsExecuting methods while navigating between train stops
Transaction management in a bounded task flow
What happens at runtime?Programmatically managing transactions for a task flow
The life span of a bounded task flow
Summary
11. More on Validations and Error Handling
Introduction
Adding validation rules in a fusion web application
Defining validations in the ADF view layerDefining a custom ADF Faces validatorStep1: Defining client-side validation in JavaScriptStep 2: Defining the validator Java classStep 3: Configuring and using the validatorDefining validations in the ADF model layerDefining validations in the ADF Business Components layerValidations using custom domain objectsCreating and registering custom message bundlesWhat you may need to know while using custom domain types on the UIWhen does the framework validate the custom domain object?Where to put validation in a Fusion web application
Displaying validation exceptions on a page
Where in the page lifecycle does validation occur?
Client-side validationServer-side validation
Error handling in ADF
Taking a closer look at DCErrorHandlerImpl
Programmatically throwing validation exceptions in business components
Localizing validation error messagesResource bundle usage in entity objects and view objectsResource bundle usage in the application moduleReading the resource bundle definition from the business componentProgrammatically throwing validation exceptionsBuilding a validation exception using message strings from the resource bundleValidation class hierarchyWrapping exceptionsProgrammatically throwing multiple RowValExceptionProgrammatically throwing AttrValException
Customizing default business component error messages
Step1: Creating and registering a custom message bundleStep 2: Customizing the DCErrorHandlerImplStep 3: Registering the CustomErrorHandlerHow does the CustomErrorHandler implementation work?
Skipping validation
Skipping validations in the ADF Faces layerSkipping validations in the business components
Summary
12. Oracle ADF Best Practices
Introduction
Setting up the project structure for your Fusion web application
Single application workspace comprising of multiple projects – monolithic approachMultiple application workspaces controlled by a single master application– microkernel approachGuidelines for setting up the application source using the microkernel approachHow to avoid cyclic dependency between modules
The life span of ADF Business Components
Life span of an application moduleHow the framework allocates an application module for serving a client requestMore configuration options for an application moduleWhen an application module is removed from the poolConfiguring the application module pool parameters – a case studyLife span of a view object, row set, and query collection in a regular application moduleThe query collection cache and view accessor row setThe life span of entity objectsWhat if you want to clear an entity cache at specific points in time?The life span of row sets in a shared application moduleThe life span of binding objects
The best practices and performance tuning for Oracle ADF
Tuning tips for an application moduleTips for optimizing an application module initializationTips for optimizing resource usages in an application moduleTips for fine-tuning the JDBC API useCoding guidelines for application modulesTuning tips for view objectsTips for optimizing query execution in a view objectTips for optimizing database read operationsTips for setting a global row fetch limit for view objectsTuning view criteria in view objectsTips for optimizing LOV definitionsGeneral tips for tuning view objectsCoding guidelines for view objectsTuning tips for entity objectsDesign guidelines for entity objectsTips for validating entity objectsGeneral tips for tuning entity objectsCoding guidelines for entity objectsTuning tips for ADF modelTips for tuning executable bindingsTips for optimizing data traffic between a binding layer and business componentsTips for optimizing count query executionsCoding guidelines for ADF binding APIsTuning tips for ADF Controller and task flowsTips for optimizing resource usage in a task flowGeneral guidelines for building successful task flowsCoding guidelines for managed beansTuning tips for ADF FacesGeneral tips for ADF Faces pagesBest practices for ADF Faces UI components
Internationalization of Fusion web applications
Configuring the time zone for a Fusion web application
Ensuring high availability for Fusion web applications
How does a bean data control participate in session replication in high availability mode?
Summary
Index

Content preview from Oracle ADF Real World Developer's Guide

Dynamically adding multiple regions to a page

ADF allows you to add or remove regions to a page at runtime. This feature is useful if you do not know the number of regions that render in the page at design time. For example, consider a page with panel tabbed display, each tab holding a region. An end user can add or remove tabs at runtime. This section discusses a solution for such use cases.

You can use a page definition file's multiTaskFlow element to reference a list of bounded task flows that are added at runtime. Each region in the UI may hold a reference to a task flow in the list. The following are the implementation details:

Implementing the logic to return a task flow binding attributes list.
The first step is to build a managed bean to ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781849684828

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Oracle ADF Real World Developer's Guide

by Jobinesh Purushothaman

Dynamically adding multiple regions to a page

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.