1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portlet;
16  
17  import com.liferay.portal.kernel.language.LanguageUtil;
18  import com.liferay.portal.kernel.log.Log;
19  import com.liferay.portal.kernel.log.LogFactoryUtil;
20  import com.liferay.portal.kernel.portlet.LiferayPortletRequest;
21  import com.liferay.portal.kernel.portlet.LiferayPortletResponse;
22  import com.liferay.portal.kernel.portlet.PortletFilterUtil;
23  import com.liferay.portal.kernel.servlet.PortletServlet;
24  import com.liferay.portal.kernel.servlet.StringServletResponse;
25  import com.liferay.portal.kernel.util.ClassUtil;
26  import com.liferay.portal.kernel.util.GetterUtil;
27  import com.liferay.portal.kernel.util.JavaConstants;
28  import com.liferay.portal.kernel.util.StringBundler;
29  import com.liferay.portal.kernel.util.StringPool;
30  import com.liferay.portal.kernel.util.Time;
31  import com.liferay.portal.model.Layout;
32  import com.liferay.portal.tools.deploy.PortletDeployer;
33  import com.liferay.portal.util.WebKeys;
34  
35  import java.io.IOException;
36  
37  import java.util.ArrayList;
38  import java.util.HashMap;
39  import java.util.List;
40  import java.util.Map;
41  import java.util.Set;
42  import java.util.concurrent.ConcurrentHashMap;
43  
44  import javax.portlet.ActionRequest;
45  import javax.portlet.ActionResponse;
46  import javax.portlet.EventRequest;
47  import javax.portlet.EventResponse;
48  import javax.portlet.Portlet;
49  import javax.portlet.PortletConfig;
50  import javax.portlet.PortletContext;
51  import javax.portlet.PortletException;
52  import javax.portlet.PortletRequest;
53  import javax.portlet.PortletSession;
54  import javax.portlet.RenderRequest;
55  import javax.portlet.RenderResponse;
56  import javax.portlet.ResourceRequest;
57  import javax.portlet.ResourceResponse;
58  import javax.portlet.filter.ActionFilter;
59  import javax.portlet.filter.EventFilter;
60  import javax.portlet.filter.FilterChain;
61  import javax.portlet.filter.PortletFilter;
62  import javax.portlet.filter.RenderFilter;
63  import javax.portlet.filter.ResourceFilter;
64  
65  import javax.servlet.RequestDispatcher;
66  import javax.servlet.ServletException;
67  import javax.servlet.http.HttpServletRequest;
68  import javax.servlet.http.HttpServletResponse;
69  import javax.servlet.http.HttpSession;
70  
71  import org.apache.commons.lang.time.StopWatch;
72  
73  /**
74   * <a href="InvokerPortletImpl.java.html"><b><i>View Source</i></b></a>
75   *
76   * @author Brian Wing Shun Chan
77   * @author Brian Myunghun Kim
78   */
79  public class InvokerPortletImpl implements InvokerPortlet {
80  
81      public static void clearResponse(
82          HttpSession session, long plid, String portletId, String languageId) {
83  
84          String sesResponseId = encodeResponseKey(plid, portletId, languageId);
85  
86          getResponses(session).remove(sesResponseId);
87      }
88  
89      public static void clearResponses(HttpSession session) {
90          getResponses(session).clear();
91      }
92  
93      public static void clearResponses(PortletSession session) {
94          getResponses(session).clear();
95      }
96  
97      public static String encodeResponseKey(
98          long plid, String portletId, String languageId) {
99  
100         StringBundler sb = new StringBundler(5);
101 
102         sb.append(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         removePortletFilters();
521 
522         Map<String, com.liferay.portal.model.PortletFilter> portletFilters =
523             _portletModel.getPortletFilters();
524 
525         for (Map.Entry<String, com.liferay.portal.model.PortletFilter> entry :
526                 portletFilters.entrySet()) {
527 
528             com.liferay.portal.model.PortletFilter portletFilterModel =
529                 entry.getValue();
530 
531             PortletFilter portletFilter = PortletFilterFactory.create(
532                 portletFilterModel, _portletContextImpl);
533 
534             Set<String> lifecycles = portletFilterModel.getLifecycles();
535 
536             if (lifecycles.contains(PortletRequest.ACTION_PHASE)) {
537                 List<ActionFilter> actionFilters = _actionFiltersMap.get(
538                     _portletId);
539 
540                 if (actionFilters == null) {
541                     actionFilters = new ArrayList<ActionFilter>();
542                 }
543 
544                 actionFilters.add((ActionFilter)portletFilter);
545 
546                 _actionFiltersMap.put(_portletId, actionFilters);
547             }
548 
549             if (lifecycles.contains(PortletRequest.EVENT_PHASE)) {
550                 List<EventFilter> eventFilters = _eventFiltersMap.get(
551                     _portletId);
552 
553                 if (eventFilters == null) {
554                     eventFilters = new ArrayList<EventFilter>();
555                 }
556 
557                 eventFilters.add((EventFilter)portletFilter);
558 
559                 _eventFiltersMap.put(_portletId, eventFilters);
560             }
561 
562             if (lifecycles.contains(PortletRequest.RENDER_PHASE)) {
563                 List<RenderFilter> renderFilters = _renderFiltersMap.get(
564                     _portletId);
565 
566                 if (renderFilters == null) {
567                     renderFilters = new ArrayList<RenderFilter>();
568                 }
569 
570                 renderFilters.add((RenderFilter)portletFilter);
571 
572                 _renderFiltersMap.put(_portletId, renderFilters);
573             }
574 
575             if (lifecycles.contains(PortletRequest.RESOURCE_PHASE)) {
576                 List<ResourceFilter> resourceFilters = _resourceFiltersMap.get(
577                     _portletId);
578 
579                 if (resourceFilters == null) {
580                     resourceFilters = new ArrayList<ResourceFilter>();
581                 }
582 
583                 resourceFilters.add((ResourceFilter)portletFilter);
584 
585                 _resourceFiltersMap.put(_portletId, resourceFilters);
586             }
587         }
588     }
589 
590     protected void invoke(
591             LiferayPortletRequest portletRequest,
592             LiferayPortletResponse portletResponse, String lifecycle,
593             List<? extends PortletFilter> filters)
594         throws IOException, PortletException {
595 
596         FilterChain filterChain = new FilterChainImpl(_portlet, filters);
597 
598         if (_portletConfigImpl.isWARFile()) {
599             String invokerPortletName = _portletConfigImpl.getInitParameter(
600                 INIT_INVOKER_PORTLET_NAME);
601 
602             if (invokerPortletName == null) {
603                 invokerPortletName = _portletConfigImpl.getPortletName();
604             }
605 
606             String path = StringPool.SLASH + invokerPortletName + "/invoke";
607 
608             RequestDispatcher requestDispatcher =
609                 _portletContextImpl.getServletContext().getRequestDispatcher(
610                     path);
611 
612             HttpServletRequest request = portletRequest.getHttpServletRequest();
613             HttpServletResponse response =
614                 portletResponse.getHttpServletResponse();
615 
616             request.setAttribute(JavaConstants.JAVAX_PORTLET_PORTLET, _portlet);
617             request.setAttribute(PortletRequest.LIFECYCLE_PHASE, lifecycle);
618             request.setAttribute(
619                 PortletServlet.PORTLET_SERVLET_FILTER_CHAIN, filterChain);
620 
621             try {
622 
623                 // Resource phase must be a forward because includes do not
624                 // allow you to specify the content type or headers
625 
626                 if (lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
627                     requestDispatcher.forward(request, response);
628                 }
629                 else {
630                     requestDispatcher.include(request, response);
631                 }
632             }
633             catch (ServletException se) {
634                 Throwable cause = se.getRootCause();
635 
636                 if (cause instanceof PortletException) {
637                     throw (PortletException)cause;
638                 }
639 
640                 throw new PortletException(cause);
641             }
642         }
643         else {
644             PortletFilterUtil.doFilter(
645                 portletRequest, portletResponse, lifecycle, filterChain);
646         }
647 
648         Map<String, String[]> properties = portletResponse.getProperties();
649 
650         if ((properties != null) && (properties.size() > 0)) {
651             if (_expCache != null) {
652                 String[] expCache = properties.get(
653                     RenderResponse.EXPIRATION_CACHE);
654 
655                 if ((expCache != null) && (expCache.length > 0) &&
656                     (expCache[0] != null)) {
657 
658                     _expCache = new Integer(GetterUtil.getInteger(expCache[0]));
659                 }
660             }
661         }
662     }
663 
664     protected void invokeAction(
665             ActionRequest actionRequest, ActionResponse actionResponse)
666         throws IOException, PortletException {
667 
668         LiferayPortletRequest portletRequest =
669             (LiferayPortletRequest)actionRequest;
670         LiferayPortletResponse portletResponse =
671             (LiferayPortletResponse)actionResponse;
672 
673         String portletId = _getPortletId(portletResponse);
674 
675         List<ActionFilter> actionFilters = _actionFiltersMap.get(portletId);
676 
677         invoke(
678             portletRequest, portletResponse, PortletRequest.ACTION_PHASE,
679             actionFilters);
680     }
681 
682     protected void invokeEvent(
683             EventRequest eventRequest, EventResponse eventResponse)
684         throws IOException, PortletException {
685 
686         LiferayPortletRequest portletRequest =
687             (LiferayPortletRequest)eventRequest;
688         LiferayPortletResponse portletResponse =
689             (LiferayPortletResponse)eventResponse;
690 
691         String portletId = _getPortletId(portletResponse);
692 
693         List<EventFilter> eventFilters = _eventFiltersMap.get(portletId);
694 
695         invoke(
696             portletRequest, portletResponse, PortletRequest.EVENT_PHASE,
697             eventFilters);
698     }
699 
700     protected String invokeRender(
701             RenderRequest renderRequest, RenderResponse renderResponse)
702         throws IOException, PortletException {
703 
704         LiferayPortletRequest portletRequest =
705             (LiferayPortletRequest)renderRequest;
706         LiferayPortletResponse portletResponse =
707             (LiferayPortletResponse)renderResponse;
708 
709         String portletId = _getPortletId(portletResponse);
710 
711         List<RenderFilter> renderFilters = _renderFiltersMap.get(portletId);
712 
713         invoke(
714             portletRequest, portletResponse, PortletRequest.RENDER_PHASE,
715             renderFilters);
716 
717         RenderResponseImpl renderResponseImpl =
718             (RenderResponseImpl)renderResponse;
719 
720         return renderResponseImpl.getTitle();
721     }
722 
723     protected void invokeResource(
724             ResourceRequest resourceRequest, ResourceResponse resourceResponse)
725         throws IOException, PortletException {
726 
727         LiferayPortletRequest portletRequest =
728             (LiferayPortletRequest)resourceRequest;
729         LiferayPortletResponse portletResponse =
730             (LiferayPortletResponse)resourceResponse;
731 
732         String portletId = _getPortletId(portletResponse);
733 
734         List<ResourceFilter> resourceFilters = _resourceFiltersMap.get(
735             portletId);
736 
737         invoke(
738             portletRequest, portletResponse, PortletRequest.RESOURCE_PHASE,
739             resourceFilters);
740     }
741 
742     protected void removePortletFilters() {
743         _actionFiltersMap.remove(_portletId);
744         _eventFiltersMap.remove(_portletId);
745         _renderFiltersMap.remove(_portletId);
746         _resourceFiltersMap.remove(_portletId);
747     }
748 
749     private String _getPortletId(LiferayPortletResponse portletResponse) {
750         PortletResponseImpl portletResponseImpl =
751             (PortletResponseImpl)portletResponse;
752 
753         com.liferay.portal.model.Portlet portlet =
754             portletResponseImpl.getPortlet();
755 
756         return portlet.getPortletId();
757     }
758 
759     private static Log _log = LogFactoryUtil.getLog(InvokerPortletImpl.class);
760 
761     private com.liferay.portal.model.Portlet _portletModel;
762     private String _portletId;
763     private Portlet _portlet;
764     private PortletConfigImpl _portletConfigImpl;
765     private PortletContextImpl _portletContextImpl;
766     private Integer _expCache;
767     private boolean _checkAuthToken;
768     private boolean _destroyable;
769     private boolean _facesPortlet;
770     private boolean _strutsPortlet;
771     private boolean _strutsBridgePortlet;
772     private Map<String, List<ActionFilter>> _actionFiltersMap =
773         new HashMap<String, List<ActionFilter>>();
774     private Map<String, List<EventFilter>> _eventFiltersMap =
775         new HashMap<String, List<EventFilter>>();
776     private Map<String, List<RenderFilter>> _renderFiltersMap =
777         new HashMap<String, List<RenderFilter>>();
778     private Map<String, List<ResourceFilter>> _resourceFiltersMap =
779         new HashMap<String, List<ResourceFilter>>();
780 
781 }