JBoss Community Archive (Read Only)

Portlet Bridge 3.0

User Guide


Welcome to the JBoss Portlet Bridge User Guide. This document provides detailed explanation of the various parts of the project and how to use them in your own portlet project.


Portlet Configuration

Here is an example portlet.xml to configure a JSF2 portlet:





Only the javax.portlet.faces.defaultViewId.view init-param is mandatory. The edit and help init-param's are only required when your portlet requires the Edit and Help portlet modes.

Portlet 2.0 Schema

To have access to the latest Portlet 2.0 spec features, such as Events and Public Render Parameters, it's important to ensure that your portlet.xml contains the following schema definition:

<portlet-app xmlns="http://java.sun.com/xml/ns/portlet/portlet-app_2_0.xsd"
  xsi:schemaLocation="http://java.sun.com/xml/ns/portlet/portlet-app_2_0.xsd http://java.sun.com/xml/ns/portlet/portlet-app_2_0.xsd">

Preserving Request Parameters outside ActionRequest

By default the JBoss Portlet Bridge does not retain any Request Parameters that were received as part of an ActionRequest from the Portal. To ensure that Request Parameters from an ActionRequest are retained in the Bridge Request Scope until a RenderRequest, add the following init-param to portlet.xml:


Render Policy

Different JSF View Declaration Languages require different behavior from the JBoss Portlet Bridge when it comes to rendering views. Instructing the Bridge on which policy to use is done using the javax.portlet.faces.RENDER_POLICY context-param in web.xml.

If you're using Facelets:

Include the following in web.xml:


If you're using JSP:

Include the following in web.xml:


Supported Render Policies in JBoss Portlet Bridge:

  • ALWAYS_DELEGATE: Indicates the Bridge should not render the view itself but rather always delegate the rendering.

  • NEVER_DELEGATE: Indicates the Bridge should always render the view itself and never delegate.

  • DEFAULT: Directs the Bridge to first delegate the render and if and only if an Exception is thrown then render the view based on its own logic. If the configuration parameter is not present or has an invalid value the Bridge renders using default behavior. I.e. as if DEFAULT is set.

JSF Portlet Development

Communicating between Portlets


Send Event
Portlet Configuration

By default, the GenericFacesPortlet of the Bridge overrides the Event handling to dispatch all events to the Bridge. If you want to explicitly set this value, to prevent confusion, add the following to portlet.xml within its' <portlet> section:


When the entire portlet is written in JSF, this init-param must be set to true. Only set it to false when your portlet uses a mix of view technologies.

The portlet also needs to specify that it is able to publish an event to the portal by adding the below to portlet.xml within its' <portlet> section:

  <qname xmlns:jbp="urn:jboss:portal:samples:event">jbp:BookingEvent</qname>

This defines an event namespace and name to use when publishing the event.

Finally the portlet application needs to specify how the event namespace and name link to an actual type within the application. For the above publishing event definition, the portlet.xml would need the following:

  <qname xmlns:jbp="urn:jboss:portal:samples:event">jbp:BookingEvent</qname>

The qname above is identical to that used earlier to create the link between a qname and class type

Event Type

To publish an event we need a type to represent the actual object that will be attached to the event. Here is an example event type:

public class BookingEvent implements Serializable {

  private String id;
  public static final QName QNAME = new QName("urn:jboss:portal:samples:event", "BookingEvent");

  public BookingEvent(String id) {
      this.id = id;

  public String getId() {
    return id;

The type needs the @XmlRootElement annotation so that the event can be serialized into a JAXB object for publishing.

Dispatch Event

To dispatch the event to other portlets within the portal, you can do something similar to the below within a Bean method, such as a method triggered by an action:

Object response = FacesContext.getCurrentInstance().getExternalContext().getResponse();
  if (response instanceof StateAwareResponse) {
    String id = "an id";
    StateAwareResponse stateResponse = (StateAwareResponse) response;
    stateResponse.setEvent(BookingEvent.QNAME, new BookingEvent(id));

Receive Event
Portlet Configuration

For a portlet to receive an event, it needs to specify the following within portlet.xml within its' <portlet> section:


The portlet also needs to specify that it is able to receive an event from the portal by adding the below to portlet.xml within its' <portlet> section:

  <qname xmlns:jbp="urn:jboss:portal:samples:event">jbp:BookingEvent</qname>

As when defining the portlet that can publish an event, the portlet that can receive that event needs to define the link between the qname and event type. The identical <event-definition> specified in Send Event can be used.

Event Handler

To process the Event within a portlet a handler, that was defined within portlet.xml as seen earlier, needs to be created with content similar to the following:

public class BookingEventHandler implements BridgeEventHandler {
  public EventNavigationResult handleEvent(FacesContext context, Event event) {
    // Process event payload as appropriate

Public Render Parameters

Public Render Parameters (or PRPs) are one of the most powerful and simple Portlet 2.0 features. Several portlets (JSF or not) can share the same render parameters. This feature can be use to present a cohesive UI to the user across all portlets on the page (i.e. using an employee ID to display relative data).

Public Render Parameters can only be used to set/retrieve a String value, and not an object as Events can.

Portlet Configuration

The portlet that sets the Public Render Parameter, and also the one receiving it, need the following defined within their portlet.xml:


  <qname xmlns:j="http://jboss.org/params">j:hotelName</qname>

The portlet that will be retrieving the Public Render Parameter also needs to define a handler in the portlet.xml as below:

Set Parameter

Setting the Public Render Parameter only needs a Bean method, most likely called as part of an Action from the UI, that sets the render parameter onto the response, as below:

Object response = FacesContext.getCurrentInstance().getExternalContext().getResponse();
if (response instanceof StateAwareResponse) {
  StateAwareResponse stateResponse = (StateAwareResponse) response;
  stateResponse.setRenderParameter("hotelName", "Name of Hotel");
Retrieve Parameter

The portlet(s) retrieving the parameter will need a Bean with a getter/setter for the parameter so it can be set by the Bridge, such as below:

public class BookingPRP {
  private String hotelName;

  public String getHotelName() {
    return hotelName;

  public void setHotelName(String hotelName) {
    this.hotelName = hotelName;

To set the value on the Bean, the Bridge needs to be informed which Public Render Parameter you want to retrieve and which Bean you want it set on. If the above Bean is defined with a EL name of bookingPRP, then the faces-config.xml would be:


bookingMapPortlet:hotelName as the parameter above needs to represent the name of your portlet (within portlet.xml) and name of the render parameter concatenated with a colon. If the portlet name is omitted and only the render parameter specified, every portlet within the web application that supports that render parameter will have their model updated. Specifying the portlet name as well restricts model updates to just that portlet.

Finally, we need the handler that was specified in the portlet.xml earlier to process the updates to the model as a result of the Public Render Parameter. Below is an example handler:

public class BookingPRPHandler implements BridgePublicRenderParameterHandler {
  public void processUpdates(FacesContext context) {
    ELContext elContext = context.getELContext();
    BookingPRPBean bean = (BookingPRPBean) elContext.getELResolver().getValue(elContext, null, "bookingPRP");

    if(null != bean) {
      System.out.println("******processUpdates from BookingPRPHandler: " + bean.getHotelName());

Portlet Session

It's possible to share data with other portlets, within the same portlet application, using name/value pairs within the PortletSession. Use the following code to set the name/value data:

Object objSession = FacesContext.getCurrentInstance().getExternalContext().getSession(false);
  try {
    if (objSession instanceof PortletSession) {
      PortletSession portalSession = (PortletSession)objSession;
      portalSession.setAttribute("your parameter name", "parameter value", PortletSession.APPLICATION_SCOPE);

A portlet application is defined as being a single Web Archive. All portlets that are part of the same WAR are considered to be within the same portlet application.

Then in your JSP or Facelets page you can retrieve the value using:

#{httpSessionScope['your parameter name']}

For more information about which EL variables are provided by the Bridge, see Provided EL Variables

Resource Serving

When using resources from your JSF portlet it's important to ensure that they are accessed in a way that allows the JBoss Portlet Bridge to generic an appropriate Portal URL to the resource being requested.

The correct way to reference a resource is to locate it within your web application within the resources folder so that it the resource can be retrieved using JSF2 Resource Handling:


stylesheet.css would be present in the root of the resources folder as it does not specify a resource library

Use of #{resource} to retrieve the content is especially import for @import within css files.


Switching Portlet Modes

A PortletMode represents a distinct render path within an application. There are three standard modes: view, edit, and help. The Bridge's ExternalContext.encodeActionURL() recognizes the query string parameter javax.portlet.faces.PortletMode and uses this parameter's value to set the portlet mode on the underlying portlet actionURL or response, but once processed it then removes this parameter from the query string.

The following navigation rule causes one to render the \edit.xhtml viewId in the portlet edit mode:


Portlet Mode's last viewId

By default a mode change will start in the mode's default view without any (prior) existing state. One common portlet pattern when returning to the mode one left after entering another mode (e.g.. view -> edit -> view) is to return to the last view (and state) of this original mode. The Bridge will explicitly encode the necessary information so that when returning to a prior mode it can target the appropriate view and restore the appropriate state. The session attributes maintained by the Bridge are intended to be used by developers to navigate back from a mode to the last location and state of a prior mode, as such a developer needs to describe a dynamic navigation: "from view X return to the last view of mode y". This is most easily expressed via an EL expression, for example:


Linking and Redirects

Linking to Facelets page within same Portlet

When linking to any Facelets page within your portlet web application, you may use the following:

<h:outputLink value="#{facesContext.externalContext.requestContextPath}/home.xhtml">
  <f:param name="javax.portlet.faces.ViewLink" value="true"/>
    navigate to the test page

Redirect to External Page or Resource

To link to a non JSF View (such as jboss.org), you may use the following:

<h:commandLink actionListener="#{yourBean.yourListener}">
  <f:param name="javax.portlet.faces.DirectLink" value="true"/>
    navigate to the test page

With a backing Bean that has the following:

public class YourBean {
  public void yourListener() {

Provided EL Variables

All EL variables found in the JSR-329 (Portlet 2.0) specification are available in the JBoss Portlet Bridge, see below.

EL Object Name



Object of type javax.portlet.PortletConfig


Object of type javax.portlet.ActionRequest (only accessible when processing an ActionRequest)


Object of type javax.portlet.ActionResponse (only accessible when processing an ActionResponse)


Object of type javax.portlet.EventRequest (only accessible when processing an EventRequest)


Object of type javax.portlet.EventResponse (only accessible when processing an EventResponse)


Object of type javax.portlet.RenderRequest (only accessible when processing a RenderRequest)


Object of type javax.portlet.RenderResponse (only accessible when processing a RenderResponse)


Object of type javax.portlet.ResourceRequest (only accessible when processing a ResourceRequest}


Object of type javax.portlet.ResourceResponse (only accessible when processing a ResourceResponse}


Current PortletSession object


Map of PortletSession attributes in PORTLET_SCOPE. JSP Expression returns immutable Map, but Faces Expression returns mutable Map.


Mutable Map of PortletSession attributes in APPLICATION_SCOPE


Current PortletPreferences object


Immutable Map containing entries equivalent to PortletPreferences.getMap()


Mutable Map of type Map<String, javax.portlet.faces.preference.Preference>. This EL variable provides read/write access to each portlet preference.


Excluding Attributes from Bridge Request Scope

When your application uses request attributes on a per request basis and you do not want that particular attribute to be managed in the Bridge Request Scope, you must use the following configuration in your faces-config.xml to have them excluded.


Above you will see that any attribute namespaced as foo.bar or any attribute beginning with foo.baz. will be excluded from the Bridge Request Scope and only be used per that application's request.

JSF Facelet View

When creating a JSF Facelet view document it's common to wrap the content with:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://java.sun.com/jsf/html" xmlns:f="http://java.sun.com/jsf/core"
    xmlns:ui="http://java.sun.com/jsf/facelets" xmlns:a4j="http://richfaces.org/a4j">

As a single portlet only reflects a potentially small portion of the HTML markup for a page, a JSF portlet returning the above markup for each portlet can be distracting and potentially problematic.

The recommended way to wrap the content of a JSF Facelet view document for a portlet is:

<f:view xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://java.sun.com/jsf/html" xmlns:f="http://java.sun.com/jsf/core"
    xmlns:ui="http://java.sun.com/jsf/facelets" xmlns:a4j="http://richfaces.org/a4j">

This results in only the relevant content of the portlet markup being returned to the page.

Although it is not relevant to a portlet, it's important to include <h:head> and <h:body> elements so that JSF can process the Facelet correctly.

JBoss.org Content Archive (Read Only), exported from JBoss Community Documentation Editor at 2020-03-11 12:26:01 UTC, last content change 2012-07-31 19:52:35 UTC.