Oracle ADF Interview questions

Why ADF ?  

Oracle ADF(Application Development Framework) is state of the art technology to rapidly build enterprise application. ADF is a mature J2EE development framework and many other products under Oracle Fusion Middleware stack are build upon ADF 11g.

ADF provides variety of inbuilt components that minimizes the need to write code allowing users to focus more on features and business aspects of the application. With WebCenter and SOA plugins, we can also integrate WebCenter Services and SOA into your application making it rich and extensible.

Explain about JSF lifecycle ?

The six phases of the JSF application lifecycle are as follows (note the event processing at each phase):

-Restore view

-Apply request values; process events

-Process validations; process events

-Update model values; process events

-Invoke application; process events

-Render response

Immediate=true :

A command button that does not provide any navigation and is set to immediate will also go directly to the Render Response phase: the Validation, Update Model, and Invoke Application phases are skipped, so any new values will not be pushed to the server.

Explain about ADf lifecylce ?

ADF Lifecycle has Nine phases as follows:

1) Initialize Context : In this phase value of associated request, binding container and lifecycle are set.

2) Prepare Model : In this phase model is prepared and initialized. In this phase page parameters are set and methods in the executable section of the page definition of the ADF page are executed.

3)Apply Input Values : This phase handles the request parameters. These may come by adding the request parameters in the URL or as a result of HTML form post action. A list of events is build using these request parameters. These are actually mapped to the bindings in the pageDef. This phase resolves the list of request parameters bind to attributes in the page def. This results into a list of updatedValues which is used in Update Model phase.

4) Validate Input Values : This phase validates the list of values built in the Apply input values field with model.

5) Update Model : After validation of input values data model is updated with the list of values created in apply input values phase.

6) Validate Model Updates : Updates in the previous phase are then validated by calling the associated lifecycle's binding container .

7) Process Component Updates : This phase handles any events in the list built during the apply input values phase. Named events as well as all the events tied to the databindings created in the pagdef are handled in this phase.

8) Metadata Commit : This phase commits the runtime metadata changes to the model. This phase is always executed before prepare render phase.

9) Prepare Render : This is the final phase where page is sent for rendering. prepareRender event is sent to all the registered listeners. This notification signals bindings to prepare or process the data for rendering. Binding container is also refreshed. This helps in updating any changes that happened during validation phases.

What is partial page rendering ? 

PPR is Partial Page Rendering, similarly to Ajax. It is used to dynamically refresh the part of page.It is done with the use of partial triggers.For a component to trigger another component to refresh, the trigger component must cause a submit when an appropriate action takes place.
Following three main component attributes are used to enable partial page rendering.

autoSubmit: When the autoSubmit attribute of an input or select component is set to true, and an appropriate action takes place (such as a value change), the component automatically submits the form it is enclosed in.

partialSubmit: When the partialSubmit attribute of a command component is set to true, clicking the button or link causes the page to be partially submitted.

partialTriggers: All rendered components support the partialTriggers attribute. Use this attribute to list the IDs of components whose change events are to trigger this component to be refreshed.

 What is a phase listener ? 

The Oracle ADF lifecycle integrates with the JavaServer Faces request lifecycle, adding all that it takes to set up the binding context, prepare the binding container, validate and update the ADF model, persist MDS changes and prepare the response. 

Developers who need to listen and interact with the request cycle may use an ADF Phase Listener to do so. Unlike the Phase Listener you define in the faces-config.xml file, the ADF Phase Listener allows you to listen to the standard and the ADF phases.The ADF Phase Listener is defined in Java - of course - and configured in the adf-settings.xml file you need to create.

ADF PagePhaseListener can be used always and for anything

In Oracle ADF framework developer can use standard JSF listener or special ADF listener which supports additional ADF-specific page cycle extensions. Listeners can be used to customize the ADF Lifcycle.

What are validators and convertors in ADF ?

validators :

If somehow you need to create your own validation logic to meet your business needs. You can either create a validation method on the page's backing bean (if you want custom validation for a component on a single page), or create JSF validator classes (if you want to reuse the validation logic by various pages in the application).In the real world, of course creating the custom JSF validator classes would be adopted for ADF application for better reuse and maintenance.

convertors :

Converters are used for converting the values from one type to another,like decimal to big-decimal or from string to date or date to string.

Explain about ADF event handling ? 

In traditional JSF applications, event handling typically takes place on the server. JSF event handling is based on the JavaBeans event model, where event classes and event listener interfaces are used by the JSF application to handle events generated by components. 

Examples of user events in an application include clicking a button or link, selecting an item from a menu or list, and changing a value in an input field. When a user activity occurs such as clicking a button, the component creates an event object that stores information about the event and identifies the component that generated the event. The event is also added to an event queue. At the appropriate time in the JSF lifecycle, JSF tells the component to broadcast the event to the appropriate registered listener, which invokes the listener method that processes the event. The listener method may trigger a change in the user interface, invoke backend application code, or both.

Like standard JSF components, ADF Faces command components deliver ActionEvent events when the components are activated, and ADF Faces input and select components deliver ValueChangeEvent events when the component local values change.

Explain role of Javascript in ADF ?

The ADF Faces architecture is designed such that application developers don’t need to write JavaScript code themselves for most of the use cases they build. JavaScript in ADF Faces applications therefore should be used as an exception rather than the rule.

Explain about ADF Architecture ?

Oracle ADF implements MVC and further separates the model layer from the business services to enable service-oriented development of applications. The Oracle ADF architecture is based on four layers:

 The Business Services layer - provides access to data from various sources and handles business logic.

 The Model layer - provides an abstraction layer on top of the Business Services layer, enabling the View and Controller layers to work with different implementations of Business Services in a consistent way.

 The Controller layer - provides a mechanism to control the flow of the Web application.

 The View layer - provides the user interface of the application.

 

Difference between backing beans and managed beans?

Backing beans are JavaBeans components associated with UI components used in a page. Backing-bean management separates the definition of UI component objects from objects that perform application-specific processing and hold data.

Backing Beans are merely a convention, a subtype of JSF Managed Beans which have a very particular purpose. There is nothing special in a Backing Bean that makes it different from any other managed bean apart from its usage.What makes a Backing Bean is the relationship it has with a JSF page; it acts as a place to put component references and Event code.

Backing Beans : A backing bean is any bean that is referenced by a form. Backing Beans should be defined only in the request scope

Managed Beans : A managed bean is a backing bean that has been registered with JSF (in faces-config.xml) and it automatically created (and optionally initialized) by JSF when it is needed. The advantage of managed beans is that the JSF framework will automatically create these beans, optionally initialize them with parameters you specify in faces-config.xml,

What is ADFc and ADFm?  

ADFc-ADF Controller : The controller component in ADF is an extension of the JSF navigation model and promotes modularization and reuse. In addition, ADFc provides declarative transaction handling and clearly defined process boundaries.

 ADFm-ADF model : Binding layer and model are represented by data controls and the binding container object. ADFm is built on JSR-227 and abstracts the view layer model access from the implementation details of the underlying business service.

 What is the role of web.xml, adfc-config.xml , faces-config.xml ?

web.xml : Part of a JSF application's configuration is determined by the contents of its Java EE application deployment descriptor, web.xml. The web.xml file, which is located in the /WEB-INF directory, defines everything about your application that a server needs to know (except the root context path, which is automatically assigned for you in JDeveloper, or assigned by the system administrator when the application is deployed). Typical runtime settings in the web.xml file include initialization parameters, custom tag library location,session time out and security settings.

The following is configured in the web.xml file for all applications that use ADF Faces:

Context parameter javax.faces.STATE_SAVING_METHOD set to client

MyFaces Trinidad filter and mapping

MyFacesTrinidad resource servlet and mapping

JSF servlet and mapping

adfc-config.xml : The adfc-config.xml file is the default page flow diagram JDeveloper provided when you created an application based on the Fusion Web Application (ADF) template. adfc-config.xml is the default file name for an unbounded task flow. On this diagram, you can create a new page based on the template, which is not part of the existing orders-flow task flow.

faces-config.xml : The JSF configuration file is where you register a JSF application's resources such as custom validators and managed beans, and define all the page-to-page navigation rules. While an application can have any JSF configuration file name, typically the file name is the faces-config.xml file. Small applications usually have one faces-config.xml file.When you use ADF Faces components in your application, JDeveloper automatically adds the necessary configuration elements for you into faces-config.xml

adf-settings.xml : The adf-settings.xml file holds project- and library-level settings such as ADF Faces help providers and caching/compression rules. The configuration settings for the adf-settings.xml files are fixed and cannot be changed during and after application deployment. There can be multiple adf-settings.xml files in an application. ADF settings file users are responsible for merging the contents of their configurations.

What are taskflows ? 

ADF task flows provide a modular approach for defining control flow in an application. Instead of representing an application as a single large JSF page flow, you can break it up into a collection of reusable task flows. Each task flow contains a portion of the application's navigational graph. The nodes in the task flows are activities. An activity node represents a simple logical operation such as displaying a page, executing application logic, or calling another task flow. The transactions between the activities are called control flow cases. 

What are various scopes in ADF.Explain difference between pageflow scope, backing bean scope, session scope, view scope, request scope, application scope?

In addition to the normal object scopes that jsf (1.2) defines, adf adds some more on top of it. I will try to differentiate the different memory scopes available in adf.

 Application Scope – Just like a static object in java. Single Object available to all users. Gets instantiated when server starts.

Session Scope – Your normal session variables. used to store the data specific to a specific user to be used during a session.

PageFlow Scope – Simply a value once set in a page flow scope is available in all the pages that are part of the taskflow.

Request Scope – Now this is good. Lets say on one page we have a number of components like a button, LOVs , input boxes etc. To clearly understand the request scope lets say we select a drop down. Clicking on the drop down sends a request to the server and the page stays as it is. So each action basically here is a request to the server and the values stored in the request scope changes on each request. Request scope doesn’t mean the entire page has to change or get submitted. ADF Faces is built on Ajax and clicking on LOVs and buttons at times generate partial submits.

View Scope – Values set in the view scope area available on till that page it rendering. One you change from one page to another the value is lost.

Explain architecture of bounded taskflows and unbounded taskflows?

The concept of unbounded and bounded task flows is new to JavaServer Faces (JSF) and is an extension exclusively available to Fusion web application developers who use the ADF Controller, which extends the JSF navigation model, for their application flow handling.

ADF task flows provide a modular approach for defining control flow in an application. Instead of representing an application as a single large JSF page flow, you can break it up into a collection of reusable task flows. Each task flow contains a portion of the application's navigational graph. The nodes in the task flows are activities. There are two types of activities: visual vs. non-visual. The transitions between the activities are called control flow cases.
Because only pages and page fragments are displayed in a browser, ADF Controller continues any navigation to non-visual activities until a visual activity is reached. This turns non-visual activities into intermediary actions that are performed on the navigation path between two views.

Task flows don't own the pages they reference. All ADF Faces pages are located in the web project HTML root directory or a subdirectory of it. Independent of whether or not a page is referenced in a bounded or unbounded task flow, or both, it is always directory accessible from the browser URL field. Developers should be aware of this and implement a protection strategy, such as one through ADF security, that prevents users from directly accessing pages that they are not authorized to access.

At design time, developers need to consider the following issues with task flows:

Whether to use a shared data control frame or its own, isolated data control frame (this creates a new application module connection). Note that a data control frame is the container associated with a task flow that contains data control instances.

Whether a new transaction is to be begun or not Whether a task flow should allow reentry or not Whether an unbounded task flow or a bounded task flow should be used

Bounded Task Flow :

Bounded task flow represents modular and reusable application flows with a defined entry (i.e., default activity) and zero to many defined exit points (i.e., task flow return activities). They can be called from other task flows, referenced from a browser URL or embedded as a region in a view. They support reuse, parameters, transaction management and reentry.

In addition, bounded task flows have the following features:

Operate within their own private memory scope--page flow scope

Are loaded lazily at runtime A new instance of TaskFlowContext (can be accessed using EL ${controllerContext.currentViewPort.taskFlowContext}) will be created each time a bounded ADF flow is entered. This context Manages the lifespan of all DataControl instances within the bounded task flow

Holds the information about the task flow ID and whether or not it contains uncommitted data

Don't support multiple transactions when sharing the data control frame with parent flow

To call a bounded task flow directly from a URL, the default activity must be a view activity

Can be set to be critical (i.e., dictates the framework to create an implicit save point when entering a bounded task flow. Also helps to prevent users from closing the browser window or browser tab if uncommitted data is present).

If protected by ADF Security, authorization is checked first.

You can create train-based activities in a bounded task flow and only one train is allowed in each

Bounded task flow should be used if it:

 Should be reused in same or other applications
 Should run as part of a page within a region container

 Requires an isolated transaction context

 Changes data and then either commits or rollbacks on exit

 Has a requirement for a single entry point

Unbounded Task Flow : 

A Fusion web application always contains an ADF unbounded task flow, which contains the entry point or points to the application. Its XML configuration file (i.e., adfc-config.xml) is automatically created when building a new application using the Fusion Web Application (ADF) application template or when adding the ADF Page Flow Technology Scope to an existing or new web project. There will always exist a single instance of unbounded task flow at runtime, even if there is no activity added to it.

A unbounded task flow has the following features:

 You cannot declaratively specify input parameters for it.
 It cannot contain a default activity (i.e., an activity designated as the first to run in the task flow). This is because an unbounded task flow does not have a single point of entry.

 It can be configured by one or many configuration files that are parsed and loaded the first time the user starts the application.

 View activities of an unbounded task flow can be configured bookmarkable

 Managed beans that are in session or application scope should be configured in the unbounded task flow definition.

 You cannot create a train from activities in an unbounded task flow.

 You cannot use a task flow template as the basis for creating a new unbounded task flow

You typically use an unbounded instead of a bounded task flow if:

 You want to take advantage of ADF Controller features not offered by bounded task flows, such as bookmarkable view activities.
 The task flow will not be called by another task flow.

 The application has multiple points of entry. The task flow can be entered through any of the pages represented by the view activity icons on the unbounded task flows.

 You want to bookmark more than one activity on the task flow.

 For application flows that are not restrictive on where a user enters the flow.

Why is ADF better from JSF and advantages of ADF over other frameworks. 

ADF Task Flows - extension of the JSF controller layer that adds complete process flow and reusability aspects.

From User prospective:

 Rich interface.

 Easy to use and/or learn to use.

 Much information on single page (accordion layout, collapsible panel, and so forth).

 Consistent look and feel.

 Drag and Drop facility, etc.

From Developer prospective:

Declarative way of building application.
 150+ ready to use Rich component.

 Multiply ways to develop and reuse components (declarative component, page template, taskflows, etc.)

 Customizable

 Maintainable

 Highly decoupled

 SOA enable, And so forth.

Any idea what are contextual events?

Often a page or a region within a page needs information from somewhere else on the page or from a different region. While you can pass parameters to obtain that information, doing so makes sense only when the parameters are well known and the inputs are EL-accessible to the page. Parameters are also useful when a task flow may need to be restarted if the parameter value changes.

However, suppose you have a task flow with multiple page fragments that contain various interesting values that could be used as input on one of the pages in the flow. If you were to use parameters to pass the value, the task flow would need to surface output parameters for the union of each of the interesting values on each and every fragment. Instead, for each fragment that contains the needed information, you can define a contextual event that will be raised when the page is submitted. The page or fragment that requires the information can then subscribe to the various events and receive the information through the event.

Contextual Events is an Oracle ADF feature that enables developers to implement view-to-region, region-to-view, and region-to-region communication.Among the options for passing information to and from regions, Contextual Events is the most powerful and the option that does not make regions refresh or require the referenced bounded task flow to restart.

Explain ADFBC architecture.

Any J2EE application has up to three separate logcal tiers :

A client tier containing code that runs on the client and with which a user interacts

A web tier containing code that generates a user interface on an application server

A business tier containing the business logic

ADF BC is a java and XML bases framework for developing : 

Business logic, including validation and default logic

Queries

Transaction handling

Data access

What advantages does ADFBC gives?

It does not create a user interface, but is a pure encapsulation of business logic that communicates with a separate client application, which handles user interaction.

The advantage of ADF BC over UI-enforced business logic is reusability.

By maintaining a cache of data in memory, ADF BC reduces the number of database trips required by an application resulting in improved performance and scalability.

Removing the business logic out of the database keeps the database from handling anything but data, which increases an application's modularity and efficiency.

Entity objects, view objects, and application modules each have two parts: a Java class file and an XML file. The files have different purposes. ADF BC is a framework, this means that much of its functionality is contained in a set of libraries. ADF BC classes extend (subclass) the base classes provided by these libraries to provide complex business logic, which requires the procedural power of Java to implement.

Explain role of VO, EO and AM?

Entity object - An entity object represents a row in a database table. You can compare it with an EJB in J2EE world. It simplifies modifying table row data by handling all data manipulation language (DML) operations for you. It can encapsulate business logic for the row and all DML goes via entity object so you can ensure that your business rules are consistently enforced. You associate an entity object with another entity object to reflect relationships in the underlying database schema. The relationship between two EOs is called Entity Association.

View object - A view object represents a SQL query. You use the full power of the familiar SQL language to join, filter, sort, and aggregate data into exactly the shape required by the end-user task. When end users modify data in the user interface, your view objects delegate the work to entity objects to consistently validate and save the changes. You can create view level relationships between different view objects and it is called as View Link.
View Links are useful when you have master-child hierarchies and you want to reflect that in the data visible to your client.

Application module - An application module is the transactional component that clients use to work with application data. It defines an updatable data model and top-level procedures and functions (called service methods) related to a logical unit of work related to an end-user task. Application Modules include one or move View Objects, along with their associated View Links.


Can we write ADF applications on a webservice?
Yes  

What is AM Pooling ? Do we need to write JDBC queries now to communicate with ADF?

At its most simple, an application module pool is a collection of instances of a single application module type which are shared by multiple application clients. For example, the ADF Toy Store application has an application module named store.model.services.storeService. An application module pool supporting the Store demo would have one or more instances of this application module component in it, based on the number of users that are visiting the site.

This pool of AM instances is shared by multiple browser clients whose typical "think time" between submitting web pages allows optimizing the number of AM components to be effectively smaller than the total number of "active" users working on the system. That is, twenty users shopping the web site from their browser might be able to be serviced by 5 or 10 application module instances instead of having as many AM instances as you have browser users.

Application module components can be used to support web application scenarios that are completely stateless, or they can be used to support a unit of work which spans multiple browser pages.

At any one moment in time, the instances of application modules in the pool are logically partitioned into three groups, reflecting their state:

Unconditionally available for use Available for use, but referenced for session affinity reuse by an active user session XYZ Unavailable, inasmuch as it's currently in use (at that very moment!) by some thread in the web container.


33.What are Datacontrols? What types of datacontrols are you aware of?  

 A data control is essentially a bridge that makes data from a source available to the user interface in an ADF Fusion Web Application. You can use the objects in the data control to create databound user interface components.

The most commonly used types of data controls include the following :

 ADF Business Components Data Control :This type of data control is generated by JDeveloper when you create an application module in your ADF Business Components application.

JavaBean Data Control : This type of data control obtains the structure of the data from POJOs (plain, old Java objects).To create a JavaBean data control, right-click a Java class file (in the Application Navigator), and choose Create Data Control.

EJB Data Control : The EJB data control is essentially the same as the JavaBean data control, except that it uses features inherent in the EJB architecture to obtain the structure of the data.You can create an EJB data control from the New Gallery. Expand the Business Tier node, select Data Controls, choose EJB Data Control, and click OK.


URL Service Data Control : A URL service data control lets you access and consume the data stream from a specified URL. This type of data control is not updateable.You can create a URL Service data control from the New Gallery. Expand the Business Tier node, select Data Controls, choose URL Service Data Control, and click OK.

Web Service Data Control : A Web Service data control obtains the structure of the data from the WSDL for a web service.You can create a Web Service data control from the New Gallery. Expand the Business Tier node, select Data Controls, choose Web Service Data Control, and click OK.

JMX Data Control : A JMX data control obtains the structure of the JMX MBeans from an MBean Server.You can create a JMX data control from the New Gallery. Expand the Business Tier node, select Data Controls, choose JMX Data Control, and click OK. For more information about creating a JMX data control, see the online help for the Create JMX Data Control wizard.Before you can create a JMX data control, you must first have a JMX connection.

Placeholder Data Control : A placeholder data control is a special type of data control that doesn't require a traditional data structure. As the name implies, it is a placeholder that can be used during UI development, and then replaced with the real data control when it becomes available.