Oracle ADF Enterprise Application Development – Made Simple, Second Edition电子书

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 people's 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