Oracle ADF Enterprise Application Development - Made Simple - Helion

ebook

Autor: Sten E Vesterli
Tytuł oryginału: Oracle ADF Enterprise Application Development - Made Simple.
ISBN: 9781782176817
stron: 432, Format: ebook
Data wydania: 2014-02-19
Księgarnia: Helion

Cena książki: 152,10 zł (poprzednio: 169,00 zł)
Oszczędzasz: 10% (-16,90 zł)

Osoby, które kupiły tę książkę, wybierały także »

Osoby które kupowały "Oracle ADF Enterprise Application Development - Made Simple", wybierały także:

Jak zhakowa 125,00 zł, (10,00 zł -92%)
Blockchain i kryptowaluty. Kurs video. Zdecentralizowane finanse od podstaw 118,90 zł, (11,89 zł -90%)
Web scraping. Kurs video. Zautomatyzowane pozyskiwanie danych z sieci 126,36 zł, (13,90 zł -89%)
GraphQL. Kurs video. Buduj nowoczesne API w Pythonie 153,64 zł, (16,90 zł -89%)
Windows Media Center. Domowe centrum rozrywki 66,67 zł, (8,00 zł -88%)

Spis treści

Oracle ADF Enterprise Application Development - Made Simple eBook -- spis treści

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