Oracle ADF Enterprise Application Development - Made Simple Sten E Vesterli

Spis treści książki

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

pokaż cały spis treści

ukryj recenzje