You are previewing Oracle ADF Enterprise Application Development – Made Simple Second Edition.
O'Reilly logo
Oracle ADF Enterprise Application Development – Made Simple Second Edition

Book Description

The simplest way to learn Oracle’s ADF is to follow an enterprise development process from start to finish, which is exactly what this book does. Combining theory with real-world examples, it’s the ultimate guide for Oracle and J2EE developers.

In Detail

Modern enterprise applications must be user-friendly, visually attractive, and fast – much like Oracle Fusion applications. Oracle are using the Application Development Framework (ADF) for their own development, and now you can too. However, you need a proven method to use this powerful and flexible tool in order to achieve consistent success in your enterprise applications.

Oracle ADF Enterprise Application Development – Made Simple, Second Edition doesn’t just cover the theory behind Oracle ADF, it clearly explains how to get the most out of the technology.

Just like you need to do more than just wield a hammer to build a house, you need to do more than just master ADF technology to build a successful enterprise application. This book gives you the blueprint you need to ensure success.

This book takes you through an entire enterprise application development project using ADF, from proof of concept through all phases of development until the final application is delivered and deployed.

The book shows you the support tools you need for source control and issue tracking as well as how to use them productively to develop an enterprise application. It explains enterprise ADF application security as well as important specialty topics like skinning, customization, and internationalization.

This book will provide you with all the knowledge you need to make a real-life Oracle ADF development project a success.

What You Will Learn

  • Develop an ADF application based on database tables using both common and exotic ADF user interface components
  • Develop necessary templates and framework classes to allow productive and flexible development
  • Customize your applications to meet the needs and expectations of different users
  • Estimate the effort required to build an ADF enterprise application
  • Test your ADF enterprise application at the component, integration, and system level
  • Understand how to secure your enterprise applications and assign roles for specific functionality
  • Downloading the example code for this book. You can download the example code files for all Packt books you have purchased from your account at If you purchased this book elsewhere, you can visit and register to have the files e-mailed directly to you.

    Table of Contents

    1. Oracle ADF Enterprise Application Development – Made Simple Second Edition
      1. Table of Contents
      2. Oracle ADF Enterprise Application Development – Made Simple Second Edition
      3. Credits
      4. About the Author
      5. Acknowledgment
      6. About the Reviewers
        1. Support files, eBooks, discount offers, and more
          1. Why subscribe?
          2. Free Access for Packt account holders
          3. Instant updates on new Packt books
      8. Preface
        1. What is an enterprise application?
          1. Application size
          2. Development team
          3. Development tools
          4. Lifetime of an enterprise application
        2. What this book covers
        3. How to read this book
        4. What you need for this book
        5. Who this book is for
        6. Conventions
        7. Reader feedback
        8. Customer support
          1. Errata
          2. Piracy
          3. Questions
      9. 1. The ADF Proof of Concept
        1. Understanding the architecture of ADF
          1. Enterprise architecture
            1. The frontend part
            2. The backend part
          2. The ADF architecture
            1. Entity objects and associations
            2. View objects and view links
            3. Application modules
            4. The ADF user interface
            5. ADF Task Flows
            6. ADF pages and fragments
        2. The Proof of Concept
          1. Content of a Proof of Concept
          2. Making the technology work
          3. Determining the development speed
          4. The Proof of Concept deliverables
        3. The Proof of Concept case study
          1. Use cases
            1. UC008 Task Overview and Edit
            2. UC104 Person Task Timeline
          2. Data model
        4. Getting started with JDeveloper
          1. The JDeveloper window and panels
          2. Setting JDeveloper preferences
        5. The Proof of Concept ADF Business Components
          1. Creating a connection
          2. Entity objects for the Proof of Concept
          3. Building associations for the Proof of Concept
          4. Building view objects and view links for the Proof of Concept
            1. Creating view objects for value lists
            2. Creating a view object for tasks
            3. Building an application module for tasks
            4. Creating view objects for scheduling
            5. Building an application module for scheduling
        6. The Proof of Concept ADF user interface
          1. ADF Task Flows
          2. The tasks page
            1. Creating the tasks page
            2. Running the initial tasks page
            3. Refining the tasks page
            4. Fixing the bindings
            5. Running the tasks page with parameters
            6. Adding database operations
            7. Running the tasks page with database operations
        7. The scheduled tasks page
          1. Adding the Gantt component
          2. Navigation
        8. Summary
      10. 2. Estimating the Effort
        1. Gathering requirements
          1. Building it just like the old system
          2. Use cases
          3. User stories
          4. Non-functional requirements
          5. Requirement lists
          6. Screen design
        2. Deciding how to build it
          1. Deciding how much to build at a time
          2. Deciding how much to build yourself
          3. Deciding how to integrate
        3. Application architecture
        4. Example Work Breakdown Structure
        5. Estimating the solution
          1. Top-down estimate
          2. Bottom-up estimate
            1. Three-point estimates
            2. Grouping – simple, normal, and hard
            3. More input, better estimates
        6. Adding it all up – the final estimate
          1. Swings and roundabouts
          2. Calculating the standard deviation for a task
          3. Calculating the standard deviation for a project
        7. Sanity check
        8. From effort to calendar time
        9. Summary
      11. 3. Getting Organized
        1. Skills required for an ADF project
          1. ADF framework knowledge
          2. Object-oriented programming
          3. Java programming
          4. Database design and programming
          5. XML knowledge
          6. Web technologies
          7. Regular expressions
          8. Graphics design
          9. Usability
          10. Testing
        2. Organizing the team
          1. Project manager
          2. Software architect and lead programmer
          3. Regular programmers
            1. Building Business Components
            2. Building the user interface
            3. Skinning
            4. Templates
            5. Defining data validation
            6. Building support classes
            7. Building database stored procedures
          4. Build/configuration manager
          5. Database and application server administrator
          6. Graphic designers
          7. Usability experts
          8. Quality assurance, test manager, and tester
          9. Data modelers
          10. Users
        3. Gathering the tools
          1. Source control
          2. Bug/issue tracking
          3. Collaboration
            1. Shared documents
            2. Discussion forums
            3. Online chat
          4. Test and requirement management
          5. Automated build system
        4. Structuring workspaces, projects, and code
          1. Using projects
          2. Simple architecture
          3. Modular architecture
            1. Application Common Workspace
              1. Application Common Code project
              2. Application Common Model project
              3. Application Common User Interface project
            2. Database workspace
            3. Subsystem workspaces
            4. Master workspace
          4. Enterprise architecture
            1. Enterprise Common Workspace
            2. Master application workspaces
        5. Naming conventions
          1. General
          2. Java packages
            1. Project code
            2. Enterprise Common Code
          3. Database objects
          4. ADF elements
          5. File locations
          6. Test code
        6. Summary
      12. 4. Productive Teamwork
        1. The secret of productivity
          1. More pixels give better productivity
          2. Version control
          3. Avoiding spreadsheets
          4. Split your project into tasks
          5. Focus
          6. Integrate your tools
        2. Version control with Subversion
          1. Effective Subversion
          2. Handling new files
          3. Starting with Subversion
          4. Working with Subversion
            1. Getting a new copy
            2. Getting other people's changes
            3. Automatic merge
            4. Handling conflicts
        3. Version control with Git
          1. Effective Git
          2. Staging and committing
          3. Preparing your local repository
          4. Initial load of a workspace
          5. Working with Git
            1. Starting the day
            2. Starting work on a task
            3. Committing often to a task
            4. Completing a task
            5. Ending the day
            6. Handling conflicts
        4. Avoiding conflicts
        5. Focusing for maximum productivity
        6. The Integrated Solution – Oracle Team Productivity Center
          1. Installing the server
          2. Connecting JDeveloper to repositories
          3. Administration tasks
        7. Working with Oracle Team Productivity Center
          1. Working with work items
            1. Finding work items
            2. Setting the active work item
            3. Linking work items
            4. Tagging work items
          2. Saving and restoring context
          3. Code reviews
          4. Viewing build status
          5. Chat
          6. Reading news
        8. Summary
      13. 5. Preparing to Build
        1. Creating common workspaces
        2. Working with task flow templates
          1. Creating a task flow template
          2. Contents of your task flow template
            1. An exception handler
            2. Initializers and finalizers
          3. Creating several levels of templates
        3. Working with page templates
          1. Creating a page template
          2. Using layout containers
          3. Working with facets
            1. Defining template facets
            2. Understanding component facets
          4. Defining template attributes
          5. Adding content to the page template
        4. Framework extension classes
          1. Understanding how Java classes are used in ADF
          2. Some Java required
          3. The place for framework extension classes
          4. Creating framework extension classes
          5. Using framework extension classes
        5. Packaging your common code
        6. Summary
      14. 6. Building the Enterprise Application
        1. Structuring your code
          1. Using workspaces
          2. The workspace hierarchy
          3. Creating a workspace
          4. Working with ADF Libraries
            1. The ADF Library workflow
            2. Using ADF Libraries
        2. Building the Common Model
          1. Use framework extension classes
          2. Entity objects
            1. Primary key generation
            2. Business rules
            3. User interface strings
          3. Common View objects
          4. Testing the Common Model
          5. Exporting an ADF Library
        3. Organizing the work
          1. Preconditions
          2. Development tasks
          3. Creating Business Components
            1. Building view objects, view links, and the application module
            2. Implementing Business Logic
            3. Testing your Business Components
          4. Creating task flows
          5. Reviewing the task flows
          6. Creating the page fragments
          7. Implementing UI logic
          8. Defining the UI test
          9. Reviewing the UI test
        4. Implementing the task management subsystem
          1. Setting up a new workspace
          2. Getting the libraries
          3. Creating Business Components
            1. Starting work
            2. Building the main view object
            3. Building the application module
            4. Testing your Business Components
            5. Checking in your code
            6. Finishing the tasks
          4. Creating the task flow
          5. Creating the page fragment
            1. Data table
            2. Search panel
            3. Fixing the bindings
            4. Running the page
            5. OK and Cancel buttons
          6. Checking in your code
          7. Deploying the task management subsystem
        5. Implementing the scheduling subsystem
          1. Setting up a new workspace
          2. Getting the libraries
          3. Creating Business Components
            1. Building the persons' view object
            2. Building the tasks view object
            3. Building the master-detail link
            4. Building the MinMaxDate view object
            5. Building the application module
            6. Testing your Business Components
            7. Finishing the tasks
          4. Building the task flow
          5. Building the page
            1. Adding a Gantt chart component
            2. Defining the start and end time
            3. Running the page
          6. Checking in your code
          7. Deploying your scheduling subsystem
        6. Building the master application
          1. Setting up the master workspace
          2. Getting the libraries
          3. Creating the master page
            1. Creating the layout
            2. Adding the menu
          4. Creating a dynamic region
          5. Understanding the dynamic region
          6. Additional code for task flow switching
            1. Storing the selected task flow value
            2. Accessing the session bean from the backing bean
            3. Setting up the task flow values
            4. Making the region redraw itself
          7. Checking in your code
        7. Summary
      15. 7. Testing Your Application
        1. Initial tests
          1. Working with JUnit
          2. Using JUnit to test code
          3. Writing good unit tests
          4. The unit testing ADF applications
          5. Preparing for unit testing
            1. Setting up a test project
            2. Adding default testing
          6. The real unit testing example
            1. Adding a test case
            2. Implementing logical delete
            3. Re-testing
          7. Automating unit testing
        2. User interface tests
          1. What should you test?
          2. About Selenium
          3. Installing Selenium IDE
          4. A simple test with Selenium
          5. Exporting your test
          6. Using Selenium effectively
            1. Value checking options
            2. Lazy content delivery
            3. Testing the context menus
            4. Verifying the item ID
          7. Testing passivation and activation
        3. Stress and performance tests
          1. Working with JMeter
          2. Testing application performance with JMeter
          3. Installing and running JMeter
          4. A simple test with JMeter
            1. Setting up JMeter as a proxy
            2. Recording a session
          5. Post-processing a recorded session
          6. Running a recorded session
          7. Troubleshooting JMeter sessions
        4. The Oracle alternative
        5. Summary
      16. 8. Changing the Appearance
        1. Controlling appearance
          1. The Cascading Style Sheets basics
          2. Styling individual components
            1. Building a style
            2. InlineStyle and ContentStyle
          3. Unravelling the mysteries of CSS styling
          4. Conditional formatting
        2. Skinning overview
          1. Skinning capabilities
          2. Skinning recommendations
          3. The skinning process
          4. Creating a skin project
        3. Skinning in practice
          1. Creating a skin CSS file
          2. Working in the Design tab
          3. Working in the Selectors tab
          4. Style Classes
          5. Global Selector Aliases
          6. At-Rules
          7. Faces Component Selectors
          8. Data Visualizations Component Selectors
          9. Finding the selector at runtime
          10. Optionally providing images for your skin
          11. Optionally creating a resource bundle for your skin
          12. Packaging the skin
          13. Using the skin
        4. Summary
      17. 9. Customizing Functionality
        1. The reason for customization
        2. The technology behind ADF customization
        3. Applying customization layers
        4. Making an application customizable
          1. Developing customization classes
            1. Building the classes
            2. Implementing the methods
            3. Deploying the customization classes
          2. Enabling seeded customization
          3. Linking the customization class to the application
          4. Configuring customization layers
          5. Using resource bundles
          6. Allowing resource bundle customization
        5. Performing customization
          1. Selecting the customization role
          2. Customizing Business Components
          3. Customizing pages
          4. Customizing strings
          5. Elements that cannot be customized
        6. Summary
      18. 10. Securing Your ADF Application
        1. The security basics
          1. Authentication means knowing your user
          2. Authorization means deciding on access
          3. The Oracle security solution
          4. Alternative security
        2. Security decisions
          1. Performing authentication
          2. Performing authorization
          3. Where to implement security
        3. Implementing ADF Security
          1. Selecting a security model
          2. Selecting the authentication type
          3. Selecting how to grant access
          4. Select a common welcome page
        4. Application roles
        5. Implementing the user interface security
          1. Securing task flows
          2. Securing pages
          3. Using entitlements
        6. Implementing data security
          1. Defining protected operations
            1. Protecting an entity object
            2. Protecting an attribute
          2. Granting operations to roles
        7. Users and groups
          1. Mapping the application to the organization
          2. Example users and enterprise roles
          3. Assigning application roles
          4. Running the application
          5. Removing inaccessible items
        8. Summary
      19. 11. Packaging and Delivery
        1. The contents of a good deployment package
          1. The runnable application
          2. Database code
          3. Installation and operation instructions
        2. Preparing for deployment
          1. Cleaning up your code
            1. Test users and groups
            2. Other development artifacts
            3. Performing code audit
            4. Ignoring rules
            5. Checking more rules
          2. Setting application parameters for production use
            1. Application module tuning
            2. Controlling database locking
            3. Tuning your ADF application
        3. Setting up the application server
          1. Number of servers
          2. Installing WebLogic 12c standalone for ADF
          3. Creating a data source on the server
        4. Deploying the application
          1. Direct deployment
            1. Creating an application server connection
            2. Deploying your application directly
          2. Deploying the file through the console
            1. Creating the EAR file
            2. Deploying the EAR file
        5. Scripting the build process
          1. Creating a build task
            1. Creating a build task for the master project
            2. Creating build tasks for ADF Libraries
            3. Creating a build task for the master application
          2. Moving your task to the test/integration server
          3. Adding a checkout
          4. Adding the database
          5. More scripting
          6. Automation
        6. Summary
      20. A. Internationalization
        1. Automatic internationalization
          1. How localizable strings are stored
          2. Defining localizable strings
          3. Performing the translation
        2. Running your localized application
          1. Testing the localized Business Components
          2. Testing the localized user interface
        3. Localizing formats
        4. More internationalization
        5. Summary
      21. Index