Java 类org.springframework.web.context.request.async.StandardServletAsyncWebRequest 实例源码

@Before
public void setUp() throws Exception {

    List<HttpMessageConverter<?>> converters = Arrays.asList(
            new StringHttpMessageConverter(), new MappingJackson2HttpMessageConverter());

    this.handler = new ResponseBodyEmitterReturnValueHandler(converters);
    this.mavContainer = new ModelAndViewContainer();

    this.request = new MockHttpServletRequest();
    this.response = new MockHttpServletResponse();
    this.webRequest = new ServletWebRequest(this.request, this.response);

    AsyncWebRequest asyncWebRequest = new StandardServletAsyncWebRequest(this.request, this.response);
    WebAsyncUtils.getAsyncManager(this.webRequest).setAsyncWebRequest(asyncWebRequest);
    this.request.setAsyncSupported(true);
}

@Before
public void setUp() throws Exception {

    this.handler = new StreamingResponseBodyReturnValueHandler();
    this.mavContainer = new ModelAndViewContainer();

    this.request = new MockHttpServletRequest("GET", "/path");
    this.response = new MockHttpServletResponse();
    this.webRequest = new ServletWebRequest(this.request, this.response);

    AsyncWebRequest asyncWebRequest = new StandardServletAsyncWebRequest(this.request, this.response);
    WebAsyncUtils.getAsyncManager(this.webRequest).setAsyncWebRequest(asyncWebRequest);
    this.request.setAsyncSupported(true);
}

private void setUpAsyncDispatch() throws Exception {
    this.request.setAsyncSupported(true);
    this.request.setAsyncStarted(true);
    DeferredResult<String> result = new DeferredResult<String>();
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(this.request);
    asyncManager.setAsyncWebRequest(
            new StandardServletAsyncWebRequest(this.request, this.response));
    asyncManager.startDeferredResultProcessing(result);
}

private void setUpAsyncDispatch() throws Exception {
    this.request.setAsyncSupported(true);
    this.request.setAsyncStarted(true);
    DeferredResult<String> result = new DeferredResult<String>();
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(this.request);
    asyncManager.setAsyncWebRequest(
            new StandardServletAsyncWebRequest(this.request, this.response));
    asyncManager.startDeferredResultProcessing(result);
}

private void setUpAsyncDispatch() throws Exception {
    this.request.setAsyncSupported(true);
    this.request.setAsyncStarted(true);
    DeferredResult<String> result = new DeferredResult<String>();
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(this.request);
    asyncManager.setAsyncWebRequest(
            new StandardServletAsyncWebRequest(this.request, this.response));
    asyncManager.startDeferredResultProcessing(result);
}

@Test
public void testOpenEntityManagerInViewInterceptorAsyncScenario() throws Exception {

    // Initial request thread

    OpenEntityManagerInViewInterceptor interceptor = new OpenEntityManagerInViewInterceptor();
    interceptor.setEntityManagerFactory(factory);

    given(factory.createEntityManager()).willReturn(this.manager);

    interceptor.preHandle(this.webRequest);
    assertTrue(TransactionSynchronizationManager.hasResource(factory));

    AsyncWebRequest asyncWebRequest = new StandardServletAsyncWebRequest(this.request, this.response);
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(this.webRequest);
    asyncManager.setTaskExecutor(new SyncTaskExecutor());
    asyncManager.setAsyncWebRequest(asyncWebRequest);
    asyncManager.startCallableProcessing(new Callable<String>() {
        @Override
        public String call() throws Exception {
            return "anything";
        }
    });

    interceptor.afterConcurrentHandlingStarted(this.webRequest);
    assertFalse(TransactionSynchronizationManager.hasResource(factory));

    // Async dispatch thread

    interceptor.preHandle(this.webRequest);
    assertTrue(TransactionSynchronizationManager.hasResource(factory));

    asyncManager.clearConcurrentResult();

    // check that further invocations simply participate
    interceptor.preHandle(new ServletWebRequest(request));

    interceptor.preHandle(new ServletWebRequest(request));
    interceptor.postHandle(new ServletWebRequest(request), null);
    interceptor.afterCompletion(new ServletWebRequest(request), null);

    interceptor.postHandle(new ServletWebRequest(request), null);
    interceptor.afterCompletion(new ServletWebRequest(request), null);

    interceptor.preHandle(new ServletWebRequest(request));
    interceptor.postHandle(new ServletWebRequest(request), null);
    interceptor.afterCompletion(new ServletWebRequest(request), null);

    interceptor.postHandle(this.webRequest, null);
    assertTrue(TransactionSynchronizationManager.hasResource(factory));

    given(this.manager.isOpen()).willReturn(true);

    interceptor.afterCompletion(this.webRequest, null);
    assertFalse(TransactionSynchronizationManager.hasResource(factory));

    verify(this.manager).close();
}

@Test
public void testOpenSessionInViewInterceptorAsyncScenario() throws Exception {
    // Initial request thread

    final SessionFactory sf = mock(SessionFactory.class);
    Session session = mock(Session.class);

    OpenSessionInViewInterceptor interceptor = new OpenSessionInViewInterceptor();
    interceptor.setSessionFactory(sf);

    given(sf.openSession()).willReturn(session);
    given(session.getSessionFactory()).willReturn(sf);

    interceptor.preHandle(this.webRequest);
    assertTrue(TransactionSynchronizationManager.hasResource(sf));

    AsyncWebRequest asyncWebRequest = new StandardServletAsyncWebRequest(this.request, this.response);
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(this.request);
    asyncManager.setTaskExecutor(new SyncTaskExecutor());
    asyncManager.setAsyncWebRequest(asyncWebRequest);
    asyncManager.startCallableProcessing(new Callable<String>() {
        @Override
        public String call() throws Exception {
            return "anything";
        }
    });

    interceptor.afterConcurrentHandlingStarted(this.webRequest);
    assertFalse(TransactionSynchronizationManager.hasResource(sf));

    // Async dispatch thread

    interceptor.preHandle(this.webRequest);
    assertTrue("Session not bound to async thread", TransactionSynchronizationManager.hasResource(sf));

    interceptor.postHandle(this.webRequest, null);
    assertTrue(TransactionSynchronizationManager.hasResource(sf));

    verify(session, never()).close();

    interceptor.afterCompletion(this.webRequest, null);
    assertFalse(TransactionSynchronizationManager.hasResource(sf));

    verify(session).setFlushMode(FlushMode.MANUAL);
    verify(session).close();
}

@Test
public void testOpenSessionInViewFilterAsyncScenario() throws Exception {
    final SessionFactory sf = mock(SessionFactory.class);
    Session session = mock(Session.class);

    // Initial request during which concurrent handling starts..

    given(sf.openSession()).willReturn(session);
    given(session.getSessionFactory()).willReturn(sf);

    StaticWebApplicationContext wac = new StaticWebApplicationContext();
    wac.setServletContext(sc);
    wac.getDefaultListableBeanFactory().registerSingleton("sessionFactory", sf);
    wac.refresh();
    sc.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, wac);

    MockFilterConfig filterConfig = new MockFilterConfig(wac.getServletContext(), "filter");

    final AtomicInteger count = new AtomicInteger(0);

    final OpenSessionInViewFilter filter = new OpenSessionInViewFilter();
    filter.init(filterConfig);

    final FilterChain filterChain = new FilterChain() {
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) {
            assertTrue(TransactionSynchronizationManager.hasResource(sf));
            count.incrementAndGet();
        }
    };

    AsyncWebRequest asyncWebRequest = new StandardServletAsyncWebRequest(this.request, this.response);
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(this.request);
    asyncManager.setTaskExecutor(new SyncTaskExecutor());
    asyncManager.setAsyncWebRequest(asyncWebRequest);
    asyncManager.startCallableProcessing(new Callable<String>() {
        @Override
        public String call() throws Exception {
            return "anything";
        }
    });

    assertFalse(TransactionSynchronizationManager.hasResource(sf));
    filter.doFilter(this.request, this.response, filterChain);
    assertFalse(TransactionSynchronizationManager.hasResource(sf));
    assertEquals(1, count.get());
    verify(session, never()).close();

    // Async dispatch after concurrent handling produces result ...

    this.request.setAsyncStarted(false);
    assertFalse(TransactionSynchronizationManager.hasResource(sf));
    filter.doFilter(this.request, this.response, filterChain);
    assertFalse(TransactionSynchronizationManager.hasResource(sf));
    assertEquals(2, count.get());

    verify(session).setFlushMode(FlushMode.MANUAL);
    verify(session).close();

    wac.close();
}