How to use

transferRequest

method

in

com.google.inject.servlet.ServletScopes

 @Override
 public Boolean call() throws Exception {
  return ServletScopes.transferRequest(FALSE_CALLABLE).call();
 }
};

/**
 * Wraps the given callable in a contextual callable that "transfers" the request to another
 * thread. This acts as a way of transporting request context data from the current thread to a
 * future thread.
 *
 * <p>As opposed to {@link #continueRequest}, this method propagates all existing scoped objects.
 * The primary use case is in server implementations where you can detach the request processing
 * thread while waiting for data, and reattach to a different thread to finish processing at a
 * later time.
 *
 * <p>Because request-scoped objects are not typically thread-safe, the callable returned by this
 * method must not be run on a different thread until the current request scope has terminated.
 * The returned callable will block until the current thread has released the request scope.
 *
 * @param callable code to be executed in another thread, which depends on the request scope.
 * @return a callable that will invoke the given callable, making the request context available to
 *     it.
 * @throws OutOfScopeException if this method is called from a non-request thread, or if the
 *     request has completed.
 * @since 4.0
 */
public static <T> Callable<T> transferRequest(Callable<T> callable) {
 return wrap(callable, transferRequest());
}

 @Override
 public Callable<Boolean> call() {
  final Object original = injector.getInstance(Object.class);
  return ServletScopes.transferRequest(
    new Callable<Boolean>() {
     @Override
     public Boolean call() {
      return original == injector.getInstance(Object.class);
     }
    });
 }
};

 @Override
 public Data call() {
  Data data = new Data();
  data.object = injector.getInstance(Object.class);
  data.scoper = ServletScopes.transferRequest();
  return data;
 }
};

 @Override
 public Boolean call() throws Exception {
  ExecutorService executor = Executors.newSingleThreadExecutor();
  try {
   Future<Boolean> future =
     executor.submit(ServletScopes.transferRequest(FALSE_CALLABLE));
   try {
    return future.get(100, TimeUnit.MILLISECONDS);
   } catch (TimeoutException e) {
    return true;
   }
  } finally {
   executor.shutdownNow();
  }
 }
};

public void testTransferHttp_outOfScope() {
 try {
  ServletScopes.transferRequest(FALSE_CALLABLE);
  fail();
 } catch (OutOfScopeException expected) {
 }
}

public void testTransferNonHttp_outOfScope() {
 try {
  ServletScopes.transferRequest(FALSE_CALLABLE);
  fail();
 } catch (OutOfScopeException expected) {
 }
}

public void testTransferNonHttp_outOfScope_closeable() {
 try {
  ServletScopes.transferRequest();
  fail();
 } catch (OutOfScopeException expected) {
 }
}

 @Override
 public Boolean call() throws Exception {
  final RequestScoper scoper = ServletScopes.transferRequest();
  ExecutorService executor = Executors.newSingleThreadExecutor();
  try {
   Future<Boolean> future =
     executor.submit(
       new Callable<Boolean>() {
        @Override
        public Boolean call() {
         RequestScoper.CloseableScope scope = scoper.open();
         try {
          return false;
         } finally {
          scope.close();
         }
        }
       });
   try {
    return future.get(100, TimeUnit.MILLISECONDS);
   } catch (TimeoutException e) {
    return true;
   }
  } finally {
   executor.shutdownNow();
  }
 }
};

 @Override
 public Boolean call() throws Exception {
  RequestScoper.CloseableScope scope = ServletScopes.transferRequest().open();
  try {
   return false;
  } finally {
   scope.close();
  }
 }
};

/**
 * Wraps the given callable in a contextual callable that "transfers" the request to another
 * thread. This acts as a way of transporting request context data from the current thread to a
 * future thread.
 *
 * <p>As opposed to {@link #continueRequest}, this method propagates all existing scoped objects.
 * The primary use case is in server implementations where you can detach the request processing
 * thread while waiting for data, and reattach to a different thread to finish processing at a
 * later time.
 *
 * <p>Because request-scoped objects are not typically thread-safe, the callable returned by this
 * method must not be run on a different thread until the current request scope has terminated.
 * The returned callable will block until the current thread has released the request scope.
 *
 * @param callable code to be executed in another thread, which depends on the request scope.
 * @return a callable that will invoke the given callable, making the request context available to
 *     it.
 * @throws OutOfScopeException if this method is called from a non-request thread, or if the
 *     request has completed.
 * @since 4.0
 */
public static <T> Callable<T> transferRequest(Callable<T> callable) {
 return wrap(callable, transferRequest());
}

/**
 * Wraps the given callable in a contextual callable that "transfers" the request to another
 * thread. This acts as a way of transporting request context data from the current thread to a
 * future thread.
 *
 * <p>As opposed to {@link #continueRequest}, this method propagates all existing scoped objects.
 * The primary use case is in server implementations where you can detach the request processing
 * thread while waiting for data, and reattach to a different thread to finish processing at a
 * later time.
 *
 * <p>Because request-scoped objects are not typically thread-safe, the callable returned by this
 * method must not be run on a different thread until the current request scope has terminated.
 * The returned callable will block until the current thread has released the request scope.
 *
 * @param callable code to be executed in another thread, which depends on the request scope.
 * @return a callable that will invoke the given callable, making the request context available to
 *     it.
 * @throws OutOfScopeException if this method is called from a non-request thread, or if the
 *     request has completed.
 * @since 4.0
 */
public static <T> Callable<T> transferRequest(Callable<T> callable) {
 return wrap(callable, transferRequest());
}

public ExtDirectJsonRequestProcessorThread() {
 Subject subject = SecurityUtils.getSubject();
 checkState(subject != null, "Subject is not set");
 // create the thread state by this moment as this is created in the master (web container) thread
 threadState = new SubjectThreadState(subject);
 final String baseUrl = BaseUrlHolder.get();
 processRequest = ServletScopes.transferRequest(new Callable<String>()
 {
  @Override
  public String call() {
   threadState.bind();
   UserIdMdcHelper.set();
   try {
    // apply base-url from the original thread
    BaseUrlHolder.set(baseUrl);
    return ExtDirectJsonRequestProcessorThread.super.processRequest();
   }
   finally {
    UserIdMdcHelper.unset();
    threadState.restore();
   }
  }
 });
}