org.glassfish.jersey.process.internal.RequestScope.activate java code examples

Common ways to obtain RequestScope

private void myMethod () {
 RequestScope r =ClientRuntime clientRuntime;clientRuntime.getRequestScope()
Smart code suggestions by Tabnine
}

@Override
protected void activate(RequestContext context, RequestContext oldContext) {
  super.activate(context, oldContext);
  if (oldContext != null) {
    CdiRequestContext oldRequestContext = (CdiRequestContext) oldContext;
    requestContextController.deactivate();
    requestContextController.dissociate(oldRequestContext.getStore());
  }
  CdiRequestContext cdiRequestContext = (CdiRequestContext) context;
  requestContextController.associate(cdiRequestContext.getStore());
  requestContextController.activate();
}

/**
 * Runs the {@link Callable task} in the request scope initialized from the
 * {@link RequestContext scope context}. The {@link RequestContext
 * scope context} is NOT released by the method (this must be done explicitly). The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestContext scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param context The request scope context from which the request scope will be initialized.
 * @param task    Task to be executed.
 * @param <T>     {@code task} result type.
 * @return result returned by the {@code task}.
 * @throws Exception Exception thrown by the {@code task}.
 */
public <T> T runInScope(RequestContext context, Callable<T> task) throws Exception {
  final RequestContext oldContext = retrieveCurrent();
  try {
    activate(context.getReference(), oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

/**
 * Runs the {@link Runnable task} in the request scope initialized from the
 * {@link RequestContext scope context}. The {@link RequestContext
 * scope context} is NOT released by the method (this must be done explicitly). The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestContext scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param context The request scope context from which the request scope will be initialized.
 * @param task    Task to be executed.
 */
public void runInScope(RequestContext context, Runnable task) {
  final RequestContext oldContext = retrieveCurrent();
  try {
    activate(context.getReference(), oldContext);
    Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

/**
 * Runs the {@link Runnable task} in the new request scope. The current thread might
 * be already in any request scope and in that case the scope will be changed to the
 * scope defined by the {@link RequestContext scope context}. At the end of
 * the method the request scope is returned to its original state. The newly created
 * {@link RequestContext scope context} will be implicitly released at the end
 * of the method call except the task will call
 * {@link RequestScope#suspendCurrent}.
 *
 * @param task Task to be executed.
 */
public void runInScope(Runnable task) {
  final RequestContext oldContext = retrieveCurrent();
  final RequestContext context = createContext();
  try {
    activate(context, oldContext);
    Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

/**
 * Runs the {@link Runnable task} in the request scope initialized from the
 * {@link RequestContext scope context}. The {@link RequestContext
 * scope context} is NOT released by the method (this must be done explicitly). The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestContext scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param context The request scope context from which the request scope will be initialized.
 * @param task    Task to be executed.
 */
public void runInScope(RequestContext context, Runnable task) {
  final RequestContext oldContext = retrieveCurrent();
  try {
    activate(context.getReference(), oldContext);
    Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

/**
 * Runs the {@link Runnable task} in the new request scope. The current thread might
 * be already in any request scope and in that case the scope will be changed to the
 * scope defined by the {@link RequestContext scope context}. At the end of
 * the method the request scope is returned to its original state. The newly created
 * {@link RequestContext scope context} will be implicitly released at the end
 * of the method call except the task will call
 * {@link RequestScope#suspendCurrent}.
 *
 * @param task Task to be executed.
 */
public void runInScope(Runnable task) {
  final RequestContext oldContext = retrieveCurrent();
  final RequestContext context = createContext();
  try {
    activate(context, oldContext);
    Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

/**
 * Runs the {@link org.glassfish.jersey.internal.util.Producer task} in the request scope initialized
 * from the {@link RequestContext scope context}.
 * The {@link RequestContext scope context} is NOT released by the method (this
 * must be done explicitly). The current thread might be already in any request scope
 * and in that case the scope will be changed to the scope defined by the
 * {@link RequestContext scope context}. At the end of the method the request
 * scope is returned to its original state.
 *
 * @param context The request scope context from which the request scope will be initialized.
 * @param task    Task to be executed.
 * @param <T>     {@code task} result type.
 * @return result returned by the {@code task}
 */
public <T> T runInScope(RequestContext context, Producer<T> task) {
  final RequestContext oldContext = retrieveCurrent();
  try {
    activate(context.getReference(), oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

/**
 * Runs the {@link org.glassfish.jersey.internal.util.Producer task} in the request scope initialized
 * from the {@link RequestContext scope context}.
 * The {@link RequestContext scope context} is NOT released by the method (this
 * must be done explicitly). The current thread might be already in any request scope
 * and in that case the scope will be changed to the scope defined by the
 * {@link RequestContext scope context}. At the end of the method the request
 * scope is returned to its original state.
 *
 * @param context The request scope context from which the request scope will be initialized.
 * @param task    Task to be executed.
 * @param <T>     {@code task} result type.
 * @return result returned by the {@code task}
 */
public <T> T runInScope(RequestContext context, Producer<T> task) {
  final RequestContext oldContext = retrieveCurrent();
  try {
    activate(context.getReference(), oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

/**
 * Runs the {@link org.glassfish.jersey.internal.util.Producer task} in the new request scope. The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestContext scope
 * instance}. At the end of the method the request scope is returned to its original
 * state. The newly created {@link RequestContext scope context} will be
 * implicitly released at the end of the method call except the task will call
 * {@link RequestScope#suspendCurrent}.
 *
 * @param task Task to be executed.
 * @param <T>  {@code task} result type.
 * @return result returned by the {@code task}.
 */
public <T> T runInScope(Producer<T> task) {
  final RequestContext oldContext = retrieveCurrent();
  final RequestContext context = createContext();
  try {
    activate(context, oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

/**
 * Runs the {@link org.glassfish.jersey.internal.util.Producer task} in the new request scope. The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestContext scope
 * instance}. At the end of the method the request scope is returned to its original
 * state. The newly created {@link RequestContext scope context} will be
 * implicitly released at the end of the method call except the task will call
 * {@link RequestScope#suspendCurrent}.
 *
 * @param task Task to be executed.
 * @param <T>  {@code task} result type.
 * @return result returned by the {@code task}.
 */
public <T> T runInScope(Producer<T> task) {
  final RequestContext oldContext = retrieveCurrent();
  final RequestContext context = createContext();
  try {
    activate(context, oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

/**
 * Runs the {@link Callable task} in the request scope initialized from the
 * {@link RequestContext scope context}. The {@link RequestContext
 * scope context} is NOT released by the method (this must be done explicitly). The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestContext scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param context The request scope context from which the request scope will be initialized.
 * @param task    Task to be executed.
 * @param <T>     {@code task} result type.
 * @return result returned by the {@code task}.
 * @throws Exception Exception thrown by the {@code task}.
 */
public <T> T runInScope(RequestContext context, Callable<T> task) throws Exception {
  final RequestContext oldContext = retrieveCurrent();
  try {
    activate(context.getReference(), oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

/**
 * Runs the {@link Callable task} in the new request scope. The current thread might
 * be already in any request scope and in that case the scope will be changed to the
 * scope defined by the {@link RequestContext scope context}. At the end of
 * the method the request scope is returned to its original state. The newly created
 * {@link RequestContext scope context} will be implicitly released at the end
 * of the method call except the task will call
 * {@link RequestScope#suspendCurrent}.
 *
 * @param task Task to be executed.
 * @param <T>  {@code task} result type.
 * @return result returned by the {@code task}.
 * @throws Exception Exception thrown by the {@code task}.
 */
public <T> T runInScope(Callable<T> task) throws Exception {
  final RequestContext oldContext = retrieveCurrent();
  final RequestContext context = createContext();
  try {
    activate(context, oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

/**
 * Runs the {@link Callable task} in the new request scope. The current thread might
 * be already in any request scope and in that case the scope will be changed to the
 * scope defined by the {@link RequestContext scope context}. At the end of
 * the method the request scope is returned to its original state. The newly created
 * {@link RequestContext scope context} will be implicitly released at the end
 * of the method call except the task will call
 * {@link RequestScope#suspendCurrent}.
 *
 * @param task Task to be executed.
 * @param <T>  {@code task} result type.
 * @return result returned by the {@code task}.
 * @throws Exception Exception thrown by the {@code task}.
 */
public <T> T runInScope(Callable<T> task) throws Exception {
  final RequestContext oldContext = retrieveCurrent();
  final RequestContext context = createContext();
  try {
    activate(context, oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

/**
 * Runs the {@link Runnable task} in the request scope initialized from the
 * {@link RequestContext scope context}. The {@link RequestContext
 * scope context} is NOT released by the method (this must be done explicitly). The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestContext scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param context The request scope context from which the request scope will be initialized.
 * @param task    Task to be executed.
 */
public void runInScope(RequestContext context, Runnable task) {
  final RequestContext oldContext = retrieveCurrent();
  try {
    activate(context.getReference(), oldContext);
    Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

/**
 * Runs the {@link Runnable task} in the new request scope. The current thread might
 * be already in any request scope and in that case the scope will be changed to the
 * scope defined by the {@link RequestContext scope context}. At the end of
 * the method the request scope is returned to its original state. The newly created
 * {@link RequestContext scope context} will be implicitly released at the end
 * of the method call except the task will call
 * {@link RequestScope#suspendCurrent}.
 *
 * @param task Task to be executed.
 */
public void runInScope(Runnable task) {
  final RequestContext oldContext = retrieveCurrent();
  final RequestContext context = createContext();
  try {
    activate(context, oldContext);
    Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

/**
 * Runs the {@link Runnable task} in the request scope initialized from the
 * {@link RequestContext scope context}. The {@link RequestContext
 * scope context} is NOT released by the method (this must be done explicitly). The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestContext scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param context The request scope context from which the request scope will be initialized.
 * @param task    Task to be executed.
 */
public void runInScope(RequestContext context, Runnable task) {
  final RequestContext oldContext = retrieveCurrent();
  try {
    activate(context.getReference(), oldContext);
    Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

/**
 * Runs the {@link Runnable task} in the new request scope. The current thread might
 * be already in any request scope and in that case the scope will be changed to the
 * scope defined by the {@link RequestContext scope context}. At the end of
 * the method the request scope is returned to its original state. The newly created
 * {@link RequestContext scope context} will be implicitly released at the end
 * of the method call except the task will call
 * {@link RequestScope#suspendCurrent}.
 *
 * @param task Task to be executed.
 */
public void runInScope(Runnable task) {
  final RequestContext oldContext = retrieveCurrent();
  final RequestContext context = createContext();
  try {
    activate(context, oldContext);
    Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

/**
 * Runs the {@link org.glassfish.jersey.internal.util.Producer task} in the new request scope. The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestContext scope
 * instance}. At the end of the method the request scope is returned to its original
 * state. The newly created {@link RequestContext scope context} will be
 * implicitly released at the end of the method call except the task will call
 * {@link RequestScope#suspendCurrent}.
 *
 * @param task Task to be executed.
 * @param <T>  {@code task} result type.
 * @return result returned by the {@code task}.
 */
public <T> T runInScope(Producer<T> task) {
  final RequestContext oldContext = retrieveCurrent();
  final RequestContext context = createContext();
  try {
    activate(context, oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

/**
 * Runs the {@link org.glassfish.jersey.internal.util.Producer task} in the request scope initialized
 * from the {@link RequestContext scope context}.
 * The {@link RequestContext scope context} is NOT released by the method (this
 * must be done explicitly). The current thread might be already in any request scope
 * and in that case the scope will be changed to the scope defined by the
 * {@link RequestContext scope context}. At the end of the method the request
 * scope is returned to its original state.
 *
 * @param context The request scope context from which the request scope will be initialized.
 * @param task    Task to be executed.
 * @param <T>     {@code task} result type.
 * @return result returned by the {@code task}
 */
public <T> T runInScope(RequestContext context, Producer<T> task) {
  final RequestContext oldContext = retrieveCurrent();
  try {
    activate(context.getReference(), oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

/**
 * Runs the {@link Callable task} in the request scope initialized from the
 * {@link RequestContext scope context}. The {@link RequestContext
 * scope context} is NOT released by the method (this must be done explicitly). The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestContext scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param context The request scope context from which the request scope will be initialized.
 * @param task    Task to be executed.
 * @param <T>     {@code task} result type.
 * @return result returned by the {@code task}.
 * @throws Exception Exception thrown by the {@code task}.
 */
public <T> T runInScope(RequestContext context, Callable<T> task) throws Exception {
  final RequestContext oldContext = retrieveCurrent();
  try {
    activate(context.getReference(), oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}

Javadoc

Stores the provided RequestContext to thread-local variable belonging to current request scope.

Popular methods of RequestScope

current
referenceCurrent
Get a new reference for to currently running request scope instance. This call prevents automatic Re
runInScope
Runs the org.glassfish.jersey.internal.util.Producer in the request scope initialized from the Reque
retrieveCurrent
<init>
createContext
Creates a new instance of the RequestContext. This instance can be then used to run task in the requ
release
Releases the provided RequestContext to thread-local variable belonging to current request scope.
resume
Resumes the provided RequestContext to thread-local variable belonging to current request scope.
createInstance
Creates a new instance of the RequestScope.Instance. This instance can be then used to run task in t
isActive
resumeCurrent
setCurrent

Popular in Java

Reactive rest calls using spring rest template
getApplicationContext (Context)
getExternalFilesDir (Context)
orElseThrow (Optional)
Return the contained value, if present, otherwise throw an exception to be created by the provided s
System (java.lang)
Provides access to system-related information and resources including standard input and output. Ena
Date (java.util)
A specific moment in time, with millisecond precision. Values typically come from System#currentTime
LinkedHashMap (java.util)
LinkedHashMap is an implementation of Map that guarantees iteration order. All optional operations a
StringTokenizer (java.util)
Breaks a string into tokens; new code should probably use String#split.> // Legacy code: StringTo
AtomicInteger (java.util.concurrent.atomic)
An int value that may be updated atomically. See the java.util.concurrent.atomic package specificati
Loader (org.hibernate.loader)
Abstract superclass of object loading (and querying) strategies. This class implements useful common
21 Best Atom Packages for 2021

How to use activatemethodin org.glassfish.jersey.process.internal.RequestScope

Best Java code snippets using org.glassfish.jersey.process.internal.RequestScope.activate (Showing top 20 results out of 315)

How to use
activate
method
in
org.glassfish.jersey.process.internal.RequestScope