Service (JCS) provides a platform to
develop
and deploy business applications
in the cloud.
In Fusion Applications
Cloud deployments customers do not have
the
option to deploy custom applications developed with JDeveloper to ensure
the
integrity
and supportability of
the hosted application service. Instead
the custom applications can be deployed
to
the JCS
and integrated to
the Fusion Application Cloud instance.
This series of articles will go through
the
features of JCS, provide end-to-end examples on how to develop
and deploy
applications on JCS
and how to integrate them with
the Fusion Applications
instance.
In this article a
custom application integrating with REST service will be implemented. We will
use REST services provided by Taleo as an example; however
the same approach
will work with any REST service.
In this example
the data from
the REST service
is used to populate a dynamic table.
Pre-requisites
Access to Cloud instance
In order to deploy
the application access to a JCS instance
is needed, a free trial JCS instance can be obtained from Oracle Cloud site. To register you will need a credit card even if
the credit card will not be charged. To register simply click "Try it"
and choose
the "Java" option.
The confirmation email will contain
the connection details. See this video for example of
the registration.Once
the request
is processed you will be assigned 2 service instances; Java
and Database. Applications deployed to
the JCS must use Oracle Database Cloud Service as their underlying database. So when JCS instance
is created a database instance
is associated with it using a JDBC data source.
The cloud services can be monitored
and managed through
the web UI. For details refer to Getting Started with Oracle Cloud.
JDeveloper
JDeveloper contains Cloud specific features related to e.g. connection
and deployment. To use these features download
the JDeveloper from JDeveloper download site by clicking
the "Download JDeveloper 11.1.1.7.1 for ADF deployment on Oracle Cloud" link, this version of JDeveloper will have
the JCS integration features that will be used
in this article. For versions that do not include
the Cloud integration features
the Oracle Java Cloud Service SDK or
the JCS Java Console can be used for deployment. For details on installing
and configuring
the JDeveloper refer to
the installation guideFor details on SDK refer to Using
the Command-Line Interface to Monitor Oracle Java Cloud Service
and Using
the Command-Line Interface to Manage Oracle Java Cloud Service.
Access to a local database
The database associated with
the JCS instance cannot be connected to with JDBC. Since creating ADFbc business component requires a JDBC connection we will need access to a local database.
3rd party libraries
This example will use some 3rd party libraries for implementing
the REST service call
and processing
the input / output content. Other libraries may also be used, however these are tested to work.
Jersey 1.x
Jersey library will be used as a client to make
the call to
the REST service. JCS documentation for supported specifications states:
Java API for RESTful Web Services (JAX-RS) 1.1
So Jersey 1.x will be used. Download
the single-JAR Jersey bundle;
in this example Jersey 1.18 JAR bundle
is used.
Json-simple
Jjson-simple library will be used to process
the json objects. Download the JAR file;
in this example json-simple-1.1.1.jar
is used.
Accessing data
in Taleo
Before implementing
the application it
is beneficial to familiarize oneself with
the data
in Taleo. Easiest way to do this
is by using a RESTClient on your browser. Once added to
the browser you can access
the UI:
The client can be used to call
the REST services to test
the URLs
and data before adding them into
the application. First derive
the base URL for
the service this can be done with:
Method: GET
URL: https://tbe.taleo.net/MANAGER/dispatcher/api/v1/serviceUrl/<company name>
The response will contain
the base URL to be used for
the service calls for
the company. Next obtain authentication token with:
Method: POST
URL: https://ch.tbe.taleo.net/CH07/ats/api/v1/login?orgCode=<company>&userName=<user name>&password=<password>
The response includes an authentication token that can be used for few hours to authenticate with
the service:
{
"response": {
"authToken": "webapi26419680747505890557"
},
"status": {
"detail": {},
"success": true
}
}
To authenticate
the service calls navigate to "Headers -> Custom Header":
And add a new request header with:
Name: Cookie
Value: authToken=webapi26419680747505890557
Once authentication token
is defined
the tool can be used to invoke REST services; for example:
Method: GET
URL: https://ch.tbe.taleo.net/CH07/ats/api/v1/object/candidate/search.xml?status=16
This data will be used on
the application to be created. For details on
the Taleo REST services refer to
the Taleo Business Edition REST API Guide.
Create Application
First Fusion Web Application
is created
and configured. Start JDeveloper
and click "New Application":
Application Name: JcsRestDemo
Application Package Prefix: oracle.apps.jcs.test
Application Template: Fusion Web Application (ADF)
Configure Local Cloud Connection
Follow
the steps documented
in the "Java Cloud Service ADF Web Application" article to configure a local database connection needed to create
the ADFbc objects.
Configure Libraries
Add
the 3rd party libraries into
the class path. Create
the following directory
and copy
the jar files into it:
<JDEV_USER_HOME>/JcsRestDemo/lib
Select
the "Model" project, navigate "Application -> Project Properties -> Libraries
and Classpath -> Add JAR / Directory"
and add
the 2 3rd party libraries:
Accessing Data from Taleo
To access data from Taleo using
the REST service
the 3rd party libraries will be used. 2 Java classes are implemented, one representing
the Candidate object
and another for accessing
the Taleo repository
Candidate
Candidate object
is a POJO object used to represent
the candidate data obtained from
the Taleo repository.
The data obtained will be used to populate
the ADFbc object used to display
the data on
the UI.
The candidate object contains simply
the variables we obtain using
the REST services
and the getters / setters for them: Navigate "New -> General -> Java -> Java Class", enter "Candidate" as
the name
and create it
in the package "oracle.apps.jcs.test.model". Copy / paste
the following as
the content:
import oracle.jbo.domain.Number;
public class Candidate {
private Number candId;
private
String firstName;
private
String lastName;
public Candidate() {
super();
}
public Candidate(Number candId,
String firstName,
String lastName) {
super();
this.candId = candId;
this.firstName = firstName;
this.lastName = lastName;
}
public void setCandId(Number candId) {
this.candId = candId;
}
public Number getCandId() {
return candId;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public
String getFirstName() {
return firstName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public
String getLastName() {
return lastName;
}
}
Taleo Repository
Taleo repository class will interact with
the Taleo REST services.
The logic will query data from Taleo
and populate Candidate objects with
the data.
The Candidate object will then be used to populate
the ADFbc object used to display data on
the UI. Navigate "New -> General -> Java -> Java Class", enter "TaleoRepository" as
the name
and create it
in the package "oracle.apps.jcs.test.model". Copy / paste
the following as
the content (for details of
the implementation refer to
the documentation
in the code):
import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.ClientResponse;
import com.sun.jersey.api.client.WebResource;
import com.sun.jersey.core.util.MultivaluedMapImpl;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import oracle.jbo.domain.Number;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
/**
* This class interacts with
the Taleo REST services
*/
public class TaleoRepository {
/**
* Connection information needed to access
the Taleo services
*/
String _company = null;
String _userName = null;
String _password = null;
/**
* Jersey client used to access
the REST services
*/
Client _client = null;
/**
* Parser for processing
the JSON objects used as
* input / output for
the services
*/
JSONParser _parser = null;
/**
*
The base url for constructing
the REST URLs. This
is obtained
* from Taleo with a service call
*/
String _baseUrl = null;
/**
* Authentication token obtained from Taleo using a service call.
*
The token can be used to authenticate on subsequent
* service calls.
The token will expire
in 4 hours
*/
String _authToken = null;
/**
* Static url that can be used to obtain
the url used to construct
* service calls for a given company
*/
private static
String _taleoUrl =
"https://tbe.taleo.net/MANAGER/dispatcher/api/v1/serviceUrl/";
/**
* Default constructor for
the repository
* Authentication details are passed as parameters
and used to generate
* authentication token. Note that each service call will
* generate its own token. This
is done to avoid dealing with
the expiry
* of
the token. Also only 20 tokens are allowed per user simultaneously.
* So instead for each call there
is login / logout.
*
* @param company
the company for which
the service calls are made
* @param userName
the user name to authenticate with
* @param password
the password to authenticate with.
*/
public TaleoRepository(String company,
String userName,
String password) {
super();
_company = company;
_userName = userName;
_password = password;
_client = Client.create();
_parser = new JSONParser();
_baseUrl = getBaseUrl();
}
/**
* This obtains
the base url for a company to be used
* to construct
the urls for service calls
* @return base url for
the service calls
*/
private
String getBaseUrl() {
String result = null;
if (null != _baseUrl) {
result = _baseUrl;
} else {
try {
String company = _company;
WebResource resource = _client.resource(_taleoUrl + company);
ClientResponse response =
resource.type(MediaType.APPLICATION_FORM_URLENCODED_TYPE).get(ClientResponse.class);
String entity = response.getEntity(String.class);
JSONObject jsonObject =
(JSONObject)_parser.parse(new StringReader(entity));
JSONObject jsonResponse =
(JSONObject)jsonObject.get("response");
result = (String)jsonResponse.get("URL");
} catch (Exception ex) {
ex.printStackTrace();
}
}
return result;
}
/**
* Generates authentication token, that can be used to authenticate on
* subsequent service calls. Note that each service call will
* generate its own token. This
is done to avoid dealing with
the expiry
* of
the token. Also only 20 tokens are allowed per user simultaneously.
* So instead for each call there
is login / logout.
* @return authentication token that can be used to authenticate on
* subsequent service calls
*/
private
String login() {
String result = null;
try {
MultivaluedMap<String, String> formData = new MultivaluedMapImpl();
formData.add("orgCode", _company);
formData.add("userName", _userName);
formData.add("password", _password);
WebResource resource = _client.resource(_baseUrl + "login");
ClientResponse response =
resource.type(MediaType.APPLICATION_FORM_URLENCODED_TYPE).post(ClientResponse.class,
formData);
String entity = response.getEntity(String.class);
JSONObject jsonObject =
(JSONObject)_parser.parse(new StringReader(entity));
JSONObject jsonResponse = (JSONObject)jsonObject.get("response");
result = (String)jsonResponse.get("authToken");
} catch (Exception ex) {
throw new RuntimeException("Unable to login ", ex);
}
if (null == result)
throw new RuntimeException("Unable to login ");
return result;
}
/**
* Releases a authentication token. Each call to login must be followed
* by call to logout after
the processing
is done. This
is required as
*
the tokens are limited to 20 per user
and if not released
the tokens
* will only expire after 4 hours.
* @param authToken
*/
private void logout(String authToken) {
WebResource resource = _client.resource(_baseUrl + "logout");
resource.header("cookie", "authToken=" + authToken).post(ClientResponse.class);
}
/**
* This method
is used to obtain a list of candidates using a REST
* service call. At this example
the query
is hard coded to query
* based on status.
The url constructed to access
the service is:
* <_baseUrl>/object/candidate/search.xml?status=16
* @return List of candidates obtained with
the service call
*/
public List<Candidate> getCandidates() {
List<Candidate> result = new ArrayList<Candidate>();
try {
// First login, note that
in finally block we must have logout
_authToken = "authToken=" + login();
/**
* Construct
the URL,
the resulting url will be:
* <_baseUrl>/object/candidate/search.xml?status=16
*/
MultivaluedMap<String, String> formData = new MultivaluedMapImpl();
formData.add("status", "16");
JSONArray searchResults =
(JSONArray)getTaleoResource("object/candidate/search",
"searchResults", formData);
/**
* Process
the results,
the resulting JSON object
is something like
* this (simplified for readability):
*
* {
* "response":
* {
* "searchResults":
* [
* {
* "candidate":
* {
* "candId": 211,
* "firstName": "Mary",
* "lastName": "Stochi",
* logic here will find
the candidate object(s), obtain
the desired
* data from them, construct a Candidate object based on
the data
*
and add it to
the results.
*/
for (Object object : searchResults) {
JSONObject temp = (JSONObject)object;
JSONObject candidate =
(JSONObject)findObject(temp, "candidate");
Long candIdTemp = (Long)candidate.get("candId");
Number candId =
(null == candIdTemp ? null : new Number(candIdTemp));
String firstName = (String)candidate.get("firstName");
String lastName = (String)candidate.get("lastName");
result.add(new Candidate(candId, firstName, lastName));
}
} catch (Exception ex) {
ex.printStackTrace();
} finally {
if (null != _authToken)
logout(_authToken);
}
return result;
}
/**
* Convenience method to construct url for
the service call, invoke
the
* service
and obtain a resource from
the response
* @param path
the path for
the service to be invoked. This
is combined
* with
the base url to construct a url for
the service
* @param resource
the key for
the object
in the response that will be
* obtained
* @param parameters any parameters used for
the service call.
The call
*
is slightly different depending whether parameters exist or not.
* @return
the resource from
the response for
the service call
*/
private Object getTaleoResource(String path,
String resource,
MultivaluedMap<String, String> parameters) {
Object result = null;
try {
WebResource webResource = _client.resource(_baseUrl + path);
ClientResponse response = null;
if (null == parameters)
response =
webResource.header("cookie", _authToken).get(ClientResponse.class);
else
response =
webResource.queryParams(parameters).header("cookie", _authToken).get(ClientResponse.class);
String entity = response.getEntity(String.class);
JSONObject jsonObject =
(JSONObject)_parser.parse(new StringReader(entity));
result = findObject(jsonObject, resource);
} catch (Exception ex) {
ex.printStackTrace();
}
return result;
}
/**
* Convenience method to recursively find a object with an key
* traversing down from a given root object. This will traverse a
* JSONObject / JSONArray recursively to find a matching key, if found
*
the object with
the key
is returned.
* @param root root object which contains
the key searched for
* @param key
the key for
the object to search for
* @return
the object matching
the key
*/
private Object findObject(Object root,
String key) {
Object result = null;
if (root instanceof JSONObject) {
JSONObject rootJSON = (JSONObject)root;
if (rootJSON.containsKey(key)) {
result = rootJSON.get(key);
} else {
Iterator children = rootJSON.entrySet().iterator();
while (children.hasNext()) {
Map.Entry entry = (Map.Entry)children.next();
Object child = entry.getValue();
if (child instanceof JSONObject ||
child instanceof JSONArray) {
result = findObject(child, key);
if (null != result)
break;
}
}
}
} else if (root instanceof JSONArray) {
JSONArray rootJSON = (JSONArray)root;
for (Object child : rootJSON) {
if (child instanceof JSONObject ||
child instanceof JSONArray) {
result = findObject(child, key);
if (null != result)
break;
}
}
}
return result;
}
}
Creating Business Objects
While JCS application can be created without a local database,
the local database
is required when using ADFbc objects even if database objects are not referred. For this example we will create a "Transient" view object that will be programmatically populated based
the data obtained from Taleo REST services.
Creating ADFbc objects
Choose
the "Model" project
and navigate "New -> Business Tier : ADF Business Components : View Object". On
the "Initialize Business Components Project" choose
the local database connection created
in previous step. On Step 1 enter "JcsRestDemoVO" on
the "Name"
and choose "Rows populated programmatically, not based on query":
On step 2 create
the following attributes:
CandId
Type: Number
Updatable: Always
Key Attribute: checked
Name
Type:
String
Updatable: Always
On steps 3
and 4 accept defaults
and click "Next". On step 5 check
the "Application Module" checkbox
and enter "JcsRestDemoAM" as
the name:
Click "Finish" to generate
the objects.
Populating
the VO
To display
the data on
the UI
the "transient VO"
is populated programmatically based on
the data obtained from
the Taleo REST services. Open
the "JcsRestDemoVOImpl.java". Copy / paste
the following as
the content (for details of
the implementation refer to
the documentation
in the code):
import java.sql.ResultSet;
import java.util.List;
import java.util.ListIterator;
import oracle.jbo.server.ViewObjectImpl;
import oracle.jbo.server.ViewRowImpl;
import oracle.jbo.server.ViewRowSetImpl;
// ---------------------------------------------------------------------
// --- File generated by Oracle ADF Business Components Design Time.
// --- Tue Feb 18 09:40:25 PST 2014
// --- Custom code may be added to this class.
// --- Warning: Do not modify method signatures of generated methods.
// ---------------------------------------------------------------------
public class JcsRestDemoVOImpl extends ViewObjectImpl {
/**
* This
is the default constructor (do not remove).
*/
public JcsRestDemoVOImpl() {
}
@Override
public void executeQuery() {
/**
* For some reason we need to reset everything, otherwise
* 2nd entry to
the UI screen may fail with
* "java.util.NoSuchElementException"
in createRowFromResultSet
* call to "candidates.next()". I am not sure why this
is happening
* as
the Iterator
is new
and "hasNext"
is true at
the point
* of
the execution. My theory
is that since
the iterator object
is
* exactly
the same
the VO cache somehow reuses
the iterator including
*
the pointer that has already exhausted
the iterable elements on
the
* previous run. Working around
the issue
* here by cleaning out everything on
the VO every time before query
*
is executed on
the VO.
*/
getViewDef().setQuery(null);
getViewDef().setSelectClause(null);
setQuery(null);
this.reset();
this.clearCache();
super.executeQuery();
}
/**
* executeQueryForCollection - overridden for custom java data source support.
*/
protected void executeQueryForCollection(Object qc, Object[] params,
int noUserParams) {
/**
* Integrate with
the Taleo REST services using TaleoRepository class.
* A list of candidates matching a hard coded query
is obtained.
*/
TaleoRepository repository = new TaleoRepository(<company>, <username>, <password>);
List<Candidate> candidates = repository.getCandidates();
/**
* Store iterator for
the candidates as user data on
the collection.
* This will be used
in createRowFromResultSet to create rows based on
*
the custom iterator.
*/
ListIterator<Candidate> candidatescIterator =
candidates.listIterator();
setUserDataForCollection(qc, candidatescIterator);
super.executeQueryForCollection(qc, params, noUserParams);
}
/**
* hasNextForCollection - overridden for custom java data source support.
*/
protected boolean hasNextForCollection(Object qc) {
boolean result = false;
/**
* Determines whether there are candidates for which to create a row
*/
ListIterator<Candidate> candidates =
(ListIterator<Candidate>)getUserDataForCollection(qc);
result = candidates.hasNext();
/**
* If all candidates to be created indicate that processing
is done
*/
if (!result) {
setFetchCompleteForCollection(qc, true);
}
return result;
}
/**
* createRowFromResultSet - overridden for custom java data source support.
*/
protected ViewRowImpl createRowFromResultSet(Object qc,
ResultSet resultSet) {
/**
* Obtain
the next candidate from
the collection
and create a row
* for it.
*/
ListIterator<Candidate> candidates =
(ListIterator<Candidate>)getUserDataForCollection(qc);
ViewRowImpl row = createNewRowForCollection(qc);
try {
Candidate candidate = candidates.next();
row.setAttribute("CandId", candidate.getCandId());
row.setAttribute("Name", candidate.getFirstName() + " " + candidate.getLastName());
} catch (Exception e) {
e.printStackTrace();
}
return row;
}
/**
* getQueryHitCount - overridden for custom java data source support.
*/
public long getQueryHitCount(ViewRowSetImpl viewRowSet) {
/**
* For this example this
is not implemented rather we always return 0.
*/
return 0;
}
}
Creating UI
Choose
the "ViewController" project
and navigate "New -> Web Tier : JSF : JSF Page". On
the "Create JSF Page" enter "JcsRestDemo" as name
and ensure that
the "Create as XML document (*.jspx)"
is checked. Open "JcsRestDemo.jspx"
and navigate to "Data Controls -> JcsRestDemoAMDataControl -> JcsRestDemoVO1"
and drag & drop
the VO to
the "<af:form> " as a "ADF Read-only Table":
Accept
the defaults
in "Edit Table Columns". To execute
the query navigate to to "Data Controls -> JcsRestDemoAMDataControl -> JcsRestDemoVO1 -> Operations -> Execute"
and drag & drop
the operation to
the "<af:form> " as a "Button":
Deploying to JCS
Follow
the same steps as documented
in previous article"Java Cloud Service ADF Web Application". Once deployed
the application can be accessed with URL:
https://java-[identity domain].java.[data center].oraclecloudapps.com/JcsRestDemo-ViewController-context-root/faces/JcsRestDemo.jspx
The UI displays a list of candidates obtained from
the Taleo REST Services:
Summary
In this article we learned how to integrate with REST services using Jersey library
in JCS.
In future articles various other integration techniques will be covered.
