@Override public void onStartup(ServletContext webappContext) throws ServletException { ModuleDataExtractor extractor = new ModuleDataExtractor(module); environment.assureModule(module); String fullRestResource = "/" + module.getContext() + "/*"; ServerData serverData = new ServerData(environment.getModuleBean(module).getPort(), Arrays.asList(), rootContext, fullRestResource, module); List<FilterData> filterDataList = extractor.createFilteredDataList(serverData); List<ServletData> servletDataList = extractor.createServletDataList(serverData); new ServletConfigurer(serverData, LinkedListX.fromIterable(servletDataList)).addServlets(webappContext); new FilterConfigurer(serverData, LinkedListX.fromIterable(filterDataList)).addFilters(webappContext); PersistentList<ServletContextListener> servletContextListenerData = LinkedListX.fromIterable(module.getListeners(serverData)).filter(i->!(i instanceof ContextLoader)); PersistentList<ServletRequestListener> servletRequestListenerData = LinkedListX.fromIterable(module.getRequestListeners(serverData)); new ServletContextListenerConfigurer(serverData, servletContextListenerData, servletRequestListenerData).addListeners(webappContext); }
public void addListeners(ServletContext webappContext) { serverData.getRootContext() .getBeansOfType(ServletContextListener.class) .values() .stream() .peek(this::logListener) .forEach(listener -> webappContext.addListener(listener)); listenerData.forEach(it -> webappContext.addListener(it)); serverData.getRootContext() .getBeansOfType(ServletRequestListener.class) .values() .stream() .peek(this::logListener) .forEach(listener -> webappContext.addListener(listener)); listenerRequestData.forEach(it -> webappContext.addListener(it)); }
/** * Init method called by the main servlet when the wrapping servlet is initialized. This means that the context is * taken into service by the system. * * @param parent The parent servlet context. Just for some delegation actions */ void init(ServletContext parent) { // Set up the tracking of event listeners. BundleContext bc = getOwner().getBundleContext(); delegate = parent; Collection<Class<? extends EventListener>> toTrack = Arrays.asList(HttpSessionListener.class, ServletRequestListener.class, HttpSessionAttributeListener.class, ServletRequestAttributeListener.class, ServletContextListener.class); Collection<String> objectFilters = toTrack.stream(). map((c) -> "(" + Constants.OBJECTCLASS + "=" + c.getName() + ")").collect(Collectors.toList()); String filterString = "|" + String.join("", objectFilters); eventListenerTracker = startTracking(filterString, new Tracker<EventListener, EventListener>(bc, getContextPath(), (e) -> e, (e) -> { /* No destruct */})); // Initialize the servlets. ServletContextEvent event = new ServletContextEvent(this); call(ServletContextListener.class, (l) -> l.contextInitialized(event)); servlets.values().forEach((s) -> init(s)); // And the filters. filters.values().forEach((f) -> init(f)); // Set up the tracking of servlets and filters. servletTracker = startTracking(Constants.OBJECTCLASS + "=" + Servlet.class.getName(), new Tracker<Servlet, String>(bc, getContextPath(), this::addServlet, this::removeServlet)); filterTracker = startTracking(Constants.OBJECTCLASS + "=" + Filter.class.getName(), new Tracker<Filter, String>(bc, getContextPath(), this::addFilter, this::removeFilter)); }
public void destroy() { final boolean openejbRequestDestroyed = getAttribute("openejb_requestDestroyed") == null; if (listeners != null && !listeners.isEmpty()) { if (begin != null && end != null && openejbRequestDestroyed) { end.requestDestroyed(new ServletRequestEvent(getServletContext(), this)); } final ServletRequestEvent event = new ServletRequestEvent(getServletContext(), this); for (final ServletRequestListener listener : listeners) { listener.requestDestroyed(event); } } if (begin != null && openejbRequestDestroyed) { setAttribute("openejb_requestDestroyed", "ok"); begin.requestDestroyed(new ServletRequestEvent(getServletContext(), this)); } }
private static boolean isWeb(final Class<?> beanClass) { if (Servlet.class.isAssignableFrom(beanClass) || Filter.class.isAssignableFrom(beanClass)) { return true; } if (EventListener.class.isAssignableFrom(beanClass)) { return HttpSessionAttributeListener.class.isAssignableFrom(beanClass) || ServletContextListener.class.isAssignableFrom(beanClass) || ServletRequestListener.class.isAssignableFrom(beanClass) || ServletContextAttributeListener.class.isAssignableFrom(beanClass) || HttpSessionListener.class.isAssignableFrom(beanClass) || HttpSessionBindingListener.class.isAssignableFrom(beanClass) || HttpSessionActivationListener.class.isAssignableFrom(beanClass) || HttpSessionIdListener.class.isAssignableFrom(beanClass) || ServletRequestAttributeListener.class.isAssignableFrom(beanClass); } return false; }
@Override public <T extends EventListener> void addListener(T t) { if (!context.getState().equals(LifecycleState.STARTING_PREP)) { throw new IllegalStateException( sm.getString("applicationContext.addListener.ise", getContextPath())); } boolean match = false; if (t instanceof ServletContextAttributeListener || t instanceof ServletRequestListener || t instanceof ServletRequestAttributeListener || t instanceof HttpSessionAttributeListener) { context.addApplicationEventListener(t); match = true; } if (t instanceof HttpSessionListener || (t instanceof ServletContextListener && newServletContextListenerAllowed)) { // Add listener directly to the list of instances rather than to // the list of class names. context.addApplicationLifecycleListener(t); match = true; } if (match) return; if (t instanceof ServletContextListener) { throw new IllegalArgumentException(sm.getString( "applicationContext.addListener.iae.sclNotAllowed", t.getClass().getName())); } else { throw new IllegalArgumentException(sm.getString( "applicationContext.addListener.iae.wrongType", t.getClass().getName())); } }
@Override public boolean fireRequestInitEvent(ServletRequest request) { Object instances[] = getApplicationEventListeners(); if ((instances != null) && (instances.length > 0)) { ServletRequestEvent event = new ServletRequestEvent(getServletContext(), request); for (int i = 0; i < instances.length; i++) { if (instances[i] == null) continue; if (!(instances[i] instanceof ServletRequestListener)) continue; ServletRequestListener listener = (ServletRequestListener) instances[i]; try { listener.requestInitialized(event); } catch (Throwable t) { ExceptionUtils.handleThrowable(t); getLogger().error(sm.getString( "standardContext.requestListener.requestInit", instances[i].getClass().getName()), t); request.setAttribute(RequestDispatcher.ERROR_EXCEPTION, t); return false; } } } return true; }
@Override public boolean fireRequestDestroyEvent(ServletRequest request) { Object instances[] = getApplicationEventListeners(); if ((instances != null) && (instances.length > 0)) { ServletRequestEvent event = new ServletRequestEvent(getServletContext(), request); for (int i = 0; i < instances.length; i++) { int j = (instances.length -1) -i; if (instances[j] == null) continue; if (!(instances[j] instanceof ServletRequestListener)) continue; ServletRequestListener listener = (ServletRequestListener) instances[j]; try { listener.requestDestroyed(event); } catch (Throwable t) { ExceptionUtils.handleThrowable(t); getLogger().error(sm.getString( "standardContext.requestListener.requestInit", instances[j].getClass().getName()), t); request.setAttribute(RequestDispatcher.ERROR_EXCEPTION, t); return false; } } } return true; }
public void requestDestroyed(final ServletRequest request) { final ServletRequestEvent sre = new ServletRequestEvent(servletContext, request); for (int i = servletRequestListeners.length - 1; i >= 0; --i) { ManagedListener listener = servletRequestListeners[i]; try { this.<ServletRequestListener>get(listener).requestDestroyed(sre); } catch (Exception e) { UndertowServletLogger.REQUEST_LOGGER.errorInvokingListener("requestDestroyed", listener.getListenerInfo().getListenerClass(), e); } } }
@Override public <T extends EventListener> void addListener(T t) { if (!context.getState().equals(LifecycleState.STARTING_PREP)) { throw new IllegalStateException(sm.getString("applicationContext.addListener.ise", getContextPath())); } boolean match = false; if (t instanceof ServletContextAttributeListener || t instanceof ServletRequestListener || t instanceof ServletRequestAttributeListener || t instanceof HttpSessionAttributeListener) { context.addApplicationEventListener(t); match = true; } if (t instanceof HttpSessionListener || (t instanceof ServletContextListener && newServletContextListenerAllowed)) { // Add listener directly to the list of instances rather than to // the list of class names. context.addApplicationLifecycleListener(t); match = true; } if (match) return; if (t instanceof ServletContextListener) { throw new IllegalArgumentException( sm.getString("applicationContext.addListener.iae.sclNotAllowed", t.getClass().getName())); } else { throw new IllegalArgumentException( sm.getString("applicationContext.addListener.iae.wrongType", t.getClass().getName())); } }
@Override public boolean fireRequestInitEvent(ServletRequest request) { Object instances[] = getApplicationEventListeners(); if ((instances != null) && (instances.length > 0)) { ServletRequestEvent event = new ServletRequestEvent(getServletContext(), request); for (int i = 0; i < instances.length; i++) { if (instances[i] == null) continue; if (!(instances[i] instanceof ServletRequestListener)) continue; ServletRequestListener listener = (ServletRequestListener) instances[i]; try { listener.requestInitialized(event); } catch (Throwable t) { ExceptionUtils.handleThrowable(t); getLogger().error(sm.getString("standardContext.requestListener.requestInit", instances[i].getClass().getName()), t); request.setAttribute(RequestDispatcher.ERROR_EXCEPTION, t); return false; } } } return true; }
@Override public boolean fireRequestDestroyEvent(ServletRequest request) { Object instances[] = getApplicationEventListeners(); if ((instances != null) && (instances.length > 0)) { ServletRequestEvent event = new ServletRequestEvent(getServletContext(), request); for (int i = 0; i < instances.length; i++) { int j = (instances.length - 1) - i; if (instances[j] == null) continue; if (!(instances[j] instanceof ServletRequestListener)) continue; ServletRequestListener listener = (ServletRequestListener) instances[j]; try { listener.requestDestroyed(event); } catch (Throwable t) { ExceptionUtils.handleThrowable(t); getLogger().error(sm.getString("standardContext.requestListener.requestInit", instances[j].getClass().getName()), t); request.setAttribute(RequestDispatcher.ERROR_EXCEPTION, t); return false; } } } return true; }
private void loadListeners(WebAppConfiguration wac) throws ClassNotFoundException, IllegalAccessException, InstantiationException, WebAppConfigurationException { for (WebAppListener listener : wac.getListeners()) { String className = listener.getListenerClass(); Class<?> clazz = classLoader.loadClass(className); Object obj = clazz.newInstance(); boolean used = false; if (obj instanceof ServletContextAttributeListener) { scaListeners.add((ServletContextAttributeListener) obj); used = true; } if (obj instanceof ServletContextListener) { scListeners.add((ServletContextListener) obj); used = true; } if (obj instanceof ServletRequestListener) { srListeners.add((ServletRequestListener) obj); used = true; } if (obj instanceof ServletRequestAttributeListener) { sraListeners.add((ServletRequestAttributeListener) obj); used = true; } if (obj instanceof HttpSessionAttributeListener) { sessionAttributeListeners.add((HttpSessionAttributeListener) obj); used = true; } if (obj instanceof HttpSessionListener) { sessionListeners.add((HttpSessionListener) obj); used = true; } if (!used) { throw new WebAppConfigurationException("Don't know what to do with '" + className + "'"); } } }
@Test public void testContributeListeners_ServletRequestListener() throws Exception { ServletRequestListener srListener = mock(ServletRequestListener.class); startApp(b -> JettyModule.extend(b).addListener(srListener)); verify(srListener, times(0)).requestInitialized(any()); verify(srListener, times(0)).requestDestroyed(any()); WebTarget base = ClientBuilder.newClient().target("http://localhost:8080"); base.path("/a").request().get(); Thread.sleep(100); verify(srListener, times(1)).requestInitialized(any()); verify(srListener, times(1)).requestDestroyed(any()); base.path("/b").request().get(); Thread.sleep(100); verify(srListener, times(2)).requestInitialized(any()); verify(srListener, times(2)).requestDestroyed(any()); // not_found request base.path("/c").request().get(); Thread.sleep(100); verify(srListener, times(3)).requestInitialized(any()); verify(srListener, times(3)).requestDestroyed(any()); }
default List<ServletRequestListener> getRequestListeners(ServerData data) { return PluginLoader.INSTANCE.plugins.get() .stream() .filter(module -> module.servletRequestListeners() != null) .flatMapI(Plugin::servletRequestListeners) .map(fn -> fn.apply(data)) .to().listX(); }
@Override public List<ServletRequestListener> getRequestListeners(ServerData data) { if (requestListeners != null) return ListX.fromIterable(concat(this.requestListeners, extract(() -> Module.super.getRequestListeners(data)))); return Module.super.getRequestListeners(data); }
public AllData(ServerData serverData, List<FilterData> filterDataList, List<ServletData> servletDataList, List<ServletContextListener> servletContextListeners, List<ServletRequestListener> servletRequestListeners ) { this.servletContextListeners = Seq.fromIterable(UsefulStaticMethods.either(servletContextListeners, new ArrayList<ServletContextListener>())); this.servletRequestListeners = Seq.fromIterable(UsefulStaticMethods.either(servletRequestListeners, new ArrayList<ServletRequestListener>())); this.filterDataList = Seq.fromIterable(UsefulStaticMethods.either(filterDataList, new ArrayList<FilterData>())); this.servletDataList = Seq.fromIterable(UsefulStaticMethods.either(servletDataList, new ArrayList<ServletData>())); this.serverData = serverData; }
public AllData(ServerData serverData, PersistentList<FilterData> filterDataList, PersistentList<ServletData> servletDataList, PersistentList<ServletContextListener> servletContextListeners, PersistentList<ServletRequestListener> servletRequestListeners ) { this.servletContextListeners = Seq.fromIterable(UsefulStaticMethods.either(servletContextListeners, new ArrayList<ServletContextListener>())); this.servletRequestListeners = Seq.fromIterable(UsefulStaticMethods.either(servletRequestListeners, new ArrayList<ServletRequestListener>())); this.filterDataList = Seq.fromIterable(UsefulStaticMethods.either(filterDataList, new ArrayList<FilterData>())); this.servletDataList = Seq.fromIterable(UsefulStaticMethods.either(servletDataList, new ArrayList<ServletData>())); this.serverData = serverData; }
private void addListenerInstance(final Object listenerInstance, final List<ServletContextAttributeListener> contextAttributeListeners, final List<ServletContextListener> contextListeners, final List<ServletRequestAttributeListener> requestAttributeListeners, final List<ServletRequestListener> requestListeners, final List<HttpSessionActivationListener> sessionActivationListeners, final List<HttpSessionAttributeListener> sessionAttributeListeners, final List<HttpSessionListener> sessionListeners) { if (listenerInstance instanceof ServletContextAttributeListener) { contextAttributeListeners.add((ServletContextAttributeListener) listenerInstance); } if (listenerInstance instanceof ServletContextListener) { contextListeners.add((ServletContextListener) listenerInstance); } if (listenerInstance instanceof ServletRequestAttributeListener) { requestAttributeListeners.add((ServletRequestAttributeListener) listenerInstance); } if (listenerInstance instanceof ServletRequestListener) { requestListeners.add((ServletRequestListener) listenerInstance); } if (listenerInstance instanceof HttpSessionActivationListener) { sessionActivationListeners.add((HttpSessionActivationListener) listenerInstance); } if (listenerInstance instanceof HttpSessionAttributeListener) { sessionAttributeListeners.add((HttpSessionAttributeListener) listenerInstance); } if (listenerInstance instanceof HttpSessionListener) { sessionListeners.add((HttpSessionListener) listenerInstance); } }
@Override public void requestInitialized(ServletRequestEvent event) { requestContextListener.requestInitialized(event); for (ServletRequestListener requestListener : HANDLER.requestListeners) { HANDLER.executeInjection(requestListener); requestListener.requestInitialized(event); } }
@Override public void requestDestroyed(ServletRequestEvent event) { requestContextListener.requestDestroyed(event); for (ServletRequestListener requestListener : HANDLER.requestListeners) { requestListener.requestDestroyed(event); } }
public void requestDestroyed(final ServletRequestEvent sre) { final Iterator<ServletRequestListener> listeners = getContextListeners(); while (listeners.hasNext()) { listeners.next().requestDestroyed(sre); } }
public void requestInitialized(final ServletRequestEvent sre) { final Iterator<ServletRequestListener> listeners = getContextListeners(); while (listeners.hasNext()) { listeners.next().requestInitialized(sre); } }
public static void destroyFakedRequest(final ServletRequestListener listener) { final Boolean faked = FAKE_REQUEST.get(); try { if (faked != null && faked) { listener.requestDestroyed(null); } } finally { FAKE_REQUEST.remove(); } }
public static void ensureRequestScope(final ContextsService cs, final ServletRequestListener listener) { final Context reqCtx = cs.getCurrentContext(RequestScoped.class); if (reqCtx == null || !cs.getCurrentContext(RequestScoped.class).isActive()) { listener.requestInitialized(null); FAKE_REQUEST.set(true); } }
public void init() { if (begin != null && getAttribute("openejb_requestInitialized") == null) { setAttribute("openejb_requestInitialized", "ok"); // if called again we loose the request scope begin.requestInitialized(new ServletRequestEvent(getServletContext(), this)); } listeners = LightweightWebAppBuilderListenerExtractor.findByTypeForContext(contextPath, ServletRequestListener.class); if (!listeners.isEmpty()) { final ServletRequestEvent event = new ServletRequestEvent(getServletContext(), this); for (final ServletRequestListener listener : listeners) { listener.requestInitialized(event); } } }
public void requestInitialized(final ServletRequest request) { final ServletRequestEvent sre = new ServletRequestEvent(servletContext, request); for (int i = 0; i < servletRequestListeners.length; ++i) { this.<ServletRequestListener>get(servletRequestListeners[i]).requestInitialized(sre); } }
