Oracle ADF Enterprise Application Development—Made Simple

There is a newer version of this book available - Oracle ADF Enterprise Application Development – Made Simple: Second Edition
Oracle ADF Enterprise Application Development—Made Simple
eBook: $32.99
Formats: PDF, PacktLib, ePub and Mobi formats
save 15%!
Print + free eBook + free PacktLib access to the book: $87.98    Print cover: $54.99
save 6%!
Anytime, Anywhere
Unlimited eBook downloads and up to 50% off the print version!
Free Shipping!
UK, US, Europe and selected countries in Asia.
Also available on:
Table of Contents
Sample Chapters
  • Best practices for real-life enterprise application development
  • Proven project methodology to ensure success with your ADF project from an Oracle ACE Director
  • Understand the effort involved in building an ADF application from scratch, or converting an existing application
  • Learn to set up and use the best support tools directly from within JDeveloper for maximum productivity
  • Experience live application development with lots of examples

Book Details

Language : English
Paperback : 396 pages [ 235mm x 191mm ]
Release Date : June 2011
ISBN : 1849681880
ISBN 13 : 9781849681889
Author(s) : Sten E. Vesterli
Topics and Technologies : All Books, Enterprise Products and Platforms, Oracle Fusion Middleware, Enterprise, Java, Oracle

Table of Contents

Chapter 1: The ADF Proof of Concept
Chapter 2: Estimating the Effort
Chapter 3: Getting Organized
Chapter 4: Productive Teamwork
Chapter 5: Prepare to Build
Chapter 6: Building the Enterprise Application
Chapter 7: Testing your Application
Chapter 8: Look and Feel
Chapter 9: Customizing the Functionality
Chapter 10: Securing your ADF Application
Chapter 11: Package and Deliver
Appendix: Internationalization
  • Chapter 1: The ADF Proof of Concept
    • The very brief ADF primer
      • Enterprise architecture
        • Frontend
        • Backend
      • ADF architecture
        • Entity objects and associations
        • View objects and View Links
        • Application modules
        • The ADF user interface
        • ADF Task Flows
        • ADF pages and fragments
    • The Proof of Concept
      • What goes into a Proof of Concept?
      • Does the technology work?
      • How long does it take?
      • The Proof of Concept deliverables
    • Proof of Concept case study
      • Use cases
        • UC008 task overview and edit
        • UC104 Person Task timeline
      • Data model
    • Getting started with JDeveloper
      • The JDeveloper window and panels
      • Setting JDeveloper preferences
    • Proof of Concept ADF Business Components
      • Database Connection
      • Building Entity Objects for the Proof of Concept
      • Building associations for the Proof of Concept
      • Building view objects and view links for the Proof of Concept
        • Creating view objects for value lists
        • Creating a view object for tasks
        • Building an application module for tasks
        • Creating view objects for scheduling
        • Building an application module for scheduling
    • Proof of Concept ADF user interface
      • Creating ADF task flows
      • The tasks page
        • Creating the tasks page
        • Running the Initial Tasks Page
        • Refining the Tasks Page
        • Running the Tasks Page with parameters
        • Adding database operations
        • Running the tasks page with database operations
      • Creating the scheduled tasks page
        • Adding the Gantt component
      • Navigation
    • Summary
    • Chapter 2: Estimating the Effort
      • Gathering requirements
        • Use cases
        • User stories
        • Non-functional requirements
        • Requirements list
        • Screen design
      • Application architecture
        • The Work Breakdown Structure
      • Estimating the solution
        • Top-down estimate
        • Bottom-up estimate
          • Three-point estimates
          • Grouping: simple, normal, hard
          • More input, better estimates
      • Adding it all up: the final estimate
        • Swings and roundabouts
        • Calculating standard deviation for a task
        • Calculating standard deviation for a project
      • Sanity check
      • From effort to calendar time
      • Summary
      • Chapter 3: Getting Organized
        • Skills required
          • ADF framework knowledge
          • Object-oriented programming
          • Java programming
          • Database design and programming
          • XML
          • Web technologies
          • Regular expressions
          • Graphics design
          • Usability
          • Testing
        • Organizing the team
          • Project manager
          • Software architect and lead programmer
          • Regular programmers
            • Building business components
            • Building the user interface
            • Skinning
            • Templates
            • Defining data validation
            • Building support classes
            • Building database stored procedures
          • Build/configuration manager
          • Database and application server administrator
          • Graphics designers
          • Usability experts
          • Quality assurance, test manager, and tester
          • Data modelers
          • Users
        • Gathering the tools
          • Source control
          • Bug/issue tracking
          • Collaboration
            • Shared documents
            • Discussion forums
            • Online chat
          • Test and requirement management
          • Automated build system
        • Structuring workspaces, projects, and code
          • Workspaces
            • Common code workspace
            • Common user interface workspace
            • Common model workspace
            • Database workspace
            • Subsystem workspaces
            • Master workspace
        • Using projects
        • Naming conventions
          • General
          • Java packages
          • Database objects
          • ADF elements
          • File locations
          • Test code
        • Summary
        • Chapter 4: Productive Teamwork
          • The secret of productivity
            • Integrate your tools
            • The Oracle solution
              • Team Navigator
              • Chat
          • Oracle Team Productivity Center
            • Installing the server
            • Installing the client
            • Administration tasks
              • Adding users and teams
              • Connecting to a Jira repository
              • Connecting to a Subversion repository
              • Connecting to a chat server
              • Disconnecting
            • Getting started with work items
              • Connecting to your work item repository
              • Creating a work item
            • Daily work with work items
              • Finding work items
              • Setting the active work item
              • Linking work items
              • Tagging work items
            • Chatting with team members
            • Saving and restoring context
          • Version control
            • The Subversion software
            • Effective Subversion
            • Logging on
            • Initial load
            • Working with Subversion
            • Teamwork with Subversion
              • Getting a new copy
              • Getting other people's changes
              • Automatic merge
              • Handling conflicts
              • Avoiding conflicts
          • Subversion and Oracle Team Productivity Center together
          • Summary
          • Chapter 5: Prepare to Build
            • Task flow templates
              • Creating a task flow template
              • Contents of your master task flow template
                • Exception handling page
                • Common Help or About pages
                • Initializers and finalizers
              • Creating several levels of templates
            • Page templates
              • Creating a page template
              • Using layout containers
              • Facet definitions
              • Attributes
            • Framework extension classes
              • How Java classes are used in ADF
              • Some Java required
              • The place for framework extension classes
              • Creating framework extension classes
              • Using framework extension classes
            • Packaging your Common Code
            • Summary
            • Chapter 6: Building the Enterprise Application
              • Structuring your code
                • Workspaces
                • The workspace hierarchy
                • Creating a workspace
                • Working with ADF Libraries
                  • ADF Library workflow
                  • Using ADF Libraries
              • Building the Common Model
                • Creating the workspace
                • Using framework extension classes
                • Entity objects
                  • Generating primary keys
                  • Business rules
                  • User interface strings
                • Common view objects
                • Testing the Common Model
                • Exporting an ADF Library
              • Organizing the work
                • Preconditions
                • Development tasks
                • Creating business components
                  • Building view objects, view links, and application module
                  • Implementing business logic
                  • Testing your business components
                • Creating task flows
                • Reviewing the task flows
                • Creating the page fragments
                • Implementing UI logic
                • Defining the UI test
                • Reviewing the UI test
              • Implementing Task Overview and Edit (UC008)
                • Setting up a new workspace
                • Getting the libraries
                • Creating business components
                  • Starting work
                  • Building the main view object
                  • Building the application module
                  • Testing your business components
                  • Checking in your code
                  • Finishing the tasks
                • Creating the task flow
                  • Starting work
                  • Building the task flow
                • Creating the page fragments
                  • Layout
                  • Data table
                  • Search panel
                  • Running the page
                  • OK and Cancel
                • Checking in your code
                • Deploying your UC008 subsystem
              • Implementing person task timeline (UC104)
                • Setting up a new workspace
                • Getting the libraries
                • Creating business components
                  • Creating view objects for scheduling
                  • Building the persons view object
                  • Building the tasks view object
                  • Building the master-detail link
                  • Building the MinMaxDate view object
                  • Building the application module
                  • Testing your business components
                  • Finishing the tasks
                • Building the Task Flow
                • Building the page
                  • Adding a Gantt chart component
                  • Defining start and end time
                  • Running the page
                • Checking in your code
                • Deploying your UC104 subsystem
              • Building the master application
                • Setting up the master workspace
                • Getting the Libraries
                • Create the master page
                  • Create the layout
                  • Adding the menu
                • Creating a dynamic region
                • Understanding the dynamic region
                • Additional code for task flow switching
                  • Storing the selected task flow value
                  • Accessing the session bean from the backing bean
                  • Setting the task flow values
                  • Making the region re-draw itself
              • Summary
              • Chapter 7: Testing your Application
                • Initial tests
                  • Working with JUnit
                  • What to test with JUnit
                  • A good unit test
                  • Unit testing ADF applications
                  • Preparing for unit testing
                    • Setting up a test project
                    • Adding default testing
                  • Real unit testing example
                    • Adding a test case
                    • Implementing the logical delete
                    • Re-testing
                  • Automating unit testing
                • User interface tests
                  • Working with Selenium
                  • What to test with Selenium
                  • Installing Selenium
                  • A simple test with Selenium
                  • Automating user interface tests
                    • Setting up to run Selenium JUnit tests
                    • Starting the Selenium server
                    • Running the test
                  • Using Selenium effectively
                    • Value checking options
                    • Lazy content delivery
                    • Testing context menus
                    • Verifying item ID
                  • Testing passivation and activation
                • Stress/performance tests
                  • Working with JMeter
                  • What to test with JMeter
                  • Installing and running JMeter
                  • A simple test with JMeter
                    • Setting up JMeter as a proxy
                    • Recording a session
                  • Post-processing a recorded session
                    • Adding a Cookie Manager
                    • Defining variables
                    • Extracting values
                    • Fixing the path and the parameters
                  • Running a recorded session
                • The Oracle alternative
                • Summary
                • Chapter 8: Look and Feel
                  • Controlling the appearance
                    • Cascading Style Sheets basics
                    • Styling individual components
                      • Building a Style
                      • InlineStyle and ContentStyle
                    • Why does it look like that?
                    • Conditional formatting
                  • Skinning
                    • What should I skin?
                    • What can I skin?
                    • Skinning overview
                    • Starting a skin
                    • Creating a skin CSS file
                      • Creating the CSS file
                      • Style Classes
                      • Global Selector Aliases
                      • Faces Component Selectors
                      • Data Visualizations Component Selectors
                      • Finding the selector at runtime
                    • Providing images for your skin
                    • Changing the color scheme
                    • Creating a resource bundle for your skin
                    • Packaging the skin
                    • Using the skin
                  • Summary
                  • Chapter 9: Customizing the Functionality
                    • Why customization?
                    • How does an ADF customization work?
                    • Applying the customization layers
                    • Making an application customizable
                      • Developing the customization classes
                        • Building the classes
                        • Implementing the methods
                        • Deploying the customization classes
                      • Enabling seeded customization
                      • Linking the customization class to the application
                      • Configuring the customization layers
                    • Setting up JDeveloper for customization
                      • Making the customization class available to JDeveloper
                      • Selecting the customization role
                    • Performing the customization
                      • Customizing business components
                      • Customizing the pages
                      • Customizing strings
                      • What cannot be customized?
                    • Summary
                    • Chapter 10: Securing your ADF Application
                      • Security basics
                        • Authentication
                        • Authorization
                        • The Oracle security solution
                      • Security decisions
                        • Authentication
                        • Authorization
                        • Where to implement security
                      • Implementing ADF security
                        • Security model
                        • Authentication type
                        • Access grants
                        • Welcome page
                      • Application roles
                      • Implementing user interface security
                      • Implementing data security
                        • Defining protected operations
                          • Protecting an entity object
                          • Protecting an attribute
                        • Granting operations to roles
                      • Users and groups
                        • Mapping the application to the organization
                        • Example users and enterprise roles
                        • Assigning application roles
                        • Running the application
                        • Removing inaccessible items
                      • Summary
                      • Chapter 11: Package and Deliver
                        • What is in the package?
                          • The runnable application
                          • Database code
                          • Installation and operation instructions
                        • Preparing for deployment
                          • Cleaning up your code
                            • Database connections
                            • Test users and groups
                            • Other development artifacts
                          • Setting the application parameters for production use
                            • Application module tuning
                            • Controlling database locking
                            • Tuning your ADF application
                        • Setting up the application server
                          • Installing the ADF Libraries
                          • Setting up your domain
                          • Creating a DataSource on the server
                        • Deploying the application
                          • Direct deployment
                            • Creating an application server connection
                            • Deploying your application directly
                          • File deployment through the console
                            • Creating the EAR file
                            • Deploying the EAR file
                        • Scripting the build process
                          • Creating a build task
                          • Moving your task to the test/integration server
                          • Adding a Checkout
                          • Adding the database
                          • More scripting
                          • Automation
                        • Summary
                        • Appendix: Internationalization
                          • Automatic internationalization
                          • How localizable strings are stored
                          • Defining localizable strings
                          • Performing the translation
                          • Running your localized application
                            • Testing the localized business components
                            • Testing the localized user interface
                          • Localizing formats
                          • More internationalization
                          • Summary

                          Sten E. Vesterli

                          Sten E. Vesterli picked up Oracle development as his first job after graduating from the Technical University of Denmark and hasn't looked back since. He has worked with almost every development tool and server Oracle has produced in the last two decades, including Oracle ADF, JDeveloper, WebLogic, SQL Developer, Oracle Portal, BPEL, Collaboration Suite, Designer, Forms, Reports, and even Oracle Power Objects.

                          He started sharing his knowledge with a conference presentation in 1997 and has given more than 100 conference presentations at Oracle OpenWorld and at ODTUG, IOUG, UKOUG, DOAG, DOUG, and other user group conferences around the world since. His presentations are highly rated by the participants, and in 2010 he received the ODTUG Best Speaker award.

                          He has also written numerous articles, participated in podcasts, and written Oracle Web Applications 101,  Oracle ADF Enterprise Application Development – Made Simple, and  Developing Web Applications with Oracle ADF Essentials. You can find his blog at and follow him on Twitter as  @stenvesterli.

                          Oracle has recognized Sten's skills as an expert communicator on Oracle technology by awarding him the prestigious title, Oracle ACE Director, carried by less than 100 people in the world. He is also an Oracle Fusion User Experience Advocate and sits on the Oracle Usability Advisory Board and participates in the Oracle WebLogic Partner Council.

                          Based in Denmark, Sten is a partner in the Oracle consulting company Scott/Tiger, where he works as a senior principal consultant. When not writing books or presenting, he is helping customers choose the appropriate technology for their needs, teaching, mentoring, and leading development projects. In his spare time, Sten enjoys triathlon and completed his first Ironman in 2012.

                          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.


                          - 1 submitted: last submission 19 Feb 2014

                          Errata type: Code



                          The originally supplied script was missing constraints. The code bundle is now revised

                          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 Enterprise Application Development—Made Simple +    Documentum Content Management Foundations: EMC Proven Professional Certification Exam E20-120 Study Guide =
                          50% Off
                          the second eBook
                          Price for both: $32.70

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

                          What you will learn from this book

                          • Develop an ADF application quickly using database tables together with common ADF user interface components and data visualization components
                          • Estimate the effort required to build an ADF enterprise application
                          • Organize the development team, choose support tools, and write development guidelines to ensure a uniform development approach
                          • Set up the necessary infrastructure and configure a development workstation
                          • Develop necessary templates and framework classes to allow productive and flexible development
                          • Build a complete application using all the enterprise support tools
                          • Test your ADF enterprise application at the component, integration, and system levels
                          • Use skinning to change the look of the application to correspond to the enterprise's visual identity
                          • Customize the application to meet the needs and expectations of different users
                          • Secure the enterprise application and assign roles for specific functionality

                          In Detail

                          With Application Development Framework (ADF), Oracle gives you the tool its own developers use. Modern enterprise applications must be user-friendly, visually attractive, and fast performing and Oracle Fusion Applications are just that; but to get the desired output you need proven methods to use this powerful and flexible tool to achieve success in developing your enterprise applications.

                          Just as you need to know more than how to wield a hammer to build a house, you need more than knowing ADF to build a successful enterprise application. This book explains how to use the technology, create a blueprint, and organize your work to ensure success.

                          This book takes you through an entire enterprise application development project using ADF. The book begins with a proof of concept, demonstrating the basics of the ADF technology, and then moves on to estimating the effort. You will then learn the necessary skills required to structure your project, your code, and how to build a successful enterprise project with ADF.

                          Additional topics allow you to explore the support tools required for source control and issue tracking, learn to integrate them into your development environment, and use them productively to develop an enterprise application. Out-of-the-box functionalities such as skinning, customization, and internationalization are discussed at length.

                          All you need to know about building enterprise applications with Oracle ADF—not just the technology, but its organization, tools, and best practices


                          This book is written in an easy-to-read style, following an enterprise development process through all the phases from proof of concept to initiation and setup to development and on to integration testing and deployment. Concepts are illustrated with real-world examples and the approaches and methods are explained step by step.


                          Podcast content courtesy of Oracle

                          Duncan Mills, Senior Director of Product Management for Oracle's Development tools and author Sten Vesterli discuss Sten's book , the growth of ADF's popularity and hints and tips for the aspiring ADF developer.

                          Who this book is for

                          This book is for developers in general - both web developers and developers experienced with classic 4GL tools like Oracle Forms - who wish to learn how to develop modern, user-friendly web applications in an Oracle environment. It is for novice ADF developers who wish to learn how to use JDeveloper and ADF, as well as for more experienced ADF developers who wish to improve their knowledge and understanding of ADF and how to use it effectively.

                          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
                          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