An Oracle Fusion web application uses various metadata XML files that summarizes basic information about data, which can make finding and working with particular instances of data easier. These files are used to configure the runtime behavior of the system.

Metadata files in a Fusion web application are structured XML files used by the application to:

• Specify the parameters, methods, and return values available to your application's Oracle ADF data control usages

• Create objects in the Oracle ADF binding context and define the runtime behavior of those objects

• Define configuration information about the UI components in JSF and ADF Faces

• Define application configuration information for the Java EE application server

In the case of ADF bindings, you can use the binding-specific editors to customize the runtime properties of the binding objects. You can open a binding editor when you display the Structure window for a page definition file and choose Go to Properties from the context menu.

Additionally, you can view and edit the contents of any metadata file in JDeveloper's XML editor. The easiest way to work with these files is through the Structure window and Properties window. In the Structure window, you can choose an element and in the Properties window, you can define attribute values for the element, often by choosing among dropdown menu choices. Use this appendix to learn the choices you can choose in the case of the Oracle ADF-specific elements.

The Oracle ADF File Hierarchy diagram helps you to understand the interrelationship of the metadata files used to work with the ADF Business Components data control in a view layer project.

The relationship between the Oracle ADF metadata files defines dependencies between the model data and the user interface projects. The dependencies are defined as file references within XML elements of the files, where these design time definitions in the Model project reference the DataBindings.jpx file in the ViewController project, which in turn references the page definition files.

Figure A-1 illustrates the hierarchical relationship of the XML metadata files that you might work with in a Fusion web application that uses an ADF Business Components application module as a service interface to JSF web pages.

Figure A-1 Oracle ADF File Hierarchy Overview for the Fusion Web Application

Description of "Figure A-1 Oracle ADF File Hierarchy Overview for the Fusion Web Application"

Oracle ADF File Syntax Diagram helps you to understand the hierarchical interrelationship of the XML metadata files in a web application that uses an ADF application module as a service interface to ADF Business Components.

Figure A-2 illustrates the hierarchical relationship of the XML metadata files that you might work with in a web application that uses an ADF application module as a service interface to ADF Business Components. At runtime, the objects created from these files interact in this sequence:

1. When the first request for an ADF databound web page occurs, the servlet registers the Oracle ADF servlet filter ADFBindingFilter named in the web.xml file.

2. The binding filter creates an empty binding context.

3. When a page is rendered, the binding filter asks the binding context to load a corresponding PageDef.xml for the page.

4. The binding context creates the binding container by loading the <page> file as referenced by the <pagemap> element in the DataBindings.cpx file.

5. The adfm.xml file loads the DataBindings.cpx contents and finds the right PageDef.xml based on the <pagemap> element reference to the <pageDefinitionUsage> element.

6. The binding container's prepareModel phase prepares and refreshes all relevant executables (most are marked deferred by default).

7. An iterator binding gets executed by referencing the named method on the data control found through the data control factory named in the case of ADF Business Components in the bc4j.xcfg file.

8. The binding container also creates the bindings defined in the <bindings> section of the pagenamePageDef.xml file for the mapped web page.

9. The web page references to ADF bindings through EL using the expression #{bindings} are resolved by accessing the binding container of the page.

10. The page pulls the available data from the bindings in the binding container.

Figure A-2 Oracle ADF File Hierarchy and Syntax Diagram for an ADF BC-based Web Application

The adfm.xml file is a registry of registries used by the ADF framework to quickly find all metadata files used at runtime. This registry XML file records four types of metadata files —.cpx, .dcx, .xcfg, .jpx.

The adfm.xml file contains the classpath-relative paths for the .cpx, .dcx, .jpx, and .xcfg files in each design time project that is included in the runtime deployed application. The adfm.xml file operates as a dynamically maintained "Registry of Registries" that is used to quickly find all .cpx, .dcx, .jpx, and .xcfg files (which are themselves registries of metadata).

The file registry is used extensively by the ADF Library resource catalog browsing implementations, by ADF Model layer design time, and at runtime during merge and discovery.

When a developer creates a binding on a page, JDeveloper adds metadata files (for example, page definitions) in the project source tree. The adfm.xml file then notes the location of each.

When a project is built, the adfm.xml file is put in project-root/adfmsrc/META-INF/adfm.xml. The project-level archive deployment profiles locate the file at META-INF/adfm.xml.

At runtime, the application classpath is scanned to build the list of .cpx files that comprise the application. The application then loads each.cpx as needed to create the binding context. For details about ADF Model layer usage, see What Happens When You Use the Data Controls Panel.

Four types of sub registries are recorded by the adfm.xml file:

• DataBindingRegistry (.cpx)

• DataControlRegistry (.dcx)

• BusinessComponentServiceRegistry (.xcfg)

• BusinessComponentProjectRegistry (.jpx)

JDeveloper uses the modelProjectName.jpx file as a registry to track the contents of the model packages. It also contains metadata for shared ADF application modules present in the project, which is used by both design-time and runtime components.

The.jpx file contains configuration information that JDeveloper uses in the design time to allow you to create the data model project with ADF Business Components. It also contains metadata that defines how a shared application module is used at runtime. Because the shared application module can be accessed by any data model project in the same Fusion web application, JDeveloper maintains the scope of the shared application module in the ADF Business Components project configuration file.

This file is saved in the src directory of the project. For example, the Summit sample application for Oracle ADF stores the Model.jpx file in the .src/oracle/summit/model subdirectory of the Model project.

The following example displays a sample default.jpx file.

<JboProject
   xmlns="http://xmlns.oracle.com/bc4j"
   Name="Model"
   Version="12.1.2.66.11"
   SeparateXMLFiles="true"
   PackageName="oracle.summit.model">
   <DesignTime>
      <Attr Name="_appModuleNames2"
         Value="oracle.summit.model.services.BackOfficeAppModule"/>
      <Attr Name="_jprName" Value="../../../../Model.jpr"/>
      <Attr Name="_appModuleNames1"
         Value="oracle.summit.model.services.CustomerSelfServiceAppModule"/>
      <Attr Name="_appModuleNames0"
         Value="oracle.summit.model.services.SummitAppModule"/>
      <Attr Name="_jbo.TypeMapEntries" Value="Java"/>
      <Attr Name="_NamedConnection" Value="summit_adf"/>
   </DesignTime>
   <Containee
      Name="assoc"
      PackageName="oracle.summit.model.entities.assoc"
      ObjectType="JboPackage">
      <DesignTime>
         <Attr Name="_AS" Value="true"/>
      </DesignTime>
   </Containee>
   <Containee
      Name="entities"
      PackageName="oracle.summit.model.entities"
      ObjectType="JboPackage">
      <DesignTime>
         <Attr Name="_EO" Value="true"/>
         <Attr Name="_VO" Value="true"/>
      </DesignTime>
   </Containee>
   <Containee
      Name="services"
      PackageName="oracle.summit.model.services"
      ObjectType="JboPackage">
      <DesignTime>
         <Attr Name="_AM" Value="true"/>
      </DesignTime>
   </Containee>
   <Containee
      Name="links"
      PackageName="oracle.summit.model.views.links"
      ObjectType="JboPackage">
      <DesignTime>
         <Attr Name="_VL" Value="true"/>
      </DesignTime>
   </Containee>
   <Containee
      Name="readonly"
      PackageName="oracle.summit.model.views.readonly"
      ObjectType="JboPackage">
      <DesignTime>
         <Attr Name="_VO" Value="true"/>
      </DesignTime>
   </Containee>
   <Containee
      Name="views"
      PackageName="oracle.summit.model.views"
      ObjectType="JboPackage">
      <DesignTime>
         <Attr Name="_VO" Value="true"/>
      </DesignTime>
   </Containee>
</JboProject>

The bc4j.xcfg file contains metadata information about the ADF application module and runtime parameters that have been configured to manage the runtime behavior of each application module instance.

The bc4j.xcfg file contains metadata information about application module names, the database connection used by the application module, and the runtime parameters the user has configured for the application module.

The bc4j.xcfg file is located in the ./common subdirectory relative to the application module's XML component definition. All of the configurations for all of the application modules in a single Java package are saved in that same file. For example, if you look at the bc4j.xcfg file in the /Model/src/oracle/summit/model/services/common directory of the Summit ADF sample application's Model project, you see the configurations for its application modules. For details about editing the configurations, see How to Change Your Application Module's Runtime Configuration and Setting Pool Configuration Parameters.

Example A-1 displays a sample bc4j.xcfg file from the Summit ADF sample application.

<?xml version = '1.0' encoding = 'UTF-8'?>
<BC4JConfig version="11.1" xmlns="http://xmlns.oracle.com/bc4j/configuration">
   <AppModuleConfigBag ApplicationName="oracle.summit.model.services.SummitAppModule">
      <AppModuleConfig name="SummitAppModuleLocal" DeployPlatform="LOCAL" JDBCName="summit_adf" jbo.project="oracle.summit.model.Model" java.naming.factory.initial="oracle.jbo.common.
       JboInitialContextFactory" ApplicationName="oracle.summit.model.services.SummitAppModule">
         <Database jbo.TypeMapEntries="Java"/>
         <Security AppModuleJndiName="oracle.summit.model.services.SummitAppModule"/>
      </AppModuleConfig>
      <AppModuleConfig name="SummitAppModuleShared" DeployPlatform="LOCAL" JDBCName="summit_adf" jbo.project="oracle.summit.model.Model" java.naming.factory.initial="oracle.jbo.common.JboInitialContextFactory"
                                 ApplicationName="oracle.summit.model.services.SummitAppModule">
         <AM-Pooling jbo.ampool.isuseexclusive="false" jbo.ampool.maxpoolsize="1"/>
         <Database jbo.TypeMapEntries="Java"/>
         <Security AppModuleJndiName="oracle.summit.model.services.SummitAppModule"/>
      </AppModuleConfig>
   </AppModuleConfigBag>
   <AppModuleConfigBag ApplicationName="oracle.summit.model.services.CustomerSelfServiceAppModule">
      <AppModuleConfig name="CustomerSelfServiceLocal" jbo.project="oracle.summit.model.Model" ApplicationName="oracle.summit.model.services.CustomerSelfServiceAppModule" 
                                          DeployPlatform="LOCAL" JDBCName="summit_adf">
         <Database jbo.TypeMapEntries="Java"/>
         <Security AppModuleJndiName="oracle.summit.model.services.CustomerSelfServiceAppModule"/>
      </AppModuleConfig>
      <AppModuleConfig name="CustomerSelfServiceShared" jbo.project="oracle.summit.model.Model" ApplicationName="oracle.summit.model.services.CustomerSelfServiceAppModule" 
                                         DeployPlatform="LOCAL" JDBCName="summit_adf">
         <AM-Pooling jbo.ampool.maxpoolsize="1" jbo.ampool.isuseexclusive="false"/>
         <Database jbo.TypeMapEntries="Java"/>
         <Security AppModuleJndiName="oracle.summit.model.services.CustomerSelfServiceAppModule"/>
      </AppModuleConfig>
   </AppModuleConfigBag>
   <AppModuleConfigBag ApplicationName="oracle.summit.model.services.BackOfficeAppModule">
      <AppModuleConfig name="BackOfficeAppModuleLocal" jbo.project="oracle.summit.model.Model" ApplicationName="oracle.summit.model.services.BackOfficeAppModule" DeployPlatform="LOCAL" JDBCName="summit_adf">
         <Database jbo.TypeMapEntries="Java"/>
         <Security AppModuleJndiName="oracle.summit.model.services.BackOfficeAppModule"/>
      </AppModuleConfig>
      <AppModuleConfig name="BackOfficeAppModuleShared" jbo.project="oracle.summit.model.Model" ApplicationName="oracle.summit.model.services.BackOfficeAppModule" DeployPlatform="LOCAL" JDBCName="summit_adf">
         <AM-Pooling jbo.ampool.maxpoolsize="1" jbo.ampool.isuseexclusive="false"/>
         <Database jbo.TypeMapEntries="Java"/>
         <Security AppModuleJndiName="oracle.summit.model.services.BackOfficeAppModule"/>
      </AppModuleConfig>
   </AppModuleConfigBag>
</BC4JConfig>

In an ADF web application, as soon as you drop a databound component on your page, a DataBindings.cpx file gets created. The DataBindings.cpx keeps track of the individual page definition files used within the project, as well as the DataControls mapping to things such as ADF Business Components Application Modules.

The DataBindings.cpx file is created in the user interface project the first time you drop a data control usage onto a web page in the visual editor. The DataBindings.cpx file defines the Oracle ADF binding context for the entire application and provides the metadata from which the Oracle ADF binding objects are created at runtime. It is used extensively by the ADF Library resource catalog browsing implementations, and also by the .cpx and .dcx design time and runtime merge and discovery. When you insert a databound UI component into your document, the page will contain binding expressions that access the Oracle ADF binding objects at runtime.

The DataBindings.cpx file appears in the /src directory of the user interface project. When you double-click the file node, the binding context description appears in the XML source editor. (To edit the binding context parameters, use the Properties window and choose the desired parameter in the Structure window.)

In an ADF web application, as soon as you draga component from Data Control panel to a JSF page, a page definition file gets created with the name pageNamePageDef.xml. The pageNamePageDef.xml file contains binding metadata for each data bound UI element present on the page.

The pageNamePageDef.xml files are created each time you insert a databound component into a web page using the Data Controls panel or Structure window. These XML files define the Oracle ADF binding container for each web page in the application. The binding container provides access to the bindings within the page. You will have one XML file for each databound web page.

The PageDef.xml file appears in the /src/view directory of the user interface project. The Applications window displays the file in the view package of the Application Sources node. When you double-click the file node, the page description appears in the XML source editor. To edit the page description parameters, use the Properties window and choose the desired parameter in the Structure window. See Working with Page Definition Files.

There are important differences in how the page definitions are generated for methods that return a single value and a collection.

ADF Faces uses adfc-config.xml to store its configurations. It is an unbounded taskflow and the adfc-config.xml file contains activies, control flow rules, and managed beans interacting to allow a user to complete a task.

The adfc-config.xml file is the source file for the ADF unbounded task flow that JDeveloper creates by default when you create an application using the ADF Fusion Web Application template. By default, JDeveloper stores the adfc-config.xml file in the following directory:

application_root\ViewController\Web Content\WEB-INF

If you create additional unbounded task flows, JDeveloper proposes the following file name for the source files of the additional unbounded task flows:

adfc-configN.xml

where N is a number that increments each time you create a new unbounded task flow. Alternatively, you choose the file name you want for an unbounded task flow's source file.

Each source file for an unbounded task flow contains the metadata for activities, control flow rules, and managed beans that you added to an unbounded task flow so that end users can interact with the Fusion web application to complete a task.

The XML schema definition file (XSD) that defines valid metadata entries for the adfc-config.xml file is adfc-config_1_0.xsd. The adfc-config_1_0.xsd file is stored in the adf-controller-schema.jar file in the following directory of your JDeveloper installation:

jdev_install\oracle_common\modules\oracle.adf.model_12.1.2

Use JDeveloper's XSD Visual Editor to view the adfc-config_1_0.xsd file. Using this editor, you can identify the valid metadata elements and attributes for the adfc-config.xml file.

The following example shows the source file for an unbounded task flow where view activities, control flow rules, and so on have yet to be added.

<?xml version="1.0" encoding="windows-1252" ?>
<adfc-config xmlns="http://xmlns.oracle.com/adf/controller" version="1.2">
</adfc-config>

Figure A-4 shows the Diagram view of the Summit sample application for ADF task flows' adfc-config.xml file. Example A-3 shows the corresponding source view of the unbounded task flow that appears in Figure A-4.

For more information about unbounded task flows, see Getting Started with ADF Task Flows .

Figure A-4 Diagram View of Summit ADF Task Flow Sample Application´s adfc-config.xml File

<?xml version="1.0" encoding="windows-1252" ?>
<adfc-config xmlns="http://xmlns.oracle.com/adf/controller" version="1.2">
  <view id="index">
    <page>/index.jsf</page>
  </view>
  <managed-bean id="__1">
    <managed-bean-name>login</managed-bean-name>
    <managed-bean-class>oracle.summit.bean.LoginBean</managed-bean-class>
    <managed-bean-scope>request</managed-bean-scope>
  </managed-bean>
  <managed-bean id="__2">
    <managed-bean-name>WelcomePageBean</managed-bean-name>
    <managed-bean-class>oracle.summit.bean.WelcomePageBean</managed-bean-class>
    <managed-bean-scope>request</managed-bean-scope>
  </managed-bean>
</adfc-config>

The task-flow-definition.xml file stores metadata definition for a bounded task flow. You can specify the task flow definition XML filename and location when you generate the task flow.

The default file name that JDeveloper proposes for the source file of the first ADF bounded task flow that you create is task-flow-definition.xml. This file stores the metadata for a bounded task flow. It contains entries for each view activity, method call activity, task flow call, and so on that you add to the bounded task flow.

JDeveloper proposes the following file name for subsequent bounded task flows that you create:

task-flow-definitionN.xml

where N is a number that increments each time you create a new bounded task flow. Alternatively, you choose the file name you want for a bounded task flow's source file. By default, JDeveloper stores the task-flow-definition.xml file in the following directory:

application_root\ViewController\Web Content\WEB-INF

The XML schema definition files (XSD) that define the valid metadata entries for the source file of a bounded task flow are stored in the adf-controller-schema.jar file in the following directory of your JDeveloper installation:

jdev_install\oracle_common\modules\oracle.adf.model_12.1.2

Use JDeveloper's XSD Visual Editor to view these XSD files and identify the valid metadata elements and attributes for the source file of a bounded task flow.

The following example shows the content of a source file when you create a new bounded task flow using the Create Task Flow dialog. The <task-flow-definition> element identifies this file as a bounded task flow. JDeveloper generates the <task-flow-definition> element when you select the Create as Bounded Task Flow checkbox in the Create Task Flow dialog. The value of the <task-flow-definition> element's id attribute (task-flow-definition) corresponds to the value that you enter in the Task Flow ID field of the Create Task Flow dialog. The <use-page-fragments/> element indicates that all view activities in this bounded task flow must be associated with page fragments. JDeveloper generates this entry when you select the Create with Page Fragments checkbox in the Create Task Flow dialog.

<?xml version="1.0" encoding="windows-1252" ?>
<adfc-config xmlns="http://xmlns.oracle.com/adf/controller" version="1.2">
  <task-flow-definition id="task-flow-definition">
    <use-page-fragments/>
  </task-flow-definition>
</adfc-config>

Example A-4 shows the Summit ADF task flow sample application's customers-task-flow-definition.xml file. You can view entries for the activities shown in the Structure window in Figure A-5. See Getting Started with ADF Task Flows .

Figure A-5 Structure View of the customers-task-flow-definition.xml File

Description of "Figure A-5 Structure View of the customers-task-flow-definition.xml File"

<?xml version="1.0" encoding="windows-1252" ?>
<adfc-config xmlns="http://xmlns.oracle.com/adf/controller" version="1.2">
  <task-flow-definition id="customer-task-flow-definition">
    <default-activity id="__1">isCustomerLogin</default-activity>
    <managed-bean id="__11">
      <managed-bean-name id="__9">CustomersBackingBean</managed-bean-name>
      <managed-bean-class id="__10">oracle.summit.backing.CustomersBackingBean</managed-bean-class>
      <managed-bean-scope id="__8">backingBean</managed-bean-scope>
    </managed-bean>
    <view id="Customers">
      <page>/customers/Customers.jsff</page>
    </view>
    <method-call id="SetCurrentRowWithKeyValue">
      <method>#{bindings.setCurrentRowWithKeyValue.execute}</method>
      <outcome>
        <fixed-outcome>setCurrentRowWithKey</fixed-outcome>
      </outcome>
    </method-call>
    <router id="isCustomerLogin">
      <case id="__4">
        <expression>#{securityContext.userInRole['Application Customer Role']}</expression>
        <outcome>customerLogin</outcome>
      </case>
      <default-outcome>notCustomerLogin</default-outcome>
    </router>
    <control-flow-rule id="__2">
      <from-activity-id>SetCurrentRowWithKeyValue</from-activity-id>
      <control-flow-case id="__3">
        <from-outcome>setCurrentRowWithKey</from-outcome>
        <to-activity-id>Customers</to-activity-id>
      </control-flow-case>
    </control-flow-rule>
    <control-flow-rule id="__5">
      <from-activity-id>isCustomerLogin</from-activity-id>
      <control-flow-case id="__6">
        <from-outcome>notCustomerLogin</from-outcome>
        <to-activity-id>Customers</to-activity-id>
      </control-flow-case>
      <control-flow-case id="__7">
        <from-outcome>customerLogin</from-outcome>
        <to-activity-id>SetCurrentRowWithKeyValue</to-activity-id>
      </control-flow-case>
    </control-flow-rule>
    <critical/>
    <use-page-fragments/>
  </task-flow-definition>
</adfc-config>

The adf-config.xml file contains application-level settings, that manages the runtime infrastructure such as failover behavior for the ADF application modules, global fetch limit for all the view objects, caching of resource bundles, automated refresh of page bindings, and so on for your application.

JDeveloper generates the adf-config.xml file when you create an application using the ADF Fusion Web Application template. JDeveloper stores this application-level descriptor file in the following directory:

application_root\.adf\META-INF

In JDeveloper, you can locate the file in the Application Resources panel of the Applications window by expanding the Descriptors > ADF META-INF nodes.

The adf-config.xml file specifies application-level settings that you define during development. You can use a deployment profile to specify settings that are used at application deploy time. You can change some of the settings at runtime using Oracle Enterprise Manager.

Examples of tasks that you can accomplish by changing settings in the adf-config.xml file include the following:

• Enable or disable the validation of ADF Controller metadata

• Replicate memory scope if you deploy your Fusion web application in a clustered environment

• Configure properties to manage the caching of resource bundles where your application uses EL expressions to retrieve strings at runtime from resource bundles

  The properties that you can configure are:

  • initial-size

    Specifies the initial number of resource bundles that your application can cache. The default value is 100.

  • max-size

    Specifies the maximum number of resource bundles that your application can cache. The default value is 100.

  • load-factor

    The default value is 0.75.

  • expire-time

    The default value is 43200 seconds (12 hours).

    You specify these properties as attribute values of the <resource-bundle-cache> element in the adf-config.xml file. Example A-5 demonstrates how you might configure these values for your application in the adf-config.xml file.

  As an alternative to configuring the caching of resource bundles in the adf-config.xml file, you can specify the resource bundle caching properties as parameters for the Java Virtual Machine (JVM). If you specify the properties as parameters for the JVM, the changes apply to all applications managed by the JVM. For this reason, consider configuring the resource bundle caching properties in the adf-config.xml file for you application. Use the following property names if you decide to specify the resource bundle caching properties as parameters for the JVM:

  • resource-bundle-cache-initial-size

  • resource-bundle-cache-max-size

  • resource-bundle-cache-load-factor

  • resource-bundle-cache-expire-time

At runtime, the Fusion web application loads the adf-config.xml file from the META-INF directory. If the Fusion web application finds more than one adf-config.xml file, it stops loading the file and logs a warning.

The following tasks modify or require you to modify the adf-config.xml file:

• In the ADF Controller layer

  • Creating task flows

    By default, the ADF Controller uses a user session level cache to store the application's unbounded task flow metadata. This enables support for user specific seeded customization or design time at runtime customization of unbounded task flow metadata in your application. Clear the Allow Unbounded Task Flow Customizations checkbox in the Controller page of the adf-config.xml's file overview editor to disable this behavior and set the value of the <allow-unbounded-task-flow-customizations> element to false. You can still have customizations of the unbounded task flow metadata in your application. However, these customizations are shared by all users of the application. For information about customizations, see Customizing Applications with MDS . For information about task flows, see Getting Started with ADF Task Flows .

  • Configure an integer value for the root-view-port-request-lock-timeout property that specifies the number of seconds a request can hold a lock on the root view port before timing out and allowing other requests to acquire the lock. The default value is 600 seconds. For information about the root view port, see About View Ports and ADF Regions.

  • Minimize the number of active root view ports in an application by specifying a value for the <max-root-view-ports> property. See Minimizing the Number of Active Root View Ports in an Application.

  • Modify the number of events collected or stop the collection of events by ADF Controller. Both tasks involve configuring the value of the <debug-history-size> element in your application's adf-config.xml file. See Reporting Incidents to the Diagnostic Framework.

  • Enabling implicit save points

    See How to Enable Implicit Save Points.

  • Specify a bounded task flow that does not require authorization to invoke when a user attempts to invoke a bounded task flow in a region for which they do not have security permissions. See Handling Access to Secured Task Flows by Unauthorized Users.

  • Enable ADF Controller to track changes to ADF memory scopes and replicate the page flow scope and view scope within the server cluster. You must set the ADF Controller parameter <adf-scope-ha-support> in the application's adf-config.xml file to true. See How to Ensure Oracle ADF Receives Notifications From Managed Bean Changes .

• In the ADF Model layer

  • Disable automatic partial page rendering as the default behavior for an application. This requires you to change the value for the changeEventPolicy attribute from the default value of ppr:

    <defaults changeEventPolicy="ppr"/>

    See What You May Need to Know About Partial Page Rendering and Iterator Bindings.

  • Configure all Query components in the user interface project to render input search fields using a bind variable.

    See What You May Need to Know About Named Bind Variables in Search Forms.

  • Control the dispatch of contextual events

    See How to Control Contextual Events Dispatch.

• Persisting saved searches in MDS

  See How to Persist Saved Searches into MDS.

• Creating RESTful web services from ADF application modules and managing the release version identifiers of REST resources

  See Creating ADF REST Resources Using the Application Module and see Versioning the ADF REST Resource.

• Configuring ADF Business Components global settings

  See Using Fetch Size to Limit the Maximum Number of Records Fetched for a View Object and How to Initialize the Data Model Project With a Database Connection.

• Enabling or disabling Oracle ADF Security

  See Enabling ADF Security and Disabling ADF Security.

• Enabling seeded customizations

  See How to Enable Seeded Customizations for User Interface Projects and How to Enable Seeded Customizations in Existing Pages.

• Configuring change persistence

  See How to Enable User Customizations.

• Enabling user customizations

  See What Happens When You Enable User Customizations.

Example A-5 shows example entries for an application's adf-config.xml file.

<?xml version="1.0" encoding="windows-1252" ?>
<adf-config xmlns="http://xmlns.oracle.com/adf/config"
            xmlns:sec="http://xmlns.oracle.com/adf/security/config">
  <sec:adf-security-child xmlns="http://xmlns.oracle.com/adf/security/config">
    <CredentialStoreContext credentialStoreClass=
                                "oracle.adf.share.security.providers.jps.CSFCredentialStore"
                                      credentialStoreLocation="../../src/META-INF/jps-config.xml"/>
    <!-- The Configure ADF Security wizard modifies JaasSecurityContext settings -->
    <JaasSecurityContext initialContextFactoryClass=
                                "oracle.adf.share.security.JAASInitialContextFactory"
                         jaasProviderClass=
                                "oracle.adf.share.security.providers.jps.JpsSecurityContext"
                         authorizationEnforce="true"
                         authenticationRequire="true"/>
  </sec:adf-security-child>
  <adf-controller-config xmlns="http://xmlns.oracle.com/adf/controller/config">
    <savepoint-datasource>java:comp/env/jdbc/summit_adfDS</savepoint-datasource>
    <enable-implicit-savepoints>true</enable-implicit-savepoints>
    <unauthorized-region-taskflow>/WEB-INF/task-flow-definition.xml</unauthorized-region-taskflow>
  </adf-controller-config>
  <adf-faces-config xmlns="http://xmlns.oracle.com/adf/faces/config">
    <persistent-change-manager>
      <persistent-change-manager-class>
           oracle.adf.view.rich.change.MDSDocumentChangeManager
      </persistent-change-manager-class>
    </persistent-change-manager>
    <taglib-config>
      <taglib uri="http://xmlns.oracle.com/adf/faces/rich">
        <tag name="calendar">
          <attribute name="activeDay">
            <persist-changes>true</persist-changes>
          </attribute>
        </tag>
        <!-- Additional tags omitted to make this example concise -->
        <tag name="table">
          <attribute name="filterVisible">
            <persist-changes>true</persist-changes>
          </attribute>
        </tag>
      </taglib>
    </taglib-config>
  </adf-faces-config>
  <adf-mds-config xmlns="http://xmlns.oracle.com/adf/mds/config">
    <mds-config xmlns="http://xmlns.oracle.com/mds/config" version="11.1.1.000">
      <cust-config>
        <match path="/">
          <customization-class name="oracle.adf.share.config.UserCC"/>
        </match>
      </cust-config>
    </mds-config>
  </adf-mds-config>
  <adf-adfm-config xmlns="http://xmlns.oracle.com/adfm/config">
    <defaults rowLimit="100"/>
    <startup>
      <amconfig-overrides>
        <config:Database jbo.SQLBuilder="Oracle" jbo.locking.mode="optimistic"/>
      </amconfig-overrides>
    </startup>
  </adf-adfm-config>
<!-- Properties to manage the caching of a resource bundle in your application -->
<adf-resourcebundle-config xmlns="http://xmlns.oracle.com/adf/resourcebundle/config">
    <applicationBundleName>
       	path-to-resource-bundle/bundle-name
    </applicationBundleName>
    <resource-bundle-cache initial-size="20" max-size="100" expire-time="30000" load-factor=".75"/>
    <bundleList>
      <bundleId override="true">
         	package.BundleID
      </bundleId>
    </bundleList>
  </adf-resourcebundle-config>
</adf-config>

The adf-settings.xml file is used by ADF application developers to extend and customize the ADF lifecycle with custom ADF phase listeners.

The adf-settings.xml file holds project-level and library-level settings such as ADF Faces help providers and ADF Controller phase listeners.

The configuration settings for adf-settings.xml are fixed and cannot be changed during or after application deployment. There can be multiple adf-settings.xml files in an application. The users of adf-settings.xml files are responsible for merging the contents of their configuration.

JDeveloper creates an adf-settings.xml file when you:

• Create an application using the ADF Fusion Web Application template

• Add ADF Page Flow (ADF Controller) as a feature to an existing project

By default, JDeveloper stores the adf-settings.xml file in the following directory:

application_root\ViewController\src\META-INF

The following tasks modify or require you to modify the adf-settings.xml file:

• Registering a phase listener

  See How to Register a Listener Globally.

• Creating help for ADF Faces components

  See Displaying Help for Components in Developing Web User Interfaces with Oracle ADF Faces.

For information about how to edit the adf-settings.xml file, see How to Configure for ADF Faces in adf-settings.xml in Developing Web User Interfaces with Oracle ADF Faces.

Example A-6 shows a sample adf-setting.xml file with settings configured for a phase listener and a help provider.

<?xml version="1.0" encoding="windows-1252" ?>
<adf-settings xmlns="http://xmlns.oracle.com/adf/config">
  <adfc-controller-config xmlns="http://xmlns.oracle.com/adf/controller/config">
    <lifecycle>
      <phase-listener>
        <listener-id>SummitPhaseListener</listener-id>
        <class>oracle.summit.listeners.SummitPhaseListener</class>
      </phase-listener>
    </lifecycle>
  </adfc-controller-config>
  <adf-faces-config>
    <help-provider prefix="MYAPP">
      <help-provider-class>oracle.summit.MyHelpProvider</help-provider-class>
      <property>
        <property-name>myCustomProperty</property-name>
        <value>someValue</value>
      </property>
    </help-provider>
  </adf-faces-config>
</adf-settings>

The web.xml file is used as a deployment descriptor file by Java web applications to determine how URLs map to servlets, which URLs require authentication, and other information. This file is an XML document that defines everything about your ADF application that a server needs to know.

Oracle ADF has specific configuration settings for the standard web.xml deployment descriptor file.

When you create a project in JDeveloper that uses JSF technology, a starter web.xml file with default settings is created for you in the /WEB-INF folder. To edit the file, double-click web.xml in the Applications window to open it in the XML editor.

The following must be configured in web.xml for all applications that use JSF and ADF Faces:

• ADF Library resource servlet and mapping: Serves up web application resources (images, style sheets, JavaScript libraries) from ADF Library JAR files on the application class path.

  By default, static web application resources (including resources in ADF Libraries), such as images, have a staleness period setting of 364 days. This staleness period setting requests that the client not make a request to the server to validate the static web application resources until one of the following events occur:

  • Staleness period expires

  • Browser cache no longer contains the static resource

  • User executes a page refresh

  If the client does make a request to the server and the resources have not changed, the server returns a HTTP 304 response (Not Modified) with no body.

  You can override the staleness period setting of 364 days for all static web application resources in ADF Libraries by adding initialization parameters to the web.xml file. The following example demonstrates how to set these initialization parameters using a number of examples.

  <!-- Expires all static resources in 30 days --> 
   <init-param> 
     <param-name>expires</param-name> 
     <param-value>60*60*24*30</param-value>  
   </init-param> 
   
  <!-- Expires static resources with the .js file extension in 1 day --> 
   <init-param> 
     <param-name>expires.js</param-name> 
     <param-value>60*60*24</param-value>     
   </init-param> 
   
  <!-- Turns off staleness setting. Use for testing --> 
   <init-param> 
     <param-name>expires</param-name> 
     <param-value>OFF</param-value>     
   </init-param> 
  

  The following example shows the default file extensions. You can add additional file extensions by configuring the extensions parameter value to include the file extensions that you want. Note that you must prepend and append "." to the file extension. The example also shows how you specify visibility for cache control.

  <!-- Specify file extensions for a number of different file formats -->
   <init-param> 
     <param-name>extensions</param-name> 
     <param-value>.png.jpg.jpeg.gif.js.css.</param-value> 
   </init-param> 
   
  <!-- Specify visibility for cache control, for example -->
   <init-param> 
     <param-name>visibility</param-name> 
     <param-value>Public</param-value> 
   </init-param> 
  

• JSF servlet and mapping: The servlet javax.faces.webapp.FacesServlet that manages the request-processing lifecycle for web applications utilizing JSF to construct the user interface.

• ADF Faces filter and mapping: A servlet filter to ensure that ADF Faces is properly initialized by establishing a AdfFacesContext object. This filter also processes file uploads.

The JSF servlet and mapping configuration settings are automatically added to the starter web.xml file when you first create a JSF project. When you insert an ADF Faces component into a JSF page for the first time, JDeveloper automatically inserts the configuration settings for ADF Faces filter and mapping, and resource servlet and mapping. See ADF Faces Configuration in Developing Web User Interfaces with Oracle ADF Faces.

ADF Logger is integrated in the WebLogic enterprise manager, and gives you the flexibility to adjust your log-levels at runtime. You can configure the logging session by editing the logging.xml file.

ADF Logger is a diagnostic tool that you can use in JDeveloper to capture runtime traces messages when you debug an application. You configure the use of this tool by editing the logging.xml file.

For information about the logging.xml file and using the ADF Logger, see Using the ADF Logger.