/*
 * Copyright 2002-2015 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.web.portlet;

import java.io.IOException;
import java.security.Principal;
import java.util.Map;
import javax.portlet.ActionRequest;
import javax.portlet.ActionResponse;
import javax.portlet.EventRequest;
import javax.portlet.EventResponse;
import javax.portlet.PortletException;
import javax.portlet.PortletRequest;
import javax.portlet.PortletResponse;
import javax.portlet.RenderRequest;
import javax.portlet.RenderResponse;
import javax.portlet.ResourceRequest;
import javax.portlet.ResourceResponse;

import org.springframework.beans.BeanUtils;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextException;
import org.springframework.context.ApplicationListener;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.SourceFilteringListener;
import org.springframework.context.i18n.LocaleContext;
import org.springframework.context.i18n.LocaleContextHolder;
import org.springframework.context.i18n.SimpleLocaleContext;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.portlet.context.ConfigurablePortletApplicationContext;
import org.springframework.web.portlet.context.PortletApplicationContextUtils;
import org.springframework.web.portlet.context.PortletRequestAttributes;
import org.springframework.web.portlet.context.PortletRequestHandledEvent;
import org.springframework.web.portlet.context.StandardPortletEnvironment;
import org.springframework.web.portlet.context.XmlPortletApplicationContext;

/**
 * Base portlet for Spring's portlet framework. Provides integration with
 * a Spring application context, in a JavaBean-based overall solution.
 *
 * <p>This class offers the following functionality:
 * <ul>
 * <li>Manages a Portlet {@link org.springframework.context.ApplicationContext}
 * instance per portlet. The portlet's configuration is determined by beans
 * in the portlet's namespace.
 * <li>Publishes events on request processing, whether or not a request is
 * successfully handled.
 * </ul>
 *
 * <p>Subclasses must implement {@link #doActionService} and {@link #doRenderService}
 * to handle action and render requests. Because this extends {@link GenericPortletBean}
 * rather than Portlet directly, bean properties are mapped onto it. Subclasses can
 * override {@link #initFrameworkPortlet()} for custom initialization.
 *
 * <p>Regards a "contextClass" parameter at the portlet init-param level,
 * falling back to the default context class
 * ({@link org.springframework.web.portlet.context.XmlPortletApplicationContext})
 * if not found. Note that, with the default FrameworkPortlet,
 * a context class needs to implement the
 * {@link org.springframework.web.portlet.context.ConfigurablePortletApplicationContext} SPI.
 *
 * <p>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.
 *
 * <p>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.
 *
 * <p>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.
 *
 * @author William G. Thompson, Jr.
 * @author John A. Lewis
 * @author Juergen Hoeller
 * @since 2.0
 * @see #doActionService
 * @see #doRenderService
 * @see #setContextClass
 * @see #setContextConfigLocation
 * @see #setNamespace
 */
public abstract class FrameworkPortlet extends GenericPortletBean
                implements ApplicationListener<ContextRefreshedEvent> {

        /**
         * Default context class for FrameworkPortlet.
         * @see org.springframework.web.portlet.context.XmlPortletApplicationContext
         */
        public static final Class<?> DEFAULT_CONTEXT_CLASS = XmlPortletApplicationContext.class;

        /**
         * 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".
         */
        public static final String DEFAULT_NAMESPACE_SUFFIX = "-portlet";

        /**
         * Prefix for the PortletContext attribute for the Portlet ApplicationContext.
         * The completion is the portlet name.
         */
        public static final String PORTLET_CONTEXT_PREFIX = FrameworkPortlet.class.getName() + ".CONTEXT.";

        /**
         * Default USER_INFO attribute names to search for the current username:
         * "user.login.id", "user.name".
         */
        public static final String[] DEFAULT_USERINFO_ATTRIBUTE_NAMES = {"user.login.id", "user.name"};


        /** Portlet ApplicationContext implementation class to use */
        private Class<?> contextClass = DEFAULT_CONTEXT_CLASS;

        /** Namespace for this portlet */
        private String namespace;

        /** Explicit context config location */
        private String contextConfigLocation;

        /** Should we publish the context as a PortletContext attribute? */
        private boolean publishContext = true;

        /** Should we publish a PortletRequestHandledEvent at the end of each request? */
        private boolean publishEvents = true;

        /** Expose LocaleContext and RequestAttributes as inheritable for child threads? */
        private boolean threadContextInheritable = false;

        /** USER_INFO attributes that may contain the username of the current user */
        private String[] userinfoUsernameAttributes = DEFAULT_USERINFO_ATTRIBUTE_NAMES;

        /** ApplicationContext for this portlet */
        private ApplicationContext portletApplicationContext;

        /** Flag used to detect whether onRefresh has already been called */
        private boolean refreshEventReceived = false;


        /**
         * 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 #createPortletApplicationContext
         */
        public void setContextClass(Class<?> contextClass) {
                this.contextClass = contextClass;
        }

        /**
         * Return the custom context class.
         */
        public Class<?> getContextClass() {
                return this.contextClass;
        }

        /**
         * Set a custom namespace for this portlet,
         * to be used for building a default context config location.
         */
        public void setNamespace(String namespace) {
                this.namespace = namespace;
        }

        /**
         * 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")
         */
        public String getNamespace() {
                return (this.namespace != null) ? this.namespace : getPortletName() + DEFAULT_NAMESPACE_SUFFIX;
        }

        /**
         * 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.
         */
        public void setContextConfigLocation(String contextConfigLocation) {
                this.contextConfigLocation = contextConfigLocation;
        }

        /**
         * Return the explicit context config location, if any.
         */
        public String getContextConfigLocation() {
                return this.contextConfigLocation;
        }

        /**
         * Set whether to publish this portlet's context as a PortletContext attribute,
         * available to all objects in the web container. Default is true.
         * <p>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.
         */
        public void setPublishContext(boolean publishContext) {
                this.publishContext = publishContext;
        }

        /**
         * 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 org.springframework.web.portlet.context.PortletRequestHandledEvent
         */
        public void setPublishEvents(boolean publishEvents) {
                this.publishEvents = publishEvents;
        }

        /**
         * Set whether to expose the LocaleContext and RequestAttributes as inheritable
         * for child threads (using an {@link java.lang.InheritableThreadLocal}).
         * <p>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).
         * <p><b>WARNING:</b> 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 {@link java.util.concurrent.ThreadPoolExecutor}),
         * since this will expose the inherited context to such a pooled thread.
         */
        public void setThreadContextInheritable(boolean threadContextInheritable) {
                this.threadContextInheritable = threadContextInheritable;
        }

        /**
         * Set the list of attributes to search in the USER_INFO map when trying
         * to find the username of the current user.
         * @see #getUsernameForRequest
         */
        public void setUserinfoUsernameAttributes(String[] userinfoUsernameAttributes) {
                this.userinfoUsernameAttributes = userinfoUsernameAttributes;
        }


        /**
         * Overridden method of GenericPortletBean, invoked after any bean properties
         * have been set. Creates this portlet's ApplicationContext.
         */
        @Override
        protected final void initPortletBean() throws PortletException {
                getPortletContext().log("Initializing Spring FrameworkPortlet '" + getPortletName() + "'");
                if (logger.isInfoEnabled()) {
                        logger.info("FrameworkPortlet '" + getPortletName() + "': initialization started");
                }
                long startTime = System.currentTimeMillis();

                try {
                        this.portletApplicationContext = initPortletApplicationContext();
                        initFrameworkPortlet();
                }
                catch (PortletException ex) {
                        logger.error("Context initialization failed", ex);
                        throw ex;
                }
                catch (RuntimeException ex) {
                        logger.error("Context initialization failed", ex);
                        throw ex;
                }

                if (logger.isInfoEnabled()) {
                        long elapsedTime = System.currentTimeMillis() - startTime;
                        logger.info("FrameworkPortlet '" + getPortletName() + "': initialization completed in " + elapsedTime + " ms");
                }
        }

        /**
         * Initialize and publish the Portlet ApplicationContext for this portlet.
         * <p>Delegates to {@link #createPortletApplicationContext} for actual creation.
         * Can be overridden in subclasses.
         * @return the ApplicationContext for this portlet
         */
        protected ApplicationContext initPortletApplicationContext() {
                ApplicationContext parent = PortletApplicationContextUtils.getWebApplicationContext(getPortletContext());
                ApplicationContext pac = createPortletApplicationContext(parent);

                if (!this.refreshEventReceived) {
                        // Apparently not a ConfigurableApplicationContext with refresh support:
                        // triggering initial onRefresh manually here.
                        onRefresh(pac);
                }

                if (this.publishContext) {
                        // publish the context as a portlet context attribute
                        String attName = getPortletContextAttributeName();
                        getPortletContext().setAttribute(attName, pac);
                        if (logger.isDebugEnabled()) {
                                logger.debug("Published ApplicationContext of portlet '" + getPortletName() +
                                                "' as PortletContext attribute with name [" + attName + "]");
                        }
                }
                return pac;
        }

        /**
         * Instantiate the Portlet ApplicationContext for this portlet, either a default
         * XmlPortletApplicationContext or a custom context class if set.
         * <p>This implementation expects custom contexts to implement
         * ConfigurablePortletApplicationContext. Can be overridden in subclasses.
         * @param parent the parent ApplicationContext to use, or null if none
         * @return the Portlet ApplicationContext for this portlet
         * @see #setContextClass
         * @see org.springframework.web.portlet.context.XmlPortletApplicationContext
         */
        protected ApplicationContext createPortletApplicationContext(ApplicationContext parent) {
                Class<?> contextClass = getContextClass();
                if (logger.isDebugEnabled()) {
                        logger.debug("Portlet with name '" + getPortletName() +
                                        "' will try to create custom ApplicationContext context of class '" +
                                        contextClass.getName() + "'" + ", using parent context [" + parent + "]");
                }
                if (!ConfigurablePortletApplicationContext.class.isAssignableFrom(contextClass)) {
                        throw new ApplicationContextException("Fatal initialization error in portlet with name '" + getPortletName() +
                                        "': custom ApplicationContext class [" + contextClass.getName() +
                                        "] is not of type ConfigurablePortletApplicationContext");
                }
                ConfigurablePortletApplicationContext pac =
                                (ConfigurablePortletApplicationContext) BeanUtils.instantiateClass(contextClass);

                // Assign the best possible id value.
                String portletContextName = getPortletContext().getPortletContextName();
                if (portletContextName != null) {
                        pac.setId(ConfigurablePortletApplicationContext.APPLICATION_CONTEXT_ID_PREFIX + portletContextName + "." + getPortletName());
                }
                else {
                        pac.setId(ConfigurablePortletApplicationContext.APPLICATION_CONTEXT_ID_PREFIX + getPortletName());
                }

                pac.setEnvironment(getEnvironment());
                pac.setParent(parent);
                pac.setPortletContext(getPortletContext());
                pac.setPortletConfig(getPortletConfig());
                pac.setNamespace(getNamespace());
                pac.setConfigLocation(getContextConfigLocation());
                pac.addApplicationListener(new SourceFilteringListener(pac, this));

                // The wac environment's #initPropertySources will be called in any case when the context
                // is refreshed; do it eagerly here to ensure portlet property sources are in place for
                // use in any post-processing or initialization that occurs below prior to #refresh
                ConfigurableEnvironment env = pac.getEnvironment();
                if (env instanceof StandardPortletEnvironment) {
                        ((StandardPortletEnvironment) env).initPropertySources(pac.getServletContext(), getPortletContext(), getPortletConfig());
                }

                postProcessPortletApplicationContext(pac);
                pac.refresh();

                return pac;
        }

        /**
         * Post-process the given Portlet ApplicationContext before it is refreshed
         * and activated as context for this portlet.
         * <p>The default implementation is empty. {@code refresh()} will
         * be called automatically after this method returns.
         * @param pac the configured Portlet ApplicationContext (not refreshed yet)
         * @see #createPortletApplicationContext
         * @see ConfigurableApplicationContext#refresh()
         */
        protected void postProcessPortletApplicationContext(ConfigurableApplicationContext pac) {
        }

        /**
         * Return the PortletContext attribute name for this portlets's ApplicationContext.
         * <p>The default implementation returns PORTLET_CONTEXT_PREFIX + portlet name.
         * @see #PORTLET_CONTEXT_PREFIX
         * @see #getPortletName
         */
        public String getPortletContextAttributeName() {
                return PORTLET_CONTEXT_PREFIX + getPortletName();
        }

        /**
         * Return this portlet's ApplicationContext.
         */
        public final ApplicationContext getPortletApplicationContext() {
                return this.portletApplicationContext;
        }


        /**
         * This method will be invoked after any bean properties have been set and
         * the ApplicationContext has been loaded.
         * <p>The default implementation is empty; subclasses may override this method
         * to perform any initialization they require.
         * @throws PortletException in case of an initialization exception
         */
        protected void initFrameworkPortlet() throws PortletException {
        }

        /**
         * Refresh this portlet's application context, as well as the
         * dependent state of the portlet.
         * @see #getPortletApplicationContext()
         * @see org.springframework.context.ConfigurableApplicationContext#refresh()
         */
        public void refresh() {
                ApplicationContext pac = getPortletApplicationContext();
                if (!(pac instanceof ConfigurableApplicationContext)) {
                        throw new IllegalStateException("Portlet ApplicationContext does not support refresh: " + pac);
                }
                ((ConfigurableApplicationContext) pac).refresh();
        }

        /**
         * ApplicationListener endpoint that receives events from this servlet's
         * WebApplicationContext.
         * <p>The default implementation calls {@link #onRefresh} in case of a
         * {@link org.springframework.context.event.ContextRefreshedEvent},
         * triggering a refresh of this servlet's context-dependent state.
         * @param event the incoming ApplicationContext event
         */
        @Override
        public void onApplicationEvent(ContextRefreshedEvent event) {
                this.refreshEventReceived = true;
                onRefresh(event.getApplicationContext());
        }

        /**
         * Template method which can be overridden to add portlet-specific refresh work.
         * Called after successful context refresh.
         * <p>This implementation is empty.
         * @param context the current Portlet ApplicationContext
         * @see #refresh()
         */
        protected void onRefresh(ApplicationContext context) {
                // For subclasses: do nothing by default.
        }


        /**
         * Overridden for friendlier behavior in unit tests.
         */
        @Override
        protected String getTitle(RenderRequest renderRequest) {
                try {
                        return super.getTitle(renderRequest);
                }
                catch (NullPointerException ex) {
                        return getPortletName();
                }
        }

        /**
         * Delegate action requests to processRequest/doActionService.
         */
        @Override
        public final void processAction(ActionRequest request, ActionResponse response)
                        throws PortletException, IOException {

                processRequest(request, response);
        }

        /**
         * Delegate render requests to processRequest/doRenderService.
         */
        @Override
        protected final void doDispatch(RenderRequest request, RenderResponse response)
                        throws PortletException, IOException {

                processRequest(request, response);
        }

        @Override
        public void serveResource(ResourceRequest request, ResourceResponse response)
                        throws PortletException, IOException {

                processRequest(request, response);
        }

        @Override
        public void processEvent(EventRequest request, EventResponse response)
                        throws PortletException, IOException {

                processRequest(request, response);
        }

        /**
         * Process this request, publishing an event regardless of the outcome.
         * The actual event handling is performed by the abstract
         * {@code doActionService()} and {@code doRenderService()} template methods.
         * @see #doActionService
         * @see #doRenderService
         */
        protected final void processRequest(PortletRequest request, PortletResponse response)
                        throws PortletException, IOException {

                long startTime = System.currentTimeMillis();
                Throwable failureCause = null;

                // Expose current LocaleResolver and request as LocaleContext.
                LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
                LocaleContextHolder.setLocaleContext(buildLocaleContext(request), this.threadContextInheritable);

                // Expose current RequestAttributes to current thread.
                RequestAttributes previousRequestAttributes = RequestContextHolder.getRequestAttributes();
                PortletRequestAttributes requestAttributes = null;
                if (previousRequestAttributes == null ||
                                PortletRequestAttributes.class == previousRequestAttributes.getClass() ||
                                ServletRequestAttributes.class == previousRequestAttributes.getClass()) {
                        requestAttributes = new PortletRequestAttributes(request, response);
                        RequestContextHolder.setRequestAttributes(requestAttributes, this.threadContextInheritable);
                }

                if (logger.isTraceEnabled()) {
                        logger.trace("Bound request context to thread: " + request);
                }

                try {
                        String phase = (String) request.getAttribute(PortletRequest.LIFECYCLE_PHASE);
                        if (PortletRequest.ACTION_PHASE.equals(phase)) {
                                doActionService((ActionRequest) request, (ActionResponse) response);
                        }
                        else if (PortletRequest.RENDER_PHASE.equals(phase)) {
                                doRenderService((RenderRequest) request, (RenderResponse) response);
                        }
                        else if (PortletRequest.RESOURCE_PHASE.equals(phase)) {
                                doResourceService((ResourceRequest) request, (ResourceResponse) response);
                        }
                        else if (PortletRequest.EVENT_PHASE.equals(phase)) {
                                doEventService((EventRequest) request, (EventResponse) response);
                        }
                        else {
                                throw new IllegalStateException("Invalid portlet request phase: " + phase);
                        }
                }
                catch (PortletException ex) {
                        failureCause = ex;
                        throw ex;
                }
                catch (IOException ex) {
                        failureCause = ex;
                        throw ex;
                }
                catch (Throwable ex) {
                        failureCause = ex;
                        throw new PortletException("Request processing failed", ex);
                }

                finally {
                        // Clear request attributes and reset thread-bound context.
                        LocaleContextHolder.setLocaleContext(previousLocaleContext, this.threadContextInheritable);
                        if (requestAttributes != null) {
                                RequestContextHolder.setRequestAttributes(previousRequestAttributes, this.threadContextInheritable);
                                requestAttributes.requestCompleted();
                        }
                        if (logger.isTraceEnabled()) {
                                logger.trace("Cleared thread-bound resource request context: " + request);
                        }

                        if (failureCause != null) {
                                logger.error("Could not complete request", failureCause);
                        }
                        else {
                                logger.debug("Successfully completed request");
                        }
                        if (this.publishEvents) {
                                // Whether or not we succeeded, publish an event.
                                long processingTime = System.currentTimeMillis() - startTime;
                                this.portletApplicationContext.publishEvent(
                                                new PortletRequestHandledEvent(this,
                                                                getPortletConfig().getPortletName(), request.getPortletMode().toString(),
                                                                (request instanceof ActionRequest ? "action" : "render"),
                                                                request.getRequestedSessionId(), getUsernameForRequest(request),
                                                                processingTime, failureCause));
                        }
                }
        }

        /**
         * Build a LocaleContext for the given request, exposing the request's
         * primary locale as current locale.
         * @param request current HTTP request
         * @return the corresponding LocaleContext
         */
        protected LocaleContext buildLocaleContext(PortletRequest request) {
                return new SimpleLocaleContext(request.getLocale());
        }

        /**
         * Determine the username for the given request.
         * <p>The default implementation first tries the UserPrincipal.
         * If that does not exist, then it checks the USER_INFO map.
         * Can be overridden in subclasses.
         * @param request current portlet request
         * @return the username, or {@code null} if none found
         * @see javax.portlet.PortletRequest#getUserPrincipal()
         * @see javax.portlet.PortletRequest#getRemoteUser()
         * @see javax.portlet.PortletRequest#USER_INFO
         * @see #setUserinfoUsernameAttributes
         */
        protected String getUsernameForRequest(PortletRequest request) {
                // Try the principal.
                Principal userPrincipal = request.getUserPrincipal();
                if (userPrincipal != null) {
                        return userPrincipal.getName();
                }

                // Try the remote user name.
                String userName = request.getRemoteUser();
                if (userName != null) {
                        return userName;
                }

                // Try the Portlet USER_INFO map.
                Map<?, ?> userInfo = (Map<?, ?>) request.getAttribute(PortletRequest.USER_INFO);
                if (userInfo != null) {
                        for (int i = 0, n = this.userinfoUsernameAttributes.length; i < n; i++) {
                                userName = (String) userInfo.get(this.userinfoUsernameAttributes[i]);
                                if (userName != null) {
                                        return userName;
                                }
                        }
                }

                // Nothing worked...
                return null;
        }


        /**
         * Subclasses must implement this method to do the work of action request handling.
         * <p>The contract is essentially the same as that for the {@code processAction}
         * method of GenericPortlet.
         * <p>This class intercepts calls to ensure that exception handling and
         * event publication takes place.
         * @param request current action request
         * @param response current action response
         * @throws Exception in case of any kind of processing failure
         * @see javax.portlet.GenericPortlet#processAction
         */
        protected abstract void doActionService(ActionRequest request, ActionResponse response)
                        throws Exception;

        /**
         * Subclasses must implement this method to do the work of render request handling.
         * <p>The contract is essentially the same as that for the {@code doDispatch}
         * method of GenericPortlet.
         * <p>This class intercepts calls to ensure that exception handling and
         * event publication takes place.
         * @param request current render request
         * @param response current render response
         * @throws Exception in case of any kind of processing failure
         * @see javax.portlet.GenericPortlet#doDispatch
         */
        protected abstract void doRenderService(RenderRequest request, RenderResponse response)
                        throws Exception;

        /**
         * Subclasses must implement this method to do the work of resource request handling.
         * <p>The contract is essentially the same as that for the {@code serveResource}
         * method of GenericPortlet.
         * <p>This class intercepts calls to ensure that exception handling and
         * event publication takes place.
         * @param request current resource request
         * @param response current resource response
         * @throws Exception in case of any kind of processing failure
         * @see javax.portlet.GenericPortlet#serveResource
         */
        protected abstract void doResourceService(ResourceRequest request, ResourceResponse response)
                        throws Exception;

        /**
         * Subclasses must implement this method to do the work of event request handling.
         * <p>The contract is essentially the same as that for the {@code processEvent}
         * method of GenericPortlet.
         * <p>This class intercepts calls to ensure that exception handling and
         * event publication takes place.
         * @param request current event request
         * @param response current event response
         * @throws Exception in case of any kind of processing failure
         * @see javax.portlet.GenericPortlet#processEvent
         */
        protected abstract void doEventService(EventRequest request, EventResponse response)
                        throws Exception;


        /**
         * Close the ApplicationContext of this portlet.
         * @see org.springframework.context.ConfigurableApplicationContext#close()
         */
        @Override
        public void destroy() {
                getPortletContext().log("Destroying Spring FrameworkPortlet '" + getPortletName() + "'");
                if (this.portletApplicationContext instanceof ConfigurableApplicationContext) {
                        ((ConfigurableApplicationContext) this.portletApplicationContext).close();
                }
        }

}