//define log for this class
  private static final Log _log = LogFactoryUtil.getLog(RenderURLByJavaScriptPortlet.class.getName());

  @Override
  public void render(RenderRequest request, RenderResponse response)
  throws PortletException, IOException {
   _log.info(" This is render method of RenderURLByJavaScriptPortlet");
  
    String data = request.getParameter("param");
    String data1= ParamUtil.getString(request, "param","");
    System.out.println("parameter with request.getParameter is =>"+data);
    System.out.println("parameter with ParamUtil.getString is =>"+data1);
   
   super.render(request, response);
  }

• We are simply reading request parameter and displaying it in logger. 

<%@page import="com.liferay.portal.kernel.portlet.LiferayWindowState"%>
<%@page import="com.liferay.portal.kernel.portlet.LiferayPortletMode"%>
<%@ taglib uri="http://java.sun.com/portlet_2_0" prefix="portlet" %>
<%@ taglib uri="http://liferay.com/tld/aui" prefix="aui" %>
<%@ taglib uri="http://liferay.com/tld/theme" prefix="liferay-theme" %>

<liferay-theme:defineObjects/>
<portlet:defineObjects />

<a id="renderURLWithJS" href=""> This render URL link is created with Javascript</a>
 
<aui:script>
 AUI().use('liferay-portlet-url', function(A) {
  var renderUrl1 = Liferay.PortletURL.createRenderURL();
  renderUrl1.setWindowState("<%=LiferayWindowState.NORMAL.toString() %>");
  renderUrl1.setParameter("param","This value comes from Javascript");
  renderUrl1.setPortletMode("<%=LiferayPortletMode.VIEW %>");
  renderUrl1.setPortletId("<%=themeDisplay.getPortletDisplay().getId() %>");
 
  A.one("#renderURLWithJS").set('href',renderUrl1.toString());
  alert("renderUrl1 is ->"+renderUrl1.toString());
});
</aui:script>

• First few lines are imports and taglib definition.
• portlet and liferay-theme taglibs are defined to place <liferay-theme:defineObjects/> and <portlet:defineObjects/> tags. These tags are used to make portlet implicit and liferay implicit objects available in JSP respectively.
• aui taglib is used to define <aui:script> tag, were we placed AUI code.
• Next we added a new link. Note that we intentionally keep href blank at this moment. We will construct render URL and then assign to href with JavaScript during page load.
• We have used <aui:script> tag to place all AUI code. This tag internally create <script> tag and make AUI core modules ( like node) ready to use.
• In <aui:script>, the code is written like AUI().use('liferay-portlet-url', function(A) {
• AUI is modular framework. To use specific module, it needs to register by declaring it in AUI().use method. More than one modules can be declared by comma separate in AUI().use.
• In our case, liferay-portlet-url module is used to create render URL so we have registered it. 
• in callback function(A), we have created render URL with following JS code.
• var renderUrl1 = Liferay.PortletURL.createRenderURL();
• Javascript variable Liferay.PortletURL provides various methods to create different kind of portletURL. Here we need to create render URL so we called createRenderURL() method.
• then we set window state and portlet mode to this render URL. Any additional parameter can be passed by calling setParameter method.
• at the end, we set this render URL to href by following code
• A.one("#renderURLWithJS").set('href',renderUrl1.toString());
• A in AUI is a placeholder to apply selector. its similar like $ in JQuery.
• We passed #renderURLWithJs (id of link) to A.one and then set its href value to generated render URL by renderUrl1.toString();
• Just debug purpose, I kept alert at the last.
• We also can create render URL to point different portlet by setting its portletId in generated render URL(in setPortletId method). 
• In this render URL, we have passed current portlet's Id by calling themeDisplay.getPortletDisplay.getId() which returns current portlet's Id. themeDisplay is liferay implicit object which is available by adding <liferay-theme:defineObjects/> tag.

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

<portlet:renderURL var="renderUrl" 
 windowState="<%=LiferayWindowState.NORMAL.toString() %>" copyCurrentRenderParameters="true" portletMode="<%=LiferayPortletMode.VIEW.toString()%>">
 <portlet:param name="param" value="Nilang"/>
</portlet:renderURL>

<a href="${renderUrl}">RenderURL Created by Portlet Tag</a>

• <portlet:renderURL> tag is used to create render URL. This render URL is pointing to portlet in which its created (same portlet).
• var attribute of <portlet:renderURL> tag is used to define a variable that holds the generated renderURL. This variable is available in page scope so that it can be accessed by EL (Expression Language) anywhere in JSP.
• In above case, renderUrl variable holds generated renderURL.
• windowState represents current state of portlet. following are possible window state
• Maximize,Minimize, Normal,POP_UP
• PortletMode represents current portlet mode. 
• Following are possible portlet modes
• Modes defined by portlet specification and provided by default implementation (portlet.jar)
• View,Edit,Help
• Additional modes provided by Liferay.
• Configuration,About,Edit_Default,Edit_Guest,Preview,Print
• copyCurrentRenderParameters :- This attribute decide if all render parameters are available in complete request cycle. By default its false. This is more understandable for action URL.
• Additional parameters can be passed with <portlet:param> tag. Such parameters are accessible by renderRequest.getParameter API in portlet's render method.
• At the end, we have created link by anchor tag and set its href to renderUrl variable ( created by <portlet:renderURL> tag which holds renderURL ) through EL(Expression Language). 
• You need to add following import in view.jsp

<%@page import="com.liferay.portal.kernel.portlet.LiferayPortletMode"%>
<%@page import="com.liferay.portal.kernel.portlet.LiferayWindowState"%>

//define log for this class
private static final Log _log = LogFactoryUtil.getLog(RenderURLByPortletTagPortlet.class.getName());

 @Override
 public void render(RenderRequest request, RenderResponse response)
   throws PortletException, IOException {
  _log.info(" This is render method of RenderURLByPortletTagPortlet");
  String data = request.getParameter("param");
  String data1= ParamUtil.getString(request, "param","");
  _log.info("parameter with request.getParameter is =>"+data);
  _log.info("parameter with ParamUtil.getString is =>"+data1);
  super.render(request, response);
 }

• On refreshing this page, we will get following logs in server console

parameter with request.getParameter is =>null
parameter with ParamUtil.getString is =>

• During the page refresh, render() method is called directly. At this time, there are no parameters passed so we will not get any parameters. 
• You can observe that request.getParameter method returns null in case the parameter is not exist while ParamUtil.getString method simply returns empty string (Default value ""). 
• ParamUtil.getString method will make developer life easy by protecting us from NullPointerException if parameter is not exist and we try to perform any operation on that.
• Now click the link shown above and you will get below logs in server console.

parameter with request.getParameter is =>Nilang
parameter with ParamUtil.getString is =>Nilang

• This time, render() method is called by renderURL so we are getting value of additional parameter in console. 
• By inspecting element in browser, you will get follwing renderURL 
• http://localhost:8080/web/guest/test?p_p_id=renderURLbyportletTag_WAR_renderURLbyportlet&p_p_lifecycle=0&p_p_state=normal&p_p_mode=view&p_p_col_id=column-1&p_p_col_count=1&_renderURLbyportletTag_WAR_renderURLbyportlet_param=Nilang 
• Explanation:- 
• p_p_id = unique portlet Id generated by portal. This is the key used to identify which renderURL points to which portlet. 
• p_p_lifecycle= Represent current Lifecycle of portlet. Following are possible lifecycles 
• 0 - render phase 
• 1 - action phase 
• 2 - serve resource phase 
• We are currently in render phase so its showing 0. 
• p_p_state= Represent current window state of portlet. 
• p_p_mode= Represents current mode of portlets. 
• p_p_col_id= Represent in which column this portlets is placed. In liferay we can define multi column layout. This parameter helps to find exact column on which this portlet is placed. 
• p_p_col_count= Represents total columns count for layout of current page on which the portlet is placed. 
• _portletphaselifecycle_WAR_portletphaselifecycleportlet_param1= This is the additional parameter name (param) that we have added while creating renderURL(through tag). You can observe that portlet namespace (p_p_id) is attached before each parameter name. This is useful if more than one portlets are placed on same page with same parameter name. In this case they all are uniquely identified with portlet name space attached before parameter name (Each portlet will have unique name space).

• renderURL can be created by portlet Tag. This tag is comes with implementation (portlet.jar) of portlet specification. 
• We can set portlet mode and window state while creating renderURL 
• We can pass additional parameter by <portlet:param> child tag inside <portlet:renderURL> 
• renderURL created by <portlet:renderURL> tag is only pointing to portlet that creates it.

In this article, we will see how to create render URL by liferay tag (< liferay-portlet:renderURL>). This tag works similarly with the one we created render URL by PortletURLFactoryUtil class. You can refer separate blog on how to create render URL with PortletURLFactoryUtil class.

First of all, we will create LiferayMVC portlet. You can refer separate blog on Creating MVC Portlet in Liferay to create project structure as per below screenshot.

I gave plugin project name as renderURL-by-LiferayTag and -portlet will be appended by Liferay IDE while creating Liferay plugin project. I gave portlet class as com.opensource.techblog.portlet.RenderURLByLiferayTagPortlet

Add following code in RenderURLByLiferayTagPortlet class.

//define log for this class
private static final Log _log = LogFactoryUtil.getLog(RenderURLByLiferayTagPortlet.class.getName());
 @Override
 public void render(RenderRequest request, RenderResponse response)
 throws PortletException, IOException {
  _log.info(" This is render method of RenderURLByLiferayTagPortlet");
 
   String data = request.getParameter("param");
   String data1= ParamUtil.getString(request, "param","");
   System.out.println("parameter with request.getParameter is =>"+data);
   System.out.println("parameter with ParamUtil.getString is =>"+data1);
   
  super.render(request, response);
 }

Explanation:-

• We are simply reading request parameter and displaying it in logger. 

We will pass this parameter while creating render URL with Liferay Tag. We will add liferay tag in view.jsp. Next step is to add following code in view.jsp

<%@ taglib uri="http://liferay.com/tld/portlet" prefix="liferay-portlet" %>
<liferay-portlet:renderURL var="openPortletURL" copyCurrentRenderParameters="true" portletMode="<%=LiferayPortletMode.VIEW.toString() %>" 
  windowState="<%=LiferayWindowState.NORMAL.toString()%>">
  <liferay-portlet:param name="param" value="This is from Liferay TAG"/>
</liferay-portlet:renderURL>
 
<a href="${openPortletURL}">Render Url created by Liferay TAG in JSP</a>

• <liferay-portlet:renderURL> tag is used to create render URL. 
• To avail this tag, we have added <%@ taglib uri="http://liferay.com/tld/portlet" prefix="liferay-portlet" %> taglib definition in this jsp.
• attribute of this tag is similar with <portlet:renderURL>. You can refer my blog on creating render URL with Portlet tag (<portlet:renderURL>).The only difference between these two tags are
• Render URL created with <portlet:renderURL> can point to current portlet only.
• Render URL created with <liferay-portlet:renderURL> can point to other portlet too. For this we need to give plid and portletName attribute for target portlet. 
• If we are not providing these attribute to <liferay-portlet:renderURL> tag then it will create render URL which point to current portlet only.
• We can set window state and portlet mode similarly <portlet:renderURL>
• We can also pass additional parameter with <liferay-portlet:param> tag similarly <portlet:param> tag.
• var attribute is used to hold this render URL so that we can refer it anywhere in JSP.
• At the end we created new link and set its href with variable (var attribute defined in <liferay-portlet:param> tag) which holds render URL.

• Render Phase
• Action Phase

• init() 
• Called when portlet is deployed. 
• render() 
• Called to render the content. Represent Render phase 
• processAction() 
• Called when any action performed. 
• processEvent() 
• Called when any event is triggered. 
• serveResource() 
• Called when any resource is served with resource URL. 
• destroy() 
• Called when portlet is un-deployed.

These lifecycle methods are managed by Portlet Container. Portlet container is responsible for 

• Loading class of portlet 
• Creating and maintaining the portlet instance 
• Initializing the Portlet 
• Submitting user request to portlet instance 
• Destroying portlet instance when it is undeployed.

If you are familiar with servlet, you can easily understand portlet by correlate lifecycle methods of portlet and servlet. 

Below diagram describes the lifecycle methods of servlet and portlet.

• There is no direct relation between lifecycle methods of portlet and servet.
• This diagram is just to understand lifecycle methods side by side. 
• For both Portlet and Servlet, init() and destroy() methods are called by respective container (Portlet and Servlet container). 
• In case of Servlet, all requests are served by service() method 
• In case of Portlet, user requests are served by different methods like render(), processAction(), processEvent() and serveResource() based on portlet's current phase. 

Explanation of Portlet's Lifecycle methods :-

I have given explanation of each Lifecycle methods in separate blog. Follow below blogs to get detail understanding of each lifecylce method.

Portlet Lifecycle method - init()
Portlet Lifecycle method - render()
Portlet Lifecycle method - processAction() - Available soon
Portlet Lifecycle method - processEvent() - Available soon
Portlet Lifecycle method - serveResource() - Available soon

• GenericPortlet implements Portlet interface. 
• LiferayPortlet extends GenericPortlet and provides additional methods. 
• MVCPortlet is defined by Liferay. It extends LiferayPortlet and provides MVC architecture by providing more additional methods. 
• PhaseAndLifecyclePortlet (our custom portlet) extends MVCPorrtlet.

To understand how init() method works, we will override it in our custom portlet. There are two version of init() methods available in Liferay portlet class hierarchy.

init() method available in MVCPortlet

• Signature:- public void init() throws PortletException
• This method having no parameter. 

init() method available in GenericPortlet

• Signature :- public void init(PortletConfig config) throws PortletException
• This method take PortletConfig as parameter. 
• PortletConfig object is used to read portlet configuration (defined in portlet.xml). 
• One of the common use of PortletConig object is to read initialization parameter defined in portlet.xml.
• PortletConfig is similar to ServletConfig (which is used to read servlet configuration from web.xml).

After Overriding above init() methods (both), our portlet class will look like below code snipped.

package com.opensource.techblog.portlet;

import javax.portlet.PortletConfig;
import javax.portlet.PortletException;

import com.liferay.portal.kernel.log.Log;
import com.liferay.portal.kernel.log.LogFactoryUtil;
import com.liferay.util.bridges.mvc.MVCPortlet;

public class PhaseAndLifecyclePortlet extends MVCPortlet {

 //define log for this class
 private static final Log _log = LogFactoryUtil.getLog(PhaseAndLifecyclePortlet.class.getName());
 
 //This method is defined in MVCPortlet
 @Override
 public void init() throws PortletException {
  _log.info(" This is init method without parameter");
  super.init();
 }

 //This method is defined in GenericPortlet
 @Override
 public void init(PortletConfig config) throws PortletException {
  String viewTemplate = config.getInitParameter("view-template");
  _log.info("Init Parameter of viewTemplatei is ==>"+viewTemplate);
  _log.info(" This is init method with PortletConfig parameter");
  super.init(config);
 }
}

Explanation:-

• LogFactoryUtil is util class provided by liferay to get log for current class.
• We have overridden both version of init() method. Added info logs in each method which will be display in server console when this portlet is deployed.
• In second version of init() method, we are reading initialization parameter called 'view-template' and putting into log. 'view-template' init parameter is defined in portlet.xml file and used to define the path of jsp which will render portlet's output.

After doing this change, deploy the porltet. Make sure server is up and running. During the Portlet deployment, portlet container will call init() method and you will see below logs in server console.

• As you can see during the deployment of this portlet, init() method overridden from GenericPortlet is called first followed by init() method overridden from MVCPortlet.
• This is because GenericPortlet is located at higher position than LiferayMVCPortlet in class hierarchy.
• Logs also shows the initialization parameter's(view-template) value (/view.jsp) which is defined in portlet.xml file. We can read all initialization parameter in init() method.

Place this portlet on some liferay page. On refreshing this page, init() methods is not called again. It is only called when portlet is instantiate by portlet container (during deployment on the server). Means every time when we deploy the portlet, it's init() method is called

Download Source

I would recommend looking at index page 'A Complete Liferay Guide' to browse all topics about liferay.