001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portlet;
016    
017    import com.liferay.portal.kernel.language.LanguageUtil;
018    import com.liferay.portal.kernel.log.Log;
019    import com.liferay.portal.kernel.log.LogFactoryUtil;
020    import com.liferay.portal.kernel.portlet.LiferayPortletRequest;
021    import com.liferay.portal.kernel.portlet.LiferayPortletResponse;
022    import com.liferay.portal.kernel.portlet.PortletFilterUtil;
023    import com.liferay.portal.kernel.servlet.PortletServlet;
024    import com.liferay.portal.kernel.servlet.StringServletResponse;
025    import com.liferay.portal.kernel.util.ClassUtil;
026    import com.liferay.portal.kernel.util.GetterUtil;
027    import com.liferay.portal.kernel.util.JavaConstants;
028    import com.liferay.portal.kernel.util.StringBundler;
029    import com.liferay.portal.kernel.util.StringPool;
030    import com.liferay.portal.kernel.util.StringUtil;
031    import com.liferay.portal.kernel.util.Time;
032    import com.liferay.portal.model.Layout;
033    import com.liferay.portal.model.PortletApp;
034    import com.liferay.portal.tools.deploy.PortletDeployer;
035    import com.liferay.portal.util.WebKeys;
036    
037    import java.io.IOException;
038    
039    import java.util.ArrayList;
040    import java.util.HashMap;
041    import java.util.List;
042    import java.util.Map;
043    import java.util.Set;
044    import java.util.concurrent.ConcurrentHashMap;
045    
046    import javax.portlet.ActionRequest;
047    import javax.portlet.ActionResponse;
048    import javax.portlet.EventRequest;
049    import javax.portlet.EventResponse;
050    import javax.portlet.Portlet;
051    import javax.portlet.PortletConfig;
052    import javax.portlet.PortletContext;
053    import javax.portlet.PortletException;
054    import javax.portlet.PortletRequest;
055    import javax.portlet.PortletSession;
056    import javax.portlet.RenderRequest;
057    import javax.portlet.RenderResponse;
058    import javax.portlet.ResourceRequest;
059    import javax.portlet.ResourceResponse;
060    import javax.portlet.filter.ActionFilter;
061    import javax.portlet.filter.EventFilter;
062    import javax.portlet.filter.FilterChain;
063    import javax.portlet.filter.PortletFilter;
064    import javax.portlet.filter.RenderFilter;
065    import javax.portlet.filter.ResourceFilter;
066    
067    import javax.servlet.RequestDispatcher;
068    import javax.servlet.ServletException;
069    import javax.servlet.http.HttpServletRequest;
070    import javax.servlet.http.HttpServletResponse;
071    import javax.servlet.http.HttpSession;
072    
073    import org.apache.commons.lang.time.StopWatch;
074    
075    /**
076     * @author Brian Wing Shun Chan
077     * @author Brian Myunghun Kim
078     */
079    public class InvokerPortletImpl implements InvokerPortlet {
080    
081            public static void clearResponse(
082                    HttpSession session, long plid, String portletId, String languageId) {
083    
084                    String sesResponseId = encodeResponseKey(plid, portletId, languageId);
085    
086                    getResponses(session).remove(sesResponseId);
087            }
088    
089            public static void clearResponses(HttpSession session) {
090                    getResponses(session).clear();
091            }
092    
093            public static void clearResponses(PortletSession session) {
094                    getResponses(session).clear();
095            }
096    
097            public static String encodeResponseKey(
098                    long plid, String portletId, String languageId) {
099    
100                    StringBundler sb = new StringBundler(5);
101    
102                    sb.append(StringUtil.toHexString(plid));
103                    sb.append(StringPool.UNDERLINE);
104                    sb.append(portletId);
105                    sb.append(StringPool.UNDERLINE);
106                    sb.append(languageId);
107    
108                    return sb.toString();
109            }
110    
111            public static Map<String, InvokerPortletResponse> getResponses(
112                    HttpSession session) {
113    
114                    Map<String, InvokerPortletResponse> responses =
115                            (Map<String, InvokerPortletResponse>)session.getAttribute(
116                                    WebKeys.CACHE_PORTLET_RESPONSES);
117    
118                    if (responses == null) {
119                            responses = new ConcurrentHashMap<String, InvokerPortletResponse>();
120    
121                            session.setAttribute(WebKeys.CACHE_PORTLET_RESPONSES, responses);
122                    }
123    
124                    return responses;
125            }
126    
127            public static Map<String, InvokerPortletResponse> getResponses(
128                    PortletSession portletSession) {
129    
130                    return getResponses(
131                            ((PortletSessionImpl)portletSession).getHttpSession());
132            }
133    
134            public InvokerPortlet create(
135                            com.liferay.portal.model.Portlet portletModel, Portlet portlet,
136                            PortletContext portletContext)
137                    throws PortletException {
138    
139                    try {
140                            InvokerPortlet invokerPortlet = (InvokerPortlet)clone();
141    
142                            invokerPortlet.prepare(portletModel, portlet, portletContext);
143    
144                            return invokerPortlet;
145                    }
146                    catch (PortletException pe) {
147                            throw pe;
148                    }
149                    catch (Exception e) {
150                            throw new PortletException(e);
151                    }
152            }
153    
154            public InvokerPortlet create(
155                            com.liferay.portal.model.Portlet portletModel, Portlet portlet,
156                            PortletConfig portletConfig, PortletContext portletContext,
157                            boolean checkAuthToken, boolean facesPortlet, boolean strutsPortlet,
158                            boolean strutsBridgePortlet)
159                    throws PortletException {
160    
161                    try {
162                            InvokerPortlet invokerPortlet = (InvokerPortlet)clone();
163    
164                            invokerPortlet.prepare(
165                                    portletModel, portlet, portletConfig, portletContext,
166                                    checkAuthToken, facesPortlet, strutsPortlet,
167                                    strutsBridgePortlet);
168    
169                            return invokerPortlet;
170                    }
171                    catch (PortletException pe) {
172                            throw pe;
173                    }
174                    catch (Exception e) {
175                            throw new PortletException(e);
176                    }
177            }
178    
179            public void destroy() {
180                    if (_destroyable) {
181                            Thread currentThread = Thread.currentThread();
182    
183                            ClassLoader contextClassLoader =
184                                    currentThread.getContextClassLoader();
185    
186                            ClassLoader portletClassLoader = getPortletClassLoader();
187    
188                            try {
189                                    if (portletClassLoader != null) {
190                                            currentThread.setContextClassLoader(portletClassLoader);
191                                    }
192    
193                                    removePortletFilters();
194    
195                                    _portlet.destroy();
196                            }
197                            finally {
198                                    if (portletClassLoader != null) {
199                                            currentThread.setContextClassLoader(contextClassLoader);
200                                    }
201                            }
202                    }
203    
204                    _destroyable = false;
205            }
206    
207            public Portlet getPortlet() {
208                    return _portlet;
209            }
210    
211            public ClassLoader getPortletClassLoader() {
212                    return (ClassLoader)_portletContextImpl.getAttribute(
213                            PortletServlet.PORTLET_CLASS_LOADER);
214            }
215    
216            public PortletConfigImpl getPortletConfig() {
217                    return _portletConfigImpl;
218            }
219    
220            public PortletContextImpl getPortletContext() {
221                    return _portletContextImpl;
222            }
223    
224            public Portlet getPortletInstance() {
225                    return _portlet;
226            }
227    
228            public Integer getExpCache() {
229                    return _expCache;
230            }
231    
232            public void init(PortletConfig portletConfig) throws PortletException {
233                    _portletConfigImpl = (PortletConfigImpl)portletConfig;
234    
235                    Thread currentThread = Thread.currentThread();
236    
237                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
238    
239                    ClassLoader portletClassLoader = getPortletClassLoader();
240    
241                    try {
242                            if (portletClassLoader != null) {
243                                    currentThread.setContextClassLoader(portletClassLoader);
244                            }
245    
246                            _portlet.init(portletConfig);
247                    }
248                    finally {
249                            if (portletClassLoader != null) {
250                                    currentThread.setContextClassLoader(contextClassLoader);
251                            }
252                    }
253    
254                    _destroyable = true;
255            }
256    
257            public boolean isCheckAuthToken() {
258                    return _checkAuthToken;
259            }
260    
261            public boolean isDestroyable() {
262                    return _destroyable;
263            }
264    
265            public boolean isFacesPortlet() {
266                    return _facesPortlet;
267            }
268    
269            public boolean isStrutsBridgePortlet() {
270                    return _strutsBridgePortlet;
271            }
272    
273            public boolean isStrutsPortlet() {
274                    return _strutsPortlet;
275            }
276    
277            public void prepare(
278                            com.liferay.portal.model.Portlet portletModel, Portlet portlet,
279                            PortletContext portletContext)
280                    throws PortletException {
281    
282                    _portletModel = portletModel;
283                    _portletId = _portletModel.getPortletId();
284                    _portlet = portlet;
285                    _portletContextImpl = (PortletContextImpl)portletContext;
286    
287                    if (_log.isDebugEnabled()) {
288                            _log.debug(
289                                    "Create root cache wrapper for " +
290                                            _portletContextImpl.getPortlet().getPortletId());
291                    }
292    
293                    Map<String, String> initParams = portletModel.getInitParams();
294    
295                    _checkAuthToken = GetterUtil.getBoolean(
296                            initParams.get("check-auth-token"), true);
297    
298                    if (ClassUtil.isSubclass(
299                                    _portlet.getClass(), PortletDeployer.JSF_MYFACES) ||
300                            ClassUtil.isSubclass(
301                                    _portlet.getClass(), PortletDeployer.JSF_STANDARD) ||
302                            ClassUtil.isSubclass(
303                                    _portlet.getClass(), PortletDeployer.JSF_SUN)) {
304    
305                            _facesPortlet = true;
306                    }
307    
308                    _strutsPortlet = ClassUtil.isSubclass(
309                            portlet.getClass(), StrutsPortlet.class);
310                    _strutsBridgePortlet = ClassUtil.isSubclass(
311                            portlet.getClass(),
312                            "org.apache.portals.bridges.struts.StrutsPortlet");
313                    _expCache = portletModel.getExpCache();
314                    setPortletFilters();
315            }
316    
317            public void prepare(
318                            com.liferay.portal.model.Portlet portletModel, Portlet portlet,
319                            PortletConfig portletConfig, PortletContext portletContext,
320                            boolean checkAuthToken, boolean facesPortlet, boolean strutsPortlet,
321                            boolean strutsBridgePortlet)
322                    throws PortletException {
323    
324                    // From prepare
325    
326                    _portletModel = portletModel;
327                    _portlet = portlet;
328                    _portletId = _portletModel.getPortletId();
329                    _portletContextImpl = (PortletContextImpl)portletContext;
330                    _checkAuthToken = checkAuthToken;
331                    _facesPortlet = facesPortlet;
332                    _strutsPortlet = strutsPortlet;
333                    _strutsBridgePortlet = strutsBridgePortlet;
334                    _expCache = portletModel.getExpCache();
335                    setPortletFilters();
336    
337                    if (_log.isDebugEnabled()) {
338                            _log.debug(
339                                    "Create instance cache wrapper for " +
340                                            _portletContextImpl.getPortlet().getPortletId());
341                    }
342    
343                    // From init
344    
345                    _portletConfigImpl = (PortletConfigImpl)portletConfig;
346            }
347    
348            public void processAction(
349                            ActionRequest actionRequest, ActionResponse actionResponse)
350                    throws IOException {
351    
352                    StopWatch stopWatch = null;
353    
354                    if (_log.isDebugEnabled()) {
355                            stopWatch = new StopWatch();
356    
357                            stopWatch.start();
358                    }
359    
360                    try {
361                            invokeAction(actionRequest, actionResponse);
362                    }
363                    catch (PortletException pe) {
364                            actionRequest.setAttribute(
365                                    _portletId + PortletException.class.getName(), pe);
366                    }
367    
368                    if (_log.isDebugEnabled()) {
369                            if (stopWatch != null) {
370                                    _log.debug(
371                                            "processAction for " + _portletId + " takes " +
372                                                    stopWatch.getTime() + " ms");
373                            }
374                            else {
375                                    _log.debug("processAction for " + _portletId + " is finished");
376                            }
377                    }
378            }
379    
380            public void processEvent(
381                            EventRequest eventRequest, EventResponse eventResponse)
382                    throws IOException, PortletException {
383    
384                    StopWatch stopWatch = null;
385    
386                    if (_log.isDebugEnabled()) {
387                            stopWatch = new StopWatch();
388    
389                            stopWatch.start();
390                    }
391    
392                    invokeEvent(eventRequest, eventResponse);
393    
394                    if (_log.isDebugEnabled()) {
395                            _log.debug(
396                                    "processEvent for " + _portletId + " takes " +
397                                            stopWatch.getTime() + " ms");
398                    }
399            }
400    
401            public void render(
402                            RenderRequest renderRequest, RenderResponse renderResponse)
403                    throws IOException, PortletException {
404    
405                    PortletException portletException =
406                            (PortletException)renderRequest.getAttribute(
407                                    _portletId + PortletException.class.getName());
408    
409                    if (portletException != null) {
410                            throw portletException;
411                    }
412    
413                    StopWatch stopWatch = null;
414    
415                    if (_log.isDebugEnabled()) {
416                            stopWatch = new StopWatch();
417    
418                            stopWatch.start();
419                    }
420    
421                    String remoteUser = renderRequest.getRemoteUser();
422    
423                    if ((remoteUser == null) || (_expCache == null) ||
424                            (_expCache.intValue() == 0)) {
425    
426                            invokeRender(renderRequest, renderResponse);
427                    }
428                    else {
429                            RenderResponseImpl renderResponseImpl =
430                                    (RenderResponseImpl)renderResponse;
431    
432                            StringServletResponse stringResponse = (StringServletResponse)
433                                    renderResponseImpl.getHttpServletResponse();
434    
435                            PortletSession portletSession = renderRequest.getPortletSession();
436    
437                            long now = System.currentTimeMillis();
438    
439                            Layout layout = (Layout)renderRequest.getAttribute(WebKeys.LAYOUT);
440    
441                            Map<String, InvokerPortletResponse> sessionResponses =
442                                    getResponses(portletSession);
443    
444                            String sessionResponseId = encodeResponseKey(
445                                    layout.getPlid(), _portletId,
446                                    LanguageUtil.getLanguageId(renderRequest));
447    
448                            InvokerPortletResponse response = sessionResponses.get(
449                                    sessionResponseId);
450    
451                            if (response == null) {
452                                    String title = invokeRender(renderRequest, renderResponse);
453    
454                                    response = new InvokerPortletResponse(
455                                            title, stringResponse.getString(),
456                                            now + Time.SECOND * _expCache.intValue());
457    
458                                    sessionResponses.put(sessionResponseId, response);
459                            }
460                            else if ((response.getTime() < now) &&
461                                             (_expCache.intValue() > 0)) {
462    
463                                    String title = invokeRender(renderRequest, renderResponse);
464    
465                                    response.setTitle(title);
466                                    response.setContent(stringResponse.getString());
467                                    response.setTime(now + Time.SECOND * _expCache.intValue());
468                            }
469                            else {
470                                    renderResponseImpl.setTitle(response.getTitle());
471                                    stringResponse.getWriter().print(response.getContent());
472                            }
473                    }
474    
475                    Map<String, String[]> properties =
476                            ((RenderResponseImpl)renderResponse).getProperties();
477    
478                    if (properties.containsKey("clear-request-parameters")) {
479                            Map<String, String[]> renderParameters =
480                                    ((RenderRequestImpl)renderRequest).getRenderParameters();
481    
482                            renderParameters.clear();
483                    }
484    
485                    if (_log.isDebugEnabled()) {
486                            _log.debug(
487                                    "render for " + _portletId + " takes " + stopWatch.getTime() +
488                                            " ms");
489                    }
490            }
491    
492            public void serveResource(
493                            ResourceRequest resourceRequest, ResourceResponse resourceResponse)
494                    throws IOException {
495    
496                    StopWatch stopWatch = null;
497    
498                    if (_log.isDebugEnabled()) {
499                            stopWatch = new StopWatch();
500    
501                            stopWatch.start();
502                    }
503    
504                    try {
505                            invokeResource(resourceRequest, resourceResponse);
506                    }
507                    catch (PortletException pe) {
508                            resourceRequest.setAttribute(
509                                    _portletId + PortletException.class.getName(), pe);
510                    }
511    
512                    if (_log.isDebugEnabled()) {
513                            _log.debug(
514                                    "serveResource for " + _portletId + " takes " +
515                                            stopWatch.getTime() + " ms");
516                    }
517            }
518    
519            public void setPortletFilters() throws PortletException {
520                    PortletApp portletApp = _portletModel.getPortletApp();
521    
522                    PortletContextBag portletContextBag = PortletContextBagPool.get(
523                            portletApp.getServletContextName());
524    
525                    if (portletApp.isWARFile() && (portletContextBag == null)) {
526                            return;
527                    }
528    
529                    removePortletFilters();
530    
531                    Map<String, com.liferay.portal.model.PortletFilter> portletFilters =
532                            _portletModel.getPortletFilters();
533    
534                    for (Map.Entry<String, com.liferay.portal.model.PortletFilter> entry :
535                                    portletFilters.entrySet()) {
536    
537                            com.liferay.portal.model.PortletFilter portletFilterModel =
538                                    entry.getValue();
539    
540                            PortletFilter portletFilter = PortletFilterFactory.create(
541                                    portletFilterModel, _portletContextImpl);
542    
543                            Set<String> lifecycles = portletFilterModel.getLifecycles();
544    
545                            if (lifecycles.contains(PortletRequest.ACTION_PHASE)) {
546                                    List<ActionFilter> actionFilters = _actionFiltersMap.get(
547                                            _portletId);
548    
549                                    if (actionFilters == null) {
550                                            actionFilters = new ArrayList<ActionFilter>();
551                                    }
552    
553                                    actionFilters.add((ActionFilter)portletFilter);
554    
555                                    _actionFiltersMap.put(_portletId, actionFilters);
556                            }
557    
558                            if (lifecycles.contains(PortletRequest.EVENT_PHASE)) {
559                                    List<EventFilter> eventFilters = _eventFiltersMap.get(
560                                            _portletId);
561    
562                                    if (eventFilters == null) {
563                                            eventFilters = new ArrayList<EventFilter>();
564                                    }
565    
566                                    eventFilters.add((EventFilter)portletFilter);
567    
568                                    _eventFiltersMap.put(_portletId, eventFilters);
569                            }
570    
571                            if (lifecycles.contains(PortletRequest.RENDER_PHASE)) {
572                                    List<RenderFilter> renderFilters = _renderFiltersMap.get(
573                                            _portletId);
574    
575                                    if (renderFilters == null) {
576                                            renderFilters = new ArrayList<RenderFilter>();
577                                    }
578    
579                                    renderFilters.add((RenderFilter)portletFilter);
580    
581                                    _renderFiltersMap.put(_portletId, renderFilters);
582                            }
583    
584                            if (lifecycles.contains(PortletRequest.RESOURCE_PHASE)) {
585                                    List<ResourceFilter> resourceFilters = _resourceFiltersMap.get(
586                                            _portletId);
587    
588                                    if (resourceFilters == null) {
589                                            resourceFilters = new ArrayList<ResourceFilter>();
590                                    }
591    
592                                    resourceFilters.add((ResourceFilter)portletFilter);
593    
594                                    _resourceFiltersMap.put(_portletId, resourceFilters);
595                            }
596                    }
597            }
598    
599            protected void invoke(
600                            LiferayPortletRequest portletRequest,
601                            LiferayPortletResponse portletResponse, String lifecycle,
602                            List<? extends PortletFilter> filters)
603                    throws IOException, PortletException {
604    
605                    FilterChain filterChain = new FilterChainImpl(_portlet, filters);
606    
607                    if (_portletConfigImpl.isWARFile()) {
608                            String invokerPortletName = _portletConfigImpl.getInitParameter(
609                                    INIT_INVOKER_PORTLET_NAME);
610    
611                            if (invokerPortletName == null) {
612                                    invokerPortletName = _portletConfigImpl.getPortletName();
613                            }
614    
615                            String path = StringPool.SLASH + invokerPortletName + "/invoke";
616    
617                            RequestDispatcher requestDispatcher =
618                                    _portletContextImpl.getServletContext().getRequestDispatcher(
619                                            path);
620    
621                            HttpServletRequest request = portletRequest.getHttpServletRequest();
622                            HttpServletResponse response =
623                                    portletResponse.getHttpServletResponse();
624    
625                            request.setAttribute(JavaConstants.JAVAX_PORTLET_PORTLET, _portlet);
626                            request.setAttribute(PortletRequest.LIFECYCLE_PHASE, lifecycle);
627                            request.setAttribute(
628                                    PortletServlet.PORTLET_SERVLET_FILTER_CHAIN, filterChain);
629    
630                            try {
631    
632                                    // Resource phase must be a forward because includes do not
633                                    // allow you to specify the content type or headers
634    
635                                    if (lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
636                                            requestDispatcher.forward(request, response);
637                                    }
638                                    else {
639                                            requestDispatcher.include(request, response);
640                                    }
641                            }
642                            catch (ServletException se) {
643                                    Throwable cause = se.getRootCause();
644    
645                                    if (cause instanceof PortletException) {
646                                            throw (PortletException)cause;
647                                    }
648    
649                                    throw new PortletException(cause);
650                            }
651                    }
652                    else {
653                            PortletFilterUtil.doFilter(
654                                    portletRequest, portletResponse, lifecycle, filterChain);
655                    }
656    
657                    portletResponse.transferMarkupHeadElements();
658    
659                    Map<String, String[]> properties = portletResponse.getProperties();
660    
661                    if ((properties != null) && (properties.size() > 0)) {
662                            if (_expCache != null) {
663                                    String[] expCache = properties.get(
664                                            RenderResponse.EXPIRATION_CACHE);
665    
666                                    if ((expCache != null) && (expCache.length > 0) &&
667                                            (expCache[0] != null)) {
668    
669                                            _expCache = new Integer(GetterUtil.getInteger(expCache[0]));
670                                    }
671                            }
672                    }
673            }
674    
675            protected void invokeAction(
676                            ActionRequest actionRequest, ActionResponse actionResponse)
677                    throws IOException, PortletException {
678    
679                    LiferayPortletRequest portletRequest =
680                            (LiferayPortletRequest)actionRequest;
681                    LiferayPortletResponse portletResponse =
682                            (LiferayPortletResponse)actionResponse;
683    
684                    String portletId = _getPortletId(portletResponse);
685    
686                    List<ActionFilter> actionFilters = _actionFiltersMap.get(
687                            portletId);
688    
689                    invoke(
690                            portletRequest, portletResponse, PortletRequest.ACTION_PHASE,
691                            actionFilters);
692            }
693    
694            protected void invokeEvent(
695                            EventRequest eventRequest, EventResponse eventResponse)
696                    throws IOException, PortletException {
697    
698                    LiferayPortletRequest portletRequest =
699                            (LiferayPortletRequest)eventRequest;
700                    LiferayPortletResponse portletResponse =
701                            (LiferayPortletResponse)eventResponse;
702    
703                    String portletId = _getPortletId(portletResponse);
704    
705                    List<EventFilter> eventFilters = _eventFiltersMap.get(portletId);
706    
707                    invoke(
708                            portletRequest, portletResponse, PortletRequest.EVENT_PHASE,
709                            eventFilters);
710            }
711    
712            protected String invokeRender(
713                            RenderRequest renderRequest, RenderResponse renderResponse)
714                    throws IOException, PortletException {
715    
716                    LiferayPortletRequest portletRequest =
717                            (LiferayPortletRequest)renderRequest;
718                    LiferayPortletResponse portletResponse =
719                            (LiferayPortletResponse)renderResponse;
720    
721                    String portletId = _getPortletId(portletResponse);
722    
723                    List<RenderFilter> renderFilters = _renderFiltersMap.get(
724                            portletId);
725    
726                    invoke(
727                            portletRequest, portletResponse, PortletRequest.RENDER_PHASE,
728                            renderFilters);
729    
730                    RenderResponseImpl renderResponseImpl =
731                            (RenderResponseImpl)renderResponse;
732    
733                    return renderResponseImpl.getTitle();
734            }
735    
736            protected void invokeResource(
737                            ResourceRequest resourceRequest, ResourceResponse resourceResponse)
738                    throws IOException, PortletException {
739    
740                    LiferayPortletRequest portletRequest =
741                            (LiferayPortletRequest)resourceRequest;
742                    LiferayPortletResponse portletResponse =
743                            (LiferayPortletResponse)resourceResponse;
744    
745                    String portletId = _getPortletId(portletResponse);
746    
747                    List<ResourceFilter> resourceFilters = _resourceFiltersMap.get(
748                            portletId);
749    
750                    invoke(
751                            portletRequest, portletResponse, PortletRequest.RESOURCE_PHASE,
752                            resourceFilters);
753            }
754    
755            protected void removePortletFilters() {
756                    _actionFiltersMap.remove(_portletId);
757                    _eventFiltersMap.remove(_portletId);
758                    _renderFiltersMap.remove(_portletId);
759                    _resourceFiltersMap.remove(_portletId);
760            }
761    
762            private String _getPortletId(LiferayPortletResponse portletResponse) {
763                    PortletResponseImpl portletResponseImpl =
764                            (PortletResponseImpl)portletResponse;
765    
766                    com.liferay.portal.model.Portlet portlet =
767                            portletResponseImpl.getPortlet();
768    
769                    return portlet.getPortletId();
770            }
771    
772            private static Log _log = LogFactoryUtil.getLog(InvokerPortletImpl.class);
773    
774            private com.liferay.portal.model.Portlet _portletModel;
775            private String _portletId;
776            private Portlet _portlet;
777            private PortletConfigImpl _portletConfigImpl;
778            private PortletContextImpl _portletContextImpl;
779            private Integer _expCache;
780            private boolean _checkAuthToken;
781            private boolean _destroyable;
782            private boolean _facesPortlet;
783            private boolean _strutsPortlet;
784            private boolean _strutsBridgePortlet;
785            private Map<String, List<ActionFilter>> _actionFiltersMap =
786                    new HashMap<String, List<ActionFilter>>();
787            private Map<String, List<EventFilter>> _eventFiltersMap =
788                    new HashMap<String, List<EventFilter>>();
789            private Map<String, List<RenderFilter>> _renderFiltersMap =
790                    new HashMap<String, List<RenderFilter>>();
791            private Map<String, List<ResourceFilter>> _resourceFiltersMap =
792                    new HashMap<String, List<ResourceFilter>>();
793    
794    }