Oracle JDeveloper 11gR2 Cookbook: Using JDeveloper to build ADF applications is a lot more straightforward when you learn through practical recipes. This book has over 85 of them to take you beyond the basics and raise your knowledge to a new level.

1. Download JDeveloper from the Oracle JDeveloper Software download page: http://www.oracle.com/technetwork/developer-tools/jdev/downloads/index.html.

2. Accept the license agreement, select Linux Install, and click on Download File to begin with the download.

3. Once the file is downloaded, open a console window and start the installation, by typing the following commands:

$ chmod u+x ./jdevstudio11121install.bin
$ ./jdevstudio11121install.bin

4. On the Choose Middleware Home Directory page, select Create a new Middleware Home and enter the Middleware home directory.

5. On the Choose Install Type page, select Complete to ensure that JDeveloper, ADF and WebLogic Server are installed.

6. Once you confirm your selections, proceed with the installation.

7. Upon a successful installation, you will see the Installation Complete page. Uncheck the Run Quickstart checkbox and click Done.

8. To start JDeveloper, go to the /jdeveloper/jdev/bin directory under the Middleware home directory you specified during the installation and type the following:

$ ./jdev

9. To make things easier, create an application launcher on your Linux desktop for the specific path indicated in the previous step.

1. To create the SharedComponents library, start by selecting New Application… in the Application Navigator. This will start the application creation wizard.

2. In the New Gallery dialog, click on the Applications node (under the General category) and select Fusion Web Application (ADF) from the list of Items.

3. In the Name your application page, enter the Application Name, Directory and the Application Package Prefix.

4. In the Name your project page, enter the business component's Project Name and Directory. For this recipe, we have called it SharedBC.

5. In the Configure Java settings page for the business components project, accept the defaults for Default Package, Java Source Path, and Output Directory.

6. Similarly, in the Name your project page for the ViewController project, enter the Project Name and Directory. For this recipe, we have called the project SharedViewController. Ensuring that you enter a unique package structure for both projects is the best guarantee for avoiding naming conflicts when these projects are deployed as ADF Library JARs.

7. Accept the defaults in the Configure Java settings and click Finish to proceed with the creation of the workspace.

8. Now, in the Application Navigator, you should see the two projects comprising the SharedComponents workspace, one for the business components and another for the ViewController.

9. You will be using this workspace to add reusable business and ViewController components. For now, we will package the workspace into an ADF library JAR, without any components in it yet. In order to do this, you will need to first setup the project dependencies. Double-click on the SharedViewController project to bring up the Project Properties dialog and select Dependencies.

10. Click on Edit Dependencies (the small pen icon) to bring up the Edit Dependencies dialog and then click on the Build Output checkbox under the business components project.

11. Click OK to close the dialog and return to the Project Properties dialog.

12. The next step is to set up the deployment profile. While at the ViewController Project Properties dialog, click on the Deployment node.

13. Since we will not be deploying this application as a WAR, select the default WAR deployment profile generated automatically by JDeveloper and delete it.

14. Then, click New… to create a new deployment profile.

15. On the Create Deployment Profile dialog, select ADF Library JAR File for the Profile Type and enter the name of the deployment profile. For this recipe, we have called the deployment profile SharedComponents. Click OK to proceed with its creation.

16. In the Edit ADF Library JAR Deployment Profile Properties dialog that is opened, select JAR Options and specify a location where you will be placing all the reusable JAR libraries. For this recipe, we will place all reusable libraries in a directory called ReUsableJARs.

17. When done, completely exit from the Project Properties dialog, saving your changes by clicking OK.

18. The last step involves the creation of the ADF Library JAR. You do this by right-clicking on the ViewController project in the Application Navigator selecting Deploy and then the name of the deployment profile name (SharedComponents in this case).

19. Select Deploy to ADF Library JAR file in the Deployment Action page and click Finish to initiate the deployment process. The deployment progress will begin. Its status is shown in the Deployment tab of the Log window.

20. To create the HRDepartments components library, similarly create a new Fusion web application for the HRDepartment components. Follow the previous steps to setup the project dependencies. No database connection to the HR schema is needed at this stage.

21. Create the deployment profile and deploy the ADF Library JAR. We will not be placing any components yet in this library.

22. To create the HREmployees components library, repeat the previous steps once more in order to create another ADF Library JAR for the HR Employee related reusable components.

23. Now create another Fusion web application, which will be used as the main application. This application will consume any of the components that reside in the ADF Library JARs created in the previous steps.

24. This can easily be done via the Resource Palette by creating a file system connection to the directory where we saved the reusable ADF Library JARs, that is, the directory called ReUsableJARs. If the Resource Palette is not visible, select View | Resource Palette to show it. In the Resource Palette, click on the New icon and select New Connection | File System….

25. In the Create File System Connection dialog that is displayed, enter the name of the connection and the directory where you have deployed the reusable components in the previous steps.

26. Click OK to continue. You should be able to see the new File System Connection in the Resource Palette.

27. To consume reusable components, first select the appropriate project on the Application Navigator, then right-click on the ADF Library JAR on the Resource Palette and select Add to Project….

28. On the Confirm Add ADF Library dialog, click on the Add Library button to proceed.

29. Alternatively, expand the ADF Library JAR and drag-and-drop the reusable component onto its appropriate place in the workspace.

1. To create framework extension classes for the commonly used business components, start with the creation of an extension class for the entity objects. Open the SharedComponents workspace in JDeveloper and right-click on the SharedBC business components project.

2. From the context menu, select New… to bring up the New Gallery dialog. Select Class from the Java category (under the General category) and click OK.

3. On the Create Java Class dialog that is displayed, enter the name of the custom entity object class, the package where it will be created, and for Extends enter the base framework class, which in this case is oracle.jbo.server.EntityImpl.

4. Now, repeat the same steps to create framework extension classes for the following components:

5. Once you are done, your project should look similar to the following:

6. The next step is to configure JDeveloper so that all new business components that you create from this point forward will be inherited from the framework extension classes you've just defined. Open the Preferences dialog from the Tools menu, expand the ADF Business Components node, and select Base Classes.

7. Then enter the framework extension classes that you created previously, each one in its corresponding category.

1. ODL logs can be generated programmatically from within your code by using the ADFLogger class. Instantiate an ADFLogger via the static createADFLogger() method and use its log() method. Go ahead and add logging support to the application module framework extension class we developed in the previous recipe, as shown in the following code snippet:

import oracle.adf.share.logging.ADFLogger;
public class ExtApplicationModuleImpl extends ApplicationModuleImpl {
// create an ADFLogger
private static final ADFLogger LOGGER = ADFLogger.createADFLogger(ExtApplicationModuleImpl.class);
public ExtApplicationModuleImpl() {
super();
// log a trace
LOGGER.log(ADFLogger.TRACE, "ExtApplicationModuleImpl was constructed");
}
}

2. The next step involves the configuration of the logger in the logging.xml file. The file is located in the config\fmwconfig\servers directory under the WebLogic domain for the server you are configuring. For the integrated WebLogic server, this file is located in the %JDEV_USER_DIR%\system11.1.2.1.38.60.81\DefaultDomain\config\fmwconfig\servers\DefaultServer directory. The exact location can vary slightly depending on the version of JDeveloper that you use.

Open the file in JDeveloper and create a custom logger called com.packt by clicking on the Add Persistent Logger icon, as shown in the following screenshot:

3. This will display the Add Persistent Logger dialog to add your logger. Enter com.packt for the Logger Name and choose FINEST for the Logger Level.

4. Repeat this step and add another logger named com if one does not already exist for it. The final result should look similar to the following screenshot:

5. One more step that is required to complete the configuration is to use the -Djbo.debugoutput=adflogger and -Djbo.adflogger.level=FINEST options when starting the JVM. You can do this in JDeveloper by double-clicking on the main application's ViewController project to bring up the Project Properties dialog and selecting the Run/Debug/Profile node.

6. Then select the appropriate Run Configuration on the right and click on the Edit… button.

7. On the Edit Run Configuration dialog that is displayed, enter these Java options in the Java Options.

1. Start by opening the SharedComponents workspace.

2. Create a new class called ExtJboException by right-clicking on the business components project and selecting New….

3. Then select Java under the General category and Java Class from list of Items on the right.

4. Click OK to display the Create Java Class dialog. Enter ExtJboException for the Name, com.packt.jdeveloper.cookbook.shared.bc.exceptions for the Package and oracle.jbo.JboException for the Extends.

5. Click OK to proceed with the creation of the custom exception class.

6. The next step is to add two additional constructors, to allow for the instantiation of the custom application exception using a standard error message code with optional error message parameters. The additional constructors look similar to the following code sample:

public ExtJboException(final String errorCode, final Object[] errorParameters) {
super(ResourceBundle.class, errorCode, errorParameters);
}
public ExtJboException(final String errorCode) {
super(ResourceBundle.class, errorCode, null);
}

7. Now, click on the Override Methods… icon on the top of the editor window and override the getMessage() method, as shown in the following screenshot:

8. Enter the following code for the getMessage() method:

public String getMessage() {
// default message
String errorMessage = "";
try {
// get access to the error messages bundle
final ResourceBundle messagesBundle = ResourceBundle.getBundle (ERRORS_BUNDLE, Locale.getDefault());
// construct the error message
errorMessage =this.getErrorCode() + " - " + messages Bundle.getString(MESSAGE_PREFIX + this.getErrorCode());
// get access to the error message parameters bundle
final ResourceBundle parametersBundle = ResourceBundle .getBundle(PARAMETERS_BUNDLE, Locale.getDefault());
// loop for all parameters
for (int i = 0; i < this.getErrorParameters().length; i++) {
// get parameter value
final String parameterValue =
parametersBundle.getString(PARAMETER_PREFIX +
(String)this.getErrorParameters()[i]);
// replace parameter placeholder in the error message string
errorMessage = errorMessage.replaceAll ("\\{" + (i + 1) + "}", parameterValue);
}
} catch (Exception e) {
// log the exception
LOGGER.warning(e);
}
return errorMessage;
}

9. Make sure that you also add the following constants:

private static final String ERRORS_BUNDLE = "com.packt.jdeveloper. cookbook.shared.bc.exceptions.messages.ErrorMessages";
private static final String PARAMETERS_BUNDLE = "com.packt. jdeveloper.cookbook.shared.bc.exceptions.messages.ErrorParams";
private static final String MESSAGE_PREFIX = "message.";
private static final String PARAMETER_PREFIX = "parameter.";
private static final ADFLogger LOGGER =ADFLogger .createADFLogger(ExtJboException.class);

10. For testing purposes add the following main() method:

// for testing purposes; remove or comment if not needed
public static void main(String[] args) {
// throw a custom exception with error code "00001" and two parameters
throw new ExtJboException("00001",
new String[] { "FirstParameter", "SecondParameter" });
}

1. To get the latest version of these classes, download and extract the latest version of the Fusion Order Demo application in your PC. This sample application can be found currently in the Fusion Order Demo (FOD) - Sample ADF Application page at the following address: http://www.oracle.com/technetwork/developer-tools/jdev/index-095536.html.

2. The latest version of the Fusion Order Demo application is 11.1.2.1 R2 at the time of this writing and is bundled in a zipped file. So go ahead download and extract the Fusion Order Demo application in your PC.

3. You should be able to locate the ADFUtils and JSFUtils classes in the location where you have extracted the Fusion Order Demo application. If multiple versions of the same class are found, compare them and use the ones that are most up-to-date. For this recipe, we have included in the source code the ADFUtils and JSFUtils found in the SupplierModule\ViewController\src\oracle\fodemo\supplier\view\utils directory.

4. Copy these classes to a specific location in your shared ViewController components project. For this recipe, we have copied them into the SharedComponents\SharedViewController\src\com\packt\jdeveloper\cookbook\shared\view\util directory.

5. Once copied, open both files with JDeveloper and change their package to reflect their new location, in this case to com.packt.jdeveloper.cookbook.shared.view.util.

1. Start by right-clicking on the ViewController project in the SharedComponents workspace and selecting New….

2. On the New Gallery dialog select JSF/Facelets from the list of Categories and ADF Page Template from the Items on the right.

3. Click OK to proceed. This will display the Create ADF Page Template dialog.

4. Enter the name of the template on the Page Template Name. Note that as you change the template name, the template File Name also changes to reflect the template name. For this recipe, we will simply call the template TemplateDef1.

5. Now, click on the Browse… button and select the directory where the template will be stored.

6. On the Choose Directory dialog navigate to the public_html/WEB-INF directory and click on the Create new subdirectory icon to create a new directory called templates.

7. For the Document Type, select JSP XML.

8. We will not be using any of the pre-defined templates, so uncheck the Use a Quick Start Layout checkbox.

9. Also, since we will not be associating any data bindings to the template, uncheck the Create Associated ADFm Page Definition checkbox.

10. Next, you will be adding the template facets. You do this by selecting the Facet Definitions tab and clicking on the New icon button. Enter the following facets:

11. Now click OK to proceed with the creation of the ADF page template.

12. Once the template is created, it is opened in the JDeveloper editor. If you followed the previous steps, the template should look similar to the following code snippet:

<af:pageTemplateDef var="attrs">
<af:xmlContent>
<component xmlns ="http://xmlns.oracle.com/adf/faces/rich/component">
<display-name>TemplateDef1</display-name>
<facet>
<description>The page's main content</description>
<facet-name>mainContent</facet-name>
</facet>
<facet>
<description>The page's menu</description>
<facet-name>menuBar</facet-name>
</facet>
<facet>
<description>The page's top toolbar</description>
<facet-name>topBar</facet-name>
</facet>
<facet>
<description>The page's popups</description>
<facet-name>popupContent</facet-name>
</facet>
</component>
</af:xmlContent>
</af:pageTemplateDef>

As you can see, at this point, the template contains only its definition in an af:xmlContent tag with no layout information whatsoever. We will proceed by adding the template's layout content.

13. From the Layout components in the Component Palette, grab a Form component and drop it into the template.

14. From the Layout container, grab a Panel Stretch Layout and drop it into the Form component. Remove the top, bottom, start, and end facets.

15. From the Layout container, grab a Panel Splitter component and drop it on the center facet of the Panel Stretch Layout. Using the Property Inspector change the Panel Splitter Orientation to vertical. Also adjust the SplitterPosition to around 100.

16. Add your application logo by dragging and dropping an Image component from the General Controls onto the first facet of the Panel Splitter. For this recipe, we have created a public_html\images directory and we copied a logo.jpg logo image there. We then specified /images/logo.jpg as image Source for the Image component.

17. Let's proceed by adding the main page's layout content. Drop a Decorative Box from the Layout components onto the second facet of the Panel Splitter. We will not be using the top facet of Decorative Box, so remove it.

18. OK, we are almost there! Drag a Panel Stretch Layout from the Layout components and drop it onto the center facet of the Decorative Box. Remove the start and end facets, since we will not be using them.

19. Drag a Facet Ref component from the Layout components and drop it onto the center facet of the Panel Stretch Layout. On the Insert Facet dialog, select the mainContent facet that you added during the template creation.

20. Finally, add the following code to the Panel Stretch Layout topBar facet:

<f:facet name="top">
<af:panelGroupLayout id="pt_pgl5" layout="vertical">
<af:facetRef facetName="popupContent"/>
<af:menuBar id="pt_mb1">
<af:facetRef facetName="menuBar"/>
</af:menuBar>
<af:panelGroupLayout id="pt_pgl2" layout="horizontal">
<af:toolbar id="pt_t2">
<af:facetRef facetName="topBar"/>
</af:toolbar>
</af:panelGroupLayout>
</af:panelGroupLayout>
</f:facet>

1. Right-click on the shared ViewController project and select New….

2. On the New Gallery dialog, select Java under the General category and Java Class from the list of items on the right.

3. On the Create Java Class dialog, enter CommonActions for the class name and com.packt.jdeveloper.cookbook.shared.view.actions for the class package.

4. Let's go ahead and add methods to provide consistent commit functionality:

public void commit(ActionEvent actionEvent) {
if (ADFUtils.hasChanges()) {
// allow derived beans to handle before commit actions
onBeforeCommit(actionEvent);
// allow derived beans to handle commit actions
onCommit(actionEvent);
// allow derived beans to handle after commit actions
onAfterCommit(actionEvent);
} else {
// display "No changes to commit" message
JSFUtils.addFacesInformationMessage(BundleUtils. loadMessage("00002"));
}
}
protected void onBeforeCommit(ActionEvent actionEvent) {
}
/**
protected void onCommit(ActionEvent actionEvent) {
// execute commit
ADFUtils.execOperation(Operations.COMMIT);
}
protected void onAfterCommit(ActionEvent actionEvent) {
// display "Changes were committed successfully" message
JSFUtils.addFacesInformationMessage(BundleUtils. loadMessage("00003"));
}

5. We have also added similar methods for consistent rollback behaviour. To provide uniform record creation/insertion functionality, let's add these methods:

public void create(ActionEvent actionEvent) {
if (hasChanges()) {
onCreatePendingChanges(actionEvent);
} else {
onContinueCreate(actionEvent);
}
}
protected void onBeforeCreate(ActionEvent actionEvent) {
// commit before creating a new record
ADFUtils.execOperation(Operations.COMMIT);
}
public void onCreate(ActionEvent actionEvent) {
execOperation(Operations.INSERT);
}
protected void onAfterCreate(ActionEvent actionEvent) {
}
public void onCreatePendingChanges(ActionEvent actionEvent) {
ADFUtils.showPopup("CreatePendingChanges");
}
public void onContinueCreate(ActionEvent actionEvent) {
onBeforeCreate(actionEvent);
onCreate(actionEvent);
onAfterCreate(actionEvent);
}

6. Similar methods were added for consistent record deletion behaviour. In this case, we have added functionality to show a delete confirmation pop-up.