Friday Feb 20, 2009

XMLPortletRequest in Portlet Container 2.1

XMLPortletRequest is a wrapper over XMLHttpRequest and shares the same syntax and semantics with XMLHttpRequest.

If a portlet wants to update its UI asynchronously through resource URL, it would simply use XMLPortletRequest instead of the XMLHttpRequest.


Here is an example on how to use XMLPortletRequest.

<script type="text/javascript" 
        src="<%=renderRequest.getContextPath()%>/js/XMLPortletRequest.js">
</script>
<script>
    var portletRequest = new XMLPortletRequest("<portlet:namespace/>");
    portletRequest.onreadystatechange = function() {.....}
    portletRequest.open("POST", "<portlet:resourceURL escapeXml='false' />");
    portletReq.send("foo=" + bar);
</script>

Check the XPRInvoiceAjaxPortlet sample(sources and binary) that showcases the usage of XMLPortletRequest. Using XMLPortletRequest drastically reduces the amount of code. Compare the view jsp page of InvoiceAjaxPortlet that does not use XMLPortletRequest with view jsp page of XPRInvoiceAjaxPortlet that uses XMLPortletRequest.

This feature has been added in Portlet Container 2.1. This is available in OpenPortal Portlet Container 2.1, Sun GlassFish Web Space Server 10.0 and Liferay version 5.2 and higher.

OpenPortal Portlet Container 2.1 released

The OpenPortal Portlet Container 2.1 has been released.

The Portlet Container 2.1 is also part of following releases


Why the version is called 2.1 and not 2.0 update 2 ?

Because, this release has lot of changes and is a major release. Following is brief list of changes  that went into this release

  • Major enhancements to support WSRP 2.0 FCS, GlassFish Web Space Server and Liferay version 5.2.
  • New features like XMLPortletRequest.
  • Jar name changes to support the deployment of OpenPortal Portlet Container and GlassFish Web Space Server on the same domain of GlassFish.
  • The third party jars used by the driver have been updated(like commons-fileupload, JSTL and Standard jars)

It is recommended that you uninstall previous versions before installing this release.

Following developer tools are available to develop, deploy and test portlets on the OpenPortal Portlet Container 2.1.

If you have questions on how to use the OpenPortal Portlet Container and other comments/suggestions/requests, we urge you to join the users@portlet-container.dev.java.net alias.

Please report any issues that you encounter while trying OpenPortal Portlet Container to issues@portlet-container.dev.java.net.

Monday Dec 01, 2008

Setting Markup Head Elements in Portlets

JSR 286 (Portlet 2.0 specification) allows the portlet to set HTML elements like <link>, <script>, <meta> in the <head> section of the portal page. This can be achieved via the addProperty method on the RenderResponse with MimeResponse.MARKUP_HEAD_ELEMENT as property name and org.w3c.dom.Element as value.

Following is the code snippet..
import javax.portlet.GenericPortlet;  
import javax.portlet.RenderRequest;  
import javax.portlet.RenderResponse;  
import javax.portlet.MimeResponse;  
import org.w3c.dom.Element;  
public class TestPortlet extends GenericPortlet {  
    @Override
    protected void doHeaders(RenderRequest request, RenderResponse response) {
        Element metaDescription = response.createElement("meta");
        metaDescription.setAttribute("name", "description");
        metaDescription.setAttribute(
              "content", "everything you want to know about stamps");
        response.addProperty(
              MimeResponse.MARKUP_HEAD_ELEMENT, metaDescription);
        Element metaKeywords = response.createElement("meta");
        metaKeywords.setAttribute("name", "keywords");
        metaKeywords.setAttribute("content", "stamps, history");
        response.addProperty(MimeResponse.MARKUP_HEAD_ELEMENT, metaKeywords);
    }
....
}

This feature has been implemented in OpenPortal Portlet Container 2.0 Update 1.

There has been lot of confusion regarding the role of container runtime option (javax.portlet.renderHeaders) while setting the headers. I get the following question a lot:

Is the container runtime option (javax.portlet.renderHeaders) needed if the portlet wants to set headers?

The answer: It depends on whether the portal is a streaming portal or a buffering portal.
First the definition: In case of streaming portal, the output of the portlet is not buffered, while it is buffered in case of buffering portal.
The buffering portal can ignore the container runtime option whereas it is mandatory in case of streaming portal.

In case of OpenPortal Portlet Container, Project WebSynergy which are buffering portals, the container runtime option(javax.portlet.renderHeaders) is not required to be present in the portlet.xml of the portlet that wants to set the headers.

Friday Nov 07, 2008

GlassFish v3 Prelude and Portlet Container 2.0_01

The OpenPortal Portlet Container 2.0 Update 1 runs on GlassFish v3 Prelude

Set ANT_HOME and use CLI to install as follows (there is an issue with GUI install)

java -jar portlet-container-configurator.jar glassfishv3-prelude\\glassfish glassfishv3-prelude\\glassfish\\domains\\domain1

Note: the glassfish home is glassfishv3-prelude\\glassfish

Please report any issues that you encounter to users@portlet-container.dev.java.net.


Friday Oct 31, 2008

OpenPortal Portlet Container 2.0_01 released

The OpenPortal Portlet Container 2.0 Update 1(2.0_01) has been released.

The OpenPortal Portlet Container 2.0_01 is also part of Java Application Platform SDK Update 6.

This release has some important fixes and enhancements to support WSRP Beta and Liferay integration. The changelog contains issues resolved. It is recommended that you uninstall previous versions before installing this release.

Following developer tools are available to develop, deploy and test portlets on the Portlet Container 2.0_01.

If you have questions on how to use the OpenPortal Portlet Container and other comments/suggestions/requests, we urge you to join the users@portlet-container.dev.java.net alias.

Please report any issues that you encounter while trying OpenPortal Portlet Container to issues@portlet-container.dev.java.net.

Tuesday Jul 22, 2008

Article in TheServerSide.com uses OpenPortal Portlet Container

Recently one of colleagues came across an article the TheServerSide.com that explains the "Action Scoped Request attributes" container runtime option. The article uses OpenPortal Portlet Container to explain the feature.

My colleague in his blog talks about this and also why he likes OpenPortal Portlet Container.

Tuesday Jun 24, 2008

Open Portal Portlet Container 2.0 released

OpenPortal Portlet Container 2.0 has been released.

The release is a fully compliant implementation of the Portlet 2.0 (JSR286) specification, which was released last week. It is recommended that you uninstall previous versions before installing this release.

The SDN article describes the new features along with samples.

Netbeans Portlet Pack 2.0 is available that helps developers to develop, deploy and test portlets on the Portlet Container 2.0.

If you have questions on how to use the OpenPortal Portlet Container and other comments/suggestions/requests, we urge you to join the users@portlet-container.dev.java.net alias.

Please report any issues that you encounter while trying OpenPortal Portlet Container to issues@portlet-container.dev.java.net.

Monday Feb 11, 2008

JSR286 : Public Render Parameter feature (updated)

When the Java Portlet Specification(JSR 286) early draft was released last year, i had written a blog on Public Render Parameter feature. Recently the proposed final draft was released, it has some changes in public render parameter feature. In this blog i will explain the feature with an example.

In JSR 168, the render parameters set in processAction is only available in the render of the same portlet.

With the Public Render Parameters feature, the render parameters set in the processAction of one portlet will be available in render of other portlets also. Using public render parameters instead of events avoids the additional process event call.

In order to allow coordination of render parameters with other portlets, within the same portlet application or across portlet applications, the portlet can declare public render parameters in its deployment descriptor using the public-render-parameter element in the portlet application section. Public render parameters can be viewed and changed by other portlets or components.

In the portlet section each portlet can specify the public render parameters it would like to share via the supported-public-render-parameter element. The supported-public-render-parameter element must reference the identifier of a public render parameter defined in the portlet application section in a public-render-parameter element.

In the code, the portlets should use the defined public render parameter identifier to access the public render parameter(new addition in the proposed final draft).

To create portlets that use the public render parameters, follow these steps(snippets from WeatherMap sample application):

1. Declare the render parameters to be shared in the portlet.xml file by setting the public render parameters at the portlet application level.

      <portlet-app xmlns="http://java.sun.com/xml/ns/portlet/portlet-app_2_0.xsd"             
                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"             
                   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"
                   id="myPortletApp" version="2.0">
        <portlet>
         . . .
        </portlet>
                      
        <public-render-parameter>
          <identifier>zip-id</identifier>
          <qname xmlns:x="http://sun.com/params">x:zip</qname>
        </public-render-parameter>

      </portlet-app>

       
2. Specify the render parameter that the portlet would like to share in the portlet section.

      <portlet-app xmlns="http://java.sun.com/xml/ns/portlet/portlet-app_2_0.xsd"             
                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"             
                   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"
                   id="myPortletApp" version="2.0">
      <portlet>
         <description>WeatherPortlet</description>
         <portlet-name>WeatherPortlet</portlet-name>
         <display-name>WeatherPortlet</display-name>
         <portlet-class>com.sun.portal.portlet.WeatherPortlet</portlet-class>
         ......               
         <supported-public-render-parameter>zip-id</supported-public-
         render-parameter>
      </portlet>

      <portlet>
         <description>MapPortlet</description>
         <portlet-name>MapPortlet</portlet-name>
         <display-name>MapPortlet</display-name>
         <portlet-class>com.sun.portal.portlet.MapPortlet</portlet-class>
          . . .
         <supported-public-render-parameter>zip-id</supported-public-
         render-parameter>
      </portlet>
          .  . .
      </portlet-app>

       
3. Set the render parameter in the processAction() method:

      public class WeatherPortlet extends GenericPortlet {
           . . .
         public void processAction(ActionRequest req, ActionResponse res)
         throws IOException, PortletException {
          . . .
                 res.setRenderParameter("zip-id", zip);
           }
           . . .
      }

You can download the binary WeatherMap.war file to deploy and run the sample application in OpenPortal Portlet Container 2.0 Beta2 (or latest). You can also get the source for the sample. If you are behind a firewall you need need to set the proxy in the webcontainer configuration.

The figure shows the Weather and Map portlets. The Weather portlet sets the zip-id which is declared as a Public Render Parameter. This parameter is supported by both Weather and Map portlets. Any change in the value of zip by Weather portlet is reflected during the render phase of both weather and map portlets.

Weather Map Sample 

Tuesday Jan 08, 2008

Portlet Container 2.0 Beta2 released

The OpenPortal Portlet Container 2.0 Beta2 has been released. This release is based on JSR 286 proposed final draft. This release contains following features and enhancements..

  • Eventing
  • Public Render Parameters
  • Resource Serving
  • Portlet Filters
  • Validation based caching
  • Request Dispatcher Include from all lifecycle
  • Request Dispatcher Forward from all lifecycle
  • Container Runtime Options that includes escapeXml and actionScopedRequestAttributes
  • Taglibrary enhancements

Netbeans Portlet Pack 2.0 Beta2 is available that helps developers to develop, deploy and test portlets on the Portlet Container 2.0 Beta2.

Thursday Sep 20, 2007

Portlet Container 2.0 beta is now available in the new Java Application Platform SDK Update 3 beta

The Java Portlet Specification, 2.0 (JSR 286) adds new features like events, public render parameters, resource serving, and portlet filtering.

Portlet Container 2.0 Beta that is part Java Application Platform SDK Update 3 beta provides a preview of these new features as defined in the JSR 286 Public Draft 1.

Link to resources and docs for Portlet Container 2.0 Beta Component

The Java Application Platform SDK Update 3 Beta also includes Web Services for Remote Portlets (WSRP) 1.0 Beta.

Netbeans Portlet Pack 2.0 Beta is available that helps developers to develop, deploy and test portlets on the Portlet Container 2.0 Beta.

 

Friday Aug 24, 2007

OpenPortal Portlet Container 1.0 Update 1 has been released

We've released the OpenPortal Portlet Container 1.0 Update 1 (1.0_01).

The changelog contains issues resolved.

If you find any issues or have any feedback, etc., please let us know!

Thursday Aug 16, 2007

JSR 286 : Public Render Parameters feature

I had written this blog when the early draft of JSR 286 was released. Recently the proposed final draft was released, it has some changes in public render parameter feature. I have written a new blog to explain this feature with an example. 

In order to provide coordination between portlets the Java Portlet Specification, JSR 286 introduces the following mechanisms

  • Eventing: portlet events that a portlet can receive and send
  • Public Render Parameters: render state that can be shared between portlets

In my previous blog, i explained Eventing feature and in this blog will explain the Public Render Parameter feature.

In JSR 168, the render parameters set in processAction is only available in the render of the same portlet.

With the Public Render Parameters feature, the render parameters set in the processAction of one portlet will be available in render of other portlets also. Using public render parameters instead of events avoids the additional process event call.

In order to allow coordination of render parameters with other portlets, within the same portlet application or across portlet applications, the portlet can declare public render parameters in its deployment descriptor using the public-render-parameter element in the portlet application section. Public render parameters can be viewed and changed by other portlets or components.

In the portlet section each portlet can specify the public render parameters it would like to share via the supported-public-render-parameter element. The supported-public-render-parameter element must reference the identifier of a public render parameter defined in the portlet application section in a public-render-parameter element.

How it works..
Consider the following example..

Declare the render parameters to be shared in the portlet.xml
    1. Set the public render parameters at the portlet application level.
    <portlet-app .....>
        <public-render-parameter>
            <identifier>id1</identifier>
            <qname xmlns:x="http://sun.com/params">x:param1</qname>
        </public-render-parameter>
        <public-render-parameter>
            <identifier>id2</identifier>
            <qname xmlns:x="http://sun.com/params">x:param2</qname>
        </public-render-parameter>

    2. Specify the render parameter the portlet would like to share in the portlet section.
    <portlet>
        ...............
            <portlet-name>PortletA</portlet-name>
        ...............
             <supported-public-render-parameter>id1</supported-public-render-parameter>
             <supported-public-render-parameter>id2</supported-public-render-parameter>
        ...............
    <portlet>
    <portlet>
        ...............
            <portlet-name>PortletB</portlet-name>
        ...............
             <supported-public-render-parameter>id1</supported-public-render-parameter>
        ...............
    <portlet>
    <portlet>
        ...............
            <portlet-name>PortletC</portlet-name>
        ...............
             <supported-public-render-parameter>id2</supported-public-render-parameter>
        ...............
    <portlet>


   
1. If portletA sets the render parameter param1, portletB receives it but not portletC
2. If portletA sets the render parameter param2, portletC receives it but not portletB
3. If portletB sets the render parameter param1, portletA receives it but not portletC
4. If portletC sets the render parameter param2, portletA receives it but not portletB

You can checkout the sources from OpenPortal Portlet Container that has the implementation of the public render parameter feature. Write portlets that uses this feature and try it.

Thursday Aug 09, 2007

JSR 286 : The Eventing feature

In order to provide coordination between portlets the Java Portlet Specification, JSR 286 introduces the  following mechanisms

  • Eventing: portlet events that a portlet can receive and send
  • Public Render Parameters: render state that can be shared between portlets

In this blog, i will explain the Eventing feature and in a later blog i will explain the Public Render Parameter feature.

Eventing can be described as a loosely coupled, brokered means of communication between portlets. It is intended to allow portlets to react on actions or state changes not directly related to an interaction of the user with the portlet.
Events are a lifecycle operation that occurs before the rendering phase.


Now let us get into the details of writing portlets that use this feature

The portlet can declare the events in its deployment descriptor using the event-definition element in the portlet application section. In the portlet section each portlet can specify the events it would like to publish via the supported-publishing-event element and the events it would like to process via the supported-processing-event element. The supported-publishing-event and supported-processing-event element must reference the event name defined in the portlet application section in a event-definition element.

The portlet issues events via the setEvent method during the action processing. This will be processed by the portlet container after the action processing has finished.

In order to receive events the portlet must implement the javax.portlet.EventPortlet interface. The portlet container will call the processEvent method for each event targeted to the portlet with an EventRequest and EventResponse object.
The portlet can access the event that triggered the current process event call by using the EventRequest.getEvent method. This method returns an object of type Event encapsulating the current event name and value.

Event names are represented as QNames in order to make them uniquely identifiable. The event name can be either retrieved with the getQName method that returns the complete QName of the event, or with the getName method that only returns the local part of the event name. The value of the event must be based on the type defined in the deployment descriptor.

Following are the steps to write portlets that make use of eventing feature

1.Declare the events in the portlet.xml
    1.1 Set the event definition at the portlet application level. This specifies the event name and the object type.
          Note: The object must be serializable.
    <portlet-app .....>
        <event-definition>
        <qname xmlns:x="http:sun.com/events">
            x:Address.Create
        </qname>
        <value-type>com.test.Address</value-type>
        </event-definition>

    1.2 In the portlet section, specify the event name defined above for those portlets that want to publish this event.
        <portlet>
            .................
            <supported-publishing-event xmlns:x="http:sun.com/events">
                    x:Address.Create
            </supported-publishing-event>

    1.3 In the portlet section, specify the event name defined above for those portlets that want to process this event.
        <portlet>
            .................
           <supported-processing-event xmlns:x="http:sun.com/events">
                  x:Address.Create
           </supported-processing-event>

    
2.Issue an event in the portlet that was specified as supported-publishing-event in the portlet
    @XmlRootElement
    public class Address implements Serializable
    {
        private String street;
        private String city;
        public void setStreet(String s) {street = s;}
        public String getStreet() { return street;}
        public void setCity(String c) { city = c;}
        public String getCity() { return city;}
    }

    void processAction(ActionRequest request, ActionResponse response)
    {
        String myStreet = request.getParameter("street");
        String myCity = request.getParameter("city");
        Address sampleAddress = new Address();
        sampleAddress.setStreet(myStreet);
        sampleAddress.setCity(myCity);
        QName name = new QName("http:sun.com/events", "Address.Create");
        response.setEvent(name, sampleAddress);
    }     

3.Process the event in the portlet that has specified as supported-processing-event in the portlet
    void processEvent(EventRequest request, EventResponse response)
    {
        Event event = request.getEvent();
        if ( event.getName().equals("Address.Create") )
        {
            Address payload = (Address) event.getValue();
            .......
        }
    }

You can checkout the sources from OpenPortal Portlet Container that has the implementation of the eventing feature. Write a portlet that uses the eventing feature and try it.

 

Friday Jul 20, 2007

JSF Portlet Bridge in Maven Repository

We now have the JSF Portlet Bridge jars available on the java.net maven2 repository.

Put this in your pom.xml

Under <repositories>

        <repository>
            <id>maven2-repository.dev.java.net</id>
            <name>Java.net Repository for Maven</name>
            <url>https://maven2-repository.dev.java.net/nonav/repository</url>
        </repository>       

Under <dependencies>

      <dependency>
            <groupId>com.sun.faces.portlet</groupId>
            <artifactId>jsf-portlet</artifactId>
            <version>1.2.1</version>
            <scope>compile</scope>
        </dependency> 

The current versions are 1.2.1 and 1.1.5

Whenever the new version is available in JSF Portlet Bridge project site it will also be available via maven2 repository

Wednesday Jul 11, 2007

JSF Portlet Bridge 1.2.1 and 1.1.5 released

We've released the JSF Portlet Bridge 1.2.1 and 1.1.5.

The changelog contains issues resolved as well as any new features added.

If you find any issues or have any feedback for features, etc., please let us know!

To know more about JSF Portlet Bridge you can check the article JavaServer Faces Technology-Based Portlet Bridge
About

Deepak Gothe

Search

Categories
Archives
« April 2014
SunMonTueWedThuFriSat
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
   
       
Today