/**
* Copyright (C) 2006 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.inject.servlet;
import com.google.inject.Key;
import com.google.inject.OutOfScopeException;
import com.google.inject.Provider;
import com.google.inject.Scope;
import com.google.inject.internal.util.Maps;
import com.google.inject.internal.util.Preconditions;
import java.util.Map;
import java.util.concurrent.Callable;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
/**
* Servlet scopes.
*
* @author crazybob@google.com (Bob Lee)
*/
public class ServletScopes {
private ServletScopes() {}
/** A sentinel attribute value representing null. */
enum NullObject { INSTANCE }
/**
* HTTP servlet request scope.
*/
public static final Scope REQUEST = new Scope() {
public <T> Provider<T> scope(Key<T> key, final Provider<T> creator) {
final String name = key.toString();
return new Provider<T>() {
public T get() {
// Check if the alternate request scope should be used, if no HTTP
// request is in progress.
if (null == GuiceFilter.localContext.get()) {
// NOTE(dhanji): We don't need to synchronize on the scope map
// unlike the HTTP request because we're the only ones who have
// a reference to it, and it is only available via a threadlocal.
Map<String, Object> scopeMap = requestScopeContext.get();
if (null != scopeMap) {
@SuppressWarnings("unchecked")
T t = (T) scopeMap.get(name);
// Accounts for @Nullable providers.
if (NullObject.INSTANCE == t) {
return null;
}
if (t == null) {
t = creator.get();
// Store a sentinel for provider-given null values.
scopeMap.put(name, t != null ? t : NullObject.INSTANCE);
}
return t;
} // else: fall into normal HTTP request scope and out of scope
// exception is thrown.
}
HttpServletRequest request = GuiceFilter.getRequest();
synchronized (request) {
Object obj = request.getAttribute(name);
if (NullObject.INSTANCE == obj) {
return null;
}
@SuppressWarnings("unchecked")
T t = (T) obj;
if (t == null) {
t = creator.get();
request.setAttribute(name, (t != null) ? t : NullObject.INSTANCE);
}
return t;
}
}
public String toString() {
return String.format("%s[%s]", creator, REQUEST);
}
};
}
public String toString() {
return "ServletScopes.REQUEST";
}
};
/**
* HTTP session scope.
*/
public static final Scope SESSION = new Scope() {
public <T> Provider<T> scope(Key<T> key, final Provider<T> creator) {
final String name = key.toString();
return new Provider<T>() {
public T get() {
HttpSession session = GuiceFilter.getRequest().getSession();
synchronized (session) {
Object obj = session.getAttribute(name);
if (NullObject.INSTANCE == obj) {
return null;
}
@SuppressWarnings("unchecked")
T t = (T) obj;
if (t == null) {
t = creator.get();
session.setAttribute(name, (t != null) ? t : NullObject.INSTANCE);
}
return t;
}
}
public String toString() {
return String.format("%s[%s]", creator, SESSION);
}
};
}
public String toString() {
return "ServletScopes.SESSION";
}
};
/**
* Wraps the given callable in a contextual callable that "continues" the
* HTTP request in another thread. This acts as a way of transporting
* request context data from the request processing thread to to worker
* threads.
* <p>
* There are some limitations:
* <ul>
* <li>Derived objects (i.e. anything marked @RequestScoped will not be
* transported.</li>
* <li>State changes to the HttpServletRequest after this method is called
* will not be seen in the continued thread.</li>
* <li>Only the HttpServletRequest, ServletContext and request parameter
* map are available in the continued thread. The response and session
* are not available.</li>
* </ul>
*
* @param callable code to be executed in another thread, which depends on
* the request scope.
* @param seedMap the initial set of scoped instances for Guice to seed the
* request scope with. To seed a key with null, use {@code null} as
* the value.
* @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 3.0
*/
public static <T> Callable<T> continueRequest(final Callable<T> callable,
final Map<Key<?>, Object> seedMap) {
Preconditions.checkArgument(null != seedMap,
"Seed map cannot be null, try passing in Collections.emptyMap() instead.");
// Snapshot the seed map and add all the instances to our continuing HTTP request.
final ContinuingHttpServletRequest continuingRequest =
new ContinuingHttpServletRequest(GuiceFilter.getRequest());
for (Map.Entry<Key<?>, Object> entry : seedMap.entrySet()) {
Object value = validateAndCanonicalizeValue(entry.getKey(), entry.getValue());
continuingRequest.setAttribute(entry.getKey().toString(), value);
}
return new Callable<T>() {
private HttpServletRequest request = continuingRequest;
public T call() throws Exception {
GuiceFilter.Context context = GuiceFilter.localContext.get();
Preconditions.checkState(null == context,
"Cannot continue request in the same thread as a HTTP request!");
// Only set up the request continuation if we're running in a
// new vanilla thread.
GuiceFilter.localContext.set(new GuiceFilter.Context(request, null));
try {
return callable.call();
} finally {
// Clear the copied context if we set one up.
if (null == context) {
GuiceFilter.localContext.remove();
}
}
}
};
}
/**
* A threadlocal scope map for non-http request scopes. The {@link #REQUEST}
* scope falls back to this scope map if no http request is available, and
* requires {@link #scopeRequest} to be called as an alertnative.
*/
private static final ThreadLocal<Map<String, Object>> requestScopeContext
= new ThreadLocal<Map<String, Object>>();
/**
* Scopes the given callable inside a request scope. This is not the same
* as the HTTP request scope, but is used if no HTTP request scope is in
* progress. In this way, keys can be scoped as @RequestScoped and exist
* in non-HTTP requests (for example: RPC requests) as well as in HTTP
* request threads.
*
* @param callable code to be executed which depends on the request scope.
* Typically in another thread, but not necessarily so.
* @param seedMap the initial set of scoped instances for Guice to seed the
* request scope with. To seed a key with null, use {@code null} as
* the value.
* @return a callable that when called will run inside the a request scope
* that exposes the instances in the {@code seedMap} as scoped keys.
* @since 3.0
*/
public static <T> Callable<T> scopeRequest(final Callable<T> callable,
Map<Key<?>, Object> seedMap) {
Preconditions.checkArgument(null != seedMap,
"Seed map cannot be null, try passing in Collections.emptyMap() instead.");
// Copy the seed values into our local scope map.
final Map<String, Object> scopeMap = Maps.newHashMap();
for (Map.Entry<Key<?>, Object> entry : seedMap.entrySet()) {
Object value = validateAndCanonicalizeValue(entry.getKey(), entry.getValue());
scopeMap.put(entry.getKey().toString(), value);
}
return new Callable<T>() {
public T call() throws Exception {
Preconditions.checkState(null == GuiceFilter.localContext.get(),
"An HTTP request is already in progress, cannot scope a new request in this thread.");
Preconditions.checkState(null == requestScopeContext.get(),
"A request scope is already in progress, cannot scope a new request in this thread.");
requestScopeContext.set(scopeMap);
try {
return callable.call();
} finally {
requestScopeContext.remove();
}
}
};
}
/**
* Validates the key and object, ensuring the value matches the key type, and
* canonicalizing null objects to the null sentinel.
*/
private static Object validateAndCanonicalizeValue(Key<?> key, Object object) {
if (object == null || object == NullObject.INSTANCE) {
return NullObject.INSTANCE;
}
if (!key.getTypeLiteral().getRawType().isInstance(object)) {
throw new IllegalArgumentException("Value[" + object + "] of type["
+ object.getClass().getName() + "] is not compatible with key[" + key + "]");
}
return object;
}
}