001
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
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
579
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 }