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

@Override
protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse,
        FilterChain filterChain) throws ServletException, IOException {
    setMdc();

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(httpServletRequest);

    UserIdLoggingFilter tenancyProcessingInterceptor = (UserIdLoggingFilter) asyncManager
            .getCallableInterceptor(CALLABLE_INTERCEPTOR_KEY);
    if (tenancyProcessingInterceptor == null) {
        asyncManager.registerCallableInterceptor(CALLABLE_INTERCEPTOR_KEY, new UserIdCallableProcessingInterceptorAdapter());
    }
    try {
        filterChain.doFilter(httpServletRequest, httpServletResponse);
    } finally {
        removeMdc();
    }

}

@Override
public void preHandle(WebRequest request) throws DataAccessException {

    String participateAttributeName = getParticipateAttributeName();

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    if (asyncManager.hasConcurrentResult()) {
        if (applyCallableInterceptor(asyncManager, participateAttributeName)) {
            return;
        }
    }

    if (TransactionSynchronizationManager.hasResource(getEntityManagerFactory())) {
        // do not modify the EntityManager: just mark the request accordingly
        Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
        int newCount = (count != null ? count + 1 : 1);
        request.setAttribute(getParticipateAttributeName(), newCount, WebRequest.SCOPE_REQUEST);
    }
    else {
        logger.debug("Opening JPA EntityManager in OpenEntityManagerInViewInterceptor");
        try {
            EntityManager em = createEntityManager();
            EntityManagerHolder emHolder = new EntityManagerHolder(em);
            TransactionSynchronizationManager.bindResource(getEntityManagerFactory(), emHolder);

            AsyncRequestInterceptor interceptor = new AsyncRequestInterceptor(getEntityManagerFactory(), emHolder);
            asyncManager.registerCallableInterceptor(participateAttributeName, interceptor);
            asyncManager.registerDeferredResultInterceptor(participateAttributeName, interceptor);
        }
        catch (PersistenceException ex) {
            throw new DataAccessResourceFailureException("Could not create JPA EntityManager", ex);
        }
    }
}

private boolean applyCallableInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return true;
}

private boolean applyEntityManagerBindingInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return true;
}

/**
 * Open a new Hibernate {@code Session} according and bind it to the thread via the
 * {@link org.springframework.transaction.support.TransactionSynchronizationManager}.
 */
@Override
public void preHandle(WebRequest request) throws DataAccessException {
    String participateAttributeName = getParticipateAttributeName();

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    if (asyncManager.hasConcurrentResult()) {
        if (applySessionBindingInterceptor(asyncManager, participateAttributeName)) {
            return;
        }
    }

    if (TransactionSynchronizationManager.hasResource(getSessionFactory())) {
        // Do not modify the Session: just mark the request accordingly.
        Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
        int newCount = (count != null ? count + 1 : 1);
        request.setAttribute(getParticipateAttributeName(), newCount, WebRequest.SCOPE_REQUEST);
    }
    else {
        logger.debug("Opening Hibernate Session in OpenSessionInViewInterceptor");
        Session session = openSession();
        SessionHolder sessionHolder = new SessionHolder(session);
        TransactionSynchronizationManager.bindResource(getSessionFactory(), sessionHolder);

        AsyncRequestInterceptor asyncRequestInterceptor =
                new AsyncRequestInterceptor(getSessionFactory(), sessionHolder);
        asyncManager.registerCallableInterceptor(participateAttributeName, asyncRequestInterceptor);
        asyncManager.registerDeferredResultInterceptor(participateAttributeName, asyncRequestInterceptor);
    }
}

private boolean applySessionBindingInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return true;
}

private boolean applySessionBindingInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return true;
}

/**
 * Open a new Hibernate {@code Session} according to the settings of this
 * {@code HibernateAccessor} and bind it to the thread via the
 * {@link TransactionSynchronizationManager}.
 * @see org.springframework.orm.hibernate3.SessionFactoryUtils#getSession
 */
@Override
public void preHandle(WebRequest request) throws DataAccessException {
    String participateAttributeName = getParticipateAttributeName();

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    if (asyncManager.hasConcurrentResult()) {
        if (applySessionBindingInterceptor(asyncManager, participateAttributeName)) {
            return;
        }
    }

    if ((isSingleSession() && TransactionSynchronizationManager.hasResource(getSessionFactory())) ||
        SessionFactoryUtils.isDeferredCloseActive(getSessionFactory())) {
        // Do not modify the Session: just mark the request accordingly.
        Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
        int newCount = (count != null ? count + 1 : 1);
        request.setAttribute(getParticipateAttributeName(), newCount, WebRequest.SCOPE_REQUEST);
    }
    else {
        if (isSingleSession()) {
            // single session mode
            logger.debug("Opening single Hibernate Session in OpenSessionInViewInterceptor");
            Session session = SessionFactoryUtils.getSession(
                    getSessionFactory(), getEntityInterceptor(), getJdbcExceptionTranslator());
            applyFlushMode(session, false);
            SessionHolder sessionHolder = new SessionHolder(session);
            TransactionSynchronizationManager.bindResource(getSessionFactory(), sessionHolder);

            AsyncRequestInterceptor asyncRequestInterceptor =
                    new AsyncRequestInterceptor(getSessionFactory(), sessionHolder);
            asyncManager.registerCallableInterceptor(participateAttributeName, asyncRequestInterceptor);
            asyncManager.registerDeferredResultInterceptor(participateAttributeName, asyncRequestInterceptor);
        }
        else {
            // deferred close mode
            SessionFactoryUtils.initDeferredClose(getSessionFactory());
        }
    }
}

private boolean applySessionBindingInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return true;
}

private boolean applySessionBindingInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return true;
}

@Override
public void preHandle(WebRequest request) throws DataAccessException {
    String participateAttributeName = getParticipateAttributeName();

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    if (asyncManager.hasConcurrentResult()) {
        if (applyCallableInterceptor(asyncManager, participateAttributeName)) {
            return;
        }
    }

    if (TransactionSynchronizationManager.hasResource(getEntityManagerFactory())) {
        // Do not modify the EntityManager: just mark the request accordingly.
        Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
        int newCount = (count != null ? count + 1 : 1);
        request.setAttribute(getParticipateAttributeName(), newCount, WebRequest.SCOPE_REQUEST);
    }
    else {
        logger.debug("Opening JPA EntityManager in OpenEntityManagerInViewInterceptor");
        try {
            EntityManager em = createEntityManager();
            EntityManagerHolder emHolder = new EntityManagerHolder(em);
            TransactionSynchronizationManager.bindResource(getEntityManagerFactory(), emHolder);

            AsyncRequestInterceptor interceptor = new AsyncRequestInterceptor(getEntityManagerFactory(), emHolder);
            asyncManager.registerCallableInterceptor(participateAttributeName, interceptor);
            asyncManager.registerDeferredResultInterceptor(participateAttributeName, interceptor);
        }
        catch (PersistenceException ex) {
            throw new DataAccessResourceFailureException("Could not create JPA EntityManager", ex);
        }
    }
}

private boolean applyCallableInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return true;
}

private boolean applyEntityManagerBindingInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return true;
}

/**
 * Open a new Hibernate {@code Session} according to the settings of this
 * {@code HibernateAccessor} and bind it to the thread via the
 * {@link TransactionSynchronizationManager}.
 * @see org.springframework.orm.hibernate3.SessionFactoryUtils#getSession
 */
@Override
public void preHandle(WebRequest request) throws DataAccessException {
    String participateAttributeName = getParticipateAttributeName();

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    if (asyncManager.hasConcurrentResult()) {
        if (applySessionBindingInterceptor(asyncManager, participateAttributeName)) {
            return;
        }
    }

    if ((isSingleSession() && TransactionSynchronizationManager.hasResource(getSessionFactory())) ||
        SessionFactoryUtils.isDeferredCloseActive(getSessionFactory())) {
        // Do not modify the Session: just mark the request accordingly.
        Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
        int newCount = (count != null ? count + 1 : 1);
        request.setAttribute(getParticipateAttributeName(), newCount, WebRequest.SCOPE_REQUEST);
    }
    else {
        if (isSingleSession()) {
            // single session mode
            logger.debug("Opening single Hibernate Session in OpenSessionInViewInterceptor");
            Session session = SessionFactoryUtils.getSession(
                    getSessionFactory(), getEntityInterceptor(), getJdbcExceptionTranslator());
            applyFlushMode(session, false);
            SessionHolder sessionHolder = new SessionHolder(session);
            TransactionSynchronizationManager.bindResource(getSessionFactory(), sessionHolder);

            AsyncRequestInterceptor asyncRequestInterceptor =
                    new AsyncRequestInterceptor(getSessionFactory(), sessionHolder);
            asyncManager.registerCallableInterceptor(participateAttributeName, asyncRequestInterceptor);
            asyncManager.registerDeferredResultInterceptor(participateAttributeName, asyncRequestInterceptor);
        }
        else {
            // deferred close mode
            SessionFactoryUtils.initDeferredClose(getSessionFactory());
        }
    }
}

private boolean applySessionBindingInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return true;
}

private boolean applySessionBindingInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return true;
}

/**
 * Open a new Hibernate {@code Session} according and bind it to the thread via the
 * {@link TransactionSynchronizationManager}.
 */
@Override
public void preHandle(WebRequest request) throws DataAccessException {
    String participateAttributeName = getParticipateAttributeName();

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    if (asyncManager.hasConcurrentResult()) {
        if (applySessionBindingInterceptor(asyncManager, participateAttributeName)) {
            return;
        }
    }

    if (TransactionSynchronizationManager.hasResource(getSessionFactory())) {
        // Do not modify the Session: just mark the request accordingly.
        Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
        int newCount = (count != null ? count + 1 : 1);
        request.setAttribute(getParticipateAttributeName(), newCount, WebRequest.SCOPE_REQUEST);
    }
    else {
        logger.debug("Opening Hibernate Session in OpenSessionInViewInterceptor");
        Session session = openSession();
        SessionHolder sessionHolder = new SessionHolder(session);
        TransactionSynchronizationManager.bindResource(getSessionFactory(), sessionHolder);

        AsyncRequestInterceptor asyncRequestInterceptor =
                new AsyncRequestInterceptor(getSessionFactory(), sessionHolder);
        asyncManager.registerCallableInterceptor(participateAttributeName, asyncRequestInterceptor);
        asyncManager.registerDeferredResultInterceptor(participateAttributeName, asyncRequestInterceptor);
    }
}

private boolean applySessionBindingInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return true;
}

private boolean applySessionBindingInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return true;
}

/**
 * Open a new Hibernate {@code Session} according and bind it to the thread via the
 * {@link org.springframework.transaction.support.TransactionSynchronizationManager}.
 */
@Override
public void preHandle(WebRequest request) throws DataAccessException {
    String participateAttributeName = getParticipateAttributeName();

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    if (asyncManager.hasConcurrentResult()) {
        if (applySessionBindingInterceptor(asyncManager, participateAttributeName)) {
            return;
        }
    }

    if (TransactionSynchronizationManager.hasResource(getSessionFactory())) {
        // Do not modify the Session: just mark the request accordingly.
        Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
        int newCount = (count != null ? count + 1 : 1);
        request.setAttribute(getParticipateAttributeName(), newCount, WebRequest.SCOPE_REQUEST);
    }
    else {
        logger.debug("Opening Hibernate Session in OpenSessionInViewInterceptor");
        Session session = openSession();
        SessionHolder sessionHolder = new SessionHolder(session);
        TransactionSynchronizationManager.bindResource(getSessionFactory(), sessionHolder);

        AsyncRequestInterceptor asyncRequestInterceptor =
                new AsyncRequestInterceptor(getSessionFactory(), sessionHolder);
        asyncManager.registerCallableInterceptor(participateAttributeName, asyncRequestInterceptor);
        asyncManager.registerDeferredResultInterceptor(participateAttributeName, asyncRequestInterceptor);
    }
}

private boolean applySessionBindingInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return true;
}

private boolean applySessionBindingInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return 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);
}

@Override
public void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
        throws IOException, ServletException {

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

    TenancyContextIntegrationFilter tenancyProcessingInterceptor = (TenancyContextIntegrationFilter) asyncManager
            .getCallableInterceptor(CALLABLE_INTERCEPTOR_KEY);
    if (tenancyProcessingInterceptor == null) {
        asyncManager.registerCallableInterceptor(CALLABLE_INTERCEPTOR_KEY, new TenancyContextCallableProcessingInterceptor());
    }

    TenancyContext contextBeforeChainExecution = determineTenancyContext(request);

    try {
        TenancyContextHolder.setContext(contextBeforeChainExecution);
        setMdc(contextBeforeChainExecution);

        chain.doFilter(request, response);

    } finally {
        // Crucial removal of ContextHolder contents - do this
        // before anything else.
        TenancyContextHolder.clearContext();
        removeMdc();
    }

}

@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
        throws ServletException, IOException {
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    asyncManager.registerCallableInterceptor(KEY, this);
    filterChain.doFilter(request, response);
    this.checkContextIsClean();
}

public void preHandle(WebRequest request) throws DataAccessException {

        String participateAttributeName = getParticipateAttributeName();

        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
        if (asyncManager.hasConcurrentResult()) {
            if (applyCallableInterceptor(asyncManager, participateAttributeName)) {
                return;
            }
        }

        if (TransactionSynchronizationManager.hasResource(getEntityManagerFactory())) {
            // do not modify the EntityManager: just mark the request accordingly
            Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
            int newCount = (count != null ? count + 1 : 1);
            request.setAttribute(getParticipateAttributeName(), newCount, WebRequest.SCOPE_REQUEST);
        }
        else {
            logger.debug("Opening JPA EntityManager in OpenEntityManagerInViewInterceptor");
            try {
                EntityManager em = createEntityManager();
                EntityManagerHolder emHolder = new EntityManagerHolder(em);
                TransactionSynchronizationManager.bindResource(getEntityManagerFactory(), emHolder);

                AsyncRequestInterceptor interceptor = new AsyncRequestInterceptor(getEntityManagerFactory(), emHolder);
                asyncManager.registerCallableInterceptor(participateAttributeName, interceptor);
                asyncManager.registerDeferredResultInterceptor(participateAttributeName, interceptor);
            }
            catch (PersistenceException ex) {
                throw new DataAccessResourceFailureException("Could not create JPA EntityManager", ex);
            }
        }
    }

private boolean applyCallableInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return true;
}

/**
 * Open a new Hibernate {@code Session} according to the settings of this
 * {@code HibernateAccessor} and bind it to the thread via the
 * {@link TransactionSynchronizationManager}.
 * @see org.springframework.orm.hibernate3.SessionFactoryUtils#getSession
 */
public void preHandle(WebRequest request) throws DataAccessException {
    String participateAttributeName = getParticipateAttributeName();

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    if (asyncManager.hasConcurrentResult()) {
        if (applySessionBindingInterceptor(asyncManager, participateAttributeName)) {
            return;
        }
    }

    if ((isSingleSession() && TransactionSynchronizationManager.hasResource(getSessionFactory())) ||
        SessionFactoryUtils.isDeferredCloseActive(getSessionFactory())) {
        // Do not modify the Session: just mark the request accordingly.
        Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
        int newCount = (count != null ? count + 1 : 1);
        request.setAttribute(getParticipateAttributeName(), newCount, WebRequest.SCOPE_REQUEST);
    }
    else {
        if (isSingleSession()) {
            // single session mode
            logger.debug("Opening single Hibernate Session in OpenSessionInViewInterceptor");
            Session session = SessionFactoryUtils.getSession(
                    getSessionFactory(), getEntityInterceptor(), getJdbcExceptionTranslator());
            applyFlushMode(session, false);
            SessionHolder sessionHolder = new SessionHolder(session);
            TransactionSynchronizationManager.bindResource(getSessionFactory(), sessionHolder);

            AsyncRequestInterceptor asyncRequestInterceptor =
                    new AsyncRequestInterceptor(getSessionFactory(), sessionHolder);
            asyncManager.registerCallableInterceptor(participateAttributeName, asyncRequestInterceptor);
            asyncManager.registerDeferredResultInterceptor(participateAttributeName, asyncRequestInterceptor);
        }
        else {
            // deferred close mode
            SessionFactoryUtils.initDeferredClose(getSessionFactory());
        }
    }
}

private boolean applySessionBindingInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return true;
}

private boolean applySessionBindingInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return true;
}

/**
 * Open a new Hibernate {@code Session} according and bind it to the thread via the
 * {@link org.springframework.transaction.support.TransactionSynchronizationManager}.
 */
public void preHandle(WebRequest request) throws DataAccessException {
    String participateAttributeName = getParticipateAttributeName();

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    if (asyncManager.hasConcurrentResult()) {
        if (applySessionBindingInterceptor(asyncManager, participateAttributeName)) {
            return;
        }
    }

    if (TransactionSynchronizationManager.hasResource(getSessionFactory())) {
        // Do not modify the Session: just mark the request accordingly.
        Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
        int newCount = (count != null ? count + 1 : 1);
        request.setAttribute(getParticipateAttributeName(), newCount, WebRequest.SCOPE_REQUEST);
    }
    else {
        logger.debug("Opening Hibernate Session in OpenSessionInViewInterceptor");
        Session session = openSession();
        SessionHolder sessionHolder = new SessionHolder(session);
        TransactionSynchronizationManager.bindResource(getSessionFactory(), sessionHolder);

        AsyncRequestInterceptor asyncRequestInterceptor =
                new AsyncRequestInterceptor(getSessionFactory(), sessionHolder);
        asyncManager.registerCallableInterceptor(participateAttributeName, asyncRequestInterceptor);
        asyncManager.registerDeferredResultInterceptor(participateAttributeName, asyncRequestInterceptor);
    }
}

private boolean applySessionBindingInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return true;
}

private boolean applySessionBindingInterceptor(WebAsyncManager asyncManager, String key) {
    if (asyncManager.getCallableInterceptor(key) == null) {
        return false;
    }
    ((AsyncRequestInterceptor) asyncManager.getCallableInterceptor(key)).bindSession();
    return true;
}

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

@Test
public void testOpenEntityManagerInViewInterceptorAsyncScenario() throws Exception {

    // Initial request thread

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

    MockServletContext sc = new MockServletContext();
    MockHttpServletRequest request = new MockHttpServletRequest(sc);
    ServletWebRequest webRequest = new ServletWebRequest(request);

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

    AsyncWebRequest asyncWebRequest = mock(AsyncWebRequest.class);

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

    verify(asyncWebRequest, times(2)).addCompletionHandler(any(Runnable.class));
    verify(asyncWebRequest).addTimeoutHandler(any(Runnable.class));
    verify(asyncWebRequest, times(2)).addCompletionHandler(any(Runnable.class));
    verify(asyncWebRequest).startAsync();

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

    // Async dispatch thread

    interceptor.preHandle(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(webRequest, null);
    assertTrue(TransactionSynchronizationManager.hasResource(factory));

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

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

    verify(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 = mock(AsyncWebRequest.class);

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

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

    verify(session).setFlushMode(FlushMode.MANUAL);
    verify(asyncWebRequest, times(2)).addCompletionHandler(any(Runnable.class));
    verify(asyncWebRequest).addTimeoutHandler(any(Runnable.class));
    verify(asyncWebRequest).startAsync();
}