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