Oracle ADF Real World Developer’s Guide


Oracle ADF Real World Developer’s Guide
eBook: $35.99
Formats: PDF, PacktLib, ePub and Mobi formats
$30.60
save 15%!
Print + free eBook + free PacktLib access to the book: $95.98    Print cover: $59.99
$90.59
save 6%!
Free Shipping!
UK, US, Europe and selected countries in Asia.
Also available on:
Overview
Table of Contents
Author
Reviews
Support
Sample Chapters
  • Full of illustrations, diagrams, and tips with clear step-by-step instructions and real-time examples.
  • Get to know the visual and declarative programming model offered by ADF.
  • In depth coverage of ADF business components and ADF binding layer.
  • Teaches you the ADF best practices and fine-tuning tips.

 

Book Details

Language : English
Paperback : 590 pages [ 235mm x 191mm ]
Release Date : October 2012
ISBN : 1849684820
ISBN 13 : 9781849684828
Author(s) : Jobinesh Purushothaman
Topics and Technologies : All Books, Enterprise Products and Platforms, Enterprise, Oracle

Table of Contents

Preface
Chapter 1: Getting Started with Oracle ADF
Chapter 2: Introduction to ADF Business Components
Chapter 3: Introducing Entity Object
Chapter 4: Introducing View Object
Chapter 5: Advanced Concepts on Entity Objects and View Objects
Chapter 6: Introducing the Application Module
Chapter 7: Binding Business Services with the User Interface
Chapter 8: Building Data Bound Web User Interfaces
Chapter 9: Controlling the Page Navigation
Chapter 10: Taking a Closer Look at the Bounded Task Flow
Chapter 11: More on Validations and Error Handling
Chapter 12: Oracle ADF Best Practices
Index
  • Chapter 1: Getting Started with Oracle ADF
    • Introduction to Oracle ADF
    • Why Oracle ADF?
    • Oracle ADF architecture
      • View layer
      • Controller layer
      • Model layer
      • Business services layer
    • Comparing the Fusion web application technology stack to the Java EE web application
      • View layer
      • Controller layer
      • Data binding layer
      • Business service layer
    • Developing with ADF
      • Setting up the development environment
      • Picking up the tool for development
        • Setting up the Software Configuration Management tool
        • Build tool
        • Team collaboration
      • Taking a quick tour of the JDeveloper IDE
    • Your first Fusion web application
      • Starting JDeveloper IDE for the first time
      • Picking up the right application template
        • Analyzing the generated metadata files
      • Connecting to the database
        • What happens when you create a database connection?
      • Generating the data model and business services
        • Building entity objects to persist your business data
        • Building view objects to shape your business data
        • Building an application module to facade your business service implementation
        • What is there in your model project source now?
      • Building user interfaces from the model
        • What have you got in your view controller project source now?
      • Deploying and running the application
        • Running the application using an integrated webLogic server
        • Running the application on a standalone application server
    • Summary
    • Chapter 2: Introduction to ADF Business Components
      • Business service layer
        • Why ADF Business Components?
      • Overview of ADF Business Components
        • Oracle ADF Business Components' feature list
        • Core building blocks
          • Entity objects
          • Associations
          • View objects
          • View links
          • Row sets
          • Query collections
          • Application modules
          • Services 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 collection
          • A closer look at query collection
        • What happens when you execute an entity-based view object?
        • What happens when you commit a transaction?
      • Summary
      • Chapter 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 connection
          • Initializing the ADF model project
          • Creating entity objects
            • Choosing the database object type
          • Generating Java classes for entity components
          • Commonly used properties of an entity attribute
            • Attribute names in an entity object
            • Attribute types in an entity object
            • Using a resource bundle to localize UI hint properties
            • Property set
            • Persistent and transient attributes
            • Specifying a default value for an entity attribute
            • Effective dated entity objects
            • Defining the primary key
            • Inheritance hierarchies in entity objects
            • Updatability of entity attributes
            • Refreshing attributes on posting changes to the database
            • Marking an attribute as mandatory
            • Checking data inconsistency by using the Change Indicator attribute
            • Queriable attributes
            • Tracking change history
            • Configuring UI hints for an attribute
            • Specifying dependency attributes
          • Commonly used properties of an entity object
            • Setting an alternate key for an entity object
            • Specifying custom properties
            • Defining entity association
            • Retaining the association accessor row set
            • Adding validation
            • Concurrent access and locking
            • Securing entity objects
            • Enabling a batch update in an entity object
        • Working with entity objects
          • Programmatically creating an entity instance
          • Entity object in a transaction post cycle
        • Summary
        • Chapter 4: Introducing View Object
          • Introduction
          • Concepts and architecture
            • Ingredients of a view object
          • Core features of ADF view objects
          • Developing view objects
            • Creating view objects
            • Using the Create View Object wizard
              • Creating a view object with entity usage mapping
              • Creating a view object with SQL query
              • Creating a view object with static list
              • Creating a programmatic view object
              • Creating a declarative SQL mode view object
            • Optionally generating Java classes for a view object
            • Commonly used properties of view objects
              • Annotate attributes using UI hints
              • Adding business rules
          • Working with view objects
            • List of values
              • Configuring the list of values
            • Linking two view objects
              • Where clause and Reverse Where clause
            • Inheritance hierarchies in view objects
              • Inheritance hierarchies in view objects with non-polymorphic entity usage
              • Inheritance hierarchies in view objects with polymorphic entity usage
            • Querying the datasource by using a view object
              • Specifying the query mode for a view object
              • Adding WHERE clause to a view object
              • Using bind variables
              • Changing the query of a view object at runtime
              • Programmatically sorting view object rows
              • In-memory filtering of row sets
              • View criteria
            • Effective dated view objects
            • Using alternate keys in a view object
            • Using findByKey() on view objects
            • Creating new rows through the view object
              • Creating child rows in composition association
            • View link consistency
              • Configuring view link consistency
              • How view link consistency works
              • Why does view link consistency fail when you add a dynamic WHERE clause?
            • What happens when you execute a view object?
          • Summary
          • Chapter 5: Advanced Concepts on Entity Objects and View Objects
            • Taking a closer look at entity objects
              • Lifecycle of an entity object
              • Reading the current state of an entity row
              • Reading the originally retrieved attribute value
              • Retrieving all entity instances in the cache
              • Lifecycle callback methods of an entity object
                • What 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 objects
              • Generating a database independent unique ID
                • How does unique ID sequencing work
                • Using middle tier generated unique keys
              • Refreshing entity rows, forgetting the changes
              • Building custom history types
            • Taking a closer look at view objects
              • Lifecycle callback methods of a view object
                • What happens when a client invokes executeQuery() on a view object instance?
                • Count queries in a view object
              • Building programmatically managed view objects
              • Intercepting query generation for view criteria
                • Using a custom view criteria adapter
                • Overriding getViewCriteriaClause(boolean forQuery) in the view object implementation class
                • Overriding getCriteriaItemClause(ViewCriteriaItem vci) in the view object implementation class
                • Tips on overriding getViewCriteriaClause() and getCriteriaItemClause() in the view object implementation
              • Customizing the query at runtime
                • Customizing the query for a row set
                • Customizing the query for a view object
              • Passing parameters to a SQL IN clause using oracle.jbo.domain.Array
                • Using oracle.jbo.domain.Array as a NamedWhereClauseParam value
                • Using oracle.jbo.domain.Array as a bind variable value for a view criteria item
              • Defining a cascading list of values
              • Switching the LOV at runtime
              • Reading and writing XML data
            • Advanced data type techniques
              • Building custom data types using domain type
              • Working with BLOB and CLOB data types
              • BLOB and CLOB support for alternate databases
            • Building business components dynamically
              • Building dynamic entity objects and view objects
                • Steps for building entity definition at runtime
                • Steps for building a view definition with entity usage at runtime
              • Personalized business components
            • Summary
            • Chapter 6: Introducing the Application Module
              • Introduction
              • Concepts and architecture
                • Ingredients of an application module
                • Additional core components
              • The core features of an application module
              • Defining an application module
                • Creating application modules
                • Optionally generating Java classes for an application module
                • Adding hierarchical view object instances to an application module
                • Overriding the default properties of an application module
                  • Commonly used application module configuration properties
                • Modifying the JDBC data source name for an application module
                • Overriding properties for a view object instance
                  • Declaratively applying view criteria to a view object instance
              • Sharing application module data
                • An alternative option to define a shared application module
                • Runtime behaviour of shared application modules
                • Query execution for a shared view object
                • Shared query collection cache management
                  • The maximum weight of the query collection pool
                  • Query collection weight
                • Consuming a shared application module
                  • Accessing view objects defined in a shared application module through a view accessor
                • Associating 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 control
                • Where do you write custom business logic in a fusion web application?
                • Invoking an application module from a Java client
                • Invoking a shared application module from a Java client
                • What 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 module
                  • Passivation activation of application modules
                  • Programmatic passivation and activation of custom data
                • Storing business data at user session level
                  • Using a transient view object
                  • Using a user session data map
                  • Using a client bound session map object
                • Using JDBC APIs in an application module
                • Using save points for undo operations
                • Programmatically configuring an application module
                • Programmatically building a master-child view object
                • Using ADF Business Components with Java EE components
              • Summary
              • Chapter 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 files
                    • adfm.xml
                    • DataBindings.cpx
                    • adf-config.xml
                    • adf-settings.xml
                • Browsing through the page definition file
                  • Parameters
                  • Executables
                  • Bindings
                  • Using the binding editor
                  • Programmatically accessing page binding elements
                    • Accessing binding container
                  • Programmatically accessing the parameter binding
                    • Programmatically executing method action binding
                  • Accessing the list control binding
                  • Accessing the attribute binding
                    • Accessing 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 HttpServlet
                  • Using ADF binding APIs in an HttpServlet
                • Adding custom phase listeners
                • Summary
                • Chapter 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 handlers
                      • Using managed bean methods as event handlers
                      • Using 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 bindings
                    • What happens at runtime in a data bound table?
                    • Adding edit functionalities for a table
                      • Creating a new row
                      • Deleting a row
                      • Committing changes
                      • Programmatically accessing a selected row from a table
                      • Declaratively reading the attribute value from the currently selected row
                  • Building data bound master-detail UIs
                    • Building a master-detail data model
                    • Building a master-detail UI
                    • What happens at runtime in the master-detail UI?
                  • Building a data bound tree table UI
                    • Building hierarchical view objects
                    • Creating a tree table UI
                      • What happens when you drop a data collection as a tree table on a page?
                      • Decorating the tree table UI
                    • What happens at runtime in a data bound tree table?
                      • Synchronizing UIs using the target data source
                      • What happens at runtime in the target data source?
                    • Adding edit functionalities for a tree table
                      • Configuring the parent view object to retain the view link accessor row set
                      • Creating utility methods for reading RowIterator and selected RowKey for the selected node
                      • Implementing create and delete methods in the application module
                      • Creating a new row
                      • Deleting a row
                    • Programmatically refreshing the tree hierarchy
                  • Accessing web tier values from business components
                    • Using ADFContext to access client specific scoped variables
                      • How does ADFContext provide uniform access across layers?
                      • The pitfalls of using ADFContext
                    • Passing web tier values as parameters to business service methods
                      • Establishing a channel for passing web tier values to the business service layer
                      • Using the user session data map to store values passed from the client
                      • When 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 criteria
                      • Using UI hints to control the display for a query component
                    • Building a search UI
                      • What happens when you drop a view criteria as a query component on a page?
                      • Commonly used properties of the search region binding
                    • Initializing criteria item values using web tier values
                    • Programmatically controlling the display of a query component
                    • Programmatically retrieving view criteria used for a query component
                    • Programmatically resetting a query component
                    • Search on a tree table
                    • What 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
                  • Chapter 9: Controlling the Page Navigation
                    • Introduction
                    • The navigation model in the JSF framework
                      • Rule based navigation
                      • Implicit navigation
                        • How does implicit navigation work?
                    • The navigation model in ADF
                    • The ingredients of an ADF task flow
                      • Task flow configuration files
                      • ADF managed beans
                        • What you need to know while using managed beans in JSF code?
                      • Task flow activities
                        • View activity
                        • URL view activity
                        • Method call activity
                        • Router activity
                        • Save point restore activity
                        • Task flow call activity
                        • Task flow return activity
                        • Parent action
                    • Building an unbounded task flow
                      • Using a managed bean to return a dynamic outcome for a navigation component
                      • Conditionally executing a control flow case
                      • Improving the readability of control flow cases
                    • Adding an exception handler
                      • Customizing the default exception handler
                        • Building a custom javax.faces.context.ExceptionHandler
                    • Using method call activity to initialize a page
                      • Building a task flow with method call activity
                        • What happens at runtime?
                    • Building a menu model
                    • Summary
                    • Chapter 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 activity
                        • Marking an activity as an exception handler
                        • Calling a bounded task flow using the task flow call activity
                          • Using dynamic task flow calls
                          • Commonly used properties for a task flow call activity
                          • Using remote task flow calls
                      • Parameterizing a bounded task flow
                        • Defining a task flow input parameter
                        • Specifying input parameter values for a task flow
                        • Defining the task flow return value
                        • Reading 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 model
                        • Using a contextual event
                          • Defining an event publisher
                          • Defining an event subscriber
                        • Contextual 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 library
                        • Consuming task flows added into an ADF library
                      • Using a train component in a bounded task flow
                        • Creating a train in a bounded task flow
                          • Setting display names for train stops
                          • Customizing the display for train stops
                          • Programmatically navigating between train stops
                          • Executing 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
                      • Chapter 11: More on Validations and Error Handling
                        • Introduction
                        • Adding validation rules in a fusion web application
                          • Defining validations in the ADF view layer
                            • Defining a custom ADF Faces validator
                          • Defining validations in the ADF model layer
                          • Defining validations in the ADF Business Components layer
                            • Validations using custom domain objects
                          • 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 validation
                          • Server-side validation
                        • Error handling in ADF
                          • Taking a closer look at DCErrorHandlerImpl
                        • Programmatically throwing validation exceptions in business components
                          • Localizing validation error messages
                            • Resource bundle usage in entity objects and view objects
                            • Resource bundle usage in the application module
                            • Reading the resource bundle definition from the business component
                          • Programmatically throwing validation exceptions
                            • Building a validation exception using message strings from the resource bundle
                          • Validation class hierarchy
                          • Wrapping exceptions
                          • Programmatically throwing multiple RowValException
                          • Programmatically throwing AttrValException
                        • Customizing default business component error messages
                          • Step1: Creating and registering a custom message bundle
                          • Step 2: Customizing the DCErrorHandlerImpl
                          • Step 3: Registering the CustomErrorHandler
                          • How does the CustomErrorHandler implementation work?
                        • Skipping validation
                          • Skipping validations in the ADF Faces layer
                          • Skipping validations in the business components
                        • Summary
                        • Chapter 12: Oracle ADF Best Practices
                          • Introduction
                          • Setting up the project structure for your Fusion web application
                            • Single application workspace comprising of multiple projects – monolithic approach
                            • Multiple application workspaces controlled by a single master application– microkernel approach
                              • Guidelines for setting up the application source using the microkernel approach
                            • How to avoid cyclic dependency between modules
                          • The life span of ADF Business Components
                            • Life span of an application module
                              • How the framework allocates an application module for serving a client request
                              • More configuration options for an application module
                              • When an application module is removed from the pool
                            • Life span of a view object, row set, and query collection in a regular application module
                              • The query collection cache and view accessor row set
                            • The life span of entity objects
                              • What if you want to clear an entity cache at specific points in time?
                            • The life span of row sets in a shared application module
                            • The life span of binding objects
                          • The best practices and performance tuning for Oracle ADF
                            • Tuning tips for an application module
                              • Tips for optimizing an application module initialization
                              • Tips for optimizing resource usages in an application module
                              • Tips for fine-tuning the JDBC API use
                              • Coding guidelines for application modules
                            • Tuning tips for view objects
                              • Tips for optimizing query execution in a view object
                              • Tips for optimizing database read operations
                              • Tips for setting a global row fetch limit for view objects
                              • Tuning view criteria in view objects
                              • Tips for optimizing LOV definitions
                              • General tips for tuning view objects
                              • Coding guidelines for view objects
                            • Tuning tips for entity objects
                              • Design guidelines for entity objects
                              • Tips for validating entity objects
                              • General tips for tuning entity objects
                              • Coding guidelines for entity objects
                            • Tuning tips for ADF model
                              • Tips for tuning executable bindings
                              • Tips for optimizing data traffic between a binding layer and business components
                              • Tips for optimizing count query executions
                              • Coding guidelines for ADF binding APIs
                            • Tuning tips for ADF Controller and task flows
                              • Tips for optimizing resource usage in a task flow
                              • General guidelines for building successful task flows
                              • Coding guidelines for managed beans
                            • Tuning tips for ADF Faces
                              • General tips for ADF Faces pages
                              • Best 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

                          Jobinesh Purushothaman

                          Jobinesh Purushothaman works with Oracle as a Principal Solutions Architect for the Oracle Application Development Framework. He has over 13 years of experience in the software industry working on Java platforms and various Java-based application frameworks. In his current role with Oracle, he is mainly focused on helping internal and external customers with the adoption of Oracle ADF. He is also involved in the design and architectural decisions of various products using ADF and Java EE technologies, and occasionally he speaks at industry conferences such as JavaOne and Oracle Develop. Links to his blog articles may be found at http://jobinesh.blogspot.com. Jobinesh holds a Master of Science (M.Sc) degree in Computer Science from Bharathiar University, India, and a Master of Business Administration (MBA) from Indira Gandhi National Open University (IGNOU), India. After completing his M.Sc in Computer Science, he started his career in 1999 with MicroObjects Private Limited, India. His career has taken him to different countries and companies where he worked as developer, technical leader, mentor, and technical architect. Jobinesh joined Oracle India Private Limited in 2008. Prior to joining Oracle, from 2004 to 2008, Jobinesh worked as Senior Software Engineer at the Emirates Group IT, Dubai, where he was part of an IT strategy and architecture team. Jobinesh currently lives in Bangalore, India, with his wife Remya and son Chinmay.

                          Code Downloads

                          Download the code and support files for this book.


                          Submit Errata

                          Please let us know if you have found any errors not listed on this list by completing our errata submission form. Our editors will check them and add them to this list. Thank you.


                          Errata

                          - 6 submitted: last submission 23 Jan 2014

                          Errata type: Typo | Page number: Preface

                          In Preface under the Acknowledgement section the fifth paragraph is as follows:

                          Special thanks to Steve Munech (Senior Architect - Oracle ADF) for all the help that he offered throughout my life at Oracle and also for teaching me Oracle ADF.

                          The correct sentence here is as follows:

                          Special thanks to Steve Muench (Senior Architect - Oracle ADF Development Team) for all the help that he offered throughout my life at Oracle and also for teaching me Oracle ADF.

                          Errata type: Typo | Page number: Preface

                          In Preface on page number 3, the link given under Chapter 13 section is incorrect. The correct link to download the chapter 13 is

                          http://www.packtpub.com/sites/default/files/downloads/4828EN_Chapter13_Building_Business_Services_with_EJB.pdf

                          The image on page number 61 is incorrect. The correct image is as follows:

                          Correction on Page 84

                          If the value is true, attribute will be part of the SELECT clause generated by the view objects based on this entity.

                          should be:

                          If the value is true, attribute can be part of the WHERE clause generated by the view object. For example, view criteria definition allows you to include only queriable attributes when used in database query execution mode or for both database and in-memory query execution mode.

                          Errata type: Typo | Page number: 73

                          The third row in the datatype mapping table should be read as
                          NUMBER         java.lang.Integer            NUMBER type is mapped to java.lang.Integer if the scale is zero and precision is between 1 to 9 .

                          Errata type: Code | Page number: 534

                          The original XML snippet at the end of the page:

                          <?xml version="1.0" encoding="windows-1252" ?>
                          <adf-config xmlns="http://xmlns.oracle.com/adf/config"
                          ...
                          <user-time-zone-config xmlns="http://xmlns.oracle.com/adf/usertimezone/config">
                          <user-timezone expression="#{adfFacesContext.timeZone.ID}"/>
                          </user-time-zone-config>

                          The correct XML snippet:

                          <?xml version="1.0" encoding="windows-1252" ?>
                          <adf-config xmlns="http://xmlns.oracle.com/adf/config"
                          ...
                          <user-timezone-config xmlns="http://xmlns.oracle.com/adf/usertimezone/config">
                          <user-timezone expression="#{adfFacesContext.timeZone.ID}"/>
                          </user-timezone-config>

                          Sample chapters

                          You can view our sample chapters and prefaces of this title on PacktLib or download sample chapters in PDF format.

                          Frequently bought together

                          Oracle ADF Real World Developer’s Guide +    Oracle SOA Suite 11g R1 Developer's Guide =
                          50% Off
                          the second eBook
                          Price for both: $48.60

                          Buy both these recommended eBooks together and get 50% off the cheapest eBook.

                          What you will learn from this book

                          • Get started with building business services using ADF business components
                          • Master how to use ADF controller to define navigation flow in an application
                          • Get to grips with building reusable web modules using ADF task flow
                          • Learn how to validate business data in different layers of an application
                          • Understand the use of EJB and web services in an ADF application
                          • Get some tips to fine tune an ADF web application

                          In Detail

                          Oracle ADF in combination with JDeveloper IDE offers visual and declarative approaches to enterprise application development. This book will teach you to build scalable rich enterprise applications using the ADF Framework, with the help of many real world examples.

                          Oracle ADF is a powerful application framework for building next generation enterprise applications. The book is a practical guide for the ADF framework and discusses how to use Oracle ADF for building rich enterprise applications.

                          "Oracle ADF Real World Developer’s Guide" discusses ADF framework in detail. This book contains a lot of real life examples which will help developers to design and develop successful enterprise applications.

                          This book starts off by introducing the development environment and JDeveloper design time features. As you read forward, you will learn to build a full stack enterprise application using ADF. You will learn how to build business services using ADF, enable validation for the data model, declaratively build user interfaces for business service and enable security across application layers.

                          Approach

                          This book is written in simple, easy to understand format with lots of screenshots and step-by-step explanations.

                          Who this book is for

                          If you are an ADF developer looking forward to building healthy and better performing applications using Oracle ADF, then this is the best guide for you. You need to be proficient with Java and ADF before getting started with this book.

                          Code Download and Errata
                          Packt Anytime, Anywhere
                          Register Books
                          Print Upgrades
                          eBook Downloads
                          Video Support
                          Contact Us
                          Awards Voting Nominations Previous Winners
                          Judges Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software
                          Resources
                          Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software