Introduction to Fusion and ADF - Describe Fusion Architecture.
- Explain how ADF fits into the Fusion architecture.
- Describe the ADF technology stack (MVC).
- Identify sources of additional information about ADF and ADF Business Components.
Getting Started with JDeveloper - Describe benefits that JDeveloper provides for application development.
- Utilize common IDE mechanisms when developing and testing components.
- Set IDE preferences based on user requirements.
- Initiate the creation of empty applications, projects, and connections in JDeveloper.
Building a Data Model with ADF Business Components - Describe the role of ADF Business Components in building a business service.
- Explain the architecture of ADF BC.
- Identify the types of components that cooperate to provide the business service implementation.
- Explain how ADF BC components are used in a Web Application.
Querying and Persisting Data - Describe the characteristics of an ADF BC view object.
- Create a view object that can be used for performing a query in a Web application.
- Define a SQL statement on which to base a query for a view object.
- Explain how entity objects relate to database tables.
- Describe the persistence mechanism of entity objects.
- Use the Create Entity Object wizard to generate entity objects from database tables.
- Create associations between entity objects to represent business relationships.
- Create updatable view objects based on entity objects.
- Link view objects to one another in a master-detail hierarchy.
- Refactor objects in an application.
Exposing Data to Clients - Explain the role of application modules.
- Describe the characteristics of application modules.
- Use the Create Application Module wizard to define the data model for an application module.
- Explain how application modules can manage business components transactions.
- Explain how application modules can manage application stateE.
- Explain the role of the ADF Model.
Declaratively Customizing Data Services - Declaratively change data behavior.
- Declaratively modify the default behavior of view objects, entity objects, and application modules.
- Define a view access or for a list of values(LOV).
- Define a list of values (LOV) for an attribute.
Programmatically Customizing Data Services - Generate Java classes for business components to modify default behavior programmatically.
- Override class methods to change or augment default behavior.
- Modify the WHERE clause of a view object at run time.
- Explain the benefits of adding service methods at the application module level (rather than at the view level).
- Create a test client for testing your custom code.
- Modify a view object's client code to add a new employee to the employees view object.
Validating User Input - Describe the types of validation available for ADF applications.
- Evaluate which validation options are appropriate for different validations.
- Add declarative validation for an entity object.
- Identify the other non-declarative validation options and when they might be used.
- Describe the benefits of using domains for validation.
Troubleshooting ADF BC Applications - Identify the JDeveloper tools for logging and diagnostics.
- Use Java code auditing tools.
- Make use of FileMon and Junit to debug an application.
- Use the JDeveloper profiler.
- Use the JDeveloper debugger.
- Identify sources of Help.
Understanding UI Technologies - Describe the use of Web browsers and HTML.
- Explain how Java has come into widespread use as a language for developing Web applications.
- Describe the function of Servlets and JSPs.
- Define JavaServer Faces.
- Explain the JSF component architecture.
- Explain some JSF component types included in the standard implementation.
- Describe the purpose of backing beans.
- Describe the JSF life cycle.
- Explain how ADF Faces augments the JSF life cycle.
Binding UI Components to Data - Create an empty JSF page.
- Use three different ways to add ADF Faces UI components to a page.
- Describe the types of data-bound components that can be added to a JSF page.
- Describe the structure of an EL (Expression Language) expression.
| Planning the User Interface - Describe the Model-View-Controller design pattern.
- Differentiate between bounded and unbounded task flows.
- Create task flows to define control flow in an application.
- Specify control flow rules.
- Define global navigation.
- Use routers to declaratively route control flow to activities based on an EL expression.
- Define the role of managed beans in task flows.
- Explain the types of validation available in the user interface.
Adding Functionality to Pages - Internationalize the user interface so that the application can be used in multiple locales.
- Use component facets to specify subordinate elements such as toolbars, headers and footers.
- Implement a list of values (LOV) to enable users to select a value from a list.
- Add a calendar component to an input date field to make it easy for users to select a date.
- Use the table component to display structured data as a formatted table.
- Employ the tree component to display hierarchical data.
- Add icons and images to an application with ADF Faces output componentsE.
- Create Search forms using the ADF query component.
- Use ADF Data Visualization components to add charts, graphs, map etc to your JSF pages.
Implementing Navigation on Pages - Implement command buttons and links.
- Create menus - Menu bar.
- Create menus - Popup.
- Create menus - Context.
- Use a navigation page.
- Use breadcrumbs.
- Create trains.
Achieving the Required Layout - Build complex page layouts with layout components.
- Explain the role of ADF Faces skins.
- Use dynamic page layout.
Ensuring Reusability - Identify the benefits of reusing components.
- Create a resource catalog to enable sharing of resources within and across teams and applications.
- Create ADF libraries to share components within and across teams and applications.
- Create a task flow template for reuse across different bounded task flows.
- Create a page template for reuse across the JSF pages in an application to enable a consistent look and feel.
- Create a declarative component for reuse in different pages of an application.
- Create a page fragment to use in multiple pages of the application.
- Employ a bounded task flow as a region in a JSF page.
Passing Values between UI Elements - Evaluate whether the data model contains opportunities to reduce the need for passing values between pages.
- Use a managed bean to pass values between JSF pages.
- Store values in memory-scoped attributes to hold and pass information between pages and life cycle phases.
- Use parameters to pass information to different parts of the application.
Responding to Application Events - Configure managed beans to contain code to respond to events.
- Explain the different types of events.
- Use phase listeners to listen for and respond to events.
- Explain the role of an event listener.
- Use action listeners.
- Describe the sequence in which events and listeners are executed.
- Describe the features of JDeveloper that support ADF Faces enhanced event handling.
- Identify the server events fired by ADF Faces components.
- Use the contextual events framework to co-ordinate regions on a JSF page.
Implementing Transactional Capabilities - Explain ADF BC transaction handling.
- Enable an ADF bounded task flow to run as a transaction.
- Manage transaction exceptions on ADF bounded or unbounded task flows.
- Define the response to the browser's Back button (for an ADF task flow that was already exited).
- Implement Save for Later functionality.
Implementing Security in ADF BC Applications - Explain the need to secure applications.
- Describe security aspects of an ADF BC application.
- Add ADF Security Authentication to an application.
- Add ADF Security Authorization to an application.
- Use two approaches for granting users access to resources.
- Prevent unauthorized access to the ADF BC Model.
- Explain the types of application authentication at run time.
- Use Expression Language to extend the default security capabilities of the framework.
| Explore the Project Structure and Core File Architecture - Define File Structure of a Project.
- Examine how Metadata files are used to specify parameters, methods, and return values to a data control.
- Define ADF Data Control and Databinding Files.
- Explore the ADF Faces and Web Configuration Files to know where task flows, pages and code are created.
- Define Hierarchical Relationship of the XML Metadata files in a Web Application.
Extend the ADF Business Components Framework - Examine some general considerations when using ADF Business Components.
- Extend the ADF Business Components (ADF BC) Framework to customize your application.
- Override the standard way data is committed to the database using a PL/SQL procedure.
- Design ADF Business components to avoid database constraints.
Use ADF Business Components for Validation, Calculations and List of Values - Build Cascading List of Values.
- Enhance the Application with Calculations and Validation.
- Create Validation for Foreign Keys.
- Employ Groovy Expressions in Validations.
Use Inheritance in the Business Domain Layer - Reuse existing Business Component designs by extending components.
- Implement Supertype/Subtype designs using Entity Objects.
- Create View Objects to access more than one table.
ADF as a part of a Service Oriented Architecture - Expose ADF Business Components as SDO for use in a SOA Process (BPEL).
- Create Rich User Interfaces that access data from a composite application.
- Create events for ADF Business Components to trigger Enterprise Service Bus.
- Use Service Data Objects to access heterogeneous data in a uniform way.
Implement Data Binding Controls - Define and Recognize ADF Model binding types.
- Define ADF Model executables and how to use them.
- Customize data-bound components within the page definition file to support application requirements.
- Use Expression Language to connect page items to model components.
- Determine how model components get transformed into Data Control Palette items.
Practical Data Binding in Action - Describe how data binding and the JavaServer Faces (JSF) page life cycle.
- Define listeners and custom controllers to augment the ADFm life cycle.
- Explain how the Application Development Framework (ADF) life cycle works.
Work with Managed Beans and JavaServer Faces - Define key JavaServer Faces (JSF) terms.
- Describe the JSF Architecture with Application Development Framework (ADF).
- Differentiate between Managed and Backing Beans.
- In a JSF page, create and reference a Managed Bean to perform a custom method.
- Set and use Managed Properties to store and retrieve user login information.
- Use context object classes to access application messages, work with the Servlet API or ADF specific functionality.
ADF Faces Advanced Features - Examine AJAX and ADF.
- Employ Partial Page Rendering (PPR) on a JSF Page.
- Enhance a page by creating input and output items using ADF Components.
- Use page, panel and splitter components to design and build a JSF page.
- Develop UI shell templates to incorporate company standard behaviors, look and feel.
- Display numerical data using Data Visualization components and Active Data Services.
Integrate with WebCenter - Allow end users to perform runtime customization to their application pages.
- Integrate ADF pages with Content Management systems to access file systems.
- Add Web Center Services, like social networking and collaboration, to JSF/ADF pages.
- Add reusable Portlets that provide dynamic view of data, into a JSF/ADF page.
Customize the Application Look and Feel with Skins - Use Firebug and Mozilla Developer Toolbar to build skins.
- Explain how skin selectors work.
- Build instance specific skins.
- Develop a managed bean to change skin at runtime.
|
