java类javax.servlet.ServletRequestEvent的实例源码

@Override
public void requestDestroyed(ServletRequestEvent requestEvent) {
    ServletRequestAttributes attributes = null;
    Object reqAttr = requestEvent.getServletRequest().getAttribute(REQUEST_ATTRIBUTES_ATTRIBUTE);
    if (reqAttr instanceof ServletRequestAttributes) {
        attributes = (ServletRequestAttributes) reqAttr;
    }
    RequestAttributes threadAttributes = RequestContextHolder.getRequestAttributes();
    if (threadAttributes != null) {
        // We're assumably within the original request thread...
        LocaleContextHolder.resetLocaleContext();
        RequestContextHolder.resetRequestAttributes();
        if (attributes == null && threadAttributes instanceof ServletRequestAttributes) {
            attributes = (ServletRequestAttributes) threadAttributes;
        }
    }
    if (attributes != null) {
        attributes.requestCompleted();
    }
}

@Override
public void requestDestroyed(ServletRequestEvent requestEvent) {
    ServletRequestAttributes attributes = null;
    Object reqAttr = requestEvent.getServletRequest().getAttribute(REQUEST_ATTRIBUTES_ATTRIBUTE);
    if (reqAttr instanceof ServletRequestAttributes) {
        attributes = (ServletRequestAttributes) reqAttr;
    }
    RequestAttributes threadAttributes = RequestContextHolder.getRequestAttributes();
    if (threadAttributes != null) {
        // We're assumably within the original request thread...
        LocaleContextHolder.resetLocaleContext();
        RequestContextHolder.resetRequestAttributes();
        if (attributes == null && threadAttributes instanceof ServletRequestAttributes) {
            attributes = (ServletRequestAttributes) threadAttributes;
        }
    }
    if (attributes != null) {
        attributes.requestCompleted();
    }
}

@Test
public void requestContextListenerWithSameThread() {
    RequestContextListener listener = new RequestContextListener();
    MockServletContext context = new MockServletContext();
    MockHttpServletRequest request = new MockHttpServletRequest(context);
    request.setAttribute("test", "value");

    assertNull(RequestContextHolder.getRequestAttributes());
    listener.requestInitialized(new ServletRequestEvent(context, request));
    assertNotNull(RequestContextHolder.getRequestAttributes());
    assertEquals("value",
            RequestContextHolder.getRequestAttributes().getAttribute("test", RequestAttributes.SCOPE_REQUEST));
    MockRunnable runnable = new MockRunnable();
    RequestContextHolder.getRequestAttributes().registerDestructionCallback(
            "test", runnable, RequestAttributes.SCOPE_REQUEST);

    listener.requestDestroyed(new ServletRequestEvent(context, request));
    assertNull(RequestContextHolder.getRequestAttributes());
    assertTrue(runnable.wasExecuted());
}

@Test
public void requestContextListenerWithSameThreadAndAttributesGone() {
    RequestContextListener listener = new RequestContextListener();
    MockServletContext context = new MockServletContext();
    MockHttpServletRequest request = new MockHttpServletRequest(context);
    request.setAttribute("test", "value");

    assertNull(RequestContextHolder.getRequestAttributes());
    listener.requestInitialized(new ServletRequestEvent(context, request));
    assertNotNull(RequestContextHolder.getRequestAttributes());
    assertEquals("value",
            RequestContextHolder.getRequestAttributes().getAttribute("test", RequestAttributes.SCOPE_REQUEST));
    MockRunnable runnable = new MockRunnable();
    RequestContextHolder.getRequestAttributes().registerDestructionCallback(
            "test", runnable, RequestAttributes.SCOPE_REQUEST);

    request.clearAttributes();
    listener.requestDestroyed(new ServletRequestEvent(context, request));
    assertNull(RequestContextHolder.getRequestAttributes());
    assertTrue(runnable.wasExecuted());
}

@Override
public void requestInitialized(ServletRequestEvent sre) {
    ServletContext servletContext = sre.getServletContext();
    ApplicationContext applicationContext = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);
    GroovyClassLoader classLoader = applicationContext.getBean(GroovyClassLoader.class);
    if (Thread.currentThread().getContextClassLoader() instanceof GroovyClassLoader) {
    } else {
        Thread.currentThread().setContextClassLoader(classLoader);
    }
    DataSource dataSource = applicationContext.getBean(DataSource.class);
    try {
        this.connection = dataSource.getConnection();
        this.connection.setAutoCommit(true);
    } catch (SQLException e) {
    }
}

@Override
public void requestInitialized(ServletRequestEvent e) {
    LOG.debug("Request entered");

    HttpServletRequest req = (HttpServletRequest) e.getServletRequest();
    WebConfiguration wc = Iocular.getConfiguration(e.getServletContext());
    Container sc = createSessionContainer(req.getSession(true));
    if(sc == null)
        throw new IllegalStateException("No session container found!?");

    //-- Create a request container,
    BasicContainer bc = new BasicContainer(wc.getRequestDefinition(), sc);
    bc.start();
    req.setAttribute(Keys.REQUEST_CONTAINER, bc);
    Iocular._setRequest((HttpServletRequest) e.getServletRequest(), bc);
}

/**
 * {@inheritDoc}
 */
public void doFilter(ServletRequest request, ServletResponse response)
    throws IOException, ServletException {
  // set our context classloader
  Thread.currentThread().setContextClassLoader(classLoader);
  // send a requestInititalized event
  ServletRequestEvent sre = new ServletRequestEvent(context, request);
  srListeners.requestInitialized(sre);
  // if (!sraListeners.isEmpty()) {
  // if we have at least one request attribute listener, wrap the
  // request so we can intercept calls to setAttribute/removeAttribute
  request = wrapRequestForServletRequestAttributeListeners(request);
  // }
  RegularExpressionRequestHandler handler = regexHandler.getRequestHandler();
  handler.doFilter(request, response);
}

@Test
public void testRequest() {
    DefaultServletEnvironment o = new DefaultServletEnvironment();

    assertFalse(o.request().isPresent());

    ServletContext mockContext = mock(ServletContext.class);
    ServletRequest mockRequest = mock(HttpServletRequest.class);
    o.requestInitialized(new ServletRequestEvent(mockContext, mockRequest));
    assertSame(mockRequest, o.request().get());

    o.requestDestroyed(new ServletRequestEvent(mockContext, mockRequest));
    assertFalse(o.request().isPresent());

    ServletRequest mockRequest2 = mock(HttpServletRequest.class);
    o.requestInitialized(new ServletRequestEvent(mockContext, mockRequest2));
    assertSame(mockRequest2, o.request().get());

    o.requestDestroyed(new ServletRequestEvent(mockContext, mockRequest2));
    assertFalse(o.request().isPresent());

    // TODO: test multithreaded scenario..
}

@Override
public void requestInitialized(ServletRequestEvent sre) {
    //System.out.println("Requset 初始化了:" + sre.getServletRequest());

    ServletContext ctx = sre.getServletContext();
    exector.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName());
            Integer count = (Integer) ctx.getAttribute(BookStoreConstants.REQUEST_COUNT); // 获得list
            if (count == null) {
                count = 0;
            }
            ctx.setAttribute(BookStoreConstants.REQUEST_COUNT, count+1);

        }
    });


}

@Override
public void requestDestroyed(ServletRequestEvent arg0) {
    logger.entering("DBInitializer","requestDestroyed");
    ServletRequest req = arg0.getServletRequest();

    req.removeAttribute(StringConstants.REQUEST_ATTR_USER_DAO);
    req.removeAttribute(StringConstants.REQUEST_ATTR_TAG_DAO);
    req.removeAttribute(StringConstants.REQUEST_ATTR_SCREEN_DAO );
    req.removeAttribute(StringConstants.REQUEST_ATTR_CONTENT_DAO );
    req.removeAttribute(StringConstants.REQUEST_ATTR_SETTING_DAO );
    req.removeAttribute(StringConstants.REQUEST_ATTR_ENTITY_MANAGER);

    EntityManager em = (EntityManager) req.getAttribute(StringConstants.REQUEST_ATTR_ENTITY_MANAGER);
    if(em!=null && em.isOpen()){
        em.close();
    }
    req.removeAttribute(StringConstants.REQUEST_ATTR_ENTITY_MANAGER);

    logger.exiting("DBInitializer","requestDestroyed");
}

@Override
public void requestInitialized(ServletRequestEvent arg0) {
    logger.entering("DBInitializer","requestInitialized");
    EntityManager em = DBConfig.getEntityManager();
    UserDao userDAO = new UserDao(em);
    TagDao tagDAO = new TagDao(em);
    ScreenDao screenDAO = new ScreenDao(em);
    ContentDao contentDAO = new ContentDao(em);
    SettingDao settingDAO = new SettingDao(em);

    ServletRequest req = arg0.getServletRequest();
    req.setAttribute(StringConstants.REQUEST_ATTR_USER_DAO, userDAO);
    req.setAttribute(StringConstants.REQUEST_ATTR_TAG_DAO, tagDAO);
    req.setAttribute(StringConstants.REQUEST_ATTR_SCREEN_DAO, screenDAO);
    req.setAttribute(StringConstants.REQUEST_ATTR_CONTENT_DAO, contentDAO);
    req.setAttribute(StringConstants.REQUEST_ATTR_SETTING_DAO, settingDAO);
    req.setAttribute(StringConstants.REQUEST_ATTR_ENTITY_MANAGER, em);
    logger.exiting("DBInitializer","requestInitialized");
}

public void requestDestroyed(ServletRequestEvent requestEvent) {
    ServletRequestAttributes attributes = null;
    Object reqAttr = requestEvent.getServletRequest().getAttribute(REQUEST_ATTRIBUTES_ATTRIBUTE);
    if (reqAttr instanceof ServletRequestAttributes) {
        attributes = (ServletRequestAttributes) reqAttr;
    }
    RequestAttributes threadAttributes = RequestContextHolder.getRequestAttributes();
    if (threadAttributes != null) {
        // We're assumably within the original request thread...
        LocaleContextHolder.resetLocaleContext();
        RequestContextHolder.resetRequestAttributes();
        if (attributes == null && threadAttributes instanceof ServletRequestAttributes) {
            attributes = (ServletRequestAttributes) threadAttributes;
        }
    }
    if (attributes != null) {
        attributes.requestCompleted();
    }
}

public void testRequestContextListenerWithSameThread() {
    RequestContextListener listener = new RequestContextListener();
    MockServletContext context = new MockServletContext();
    MockHttpServletRequest request = new MockHttpServletRequest(context);
    request.setAttribute("test", "value");

    assertNull(RequestContextHolder.getRequestAttributes());
    listener.requestInitialized(new ServletRequestEvent(context, request));
    assertNotNull(RequestContextHolder.getRequestAttributes());
    assertEquals("value",
            RequestContextHolder.getRequestAttributes().getAttribute("test", RequestAttributes.SCOPE_REQUEST));
    MockRunnable runnable = new MockRunnable();
    RequestContextHolder.getRequestAttributes().registerDestructionCallback(
            "test", runnable, RequestAttributes.SCOPE_REQUEST);

    listener.requestDestroyed(new ServletRequestEvent(context, request));
    assertNull(RequestContextHolder.getRequestAttributes());
    assertTrue(runnable.wasExecuted());
}

public void testRequestContextListenerWithSameThreadAndAttributesGone() {
    RequestContextListener listener = new RequestContextListener();
    MockServletContext context = new MockServletContext();
    MockHttpServletRequest request = new MockHttpServletRequest(context);
    request.setAttribute("test", "value");

    assertNull(RequestContextHolder.getRequestAttributes());
    listener.requestInitialized(new ServletRequestEvent(context, request));
    assertNotNull(RequestContextHolder.getRequestAttributes());
    assertEquals("value",
            RequestContextHolder.getRequestAttributes().getAttribute("test", RequestAttributes.SCOPE_REQUEST));
    MockRunnable runnable = new MockRunnable();
    RequestContextHolder.getRequestAttributes().registerDestructionCallback(
            "test", runnable, RequestAttributes.SCOPE_REQUEST);

    request.clearAttributes();
    listener.requestDestroyed(new ServletRequestEvent(context, request));
    assertNull(RequestContextHolder.getRequestAttributes());
    assertTrue(runnable.wasExecuted());
}

/**
 * Test of getPage method, of class fr.paris.lutece.portal.web.search.SearchApp.
 * 
 * @throws SiteMessageException
 */
public void testGetPage( ) throws SiteMessageException
{
    System.out.println( "getPage" );

    MockHttpServletRequest request = new MockHttpServletRequest( );
    request.addParameter( "query", "lutece" );
    request.addParameter( "items_per_page", "5" );

    RequestContextListener listener = new RequestContextListener( );
    ServletContext context = new MockServletContext( );
    listener.requestInitialized( new ServletRequestEvent( context, request ) );

    int nMode = 0;
    Plugin plugin = null;
    SearchApp instance = SpringContextService.getBean( "core.xpage.search" );

    XPage result = instance.getPage( request, nMode, plugin );

    listener.requestDestroyed( new ServletRequestEvent( context, request ) );
}

@Override
public void service(HttpServletRequest req, HttpServletResponse res)
    throws ServletException, IOException
{
    final ServletRequestEvent sre = new ServletRequestEvent(getServletContext(), req);
    this.controller.getRequestListener().requestInitialized(sre);
    try
    {
        req = new AttributeEventRequest(getServletContext(), this.controller.getRequestAttributeListener(), req);
        this.controller.getDispatcher().dispatch(req, res, new NotFoundFilterChain());
    }
    finally
    {
        this.controller.getRequestListener().requestDestroyed(sre);
    }
}

/**
 * {@inheritDoc}
 */
@Override
public void requestInitialized(final ServletRequestEvent event) {
    final Object oldContext = ThreadSingletonServiceImpl.enter(this.webBeansContext);
    if (event != null) {
        event.getServletRequest().setAttribute(contextKey, oldContext);
    }

    try {
        if (logger.isDebugEnabled()) {
            logger.debug("Starting a new request : [{0}]", event == null ? "null" : event.getServletRequest().getRemoteAddr());
        }

        if (webBeansContext instanceof WebappWebBeansContext) { // start before child
            ((WebappWebBeansContext) webBeansContext).getParent().getContextsService().startContext(RequestScoped.class, event);
        }
        contextsService.startContext(RequestScoped.class, event);

        // we don't initialise the Session here but do it lazily if it gets requested
        // the first time. See OWB-457

    } catch (final Exception e) {
        logger.error(OWBLogConst.ERROR_0019, event == null ? "null" : event.getServletRequest());
        WebBeansUtil.throwRuntimeExceptions(e);
    }
}

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));
    }
}

/**
 * Generate a new request instance which will be read by the servlet
 * context and callback
 */
@Before
public void setUp() {
    HttpServletRequest request = mock(HttpServletRequest.class);

    Map<String, String[]> params = new HashMap<String, String[]>();
    params.put("account", new String[]{"Acme Co"});
    params.put("name", new String[]{"Bill"});
    when(request.getParameterMap()).thenReturn(params);

    when(request.getMethod()).thenReturn("PATCH");
    when(request.getRequestURL()).thenReturn(new StringBuffer("/foo/bar"));
    when(request.getRequestURI()).thenReturn("/foo/bar");
    when(request.getRemoteAddr()).thenReturn("12.0.4.57");

    Enumeration<String> headers = new Vector<String>(
            Arrays.asList("Content-Type", "Content-Length")).elements();
    when(request.getHeaderNames()).thenReturn(headers);
    when(request.getHeader("Content-Type")).thenReturn("application/json");
    when(request.getHeader("Content-Length")).thenReturn("54");

    ServletContext context = mock(ServletContext.class);
    BugsnagServletRequestListener listener = new BugsnagServletRequestListener();
    listener.requestInitialized(new ServletRequestEvent(context, request));
}

public void requestDestroyed(ServletRequestEvent servletRequestEvent) {
    ServletRequestAttributes attributes = (ServletRequestAttributes) servletRequestEvent.getServletRequest()
            .getAttribute(REQUEST_ATTRIBUTES_ATTRIBUTE);
    ServletRequestAttributes threadAttributes =
            (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
    if (threadAttributes != null) {
        if (attributes == null) {
            attributes = threadAttributes;
        }
        RequestContextHolder.setRequestAttributes(null);
        LocaleContextHolder.setLocale(null);
    }
    if (attributes != null) {
        attributes.requestCompleted();
    }
}

/**
 * Receives notification that a ServletRequest is about to come into scope of the web application.
 *
 * @param sre
 *            the ServletRequestEvent containing the ServletRequest and the ServletContext representing the web
 *            application
 */
@Override
public void requestInitialized(ServletRequestEvent sre) {
    // TODO: log debug level only
    // System.out.println(HttpSessionInitializer.class.getSimpleName() + ": requestInitialized");

    HttpServletRequest servletRequest = (HttpServletRequest) sre.getServletRequest();

    // call getSession() so that the Servlet Container will initialize the HttpSession
    servletRequest.getSession();
}

public void requestDestroyed(ServletRequestEvent servletRequestEvent) {
    HttpServletRequest request=(HttpServletRequest)servletRequestEvent.getServletRequest();
    long now=System.currentTimeMillis();
    try {
        HOOK.get().postHook();
    } catch (RpcTransactionRollbackException e) {
        e.printStackTrace();
    }
    log.debug(request.getRequestURL()+" spend:"+(System.currentTimeMillis()-now));
    HOOK.set(null);
}

@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;
}

@Override
public void requestInitialized(ServletRequestEvent requestEvent) {
    if (!(requestEvent.getServletRequest() instanceof HttpServletRequest)) {
        throw new IllegalArgumentException(
                "Request is not an HttpServletRequest: " + requestEvent.getServletRequest());
    }
    HttpServletRequest request = (HttpServletRequest) requestEvent.getServletRequest();
    ServletRequestAttributes attributes = new ServletRequestAttributes(request);
    request.setAttribute(REQUEST_ATTRIBUTES_ATTRIBUTE, attributes);
    LocaleContextHolder.setLocale(request.getLocale());
    RequestContextHolder.setRequestAttributes(attributes);
}

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 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;
}

@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;
}