Passing Information from the Action Phase to the Render Phase Phase

There are two ways to pass information from the action phase to the render phase. The first way is through render parameters. In the processAction method you can invoke the

setRenderParameter method to add a new parameter to the request. The render phase can read this:

actionResponse.setRenderParameter("parameter-name", "value");

From the render phase (in our case, the JSP), this value is read like this:

renderRequest.getParameter("parameter-name");

It's important to be aware that when invoking an action URL, the parameters specified in the URL are only readable from the action phase (that is within the processAction method). In order to pass parameter values to the render phase you must read them from the

actionRequest and then invoke the setRenderParameter method for each parameter needed.

Tip: Liferay offers a convenient extension to the portlet specification through the MVCPortlet class to copy all action parameters directly as render parameters. You can achieve this by setting the following init-param in your portlet.xml:

<init-param>

Liferay 6.2 Developer Guide Page 113

<name>copy-request-parameters</name>

<value>true</value>

</init-param>

One final note about render parameters: the portal remembers them for all later executions of the portlet until the portlet is invoked with different parameters. That is, if a user clicks a link in our portlet and a render parameter is set, and then the user continues browsing through other portlets on the page, each time the page is reloaded, the portal renders our portlet using the render parameters that we initially set. If we used render parameters in our example, then the success message will be shown not only right after saving, but also every time the portlet is rendered until the portlet is invoked again without that render parameter.

The second way of passing information from the action phase to the render phase is not unique to portlets, so it might be familiar to you--using the session. Your code can set an attribute in the actionRequest that is then read from the JSP. In our case, the JSP would also immediately remove the attribute from the session so the message is only shown once. Liferay provides a helper class and taglib to do this operation easily. In the processAction method, you need to use the SessionMessages class:

package com.liferay.samples;

public class MyGreetingPortlet extends MVCPortlet { @Override

public void processAction(

ActionRequest actionRequest, ActionResponse actionResponse) throws IOException, PortletException {

PortletPreferences prefs = actionRequest.getPreferences();

String greeting = actionRequest.getParameter("greeting");

if (greeting != null) {

prefs.setValue("greeting", greeting);

prefs.store();

}

SessionMessages.add(actionRequest, "success");

super.processAction(actionRequest, actionResponse);

} }

Next, in view.jsp, add the liferay-ui:success JSP tag and add the taglib declarations below:

<%@ taglib uri="http://java.sun.com/portlet_2_0" prefix="portlet" %>

<%@ taglib uri="http://liferay.com/tld/ui" prefix="liferay-ui" %>

Liferay 6.2 Developer Guide Page 114

<%@ page import="javax.portlet.PortletPreferences" %>

<portlet:defineObjects />

<liferay-ui:success key="success" message="Greeting saved successfully!"

/>

<% PortletPreferences prefs = renderRequest.getPreferences(); String greeting = (String)prefs.getValue(

"greeting", "Hello! Welcome to our portal."); %>

<p><%= greeting %></p>

<portlet:renderURL var="editGreetingURL">

<portlet:param name="mvcPath" value="/edit.jsp" />

</portlet:renderURL>

<p><a href="<%= editGreetingURL %>">Edit greeting</a></p>

After this change, redeploy the portlet, go to the edit screen, edit the greeting, and save it. You should see a nice message that looks like this:

There's also an equivalent utility class for error notification. You can add the liferay-ui:error tag to your view.jsp after the liferay-ui:success tag:

<liferay-ui:error

key="error" message="Sorry, an error prevented saving your greeting" />

This error utility is commonly used after catching an exception in the processAction method. For

SessionErrors.add(actionRequest, "error");

}

Your view.jsp shows the error message in your portlet, if an error occurs while processing the action request.

Liferay 6.2 Developer Guide Page 115 The first message is

automatically added by Liferay.

The second one is the one you added in your JSP. You've successfully created and rendered your portlet's error message. Terrific!

Have you ever wondered how Liferay Portal determines which portlet to associate with a request parameter--especially when the portal receives multiple parameters, with the same name, coming from different portlets? Each of Liferay's core portlets namespaces its request parameters, so that Liferay can distinguish them from other request parameters. And you can leverage namespacing in your portlets, too. Let's discuss portlet namespacing and how to turn on/off the portal's namespacing logic for a portlet.

3.5.1. Using Portlet Namespacing

Namespacing ensures that a given portlet's name is uniquely associated with elements in request parameters it sends to the portal. This prevents name conflicts with other elements on the portal page and with elements from other portlets on the page. Namespacing your portlet elements is easy. Simply use the <portlet:namespace /> tag to produce a unique value for your portlet's elements. The following example code uses the <portlet:namespace /> tag to reference the portlet's fm form during submission:

submitForm(document.<portlet:namespace />fm);

To illustrate the benefits of namespacing an element, such as the fm form from the example code above, suppose you have portlets named A and B in your portal and they both have a form named fm. Without portlet namespacing, the portal would be unable to differentiate between the two forms and, likewise, would be unable to determine their associated portlets. But, submitting both portlet A's form and portlet B's form as <portlet:namespace />fm would distinguish the forms as *_Afm* and *_Bfm*, respectively. Liferay associates each namespaced element, such as these namespaced forms, with the portlet that produced it.

By default, Liferay only allows namespaced parameters to access portlets. However, many third-party portlets send unnamespaced parameters. Therefore, Liferay gives you the option to turn off the unnamespaced parameters filter for portlets, to avoid third-party portlets from breaking. To turn the filter off for a portlet, navigate to the portlet's liferay-portlet.xml file and enter the following tag:

<requires-namespaced-parameters>false</requires-namespaced-parameters>

Turning this filter off is on a per portlet basis, so you'll need to set the <requires-namespaced-parameters/> tag to false for every third-party portlet that sends unnamespaced parameters.

Liferay 6.2 Developer Guide Page 116 Interested in developing your custom portlet with multiple actions? Then you'll definitely want to check out the next section!