You are previewing Oracle ADF Enterprise Application Development—Made Simple.
O'Reilly logo
Oracle ADF Enterprise Application Development—Made Simple

Book Description

What better way to learn ADF than by completing an entire enterprise application development project, step by step? This book leads you through the whole process with plain instructions and clear guidance at every stage.

  • 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

  • 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

    Table of Contents

    1. Oracle ADF Enterprise Application Development—Made Simple
      1. Table of Contents
      2. Oracle ADF Enterprise Application Development—Made Simple
      3. Credits
      4. About the Author
      5. Acknowledgement
      6. About the Reviewers
      7. www.PacktPub.com
        1. Support files, eBooks, discount offers and more
        2. Why Subscribe?
        3. Free Access for Packt account holders
        4. 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. Downloading the example code
          2. Errata
          3. Piracy
          4. Questions
      9. 1. The ADF Proof of Concept
        1. The very brief ADF primer
          1. Enterprise architecture
            1. Frontend
            2. Backend
          2. 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. What goes into a Proof of Concept?
          2. Does the technology work?
          3. How long does it take?
          4. The Proof of Concept deliverables
        3. 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. Proof of Concept ADF Business Components
          1. Database Connection
          2. Building 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. Proof of Concept ADF user interface
          1. Creating ADF task flows
          2. The tasks page
            1. Creating the tasks page
            2. Running the Initial Tasks Page
            3. Refining the Tasks Page
            4. Running the Tasks Page with parameters
            5. Adding database operations
            6. Running the tasks page with database operations
          3. Creating the scheduled tasks page
            1. Adding the Gantt component
          4. Navigation
        7. Summary
      10. 2. Estimating the Effort
        1. Gathering requirements
          1. Use cases
          2. User stories
          3. Non-functional requirements
          4. Requirements list
          5. Screen design
        2. Application architecture
          1. The Work Breakdown Structure
        3. Estimating the solution
          1. Top-down estimate
          2. Bottom-up estimate
            1. Three-point estimates
            2. Grouping: simple, normal, hard
            3. More input, better estimates
        4. Adding it all up: the final estimate
          1. Swings and roundabouts
          2. Calculating standard deviation for a task
          3. Calculating standard deviation for a project
        5. Sanity check
        6. From effort to calendar time
        7. Summary
      11. 3. Getting Organized
        1. Skills required
          1. ADF framework knowledge
          2. Object-oriented programming
          3. Java programming
          4. Database design and programming
          5. XML
          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. Graphics 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. Workspaces
            1. Common code workspace
            2. Common user interface workspace
            3. Common model workspace
            4. Database workspace
            5. Subsystem workspaces
            6. Master workspace
        5. Using projects
        6. Naming conventions
          1. General
          2. Java packages
          3. Database objects
          4. ADF elements
          5. File locations
          6. Test code
        7. Summary
      12. 4. Productive Teamwork
        1. The secret of productivity
          1. Integrate your tools
          2. The Oracle solution
            1. Team Navigator
            2. Chat
        2. Oracle Team Productivity Center
          1. Installing the server
          2. Installing the client
          3. Administration tasks
            1. Adding users and teams
            2. Connecting to a Jira repository
            3. Connecting to a Subversion repository
            4. Connecting to a chat server
            5. Disconnecting
          4. Getting started with work items
            1. Connecting to your work item repository
            2. Creating a work item
          5. Daily work with work items
            1. Finding work items
            2. Setting the active work item
            3. Linking work items
            4. Tagging work items
          6. Chatting with team members
          7. Saving and restoring context
        3. Version control
          1. The Subversion software
          2. Effective Subversion
          3. Logging on
          4. Initial load
          5. Working with Subversion
          6. Teamwork with Subversion
            1. Getting a new copy
            2. Getting other people's changes
            3. Automatic merge
            4. Handling conflicts
            5. Avoiding conflicts
        4. Subversion and Oracle Team Productivity Center together
        5. Summary
      13. 5. Prepare to Build
        1. Task flow templates
          1. Creating a task flow template
          2. Contents of your master task flow template
            1. Exception handling page
            2. Common Help or About pages
            3. Initializers and finalizers
          3. Creating several levels of templates
        2. Page templates
          1. Creating a page template
          2. Using layout containers
          3. Facet definitions
          4. Attributes
        3. Framework extension classes
          1. 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
        4. Packaging your Common Code
        5. Summary
      14. 6. Building the Enterprise Application
        1. Structuring your code
          1. Workspaces
          2. The workspace hierarchy
          3. Creating a workspace
          4. Working with ADF Libraries
            1. ADF Library workflow
            2. Using ADF Libraries
        2. Building the Common Model
          1. Creating the workspace
          2. Using framework extension classes
          3. Entity objects
            1. Generating primary keys
            2. Business rules
            3. User interface strings
          4. Common view objects
          5. Testing the Common Model
          6. Exporting an ADF Library
        3. Organizing the work
          1. Preconditions
          2. Development tasks
          3. Creating business components
            1. Building view objects, view links, and 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 Task Overview and Edit (UC008)
          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
            1. Starting work
            2. Building the task flow
          5. Creating the page fragments
            1. Layout
            2. Data table
            3. Search panel
            4. Running the page
            5. OK and Cancel
          6. Checking in your code
          7. Deploying your UC008 subsystem
        5. Implementing person task timeline (UC104)
          1. Setting up a new workspace
          2. Getting the libraries
          3. Creating business components
            1. Creating view objects for scheduling
            2. Building the persons view object
            3. Building the tasks view object
            4. Building the master-detail link
            5. Building the MinMaxDate view object
            6. Building the application module
            7. Testing your business components
            8. Finishing the tasks
          4. Building the Task Flow
          5. Building the page
            1. Adding a Gantt chart component
            2. Defining start and end time
            3. Running the page
          6. Checking in your code
          7. Deploying your UC104 subsystem
        6. Building the master application
          1. Setting up the master workspace
          2. Getting the Libraries
          3. Create the master page
            1. Create 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 the task flow values
            4. Making the region re-draw itself
        7. Summary
      15. 7. Testing your Application
        1. Initial tests
          1. Working with JUnit
          2. What to test with JUnit
          3. A good unit test
          4. Unit testing ADF applications
          5. Preparing for unit testing
            1. Setting up a test project
            2. Adding default testing
          6. Real unit testing example
            1. Adding a test case
            2. Implementing the logical delete
            3. Re-testing
          7. Automating unit testing
        2. User interface tests
          1. Working with Selenium
          2. What to test with Selenium
          3. Installing Selenium
          4. A simple test with Selenium
          5. Automating user interface tests
            1. Setting up to run Selenium JUnit tests
            2. Starting the Selenium server
            3. Running the test
          6. Using Selenium effectively
            1. Value checking options
            2. Lazy content delivery
            3. Testing context menus
            4. Verifying item ID
          7. Testing passivation and activation
        3. Stress/performance tests
          1. Working with JMeter
          2. What to test 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
            1. Adding a Cookie Manager
            2. Defining variables
            3. Extracting values
            4. Fixing the path and the parameters
          6. Running a recorded session
        4. The Oracle alternative
        5. Summary
      16. 8. Look and Feel
        1. Controlling the appearance
          1. Cascading Style Sheets basics
          2. Styling individual components
            1. Building a Style
            2. InlineStyle and ContentStyle
          3. Why does it look like that?
          4. Conditional formatting
        2. Skinning
          1. What should I skin?
          2. What can I skin?
          3. Skinning overview
          4. Starting a skin
          5. Creating a skin CSS file
            1. Creating the CSS file
            2. Style Classes
            3. Global Selector Aliases
            4. Faces Component Selectors
            5. Data Visualizations Component Selectors
            6. Finding the selector at runtime
          6. Providing images for your skin
          7. Changing the color scheme
          8. Creating a resource bundle for your skin
          9. Packaging the skin
          10. Using the skin
        3. Summary
      17. 9. Customizing the Functionality
        1. Why customization?
        2. How does an ADF customization work?
        3. Applying the customization layers
        4. Making an application customizable
          1. Developing the 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 the customization layers
        5. Setting up JDeveloper for customization
          1. Making the customization class available to JDeveloper
          2. Selecting the customization role
        6. Performing the customization
          1. Customizing business components
          2. Customizing the pages
          3. Customizing strings
          4. What cannot be customized?
        7. Summary
      18. 10. Securing your ADF Application
        1. Security basics
          1. Authentication
          2. Authorization
          3. The Oracle security solution
        2. Security decisions
          1. Authentication
          2. Authorization
          3. Where to implement security
        3. Implementing ADF security
          1. Security model
          2. Authentication type
          3. Access grants
          4. Welcome page
        4. Application roles
        5. Implementing user interface security
        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. Package and Deliver
        1. What is in the package?
          1. The runnable application
          2. Database code
          3. Installation and operation instructions
        2. Preparing for deployment
          1. Cleaning up your code
            1. Database connections
            2. Test users and groups
            3. Other development artifacts
          2. Setting the 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. Installing the ADF Libraries
          2. Setting up your domain
          3. Creating a DataSource on the server
        4. Deploying the application
          1. Direct deployment
            1. Creating an application server connection
            2. Deploying your application directly
          2. File deployment through the console
            1. Creating the EAR file
            2. Deploying the EAR file
        5. Scripting the build process
          1. Creating a build task
          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
        2. How localizable strings are stored
        3. Defining localizable strings
        4. Performing the translation
        5. Running your localized application
          1. Testing the localized business components
          2. Testing the localized user interface
        6. Localizing formats
        7. More internationalization
        8. Summary
      21. Index