FrameworkPortlet

java.lang.Object
- GenericPortlet
- - org.springframework.web.portlet.GenericPortletBean
  - - org.springframework.web.portlet.FrameworkPortlet

All Implemented Interfaces:

java.util.EventListener, Aware, ApplicationListener<ContextRefreshedEvent>, EnvironmentAware, EnvironmentCapable

Direct Known Subclasses:

DispatcherPortlet
```
public abstract class FrameworkPortlet
extends GenericPortletBean
implements ApplicationListener<ContextRefreshedEvent>
```
Base portlet for Spring's portlet framework. Provides integration with a Spring application context, in a JavaBean-based overall solution.
This class offers the following functionality:
- Manages a Portlet ApplicationContext instance per portlet. The portlet's configuration is determined by beans in the portlet's namespace.
- Publishes events on request processing, whether or not a request is successfully handled.
Subclasses must implement doActionService(ActionRequest, ActionResponse) and doRenderService(RenderRequest, RenderResponse) to handle action and render requests. Because this extends GenericPortletBean rather than Portlet directly, bean properties are mapped onto it. Subclasses can override initFrameworkPortlet() for custom initialization.
Regards a "contextClass" parameter at the portlet init-param level, falling back to the default context class (XmlPortletApplicationContext) if not found. Note that, with the default FrameworkPortlet, a context class needs to implement the ConfigurablePortletApplicationContext SPI.
Passes a "contextConfigLocation" portlet init-param to the context instance, parsing it into potentially multiple file paths which can be separated by any number of commas and spaces, like "test-portlet.xml, myPortlet.xml". If not explicitly specified, the context implementation is supposed to build a default location from the namespace of the portlet.
Note: In case of multiple config locations, later bean definitions will override ones defined in earlier loaded files, at least when using one of Spring's default ApplicationContext implementations. This can be leveraged to deliberately override certain bean definitions via an extra XML file.
The default namespace is "'portlet-name'-portlet", e.g. "test-portlet" for a portlet-name "test" (leading to a "/WEB-INF/test-portlet.xml" default location with XmlPortletApplicationContext). The namespace can also be set explicitly via the "namespace" portlet init-param.
Since:

2.0

Author:

William G. Thompson, Jr., John A. Lewis, Juergen Hoeller

See Also:

doActionService(ActionRequest, ActionResponse), doRenderService(RenderRequest, RenderResponse), setContextClass(java.lang.Class<?>), setContextConfigLocation(java.lang.String), setNamespace(java.lang.String)

Field Summary

Fields
Modifier and Type	Field and Description
`private java.lang.Class<?>`	`contextClass` Portlet ApplicationContext implementation class to use
`private java.lang.String`	`contextConfigLocation` Explicit context config location
`static java.lang.Class<?>`	`DEFAULT_CONTEXT_CLASS` Default context class for FrameworkPortlet.
`static java.lang.String`	`DEFAULT_NAMESPACE_SUFFIX` Suffix for Portlet ApplicationContext namespaces.
`static java.lang.String[]`	`DEFAULT_USERINFO_ATTRIBUTE_NAMES` Default USER_INFO attribute names to search for the current username: "user.login.id", "user.name".
`private java.lang.String`	`namespace` Namespace for this portlet
`static java.lang.String`	`PORTLET_CONTEXT_PREFIX` Prefix for the PortletContext attribute for the Portlet ApplicationContext.
`private ApplicationContext`	`portletApplicationContext` ApplicationContext for this portlet
`private boolean`	`publishContext` Should we publish the context as a PortletContext attribute?
`private boolean`	`publishEvents` Should we publish a PortletRequestHandledEvent at the end of each request?
`private boolean`	`refreshEventReceived` Flag used to detect whether onRefresh has already been called
`private boolean`	`threadContextInheritable` Expose LocaleContext and RequestAttributes as inheritable for child threads?
`private java.lang.String[]`	`userinfoUsernameAttributes` USER_INFO attributes that may contain the username of the current user

Fields inherited from class org.springframework.web.portlet.GenericPortletBean
logger

Constructor Summary

Constructors
Constructor and Description

FrameworkPortlet()

Constructors
Constructor and Description
`FrameworkPortlet()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected LocaleContext`	`buildLocaleContext(PortletRequest request)` Build a LocaleContext for the given request, exposing the request's primary locale as current locale.
`protected ApplicationContext`	`createPortletApplicationContext(ApplicationContext parent)` Instantiate the Portlet ApplicationContext for this portlet, either a default XmlPortletApplicationContext or a custom context class if set.
`void`	`destroy()` Close the ApplicationContext of this portlet.
`protected abstract void`	`doActionService(ActionRequest request, ActionResponse response)` Subclasses must implement this method to do the work of action request handling.
`protected void`	`doDispatch(RenderRequest request, RenderResponse response)` Delegate render requests to processRequest/doRenderService.
`protected abstract void`	`doEventService(EventRequest request, EventResponse response)` Subclasses must implement this method to do the work of event request handling.
`protected abstract void`	`doRenderService(RenderRequest request, RenderResponse response)` Subclasses must implement this method to do the work of render request handling.
`protected abstract void`	`doResourceService(ResourceRequest request, ResourceResponse response)` Subclasses must implement this method to do the work of resource request handling.
`java.lang.Class<?>`	`getContextClass()` Return the custom context class.
`java.lang.String`	`getContextConfigLocation()` Return the explicit context config location, if any.
`java.lang.String`	`getNamespace()` Return the namespace for this portlet, falling back to default scheme if no custom namespace was set.
`ApplicationContext`	`getPortletApplicationContext()` Return this portlet's ApplicationContext.
`java.lang.String`	`getPortletContextAttributeName()` Return the PortletContext attribute name for this portlets's ApplicationContext.
`protected java.lang.String`	`getTitle(RenderRequest renderRequest)` Overridden for friendlier behavior in unit tests.
`protected java.lang.String`	`getUsernameForRequest(PortletRequest request)` Determine the username for the given request.
`protected void`	`initFrameworkPortlet()` This method will be invoked after any bean properties have been set and the ApplicationContext has been loaded.
`protected ApplicationContext`	`initPortletApplicationContext()` Initialize and publish the Portlet ApplicationContext for this portlet.
`protected void`	`initPortletBean()` Overridden method of GenericPortletBean, invoked after any bean properties have been set.
`void`	`onApplicationEvent(ContextRefreshedEvent event)` ApplicationListener endpoint that receives events from this servlet's WebApplicationContext.
`protected void`	`onRefresh(ApplicationContext context)` Template method which can be overridden to add portlet-specific refresh work.
`protected void`	`postProcessPortletApplicationContext(ConfigurableApplicationContext pac)` Post-process the given Portlet ApplicationContext before it is refreshed and activated as context for this portlet.
`void`	`processAction(ActionRequest request, ActionResponse response)` Delegate action requests to processRequest/doActionService.
`void`	`processEvent(EventRequest request, EventResponse response)`
`protected void`	`processRequest(PortletRequest request, PortletResponse response)` Process this request, publishing an event regardless of the outcome.
`void`	`refresh()` Refresh this portlet's application context, as well as the dependent state of the portlet.
`void`	`serveResource(ResourceRequest request, ResourceResponse response)`
`void`	`setContextClass(java.lang.Class<?> contextClass)` Set a custom context class.
`void`	`setContextConfigLocation(java.lang.String contextConfigLocation)` Set the context config location explicitly, instead of relying on the default location built from the namespace.
`void`	`setNamespace(java.lang.String namespace)` Set a custom namespace for this portlet, to be used for building a default context config location.
`void`	`setPublishContext(boolean publishContext)` Set whether to publish this portlet's context as a PortletContext attribute, available to all objects in the web container.
`void`	`setPublishEvents(boolean publishEvents)` Set whether this portlet should publish a PortletRequestHandledEvent at the end of each request.
`void`	`setThreadContextInheritable(boolean threadContextInheritable)` Set whether to expose the LocaleContext and RequestAttributes as inheritable for child threads (using an `InheritableThreadLocal`).
`void`	`setUserinfoUsernameAttributes(java.lang.String[] userinfoUsernameAttributes)` Set the list of attributes to search in the USER_INFO map when trying to find the username of the current user.

Methods inherited from class org.springframework.web.portlet.GenericPortletBean
addRequiredProperty, createEnvironment, getEnvironment, getPortletContext, getPortletName, init, initBeanWrapper, setEnvironment

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - DEFAULT_CONTEXT_CLASS
```
public static final java.lang.Class<?> DEFAULT_CONTEXT_CLASS
```
    Default context class for FrameworkPortlet.
    
    See Also:
    
    XmlPortletApplicationContext
  - DEFAULT_NAMESPACE_SUFFIX
```
public static final java.lang.String DEFAULT_NAMESPACE_SUFFIX
```
    Suffix for Portlet ApplicationContext namespaces. If a portlet of this class is given the name "test" in a context, the namespace used by the portlet will resolve to "test-portlet".
    
    See Also:
    
    Constant Field Values
  - PORTLET_CONTEXT_PREFIX
```
public static final java.lang.String PORTLET_CONTEXT_PREFIX
```
    Prefix for the PortletContext attribute for the Portlet ApplicationContext. The completion is the portlet name.
  - DEFAULT_USERINFO_ATTRIBUTE_NAMES
```
public static final java.lang.String[] DEFAULT_USERINFO_ATTRIBUTE_NAMES
```
    Default USER_INFO attribute names to search for the current username: "user.login.id", "user.name".
  - contextClass
```
private java.lang.Class<?> contextClass
```
    Portlet ApplicationContext implementation class to use
  - namespace
```
private java.lang.String namespace
```
    Namespace for this portlet
  - contextConfigLocation
```
private java.lang.String contextConfigLocation
```
    Explicit context config location
  - publishContext
```
private boolean publishContext
```
    Should we publish the context as a PortletContext attribute?
  - publishEvents
```
private boolean publishEvents
```
    Should we publish a PortletRequestHandledEvent at the end of each request?
  - threadContextInheritable
```
private boolean threadContextInheritable
```
    Expose LocaleContext and RequestAttributes as inheritable for child threads?
  - userinfoUsernameAttributes
```
private java.lang.String[] userinfoUsernameAttributes
```
    USER_INFO attributes that may contain the username of the current user
  - portletApplicationContext
```
private ApplicationContext portletApplicationContext
```
    ApplicationContext for this portlet
  - refreshEventReceived
```
private boolean refreshEventReceived
```
    Flag used to detect whether onRefresh has already been called
- Constructor Detail
  - FrameworkPortlet
```
public FrameworkPortlet()
```
- Method Detail
  - setContextClass
```
public void setContextClass(java.lang.Class<?> contextClass)
```
    Set a custom context class. This class must be of type ApplicationContext; when using the default FrameworkPortlet implementation, the context class must also implement ConfigurablePortletApplicationContext.
    
    See Also:
    
    createPortletApplicationContext(org.springframework.context.ApplicationContext)
  - getContextClass
```
public java.lang.Class<?> getContextClass()
```
    Return the custom context class.
  - setNamespace
```
public void setNamespace(java.lang.String namespace)
```
    Set a custom namespace for this portlet, to be used for building a default context config location.
  - getNamespace
```
public java.lang.String getNamespace()
```
    Return the namespace for this portlet, falling back to default scheme if no custom namespace was set. (e.g. "test-portlet" for a portlet named "test")
  - setContextConfigLocation
```
public void setContextConfigLocation(java.lang.String contextConfigLocation)
```
    Set the context config location explicitly, instead of relying on the default location built from the namespace. This location string can consist of multiple locations separated by any number of commas and spaces.
  - getContextConfigLocation
```
public java.lang.String getContextConfigLocation()
```
    Return the explicit context config location, if any.
  - setPublishContext
```
public void setPublishContext(boolean publishContext)
```
    Set whether to publish this portlet's context as a PortletContext attribute, available to all objects in the web container. Default is true.
    This is especially handy during testing, although it is debatable whether it's good practice to let other application objects access the context this way.
  - setPublishEvents
```
public void setPublishEvents(boolean publishEvents)
```
    Set whether this portlet should publish a PortletRequestHandledEvent at the end of each request. Default is true; can be turned off for a slight performance improvement, provided that no ApplicationListeners rely on such events.
    
    See Also:
    
    PortletRequestHandledEvent
  - setThreadContextInheritable
```
public void setThreadContextInheritable(boolean threadContextInheritable)
```
    Set whether to expose the LocaleContext and RequestAttributes as inheritable for child threads (using an InheritableThreadLocal).
    Default is "false", to avoid side effects on spawned background threads. Switch this to "true" to enable inheritance for custom child threads which are spawned during request processing and only used for this request (that is, ending after their initial task, without reuse of the thread).
    WARNING: Do not use inheritance for child threads if you are accessing a thread pool which is configured to potentially add new threads on demand (e.g. a JDK ThreadPoolExecutor), since this will expose the inherited context to such a pooled thread.
  - setUserinfoUsernameAttributes
```
public void setUserinfoUsernameAttributes(java.lang.String[] userinfoUsernameAttributes)
```
    Set the list of attributes to search in the USER_INFO map when trying to find the username of the current user.
    
    See Also:
    
    getUsernameForRequest(PortletRequest)
  - initPortletBean
```
protected final void initPortletBean()
                              throws PortletException
```
    Overridden method of GenericPortletBean, invoked after any bean properties have been set. Creates this portlet's ApplicationContext.
    
    Overrides:
    
    initPortletBean in class GenericPortletBean
    
    Throws:
    
    PortletException - if subclass initialization fails
  - initPortletApplicationContext
```
protected ApplicationContext initPortletApplicationContext()
```
    Initialize and publish the Portlet ApplicationContext for this portlet.
    Delegates to createPortletApplicationContext(org.springframework.context.ApplicationContext) for actual creation. Can be overridden in subclasses.
    
    Returns:
    
    the ApplicationContext for this portlet
  - createPortletApplicationContext
```
protected ApplicationContext createPortletApplicationContext(ApplicationContext parent)
```
    Instantiate the Portlet ApplicationContext for this portlet, either a default XmlPortletApplicationContext or a custom context class if set.
    This implementation expects custom contexts to implement ConfigurablePortletApplicationContext. Can be overridden in subclasses.
    
    Parameters:
    
    parent - the parent ApplicationContext to use, or null if none
    
    Returns:
    
    the Portlet ApplicationContext for this portlet
    
    See Also:
    
    setContextClass(java.lang.Class<?>), XmlPortletApplicationContext
  - postProcessPortletApplicationContext
```
protected void postProcessPortletApplicationContext(ConfigurableApplicationContext pac)
```
    Post-process the given Portlet ApplicationContext before it is refreshed and activated as context for this portlet.
    The default implementation is empty. refresh() will be called automatically after this method returns.
    
    Parameters:
    
    pac - the configured Portlet ApplicationContext (not refreshed yet)
    
    See Also:
    
    createPortletApplicationContext(org.springframework.context.ApplicationContext), ConfigurableApplicationContext.refresh()
  - getPortletContextAttributeName
```
public java.lang.String getPortletContextAttributeName()
```
    Return the PortletContext attribute name for this portlets's ApplicationContext.
    The default implementation returns PORTLET_CONTEXT_PREFIX + portlet name.
    
    See Also:
    
    PORTLET_CONTEXT_PREFIX, GenericPortletBean.getPortletName()
  - getPortletApplicationContext
```
public final ApplicationContext getPortletApplicationContext()
```
    Return this portlet's ApplicationContext.
  - initFrameworkPortlet
```
protected void initFrameworkPortlet()
                             throws PortletException
```
    This method will be invoked after any bean properties have been set and the ApplicationContext has been loaded.
    The default implementation is empty; subclasses may override this method to perform any initialization they require.
    
    Throws:
    
    PortletException - in case of an initialization exception
  - refresh
```
public void refresh()
```
    Refresh this portlet's application context, as well as the dependent state of the portlet.
    
    See Also:
    
    getPortletApplicationContext(), ConfigurableApplicationContext.refresh()
  - onApplicationEvent
```
public void onApplicationEvent(ContextRefreshedEvent event)
```
    ApplicationListener endpoint that receives events from this servlet's WebApplicationContext.
    The default implementation calls onRefresh(org.springframework.context.ApplicationContext) in case of a ContextRefreshedEvent, triggering a refresh of this servlet's context-dependent state.
    
    Specified by:
    
    onApplicationEvent in interface ApplicationListener<ContextRefreshedEvent>
    
    Parameters:
    
    event - the incoming ApplicationContext event
  - onRefresh
```
protected void onRefresh(ApplicationContext context)
```
    Template method which can be overridden to add portlet-specific refresh work. Called after successful context refresh.
    This implementation is empty.
    
    Parameters:
    
    context - the current Portlet ApplicationContext
    
    See Also:
    
    refresh()
  - getTitle
```
protected java.lang.String getTitle(RenderRequest renderRequest)
```
    Overridden for friendlier behavior in unit tests.
  - processAction
```
public final void processAction(ActionRequest request,
                                ActionResponse response)
                         throws PortletException,
                                java.io.IOException
```
    Delegate action requests to processRequest/doActionService.
    
    Throws:
    
    PortletException
    
    java.io.IOException
  - doDispatch
```
protected final void doDispatch(RenderRequest request,
                                RenderResponse response)
                         throws PortletException,
                                java.io.IOException
```
    Delegate render requests to processRequest/doRenderService.
    
    Throws:
    
    PortletException
    
    java.io.IOException
  - serveResource
```
public void serveResource(ResourceRequest request,
                          ResourceResponse response)
                   throws PortletException,
                          java.io.IOException
```
    Throws:
    
    PortletException
    
    java.io.IOException
  - processEvent
```
public void processEvent(EventRequest request,
                         EventResponse response)
                  throws PortletException,
                         java.io.IOException
```
    Throws:
    
    PortletException
    
    java.io.IOException
  - processRequest
```
protected final void processRequest(PortletRequest request,
                                    PortletResponse response)
                             throws PortletException,
                                    java.io.IOException
```
    Process this request, publishing an event regardless of the outcome. The actual event handling is performed by the abstract doActionService() and doRenderService() template methods.
    
    Throws:
    
    PortletException
    
    java.io.IOException
    
    See Also:
    
    doActionService(ActionRequest, ActionResponse), doRenderService(RenderRequest, RenderResponse)
  - buildLocaleContext
```
protected LocaleContext buildLocaleContext(PortletRequest request)
```
    Build a LocaleContext for the given request, exposing the request's primary locale as current locale.
    
    Parameters:
    
    request - current HTTP request
    
    Returns:
    
    the corresponding LocaleContext
  - getUsernameForRequest
```
protected java.lang.String getUsernameForRequest(PortletRequest request)
```
    Determine the username for the given request.
    The default implementation first tries the UserPrincipal. If that does not exist, then it checks the USER_INFO map. Can be overridden in subclasses.
    
    Parameters:
    
    request - current portlet request
    
    Returns:
    
    the username, or null if none found
    
    See Also:
    
    javax.portlet.PortletRequest#getUserPrincipal(), javax.portlet.PortletRequest#getRemoteUser(), javax.portlet.PortletRequest#USER_INFO, setUserinfoUsernameAttributes(java.lang.String[])
  - doActionService
```
protected abstract void doActionService(ActionRequest request,
                                        ActionResponse response)
                                 throws java.lang.Exception
```
    Subclasses must implement this method to do the work of action request handling.
    The contract is essentially the same as that for the processAction method of GenericPortlet.
    This class intercepts calls to ensure that exception handling and event publication takes place.
    
    Parameters:
    
    request - current action request
    
    response - current action response
    
    Throws:
    
    java.lang.Exception - in case of any kind of processing failure
    
    See Also:
    
    javax.portlet.GenericPortlet#processAction
  - doRenderService
```
protected abstract void doRenderService(RenderRequest request,
                                        RenderResponse response)
                                 throws java.lang.Exception
```
    Subclasses must implement this method to do the work of render request handling.
    The contract is essentially the same as that for the doDispatch method of GenericPortlet.
    This class intercepts calls to ensure that exception handling and event publication takes place.
    
    Parameters:
    
    request - current render request
    
    response - current render response
    
    Throws:
    
    java.lang.Exception - in case of any kind of processing failure
    
    See Also:
    
    javax.portlet.GenericPortlet#doDispatch
  - doResourceService
```
protected abstract void doResourceService(ResourceRequest request,
                                          ResourceResponse response)
                                   throws java.lang.Exception
```
    Subclasses must implement this method to do the work of resource request handling.
    The contract is essentially the same as that for the serveResource method of GenericPortlet.
    This class intercepts calls to ensure that exception handling and event publication takes place.
    
    Parameters:
    
    request - current resource request
    
    response - current resource response
    
    Throws:
    
    java.lang.Exception - in case of any kind of processing failure
    
    See Also:
    
    javax.portlet.GenericPortlet#serveResource
  - doEventService
```
protected abstract void doEventService(EventRequest request,
                                       EventResponse response)
                                throws java.lang.Exception
```
    Subclasses must implement this method to do the work of event request handling.
    The contract is essentially the same as that for the processEvent method of GenericPortlet.
    This class intercepts calls to ensure that exception handling and event publication takes place.
    
    Parameters:
    
    request - current event request
    
    response - current event response
    
    Throws:
    
    java.lang.Exception - in case of any kind of processing failure
    
    See Also:
    
    javax.portlet.GenericPortlet#processEvent
  - destroy
```
public void destroy()
```
    Close the ApplicationContext of this portlet.
    
    See Also:
    
    ConfigurableApplicationContext.close()

Class FrameworkPortlet

Field Summary

Fields inherited from class org.springframework.web.portlet.GenericPortletBean

Constructor Summary

Method Summary

Methods inherited from class org.springframework.web.portlet.GenericPortletBean

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_CONTEXT_CLASS

DEFAULT_NAMESPACE_SUFFIX

PORTLET_CONTEXT_PREFIX

DEFAULT_USERINFO_ATTRIBUTE_NAMES

contextClass

namespace

contextConfigLocation

publishContext

publishEvents

threadContextInheritable

userinfoUsernameAttributes

portletApplicationContext

refreshEventReceived

Constructor Detail

FrameworkPortlet

Method Detail

setContextClass

getContextClass

setNamespace

getNamespace

setContextConfigLocation

getContextConfigLocation

setPublishContext

setPublishEvents

setThreadContextInheritable

setUserinfoUsernameAttributes

initPortletBean

initPortletApplicationContext

createPortletApplicationContext

postProcessPortletApplicationContext

getPortletContextAttributeName

getPortletApplicationContext

initFrameworkPortlet

refresh

onApplicationEvent

onRefresh

getTitle

processAction

doDispatch

serveResource

processEvent

processRequest

buildLocaleContext

getUsernameForRequest

doActionService

doRenderService

doResourceService

doEventService

destroy