Portlet
is small fragment of dynamic content in the web page. And this
dynamic content may be text,HTML,xml or some other MIME format.
Portlet technology implemented by JSR 168 and JSR 286 standards.
Generally
in web application we are very familiar with servlet technology and
portlet technology is similar to servlet technology but it consist
its own features. servlet technology based on client and server
architecture in the web world here the client is browser.
Portlets
life cycle is managed by portlet containers these are in application
servers. portlet life cycle consist different stages like
instantiation,serving and destroying. Portlet containers are similar
to servlet containers to manage entire life cycle of portlet.
Generally in the portlet technology each page consist one or more portlets and each portlet render dynamic content to make complete web page.
In
technical understand portlet technology implemented in Java in the
package javax.portlet.
This
portlet API consist many interfaces and implementation classes to
developed portlet based application in the web world.
How
does portlets are differed from servlet
Generally
in servlet web application each servlet will be referred by URL to
invoke or access and each web page content will be served by one
servlet but in portlets each page will be served by different
portlet and each portlet will have its own lifecycle and own URL
pattern to execute.
Servlet
will generate dynamic content which send to browser and it’s in
single web page but portlet will server fragment of dynamic content
and portal page is responsible to aggregate content from different
portlet to generate whole page.
There
are many people implemented the portlet technology.
Liferay
JetSpeed
Pluto
uPortal
WebLogic
Websphere
Entando
Understanding
the Portlet Technology
Basically we need to following things to run portlet based application
JRE
Portlet
Container+Application Server
Portlets
Portlet
Container
Portlet containers
is responsible for run the portlet and it provides the required run
time environment. Portlet containers manage the life cycle of
portlets. When ever portal server send the request then portlet
containers receive the requests and its invoke the respective
portlet to process request means its instantiated the portlet and
execute appropriate life cycle methods to prepare response. Portlet
container send portlet response back to portal server like that
portal server receive responses of different portlets and aggregate
all response to complete client request.
Application
Server
Application servers
are responsible to process client request and send response back to
client. Application server provided different services to manage and
run web applications. The services like JMS, JNDI, JTS, JAAS,
JDO,Connection Pooling and all these services required by the
applications.
Application servers
integrated with different containers to provide different run time
environments like servlet containers to provides run time environment
to execute servlets, portlet containers is to provides the run time
environment to execute portlet, EJB containers to provided
environment to execute Enterprise Java Beans applications.
Apart from this
application severs have more capabilities to provide different
services to run different technology based applications.
Portlets
As
we already know each portlet has it own life cycle and which will be
managed by portlet container. According to the JSR 168 standard
portlet have three life cycle stages.
Basic
portlet consist following life cycle stages
Portlet
life cycle
init:
Initialize
the portlet and put the portlet into service
Handle
requests:
Process
different kinds of action- and render-requests
Destroy:
Put
portlet out of service
Theoretically
we have 3 life cycle stages in portlets and these will be implemented
via portlet interface. Portlet interface is implemented in
javax.portlet package by Sun Microsystems.
Every
portlet that should implements the portlet interface or it should
extend the class that already implemented the portlet interface.
As
we know portlet have three life cycle staged and the following are
interface methods which handle portlet life cycle in portlet
implementation.
init(PortletConfig
config):
This
method is initialize the portlet and this will be called only once
when portlet is instantiated, we can say when we drag and drop
portlet in page.
If
any necessary functionality required at initial time of portlet we
will use this method and write code here. It is similar to servlet
init method. This method can be used to create expensive
objects/resources used by the portlet.
processAction(ActionRequest
request, ActionResponse response):
When
user is requested to server then portlet will execute process action
method.
This
method will notify the portlet that used has triggered an action this
portlet. , a portlet can issue a redirect, change its portlet mode or
window state, modify its persistent state, or set render parameters.
render(RenderRequest
request, RenderResponse response):
Render
method will generate content and that will be send to web client.
In
the portal page we have many portlet we have triggered action in one
portlet then all portlet will be executed render method to aggregate
dynamic content. The portlet can produce markup that may depend on
the portlet mode or window state, render parameters, request
attributes, persistent state, session data, or backend data.
destroy
():
Indicate
to the portlet the life cycle's end. This method allows the portlet
to free up resources and update any persistent data that belongs to
this portlet.
Note:
In
the portlet life cycle for each action or request the final method is
render method. Render method will be called for every time to
aggregate content or produce content.
Generally
portlet have different URL to call these methods like Action URL and
Render URL.
Action
URL will execute portlet porcessAction(----) method and
then it will be execute the render(----) method.
Render
URL will execute the portlet render (---) method only.
Portlet Lyfecycle Execution Process
Portlet
Characteristics
Portlet
have addition Characteristics when we compare with servlet.
Portlet
Widow States:
Portlet
has different window states. Window state specifies how portlet will
look in the page .Window state decides how much space will be
accommodated in portlet page.
The
following are important window states as for JSR 168 Standards.
Maximized:
When
portlet state is decided as Maximized then entire page only one
portlet is visible.
Generally
we will use this state after perform some action then we will make
widow state is Maximized.
Normal:
Specified
that is portlet may share the page with other portlets. This is the
default window state.
Minimized:
Portlet
should only render minimal output or no output at all.
Portlet
Modes:
Portlet
mode specifies that the function will be performed by portlet.
Generally
following are the portlet modes that each portlet should support as
for JSR 168&286 standards.
View:
This
view mode is when portlet is access or render then portlet is in view
mode and this is default mode for portlet.
Edit:
Edit
mode will be used to edit some portlet functionality and generally we
wil use this mode for administrator to modify or edit something.
Help:
This
will used to provide content to end user about portlet i.e how to use
and access portlet like help information.
Persistent
storage for preferences:
Portlets
provide a Portlet Preferences object for storing user preferences.
These preferences are stored in a persistent data store, so they will
be available across server restarts. As a developer, you don't have
to worry about the actual implementation of how it is stored.
Portlet
Sessions:
Like
Http Session in the portlet technology also have different scopes of
session to share data among the portlet or with in the portlet.
Portlet also can use Http Session.
Portlet
Session by default scope is portlet level what ever the data stored
in Portlet Session can be available with in portlet. If we want share
data among the portlets then we have to use application level scope
so that data can be shares across the portlets.
Portlet
technology have concept called publics render parameters to exchange
data among portlets this is we can all it as Inter
Portlet Communication.
We
can use portlet sessions or public render parameters to establish
communication among portlets which are in same page.
Portal
context
Portal
context provides information such as the portal vendor, the portal
version, and specific portal properties. The information allows the
portlet to use specific vendor extensions when being called by a
portal that supports these extensions and, when being called by other
portals, to return to some simpler default behavior.
Properties
Properties
communicate vendor-specific settings between the portlet and portlet
container, and between the portlet and the portal.
These
properties show up in several places in JSR 168. The portlet can read
String properties with getProperty() from:
ActionRequest,
to receive properties that are action-request specific
RenderRequest,
to receive properties that are render-request specific
PortalContext,
to receive properties that are portal specific and do not change for
different requests
The
portlet can write String properties with setProperty() to:
ActionResponse,
to set properties in response to an action request
RenderResponse,
to set properties in response to a render request
Packaging
and deployment
Portlet
are packages as web archive file(WAR) this archive file consist of
portlet deployment descriptors, resources and other java libraries
which are required by portlets.
In
the portlet application we have two deployment descriptors that is
web.xml and portlet.xml
web.xml
specifies the things related to web application deployment properties
portlet.xml
specifies the
portlet application related deployment properties and it always
describes only one specific portlet application.
portlet
application deployment is a two-step deployment that deploys the Web
application into the application server and the portlets into the
portal server.
Author
Posts
