Wednesday, April 20, 2016

Overview of "Profile" and "Folder" in WebCenter Content

In this post, I will go over the basics of two features in WebCenter Content (WCC) - Profile and Folder - and then talk about their own design considerations and usages, and finally discuss their differences.

In WCC, the Profile (a.k.a metadata profile or content profile, to differentiate from user profile) is an approach of metadata modeling. The profile is a powerful tool that can be used to manage the metadata fields to achieve efficient processing of content items, such as check-in, update, search, etc.

Essentially, content profiles consist of set of rules that manage the display of the metadata fields of content items. Through content profiles, you can control what metadata fields should be displayed/hidden, required or not, read-only/editable, initialized with default value or not, and grouped based on the action to the content – whether you are viewing the content information, checking in, updating or searching. Profile provides the capability to customize the user interface of the metadata presented to the users. This is important as the profile can not only improve the user experience but also improve the data quality and accuracy. If a user is presented with too many irrelevant fields when dealing with a content item, the experience could be daunting and very likely the user would not provide quality data input. It doesn't need to take long before your content system filled with more and more irrelevant data and is abused in a sense. Bad profiling could definitely hurt searching experience as well. Consider a profile is defined in a way that captures irrelevant and inaccurate data, the overall search output would be misleading.

One of the frustrations I heard from customers was users wanted multiple profiles on a content item. In WCC, only one profile can be associated with a content item. You may find it a drawback from your unique business use cases or the way you handle the content processing. However, it’s designed in this way for a purpose. You can consider the profile is to define the type of a content item. Any content item belongs to a certain type but not more than one types. The capability of aggregating multiple profiles into one content item could very much likely lead to data abuse and subsequently many other undesired outcomes. Another frustration was “specific resources are required to build or update the profiles”. From what we have discussed, a new profile should be created only if there is a new type of content item required in the system. A profile should stay as static as possible and be updated only if the type of the content item changes with your business context. If the business context doesn’t require any new types of content or any existing types to be retired, the profile should not be built or updated frequently. You may need to look into the initial design and definition of the profiles to match the business needs. Since profile is the approach of metadata modeling, the proper metadata design is essential for daily content management. Metadata in WCC should match your enterprise taxonomy to achieve best outcome on content organization.

Speaking of the number of the profiles, there is no good or bad number. It just needs to fit your business needs. The 50-100 range is the average number of profiles for all US WCC implementations (the statistics is not published anywhere but from a technical summit with Oracle WCC team). The extreme case I have seen with a client is over thousands of profiles in the WCC system and it works just fine. There is a performance caveat with very high number of the profiles in the WCC system. I encountered such performance issue in one of my WCC implementations and the issue has been addressed by Oracle team. For details, please check here.

Folder, in WCC, is a way to structure and organize content items. It’s worthy to note that in WCC the folders are standalone “virtual” structures. Content items are not physically stored in any folder. Every content item in a folder has a metadata field (xCollectionId) to store a numeric folder ID that links the content item to a folder. It behaves like a symbolic link in WCC system.

Content folders offer a conventional hierarchy structure that provides easy access to a content item in WCC. They are just like the directories on your local laptop that point to virtual locations of the content system. With folders in WCC, you can just perform actions like you do in the conventional file system. Quoted in Oracle documentation, “The familiar folder and file model provides a framework for organizing and accessing content stored in the repository. Functionally, folders and files are very similar to those in a conventional file system. You can copy, move, rename, and delete folders and files. You can also create shortcuts to folders or files so you can access a content item from multiple locations in the hierarchy. You can think of the files in the Folders interface as symbolic links or pointers to content items in the repository. The operations you perform in the Folders interface, such as searching or propagating metadata, effectively operate on the associated content items.” 

The hierarchical folder interface is achieved by a component installed in WCC. This component is called FrameworkFolders. It is a scalable enterprise solution and is intended to replace the earlier Contribution Folder interface (called Folders_g component). For a comparison of FrameworkFolders and Folders_g, you can visit this link for more details.
  • There are different types of folders can be used to organize content to fit your different needs. Traditional Folders: it’s the general folder we have discussed that you use to organize your content just like the one you use in your computer.
  • Query Folders: it’s a folder you can create based on a search/query result. It contains collections of document based on the search criteria you defined. You can save the query folder just like you create a regular folder.
  • Retention Folder: it’s a type of query folder with retention rules.


Conceptually, the Folder and Profile are distinct on their functionality and their design purpose. Profile can be considered as a way to define a content “type”. Folder, like the conventional folder in your laptop, is a way to aggregate and organize content. You can store content items with the same profile in the same folder or different folders. You can have a folder containing content items with the same profile or different profiles. I will use an example to better illustrate the usage of the profile and folder.  Say in your company you have the following types of content items: legal document, sales document, and reports. You also have the following departments: HR, IT and Sales. All departments may have their own legal documents and reports. Sales document would almost fall into the sales department not the other two. In this case, you may want to take the content types as the profiles and aggregate the content into folders as per the departments. You don’t want to create profile based on departments because the department can have all kinds of content items and it’s not just one static type. If somehow you define the profile as per department, you will find yourself in a way that has to create/update profiles all the time.

Folder and Profile do reveal some similarities in ways that how content is managed. You can manage content items based on a folder or a profile.  For example, you can search content items either by a folder or a profile; you can batch process content items in a folder or a profile, such as manage workflow, govern security, update content information, etc. On the other hand, folder and profile do have many differences from the way they are designed.
  • Folder, just like a file, can have its own metadata. You can also propagate metadata from a folder to the subfolder and the content items within it. But for profile, it is a way to manage metadata and you cannot apply metadata on top of a profile.
  • Folder has its own security. Each folder has an owner who can modify its metadata and delete it if needed. But the folder owner doesn’t have any additional privileges over the content items inside the folder. Profile has little to do with security directly. But since Profile is to manage the metadata, it could manage profile indirectly. The “Security Group” and “Account” metadata can be used to manage security of a content item.
  • With folder, you can perform basic content retention scheduling by creating a retention query folder, assigning retention attributes to the folder, and then configuring the retention schedule. There is also a specific folder type – retention folder in WCC – which is based on query folder with rules for content retention. Since Profile is to manage the metadata, it has little to do with retention directly.
  • In workflow, actions can be applied on top of content items either within a folder or associated with a profile. In this perspective, folder and profile have similar effects.
  • WCC doesn’t have standalone tagging service. But you can create custom metadata for this purpose. Folder has its own metadata, so you can apply the custom tag on top of a folder. Profile, again, as a way to model metadata, can be used to manage any metadata field, including the tagging.
In a quick summary, Profile and Folder are two different concepts in WCC. Although they may reveal some level of similarities in how content can be managed, their design basis are quite distinct. Profile can be considered as a way to define the "type" of a content item and provide a customizable user interface for users to manage their content. Folder provides a virtual hierarchical structure just like the conventional file system in your computer to help to organize and manage content. They should be used and designed as per the essentials of their function, to avoid inefficient content management.

Monday, April 11, 2016

Build A Concurrent Web Page With A Simple Example

Today, by using a simple example, I am going to demonstrate on how to build a concurrent web page in ADF using Jdeveloper.

From time to time, I see requirements from various contexts with such needs to build concurrencies on web pages. The performance can be greatly benefited since multiple processes are executed at the same time so that the response time is greatly improved. It's also very suitable for the use cases that the processes are not associated with any user interface interactions, such as sending an email to user after performing some action but the web page does not need to know if/when the email is sent. Such processes can be executed in a separate thread from the main thread dealing with the web page rendering and other user interactions. Even if you don't have hard requirement on such concurrency needs, why waste it? Nowadays, all servers are built with multi-core computation capabilities and designed for parallel processing. In years the speed of the CPU is not getting much faster but the number of the processing cores are getting more. If you are not taking advantage of it, it would be your waste.

Implementing such concurrency in Java EE application does not seem to be complicated, especially considering the fact that Java concurrency has been introduced since Java 1.5. But, such implementation seems to be somewhat formidable to the development team from my experience. The reason could be without careful handing and design of the Java concurrency, your expected performance gain could lead to an (much worse) opposite degradation. It could also be because there is a lack of examples to demonstrate such use case and that's definitely the purpose of this post to compensate it.

In this example, I have a page built in ADF with 3 sections - left, central and right section. Each section has their independent content and requires different period of time to process. Let's say the left will take 2 seconds, central will take 3 seconds and right will take 5 seconds to return the data.

I will start with the default approach (no concurrency) followed by two others on how to improve our web page response time.

The default

There is no concurrency here. Everything runs sequentially. My page looks like this:

Since everything runs in sequence, so the response time takes 2 (left) + 3 (central) + 5 (right) = 10 seconds minimal. It actually take 10.59 seconds - not a surprise.

If you are wondering what's the code behind the scene on the content rendering, here it is:

Now it's time to explore the better solution.

The Better

In this approach, I would use ExecutorService to mange the creation and termination of the Java threads to perform the parallel processing. Since there is 3 sections in the page that I need to run in parallel, I will create the thread pool with 3 threads. Then I would need to submit individual tasks to the executor service to perform. The task is basically the work unit that needs to be done for each section. Since our task needs return values, I am going to use Callable interface to implement the task. We can get a reference of the task submission which is the Future object. With the Future object, we can get the output of the task when it completes.

CentralContentTask codes -

As you can see, I only need to put the task code into the call() method that I need to implement which is defined by Callable interface.

In the managed bean to render the web page, here is the logic that used to manage threads by ExecutorService - task submission, termination, output retrievemcent, etc.

Please note: it is very important to shut down the ExecutorService after task submission. Otherwise the memory leak would happen. There is no need to wait until the task complete to shut down. You can also shut down the executor service immediately regardless of task complete status by using shutDownNow() but that's not we are going to pursuit.

After, we get the output of the task by get() on the Future object. This method will make the thread to wait until the task complete and return the output.

Let's run the page and see our response time -

It takes 5.37 seconds to load the page. As we are running 3 processes in parallel, the total time will be the one with the longest processing time, which is 5 seconds.

It's much better. But not enough? Can we push all 3 processes to the back without interfering the page rendering?

The Ultimate

The idea is to separate the main thread which is rendering the web page from the parallel processing the 3 sections. It's fairly simple and we actually have already done that in previous code. The only thing blocking the main thread is using the Future.get() to return the output of the task. We will need to avoid that in the main thread. So the question becomes how could we retrieve the output of the task  that takes a period of time and push back to the web page we already rendered?

The answer is the ADF poll component. ADF poll can be used to various use cases that require pushing data to web pages after rendered. Here is how to leverage it in our use case.

First, we add a <af:poll> on the web page with an interval 1 second and makes all 3 sections listen to this component.

Second, we construct the refresh() method defined in the poll component to retrieve the output of the tasks.

Here we use Future.isDone() to check if the task is complete or not before getting the output, so that the thread is not waiting if the task is not complete yet.

Another note is after all 3 processes complete, we will need to stop the poll event. ADF poll offers a property "timeout" to expire the poll after a period of time. But at this time, this feature doesn't work well in ADF 11g including This is a bug already filed but very likely it will NOT be fixed in ADF 11g. To disable the poll, we will use a workaround here to reset the poll interval to "-1" (negative) which will automatically disable the poll.

Let's take a look how long the page takes to render -

Yes, 407ms!

Now all 3 processes are running behind the page and when they are ready, it's pushed to the page individually. If you watch the page, you will see the left content comes first, then the central content and finally the right content.

In most time, the user perception is everything. In our last approach, we are able to give the user the page rendering with no time and gradually add the content when they are ready. It is an ultimate scenario. In cases that the user doesn't want to see the empty content to start with, we can put the process of the desired content back to the main thread with the page rendering, so that the web page always shows the desired content at the user's first sight. In that case the total response time will be a few hundreds of milliseconds plus whatever the process of the desired content will take.

The sample example demoed in the post can be downloaded here. It's built in Jdeveloper

Friday, December 18, 2015

Caveat: URL Parameter in Navigation Model (WebCenter) Cannot Be Null Object

In WebCenter Portal, you can define the URL parameter name/value pair in the URL parameters section in the Navigation Model. When you do that, the name/value pair will be added to the URL as a query string, such as "?name=value".

As the header suggests, the URL parameter in the Navigation Model of WebCenter Portal application cannot be a NULL object.

If the URL parameter is a static value, then it's not a concern. In case there is a need to dynamically populate the URL parameter in the navigation model, it's important to make sure the dynamical value cannot be NULL object. Because when the value is NULL, the navigation model does NOT know how to construct the query string. Note the NULL object is not equivalent to empty string. In this case, WebCenter Portal will not able to recognize the requested URL. In such case, it will redirect to the application context root which will induce the index page or whatever page you have define as the default page to render.

To work around it, simply return an empty string if the dynamic value could be null in your logic.

Friday, September 4, 2015

Work with the ADF Control State on External Link URL in WebCenter Portal Navigation Model

In the Navigation Model of a WebCenter Portal application (11g), there is an option to define a navigation resource by "external link". In a normal case, you should NOT define any internal JSPX page using this option, but only if there is a need to navigate to a third party site - by what the name means, an external link. The internal JSPX page should be added to the Navigation Model by the "page" type.

The impact of defining internal JSPX page as an external link is, the redundant memory footprint due to the ADF control state token recreations every time this external link is clicked. ADF control token is an identifier used by the Controller to track user's state so that all in process task flows for the same user can be retrieved. Normally, this ADF control state should be not recreated for the same user. With the external link type, the navigation behaves like entering the application in a blank new context so every navigation with external link type will auto generate a new ADF control token. Within the same user session, the recreations of the ADF control token mean redundant memory use. The less negative thing is the ADF control state will be garbage collected after user session is invalidated. So this memory issue is only scoped within user sessions and will not accumulate over time - well this is assuming your application doesn't have a crazy long timeout setting nor your users would stay active for long time (long or short, is relative. It's impossible to name a threshold without doing some load testing and analyses on the application, as at the end of the day every application is different). In this regard, it's not a memory leak in time. However, when there is a high concurrency of users navigating the application, this issue could be a concern.

The main focus of this post is how to get around this memory issue with the external link type for internal JSPX page. You may ask what's the use case for this type of implementation - well, there is always some special unique use case down the road you might come across one day. Let's say one day you cannot use goLink and commandLink on the navigation model, but rather have to a programmatic redirect to some other page in your application with this ADF control state recreation issue.

The foremost thing is to understand the navigation model - why using navigation model API would keep the ADF control token intact throughout the application. Let's start with a new WebCenter Portal framework application and understand what navigation model API would do.

In the home.jspx page, add a navigation model goLink prettyURL syntax as the value of an output text like below.

It's basically printing out the navigation model prettyURL of the home page. When the page renders, you would see -

The navigation model prettyURL returns "/faces/home?_adf.ctrl-state=xxxxx". So the secret of navigation model capable of keeping the same ADF control token around is to attach it as a query string in the URL on every navigation.

After this is figured out, the rest should be easy. To use external link to reference an internal JSPX page, it's necessary to make the URL path relative so that your application can work properly on different environment. When defining an external link in navigation model, the URL field doesn't have the expression language facility (a nice popup that you can build objects using EL trees) but we still can use EL to construct the URL.

Using the home.jspx as an example, here is the syntax we should use:


Here is the External Link definition in the navigation model -

Note we need to add the "_adf.ctrl-state" URL parameter below. Alternatively, you can also define the URL parameters as part of the URL like


The source of the external link definition looks like below:

Note the actual prettyURL is not mandatory. "/faces/home" can also be replaced by "/faces/oracle/webcenter/portalapp/pages/home.jspx".

Now we can run the application. When clicking between the Home and "Home External Link", the ADF control state never changes.

Wednesday, July 29, 2015

Understand WebCenter/ADF Session Invalidation and Removal

There are a couple of ways to invalidate the session in WebCenter Portal (or ADF) application. They are not the same. They all would invalidate the user session which is intended. The main difference is around whether the session will be removed after it's invalidated. In this post, I will walk through this.

In WebCenter Portal framework application, the built-in page template already has a logout function provided. Let's take a look at it.

Create a WebCenter portal application and open up the page template as below

In this JSPX file, you will find a logout command link with action specified as "#{o_w_s_l_LoginBackingBean.doLogout}". The source code of this bean is not available unless you trace back to the shipped libraries that were installed with Jdeveloper.

Let's take a look at the effect of the logout function. Run the portal application.

Open the local weblogic console, navigate to the deployment, find your application, go to application configuration, and select the monitor tab to look at the session statistics.

Before going forward, let's look at the definitions of the 3 columns we are interested in:

  • Sessions: Displays the current number of open sessions associated with this web application.
  • Sessions High: Displays the highest number of concurrent open sessions associated with this web application that have ever been reached since the weblogic instance was started.
  • Total Sessions: Displays the total number of open sessions ever associated with this web application.

We can see there is 1 current open session. At this time the user is not logged in yet. So it's anonymous session. Please note this is true for an type of pages - JSP, JSPX or HTML, as long as they are part of the web application (war or ear). If you may need to avoid this anonymous session, assuming your application entry page is not dynamic, you can consider build such login page in HTML and store it in web server. In this case, there will no session attached when such page is visited.

Let's login.

Check the session statistics again, we can see the current open session is still 1 but the session high and total session is 2. The anonymous session gets removed and a new authenticated user session created. That makes sense.

Let's logout and check the session statistics again. Now the open session is 2, session high is 2 and total session is 4. What does this mean?
Let's review the numbers. Total session increases from 2 to 4. That means 2 new sessions created. But the open session increases from 1 to 2. That means there are 2 current open session, increased only 1 from previous state. One thing to note is after the logout, the page lands on the entry page again just like the page before the login.

The explanation on above behaviors would be the previous authenticate session gets removed, but as soon as it's removed, an anonymous session is created. It's like the authenticated session gets converted to an anonymous session. Since the page is redirected to the login page, it's just like the initial rendering of the login page, there is a new anonymous session created. So it's 2 - one is not associated with the current UI (login page) and the other is associated. When the first anonymous session will be removed? It will be removed after the session timeout setting reached (set in web.xml). The second anonymous session will be removed after the server detects the user is idle for the session timeout setting reached.

Well, you may say that's not desired. Correct, it's not. Let's look how can we avoid the redundant anonymous sessions.

We have reviewed the second anonymous session is associated with page as it's part of the web application. Let's do a test and force the redirection to go to a page outside of the web application. To do such redirect, we will need to put in some custom code. I am going to reuse the WebCenter portal built-in logout function by taking the expression inside my managed bean.

Here is the custom managed bean associated with the command link:

Here is the logic for the custom managed bean:

Basically, I used an utility method to resolve the expression function to logout. Then issue a redirect to the server host. Here is the page landed after the logout.

Let's look at the session statistics again. Since the statistics are the same until the logout, here is just the statistics after issuing a logout.

Now we can see there is only 1 open session with total session of 3. This open session is the anonymous session converted from authenticated users session.

Next, let's look at how to avoid the anonymous session conversion but rather to remove it for good.

After some trials, none of the JEE related methods work as expected. This includes HttpSession.invalidate(), HttpSession.setMaxInactiveInterval(), and a few other methods. No mistaken, the session indeed get invalidated and there is no security concern, but the redundant anonymous session (not associated with any front-end) hanging around is the complaint.

The only working way is to use the ADF authentication servlet. Here is the code snippet to use:

In the code, I used "/adfAuthentication?logout=true&end_url=../" to call the ADF authentication servlet to invalidate the user (and remove the session) and redirect the page to host with parameter "end_url". The ADF authentication servlet is defined in web.xml by default:

Now let's use the new doLogout() method which uses ADF authentication Servlet to logout and review the session statistics after logout:

Great. There is 0 open sessions and no redundant session hanging around.


1. To avoid anonymous session before login or after logout, please redirect to pages outside of web application.
2. To avoid anonymous session hanging around being converted from authenticated session, please use ADF authenticate servlet to logout.

Tuesday, July 21, 2015

Sunday, July 19, 2015

Install JDeveloper on OS X with JDK7

The info is taken from this post:

Thanks to Justin, it saved quite some efforts.

1 If you do not have Apple Java 1.6, download it here (Java for OS X 2014-001).
2 Start the JDeveloper installer using Apple Java 1.6.
3 $(/usr/libexec/java_home -v 1.6)/bin/java -jar ~/Downloads/jdevstudio11119install.jar
4 Follow the screens and when you reach the portion of the installer that asks for the JDK, point it to your JDK 1.7 location. In my case, I have used JDK 7u80.
5 /Library/Java/JavaVirtualMachines/jdk1.7.0_80.jdk/Contents/Home

6 Complete the installation.

Tuesday, October 21, 2014

IE11 Support has come to WebCenter BP5

If you are on edge of using IE as your support browser, IE 11 support on WebCenter has come. The patch for it is initially released via BP4 and included in BP5. Please see the link for the details: 

Tuesday, October 7, 2014

Required Flag for the View Object Bind Variable

When creating a bind variable for a view object in ADF, there are two properties can be configured - Updatable and Required.

The updatable flag should be enabled pretty much all the time as it allows you to change the bind variable value to run the query again. For the Required flag, it should be disabled unless you specifically need it - seems worthless to say ...

When the required is enabled, the bind variable will be defined as "Kind=where" - this can be examined in the view object xml file. This is pretty straightforward. "Kind=where" means this bind variable will always be added into the where clause when this VO is queried. Therefore it's always "required".

When the required is disabled, the bind variable will be defined as "Kind=viewcriteria". This means this bind variable is optional and can be added by applying the corresponding view criteria. Therefore it's not required.

In most cases, the bind variable should be optional. Unless this VO instance is meant to be queried with the specific where clause all the time.

Tuesday, September 2, 2014

Oracle WebCenter Portal Mobilizing – Responsive or Adaptive, or Both?

With today’s quickly evolving web and advanced rendering capabilities, enterprise continues to seek applications with which to run massive amounts of transactional data on mobile devices. Few applications can support the increasing mobility of interfacing technologies, and those that do require teams of engineers to build and maintain them across multiple platforms. This extra layer of complexity and cost can prohibit some enterprises, and dissuade others seeking more flexible and wide-reaching data infrastructure.

Read more ...

Sunday, July 13, 2014

IOUG Speaking - Build Your Responsive & Mobilized Enterprise Portal

Hi there,

For those of you who missed out my Collaborate 14 presentation on WebCenter Responsive Web Design, here is another chance for you to regain the opportunity, for free!

Here is the summary of the talk. You can register the event by the link provided at the bottom.


Thursday, July 17th, 2014 12:00 p.m. - 1:00 p.m. CDT
Mobilizing emerges as a "must-have" feature for modern web experience. Oracle WebCenter Portal introduces multi-channel portal experience to support mobilized web for smart devices. This session reveals the essential secret sauce of the new mobilizing support – responsive web design, and teaches how to extend the responsive template to support your custom needs. The session helps to determine your mobile enterprise portal strategy and teaches how to build the responsive from scratch to create your own mobilized enterprise portal on WebCenter Portal Framework applications. Further, the session analyzes real world customer cases to help you avoid the pitfalls and exploit first hand best practices.
Featured Speakers: JayJay Zheng, Director, Primitive Logic

You can register the event by  clicking | Register Here |

Tuesday, May 27, 2014

Caveats on Using WebLogic Server with JDK7

Now JDK 7 has been out for a while (JDK 8 is out too as of writing). There are some caveats using WebLogic Server with JDK 7 you might want to know, not matter it's on 10.3.6 or 12c.

1. Out of memory error on starting Admin Server. This error is caused by the fact that the new JVM requires more PermGen space. Depending on your RAM, you can set it >350m. In my case, I would set the perm size to 512M.


2. In some cases, the new compiler generates larger byte code. It is possible that a large method may exceed the 64KB limit per method. In this situation, you may need to refactor the method. This seems to only affect WebLogic 10.3.6

3. Classes may have been removed that are from the internal package sun.*, or that have been marked as deprecated in a previous version of the JVM. If an application uses these removed methods, a ClassNotFound exception will occur.

4. JDBC 4.1 is introduced in JDK7. JDBC 4.1 methods are not currently supported in WebLogic Server with JDK 7. Calls to these methods will result in an SQLException indicating that the method is not supported.

If you are using WebLogic 10.3.6, after installing WebLogic Server, copy the following files from WL_HOME/modules to JAVA_HOME/jre/lib/endorsed, where WL_HOME is the WebLogic Server installation home directory:
  • javax.annotation_1.0.0.0_1-0.jar
  • javax.xml.bind_2.1.1.jar
  • javax.xml.ws_2.1.1.jar


Monday, May 26, 2014

FrameworkFolders Support has come to Oracle WebCenter Portal

As of late April 2014, FrameworkFolders support on Oracle WebCenter Portal has been enabled by Oracle WebCenter Previously, Oracle WebCenter Portal only supported Folders_g.

Now it's time to review the essentials on what, why and how.

What's Framework Folders?

Introduced in WebCenter PS5, the framework folders (also called folders component) provide a hierarchical folder interface, similar to conventional file system, for organizing and locating some or all of the content in the repository. It's a scalable, enterprise solution and is meant to be a replacement for contribution folders (folders_g component).

Why it's better than Folders_g (FrameworkFolders vs. Folders_g)?

With the FrameworkFolders component as the underlying folder architecture, many functionalities and features have been made available.
  • Mass metadata updates with folders (metadata propagation):  "Query Folders" is added in the FrameworkFolders component. Query folders are folders that are populated simply by a query. Query folders contain the actual repository content items returned by the query. The contents of query folders can change dynamically as the contents of the repository change. By using the query folder and the propagate function, one can make mass metadata updates of folders in a very easy way.
  • Unlimited content items: There is a limitation of 1000 content items in a folder or subfolders within a folder with Folders_g. There is no such limit with FrameworkFolders.
  • Enhanced search functionality: With frameworkFolders, several enhanced features are available to make search easier and more performant. User can save a query result in a query folder, as well as records management by using RetentionQuery folder. By default, you cannot search folders with folders_g. Now users can search for folders, content items within a folder with FrameworkFolders.
  • Personal folder support: Added personal folder for each user and the content within a personal folder is only available for the user himself/herself.
  • New user interface support: with the FrameworkFolders component, a new look and feel presentation layer of the content server is available. The new UI is built by ADF technology.
How to get it?

For an Oracle WebCenter Portal instance patched from an earlier release, you must continue to use Folders_g. For new installations of Oracle WebCenter Portal, it is recommended that you enable the FrameworkFolders component on Content Server for better performance and so as to be able to use any new Content Server features.

The FrameworkFolders component can be enabled only for the installations that meet the following criteria:

  • You must have a new Oracle WebCenter Portal installation. Oracle WebCenter Portal must not have been patched from a previous release, that is, it should be a completely fresh instance.
  • You must have a new installation of Oracle WebCenter Content, with the FrameworkFolders component enabled. Oracle WebCenter Content must not have been patched from a previous release, that is, it should be a completely fresh instance.
  • Content Server should never have been configured to run with the Folders_g component. You must not enable FrameworkFolders if Folders_g was previously enabled.

To configure FrameworkFolders support for Oracle WebCenter Portal, you need to apply various patches to your new installations of Oracle WebCenter Content and Oracle WebCenter Portal

To prepare Oracle WebCenter Portal for FrameworkFolders support:

  • Ensure there is no content within Oracle WebCenter Content and Oracle WebCenter Portal
  • Download and apply the WebCenter Content MLR04 patch (latest as of today)
  • Download and apply the WebCenter Portal BP3 patch 18085041
  • Download and apply the WebCenterConfigure component patch 18387955


11g Folders – organized, optimized, modernized
Mass Metadata Update with Folders
WebCenter Content FrameworkFolders
Using Folders and WebDAV
Folder Services

Tuesday, April 22, 2014

Interview with Bob Rhubart on Responsive WebCenter Portal @ Collaborate 14

Short after my presentation on Responsive WebCenter Portal @ Collaborate 14 in Vegas, I had a video interview with Bob Rhubart who runs Oracle ArchBeat - the official blog of the OTN Architect Community. In this 10 min talk, I had reviewed my presentation topic, the hot gossips in the hallway and the visions of hot topics in the next coming collaborate.

Sunday, April 20, 2014

Building a Responsive WebCenter Portal Application - Technical Paper Published

In this article I reviewed the essentials of responsive web design, walked through how to design and develop a responsive WebCenter Portal application, and reviewed the essential development considerations. The article covers technical aspects of building a responsive WebCenter Portal as well as the business decision points behind each scenario. It is intended for software architects, developers, and business users who regularly work with Oracle WebCenter Portal.

Monday, April 7, 2014

Build Your Responsive & Mobilized Enterprise Portal

Let’s collaborate at Collaborate14!
Location: Las Vegas, NV – Venetian & Sands Expo Center
Dates: April 7th – April 11th
Build Your Responsive & Mobilized Enterprise Portal, by JayJay Zheng

Date: 04/10/2014
Time: 11:00 AM – 12:00 PM
Location: Level 3, San Polo 3502
Abstract: Mobilizing emerges as a "must-have" feature for modern web experience. Oracle WebCenter Portal introduces multi-channel portal experience to support mobilized web for smart devices. This session reveals the essential secret sauce of the new mobilizing support – responsive web design, and teaches how to extend the responsive template to support your custom needs. The session helps to determine your mobile enterprise portal strategy and teaches how to build the responsive from scratch to create your own mobilized enterprise portal on WebCenter Portal Framework applications. Further, the session analyzes real world customer cases to help you avoid the pitfalls and exploit first hand best practices.

Objective 1: Discover fundamentals utilized in the Oracle WebCenter mobile support.

Objective 2: Describe and explain how to build a responsive template from scratch.

Objective 3: Discuss mobile enterprise portal strategy for various organizations' needs and analyzes the real world customer cases for mobile support.